text:
/**
 *
 * @file core_dblas.h
 *
 *  PLASMA auxiliary routines
 *  PLASMA is a software package provided by Univ. of Tennessee,
 *  Univ. of California Berkeley and Univ. of Colorado Denver
 *
 * @version 2.4.2
 * @author Jakub Kurzak
 * @author Hatem Ltaief
 * @author Mathieu Faverge
 * @author Azzam Haidar
 * @date 2010-11-15
 * @generated d Thu Sep 15 12:08:48 2011
 *
 **/
#ifndef _PLASMA_CORE_DBLAS_H_
#define _PLASMA_CORE_DBLAS_H_
#define REAL

#ifdef __cplusplus
extern "C" {
#endif

/** ****************************************************************************
 *  Declarations of serial kernels - alphabetical order
 **/

int CORE_dlarfx2(int side, int N,
                 double V,
                 double TAU,
                 double *C1, int LDC1,
                 double *C2, int LDC2);
int CORE_dlarfx2c(int uplo,
                  double V,
                  double TAU,
                  double *C1,
                  double *C2,
                  double *C3);
int CORE_dlarfx2ce(int uplo,
                double *V,
                double *TAU,
                double *C1,
                double *C2,
                double *C3);
int CORE_dhbelr(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
int CORE_dhbrce(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
int CORE_dhblrx(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
int CORE_dgbelr(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
int CORE_dgbrce(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
int CORE_dgblrx(int uplo, int N,
                PLASMA_desc *A,
                double *V,
                double *TAU,
                int st,
                int ed,
                int eltsize);
void CORE_dasum(int storev, int uplo, int M, int N,
                 double *A, int lda, double *work);
void CORE_daxpy(int M, int N,  double alpha,
                double *A, int LDA,
                double *B, int LDB);
void CORE_dbrdalg(PLASMA_enum uplo, int N, int NB,
                  PLASMA_desc *pA, double *C, double *S,
                  int i, int j, int m, int grsiz);
int  CORE_dgelqt(int M, int N, int IB,
                 double *A, int LDA,
                 double *T, int LDT,
                 double *TAU, double *WORK);
void CORE_dgemm(int transA, int transB,
                int M, int N, int K,
                double alpha, double *A, int LDA,
                double *B, int LDB,
                double beta, double *C, int LDC);
int  CORE_dgeqrt(int M, int N, int IB,
                 double *A, int LDA,
                 double *T, int LDT,
                 double *TAU, double *WORK);
int  CORE_dgessm(int M, int N, int K, int IB,
                 int *IPIV,
                 double *L, int LDL,
                 double *A, int LDA);
int  CORE_dgetrf(int M, int N,
                 double *A, int LDA,
                 int *IPIV, int *INFO);
int  CORE_dgetrf_incpiv(int M, int N, int IB,
                        double *A, int LDA,
                        int *IPIV, int *INFO);
int  CORE_dgetrf_reclap(const int M, const int N,
                        double *A, const int LDA,
                        int *IPIV, int *info);
int  CORE_dgetrf_rectil(const PLASMA_desc A, int *IPIV, int *info);
void CORE_dgetrip(int m, int n, double *A,
                  double *work);
#ifdef COMPLEX
void CORE_dsygst(int itype, int uplo, int N,
                 double *A, int LDA,
                 double *B, int LDB, int *INFO);
void CORE_dsymm(int side, int uplo,
                int M, int N,
                double alpha, double *A, int LDA,
                double *B, int LDB,
                double beta, double *C, int LDC);
void CORE_dsyrk(int uplo, int trans,
                int N, int K,
                double alpha, double *A, int LDA,
                double beta, double *C, int LDC);
void CORE_dsyr2k(int uplo, int trans,
                 int N, int K,
                 double alpha, double *A, int LDA,
                 double *B, int LDB,
                 double beta, double *C, int LDC);
int  CORE_dsyrfb(PLASMA_enum uplo, int N, int K, int IB, int NB,
                 double *A, int LDA,
                 double *T, int LDT,
                 double *C, int LDC,
                 double *WORK, int LDWORK);
#endif
void CORE_dlacpy(PLASMA_enum uplo, int M, int N,
                 double *A, int LDA,
                 double *B, int LDB);
void CORE_dlange(int norm, int M, int N,
                 double *A, int LDA,
                 double *work, double *normA);
#ifdef COMPLEX
void CORE_dlansy(int norm, int uplo, int N,
                 double *A, int LDA,
                 double *work, double *normA);
#endif
void CORE_dlansy(int norm, int uplo, int N,
                 double *A, int LDA,
                 double *work, double *normA);
void CORE_dlaset(PLASMA_enum uplo, int n1, int n2, double alpha,
                 double beta, double *tileA, int ldtilea);
void CORE_dlaset2(PLASMA_enum uplo, int n1, int n2, double alpha,
                  double *tileA, int ldtilea);
void CORE_dlaswp(int N, double *A, int LDA,
                 int I1,  int I2, int *IPIV, int INC);
int  CORE_dlaswp_ontile(PLASMA_desc descA, int i1, int i2, int *ipiv, int inc);
void CORE_dlauum(int uplo, int N, double *A, int LDA);
void CORE_dplgsy(double bump, int m, int n, double *A, int lda,
                 int bigM, int m0, int n0, unsigned long long int seed );
void CORE_dplgsy(double bump, int m, int n, double *A, int lda,
                 int bigM, int m0, int n0, unsigned long long int seed );
void CORE_dplrnt(int m, int n, double *A, int lda,
                 int bigM, int m0, int n0, unsigned long long int seed );
void CORE_dpotrf(int uplo, int N, double *A, int LDA, int *INFO);
void CORE_dshift(int s, int m, int n, int L,
                 double *A);
void CORE_dshiftw(int s, int cl, int m, int n, int L,
                  double *A, double *W);
int  CORE_dssssm(int M1, int N1, int M2, int N2, int K, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *L1, int LDL1,
                 double *L2, int LDL2,
                 int *IPIV);
void CORE_dsymm(int side, int uplo,
                int M, int N,
                double alpha, double *A, int LDA,
                double *B, int LDB,
                double beta, double *C, int LDC);
void CORE_dsyrk(int uplo, int trans,
                int N, int K,
                double alpha, double *A, int LDA,
                double beta, double *C, int LDC);
void CORE_dsyr2k(int uplo, int trans,
                 int N, int K,
                 double alpha, double *A, int LDA,
                 double *B, int LDB,
                 double beta, double *C, int LDC);
void CORE_dswpab(int i, int n1, int n2,
                 double *A, double *work);
int  CORE_dswptr_ontile(PLASMA_desc descA, int i1, int i2, int *ipiv, int inc,
                        double *Akk, int ldak);
void CORE_dtrdalg(PLASMA_enum uplo, int N, int NB,
                  PLASMA_desc *pA, double *C, double *S,
                  int i, int j, int m, int grsiz);
void CORE_dtrmm(int side, int uplo,
                int transA, int diag,
                int M, int N,
                double alpha, double *A, int LDA,
                double *B, int LDB);
void CORE_dtrsm(int side, int uplo,
                int transA, int diag,
                int M, int N,
                double alpha, double *A, int LDA,
                double *B, int LDB);
void CORE_dtrtri(int uplo, int diag, int N, double *A, int LDA, int *info);
int  CORE_dtslqt(int M, int N, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *T, int LDT,
                 double *TAU, double *WORK);
int  CORE_dtsmlq(int side, int trans,
                 int M1, int N1, int M2, int N2, int K, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int CORE_dtsmlq_corner( int m1, int n1, int m2, int n2, int m3, int n3,
                        int k, int ib, int nb,
                        double *A1, int lda1,
                        double *A2, int lda2,
                        double *A3, int lda3,
                        double *V, int ldv,
                        double *T, int ldt,
                        double *WORK, int ldwork);
int CORE_dtsmlq_sytra1( int side, int trans,
                        int m1, int n1, int m2, int n2,
                        int k, int ib,
                        double *A1, int lda1,
                        double *A2, int lda2,
                        double *V, int ldv,
                        double *T, int ldt,
                        double *WORK, int ldwork);
int  CORE_dtsmqr(int side, int trans,
                 int M1, int N1, int M2, int N2, int K, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int CORE_dtsmqr_corner( int m1, int n1, int m2, int n2, int m3, int n3,
                        int k, int ib, int nb,
                        double *A1, int lda1,
                        double *A2, int lda2,
                        double *A3, int lda3,
                        double *V, int ldv,
                        double *T, int ldt,
                        double *WORK, int ldwork);
int CORE_dtsmqr_sytra1( int side, int trans,
                        int m1, int n1, int m2, int n2,
                        int k, int ib,
                        double *A1, int lda1,
                        double *A2, int lda2,
                        double *V, int ldv,
                        double *T, int ldt,
                        double *WORK, int ldwork);
int  CORE_dtsqrt(int M, int N, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *T, int LDT,
                 double *TAU, double *WORK);
int  CORE_dtsrfb(int side, int trans, int direct, int storev,
                 int M1, int N1, int M2, int N2, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int  CORE_dtstrf(int M, int N, int IB, int NB,
                 double *U, int LDU,
                 double *A, int LDA,
                 double *L, int LDL,
                 int *IPIV, double *WORK,
                 int LDWORK, int *INFO);
int  CORE_dttmqr(int side, int trans,
                 int M1, int N1, int M2, int N2, int K, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int  CORE_dttqrt(int M, int N, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *T, int LDT,
                 double *TAU,
                 double *WORK);
int  CORE_dttmlq(int side, int trans,
                 int M1, int N1, int M2, int N2, int K, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int  CORE_dttlqt(int M, int N, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *T, int LDT,
                 double *TAU,
                 double *WORK);
int  CORE_dttrfb(int side, int trans, int direct, int storev,
                 int M1, int N1, int M2, int N2, int IB,
                 double *A1, int LDA1,
                 double *A2, int LDA2,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *WORK, int LDWORK);
int  CORE_dormlq(int side, int trans,
                 int M, int N, int IB, int K,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *C, int LDC,
                 double *WORK, int LDWORK);
int  CORE_dormqr(int side, int trans,
                 int M, int N, int K, int IB,
                 double *V, int LDV,
                 double *T, int LDT,
                 double *C, int LDC,
                 double *WORK, int LDWORK);

/** ****************************************************************************
 *  Declarations of QUARK wrappers (called by PLASMA) - alphabetical order
 **/
void QUARK_CORE_dasum(Quark *quark, Quark_Task_Flags *task_flags,
                       PLASMA_enum storev, PLASMA_enum uplo, int m, int n,
                       double *A, int lda, int szeA,
                       double *work, int szeW);
void QUARK_CORE_dasum_f1(Quark *quark, Quark_Task_Flags *task_flags,
                          PLASMA_enum storev, PLASMA_enum uplo, int m, int n,
                          double *A, int lda, int szeA,
                          double *work, int szeW,
                          double *fake, int szeF);
void QUARK_CORE_daxpy(Quark *quark, Quark_Task_Flags *task_flags,
                      int m, int n, int nb, double alpha,
                      double *A, int lda,
                      double *B, int ldb);
void QUARK_CORE_dbrdalg(Quark *quark, Quark_Task_Flags *task_flags,
                        int uplo,
                        int N, int NB,
                        PLASMA_desc *A,
                        double *C,
                        double *S,
                        int i, int j, int m, int grsiz, int BAND,
                        int *PCOL, int *ACOL, int *MCOL);
void QUARK_CORE_dgelqt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A, int lda,
                       double *T, int ldt);
void QUARK_CORE_dgemm(Quark *quark, Quark_Task_Flags *task_flags,
                      int transA, int transB,
                      int m, int n, int k, int nb,
                      double alpha, double *A, int lda,
                      double *B, int ldb,
                      double beta, double *C, int ldc);
void QUARK_CORE_dgemm2( Quark *quark, Quark_Task_Flags *task_flags,
                        int transA, int transB,
                        int m, int n, int k, int nb,
                        double alpha, double *A, int lda,
                        double *B, int ldb,
                        double beta, double *C, int ldc);
void QUARK_CORE_dgemm_f2(Quark *quark, Quark_Task_Flags *task_flags,
                         int transA, int transB,
                         int m, int n, int k, int nb,
                         double alpha, double *A, int lda,
                         double *B, int ldb,
                         double beta, double *C, int ldc,
                         double *fake1, int szefake1, int flag1,
                         double *fake2, int szefake2, int flag2);
void QUARK_CORE_dgemm_p2(Quark *quark, Quark_Task_Flags *task_flags,
                         int transA, int transB,
                         int m, int n, int k, int nb,
                         double alpha, double *A, int lda,
                         double **B, int ldb,
                         double beta, double *C, int ldc);
void QUARK_CORE_dgemm_p2f1(Quark *quark, Quark_Task_Flags *task_flags,
                           int transA, int transB,
                           int m, int n, int k, int nb,
                           double alpha, double *A, int lda,
                           double **B, int ldb,
                           double beta, double *C, int ldc,
                           double *fake1, int szefake1, int flag1);
void QUARK_CORE_dgemm_p3(Quark *quark, Quark_Task_Flags *task_flags,
                         int transA, int transB,
                         int m, int n, int k, int nb,
                         double alpha, double *A, int lda,
                         double *B, int ldb,
                         double beta, double **C, int ldc);
void QUARK_CORE_dgeqrt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A, int lda,
                       double *T, int ldt);
void QUARK_CORE_dgessm(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int k, int ib, int nb,
                       int *IPIV,
                       double *L, int ldl,
                       double *A, int lda);
void QUARK_CORE_dgetrf(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int nb,
                       double *A, int lda,
                       int *IPIV,
                       PLASMA_sequence *sequence, PLASMA_request *request,
                       PLASMA_bool check_info, int iinfo);
void QUARK_CORE_dgetrf_incpiv(Quark *quark, Quark_Task_Flags *task_flags,
                              int m, int n, int ib, int nb,
                              double *A, int lda,
                              int *IPIV,
                              PLASMA_sequence *sequence, PLASMA_request *request,
                              PLASMA_bool check_info, int iinfo);
void QUARK_CORE_dgetrf_reclap(Quark *quark, Quark_Task_Flags *task_flags,
                              int m, int n, int nb,
                              double *A, int lda,
                              int *IPIV,
                              PLASMA_sequence *sequence, PLASMA_request *request,
                              PLASMA_bool check_info, int iinfo,
                              int nbthread);
void QUARK_CORE_dgetrf_rectil(Quark *quark, Quark_Task_Flags *task_flags,
                              PLASMA_desc A, double *Amn, int size,
                              int *IPIV,
                              PLASMA_sequence *sequence, PLASMA_request *request,
                              PLASMA_bool check_info, int iinfo,
                              int nbthread);
void QUARK_CORE_dgetrip(Quark *quark, Quark_Task_Flags *task_flags,
                        int m, int n, double *A, int szeA);
void QUARK_CORE_dgetrip_f1(Quark *quark, Quark_Task_Flags *task_flags,
                           int m, int n, double *A, int szeA,
                           double *fake, int szeF, int paramF);
void QUARK_CORE_dgetrip_f2(Quark *quark, Quark_Task_Flags *task_flags,
                           int m, int n, double *A, int szeA,
                           double *fake1, int szeF1, int paramF1,
                           double *fake2, int szeF2, int paramF2);
void QUARK_CORE_dsymm(Quark *quark, Quark_Task_Flags *task_flags,
                      int side, int uplo,
                      int m, int n, int nb,
                      double alpha, double *A, int lda,
                      double *B, int ldb,
                      double beta, double *C, int ldc);
void QUARK_CORE_dsygst(Quark *quark, Quark_Task_Flags *task_flags,
                       int itype, int uplo, int N,
                       double *A, int LDA,
                       double *B, int LDB,
                       PLASMA_sequence *sequence, PLASMA_request *request,
                       int iinfo);
void QUARK_CORE_dsyrk(Quark *quark, Quark_Task_Flags *task_flags,
                      int uplo, int trans,
                      int n, int k, int nb,
                      double alpha, double *A, int lda,
                      double beta, double *C, int ldc);
void QUARK_CORE_dsyr2k(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo, int trans,
                       int n, int k, int nb,
                       double alpha, double *A, int lda,
                       double *B, int LDB,
                       double beta, double *C, int ldc);
void QUARK_CORE_dsyrfb(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo,
                       int n, int k, int ib, int nb,
                       double *A, int lda,
                       double *T, int ldt,
                       double *C, int ldc);
void QUARK_CORE_dlacpy(Quark *quark, Quark_Task_Flags *task_flags,
                       PLASMA_enum uplo, int m, int n, int mb,
                       double *A, int lda,
                       double *B, int ldb);
void QUARK_CORE_dlange(Quark *quark, Quark_Task_Flags *task_flags,
                       int norm, int M, int N,
                       double *A, int LDA, int szeA,
                       int szeW, double *result);
void QUARK_CORE_dlange_f1(Quark *quark, Quark_Task_Flags *task_flags,
                          int norm, int M, int N,
                          double *A, int LDA, int szeA,
                          int szeW, double *result,
                          double *fake, int szeF);
#ifdef COMPLEX
void QUARK_CORE_dlansy(Quark *quark, Quark_Task_Flags *task_flags,
                       int norm, int uplo, int N,
                       double *A, int LDA, int szeA,
                       int szeW, double *result);
void QUARK_CORE_dlansy_f1(Quark *quark, Quark_Task_Flags *task_flags,
                          int norm, int uplo, int N,
                          double *A, int LDA, int szeA,
                          int szeW, double *result,
                          double *fake, int szeF);
#endif
void QUARK_CORE_dlansy(Quark *quark, Quark_Task_Flags *task_flags,
                       int norm, int uplo, int N,
                       double *A, int LDA, int szeA,
                       int szeW, double *result);
void QUARK_CORE_dlansy_f1(Quark *quark, Quark_Task_Flags *task_flags,
                          int norm, int uplo, int N,
                          double *A, int LDA, int szeA,
                          int szeW, double *result,
                          double *fake, int szeF);
void QUARK_CORE_dlaset(Quark *quark, Quark_Task_Flags *task_flags,
                       PLASMA_enum uplo, int n1, int n2, double alpha,
                       double beta, double *tileA, int ldtilea);
void QUARK_CORE_dlaset2(Quark *quark, Quark_Task_Flags *task_flags,
                        PLASMA_enum uplo, int n1, int n2, double alpha,
                        double *tileA, int ldtilea);
void QUARK_CORE_dlaswp(Quark *quark, Quark_Task_Flags *task_flags,
                       int n, double *A, int lda,
                       int i1,  int i2, int *ipiv, int inc);
void QUARK_CORE_dlaswp_f2(Quark *quark, Quark_Task_Flags *task_flags,
                          int n, double *A, int lda,
                          int i1,  int i2, int *ipiv, int inc,
                          double *fake1, int szefake1, int flag1,
                          double *fake2, int szefake2, int flag2);
void QUARK_CORE_dlaswp_ontile(Quark *quark, Quark_Task_Flags *task_flags,
                              PLASMA_desc descA, double *A,
                              int i1,  int i2, int *ipiv, int inc, double *fakepanel);
void QUARK_CORE_dlaswp_ontile_f2(Quark *quark, Quark_Task_Flags *task_flags,
                                 PLASMA_desc descA, double *A,
                                 int i1,  int i2, int *ipiv, int inc,
                                 double *fake1, int szefake1, int flag1,
                                 double *fake2, int szefake2, int flag2);
void QUARK_CORE_dlauum(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo, int n, int nb,
                       double *A, int lda);
void QUARK_CORE_dplgsy(Quark *quark, Quark_Task_Flags *task_flags,
                       double bump, int m, int n, double *A, int lda,
                       int bigM, int m0, int n0, unsigned long long int seed );
void QUARK_CORE_dplgsy(Quark *quark, Quark_Task_Flags *task_flags,
                       double bump, int m, int n, double *A, int lda,
                       int bigM, int m0, int n0, unsigned long long int seed );
void QUARK_CORE_dplrnt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, double *A, int lda,
                       int bigM, int m0, int n0, unsigned long long int seed );
void QUARK_CORE_dpotrf(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo, int n, int nb,
                       double *A, int lda,
                       PLASMA_sequence *sequence, PLASMA_request *request,
                       int iinfo);
void QUARK_CORE_dshift( Quark *quark, Quark_Task_Flags *task_flags,
                        int s, int m, int n, int L,
                        double *A);
void QUARK_CORE_dshiftw(Quark *quark, Quark_Task_Flags *task_flags,
                        int s, int cl, int m, int n, int L,
                        double *A, double *W);
void QUARK_CORE_dssssm(Quark *quark, Quark_Task_Flags *task_flags,
                       int m1, int n1, int m2, int n2, int k, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *L1, int ldl1,
                       double *L2, int ldl2,
                       int *IPIV);
void QUARK_CORE_dsymm(Quark *quark, Quark_Task_Flags *task_flags,
                      int side, int uplo,
                      int m, int n, int nb,
                      double alpha, double *A, int lda,
                      double *B, int ldb,
                      double beta, double *C, int ldc);
void QUARK_CORE_dsyrk(Quark *quark, Quark_Task_Flags *task_flags,
                      int uplo, int trans,
                      int n, int k, int nb,
                      double alpha, double *A, int lda,
                      double beta, double *C, int ldc);
void QUARK_CORE_dsyr2k(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo, int trans,
                       int n, int k, int nb,
                       double alpha, double *A, int lda,
                       double *B, int LDB,
                       double beta, double *C, int ldc);
void QUARK_CORE_dswpab(Quark *quark, Quark_Task_Flags *task_flags,
                       int i, int n1, int n2,
                       double *A, int szeA);
void QUARK_CORE_dswptr_ontile(Quark *quark, Quark_Task_Flags *task_flags,
                              PLASMA_desc descA, double *Aij,
                              int i1,  int i2, int *ipiv, int inc,
                              double *Akk, int ldak);
void QUARK_CORE_dtrdalg(Quark *quark, Quark_Task_Flags *task_flags,
                        int uplo,
                        int N, int NB,
                        PLASMA_desc *A,
                        double *C,
                        double *S,
                        int i, int j, int m, int grsiz, int BAND,
                        int *PCOL, int *ACOL, int *MCOL);
void QUARK_CORE_dtrmm(Quark *quark, Quark_Task_Flags *task_flags,
                      int side, int uplo, int transA, int diag,
                      int m, int n, int nb,
                      double alpha, double *A, int lda,
                      double *B, int ldb);
void QUARK_CORE_dtrmm_p2(Quark *quark, Quark_Task_Flags *task_flags,
                         int side, int uplo, int transA, int diag,
                         int m, int n, int nb,
                         double alpha, double *A, int lda,
                         double **B, int ldb);
void QUARK_CORE_dtrsm(Quark *quark, Quark_Task_Flags *task_flags,
                      int side, int uplo, int transA, int diag,
                      int m, int n, int nb,
                      double alpha, double *A, int lda,
                      double *B, int ldb);
void QUARK_CORE_dtrtri(Quark *quark, Quark_Task_Flags *task_flags,
                       int uplo, int diag, int n, int nb,
                       double *A, int lda,
                       PLASMA_sequence *sequence, PLASMA_request *request,
                       int iinfo);
void QUARK_CORE_dtslqt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *T, int ldt);
void QUARK_CORE_dtsmlq(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m1, int n1, int m2, int n2, int k, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *V, int ldv,
                       double *T, int ldt);
void QUARK_CORE_dtsmlq_sytra1(Quark *quark, Quark_Task_Flags *task_flags,
                              int side, int trans,
                              int m1, int n1, int m2, int n2, int k, int ib, int nb,
                              double *A1, int lda1,
                              double *A2, int lda2,
                              double *V, int ldv,
                              double *T, int ldt);
void QUARK_CORE_dtsmlq_corner(Quark *quark, Quark_Task_Flags *task_flags,
                              int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb,
                              double *A1, int lda1,
                              double *A2, int lda2,
                              double *A3, int lda3,
                              double *V, int ldv,
                              double *T, int ldt);
void QUARK_CORE_dtsmqr(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m1, int n1, int m2, int n2, int k, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *V, int ldv,
                       double *T, int ldt);
void QUARK_CORE_dtsmqr_sytra1(Quark *quark, Quark_Task_Flags *task_flags,
                              int side, int trans,
                              int m1, int n1, int m2, int n2, int k, int ib, int nb,
                              double *A1, int lda1,
                              double *A2, int lda2,
                              double *V, int ldv,
                              double *T, int ldt);
void QUARK_CORE_dtsmqr_corner(Quark *quark, Quark_Task_Flags *task_flags,
                              int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb,
                              double *A1, int lda1,
                              double *A2, int lda2,
                              double *A3, int lda3,
                              double *V, int ldv,
                              double *T, int ldt);
void QUARK_CORE_dtsqrt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *T, int ldt);
void QUARK_CORE_dtstrf(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *U, int ldu,
                       double *A, int lda,
                       double *L, int ldl,
                       int *IPIV,
                       PLASMA_sequence *sequence, PLASMA_request *request,
                       PLASMA_bool check_info, int iinfo);
void QUARK_CORE_dttmqr(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m1, int n1, int m2, int n2, int k, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *V, int ldv,
                       double *T, int ldt);
void QUARK_CORE_dttqrt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *T, int ldt);
void QUARK_CORE_dttmlq(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m1, int n1, int m2, int n2, int k, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *V, int ldv,
                       double *T, int ldt);
void QUARK_CORE_dttlqt(Quark *quark, Quark_Task_Flags *task_flags,
                       int m, int n, int ib, int nb,
                       double *A1, int lda1,
                       double *A2, int lda2,
                       double *T, int ldt);
void QUARK_CORE_dormlq(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m, int n, int ib,  int nb, int k,
                       double *A, int lda,
                       double *T, int ldt,
                       double *C, int ldc);
void QUARK_CORE_dormqr(Quark *quark, Quark_Task_Flags *task_flags,
                       int side, int trans,
                       int m, int n, int k, int ib, int nb,
                       double *A, int lda,
                       double *T, int ldt,
                       double *C, int ldc);

/** ****************************************************************************
 *  Declarations of QUARK wrappers (called by QUARK) - alphabetical order
 **/
void CORE_dasum_quark(Quark *quark);
void CORE_dasum_f1_quark(Quark *quark);
void CORE_daxpy_quark(Quark *quark);
void CORE_dbrdalg_quark(Quark *quark);
void CORE_dgelqt_quark(Quark *quark);
void CORE_dgemm_quark(Quark *quark);
void CORE_dgeqrt_quark(Quark *quark);
void CORE_dgessm_quark(Quark *quark);
void CORE_dgetrf_quark(Quark *quark);
void CORE_dgetrf_incpiv_quark(Quark *quark);
void CORE_dgetrf_reclap_quark(Quark *quark);
void CORE_dgetrf_rectil_quark(Quark* quark);
void CORE_dgetrip_quark(Quark *quark);
void CORE_dgetrip_f1_quark(Quark *quark);
void CORE_dgetrip_f2_quark(Quark *quark);
#ifdef COMPLEX
void CORE_dsymm_quark(Quark *quark);
void CORE_dsyrk_quark(Quark *quark);
void CORE_dsyr2k_quark(Quark *quark);
#endif
void CORE_dsygst_quark(Quark *quark);
void CORE_dsyrfb_quark(Quark *quark);
void CORE_dlacpy_quark(Quark *quark);
void CORE_dlange_quark(Quark *quark);
void CORE_dlange_f1_quark(Quark *quark);
#ifdef COMPLEX
void CORE_dlansy_quark(Quark *quark);
void CORE_dlansy_f1_quark(Quark *quark);
#endif
void CORE_dlansy_quark(Quark *quark);
void CORE_dlansy_f1_quark(Quark *quark);
void CORE_dlaset_quark(Quark *quark);
void CORE_dlaset2_quark(Quark *quark);
void CORE_dlauum_quark(Quark *quark);
void CORE_dplgsy_quark(Quark *quark);
void CORE_dplgsy_quark(Quark *quark);
void CORE_dplrnt_quark(Quark *quark);
void CORE_dpotrf_quark(Quark *quark);
void CORE_dshift_quark(Quark *quark);
void CORE_dshiftw_quark(Quark *quark);
void CORE_dssssm_quark(Quark *quark);
void CORE_dsymm_quark(Quark *quark);
void CORE_dsyrk_quark(Quark *quark);
void CORE_dsyr2k_quark(Quark *quark);
void CORE_dswpab_quark(Quark *quark);
void CORE_dswptr_ontile_quark(Quark *quark);
void CORE_dtrdalg_quark(Quark *quark);
void CORE_dtrmm_quark(Quark *quark);
void CORE_dtrsm_quark(Quark *quark);
void CORE_dtrtri_quark(Quark *quark);
void CORE_dtslqt_quark(Quark *quark);
void CORE_dtsmlq_quark(Quark *quark);
void CORE_dtsmlq_sytra1_quark(Quark *quark);
void CORE_dtsmlq_corner_quark(Quark *quark);
void CORE_dtsmqr_quark(Quark *quark);
void CORE_dtsmqr_sytra1_quark(Quark *quark);
void CORE_dtsmqr_corner_quark(Quark *quark);
void CORE_dtsqrt_quark(Quark *quark);
void CORE_dtstrf_quark(Quark *quark);
void CORE_dttmqr_quark(Quark *quark);
void CORE_dttqrt_quark(Quark *quark);
void CORE_dttmlq_quark(Quark *quark);
void CORE_dttlqt_quark(Quark *quark);
void CORE_dormlq_quark(Quark *quark);
void CORE_dormqr_quark(Quark *quark);

void CORE_dlaswp_quark(Quark* quark);
void CORE_dlaswp_f2_quark(Quark* quark);
void CORE_dlaswp_ontile_quark(Quark *quark);
void CORE_dlaswp_ontile_f2_quark(Quark *quark);
void CORE_dtrmm_p2_quark(Quark* quark);
void CORE_dgemm_f2_quark(Quark* quark);
void CORE_dgemm_p2_quark(Quark* quark);
void CORE_dgemm_p2f1_quark(Quark* quark);
void CORE_dgemm_p3_quark(Quark* quark);

void CORE_dtrdalg_v2_quark(Quark *quark);

void QUARK_CORE_dtrdalg_v2(Quark *quark, Quark_Task_Flags *task_flags,
                        int uplo,
                        PLASMA_desc *A,
                        double *C,
                        double *S,
                        int grsiz, int s, int id, int blktile);

void CORE_dtrdalg_v2(PLASMA_enum uplo,
                  PLASMA_desc *pA, double *C, double *S,
                  int grsiz, int s, int id, int blktile);

#ifdef __cplusplus
}
#endif

#endif


text:
using System.Threading.Tasks;

namespace Trinity.Wallets.Api.Commands
{
	public interface ISendToAddressCommand
	{
		Task<string> ExecuteAsync(string assetId, string scriptHash, string value, string transactionFee, string changeAddress);
	}
}

redpajama_set_name: RedPajamaGithub


text:
			    <form class="form frame-form" name="form" ng-submit="createSchool(form)">

			          <input
			            type="name"
			            name="name"
			            class="form-control"
			            ng-model="school.name"
			            autofocus
			            placeholder="School Name"
			            mongoose-error
			            required
			            ng-maxlength="150" />

Sorry, the school name can´t be empty.

{{errors.name}}

Sorry, the name of the school can´t have more than 150 characters.

			          <input
			            type="text"
			            name="code"
			            class="form-control"
			            ng-model="school.code"
			            autofocus
			            placeholder="Code"
			            unique-school-code
			            ng-minlength="3"
			            ng-maxlength="3"
			            required />

Sorry, school code can´t be empty.

Sorry, school code must have 3 characters.

Sorry, school code must have 3 characters.

Sorry, this school code is already taken.

			           	<ui-select ng-model="address.selected" theme="selectize" ng-disabled="disabled" reset-search-input="false" style="width: 300px; height:0px;" ng-required="true">
		    				<ui-select-match placeholder="{{school.address}}">{{$select.selected.formatted_address}}</ui-select-match>
	    			    	<ui-select-choices repeat="address in addresses track by $index"
	    			             refresh="refreshAddresses($select.search)"
	    			             refresh-delay="0">

	    			    	</ui-select-choices>
	    			 	</ui-select>

			          <input ng-disabled="form.$invalid" class="btn btn-success" value="Save Changes" type="submit" ngClick="Submit">

			    </form>


text:
package org.unitime.timetable.form;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.unitime.localization.impl.Localization;
import org.unitime.localization.messages.CourseMessages;
import org.unitime.timetable.defaults.ApplicationProperty;
import org.unitime.timetable.model.CourseOffering;
import org.unitime.timetable.model.Preference;
import org.unitime.timetable.model.SubjectArea;
import org.unitime.timetable.model.dao.SubjectAreaDAO;
import org.unitime.timetable.util.DynamicList;
import org.unitime.timetable.util.DynamicListObjectFactory;

/**
 * MyEclipse Struts
 * Creation date: 07-25-2006
 *
 * XDoclet definition:
 * @struts:form name="courseOfferingEditForm"
 *
 * @author Tomas Muller, Stephanie Schluttenhofer, Zuzana Mullerova
 */
public class CourseOfferingEditForm extends ActionForm {

	protected final static CourseMessages MSG = Localization.create(CourseMessages.class);

	private static final long serialVersionUID = 5719027599139781262L;
	// --------------------------------------------------------- Instance Variables
    private String op;
    private boolean add = false;
    private Long subjectAreaId;
    private Long courseOfferingId;
    private Long instrOfferingId;
    private String courseName;
    private String courseNbr;
    private String title;
    private String scheduleBookNote;
    private Long demandCourseOfferingId;
    private boolean allowDemandCourseOfferings;
    private Long consent;
    private String creditFormat;
    private Long creditType;
    private Long creditUnitType;
    private Float units;
    private Float maxUnits;
    private Boolean fractionalIncrementsAllowed;
    private String creditText;
    private Boolean isControl;
    private Boolean ioNotOffered;
    private String catalogLinkLabel;
    private String catalogLinkLocation;
    private Boolean byReservationOnly;
    private List instructors;
    private String wkEnroll, wkChange, wkDrop;
    private Integer wkEnrollDefault, wkChangeDefault, wkDropDefault;
    private String weekStartDayOfWeek;
    private String courseTypeId;

    // --------------------------------------------------------- Methods

    /**
     * Method validate
     * @param mapping
     * @param request
     * @return ActionErrors
     */
    public ActionErrors validate(
        ActionMapping mapping,
        HttpServletRequest request) {

        ActionErrors errors = new ActionErrors();

        if (getCourseNbr() != null && ApplicationProperty.CourseOfferingNumberUpperCase.isTrue()) {
        	setCourseNbr(getCourseNbr().toUpperCase());
        }

		if (op.equals(MSG.actionUpdateCourseOffering()) || op.equals(MSG.actionSaveCourseOffering())) {
			if (subjectAreaId == null || subjectAreaId == 0) {
				errors.add("subjectAreaId", new ActionMessage("errors.generic", MSG.errorSubjectRequired()));
			} else if (courseNbr==null || courseNbr.trim().length()==0) {
				errors.add("courseNbr", new ActionMessage("errors.generic", MSG.errorCourseNumberRequired()));
			}
			else {

		    	String courseNbrRegex = ApplicationProperty.CourseOfferingNumberPattern.value();
		    	String courseNbrInfo = ApplicationProperty.CourseOfferingNumberPatternInfo.value();
		    	try {
			    	Pattern pattern = Pattern.compile(courseNbrRegex);
			    	Matcher matcher = pattern.matcher(courseNbr);
			    	if (!matcher.find()) {
				        errors.add("courseNbr", new ActionMessage("errors.generic", courseNbrInfo));
			    	}
		    	}
		    	catch (Exception e) {
			        errors.add("courseNbr", new ActionMessage("errors.generic", MSG.errorCourseNumberCannotBeMatched(courseNbrRegex,e.getMessage())));
		    	}

		    	if (ApplicationProperty.CourseOfferingNumberMustBeUnique.isTrue()){
					SubjectArea sa = new SubjectAreaDAO().get(subjectAreaId);
					CourseOffering co = CourseOffering.findBySessionSubjAreaAbbvCourseNbr(sa.getSessionId(), sa.getSubjectAreaAbbreviation(), courseNbr);
					if (add && co != null) {
						errors.add("courseNbr", new ActionMessage("errors.generic", MSG.errorCourseCannotBeCreated()));
					} else if (!add && co!=null && !co.getUniqueId().equals(courseOfferingId)) {
			            errors.add("courseNbr", new ActionMessage("errors.generic", MSG.errorCourseCannotBeRenamed()));
					}
		    	}

			}
		}

        return errors;
    }

    protected DynamicListObjectFactory factory = new DynamicListObjectFactory() {
        public Object create() {
            return new String(Preference.BLANK_PREF_VALUE);
        }
    };

    /**
     * Method reset
     * @param mapping
     * @param request
     */
    public void reset(ActionMapping mapping, HttpServletRequest request) {
        op = "";
        subjectAreaId = null;
        courseOfferingId = null;
        instrOfferingId = null;
        courseName = "";
        title = "";
        scheduleBookNote = "";
        demandCourseOfferingId = null;
        consent = null;
        creditFormat = null; creditType = null;
        creditUnitType = null;
        units = null;
        maxUnits = null;
        fractionalIncrementsAllowed = new Boolean(false);
        creditText = "";
        courseNbr = "";
        ioNotOffered = null;
        catalogLinkLabel = null;
        catalogLinkLocation = null;
        instructors = DynamicList.getInstance(new ArrayList(), factory);
        byReservationOnly = false;
        wkEnroll = null; wkChange = null; wkDrop = null;
        wkEnrollDefault = null; wkChangeDefault = null; wkDropDefault = null;
        weekStartDayOfWeek = null;
        courseTypeId = null;
        add = false;
    }

    public boolean isAdd() { return add; }
    public void setAdd(boolean add) { this.add = add; }

    public Long getCourseOfferingId() {
        return courseOfferingId;
    }
    public void setCourseOfferingId(Long courseOfferingId) {
        this.courseOfferingId = courseOfferingId;
    }

    public String getScheduleBookNote() {
        return scheduleBookNote;
    }
    public void setScheduleBookNote(String scheduleBookNote) {
        this.scheduleBookNote = scheduleBookNote;
    }

    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }

    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
    public Long getInstrOfferingId() {
        return instrOfferingId;
    }
    public void setInstrOfferingId(Long instrOfferingId) {
        this.instrOfferingId = instrOfferingId;
    }
    public String getOp() {
        return op;
    }
    public void setOp(String op) {
        this.op = op;
    }
    public Long getSubjectAreaId() {
        return subjectAreaId;
    }
    public void setSubjectAreaId(Long subjectAreaId) {
        this.subjectAreaId = subjectAreaId;
    }
    public Long getDemandCourseOfferingId() {
    	return demandCourseOfferingId;
    }
    public void setDemandCourseOfferingId(Long demandCourseOfferingId) {
    	this.demandCourseOfferingId = demandCourseOfferingId;
    }
    public boolean getAllowDemandCourseOfferings() {
    	return allowDemandCourseOfferings;
    }
    public void setAllowDemandCourseOfferings(boolean allowDemandCourseOfferings) {
    	this.allowDemandCourseOfferings = allowDemandCourseOfferings;
    }
    public Long getConsent() {
        return consent;
    }
    public void setConsent(Long consent) {
        this.consent = consent;
    }

	public String getCreditFormat() {
		return creditFormat;
	}

	public void setCreditFormat(String creditFormat) {
		this.creditFormat = creditFormat;
	}

	public String getCreditText() {
		return creditText;
	}

	public void setCreditText(String creditText) {
		this.creditText = creditText;
	}

	public Long getCreditType() {
		return creditType;
	}

	public void setCreditType(Long creditType) {
		this.creditType = creditType;
	}

	public Long getCreditUnitType() {
		return creditUnitType;
	}

	public void setCreditUnitType(Long creditUnitType) {
		this.creditUnitType = creditUnitType;
	}

	public Boolean getFractionalIncrementsAllowed() {
		return fractionalIncrementsAllowed;
	}

	public void setFractionalIncrementsAllowed(Boolean fractionalIncrementsAllowed) {
		this.fractionalIncrementsAllowed = fractionalIncrementsAllowed;
	}

	public Float getMaxUnits() {
		return maxUnits;
	}

	public void setMaxUnits(Float maxUnits) {
		this.maxUnits = maxUnits;
	}

	public Float getUnits() {
		return units;
	}

	public void setUnits(Float units) {
		this.units = units;
	}

	public String getCourseNbr() {
		return courseNbr;
	}

	public void setCourseNbr(String courseNbr) {
		if (ApplicationProperty.CourseOfferingNumberUpperCase.isTrue())
        	courseNbr = courseNbr.toUpperCase();
		this.courseNbr = courseNbr;
	}

	public Boolean getIsControl() {
		return isControl;
	}

	public void setIsControl(Boolean isControl) {
		this.isControl = isControl;
	}

	public Boolean getIoNotOffered() {
		return ioNotOffered;
	}

	public void setIoNotOffered(Boolean ioNotOffered) {
		this.ioNotOffered = ioNotOffered;
	}

	public String getCatalogLinkLabel() {
		return catalogLinkLabel;
	}

	public void setCatalogLinkLabel(String catalogLinkLabel) {
		this.catalogLinkLabel = catalogLinkLabel;
	}

	public String getCatalogLinkLocation() {
		return catalogLinkLocation;
	}

	public void setCatalogLinkLocation(String catalogLinkLocation) {
		this.catalogLinkLocation = catalogLinkLocation;
	}

    public List getInstructors() { return instructors; }
    public String getInstructors(int key) { return instructors.get(key).toString(); }
    public void setInstructors(int key, Object value) { this.instructors.set(key, value); }
    public void setInstructors(List instructors) { this.instructors = instructors; }

    public boolean isByReservationOnly() { return byReservationOnly; }
    public void setByReservationOnly(boolean byReservationOnly) { this.byReservationOnly = byReservationOnly; }

    public String getWkEnroll() { return wkEnroll; }
    public void setWkEnroll(String wkEnroll) { this.wkEnroll = wkEnroll; }
    public Integer getWkEnrollDefault() { return wkEnrollDefault; }
    public void setWkEnrollDefault(Integer wkEnrollDefault) { this.wkEnrollDefault = wkEnrollDefault; }

    public String getWkChange() { return wkChange; }
    public void setWkChange(String wkChange) { this.wkChange = wkChange; }
    public Integer getWkChangeDefault() { return wkChangeDefault; }
    public void setWkChangeDefault(Integer wkChangeDefault) { this.wkChangeDefault = wkChangeDefault; }

    public String getWkDrop() { return wkDrop; }
    public void setWkDrop(String wkDrop) { this.wkDrop = wkDrop; }
    public Integer getWkDropDefault() { return wkDropDefault; }
    public void setWkDropDefault(Integer wkDropDefault) { this.wkDropDefault = wkDropDefault; }

    public String getWeekStartDayOfWeek() { return weekStartDayOfWeek; }
    public void setWeekStartDayOfWeek(String weekStartDayOfWeek) { this.weekStartDayOfWeek = weekStartDayOfWeek; }

    public String getCourseTypeId() { return courseTypeId; }
    public void setCourseTypeId(String courseTypeId) { this.courseTypeId = courseTypeId; }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <title>Grid sidebar test</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
    <link rel="stylesheet" type="text/css" media="all" href="css/snow.css" />

Home

Link

Link

Link

        <form name="searchform" method="POST" action="">
            <input type="search" name="searchbox" class="searchbox" placeholder="Search" />
        </form>

A test

                    Mucking around with simple layouts, trying the old "blog with sidebar",
                    only this is using grid. Interesting but not sure if I want to use yet.
                    Right now it lets the main slide under the fixed sidebar.
                    Which ruins the entire point. In fact I've forgotten why I
                    was using grid for this.

                    For mobile, the footer is visible and has a link that'll scroll back
                    up to the top of the page.
                    On desktop, the sidebar is fixed so
                    no need for a footer.

Edit - Delete

tag tag tag tag taggy tag

Padding

                    Let's have a little bit of fun today.
                    Work on one thing at a time. Don't get carried away - we have plenty of time.
                    I think there's an artist hidden in the bottom of every single one of us.
                    Nature is so fantastic, enjoy it. Let it make you happy.

                    Snow refers to forms of ice crystals that precipitate from the
                    atmosphere (usually from clouds) and undergo changes on the
                    Earth's surface. It pertains to frozen crystalline water
                    throughout its life cycle, starting when, under suitable conditions,
                    the ice crystals form in the atmosphere, increase to millimeter
                    size, precipitate and accumulate on surfaces, then metamorphose
                    in place, and ultimately melt, slide or sublimate away.
                    Snowstorms organize and develop by feeding on sources of
                    atmospheric moisture and cold air. Snowflakes nucleate around
                    particles in the atmosphere by attracting supercooled water
                    droplets, which freeze in hexagonal-shaped crystals. Snowflakes
                    take on a variety of shapes, basic among these are platelets,
                    needles, columns and rime. As snow accumulates into a snowpack,
                    it may blow into drifts. Over time, accumulated snow metamorphoses,
                    by sintering, sublimation and freeze-thaw. Where the climate
                    is cold enough for year-to-year accumulation, a glacier may form.
                    Otherwise, snow typically melts seasonally, causing runoff
                    into streams and rivers and recharging groundwater.

Edit - Delete

tag tag tag tag

Back to top


text:
<!DOCTYPE html>

<meta charset="utf-8">
<title>Inheritance of CSS Backgrounds and Borders properties</title>
<link rel="help" href="https://drafts.csswg.org/css-backgrounds-3/#property-index">
<link rel="help" href="https://drafts.csswg.org/css-backgrounds-4/#property-index">
<meta name="assert" content="Properties inherit or not according to the spec.">
<meta name="assert" content="Properties have initial values according to the spec.">


text:
package org.gluu.oxtrust.action;

import java.io.Serializable;
import java.util.Comparator;
import java.util.List;

import javax.enterprise.context.ConversationScoped;
import javax.faces.application.FacesMessage;
import javax.inject.Inject;
import javax.inject.Named;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.gluu.jsf2.message.FacesMessages;
import org.gluu.jsf2.service.ConversationService;
import org.gluu.oxtrust.model.OxTrustedIdp;
import org.gluu.oxtrust.service.ClientService;
import org.gluu.oxtrust.service.TrustedIDPService;
import org.gluu.oxtrust.util.OxTrustConstants;
import org.gluu.service.security.Secure;
import org.gluu.util.Util;
import org.slf4j.Logger;

/**
 * Action class for search Trusted Idp
 *
 * @author Shekhar L. Date: 12.09.2022
 */
@Named
@ConversationScoped
@Secure("#{permissionService.hasPermission('client', 'access')}")
public class SearchTrustedIdpAction implements Serializable {

	private static final long serialVersionUID = 8361095046179474395L;

	@Inject
	private Logger log;

	@Inject
	private FacesMessages facesMessages;

	@Inject
	private ConversationService conversationService;

	@NotNull
	@Size(min = 0, max = 30, message = "Length of search string should be less than 30")
	private String searchPattern = "";

	private String oldSearchPattern;

	private List<OxTrustedIdp> oxTrustedIdpList;

	@Inject
	private TrustedIDPService trustedIdpService;

	public String start() {
		return search();
	}

	public String search() {
		if (Util.equals(this.oldSearchPattern, this.searchPattern)) {
			return OxTrustConstants.RESULT_SUCCESS;
		}
		return searchImpl();
	}

	protected String searchImpl() {
		try {
			if (searchPattern == null || searchPattern.isEmpty()) {
				this.oxTrustedIdpList = trustedIdpService.getAllTrustedIDP();
			} else {
				this.oxTrustedIdpList = trustedIdpService.searchOxTrustedIdp(this.searchPattern, 100);
			}
			//this.trustedIdpList.sort(Comparator.comparing(OxAuthClient::getDisplayName));
			this.oldSearchPattern = this.searchPattern;
			this.searchPattern = "";
		} catch (Exception ex) {
			log.error("Failed to find trustedIdps", ex);
			facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to find trustedIdps");
			conversationService.endConversation();
			return OxTrustConstants.RESULT_FAILURE;
		}
		return OxTrustConstants.RESULT_SUCCESS;
	}

	public String getSearchPattern() {
		return searchPattern;
	}

	public void setSearchPattern(String searchPattern) {
		this.searchPattern = searchPattern;
	}

	public String deleteTrustedIdps() {
		for (OxTrustedIdp trustedIdp : oxTrustedIdpList) {
			if (trustedIdp.isSelected()) {
				trustedIdpService.removeTrustedIDP(trustedIdp);
			}
		}
		return searchImpl();
	}

	public List<OxTrustedIdp> getOxTrustedIdpList() {
		return oxTrustedIdpList;
	}

	public void setOxTrustedIdpList(List<OxTrustedIdp> oxTrustedIdpList) {
		this.oxTrustedIdpList = oxTrustedIdpList;
	}
}


text:
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

const METHOD_LIST = ['logOut', 'getInstalledArcApps'];

/**
 * Class that implements the client side of the AddSupervision postMessage API.
 * All of the actual functionality is in the superclass.  Family Link uses
 * its own implementation of this client library to meet their separate
 * google dev and deployment processes and standards, so this file serves
 * as a reference implementation, and can be used by end-to-end tests of the
 * API's behavior.  It is not used in the build, but it is included by
 * webview-example.html and webview-example2.html, which demonstrate how
 * to use the API from an embedded webview.
 */
class AddSupervisionAPIClient extends PostMessageAPIClient {
  constructor() {
    super(METHOD_LIST);
  }
}


text:
package hu.adamsan.selenium.framework.pages;

import org.openqa.selenium.By;

import hu.adamsan.selenium.framework.selenium.Driver;

public class LoginCommand {

    private String username;
    private String password;

    public LoginCommand(String username) {
        this.username = username;
    }

    public LoginCommand withPassword(String password) {
        this.password = password;
        return this;
    }

    public void login() {
        Driver.INSTANCE.findElement(By.id("user_login")).sendKeys(username);
        Driver.INSTANCE.findElement(By.id("user_pass")).sendKeys(password);
        Driver.INSTANCE.findElement(By.id("wp-submit")).click();
    }
}


text:
var axios = require('axios')
var http = require('http')
var yaml = require('yamljs')
var Promise = require('bluebird')
Promise.longStackTraces()

var logger = require.main.exports.logger
if (!logger) {
  var log_file = 'usgs_helpers'
  logger = require('../helpers/logger.js')(log_file)
}

//modules
var USGS_CONSTANT = require("./usgs_constants.js")
var USGS_FUNCTION = require("./usgs_functions.js")
var app_helpers = require("../helpers/app_helpers.js")()
const MAX_LOGIN_ATTEMPTS = 5
const MAX_REQUEST_ATTEMPTS = 5

// Settings for USGS
const USGS_CONFIG = app_helpers.get_usgs_config()

module.exports = {

  logger,

  get_datasetName: function (scene_id, acquisition_date) {
    //check of slc of off in not assume on
    const slc_off = this.check_slc(acquisition_date)
    const use_c1 = this.check_c1(acquisition_date)

    //get product abbrevation
    const proudctAbbrevation = this.get_product_abbrevation(scene_id)

    //get the product abbrevation so we can determine the USGS
    //  dataset name
    switch (true) {
      case (proudctAbbrevation === "LC8" ) && (use_c1): //LANDSAT 8
        return  "LANDSAT_8_C1"
        break
      case (proudctAbbrevation === "LC8" ) && (!use_c1): //LANDSAT 8
        return  "LANDSAT_8_C1" // used to be "LANDSAT_8"
        break
      case (proudctAbbrevation === "LE7") && (use_c1): //LANDSAT 7 with slc off
        return "LANDSAT_ETM_C1"
        break
      case (proudctAbbrevation === "LE7") && (slc_off) && (!use_c1): //LANDSAT 7 with slc off
        return "LANDSAT_ETM_C1" // used to be LANDSAT_ETM_SLC_OFF
        break
      case (proudctAbbrevation === "LE7") && (!slc_off) && (!use_c1): //LANDSAT 7 with slc on
        return "LANDSAT_ETM_C1" // used to be LANDSAT_ETM
        break
      case (proudctAbbrevation === "LT5") && (use_c1): //LANDSAT 5
        return "LANDSAT_TM_C1"
        break
      case (proudctAbbrevation === "LT4") && (use_c1): //LANDSAT 4
        return "LANDSAT_TM_C1"
        break
      case (proudctAbbrevation === "LT5") && (!use_c1): //LANDSAT 5
        return "LANDSAT_TM_C1" // used to be LANDSAT_TM
        break
      case (proudctAbbrevation === "LT4")  && (!use_c1): //LANDSAT 4
        return "LANDSAT_TM_C1" // used to be LANDSAT_TM
        break
      default:
        return "LANDSAT_8_C1"
        break
    }

  },

  /**
   * Sort scene records by which dataset they belong to.
   *
   * @param records is a list of records (scenes) from the metadata table.
   * In other words, the 'rows' field of the result of a select query.
   *
   * @return an object: keys are dataset names, values are lists of scene ids.
   *
   */
  sort_scene_records_by_dataset: function(records) {
    if (records && records.length) {
      var _this = this
      var scenes_by_dataset = { }
      USGS_CONSTANT.LANDSAT_DATASETS.map(function (dataset_name) {
        scenes_by_dataset[dataset_name] = []
      })
      records.forEach(function(row) {
        const row_dataset = _this.get_datasetName(row.scene_id, row.acquisition_date)
        scenes_by_dataset[row_dataset].push(row.scene_id)
      })
      return scenes_by_dataset
    }
    else {
      this.throw_error('No records supplied to sort by dataset')
    }
  },

  /**
   * Process scenes for each landsat dataset. Run a callback for each group of scenes.
   * When a callback finishes, put the result of the callback in place of the list of scenes
   * just processed. When every dataset is processed, return all callback results.
   *
   * @param dataset_names is a list of landsat dataset names
   * @param scenes_by_dataset is the output of sort_scene_records_by_dataset
   *
   * @param callback is a function to call for each group of scenes.
   *    @param dataset_name is the name of the dataset
   *           to which the current batch of scenes belong
   *    @param dataset_scenes is a list of scene objects from the metadata table.
   *    ...
   *    @param user parameters (cb_params) are placed after the previous two parameters
   *
   *
   * @param cb_params is a list of additional arguments for the callback function.
   *
   * @return an object where fields are dataset names and the values
   *    are the return values of the invoked callbacks for each dataset.
   *
   */
  process_scenes_by_dataset: function (dataset_names, scenes_by_dataset, callback, cb_params) {
    var _this = this
    const dataset_name = dataset_names.pop()
    const dataset_scenes = scenes_by_dataset[dataset_name]
    cb_params = cb_params || []
    cb_params.splice(0, 0, dataset_name, dataset_scenes)
    return Promise.resolve().then(function () {
      if (typeof(callback) === 'function' && dataset_scenes.length) {
        return callback.apply(null, cb_params)
      }
    }).then(function (cb_result) {
      scenes_by_dataset[dataset_name] = cb_result
      if (dataset_names.length) {
        return _this.process_scenes_by_dataset(dataset_names, scenes_by_dataset, callback, cb_params)
      }
      return scenes_by_dataset
    })
  },

  //get the product abbrevation from the scene_id
  //  this will help do things like determine the datasetName for sending requests
  //  to the USGS api
  get_product_abbrevation: function(scene_id){
    return scene_id.substring(0, 3)
    //get product abbrevation. This identifes the imager product
  },

  //decide if c1 not
  check_c1: function(acquisition_date){

    //needs to be a date type for comparison
    const image_acquisition_date = new Date(acquisition_date)

    return (USGS_CONSTANT.C1_DATA_DATE < image_acquisition_date)
  },

  //decide if slc is off or on for landsat 7 imagery
  check_slc: function(acquisition_date){

    //needs to be a date type for comparison
    const image_acquisition_date = new Date(acquisition_date)

    return (USGS_CONSTANT.SLC_ONFF_DATE < image_acquisition_date)
  },

  //function to login and get apiKey will need to use .then to access
  //  which is how promises are resolved.
  get_api_key: function(num_attempts) {

    num_attempts = num_attempts || 1

    //get the user name and password from config file
    //config yaml should always be in format
    // username: usgs user name
    // password: usgs password
    //and shold be in a file named config.yaml
    const username = USGS_CONFIG.username
    const password = USGS_CONFIG.password

    //create the login data JSON data from the response
    var login_data = this.makeLoginData(username, password)

    const USGS_REQUEST_CODE_LOGIN = this.get_usgs_response_code('login')

    //declare _this so it's available
    var _this = this

    //HTTP post for login
    return this.get_usgsapi_response(USGS_REQUEST_CODE_LOGIN, login_data)

  },

  //generic axio request function using HTTP get
  get_usgsapi_response: function(action, body, num_attempts) {

    num_attempts = num_attempts || 1

    var request_action =  this.create_url_action(action)
    var request_body =  this.create_PostBody(body)

    //declare _this so it's available
    var _this = this

    return axios.post(
      request_action,
      request_body,
      USGS_CONSTANT.REQUEST_POST_HEADERS
    )
    .then( response =>  {
      //USGS format is in data object so its in response.data.data
      var response_data = _this.get_response_data(response)

      //check of data is null this usually means there is some kind
      // of error in the returned from USGS JSON API
      if (response_data === null || response.data.error) {
        return Promise.reject(new Error(this.get_response_error(response)))
      }
      return response_data

    })
    .catch(function (error) {
      if (error.message.indexOf('Rate limit exceeded') >= 0) {
        if (num_attempts < MAX_REQUEST_ATTEMPTS) {
          logger.log(
            logger.LEVEL_INFO,
            'INFO USGS API call failed (simultaneous requests error): '
            + 'will try again until we reach the limit for request attempts '
            + '(' + MAX_REQUEST_ATTEMPTS + ')'
          )
          return _this.get_usgsapi_response(action, body, ++num_attempts)
        }
        else {
          logger.log(
            logger.LEVEL_ERROR,
            'ERROR USGS API call failed (simultaneous requests error): '
            + 'limit for request attempts reached'
          )
          return Promise.reject(error)
        }
      }
      logger.log(logger.LEVEL_ERROR, error.stack)
      return Promise.reject(error)
    })
  },

  //function to create the body of the http post.  for usgs this needs to be a key of jsonRequest in the
  //  URL string followed by JSON "string".  this function formats properly
  create_PostBody: function(data){
     const USGS_JSON_REQUEST = 'jsonRequest='
     return USGS_JSON_REQUEST + JSON.stringify(data)
  },

  //function to create the url action the correct URL structure for the JSON API is:
  // Formulating the Request URL
  // Each request follows a standard URL format.
  //
  // <http_service_endpoint>/json/<request_code>?jsonRequest=<json_request_content>
  //the <request_code> is the action
  create_url_action: function(action){
     return '/' + action
  },

  //function to get the JSON response data.
  //  the response is in .data but errors are in .error.
  // use this function to get data.
  get_response_data: function(response){
    if (response.data.data != null){
      return response.data.data
    }
  },

  //function to get the JSON response error
  // Errors
  // Errors within this API are typically returned in the returned JSON object.
  // However, be sure to inspect the HTTP status code on each request, as some errors may not be caught by the service endpoint.
  // Error codes can be found on the error code page. The error response field may provide additional details about an error.
  get_response_error: function(response){
    if (response.data.error !== null){
      return 'Error in USGS response: ' + response.data.error
    } else {
      return 'Unknown error occurred.'
    }
  },

  //throw error with custom message
  throw_error: function(error_message) {
    //create error
    //const error = new Error(error_message)
    throw new Error(error_message)
  },

  //makes loging data json data from YAML config file
  makeLoginData: function(username,password){
    return {
      username,
      password,
    }
  },

  //must be one of these request codes
  get_usgs_response_code: function(request_code){
    valid_request_codes = ['clearbulkdownloadorder',
                   'clearorder',
                   'datasetfields',
                   'datasets',
                   'download',
                   'downloadoptions',
                   'getbulkdownloadproducts',
                   'getorderproducts',
                   'grid2ll',
                   'itembasket',
                   'login',
                   'logout',
                   'removebulkdownloadscene',
                   'removeorderscene',
                   'metadata',
                   'search',
                   'hits',
                   'submitbulkdownloadorder',
                   'submitorder',
                   'updatebulkdownloadscene',
                   'updateorderscene'
                 ]

    if (valid_request_codes.indexOf(request_code) >= 0) {
       return request_code
    } else {
      this.throw_error('request ' + request_code + ' is not available or is an invalid request code.  Check the USGS JSON api documentation @ http://earthexplorer.usgs.gov/inventory/documentation.  Maybe the request code is a new call that has been added to the api but not updated here.')
    }
  },

  //merge json objects. would use spread but not availabe in node yet
  mergejson: function(a, b){
     for(var key in b)
         if(b.hasOwnProperty(key))
             a[key] = b[key]
     return a
  },

  //logout
  usgs_logout: function (apiKey){

    //get logout json request
    request_body = USGS_FUNCTION.usgsapi_logout(apiKey)

    //make sure this is a valid request code
    const request_code = 'logout'
    const USGS_REQUEST_CODE = this.get_usgs_response_code(request_code)
    //send logout request to usgs api
    return this.get_usgsapi_response(USGS_REQUEST_CODE, request_body)
  },

}


text:
<package>
    <name>upo_rrt_planners</name>
    <version>1.0.0</version>
    <description>

        A library with some implementations of RRT planners.

    </description>
    <author>Noé Pérez-Higueras</author>
    <maintainer email="noeperez@upo.es">Noé Pérez</maintainer>
    <license>BSD</license>
    <url>https://github.com/robotics-upo</url>

    <buildtool_depend>catkin</buildtool_depend>

	<build_depend>angles</build_depend>
    <build_depend>cmake_modules</build_depend>
    <!--build_depend>costmap_2d</build_depend-->
    <build_depend>geometry_msgs</build_depend>
    <build_depend>nav_msgs</build_depend>
	<build_depend>rosconsole</build_depend>
    <build_depend>roscpp</build_depend>
    <build_depend>std_msgs</build_depend>
    <build_depend>tf</build_depend>
    <build_depend>visualization_msgs</build_depend>
  	<build_depend>upo_msgs</build_depend>
	<build_depend>navigation_features</build_depend>
	<build_depend>gmm_sampling</build_depend>
	<build_depend>dynamic_reconfigure</build_depend>
	<build_depend>message_generation</build_depend>

	<run_depend>angles</run_depend>
	<run_depend>cmake_modules</run_depend>
    <!--run_depend>costmap_2d</run_depend-->
    <run_depend>geometry_msgs</run_depend>
    <run_depend>nav_msgs</run_depend>
	<run_depend>rosconsole</run_depend>
    <run_depend>roscpp</run_depend>
    <run_depend>std_msgs</run_depend>
    <run_depend>tf</run_depend>
    <run_depend>visualization_msgs</run_depend>
  	<run_depend>upo_msgs</run_depend>
	<run_depend>navigation_features</run_depend>
	<run_depend>gmm_sampling</run_depend>
	<run_depend>dynamic_reconfigure</run_depend>
	<run_depend>message_runtime</run_depend>

</package>


text:
#pragma once
#include "FBCommonHeaders/Helpers.h"
#include "FBRenderer/RendererStructs.h"
namespace fb{
	class IScene;
	struct ParticleRenderKey{
		IScene* mScene;
		int mScreenspace;
		char mTexturePath[256];
		BLEND_DESC mBDesc;
		bool mGlow;
		bool mDepthFade;
		char padding[2];

		ParticleRenderKey();
		ParticleRenderKey(IScene* scene, const char* texturePath,
			const BLEND_DESC& desc, bool glow, bool depthFade, int screenspace);
		bool operator==(const ParticleRenderKey& other) const;
		bool operator<(const ParticleRenderKey& other) const;
	};
}

namespace std {
	template<>
	struct hash<fb::ParticleRenderKey>
		: public _Bitwise_hash<fb::ParticleRenderKey>
	{
		typedef fb::ParticleRenderKey _Kty;
		typedef _Bitwise_hash<_Kty> _Mybase;

		size_t operator()(const _Kty& _Keyval) const
		{
			auto h = std::hash<void*>()(_Keyval.mScene);
			fb::hash_combine(h, std::hash<int>()(_Keyval.mScreenspace));
			fb::hash_combine(h, std::hash<std::string>()(std::string(_Keyval.mTexturePath)));
			fb::hash_combine(h, std::hash<fb::BLEND_DESC>()(_Keyval.mBDesc));
			fb::hash_combine(h, std::hash<bool>()(_Keyval.mGlow));
			fb::hash_combine(h, std::hash<bool>()(_Keyval.mDepthFade));
			return h;
		}
	};
}


text:
<!DOCTYPE html>

	<title>UserList - RequireJS Test Page</title>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
	<meta name="keywords" content="">
	<meta name="description" content="">

	<link href="../assets/css/common.css" rel="stylesheet" />
    <link href="../assets/bootstrap-3.3.4/css/bootstrap.min.css" rel="stylesheet" />

                {{$user.username}}


text:
package aws

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path"
	"strconv"

	"github.com/stardog-union/stardog-graviton"
	"errors"
)

// VolumeStatusDescription is an opaque way to pass AWS specific information to
// the calling code.
type VolumeStatusDescription struct {
	VolumeIds []string
}

// EbsVolumes describes the disk volumes used by aws to store STARDOG_HOME.
type EbsVolumes struct {
	DeploymentName   string `json:"deployment_name,omitempty"`
	Region           string `json:"aws_region,omitempty"`
	SizeOfEachVolume string `json:"stardog_home_volume_size,omitempty"`
	ClusterSize      string `json:"cluster_size,omitempty"`
	AwsKeyName       string `json:"aws_key_name,omitempty"`
	KeyPath          string `json:"key_path,omitempty"`
	AmiID            string `json:"ami,omitempty"`
	InstanceType     string `json:"instance_type,omitempty"`
	LicensePath      string `json:"stardog_license,omitempty"`
	VolumeType       string `json:"stardog_home_volume_type,omitempty"`
	IoPs             string `json:"stardog_home_volume_iops,omitempty"`
	VolumeDir        string `json:"-"`
	appContext       sdutils.AppContext
}

// NewAwsEbsVolumeManager returns a EbsVolumes structure that will be used by
// graviton to manage the volumes.
func NewAwsEbsVolumeManager(ac sdutils.AppContext, dd *awsDeploymentDescription) *EbsVolumes {
	volumeDir := path.Join(dd.deployDir, "etc", "terraform", "volumes")

	return &EbsVolumes{
		DeploymentName: dd.Name,
		Region:         dd.Region,
		AwsKeyName:     dd.AwsKeyName,
		KeyPath:        dd.PrivateKeyPath,
		AmiID:          dd.AmiID,
		InstanceType:   dd.SdInstanceType,
		VolumeDir:      volumeDir,
		appContext:     ac,
	}
}

// LoadEbsVolume will inflate a EbsVolumes structure for the information stored in the
// files under the configuration directory.
func LoadEbsVolume(ac sdutils.AppContext, volDir string) (*EbsVolumes, error) {
	var ebsC EbsVolumes
	confFile := path.Join(volDir, "config.json")
	err := sdutils.LoadJSON(&ebsC, confFile)
	if err != nil {
		return nil, err
	}
	return &ebsC, nil
}

// VolumeExists returns true or false based on whether or not the Volumes already
// exist.
func (v *EbsVolumes) VolumeExists() bool {
	confFile := path.Join(v.VolumeDir, "config.json")
	return sdutils.PathExists(confFile)
}

// CreateSet uses terraform to create and format the EBS volumes in AWS.
func (v *EbsVolumes) CreateSet(licensePath string, sizeOfEachVolume int, clusterSize int) error {
	// TODO make sure we clean up resources on failure
	v.appContext.ConsoleLog(2, "Creating an aws volume set in directory %s\n", v.VolumeDir)
	terraformPath, err := GetTerraformPath(v.appContext)
	if err != nil {
		return err
	}
	v.ClusterSize = fmt.Sprintf("%d", clusterSize)
	v.SizeOfEachVolume = fmt.Sprintf("%d", sizeOfEachVolume)
	v.LicensePath = licensePath

	envVolType := os.Getenv("TF_VAR_stardog_home_volume_type")
	if envVolType != "" && envVolType != "io1" {
		v.IoPs = fmt.Sprintf("%d", 0)
	} else {
		envVolIops := os.Getenv("TF_VAR_stardog_home_volume_iops")
		var iops int

		if envVolIops != "" {
			iops, err = strconv.Atoi(envVolIops)
			if err != nil {
				return err
			}
		} else {
			iops = sizeOfEachVolume * sdutils.GetMaxIopsRatio()
		}

		v.IoPs = fmt.Sprintf("%d", iops)
	}

	confFile := path.Join(v.VolumeDir, "config.json")
	if _, err := os.Stat(confFile); err == nil {
		v.appContext.ConsoleLog(1, "Volumes have already been created for the %s deployment, running terraform apply again.", v.DeploymentName)
		v.appContext.Logf(sdutils.WARN, "Volumes have already been created for the %s deployment, running terraform apply again.", v.DeploymentName)
	}
	err = sdutils.WriteJSON(v, confFile)
	if err != nil {
		return err
	}

	cmdInitArray := []string{terraformPath, "init", "-input=false"}
	cmdInit := exec.Cmd{
		Path: cmdInitArray[0],
		Args: cmdInitArray,
		Dir:  v.VolumeDir,
	}
	spin := sdutils.NewSpinner(v.appContext, 1, "Initializing terraform...")
	_, err = sdutils.RunCommand(v.appContext, cmdInit, nil, spin)
	if err != nil {
		return err
	}

	cmdArray := []string{terraformPath, "apply", "-input=false", "-auto-approve",
		"-var-file", confFile}
	cmd := exec.Cmd{
		Path: cmdArray[0],
		Args: cmdArray,
		Dir:  v.VolumeDir,
	}
	spin = sdutils.NewSpinner(v.appContext, 1, "Calling out to terraform to create the volumes")
	_, err = sdutils.RunCommand(v.appContext, cmd, nil, spin)
	if err != nil {
		return err
	}
	err = os.Remove(path.Join(v.VolumeDir, "builder.tf"))
	if err != nil {
		return err
	}
	spin = sdutils.NewSpinner(v.appContext, 1, "Calling out to terraform to stop builder instances")
	_, err = sdutils.RunCommand(v.appContext, cmd, nil, spin)
	if err != nil {
		return err
	}
	v.appContext.ConsoleLog(1, "Successfully created the volumes.\n")
	return nil
}

// DeleteSet will delete the EBS volumes from AWS.
func (v *EbsVolumes) DeleteSet() error {
	confFile := path.Join(v.VolumeDir, "config.json")
	terraformPath, err := GetTerraformPath(v.appContext)
	if err != nil {
		return err
	}
	cmdArray := []string{terraformPath, "destroy", "-force",
		"-var-file", confFile}

	cmd := exec.Cmd{
		Path: cmdArray[0],
		Args: cmdArray,
		Dir:  v.VolumeDir,
	}
	spin := sdutils.NewSpinner(v.appContext, 1, "Calling out to terraform to delete the images")
	_, err = sdutils.RunCommand(v.appContext, cmd, nil, spin)
	if err != nil {
		return err
	}
	err = os.Remove(confFile)
	if err != nil {
		return err
	}
	v.appContext.ConsoleLog(1, "Successfully destroyed the volumes.\n")
	return nil
}

func (v *EbsVolumes) getStatusInformation() (*VolumeStatusDescription, error) {
	terraformPath, err := GetTerraformPath(v.appContext)
	if err != nil {
		return nil, err
	}

	cmdArray := []string{terraformPath, "output", "-json"}
	cmd := exec.Cmd{
		Path: cmdArray[0],
		Args: cmdArray,
		Dir:  v.VolumeDir,
	}
	data, err := cmd.Output()
	if err != nil {
		return nil, err
	}
	try := make(map[string]OutputEntry)
	err = json.Unmarshal(data, &try)
	if err != nil {
		return nil, err
	}
	volStatus := VolumeStatusDescription{}
	volsEnt, ok := try["volumes"]
	if !ok {
		return nil, errors.New("Invalid volume results in terraform output")
	}
	interList := volsEnt.Value.([]interface{})

	volStatus.VolumeIds = make([]string, len(interList), len(interList))
	for ndx, x := range interList {
		volStatus.VolumeIds[ndx] = x.(string)
	}

	return &volStatus, nil
}

// Status will print out status information about the EBS volumes.
func (v *EbsVolumes) Status() error {
	vD, err := v.getStatusInformation()
	if err != nil {
		return err
	}
	v.appContext.ConsoleLog(1, "Volumes:\n")
	for _, x := range vD.VolumeIds {
		v.appContext.ConsoleLog(1, "%s\n", x)
	}
	return nil
}


text:
title: Starbucks Bags
subtitle:
type: no-zoom
date: 2015-11-01
thumbnail: /CollectedMaterials/StrBcks-b_tile_s.jpg
thumbnail-alt: Notebook Project Starbucks Packaging Bag
---


text:
TODO: Write a gem description

## Installation

Add this line to your application's Gemfile:

    gem 'geography_client', path: '(*)/operadorPrestador_gem'

    (*) = path a la gem

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install geography_client

## Usage
  Add in the model:

 * Area.rb
 ```ruby
class Area < AeroAPI::Area
end
```

 * Country.rb
  ```ruby
class Country < AeroAPI::Country
end
```

 * Destination.rb
  ```ruby
class Destination < AeroAPI::Destination
end
```

 * Region.rb
  ```ruby
class Region< AeroAPI::Region
end
```

Ej:

  ```ruby
Region.find(1)
Destination.all

```
Las regiones tienen paises, los paises tiene areas(Ciudades), las areas tiene destinos.

## Contributing

1. Fork it ( https://github.com/[my-github-username]/aero_operator_provider_client/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text: Xcode Code Snippet


text:
<TITLE>Counter Snip</TITLE>
<META NAME="TITLE" CONTENT="Counter-Snip">
<META NAME="identifer-URL" CONTENT="http://sniperman.free.fr">
<META NAME="AUTHOR" lang="fr" CONTENT="Sniperman">
<META NAME="OWNER" CONTENT="snake.spm@laposte.net">
<META NAME="SUBJECT" CONTENT="Counter Strike">
<META NAME="Category" CONTENT="Internet - Jeux - Cs">
<META NAME="DESRIPTION" CONTENT="Tout sur Counter Strike et plus">
<META NAME="KEYWORDS" CONTENT="sniperman,kirikiri,countersnip,counter-snip,cs,counter strike,counterstrike,wallpapers,fond d'écran,sms,loto,prizee,astuces,armes,skins,binds,alias,half life,maps,download,téléchargement,patchs,guide,dossier,aide,ping,fps,optimisation,mms,loteries,Orange,LAN,réseau,France,fr,hl key fr,1.5,1.3,1.4,Forum,Astuces,Console,commandes,Cheat,Hack,OGL,wallhack,liens,GBA,rom,Annuaire,">
<META NAME="LANGUAGE" CONTENT="FR">
<META NAME="robots" CONTENT="All">

        Dossier Wallpapers

 Accueil

  Téléchargement

    <MARQUEE behavior= "scroll" align= "center" direction= "up" height="80" scrollamount= "2" scrolldelay= "10" onmouseover='this.stop()' onmouseout='this.start()'>

- Counter Strike 1.5 -

        127 mo

- Pack CS 1.6 OFFline -

              Dossier

- Counter Strike 1.6 -

        Full 388 mo

- Half life 1.1.1.0 -

        Full 84 mo

- Pod Bot 2.5 -

        2 mo

- Akimbot Bot 3.0 -

        0.3 mo

- Steam Customizer -

        0.3 mo

- All-Seeing Eyes -

    </MARQUEE>

  Stats :

         Wallpapers CS : 46

             Screen FUN : 20

             Wallpapers HL² : 19

             Screen HL² : 28

             Clicks :

    		Ho la
              belle collection !

                <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0" width="108" height="28">
                  <param name="BGCOLOR" value="#4D574A">
                  <param name="movie" value="page4.swf">
                  <param name="quality" value="high">
                  <param name="base" value=".">
                  <embed src="page4.swf" width="108" height="28" base="."  quality="high" pluginspage="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash" type="application/x-shockwave-flash" bgcolor="#4D574A" ></embed>
                </object>
                <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0" width="108" height="28">
                  <param name="movie" value="page1.swf">
                  <param name="quality" value="high">
                  <param name="base" value=".">
                  <param name="bgcolor" value="#4D574A">
                  <embed src="page1.swf" base="."  quality="high" pluginspage="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash" type="application/x-shockwave-flash" width="108" height="28" bgcolor="#4D574A"></embed>
                </object>
                <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0" width="108" height="28">
                  <param name="movie" value="page2b.swf">
                  <param name="quality" value="high">
                  <param name="base" value=".">
                  <param name="bgcolor" value="#4D574A">
                  <embed src="page2b.swf" base="."  quality="high" pluginspage="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash" type="application/x-shockwave-flash" width="108" height="28" bgcolor="#4D574A"></embed>
                </object>
                <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0" width="108" height="28">
                  <param name="movie" value="page3.swf">
                  <param name="quality" value="high">
                  <param name="base" value=".">
                  <param name="bgcolor" value="#4D574A">
                  <embed src="page3.swf" base="."  quality="high" pluginspage="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash" type="application/x-shockwave-flash" width="108" height="28" bgcolor="#4D574A"></embed>
                </object>

Voici ma collection de wallpapers qui n'est pour le moment pas
                au complet.

                Ce dossier sera mis à jour régulièrement
                 alors revenez surfer sur ces pages souvent !

Naviguez sur les 3 pages de fonds d'écran avec les boutons
                de navigations en haut

.::[ Images
                    FUN | Page 1 | Page
                    2 | Page
              3 ]::.


text:
#define EVENTTRACING

using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Box2D.XNA.TestBed.Framework
{
    public interface IEventTrace
    {
        int Register(string label, Color color);
        void BeginTrace(int eventID);
        void EndTrace(int eventID);

        void ResetFrame();
    }

    public class EventTrace : IEventTrace
    {
        public EventTrace(Game game)
        {
            _game = game;
            game.Services.AddService(typeof(IEventTrace), this);
        }

        public int Register(string label, Color color)
        {
            var e = new Event();
            e.Id = _nextId;
            e.Label = label;
            e.Color = color;
            e.TraceTicks = new List<long>(10);

            _registeredEvents[_nextId] = e;
            return _nextId++;
        }

        public void BeginTrace(int eventID)
        {
#if EVENTTRACING
            if (_stopwatch.IsRunning)
            {
                Event e = _registeredEvents[eventID];
                if (!e.LastTraceWasStart)
                {
                    e.TraceTicks.Add(_stopwatch.ElapsedTicks);
                    e.LastTraceWasStart = true;
                }
            }
#endif
        }

        public void EndTrace(int eventID)
        {
#if EVENTTRACING
            if (_stopwatch.IsRunning)
            {
                Event e = _registeredEvents[eventID];
                if (e.LastTraceWasStart)
                {
                    e.TraceTicks.Add(_stopwatch.ElapsedTicks);
                    e.LastTraceWasStart = false;
                }
            }
#endif
        }

        public void ResetFrame()
        {
#if EVENTTRACING
            if (_stopwatch.IsRunning)
            {
                EnsureContent();

                double totalTime = _stopwatch.Elapsed.TotalSeconds;
                Vector2 offset = new Vector2(50, 100);
                float height = 20;
                float textWidth = 175;
                float timeWidth = 500;

                _spriteBatch.Begin();

                foreach (var e in _registeredEvents.Values)
                {
                    var count = e.TraceTicks.Count;
                    if (count % 2 != 0)
                    {
                        throw new InvalidOperationException();
                    }

                    int intervals = 0;
                    double eventTime = 0;
                    for (int i=0; i<count; i+=2)
                    {
                        double startRatio = (double)e.TraceTicks[i] / (double)Stopwatch.Frequency / totalTime;
                        double endRatio = (double)e.TraceTicks[i + 1] / (double)Stopwatch.Frequency / totalTime;
                        int startOffset = (int)(offset.X + textWidth + startRatio * timeWidth);
                        int endOffset = (int)(offset.X + textWidth + endRatio * timeWidth);
                        if (endOffset <= startOffset)
                            endOffset++;

                        _spriteBatch.Draw(_1x1, new Rectangle(startOffset, (int)offset.Y, endOffset - startOffset, (int)height), e.Color);
                        intervals++;
                        eventTime += (endRatio - startRatio) * totalTime;
                    }

                    _spriteBatch.DrawString(_font, string.Format("{0} ({1}) {2:f}", e.Label, intervals, eventTime * 1000.0), offset, e.Color);

                    e.ResetFrame();
                    offset.Y += height + 5;
                }

                _spriteBatch.End();
            }
            _stopwatch.Reset();
            _stopwatch.Start();
#endif
        }

        private void EnsureContent()
        {
            if (_spriteBatch == null)
            {
                _spriteBatch = new SpriteBatch(_game.GraphicsDevice);
            }

            if (_font == null)
            {
                _font = _game.Content.Load<SpriteFont>("font");
            }

            if (_1x1 == null)
            {
                _1x1 = _game.Content.Load<Texture2D>("1x1");
            }
        }

        private Game _game;
        private SpriteBatch _spriteBatch;
        private SpriteFont _font;
        private Texture2D _1x1;
        private int _nextId;
        private Stopwatch _stopwatch = new Stopwatch();
        private Dictionary<int, Event> _registeredEvents = new Dictionary<int,Event>();

        public class Event
        {
            public int Id;
            public string Label;
            public Color Color;
            public List<long> TraceTicks;
            public bool LastTraceWasStart;

            internal void ResetFrame()
            {
                if (LastTraceWasStart)
                {
                    throw new InvalidOperationException();
                }

                TraceTicks.Clear();
            }
        }
    }
}


text:
#include "allegro5/allegro.h"
#include "allegro5/internal/aintern_system.h"

/* Function: al_get_num_video_adapters
 */
int al_get_num_video_adapters(void)
{
   ALLEGRO_SYSTEM *system = al_get_system_driver();

   if (system && system->vt && system->vt->get_num_video_adapters) {
      return system->vt->get_num_video_adapters();
   }

   return 0;
}

/* Function: al_get_monitor_info
 */
bool al_get_monitor_info(int adapter, ALLEGRO_MONITOR_INFO *info)
{
   ALLEGRO_SYSTEM *system = al_get_system_driver();

   if (adapter < al_get_num_video_adapters()) {
      if (system && system->vt && system->vt->get_monitor_info) {
         return system->vt->get_monitor_info(adapter, info);
      }
   }

   info->x1 = info->y1 = info->x2 = info->y2 = INT_MAX;
   return false;
}

/* vim: set sts=3 sw=3 et: */