file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/76700726.c
|
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2016. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
#include <stdio.h>
void
abc(void)
{
void xyz(void);
printf("abc() calling xyz()\n");
xyz();
}
__asm__(".symver xyz,xyz@VER_1");
|
the_stack_data/151423.c
|
#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;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
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;}
#endif
#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)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/Cd(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#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) = conjf(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) (cimagf(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;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
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;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
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;
}
#endif
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;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_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;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_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;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_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;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_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__1 = 1;
static doublecomplex c_b10 = {-1.,0.};
/* > \brief \b ZGETC2 computes the LU factorization with complete pivoting of the general n-by-n matrix. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZGETC2 + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zgetc2.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zgetc2.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetc2.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZGETC2( N, A, LDA, IPIV, JPIV, INFO ) */
/* INTEGER INFO, LDA, N */
/* INTEGER IPIV( * ), JPIV( * ) */
/* COMPLEX*16 A( LDA, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZGETC2 computes an LU factorization, using complete pivoting, of the */
/* > n-by-n matrix A. The factorization has the form A = P * L * U * Q, */
/* > where P and Q are permutation matrices, L is lower triangular with */
/* > unit diagonal elements and U is upper triangular. */
/* > */
/* > This is a level 1 BLAS version of the algorithm. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is COMPLEX*16 array, dimension (LDA, N) */
/* > On entry, the n-by-n matrix to be factored. */
/* > On exit, the factors L and U from the factorization */
/* > A = P*L*U*Q; the unit diagonal elements of L are not stored. */
/* > If U(k, k) appears to be less than SMIN, U(k, k) is given the */
/* > value of SMIN, giving a nonsingular perturbed system. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1, N). */
/* > \endverbatim */
/* > */
/* > \param[out] IPIV */
/* > \verbatim */
/* > IPIV is INTEGER array, dimension (N). */
/* > The pivot indices; for 1 <= i <= N, row i of the */
/* > matrix has been interchanged with row IPIV(i). */
/* > \endverbatim */
/* > */
/* > \param[out] JPIV */
/* > \verbatim */
/* > JPIV is INTEGER array, dimension (N). */
/* > The pivot indices; for 1 <= j <= N, column j of the */
/* > matrix has been interchanged with column JPIV(j). */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > > 0: if INFO = k, U(k, k) is likely to produce overflow if */
/* > one tries to solve for x in Ax = b. So U is perturbed */
/* > to avoid the overflow. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date June 2016 */
/* > \ingroup complex16GEauxiliary */
/* > \par Contributors: */
/* ================== */
/* > */
/* > Bo Kagstrom and Peter Poromaa, Department of Computing Science, */
/* > Umea University, S-901 87 Umea, Sweden. */
/* ===================================================================== */
/* Subroutine */ int zgetc2_(integer *n, doublecomplex *a, integer *lda,
integer *ipiv, integer *jpiv, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
doublereal d__1;
doublecomplex z__1;
/* Local variables */
doublereal smin, xmax;
integer i__, j;
extern /* Subroutine */ int zgeru_(integer *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *), zswap_(integer *, doublecomplex *,
integer *, doublecomplex *, integer *), dlabad_(doublereal *,
doublereal *);
extern doublereal dlamch_(char *);
integer ip, jp;
doublereal bignum, smlnum, eps;
integer ipv, jpv;
/* -- LAPACK auxiliary routine (version 3.8.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* June 2016 */
/* ===================================================================== */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--ipiv;
--jpiv;
/* Function Body */
*info = 0;
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Set constants to control overflow */
eps = dlamch_("P");
smlnum = dlamch_("S") / eps;
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Handle the case N=1 by itself */
if (*n == 1) {
ipiv[1] = 1;
jpiv[1] = 1;
if (z_abs(&a[a_dim1 + 1]) < smlnum) {
*info = 1;
i__1 = a_dim1 + 1;
z__1.r = smlnum, z__1.i = 0.;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
return 0;
}
/* Factorize A using complete pivoting. */
/* Set pivots less than SMIN to SMIN */
i__1 = *n - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Find f2cmax element in matrix A */
xmax = 0.;
i__2 = *n;
for (ip = i__; ip <= i__2; ++ip) {
i__3 = *n;
for (jp = i__; jp <= i__3; ++jp) {
if (z_abs(&a[ip + jp * a_dim1]) >= xmax) {
xmax = z_abs(&a[ip + jp * a_dim1]);
ipv = ip;
jpv = jp;
}
/* L10: */
}
/* L20: */
}
if (i__ == 1) {
/* Computing MAX */
d__1 = eps * xmax;
smin = f2cmax(d__1,smlnum);
}
/* Swap rows */
if (ipv != i__) {
zswap_(n, &a[ipv + a_dim1], lda, &a[i__ + a_dim1], lda);
}
ipiv[i__] = ipv;
/* Swap columns */
if (jpv != i__) {
zswap_(n, &a[jpv * a_dim1 + 1], &c__1, &a[i__ * a_dim1 + 1], &
c__1);
}
jpiv[i__] = jpv;
/* Check for singularity */
if (z_abs(&a[i__ + i__ * a_dim1]) < smin) {
*info = i__;
i__2 = i__ + i__ * a_dim1;
z__1.r = smin, z__1.i = 0.;
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
}
i__2 = *n;
for (j = i__ + 1; j <= i__2; ++j) {
i__3 = j + i__ * a_dim1;
z_div(&z__1, &a[j + i__ * a_dim1], &a[i__ + i__ * a_dim1]);
a[i__3].r = z__1.r, a[i__3].i = z__1.i;
/* L30: */
}
i__2 = *n - i__;
i__3 = *n - i__;
zgeru_(&i__2, &i__3, &c_b10, &a[i__ + 1 + i__ * a_dim1], &c__1, &a[
i__ + (i__ + 1) * a_dim1], lda, &a[i__ + 1 + (i__ + 1) *
a_dim1], lda);
/* L40: */
}
if (z_abs(&a[*n + *n * a_dim1]) < smin) {
*info = *n;
i__1 = *n + *n * a_dim1;
z__1.r = smin, z__1.i = 0.;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
/* Set last pivots to N */
ipiv[*n] = *n;
jpiv[*n] = *n;
return 0;
/* End of ZGETC2 */
} /* zgetc2_ */
|
the_stack_data/59192.c
|
/*
Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it andor
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http:www.gnu.org/licenses/>.
*/
/*
This header is separate from features.h so that the compiler can
include it implicitly at the start of every compilation. It must
not itself include <features.h> or any other header that includes
<features.h> because the implicit include comes before any feature
test macros that may be defined in a source file before it first
explicitly includes a system header. GCC knows the name of this
header in order to preinclude it.
*/
/*
glibc's intent is to support the IEC 559 math functionality, real
and complex. If the GCC (4.9 and later) predefined macros
specifying compiler intent are available, use them to determine
whether the overall intent is to support these features; otherwise,
presume an older compiler has intent to support these features and
define these macros by default.
*/
/*
wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is
synchronized with ISOIEC 10646:2017, fifth edition, plus
the following additions from Amendment 1 to the fifth edition:
- 56 emoji characters
- 285 hentaigana
- 3 additional Zanabazar Square characters
*/
/*
Copyright (c) 2017, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory
Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
Markus Schordan, and Ian Karlin
(email: [email protected], [email protected], [email protected],
[email protected], [email protected])
LLNL-CODE-732144
All rights reserved.
This file is part of DataRaceBench. For details, see
https:github.comLLNL/dataracebench. Please also see the LICENSE file
for our additional BSD notice.
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 disclaimer below.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the disclaimer (as noted below)
in the documentation and/or other materials provided with the
distribution.
* Neither the name of the LLNS/LLNL nor the names of its contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
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 LAWRENCE LIVERMORE NATIONAL
SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY 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.
*/
/*
A file-scope variable used within a function called by a parallel region.
No threadprivate is used to avoid data races.
This is the case for a variable referenced within a construct.
Data race pairs sum0@68:7 vs. sum0@68:12
sum0@68:7 vs. sum0@68:7
*/
#include <stdio.h>
#include <assert.h>
int sum0 = 0, sum1 = 0;
/* #pragma omp threadprivate(sum0) */
int main()
{
int i, sum = 0;
int _ret_val_0;
#pragma cetus private(i)
#pragma loop name main#0
#pragma cetus parallel
#pragma omp parallel for private(i)
for (i=1; i<=1000; i ++ )
{
}
sum0+=500500;
sum=(sum+sum0);
/* reference calculation */
#pragma cetus private(i)
#pragma loop name main#1
#pragma cetus parallel
#pragma omp parallel for private(i)
for (i=1; i<=1000; i ++ )
{
}
sum1+=500500;
printf("sum=%d; sum1=%d\n", sum, sum1);
/* assert(sum==sum1); */
_ret_val_0=0;
return _ret_val_0;
}
|
the_stack_data/30858.c
|
/* { dg-do compile } */
/* { dg-options "-mcmse" } */
typedef struct
{
char a:3;
} test_st3;
typedef struct
{
char a:3;
} test_st2;
typedef struct
{
test_st2 st2;
test_st3 st3;
} test_st;
typedef union
{
test_st st;
struct
{
unsigned int v1;
unsigned int v2;
unsigned int v3;
unsigned int v4;
}values;
} read_st;
typedef void __attribute__ ((cmse_nonsecure_call)) (*foo_ns) (test_st);
int
main (void)
{
read_st r;
foo_ns f;
f = (foo_ns) 0x200000;
r.values.v1 = 0xFFFFFFFF;
f (r.st);
return 0;
}
/* { dg-final { scan-assembler "movw\tip, #1799" } } */
/* { dg-final { scan-assembler "and\tr0, r0, ip" } } */
/* { dg-final { scan-assembler "lsrs\tr4, r4, #1" } } */
/* { dg-final { scan-assembler "lsls\tr4, r4, #1" } } */
/* { dg-final { scan-assembler "mov\tr1, r4" } } */
/* { dg-final { scan-assembler "mov\tr2, r4" } } */
/* { dg-final { scan-assembler "mov\tr3, r4" } } */
/* { dg-final { scan-assembler "bl\t__gnu_cmse_nonsecure_call" } } */
|
the_stack_data/1095.c
|
// INFO: recovery required on readonly filesystem
// https://syzkaller.appspot.com/bug?id=8fba766ebc0cb4586325380ed578c469fa92de44
// status:invalid
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <linux/kvm.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.h>
__attribute__((noreturn)) static void doexit(int status)
{
volatile unsigned i;
syscall(__NR_exit_group, status);
for (i = 0;; i++) {
}
}
#include <errno.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
#include <sys/stat.h>
const int kFailStatus = 67;
const int kRetryStatus = 69;
static void fail(const char* msg, ...)
{
int e = errno;
va_list args;
va_start(args, msg);
vfprintf(stderr, msg, args);
va_end(args);
fprintf(stderr, " (errno %d)\n", e);
doexit((e == ENOMEM || e == EAGAIN) ? kRetryStatus : kFailStatus);
}
static __thread int skip_segv;
static __thread jmp_buf segv_env;
static void segv_handler(int sig, siginfo_t* info, void* uctx)
{
uintptr_t addr = (uintptr_t)info->si_addr;
const uintptr_t prog_start = 1 << 20;
const uintptr_t prog_end = 100 << 20;
if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
(addr < prog_start || addr > prog_end)) {
_longjmp(segv_env, 1);
}
doexit(sig);
for (;;) {
}
}
static void install_segv_handler()
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = segv_handler;
sa.sa_flags = SA_NODEFER | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
}
#define NONFAILING(...) \
{ \
__atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \
if (_setjmp(segv_env) == 0) { \
__VA_ARGS__; \
} \
__atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \
}
static void use_temporary_dir()
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
fail("failed to mkdtemp");
if (chmod(tmpdir, 0777))
fail("failed to chmod");
if (chdir(tmpdir))
fail("failed to chdir");
}
const char kvm_asm16_cpl3[] =
"\x0f\x20\xc0\x66\x83\xc8\x01\x0f\x22\xc0\xb8\xa0\x00\x0f\x00\xd8"
"\xb8\x2b\x00\x8e\xd8\x8e\xc0\x8e\xe0\x8e\xe8\xbc\x00\x01\xc7\x06"
"\x00\x01\x1d\xba\xc7\x06\x02\x01\x23\x00\xc7\x06\x04\x01\x00\x01"
"\xc7\x06\x06\x01\x2b\x00\xcb";
const char kvm_asm32_paged[] =
"\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22\xc0";
const char kvm_asm32_vm86[] =
"\x66\xb8\xb8\x00\x0f\x00\xd8\xea\x00\x00\x00\x00\xd0\x00";
const char kvm_asm32_paged_vm86[] =
"\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22\xc0\x66\xb8\xb8\x00\x0f"
"\x00\xd8\xea\x00\x00\x00\x00\xd0\x00";
const char kvm_asm64_vm86[] = "\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22"
"\xc0\x66\xb8\xb8\x00\x0f\x00\xd8\xea\x00"
"\x00\x00\x00\xd0\x00";
const char kvm_asm64_enable_long[] =
"\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22\xc0\xea\xde\xc0\xad\x0b"
"\x50\x00\x48\xc7\xc0\xd8\x00\x00\x00\x0f\x00\xd8";
const char kvm_asm64_init_vm[] =
"\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22\xc0\xea\xde\xc0\xad\x0b"
"\x50\x00\x48\xc7\xc0\xd8\x00\x00\x00\x0f\x00\xd8\x48\xc7\xc1\x3a"
"\x00\x00\x00\x0f\x32\x48\x83\xc8\x05\x0f\x30\x0f\x20\xe0\x48\x0d"
"\x00\x20\x00\x00\x0f\x22\xe0\x48\xc7\xc1\x80\x04\x00\x00\x0f\x32"
"\x48\xc7\xc2\x00\x60\x00\x00\x89\x02\x48\xc7\xc2\x00\x70\x00\x00"
"\x89\x02\x48\xc7\xc0\x00\x5f\x00\x00\xf3\x0f\xc7\x30\x48\xc7\xc0"
"\x08\x5f\x00\x00\x66\x0f\xc7\x30\x0f\xc7\x30\x48\xc7\xc1\x81\x04"
"\x00\x00\x0f\x32\x48\x83\xc8\x3f\x48\x21\xd0\x48\xc7\xc2\x00\x40"
"\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x02\x40\x00\x00\x48\xb8\x84\x9e"
"\x99\xf3\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x1e\x40\x00\x00"
"\x48\xc7\xc0\x81\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc1\x83\x04\x00"
"\x00\x0f\x32\x48\x0d\xff\x6f\x03\x00\x48\x21\xd0\x48\xc7\xc2\x0c"
"\x40\x00\x00\x0f\x79\xd0\x48\xc7\xc1\x84\x04\x00\x00\x0f\x32\x48"
"\x0d\xff\x17\x00\x00\x48\x21\xd0\x48\xc7\xc2\x12\x40\x00\x00\x0f"
"\x79\xd0\x48\xc7\xc2\x04\x2c\x00\x00\x48\xc7\xc0\x00\x00\x00\x00"
"\x0f\x79\xd0\x48\xc7\xc2\x00\x28\x00\x00\x48\xc7\xc0\xff\xff\xff"
"\xff\x0f\x79\xd0\x48\xc7\xc2\x02\x0c\x00\x00\x48\xc7\xc0\x50\x00"
"\x00\x00\x0f\x79\xd0\x48\xc7\xc0\x58\x00\x00\x00\x48\xc7\xc2\x00"
"\x0c\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x04\x0c\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x06\x0c\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x08\x0c\x00"
"\x00\x0f\x79\xd0\x48\xc7\xc2\x0a\x0c\x00\x00\x0f\x79\xd0\x48\xc7"
"\xc0\xd8\x00\x00\x00\x48\xc7\xc2\x0c\x0c\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x02\x2c\x00\x00\x48\xc7\xc0\x00\x05\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x00\x4c\x00\x00\x48\xc7\xc0\x50\x00\x00\x00\x0f\x79"
"\xd0\x48\xc7\xc2\x10\x6c\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f"
"\x79\xd0\x48\xc7\xc2\x12\x6c\x00\x00\x48\xc7\xc0\x00\x00\x00\x00"
"\x0f\x79\xd0\x0f\x20\xc0\x48\xc7\xc2\x00\x6c\x00\x00\x48\x89\xc0"
"\x0f\x79\xd0\x0f\x20\xd8\x48\xc7\xc2\x02\x6c\x00\x00\x48\x89\xc0"
"\x0f\x79\xd0\x0f\x20\xe0\x48\xc7\xc2\x04\x6c\x00\x00\x48\x89\xc0"
"\x0f\x79\xd0\x48\xc7\xc2\x06\x6c\x00\x00\x48\xc7\xc0\x00\x00\x00"
"\x00\x0f\x79\xd0\x48\xc7\xc2\x08\x6c\x00\x00\x48\xc7\xc0\x00\x00"
"\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x0a\x6c\x00\x00\x48\xc7\xc0\x00"
"\x3a\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x0c\x6c\x00\x00\x48\xc7\xc0"
"\x00\x10\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x0e\x6c\x00\x00\x48\xc7"
"\xc0\x00\x38\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x14\x6c\x00\x00\x48"
"\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x16\x6c\x00\x00"
"\x48\x8b\x04\x25\x10\x5f\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x00\x00"
"\x00\x00\x48\xc7\xc0\x01\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x02"
"\x00\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2"
"\x00\x20\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7"
"\xc2\x02\x20\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x04\x20\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x06\x20\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79"
"\xd0\x48\xc7\xc1\x77\x02\x00\x00\x0f\x32\x48\xc1\xe2\x20\x48\x09"
"\xd0\x48\xc7\xc2\x00\x2c\x00\x00\x48\x89\xc0\x0f\x79\xd0\x48\xc7"
"\xc2\x04\x40\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x0a\x40\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x0e\x40\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79"
"\xd0\x48\xc7\xc2\x10\x40\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f"
"\x79\xd0\x48\xc7\xc2\x16\x40\x00\x00\x48\xc7\xc0\x00\x00\x00\x00"
"\x0f\x79\xd0\x48\xc7\xc2\x14\x40\x00\x00\x48\xc7\xc0\x00\x00\x00"
"\x00\x0f\x79\xd0\x48\xc7\xc2\x00\x60\x00\x00\x48\xc7\xc0\xff\xff"
"\xff\xff\x0f\x79\xd0\x48\xc7\xc2\x02\x60\x00\x00\x48\xc7\xc0\xff"
"\xff\xff\xff\x0f\x79\xd0\x48\xc7\xc2\x1c\x20\x00\x00\x48\xc7\xc0"
"\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x1e\x20\x00\x00\x48\xc7"
"\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x20\x20\x00\x00\x48"
"\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x22\x20\x00\x00"
"\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x00\x08\x00"
"\x00\x48\xc7\xc0\x58\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x02\x08"
"\x00\x00\x48\xc7\xc0\x50\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x04"
"\x08\x00\x00\x48\xc7\xc0\x58\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2"
"\x06\x08\x00\x00\x48\xc7\xc0\x58\x00\x00\x00\x0f\x79\xd0\x48\xc7"
"\xc2\x08\x08\x00\x00\x48\xc7\xc0\x58\x00\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x0a\x08\x00\x00\x48\xc7\xc0\x58\x00\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x0c\x08\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79"
"\xd0\x48\xc7\xc2\x0e\x08\x00\x00\x48\xc7\xc0\xd8\x00\x00\x00\x0f"
"\x79\xd0\x48\xc7\xc2\x12\x68\x00\x00\x48\xc7\xc0\x00\x00\x00\x00"
"\x0f\x79\xd0\x48\xc7\xc2\x14\x68\x00\x00\x48\xc7\xc0\x00\x3a\x00"
"\x00\x0f\x79\xd0\x48\xc7\xc2\x16\x68\x00\x00\x48\xc7\xc0\x00\x10"
"\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x18\x68\x00\x00\x48\xc7\xc0\x00"
"\x38\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x00\x48\x00\x00\x48\xc7\xc0"
"\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x02\x48\x00\x00\x48\xc7"
"\xc0\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x04\x48\x00\x00\x48"
"\xc7\xc0\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x06\x48\x00\x00"
"\x48\xc7\xc0\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x08\x48\x00"
"\x00\x48\xc7\xc0\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x0a\x48"
"\x00\x00\x48\xc7\xc0\xff\xff\x0f\x00\x0f\x79\xd0\x48\xc7\xc2\x0c"
"\x48\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2"
"\x0e\x48\x00\x00\x48\xc7\xc0\xff\x1f\x00\x00\x0f\x79\xd0\x48\xc7"
"\xc2\x10\x48\x00\x00\x48\xc7\xc0\xff\x1f\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x12\x48\x00\x00\x48\xc7\xc0\xff\x1f\x00\x00\x0f\x79\xd0"
"\x48\xc7\xc2\x14\x48\x00\x00\x48\xc7\xc0\x93\x40\x00\x00\x0f\x79"
"\xd0\x48\xc7\xc2\x16\x48\x00\x00\x48\xc7\xc0\x9b\x20\x00\x00\x0f"
"\x79\xd0\x48\xc7\xc2\x18\x48\x00\x00\x48\xc7\xc0\x93\x40\x00\x00"
"\x0f\x79\xd0\x48\xc7\xc2\x1a\x48\x00\x00\x48\xc7\xc0\x93\x40\x00"
"\x00\x0f\x79\xd0\x48\xc7\xc2\x1c\x48\x00\x00\x48\xc7\xc0\x93\x40"
"\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x1e\x48\x00\x00\x48\xc7\xc0\x93"
"\x40\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x20\x48\x00\x00\x48\xc7\xc0"
"\x82\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x22\x48\x00\x00\x48\xc7"
"\xc0\x8b\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x1c\x68\x00\x00\x48"
"\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x1e\x68\x00\x00"
"\x48\xc7\xc0\x00\x91\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x20\x68\x00"
"\x00\x48\xc7\xc0\x02\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x06\x28"
"\x00\x00\x48\xc7\xc0\x00\x05\x00\x00\x0f\x79\xd0\x48\xc7\xc2\x0a"
"\x28\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7\xc2"
"\x0c\x28\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48\xc7"
"\xc2\x0e\x28\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0\x48"
"\xc7\xc2\x10\x28\x00\x00\x48\xc7\xc0\x00\x00\x00\x00\x0f\x79\xd0"
"\x0f\x20\xc0\x48\xc7\xc2\x00\x68\x00\x00\x48\x89\xc0\x0f\x79\xd0"
"\x0f\x20\xd8\x48\xc7\xc2\x02\x68\x00\x00\x48\x89\xc0\x0f\x79\xd0"
"\x0f\x20\xe0\x48\xc7\xc2\x04\x68\x00\x00\x48\x89\xc0\x0f\x79\xd0"
"\x48\xc7\xc0\x18\x5f\x00\x00\x48\x8b\x10\x48\xc7\xc0\x20\x5f\x00"
"\x00\x48\x8b\x08\x48\x31\xc0\x0f\x78\xd0\x48\x31\xc8\x0f\x79\xd0"
"\x0f\x01\xc2\x48\xc7\xc2\x00\x44\x00\x00\x0f\x78\xd0\xf4";
const char kvm_asm64_vm_exit[] =
"\x48\xc7\xc3\x00\x44\x00\x00\x0f\x78\xda\x48\xc7\xc3\x02\x44\x00"
"\x00\x0f\x78\xd9\x48\xc7\xc0\x00\x64\x00\x00\x0f\x78\xc0\x48\xc7"
"\xc3\x1e\x68\x00\x00\x0f\x78\xdb\xf4";
const char kvm_asm64_cpl3[] =
"\x0f\x20\xc0\x0d\x00\x00\x00\x80\x0f\x22\xc0\xea\xde\xc0\xad\x0b"
"\x50\x00\x48\xc7\xc0\xd8\x00\x00\x00\x0f\x00\xd8\x48\xc7\xc0\x6b"
"\x00\x00\x00\x8e\xd8\x8e\xc0\x8e\xe0\x8e\xe8\x48\xc7\xc4\x80\x0f"
"\x00\x00\x48\xc7\x04\x24\x1d\xba\x00\x00\x48\xc7\x44\x24\x04\x63"
"\x00\x00\x00\x48\xc7\x44\x24\x08\x80\x0f\x00\x00\x48\xc7\x44\x24"
"\x0c\x6b\x00\x00\x00\xcb";
#define ADDR_TEXT 0x0000
#define ADDR_GDT 0x1000
#define ADDR_LDT 0x1800
#define ADDR_PML4 0x2000
#define ADDR_PDP 0x3000
#define ADDR_PD 0x4000
#define ADDR_STACK0 0x0f80
#define ADDR_VAR_HLT 0x2800
#define ADDR_VAR_SYSRET 0x2808
#define ADDR_VAR_SYSEXIT 0x2810
#define ADDR_VAR_IDT 0x3800
#define ADDR_VAR_TSS64 0x3a00
#define ADDR_VAR_TSS64_CPL3 0x3c00
#define ADDR_VAR_TSS16 0x3d00
#define ADDR_VAR_TSS16_2 0x3e00
#define ADDR_VAR_TSS16_CPL3 0x3f00
#define ADDR_VAR_TSS32 0x4800
#define ADDR_VAR_TSS32_2 0x4a00
#define ADDR_VAR_TSS32_CPL3 0x4c00
#define ADDR_VAR_TSS32_VM86 0x4e00
#define ADDR_VAR_VMXON_PTR 0x5f00
#define ADDR_VAR_VMCS_PTR 0x5f08
#define ADDR_VAR_VMEXIT_PTR 0x5f10
#define ADDR_VAR_VMWRITE_FLD 0x5f18
#define ADDR_VAR_VMWRITE_VAL 0x5f20
#define ADDR_VAR_VMXON 0x6000
#define ADDR_VAR_VMCS 0x7000
#define ADDR_VAR_VMEXIT_CODE 0x9000
#define ADDR_VAR_USER_CODE 0x9100
#define ADDR_VAR_USER_CODE2 0x9120
#define SEL_LDT (1 << 3)
#define SEL_CS16 (2 << 3)
#define SEL_DS16 (3 << 3)
#define SEL_CS16_CPL3 ((4 << 3) + 3)
#define SEL_DS16_CPL3 ((5 << 3) + 3)
#define SEL_CS32 (6 << 3)
#define SEL_DS32 (7 << 3)
#define SEL_CS32_CPL3 ((8 << 3) + 3)
#define SEL_DS32_CPL3 ((9 << 3) + 3)
#define SEL_CS64 (10 << 3)
#define SEL_DS64 (11 << 3)
#define SEL_CS64_CPL3 ((12 << 3) + 3)
#define SEL_DS64_CPL3 ((13 << 3) + 3)
#define SEL_CGATE16 (14 << 3)
#define SEL_TGATE16 (15 << 3)
#define SEL_CGATE32 (16 << 3)
#define SEL_TGATE32 (17 << 3)
#define SEL_CGATE64 (18 << 3)
#define SEL_CGATE64_HI (19 << 3)
#define SEL_TSS16 (20 << 3)
#define SEL_TSS16_2 (21 << 3)
#define SEL_TSS16_CPL3 ((22 << 3) + 3)
#define SEL_TSS32 (23 << 3)
#define SEL_TSS32_2 (24 << 3)
#define SEL_TSS32_CPL3 ((25 << 3) + 3)
#define SEL_TSS32_VM86 (26 << 3)
#define SEL_TSS64 (27 << 3)
#define SEL_TSS64_HI (28 << 3)
#define SEL_TSS64_CPL3 ((29 << 3) + 3)
#define SEL_TSS64_CPL3_HI (30 << 3)
#define MSR_IA32_FEATURE_CONTROL 0x3a
#define MSR_IA32_VMX_BASIC 0x480
#define MSR_IA32_SMBASE 0x9e
#define MSR_IA32_SYSENTER_CS 0x174
#define MSR_IA32_SYSENTER_ESP 0x175
#define MSR_IA32_SYSENTER_EIP 0x176
#define MSR_IA32_STAR 0xC0000081
#define MSR_IA32_LSTAR 0xC0000082
#define MSR_IA32_VMX_PROCBASED_CTLS2 0x48B
#define NEXT_INSN $0xbadc0de
#define PREFIX_SIZE 0xba1d
#define KVM_SMI _IO(KVMIO, 0xb7)
#define CR0_PE 1
#define CR0_MP (1 << 1)
#define CR0_EM (1 << 2)
#define CR0_TS (1 << 3)
#define CR0_ET (1 << 4)
#define CR0_NE (1 << 5)
#define CR0_WP (1 << 16)
#define CR0_AM (1 << 18)
#define CR0_NW (1 << 29)
#define CR0_CD (1 << 30)
#define CR0_PG (1 << 31)
#define CR4_VME 1
#define CR4_PVI (1 << 1)
#define CR4_TSD (1 << 2)
#define CR4_DE (1 << 3)
#define CR4_PSE (1 << 4)
#define CR4_PAE (1 << 5)
#define CR4_MCE (1 << 6)
#define CR4_PGE (1 << 7)
#define CR4_PCE (1 << 8)
#define CR4_OSFXSR (1 << 8)
#define CR4_OSXMMEXCPT (1 << 10)
#define CR4_UMIP (1 << 11)
#define CR4_VMXE (1 << 13)
#define CR4_SMXE (1 << 14)
#define CR4_FSGSBASE (1 << 16)
#define CR4_PCIDE (1 << 17)
#define CR4_OSXSAVE (1 << 18)
#define CR4_SMEP (1 << 20)
#define CR4_SMAP (1 << 21)
#define CR4_PKE (1 << 22)
#define EFER_SCE 1
#define EFER_LME (1 << 8)
#define EFER_LMA (1 << 10)
#define EFER_NXE (1 << 11)
#define EFER_SVME (1 << 12)
#define EFER_LMSLE (1 << 13)
#define EFER_FFXSR (1 << 14)
#define EFER_TCE (1 << 15)
#define PDE32_PRESENT 1
#define PDE32_RW (1 << 1)
#define PDE32_USER (1 << 2)
#define PDE32_PS (1 << 7)
#define PDE64_PRESENT 1
#define PDE64_RW (1 << 1)
#define PDE64_USER (1 << 2)
#define PDE64_ACCESSED (1 << 5)
#define PDE64_DIRTY (1 << 6)
#define PDE64_PS (1 << 7)
#define PDE64_G (1 << 8)
struct tss16 {
uint16_t prev;
uint16_t sp0;
uint16_t ss0;
uint16_t sp1;
uint16_t ss1;
uint16_t sp2;
uint16_t ss2;
uint16_t ip;
uint16_t flags;
uint16_t ax;
uint16_t cx;
uint16_t dx;
uint16_t bx;
uint16_t sp;
uint16_t bp;
uint16_t si;
uint16_t di;
uint16_t es;
uint16_t cs;
uint16_t ss;
uint16_t ds;
uint16_t ldt;
} __attribute__((packed));
struct tss32 {
uint16_t prev, prevh;
uint32_t sp0;
uint16_t ss0, ss0h;
uint32_t sp1;
uint16_t ss1, ss1h;
uint32_t sp2;
uint16_t ss2, ss2h;
uint32_t cr3;
uint32_t ip;
uint32_t flags;
uint32_t ax;
uint32_t cx;
uint32_t dx;
uint32_t bx;
uint32_t sp;
uint32_t bp;
uint32_t si;
uint32_t di;
uint16_t es, esh;
uint16_t cs, csh;
uint16_t ss, ssh;
uint16_t ds, dsh;
uint16_t fs, fsh;
uint16_t gs, gsh;
uint16_t ldt, ldth;
uint16_t trace;
uint16_t io_bitmap;
} __attribute__((packed));
struct tss64 {
uint32_t reserved0;
uint64_t rsp[3];
uint64_t reserved1;
uint64_t ist[7];
uint64_t reserved2;
uint32_t reserved3;
uint32_t io_bitmap;
} __attribute__((packed));
static void fill_segment_descriptor(uint64_t* dt, uint64_t* lt,
struct kvm_segment* seg)
{
uint16_t index = seg->selector >> 3;
uint64_t limit = seg->g ? seg->limit >> 12 : seg->limit;
uint64_t sd =
(limit & 0xffff) | (seg->base & 0xffffff) << 16 |
(uint64_t)seg->type << 40 | (uint64_t)seg->s << 44 |
(uint64_t)seg->dpl << 45 | (uint64_t)seg->present << 47 |
(limit & 0xf0000ULL) << 48 | (uint64_t)seg->avl << 52 |
(uint64_t)seg->l << 53 | (uint64_t)seg->db << 54 |
(uint64_t)seg->g << 55 | (seg->base & 0xff000000ULL) << 56;
NONFAILING(dt[index] = sd);
NONFAILING(lt[index] = sd);
}
static void fill_segment_descriptor_dword(uint64_t* dt, uint64_t* lt,
struct kvm_segment* seg)
{
fill_segment_descriptor(dt, lt, seg);
uint16_t index = seg->selector >> 3;
NONFAILING(dt[index + 1] = 0);
NONFAILING(lt[index + 1] = 0);
}
static void setup_syscall_msrs(int cpufd, uint16_t sel_cs,
uint16_t sel_cs_cpl3)
{
char buf[sizeof(struct kvm_msrs) + 5 * sizeof(struct kvm_msr_entry)];
memset(buf, 0, sizeof(buf));
struct kvm_msrs* msrs = (struct kvm_msrs*)buf;
msrs->nmsrs = 5;
msrs->entries[0].index = MSR_IA32_SYSENTER_CS;
msrs->entries[0].data = sel_cs;
msrs->entries[1].index = MSR_IA32_SYSENTER_ESP;
msrs->entries[1].data = ADDR_STACK0;
msrs->entries[2].index = MSR_IA32_SYSENTER_EIP;
msrs->entries[2].data = ADDR_VAR_SYSEXIT;
msrs->entries[3].index = MSR_IA32_STAR;
msrs->entries[3].data =
((uint64_t)sel_cs << 32) | ((uint64_t)sel_cs_cpl3 << 48);
msrs->entries[4].index = MSR_IA32_LSTAR;
msrs->entries[4].data = ADDR_VAR_SYSRET;
ioctl(cpufd, KVM_SET_MSRS, msrs);
}
static void setup_32bit_idt(struct kvm_sregs* sregs, char* host_mem,
uintptr_t guest_mem)
{
sregs->idt.base = guest_mem + ADDR_VAR_IDT;
sregs->idt.limit = 0x1ff;
uint64_t* idt = (uint64_t*)(host_mem + sregs->idt.base);
int i;
for (i = 0; i < 32; i++) {
struct kvm_segment gate;
gate.selector = i << 3;
switch (i % 6) {
case 0:
gate.type = 6;
gate.base = SEL_CS16;
break;
case 1:
gate.type = 7;
gate.base = SEL_CS16;
break;
case 2:
gate.type = 3;
gate.base = SEL_TGATE16;
break;
case 3:
gate.type = 14;
gate.base = SEL_CS32;
break;
case 4:
gate.type = 15;
gate.base = SEL_CS32;
break;
case 6:
gate.type = 11;
gate.base = SEL_TGATE32;
break;
}
gate.limit = guest_mem + ADDR_VAR_USER_CODE2;
gate.present = 1;
gate.dpl = 0;
gate.s = 0;
gate.g = 0;
gate.db = 0;
gate.l = 0;
gate.avl = 0;
fill_segment_descriptor(idt, idt, &gate);
}
}
static void setup_64bit_idt(struct kvm_sregs* sregs, char* host_mem,
uintptr_t guest_mem)
{
sregs->idt.base = guest_mem + ADDR_VAR_IDT;
sregs->idt.limit = 0x1ff;
uint64_t* idt = (uint64_t*)(host_mem + sregs->idt.base);
int i;
for (i = 0; i < 32; i++) {
struct kvm_segment gate;
gate.selector = (i * 2) << 3;
gate.type = (i & 1) ? 14 : 15;
gate.base = SEL_CS64;
gate.limit = guest_mem + ADDR_VAR_USER_CODE2;
gate.present = 1;
gate.dpl = 0;
gate.s = 0;
gate.g = 0;
gate.db = 0;
gate.l = 0;
gate.avl = 0;
fill_segment_descriptor_dword(idt, idt, &gate);
}
}
struct kvm_text {
uintptr_t typ;
const void* text;
uintptr_t size;
};
struct kvm_opt {
uint64_t typ;
uint64_t val;
};
#define KVM_SETUP_PAGING (1 << 0)
#define KVM_SETUP_PAE (1 << 1)
#define KVM_SETUP_PROTECTED (1 << 2)
#define KVM_SETUP_CPL3 (1 << 3)
#define KVM_SETUP_VIRT86 (1 << 4)
#define KVM_SETUP_SMM (1 << 5)
#define KVM_SETUP_VM (1 << 6)
static uintptr_t syz_kvm_setup_cpu(uintptr_t a0, uintptr_t a1,
uintptr_t a2, uintptr_t a3,
uintptr_t a4, uintptr_t a5,
uintptr_t a6, uintptr_t a7)
{
const int vmfd = a0;
const int cpufd = a1;
char* const host_mem = (char*)a2;
const struct kvm_text* const text_array_ptr = (struct kvm_text*)a3;
const uintptr_t text_count = a4;
const uintptr_t flags = a5;
const struct kvm_opt* const opt_array_ptr = (struct kvm_opt*)a6;
uintptr_t opt_count = a7;
const uintptr_t page_size = 4 << 10;
const uintptr_t ioapic_page = 10;
const uintptr_t guest_mem_size = 24 * page_size;
const uintptr_t guest_mem = 0;
(void)text_count;
int text_type = 0;
const void* text = 0;
uintptr_t text_size = 0;
NONFAILING(text_type = text_array_ptr[0].typ);
NONFAILING(text = text_array_ptr[0].text);
NONFAILING(text_size = text_array_ptr[0].size);
uintptr_t i;
for (i = 0; i < guest_mem_size / page_size; i++) {
struct kvm_userspace_memory_region memreg;
memreg.slot = i;
memreg.flags = 0;
memreg.guest_phys_addr = guest_mem + i * page_size;
if (i == ioapic_page)
memreg.guest_phys_addr = 0xfec00000;
memreg.memory_size = page_size;
memreg.userspace_addr = (uintptr_t)host_mem + i * page_size;
ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &memreg);
}
struct kvm_userspace_memory_region memreg;
memreg.slot = 1 + (1 << 16);
memreg.flags = 0;
memreg.guest_phys_addr = 0x30000;
memreg.memory_size = 64 << 10;
memreg.userspace_addr = (uintptr_t)host_mem;
ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &memreg);
struct kvm_sregs sregs;
if (ioctl(cpufd, KVM_GET_SREGS, &sregs))
return -1;
struct kvm_regs regs;
memset(®s, 0, sizeof(regs));
regs.rip = guest_mem + ADDR_TEXT;
regs.rsp = ADDR_STACK0;
sregs.gdt.base = guest_mem + ADDR_GDT;
sregs.gdt.limit = 256 * sizeof(uint64_t) - 1;
uint64_t* gdt = (uint64_t*)(host_mem + sregs.gdt.base);
struct kvm_segment seg_ldt;
seg_ldt.selector = SEL_LDT;
seg_ldt.type = 2;
seg_ldt.base = guest_mem + ADDR_LDT;
seg_ldt.limit = 256 * sizeof(uint64_t) - 1;
seg_ldt.present = 1;
seg_ldt.dpl = 0;
seg_ldt.s = 0;
seg_ldt.g = 0;
seg_ldt.db = 1;
seg_ldt.l = 0;
sregs.ldt = seg_ldt;
uint64_t* ldt = (uint64_t*)(host_mem + sregs.ldt.base);
struct kvm_segment seg_cs16;
seg_cs16.selector = SEL_CS16;
seg_cs16.type = 11;
seg_cs16.base = 0;
seg_cs16.limit = 0xfffff;
seg_cs16.present = 1;
seg_cs16.dpl = 0;
seg_cs16.s = 1;
seg_cs16.g = 0;
seg_cs16.db = 0;
seg_cs16.l = 0;
struct kvm_segment seg_ds16 = seg_cs16;
seg_ds16.selector = SEL_DS16;
seg_ds16.type = 3;
struct kvm_segment seg_cs16_cpl3 = seg_cs16;
seg_cs16_cpl3.selector = SEL_CS16_CPL3;
seg_cs16_cpl3.dpl = 3;
struct kvm_segment seg_ds16_cpl3 = seg_ds16;
seg_ds16_cpl3.selector = SEL_DS16_CPL3;
seg_ds16_cpl3.dpl = 3;
struct kvm_segment seg_cs32 = seg_cs16;
seg_cs32.selector = SEL_CS32;
seg_cs32.db = 1;
struct kvm_segment seg_ds32 = seg_ds16;
seg_ds32.selector = SEL_DS32;
seg_ds32.db = 1;
struct kvm_segment seg_cs32_cpl3 = seg_cs32;
seg_cs32_cpl3.selector = SEL_CS32_CPL3;
seg_cs32_cpl3.dpl = 3;
struct kvm_segment seg_ds32_cpl3 = seg_ds32;
seg_ds32_cpl3.selector = SEL_DS32_CPL3;
seg_ds32_cpl3.dpl = 3;
struct kvm_segment seg_cs64 = seg_cs16;
seg_cs64.selector = SEL_CS64;
seg_cs64.l = 1;
struct kvm_segment seg_ds64 = seg_ds32;
seg_ds64.selector = SEL_DS64;
struct kvm_segment seg_cs64_cpl3 = seg_cs64;
seg_cs64_cpl3.selector = SEL_CS64_CPL3;
seg_cs64_cpl3.dpl = 3;
struct kvm_segment seg_ds64_cpl3 = seg_ds64;
seg_ds64_cpl3.selector = SEL_DS64_CPL3;
seg_ds64_cpl3.dpl = 3;
struct kvm_segment seg_tss32;
seg_tss32.selector = SEL_TSS32;
seg_tss32.type = 9;
seg_tss32.base = ADDR_VAR_TSS32;
seg_tss32.limit = 0x1ff;
seg_tss32.present = 1;
seg_tss32.dpl = 0;
seg_tss32.s = 0;
seg_tss32.g = 0;
seg_tss32.db = 0;
seg_tss32.l = 0;
struct kvm_segment seg_tss32_2 = seg_tss32;
seg_tss32_2.selector = SEL_TSS32_2;
seg_tss32_2.base = ADDR_VAR_TSS32_2;
struct kvm_segment seg_tss32_cpl3 = seg_tss32;
seg_tss32_cpl3.selector = SEL_TSS32_CPL3;
seg_tss32_cpl3.base = ADDR_VAR_TSS32_CPL3;
struct kvm_segment seg_tss32_vm86 = seg_tss32;
seg_tss32_vm86.selector = SEL_TSS32_VM86;
seg_tss32_vm86.base = ADDR_VAR_TSS32_VM86;
struct kvm_segment seg_tss16 = seg_tss32;
seg_tss16.selector = SEL_TSS16;
seg_tss16.base = ADDR_VAR_TSS16;
seg_tss16.limit = 0xff;
seg_tss16.type = 1;
struct kvm_segment seg_tss16_2 = seg_tss16;
seg_tss16_2.selector = SEL_TSS16_2;
seg_tss16_2.base = ADDR_VAR_TSS16_2;
seg_tss16_2.dpl = 0;
struct kvm_segment seg_tss16_cpl3 = seg_tss16;
seg_tss16_cpl3.selector = SEL_TSS16_CPL3;
seg_tss16_cpl3.base = ADDR_VAR_TSS16_CPL3;
seg_tss16_cpl3.dpl = 3;
struct kvm_segment seg_tss64 = seg_tss32;
seg_tss64.selector = SEL_TSS64;
seg_tss64.base = ADDR_VAR_TSS64;
seg_tss64.limit = 0x1ff;
struct kvm_segment seg_tss64_cpl3 = seg_tss64;
seg_tss64_cpl3.selector = SEL_TSS64_CPL3;
seg_tss64_cpl3.base = ADDR_VAR_TSS64_CPL3;
seg_tss64_cpl3.dpl = 3;
struct kvm_segment seg_cgate16;
seg_cgate16.selector = SEL_CGATE16;
seg_cgate16.type = 4;
seg_cgate16.base = SEL_CS16 | (2 << 16);
seg_cgate16.limit = ADDR_VAR_USER_CODE2;
seg_cgate16.present = 1;
seg_cgate16.dpl = 0;
seg_cgate16.s = 0;
seg_cgate16.g = 0;
seg_cgate16.db = 0;
seg_cgate16.l = 0;
seg_cgate16.avl = 0;
struct kvm_segment seg_tgate16 = seg_cgate16;
seg_tgate16.selector = SEL_TGATE16;
seg_tgate16.type = 3;
seg_cgate16.base = SEL_TSS16_2;
seg_tgate16.limit = 0;
struct kvm_segment seg_cgate32 = seg_cgate16;
seg_cgate32.selector = SEL_CGATE32;
seg_cgate32.type = 12;
seg_cgate32.base = SEL_CS32 | (2 << 16);
struct kvm_segment seg_tgate32 = seg_cgate32;
seg_tgate32.selector = SEL_TGATE32;
seg_tgate32.type = 11;
seg_tgate32.base = SEL_TSS32_2;
seg_tgate32.limit = 0;
struct kvm_segment seg_cgate64 = seg_cgate16;
seg_cgate64.selector = SEL_CGATE64;
seg_cgate64.type = 12;
seg_cgate64.base = SEL_CS64;
int kvmfd = open("/dev/kvm", O_RDWR);
char buf[sizeof(struct kvm_cpuid2) +
128 * sizeof(struct kvm_cpuid_entry2)];
memset(buf, 0, sizeof(buf));
struct kvm_cpuid2* cpuid = (struct kvm_cpuid2*)buf;
cpuid->nent = 128;
ioctl(kvmfd, KVM_GET_SUPPORTED_CPUID, cpuid);
ioctl(cpufd, KVM_SET_CPUID2, cpuid);
close(kvmfd);
const char* text_prefix = 0;
int text_prefix_size = 0;
char* host_text = host_mem + ADDR_TEXT;
if (text_type == 8) {
if (flags & KVM_SETUP_SMM) {
if (flags & KVM_SETUP_PROTECTED) {
sregs.cs = seg_cs16;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds16;
sregs.cr0 |= CR0_PE;
} else {
sregs.cs.selector = 0;
sregs.cs.base = 0;
}
NONFAILING(*(host_mem + ADDR_TEXT) = 0xf4);
host_text = host_mem + 0x8000;
ioctl(cpufd, KVM_SMI, 0);
} else if (flags & KVM_SETUP_VIRT86) {
sregs.cs = seg_cs32;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32;
sregs.cr0 |= CR0_PE;
sregs.efer |= EFER_SCE;
setup_syscall_msrs(cpufd, SEL_CS32, SEL_CS32_CPL3);
setup_32bit_idt(&sregs, host_mem, guest_mem);
if (flags & KVM_SETUP_PAGING) {
uint64_t pd_addr = guest_mem + ADDR_PD;
uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD);
NONFAILING(pd[0] = PDE32_PRESENT | PDE32_RW | PDE32_USER |
PDE32_PS);
sregs.cr3 = pd_addr;
sregs.cr4 |= CR4_PSE;
text_prefix = kvm_asm32_paged_vm86;
text_prefix_size = sizeof(kvm_asm32_paged_vm86) - 1;
} else {
text_prefix = kvm_asm32_vm86;
text_prefix_size = sizeof(kvm_asm32_vm86) - 1;
}
} else {
sregs.cs.selector = 0;
sregs.cs.base = 0;
}
} else if (text_type == 16) {
if (flags & KVM_SETUP_CPL3) {
sregs.cs = seg_cs16;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds16;
text_prefix = kvm_asm16_cpl3;
text_prefix_size = sizeof(kvm_asm16_cpl3) - 1;
} else {
sregs.cr0 |= CR0_PE;
sregs.cs = seg_cs16;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds16;
}
} else if (text_type == 32) {
sregs.cr0 |= CR0_PE;
sregs.efer |= EFER_SCE;
setup_syscall_msrs(cpufd, SEL_CS32, SEL_CS32_CPL3);
setup_32bit_idt(&sregs, host_mem, guest_mem);
if (flags & KVM_SETUP_SMM) {
sregs.cs = seg_cs32;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32;
NONFAILING(*(host_mem + ADDR_TEXT) = 0xf4);
host_text = host_mem + 0x8000;
ioctl(cpufd, KVM_SMI, 0);
} else if (flags & KVM_SETUP_PAGING) {
sregs.cs = seg_cs32;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32;
uint64_t pd_addr = guest_mem + ADDR_PD;
uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD);
NONFAILING(pd[0] =
PDE32_PRESENT | PDE32_RW | PDE32_USER | PDE32_PS);
sregs.cr3 = pd_addr;
sregs.cr4 |= CR4_PSE;
text_prefix = kvm_asm32_paged;
text_prefix_size = sizeof(kvm_asm32_paged) - 1;
} else if (flags & KVM_SETUP_CPL3) {
sregs.cs = seg_cs32_cpl3;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss =
seg_ds32_cpl3;
} else {
sregs.cs = seg_cs32;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32;
}
} else {
sregs.efer |= EFER_LME | EFER_SCE;
sregs.cr0 |= CR0_PE;
setup_syscall_msrs(cpufd, SEL_CS64, SEL_CS64_CPL3);
setup_64bit_idt(&sregs, host_mem, guest_mem);
sregs.cs = seg_cs32;
sregs.ds = sregs.es = sregs.fs = sregs.gs = sregs.ss = seg_ds32;
uint64_t pml4_addr = guest_mem + ADDR_PML4;
uint64_t* pml4 = (uint64_t*)(host_mem + ADDR_PML4);
uint64_t pdpt_addr = guest_mem + ADDR_PDP;
uint64_t* pdpt = (uint64_t*)(host_mem + ADDR_PDP);
uint64_t pd_addr = guest_mem + ADDR_PD;
uint64_t* pd = (uint64_t*)(host_mem + ADDR_PD);
NONFAILING(pml4[0] =
PDE64_PRESENT | PDE64_RW | PDE64_USER | pdpt_addr);
NONFAILING(pdpt[0] =
PDE64_PRESENT | PDE64_RW | PDE64_USER | pd_addr);
NONFAILING(pd[0] =
PDE64_PRESENT | PDE64_RW | PDE64_USER | PDE64_PS);
sregs.cr3 = pml4_addr;
sregs.cr4 |= CR4_PAE;
if (flags & KVM_SETUP_VM) {
sregs.cr0 |= CR0_NE;
NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMXON_PTR)) =
ADDR_VAR_VMXON);
NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMCS_PTR)) =
ADDR_VAR_VMCS);
NONFAILING(memcpy(host_mem + ADDR_VAR_VMEXIT_CODE,
kvm_asm64_vm_exit,
sizeof(kvm_asm64_vm_exit) - 1));
NONFAILING(*((uint64_t*)(host_mem + ADDR_VAR_VMEXIT_PTR)) =
ADDR_VAR_VMEXIT_CODE);
text_prefix = kvm_asm64_init_vm;
text_prefix_size = sizeof(kvm_asm64_init_vm) - 1;
} else if (flags & KVM_SETUP_CPL3) {
text_prefix = kvm_asm64_cpl3;
text_prefix_size = sizeof(kvm_asm64_cpl3) - 1;
} else {
text_prefix = kvm_asm64_enable_long;
text_prefix_size = sizeof(kvm_asm64_enable_long) - 1;
}
}
struct tss16 tss16;
memset(&tss16, 0, sizeof(tss16));
tss16.ss0 = tss16.ss1 = tss16.ss2 = SEL_DS16;
tss16.sp0 = tss16.sp1 = tss16.sp2 = ADDR_STACK0;
tss16.ip = ADDR_VAR_USER_CODE2;
tss16.flags = (1 << 1);
tss16.cs = SEL_CS16;
tss16.es = tss16.ds = tss16.ss = SEL_DS16;
tss16.ldt = SEL_LDT;
struct tss16* tss16_addr =
(struct tss16*)(host_mem + seg_tss16_2.base);
NONFAILING(memcpy(tss16_addr, &tss16, sizeof(tss16)));
memset(&tss16, 0, sizeof(tss16));
tss16.ss0 = tss16.ss1 = tss16.ss2 = SEL_DS16;
tss16.sp0 = tss16.sp1 = tss16.sp2 = ADDR_STACK0;
tss16.ip = ADDR_VAR_USER_CODE2;
tss16.flags = (1 << 1);
tss16.cs = SEL_CS16_CPL3;
tss16.es = tss16.ds = tss16.ss = SEL_DS16_CPL3;
tss16.ldt = SEL_LDT;
struct tss16* tss16_cpl3_addr =
(struct tss16*)(host_mem + seg_tss16_cpl3.base);
NONFAILING(memcpy(tss16_cpl3_addr, &tss16, sizeof(tss16)));
struct tss32 tss32;
memset(&tss32, 0, sizeof(tss32));
tss32.ss0 = tss32.ss1 = tss32.ss2 = SEL_DS32;
tss32.sp0 = tss32.sp1 = tss32.sp2 = ADDR_STACK0;
tss32.ip = ADDR_VAR_USER_CODE;
tss32.flags = (1 << 1) | (1 << 17);
tss32.ldt = SEL_LDT;
tss32.cr3 = sregs.cr3;
tss32.io_bitmap = offsetof(struct tss32, io_bitmap);
struct tss32* tss32_addr =
(struct tss32*)(host_mem + seg_tss32_vm86.base);
NONFAILING(memcpy(tss32_addr, &tss32, sizeof(tss32)));
memset(&tss32, 0, sizeof(tss32));
tss32.ss0 = tss32.ss1 = tss32.ss2 = SEL_DS32;
tss32.sp0 = tss32.sp1 = tss32.sp2 = ADDR_STACK0;
tss32.ip = ADDR_VAR_USER_CODE;
tss32.flags = (1 << 1);
tss32.cr3 = sregs.cr3;
tss32.es = tss32.ds = tss32.ss = tss32.gs = tss32.fs = SEL_DS32;
tss32.cs = SEL_CS32;
tss32.ldt = SEL_LDT;
tss32.cr3 = sregs.cr3;
tss32.io_bitmap = offsetof(struct tss32, io_bitmap);
struct tss32* tss32_cpl3_addr =
(struct tss32*)(host_mem + seg_tss32_2.base);
NONFAILING(memcpy(tss32_cpl3_addr, &tss32, sizeof(tss32)));
struct tss64 tss64;
memset(&tss64, 0, sizeof(tss64));
tss64.rsp[0] = ADDR_STACK0;
tss64.rsp[1] = ADDR_STACK0;
tss64.rsp[2] = ADDR_STACK0;
tss64.io_bitmap = offsetof(struct tss64, io_bitmap);
struct tss64* tss64_addr = (struct tss64*)(host_mem + seg_tss64.base);
NONFAILING(memcpy(tss64_addr, &tss64, sizeof(tss64)));
memset(&tss64, 0, sizeof(tss64));
tss64.rsp[0] = ADDR_STACK0;
tss64.rsp[1] = ADDR_STACK0;
tss64.rsp[2] = ADDR_STACK0;
tss64.io_bitmap = offsetof(struct tss64, io_bitmap);
struct tss64* tss64_cpl3_addr =
(struct tss64*)(host_mem + seg_tss64_cpl3.base);
NONFAILING(memcpy(tss64_cpl3_addr, &tss64, sizeof(tss64)));
if (text_size > 1000)
text_size = 1000;
if (text_prefix) {
NONFAILING(memcpy(host_text, text_prefix, text_prefix_size));
void* patch = 0;
NONFAILING(patch = memmem(host_text, text_prefix_size,
"\xde\xc0\xad\x0b", 4));
if (patch)
NONFAILING(*((uint32_t*)patch) = guest_mem + ADDR_TEXT +
((char*)patch - host_text) + 6);
uint16_t magic = PREFIX_SIZE;
patch = 0;
NONFAILING(patch = memmem(host_text, text_prefix_size, &magic,
sizeof(magic)));
if (patch)
NONFAILING(*((uint16_t*)patch) =
guest_mem + ADDR_TEXT + text_prefix_size);
}
NONFAILING(
memcpy((void*)(host_text + text_prefix_size), text, text_size));
NONFAILING(*(host_text + text_prefix_size + text_size) = 0xf4);
NONFAILING(memcpy(host_mem + ADDR_VAR_USER_CODE, text, text_size));
NONFAILING(*(host_mem + ADDR_VAR_USER_CODE + text_size) = 0xf4);
NONFAILING(*(host_mem + ADDR_VAR_HLT) = 0xf4);
NONFAILING(memcpy(host_mem + ADDR_VAR_SYSRET, "\x0f\x07\xf4", 3));
NONFAILING(memcpy(host_mem + ADDR_VAR_SYSEXIT, "\x0f\x35\xf4", 3));
NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_FLD) = 0);
NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_VAL) = 0);
if (opt_count > 2)
opt_count = 2;
for (i = 0; i < opt_count; i++) {
uint64_t typ = 0;
uint64_t val = 0;
NONFAILING(typ = opt_array_ptr[i].typ);
NONFAILING(val = opt_array_ptr[i].val);
switch (typ % 9) {
case 0:
sregs.cr0 ^= val & (CR0_MP | CR0_EM | CR0_ET | CR0_NE | CR0_WP |
CR0_AM | CR0_NW | CR0_CD);
break;
case 1:
sregs.cr4 ^= val & (CR4_VME | CR4_PVI | CR4_TSD | CR4_DE |
CR4_MCE | CR4_PGE | CR4_PCE | CR4_OSFXSR |
CR4_OSXMMEXCPT | CR4_UMIP | CR4_VMXE |
CR4_SMXE | CR4_FSGSBASE | CR4_PCIDE |
CR4_OSXSAVE | CR4_SMEP | CR4_SMAP | CR4_PKE);
break;
case 2:
sregs.efer ^= val & (EFER_SCE | EFER_NXE | EFER_SVME |
EFER_LMSLE | EFER_FFXSR | EFER_TCE);
break;
case 3:
val &= ((1 << 8) | (1 << 9) | (1 << 10) | (1 << 12) | (1 << 13) |
(1 << 14) | (1 << 15) | (1 << 18) | (1 << 19) |
(1 << 20) | (1 << 21));
regs.rflags ^= val;
NONFAILING(tss16_addr->flags ^= val);
NONFAILING(tss16_cpl3_addr->flags ^= val);
NONFAILING(tss32_addr->flags ^= val);
NONFAILING(tss32_cpl3_addr->flags ^= val);
break;
case 4:
seg_cs16.type = val & 0xf;
seg_cs32.type = val & 0xf;
seg_cs64.type = val & 0xf;
break;
case 5:
seg_cs16_cpl3.type = val & 0xf;
seg_cs32_cpl3.type = val & 0xf;
seg_cs64_cpl3.type = val & 0xf;
break;
case 6:
seg_ds16.type = val & 0xf;
seg_ds32.type = val & 0xf;
seg_ds64.type = val & 0xf;
break;
case 7:
seg_ds16_cpl3.type = val & 0xf;
seg_ds32_cpl3.type = val & 0xf;
seg_ds64_cpl3.type = val & 0xf;
break;
case 8:
NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_FLD) =
(val & 0xffff));
NONFAILING(*(uint64_t*)(host_mem + ADDR_VAR_VMWRITE_VAL) =
(val >> 16));
break;
default:
fail("bad kvm setup opt");
}
}
regs.rflags |= 2;
fill_segment_descriptor(gdt, ldt, &seg_ldt);
fill_segment_descriptor(gdt, ldt, &seg_cs16);
fill_segment_descriptor(gdt, ldt, &seg_ds16);
fill_segment_descriptor(gdt, ldt, &seg_cs16_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_ds16_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_cs32);
fill_segment_descriptor(gdt, ldt, &seg_ds32);
fill_segment_descriptor(gdt, ldt, &seg_cs32_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_ds32_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_cs64);
fill_segment_descriptor(gdt, ldt, &seg_ds64);
fill_segment_descriptor(gdt, ldt, &seg_cs64_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_ds64_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_tss32);
fill_segment_descriptor(gdt, ldt, &seg_tss32_2);
fill_segment_descriptor(gdt, ldt, &seg_tss32_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_tss32_vm86);
fill_segment_descriptor(gdt, ldt, &seg_tss16);
fill_segment_descriptor(gdt, ldt, &seg_tss16_2);
fill_segment_descriptor(gdt, ldt, &seg_tss16_cpl3);
fill_segment_descriptor_dword(gdt, ldt, &seg_tss64);
fill_segment_descriptor_dword(gdt, ldt, &seg_tss64_cpl3);
fill_segment_descriptor(gdt, ldt, &seg_cgate16);
fill_segment_descriptor(gdt, ldt, &seg_tgate16);
fill_segment_descriptor(gdt, ldt, &seg_cgate32);
fill_segment_descriptor(gdt, ldt, &seg_tgate32);
fill_segment_descriptor_dword(gdt, ldt, &seg_cgate64);
if (ioctl(cpufd, KVM_SET_SREGS, &sregs))
return -1;
if (ioctl(cpufd, KVM_SET_REGS, ®s))
return -1;
return 0;
}
long r[13];
void loop()
{
memset(r, -1, sizeof(r));
r[0] = syscall(__NR_mmap, 0x20000000ul, 0xfff000ul, 0x3ul, 0x32ul,
0xfffffffffffffffful, 0x0ul);
NONFAILING(memcpy((void*)0x20004ff7,
"\x2f\x64\x65\x76\x2f\x6b\x76\x6d\x00", 9));
r[2] = syscall(__NR_openat, 0xffffffffffffff9cul, 0x20004ff7ul, 0x0ul,
0x0ul);
r[3] = syscall(__NR_ioctl, r[2], 0xae01ul, 0x0ul);
r[4] = syscall(__NR_ioctl, r[3], 0xae41ul, 0x0ul);
NONFAILING(*(uint64_t*)0x20040000 = (uint64_t)0x8);
NONFAILING(*(uint64_t*)0x20040008 = (uint64_t)0x20fccf88);
NONFAILING(*(uint64_t*)0x20040010 = (uint64_t)0x78);
NONFAILING(memcpy(
(void*)0x20fccf88,
"\x97\x0f\x6f\x27\x69\x42\x42\x00\xd3\x0f\xc7\x18\x10\x25\xb9\xab"
"\x80\x00\x00\x9c\x00\x9c\x66\x35\x00\x10\x00\x00\x0f\x30\x2e\x36"
"\x66\x0f\x73\xd6\x0b\x66\xb9\x80\x00\x00\xc0\x3e\x3e\x26\x67\x0f"
"\xc7\x9b\x00\x00\x01\x00\x66\x35\x00\x01\x00\x00\x0f\x30\x26\x0f"
"\xc7\x5f\x00\xba\xf8\x0c\x66\xb8\xd2\x3f\x1e\x87\x7c\xba\xfc\x0c"
"\xed\xba\xf8\x0c\x66\xb8\x50\x0e\xce\x84\x66\xb8\x01\x00\x00\x00"
"\x0f\x23\xd8\x0f\x21\xf8\x66\x35\x40\x00\x00\xa0\x0f\x23\xf8\xba"
"\xfc\x0c\xb0\x00\xee\x0f\x1d\xf4",
120));
NONFAILING(*(uint64_t*)0x20416ff0 = (uint64_t)0x2);
NONFAILING(*(uint64_t*)0x20416ff8 = (uint64_t)0x101);
r[11] = syz_kvm_setup_cpu(0xfffffffffffffffful, r[4], 0x205cc000ul,
0x20040000ul, 0x1ul, 0x5ul, 0x20416ff0ul,
0x1ul);
r[12] = syscall(__NR_ioctl, r[4], 0xae80ul, 0x0ul);
}
int main()
{
install_segv_handler();
use_temporary_dir();
loop();
return 0;
}
|
the_stack_data/33683.c
|
extern float strtof(const char *__restrict__ ptr, char **__restrict__ endptr);
extern double strtod(const char *__restrict ptr, char **__restrict endptr);
/* restrict: -std=c99 or -std=gnu99 or -std=c11 */
extern long double strtold(const char *restrict ptr, char **restrict endptr);
extern int (*funcs[])(void);
/* typeof: no -std or -std=gnu90 or -std=gnu99 or -std=gnu11 */
extern typeof (funcs[0]) f0;
extern __typeof (funcs[1]) f1;
extern __typeof__(funcs[2]) f2;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
static __inline__ uint16_t swap16(uint16_t val)
{
return ((((uint16_t)(val) & (uint16_t)0x00ffU) << 8) |
(((uint16_t)(val) & (uint16_t)0xff00U) >> 8));
}
static __inline uint32_t swap32(uint32_t val)
{
return ((((uint32_t)(val) & (uint32_t)0x000000ffUL) << 24) |
(((uint32_t)(val) & (uint32_t)0x0000ff00UL) << 8) |
(((uint32_t)(val) & (uint32_t)0x00ff0000UL) >> 8) |
(((uint32_t)(val) & (uint32_t)0xff000000UL) >> 24));
}
/* inline: no -std or -std=gnu90 or -std=c99 or -std=c11 */
static inline uint64_t swap64(uint64_t val)
{
return ((((uint64_t)(val) & (uint64_t)0x00000000000000ffULL) << 56) |
(((uint64_t)(val) & (uint64_t)0x000000000000ff00ULL) << 40) |
(((uint64_t)(val) & (uint64_t)0x0000000000ff0000ULL) << 24) |
(((uint64_t)(val) & (uint64_t)0x00000000ff000000ULL) << 8) |
(((uint64_t)(val) & (uint64_t)0x000000ff00000000ULL) >> 8) |
(((uint64_t)(val) & (uint64_t)0x0000ff0000000000ULL) >> 24) |
(((uint64_t)(val) & (uint64_t)0x00ff000000000000ULL) >> 40) |
(((uint64_t)(val) & (uint64_t)0xff00000000000000ULL) >> 56));
}
/*
* check-name: alternate keywords
*/
|
the_stack_data/192331212.c
|
/* Generated by CIL v. 1.7.0 */
/* print_CIL_Input is false */
struct _IO_FILE;
struct timeval;
extern void signal(int sig , void *func ) ;
extern float strtof(char const *str , char const *endptr ) ;
typedef struct _IO_FILE FILE;
extern int atoi(char const *s ) ;
extern double strtod(char const *str , char const *endptr ) ;
extern int fclose(void *stream ) ;
extern void *fopen(char const *filename , char const *mode ) ;
extern void abort() ;
extern void exit(int status ) ;
extern int raise(int sig ) ;
extern int fprintf(struct _IO_FILE *stream , char const *format , ...) ;
extern int strcmp(char const *a , char const *b ) ;
extern int rand() ;
extern unsigned long strtoul(char const *str , char const *endptr , int base ) ;
void RandomFunc(unsigned short input[1] , unsigned short output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
void megaInit(void)
{
{
}
}
int main(int argc , char *argv[] )
{
unsigned short input[1] ;
unsigned short output[1] ;
int randomFuns_i5 ;
unsigned short randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = (unsigned short )strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == (unsigned short)31026) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%u\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
void RandomFunc(unsigned short input[1] , unsigned short output[1] )
{
unsigned short state[1] ;
unsigned short local1 ;
{
state[0UL] = input[0UL] + (unsigned short)11483;
local1 = 0UL;
while (local1 < 1UL) {
local1 ++;
}
local1 = 0UL;
while (local1 < 1UL) {
state[local1] |= ((state[0UL] + state[0UL]) & (unsigned short)15) << 2UL;
local1 ++;
}
output[0UL] = (state[0UL] | 957911421UL) | (unsigned short)64421;
}
}
|
the_stack_data/54824999.c
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int syote;
double keskikulutus,
kokonaiskeskikulutus,
ajetutKilometrit,
bensamaara,
kaikkiAjetutKilometrit,
kaikkiBensamaara;
bensamaara = 0;
keskikulutus = 0;
kokonaiskeskikulutus = 0;
ajetutKilometrit = 0;
kaikkiAjetutKilometrit = 0;
kaikkiBensamaara = 0;
while(0==0) {
printf("Anna tankatun bensiinin maara (-1 lopettaa) > ");
scanf("%d",&syote);
if(syote==-1) {
break;
}
bensamaara = syote;
kaikkiBensamaara += bensamaara;
printf("Ajetut kilometrit > ");
scanf("%lf", &ajetutKilometrit);
keskikulutus = bensamaara/(ajetutKilometrit/100);
kaikkiAjetutKilometrit += ajetutKilometrit;
printf("Keskikulutus talla tankkauksella on %0.3lfl/km\n",keskikulutus);
}
kokonaiskeskikulutus = kaikkiBensamaara/(kaikkiAjetutKilometrit/100);
printf("kokonaiskeskikulutus on %0.2lfl/km", kokonaiskeskikulutus);
}
|
the_stack_data/75136682.c
|
// using dequeue, yet to come
|
the_stack_data/34513170.c
|
typedef struct
{
int *coordinate;
int dist;
} DATA;
int compare(const void *a, const void *b)
{
DATA d1 = *(DATA *)a;
DATA d2 = *(DATA *)b;
return d1.dist - d2.dist;
}
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
int** allCellsDistOrder(int R, int C, int r0, int c0, int* returnSize, int** returnColumnSizes)
{
DATA *d = malloc(sizeof(DATA)*R*C);
int **ret = malloc(sizeof(int *)*R*C);
*returnSize = R*C;
*returnColumnSizes = malloc(sizeof(int)*R*C);
int ctr = 0;
for (int i = 0; i < R; i++)
{
for (int j = 0; j < C; j++)
{
d[ctr].coordinate = malloc(sizeof(int)*2);
d[ctr].coordinate[0] = i;
d[ctr].coordinate[1] = j;
d[ctr].dist = abs(i-r0) + abs(j-c0);
ctr++;
}
}
qsort(d, R*C, sizeof(DATA), compare);
for (int i = 0; i < R*C; i++)
{
ret[i] = d[i].coordinate;
(*returnColumnSizes)[i] = 2;
}
free(d);
return ret;
}
|
the_stack_data/89200006.c
|
#include <stdio.h>
int main (){
int num1 = 0;
int num2 = 1;
int sum = 0;
int i = 0;
long sumapares = 0;
int seguir = 1;
do{
sum = num1 + num2;
if (sum < 4000000){
if (sum % 2 == 0){
sumapares += sum;
}
num1 = num2;
num2 = sum;
printf ("%d\n", num2);
}
else{
seguir = 0;
}
}while (seguir);
printf ("la suma de los numeros pares de la secuencia de fibonacci entre 0 y 10 es: %d\n", sumapares);
return 0;
}
|
the_stack_data/153970.c
|
// C++ program to find groups of unknown
// Points using K nearest neighbour algorithm.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct _Point
{
int distance; // Distance from test point
int x, y, z, k, w; // Co-ordinate of point
int val; // Group of point
} Point;
static int class[12] ;
/***
//results
Classified as 1
Classified as 1
Classified as 1
Classified as 1
Classified as 0
Classified as 0
Classified as 0
Classified as 2
Classified as 2
Classified as 2
Classified as 2
Classified as 2
*/
volatile int __attribute__((section(".mySection_par"))) startPar = 0x00 ;
volatile int __attribute__((section(".mySection_par_num"))) par_num = 0x03 ; //constant
volatile int __attribute__((section(".mySection_arr_str"))) arr_str = 0x00 ;
volatile int __attribute__((section(".mySection_arr_end"))) arr_end = 0x00 ;
int comparison(const void* a, const void* b)
{
const Point* p1 = a;
const Point* p2 = b;
return (p1->distance - p2->distance);
}
// This function finds classification of point p using
// k nearest neighbour algorithm. It assumes only two
// groups and returns 0 if p belongs to group 0, else
// 1 (belongs to group 1).
int classifyAPoint(Point* arr, int n, int k, Point p)
{
// Fill distances of all points from p
startPar = 0x1;
for ( int i = 0; i < n; i++){
arr[i].distance =
(arr[i].x - p.x) * (arr[i].x - p.x) +
(arr[i].z - p.z) * (arr[i].z - p.z) + //sqrt
(arr[i].k - p.k) * (arr[i].k - p.k) +
(arr[i].y - p.y) * (arr[i].y - p.y)+
(arr[i].w - p.w) * (arr[i].w - p.w);
//printf(" %d ", arr[i].distance);
}
startPar = 0x0;
// Sort the Points by distance from p
qsort(arr, n, sizeof(Point), &comparison);
// printf("\n as \n");
// for (int i = 0; i < n; i++){
// printf("%d ", arr[i].distance);
// printf(": %d / ", arr[i].x);
// }
// printf("\n");
// Now consider the first k elements and only
// 3 groups
int freq1 = 0; // Frequency of group 0
int freq2 = 0; // Frequency of group 1
int freq3 = 0; // Frequency of group 3
for (int i = 0; i < k; i++)
{
if (arr[i].val == 0)
freq1++;
else if (arr[i].val == 1)
freq2++;
else if (arr[i].val == 2)
freq3++;
}
// return 1;
if (freq1 >= freq3 && freq1 >= freq2)
return 0;
if (freq2 >= freq1 && freq2 >= freq3)
return 1;
if (freq3 >= freq2 && freq3 >= freq1)
return 2;
}
static Point arr [150] = {{0,0x51,0x51,0x38,0x16,0x03,1},
{0,0x4E,0x4E,0x30,0x16,0x03,1},
{0,0x4B,0x4B,0x33,0x14,0x03,1},
{0,0x49,0x49,0x31,0x18,0x03,1},
{0,0x50,0x50,0x39,0x16,0x03,1},
{0,0x56,0x56,0x3E,0x1B,0x06,1},
{0,0x49,0x49,0x36,0x16,0x04,1},
{0,0x50,0x50,0x36,0x18,0x03,1},
{0,0x46,0x46,0x2E,0x16,0x03,1},
{0,0x4E,0x4E,0x31,0x18,0x01,1},
{0,0x56,0x56,0x3B,0x18,0x03,1},
{0,0x04,0x04,0x36,0x19,0x03,1},
{0,0x04,0x04,0x30,0x16,0x01,1},
{0,0x44,0x44,0x30,0x11,0x01,1},
{0,0x5C,0x5C,0x40,0x13,0x03,1},
{0,0x5B,0x5B,0x46,0x18,0x06,1},
{0,0x56,0x56,0x3E,0x14,0x06,1},
{0,0x51,0x51,0x38,0x16,0x04,1},
{0,0x5B,0x5B,0x3C,0x1B,0x04,1},
{0,0x51,0x51,0x3C,0x18,0x04,1},
{0,0x56,0x56,0x36,0x1B,0x03,1},
{0,0x51,0x51,0x3B,0x18,0x06,1},
{0,0x49,0x49,0x39,0x10,0x03,1},
{0,0x51,0x51,0x34,0x1B,0x08,1},
{0,0x04,0x04,0x36,0x1E,0x03,1},
{0,0x50,0x50,0x30,0x19,0x03,1},
{0,0x50,0x50,0x36,0x19,0x06,1},
{0,0x53,0x53,0x38,0x18,0x03,1},
{0,0x53,0x53,0x36,0x16,0x03,1},
{0,0x4B,0x4B,0x33,0x19,0x03,1},
{0,0x04,0x04,0x31,0x19,0x03,1},
{0,0x56,0x56,0x36,0x18,0x06,1},
{0,0x53,0x53,0x41,0x18,0x01,1},
{0,0x58,0x58,0x43,0x16,0x03,1},
{0,0x4E,0x4E,0x31,0x18,0x01,1},
{0,0x50,0x50,0x33,0x13,0x03,1},
{0,0x58,0x58,0x38,0x14,0x03,1},
{0,0x4E,0x4E,0x31,0x18,0x01,1},
{0,0x46,0x46,0x30,0x14,0x03,1},
{0,0x51,0x51,0x36,0x18,0x03,1},
{0,0x50,0x50,0x38,0x14,0x04,1},
{0,0x48,0x48,0x24,0x14,0x04,1},
{0,0x46,0x46,0x33,0x14,0x03,1},
{0,0x50,0x50,0x38,0x19,0x09,1},
{0,0x51,0x51,0x3C,0x1E,0x06,1},
{0,0x04,0x04,0x30,0x16,0x04,1},
{0,0x51,0x51,0x3C,0x19,0x03,1},
{0,0x49,0x49,0x33,0x16,0x03,1},
{0,0x54,0x54,0x3B,0x18,0x03,1},
{0,0x50,0x50,0x34,0x16,0x03,1},
{0,0x70,0x70,0x33,0x4B,0x16,0},
{0,0x66,0x66,0x33,0x48,0x18,0},
{0,0x6E,0x6E,0x31,0x4E,0x18,0},
{0,0x58,0x58,0x24,0x40,0x14,0},
{0,0x68,0x68,0x2C,0x49,0x18,0},
{0,0x5B,0x5B,0x2C,0x48,0x14,0},
{0,0x64,0x64,0x34,0x4B,0x19,0},
{0,0x4E,0x4E,0x26,0x34,0x10,0},
{0,0x69,0x69,0x2E,0x49,0x14,0},
{0,0x53,0x53,0x2B,0x3E,0x16,0},
{0,0x50,0x50,0x20,0x38,0x10,0},
{0,0x5E,0x5E,0x30,0x43,0x18,0},
{0,0x60,0x60,0x23,0x40,0x10,0},
{0,0x61,0x61,0x2E,0x4B,0x16,0},
{0,0x59,0x59,0x2E,0x39,0x14,0},
{0,0x6B,0x6B,0x31,0x46,0x16,0},
{0,0x59,0x59,0x30,0x48,0x18,0},
{0,0x5C,0x5C,0x2B,0x41,0x10,0},
{0,0x63,0x63,0x23,0x48,0x18,0},
{0,0x59,0x59,0x28,0x3E,0x11,0},
{0,0x5E,0x5E,0x33,0x04,0x1C,0},
{0,0x61,0x61,0x2C,0x40,0x14,0},
{0,0x64,0x64,0x28,0x4E,0x18,0},
{0,0x61,0x61,0x2C,0x4B,0x13,0},
{0,0x66,0x66,0x2E,0x44,0x14,0},
{0,0x69,0x69,0x30,0x46,0x16,0},
{0,0x6C,0x6C,0x2C,0x04,0x16,0},
{0,0x6B,0x6B,0x30,0x50,0x1B,0},
{0,0x60,0x60,0x2E,0x48,0x18,0},
{0,0x5B,0x5B,0x29,0x38,0x10,0},
{0,0x58,0x58,0x26,0x3C,0x11,0},
{0,0x58,0x58,0x26,0x3B,0x10,0},
{0,0x5C,0x5C,0x2B,0x3E,0x13,0},
{0,0x60,0x60,0x2B,0x51,0x19,0},
{0,0x56,0x56,0x30,0x48,0x18,0},
{0,0x60,0x60,0x36,0x48,0x19,0},
{0,0x6B,0x6B,0x31,0x4B,0x18,0},
{0,0x64,0x64,0x24,0x46,0x14,0},
{0,0x59,0x59,0x30,0x41,0x14,0},
{0,0x58,0x58,0x28,0x40,0x14,0},
{0,0x58,0x58,0x29,0x46,0x13,0},
{0,0x61,0x61,0x30,0x49,0x16,0},
{0,0x5C,0x5C,0x29,0x40,0x13,0},
{0,0x50,0x50,0x24,0x34,0x10,0},
{0,0x59,0x59,0x2B,0x43,0x14,0},
{0,0x5B,0x5B,0x30,0x43,0x13,0},
{0,0x5B,0x5B,0x2E,0x43,0x14,0},
{0,0x63,0x63,0x2E,0x44,0x14,0},
{0,0x51,0x51,0x28,0x30,0x11,0},
{0,0x5B,0x5B,0x2C,0x41,0x14,0},
{0,0x64,0x64,0x34,0x60,0x28,2},
{0,0x5C,0x5C,0x2B,0x51,0x1E,2},
{0,0x71,0x71,0x30,0x5E,0x21,2},
{0,0x64,0x64,0x2E,0x59,0x1C,2},
{0,0x68,0x68,0x30,0x5C,0x23,2},
{0,0x79,0x79,0x30,0x69,0x21,2},
{0,0x4E,0x4E,0x28,0x48,0x1B,2},
{0,0x74,0x74,0x2E,0x64,0x1C,2},
{0,0x6B,0x6B,0x28,0x5C,0x1C,2},
{0,0x73,0x73,0x39,0x61,0x28,2},
{0,0x68,0x68,0x33,0x51,0x20,2},
{0,0x66,0x66,0x2B,0x54,0x1E,2},
{0,0x6C,0x6C,0x30,0x58,0x21,2},
{0,0x5B,0x5B,0x28,0x50,0x20,2},
{0,0x5C,0x5C,0x2C,0x51,0x26,2},
{0,0x66,0x66,0x33,0x54,0x24,2},
{0,0x68,0x68,0x30,0x58,0x1C,2},
{0,0x7B,0x7B,0x3C,0x6B,0x23,2},
{0,0x7B,0x7B,0x29,0x6E,0x24,2},
{0,0x60,0x60,0x23,0x50,0x18,2},
{0,0x6E,0x6E,0x33,0x5B,0x24,2},
{0,0x59,0x59,0x2C,0x4E,0x20,2},
{0,0x7B,0x7B,0x2C,0x6B,0x20,2},
{0,0x64,0x64,0x2B,0x4E,0x1C,2},
{0,0x6B,0x6B,0x34,0x5B,0x21,2},
{0,0x73,0x73,0x33,0x60,0x1C,2},
{0,0x63,0x63,0x2C,0x04,0x1C,2},
{0,0x61,0x61,0x30,0x4E,0x1C,2},
{0,0x66,0x66,0x2C,0x59,0x21,2},
{0,0x73,0x73,0x30,0x5C,0x19,2},
{0,0x76,0x76,0x2C,0x61,0x1E,2},
{0,0x7E,0x7E,0x3C,0x66,0x20,2},
{0,0x66,0x66,0x2C,0x59,0x23,2},
{0,0x64,0x64,0x2C,0x51,0x18,2},
{0,0x61,0x61,0x29,0x59,0x16,2},
{0,0x7B,0x7B,0x30,0x61,0x24,2},
{0,0x64,0x64,0x36,0x59,0x26,2},
{0,0x66,0x66,0x31,0x58,0x1C,2},
{0,0x60,0x60,0x30,0x04,0x1C,2},
{0,0x6E,0x6E,0x31,0x56,0x21,2},
{0,0x6B,0x6B,0x31,0x59,0x26,2},
{0,0x6E,0x6E,0x31,0x51,0x24,2},
{0,0x5C,0x5C,0x2B,0x51,0x1E,2},
{0,0x6C,0x6C,0x33,0x5E,0x24,2},
{0,0x6B,0x6B,0x34,0x5B,0x28,2},
{0,0x6B,0x6B,0x30,0x53,0x24,2},
{0,0x64,0x64,0x28,0x50,0x1E,2},
{0,0x68,0x68,0x30,0x53,0x20,2},
{0,0x63,0x63,0x36,0x56,0x24,2},
{0,0x5E,0x5E,0x30,0x51,0x1C,2} };
int* knn(){
/***
//changeable variables */
//#define print_en
//arr = 0x200;
//test = 0x100;
arr_str = &arr[0] ;
arr_end = &arr[149] + (&arr[149] -&arr[148] ) ;
static Point test [12] = { {0,0x44,0x44,0x2E,0x1B,0x04,0},
{0,0x49,0x49,0x2B,0x18,0x03,0},
{0,0x54,0x54,0x36,0x19,0x03,0},
{0,0x53,0x53,0x41,0x18,0x01,0},
{0,0x60,0x60,0x23,0x43,0x10,0},
{0,0x63,0x63,0x24,0x48,0x18,0},
{0,0x50,0x50,0x21,0x39,0x13,0},
{0,0x69,0x69,0x2C,0x56,0x20,0},
{0,0x66,0x66,0x33,0x54,0x24,0},
{0,0x70,0x70,0x31,0x58,0x1C,0},
{0,0x63,0x63,0x34,0x5E,0x21,0},
{0,0x69,0x69,0x2E,0x54,0x24,0}};
int n = 150; // Number of data points
/*Testing Point*/
// Parameter to decide groupr of the testing point
int k = 3;
/***
//non changable variables */
//volatile int class[12] ;
//int* class = ;
for ( int z = 0; z < 1; z++){
class[z] = 1 ;
class[z] = classifyAPoint(arr, n, k, test[z]) ;
#ifdef print_en
printf(" Classified as %d\n", class[z]);
#endif // print_en
}
return class;
}
// http://www.bytecraft.com/Fixed_Point_Converter
//int* a; a = 0x100; 256
//int* b; b = 0x200; 512
// Used to sort an array of points by increasing
// order of distance
// Driver code
int main()
{
volatile int* i;
i = knn();
return 0;
}
|
the_stack_data/12638879.c
|
#include <stdio.h>
char *ft_strlowcase(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
if (str[i] >= 'A' && str[i] <= 'Z')
{
str[i] = (str[i] + 32);
}
i++;
}
return (str);
}
int main(void)
{
char string[] = "WHY DOESN'T THIS WORK :(";
ft_strlowcase(string);
printf("%s", string);
}
|
the_stack_data/193892945.c
|
#include <stdio.h>
int main() {
freopen("input.txt", "r", stdin);
int a[200 + 50];
int N;
scanf("%d", &N);
while (N--) {
int M, i;
scanf("%d", &M);
for (i = 0; i < M; i++) scanf("%d", &a[i]);
int sum = 0;
for (i = 0; i < M; i++) sum += a[i];
printf("%d\n", sum);
}
}
|
the_stack_data/29824893.c
|
#include <stdio.h>
#include <stdlib.h>
void quickSort(int *numbers, int left, int right)
{
int pivot;
int l_hold = left;
int r_hold = right;
pivot = numbers[left];
while (left < right)
{
while ((numbers[right] >= pivot) && (left < right))
right--;
if (left != right)
{
numbers[left] = numbers[right];
left++;
}
while ((numbers[left] <= pivot) && (left < right))
left++;
if (left != right)
{
numbers[right] = numbers[left];
right--;
}
}
numbers[left] = pivot;
pivot = left;
left = l_hold;
right = r_hold;
if (left < pivot)
quickSort(numbers, left, pivot - 1);
if (right > pivot)
quickSort(numbers, pivot + 1, right);
}
int main()
{
int size=0;
scanf ("%d",&size);
int a[size];
for (int i = 0; i<size; i++)
scanf ("%d",&a[i]);
quickSort(a, 0, size);
for (int i = 0; i<size; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}
|
the_stack_data/62943.c
|
#include <stdio.h>
#include "math.h"
int main() {
printf("I am of %d years old.\n", 26);
return 0;
}
|
the_stack_data/232954590.c
|
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/sysinfo.h>
#include <sys/wait.h>
#define NUM_KIDS 20
int main()
{
//test
// test git
// Add MacOS
// ADD TEST_BRANCH
pid_t pid, ppid, value, childPid;
int status, sum = 0, i = 0;
for (i = 0; i < NUM_KIDS; i++)
{
switch (value = fork())
{
case -1:
fprintf(stderr, "Error #%03d: %s\n", errno, strerror(errno));
break;
case 0:
pid = getpid();
ppid = getppid();
srand(getpid());
int r = rand() % 6 + 1;
printf("PID: %d, PPID: %d, i: %d\n", pid, ppid, r);
exit(r);
break;
default:
break;
}
}
sleep(1);
printf("\n");
while ((childPid = waitpid(0, &status, 0)) != -1)
{
if (childPid == 0)
{
printf("No child terminated\n");
}
else
{
sum += WEXITSTATUS(status);
printf("PARENT: PID=%d terminated (the child) with status %d\n", childPid, WEXITSTATUS(status));
}
}
printf("Sum: %d\n", sum);
}
|
the_stack_data/90763760.c
|
// RUN: %bmc -bound 1 -inline=all -trace "%s" | FileCheck "%s"
// CHECK: Verification FAILED
// This test caused trace generation to crash due to an invalid null pointer.
int c;
void __VERIFIER_error();
int a();
int b();
int d() {
b();
__VERIFIER_error();
return 0;
}
int b() { return c; }
int main() {
int e = a();
c = 0;
if (e)
c = 7;
d();
}
|
the_stack_data/103538.c
|
#include <stdio.h>
#include <string.h>
#define SIZE 80
char * s_gets(char * st, int n);
int main(void)
{
char flower[SIZE];
char addon[] = "s smell like old shoes.";
puts("What is your favorite flower!");
if (s_gets(flower, SIZE))
{
strcat(flower, addon);
puts(flower);
puts(addon);
}
else
puts("End of file encountered");
puts("Bye!");
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != '\n' && st[i] != '\0')
i++;
if ( st[i] == '\n')
st[i] = '\0';
else
while (getchar() != '\n')
continue;
}
return ret_val;
}
|
the_stack_data/92327194.c
|
/*
Exercise 5-4. Write the function strend(s,t) , which returns 1 if the
string t occurs at the end of the string s , and zero otherwise.
*/
#include <stdio.h>
int strend(char *s, char *t);
int main(void)
{
char *s = "Good Morning!";
char *t = "ning!";
char *t1 = "boom";
printf("s: %s\n", s);
printf("t: %s\n", t);
printf("t1: %s\n", t1);
printf("\n");
printf("t at the end of s? %i\n", strend(s,t));
printf("t1 at the end of s? %i\n", strend(s,t1));
return 0;
}
/* strend: return 1 if t occurs at the end of s, 0 otherwise */
int strend(char *s, char *t) {
int i = 0,j = 0;
while (*s) { /* find end of s, count size */
s++;
i++;
}
while (*t) { /* find end of t, count size */
t++;
j++;
}
if (j > i) /* t is bigger than s */
return 0;
while (j >= 0) { /* check moving backwards */
if (*(s - j) != *(t - j))
return 0;
j--;
}
return 1;
}
|
the_stack_data/37638496.c
|
#include <stdio.h>
int main() {
int numero, d1, d2, d3, d4;
printf("Introduzca un numero de 3 digitos para su desgloce: ");
scanf("%i", &numero);
printf("\n");
d1 = numero / 100; // Obteniendo la centena.
d2 = numero % 100; // Obteniendo el residuo.
d3 = d2 / 10; // Obteniendo la decena.
d4 = d2 % 10; // Obteniendo el residuo.
printf("Usted a indroducido la cantidad de: %i \n", numero);
printf("Y su desgloce es: %i - %i - %i", d1,d3,d4);
printf("\n\n");
return 0;
}
|
the_stack_data/51700542.c
|
// sorting_main.c
/**
* This is a simple program to show how the different main sorting
* alghortims work.
*
* To compile the program use the following command:
gcc -DSORT_VERBOSE -lm -g -o sort.exe sorting_main.c
* where the SORT_VERBOSE flag indicates to produce output at each step of sorting.
* It is also possible to use the SORT_SIMPLE flag to produce a very simple
* initial array to ease the alghortim analysys.
*
*
*
* The following is an example of a program output:
Welcome to the sorting sample!
The program is configured for sorting max 10000 random values
#######################################
Bubble Sort O(n^2) = 100000000
Bubble Sort took 1.04 secs, complexity was 25224415
Bubble Sort Aggressive took 0.65 secs, complexity was 25119051
#######################################
#######################################
Selection Sort O(n^2) = 100000000
Selection Sort took 0.25 secs, complexity was 10000
#######################################
#######################################
Quick Sort O( n log n) = 92103.403720 up to O(n^2) = 100000000
Quick Sort took 0.00 secs, complexity was 33541
#######################################
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h> // for memset/bzero utilities
#include <time.h> // for getting times
#include <math.h> // for log functions
// number of items in the array
// to sort
#define MAX_ITEMS 10000
#define MICROSECS_PER_SECOND 1000000
/*
* Alghoritm selectors
*/
typedef enum {
BUBBLE_SORT = 0, /* DO NOT MOVE! */
BUBBLE_SORT_AGGRESSIVE,
MERGE_SORT,
QUICK_SORT,
SELECTION_SORT /* DO NOT MOVE! */
} SORT_ENGINE;
double
duration( struct timeval *startTime, struct timeval *endTime );
void
init_array_with_random_values( int* arrayToFill, int count );
void
_dump( int * arrayToDump, int end );
long
do_bubble_sort( int* array, int start, int end );
long
do_bubble_sort_aggressive( int* array, int start, int end );
long
do_selection_sort( int* array, int start, int end );
long
do_quick_sort( int* array, int start, int end );
long
do_merge_sort( int* array, int start, int end );
void
do_merge( int* array, int start, int partitionIndex, int end );
void
run_sort( int whichAlghoritm, int* array_to_sort, int start, int end );
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv ){
long number_of_elements = 0;
int current_sort_engine = -1;
printf( "\nWelcome to the sorting sample!\n" );
printf( "\nThe program is configured for sorting max %ld random values\n", (long) MAX_ITEMS );
// get the number of elements to sort from the command line
if( argc == 2 )
number_of_elements = atol( argv[1] );
else
number_of_elements = MAX_ITEMS;
// create an integer array
// with the number of items
int* array_to_sort = (int*) malloc( sizeof( int ) * number_of_elements );
// zero fill the array
memset( array_to_sort, 0, sizeof( int ) * number_of_elements );
// or this is equivalent
bzero( array_to_sort, sizeof( int ) * number_of_elements );
// init the array
init_array_with_random_values( array_to_sort, number_of_elements );
// loop on each sort engine
for( current_sort_engine = BUBBLE_SORT; current_sort_engine <= SELECTION_SORT; current_sort_engine++ )
run_sort( current_sort_engine, array_to_sort, 0, number_of_elements );
free( array_to_sort );
}
/**
* Main entry poinf for calling a specific sorting alghoritm.
* The function does a copy of the initial data set, so that it is left unchanged,
* and then calls the right alghoritm printing also a report about the execution
* time and so on.
*
* \param whichAlghoritm an identifier for the alghoritm to iovoke
* \param array_to_sort_src the source array to sort, it will be cloned and therefore
* will be unchanged
* \param start initial index in the array, usually 0
* \param end the last entry in the array
*/
void
run_sort( int whichAlghoritm, int* array_to_sort_src, int start, int end ){
/* check arguments */
if( start < 0
|| end > MAX_ITEMS
|| start == end
|| start > end ) {
printf( "\nCannot sort an array that starts on %d and ends on %d", start, end );
return;
}
// pointer to the sorter engine
long (*sorter)(int*, int, int);
char *title = NULL;
int number_of_elements = end - start;
long complexity = 0;
int *array_to_sort = (int*) malloc( sizeof( int ) * number_of_elements );
// clone the array to sort so that the initial array is untouched
memcpy( array_to_sort, array_to_sort_src, sizeof( int ) * number_of_elements );
// variables to handle timing of the sorting alghoritms
struct timeval *startTime, *endTime;
// allocate time structures
startTime = (struct timeval *) malloc( sizeof( struct timeval ) );
endTime = (struct timeval *) malloc( sizeof( struct timeval ) );
switch( whichAlghoritm ){
case BUBBLE_SORT:
sorter = do_bubble_sort;
title = "Bubble Sort O(n^2)";
break;
case BUBBLE_SORT_AGGRESSIVE:
sorter = do_bubble_sort_aggressive;
title = "Bubble Sort Aggressive";
break;
case MERGE_SORT:
sorter = do_merge_sort;
title = "Merge Sort O(n log n)";
break;
case QUICK_SORT:
sorter = do_quick_sort;
title = "Quick Sort O(n log n)";
break;
case SELECTION_SORT:
sorter = do_selection_sort;
title = "Selection Sort O(n^2)";
break;
default:
sorter = NULL;
printf( "\nNo sorter specified!\n" );
return;
}
printf( "\n\t#######################################\n" );
printf( "\n\t\tDoing a %s", title );
#ifdef SORT_VERBOSE
printf( "\n Initial array is\n" );
_dump( array_to_sort, number_of_elements );
#endif // SORT_VERBOSE
gettimeofday( startTime, NULL );
complexity = sorter( array_to_sort, start, number_of_elements );
gettimeofday( endTime, NULL );
printf( "\n\t\t%s\n", title );
printf( "\t\t %2.2f secs, complexity was %ld",
duration( startTime, endTime ),
complexity );
#ifdef SORT_VERBOSE
printf( "\nSorted array is\n" );
_dump( array_to_sort, number_of_elements );
#endif //SORT_VERBOSE
printf( "\n\t#######################################\n" );
/*
free( startTime );
free( endTime );
*/
free( array_to_sort );
}
/**
* A method to compute the elapsed seconds between a start and an and time.
* Suppose none of the alghoritms is using more than one day!
* \param startTime a pointer to the starting time struct
* \param endTime a pointer to the end time struct
* \returns the number of elapsed seconds
*/
double
duration( struct timeval *startTime, struct timeval *endTime ){
double secs = ( endTime->tv_sec - startTime->tv_sec ) * MICROSECS_PER_SECOND;
secs += ( endTime->tv_usec - startTime->tv_usec );
secs /= MICROSECS_PER_SECOND;
return secs;
}
/**
* A function to init an integer array with random values.
* \param arrayToFill the array to fill
* \param count how many entries of the array to fill
*/
void init_array_with_random_values( int* arrayToFill, int count ){
int i = 0;
for( i = 0; i < count; i++ )
#ifndef SORT_SIMPLE
arrayToFill[ i ] = (int) random();
#else
arrayToFill[ i ] = 10 - i;
#endif //SORT_SIMPLE
}
/**
* A method to implement the classic bubble sort.
* The complexity is O(n^2).
* \param array the array to sort
* \param count the number of items to sort
* \returns the number of steps performed to sort the
* array
*/
long
do_bubble_sort( int* array, int start, int end ){
long complexity = 0;
int swap_counter = 0;
int swapping_value;
int i;
do{
swap_counter = 0;
for( i = start; i < end - 1; i++ )
if( array[ i ] > array[ i + 1 ] ){
// need a swap here
swapping_value = array[ i ];
array[ i ] = array[ i + 1 ];
array[ i + 1 ] = swapping_value;
swap_counter++;
}
complexity += swap_counter;
}while( swap_counter != 0 );
return complexity;
}
/**
* A method to implement an aggressive version of the bubble sort.
* The idea is that at each step the end of the array contains its
* biggest value, so at the first step the biggest element is placed
* and never moved, and therefore the set of entries to inspect can be
* reduced by one each complete loop. Moreover, it is possible to state
* that it is possible to not see all the last i-th items being i
* the greater index at which a sort happened in the current loop.
*
* \param array the array to sort
* \param count the number of items to sort
* \returns the number of steps performed to sort the
* array
*/
long
do_bubble_sort_aggressive( int* array, int start, int end ){
long complexity = 0;
int swap_counter = 0;
int biggest_swapped_index = 0;
int stopAtItem = end - 1;
int swapping_value;
int i;
do{
swap_counter = 0;
biggest_swapped_index = 0;
for( i = start; i < stopAtItem; i++ )
if( array[ i ] > array[ i + 1 ] ){
// need a swap here
swapping_value = array[ i ];
array[ i ] = array[ i + 1 ];
array[ i + 1 ] = swapping_value;
swap_counter++;
biggest_swapped_index = i;
}
stopAtItem = biggest_swapped_index;
complexity += swap_counter;
}while( swap_counter != 0 );
return complexity;
}
/**
* Classical implementation of the selection sort.
* The alghortim is as follows:
* 1) select the minimum value in the list
* 2) swap the min value with the first position of the list
* 3) move to the first element of the list and search again the min value
* 4) swap the value with the first element
* 5) repeat for every value in the list
*/
long
do_selection_sort( int* array, int start, int end ){
long complexity = 0;
int current_min_index = 0;
int swapping = 0;
int i;
int start_index;
start_index = 0 + start;
do{
current_min_index = start_index;
for( i = start_index; i < end; i++ )
if( array[ current_min_index ] > array[ i ] )
// the i-th position is the new current min
current_min_index = i;
#ifdef SORT_VERBOSE
printf( "\n\t[doSelectionSort] min index is %d, swapping value with index %d",
current_min_index, start_index );
#endif // SORT_VERBOSE
// now I've got the min value in the list, place it at the
// last position
swapping = array[ current_min_index ]; // current min value
array[ current_min_index ] = array[ start_index ]; // move the current start value
array[ start_index ] = swapping; // place the min at the begin
start_index++;
complexity++;
}while( start_index < end );
return complexity;
}
long
do_quick_sort( int* array, int start, int end ){
long complexity = 0;
int pivot_value = 0;
int pivot_index = 0;
int i;
int swapping;
int partition_start = start;
int partition_end = end;
// pick a pivot (get an index in the middle of the partition)
pivot_index = ( partition_end - partition_start ) / 2 + partition_start;
pivot_value = array[ pivot_index ];
#ifdef SORT_VERBOSE
printf( "\n\t[do_quick_sort] pivot value is %d at index %d - current partition from %d to %d ",
pivot_value, pivot_index, start, end );
#endif // SORT_VERBOSE
// do the partitioning
while( partition_start <= partition_end ){
while( array[ partition_start ] < pivot_value )
partition_start++;
while( array[ partition_end ] > pivot_value )
partition_end--;
if( partition_start <= partition_end ){
#ifdef SORT_VERBOSE
printf( "\n\t[do_quick_sort] swapping values at indexes %d <-> %d",
partition_start, partition_end );
#endif // SORT_VERBOSE
swapping = array[ partition_start ];
array[ partition_start ] = array[ partition_end ];
array[ partition_end ] = swapping;
partition_start++;
partition_end--;
complexity++;
}
}
// recursion
if( start < partition_end )
complexity += do_quick_sort( array, start, partition_end );
if( end > partition_start )
complexity += do_quick_sort( array, partition_start, end );
return complexity;
}
long
do_merge_sort( int* array, int start, int end ){
int partitionIndex = ( end + start ) / 2;
long complexity = -1;
if( start < end ){
#ifdef SORT_VERBOSE
printf( "\nAnalyzing partition split at index %d\n", partitionIndex );
#endif // SORT_VERBOSE
do_merge_sort( array, start, partitionIndex );
do_merge_sort( array, partitionIndex + 1, end );
#ifdef SORT_VERBOSE
printf( "\nDoing merge of %d <-> %d and %d <-> %d\n",
start, partitionIndex, partitionIndex + 1, end );
#endif // SORT_VERBOSE
// do the merge
do_merge( array, start, partitionIndex, end );
}
return complexity;
}
void
do_merge( int* array, int start, int partitionIndex, int end ){
int copyArray[ (end - start + 1 ) ];
int leftIndex = start, rightIndex = partitionIndex + 1;
int copyIndex = 0;
int mergeIndex = 0;
// sorting phase
while( leftIndex <= partitionIndex && rightIndex <= end )
if( array[ leftIndex ] < array[ rightIndex ] )
copyArray[ copyIndex++ ] = array[ leftIndex++ ];
else
copyArray[ copyIndex++ ] = array[ rightIndex++ ];
while( leftIndex <= partitionIndex )
copyArray[ copyIndex++ ] = array[ leftIndex++ ];
while( rightIndex <= end )
copyArray[ copyIndex++ ] = array[ rightIndex++ ];
// merge
for( mergeIndex = 0; mergeIndex < copyIndex; mergeIndex++ )
array[ start + mergeIndex ] = copyArray[ mergeIndex ];
}
////////////////////////////////////////////////////////////////////////////////
void _dump( int * array, int count ){
int i = 0;
printf( "\n" );
for( i = 0; i < count; i++ ){
printf( "array[ %d ] = %d\n", i, array[ i ] );
}
printf( "\n" );
}
|
the_stack_data/232955618.c
|
/*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* This file contains the resampling by two functions.
* The description header can be found in signal_processing_library.h
*
*/
#if defined(MIPS32_LE)
#include "signal_processing_library.h"
// allpass filter coefficients.
static const uint16_t kResampleAllpass1[3] = {3284, 24441, 49528};
static const uint16_t kResampleAllpass2[3] = {12199, 37471, 60255};
// Multiply a 32-bit value with a 16-bit value and accumulate to another input:
#define MUL_ACCUM_1(a, b, c) WEBRTC_SPL_SCALEDIFF32(a, b, c)
#define MUL_ACCUM_2(a, b, c) WEBRTC_SPL_SCALEDIFF32(a, b, c)
// decimator
void WebRtcSpl_DownsampleBy2(const int16_t* in,
const int16_t len,
int16_t* out,
int32_t* filtState) {
int32_t out32;
int16_t i, len1;
register int32_t state0 = filtState[0];
register int32_t state1 = filtState[1];
register int32_t state2 = filtState[2];
register int32_t state3 = filtState[3];
register int32_t state4 = filtState[4];
register int32_t state5 = filtState[5];
register int32_t state6 = filtState[6];
register int32_t state7 = filtState[7];
#if defined(MIPS_DSP_R2_LE)
int32_t k1Res0, k1Res1, k1Res2, k2Res0, k2Res1, k2Res2;
k1Res0= 3284;
k1Res1= 24441;
k1Res2= 49528;
k2Res0= 12199;
k2Res1= 37471;
k2Res2= 60255;
len1 = (len >> 1);
const int32_t* inw = (int32_t*)in;
int32_t tmp11, tmp12, tmp21, tmp22;
int32_t in322, in321;
int32_t diff1, diff2;
for (i = len1; i > 0; i--) {
__asm__ volatile (
"lh %[in321], 0(%[inw]) \n\t"
"lh %[in322], 2(%[inw]) \n\t"
"sll %[in321], %[in321], 10 \n\t"
"sll %[in322], %[in322], 10 \n\t"
"addiu %[inw], %[inw], 4 \n\t"
"subu %[diff1], %[in321], %[state1] \n\t"
"subu %[diff2], %[in322], %[state5] \n\t"
: [in322] "=&r" (in322), [in321] "=&r" (in321),
[diff1] "=&r" (diff1), [diff2] "=r" (diff2), [inw] "+r" (inw)
: [state1] "r" (state1), [state5] "r" (state5)
: "memory"
);
__asm__ volatile (
"mult $ac0, %[diff1], %[k2Res0] \n\t"
"mult $ac1, %[diff2], %[k1Res0] \n\t"
"extr.w %[tmp11], $ac0, 16 \n\t"
"extr.w %[tmp12], $ac1, 16 \n\t"
"addu %[tmp11], %[state0], %[tmp11] \n\t"
"addu %[tmp12], %[state4], %[tmp12] \n\t"
"addiu %[state0], %[in321], 0 \n\t"
"addiu %[state4], %[in322], 0 \n\t"
"subu %[diff1], %[tmp11], %[state2] \n\t"
"subu %[diff2], %[tmp12], %[state6] \n\t"
"mult $ac0, %[diff1], %[k2Res1] \n\t"
"mult $ac1, %[diff2], %[k1Res1] \n\t"
"extr.w %[tmp21], $ac0, 16 \n\t"
"extr.w %[tmp22], $ac1, 16 \n\t"
"addu %[tmp21], %[state1], %[tmp21] \n\t"
"addu %[tmp22], %[state5], %[tmp22] \n\t"
"addiu %[state1], %[tmp11], 0 \n\t"
"addiu %[state5], %[tmp12], 0 \n\t"
: [tmp22] "=r" (tmp22), [tmp21] "=&r" (tmp21),
[tmp11] "=&r" (tmp11), [state0] "+r" (state0),
[state1] "+r" (state1),
[state2] "+r" (state2),
[state4] "+r" (state4), [tmp12] "=&r" (tmp12),
[state6] "+r" (state6), [state5] "+r" (state5)
: [k1Res1] "r" (k1Res1), [k2Res1] "r" (k2Res1), [k2Res0] "r" (k2Res0),
[diff2] "r" (diff2), [diff1] "r" (diff1), [in322] "r" (in322),
[in321] "r" (in321), [k1Res0] "r" (k1Res0)
: "hi", "lo", "$ac1hi", "$ac1lo"
);
// upper allpass filter
__asm__ volatile (
"subu %[diff1], %[tmp21], %[state3] \n\t"
"subu %[diff2], %[tmp22], %[state7] \n\t"
"mult $ac0, %[diff1], %[k2Res2] \n\t"
"mult $ac1, %[diff2], %[k1Res2] \n\t"
"extr.w %[state3], $ac0, 16 \n\t"
"extr.w %[state7], $ac1, 16 \n\t"
"addu %[state3], %[state2], %[state3] \n\t"
"addu %[state7], %[state6], %[state7] \n\t"
"addiu %[state2], %[tmp21], 0 \n\t"
"addiu %[state6], %[tmp22], 0 \n\t"
// add two allpass outputs, divide by two and round
"addu %[out32], %[state3], %[state7] \n\t"
"addiu %[out32], %[out32], 1024 \n\t"
"sra %[out32], %[out32], 11 \n\t"
: [state3] "+r" (state3), [state6] "+r" (state6),
[state2] "+r" (state2), [diff2] "=&r" (diff2),
[out32] "=r" (out32), [diff1] "=&r" (diff1), [state7] "+r" (state7)
: [tmp22] "r" (tmp22), [tmp21] "r" (tmp21),
[k1Res2] "r" (k1Res2), [k2Res2] "r" (k2Res2)
: "hi", "lo", "$ac1hi", "$ac1lo"
);
// limit amplitude to prevent wrap-around, and write to output array
*out++ = WebRtcSpl_SatW32ToW16(out32);
}
#else // #if defined(MIPS_DSP_R2_LE)
int32_t tmp1, tmp2, diff;
int32_t in32;
len1 = (len >> 1)/4;
for (i = len1; i > 0; i--) {
// lower allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state1;
tmp1 = MUL_ACCUM_1(kResampleAllpass2[0], diff, state0);
state0 = in32;
diff = tmp1 - state2;
tmp2 = MUL_ACCUM_2(kResampleAllpass2[1], diff, state1);
state1 = tmp1;
diff = tmp2 - state3;
state3 = MUL_ACCUM_2(kResampleAllpass2[2], diff, state2);
state2 = tmp2;
// upper allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state5;
tmp1 = MUL_ACCUM_1(kResampleAllpass1[0], diff, state4);
state4 = in32;
diff = tmp1 - state6;
tmp2 = MUL_ACCUM_1(kResampleAllpass1[1], diff, state5);
state5 = tmp1;
diff = tmp2 - state7;
state7 = MUL_ACCUM_2(kResampleAllpass1[2], diff, state6);
state6 = tmp2;
// add two allpass outputs, divide by two and round
out32 = (state3 + state7 + 1024) >> 11;
// limit amplitude to prevent wrap-around, and write to output array
*out++ = WebRtcSpl_SatW32ToW16(out32);
// lower allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state1;
tmp1 = MUL_ACCUM_1(kResampleAllpass2[0], diff, state0);
state0 = in32;
diff = tmp1 - state2;
tmp2 = MUL_ACCUM_2(kResampleAllpass2[1], diff, state1);
state1 = tmp1;
diff = tmp2 - state3;
state3 = MUL_ACCUM_2(kResampleAllpass2[2], diff, state2);
state2 = tmp2;
// upper allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state5;
tmp1 = MUL_ACCUM_1(kResampleAllpass1[0], diff, state4);
state4 = in32;
diff = tmp1 - state6;
tmp2 = MUL_ACCUM_1(kResampleAllpass1[1], diff, state5);
state5 = tmp1;
diff = tmp2 - state7;
state7 = MUL_ACCUM_2(kResampleAllpass1[2], diff, state6);
state6 = tmp2;
// add two allpass outputs, divide by two and round
out32 = (state3 + state7 + 1024) >> 11;
// limit amplitude to prevent wrap-around, and write to output array
*out++ = WebRtcSpl_SatW32ToW16(out32);
// lower allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state1;
tmp1 = MUL_ACCUM_1(kResampleAllpass2[0], diff, state0);
state0 = in32;
diff = tmp1 - state2;
tmp2 = MUL_ACCUM_2(kResampleAllpass2[1], diff, state1);
state1 = tmp1;
diff = tmp2 - state3;
state3 = MUL_ACCUM_2(kResampleAllpass2[2], diff, state2);
state2 = tmp2;
// upper allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state5;
tmp1 = MUL_ACCUM_1(kResampleAllpass1[0], diff, state4);
state4 = in32;
diff = tmp1 - state6;
tmp2 = MUL_ACCUM_1(kResampleAllpass1[1], diff, state5);
state5 = tmp1;
diff = tmp2 - state7;
state7 = MUL_ACCUM_2(kResampleAllpass1[2], diff, state6);
state6 = tmp2;
// add two allpass outputs, divide by two and round
out32 = (state3 + state7 + 1024) >> 11;
// limit amplitude to prevent wrap-around, and write to output array
*out++ = WebRtcSpl_SatW32ToW16(out32);
// lower allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state1;
tmp1 = MUL_ACCUM_1(kResampleAllpass2[0], diff, state0);
state0 = in32;
diff = tmp1 - state2;
tmp2 = MUL_ACCUM_2(kResampleAllpass2[1], diff, state1);
state1 = tmp1;
diff = tmp2 - state3;
state3 = MUL_ACCUM_2(kResampleAllpass2[2], diff, state2);
state2 = tmp2;
// upper allpass filter
in32 = (int32_t)(*in++) << 10;
diff = in32 - state5;
tmp1 = MUL_ACCUM_1(kResampleAllpass1[0], diff, state4);
state4 = in32;
diff = tmp1 - state6;
tmp2 = MUL_ACCUM_1(kResampleAllpass1[1], diff, state5);
state5 = tmp1;
diff = tmp2 - state7;
state7 = MUL_ACCUM_2(kResampleAllpass1[2], diff, state6);
state6 = tmp2;
// add two allpass outputs, divide by two and round
out32 = (state3 + state7 + 1024) >> 11;
// limit amplitude to prevent wrap-around, and write to output array
*out++ = WebRtcSpl_SatW32ToW16(out32);
}
#endif // #if defined(MIPS_DSP_R2_LE)
__asm__ volatile (
"sw %[state0], 0(%[filtState]) \n\t"
"sw %[state1], 4(%[filtState]) \n\t"
"sw %[state2], 8(%[filtState]) \n\t"
"sw %[state3], 12(%[filtState]) \n\t"
"sw %[state4], 16(%[filtState]) \n\t"
"sw %[state5], 20(%[filtState]) \n\t"
"sw %[state6], 24(%[filtState]) \n\t"
"sw %[state7], 28(%[filtState]) \n\t"
:
: [state0] "r" (state0), [state1] "r" (state1), [state2] "r" (state2),
[state3] "r" (state3), [state4] "r" (state4), [state5] "r" (state5),
[state6] "r" (state6), [state7] "r" (state7), [filtState] "r" (filtState)
: "memory"
);
}
#endif // #if defined(MIPS32_LE)
|
the_stack_data/126701968.c
|
int main()
{
int a = 1;
int b = 2;
int c = 4;
if(a == b) { c = 3; }
else if(a > b) { c= 2; }
else if (a < b) { c= 1; }
return c;
}
|
the_stack_data/64199403.c
|
/*
*
* _RAW_C_
*
* Copyright (C) 2018 Tactical Computing Laboratories, LLC
* All Rights Reserved
* [email protected]
*
*/
#include <stdio.h>
#include <stdint.h>
int main(int argc, char **argv ){
/* source data */
uint64_t S_U64 = 0x01ull;
uint32_t S_U32 = 0x1ul;
uint16_t S_U16 = 0x01;
uint8_t S_U8 = 1;
/* pointers to source data */
uint64_t *P_U64 = &S_U64;
uint32_t *P_U32 = &S_U32;
uint16_t *P_U16 = &S_U16;
uint8_t *P_U8 = &S_U8;
/* destination data */
uint64_t U64 = 0x00ull;
uint32_t U32 = 0x0ul;
uint16_t U16 = 0x00;
uint8_t U8 = 0;
/* raw load/stores */
asm("erld a5,a6,e10");
asm("erlw a5,a6,e10");
asm("erlh a5,a6,e10");
asm("erlb a5,a6,e10");
asm("erlhu a5,a6,e10");
asm("erlbu a5,a6,e10");
asm("ersd a5,a5,e10");
asm("ersw a5,a5,e10");
asm("ersh a5,a5,e10");
asm("ersb a5,a5,e10");
asm("erse e10,a5,e11");
asm("eaddi a5,e10,0");
asm("eaddie e10,a5,0");
asm("eaddix e21,e10,0");
return 0;
}
|
the_stack_data/115765825.c
|
#include <stdio.h>
#include <stdlib.h>
/*Faça um programa que leia dois números e mostre o maior deles. Se, por acaso, os dois numeros forem iguais, imprima a mensagem: "Números iguais". */
int main(void){
int num1, num2;
printf("\nDigite o primeiro numero: ");
scanf("%d", &num1);
printf("\nDigite o segundo numero: ");
scanf("%d", &num2);
if(num1 > num2){
printf("\nO primeiro numero e maior: %d", num1);
}
if (num2 > num1){
printf("\nO segundo numero e maior: %d", num2);
}else{
if(num1 == num2)
printf("\nNumeros sao iguais");
}
return(0);
}
|
the_stack_data/22451.c
|
// File: 'MaterialIcons-Regular.ttf' (128180 bytes)
// Exported using binary_to_compressed_c.cpp
static const unsigned int mtir_compressed_size = 84439;
static const unsigned int mtir_compressed_data[84440/4] =
{
0x0000bc57, 0x00000000, 0xb4f40100, 0x00000400, 0x00010037, 0x000f0000, 0x00030080, 0x45444770, 0x00000446, 0x8b010053, 0x28158208, 0x4f504724,
0xef18e053, 0x200f829c, 0x280f822c, 0x55534736, 0xa9d2e442, 0x230f8251, 0x69000064, 0x2f291d82, 0x22730a32, 0x01000063, 0x2b1f8278, 0x616d6360,
0x31f0f170, 0x090000e0, 0x06290f82, 0x74766302, 0x01110020, 0x20608244, 0x261f827c, 0x73616704, 0x82ffff70, 0x8b012169, 0x00390e82, 0x796c6708,
0xec7d4466, 0x17000004, 0x7201001c, 0x61656848, 0x8bda0664, 0x201c8266, 0x210382fc, 0x10826836, 0x02010422, 0x01211f82, 0x380f8234, 0x746d6824,
0x69e66a78, 0x01000046, 0x070000d8, 0x636f6ca0, 0x96293b61, 0x205f8285, 0x280f8280, 0x78616d9c, 0x00270470, 0x201f82e1, 0x2c2f8258, 0x6d616e20,
0x350f1c65, 0x890100e4, 0x2b138264, 0x736f707a, 0x0086ff74, 0x8a010032, 0x0021a382, 0x2efb8420, 0x4fd00201, 0x5f8822bf, 0x00f53c0f, 0x83000209,
0xded22300, 0x0786caa3, 0x0000cd26, 0x0002feff, 0x00228383, 0x1e850008, 0x00204a82, 0x10850a86, 0x01210582, 0x20008d00, 0x255b8303, 0xb000cd03,
0x18841800, 0x00000224, 0x01820100, 0x40000024, 0x0b822e00, 0x0400002e, 0x90010002, 0x00000500, 0x66014c01, 0x47201182, 0xf5240786, 0x84001900,
0x05215f83, 0x85158203, 0x12012102, 0x04200782, 0x02880382, 0x30008026, 0x0002ffff, 0x02210083, 0x8b008400, 0x00202681, 0x0000022b, 0x21178311,
0x00cc0002, 0x2b002b26, 0x40001500, 0x40200582, 0x55200582, 0x35200384, 0x6b220d88, 0x1b846b00, 0x27832583, 0x80002b22, 0x2b221b82, 0x0584ab00,
0x39831583, 0x40223f83, 0x01825500, 0x1f848020, 0x2b202385, 0x6b223984, 0x07829500, 0x22205f85, 0x25836982, 0x15200387, 0x59850f82, 0x09825520,
0x53841520, 0x2c201383, 0x09833984, 0x40202185, 0x40202784, 0x5522f782, 0x1b827700, 0x55006b22, 0x7f85a184, 0x2b200b83, 0x6583a784, 0x45846b20,
0x33002b22, 0x32824384, 0x5b200282, 0x6b203f82, 0x31830384, 0xef840020, 0x3e203583, 0x22827586, 0xeb87f784, 0x51836983, 0xbb855f85, 0x3d207383,
0x20080b41, 0x856f8221, 0x8400201d, 0x892387dd, 0x85cd8531, 0x210585dd, 0x01870095, 0x55206783, 0x0f213782, 0x20018500, 0x83cf822b, 0x41f18795,
0x0820058f, 0xfb83c984, 0x0120bb83, 0x53852382, 0x17823320, 0x08001524, 0x03820900, 0x66002b22, 0x2b20bc82, 0x87205982, 0x8f878786, 0x0f864020,
0x95220789, 0x2b822b00, 0x03825520, 0x80241383, 0x35002000, 0x55201182, 0x83063941, 0x006b22df, 0x41e18480, 0x4022075d, 0x21827700, 0x21824020,
0x41051742, 0x572005b7, 0x4b208984, 0x41833b84, 0x57846b20, 0x5a825b83, 0x6b200284, 0x42061d41, 0x1520055b, 0xc7411382, 0x84802005, 0x8240204d,
0x00802405, 0x84b700ab, 0x2213836d, 0x8215002b, 0x84268231, 0x82402002, 0x8341835f, 0x87a9830c, 0x8255200f, 0x056d4225, 0x21821520, 0x71410987,
0x20b98305, 0x20bb822b, 0x83d38435, 0x0559410d, 0xb1410f20, 0x83938508, 0x8527834f, 0x82002007, 0x8440201d, 0x83678555, 0x075b4205, 0x55205f83,
0x2b22e384, 0x2382a800, 0x89099b41, 0x202f8309, 0x42238200, 0x312005b3, 0x2b204984, 0x2006ef42, 0x22be8255, 0x821e002b, 0x201d8361, 0x8787842a,
0x842b206b, 0x42738915, 0x8028051f, 0x2b006b00, 0xb700ab00, 0x13831d84, 0x42058741, 0x338505df, 0x57001222, 0x1522fb84, 0x2b821800, 0x2b20fb85,
0x59206982, 0x25203382, 0x55851184, 0xb3841282, 0x05842b20, 0x4c208183, 0x29831282, 0xdd834785, 0x49840020, 0x05822520, 0x8305b943, 0x8517832b,
0x05d1428d, 0x41052b41, 0x75410579, 0x82402005, 0x002b222f, 0x836f8280, 0x212b8569, 0x3b85003a, 0x15221183, 0xc7826000, 0x3a20c983, 0x35832384,
0x11843e20, 0x69424020, 0x82552006, 0x822b2017, 0x83238345, 0x82952079, 0x8495203d, 0x84492055, 0x826b20fd, 0x8680205d, 0x00552631, 0x005600d5,
0x2001829e, 0x85118255, 0x447720a7, 0xed850a93, 0x0020b585, 0x200ac941, 0x83638200, 0x0545412d, 0x0d823d20, 0x65826b20, 0x2405d743, 0x002a0015,
0x06514420, 0x4107e541, 0x802005d3, 0xaf838582, 0x3d841520, 0x31821520, 0x0382d520, 0xe944ab83, 0x85598309, 0x855f8555, 0x203f83cd, 0x06dd4455,
0x41059942, 0x1f410527, 0x05454105, 0x2b220b87, 0x6f450100, 0x05534508, 0x23002b22, 0x45416784, 0x24d78709, 0x00000055, 0x20ef8255, 0x2005826b,
0x83b3840e, 0x84552023, 0x0797432d, 0x09004922, 0xb9414f82, 0x429d8709, 0x0d8305cd, 0x22058743, 0x8280002b, 0x413b8501, 0x998507cb, 0x8505d743,
0x05c34137, 0x40203585, 0x79837d82, 0x0020f383, 0x0b207d82, 0x85084d43, 0x001521e3, 0x20055541, 0x2017822d, 0x200b8200, 0x20238280, 0x06714211,
0x07846b20, 0xb7824020, 0x25845a20, 0x22056141, 0x8234002b, 0x051b41bb, 0x9f42bf83, 0x05ff4507, 0x40206783, 0x1520e584, 0x2b202584, 0x8943f984,
0x093d460b, 0x53413985, 0x85898309, 0x224185cd, 0x82270035, 0x846b20ed, 0x825a20b1, 0x823e204d, 0x22938357, 0x84650000, 0x052f418f, 0x2005c143,
0x201f8255, 0x201f82ab, 0x45ad8240, 0x0585057b, 0x0f820020, 0x6b83d783, 0x3f000022, 0x83459384, 0x07fb4105, 0x00207f89, 0x05200082, 0x03200382,
0x2c200382, 0x0a260382, 0x1c020000, 0x09820100, 0xfc040024, 0x09840300, 0x07822c20, 0x04221785, 0x1982f001, 0x9d827820, 0x00057a08, 0x00390038,
0xe07a005f, 0xe019e003, 0xe024e021, 0xe031e02c, 0xe053e039, 0xe0bce071, 0xe0c4e0bf, 0xe16de1e5, 0xe19ce195, 0xe1c8e1c3, 0xe1dbe1d0, 0xe264e2e2,
0xe2c9e2c4, 0xe308e3cc, 0xe338e318, 0xe4eee3e0, 0xe42ee413, 0xe536e53c, 0xe6dde572, 0xe645e620, 0xe6dde6c5, 0xe7e1e6df, 0xe801e8e9, 0xe815e80e,
0xe851e83a, 0xe8b6e873, 0xe900e9ce, 0xe90fe906, 0xff4ceb2b, 0x208182ff, 0x22798230, 0x8200e061, 0xe01b3879, 0xe028e023, 0xe033e02e, 0xe055e03b,
0xe0bee0af, 0xe1c6e0c3, 0x8290e145, 0x82a32079, 0xe1cd2a79, 0xe2e0e1d8, 0xe2bce226, 0x3a7982c6, 0xe30ae307, 0xe39de31a, 0xe4f1e3e2, 0xe530e415,
0xe539e52d, 0xe60ee6c3, 0x87c4e623, 0xe7920879, 0xe80be8ee, 0xe834e811, 0xe853e84d, 0xe8b8e875, 0xe902e9d0, 0xeb11e908, 0xffffff3b, 0xffaeffd3,
0x202820ad, 0x20122013, 0x200e2011, 0x200c200d, 0x1f0a200b, 0x1fcc1fcd, 0x1fc81fc9, 0x1f471f69, 0x1f3b1f41, 0x1f331f37, 0x1e281f2c, 0x1e8e1ee5,
0x1e8b1e8d, 0x1e501e51, 0x1deb1d4f, 0x1de81dea, 0x1ce61de7, 0x1cf41cf6, 0x1c741ca4, 0x1bf41b72, 0x1bdc1bdd, 0x1ad41adb, 0x1ac71ad0, 0x1aa71ac5,
0x1a941a95, 0x1a921a93, 0x1a901a91, 0x188e1a8f, 0x5149007f, 0xeafc820b, 0x830c2002, 0xe002216b, 0x03820583, 0x03823c20, 0x03823020, 0x03823920,
0x03820320, 0x03865f20, 0x07820d20, 0x03826120, 0x03827a20, 0x00000e23, 0x200682e0, 0x201f83e0, 0x200b8228, 0x21038519, 0x07822c00, 0x03821b20,
0x1c822120, 0x07822d20, 0x03822320, 0x0b822420, 0x07823420, 0x1f822783, 0x82360021, 0x822e200b, 0x82312003, 0x823b2017, 0x82332007, 0x82392003,
0x823f200b, 0x823b2007, 0x82532003, 0x8246200b, 0x82552007, 0x85712003, 0xafe0217b, 0xbc200b82, 0x7c200b82, 0xbe200782, 0xbf200382, 0x8a200b82,
0xc3200782, 0xc4200382, 0x8c200b82, 0xc6200782, 0xe5200382, 0x8e240b82, 0x45e10000, 0x6d200382, 0xae200b82, 0x90200782, 0x95200382, 0xd7200b82,
0x9c200782, 0x00210385, 0x200782dd, 0x820382a3, 0xde00213f, 0xc8200782, 0x00210385, 0x200782ff, 0x230382cd, 0x010000d0, 0xe1213282, 0x200b82d8,
0x200b82db, 0x82078204, 0xe2e129f0, 0x08010000, 0x26e20000, 0x64200382, 0x0b200b82, 0xbc200782, 0xc4200382, 0x4a200b82, 0xc6200782, 0xc9200382,
0xc3820b82, 0x82cce221, 0x2503820b, 0x00005701, 0x038207e3, 0x01213782, 0x20078258, 0x2003820a, 0x20238218, 0x2007825a, 0x2003821a, 0x200b8238,
0x20078269, 0x2003829d, 0x200b82e0, 0x20078288, 0x200382e2, 0x820b82ee, 0xf1e3253f, 0x13e40000, 0xd9200b82, 0x15200782, 0x2e200382, 0xfc200b82,
0x30200782, 0x3c280382, 0x16020000, 0x2de50000, 0x36200382, 0x23200b82, 0x39200782, 0x72200382, 0x13830b82, 0xe520df82, 0x0225eb82, 0xe6000067,
0x2003820e, 0x20178220, 0x82078282, 0x45e62127, 0x95200b82, 0xc4200b82, 0xc5200382, 0xb8200b82, 0x2b820782, 0x0382e620, 0x82ba0221, 0x85df200b,
0xbb022103, 0xe1200782, 0x02200385, 0xe724eb82, 0xe70000e9, 0x02210382, 0x820782bd, 0x01e821a3, 0xbe243b82, 0x0be80000, 0x63820382, 0x82d20221,
0x82112007, 0x21ab8203, 0x0782d602, 0x03823420, 0x23823a20, 0x0782db20, 0x03824d20, 0x0b825120, 0xe821df82, 0x200b8253, 0x200b8273, 0x200782e7,
0x24038275, 0x030000b6, 0x20078208, 0x200382b8, 0x200b82ce, 0x2407824a, 0xe90000d0, 0x200b8200, 0x20078261, 0x20038202, 0x200b8206, 0x82078292,
0x0fe92127, 0x97200b82, 0x6b820b82, 0x822be921, 0x009f240b, 0x823beb00, 0x824c2003, 0x00ba240b, 0x84fdff10, 0x03002803, 0x010000cc, 0x43000006,
0x0120075e, 0x00204782, 0x430fa64c, 0x032a127b, 0x07060504, 0x0b0a0908, 0x00a3000c, 0x0e000d3b, 0x1211100f, 0x16151413, 0x1a191817, 0x1e1d1c1b,
0x2221201f, 0x26252423, 0xe33fa327, 0x01112223, 0x21668244, 0x01830029, 0x0031b50f, 0x00410039, 0x00510049, 0x00610059, 0x00710069, 0x00810079,
0x00910089, 0x00a10099, 0x00b100a9, 0x00c100b9, 0x00d100c9, 0x00e100d9, 0x00f100e9, 0x010101f9, 0x01110109, 0x01210119, 0x01310129, 0x01410139,
0x01510149, 0x0195016e, 0x02e401ad, 0x0255020c, 0x02c002a8, 0x03fc02ea, 0x0333030d, 0x03ca0384, 0x042404f9, 0x049e0460, 0x05fc04c5, 0x05710536,
0x05cb05a2, 0x06fb05de, 0x062f0623, 0x06680646, 0x06c5068e, 0x072607f0, 0x07830765, 0x07cb07aa, 0x080208f0, 0x084d0815, 0x088c085b, 0x090709d9,
0x09500928, 0x09760966, 0x0adc09b4, 0x0a450a09, 0x0b9e0a73, 0x0cc00b0d, 0x0d900c21, 0x0da90d46, 0x0e300edf, 0x0e9a0e7b, 0x0fdd0ecc, 0x0f350f01,
0x0f870f63, 0x10ef0fc1, 0x10591036, 0x10bc109a, 0x110711df, 0x11481129, 0x11991176, 0x121b12ef, 0x1260124d, 0x1291127b, 0x12c112a4, 0x130613ec,
0x13711334, 0x143414be, 0x14841459, 0x15d2149d, 0x154d1514, 0x15a31575, 0x16e015bd, 0x162f1603, 0x17da1691, 0x1760171b, 0x17bb1798, 0x180018dd,
0x18521822, 0x18b3187c, 0x191119da, 0x1a931959, 0x1a3a1a0d, 0x1a9f1a74, 0x1b091bca, 0x1b461b1e, 0x1b831b5a, 0x1bcc1ba2, 0x1c2e1cff, 0x1c711c57,
0x1df11ca0, 0x1d4a1d2b, 0x1d851d6c, 0x1eaa1d99, 0x1e371e0e, 0x1e901e6b, 0x1ed11eb5, 0x1ff51ede, 0x1f2b1f17, 0x1f6c1f49, 0x200a2097, 0x2033201b,
0x206d2051, 0x21ce209b, 0x21342100, 0x219d216e, 0x22fe21ca, 0x22592232, 0x22bf2292, 0x230f23e4, 0x23562336, 0x23b62376, 0x240d24da, 0x24712438,
0x24d1249e, 0x251c25f8, 0x2589254c, 0x26f825b9, 0x26652634, 0x27f926af, 0x2750272a, 0x2773275d, 0x28fd27b6, 0x2862281b, 0x290929a9, 0x2978294e,
0x29c229b5, 0x2afe29db, 0x2a2b2a12, 0x2a892a3a, 0x2bd62aac, 0x2b502b12, 0x2cd82ba0, 0x2c372c12, 0x2d182d9d, 0x2da02d3c, 0x2e5e2ef6, 0x2ff42e8f,
0x2f912f2a, 0x301c30f7, 0x30683042, 0x30ba308f, 0x311631dd, 0x3159313b, 0x31ac3182, 0x32e831c1, 0x325f3223, 0x32a5328c, 0x32dd32c0, 0x332133ff,
0x33583341, 0x33b23384, 0x340e34d2, 0x3472343e, 0x34b13496, 0x35eb34cc, 0x35133501, 0x35793562, 0x35b1359a, 0x361436dc, 0x36763626, 0x36c7369c,
0x37f536d9, 0x37453733, 0x37983777, 0x38ed37c3, 0x385a3816, 0x38be3894, 0x39eb38d5, 0x392e3909, 0x398c3961, 0x3a0b3ac6, 0x3a593a30, 0x3aca3a84,
0x3b173bf1, 0x3b653b3c, 0x3bce3bbd, 0x3bef3bdf, 0x3c143cff, 0x3c863c2a, 0x3cb93c9e, 0x3d093de4, 0x3d5b3d26, 0x3dcd3d82, 0x3e163eee, 0x3e733e43,
0x3ffd3eb2, 0x3f4b3f28, 0x3fa93f87, 0x403140e8, 0x407e4055, 0x40d440ac, 0x411f41fc, 0x41634145, 0x42f041b1, 0x42504227, 0x4291427d, 0x434243ac,
0x45b344d5, 0x45b845a7, 0x46ec45d2, 0x4643461c, 0x469a4667, 0x47ef46c8, 0x4765472f, 0x48db47a4, 0x48634825, 0x49dd48ac, 0x4952492a, 0x49ad4983,
0x4a094ae8, 0x4a524a2d, 0x4a954a74, 0x4bec4ab9, 0x4b3a4b0e, 0x4b804b5c, 0x4bac4b99, 0x4c014ccb, 0x4c494c17, 0x4cac4c67, 0x4d244deb, 0x4dbc4d6d,
0x4e324ef5, 0x4fc74e79, 0x4f614f01, 0x500950b0, 0x506e5030, 0x50df50ad, 0x512351f2, 0x52e45183, 0x52495227, 0x52785267, 0x532453c2, 0x54e15383,
0x54775431, 0x55dc54b4, 0x55795504, 0x56d6559d, 0x561e560b, 0x56ac565b, 0x57f756be, 0x5744571c, 0x57af5775, 0x580758d3, 0x58785835, 0x58b8589f,
0x590b59d5, 0x592d591c, 0x599e597a, 0x5aee59bb, 0x5a525a1f, 0x5aa15a76, 0x5b085bd7, 0x5b9d5b63, 0x5cfd5bc9, 0x5c705c37, 0x5dca5c99, 0x5d385d0a,
0x5da35d67, 0x5efc5dd3, 0x5ffa5e7b, 0x5f775f2c, 0x60eb5fbd, 0x60666020, 0x60b5607f, 0x610e61d6, 0x61836153, 0x620762a7, 0x6293626c, 0x631063c8,
0x639f635d, 0x641a64e1, 0x646e6449, 0x65f6649a, 0x6580653d, 0x660e66cf, 0x667c663d, 0x66d566b0, 0x671767f9, 0x676a6748, 0x68ec67b2, 0x68306809,
0x68cf68a0, 0x695269fc, 0x6adf699d, 0x6a2c6a08, 0x6a916a72, 0x6b0a6bca, 0x6b536b34, 0x6ba76b7b, 0x6c066ccc, 0x6c5a6c2b, 0x6cbd6c87, 0x6d426dfb,
0x6d9d6d77, 0x6eeb6dd9, 0x6e3e6e16, 0x6e996e6c, 0x6ff26ece, 0x6f686f05, 0x6fc86f9d, 0x700b70fa, 0x7070703f, 0x71e57099, 0x71677116, 0x72ec71ae,
0x726c7234, 0x728d7281, 0x72b072a4, 0x72ea72c5, 0x730c73fb, 0x7337731d, 0x73597348, 0x73a2737d, 0x74e373bb, 0x7431740a, 0x7468744d, 0x7493747d,
0x74be74a9, 0x75ec74d5, 0x7565752c, 0x75b8758f, 0x762476e1, 0x76977659, 0x77fb76cd, 0x775a771d, 0x78e27797, 0x785a7818, 0x79eb78ac, 0x794e7924,
0x799e7974, 0x7af379c4, 0x7a727a37, 0x7bdb7a9e, 0x7b577b1e, 0x7ce07b7b, 0x7c347c08, 0x7c857c54, 0x7de37cb2, 0x7d677d29, 0x7ed67da2, 0x7e2c7e04,
0x7e8a7e4c, 0x7fed7eb1, 0x7f6a7f33, 0x7fd87fa9, 0x800680ef, 0x80508026, 0x80a4807a, 0x811281b7, 0x81a08168, 0x822a82e5, 0x82a28266, 0x83ff82cc,
0x837a833d, 0x84e783b1, 0x8464842c, 0x85dc84c0, 0x853a8506, 0x85848558, 0x86dc85c1, 0x86478615, 0x87c08688, 0x874d8701, 0x87ad8787, 0x88ee87d1,
0x882d8816, 0x8875884e, 0x890389e2, 0x89608929, 0x8ab98991, 0x8a3e8a0a, 0x8ac98a77, 0x8b698bfe, 0x8bc18b8e, 0x8c2d8ced, 0x8cac8c72, 0x8d1d8de5,
0x8d848d55, 0x8dd18dae, 0x8e078ee8, 0x8e7f8e55, 0x8ec18eae, 0x8f0e8fdc, 0x8f4c8f31, 0x8f938f76, 0x90df8fb4, 0x90369025, 0x90869056, 0x91dd90b9,
0x9158911c, 0x91be917a, 0x921892e4, 0x92ab924d, 0x930b93f4, 0x93569322, 0x93ba938a, 0x94fc93e8, 0x94369421, 0x948e9470, 0x95e394b6, 0x951b9501,
0x95a1953d, 0x96f695cc, 0x966d9630, 0x97ef96ad, 0x97419713, 0x9799976e, 0x980098c6, 0x986d982a, 0x991b99a7, 0x997c9948, 0x9ae499b0, 0x9a2c9a02,
0x9a709a49, 0x9ac69a9f, 0x9b339bf1, 0x9baa9b92, 0x9c009cd8, 0x9c519c27, 0x9d2b9db3, 0x9d8e9d5a, 0x9e029ec0, 0x9e6a9e2e, 0x9f2a9fca, 0x9fac9f54,
0xa023a0e6, 0xa099a059, 0xa1ffa0d5, 0xa16da137, 0xa2eba1af, 0xa230a20e, 0xa272a254, 0xa2c0a2a7, 0xa3fda2d9, 0xa351a32c, 0xa4f6a3b6, 0xa452a424,
0xa4c2a498, 0xa521a5f3, 0xa5a6a56c, 0xa5cfa5be, 0xa6fea5e7, 0xa63ca61d, 0xa686a66c, 0xa6b9a69f, 0xa701a7e1, 0xa752a72b, 0xa782a76f, 0xa8f2a7c6,
0xa8a4a845, 0xa912a9d2, 0xa96fa93d, 0xa9bba982, 0xaa16aaf6, 0xaa7eaa4e, 0xabe3aab9, 0xab35ab0b, 0xab84ab54, 0xabc7aba6, 0xad3bacf7, 0xad26ad02,
0xad8bad62, 0xae1baedb, 0xae80ae66, 0xafebaeba, 0xaf5aaf19, 0xafbfaf7a, 0xb04eb0df, 0xb0a6b071, 0xb132b1f3, 0xb1aeb17c, 0xb206b2c8, 0xb2b8b23f,
0xb339b3ff, 0xb3a3b370, 0xb42bb4e4, 0xb49bb469, 0xb52bb5d7, 0xb6eab5a6, 0xb645b61c, 0xb7dcb66d, 0xb7c1b710, 0xb839b8e6, 0xb9b4b888, 0x00020024,
0x00000011, 0x00550199, 0x00070003, 0x0001b12e, 0x07b23c2f, 0x32ed0004, 0xdc0506b1, 0x0203b23c, 0x00220a82, 0x168303b1, 0x16830520, 0x0607b227,
0xb23cfc01, 0x33178301, 0x11331133, 0x23113327, 0x66778811, 0xfe550166, 0x330111ab, 0x8208f448, 0x00002256, 0x09044931, 0x020f0010, 0x00033537,
0x012b002b, 0x00d501d5, 0x00070003, 0x2500000f, 0x17152335, 0x023a0382, 0x06141632, 0x01342622, 0x2a2a2a15, 0x7d7db043, 0x80eb7db0, 0x2b2b5680,
0x0a824001, 0x00b07d23, 0x83398804, 0x00132d37, 0x36000017, 0x26343632, 0x12140622, 0x37243b86, 0x15231533, 0xba260382, 0x8c65658c, 0x44845365,
0x4e82c020, 0x82552a21, 0x8c65230e, 0x49841b01, 0x2b801323, 0x247d822b, 0x01400015, 0x208786eb, 0x2287890a, 0x84131307, 0xebd62d82, 0x5656d5eb,
0x402b2b55, 0x6bfe9501, 0x40242f82, 0xc0011500, 0x0b242f82, 0x25001f00, 0xb5822f84, 0x332a6e83, 0x15171735, 0x35373521, 0x03833634, 0x15163228,
0x15161615, 0xce833307, 0x4055013b, 0x2a40402a, 0x80fe2d7e, 0x1431402d, 0x4031141c, 0x221954bd, 0x402bea19, 0x36028240, 0x17172d51, 0x51337c2d,
0x140e0f0b, 0x0b0f0e14, 0x11d53351, 0x82001a1a, 0x0725416d, 0x1722eb83, 0xe1870000, 0xf1860620, 0xf1863620, 0x0c12f72c, 0x130c120c, 0x50383850,
0xef840838, 0x82150121, 0x120c2210, 0x22108269, 0x84fd5038, 0x00002bf0, 0x00400004, 0x01c00140, 0x4f8300c0, 0x32002a26, 0x34360000, 0x36204385,
0x0b82a683, 0x85332721, 0x34353352, 0x07173537, 0x14150627, 0x35363216, 0x15272634, 0x2a861423, 0x120c8026, 0xf4120d0d, 0x89310584, 0x70705015,
0x914d70a0, 0x5721741e, 0x364a577c, 0x8576842a, 0x841e208f, 0x82ab2095, 0x5070321f, 0x91013960, 0x3529731e, 0x3e57573e, 0x29085438, 0x204383df,
0x22e1820c, 0x82550040, 0x00ab2991, 0x002f0017, 0x0100003f, 0x23246b82, 0x15062223, 0x33217882, 0x257a8233, 0x23152335, 0x03823335, 0x93263421,
0x32373717, 0x14111516, 0x22212306, 0x34113526, 0x80013336, 0x0940090c, 0x04820d0d, 0x2b200c24, 0x0884752b, 0x0d821284, 0x1a11ca32, 0xd6fe111a,
0x12191912, 0x09161501, 0x56090c0c, 0x16230483, 0x8d0b400b, 0x1a96240d, 0x8300ff11, 0x8201202c, 0x82002005, 0x825520a5, 0x01ab22a5, 0x220982ab,
0x820b0007, 0x209082a5, 0x37958221, 0x11331133, 0x56565501, 0x2a5600ff, 0xeb400156, 0x5601abab, 0x0200aafe, 0x22086741, 0x821b000b, 0x23c3822d,
0x35233533, 0xaf900383, 0x80804026, 0xaa555555, 0xfe216c83, 0x277284d6, 0x2bd62b40, 0x802b2a2b, 0x1084aa83, 0x1a112a23, 0x26538200, 0x01800055,
0x828001cb, 0x82052009, 0x07173153, 0x01171123, 0xc0b6b615, 0x808001b6, 0x80000180, 0x35242383, 0xab018000, 0x13262387, 0x27231137, 0x2182f537,
0x1e82b620, 0x8000ff23, 0x0a3d4380, 0x09000426, 0x13000e00, 0xcb824982, 0x37072726, 0x03231517, 0x35345382, 0x35270725, 0x75600133, 0x40604075,
0x40208040, 0x15017540, 0x01220882, 0x10838040, 0x15830c85, 0x03000022, 0x2b2de582, 0xe601c001, 0x0f000700, 0x00003500, 0x06204212, 0x14062732,
0x34260717, 0x36321337, 0x06143335, 0x26272223, 0x35200185, 0x15292083, 0x22263423, 0x17141506, 0x08018516, 0x2c20f52b, 0x722c1f1f, 0x451e3838,
0x1911e645, 0x1423322b, 0x0712290f, 0x1714291d, 0x2b567e57, 0x113e5a3d, 0x0b28240e, 0x0108170d, 0x2329832a, 0xa038bd1f, 0x21082b82, 0x6ffe45c2,
0x3223111a, 0x16371507, 0x29251e16, 0x56563f2a, 0x3e3e2d3f, 0x1b1f202d, 0x26221e1b, 0xef42040c, 0x055d4205, 0x1700032d, 0x33002300, 0x35250000,
0x42171533, 0x152a0c63, 0x32333533, 0x23350736, 0x03822315, 0x15200c82, 0x2310a341, 0x0c202b35, 0x2a055542, 0x09102010, 0x2b20950c, 0x422b2020,
0xe0240a4c, 0x560b4040, 0x2a064e42, 0x0c0c2020, 0x80353580, 0x42eb2b2b, 0x022c0c44, 0x15005500, 0xeb01ab01, 0x1d000e00, 0x17348783, 0x26223507,
0x17373435, 0x16141506, 0x15163213, 0x36270714, 0x152d9983, 0x00013727, 0x65465555, 0x4b0f1f1b, 0x31068635, 0x40805555, 0x65405655, 0x1f293246,
0x4b35211b, 0x0a882b01, 0x00341782, 0x006b0002, 0x01950140, 0x000f00d5, 0x0100001b, 0x07061433, 0x2628cf82, 0x14333526, 0x06363216, 0x7c416982,
0x15260805, 0x24710114, 0x352a354b, 0x5c43244b, 0x26345743, 0x01263426, 0x08513615, 0x51084646, 0x3d3d2f36, 0x801a2611, 0x0483261a, 0x03000022,
0x1c22558a, 0x57912800, 0xba822720, 0x36323329, 0x26343735, 0x96160622, 0x0f8b2964, 0x010f0a0b, 0x34101410, 0xb12a6d91, 0x0e0f0a84, 0x0f0b840b,
0x778ccd0f, 0x2c05a744, 0x001900d5, 0x00270021, 0x07011300, 0x25d08a27, 0x27373233, 0x6e832306, 0x27052722, 0x172cd785, 0x36270714, 0x65015b35,
0x2116591b, 0x2e2bdd84, 0x08231819, 0x80261a06, 0x82800001, 0x13552be4, 0xc001091a, 0x591b9bfe, 0xeb86050e, 0x02230b29, 0x80101a26, 0x84047f93,
0x212530f0, 0x0017141b, 0x002b0001, 0x01d50155, 0x831800ab, 0x0b5b44ef, 0x33173323, 0x08038627, 0x55800122, 0xaafe1119, 0x11191911, 0x2a402a16,
0x2b402b2a, 0x01402b2b, 0x11d5feab, 0x01111a1a, 0x561a1100, 0xc1450083, 0x000b240a, 0x8224001b, 0x23352151, 0x42082f46, 0x07240f67, 0x21152111,
0x1128d582, 0x2b559501, 0x6b2b5555, 0x87445e83, 0x01562805, 0x11d5fe2b, 0x83150119, 0x55552317, 0x9f4419c0, 0x55192b09, 0x192ad5fe, 0x002b0111,
0x55470500, 0x2171890c, 0x73821715, 0x03833720, 0x8a0e2d45, 0x80d52571, 0xebd5d580, 0x6b287191, 0x2bab2a2a, 0x2b2b552b, 0xc9477396, 0x00082709,
0x00260016, 0xc5871300, 0x70820520, 0x22232629, 0x32161406, 0x8f353536, 0x865520ec, 0x555528d1, 0x2016120e, 0x8a1f2c20, 0x800121ed, 0x1523d286,
0x820b752a, 0x161f231a, 0xf18b6a76, 0x0300002a, 0x21001500, 0xdf01eb01, 0x07220982, 0xb7471b00, 0x07252909, 0x27070717, 0x37272707, 0x37360183,
0x17173717, 0x2a150107, 0x00012a2a, 0x284d0734, 0x4d284949, 0x09883407, 0x2c055a48, 0x114f3b6b, 0x431f1f44, 0x3c3b4f12, 0x2209834e, 0x474f1144,
0x2523117b, 0x82343536, 0x130728ce, 0x06273732, 0x48161415, 0x873b08a9, 0x3c466524, 0x2d3c692d, 0x126524f0, 0xb07d7db0, 0x3c2d977d, 0xfe246546,
0x83f024ce, 0x80012108, 0x7d2b1282, 0x000200b0, 0x016b0080, 0x84950180, 0x010036b3, 0x23231133, 0x01113311, 0xab55552b, 0xfe950155, 0xfe2a01d6,
0x49778ad6, 0x23200a19, 0x240b1949, 0x2b2a2b40, 0x21678418, 0x0082aaab, 0x472a0121, 0x534908dd, 0x000b2a09, 0x00170013, 0x33352500, 0x072b4815,
0x20073b48, 0x23138217, 0x862b1501, 0x210a1c49, 0x49822b95, 0x1c495620, 0xaaad260b, 0x000100aa, 0x20af82ab, 0x2caf8295, 0x13000002, 0xeaab0717,
0x959501ea, 0x87c78295, 0x00022867, 0x3700000a, 0x48262737, 0x34240533, 0x2d8080d5, 0xa0239884, 0x86756060, 0x091f4295, 0x0f000724, 0xad491200,
0x35172211, 0x0ba84917, 0x4980aa21, 0xb8250ca5, 0x000060c0, 0x06934304, 0x03008022, 0xd9844382, 0xc5823720, 0x15333730, 0x35231523, 0x35333523,
0x21152733, 0x03820535, 0xabaa2b25, 0x832b5555, 0x82ff2002, 0x00ff23c0, 0x00822aab, 0x2a565626, 0x2b2b5556, 0x53490282, 0x6391430b, 0x40000433,
0xd5015500, 0x0d008001, 0x15001100, 0x00001900, 0x49b58301, 0x3327056d, 0x35051732, 0x82371533, 0x822520b7, 0x6b012e03, 0x3426406a, 0x081a2626,
0xabd5fe0e, 0x25c08555, 0xc02b8001, 0x1682261a, 0x2a260424, 0xc485802a, 0x26075341, 0x000700eb, 0x8221000f, 0x21352153, 0x33223f82, 0x174a0415,
0x25032406, 0x43330717, 0x01280ceb, 0x01aafeab, 0xfbfe2b00, 0x34365f82, 0x0e011026, 0x12fab00e, 0xfe121818, 0x011812aa, 0x2b555500, 0x6382ab2b,
0x01342633, 0x47246e02, 0x00ff1219, 0x11191911, 0x001e0001, 0x24b58205, 0x01eb016b, 0x2f6b8495, 0x0023001f, 0x25000027, 0x22263435, 0x36151506,
0x2005dd43, 0x0fdc4334, 0x11012b08, 0x33131133, 0x0b012311, 0x73423c42, 0x261d1d26, 0x0c09501d, 0x00ff090c, 0x090d0d09, 0x2b2a4001, 0x10952b2b,
0x161a1a16, 0x1b82c610, 0x57261d22, 0x21821b84, 0x09000123, 0x0509430c, 0xfe2a0125, 0x480200d6, 0xd5240663, 0x11000800, 0x33337783, 0x27152115,
0x15351537, 0x35213523, 0x01350717, 0x82ff2a6b, 0x832a20be, 0x569527c3, 0x55554080, 0x0685d640, 0x26089f48, 0x000600d5, 0x8218000f, 0x3523273d,
0x33373523, 0x44903517, 0x20201525, 0x8956152b, 0x55c02449, 0x8dab1516, 0x0001334d, 0x01400055, 0x00eb01ab, 0x01000013, 0x14151632, 0x5d472206,
0x26342206, 0x38938223, 0x64470001, 0x2b658c65, 0x4b4b6a4b, 0x016b6b35, 0x47466495, 0x35476464, 0x2210824b, 0x4a6b6b56, 0x06220b45, 0xcd840d00,
0x37172408, 0x27372315, 0x27153337, 0x07012701, 0x01372707, 0x762c433c, 0x7617432c, 0x1ef4fe2c, 0x1e7f0c01, 0x84e21e6f, 0x86e72011, 0x82432011,
0x00002711, 0x00800002, 0x01820180, 0x0621e382, 0x06494400, 0x5501172b, 0xb5d52b2b, 0x00ff8001, 0x891f8201, 0x82022023, 0x13002dff, 0x33011137,
0xb5cb2311, 0x2b2b00ff, 0x5c421f82, 0x08314605, 0x0900d822, 0x19309182, 0x21001d00, 0x35130000, 0x33071533, 0x37352315, 0x200f674c, 0x83a38225,
0xc02408a7, 0x804d4d80, 0x577c4b4d, 0x45577c57, 0xa07070a0, 0x1b950170, 0x62cb1b62, 0x1501621b, 0x2b5a262b, 0x58c05927, 0xfe2d1d83, 0x71719e71,
0x53214c9e, 0x20522020, 0x8aaa8252, 0x130027b9, 0x80211121, 0x8a820001, 0xbd46b382, 0x01552205, 0x08654bd5, 0x1f000f22, 0x2809d745, 0x15233523,
0x35331535, 0x0cd54225, 0x0133362d, 0x56d6d6ab, 0x0156d62a, 0x47191100, 0xd5240791, 0x2b552b2b, 0x80230082, 0x49ab2b2b, 0x05200c83, 0x26064744,
0x000700ab, 0x82180010, 0x4d3120eb, 0x17290953, 0x07273436, 0x07141516, 0x06444326, 0x35260729, 0x06273734, 0x8e011714, 0x22ef3973, 0x1a221a1a,
0x1f3232a4, 0x467e2526, 0x32463232, 0x1e252605, 0x24013232, 0x01218389, 0x2422822b, 0x328a221a, 0x2325828e, 0x06253634, 0x32232582, 0x82263746,
0x821e200a, 0x24012113, 0xf545988c, 0x0002240a, 0x821b0012, 0x273721f7, 0x470f5443, 0x002309ac, 0x47ab8080, 0xcb2310a9, 0x484a6060, 0x01311416,
0x80004000, 0x8001c001, 0x00001300, 0x27153701, 0x062f4d15, 0x36343524, 0xdb822133, 0x556b0128, 0xff090d55, 0x7f430900, 0x010d2605, 0x55ea5520,
0x200d834b, 0x2f0483d6, 0x00020000, 0x0140002b, 0x00d501c0, 0x0017000f, 0x24058d49, 0x26222123, 0x25418335, 0x15052733, 0x46823327, 0x01461527,
0x06441b7a, 0x3a488506, 0x95013a10, 0x0d0984ef, 0x86fed501, 0x0c04441b, 0x0c09d609, 0xefe4453a, 0x824b090c, 0x006b2a4f, 0x018b0155, 0x000500ab,
0x3e4f8209, 0x27113733, 0x07142423, 0x6b556b35, 0x2001556b, 0x6b400136, 0x7b6baafe, 0x00ac1b76, 0x82950001, 0x8455202b, 0x1300212b, 0x95242984,
0x566a6a56, 0xd34e2285, 0x0002260b, 0x001e0012, 0x2fe38224, 0x01272715, 0x07062707, 0x27373635, 0x35232715, 0x3424a282, 0x16352726, 0x2205634b,
0x82071427, 0x0152080b, 0x01782d00, 0x252c1b65, 0x5b171929, 0x6565556b, 0x2f3b5501, 0x20165441, 0x3401350b, 0x5aab0135, 0x9bfe422d, 0x0a1d2c1b,
0x5b12072c, 0x65806b90, 0x0e4e33a5, 0x44690e2c, 0x1b212930, 0x3404091d, 0x03001a2f, 0x45004000, 0xbb01c001, 0x0f000b00, 0x79821500, 0x14161622,
0x36207683, 0x16206e82, 0x0720cf82, 0x012caf84, 0x5454412b, 0x3b3b2f41, 0xeb35352f, 0xbb24e184, 0x6988690e, 0x4e284d82, 0x530e4e66, 0x16ac1a78,
0xe746ee83, 0x07674e09, 0x2106d748, 0x1b513527, 0x0f874205, 0x56ab0128, 0xebebeb15, 0x76425601, 0xc0802509, 0x55556bc0, 0x01210282, 0x0c60422b,
0xa9820420, 0x2605f94f, 0x000d0003, 0x45290019, 0x2729054b, 0x36323315, 0x26343535, 0x0bff4c23, 0xef421320, 0x3501290e, 0x09564b2b, 0x80090c0c,
0x2312f84c, 0x090c8060, 0x80201c82, 0x2105f34c, 0xb54e0001, 0x0005320d, 0x01310022, 0x00cf01d2, 0x000c0009, 0x00170014, 0x0879821a, 0x2315334e,
0x35233735, 0x33051533, 0x17332727, 0x07232723, 0x07331723, 0x01372313, 0x7eb68250, 0x9cfeb17d, 0x23112a53, 0x6d142760, 0x63b92714, 0x32653332,
0xb71b22a8, 0x6f821b22, 0x3434f42e, 0x6c013223, 0x02000032, 0x2b001500, 0xc001eb01, 0x1d415585, 0x22578207, 0x82112111, 0x06115062, 0x1737132e,
0x1a11c001, 0x5555111a, 0x555580fe, 0x403c0983, 0xc0018080, 0x00ff111a, 0x012a1911, 0x2a00ff00, 0x00011119, 0x6bfe1a11, 0x04008080, 0x240ae745,
0x003b0034, 0x34af824f, 0x37323314, 0x35353637, 0x23263426, 0x06070722, 0x37161515, 0x2c078214, 0x23062223, 0x26262722, 0x35352627, 0x39218234,
0x33363233, 0x021e1732, 0x07151617, 0x35073523, 0x34073337, 0x17353336, 0x27473507, 0x33353905, 0x26220614, 0x050a1a01, 0x02020402, 0x03030209,
0x28030304, 0x04070602, 0x09230c82, 0x82060204, 0x06072106, 0x21080c86, 0x02040407, 0x26151459, 0x47649403, 0x4c346b6b, 0x2b4c684c, 0xbc658c65,
0x04050207, 0x04042b02, 0x20820305, 0x13042b2e, 0x060d040d, 0x04010202, 0x0f190501, 0x02370b87, 0x350b060c, 0x0c0f0646, 0x5664461b, 0x4b566b6b,
0x354b4b6a, 0x8c646447, 0x002727dd, 0x00890047, 0xa2923700, 0xf19e3720, 0x232cf092, 0x26353532, 0x06232334, 0x23151522, 0x322e5282, 0x17323336,
0x06151516, 0x22231415, 0x0a821607, 0x06071425, 0x41060706, 0x33260a33, 0x33141615, 0x38863633, 0x8c553521, 0x41c720e7, 0x02220a24, 0x24412a02,
0x07270806, 0x03040210, 0x04070603, 0x09020802, 0x04070204, 0x0f710204, 0x020b0402, 0x070b1604, 0x0c010801, 0x0402080c, 0x82090502, 0x04012604,
0x02070401, 0x20288209, 0x202b8201, 0x23248412, 0xeb0d0402, 0x200d1141, 0x144e4118, 0x09244882, 0x060b0f08, 0x25055941, 0x0b060c02, 0x5282040d,
0x08040427, 0x0406020f, 0x247e820f, 0x03050504, 0x2a678208, 0x04010601, 0x02010202, 0x84100501, 0x020b2521, 0x02000f04, 0x38084342, 0x00460032,
0x15063700, 0x33372307, 0x32072315, 0x35363435, 0x17323333, 0x0b104116, 0x20054142, 0x07734133, 0x26272724, 0x94412723, 0x07fa2d12, 0x33050d02,
0x03020225, 0x03080404, 0x09217882, 0x217b8202, 0x06820f08, 0x09020724, 0xf7820d11, 0x05020225, 0x41a90204, 0xde300c47, 0x2f030103, 0x0102130f,
0x01030101, 0x0e090104, 0x08222e82, 0xb2840802, 0x020a0e2a, 0x0d020404, 0x0d020504, 0x420d1541, 0x05430c27, 0x49372041, 0x0543132e, 0x07e0410d,
0x25130543, 0x2615145b, 0x5d491703, 0x684c2605, 0x6b344c4c, 0x2d05436b, 0x8a498f20, 0x09e3430e, 0x35001526, 0x8b007700, 0x210ae343, 0xe64d2634,
0x10e54305, 0x4154f342, 0x1e2a1419, 0x0402040b, 0x02080202, 0x06820304, 0x42071f44, 0x332041fa, 0x23134241, 0x02010401, 0x420c4a44, 0xb5203dfb,
0x430e6a41, 0x34220a0b, 0x0b434800, 0x030e221b, 0x084d4507, 0x200c0b43, 0x123d4235, 0x0207fc23, 0x100b430f, 0x01050424, 0x0d430b02, 0x43f38c0f,
0x0422140c, 0xc1430103, 0x090e4305, 0xc58fb720, 0x15000331, 0xeb014000, 0x0b00c001, 0x23000f00, 0x4e010000, 0x1525097a, 0x11211117, 0x28a48201,
0x23061403, 0x35231523, 0x06794623, 0x3506f557, 0x0180feab, 0x011a1180, 0xaa6b1119, 0x1919126b, 0x2b2b0112, 0x02824040, 0x00019626, 0x2b0100ff,
0x2a056d4d, 0x11192b2b, 0x19120001, 0x88060000, 0x000d2a6b, 0x001e0014, 0x0032002e, 0x22718236, 0x82263435, 0x35332e5e, 0x27331733, 0x23370736,
0x17232707, 0x21148627, 0x184b3632, 0x3317240f, 0x82252315, 0xc0013a03, 0x204b0e12, 0x13201219, 0x2026b313, 0x25201516, 0x4b0d1342, 0x01130d4b,
0x218b8315, 0x058380fe, 0x2b2b2024, 0x03821501, 0x0e150b2f, 0x2b2b8012, 0x8036092d, 0x20804949, 0x230d8240, 0x1219ee12, 0x26069856, 0xa019122a,
0x48154040, 0x112a0ba7, 0x27001d00, 0x00003700, 0xf9843525, 0xb957fd83, 0x82272006, 0x07f55611, 0x0b820720, 0x15232725, 0x8f173533, 0xb50139a6,
0x181b181a, 0x55090d1b, 0x55950c09, 0x35353555, 0x1a361a36, 0x0f01371a, 0x36079d4e, 0x6bd51218, 0x604b4b60, 0x0c0c096b, 0x1b801b59, 0x65181b17,
0x824b4b80, 0x19eb2402, 0x8300ff12, 0x053741be, 0x2b000430, 0xd5016b00, 0x02009501, 0x0a000600, 0x95820e00, 0x25071726, 0x37152135, 0x37061c50,
0x6a6a6b01, 0x1501c0fe, 0x0196fe55, 0xeb96fe6a, 0x2b554040, 0x2a2ad52b, 0x00210582, 0x203d8205, 0x373d8295, 0x0004006b, 0x00180014, 0x0020001c,
0x07273700, 0x15370727, 0x23230614, 0x2607ed4a, 0x35171632, 0x82351533, 0x23172fe8, 0x30e03335, 0xb5251b25, 0x1180111a, 0x04821919, 0xaa2b1a22,
0xc0280083, 0x30203040, 0x1a118080, 0x1a2d1883, 0x2b2bbc1a, 0x802b2bd6, 0x0001002a, 0x06475855, 0x79590720, 0x05ee5009, 0x82050251, 0x821520b9,
0x01eb2621, 0x000b00ab, 0x0d4f4a13, 0x5d570420, 0x6b012b06, 0x38484838, 0x262f2f26, 0xb251aafe, 0x0ea52e05, 0x0e5c765c, 0x54420d2c, 0x8cbf0d42,
0x5a148265, 0xc02608d7, 0x11000d00, 0x6d842100, 0x83323321, 0x822320b9, 0x422220cd, 0xdd5407b1, 0x26ab290b, 0x6b0e071a, 0xef342640, 0x2205af42,
0x84fe111a, 0x34a62fc1, 0x2b840426, 0x15251a96, 0xd6fe2a01, 0xe0495501, 0x098d5b0c, 0x1200022c, 0x1a001600, 0x27250000, 0x614c2515, 0x15272c0e,
0x21053521, 0x55012135, 0x4d000180, 0x013e07a5, 0x55191156, 0x2b0100ff, 0x5601aafe, 0x9b8b45ab, 0x191911ab, 0x1a11ab11, 0x2a2ac41a, 0x65422b80,
0x01eb2607, 0x00050080, 0x27c78409, 0x07170100, 0x25173727, 0x20063351, 0x2a568205, 0x9520cb01, 0xfe412061, 0x4e56aad5, 0x012905d2, 0x6096200b,
0x2a164020, 0x05064e2a, 0x0300002a, 0x20001500, 0xc0010002, 0x11254782, 0x00002800, 0x22448225, 0x52273727, 0x37290a3d, 0x15151632, 0x11213523,
0x05d64321, 0x2106c043, 0x49820002, 0x8b204025, 0x822a4040, 0x259a8202, 0x0180fe2b, 0xc5432b40, 0x84802005, 0x2b4b2d1b, 0x402b4040, 0xaa121955,
0x2a00ffaa, 0x4408c443, 0x0327092f, 0x1b000700, 0x82010000, 0x4405205e, 0xaa221827, 0x24441501, 0x442b2012, 0x06301520, 0x2c002c00, 0xd401d501,
0x11000b00, 0x1d001700, 0x20059351, 0x08794c00, 0x03163533, 0x15171637, 0x17162726, 0x37272607, 0x36230706, 0x08058237, 0x37362734, 0x07061717,
0x516ed501, 0x3f56563f, 0x251eee51, 0x06553f2f, 0x06291e1c, 0x2b061c4d, 0x2f902906, 0x3f331e25, 0x413f3f2b, 0x7aa45201, 0x61082b08, 0x05826180,
0x1e8ffe22, 0xb9261e83, 0x331f242f, 0x33827e3f, 0x84223321, 0x2fa53834, 0x0000312f, 0x00400002, 0x01c00155, 0x000300ab, 0x25000013, 0x4b152135,
0x935b0789, 0xfe952608, 0x122a01d6, 0x077b5b19, 0xd5d58022, 0x200e9e4c, 0x09994f00, 0x9f4c0920, 0x832d2006, 0x1523214b, 0x21053544, 0x09823523,
0x2108ff44, 0x1a4f3632, 0x3317350f, 0xab012315, 0x1b1b351b, 0x2b208636, 0x204b0e12, 0xeb120e2b, 0x23094144, 0xc02b2b20, 0x29053344, 0x154b8080,
0x2b80120e, 0x3c44ad13, 0x158b210b, 0xe145c782, 0x21c78607, 0x074d1523, 0xc0c02410, 0x431a11c0, 0x6b220717, 0x0c438080, 0x4143910e, 0xc020120b,
0x220d5d43, 0x8f40406b, 0x0d3b4245, 0x00001723, 0x06ff4d01, 0x20103b45, 0x21908200, 0x92898001, 0x2a6b0127, 0x2b2b562a, 0x0ca243ab, 0x4d83958f,
0x478c4992, 0x95950023, 0x20448cc0, 0x08395102, 0x10000222, 0x15279182, 0x14153733, 0x43052306, 0x21240628, 0x20754001, 0x2808d843, 0x768b0100,
0x1911ab16, 0x05095901, 0x50052342, 0x0b200581, 0x5906d351, 0x8f500903, 0x402b2613, 0x2b40402b, 0x0d955080, 0x402aeb23, 0x20028240, 0x109b5035,
0x410eb741, 0xab242173, 0x1501eaea, 0x0021de8c, 0x2edf820c, 0x01d50140, 0x000300c0, 0x00130007, 0x821b0017, 0x002322a9, 0x2b178227, 0x0033002f,
0x25000039, 0x37352315, 0x17200382, 0x6060bb82, 0x03152106, 0x83069941, 0x8f038313, 0x33132c0f, 0x33112111, 0x2b2b8001, 0x82ab562b, 0x2b2b2204,
0x8400852a, 0x2e04820b, 0x56fed5ab, 0x2b2bc0d5, 0xaa2a2a55, 0x822a2bd5, 0x0001271f, 0x2b562a2a, 0x1384552b, 0xfe260c8e, 0x008001d5, 0xcb4f0100,
0x001c3708, 0x17161300, 0x16173637, 0x15163233, 0x23061415, 0x34352622, 0x0d833336, 0x16171434, 0x5d308d07, 0x240c0a2f, 0x0c0c0928, 0x0cd59609,
0x08824b09, 0x01090428, 0x2f305d1a, 0x1382050a, 0xd5210f82, 0x24138296, 0x0d242809, 0x3f578209, 0x02ae0000, 0x006b0100, 0x0100001e, 0x14150722,
0x06070607, 0x26272722, 0x20363734, 0x07141617, 0x26370d83, 0x35352627, 0x34000126, 0x19200c2e, 0x35061206, 0x01690606, 0x82066922, 0x06122d08,
0x320c2019, 0x420f4001, 0x180f050f, 0x64211185, 0x25238564, 0x0e050f18, 0x01471042, 0x01952406, 0x82080095, 0x153332bb, 0x27073523, 0xd5c02337,
0xf81ef82a, 0xd595018d, 0x2a07828d, 0x00020000, 0x014d0077, 0x82b50189, 0x820c2025, 0x17372327, 0x27821523, 0x2713353d, 0x60a01737, 0x1e804b60,
0x1e498074, 0x60550149, 0x1e808860, 0xf8fe7773, 0x82481e48, 0x0040245b, 0x82c0018d, 0x820a20bf, 0x071722bf, 0x825d8227, 0x01172b61, 0x95c01ea2,
0x7762ab2b, 0x08826b01, 0x2bab6223, 0x271e8277, 0x6b006b00, 0xab01ab01, 0x00226182, 0x26820701, 0x15333527, 0xf8ab0137, 0x238a828d, 0x2af88d01,
0x00208982, 0xaf478782, 0x00082707, 0x1300000f, 0x52821707, 0x35072726, 0x27153333, 0xd5348f82, 0x652a7131, 0x3180d631, 0x013e1e3e, 0xb47131ab,
0x803165a2, 0x00200d84, 0x26091747, 0x00070003, 0x8219000b, 0x21352972, 0x23351715, 0x21153515, 0x08090c5b, 0x34110721, 0x80013336, 0xabab00ff,
0x112b0001, 0xfe111919, 0x111955d5, 0x2b2b5501, 0x6b2b2b80, 0x53952b2b, 0x552a05d2, 0x19118001, 0x40000300, 0xe1849500, 0x00255585, 0x21152113,
0x20578207, 0x22038225, 0x822b0195, 0x2b012f3b, 0x2a0100ff, 0xab2b6b01, 0x2a562b2b, 0x8997002a, 0x31820520, 0x25220383, 0xa6452711, 0x32212207,
0x21898316, 0x48470001, 0x55552306, 0x9183d5fe, 0x11560123, 0x22908319, 0x822b2b40, 0xfed62702, 0x111a5580, 0x19820001, 0x00050023, 0x22d7822b,
0x580002d5, 0x11202b1b, 0x112f7982, 0x01352115, 0x4944496b, 0x1c1c287f, 0x847b1c28, 0x85aa20f8, 0xaafe296c, 0x1e182095, 0xdb20181e, 0x1c221982,
0xc7525728, 0x55fe270b, 0x00022b2b, 0x79822b2b, 0x2605215e, 0x001c00c0, 0x4b260020, 0x25200521, 0x20140443, 0x05214307, 0x23353723, 0x05f24715,
0x61152721, 0x3324058a, 0x37152315, 0x01210b82, 0x0d1f43ab, 0x5e2f2f2d, 0x240d092f, 0x40151628, 0x8440152b, 0x165624f5, 0x43090cb5, 0x2f2e0c2d,
0x092f315c, 0x16e00c04, 0x2b402b16, 0x2b824040, 0x2b16152a, 0x00006b6b, 0x0055000a, 0x3205e75f, 0x000f0007, 0x001f0017, 0x002f0027, 0x003f0037,
0x564f0047, 0x1620096d, 0x6306325b, 0x2621057d, 0x5b0f8734, 0x3623074a, 0x83342622, 0x8e04201b, 0x5b2f8727, 0x8b5607cd, 0x221a2205, 0x2002821a,
0x8505849a, 0x8466200b, 0x84bc200b, 0xc4fe2105, 0x2a8b188a, 0x84eb0121, 0x8466200d, 0x21418305, 0x0b8b221a, 0x1784c420, 0x9a200585, 0x05850b84,
0x0685fe20, 0x46000021, 0x052a0915, 0x00001500, 0x27073501, 0x9b471715, 0xab01210f, 0xe1410083, 0x2b55260a, 0x6a2b6b6b, 0x0c9f54c0, 0x0f664983,
0x000d2205, 0x2549821a, 0x23230614, 0x9f561107, 0x17310806, 0x11151632, 0x26222327, 0x35213535, 0x090d6b01, 0x090c55d5, 0x0d091501, 0x550c0955,
0x010c09eb, 0x09000115, 0x2b01560c, 0x090c0c09, 0xfe090c40, 0x211f82c0, 0x9f83c02b, 0x006b2208, 0x01950140, 0x000600c0, 0x2500000d, 0x33270733,
0x17273335, 0x35231523, 0x40550123, 0x2a405555, 0x38038295, 0x55559540, 0x96559596, 0x00030096, 0x01200040, 0x00d001c0, 0x000f0008, 0x2589821d,
0x17372707, 0xd8821616, 0x27353208, 0x16141506, 0x27071717, 0x27222306, 0x27372626, 0x00010037, 0x794f1e31, 0x9b161226, 0xed4c1a66, 0x2f3a1b07,
0x2e32473c, 0x1b3b2907, 0x93012b01, 0x361b8330, 0xd39a2f6b, 0x2b226667, 0x081b4c34, 0x32263a1b, 0x3b32832f, 0x66d5fe1b, 0x15240a49, 0x2c001900,
0x36206982, 0x2f05545b, 0x32363433, 0x07071416, 0x33151506, 0x35073734, 0x22098748, 0x4e270723, 0x2408085a, 0x46321441, 0x221a2a32, 0x191a0d1a,
0x2a19192a, 0x1a1a11aa, 0x40405511, 0x19191255, 0x14250112, 0x3333231c, 0x3c138223, 0x1b1b0d22, 0x1b220b21, 0x012b2b92, 0xfe111955, 0x401a11d5,
0x01111a40, 0x0019112b, 0x05754100, 0xd501ab2a, 0x23001300, 0x16130000, 0x0626dc83, 0x042e0707, 0xde823435, 0x22371726, 0x33362707, 0x08099a62,
0x446dfa2f, 0x2410481b, 0x14060a0a, 0x04202734, 0x08b21b44, 0x2c451017, 0x24573e40, 0x011f114d, 0x1b446c0b, 0x0b2e1847, 0x4517070b, 0x0b1f5241,
0x2c208216, 0x2e441267, 0x45303e57, 0x16180f4e, 0x0591411f, 0x95012b22, 0x07257182, 0x00001800, 0x066a5912, 0x63832620, 0x85020e21, 0x2cea2d79,
0x1f2c1f1f, 0x1f577c09, 0x100f2b2c, 0x01216a84, 0x2a11820b, 0x57ab2c1f, 0x46501f3e, 0x8511123d, 0x443e2060, 0x894a20dd, 0x08674508, 0x4508dd44,
0x40220d6c, 0x02822b2b, 0x45000121, 0x01200b6d, 0x22084d61, 0x8e00000d, 0x45ab2049, 0xd52009aa, 0xc742338b, 0x00042909, 0x25000012, 0x37112111,
0xfe233a8f, 0x89012baa, 0x01ab277d, 0x2bd5fe00, 0x458d2a01, 0x1d003328, 0xc001c301, 0x45830b00, 0x07011323, 0x06814e27, 0x25272908, 0x33372715,
0x014e1632, 0x0c281c75, 0x1911d608, 0xf2620138, 0x19119632, 0x8cfead01, 0x1a06291c, 0x0338ef11, 0x1a32f2f9, 0x32592748, 0x002b0003, 0x01d50135,
0x002200d5, 0x00420032, 0x82171300, 0x07232ca0, 0x37352622, 0x14150627, 0x5b260717, 0x15220539, 0x0b871614, 0x49421720, 0x6417200e, 0x158805ea,
0x15467908, 0xa01b6501, 0x1a110401, 0x2a092201, 0x14231d15, 0x272e211e, 0x2c393115, 0x252bd52c, 0x583d321f, 0x15201f7d, 0x01233165, 0x04092332,
0x351a1623, 0x16cb014b, 0xa11b9bfe, 0x04111a01, 0x31141222, 0x3b112519, 0x1f1f2623, 0x4f2e362e, 0x631c2517, 0x2d394a3a, 0x1f1f1405, 0x323d587d,
0x4629271f, 0x0423db65, 0x01322309, 0x354b0923, 0x0004001a, 0x02400000, 0x00c00100, 0x2705a345, 0x2500002f, 0x33373426, 0x0728c082, 0x16171406,
0x07273717, 0x21058e43, 0xe35e1215, 0x087d3e17, 0x2a202308, 0x06060f2c, 0x202a2c0f, 0x58505875, 0x2626349a, 0x11ea2634, 0xfe111a1a, 0x27058356,
0x152c15d5, 0x34212b2a, 0x342c0682, 0x552a2b21, 0x25251d15, 0x0001151d, 0x26222582, 0x824a6634, 0x8805200c, 0x00032f91, 0x0013000b, 0x00290023,
0x23350100, 0x879e1515, 0x27070528, 0x01371735, 0x8093aad5, 0x40950122, 0x01240082, 0x80808000, 0x6b277b99, 0x2b162a2a, 0x8204002b, 0x02432481,
0x82d50100, 0x00083109, 0x002a000c, 0x27261300, 0x15371737, 0x07173523, 0x014a0882, 0x0f1f4a0c, 0x024a892b, 0x2a6e4c1e, 0x4c1e4cd8, 0x05fa4955,
0x0c1d1c24, 0x254a682e, 0x2f012d0c, 0x4c1f014a, 0x5b6a6a88, 0xfd4c1e4b, 0x2505184a, 0x0e050e1a, 0x324a0f42, 0x357f820c, 0x012b005b, 0x00eb01a5,
0x00130003, 0x0023001b, 0x23352500, 0xdf473715, 0x51232006, 0x2629068b, 0x26071732, 0x17270722, 0x28088536, 0x7d804001, 0x0a0e0e0a, 0x3604837a,
0x1e45c023, 0x1e389e38, 0x2c7e2c3a, 0x1f5a1f1f, 0xd5abab55, 0x83cf0a0e, 0x0acf221a, 0x2a1c830f, 0x2c3d1e38, 0x1f1f1e2c, 0x60020000, 0x6f8308e3,
0x21010025, 0x46252115, 0xc950067b, 0x069f6307, 0x11198122, 0x2709284d, 0xd6d66b01, 0x11191911, 0xdb440484, 0x01152205, 0x24b58695, 0x23112500,
0x07414e11, 0x8b08b645, 0x016b2731, 0x01d6fe2a, 0x6751197f, 0x40578306, 0x01208a89, 0x27064d53, 0x002100ab, 0x23170100, 0x4205ef60, 0x3329068b,
0x35332707, 0x16323634, 0x051f6c15, 0x0123352d, 0x32405580, 0x221a3246, 0x8855401a, 0xab013309, 0x32239556, 0x11952332, 0x95111a1a, 0x23955555,
0x0c863333, 0x5415974a, 0xa14e0943, 0x05b94508, 0x2b2b6b27, 0x012b2b2a, 0x09764516, 0x842b1521, 0x06956600, 0x2f071f4b, 0x02950000, 0x00800100,
0x000f0007, 0x24000023, 0x60065f46, 0x242207c7, 0xfb5e1632, 0x08bb8405, 0x33071423, 0x01343526, 0x2b2b3e6c, 0x3eea2c3e, 0x2b3e2c2c, 0x44622f01,
0xeafe3144, 0x62444431, 0x1b601b45, 0x821382c0, 0x2005841c, 0x20128294, 0x2d1e8345, 0x2b20202b, 0x02000031, 0x80001500, 0x6d84eb01, 0xd7641920,
0x52372009, 0x063f0657, 0x26222306, 0x32333634, 0x1a228416, 0xa319221a, 0x5d552bdd, 0x352a420d, 0x2a354b4b, 0x831ad542, 0x563c2914, 0x2f265555,
0x2f4b6a4b, 0x596e4d82, 0x00eb2205, 0x5cb98317, 0x222b08cd, 0x33353526, 0x23113315, 0x82352315, 0x1721084d, 0x27071707, 0x27372707, 0x01371737,
0x1a1a1195, 0x1a11d511, 0x2bd5d52b, 0x5555111a, 0x56551555, 0x24058215, 0xeb015556, 0x0656421a, 0x012b4028, 0x11402b56, 0x1a879a1a, 0x00332082,
0x55000300, 0xc0011500, 0x0700eb01, 0x35001d00, 0x41130000, 0x634307d9, 0x05e5410e, 0x8207d349, 0x318d8cd1, 0x131a13cb, 0x11100a5b, 0x100a750b,
0x2e250a10, 0x918caf24, 0x2015012b, 0x0c10100c, 0x4b0b1020, 0x2824820a, 0x200f0a4b, 0x16202016, 0x479b8fb6, 0x152205c7, 0x3b43d501, 0x001a2306,
0x3f430022, 0x16052714, 0x36270714, 0x06843727, 0x01273423, 0x0a80432b, 0x142b0133, 0x12121514, 0x16282842, 0x01551d1d, 0x01aafe56, 0x37688796,
0x1a118001, 0x133415bc, 0x42181916, 0x16256b26, 0x001c4f1f, 0x3e000300, 0x24060341, 0x001f0017, 0x09e34754, 0x0220e58f, 0x28064542, 0x07161737,
0x27230607, 0x82058306, 0x27373324, 0x06072726, 0x37342727, 0x26273537, 0x33363737, 0x05833617, 0x1532332c, 0x37171617, 0x14171736, 0xa4410707,
0x2620080e, 0x22191922, 0x04177c1a, 0x04021502, 0x05050e1c, 0x022b0105, 0x05040103, 0x05021e0e, 0x18180215, 0x05241883, 0x04070d1b, 0x06291882,
0x1c0e0505, 0x02150402, 0x11cf4117, 0x1aeafe3f, 0x221a1a22, 0x02041306, 0x090b0225, 0x04051b02, 0x09021b01, 0x24050209, 0x16110404, 0x20168811,
0x25158305, 0x04240401, 0xf3831102, 0x2d072d51, 0x000a0006, 0x1300001a, 0x23173723, 0x10562315, 0x2ad52a13, 0x562a5555, 0x0180feeb, 0x09295880,
0x5500012f, 0x01415555, 0x01d4fe2c, 0xfe121956, 0x081983d6, 0x122a0126, 0x00020019, 0x01350015, 0x00a001eb, 0x00260009, 0x26352500, 0x15072223,
0x03323336, 0x14111732, 0x27222306, 0x03831083, 0x0c822220, 0x11352622, 0x3d081a82, 0xc0013617, 0x34412a21, 0x27274134, 0x04072a4c, 0x3d290203,
0x4a2b3441, 0x03013036, 0x2b070401, 0x2b2b4a4b, 0x200af675, 0x200120f5, 0x04c9fe20, 0x20160107, 0x06011720, 0x20390104, 0xcd832020, 0x2d07ab6b,
0x00070002, 0x01000017, 0x35012137, 0x81542707, 0xab002811, 0x5601aafe, 0x6101abab, 0x01270a2b, 0x00ff6b15, 0x546a6ad5, 0x02280f8c, 0x55000000,
0xab010002, 0x2e05b955, 0x15273725, 0x33360706, 0x21153317, 0x62223335, 0x212005f4, 0x30052643, 0x56561501, 0x552b1769, 0x00fe5596, 0x18181255,
0x2e5f8412, 0x2e5050cb, 0x7a3a6e0f, 0x12192b2b, 0x821912d5, 0x1a112304, 0x55820400, 0x00021b24, 0x0982db01, 0x2100122f, 0x00002500, 0x27373637,
0x07012706, 0x26578727, 0x14012737, 0x82372707, 0x0722226f, 0x2f628327, 0x23153303, 0x22311d95, 0xa5016e20, 0x7dfe3a1b, 0x34086382, 0xbd01210e,
0x56227616, 0x70020702, 0x19111101, 0xc0113b10, 0x1f220c28, 0x1b5bfee4, 0x11192b3a, 0x210c13d6, 0x0c19eafe, 0x2d4f2076, 0x186f0101, 0x2b00ff12,
0x0d1b5100, 0x17371325, 0x82352337, 0x07352b5a, 0x77a21e40, 0x952bab62, 0x08824d01, 0x62ab2b2d, 0x00030095, 0x01550055, 0x82a101a1, 0x000f25fd,
0x13000019, 0x2324ea82, 0x35232634, 0x2d080786, 0x32363415, 0x23061416, 0x58552622, 0x3e593d7c, 0x9f3cc389, 0x1a281b71, 0x1b14131b, 0x587c2901,
0xc3b5593e, 0xe19f7189, 0x281a1b13, 0x79821b1b, 0x6b006b2f, 0x95019501, 0x00000b00, 0x23152325, 0x827a8235, 0x0133257c, 0x802a8095, 0xeb200282,
0x80200483, 0x200f3371, 0x1a276d25, 0x566b0127, 0x2a56562a, 0x09cd7180, 0x0f83eb20, 0xd5565622, 0x4b0c5149, 0x0b22098b, 0xa9731300, 0x07654f0d,
0x6d254986, 0xb07d7db0, 0x2044867d, 0x210a82ea, 0xff6bb07d, 0x6a1b200e, 0x372111b7, 0x09405815, 0x200bc06a, 0x219a82ea, 0xd5595656, 0x076a7405,
0x5620af84, 0xb5505382, 0x00033207, 0x001e000a, 0x27211300, 0x23371321, 0x23152335, 0x0bc77225, 0x36373734, 0x17322133, 0x1426016d, 0x758100ff,
0x014a564a, 0xdc850a2b, 0x1d0a2208, 0x00010f0a, 0x95010a0f, 0x75e0fe16, 0x0c902b2b, 0x11f6fe0f, 0x01111a1a, 0x240c0f0a, 0x00000c0c, 0x08494a02,
0x8f590b20, 0x27372905, 0x17072707, 0x17371707, 0x23078f48, 0x27272221, 0x01286282, 0x1e4c4c95, 0x4d1e4d4c, 0x4c210282, 0x2844835e, 0x0e14c0fe,
0x140e7373, 0x851283b3, 0x014d2218, 0x2379852b, 0x13adad13, 0x30129374, 0x35363225, 0x16072734, 0x37171427, 0x06222326, 0x06b15036, 0x46000127,
0x2df02465, 0x05046d6f, 0x27058575, 0x3c466555, 0xab24f02d, 0x65210483, 0x0568418f, 0x200d2142, 0x0cdf4601, 0x1e777722, 0x01210287, 0x230c8a77,
0x2b000300, 0x2406bb45, 0x00130003, 0x152d461c, 0x2115372c, 0x34112311, 0x95013336, 0xdd83eaea, 0xaa2b0484, 0x192a00ff, 0x2b014011, 0x4f01d5fe,
0x0f4f0611, 0x83562005, 0x112b2311, 0x1569001a, 0x05094b08, 0x1800102f, 0x00003500, 0x07153301, 0x34320627, 0x09146922, 0x23057676, 0x23150117,
0x1520ff82, 0x2108d36b, 0xfa472737, 0x16322c05, 0x95011415, 0x202b9540, 0x51861616, 0x79330a82, 0x95400701, 0x46320732, 0x14233232, 0x0f32320f,
0x82322314, 0xc0012d0c, 0x4b2b9615, 0x2419b616, 0xe7241919, 0x11240584, 0x9515f8fe, 0x07211f87, 0x30338732, 0x00030000, 0x012b0040, 0x000002c0,
0x000f0007, 0x24ff8425, 0x23352315, 0x17ad4c11, 0x36363330, 0x01171632, 0x2ad62a95, 0x0c0c129e, 0x3d430c12, 0x1a113206, 0x0759111a, 0x07202a20,
0x40560155, 0x01aafe40, 0x821c8280, 0x08cd5702, 0x19115627, 0x13181813, 0x0aa14300, 0x00092508, 0x0100000e, 0x36372707, 0x16171732, 0x17370514,
0xba012307, 0x06275027, 0x06320612, 0x50ec80fe, 0x6a0150ec, 0x0e820f83, 0x82e01221, 0x092b520e, 0xbb82eb20, 0xaf821220, 0x07273723, 0x09265c05,
0x1737372a, 0xb0000116, 0x8501b0b0, 0x14297885, 0xeb14c1c1, 0x0467676e, 0x25a183d5, 0x710c19d5, 0xf5840c71, 0x20054758, 0x08f78203, 0x00000b21,
0x15213537, 0x21152125, 0x15333517, 0xfe000180, 0xfe8001c0, 0xeb569580, 0x2b952a2a, 0x552b2bd5, 0x402605e7, 0xab01ab01, 0x0c820900, 0x2315332f,
0x23152327, 0x33013311, 0x78089678, 0x242e822a, 0x01952ad5, 0x5d1a826b, 0x06350899, 0x35010000, 0x23350717, 0xab000135, 0x5501abab, 0x56abab56,
0x21bf83aa, 0x4167003d, 0x00082205, 0x2bbf8245, 0x06373632, 0x16141506, 0x37362727, 0x26062351, 0x16060706, 0x85373233, 0x8217200f, 0x0606216c,
0x08059057, 0x042e3789, 0x0e072223, 0x26060702, 0x033e3435, 0x26273637, 0x1c0e2801, 0x0a201e04, 0x080a25c0, 0x23131f1b, 0x060b1c1c, 0x0f090805,
0x39301b16, 0x3503292a, 0x213e0634, 0x373c281c, 0x07050101, 0x3b1c0a0e, 0x0b180d11, 0x120b3223, 0x11010f10, 0x2574070b, 0x0d260826, 0x24f90907,
0x1e1b080c, 0x27281e1f, 0x12181124, 0x373c2416, 0x3e453522, 0x48211b27, 0x0d06080a, 0x15490506, 0x0b03140f, 0x240f2430, 0x01161b22, 0x4103041c,
0x19200dc5, 0x3528c782, 0x14331521, 0x35363216, 0x3a10ed5a, 0x56d5fe95, 0x55263426, 0x111a1a11, 0x1812d5fe, 0xd5c01218, 0x26261ad5, 0x6000011a,
0x19330512, 0x122a0112, 0x00030019, 0x0195002b, 0x006b01d5, 0x4a13000f, 0x142906bb, 0x35232306, 0x34363233, 0x29078226, 0x15333507, 0x33161424,
0x114b1533, 0x30078305, 0x3e2c6b01, 0x56562c3e, 0x1b27271b, 0xfeaa6a56, 0x200682fe, 0x2d128656, 0x583f6b01, 0x3627293f, 0x2a802927, 0x0682302a,
0x6d540e83, 0x05696c4f, 0x243fb754, 0x00210001, 0x08fb84ab, 0x00000e2b, 0x23153701, 0x22232637, 0x36270706, 0x01323336, 0x4ec04c89, 0x59383e30,
0x75163211, 0x1e015549, 0x284dc04d, 0x44103441, 0x05974256, 0x9501eb2c, 0x03001501, 0x21250000, 0x5f4e2135, 0x2aeb2105, 0x22069353, 0x82d501d5,
0x820b2019, 0x2335221b, 0x08514515, 0x13d66b22, 0x2006a946, 0x14a5462a, 0xa5461320, 0x7b172011, 0x6a220e07, 0x9a46d6d6, 0x2a43230c, 0xc15d0100,
0x00953e06, 0x13000008, 0x26171616, 0x37271523, 0x127168d5, 0x95959e4d, 0x810f4001, 0x95576d5b, 0x49998295, 0x27830517, 0x2987ed83, 0x17070722,
0x01212f82, 0x22308615, 0x8a555580, 0x55402535, 0x95954055, 0x470cf946, 0x1522078d, 0x40453216, 0x13210805, 0x23071517, 0x01373527, 0x160a2a15,
0x11161111, 0xa070706c, 0x80eb7070, 0x16115c80, 0x01161010, 0x210e8320, 0x458e70a0, 0x00001925, 0x8a233501, 0x0c077a45, 0x7bd5402a, 0x34262634,
0x1a55ab26, 0x8207f279, 0x82d5208b, 0x34263011, 0xff552f01, 0x1a1a1100, 0x112a0111, 0x8212001a, 0x05d943ff, 0x08055544, 0x13000f27, 0x1c001700,
0x24002000, 0x2c002800, 0x36003100, 0x3e003a00, 0x46004200, 0x00004b00, 0x35331513, 0x15333507, 0x20038603, 0x20078237, 0x210b8527, 0x08830614,
0x15221c84, 0x20833523, 0x2622152a, 0x32013335, 0x27231516, 0x19831182, 0x2e861320, 0x36342729, 0x80c01533, 0x822bd6ab, 0x822a2000, 0x2b2b2d03,
0xd52b111a, 0x552b552a, 0x2b1a112b, 0x2b279983, 0x2bab2a80, 0x83802b2a, 0x40012219, 0x272b8280, 0x2b0001d6, 0x2babfe2b, 0x2b202382, 0xff210582,
0x212a8200, 0x25822aab, 0x82012b21, 0xd5fe2125, 0xd4821882, 0x2b21f182, 0x8236832b, 0x822b201f, 0x82aa201e, 0x8200204f, 0x40003d39, 0xc001eb01,
0x00000500, 0x25253537, 0x012b0535, 0x01c0fe40, 0x2b9540c0, 0x00c0952b, 0x20195d45, 0x29b28215, 0xff000140, 0xfe800100, 0x5c458080, 0x00032108,
0x2205d949, 0x630200ab, 0x2908056d, 0x07330701, 0x33372307, 0x07272317, 0x01211521, 0x5d502800, 0x20652c14, 0xca142c65, 0xd6fe2a01, 0x266b8001,
0x2febeb2f, 0x8d842a5a, 0x01ab3208, 0x006b01df, 0x0100000e, 0x07171632, 0x22232626, 0x35231707, 0x0b013617, 0x32177449, 0x3e385911, 0x4cc04e30,
0x5655013f, 0x41341044, 0x4dc04d28, 0x0c954937, 0x1a00172c, 0x33250000, 0x33032303, 0xbd443337, 0x37172d0f, 0x2d540117, 0x2d6d286d, 0x116f7818,
0x29081a70, 0x752c2c7f, 0xeafe1601, 0xae5e0140, 0x11562609, 0x7676f519, 0x0a5d4200, 0x10000624, 0x97822000, 0x33270722, 0x1720fa82, 0x25192245,
0x2a555555, 0x27456a56, 0x2b012610, 0x40405656, 0x072d456b, 0x45053e49, 0x034a082d, 0x07172312, 0x6a821533, 0x034a3720, 0x0a41211d, 0x4a05ca42,
0x76260a02, 0xd12b2b75, 0x014a100c, 0x0c102407, 0x490c0c23, 0xc02f09a3, 0x09000500, 0x00002300, 0x07273737, 0x82110717, 0x32352563, 0x33151516,
0x6f05bd4c, 0x352c09c2, 0xeb333634, 0x40165555, 0x19115640, 0x360a224d, 0x75111956, 0x40155556, 0x2a0a0140, 0x12192b2a, 0xeb111a2a, 0x82191911,
0x2a1a2304, 0xad521a11, 0x0011250a, 0x01000027, 0x06285683, 0x21151506, 0x27263435, 0x04205383, 0x0d83688d, 0x012f1b82, 0x131a1180, 0x1800ff18,
0x01111a13, 0x4f1a222f, 0x223706a5, 0x012a011a, 0x2e111995, 0x2c152007, 0x0720152c, 0x6a19112e, 0x836b111a, 0x116b2170, 0x40222582, 0x9b491140,
0x05bb4505, 0x11000728, 0x19001500, 0x79821d00, 0x33317282, 0x03173337, 0x14153335, 0x22232306, 0x15332526, 0x210c8223, 0x07821523, 0xff2b012b,
0x55154000, 0x19d5ab16, 0x317a8211, 0x80800001, 0x55559595, 0x2a2a9501, 0xebfe1616, 0x5c82d5d5, 0x802b9125, 0x762b802a, 0x95200869, 0x2006cd64,
0x0539651e, 0x222c4482, 0x33161406, 0x07173533, 0x37222335, 0x35205c86, 0x2b2f0782, 0x4b4b3951, 0x28383828, 0x0b40400b, 0x84aaaf39, 0x72d23000,
0x50382a51, 0x40402a38, 0xa02b2b2b, 0x4a2aa02b, 0xd8240953, 0x0f000700, 0x3620b787, 0x2a0ec77f, 0x07171537, 0x07273527, 0x82053727, 0x73c22003,
0xcb2d0a5f, 0x43651055, 0x01621b62, 0x1b621b48, 0x0a5b7355, 0x32701b2d, 0x63803c1a, 0x52522052, 0x89205321, 0xb7da2067, 0x64112367, 0x67846342,
0x861c6321, 0xa0703167, 0x1aa07070, 0x3e1a3371, 0x20516280, 0x54205151, 0x5b067b4f, 0x052205b1, 0xcf820d00, 0x84010021, 0x072b51bb, 0x054c1220,
0x600b2507, 0x8c317010, 0x09884118, 0x706b0128, 0x80441b39, 0x6e78eafe, 0x08714b0b, 0x0b00d825, 0x61001300, 0x5182057b, 0x7409614d, 0x01271789,
0x2a404015, 0x41294040, 0x8a740a2a, 0x40402209, 0x2002832b, 0x0a2e41eb, 0x4e088a74, 0xc035051d, 0x0f00d501, 0x00001a00, 0x07013713, 0x15171527,
0x37350727, 0x20038235, 0x7c0a8237, 0x2e08065a, 0x50011b40, 0x4b2b7b1b, 0x7faa2a4a, 0xa744ab6b, 0x01131a13, 0xb0fe1b90, 0x204f7a1b, 0x20151520,
0x2a357520, 0x2a6b1b50, 0x0d4ea715, 0x470d1313, 0x598306c1, 0x15000022, 0x17205982, 0x4f53578b, 0x17152405, 0x84abe7d9, 0x82aa2051, 0x01ab254d,
0x75359540, 0x6b214b88, 0x2a468375, 0x00006b75, 0x00950003, 0x826b012b, 0x500320a3, 0x3523068b, 0x5c171523, 0x22350b11, 0x34113526, 0x35333336,
0x15011533, 0x632a2a2a, 0x0c11110c, 0x3804839c, 0x6bd55623, 0x2b2b556b, 0x0c112b01, 0x100cb9fe, 0x47010c10, 0x2a2a110c, 0x879f8200, 0x00052a55,
0x37000019, 0x07352337, 0x0be15333, 0xeb245187, 0x2b552b55, 0x5524518b, 0xe0a076a0, 0x01204e8e, 0x1321a388, 0x08255b00, 0x978b2320, 0x938a4e20,
0x8eab0121, 0xbf00203e, 0x0923413f, 0x18001427, 0x00002c00, 0x10475d25, 0x8b0f465d, 0x0f31309c, 0x20263426, 0x09121c12, 0x12221414, 0x8a62280f,
0x0ff12aac, 0x26261a15, 0x13130d1a, 0x271d821a, 0x61121017, 0x2a012929, 0x032ec08e, 0x2b006b00, 0xd5017a01, 0x05000200, 0x7f821300, 0x15272d08,
0x33371511, 0x23071707, 0x37270735, 0x35173727, 0x283d0133, 0x5c5c3d28, 0x1e62157a, 0x621e7777, 0x5129a415, 0x29510801, 0xa2795c5c, 0xa2201185,
0x40203b82, 0xc0204782, 0x03284782, 0x09000600, 0x1b001700, 0x2005c562, 0x204f9207, 0x25588207, 0x2b2b9501, 0x578d2e2a, 0x2b2a6b25, 0x822b012b,
0x905c2000, 0x82d52060, 0x00002415, 0x82550003, 0x84ab2065, 0x000d22ad, 0x25ad8216, 0x01272737, 0xab862707, 0x27151725, 0x83173335, 0x2815285c,
0x3801a228, 0x835c311e, 0xc08d30b2, 0x417a152a, 0x287c221e, 0xc8fede29, 0x835b311e, 0x098d29b5, 0x796b2b45, 0x00231e41, 0x0341bb8a, 0x001b2205,
0x15074121, 0xb8551720, 0x37072a06, 0x07141516, 0x28281301, 0x0a15413c, 0x211fcc29, 0x56151519, 0x410a0a31, 0x642d111f, 0x19347a32, 0x562a582a,
0x19181931, 0x29c78219, 0x010f000f, 0x00f101f1, 0x07480007, 0x23273106, 0x33373307, 0x15071737, 0x23270723, 0x35372735, 0x33330c82, 0x01173707,
0x2a452931, 0x440f2945, 0x64464689, 0x85644747, 0x19c42705, 0xc0c0ab19, 0x1088722a, 0xb9464625, 0x8c004e4e, 0x000f2259, 0x0bb1611f, 0x2005ad4a,
0x2d618e25, 0x323246dd, 0x6a203246, 0x4b6a4b4b, 0x628b2b01, 0x82550121, 0x46322218, 0x221882a3, 0x8a7c6a4b, 0x00002368, 0xbf8b0002, 0x08c14618,
0xbb8c0520, 0xcb171522, 0xb6895586, 0x84804621, 0x8612204d, 0x8b6e83c5, 0x0005264d, 0x25000015, 0x21a98232, 0x4b8e1723, 0x35000126, 0xab354b4b,
0xc7204a8e, 0x1345488b, 0x01d52605, 0x001100d4, 0x2147831d, 0xc14e1737, 0x06152607, 0x16141506, 0x06427713, 0x34353a08, 0x00012726, 0x40382c48,
0x6f7d586c, 0x574a3651, 0x126f5153, 0x364a0a38, 0x5721386b, 0x7953587d, 0x54084008, 0x01573e38, 0x53790869, 0x1c212730, 0x0854381a, 0x55000400,
0x051b6300, 0x13000d26, 0x27001900, 0xb1476382, 0x82352008, 0x07372809, 0x07173727, 0x82372717, 0x58252006, 0x9a6b06f0, 0x6b013605, 0xd611192a,
0x402a1911, 0x1e62621e, 0x431eb743, 0xfe621e43, 0x291486ea, 0x11552a6b, 0x55111a1a, 0x1d83512a, 0x1e624427, 0x621e4444, 0x21148395, 0x15821901,
0x03000023, 0x05bb4c00, 0x2005a56a, 0x154f5c20, 0x15252a08, 0x35211533, 0x36343533, 0x01152133, 0x096b55d5, 0x80090c0c, 0x090d0d09, 0xfed6eafe,
0x11192bd5, 0x96958001, 0x090cc096, 0x2c1483d5, 0x2b0c09d5, 0xeb4040eb, 0x002b1a11, 0x08b36f06, 0x8209434c, 0x821320dd, 0x823720c3, 0x87052003,
0x16016c07, 0x2a2a9528, 0xea2a012a, 0x076ceaea, 0x27d3830d, 0x2b2b0001, 0x552a2a55, 0xc02d0584, 0x00ff0001, 0x111a2b01, 0x191100ff, 0x2290832b,
0x831a1100, 0x00152bdd, 0x01eb0115, 0x000700eb, 0x7782001f, 0x26075748, 0x23153325, 0x82070606, 0x26262e7d, 0x33352327, 0x35373636, 0x16161533,
0x069d4706, 0x2a056148, 0x2c2c5401, 0x2a436007, 0x87076043, 0x46db2c08, 0x32463232, 0x577c576b, 0x8b537c57, 0x20218418, 0x241b8203, 0x00004632,
0x89f58202, 0x08c54277, 0x6d987597, 0xd98d6797, 0x2f001930, 0x27250000, 0x16141506, 0x37033233, 0x44180701, 0xd9840712, 0x83053721, 0x600720eb,
0xe9850957, 0xd15b012e, 0x323e571f, 0x65011bf2, 0x372d2c1b, 0x0630ca85, 0x2c530125, 0x2010052c, 0x1e3e570b, 0x251f201b, 0x8a2e1682, 0x3e3229d1,
0x1b3a0157, 0x2c1b9bfe, 0x08410625, 0x2d372e05, 0x1d272a64, 0x3e1e1b20, 0x10200b57, 0x40148305, 0x89419593, 0x54052061, 0x01220571, 0xe14200d5,
0x01002d09, 0x07231533, 0x25113311, 0x17153335, 0x27200782, 0x013b0382, 0x552b2b95, 0x2bd5fe2b, 0x2b802a80, 0x55562b01, 0x00ff0001, 0xaa565655,
0x85feaa01, 0x6300200c, 0x022e0959, 0x21250000, 0xfed50101, 0x2baa0156, 0x1982aa01, 0x36000828, 0xc001f801, 0xfd460900, 0x37303905, 0x17323627,
0xb501b401, 0x794401b5, 0x170179fe, 0x01e0e001, 0x00555554, 0x240a0b4e, 0x001c0018, 0x222f822c, 0x82112111, 0x33153290, 0x16152335, 0x22061415,
0x37343526, 0x33363435, 0x06764313, 0x200c2050, 0x2c958280, 0x1640aa2a, 0x161a221a, 0xfe961119, 0x0c1b5aaa, 0x01341d82, 0xaaaa2b00, 0x11190c30,
0x19111a1a, 0x1a11300c, 0x5601d5fe, 0x80232682, 0x68fe1119, 0x112306ab, 0x64060019, 0x082e0825, 0x1a001100, 0x27002200, 0x00003000, 0x89821537,
0x35218082, 0x06e04405, 0x44133521, 0x232205c8, 0x28561635, 0x07322605, 0x21173717, 0x05e54403, 0x55153329, 0x19119696, 0x822a8001, 0x2e08828a,
0x1356962a, 0x1a13131a, 0x402b4083, 0x832b00ff, 0x96eb2115, 0x26831b84, 0x82012a21, 0x96962383, 0x22837d2a, 0x4f801326, 0x2b015539, 0x00291784,
0x00400002, 0x01dc0140, 0x082f71dc, 0x35228682, 0x65822733, 0x2805b150, 0x79796301, 0x784eab5d, 0x220082ab, 0x8279dc01, 0x4e783507, 0xddfe5dab,
0x0400abab, 0x6b001500, 0x9501eb01, 0x1d000700, 0x28051b7f, 0x35331513, 0x06222634, 0x06f65a07, 0x8306bd4a, 0x061427c9, 0x21351723, 0xe14d0115,
0xe6332d0d, 0x0f160f34, 0x0c0c0911, 0x19241909, 0x6a250683, 0x5501d6fe, 0x08356f11, 0x162b0132, 0x0f0f0a16, 0x40090c8a, 0x11160c09, 0x16121819,
0xd6240a85, 0x190001d6, 0x23054a61, 0x001911d6, 0x6b228d82, 0x4d611500, 0x001b2208, 0x15e35731, 0xa19c1720, 0x200ca161, 0x619a8f51, 0x80200580,
0x25067e4e, 0x11800111, 0x9d95c01a, 0x15318d82, 0xfa011500, 0x07000002, 0x27001d00, 0x00003f00, 0x2a799c01, 0x07173705, 0x33272622, 0x63251616,
0x013d0636, 0x37373426, 0x17173236, 0x17072707, 0x01372737, 0x1e154966, 0x0c091116, 0x2c20090c, 0x0806831f, 0x1cf5fe35, 0x93640e51, 0x45062008,
0x0a0a7001, 0x0a1a0988, 0x0a0a00ff, 0x0a1b0987, 0x792d1e34, 0x1e2f78f2, 0x0b0bcb01, 0x9a15150f, 0x0956090c, 0x1f160b0c, 0x840b161f, 0x2539820a,
0x3b638801, 0x2b828c61, 0x0a0a8724, 0x3b820001, 0x820a8821, 0x782c2536, 0x1e2f79f2, 0x0120bf82, 0xff20b182, 0x0922bf82, 0xc1840d00, 0x88370021,
0x371725a1, 0x01370701, 0x072aa68e, 0x16323727, 0x26262317, 0x94861da0, 0x88d14428, 0x9e8800ff, 0x9a850101, 0x84fffe21, 0x88902007, 0x1c36221e,
0x29838251, 0x8813603c, 0x9f880001, 0x8285fffe, 0x84010121, 0x861b2007, 0x4a89821c, 0x196d0781, 0x09f7610a, 0x250b3d6a, 0x80013713, 0x0182152b,
0x1a11ab2d, 0x00ff111a, 0x7f011a11, 0x84565501, 0x09844300, 0x00800023, 0x0a7d4703, 0x26001325, 0x43250000, 0x132912f0, 0x34352622, 0x36333736,
0x82d78233, 0x06142303, 0x8c710123, 0x1a80300e, 0x04182126, 0x2a1c2e15, 0x1f160104, 0x5e6a161f, 0x555c05e7, 0xebfe2d0b, 0x24191a26, 0x1b252b02,
0x001f2c1f, 0x250dc944, 0x2b110137, 0x0282aa01, 0x4456fe21, 0x04300b9d, 0x0c000800, 0x01370000, 0x33112315, 0x27153335, 0x24820382, 0x2a2b5524,
0x07822a2a, 0xd6fe802a, 0xab552a2a, 0x000200ab, 0x2043f567, 0x088f4402, 0x05000222, 0x112ea082, 0x21010121, 0x56fed501, 0xe7fe8001, 0x09841901,
0xe7fe4322, 0x0806bb47, 0xeb01d52a, 0x09000600, 0x01130000, 0x37212707, 0x27112527, 0x1b6f0166, 0xbd85fe2a, 0xb7750187, 0x90fea001, 0x88bd2b1b,
0xb791fe66, 0x340a9b45, 0x25000004, 0x17323603, 0x79f80001, 0x013679fe, 0x00555535, 0x28458203, 0x0100022b, 0x001b00c0, 0x052f7123, 0x3703072f,
0x1e32073e, 0x07171706, 0x06222326, 0x1c626217, 0x4b012508, 0x0606f74b, 0x2019160d, 0x2e2d2724, 0x2024272d, 0x060d1619, 0x10062c06, 0x138a3d2d,
0x0856131a, 0x6b080d0d, 0x26080483, 0xcb1f2e1e, 0x36015e38, 0x0e090405, 0x0a0b0f0c, 0x0b0a0505, 0x090e0c0f, 0x02380504, 0x0d204d3d, 0x200d1313,
0x8355080e, 0x0855272a, 0x1e17200e, 0xed82161f, 0x24055746, 0x000a00e1, 0x08ed8210, 0x17001637, 0x03072707, 0x05273736, 0x33362707, 0x010c4632,
0x471b481b, 0x2d21f853, 0x74cd012b, 0x7f2c2ddd, 0xfe0ce101, 0x471b4ae6, 0x1b350167, 0x915b2c14, 0x06000adc, 0x076f6000, 0x20090347, 0x2f4d8217,
0x07353315, 0x25152135, 0x27152335, 0x17211521, 0x55280f86, 0xaa01552b, 0x2a2babfe, 0x56210582, 0x270c832a, 0x2a2a1501, 0x96565640, 0xc0200583,
0x00350a84, 0x00660001, 0x01950126, 0x002c00eb, 0x15330100, 0x06141523, 0x0bbf4623, 0x26222325, 0x45263535, 0x14210579, 0x235a8207, 0x23173723,
0x01330683, 0x19155540, 0x1b1a4012, 0x401a1b28, 0x1c1a1912, 0x50191c26, 0x152b05f0, 0x2a566b01, 0x0e411912, 0x821c131c, 0x0e240802, 0x2c121941,
0x1b141b0e, 0x0d1c141b, 0x5656aa2c, 0x00002aaa, 0x00000003, 0x0100022b, 0x000700d5, 0x0029001d, 0x08d34718, 0x84071c54, 0x36342277, 0x36798533,
0x15062227, 0x36010715, 0x26071720, 0x1a13d501, 0x0c095613, 0x836b090c, 0x2c1f2f04, 0x3e2c3620, 0x7000ff4b, 0x39702001, 0x8141ab06, 0x090d2205,
0x321c8355, 0x200d0955, 0x161f1f16, 0x3d2c3e6a, 0x55550163, 0x43014c55, 0x322f051b, 0xc001d501, 0x2d001700, 0x00003500, 0x82163212, 0x270722f6,
0x06bb4f36, 0x2207386a, 0x49061405, 0x7d8205d1, 0x4b6a1420, 0x32362105, 0x0808bd4a, 0x7db0a852, 0x27163139, 0x648e642f, 0x3115272e, 0x23550139,
0x322a151d, 0x152a3246, 0x6a4b231d, 0x1a22914b, 0x011a221a, 0x3a597cc0, 0x17251c63, 0x64462e4f, 0x4e2f4664, 0x631c2517, 0x2359593a, 0x1925113b,
0x32322331, 0x25193123, 0x35233b11, 0x190b4b4b, 0x00303183, 0x95000100, 0x80011500, 0x2700eb01, 0x33010000, 0x21054a48, 0x7a823411, 0x0b851520,
0x13823520, 0x36321623, 0x05d14235, 0x83141121, 0x60012f0b, 0x45624420, 0x1f324633, 0x0d20202c, 0x06820c12, 0x013e0c82, 0x4531f580, 0x0a013145,
0x23333323, 0x1f1f16e0, 0x09cbcb16, 0xe0090c0c, 0x16202016, 0x1583f6fe, 0x002e6282, 0x01400087, 0x00c00160, 0x13000028, 0x6482031e, 0x2206b34b,
0x82331633, 0x27342566, 0x36343526, 0x0805d04a, 0x2623174a, 0x15062223, 0x1d16fc14, 0x22291120, 0x022b2140, 0x1f3b042f, 0x2a64401b, 0x23214020,
0x34022f01, 0x17011f1a, 0x20150c06, 0x06271f16, 0x2a072e2e, 0x0f172d21, 0x41171024, 0x2e07291d, 0x1d2c082f, 0x1d12162d, 0x40000500, 0xc0227382,
0xcf49c001, 0x065f520c, 0x07862720, 0x11210329, 0x80950121, 0x822a8080, 0x012b2903, 0x0180fe80, 0xaa808015, 0x01260287, 0x0080fe55, 0x49921100,
0x3f751720, 0x0037310e, 0x003f003b, 0x37000043, 0x15352315, 0x25152135, 0x25280782, 0x27153335, 0x05231533, 0x05200b82, 0x20061845, 0x200b8227,
0x20038223, 0x83038217, 0x8703830b, 0x8613200b, 0x836b2013, 0x2bab2489, 0x822b5501, 0xd6fe2100, 0x0c820885, 0x2b802a23, 0x2403822b, 0x2b2b2ad5,
0x20038280, 0x230682c0, 0x2ad52b2b, 0x2b220a82, 0x05822b80, 0x2b2bd626, 0xd52a2a56, 0x2b213482, 0x076475ab, 0x20053d59, 0x05644dff, 0x15000022,
0x4729cbaa, 0x4f004b00, 0x00005300, 0x20bb8201, 0x20038607, 0x20078203, 0x83d38237, 0x5a33200f, 0x15210515, 0x831b8627, 0x870b8707, 0x8f27872f,
0x40012123, 0xc782a683, 0xaa20d382, 0x0d84d482, 0xbd84cc82, 0x80220c84, 0x17862a2a, 0x2b950124, 0x055aaa2b, 0x83552005, 0x8304841a, 0x82e585d2,
0x2baa22f3, 0x2014822b, 0x85f48755, 0x2b2b210d, 0x19821f82, 0x03000023, 0x22008200, 0x83020002, 0x000d2809, 0x35000012, 0x5f211521, 0x073a09df,
0x37352307, 0x00fe0002, 0x502aba01, 0x0612062a, 0xd6450632, 0x5555d650, 0x0f83aa01, 0x12200e82, 0x09420f83, 0x3525242e, 0x41231533, 0x372006f5,
0x82070942, 0x82072078, 0x200f830b, 0x06054203, 0x11423720, 0x82232006, 0x86132007, 0x8235202f, 0x8211200b, 0x20f9820b, 0x05234180, 0xfe2b2b28,
0xd58001ab, 0xd483802a, 0x80220582, 0xf2822a2b, 0x2b2b8024, 0x1241402b, 0x2bab2306, 0x2641802b, 0x53552006, 0x06820525, 0x1e830282, 0x2882fe20,
0xd6200a82, 0xd5244582, 0x0d002b2b, 0x780c0542, 0x3725110d, 0x00003b00, 0x06d54125, 0x56150321, 0x132009a5, 0x13201382, 0x07820e83, 0x8207c942,
0x0335210e, 0xb3830f82, 0xf3831f83, 0x2b28b782, 0xababab2b, 0x55abab2a, 0x2b20a882, 0xd520aa82, 0x90849d82, 0x952b8022, 0x2b220f83, 0x1e838001,
0x83ab2a21, 0x8001219b, 0x20822182, 0x2b21ab83, 0x86a282fe, 0x43ab82a9, 0xa9422c7d, 0x41172007, 0x27200647, 0x11209c82, 0x1320c786, 0x01230782,
0x5c113311, 0x15200acf, 0xdf5c0b87, 0x07152106, 0x40202383, 0x2008b05c, 0x2192822b, 0xa0822b2a, 0x98842a20, 0xdb782b20, 0x42058205, 0xab260991,
0x2bd52a2a, 0xd18500ff, 0x445c0682, 0x05784205, 0x2babfe23, 0x8409822b, 0x212387f5, 0x7b410700, 0x000b210c, 0x23058d5d, 0x1300001b, 0x28060f42,
0x11211117, 0x21112103, 0x06174225, 0x07823720, 0x802bc026, 0xd6feaa2a, 0x8205a144, 0x2082838b, 0x05345115, 0xfe2a0128, 0xfe5501d6, 0x1382d580,
0x2b562a23, 0x2ea5422b, 0x42077142, 0x35260895, 0x33131533, 0xaf432311, 0x831b830b, 0x4217200f, 0x354106d1, 0x82232007, 0x203f830f, 0x207a83eb,
0x06e75d2a, 0xaa825520, 0x2305c443, 0x2bd52a80, 0x2f079b44, 0x2b2b4001, 0xaa2b2b55, 0x2baa2a2a, 0x2babfe2b, 0xbe43c984, 0x770c8205, 0x058205cb,
0xb2432b20, 0x21238506, 0x2b410800, 0x0009220a, 0x080f5b0d, 0x93442120, 0x21252505, 0x23112115, 0x8307a742, 0x209183a5, 0x26a58633, 0xfe2b9501,
0x82800180, 0x8201206c, 0xd52b2879, 0xd52b802a, 0x832b802b, 0x82802089, 0x08214582, 0x4505da41, 0x73832de5, 0xfd441720, 0x43132006, 0x012006cf,
0xe5458d82, 0x07314107, 0x41070545, 0x0783073d, 0x6742a383, 0x822a2006, 0x2b2b2295, 0x20a7852a, 0x41a68680, 0x2b21053c, 0x07ff442b, 0x2a2aeb28,
0x012b2bab, 0x66422b00, 0x2b2b2408, 0x822a2aaa, 0x053941d3, 0x1f845520, 0x82056442, 0xb10d84d4, 0x209183cd, 0x83c98203, 0x432720d5, 0x138306e1,
0x31432320, 0x86012006, 0x20d987ed, 0x0a0f4633, 0x83083543, 0x054e41cb, 0x802ad525, 0x43d5fe2b, 0x044206d1, 0x2b2b2105, 0xaa85c986, 0x2307ab44,
0x80fe8001, 0xdf8a1182, 0x0120c487, 0xc9472885, 0x21132415, 0x82172115, 0x790720a7, 0x0b8207e7, 0x4b844020, 0x55d6d622, 0x03820783, 0xd6d6d527,
0x2a2bc001, 0x0521412b, 0x55798020, 0x09df4a0b, 0x49830020, 0x45861520, 0x07860520, 0x45864984, 0x07858020, 0x62464982, 0x2095990b, 0x20438211,
0x24038225, 0x35211527, 0x8a038205, 0x7a80204b, 0xc0210679, 0x061a442b, 0x2b2b8023, 0x0ced79ab, 0x1720978e, 0x80239793, 0x82fe0001, 0x00ff2194,
0x988f0785, 0x00030030, 0x01800095, 0x00ab017b, 0x000f0007, 0x2f57001b, 0x23300806, 0x33153515, 0x26343632, 0x15161723, 0x23230614, 0x16323311,
0x0e200114, 0x4b0e1212, 0x13130d40, 0x2d2e380d, 0x24869722, 0x1a13b531, 0x40c04013, 0x52080582, 0x2234155b, 0x322b012f, 0x02000048, 0x40002b00,
0x9501ab01, 0x11000800, 0x21130000, 0x27072315, 0x27272337, 0x27070117, 0x27372307, 0x7c2b0180, 0x330f2d22, 0x01063a3c, 0x21791b34, 0x01943440,
0x2c504095, 0x05043c24, 0x791bcbfe, 0x00947b4e, 0x47000400, 0x0e200989, 0x21214782, 0x058b4700, 0x2b07ce52, 0x33253736, 0x14161727, 0x23060707,
0x2105997d, 0x9a472737, 0x952c0805, 0x19221a2b, 0xe5fe0a15, 0x0a8c67cd, 0x0d0a750a, 0x0a760a0c, 0x1f336e0a, 0x0b015555, 0x1a111c2f, 0x260c111a,
0x50662d0c, 0x75091a0a, 0x09212082, 0x2f1c821a, 0x0200001e, 0x3d005500, 0xbc01a801, 0x13000b00, 0xad82b782, 0x2305f357, 0x14052737, 0x2808c182,
0x0170021e, 0x25391b38, 0x1c4b352f, 0x032b0147, 0x2b0e3ab7, 0xfe900147, 0x20381bc8, 0x3622354b, 0x0d0f9f47, 0x36104bb8, 0x0745487b, 0x82c00121,
0x000a2253, 0x084b820e, 0x2727332a, 0x27231333, 0x07230723, 0xcd211521, 0x2a153366, 0x86173075, 0x02753018, 0x0100fe00, 0xfe398700, 0x404040d5,
0x06000055, 0x2410f545, 0x00160012, 0x07494500, 0x3e822520, 0x21351130, 0x15372515, 0x15333517, 0xd5d5d5eb, 0x774280fe, 0x80fe3605, 0xebd55655,
0x2b552a2a, 0xfe2b802b, 0xc02b2bab, 0x2b16aa55, 0x2051a32b, 0x234a8213, 0x15071725, 0x51895882, 0x5982ab20, 0x01555523, 0x21528780, 0x528300ff,
0x826b5521, 0x21b18252, 0x76820080, 0x00ab0123, 0x21dd830b, 0x387e2315, 0x23372605, 0x483cabd5, 0x3003832f, 0xab40ab01, 0x00ab4040, 0x00200004,
0x01d5014b, 0x065d4bb5, 0xcb831520, 0x05152122, 0x01206a82, 0x232acb82, 0x27073315, 0x37233533, 0x9078d517, 0xff002a08, 0x4a355500, 0x4b35354b,
0x287b824a, 0x012a2a80, 0x4ad62a2a, 0x8202824a, 0x003526cb, 0x01c00160, 0x244d86a0, 0x001b0013, 0x82818223, 0x07994349, 0xd1572420, 0x07775f06,
0x0f861620, 0x2b019524, 0x0386d5fe, 0x131a8823, 0x22028d13, 0x822a9501, 0x20028268, 0x27188435, 0x1c121301, 0x6e1c1212, 0xed4e0584, 0x82c02006,
0x057543ed, 0x75821520, 0xc78d2720, 0x18350721, 0x21072954, 0xb7453527, 0x83078207, 0x8b35200b, 0x6ad52f79, 0x40272740, 0x2a151126, 0x2a40402a,
0xe0881515, 0x14165623, 0x3102822c, 0x56164040, 0x165616c0, 0x000a160a, 0x55000100, 0xed822b00, 0x1f00d522, 0x260a114f, 0x35352622, 0x6a233533,
0x27080932, 0x32213336, 0x80011516, 0x090cab40, 0xd50c092b, 0xff090c15, 0x0d0d0900, 0x09000109, 0xabab010c, 0x0c0c09c0, 0x1555eb09, 0x55201283,
0x002a0b83, 0x6b000200, 0x95019500, 0x0f7c6b01, 0x84372006, 0x852320b3, 0x2b012f06, 0x2a80402a, 0x80402beb, 0x8056952b, 0x03835680, 0x40243182,
0xd5016b00, 0x21062b44, 0xef821300, 0x23152328, 0x15213735, 0x01821123, 0x40c04032, 0x15014040, 0x016b406a, 0x95404000, 0xff40ab95, 0x0022be82,
0x35830003, 0x22053941, 0x6a0f000b, 0x232008a7, 0x23203a82, 0x402f4383, 0xabfe8001, 0x566a2a01, 0xd5566a6a, 0x82d62b2b, 0x82ff2045, 0x85a18540,
0x000628fb, 0x25000015, 0x82213507, 0x22272501, 0x33363426, 0x2506664a, 0xc0012315, 0x6682ff55, 0x3223ab36, 0x2bab2332, 0x802b2a2b, 0x402a4055,
0x32463256, 0xebebeb2a, 0x5526b382, 0xab012b00, 0xe582d501, 0xab824382, 0x27152124, 0x438d3737, 0x0001ab27, 0x565600ff, 0x2743852a, 0x952b2b2a,
0x5555402a, 0x397d438a, 0x00032207, 0x26bf8213, 0x36211521, 0x4e352622, 0x333e08f7, 0x016b1415, 0xcad6fe2a, 0x2c354b6a, 0x6b352c3e, 0x354b552b,
0x2b1fabab, 0xabab1f2b, 0x9d820035, 0x00802c08, 0x01800155, 0x000b00ab, 0x23150100, 0x15330717, 0x27373521, 0x95800135, 0xff956a6a, 0x018b8b00,
0x6b6b40ab, 0x80802b40, 0x4304002b, 0x1b200efd, 0x0d4f4a18, 0x5f08407b, 0x012106b8, 0x24f4836b, 0x1100012b, 0x079a531a, 0x56569526, 0x9696d6d6,
0x6707aa6e, 0x411806d9, 0x05201685, 0x84063546, 0xfe401857, 0xfb401808, 0x112b220c, 0xfd401819, 0x2b552307, 0x0284402b, 0x19000123, 0xfc401811,
0x0a654108, 0x10000222, 0x3324e382, 0x17332727, 0x29076058, 0x01363413, 0x95767615, 0xb75480ab, 0x01193006, 0x80207540, 0x191100ff, 0x56011119,
0x62001911, 0xd52008f1, 0x0d300982, 0x1d001500, 0x00002500, 0x27262224, 0x22260633, 0x2005fb7f, 0x62078616, 0xdb4307fb, 0x25012d07, 0xda0d3b4a,
0x131a9e0d, 0x83131a13, 0xb1210584, 0x0961638c, 0x21298b24, 0xe8436121, 0x63d3200a, 0x03200c69, 0x2f066b41, 0x000300eb, 0x001f001b, 0x21352500,
0x15331315, 0x0d2e5a18, 0x2b055262, 0x23151733, 0xfe950135, 0x152bead6, 0x2d056b41, 0x12191912, 0x16aa2b15, 0xeaea6b6b, 0x18708001, 0x056d4106,
0xc02b2b25, 0x82006b6b, 0x670d6c55, 0x69004021, 0x042a05b5, 0x00001400, 0x27210737, 0x64181707, 0x21290a08, 0xb5151632, 0x602a014a, 0x0c15724a,
0x8060e024, 0xcb833560, 0x832a0121, 0x6b441805, 0x002b2b39, 0x01d5012b, 0x000d00d5, 0x43180100, 0xd5200d43, 0x24073942, 0x01191156, 0x083142ab,
0x7b6d1920, 0x33416f0d, 0x55006b2a, 0xab019501, 0x0a000600, 0x2608f182, 0x15231737, 0x21273523, 0x956b2115, 0x55805595, 0xd6fe2a01, 0x809696d5,
0x002bd680, 0x00550001, 0x01ab01c0, 0x82070040, 0x1533239f, 0x03823521, 0x2b80012c, 0x012baafe, 0x80400100, 0x8d855580, 0xc0018028, 0x1f00c001,
0x4f823800, 0x33143408, 0x26343532, 0x26262227, 0x21352323, 0x16142315, 0x14151617, 0x22230607, 0x26272627, 0x23343735, 0x15060722, 0x17161714,
0x35263423, 0x37343526, 0x82323336, 0xc8530822, 0x110d313e, 0x02040501, 0x538001cd, 0x43070103, 0x0f101915, 0xae271424, 0x030b2433, 0x620e1010,
0x22200804, 0x1f1e3531, 0x102436e8, 0x0202080e, 0x05012b2b, 0x3d121101, 0x07030613, 0x78321d0f, 0x0806162d, 0x050a0b0f, 0x0d010301, 0x181a2517,
0x83291c1b, 0x0055229d, 0x22c18240, 0x840300c0, 0x152126ed, 0x27072521, 0x77c78233, 0x002c05db, 0x2a405555, 0x56ab2b6b, 0x00d5d556, 0x59602382,
0x492d8307, 0x2f87057f, 0x28410320, 0x20368a05, 0x293b836a, 0xaa2a1501, 0x56565555, 0x0583d6fe, 0x00020022, 0x13206f8c, 0x17206f82, 0x5620388a,
0xc0223284, 0x6f89802b, 0xc0014037, 0x12009501, 0x1a001600, 0x32010000, 0x23061416, 0x37271523, 0x05444a15, 0x25352126, 0x11352115, 0x0139af82,
0x3232236b, 0x40402b23, 0x1a1a1130, 0x01e5fe11, 0x80aafe56, 0x46321501, 0x2b138232, 0x1a221a2b, 0x2a2a802a, 0x2a2ad6fe, 0x572a8382, 0xa9014000,
0x1400c001, 0x62182200, 0x272d0cf5, 0x32331633, 0x35262737, 0x07221727, 0x090a5427, 0x01722608, 0x132f1b37, 0x2c214021, 0x3c042f02, 0x534b0e25,
0x0e13b449, 0x40120e1f, 0x2f012320, 0xfea90102, 0x11301bc8, 0x05055407, 0x194a1429, 0x0621493b, 0x5405071f, 0xf3840506, 0x22052542, 0x46070003,
0x352005a5, 0x5520b482, 0x3d53a183, 0x00002205, 0x08e35f08, 0x2205e56b, 0x821e0012, 0x0026229b, 0x232f823a, 0x23172733, 0x2505f06b, 0x23353337,
0xfe823513, 0x08823520, 0x23240782, 0x07153315, 0x11240782, 0x05353315, 0x23200c83, 0x23200c82, 0x33201c84, 0x332d1282, 0x251c38e4, 0x49230f4b,
0x6022481e, 0x05b04f2b, 0x2a2ad62b, 0x012b2b2a, 0x802b2b80, 0x280485d6, 0x2a6d52f0, 0x2beac0c0, 0x210e82fe, 0x1f822a2b, 0x2082d620, 0x55202184,
0x2b2a2186, 0x0004002b, 0x012b004b, 0x975e01b5, 0x00132707, 0x17370100, 0x03822507, 0x08058753, 0x07152128, 0x01352315, 0x2d1e2d6a, 0x2d1ec3fe,
0x2a2a731e, 0x4000016b, 0x2d740180, 0x1e2e2e1e, 0x40801f2d, 0x406b6bc0, 0x38826a6a, 0x002b0029, 0x01d501cb, 0x821b0035, 0x1632280c, 0x22230614,
0x83062327, 0x22232903, 0x33363426, 0x36331732, 0x012a0383, 0x1f1f16a0, 0x3e0d2416, 0x0382480d, 0x0c8b2420, 0x1f350125, 0x82201f2c, 0x42068600,
0x654105c9, 0x8233200b, 0x15212d8e, 0xd6d65521, 0xaafe5601, 0x2b802beb, 0x35242383, 0xcb016b00, 0x22076748, 0x82231501, 0x35232324, 0x67482127,
0xcb013605, 0xd6404040, 0x406b1601, 0x4040016b, 0x6b409595, 0x0100ff40, 0x20378300, 0x0687442b, 0x2a002227, 0x36250000, 0x052b5635, 0x2628a983,
0x15233527, 0x14150606, 0x8205cf4c, 0x171624c5, 0x4a023315, 0x35080618, 0x5a431e01, 0x2d181b38, 0x3b022a02, 0x59251d39, 0x351c1739, 0x43032a04,
0x7db07639, 0x7e7db07d, 0x173d360d, 0x140f1b0e, 0x2a0f3928, 0x1b23062a, 0x210d1638, 0x0d83150d, 0x07cf6218, 0xff6d0120, 0x00072308, 0xa9861300,
0x2a016b26, 0x01754075, 0x82060849, 0x002b28a3, 0x01d50180, 0x6b25006b, 0x7e830649, 0x4d412320, 0x15332505, 0x33142223, 0x20052e43, 0x055f6b23,
0x2b3e1182, 0x23e03144, 0xb5233232, 0x16202016, 0x0909a2a0, 0x1a1a11b7, 0x2c1fe011, 0xcbcb1f2c, 0x6257c431, 0x152b2807, 0x2c1a2219, 0x822b2b3e,
0x00002d63, 0x01000255, 0x001200ab, 0x16160100, 0x0807224a, 0x37363427, 0x32333636, 0x299d0116, 0xfe2c3f3a, 0x424b35eb, 0x2d4c1530, 0x2a01583a,
0x2c2a3d03, 0x31354b3f, 0x30270549, 0x0b454149, 0x1a001222, 0x21080f4e, 0x94822634, 0x84270721, 0x08354198, 0x16602108, 0x0b161f1f, 0x2d1e2332,
0x261a0307, 0xb0031a26, 0x7db07d7d, 0x1f2c1fab, 0x1c253323, 0x26342601, 0x088f6318, 0x73640220, 0x00052b08, 0x37000018, 0x27072737, 0x9f912507,
0x1e8dd527, 0x011e2c6f, 0x26a58e12, 0x6e1e8d95, 0x8d4a1e2c, 0x225389aa, 0x82190006, 0x352326a9, 0x17231523, 0x25549137, 0x56406b01, 0xf98f6b40,
0x5555eb24, 0x518daa6b, 0x00000331, 0x00022b00, 0x0700ab01, 0x2b001300, 0x41130000, 0x0124068a, 0x27070137, 0x2006bf74, 0x09f76505, 0x23234408,
0x23263435, 0x36270722, 0xa5163233, 0x32322325, 0xf0fed023, 0x1b65011b, 0x4b35fa2b, 0x22013348, 0x1f2d3a29, 0x201a2621, 0x171f3144, 0x3a2f2720,
0x332b0158, 0x10013246, 0x1b9bfe1b, 0x34354b2a, 0x822b024a, 0x20372f82, 0x1a26121f, 0x44310b26, 0x49191f0d, 0xd9890000, 0x26001322, 0x84088341,
0x0706216b, 0x3b419285, 0x95012312, 0x6a84261a, 0x0b3e2823, 0x218b830f, 0x46411d01, 0x2680220e, 0x21648334, 0x83822530, 0x738afa8e, 0x25054d41,
0x33072733, 0x4d413315, 0x402b2613, 0x56406b6b, 0x245b8e72, 0x566a6aeb, 0x0d4e4195, 0xa5475382, 0x11b74605, 0x2a016b31, 0x2a01d6fe, 0x80559595,
0x95eb2b80, 0x4b808095, 0x552305ef, 0x8a019501, 0x3537262d, 0x23173723, 0x212d8415, 0x2d835555, 0x80562b22, 0x68182d82, 0x11240a99, 0x17130000,
0x260bc46f, 0x33363411, 0x70ab2bd5, 0x012509e7, 0x111a2bab, 0xc16c18d5, 0xa9491809, 0x00032409, 0x18000015, 0x4307a551, 0x3f83072a, 0x01173323,
0x0d0463ab, 0x802b8026, 0x0001d5d5, 0x2b20488a, 0x240b737d, 0x000f0007, 0x09375c21, 0x45183620, 0x578e0a27, 0x343b952a, 0x1a22663b, 0x401a221a,
0x802fa289, 0x1316952b, 0x16131717, 0x19221aab, 0x8c5a2219, 0x22af8966, 0x7b1d000b, 0x44180dbb, 0x21200705, 0x82060d4c, 0x409526b7, 0x2a40402a,
0xef511856, 0x2b802509, 0x40402bd5, 0xab210282, 0x05817d19, 0x12000126, 0x04002b19, 0x83082760, 0x001423bb, 0xdd7c0027, 0x7c152008, 0x078307dd,
0x0c4a5e18, 0x23153008, 0x33363435, 0x2b8a6115, 0x583e4f71, 0x1a2c3f2b, 0xab014026, 0x111a1a11, 0x80fe9595, 0x01111a2b, 0x50618a2b, 0x3e572b70,
0x262b3f2c, 0x4c80011a, 0x2b210593, 0x23938201, 0x05001a11, 0x12287388, 0x21001a00, 0x2e002900, 0x230a276d, 0x21113335, 0x07206085, 0x25268086,
0x26262315, 0x0e873527, 0x01219784, 0x206e8ac0, 0x2689842b, 0x14788001, 0x88563f5f, 0x8cc02090, 0x83952075, 0xd66b2691, 0x2314603f, 0x43978696,
0x03220b61, 0xf9821700, 0x35211523, 0x12d37e11, 0x56015526, 0x5500fe55, 0x2707a94c, 0xd5800119, 0x2b00ffd5, 0x20074f42, 0x20d382d5, 0x27d38202,
0x01eb012b, 0x000300d5, 0x41064378, 0x17200832, 0x3720ce82, 0x6107ff6d, 0x95240960, 0x952aaa2a, 0xd520c583, 0x2e05e863, 0x1a1100ff, 0x40151540,
0x0001111a, 0x8b001911, 0x611b2051, 0x3d480dbf, 0x18332005, 0x61095559, 0x538808b4, 0x0001ab28, 0x2a0100ff, 0x55831119, 0x2a2a2b22, 0x5584ab82,
0x2b000623, 0xd5511800, 0x054b5809, 0x00002f27, 0x23153301, 0x20038227, 0x20038237, 0x24038207, 0x11211105, 0x20668425, 0x420d8215, 0x212d0bbb,
0x15151632, 0x55000133, 0x6b6b8055, 0x26058480, 0xd5fe0001, 0x832a8001, 0x1a200800, 0x11d5fe11, 0x01111919, 0x2a1a112b, 0xd6801501, 0x40406b6b,
0x2a012a56, 0x2bd5d6fe, 0x2a2b2b2a, 0x2a09674c, 0x0003002a, 0x01150080, 0x82eb0180, 0x00132209, 0x6fe38217, 0x112712c7, 0x01153335, 0x83aaaa55,
0x22048538, 0x83d5d5c0, 0x206889d8, 0x215882fe, 0xd94e0000, 0xc76f1809, 0x07ff7741, 0x1900eb25, 0x65120000, 0x232206cf, 0xdc5e3335, 0x07c76605,
0xb0342608, 0x1a2670a0, 0x7c575540, 0x1a405557, 0x71eb0126, 0x261a964f, 0x573e2bab, 0xab2b3e57, 0x4f961a26, 0x00010000, 0x20e38240, 0x20e382c0,
0x96498d1d, 0x9580224d, 0x244f8b55, 0x2b261ad6, 0x28518d15, 0x002b000c, 0x01d5016b, 0x0aa55e95, 0x200b5b5e, 0x1d55183b, 0x07b35e09, 0x23351723,
0x240b8715, 0x35331537, 0x20038227, 0x44078617, 0x35290b3b, 0x01333634, 0x2a2a2a95, 0x21038216, 0x0583aa2a, 0x0d864020, 0xa5449620, 0x2b012309,
0x16822a2a, 0x56230285, 0x84962b2b, 0x8827820e, 0x66402014, 0x01370bb5, 0xbb008000, 0x59018001, 0x00000500, 0x17371713, 0x629e2707, 0x82801e62,
0x2a068411, 0x00010000, 0x018b00ab, 0x838b0149, 0x07252221, 0x21228227, 0x20824901, 0xa9621e22, 0x21830584, 0x8500b727, 0x85015501, 0x21438200,
0x21833737, 0x3c84b720, 0x0584a320, 0x80264182, 0x8001b700, 0x1f845501, 0x27211e83, 0x203a849e, 0x820584b7, 0x00402d1f, 0x01c00180, 0x00080080,
0x21150100, 0x64838382, 0xd2fec023, 0x2420834c, 0x2a15014c, 0x2208834d, 0x8202004d, 0x018028ad, 0x00890180, 0x4b090003, 0x272005ff, 0x80209184,
0xb583c782, 0x2b801e24, 0x0884cd2b, 0x000d0029, 0x0115002b, 0x82c001d5, 0x00062435, 0x750e000a, 0x222f0821, 0x2a002600, 0x3e002e00, 0x27250000,
0x72353733, 0x8e4105a2, 0x55002234, 0x078341aa, 0x23189141, 0x2bea5615, 0x26069151, 0x552b2b40, 0x84952b2b, 0x8a2b200e, 0x46402014, 0xd524064b,
0x01001a11, 0x0d41b782, 0x000a2405, 0x41330100, 0x2125070e, 0xfe2b9501, 0x050741bc, 0x01190124, 0x0a85806b, 0xdd820020, 0x80001522, 0x8024e782,
0x0c000300, 0x113d3183, 0x17372723, 0x21372707, 0xab012135, 0x1eb42a2a, 0x4d1e8080, 0x2f01d1fe, 0x00ff8001, 0x200d84e2, 0x2735822a, 0x012b006b,
0x00c00195, 0x337f7118, 0x5136002b, 0x08464608, 0x3e2f3651, 0x7f71183e, 0x0913490b, 0x203fb145, 0x068b4a03, 0xd582c020, 0xa3820720, 0x3525002f,
0x35171521, 0x33211523, 0x33352115, 0x27da8211, 0x56d6aafe, 0xfe2b0001, 0xaa2ac782, 0x40d5d5c0, 0x2b2b1515, 0x2f824001, 0x27055d4b, 0x000700c0,
0x0023000b, 0x2008e56d, 0x21388203, 0x71513311, 0x17451806, 0x12f72f0e, 0x0c120c0c, 0x55560196, 0x56fe111a, 0x4d461a11, 0x826b2009, 0x120c2e17,
0xeaea1e01, 0x1a11ebfe, 0x111a111a, 0x820683ea, 0x088d4904, 0x1920a383, 0x200b9f46, 0x74451835, 0x4623200d, 0x11290fa1, 0xd5d59501, 0x2b2bebfe,
0x0af74115, 0x220b5354, 0x5f370033, 0x232105b1, 0x06e74515, 0x7368b682, 0x4e5d8308, 0x3520069a, 0x21064b75, 0x10533533, 0x33152e05, 0x15233507,
0x35231537, 0x01d66b01, 0x2800822b, 0x2b2b1119, 0x112b2b2a, 0x270c8d19, 0x80552aab, 0x80d6d695, 0x34851a92, 0x822a5521, 0x50802021, 0xe92608a7,
0x0c000400, 0xe5831100, 0x34232d08, 0x21350336, 0x22061415, 0x16161326, 0x96eb2315, 0x56015757, 0xc0658c65, 0x0196573f, 0x6041a9e9, 0x5555dffe,
0x01656546, 0x4160086f, 0x6b204182, 0x2808176b, 0x00170007, 0x23112500, 0x13137611, 0xe070012a, 0x1a80569b, 0xaa1a2626, 0x802c0483, 0xd5fe2b01,
0x01151540, 0xfe1a26ab, 0x01241184, 0x00261a56, 0x97464f86, 0x000b2205, 0x7d4f851b, 0x32200899, 0x4705917a, 0x552d08cf, 0x131a53c0, 0x76131a13,
0x161f1f16, 0x840483ab, 0x82552057, 0x1a132f12, 0x1620ad01, 0x201696fe, 0x6a011620, 0x73712016, 0x00042f60, 0x02230000, 0x00dd0100, 0x00150012,
0xcc820022, 0xbd460120, 0x27560807, 0x15233533, 0x36343527, 0x33152533, 0x17001601, 0x35212707, 0x37343533, 0x27210527, 0x09eb0121, 0x04090c0c,
0x2b552e40, 0xeafe090d, 0x51effee5, 0x1b222b01, 0x2b86fe32, 0xc701270a, 0x012be7fe, 0x0c550144, 0x0d09d509, 0x2b6f9640, 0x250c0959, 0x514801e5,
0x2382d4fe, 0x0feb4025, 0x5a42270c, 0x1f24115f, 0x33002900, 0x180db756, 0x20078f56, 0x06bf4221, 0x33353325, 0x4d073715, 0x1720073c, 0x01270888,
0x2a202b40, 0x55012b20, 0x113b0663, 0xd5111a1a, 0x1511312b, 0x11152021, 0x3129281e, 0x29303129, 0x3e3d2d11, 0x842b802d, 0x1a6b2300, 0x24835511,
0x55240482, 0x15118655, 0x0d2e2582, 0x2d112424, 0x0300002d, 0x55004000, 0x2f47c001, 0x891a2006, 0x1625238f, 0x3b591516, 0x37252a0c, 0x2bd59501,
0x0b3b012a, 0x053a4a0f, 0x01111a27, 0x0fd4fe0c, 0x24628395, 0x0d170387, 0x21628675, 0x5418286d, 0xeb2a08ab, 0x0e000900, 0x00001200, 0x4b821701,
0x26073108, 0x17353526, 0x37363615, 0x15073523, 0x6ec00001, 0xc06e5252, 0x9508523b, 0x56eb0195, 0x14935980, 0x80599314, 0x6913bf95, 0x7a42bc43,
0x00070000, 0x260df96b, 0x0013000f, 0x85250017, 0x072e46a3, 0x23250787, 0x01152335, 0x065d4413, 0x37112108, 0x01163233, 0x2a2b2b6b, 0x2b2b2a2a,
0x2b802bd6, 0x1a011501, 0x1100ff11, 0x11ab801a, 0x5555c019, 0x80211982, 0x82008455, 0x012a2222, 0x06a06f40, 0x19800022, 0x6e05634d, 0x4c180949,
0x276e1457, 0x974f180c, 0x00042113, 0x2005df45, 0x24c582d5, 0x0019000f, 0x11177629, 0x06221329, 0x32331614, 0x79263436, 0xe6350f4b, 0x34262634,
0x3f581426, 0x6b3f583f, 0x12191912, 0x5a1a1a11, 0x38501811, 0x00012107, 0x26221c82, 0x1c828534, 0x01583f26, 0x1a221a17, 0x2a200282, 0x200c6370,
0x08377505, 0x1000082b, 0x21001800, 0x00003100, 0xe36a1813, 0x34162607, 0x14163236, 0x97461806, 0x8f888709, 0xd5803387, 0xa01912d5, 0x1f1f2c20,
0x32460d2c, 0x67334632, 0x8c821a22, 0x102f1936, 0xb3101717, 0x10161610, 0xabfe9501, 0x01111a2b, 0x202cb655, 0x20202782, 0x332c2382, 0x2419ee46,
0x44241818, 0xcdfe1017, 0x33302384, 0x02001710, 0x55001500, 0xab01eb01, 0x13000300, 0x2009af4b, 0x0a805703, 0xd6254b82, 0x1a115501, 0x20ca8201,
0x21f18280, 0xbc748011, 0x821a200a, 0x11002264, 0x263d821a, 0x01000040, 0x820002c0, 0x06cd4409, 0xcd442120, 0x07e54d0c, 0xfe9b012c, 0xab56c6ca,
0x1a26261a, 0x058300ff, 0x55016b2d, 0x1540abfe, 0x26d50115, 0x8380fe1a, 0x82012011, 0x20478305, 0x4451882b, 0x212106cf, 0x0fcf4411, 0x952f5588,
0x1a93c0fe, 0x131a1313, 0x1f1f16b6, 0x83d5fe16, 0x71598405, 0x0121057e, 0x201482d8, 0x2514836a, 0x1f169601, 0x0b550400, 0x00052608, 0x0011000b,
0x2d698217, 0x26220614, 0x26223335, 0x15333634, 0xff821632, 0x29052f6b, 0x60450001, 0x4530eb46, 0x03833045, 0x01210b82, 0x20088600, 0x221887eb,
0x4e020000, 0x0320081b, 0x1805c945, 0x4c164766, 0x012a06f1, 0xaa6b1119, 0x1a1a116b, 0x4a419511, 0x0a07760a, 0x55000222, 0xab2a9182, 0x07000002,
0x00001300, 0xf7851412, 0x0714162b, 0x26272307, 0x33373734, 0x053e7817, 0x1541e025, 0x834115aa, 0x35013004, 0x6a4b4b6a, 0x34a42e4b, 0xa8327a7a,
0x827a7a32, 0x088d5b40, 0x00001829, 0x23153325, 0x82072735, 0x37332304, 0x866c2635, 0x07062707, 0x556b0115, 0x0282556b, 0x13562608, 0x26342618,
0x6bab1318, 0x415a5a41, 0x0744556b, 0x261a1520, 0x20151a26, 0x00004407, 0x002b0004, 0x01c001c0, 0x08bf4b40, 0x35250023, 0x058e5833, 0x27280782,
0x01211521, 0x00ff6b55, 0x6a270282, 0xfe95016a, 0x842bc06b, 0x2b802400, 0x42050000, 0x1b240c63, 0x37002900, 0x5b15b777, 0x3724071f, 0x14151615,
0xa682aa83, 0x27353722, 0x08071f43, 0x3336342d, 0xc0011521, 0x0e086a55, 0x0880080e, 0x77080d0d, 0x1a13131a, 0x16164a13, 0x80151555, 0x1a115555,
0x8001111a, 0xd5abab80, 0x83d5080d, 0x08d52324, 0x2082ca0d, 0x621a1331, 0x1c1b1426, 0x13262614, 0x26131c1d, 0x4e00ff80, 0x1a200558, 0x25054950,
0x01eb0180, 0x43620080, 0x002b2305, 0xcb7f0000, 0x208d8706, 0xc14c1827, 0x0f09460a, 0x1c920127, 0x121c1212, 0x22878442, 0x822b4040, 0x06fd4502,
0x8c848020, 0x1c820020, 0x521c1222, 0x19230584, 0x8240402a, 0x1a952202, 0x05114e11, 0x001a1123, 0x08e36f03, 0x7a180b20, 0x6d896255, 0x1720eb83,
0xc074e982, 0x10975c06, 0x34264026, 0x60342626, 0x210a8b5c, 0x11831a01, 0x5ceb2621, 0x00210c82, 0x06274e02, 0x0700d52d, 0x00001a00, 0x27273725,
0x18170707, 0x18089d4c, 0x230be75a, 0x28585828, 0x95280383, 0x111a1a11, 0x55404055, 0xed200783, 0x28231284, 0x18400158, 0x230fd15a, 0x006b0001,
0x25ef4918, 0x27828020, 0x2805af4b, 0x15330100, 0x06231523, 0x05955606, 0x0117323b, 0x01559500, 0x28253604, 0x11283838, 0x40c0010f, 0x383124eb,
0x00063850, 0x0877410e, 0x13db5d18, 0x5f005728, 0x6f006700, 0x8b610000, 0x32172707, 0x22231415, 0x27413435, 0x8605200f, 0x201f8717, 0x20238227,
0x21138233, 0x1a763206, 0x200f8705, 0x86278f07, 0x07db610f, 0x2d05f645, 0x22013426, 0x120c0c12, 0x0a0a160d, 0x7b41660b, 0x8240200b, 0x820b2010,
0x0b352403, 0x84130a0b, 0x20118322, 0x200d824b, 0x2003824a, 0x23038236, 0x0d0d1241, 0x05821884, 0x0984eb20, 0x30833e20, 0xae414b20, 0x0a23210b,
0x55202882, 0x80201683, 0x20200483, 0x0d226982, 0x0f882c12, 0x09834020, 0x23839520, 0x40844a20, 0x1f846220, 0x0e000022, 0x41084544, 0x1d38052b,
0x29002500, 0x39003100, 0x49004100, 0x55004d00, 0x65005d00, 0x22240000, 0x2005eb5e, 0x25078e26, 0x33342217, 0x09411432, 0x21252407, 0x41052115,
0x298e0725, 0x03243987, 0x02152135, 0x06201b86, 0x0121078e, 0x84e5871e, 0x820c209d, 0x82402005, 0x27b583d5, 0x8001cbfe, 0x2b0180fe, 0xac200e82,
0x0c222483, 0x25631a5d, 0x014b2209, 0x05ca4c80, 0x1a8a0c20, 0xe7849520, 0x12844920, 0x0d260582, 0x1657120d, 0x4b835616, 0xf52b7524, 0x08820a0b,
0x3e272084, 0x12121c12, 0x8313431c, 0xf8fe254e, 0x00012b2b, 0x61207b84, 0x6c203784, 0x36081684, 0x00120000, 0x01350035, 0x00cb01cb, 0x000d0005,
0x00190013, 0x00270021, 0x0054002f, 0x0062005a, 0x0072006a, 0x0080007a, 0x008c0086, 0x00a00098, 0x15323600, 0x41352214, 0x172607ff, 0x22231432,
0x138c2634, 0x0d842420, 0x24074942, 0x07013703, 0x053b6627, 0x33363426, 0x06271732, 0x2105db65, 0x15893736, 0x46851720, 0x32411220, 0x0742410e,
0x2c075e41, 0x34352216, 0x22271532, 0x14323334, 0x24058433, 0x27262607, 0x057b4835, 0x86362321, 0x1635253d, 0x0c124216, 0x6a24e282, 0x960a0b0b,
0x01310c87, 0xe916164a, 0x120d0d12, 0x011b8b0c, 0x01501c5b, 0x2b0c820c, 0x3c020409, 0x0d0c1202, 0x3c0b1013, 0x0c281082, 0xa506090c, 0x690b0a0a,
0x41823e84, 0xb7200288, 0x0d241183, 0xf61616e0, 0x4b201e82, 0x0f295782, 0x1301100a, 0x0d13131a, 0x24538409, 0x0a0a0be0, 0x282d8440, 0xea16163e,
0x400b0b0a, 0x2031830d, 0x29168802, 0xfe1b0701, 0x02511ba5, 0x99830904, 0x0b3c0127, 0x0c0d1310, 0x217d8212, 0x93830904, 0x16f40125, 0x84200116,
0x42622040, 0x9f200ac2, 0x57201184, 0x8a214582, 0x26008216, 0x0a1001aa, 0x82130d05, 0x84602077, 0x00002218, 0x08bb4118, 0x0805e142, 0x25001f2b,
0x33002d00, 0x43003b00, 0x53004b00, 0x63005b00, 0x6f006900, 0x7b007500, 0x89008300, 0x97009100, 0xa7009f00, 0x0000af00, 0x06e94300, 0x4107c941,
0xd14307af, 0x05924107, 0xf5410d87, 0x8e262005, 0x0f054433, 0x8a411f87, 0x05aa4107, 0x23420320, 0x2237240a, 0x45323334, 0x162106bb, 0x05d04114,
0x2507ab44, 0x14153206, 0x71873522, 0x01215b8f, 0x0a14431e, 0x0d123f26, 0x080c120d, 0x762d1184, 0x020b0a0a, 0x120c0c12, 0x1616a00d, 0x10ba413e,
0x11840c20, 0x2a84a320, 0xa4442920, 0x420b2008, 0xf620051b, 0x01200682, 0x8b234b84, 0x43fe1616, 0x3620057c, 0x41073242, 0x088208fd, 0x134b0122,
0x4a434183, 0x844d2005, 0x84c22019, 0x16ed2311, 0xa5414a16, 0x43c02008, 0xbb410a90, 0x05cd4105, 0x2a841720, 0x1d848920, 0x68823e20, 0x16169627,
0x0a0a0b95, 0x203b8be0, 0x241d846a, 0x0b0b0a54, 0x21ca8215, 0x3f8b120d, 0x230ae377, 0x36000007, 0x2705f042, 0xb07d2b22, 0xa8b07d7d, 0x7d200483,
0x6b2c2182, 0xab012b00, 0x0d00d501, 0x32130000, 0x3305375e, 0x26343636, 0x59d53627, 0x3a597d7d, 0x39393130, 0xd5013031, 0x1c263482, 0x6374631c,
0x33821c1c, 0x2b008024, 0x33939501, 0x7d58c02b, 0x1e22587d, 0x42535342, 0x2733841e, 0x8e711409, 0x00091471, 0x09354218, 0x1d000d22, 0x2207235b,
0x82160722, 0x16072170, 0x0ff94218, 0x3500012d, 0x1a354b4b, 0x2929211b, 0x18c51b21, 0x2b0b9742, 0x4b6a4b80, 0x4c3f0f0c, 0xc70c0f3f, 0xa2954218,
0x43180320, 0x43180a2b, 0x40215b91, 0x054f6400, 0x1b000d26, 0x17010000, 0x26082d4f, 0x37173717, 0x82072715, 0x34352901, 0x32213336, 0x40800116,
0x2305324f, 0x95565540, 0x55200382, 0x01300e82, 0x011a112a, 0x1161400c, 0x8c111a1a, 0xde565640, 0x56210483, 0x200f8341, 0x3f7b1800, 0x00c02408,
0x82160009, 0x14162b5b, 0x37270707, 0x04173236, 0x66831632, 0x3227223b, 0x01343536, 0xbf0606ba, 0x1206bf3b, 0x34defe06, 0x34233226, 0x011b0f21,
0x830e829d, 0xe5062b14, 0x32231a26, 0x1a13172b, 0x85480600, 0x000c3e0a, 0x00190012, 0x0025001e, 0x36363700, 0x23061737, 0x07332722, 0x17372626,
0x34352623, 0x275d8205, 0x37272707, 0x16163723, 0x363b7182, 0xd2173233, 0x4e154e04, 0xb7154c3b, 0x432e4fcf, 0x04a06c20, 0x3804a601, 0x839b0666,
0x02f4210e, 0x19301983, 0x23880730, 0x87953087, 0xbbff4711, 0x28531813, 0x3d230382, 0x82150bb0, 0x024f260f, 0x00053087, 0x287f8203, 0x01d50155,
0x000700d5, 0x0b11541b, 0x17331322, 0x4e104566, 0xd429079c, 0x583f3f58, 0x27802b3f, 0x095b5744, 0x28234427, 0x38282838, 0x24188295, 0x0101583f,
0x05d14f2a, 0x01111a26, 0xc71a1100, 0x282a1983, 0x6b000400, 0x95010000, 0x6b820002, 0x27001f22, 0x00297982, 0x36341513, 0x35151632, 0x29048235,
0x23061411, 0x35071723, 0x1f5a3523, 0x07356709, 0x15331127, 0x44499523, 0x256f8349, 0x6a404096, 0x0983406a, 0x19227c2f, 0x6a1a2219, 0xe0d5016a,
0x181e1e18, 0x06c266e0, 0x2b404023, 0x2d0a822a, 0x1a112a01, 0x1a221aab, 0xe6fe221a, 0xe982002a, 0x08247d87, 0x24002000, 0xe34b8982, 0x4f162006,
0x7c8e085a, 0x74821320, 0x6383be82, 0x8d7d1921, 0x82962079, 0x1a802174, 0x225c7e84, 0x22748a06, 0x822a55fe, 0x05cb61e1, 0xeb58eb20, 0x5833200c,
0x235111e1, 0x33132607, 0x06142311, 0x079c5323, 0x34353329, 0x32333336, 0x82151516, 0xab012204, 0x2200822b, 0x822a2a2a, 0x562b2605, 0x111aaaaa,
0x2d8e83ab, 0x55090c16, 0x11150d09, 0x2b40011a, 0x028dc02b, 0xfe150123, 0x2b2383c0, 0x1a114001, 0x0d0d0915, 0x001a1509, 0x28092578, 0x00110008,
0x0023001a, 0xb345182b, 0xd2401809, 0x5c072009, 0x332205c3, 0x2e5a0715, 0x089b4a07, 0x1a2b952a, 0x11555511, 0xd5552b1a, 0x0b830984, 0x32469d26,
0x6b324632, 0x01211684, 0x211f8355, 0x0c842b2b, 0x8355d521, 0x82952023, 0x4632211c, 0x2a0ac16d, 0x000f0007, 0x00210018, 0x5633002a, 0x2b47097f,
0x60411808, 0x268d9110, 0x1a1a22ef, 0x84081a22, 0x92ea2076, 0x82d52090, 0x221a221d, 0x20778466, 0x7d9697b8, 0x082f0bd3, 0x1d000d00, 0x33130000,
0x21152111, 0x68352622, 0x2b2e147e, 0xfe2b012a, 0xc01911d5, 0x56000140, 0x9e5cbf3f, 0x111a3105, 0x19110001, 0xd5fe8001, 0xab11192a, 0x1b4f6a55,
0x2405f14d, 0x11191911, 0x0a6f4100, 0x20075348, 0x09594e34, 0x614e2620, 0x07574c0e, 0x45443720, 0x22232405, 0x44141506, 0x262a054f, 0x68013634,
0x1a13131a, 0x05842d13, 0x0b8a5720, 0x714f952e, 0x0e252c3f, 0x0e121012, 0x01707050, 0x47056a4e, 0x3083055b, 0x1a135308, 0x121c1268, 0x64ae1c12,
0x133e2c47, 0x0c140b0d, 0xa070120e, 0x00020070, 0x01400040, 0x00c001c9, 0x00150003, 0x27373700, 0x07162507, 0x27071707, 0x37352307, 0x37173727,
0x94173236, 0x01ac29ac, 0x430f0f4f, 0xbf1e1e29, 0x1e1ebe65, 0x12064329, 0x15826b06, 0x1485f420, 0xbf65be22, 0x06201484, 0x240a5354, 0x0010000d,
0x0b135f1e, 0x23111729, 0x07350335, 0x82333513, 0x07dd4208, 0x1195012e, 0x6a111a1a, 0x6a566a6a, 0x6a2b2b6a, 0x01200c83, 0x2c06f45e, 0x150180c0,
0x80c0fe2b, 0x2b400180, 0x07c643fe, 0x0fa95a18, 0x55181b20, 0x5b18111b, 0x042032c1, 0x085b5b18, 0x0f000722, 0x20050f6f, 0x06954124, 0x2c078f42,
0x17161406, 0x34262615, 0x06153736, 0x0a1b7817, 0x7c020123, 0x2e831857, 0x2e552e08, 0x48483827, 0x40fc2738, 0x40402a40, 0x3417826b, 0x70fe7c57,
0xa07070a0, 0x12495824, 0x7a64142e, 0x122e1464, 0x231c8320, 0x0200402a, 0x08c18118, 0x22056d53, 0x50152135, 0x95241051, 0x2a01d6fe, 0x2309106d,
0xd5aaaaab, 0x830a3150, 0x01552141, 0x09a57318, 0x121f4118, 0x418e0120, 0x1813ae53, 0x250af147, 0x00190010, 0x75183700, 0x3526092f, 0x35333523,
0x06831333, 0x1516322b, 0x56019515, 0x11d62a56, 0x33058319, 0x1911abab, 0x56562a95, 0x2ad61119, 0xabd5fe56, 0xab11192a, 0x6b20d384, 0x95209182,
0x0d377418, 0x22087547, 0x8f333634, 0x18952091, 0x830f2344, 0x0f6f18d5, 0x00132307, 0x17412500, 0x80c02822, 0x111aab80, 0x841a1180, 0x47858404,
0xc75405f5, 0x07c76d0c, 0x85921120, 0x20051e56, 0x08345755, 0x1a112a25, 0x4e040000, 0x082008ed, 0x21062745, 0x45180100, 0x132007ef, 0x2007a044,
0x051c4527, 0x82023d21, 0x15333055, 0x01231523, 0x2b1a1195, 0x1a2b5555, 0x52d55511, 0x0c820586, 0x82c00121, 0x2b55230e, 0x1183abfe, 0x27831d87,
0x33410020, 0x07ff6d44, 0xb382c020, 0x18000829, 0x17250000, 0x18173723, 0x2613ff61, 0xea4b2a01, 0x42a62a3a, 0xfa250d57, 0x43334c65, 0x08781801,
0x709b8211, 0x25210c31, 0xfd661811, 0x0d464124, 0x5b180220, 0x8d410885, 0xff802419, 0x18000100, 0x20070f44, 0x1454561a, 0x00030029, 0x018b002b,
0x478b01d5, 0xc3760649, 0x15212105, 0x2b240184, 0x56feaa01, 0x8b250388, 0x402b402b, 0x59bd822a, 0xab200537, 0xb95f0982, 0x21253105, 0x78788803,
0x8001c8fe, 0xd58001c0, 0xaafe2bd5, 0x613fbf6d, 0x022e09b3, 0x16000600, 0x00002200, 0x13011125, 0x72183315, 0x222c090e, 0x34113526, 0x23133336,
0x33353335, 0x26053b44, 0xaafeab01, 0x49c08016, 0xeb300935, 0x2a2b2b2b, 0x01552b2a, 0x01aafe56, 0x402a2a40, 0x210b2a58, 0x1d82c0fe, 0xcf832b20,
0x80005526, 0x95019501, 0x0a206982, 0x23396782, 0x37350735, 0x15330533, 0x2a950123, 0xfe066440, 0x80ababc0, 0x242416e3, 0x202b8380, 0x5a2b822b,
0x20230533, 0x82130000, 0x32252524, 0x06071415, 0x07200182, 0x45080c82, 0x37363735, 0x27343536, 0x15222326, 0x36373423, 0x01aaaa2b, 0x07045634,
0x3d171104, 0x1259b87f, 0x0a02070d, 0x182e2e1c, 0x2a150119, 0x0b0e4baa, 0x171b0613, 0x61202442, 0x100c1612, 0x311a050d, 0x00191824, 0x8f830002,
0x8f84ab20, 0x8f881220, 0x1e450720, 0x2bab2a0b, 0xd6076440, 0x562a5656, 0x20998456, 0x2109832a, 0x3d4b562a, 0x01802205, 0x223b82d5, 0x8230000b,
0x20348a9f, 0x219e8d17, 0xa0840607, 0x33363727, 0x17161732, 0x26c38616, 0x2b5555ab, 0x84d65555, 0x0b0838aa, 0x0e15140a, 0x0e182e0b, 0x1216120f,
0x17071412, 0x0e050c10, 0x856b0109, 0x84c7206c, 0x0f0d37b6, 0x0e0d0f10, 0x1824180b, 0x0506050e, 0x23140708, 0x05141a18, 0xc5820910, 0x8000a824,
0x89825901, 0x2900152d, 0x34010000, 0x26272627, 0x82060722, 0x14152b77, 0x32331617, 0x35353637, 0x7d833407, 0x23151523, 0x20188314, 0x08228322,
0x2b013544, 0x070a040b, 0x040a0716, 0x0b07190b, 0x840c0b15, 0x07114158, 0x0e0e1801, 0x0e102810, 0x2801180e, 0x06061128, 0x06060404, 0x38392811,
0x1211040f, 0x74073928, 0x2c1c1a3e, 0x05101f3b, 0x10050606, 0x7d583f1b, 0x0003240a, 0x42190013, 0x3158053f, 0x0baf4405, 0x23351326, 0x25153335,
0x28069848, 0xfec00111, 0x112b01d5, 0x07ac641a, 0x552b962d, 0x5501ebfe, 0x1a11abfe, 0x822b0195, 0x6456201b, 0xfe250bc6, 0xd52aabd5, 0x06045ad5,
0x1429718a, 0x28001800, 0x00003100, 0x06e94925, 0x2407e745, 0x23230614, 0x133d4415, 0x09ad8818, 0x19806b2c, 0x55552b11, 0x111a1912, 0x8c8dab2b,
0x88855520, 0x822beb21, 0x2a2b281d, 0x122b1218, 0x91562a19, 0x87562095, 0x26918a90, 0x00210018, 0x82350025, 0x21828391, 0x90833335, 0x3221948a,
0x0a024116, 0x2513ed46, 0x55111a6b, 0x97842b55, 0x0d0d1325, 0x85d5fe13, 0x8e01208a, 0x12eb25a1, 0x2b2a2b19, 0x20259b83, 0x0d13130d, 0x2189868a,
0xa59100ff, 0xa1410020, 0x821c200e, 0x894818a1, 0x081a4114, 0x23170524, 0xa0411737, 0x0613410f, 0x4c3f0125, 0x412a3beb, 0x0c4112a2, 0x64712307,
0x718e324b, 0x48181d20, 0x352518fb, 0x15333523, 0x1b174233, 0x8255ab21, 0x070541e6, 0xfe257692, 0x558055d5, 0x131b4255, 0x1a001126, 0x2e001e00,
0x230c8941, 0x33152315, 0x25258241, 0x2b568055, 0x7e411a11, 0x2a80251c, 0x8012192b, 0x211c7941, 0x51180005, 0x032b0701, 0x1b001700, 0x34002b00,
0x82010000, 0xb94c18f1, 0x86332007, 0x14152291, 0xec681806, 0x08934114, 0x2b150128, 0x1919112b, 0x96835611, 0x80111a22, 0x2414b042, 0x2a2a1501,
0x21938255, 0x9a831812, 0x19122a23, 0x110e422b, 0x5c08b442, 0x062e0935, 0x1a000a00, 0x00002300, 0x23372325, 0x37433335, 0x2a15251e, 0x55805555,
0xc0247f94, 0xd62a2aab, 0x0021729a, 0x0a0f4106, 0x25000728, 0x39002900, 0x11414200, 0x41272005, 0x98600a15, 0x06366107, 0xce430686, 0x2b15211d,
0x11290082, 0x0d0d1319, 0x2b111913, 0x41088412, 0x562e1b27, 0x19ab2b2b, 0x130d2012, 0x12200d13, 0x09871818, 0x201c3241, 0x15cf4100, 0x70183520,
0xf14f0a03, 0x34352106, 0x15de4f18, 0x2109cf41, 0xa4822b40, 0x55111a28, 0x19112b55, 0xde431119, 0x076c430e, 0x552c2482, 0x12801218, 0x192a2b19,
0x18122b12, 0x4113df43, 0x9d8a08d0, 0x1f000f2f, 0x37002300, 0x00004000, 0x11213501, 0x22a18221, 0x82233523, 0x1533219b, 0x5e072250, 0x1724076b,
0x17233533, 0x4107ab44, 0x27200a78, 0x220da945, 0x822b2a2b, 0x09af4502, 0x15155628, 0x40111a40, 0x12831540, 0xbb450482, 0x40012606, 0x80d5fe80,
0x212c822a, 0xc045ab2b, 0x15ab220b, 0x28c48255, 0x15121915, 0x12191912, 0x06344340, 0x0adb5e18, 0x13000328, 0x00001600, 0x4b411125, 0x0b394605,
0x33071726, 0x95959501, 0x8209444c, 0x016b230c, 0x7e18802a, 0xab210c4f, 0x0da54eaa, 0x19001028, 0x2b002200, 0x9d780000, 0x4f172007, 0x1161228f,
0x05105005, 0x200d1a50, 0x05435c01, 0x844faf20, 0x09136718, 0x2a001722, 0x2b0d2770, 0x15161607, 0x22263423, 0x33161406, 0x291b2b70, 0x3529243a,
0x3246322b, 0x2d702332, 0x0b2f2517, 0x33232c45, 0x5d123170, 0x8482060b, 0x0a000331, 0x00001d00, 0x21152101, 0x27231117, 0x6d112307, 0x986e0702,
0x17372e08, 0x00ff8001, 0x602b0001, 0x01614b4a, 0x09c24956, 0x5555562a, 0x2bd55501, 0x4b4b2b01, 0x210f8047, 0x30825555, 0x8000153a, 0x8001eb01,
0x00000600, 0x37211301, 0x01273717, 0x2afec02b, 0x3c226080, 0xab255183, 0x00511980, 0x0ae14303, 0x1c001322, 0x870d336d, 0x09054382, 0x820e0548,
0x1601487f, 0x0809e542, 0x2c000928, 0xd4012c00, 0x0500d401, 0x11000b00, 0x1f001900, 0x2b002500, 0x37003100, 0x37370000, 0x26151716, 0x17373637,
0x05820706, 0x07063323, 0x06595826, 0x1716072c, 0x37272607, 0x36230706, 0x08820537, 0x17162608, 0x27260727, 0x06071635, 0x37362707, 0x2f251e79,
0x242f693f, 0x723f331f, 0x062b061c, 0x34266529, 0xc3342626, 0x86821806, 0x4e012109, 0x29850c85, 0x331e2525, 0x831e5b3f, 0x8425202a, 0x266b2516,
0xa1333e2d, 0x26213383, 0x20468455, 0x2250827e, 0x832f7233, 0x8a902027, 0x00002227, 0x28a98202, 0x01cf0111, 0x000700ef, 0x09fd4f40, 0x3634072d,
0x26262737, 0x16173635, 0x82352617, 0x1616310c, 0x36071415, 0x14173637, 0x020e0706, 0x17021e07, 0x06231182, 0x82272627, 0x82d68217, 0x08cc8223,
0x46dd0624, 0x32463232, 0x12252d7a, 0x4040221e, 0x23020809, 0x02231d1d, 0x40400908, 0x07021e22, 0x06030306, 0x198e0207, 0x3082ab20, 0x46322608,
0x0c452654, 0x213b1209, 0x07042525, 0x3b23060e, 0x233b1111, 0x04070e06, 0x3b212525, 0x03040112, 0x04030101, 0x221f9301, 0x45090000, 0x0b200cc5,
0x0c978018, 0x35370029, 0x37271533, 0x82370717, 0x07fb5903, 0x1533172c, 0x27073723, 0x23152737, 0x07820735, 0x07820720, 0x9d2aeb33, 0xa62e1e2e,
0x841e2e1e, 0x34262634, 0x8080ab26, 0x2210821d, 0x82272a55, 0x80012512, 0x81808015, 0x02820e82, 0x82c81e21, 0x3426241d, 0x827f2a05, 0x8063230c,
0x1f829180, 0x2a2a7336, 0x40000300, 0xda011500, 0x0200d501, 0x11000a00, 0x33010000, 0x2b087782, 0x07232723, 0x33213723, 0x35033307, 0x32670123,
0x29451519, 0x290f440f, 0xd5d5fe45, 0x40955555, 0x2a4e5d01, 0xc02b2bc0, 0xc000ffc0, 0x5805c34b, 0x052205ed, 0x41820e00, 0x27072c08, 0x27073335,
0x07270701, 0x27352335, 0xb5216b01, 0x01cf56d6, 0x4d581b4f, 0x2b016a40, 0xaa2eb539, 0x1bb0fe95, 0x4fc08359, 0x1801006b, 0x2308615e, 0x13000006,
0x95287085, 0x965656d6, 0xaad50140, 0x09205d84, 0xc03fa184, 0x0400eb01, 0x0c000800, 0x14001000, 0x27001900, 0x2f002b00, 0x35250000, 0x27061433,
0x83153335, 0x82132003, 0x11072907, 0x32131133, 0x21231516, 0x2705874f, 0x23153311, 0x25352622, 0x03201a82, 0x01340382, 0x111a2b95, 0x2a2b802b,
0x802ad52b, 0xfe2b1a11, 0x55111aab, 0x11230082, 0x8255011a, 0x2b403316, 0x2aab1a11, 0x2b2baa2a, 0x2b2b00ff, 0xfed60180, 0x2182012a, 0xd6202883,
0xd5203882, 0x00221785, 0x11500a00, 0x410f2008, 0x8d8306b7, 0x3f00332d, 0x47004300, 0x35010000, 0x83331521, 0x05974901, 0x46153521, 0x15210539,
0x44078223, 0x17200f48, 0x2006ab70, 0x83308327, 0x35233120, 0x33151733, 0x15232135, 0xfe950133, 0x2b2b2ad6, 0x137f0282, 0x23138210, 0x552b2bab,
0x80291d85, 0x2a00ff2a, 0x8015012a, 0x212a8580, 0x00842b95, 0xc9580120, 0x111a2506, 0x1a112a01, 0x20055f68, 0x8200832a, 0x0000221d, 0x088f4f08,
0x450fef60, 0x295c08ed, 0x10c95c07, 0x1806105e, 0x870fbf7e, 0x22c42c27, 0x19221a1a, 0x1919226f, 0x836f1a22, 0x3b1a210b, 0x91200b84, 0x11b17e18,
0x19211e84, 0x05975701, 0x2f823c20, 0x3c221a22, 0x19233b82, 0x831a3b22, 0x8bc4202c, 0x221d8a05, 0x82000900, 0x01200800, 0x00e501e5, 0x00070002,
0x0010000c, 0x00160013, 0x00240020, 0x2500003d, 0x35072733, 0x27152327, 0x22080483, 0x15233517, 0x17331511, 0x01033315, 0x22212707, 0x27113526,
0x35331505, 0x21272321, 0x11151632, 0x6a233527, 0x07860650, 0x1f550126, 0x4a0c2a1f, 0x563e0282, 0x1f611f56, 0x1bca01d9, 0x11b6fe2b, 0x55012b19,
0x1f00ff56, 0x114a012b, 0x2b1f2a19, 0x0485564a, 0x4a232d82, 0x8380560c, 0x56562303, 0x31821f01, 0xfe100136, 0x192b1b36, 0x2b4a0111, 0x2a56561f,
0xb6fe1119, 0x562a1f2b, 0x04830d82, 0x0a000022, 0x1808e359, 0x2709f146, 0x001b0017, 0x0023001f, 0x180a1158, 0x200f7384, 0x83c88203, 0x42038313,
0x01220f45, 0x008356ab, 0x058a2a20, 0x820b9346, 0x805622b9, 0x21028356, 0x06840001, 0x098a0c82, 0x0df45818, 0x0004003a, 0x011e001e, 0x00cb01cd,
0x001d0014, 0x00300021, 0x01161300, 0x35232707, 0x09f64c18, 0x33353334, 0x27231727, 0x15163233, 0x15372715, 0x23073533, 0x0d843527, 0x82071421,
0x35232a17, 0x18360162, 0x202048a2, 0x0802822b, 0xf775083d, 0x0d282008, 0x2b602013, 0x4b18082b, 0x1313130d, 0x01181320, 0xcdfe63cb, 0x2049a217,
0x80353569, 0x95752b2b, 0x290d1320, 0x15150920, 0x13691760, 0x0717150d, 0x00002b2d, 0x66400005, 0x0d240863, 0x1d001900, 0x4805a358, 0x152905df,
0x23230614, 0x33350735, 0x06384315, 0x35051525, 0x85331523, 0x83138281, 0x1501238f, 0x70822a2a, 0x404a0d22, 0x01238b84, 0x844b2b40, 0x8220207d,
0x40e02886, 0x0d136040, 0x82130d40, 0x8380207e, 0x150a2d84, 0x2d0a1415, 0x13802b2b, 0x0003000d, 0x4307a947, 0x0020051f, 0x0fcf6518, 0xb35f2420,
0x225a2306, 0x7f581919, 0x01332706, 0x4b4b6a21, 0x72584b6a, 0x825d200b, 0x6a4b220f, 0x564f9100, 0xe7450f5b, 0x48012607, 0x46323246, 0x20498533,
0x460b84a3, 0xa320056c, 0x20214984, 0x2a128332, 0x00070000, 0x012a002a, 0x82d501d5, 0x000b3059, 0x001b0013, 0x0027001f, 0x2500004c, 0x77072737,
0x455807af, 0x075d5807, 0x1b822720, 0x06221628, 0x36321614, 0x48181734, 0x0721096a, 0x6f481806, 0x34262707, 0x32363737, 0x04841717, 0x07141634,
0x4e4e6301, 0x0d121e4d, 0x490c120d, 0x120c0c12, 0x0b841f0c, 0x4d4d2424, 0x0f84bb4e, 0x06556531, 0x09065c06, 0x5554060a, 0x5d061206, 0x82550606,
0x825d2010, 0x5455230a, 0x19821306, 0x3f820620, 0x5f7a4e21, 0x1f200abe, 0x1f250b84, 0x234e4d4e, 0x204b830c, 0x83379634, 0x825c2047, 0x0b995342,
0x3d0d4218, 0xdb5c0620, 0x00ab2206, 0x0a6d4703, 0x2014c54f, 0x06514217, 0x37200783, 0x3d790b82, 0x2bab270f, 0x2ad52b2a, 0x47572a2a, 0x2b802112,
0x56240082, 0x2b562a2a, 0x0dfb4418, 0x1200062e, 0x00002200, 0x33352325, 0x37011117, 0x22051e46, 0x4b352335, 0x012d11aa, 0x2a6b6b6b, 0x2b0ad6fe,
0x202b2b20, 0x0ab14bf5, 0x014a2022, 0xf5201782, 0x2b221683, 0xa456602b, 0x4201200c, 0x574a08ad, 0x4606201b, 0x072a08b7, 0x14000c00, 0x24001c00,
0x93822900, 0x33363427, 0x15062215, 0x20078333, 0x280c8623, 0x23061403, 0x35363235, 0x20078633, 0x20078323, 0x07097901, 0x1679eb20, 0x83802008,
0x26803209, 0x573e401a, 0x1a2c3f2a, 0x8a614026, 0x0150702b, 0x840e8480, 0x5a13820b, 0x6f4a0afb, 0x002d2505, 0x01000033, 0x07227683, 0x06832717,
0x0714032f, 0x07353627, 0x27070137, 0x34231506, 0x82058737, 0x830b8283, 0x84372005, 0x01560821, 0x2f3f3948, 0x1b22422a, 0x22890c1e, 0x1bc0161f,
0x3d1b6501, 0x1f1f2a13, 0x35382b2b, 0x35455642, 0x2232291f, 0x220b581b, 0x22090103, 0x2242162b, 0x15012a0b, 0x2a1f393f, 0xfe1b1b2f, 0x1b3d1b9b,
0x1e293222, 0x42564435, 0x2b2b3835, 0x132a1f1f, 0x221b1e58, 0x59180c0b, 0x07200bed, 0x6209ef4c, 0x01260503, 0x7db07dd5, 0x8942b07d, 0x0018220b,
0x23328228, 0x23263435, 0x23095b78, 0x35363233, 0x8c181183, 0x012f11c2, 0x56111940, 0x562b2b56, 0x12191156, 0x4c120e0e, 0xd535052e, 0x111a1a11,
0x12202001, 0x2a2b2b19, 0x12192b2b, 0x12120e20, 0x0cd641ae, 0x0002002d, 0x01950015, 0x008001eb, 0x8417000b, 0x05054d97, 0x36210582, 0x06114d32,
0x20080b82, 0x2b8ac29f, 0x2b70a070, 0x2a587aae, 0x2a3f583f, 0x618a8001, 0x4f71714f, 0x3e583561, 0x2c3f3f2c, 0x20bb8b3e, 0x05d77909, 0x23152323,
0x20bc8335, 0x4e478213, 0x01210b29, 0x218d8240, 0x77428055, 0x56d6240a, 0x18568056, 0x590e7e47, 0x11250a5d, 0x00002100, 0x824b8401, 0x0604414f,
0xf8562320, 0x40012b10, 0x55555580, 0x12191a11, 0xa918aa2a, 0x80200c11, 0x2b23fb83, 0x182b1812, 0x580e15a9, 0x132409cd, 0x27002300, 0x22216384,
0x3caa1806, 0x26342209, 0x24659123, 0x15333513, 0x05496a01, 0x6b8f2a20, 0x822a8021, 0x121926db, 0x19191280, 0x236f9012, 0x2b2b00ff, 0x200b2541,
0x054b7d05, 0x22142141, 0x4f2b562b, 0xd6220b49, 0x1d41ab2b, 0x00142219, 0x0b294224, 0x3324c083, 0x33352335, 0x27132542, 0x5555111a, 0x8019122a,
0x55200483, 0x280a2341, 0x19122b15, 0x12182b2b, 0x20048256, 0x0c2042bd, 0x220bbf6b, 0x5d1f0013, 0x15210c07, 0x05406015, 0x0b5d3420, 0x11192414,
0x187d58ab, 0x260ecf78, 0x1911ab58, 0x5713b07d, 0x0021052f, 0x08617b02, 0x2f001b27, 0x11250000, 0x06046f23, 0x34262230, 0x32153336, 0x23263436,
0x14062235, 0x8f183316, 0x332e104d, 0x01173337, 0x3e2dabab, 0x281c2d3e, 0x03831c28, 0x5e820b83, 0x2f07d058, 0x26802645, 0x1600016b, 0x263e5a3d,
0x89273a28, 0x26200382, 0x15220b82, 0x4a5f2a01, 0x2b2b230b, 0xb5450100, 0x18182008, 0x2a42b3a7, 0x00800001, 0x01800140, 0x180d00c0, 0x84087f4c,
0x173221ce, 0x55311a82, 0x32324633, 0x01161523, 0x23d655c0, 0x33463232, 0x3224820c, 0x2b006b00, 0xd2019901, 0x00001100, 0x15331525, 0x6f333521,
0x013b0a2c, 0xd6fe8015, 0x58473680, 0xa84c577c, 0x542a2a53, 0x3e375309, 0x393e5858, 0x82020054, 0x012b22b9, 0x253982d9, 0x00250007, 0x67831200,
0x14163226, 0x07061425, 0x23204684, 0x2108d361, 0x52881523, 0x121c6e34, 0x01121c12, 0x40384c59, 0x0c15abfe, 0x0c094009, 0x5e84ab15, 0x13150134,
0x1a13131a, 0x07543914, 0x566a2a53, 0x090c0c09, 0x6e864056, 0x0001002b, 0x018000ab, 0x00800149, 0x2db28205, 0x27071707, 0x62490137, 0x80801e62,
0x06846201, 0xb7242182, 0x55018000, 0x13202185, 0x27282083, 0x1e8080d5, 0x80016262, 0xf9510684, 0x000f250d, 0x001f0017, 0x27899f60, 0x01550015,
0x00ab01eb, 0x20090148, 0x0a8e7205, 0x4a182120, 0x012a080f, 0xfe111a00, 0x1a1a1180, 0x05820111, 0x4a18f520, 0x00200810, 0x91411283, 0x01d52606,
0x000700d5, 0x0c2b430f, 0x22061424, 0x7b183426, 0x75180be9, 0x00200c48, 0x55223984, 0x8182d501, 0x2100173c, 0x32010000, 0x23141115, 0x22262722,
0x22230607, 0x33341135, 0x32161732, 0x0d833637, 0x36152722, 0x012a0d82, 0x020c0cc9, 0x60c66004, 0x08870204, 0x5d4e1c35, 0x59525358, 0xab015358,
0x0ec6fe0e, 0x02232302, 0x843a010e, 0x18372507, 0x1818e818, 0x55216582, 0x056b6800, 0x2000082e, 0x33370000, 0x23373426, 0x05141516, 0x23340382,
0x34352221, 0x27343637, 0x33343526, 0x14153221, 0x8c140607, 0xe8243482, 0x02050118, 0x55224f8d, 0x6783b053, 0x7a896b20, 0xc78b8386, 0x1f001335,
0x32120000, 0x1416021f, 0x2206020f, 0x3426022f, 0x8216023f, 0x841420cf, 0x27342bc9, 0x135d9ab3, 0x06121206, 0x08875d13, 0x568cf025, 0x83560f0f,
0xab012a04, 0x42130310, 0x03134286, 0x25088710, 0x72390e1b, 0x04830e39, 0x490b4545, 0x03203db1, 0x22085576, 0x60090004, 0x27260593, 0x15272707,
0x5d461737, 0x01802910, 0x2e405200, 0x95363540, 0x28093f5e, 0x37526d6b, 0x2020abee, 0x0d7175ab, 0x456be366, 0x5564099f, 0x4e072057, 0x0c300a4d,
0x1a001000, 0x30002400, 0x00004000, 0x15333501, 0x20087f56, 0x2a0c8217, 0x15233537, 0x35333533, 0x18073523, 0x1808599a, 0x4607639a, 0x2108148f,
0x01eb152b, 0x11d5fe2b, 0xe0159519, 0x20202040, 0x350e1235, 0x6b120e35, 0x20350d13, 0xb6130d15, 0xab451911, 0x400b3b08, 0xd5fe7540, 0x0111192a,
0x16164b2b, 0x2a802016, 0x40401620, 0x1380130d, 0x05821637, 0xad132a22, 0x00232a88, 0x61001911, 0x03270a53, 0x1b001300, 0x4b002300, 0x13271487,
0x34352315, 0x6e163236, 0x356207a8, 0xc0f52a0f, 0x4c423c42, 0x281c1c28, 0x12ba611c, 0x10e5fe3c, 0x1a1a1610, 0x1d261d40, 0x0000261d, 0x00150003,
0x01eb0160, 0x000700a0, 0x8482000f, 0x7507d556, 0x06210549, 0x26688214, 0x22060617, 0x77362726, 0x1c250bd5, 0x1c1c809e, 0x56048380, 0xcd7706bf,
0x58cc2405, 0x82584848, 0x08578303, 0x2b00125c, 0xf001d501, 0x1a001600, 0x00001e00, 0x07141601, 0x27222306, 0x32331637, 0x27343637, 0x27152326,
0x05321537, 0x35273717, 0x01270717, 0x3738389d, 0x202b3151, 0x2c3e211b, 0x3e2c2b2b, 0xfe515a5a, 0x4e4e4ee9, 0x018b8a8a, 0x389f3872, 0x0d1f1838,
0x2c7c2b2c, 0x5b5a452c, 0x1882be45, 0x8a8a3c32, 0x0400008a, 0x57005700, 0xeb01ab01, 0x14000e00, 0x20206982, 0xa4186983, 0x63820993, 0x111a9818,
0x15013e08, 0x3f57573f, 0x2e3d3d2e, 0x1f7e6161, 0x39301e17, 0x1c1e1005, 0x04124106, 0x011d062b, 0x826008a9, 0x082b0860, 0x08475e47, 0xfe615f53,
0x05111f8e, 0x1d8e062b, 0x2e251e18, 0x2d1b1a5f, 0x20738226, 0x20738255, 0x4b7382a9, 0x738205b7, 0x37362526, 0x07070633, 0x21051d56, 0xe5822623,
0x35072723, 0x09196506, 0x68013522, 0x1c2e4583, 0x1f171e72, 0x2b943024, 0x1c1f1105, 0x82836157, 0xb6258a83, 0x252e1e17, 0x28138316, 0x171ebe06,
0x5f47251e, 0x207e8453, 0x218a842b, 0xcd580042, 0x11075f13, 0x07171722, 0x220f0a42, 0x426b6b6a, 0x6b241202, 0x02005555, 0x23081b4d, 0x00230013,
0x0ccd9c18, 0x99532320, 0x10716506, 0xaa59c020, 0x23058205, 0x1a118001, 0x22075346, 0x8655aaab, 0x0c806500, 0x00040039, 0x01300018, 0x00c501dd,
0x000d0005, 0x00260020, 0x17353700, 0x50262223, 0x41080733, 0x07061605, 0x22230607, 0x35260327, 0x36373734, 0x01173233, 0x37372626, 0x1f4a7d15,
0x12221a11, 0x0c120c0c, 0x0e074301, 0x09089d10, 0x036a0b1c, 0x08099e1a, 0xcafe0b1b, 0x34070e10, 0x1ab2875b, 0x22830dfb, 0x2110a628, 0x1a034107,
0x1c830001, 0xfe260882, 0x102007b2, 0xd545c07d, 0x00d52409, 0x821d0009, 0x273728e1, 0x07352315, 0x5a333517, 0x33280fa7, 0x01173337, 0x804b4b40,
0x6b200282, 0x2809b358, 0x27802744, 0x364b4bb5, 0x20038236, 0x0ba96bc0, 0x002a2a23, 0xa5431802, 0x235b8f08, 0x15271137, 0x210e8447, 0x58821501,
0x804a4a31, 0x0c55556b, 0x09d5fe09, 0x01090c0c, 0x870c092b, 0x564a255b, 0x4b56eafe, 0x00201584, 0x53180583, 0xfb6a7929, 0x00032f09, 0x000f0009,
0x00190013, 0x15373700, 0xd1823707, 0x01372328, 0x34350733, 0x05823336, 0x16253408, 0x27260117, 0xbdbdfac6, 0x552a111a, 0x552aabfe, 0xfa3da31a,
0x06196001, 0x0717a1fe, 0xbd3dfa40, 0x551a112b, 0x2a552b01, 0x3dfa1a11, 0xfe1707bb, 0x681707a2, 0x10820f9f, 0x44070942, 0x24270773, 0x22061416,
0x48353727, 0x01260b73, 0x6a4a4c09, 0x7a485a26, 0x4c283c0c, 0x5a264c68, 0x04000080, 0x7e000000, 0x82010002, 0x1e001200, 0x5c005500, 0x63250000,
0x073105b8, 0x14151506, 0x32161617, 0x27363637, 0x17323334, 0x2b0f8216, 0x25352223, 0x1e141522, 0x17163305, 0x15200186, 0x08059544, 0x333526c4,
0x35323314, 0x27032e34, 0x35262726, 0x33363734, 0x23151632, 0x25262734, 0x23113337, 0x13010735, 0x0a17070a, 0x01021708, 0x06082c10, 0x29537b04,
0x53521613, 0x011e1c01, 0x02040202, 0x0a090107, 0x0e081309, 0x2c050508, 0x1139120c, 0x21262905, 0x230e0606, 0x130c0806, 0x21110c2a, 0x0c122a2a,
0x066549fe, 0x36e6402b, 0x030f1124, 0x1835340e, 0x10200509, 0x6d47120c, 0x29391c18, 0x17356e6e, 0x03030503, 0x04030102, 0x03060201, 0x0a0b0509,
0x040f250b, 0x1e0a0c27, 0x03090617, 0x03020906, 0x26170d08, 0x1d1e040e, 0x3a030415, 0xcd00ff25, 0x00020016, 0x017e0059, 0x008201c2, 0x005e0038,
0xda830100, 0x16320422, 0x1620dc94, 0x2620dd83, 0xdf8fdb82, 0x1516072b, 0x22060714, 0x14333526, 0x2b248217, 0x35232334, 0x36373233, 0x22233435,
0x29065d64, 0x14163233, 0x011f7601, 0xe9820301, 0x09010629, 0x08120b09, 0x8206070e, 0x38132fe9, 0x16280511, 0x06062111, 0x1c100507, 0xea851214,
0x0c132508, 0x17182aa1, 0x0b2b2f4a, 0x2e2a110d, 0x0920191a, 0x0a1a2602, 0x11302a03, 0x012a2610, 0x04031721, 0x03010303, 0x0f22e890, 0xe982170f,
0x06236382, 0x84180c0d, 0x05143be9, 0x2a101e03, 0x26141225, 0x0a081422, 0x05172152, 0x0614260b, 0x05132d09, 0x2d474824, 0x012b2605, 0x00eb01c0,
0x07634607, 0x08057218, 0x080a0176, 0x17163723, 0x15333507, 0x35231513, 0x57577cc2, 0x2b01577c, 0x70a0702a, 0x37415070, 0xc90e101e, 0x55802b2a,
0x39178358, 0x4f4235b5, 0x719e7171, 0x110d1f2b, 0x018080ac, 0x002b2b16, 0x25000500, 0x63861500, 0x17001323, 0x05f34d00, 0x2737322a, 0x16141506,
0x27070103, 0x22055d76, 0x82172737, 0x82372062, 0x17172262, 0x247b8207, 0x35362707, 0xed401834, 0x27003109, 0x5714cc24, 0x1b7b0182, 0x50383236,
0xc63b2070, 0x30087582, 0x2a1e1ed6, 0x57141f20, 0x2022283e, 0x35433a30, 0x22cc1555, 0x01583e29, 0x1b85fe56, 0x4f712036, 0x593b303a, 0x2bdf491e,
0x1f1e4c2b, 0x303a4235, 0x271d821f, 0x201f1457, 0x0800002a, 0x2608dd48, 0x00090004, 0x8412000d, 0x00212a99, 0x25000029, 0x15233736, 0x20048317,
0x25048215, 0x26331535, 0x04872727, 0x06110323, 0xc5b31806, 0xa53e080a, 0x70940202, 0x207f030c, 0x02943e1e, 0x037f9002, 0x1e3e700c, 0x57573f4a,
0x7d7db004, 0x06d57db0, 0x11401610, 0x043e1605, 0x1016c010, 0x05164006, 0x10143e11, 0x5201b2fe, 0x60826008, 0xfd517601, 0x002b2608, 0x01d50115,
0x239582eb, 0x1300001f, 0x2705ef56, 0x23173523, 0x27073315, 0x2205a470, 0x82352335, 0x17373308, 0xd5211123, 0x2b1a1180, 0x402b5580, 0x11aa2a40,
0x0884551a, 0x012a0129, 0x111a2b55, 0x82d58080, 0x21088216, 0x07822baa, 0x0000ff22, 0x230c0f6f, 0x0013000b, 0x21050d58, 0x29680100, 0x82172006,
0x33252356, 0x5e832315, 0x0b821720, 0x0b821520, 0x03820320, 0x012a0783, 0x55552b40, 0xfed5d555, 0x08822bd5, 0x2a2a8032, 0xd5d5abab, 0x018080d5,
0x2a2b8040, 0x2b2a552b, 0xd5200682, 0x012a0382, 0x2ad62a2a, 0x000c0000, 0x49180040, 0x2f211b75, 0x05337b00, 0x68837982, 0x37200387, 0x27200f82,
0x0f837182, 0x1b8a1720, 0x0b822720, 0x5580012b, 0x56c05555, 0x55c055c0, 0x230782eb, 0x15556a56, 0x55250c84, 0x55950155, 0x063147d5, 0x566a5522,
0x55231482, 0x84566b55, 0x556b2200, 0x05eb4755, 0x00268b8b, 0x21152113, 0x04823517, 0x402f5582, 0x6bfe9501, 0xfe000195, 0x9501806b, 0x8295aa80,
0x3b318300, 0x01550000, 0x00ab01fc, 0x001e0007, 0x37000021, 0x07232733, 0x25333733, 0x27230733, 0x06200282, 0x0808e97b, 0x3717333f, 0x37251733,
0x4428dc17, 0x0f29442b, 0x27080144, 0x2020252c, 0x52150226, 0x64644731, 0x10335247, 0x2022201a, 0x1819d6fe, 0x2ac0c0ab, 0x8282c096, 0x65342b09,
0x8740658c, 0x4e0e8787, 0x7b52184e, 0x00062a42, 0x01210015, 0x00e001eb, 0x24af8203, 0x00190015, 0x82b3831d, 0x37072694, 0x27231533, 0x05bc4316,
0x3634352a, 0x07333537, 0x17352315, 0x0806f75d, 0x1e700137, 0x40151e26, 0x231d6b40, 0x234b6a4b, 0x40eb801d, 0x26c92ad6, 0x1d7d261e, 0x2bca1e26,
0x233a1184, 0x354b4b35, 0x67113a23, 0xff2b2bc0, 0x27533f3f, 0x0000271e, 0x206f8609, 0x206f84f4, 0x0e535e0f, 0x07173722, 0x02205f83, 0x2006b758,
0x20818205, 0x20138207, 0x07535e13, 0x37207f82, 0x4c200b82, 0x81246682, 0x4b6a4a2a, 0x01247982, 0x3b40402b, 0x02828a82, 0x2a812625, 0x827b4096,
0x82742008, 0x3f35246a, 0x586a013f, 0x2b21058e, 0x21928278, 0x34824b01, 0xd4231482, 0x82792b2b, 0x0bff4622, 0x14000422, 0x0025f582, 0x15233501,
0x0f8e4837, 0x2309c260, 0x36356bab, 0x10f5b018, 0xab000125, 0x18b520ab, 0x1814f7b0, 0x20095d41, 0x255f8204, 0x27213700, 0x92182707, 0x22200856,
0x3605696b, 0x602a016b, 0x0b01364a, 0x101b1b10, 0x1a1180fe, 0x8095101b, 0x82cb4060, 0x10d62a0c, 0x01111a1b, 0x001b102a, 0xa541180e, 0x00043208,
0x000f000b, 0x00180013, 0x0020001c, 0x00290024, 0x1d84182d, 0x37002208, 0x205f8233, 0x050e7227, 0xb15d1320, 0x23152407, 0x82013634, 0x8211200c,
0x82052003, 0x217f8303, 0x08821523, 0x03822720, 0x06141325, 0x43353523, 0x403706a2, 0x273544d5, 0xff2b0160, 0x561a1100, 0x2b552a2a, 0x1b2b802b,
0x822a3b01, 0xaafe3000, 0xab012b2b, 0x2b2b1b10, 0x2b2bab2b, 0x82101bd6, 0x6b2b2608, 0x662e455b, 0x82a282d5, 0x2c0f8229, 0xabfe1b10, 0x2b80012b,
0x1b802b2a, 0x21048210, 0xc082fe2b, 0x2aaa2b24, 0xb1822b2b, 0x4000152a, 0xc001eb01, 0x07000300, 0x1022c182, 0xc1861400, 0x2c002730, 0x34003000,
0x3d003900, 0x00004100, 0xc9431513, 0x82072005, 0x84372007, 0x830882b9, 0x82032014, 0x22038307, 0x83262213, 0x321325af, 0x17231516, 0x27201382,
0xc4840382, 0x35202d82, 0x95221083, 0xb682802a, 0xb8822b20, 0xb7826520, 0xd52b2b28, 0x1a112b2b, 0xba84d5d6, 0xb9878020, 0x82c00121, 0xab2b25af,
0x2bab2a2a, 0x2b21b584, 0x82c28201, 0x012b25bd, 0xfe2b2b00, 0x5522d282, 0xc4840180, 0x17842b20, 0xaa223c82, 0x0a822a2a, 0x0b2f4318, 0x49000721,
0xd4410a2f, 0x8eb9270f, 0x648e6464, 0x944b6b01, 0x4b802609, 0x6a4b4b6a, 0x0c1655f5, 0x00070029, 0x0121004c, 0x41f401b4, 0x0b430617, 0x00210807,
0x17372737, 0x07173703, 0x37270701, 0x33352307, 0x27071713, 0x23153327, 0x15213507, 0x1e261e6a, 0x21038244, 0x04824201, 0x2a2a7923, 0x2b068281,
0x802a2a85, 0x1f562a01, 0x24011e26, 0xfe280e82, 0x1e271ef9, 0x5f013f7a, 0x5b270b82, 0x8080ea3f, 0x82000400, 0x00022b00, 0x10000002, 0x25001900,
0x39713100, 0x35172112, 0x322f6982, 0x03151516, 0x23171632, 0x07272626, 0x82363227, 0x06223185, 0x27262223, 0xab161633, 0x2b2b0001, 0x2b1912aa,
0x80300582, 0x7f1a1180, 0x20089364, 0x1d354406, 0x5f080351, 0x03200483, 0xab201085, 0x1a362082, 0x2b2baa11, 0x192b80d6, 0x2b018012, 0x603c6388,
0x01511c19, 0x048236fe, 0x5e180c83, 0x08200a7b, 0x24279182, 0x34002c00, 0x82010000, 0x3433247c, 0x18152326, 0x2008ee92, 0x0bba4b33, 0x33373327,
0x27163215, 0x39258235, 0x02263423, 0x16323634, 0x01220614, 0x1c191255, 0x58811d2a, 0x3f583f3f, 0xb9556ad6, 0x27443907, 0x16191280, 0x3b1c4b35,
0x283828c2, 0x80013828, 0x2a1d1219, 0x3eebfe1c, 0x31082883, 0x1911eb97, 0x00011119, 0x402b1a11, 0x4b1c6719, 0xfe3b2935, 0x28283aff, 0x0400273a,
0x2b000000, 0xeb01eb01, 0x11000900, 0x30002400, 0x34360000, 0x74823336, 0xa95c6c82, 0x35272307, 0x6a783533, 0x033d220c, 0x08146e33, 0x1c28d123,
0x204a821d, 0x2b68830f, 0x95402b3e, 0x1a114427, 0xabfe111a, 0x40236c83, 0x82b8402b, 0x1c1d2367, 0x88842628, 0x40408227, 0xff111a2b, 0x218e8300,
0x0c8280d6, 0x54180282, 0x282b0fe1, 0x37010000, 0x07072727, 0x86071717, 0x33132107, 0x820b0b59, 0x86272089, 0x69012503, 0x14142c2c, 0x65290382,
0x1a1b3b3b, 0xab1a3b3b, 0x07114155, 0x402a162c, 0x402b2a2a, 0x402b2b2b, 0x23840101, 0x1a2c1424, 0x27841b1a, 0x182b0121, 0x200936be, 0x4e008340,
0x07240be1, 0x22000f00, 0x17278382, 0x27270707, 0x84173737, 0x07172204, 0x0d9c4117, 0x11231528, 0x3a1b0121, 0x03831b3a, 0x82836b20, 0x17210382,
0x207d822a, 0x25fe83d5, 0x2b01c0c0, 0x1c841b01, 0x2a3a1b22, 0x1422a385, 0x1a83c02c, 0x112a0129, 0xd6fe2b1a, 0x18000400, 0x2007fd77, 0x061f4404,
0x4505d144, 0x23240f8f, 0x03231133, 0xeb3b0382, 0x263644d5, 0x0d0d09b5, 0x0900ff09, 0x6a090c0c, 0x2b562a2a, 0x445a952b, 0x860cbc2e, 0xcbb91812,
0xf1431809, 0x00eb2208, 0x265d8205, 0x27373700, 0x43072707, 0xd78205b7, 0x25058b45, 0xa21ec0d5, 0x8f831e4c, 0xadad1326, 0xab111a13, 0xd62e0f84,
0xecfe111a, 0x74740e15, 0x1401150e, 0x49821a11, 0x2b002b2a, 0xd501dd01, 0x1a000b00, 0x2906c74e, 0x15150622, 0x37333533, 0xa55e0716, 0x32363408,
0x4a2b0117, 0x0c096b4a, 0x0ea4562a, 0x1206c00e, 0x8206c006, 0x06122b02, 0x354b4acb, 0x4055090d, 0x1582100f, 0x18821184, 0x06000038, 0x2b000000,
0xe0010002, 0x0f000700, 0x2d002500, 0x3d003500, 0x815f0000, 0x1727250f, 0x27352315, 0x2608a14f, 0x15331617, 0x43272722, 0x14430732, 0x34262105,
0x07d54218, 0x76013108, 0x3e2c2c3e, 0x3e5a1d2b, 0x453d5a3e, 0x0c452a2f, 0x16083c0c, 0x20290f13, 0x112d3f2c, 0x2b2b3ece, 0x5a1e2c3e, 0x3e5a3d3d,
0x1a225c01, 0x4b19221a, 0x2c221082, 0x2d828a3e, 0x5e5a3d25, 0x826a8431, 0x0c122b2d, 0x290c0c3c, 0x112d2b20, 0x1d8af8fe, 0x8319c921, 0x00002830,
0x00550004, 0x5fab0140, 0x312508e3, 0x35010000, 0x158b1821, 0x09334308, 0x9c823420, 0x14151523, 0x06f15907, 0x23353522, 0x262b0988, 0x00ff8001,
0x12121cd2, 0x84ae121c, 0x582b2b05, 0x0c1658a6, 0x0d091509, 0x05820daa, 0x01160c26, 0x806b6b15, 0x0a536218, 0x33d5032f, 0xd5332222, 0x0926141c,
0x16090c0c, 0x21058316, 0x8d831426, 0x8d824020, 0x9501c031, 0x0b000300, 0x2d001300, 0x21130000, 0x78162327, 0x25210eb9, 0x207b8817, 0x2c098821,
0x33333637, 0x2a016b32, 0x1addea20, 0x206b8213, 0x220584d7, 0x822c2901, 0x0c092360, 0x068400ff, 0x19062c28, 0x150119ea, 0x8c8aca60, 0xab80c222,
0xab228589, 0x7b821580, 0xfeff252c, 0xeb01db01, 0x22000400, 0x83823500, 0x1737152a, 0x26270135, 0x34353737, 0x352f6582, 0x32331533, 0x17151516,
0x23070716, 0x82062722, 0x05232302, 0x0a831533, 0x4d062721, 0x4a0805f1, 0x16373216, 0xfe808080, 0x150728d4, 0x40111a1b, 0x1a114080, 0x2807151b,
0x25253101, 0x31252560, 0x2a2a5601, 0x5555292d, 0x2a2a2d29, 0x5c27282e, 0x80012827, 0x552a2a55, 0x148eebfe, 0x11630907, 0x1a40401a, 0x07096311,
0x822a8e14, 0x2b2b2d00, 0x152c2c15, 0x1b1b1c2b, 0x0500001c, 0x240cb141, 0x0017000f, 0xc98c1829, 0x1827200d, 0x200ad58c, 0x07936d12, 0x35211533,
0x35262237, 0x80013435, 0x121c3d6b, 0x55121c12, 0x8204826b, 0xa62d2a02, 0x201f2c58, 0x1f2000ff, 0x09a6412c, 0xaf416d20, 0x2d013007, 0x1fcb3322,
0x0b0b202b, 0xcb1f2b20, 0x18030033, 0x22089bb4, 0x490b0003, 0x2d420575, 0x35272109, 0x22062542, 0x85172306, 0x80012b70, 0x226f00ff, 0x1a221a1a,
0x678a5880, 0x6a6a2b23, 0x28138296, 0xe006221a, 0x33232333, 0xfe6086e0, 0x022408db, 0x15008000, 0xe0019501, 0x21001900, 0x03130000, 0x15173733,
0x37273533, 0x22353316, 0x23262727, 0x07230622, 0x37201082, 0x07234318, 0x2d3cd135, 0x2d2b2c27, 0x3e472e0d, 0x150f161d, 0x6f030b03, 0x8460262b,
0x420134ee, 0x2babd3fe, 0x402ba080, 0x22342a35, 0x642f0215, 0x43490f48, 0x88180673, 0x8718093b, 0x02213fe1, 0x05b55a00, 0x0e009526, 0x00001600,
0x24063378, 0x11231521, 0x18a78233, 0x3b078345, 0x33239501, 0x2b80fe2b, 0x343cab2b, 0x26342626, 0x23336b01, 0x014040c0, 0x8096c040, 0x3c080e82,
0x02003426, 0x3f004000, 0xd501c001, 0x0d000700, 0x26250000, 0x17372726, 0x37070606, 0x37270717, 0x91090001, 0x26c0c026, 0x239d0a90, 0xab23c0c0,
0x951d7107, 0x3f701d95, 0x95951b7b, 0x05ef461b, 0xd5013f30, 0x0f00eb01, 0x18001400, 0x01130000, 0x36822707, 0x27371723, 0x22478307, 0x82060527,
0x8213200d, 0x01462b50, 0x6a501b8f, 0x4b9d23c0, 0x52822d1e, 0x015a4538, 0xa83b1b95, 0x191fa73e, 0xfeeb011f, 0x52511b70, 0x3b7b1b95, 0x6082221e,
0x905a3631, 0x30a82e15, 0x131febfe, 0x0001001e, 0x842b002b, 0x8214209d, 0x1527229b, 0x66891817, 0x066f4208, 0xc0011722, 0x0a0e8918, 0x8918ab20,
0x9159130c, 0x00ab2607, 0x00130003, 0x160b5833, 0x08094018, 0x7108e743, 0x23210af7, 0x05a36315, 0x09275c18, 0x552b9629, 0x0c0c0940, 0x872a1609,
0x01802f08, 0x0100ff00, 0xff12192b, 0x19191200, 0x05820112, 0x16eafe26, 0x090c162a, 0x16202882, 0x4f550888, 0x00ab2409, 0x82260009, 0x4827208d,
0x0724051c, 0x16143637, 0x26089b47, 0x35363235, 0x83232634, 0x3221338c, 0x22151516, 0x46174c01, 0x5b21215a, 0xab4c1747, 0x1c481119, 0x18122105,
0x01210983, 0x350e8256, 0x053a579a, 0x3a055454, 0x22463157, 0x1a11551a, 0x1955111a, 0x09861112, 0x5d457383, 0x00c02d05, 0x000f0003, 0x37331300,
0x15072121, 0x3b056e5e, 0x9f213527, 0xf2fe26c2, 0x6bab4701, 0xab6b00ff, 0x6b018001, 0x2b6ac02a, 0x2bc06a2b, 0x1805e341, 0x2b09095b, 0x37000019,
0x11152135, 0x37152335, 0x46065f44, 0x2b08090c, 0x2b80012b, 0x1818122b, 0x23322b12, 0x40332380, 0x15012b2b, 0x196b4040, 0x18124012, 0x33332340,
0x0700d523, 0x15004000, 0xef01c001, 0x2408e545, 0x00430038, 0x4555824e, 0x262b2ceb, 0x34352622, 0x16373736, 0x94161415, 0x200c460a, 0xea18072d,
0x131aeb18, 0x20080810, 0x83121c59, 0x85582006, 0x60eb220d, 0x051c45cb, 0xc3280584, 0x0d09aa80, 0x1515090d, 0xaa2d0583, 0x132a1680, 0x0a1d090d,
0x0d15250a, 0x4a099213, 0x09240b01, 0x21001500, 0x26059d45, 0x15233523, 0x84271533, 0x25098205, 0x37352335, 0x14831133, 0x3311233e, 0x55012135,
0x2b161515, 0x2a2a4055, 0x40d52b40, 0x40aa56aa, 0x00012a01, 0x402b2b6b, 0x162c0282, 0x16154015, 0x56eafe40, 0x40160156, 0x0a97c218, 0x0e000324,
0x5d821800, 0x21374508, 0x36321617, 0x27263435, 0x14150627, 0x06032103, 0x22232306, 0x87012726, 0x09e0fe09, 0x2026346d, 0x80401010, 0x022b8001,
0x10d61018, 0x55010218, 0x26ea5656, 0x133a131a, 0x1a2b4813, 0x7bfe4401, 0x10151510, 0x270d0354, 0x00370031, 0x0000003d, 0x2906c967, 0x26373407,
0x33363435, 0x72431732, 0x05544b06, 0x15160727, 0x22230614, 0x23058227, 0x35352622, 0x26210a82, 0x22088217, 0x82151632, 0x06142f2b, 0x1f2c1601,
0xbe1f2c1f, 0x16201f1f, 0x09820f0f, 0x160f0f23, 0x210c8320, 0x0c820d11, 0x16110d28, 0x70508920, 0x02827050, 0x208b0122, 0x46302a83, 0x210f0f21,
0x040a2016, 0x16202016, 0x16200a04, 0x1f2e0f84, 0x1f160409, 0x0904161f, 0x4f71e41f, 0x02824f71, 0x87467120, 0x01b52806, 0x000700c0, 0x1835000b,
0x2609e540, 0x15233507, 0x86151625, 0x15232391, 0x42181123, 0xa2180ad6, 0x6854076f, 0x01372c07, 0x0c0c1277, 0x806b0c12, 0x820f2601, 0xd6202992,
0x1180111a, 0x1a11151a, 0x09281482, 0x221f160c, 0x2b01172d, 0x02820b82, 0x3b6a6a25, 0x83cb170f, 0xa06b3888, 0x1a115501, 0x1a95111a, 0x0c096011,
0x049a090c, 0x0e24161f, 0x8200162d, 0x44152095, 0x072406a9, 0x2b002300, 0x09cb4d18, 0x1733013b, 0x15163221, 0x06070714, 0x07072323, 0x15333314,
0x35262221, 0x27373734, 0x07af5723, 0xe6690120, 0xd5fe3f05, 0x3c011446, 0x4c030c09, 0x139f190c, 0xfff70501, 0x05191100, 0x6f2b4d1d, 0x221a1a22,
0x03828019, 0x01221936, 0x090d2a6f, 0x168a0505, 0x2b050323, 0x0a0a111a, 0xd5fea235, 0x00201984, 0x0e3dce18, 0x23352528, 0x23152335, 0x287c3315,
0x80012712, 0x55555655, 0xcc836a56, 0x83d6fe21, 0x83d52005, 0x5555220f, 0x0cea4eeb, 0x20476546, 0x086b5f05, 0x0f000728, 0x27001700, 0x21612d00,
0x0669420a, 0x0b076218, 0x310c977a, 0x06141637, 0x4b6acb22, 0x1e4b6a4b, 0x120c0c12, 0x0584330d, 0x19129522, 0x25076d45, 0x32197844, 0x1f825546,
0x016a4b24, 0x4d180d0b, 0x373909b2, 0xaafe1218, 0x12181812, 0x18125601, 0x1979c4fe, 0x02003247, 0x1f004000, 0x05f14601, 0x00112508, 0x26220000,
0x16323634, 0x33360714, 0x26072215, 0x01323523, 0x2626341a, 0x50402634, 0x51516f70, 0x5501706f, 0x26270c82, 0xea4b7134, 0x43ea4c4c, 0xeb240883,
0x11000b00, 0x0025c782, 0x35363236, 0x209f8223, 0x82058226, 0x331523c1, 0xf3661734, 0x8333200e, 0xd415245f, 0x822b3f58, 0x852b2548, 0x55802634,
0x2e097641, 0x3f583f2a, 0x1a2c3eeb, 0x2c1a2626, 0x821a2697, 0x06564e00, 0x11000129, 0x3f3f2c1a, 0x4907002c, 0xc0200677, 0x200c6d50, 0x055b442b,
0x5d181720, 0x01201234, 0x82065d44, 0x050d481a, 0x33153325, 0x832b8001, 0x84aa2000, 0x00012105, 0x0a840682, 0x012baa2c, 0x552b2b40, 0x2b562a2a,
0x0887ab2b, 0xfe2b0122, 0x33842d84, 0xd7620020, 0x0019230c, 0x914b1200, 0x16052206, 0x06344d14, 0x34353528, 0x32333336, 0x764b6817, 0x0c743005,
0x240c960c, 0x190cc00c, 0x0c129611, 0x83136b01, 0x82752016, 0x0c962111, 0x12241482, 0x0c191196, 0x80265382, 0x95014000, 0xdd82c001, 0xc9821120,
0x3436322b, 0x15232326, 0x14163237, 0x3c078206, 0x1a011123, 0x11191911, 0x4b354045, 0x5540354b, 0x221a1501, 0x4bab561a, 0x01804b6a, 0x09cd4680,
0x0b00eb22, 0x42066d68, 0x152c09e7, 0x21151707, 0x35273735, 0x07173721, 0x0747bb18, 0xd1842b20, 0x1f0f0128, 0x2bd51832, 0x02824040, 0x802ac022,
0x8027e382, 0x13562a80, 0x6a010043, 0x1c2608b9, 0x16130000, 0xb3183717, 0x03204617, 0xbd485782, 0x00072405, 0x4214000f, 0x262109f1, 0x05d74c14,
0x17322627, 0x22ef0303, 0x20dd821a, 0x2d038240, 0xe622221a, 0xc0c0c04d, 0x1919221a, 0x1683a222, 0x5540192f, 0x5501abfe, 0x2b000200, 0xd5015500,
0x6d334801, 0x9a187387, 0x04203feb, 0x2d08eb67, 0x000b0003, 0x001d000f, 0x21150100, 0x49420435, 0x35072206, 0x054d4823, 0x14822320, 0x3435233f,
0x80013336, 0x0c0100ff, 0x120d0d12, 0xeaaa2b0c, 0xff55261a, 0x1a265500, 0x5555c001, 0x391584c0, 0xea6a6aa1, 0x55801a26, 0x261a8055, 0x3a000200,
0xd6013a00, 0x1100c101, 0x9f661700, 0x072c0806, 0x36263727, 0x16363637, 0x06060706, 0x34262707, 0x3d011737, 0x931e931f, 0x0cd01e93, 0x4c1f1911,
0x191f092e, 0x195aa840, 0x0a019619, 0x182f1786, 0x091f1940, 0x191f4d2e, 0x195a1b10, 0x47951946, 0x4a1809cd, 0xcf4b65af, 0x00ab2805, 0x000b0007,
0x50290013, 0x37230941, 0x41331523, 0x2522072b, 0x6c441517, 0x22063607, 0x35233526, 0x21333634, 0x1c720115, 0x121c1212, 0xfe5f3540, 0x270984a8,
0x2b404b01, 0x80263426, 0x2b2d0382, 0x2b01111a, 0x131a1375, 0x35ad1a13, 0x2607848b, 0x1a6b55cd, 0x831a2626, 0x11eb2303, 0x2f63561a, 0x207b830c,
0x2e7b4f31, 0x15333522, 0x22247f4f, 0x4f358035, 0x2b241f81, 0x0003002b, 0x6705234a, 0x22200547, 0x15276818, 0x06141123, 0xed551823, 0x8024080b,
0x98585058, 0x30222230, 0x1a115b22, 0x4055111a, 0x19125540, 0x13ab1219, 0x1d25251d, 0x3022e413, 0x68302121, 0x0ff35518, 0x20092f47, 0x058f6b03,
0x1315273d, 0x14111532, 0x07270707, 0x11352207, 0x17373734, 0x80400137, 0x78080bf5, 0x84037280, 0xfd6b3105, 0x2801fd2d, 0x08befe0b, 0x2c2d2902,
0x42010b01, 0xb5820884, 0x8f181520, 0x012e7449, 0x40006000, 0xd501a001, 0x00000500, 0xb9821301, 0x00012730, 0x91910fa0, 0xfed5010f, 0x40400f7a,
0x9b82000f, 0x77006b21, 0x38080543, 0x000c0003, 0x37000019, 0x12211521, 0x32331614, 0x22263436, 0x07061417, 0x35022e07, 0x16323634, 0xfe2a016b,
0x111a6ad6, 0x221a1912, 0x20204091, 0x4b472b0e, 0x2a554b6a, 0x05637501, 0x752b2b2d, 0x340f2525, 0x4b352b7c, 0x1802004b, 0x200ad95c, 0x09174618,
0x3891b118, 0x8309cd66, 0x001a2ea5, 0x23352500, 0x37332307, 0x26272736, 0x06f25307, 0x23062508, 0x34110721, 0x80013336, 0x35602b75, 0x26080893,
0x01930708, 0x1919112b, 0x55d5fe11, 0x2bd51119, 0x0708932b, 0x93212e82, 0x05d959cb, 0x80015523, 0x44f08211, 0x04205923, 0x2e083b46, 0x000c0004,
0x00210011, 0x27213700, 0x48272707, 0x23220516, 0x08821535, 0x5a0f0a55, 0x4a28053c, 0x3e2b573e, 0xea261a2c, 0x2d090d48, 0x40608080, 0x2c3e5820,
0x27416b3f, 0x8a492a1a, 0x0300210c, 0x49186982, 0x11200789, 0x2505af42, 0x23251523, 0x66642315, 0x37353d05, 0x15271721, 0x00013521, 0x15400180,
0x15d6552b, 0x15560115, 0x80aafe15, 0x80555555, 0x2b280082, 0x2bab6b6b, 0x0100002b, 0x5424cd71, 0xc02b071d, 0x12000900, 0x49001b00, 0x82120000,
0x263424c9, 0x46150622, 0x232005bd, 0x2006b649, 0x25088326, 0x07061437, 0x04833315, 0x23061429, 0x35262223, 0x6c262635, 0x332005ca, 0x8a4b0985,
0x23238308, 0x191924ee, 0x1a220284, 0x09831211, 0xd62d0683, 0x24401c24, 0xaa090d1c, 0x241c0d09, 0x84028540, 0x2115820d, 0x21824001, 0x1218182b,
0x221a8511, 0x84221a1a, 0x33058319, 0x082d1ea7, 0x082c1e18, 0x0c0c0919, 0x2c081909, 0x2d08181e, 0x2c220382, 0x1083161e, 0x19821620, 0x0200183f,
0x16003e00, 0xe0019501, 0x22001a00, 0x27370000, 0x07371737, 0x37352315, 0x32333632, 0x05835517, 0x82170721, 0x51272010, 0xd33607d8, 0x22690895,
0x036f2a27, 0x0f15030b, 0x473f1d15, 0x2b2d0d2e, 0x7083492d, 0x1d631939, 0x0fad152b, 0x022f6449, 0x2b332215, 0xa02a4035, 0x1acb2a80, 0x82191922,
0x090d435a, 0x1c000b25, 0x4b010000, 0x11430a7b, 0x0692480c, 0x577c5331, 0x0f2b2c1f, 0x34140610, 0x2b012027, 0x8240402a, 0x57aa2202, 0xa5b4183e,
0x4303200e, 0x0c220a63, 0x57821d00, 0x2a050d43, 0x27370717, 0x32361507, 0x18141516, 0x2d07fcb4, 0x06063e01, 0x0f050614, 0x1f47501f, 0x5e8c0247,
0x82055f21, 0x85062019, 0xd51f2119, 0xfd48648f, 0x82052009, 0x2303315f, 0x01352727, 0x3815a1c0, 0xfec00192, 0x15389280, 0x230b3f44, 0x00110007,
0x3628ec82, 0x26343732, 0x36150622, 0x21060c42, 0xe38c3435, 0x1e6ec922, 0x08b76d18, 0x898b6920, 0x132ed52e, 0xa8131919, 0x1912111a, 0x44111219,
0x4b43898f, 0x00063309, 0x0014000d, 0x2500001b, 0x27372315, 0x23071737, 0x05821735, 0x3335272a, 0x27071707, 0x27153337, 0x012d0582, 0x3e3180c0,
0x80cf3d1f, 0x3e1f3d31, 0x820b8a4f, 0x85118e17, 0x05394a1d, 0x82079149, 0x3401275d, 0x23113336, 0x57822335, 0x08398918, 0x33353524, 0x03823315,
0x55012208, 0x36352a41, 0x222e2a6a, 0x2b2e2235, 0x80012b2a, 0x56fe371e, 0x95956baa, 0xc0023122, 0x223102c0, 0x4e008295, 0x05200a8d, 0x3731b382,
0x37370000, 0x33073523, 0x34363236, 0x14062226, 0x288f4e37, 0x2b55ab2b, 0x12cc2b55, 0x0c120c0c, 0x17904e3b, 0x6b958024, 0x20824ba0, 0x2f120c22,
0x721f904e, 0xeb2e05df, 0x0b00eb01, 0x1f001300, 0x14130000, 0x2e590717, 0x06332105, 0x075b5318, 0x33360724, 0xf9821732, 0x3523233c, 0xd129f534,
0x9a111a0d, 0x583f2010, 0x48583f3f, 0x1f214034, 0x0195111a, 0x17823980, 0x2a011126, 0x4e1e1a11, 0x3f291883, 0x7f0b2747, 0x0f751a11, 0x33d81800,
0x00162809, 0x00260022, 0x4736002e, 0x232105ab, 0x05477322, 0x3315073a, 0x33173337, 0x36322735, 0x15161603, 0x34112111, 0x32363736, 0x23153307,
0x36218087, 0x05f85834, 0x80014708, 0x453b3e42, 0x24181721, 0x20203c20, 0x04211718, 0x56fe2e2b, 0xa22b2b2e, 0x0ad5d5bb, 0x0d0d120c, 0x120d8912,
0xad120c0c, 0x1a1a2693, 0x21179326, 0x20200818, 0x01211808, 0x2d44102e, 0x1801e8fe, 0x1110442d, 0x184e6b95, 0x20298405, 0x0b2f570d, 0x0b000728,
0x17000f00, 0x55493000, 0x33272409, 0x57072335, 0x13200a2f, 0x2606cf52, 0x27231517, 0x57230723, 0x3e2c0633, 0x1c520102, 0x121c1212, 0x2a6b6b2b,
0x38063657, 0x2c585380, 0x2a2b201f, 0x20302a51, 0x351c2c1f, 0x1a139535, 0x831a1313, 0x20008255, 0x570a8496, 0x2b2a083a, 0x2b200b2b, 0x241bcb1f,
0x85470610, 0x000b250c, 0x2500002a, 0x37247d8a, 0x33230614, 0x26347a88, 0x34353526, 0x23373736, 0x23153335, 0x15161607, 0x5dd66b01, 0xb5238684,
0x85021a1d, 0x17222f7a, 0x113b4420, 0x1046d666, 0x6bd5413f, 0x7884606b, 0x261c0f30, 0x2a2a0a20, 0x2405220a, 0x1f29b417, 0x00822002, 0x2a1e0225,
0x64000400, 0xe028055d, 0x21001900, 0x2f002800, 0x260fe356, 0x26272726, 0x56072223, 0x13270ce3, 0x35071735, 0x82373523, 0x15260883, 0x3b7b3727,
0x2b2e252d, 0x472d0d2c, 0x140f311d, 0x0709190b, 0x61262a70, 0x221a1a22, 0x3535ab19, 0x75753575, 0xfa563535, 0x2ca12d06, 0x1d2a3740, 0x03142218,
0x1047642e, 0x2805fb56, 0x3525b7fe, 0x5a202636, 0x2a068220, 0x00090000, 0x01550055, 0x4eab01ab, 0x1b2b0cd3, 0x23001f00, 0x35250000, 0x86271533,
0x82372003, 0x6407207c, 0x07830611, 0x6b7f3320, 0x56552907, 0x56d65656, 0x8056562a, 0x56200682, 0xd6220882, 0x0c835556, 0x19820f82, 0x03828020,
0x01260985, 0x00565600, 0x6f880100, 0x0cd96c18, 0xfcfeab2c, 0xabab1e77, 0x1501771e, 0x0883782a, 0x29827820, 0xc000952f, 0x2b016b01, 0x00000200,
0x95073313, 0x200b82d6, 0x0b054f6b, 0x0a000222, 0x3721a382, 0x08527b23, 0xaa550023, 0x05ea6503, 0x18aa5621, 0x220899ac, 0x82d50095, 0x83402045,
0x37372745, 0x6b6b9517, 0x45826bd5, 0x1729878d, 0x21372707, 0x01272135, 0x26838300, 0x0401fcfe, 0x82ab0177, 0x2a78220a, 0x0a754f78, 0x13000b22,
0x27052556, 0x17072707, 0x17371707, 0x08527618, 0x4d4d6b23, 0x2002871e, 0x188184a5, 0x200c7dad, 0x3a8c8540, 0x00490001, 0x01c0016b, 0x00050089,
0x17373700, 0xc0372701, 0x00ff1ee2, 0x85a71e77, 0x44df7306, 0x6b000122, 0x95246582, 0x0b009501, 0x2609834d, 0x37173727, 0x18779501, 0x22178bad,
0x18800001, 0x21098f6e, 0xbb4a1701, 0x1e802605, 0x011e6262, 0x82068455, 0x00802699, 0x018001ab, 0x83bb8349, 0x22be8221, 0x82801e62, 0x4901211c,
0x00210684, 0x18778804, 0x24095965, 0x35231533, 0x05476623, 0x82352721, 0x021d210c, 0x35360482, 0x2a6a2b01, 0x6a2a4040, 0x40406ac0, 0x6a95016a,
0x6a40d640, 0x1382962a, 0x14825620, 0x33214798, 0x20418303, 0x21478415, 0x0b831535, 0x55013522, 0x2a2d3882, 0x2aaa406a, 0x012a6a6a, 0xfe6a2a55,
0x204582d6, 0x821482ea, 0x05a55511, 0xc0018024, 0x50188001, 0x86180c43, 0x012111ff, 0x23908280, 0x2b2b6b2a, 0x552c2782, 0xab01d500, 0x07002b01,
0x17000f00, 0x4509217a, 0x2621051c, 0x076a4234, 0x26052a50, 0x1a1a229a, 0x84e61a22, 0x2b012105, 0x028d0a82, 0x4f820020, 0x5500d526, 0xab012b01,
0x5e184f87, 0x1625090f, 0x26220614, 0x07ec4834, 0x3e854f85, 0x4f843c20, 0x0c84ab20, 0x05849a20, 0x05844420, 0x00010023, 0x06ab4356, 0x00001832,
0x23153701, 0x22232637, 0x33161406, 0x33373632, 0x36081167, 0x96327901, 0x35342645, 0x2a354b4b, 0x0e2c0d42, 0x64463b5c, 0x85474664, 0x6a4b2d16,
0x38262f4b, 0x648e6448, 0x9e000200, 0x62204d82, 0x05209b82, 0x31052942, 0x37173727, 0x07173703, 0x62010727, 0x441e6262, 0x0584a644, 0x848d0121,
0xc8fe2106, 0x00200684, 0x40253784, 0xc0016201, 0x20378400, 0x23318325, 0x27073737, 0x01230782, 0x841e4400, 0x20058325, 0x200b847c, 0x430584c4,
0x13200ef7, 0x272b2b82, 0x07112311, 0x1fabab55, 0x43782a77, 0x29830a76, 0x07ff6318, 0x00000a2a, 0x33071713, 0x23113335, 0xeb2f9582, 0x2bc44d1e,
0x801e4def, 0x4d1e4001, 0x8200ffd6, 0x01002709, 0x40005500, 0xc3829501, 0x25202b82, 0x23318382, 0x33153311, 0x95013727, 0xef4d1e80, 0x1e4dc42b,
0x240882c0, 0x4dd60001, 0x0e79441e, 0x17262b82, 0x37113311, 0x828bab01, 0xfe040124, 0xe18277fc, 0x8000802a, 0x80018901, 0x09000300, 0x7f828382,
0x17305b83, 0x2b2b8007, 0x801e0901, 0x01621e80, 0x1e00ff80, 0x2d820984, 0x2d827720, 0x2d878020, 0x2d820120, 0xdf832720, 0x55013725, 0x88de2b2b,
0x84e2202d, 0x04003209, 0x15006b00, 0xe1019501, 0x0f000700, 0x27001f00, 0x75661800, 0x16372710, 0x35211515, 0x45823734, 0x17323634, 0x35011737,
0x06141521, 0x37012622, 0x120c0c12, 0x0584740c, 0xfe3dad35, 0x122d3dd6, 0x20442031, 0xe6fe1231, 0x7c572a01, 0x18400157, 0x39081a63, 0x2d57120d,
0x4b16164b, 0x31112d2d, 0x11311010, 0x5555dbfe, 0x0058583e, 0x09530500, 0x82022008, 0x0013220b, 0xe7a1181b, 0x53042060, 0x07250831, 0x15001100,
0x67b91800, 0x3225080b, 0x23061416, 0x36342622, 0x23153305, 0x15333515, 0x1a1a22c4, 0x472a1922, 0x46476464, 0x1c016464, 0xd52a2a2a, 0x2b13831a,
0x658c65bc, 0x40648e64, 0x2a2a556b, 0x2112776f, 0xb2183225, 0x252319c1, 0x827230ef, 0x46392203, 0xc1b21865, 0x30392408, 0x83ab25ef, 0x18652004,
0x4e07c1b2, 0xf94309f3, 0x82252006, 0x23262250, 0x2be01822, 0x4e042039, 0x47610a25, 0x18072555, 0x2b0118ea, 0x731c265b, 0xeb200867, 0xeb410982,
0x21352105, 0x105bb718, 0x694b3320, 0x07072106, 0x18052746, 0x31092f56, 0x12191912, 0x2baa2b15, 0x17447f1f, 0xea6b682d, 0x551801ea, 0x2b200cee,
0xac200082, 0xef641a84, 0x22698509, 0x18000027, 0x871347cc, 0x27032269, 0x246a8337, 0x07170717, 0x0be27327, 0xb9236f87, 0x82343417, 0x34162402,
0x94341634, 0xd5fe2175, 0x05842185, 0x83083753, 0x4807207b, 0x152306bb, 0x9b053523, 0x241f82eb, 0x01962b01, 0x25ec9100, 0x2ad5d615, 0xeb936a2a,
0x2b2b9522, 0x200c0156, 0x0b355e1b, 0xb74a3720, 0x18212006, 0x2909d57a, 0x4837117f, 0x37481d1d, 0x86733f11, 0x2b80320a, 0x06304795, 0x30064343,
0x1ac62547, 0x1a11d511, 0x0549671a, 0x230bdb48, 0x00120004, 0x5005bf50, 0x072408b2, 0x33363411, 0x2005b050, 0x096751f6, 0x40608023, 0x0c6151a0,
0x0ddf5a18, 0x26001722, 0x6409694b, 0x07870749, 0x3005bd65, 0x22212306, 0x36372727, 0x1a880133, 0x131a1313, 0x27058457, 0x12121c59, 0x3501121c,
0xfe289d83, 0x730e16c2, 0xe0140e73, 0x830a905d, 0x1c12221d, 0x051951ce, 0xadad1328, 0x03000013, 0xf9671500, 0x00072206, 0x05574b1d, 0x22263423,
0xacac1806, 0x18232009, 0x200c839e, 0x821a8327, 0x0121261d, 0x01262215, 0x255b82c0, 0x0d0d0955, 0x04836a09, 0x1f2c1f2c, 0x15382835, 0x9601eafe,
0x98180702, 0x602a158e, 0x13062838, 0x9601401d, 0xff4101c1, 0x001c280a, 0x0022001f, 0x18000030, 0x221c49c8, 0x82371527, 0x27073202, 0x17372737,
0x07173335, 0x35230717, 0x0c09ab01, 0x63cb180c, 0x2f2f370a, 0x0d092f5e, 0x14140324, 0x3b0f5a14, 0x0a310f3b, 0x3d2e2e3d, 0xc818b50a, 0xb12c1545,
0x28701428, 0x3c0f7914, 0x51310f3c, 0x51202883, 0x2805e34e, 0x01eb0140, 0x001c00eb, 0x25919f23, 0x33352335, 0x84971735, 0x6b555522, 0x60247896,
0x6b405640, 0x270f6d68, 0x0100002c, 0x35232634, 0x83060f6a, 0x42072007, 0xcc18069d, 0x07200d5e, 0x2b056359, 0x1a264001, 0x572a3f2c, 0x1570503e,
0x2c140541, 0x261a0001, 0x3e2c3f2b, 0x50702b57, 0x1501414b, 0xeb268389, 0x1d000700, 0x83823a00, 0xff413520, 0x9c11201b, 0x169a2491, 0x835a151e,
0xa09a188b, 0x27979507, 0x160f0aab, 0x0d0a0f16, 0x08aa9a18, 0x20160a26, 0x00ff1620, 0x0228a397, 0x43000000, 0xc0010002, 0x2823a182, 0x18250000,
0x201c10c3, 0x054d6d25, 0x1737172d, 0x06fa0107, 0x12063506, 0x181d1c06, 0x290f11c3, 0x8020fafe, 0x1580604b, 0xc3189c95, 0x8b23180d, 0x8220804b,
0x45962021, 0xc020088d, 0x20290982, 0x00002400, 0x23153301, 0x1b074117, 0x82820320, 0x2b950124, 0xfe94162b, 0x012b1825, 0x957695c0, 0x0b0127eb,
0x00009595, 0x73180004, 0x19200db1, 0x20090961, 0x94461823, 0x3713250e, 0x152b8001, 0x24ab9f18, 0x1523538b, 0x82250000, 0x82172049, 0x63441803,
0x234d820b, 0x2a2a2a15, 0x2808a77d, 0x6aeb7f01, 0x2b2b566a, 0xec5a1801, 0x80002109, 0xe6189f83, 0x072309f1, 0x8e000b00, 0x08a1449f, 0x34110727,
0x6b013336, 0x43c2182b, 0x82538b25, 0x8f01209f, 0x834d859f, 0x45c0209f, 0x01230849, 0x8355552b, 0x4500209f, 0x02210c4d, 0xf3eb1800, 0x0336085b,
0x3d003d00, 0xab01ab01, 0x23000c00, 0x00002900, 0x15160701, 0x36270714, 0x07273435, 0x01370735, 0x07062707, 0x27373635, 0x17141506, 0x37231537,
0x37343526, 0x20820637, 0xab013734, 0x201a3333, 0xee2f260f, 0x1b4f011b, 0x08181832, 0x0d82ac09, 0x15828020, 0x0a066625, 0x8316191f, 0x30453520,
0x1d1e1f2a, 0x802f2634, 0xb0fe1b1e, 0x060e321b, 0xac05032c, 0x33211185, 0x251d8333, 0x0f200602, 0xab480005, 0x00122b0b, 0x00250016, 0x33353700,
0x8d833715, 0x8f858083, 0x12820320, 0x36342725, 0x88061537, 0x2aeb2d8e, 0x483232ab, 0x252f2638, 0xd52a5530, 0x80390885, 0x80eb3232, 0x3233c080,
0x0e5c3b46, 0x2a420d2c, 0x802f2535, 0x2b2beafe, 0x220f8a6b, 0x18003233, 0x2a0a0779, 0x000a0006, 0x2500001a, 0x82332707, 0x11172163, 0x12785e18,
0x55555527, 0xd6562a40, 0x747518d6, 0x56eb2508, 0x806a6a56, 0x1280c518, 0x2a066351, 0x00eb0195, 0x001c0014, 0x18290021, 0x2b0a9962, 0x11332726,
0x27261523, 0x33363435, 0x0ca08118, 0x2206156f, 0x836b0123, 0x2d350861, 0xd6411103, 0x11191119, 0x2a89616a, 0x261a4f71, 0x2b573e40, 0xea012c3e,
0x95fe1119, 0x2a2b1911, 0x0b801501, 0x1a119d03, 0x4f6289eb, 0x1a268071, 0x2c3e5896, 0x0c47413f, 0x2879f349, 0x00000006, 0x01000240, 0x014b18c0,
0x1156410f, 0x33351328, 0x15333715, 0xe5510523, 0x55012806, 0x120eb5aa, 0x83c00e12, 0x2bf52704, 0xfe2b2b15, 0x01822b6b, 0xfe2a0128, 0x125501d6,
0x1884fe0e, 0x0e40012f, 0xd6d5fe12, 0x2b80abd6, 0x802bd6d6, 0x0a235180, 0x15000729, 0x35250000, 0x62233507, 0x6f430beb, 0x55802405, 0x4380abab,
0xd526086f, 0xab4444ab, 0x6d43bb45, 0x8204200c, 0x01153b3d, 0x00eb01eb, 0x002f000a, 0x004d0037, 0x22353700, 0x27353526, 0x16141506, 0xea643337,
0x35262205, 0x082e5534, 0x06141523, 0x2a6a8223, 0x15151632, 0x36173233, 0x46373435, 0x22081c73, 0x671911d5, 0x2bfe5604, 0x59587d01, 0x1f597d7d,
0x2b111a21, 0x802b090c, 0x1f150d09, 0x152f2c0a, 0x4859151e, 0x412c0b83, 0x1611192a, 0x41161066, 0x0e07b761, 0x58313083, 0x11360a7d, 0x0d092a1a,
0x40090d2a, 0x0e442f1d, 0x147f46b2, 0x00002e08, 0x002a0003, 0x01d50180, 0x0007006b, 0x0016000f, 0x06061200, 0x36362626, 0x15210716, 0x35231523,
0x21152523, 0x16323335, 0x263426ab, 0x2e038201, 0x80aa017f, 0xaa0180aa, 0x23c0ebfe, 0x84110132, 0x26012913, 0x2b2b2a70, 0x33802a6a, 0x20264f83,
0xe7016b00, 0x4f89a501, 0x16254e84, 0x07053707, 0x2b508227, 0x37250725, 0xb4161617, 0x11163330, 0xa5310382, 0x0e95010f, 0x3001aa61, 0x2df8fe0f,
0x011e22b6, 0x2f168431, 0x28673011, 0x22222892, 0x5f280460, 0x400c4279, 0x08794a18, 0x0a006b24, 0x27431200, 0x6a988305, 0xfe210eb9, 0x0bb76a2a,
0x96d68023, 0x06b46a96, 0x21083f82, 0x0140002b, 0x00c001ee, 0x001f0013, 0x06162500, 0x23270707, 0x35352622, 0x32331533, 0x36371717, 0xbc182516,
0x13820737, 0xe7013008, 0x4f0c0a07, 0x261a9549, 0x0b1b4b80, 0x190c1848, 0x1a2674fe, 0x3e2c8080, 0x1a0c902a, 0x26952406, 0x1880ab1a, 0x08050b95,
0x2b261a65, 0x49c02c3f, 0xd5200745, 0x32266188, 0x23061416, 0x63883523, 0x15151622, 0xb525618c, 0x0d13130d, 0x24618360, 0xfe19116b, 0x255d84d6,
0x12802b3f, 0x5c84121c, 0x95111a23, 0x5e5a8680, 0xad200575, 0x0b255982, 0x00002100, 0x20a78b13, 0x20638316, 0x32648a37, 0x16323307, 0x551a266b,
0x2b3f2c55, 0x13033f01, 0x8215600f, 0x82802047, 0x1e2a2363, 0x1f49130c, 0xfec02606, 0x40170fa6, 0x82c48355, 0x000f2267, 0x066f6103, 0x1500d822,
0x2a266182, 0x17250000, 0x54822707, 0x26272730, 0x36333736, 0x37161717, 0x17270615, 0x13841517, 0x16173329, 0x26023316, 0x82363626, 0x064f0808,
0x207b5a01, 0x23179251, 0x17031d05, 0x0f160113, 0x30343023, 0x9663163e, 0x2a063c28, 0x24042a2a, 0x061c3f18, 0x0e0e2314, 0x60c01407, 0x171d4020,
0x0420147e, 0x251b0c03, 0x22082e0a, 0x332b5557, 0x17cad127, 0x1413011f, 0x0a071c23, 0x821c230b, 0x00552c8b, 0x01ab0135, 0x001600d6, 0x822a0022,
0x648a848b, 0x72820733, 0x22153326, 0x07331527, 0x210a0641, 0x16582636, 0xab013305, 0x1a6c4b1f, 0x01131d26, 0x111e1013, 0x383e1a39, 0x5841bf4a,
0x1a2f3506, 0x1a1a221a, 0x264b1f54, 0x1d137b1a, 0x18132110, 0x154f2f2f, 0x20056141, 0x211a8315, 0xe5471a22, 0x05356305, 0x07000326, 0x28000b00,
0x220d3365, 0x6b062237, 0x01211971, 0x24ee8215, 0x11ea2a2a, 0x116d6b19, 0x2a4b0124, 0x0284602a, 0x6a82a020, 0x230a6d6b, 0x12191912, 0x2c088f4c,
0x000200d5, 0x001d0006, 0x07171300, 0x48601805, 0x4e332012, 0xc026058a, 0x00019595, 0x421880fe, 0xa22b0b09, 0x55550f46, 0x2b01460f, 0x6c2b5556,
0x89830955, 0x12000123, 0x201c8519, 0x24678400, 0x01eb0140, 0x206784c0, 0x21db821a, 0x67873507, 0x1150e018, 0x01256488, 0xaa6b1119, 0x24a9836b,
0xab551501, 0x235f8bd6, 0x11192b2b, 0x00206183, 0x355f7a18, 0x66825383, 0x2107056d, 0x4f891911, 0x09194b18, 0xed431420, 0x15072506, 0x35273523,
0x09358118, 0x56012008, 0x6a4b1a10, 0x01101a4b, 0x012a562a, 0x75101b6b, 0x4b40404b, 0x551b1075, 0x00005555, 0x69550004, 0x0f25085d, 0x29001b00,
0x08b76700, 0x42220621, 0x132c052d, 0x37233523, 0x32333336, 0x05231717, 0x2e051863, 0x15163233, 0x01152315, 0x19192472, 0x84d91924, 0x40b53905,
0x1e0b3640, 0x360b1e02, 0x20f5fe40, 0x1140111a, 0x8001201a, 0x18182419, 0x05821e83, 0x8092fe31, 0xa21e1ea2, 0x1175a080, 0x75111a1a, 0x6f0300a0,
0xa1310669, 0x0c000700, 0x00001400, 0x17323637, 0x07222607, 0x22078317, 0x84203627, 0x3e6b3a0c, 0x2c2a3daf, 0x1a2b2c7e, 0xeb401a4c, 0x61130162,
0x50e0502b, 0x2b3d3deb, 0x8213822c, 0x61612512, 0x004f4f2b, 0xc54a4d82, 0x00eb2605, 0x0013000b, 0xa18a182b, 0x1527270d, 0x26343533, 0x9b4b0622,
0x22212207, 0x05284326, 0x36343522, 0x3c5ecb83, 0x84572506, 0xc2273627, 0xff219e83, 0x24058300, 0x3f583f15, 0x05425eab, 0x2b2bd528, 0x4627271b,
0xb1481119, 0x2c2b2407, 0x182c3f3f, 0x200a137b, 0x935b18aa, 0x83282008, 0x07172ac9, 0x26330706, 0x17163727, 0x22058437, 0x82363621, 0x070627ce,
0x03153225, 0x2c6b0615, 0x37640806, 0x5c406b36, 0xd625311c, 0x200c0f0b, 0x31272b18, 0xfe33450b, 0x4f9b3b2a, 0x2d773d19, 0x340b1301, 0x120f1803,
0x036f0519, 0x3d0340eb, 0x0a0b2506, 0x2a18103e, 0x193c1427, 0x0e2f3b33, 0x2d290839, 0xedfe0a80, 0x19140e01, 0xf80a0b12, 0x02000008, 0x15004000,
0xeb01c001, 0x23001500, 0x15130000, 0x33363627, 0x085ebc18, 0x03412720, 0x07012405, 0x41230627, 0x372e0500, 0x27be3727, 0x2c293b05, 0x1a11153f,
0xfc8274dd, 0x1a020125, 0x83060818, 0x2c1728fd, 0x1a80011a, 0x82362827, 0x111923e5, 0xfe83dcb2, 0x1a94fe2b, 0x11190218, 0x2b0c19d6, 0x073b421a,
0xd501d536, 0x0a000600, 0x2b001200, 0x17010000, 0x35233507, 0x23351733, 0x08e4f218, 0x65333721, 0x22240758, 0x33353526, 0x27221982, 0x94831537,
0x6b012808, 0xabab4040, 0x12495515, 0x0d120c0c, 0x26aa2ad6, 0x112b2634, 0x4056961a, 0x1a11eb40, 0x4040d501, 0x40d62b2b, 0x830d8040, 0x2a332a1f,
0x1a26261a, 0x40401119, 0x2417822a, 0x0000111a, 0x21e38203, 0x7d830115, 0x0f00032b, 0x00001b00, 0x23273337, 0xf1401827, 0x2305210a, 0x0829d518,
0x4a953333, 0x01651f2b, 0x363b1ca0, 0x267d5843, 0x4a56013c, 0x3009849a, 0x2aeb1f63, 0x1b60febb, 0x587d263c, 0x9f3b3643, 0x2007849a, 0x0bb95164,
0x0b000325, 0x82250000, 0x07eb57b6, 0xc1180120, 0x022811f3, 0x4000d500, 0xc0012b01, 0x2d829582, 0x11331324, 0x69451423, 0xd5223205, 0x24195656,
0x01241919, 0x6700ffc0, 0x24181824, 0x4c238219, 0x042207cf, 0xbb820900, 0x3325003f, 0x11070606, 0x23171616, 0x26261127, 0x16013634, 0x4c6c07bf,
0xbf076c4c, 0x6f6f512b, 0x210882ea, 0x1082aa01, 0x56febf28, 0x7aa67a08, 0x41180400, 0x0a200a5d, 0x17203f82, 0x362d9f82, 0x26233736, 0x11171614,
0x33153706, 0x08c85a2e, 0x3a152208, 0xc0940753, 0x693f4056, 0xa7530794, 0xb07d7db0, 0x5307577d, 0x6082563a, 0x08520108, 0x533a9408, 0x05cb5a33,
0xc75b0320, 0x82072008, 0x18192051, 0x200939fa, 0x82c78606, 0x32332e96, 0x23061416, 0x563bde22, 0x08563c3c, 0x29cc8319, 0x1c1d28d5, 0x1d1c2828,
0x13831901, 0x83703b21, 0x5c1929e9, 0x3a272838, 0x01000027, 0x7624a782, 0x9501d501, 0x82053d68, 0x272621de, 0x0806c672, 0x2223262b, 0x33362707,
0x01371732, 0x072541d5, 0x5619062b, 0xa0208055, 0x553b3d55, 0x481e3b49, 0x3d47665a, 0x3b496c01, 0x612e3348, 0x27178256, 0x34454656, 0x444f401e,
0x8a235389, 0x62000700, 0x17230575, 0x824b2707, 0x1e972b39, 0x207655b5, 0x1eaa56a0, 0xc71856cc, 0x1b240a8b, 0x3f003300, 0x25061945, 0x27220614,
0x04860727, 0x2707ff43, 0x16171533, 0x15373233, 0x2121d982, 0x83148222, 0x1737260c, 0x37373216, 0x210e8227, 0x0b823734, 0x38081b82, 0x261a8001,
0x2e0c2219, 0x0c230c2e, 0x220c2e2d, 0x6b1a2619, 0x1e164d2a, 0x090c1416, 0x0c09aafe, 0x161e1713, 0x3e151717, 0x114b1715, 0x2424071a, 0x40011907,
0x11211a26, 0x83328319, 0x11193003, 0x2b261a21, 0x0d16952b, 0x0c0c0962, 0x830d6209, 0x1715322e, 0x0b111abe, 0x0b3f3f0b, 0x001a110b, 0x2b000c00,
0x09117200, 0x17001323, 0x05b75d00, 0x17822720, 0xc7822f20, 0x00003925, 0x18231525, 0x7a85f1de, 0x0a26099b, 0x1c001400, 0x9b822400, 0x16163223,
0x239f8215, 0x22362734, 0x21230a84, 0x5b363435, 0x16200710, 0x35064c46, 0x421c5501, 0x072a8038, 0x374238b9, 0x7838d5fe, 0x34262634, 0x05838525,
0x10eb2629, 0x35351724, 0x84011e2c, 0x24172307, 0x1684263a, 0x00370584, 0x00000005, 0x01000280, 0x00070095, 0x0017000f, 0x002f0023, 0x59323600,
0x2520055a, 0x4c187886, 0x1723076f, 0x82362722, 0x32332585, 0x27061416, 0x2f059e4b, 0x33353335, 0x5850ed15, 0x0e0100ff, 0x91403825, 0x2b3d5a84,
0x1313090a, 0x261a0a09, 0x2b40ef26, 0xeb2b4040, 0x2b2b1d23, 0x1f061f1d, 0x222b2b17, 0x25788448, 0x441b0326, 0x0a82031b, 0xde6c1620, 0x00002305,
0xf173000a, 0x75b51805, 0x07a9410b, 0x3b512c20, 0x50032009, 0x476e06a3, 0x33372e13, 0x33112115, 0x01173735, 0x2a2a2a95, 0x83038256, 0x2e078502,
0x80fe80d5, 0xc0404080, 0x2a552b2b, 0x8200012a, 0x8409821e, 0x88aa200c, 0x01d52508, 0x40402a2b, 0x230a2762, 0x000d0005, 0x69af9c18, 0x8a099f62,
0x32362477, 0x41231716, 0x7f1810ee, 0xdb260f67, 0xda0d3b4a, 0x9d18220d, 0xd5241626, 0x69212129, 0x270a457a, 0x658c65d3, 0x1b018c65, 0x08c94518,
0x2d05e147, 0x001300cb, 0x2500001a, 0x35211517, 0x01193537, 0x2e080ddb, 0x33352622, 0x80010614, 0x2baafe2b, 0x1c122d33, 0x80332d12, 0x1a561912,
0x15152bab, 0x4a326a2b, 0x130d0f0b, 0x0b0f0d13, 0x19ea324a, 0x48191111, 0xcb220835, 0x3b5b0700, 0x54352006, 0x372005e3, 0x06205d92, 0x01255d84,
0x2e4e2e55, 0x2b608ad5, 0x561a226f, 0x37298095, 0x16802937, 0x65866694, 0x8301c021, 0x001922b9, 0x28bb8227, 0x37363627, 0x36323733, 0x06804833,
0x15161622, 0x03255d85, 0x07171616, 0x2dd88427, 0x01372737, 0x0a03bf80, 0x01060102, 0xcb840206, 0x19246e36, 0xcb188456, 0xfe2b1b36, 0x3c112bdb,
0x01c9c71b, 0x02030105, 0x1830d489, 0x3a011212, 0x1b39d019, 0x6b2b152b, 0x1c3b2029, 0x2b082d46, 0x000500cb, 0x001f0019, 0x24000025, 0x3721c784,
0x31e29115, 0x37272617, 0x06251716, 0x37362307, 0x19241201, 0xe78a5655, 0x46052a32, 0xfe05531e, 0x2b0547cd, 0x192b5305, 0x6ad21211, 0x272aee8f,
0x401e3356, 0x57328967, 0x91494067, 0x00cb3209, 0x001d0009, 0x01000024, 0x33152335, 0x35331507, 0x97031923, 0x28958414, 0x6a350106, 0x3b6a3b3b,
0x0fc14186, 0x262f0127, 0x26264926, 0x41728f3b, 0xe78206c8, 0x28059743, 0x000800c0, 0x001a0011, 0x06f54523, 0x37233008, 0x27133507, 0x06141533,
0x27352323, 0x23153707, 0x023d2622, 0x33333634, 0x23172715, 0x1a119501, 0x5656166b, 0x111a6b16, 0x56166a80, 0x821a1180, 0x210e8208, 0x0785c001,
0x83d5fe21, 0x406b2113, 0xaa202185, 0x79182d84, 0x0d260a6f, 0x2f001b00, 0xaf5c0000, 0x16232105, 0x16296584, 0x15062237, 0x26331714, 0x18658335,
0x5a087b88, 0x372e0847, 0x00011733, 0x2d023f2c, 0x551a2604, 0x09883421, 0x4d187720, 0x952a0dda, 0x0e072c3f, 0x261a070e, 0x0988d62b, 0x111a4024,
0x605a00ff, 0x2a2a2207, 0x23401800, 0x6587450a, 0x18000721, 0x45079340, 0x1f260587, 0x31002900, 0xd5763e00, 0xa4801809, 0x14062509, 0x34363216,
0x17260f87, 0x23263435, 0x21460722, 0x22262505, 0x25151506, 0x3206bd45, 0x17323336, 0x22710136, 0x1a221a1a, 0x2c2c3e0c, 0x8afa2c3e, 0x47e0370b,
0x0b261a24, 0x47484720, 0x602b2b01, 0x2b602afe, 0x0131312f, 0x22831975, 0x3e2c5c26, 0x493e2b2b, 0xa1270b8a, 0x0c1c0a1a, 0x821a0d0d, 0x0a1c2e06,
0x1f27601a, 0x271f3a3a, 0x00001616, 0x0cdf4802, 0x46083946, 0xca37079e, 0xaafe756c, 0x323246ce, 0x2fd53246, 0x262b2b26, 0x3346325a, 0x4c004633,
0xab2908a3, 0x13000700, 0x00001b00, 0x21b58624, 0x58463327, 0x08dc4609, 0x46830a20, 0x40401523, 0x2002822b, 0x204d8ae3, 0x21108385, 0x53866b40,
0x8b880420, 0x11000927, 0x21001900, 0x468f8300, 0x362205ca, 0x49623236, 0x22162805, 0x21151506, 0x6c263435, 0xe027060c, 0xfe3f4c40, 0x84493faa,
0x58813455, 0x6f040156, 0x261a1a26, 0x2a12eb1a, 0x1a40401a, 0x8333d22a, 0x21b62b19, 0x0c17170c, 0x19261ae1, 0xf3842619, 0x95018026, 0x05009501,
0x00286782, 0x23113701, 0x15070735, 0x0135b889, 0x362a6035, 0x2a565660, 0x7e015656, 0xe2ebfe17, 0x2b55020b, 0x20028255, 0x0a4d4300, 0xf9820320,
0xf9830b20, 0x65182520, 0xc9571a0f, 0x11002207, 0x05415c1a, 0x18111a21, 0x5f15ffa3, 0x17200997, 0x2006b550, 0x25e38236, 0x06141527, 0xfb532323,
0x5407200c, 0xcd4a0927, 0x7e360808, 0x1a303b2d, 0x090d2a11, 0x0c09802a, 0x11881e15, 0x5705661a, 0x7d7db004, 0x308d7db0, 0x13563543, 0x2b191109,
0x0c2b0c09, 0x29544009, 0x6615111a, 0x60411214, 0x3e467601, 0x7b481805, 0x00063909, 0x0100000c, 0x35231517, 0x17172707, 0x27071537, 0x2beb0001,
0x9556ebc0, 0x012c0082, 0x94ab80c0, 0x52598069, 0x51515652, 0x002e2682, 0x012c0040, 0x00d501c0, 0x25000026, 0xa3821632, 0x3526222f, 0x06273734,
0x34262223, 0x17323336, 0x220e8237, 0x82163236, 0x27223cc0, 0x07141607, 0x80013617, 0x3225241a, 0x13970125, 0x26261a19, 0x9613191a, 0x82342602,
0x14183108, 0x98020296, 0x1925a912, 0x1a25251a, 0x1158040a, 0x11231682, 0x82050a57, 0x26342825, 0x0a0a5812, 0x1810580a, 0x33084d58, 0x000b00f2,
0x37000020, 0x34353632, 0x06070627, 0x13161415, 0x08794a18, 0x0d823720, 0x19833320, 0x27263308, 0x0c3b2bfa, 0x283c441f, 0x644b4043, 0x2c45648e,
0x08292021, 0x2b3b6b04, 0x0e292a2c, 0x271c350d, 0x95348701, 0x64644654, 0x08526c46, 0x222d2e21, 0x616a3414, 0x0781420b, 0x0000292c, 0x17163236,
0x07222623, 0x43753623, 0x14062205, 0x078b4212, 0x6a06034c, 0xdb2c0754, 0x230d3b4a, 0x23196219, 0x658c1a0d, 0x08cf0919, 0x1a136a26, 0x831a1313,
0xd5260584, 0x2a2a2129, 0xbf475721, 0x8330200b, 0x8320821d, 0x48002002, 0x47440abb, 0x75232007, 0x779709c5, 0x15330723, 0x79511823, 0x22718b0b,
0x1880807e, 0x8b0c8151, 0x2040216e, 0xf18c6f8a, 0x06333727, 0x27262206, 0x20f19f33, 0x20ec83cf, 0x20f6833b, 0x26f19604, 0x29212aab, 0xa3802129,
0x000526f1, 0x001d0011, 0x05a97925, 0x23171624, 0x3d613736, 0x1737250a, 0x27071707, 0x4905ca5e, 0x0721153d, 0x20008217, 0x82038216, 0x8a9c2002,
0x8a89200b, 0x29d52899, 0x17542121, 0x82161716, 0x21068200, 0x0a824317, 0x16222a85, 0x5549ef16, 0x0bcd490d, 0x8f440b20, 0x22242507, 0x06332726,
0x17228683, 0x92823707, 0x8f072721, 0x25012f8b, 0xda0d3b4a, 0x1716a30d, 0x41172e2d, 0x65822d2e, 0x808a7220, 0x80828b20, 0x17177824, 0x03852d2d,
0x8cc01721, 0x091f7474, 0x7c180520, 0x272007b9, 0x61098872, 0x4618066f, 0x1225077c, 0xfe121919, 0x260583d6, 0xa21fc095, 0x71c01e4c, 0x4b890dbd,
0x13000f22, 0x7a05f347, 0x05250be3, 0x01211121, 0x09964495, 0xfe2a0126, 0x012a01d6, 0x2b22448c, 0xf14fd6fe, 0x655c180b, 0x106b642f, 0x4207a36e,
0x362007c7, 0x42064743, 0xa9250bbb, 0x583f3f58, 0x0cb2423f, 0x10821320, 0x82583f21, 0x4e0020c2, 0x23080507, 0x000900d5, 0x37072500, 0x17373727,
0x01170717, 0x74238400, 0x993c3c99, 0x50902374, 0x8d0d6596, 0x96650d8d, 0x4030b785, 0xd501d501, 0x0f000500, 0x17250000, 0x27273727, 0x27202e82,
0x012a3885, 0x47155000, 0x74d5245e, 0x3e858423, 0x5b30b729, 0x4356083e, 0x85509665, 0x22418b44, 0x87130009, 0x07072641, 0x07250717, 0x25458d17,
0x15475e24, 0x4a8e2501, 0x3e085624, 0x4e89b45b, 0x01000522, 0xff22c282, 0xbd820002, 0x1f001326, 0x4e004400, 0x20080f82, 0x23171632, 0x07272626,
0x23341727, 0x32331523, 0x27353637, 0x15161732, 0x06071415, 0x07352323, 0x82088316, 0x2622240a, 0x18143335, 0x2808e553, 0x15222334, 0x36373423,
0x082a8333, 0x37071440, 0x26220717, 0x16163327, 0x93640001, 0x45052008, 0x6f511d35, 0x2413142f, 0x352f020a, 0x16150513, 0x1c313123, 0x0f050605,
0x1b1e1819, 0x1f1c0c0f, 0x1a1d1010, 0x100f1c19, 0x040e2316, 0xbf181d48, 0x2f080734, 0x63870002, 0x1c19603b, 0x7b39fb51, 0x59110722, 0x08160c2f,
0xaa161526, 0x0a1c0b53, 0x0c040c0a, 0x0e0b1718, 0x17321636, 0x1b0d0f11, 0xd9170c08, 0x07a34b18, 0x6b670220, 0x000b2208, 0x25d38213, 0x35231123,
0x05831523, 0x41262121, 0x013906e1, 0x2a2b80c0, 0x8001802b, 0x1a1a22d1, 0x40011a22, 0x8080ebfe, 0x6a2b1501, 0x200f8319, 0x056b4300, 0x6d18c020,
0x002e0c15, 0x21151713, 0x15330535, 0x21350523, 0x07820315, 0x03822720, 0xfecbf539, 0x402a016b, 0x01d6fe40, 0x4040eb95, 0x01404080, 0x2b2b6beb,
0x826a9655, 0x96002209, 0x077b6096, 0xc001d528, 0x0b000700, 0x15642500, 0x35072409, 0x50071533, 0x112a07cf, 0x21333634, 0x15151632, 0x3b702223,
0x48012905, 0x1a13131a, 0x15d53513, 0x0884d318, 0x1a112a27, 0x191912c0, 0x050e6412, 0xaaaa4729, 0x1a11152b, 0x8201111a, 0x111a2117, 0xaa242682,
0x03001a11, 0x68088d75, 0x002105e7, 0x069c4837, 0xa1483620, 0x86272006, 0x077b4368, 0x0001802e, 0xc0585058, 0x26263426, 0x1219da34, 0xfe2a4c85,
0x951912d6, 0x251d1515, 0x17837425, 0x97432620, 0x0a15530a, 0x27051146, 0x37323600, 0x06222626, 0x08156918, 0x28076341, 0x012fa2af, 0x01584e58,
0x2c42849a, 0x7d7db098, 0x45667db0, 0x1d25261c, 0x206d84ea, 0x05ef4766, 0x15000428, 0xc3012b00, 0x6b45eb01, 0x00392306, 0x40183700, 0x35300c23,
0x16171633, 0x36331716, 0x06071737, 0x16072323, 0x8706c341, 0x35372c67, 0x35333523, 0x15331533, 0x18991523, 0x08093240, 0x14144636, 0x960a2405,
0x5225074b, 0x139f190c, 0x191922c0, 0x22bc1a22, 0x19221a1a, 0x2a404080, 0x05c54040, 0x0a111a2b, 0x2aa2350a, 0x4d092b2a, 0x150e8815, 0x48231695,
0x27821e82, 0xda230584, 0x82402b40, 0x08934602, 0x1800d821, 0x24657fd0, 0x000b00d8, 0x06535213, 0x4a010021, 0xdb450a07, 0x07a74407, 0x07530419,
0xcf180120, 0x052a37c9, 0x2b002300, 0xd801d501, 0x73820300, 0x21001d36, 0x00003100, 0x37270713, 0x15062713, 0x32331614, 0x17001603, 0x099b5618,
0x27211882, 0x20048205, 0x05145407, 0x089f5618, 0x12ab3c08, 0xd2d2131f, 0x343e5722, 0x19014cf6, 0x372f1b25, 0x2f705047, 0x181e1811, 0x1bb2011d,
0x1b731b62, 0x2a2a2118, 0x21137050, 0xba015709, 0xfe0f1e0f, 0x352ad2a0, 0x7a01583e, 0x82e8fe4c, 0x712f3a2e, 0x1137464f, 0x1d131f14, 0x2053212e,
0x14200958, 0x282c4f71, 0x3e1c1820, 0x09814857, 0x5000d821, 0x192605c5, 0x00001d00, 0x96823737, 0x5e183720, 0x14250a59, 0x34262206, 0x839b8237,
0x69e1379f, 0x16448017, 0x57577c0f, 0xa045577c, 0x70a07070, 0x621b6268, 0x8a824801, 0x836aca21, 0x18a2201a, 0x240ad6d0, 0x5220527e, 0x36768252,
0x00060000, 0x0100002b, 0x000402d5, 0x00070003, 0x0026001a, 0x634c0032, 0x373409b7, 0x34211516, 0x36262737, 0x33361717, 0x36371732, 0x32160716,
0x2108dd74, 0x0b8a2434, 0x21351722, 0x8305244b, 0x35352296, 0x058d4a23, 0x23352208, 0x40012622, 0x8b155615, 0x3400ff35, 0x0710081c, 0x1e1f1a20,
0x0e08201a, 0x131a4107, 0xfe131a13, 0x250684a9, 0x0c000155, 0x0f821609, 0x03822a20, 0x0c091625, 0x82169501, 0x263d2500, 0x1c254241, 0x20312b82,
0x07200e0e, 0x1399080e, 0x120e950d, 0x0d950e12, 0x25098813, 0x09d5d5c2, 0x15834b0c, 0x05854b20, 0xb36b0c20, 0x23d5830b, 0x25000015, 0x37208f82,
0x630b8364, 0xc0261395, 0x80552b2b, 0x2560c080, 0x056f5b10, 0x13000326, 0x1f001900, 0x15494818, 0x23151725, 0x84153335, 0x01352105, 0x0871a218,
0x1180fe2b, 0x55111a1a, 0x6ac06a2a, 0x1cc41840, 0x40802312, 0x02832b6b, 0xd14c0020, 0x00052158, 0x21057750, 0x294d00eb, 0x00132205, 0x0d0d5d29,
0xc14d1220, 0x0fab7a06, 0x3636332c, 0x01171632, 0xd6d6d66b, 0x056e9696, 0x21cb8405, 0xd183d6fe, 0x20075925, 0x1807202a, 0x27094442, 0x120c2b01,
0x0c120d0d, 0x230bfc48, 0x13181813, 0xeb2cd788, 0x0f000700, 0x2d001700, 0x35250000, 0x8705c352, 0x07434e79, 0x80238196, 0x45585058, 0x916e054c,
0x2e859005, 0x251d1e6b, 0x011e1d25, 0x26342600, 0x967b3426, 0x20898c88, 0x238b820b, 0x12000025, 0x5506ad77, 0x51660705, 0x3411230b, 0x03413336,
0x12f72605, 0x0c120c0c, 0x1800822a, 0x410a626a, 0x95200600, 0x0c28f382, 0x8080cd12, 0x012b2b55, 0x0c1a7318, 0xb118fd84, 0x0624093b, 0x24000e00,
0x2324fb83, 0x35170735, 0x241e7441, 0x6b6b5555, 0x90758409, 0x55c027ec, 0x406b6a40, 0xe5970001, 0x37257191, 0x15233523, 0x64451823, 0x25e28517,
0x406b0001, 0xe5414056, 0x6b802416, 0xa1d55555, 0x00052a6f, 0x0023000d, 0x27373700, 0x2b701807, 0x15d34109, 0x1eabd526, 0x891e378d, 0x9525e195,
0x378c1eab, 0x6770971e, 0x28080e21, 0x14151601, 0x27152306, 0x36321537, 0x27273435, 0x14150622, 0x35260717, 0x35333634, 0x90010717, 0x5546651b,
0x0f4b3555, 0x20038271, 0x330c841f, 0x32295b01, 0x56406546, 0x354b4055, 0x4b441e1e, 0x1f1b2135, 0x002b1186, 0x00000200, 0x00025500, 0x1800ab01,
0x2d4bdfa9, 0x012b0055, 0x00d501ab, 0x00140004, 0x66181300, 0x35211468, 0x08ba6836, 0x01111a23, 0x5f6618ab, 0x00013211, 0x0140006b, 0x00c00195,
0x0100000a, 0x11151632, 0x05c04427, 0x19116b33, 0x11199595, 0x111ac001, 0x4040abfe, 0x1a115501, 0x87c78200, 0x00042a2d, 0x2500000f, 0x37112311,
0x21348b13, 0x37866bd6, 0x15018027, 0x012febfe, 0x203d8b11, 0x79461803, 0x4437200c, 0x372b092f, 0x15162315, 0x23153315, 0x82071415, 0x06062a05,
0x23272622, 0x35263335, 0x22058235, 0x82373435, 0x72362005, 0x07350848, 0x2b011716, 0xd6565656, 0x2b2b022d, 0x113c2d02, 0x113b463b, 0x080c863c,
0x23180f24, 0x1e0f2f1e, 0x231e2f0f, 0x00010f18, 0x2a552b2b, 0x0e2aaa2a, 0x152b1508, 0x1d2b0e07, 0x2b1d2323, 0x0c82070e, 0x2a0e082e, 0x1e231119,
0x2e03032e, 0x1911231e, 0x00298a82, 0x010d000e, 0x00ee01eb, 0x08d78216, 0x07061631, 0x27270607, 0x26272606, 0x37173726, 0x17163627, 0x01071616,
0x080107e4, 0xc20f0f31, 0x201e5124, 0x405e1410, 0x2058265c, 0x6b0f111e, 0x83071304, 0x110f2f16, 0x2658201e, 0x125c405c, 0x511e200e, 0x9c180024,
0x0e37099b, 0x00001d00, 0x27073313, 0x33363433, 0x26071732, 0x25062223, 0x18142317, 0x32077865, 0x80233536, 0x40565540, 0x29324665, 0x35211b1f,
0x8a15014b, 0x01402b0c, 0x46555500, 0x0f1f1b65, 0x0786204b, 0xbf4c3520, 0x01552405, 0x82ab01d5, 0x82052067, 0x211334c0, 0x01210713, 0x56fed500,
0x100188d5, 0xaafeab01, 0x82da0501, 0x002b221b, 0x2425822b, 0x000500d5, 0x0845430d, 0x4e06f349, 0x3d25056b, 0xb07d7db0, 0x05654e7d, 0x0982d520,
0x82b07d21, 0x0015242b, 0x82eb0140, 0x0003215b, 0x2107915b, 0xd0682500, 0x07d5550a, 0x15331724, 0x03823523, 0x03821520, 0xfc180120, 0xd5210c95,
0x38008496, 0xfe15016b, 0x1a4001eb, 0x11ebfe11, 0x01111a1a, 0xe01a1115, 0x15208a20, 0x08f15120, 0x243dbf42, 0x002b0002, 0x20df8280, 0x26b38280,
0x2500000b, 0x50372737, 0x17290548, 0x63370107, 0x80801e63, 0x2403828c, 0x629e631e, 0x83078362, 0x00622303, 0x35820300, 0x2309c963, 0x01000017,
0x20064f77, 0x6b491801, 0xab01250e, 0x5601aafe, 0x4f180383, 0x012609ab, 0xd52b2b55, 0x4f188080, 0x69470d9b, 0x820f2011, 0x15332755, 0x33351123,
0x97682115, 0xab152507, 0x80feabab, 0x01250482, 0x00ff80c0, 0x224582d5, 0x43d5d5ab, 0x07220a55, 0x35821100, 0x2a082f83, 0x03173337, 0x14112111,
0x22232306, 0xfe950126, 0x6a164ad6, 0x0001cb16, 0x11aa111a, 0x2bab011a, 0xfe15152b, 0xff0001c0, 0x601a1100, 0xab210893, 0x05236401, 0x18000a22,
0x33214582, 0x087e4627, 0x9e4c1720, 0x34132d07, 0x15013336, 0xaa407676, 0x8080aaaa, 0x28055557, 0x01111901, 0x2be07540, 0x21d6822b, 0x96825501,
0x82191121, 0x11562211, 0x08d94619, 0x0700c028, 0x1f001700, 0xd9462f00, 0x72252009, 0x35200a25, 0xf1465482, 0x29178f07, 0x1a1a2284, 0x40011922,
0x315e0c09, 0x090c2205, 0x2111902f, 0x22824001, 0x66221928, 0x0980090c, 0x04820d0d, 0xabfe0c23, 0x20258319, 0x840c8467, 0x7a002016, 0x1d311875,
0xff1ee3a6, 0x001e7700, 0x00090003, 0x01f9016b, 0x08098489, 0x00000d21, 0x07173737, 0x27011701, 0x07371737, 0x1e093727, 0x5a011e77, 0x7800ff1f,
0x8787591f, 0x83e2871e, 0x841e200f, 0xc459243a, 0x4d881e88, 0xeb2008eb, 0x1b200982, 0x0020ed82, 0x4e8fb818, 0x2209b151, 0x51200017, 0x35300db1,
0x11211533, 0x35231521, 0x13333634, 0x33352337, 0x0720b382, 0x3107be51, 0x012b1912, 0x2bd6fe2a, 0x376c1219, 0x1e37cece, 0xc6516b6b, 0x55552c09,
0x55552a01, 0xf3fe1a11, 0x82382a38, 0x0d9f4a19, 0x13000b28, 0x37250000, 0x59540707, 0x06f74308, 0x512f0136, 0xb02851af, 0x7db07d7d, 0x0d0d14cb,
0xafd10d14, 0x5501af51, 0x7d220e82, 0x0e8241b0, 0x00140d25, 0x732b0001, 0x2f200605, 0xa956ab84, 0x06644908, 0x2622232a, 0x32333535, 0x23263436,
0x3320b684, 0x3906d15b, 0x15163233, 0x16b50115, 0x20162020, 0x22511119, 0x11512230, 0x21182019, 0x0e821821, 0x2c1f5628, 0x1911561f, 0x07851501,
0x25871687, 0x56203486, 0x310b4f6f, 0x0016000e, 0x0026001e, 0x36323600, 0x06273435, 0x15562223, 0x20d28705, 0x0ebe4e04, 0x658cba2a, 0x6e1d1307,
0x014f2140, 0x27052777, 0x10160a01, 0x70101610, 0x552b0584, 0x1a164665, 0x23505a05, 0x5d460c06, 0x53210660, 0x2019830f, 0x8405840f, 0x01392cf5,
0x00c001d5, 0x25000014, 0x6b032e27, 0x362005a3, 0x2b08d583, 0x07060614, 0x351f0001, 0x43163b30, 0x26263a32, 0x3443323a, 0x1c39453d, 0x37442e30,
0x2d44311d, 0x2731442d, 0x003e3e54, 0x002b0002, 0x18224385, 0x45822d00, 0x44823e20, 0x22232626, 0x26230706, 0x15310683, 0x17021e14, 0x16321317,
0x020e1415, 0x2e270707, 0x08638602, 0x30020121, 0x2b15362e, 0x082b1920, 0x192b0828, 0x36152b20, 0x6002302e, 0x3b164332, 0x1f1f3530, 0x84343d45,
0x74220876, 0x2e3c2c2b, 0x1c2a2016, 0x2a1c1616, 0x3c2e1620, 0x01022b2c, 0x1d31444e, 0x302e4437, 0x3e3e1b1c, 0x8c832754, 0x210d0942, 0x3f700007,
0x056b4841, 0x21000724, 0x11570000, 0x27172307, 0x08513536, 0x32332f05, 0x23061737, 0x35262221, 0x33363413, 0x01511733, 0xc5270805, 0x583f1252,
0x1f2c3f3f, 0x0e0b5e1c, 0x1a1100ff, 0xab111901, 0x2634d180, 0x4d263426, 0x2c1f1c52, 0x3f583e3e, 0x44085f12, 0x802d056f, 0x00020000, 0x01360055,
0x00ab01ca, 0x20678312, 0x052d4f25, 0x07273608, 0x16073335, 0x37363233, 0x22270633, 0x36230706, 0x17323336, 0x37231537, 0x67630126, 0x3028681f,
0x802c2c3e, 0x272d1f36, 0x042b0839, 0x083a278f, 0x3854082b, 0x2413843d, 0x671f68bd, 0x2709841d, 0xa4242530, 0x4a362530, 0x00210c84, 0xe9bd180d,
0x0010360c, 0x00190015, 0x0022001d, 0x002b0026, 0x0034002f, 0x003c0038, 0x897f1800, 0x11052307, 0xdb831521, 0x3505112a, 0x27061433, 0x07153335,
0x052e0382, 0x33352622, 0x35231513, 0x15163233, 0x08820723, 0x23150324, 0x79183634, 0x40300886, 0xff2b2b2b, 0xff000100, 0x01191200, 0x111a2b55,
0x122e0f84, 0x2a552b19, 0x2b1a11aa, 0x2b2b2a80, 0x13821219, 0x2b2b9529, 0x2b2b0001, 0x8200ff2a, 0x00012723, 0x1a112bd6, 0x24822bab, 0x1a562a23,
0x22188311, 0x84d5111a, 0x26168221, 0x2b562a2a, 0x8c09002b, 0x500b20bb, 0x282706db, 0x30002c00, 0x82370000, 0x82332099, 0x72372003, 0x152006c9,
0x25054246, 0x36343535, 0x17821333, 0x03820120, 0xb9831120, 0x0383c683, 0x2a257e82, 0x11d5d580, 0x2867821a, 0x12191912, 0xd5fe2b80, 0x82a5822b,
0x832b2099, 0x822b20c2, 0x0001211c, 0x8206e177, 0x80fe2126, 0xda828d84, 0x82111a21, 0x2a5622c2, 0x05174a2a, 0x95015523, 0x6bb41801, 0x20d48225,
0x05bb5500, 0x2023e955, 0x08f76504, 0x2005e94d, 0x09f3531f, 0x07f74e18, 0x6f4d0220, 0x07144406, 0x2c3f012d, 0x1f2c2020, 0x1f2c1f55, 0x83552c1f,
0x33202704, 0xb07d7db0, 0x11848b7d, 0x1184c120, 0x8400ff21, 0x2b01210c, 0x7d211782, 0x0b2f43b0, 0x9d5c1520, 0x42012005, 0x152a05dc, 0x32363433,
0x07071416, 0x0a821506, 0x35073724, 0x9a5b1523, 0x18412008, 0x200efcfc, 0x26658443, 0x1c141001, 0x18323223, 0x2609f5fc, 0x2a911b21, 0x856a012a,
0x0d375768, 0xff591b20, 0x17052111, 0x57090b59, 0x01240b3b, 0x37371e0c, 0x42570287, 0x8a03200c, 0x02003618, 0x40001500, 0xc001d501, 0x1c000500,
0x33010000, 0x27071715, 0x25c18226, 0x37272206, 0x2a413316, 0x15370805, 0x27270733, 0x00013433, 0x5b104b20, 0x71719e3a, 0x2c1e389e, 0x58583e3d,
0x5640577c, 0x01405302, 0x1a2d5a55, 0xa070d537, 0x2c1f3870, 0x57577c57, 0x5303563e, 0x49010050, 0xc02c0637, 0x00000a00, 0x23352337, 0x15231737,
0x3d080682, 0xd5406ad5, 0x566a40d5, 0xc0c0ab55, 0x000080ab, 0x00800003, 0x0180012b, 0x000400d5, 0x00130009, 0x35370100, 0x27171523, 0x03331507,
0x17071521, 0x37352115, 0x55000127, 0x5555aaaa, 0x0882d5aa, 0x00ff5532, 0x0b015555, 0xc04b4b55, 0x014b5555, 0x55558080, 0x38820383, 0x09234988,
0x88130000, 0x8880203b, 0x87d52033, 0x7f73182a, 0x05115007, 0x3a822720, 0x0f503520, 0x07d75205, 0x230bd97a, 0x33363435, 0x2b07b246, 0x36274201,
0x1a223127, 0xab1a221a, 0x280d046b, 0x1b2b5501, 0x2b1b2727, 0x221a82c0, 0x6ba6221a, 0xcb411105, 0x00032409, 0x4c0f0007, 0x214209d1, 0x2a152308,
0x15422a2a, 0x2b402706, 0x8080ab2b, 0x06424001, 0x08a16205, 0x0300d528, 0x13000b00, 0xdf821700, 0x6a333521, 0xcb420840, 0x82172007, 0x2aeb2213,
0x0a645a5b, 0x012ac022, 0xeb204a82, 0x220b5a5a, 0x418080c3, 0xeb2806f7, 0x0600c001, 0x00001e00, 0x2005c755, 0x0b284f17, 0x230b6648, 0x55d6d6eb,
0x082c7018, 0x80012b3d, 0x1a2b80fe, 0x2a40ab11, 0x19c05540, 0x11d5fe12, 0x56111919, 0x562c0156, 0x821a1155, 0x00552659, 0x01ab0134, 0x825982d0,
0x112527e3, 0x14150607, 0xb15f3716, 0x37373f05, 0x265a0001, 0x6432ad4c, 0x7932648e, 0x5a35015e, 0x4c343526, 0x648d32f9, 0x79328d64, 0x69180100,
0x0e2608c1, 0x17010000, 0x0c190607, 0x01360ac0, 0x0d5d5d78, 0x1a11ea16, 0x16ea111a, 0x83838301, 0xd6111912, 0x6f821911, 0x07f56918, 0x1300042a,
0x37250000, 0x25152327, 0x55253a8e, 0x01ea4c4c, 0x243f8a0d, 0xd66b6b95, 0x204288ee, 0xb7821800, 0x07220809, 0x14000c00, 0x1e001900, 0x2b002300,
0x35003000, 0x00003d00, 0x34363325, 0x14162327, 0x23373607, 0x0b832706, 0x17140623, 0x2e0c8217, 0x37362716, 0x16150706, 0x27272617, 0x82342633,
0x8214201d, 0x2633210f, 0x13820f82, 0xf3853220, 0x5d012608, 0x48060648, 0x203d2903, 0x03190a3f, 0x03036403, 0x520d1c32, 0x140a390d, 0x3d20203d,
0x48500a14, 0x06480303, 0x201383ab, 0x330f8378, 0x7d7db0ad, 0x1cd57db0, 0x2c151c1e, 0x2838148b, 0x152c1552, 0x7f2e0282, 0xd62c2c29, 0x38142428,
0x241438aa, 0x11822a28, 0xb91e1c22, 0x2c201382, 0x80200e83, 0x4a052642, 0x082f0935, 0x00001b00, 0x23153301, 0x37270735, 0x18351323, 0x2308db5b,
0x33363411, 0x112c1682, 0x2b952b01, 0x4cd11ed1, 0x111a2b6a, 0x2406395c, 0x95c00195, 0x2413824c, 0x9595d6fe, 0x06dc5811, 0xd6fe2b27, 0x40000600,
0x211b8200, 0x47186b01, 0x00290c2f, 0x21152113, 0x15213515, 0x46038425, 0x272005e5, 0x95246882, 0xd5fe2b01, 0x80210386, 0x1900832b, 0x2808d705,
0xab2b2b55, 0x2a562b2b, 0x0853662a, 0x266d7f43, 0x012b0055, 0x82eb01ab, 0x0021227d, 0x09ad7f29, 0x4307085a, 0x262c06e7, 0x23150622, 0x16323634,
0x22061515, 0x2005df6f, 0xbf951801, 0x27c2320e, 0x3f292736, 0x225a3f58, 0x1a221a1a, 0x01d6d655, 0x0aef4300, 0x27271b27, 0x3f3f2c1b, 0x060a442c,
0x8309917a, 0x000b2479, 0x852b0023, 0x6f13207b, 0x7d8b1e71, 0x766f3e20, 0x217d8912, 0x796f2b2b, 0x058a4414, 0x240bad46, 0x00180010, 0x277d822a,
0x23263436, 0x27070722, 0x2105644a, 0x14471717, 0x58571807, 0x70012f11, 0x17161f10, 0x0f0f100f, 0x0f1f1617, 0x5718ad5b, 0xba271367, 0x0f1f2c10,
0x830f1010, 0x015b2328, 0x5718130c, 0x00201274, 0x2405234c, 0x000002d5, 0x0dcf4c17, 0x36341124, 0x16503333, 0x01352805, 0x191911ab, 0x83aafe11,
0xab2b2405, 0x4e012a80, 0x13820576, 0x11000127, 0xab55801a, 0x08394280, 0x0200d524, 0xb3460e00, 0x13272405, 0x18352335, 0x20076c5a, 0x11bf4e13,
0x402a4025, 0x4e162a40, 0xfe210cc1, 0x231383f6, 0x2a014040, 0x180bc34e, 0x22096f9a, 0x821e0006, 0x05af46a5, 0x2b071545, 0x35333523, 0x15331521,
0x35262223, 0x0122b483, 0x59825500, 0x1912ea34, 0x5555111a, 0x5555d6fe, 0x12191912, 0x80562b01, 0x2c4fd680, 0xd52b2505, 0x111a2bd5, 0xab82b983,
0x21050157, 0x994300c0, 0x093b784b, 0x0d000632, 0x1b001400, 0x15250000, 0x33270733, 0x35072535, 0x0727ae83, 0x27152315, 0x47371537, 0x012b057b,
0x6b6b402b, 0x6b160140, 0x82c04040, 0x82552009, 0x25088403, 0x406b4040, 0x02824056, 0x15201d82, 0xf3501483, 0x000d240b, 0x8225001d, 0x4b372057,
0x51550bbe, 0x4416200f, 0x662b07eb, 0x380f3e1e, 0x28383850, 0x4183191a, 0x8a2c09ca, 0x2c20202c, 0x3e1e7c1f, 0x38281a19, 0x0f211e82, 0x0ba367f1,
0x831f6b21, 0x23738b1e, 0x00070003, 0x20456751, 0x082f6e02, 0x2f000b22, 0xe547c582, 0x16142306, 0xd6413632, 0x18362009, 0x2109445b, 0xde411716,
0x37332808, 0x2b011733, 0x821a221a, 0x83802002, 0x2d962acb, 0x46322b3e, 0x2d3e2b32, 0x240e8396, 0x27802744, 0x057f75eb, 0x1a1a1123, 0x05ae59bb,
0x47082d33, 0x3333232f, 0x08472f23, 0x01111a2d, 0x2b191100, 0x41d9832b, 0xed4405fd, 0x0f7d5808, 0x200f4f41, 0x06974b33, 0x77580120, 0x45698409,
0x152a05a9, 0x802baa2b, 0x25251d15, 0x6f58151d, 0x1a662206, 0x05125911, 0x112a0124, 0x00822b1a, 0x002c7383, 0xfe010000, 0x07000002, 0x4d004300,
0x2209074b, 0x54161737, 0x073405af, 0x23231407, 0x26273522, 0x27060727, 0x37372627, 0x36342634, 0x37250e82, 0x17173637, 0x200e8236, 0x12fe1833,
0x23328209, 0x06141516, 0x0805da56, 0x07012324, 0x1a880126, 0x131a1313, 0x0203176f, 0x1a040315, 0x06040f03, 0x0804062a, 0x02051a0a, 0x17030215,
0x18830101, 0x1a050224, 0x1884060c, 0x880e0421, 0x424f2918, 0x01f7025e, 0x4b0e01ab, 0x133e3f82, 0x0311021a, 0x02052504, 0x1d07030b, 0x041d0404,
0x05020b06, 0x11030425, 0x07040801, 0x1a821201, 0x0b02042d, 0x041c0308, 0x09021c04, 0x8204020b, 0x03122d1a, 0xaa080207, 0x0e08425e, 0x02f7ab01,
0x0e71e118, 0x1b001723, 0x0c7b5400, 0x2407ac43, 0x35231517, 0x21038237, 0x4f7d6b01, 0x2a80240a, 0x7d6b2a2a, 0xd625114e, 0x2b568080, 0x2259822b,
0x82550055, 0x00ab21a8, 0x285d8368, 0x00000003, 0x0100022b, 0x227182d5, 0x181f0016, 0x210a0345, 0x264f1415, 0x08584e0b, 0x01952008, 0x4b354b2b,
0x1a1a11e0, 0x11abfe11, 0x1119011a, 0x00ff2b80, 0x80fe8001, 0x60c01a11, 0x186b6040, 0x28096145, 0xfe2b2a19, 0x11192ad5, 0x01841801, 0x0004290c,
0x01000021, 0x07231533, 0x1c884118, 0xc0000124, 0x44184080, 0x302a0f22, 0x0d092f5d, 0x95c00124, 0x41183640, 0x5d260f84, 0x04092f30, 0xcf87000c,
0x0982c020, 0x0d000734, 0x33130000, 0x35172335, 0x32131523, 0x36010117, 0x00822aeb, 0x78881536, 0x00ff00ff, 0x2b550176, 0x018080d5, 0xc6fe5b15,
0x005a3b01, 0x200a5778, 0x05e54a03, 0xbc782520, 0x15052212, 0x10dd5c23, 0xaa550122, 0x2212da5c, 0x82808055, 0x0b0027e8, 0xf5015500, 0x8b83ab01,
0x07170136, 0x03273723, 0x33372723, 0x01131707, 0x55606095, 0x55a83860, 0x01210685, 0x220082ab, 0x83f2fe63, 0x0e012205, 0x0ab54500, 0x17001322,
0xda684882, 0x06172a08, 0x32161415, 0x27343536, 0x088b8327, 0x70447c25, 0x1e4470a0, 0x577c5737, 0x012a4937, 0x50583a92, 0x58507070, 0x472d1e3a,
0x3e57573e, 0xd54d2c47, 0x180000d5, 0x4c5d895c, 0x0520095d, 0x1520e782, 0xf018ad82, 0x02203bd9, 0x1908474f, 0x204bd90c, 0x081d6404, 0x1d00192c,
0x25002100, 0x11370000, 0x01893717, 0x07271122, 0x25200188, 0x20066557, 0x21078205, 0x00952040, 0x51200121, 0x01260533, 0x2b00ff00, 0x248baa01,
0x8a56fe21, 0x2bf5230d, 0x0e51552b, 0x05002105, 0x39061146, 0x000c00d5, 0x00180010, 0x00410020, 0x23352500, 0x27260717, 0x37270706, 0x70831523,
0x5c071b5d, 0x147907b1, 0x35262310, 0xec7d3634, 0x32333505, 0x07141516, 0x2d6dab01, 0x08084023, 0x6d2d2340, 0xaafe5601, 0x8505c65c, 0x58562005,
0x2f3f090e, 0x211a2604, 0x140b0b14, 0x04261a21, 0x193c80d5, 0x570b0b57, 0x6a803c19, 0x40012a2a, 0x5c0c120d, 0x0c2705e1, 0x12191e12, 0x841912ea,
0x070e2b04, 0x0f1c261a, 0x1a261c0f, 0x1f430e07, 0x05597308, 0x4b730a20, 0x13072809, 0x2a150113, 0x19d62a2a, 0x4f0df933, 0x58185bdf, 0x07230975,
0x5e001800, 0x571808c7, 0xea210c8d, 0x150d192c, 0x4fc14229, 0x4b00402a, 0xc001b501, 0x19000700, 0x24093751, 0x27071717, 0x06996c35, 0x1516323a,
0xa3170714, 0x50383850, 0x206ae038, 0x3426066a, 0x7451513a, 0xd5062150, 0x02821182, 0x11351382, 0x74502106, 0x343a5151, 0x00000626, 0x002d0002,
0x01d3012b, 0x205382d5, 0x4753893f, 0x06240a51, 0x27222323, 0x24095147, 0x27373426, 0x074f4726, 0x33333629, 0x16171732, 0x82363717, 0x07073705,
0x3ee11416, 0x2c3e2c2c, 0x05072dea, 0x3509042b, 0x02080f15, 0x03825608, 0x3511132a, 0x052b0409, 0x01012d07, 0xb5201a99, 0x2c3b3982, 0x05230a3e,
0x03074a09, 0x38060f15, 0x08380909, 0x0703150d, 0x2305094a, 0x97071c07, 0x08b95818, 0x3700c02d, 0x4f004700, 0x34240000, 0x82363727, 0x070722b3,
0x82058226, 0x070725bf, 0x26270706, 0x17260582, 0x17140617, 0xad820607, 0x16373722, 0xbf820582, 0xed82cb82, 0x27210582, 0x0fb34827, 0x3408034a,
0x05200170, 0x06031e04, 0x060c0d25, 0x063c0502, 0x09100601, 0x23118225, 0x01200504, 0x26201a99, 0x3f09c36a, 0x1a1a2284, 0x14f61a22, 0x06041805,
0x0f020534, 0x0627050a, 0x07072806, 0x3306020f, 0x05180406, 0xcf201897, 0x200b0549, 0x33428295, 0x0000221a, 0x00000002, 0x01c00140, 0x001600c0,
0x1200001e, 0x5206866e, 0x33210cdc, 0x05aa4f34, 0xb0323635, 0x507070a0, 0x281e3342, 0x57573e2f, 0x5640577c, 0x84eb4055, 0xc0012748, 0x2870a070,
0x14821b1e, 0x553e5725, 0x843f5055, 0x060028a3, 0x00006b00, 0x83027a01, 0x00052167, 0x2609fd5c, 0x15111527, 0x18073337, 0x240b4df3, 0x15333513,
0x07d74923, 0x0e59f318, 0xd62b403a, 0xcf2a2b2b, 0x07015028, 0x5c5b2850, 0x1e62a27a, 0x621e7778, 0x2b00fea2, 0x00230084, 0x82800005, 0x82802067,
0x16635d67, 0x8707e748, 0x27698365, 0xaaaa5501, 0x111a1a11, 0x952c0484, 0x802a802b, 0x0001ab2b, 0x550100ff, 0x25053848, 0x5501111a, 0x63881a11,
0x0967c818, 0x15000526, 0x29001900, 0x15357182, 0x26343632, 0x37273507, 0x17373335, 0x07171533, 0x27072315, 0x12934717, 0x1a000128, 0x206f2626,
0x02873520, 0x4018e020, 0x01260d56, 0x34268040, 0x1e889526, 0x41260882, 0xd4fe2c01, 0xb4415601, 0x26e7820b, 0x01750011, 0x828b01ef, 0x00092609,
0x0011000d, 0x2c858217, 0x37270717, 0x33350727, 0x23153715, 0x21078335, 0x12830727, 0x747b013a, 0x5d5d2174, 0x2b562a6f, 0x5d1a2bab, 0x7474215d,
0x8b8b8b01, 0x8570701b, 0x26062f78, 0x7070852a, 0x488b8b1b, 0x22320557, 0xeb01eb01, 0x1c000b00, 0x00002800, 0x15163212, 0xea4f3423, 0x82052005,
0x822720d7, 0x26352162, 0x2105975a, 0x8e182614, 0x013e1280, 0x401e4900, 0x20491e40, 0x731f2c1f, 0x3f2a577c, 0x012a3f58, 0x50618aeb, 0x61507070,
0x1c854692, 0x240d462f, 0x161f1f16, 0x3e57b924, 0x2c3f3f2c, 0xd19e183e, 0x000a2d0a, 0x00220016, 0x0039002d, 0x25000045, 0x1422cb82, 0xcd820706,
0x15032623, 0x54068233, 0x205f055e, 0x20848505, 0x84228301, 0x37262121, 0x2e8c2d89, 0x806b0125, 0x822b1318, 0x2b8033fd, 0xab0c120c, 0x0d2a802b,
0x55fe0c12, 0x132b2a80, 0x1a82ab18, 0x18132a24, 0x1b832a55, 0x2aab0d33, 0x0720152a, 0x010f5a5a, 0x80805557, 0x0d0d0955, 0x2b06855e, 0x2ad6fe09,
0x5a0f2d2a, 0x1520075a, 0x07232386, 0x863f0120, 0x40002024, 0xa346c0bf, 0x000b2609, 0x1300001d, 0x07594d15, 0x17353336, 0x15071533, 0x35273523,
0x36343533, 0x16323333, 0x162aab15, 0x2b240182, 0x40aa4015, 0x2305d26b, 0x2a40ab01, 0x40230082, 0x84808040, 0x19112703, 0x00001119, 0x63180007,
0x0f2a096d, 0x1f001700, 0x33002700, 0x6b183b00, 0x236a0975, 0x0f0f7007, 0x20072145, 0x05655936, 0x06217584, 0x05e55114, 0x1a3e0127, 0x131a1313,
0x2c05843d, 0x7070a0a5, 0xc25f70a0, 0x8ac28a8a, 0x25118493, 0x400e12ab, 0x0483120e, 0x25828320, 0xc01a1328, 0x12121c12, 0x0b847d1c, 0x2b82d820,
0x01a07023, 0x222c823b, 0x84a1c28a, 0x84d42018, 0x847d2034, 0x06002105, 0x3b68af82, 0x00162409, 0x681c0019, 0x132a173f, 0x15272707, 0x07172527,
0xec181727, 0xeb2b1066, 0x35552b2b, 0x35353501, 0x4b562b80, 0xfe26126a, 0x803636eb, 0x00822b56, 0x6036b621, 0x20260ddf, 0x28002400, 0x4d180000,
0x272420f7, 0x23352315, 0x16fb4d18, 0x2705754c, 0x2a2b2b18, 0x602b4001, 0x2015784c, 0x247b828b, 0x0005002b, 0x256b8255, 0x00d501ab, 0x737c0003,
0x21002507, 0x03153335, 0x2016bd4b, 0x06974511, 0x0a2f5882, 0x648e644a, 0x4b3d1e4a, 0x2d3e4b6a, 0x82802a2a, 0xa1013650, 0x64465834, 0x34584664,
0x3548261e, 0x48354b4b, 0xd5d55325, 0x311982fe, 0x04002b2b, 0x15005a00, 0x0002a601, 0x10000800, 0xe5841800, 0x07173229, 0x27072226, 0x85360736,
0x0b505809, 0x5206a161, 0x633b063d, 0xa0381e43, 0x09451e38, 0x1e2c7c2c, 0x3b1f5a1f, 0x221a1a22, 0x0c096b1a, 0x8380090c, 0x00022404, 0x82381e45,
0x2c81211f, 0x1f211e82, 0x07f760a1, 0xdc18ff20, 0xeb82082e, 0xeb826b20, 0xeb019526, 0x13000f00, 0x2322ed82, 0x0f822700, 0x23065844, 0x14333526,
0x35217c82, 0x23df8603, 0x35262236, 0x21055a44, 0x13831415, 0x95012608, 0x352a354b, 0x5c43244b, 0x802b3143, 0x2634052a, 0xab263426, 0x362b012b,
0x46460852, 0x2f365208, 0xfe2f3e3e, 0x25e983d5, 0x801a26eb, 0x0483261a, 0x50effe21, 0x7d7105cf, 0x00022e07, 0x001a0006, 0x27373700, 0x35331537,
0x627a1817, 0x08544309, 0xa0a0c02c, 0x802a5615, 0xaafe1218, 0x06821812, 0x05825620, 0x6b556b22, 0xfe305682, 0x191912eb, 0x2b150112, 0x12181812,
0x15000400, 0x85064360, 0x00252653, 0x27372500, 0x55558435, 0x558808a0, 0x21150523, 0x051b4f14, 0x00013537, 0x2b557575, 0xfe12196b, 0x6a1812d5,
0x12551219, 0x01c0fe19, 0x25708255, 0xc01912d5, 0x6a834055, 0x20054b4b, 0x216f832b, 0x6e83eb80, 0x494beb20, 0x0007240a, 0x4922000a, 0x272a09cd,
0x33172733, 0x06151632, 0x61830706, 0x27272a08, 0x36343526, 0x36373333, 0x22ef1732, 0x1a221a1a, 0x6f408015, 0x0a0d0966, 0x20090528, 0x0920eafe,
0x090d0136, 0x18065d66, 0x05724806, 0x5e5e9131, 0x9128090c, 0xc61f1f13, 0x0c090402, 0x1809098c, 0x20849f6f, 0x08d14d07, 0x07000324, 0x31420b00,
0x5a252006, 0x17240985, 0x27152335, 0x07830382, 0xdd640383, 0x05e26708, 0xabab8027, 0x2a6b6bab, 0x1800832b, 0x240af466, 0x2b2b5501, 0x20028440,
0x82058480, 0x0001210b, 0x2e0bba6c, 0x00340003, 0x01eb0120, 0x000500c0, 0x47100008, 0x2d0806cd, 0x27332717, 0x07232717, 0x13331323, 0xcb1ecd01,
0x974e1e6c, 0x19552c58, 0x6d2d1878, 0x09016d28, 0x1e6dcb1e, 0xe076b94f, 0x15014040, 0x7974ebfe, 0x0009250b, 0x25000011, 0x08b77418, 0x3b083b5b,
0x6950185a, 0x50692929, 0xb0585a18, 0x7db07d7d, 0x09456780, 0x45086160, 0x1f013667, 0x18051d59, 0x2847c366, 0x00550004, 0x01ab016b, 0x080f5995,
0x2a080b59, 0x35211535, 0x35231517, 0x66560155, 0xd62b050a, 0x2a9501d6, 0x802b2bab, 0x7cab2b2b, 0x2b20058b, 0xd5203b82, 0x0a2d3b82, 0x1a001200,
0x00002200, 0x06173237, 0x24338215, 0x16363634, 0x07fb7b32, 0x20057658, 0x067e5816, 0x16c02608, 0x3795331d, 0x504a9742, 0x263411ea, 0x76263426,
0x2c1f1f2c, 0x1c06eb1f, 0x1735302e, 0x20161024, 0x1a30301a, 0x22188260, 0x553b3426, 0x0222064d, 0x69824000, 0x6982c020, 0x0d000625, 0x56010000,
0x33340710, 0x27152315, 0x9655c001, 0x9696d696, 0x55400155, 0x80402a40, 0x55200382, 0x840a5966, 0x17132231, 0x28958223, 0x07331723, 0x33353327,
0x222783c0, 0x825540ea, 0x223c8506, 0x82965555, 0x072f68ff, 0x15253183, 0x23250000, 0x23348235, 0x15332717, 0x475e3282, 0x34262806, 0x2b357501,
0x83a04b35, 0xb02d2a04, 0x7db07d7d, 0x4b5555c0, 0x200382cb, 0x0598414a, 0x152a7982, 0xeb013500, 0x1700b501, 0x1d581e00, 0x23152712, 0x23112111,
0x88830335, 0x01331524, 0x8c1811c0, 0x802408b7, 0x80800180, 0x0125c384, 0xfe1119b5, 0x2e1983d5, 0x19112b01, 0x01d5fe2a, 0xebfe2a2b, 0x5cc0c055,
0x05210aeb, 0x20a38300, 0x20a48235, 0x10bb6711, 0xd5abc022, 0x0b064b18, 0x55d56b24, 0x5918d6fe, 0x00220df9, 0x49470f00, 0x1807200a, 0x201b9382,
0x53e91825, 0x3507250a, 0x01061433, 0x03201082, 0x13200382, 0x03200386, 0x2005e941, 0x075b6103, 0x17821720, 0x36340322, 0x2e09455b, 0x802a6b01,
0x2b2b802b, 0x9afe1a2b, 0x182a2a2a, 0x21089482, 0x13821a11, 0xd62b8024, 0x7261111a, 0x2aab2608, 0x112bab2a, 0x8f82181a, 0x2b553108, 0x2b00ff2b,
0x1a2b012b, 0xfe805511, 0x2a111a80, 0x8206ae67, 0x9382183b, 0x6b072007, 0x0d440c5d, 0xd7711807, 0x0543496b, 0x0300c022, 0x3105c359, 0x32032311,
0x14151516, 0x26270707, 0x23373535, 0x04822622, 0x37343532, 0x01333637, 0x55565695, 0x8c0d1a11, 0x87150917, 0x013ee782, 0x1d0a4103, 0x00ffc001,
0x111a0001, 0x8d0d11d5, 0x070d0917, 0x02111962, 0x96080829, 0xef41001a, 0x00eb2208, 0x215b8418, 0x56833307, 0x83230621, 0x20518353, 0x2a678217,
0x16323307, 0x11331105, 0x8401eb01, 0x89c0204e, 0x2afe245f, 0x852b0156, 0x235e8b4b, 0xff0001fc, 0x00205b83, 0x02280483, 0x00170000, 0x0100002f,
0x3621b389, 0x85b48436, 0x902720b2, 0x06062171, 0x01327283, 0x09120ee0, 0x0307116a, 0x096f010b, 0x0931020c, 0x04835014, 0x158b9020, 0x132b0135,
0x090e8b0d, 0x0a071169, 0x0c07340e, 0x08031b09, 0x84551471, 0x5d188c05, 0x25281797, 0x27153335, 0x15231533, 0x21200782, 0x24089f5d, 0x95011521,
0x2200832b, 0x5d0180fe, 0xeb25089f, 0x2b802a2a, 0x231583ab, 0x552a2a56, 0x270da958, 0x00070003, 0x1300001f, 0x5c184982, 0x95221b53, 0x5c186b6b,
0x0123134f, 0x18556b2b, 0x4d134d5c, 0x552e0589, 0xab01eb01, 0x13000b00, 0x00001b00, 0xb6181412, 0x55740979, 0x4021080f, 0x4838262f, 0x9c263848,
0x6a4b4b6a, 0x658c3a4b, 0x01658c65, 0x0d42542a, 0x765c0e2c, 0x0d2c0e5c, 0x221682ec, 0x82e06a4b, 0x8c652116, 0x0be99c18, 0xad553520, 0x36342408,
0x49153333, 0x352108fa, 0x08b95506, 0x14873720, 0x8a373621, 0x97013515, 0x7db07d3e, 0x1615587d, 0x161a221a, 0x4632241c, 0x261e1932, 0x3d236582,
0x82573f2e, 0x82322066, 0x58592220, 0x0823827d, 0x190cb026, 0x111a1a11, 0x082d0c19, 0x32231e2c, 0x1b212332, 0x3534261e, 0x2f354b4b, 0x082b0847,
0x65464160, 0x32474665, 0x2b20f185, 0x2008f182, 0x000200d5, 0x0023000a, 0x27332500, 0x27231337, 0x13230723, 0x07270707, 0x27263727, 0x36171633,
0x084b7737, 0x07063f08, 0x45530107, 0x2b601623, 0x2b186518, 0x42114d60, 0x286d1e6b, 0x1c152b18, 0x96ef162e, 0x1a3f962a, 0x5d950135, 0x4000ff39,
0x6c000140, 0x1e6a422c, 0x28352c6b, 0x2b3f331f, 0x502b2a2a, 0x0941013b, 0x01802405, 0x828001d5, 0x25002271, 0x30648337, 0x37173717, 0x31550115,
0x1e9e5568, 0x31865580, 0x83098980, 0x0040222f, 0x282f82ab, 0x00060055, 0x35070100, 0x25018221, 0xfe55d501, 0x618201c0, 0x2a405525, 0x6d010040,
0x0a20083b, 0x33212182, 0x82528215, 0x37172eb9, 0x31805501, 0x1e805586, 0x0168559e, 0x820a8880, 0x6a2b7022, 0x09d34d18, 0x0f000523, 0x06fd7100,
0x15171329, 0x26070614, 0x71353526, 0x802505e9, 0x52526ec0, 0x05d8716e, 0x18000121, 0x1808e9cd, 0x220be7be, 0x821f000f, 0x0ead6cb8, 0x0f8e0520,
0x09ab0127, 0xfe090c0c, 0x21058395, 0x0b8a6b01, 0x6c0cc021, 0xd5200893, 0x270a8c6c, 0x55000300, 0xc0018000, 0x39082f48, 0x33113700, 0x11331311,
0x33112123, 0x15c0ab11, 0xd5fe4040, 0x15018040, 0x0387ebfe, 0x33820020, 0x20052748, 0x066348ab, 0x3301003f, 0x35212315, 0x11171533, 0x80011133,
0xabfe5555, 0x01d61555, 0xebebeb80, 0xfe40012a, 0x8e3183c0, 0x86012065, 0x83332061, 0x6b552931, 0x6b00ff6b, 0x95016b15, 0x1b53658f, 0x00032a05,
0x00170013, 0x15211300, 0x24ef8f21, 0x15213503, 0x2237822b, 0x8980016b, 0x011526ec, 0x40c00195, 0x06a94c2b, 0xfe241882, 0x004040eb, 0x201a1949,
0x06894405, 0x49081949, 0x01250521, 0x2b562a95, 0x0795462b, 0x55000624, 0x29416b00, 0x05d54c0a, 0x62085d49, 0xc0240f69, 0x00ff0001, 0xfe220385,
0x00835695, 0x5595012a, 0x6a5555d5, 0x556b5656, 0x00200886, 0x7d415383, 0x2053860b, 0xf18d1801, 0x6b552717, 0x156b806b, 0x0182eb6b, 0x016b6b26,
0x80808095, 0x06850383, 0xe1840020, 0x00214d8d, 0x28498213, 0x15333517, 0x11331121, 0x26078233, 0x80ebebd5, 0x8295fe6b, 0x823d8243, 0x1501273b,
0x8080ebfe, 0x05420200, 0x21d3880c, 0x2b820155, 0x68830120, 0xf7412a82, 0x01c02407, 0x6f0f0095, 0xa7480543, 0x07df5307, 0xd2183320, 0x23200edb,
0x012b0f8e, 0x0d0d0915, 0x0c094009, 0x83d6090c, 0x83402004, 0x85eb200e, 0x22138209, 0x180c9501, 0x970ae686, 0x05b3440b, 0x98186020, 0xe54d5251,
0x01ea2d05, 0x000500c0, 0x00250015, 0x13000035, 0x1520d283, 0x2206f47a, 0x83062737, 0x373427e9, 0x07013727, 0x0d842626, 0x37362729, 0x22172626,
0x82362707, 0x06172129, 0x5e080782, 0xfd263435, 0x9f261a03, 0x172c3f0c, 0x06082118, 0x9702261a, 0x1b7a011b, 0x2b0e3505, 0x1c804f32, 0x2b0c3719,
0x2e1314d2, 0x7f4f2e27, 0x3e31181c, 0x40013f08, 0x33041a26, 0x3f2c1718, 0x2602210c, 0x9708061a, 0x1b86fe1b, 0x120e3405, 0x2c3e4858, 0x08372c0c,
0x48580f2e, 0x133e2a3b, 0x5a3f2c14, 0x5e18c023, 0x1c200b0b, 0x280daf72, 0x23061415, 0x07271523, 0x050d4935, 0x72333621, 0x563a0db4, 0x12565555,
0x01121818, 0x6b80802b, 0x15012b2b, 0x12eb1218, 0x2a2a6a19, 0x0882196a, 0xc35c1820, 0x4ed52008, 0x2d200641, 0x0d759818, 0x21350527, 0x33151315,
0x102e5b35, 0x53343521, 0x152e0562, 0x2b40ab01, 0x01402b80, 0x6baafe56, 0x185b6b80, 0x19402809, 0x19128012, 0x822a80d5, 0x050d5b00, 0x2b2b2b22,
0x2009045b, 0x2029832b, 0x8741182b, 0x0003220b, 0x22d9831d, 0x45331523, 0x23500e9f, 0x01152408, 0x89d6562b, 0x18562261, 0x21da8212, 0x56928001,
0x2b00012a, 0xd5014b00, 0x2000c001, 0x215acf82, 0x0d006b07, 0xc1823320, 0x0805305a, 0x6a6b0125, 0x26066b1f, 0x20212634, 0x38281413, 0x4a385038,
0x52355258, 0x22513a39, 0x206ad506, 0x2106106b, 0x82081f13, 0x28382a16, 0x52395555, 0x27333a51, 0x29b98306, 0x016b006b, 0x00950195, 0x0e820002,
0x21170136, 0x21152107, 0xfe8e0001, 0x2a0107e4, 0x9501d6fe, 0x002a2bd5, 0x073d5918, 0x0700c026, 0x23000f00, 0x27268d82, 0x17373727, 0x4b540717,
0x33132207, 0x07024417, 0x64222121, 0x33260587, 0x3a1b0001, 0x03821b3a, 0x3f584726, 0x2b3f583f, 0x0daec418, 0x1b3b9530, 0x1a3b3b1a, 0x583f501b,
0x01583e3e, 0x9d4f2b01, 0x059d6205, 0x596a0020, 0x0013220a, 0x2371821b, 0x12000027, 0x0625e783, 0x3e342315, 0x052f6302, 0x18342321, 0x300ffc45,
0x15333517, 0x403246dd, 0x1418142a, 0x2a1a221a, 0x0d726a0f, 0x23328030, 0x1717391b, 0x0e160f21, 0x11191911, 0x7f6af923, 0x2bd8220b, 0x4e75822b,
0x0320079d, 0x45068d50, 0x29460811, 0x01402407, 0x8980fe80, 0x0d294603, 0x5b000321, 0x0b2b07dd, 0x25001300, 0x23010000, 0x49352315, 0x2b410640,
0x11eb5b07, 0x2b000124, 0x02822b15, 0xf35b5d20, 0x2b012112, 0x2b211983, 0x14fa5b6b, 0x032a6f89, 0x1d000b00, 0x33130000, 0x14412315, 0x23679107,
0x0e6b6b95, 0x40226293, 0x5e945615, 0x00050032, 0x01c00015, 0x004001eb, 0x000f0003, 0x001f0017, 0x18068b4d, 0x2309e984, 0x35073523, 0xe6857482,
0xee831520, 0x35200f84, 0x33300983, 0x2bcb0115, 0x13130d2b, 0x75202b0d, 0x96202060, 0x55350382, 0x202b2020, 0x150b0120, 0x0d133515, 0x2b130d15,
0x20202080, 0x2a188260, 0x2b0b6060, 0x80353580, 0x6504002b, 0x0929081d, 0x11000d00, 0x00001900, 0xbba31825, 0x82052008, 0x4b25206c, 0x232006fd,
0x013b6582, 0x111ad66b, 0xfe1a1180, 0x014040c0, 0xfe40406a, 0x405601c0, 0x11aaebd6, 0x82111a1a, 0xab40300e, 0x40408080, 0x00020000, 0x01400035,
0x82d501cb, 0x8215204f, 0x2726254f, 0x021f3527, 0x34080282, 0x06071616, 0x21052706, 0x2b012115, 0x1f227c52, 0x3b296a14, 0x030d0d71, 0xfe0d1604,
0xfe960198, 0x2017cc6a, 0x32086e0a, 0xc00bb01c, 0x0d17041e, 0x43030c0d, 0x204f832b, 0x224f8227, 0x85b401da, 0x16002b4f, 0x0f060706, 0x37272602,
0x03833717, 0x50843620, 0x0d06d433, 0x71527c0d, 0x1f310722, 0x29586a2a, 0xfe0d7293, 0x33528378, 0x161a3f01, 0x1e162104, 0x08540c0a, 0x0b991c20,
0xe2041e89, 0x802d5384, 0x80015500, 0x0b009501, 0x00001200, 0x05285537, 0x14333b08, 0x37262206, 0x07331533, 0x2b803327, 0x2b324632, 0x6b4b6a4b,
0x60604b2a, 0x3223d54b, 0x4b352332, 0x6077f54b, 0x00030060, 0x01c0006b, 0x00400195, 0x001f0009, 0x01000023, 0x98411523, 0x23332505, 0x15151632,
0x35210d82, 0x0a497133, 0x15023b31, 0x40950123, 0x60202b2b, 0x4a0c09d5, 0x470c202a, 0x7537059f, 0x20012020, 0x802b2015, 0x400b090c, 0x0c092b20,
0x0956090c, 0x6b00800c, 0x032209c5, 0x5f451300, 0x47252005, 0xd61806e5, 0x6b220801, 0x4c1801d6, 0xeb230a47, 0x5bd52a2a, 0x99510c46, 0x8205200a,
0x4b1120a5, 0x17250713, 0x12152335, 0x05ec5c32, 0x1e8fdc2e, 0xd61e2971, 0x7db013d6, 0xd57db07d, 0x9c220d84, 0xd9752b2b, 0x00200806, 0x005a0006,
0x01af0152, 0x000700a7, 0x0012000f, 0x00180015, 0x2400001b, 0x22263436, 0x12161406, 0x21084485, 0x33350736, 0x21352311, 0x33112315, 0x44350115,
0x44446144, 0x7c58586e, 0x556c5656, 0x55550155, 0x11838855, 0x01446123, 0x2513830a, 0x5540587c, 0x1884abfe, 0x0ecb4418, 0x00002f23, 0x0e977136,
0x1522172c, 0x32331415, 0x14333536, 0xad460607, 0x36372c05, 0x16173233, 0x27342315, 0x70262726, 0xd2350bed, 0x140f2828, 0x1e151626, 0x18142a28,
0x15132126, 0x02050326, 0x0cf6700a, 0x3a1b2e08, 0x0d113a06, 0x30121319, 0x1729062a, 0x1c15131b, 0x020a0607, 0x0005000a, 0x012b003e, 0x00d501c4,
0x004a0036, 0x007c0065, 0x2500008d, 0x57608223, 0x1435052c, 0x35363216, 0x22232634, 0x15060706, 0x06161714, 0x37342627, 0x06e47536, 0x45262221,
0x17820520, 0x07161726, 0x16142706, 0x3221b082, 0x220b8316, 0x82272223, 0x3233221c, 0x83078207, 0x32362509, 0x22141516, 0x03262e8c, 0x36372622,
0xd2823637, 0x72823c84, 0x82072621, 0x82252065, 0x22232331, 0x67830607, 0xeb08ef83, 0x033e0106, 0x262e212e, 0x26192736, 0x2e405b1a, 0x0e0c134c,
0x10031403, 0x3457150f, 0x36276749, 0x19261a26, 0x092a1c28, 0x373d0202, 0x090e0229, 0x0b020109, 0x1a280e0c, 0x390a0b33, 0x101b0304, 0x47644717,
0x3a523a16, 0x081b0d13, 0x078a0308, 0x30200406, 0x31327832, 0x0a09061f, 0x2e2d1b05, 0x1c2d2e6c, 0x042c0103, 0x413c3b01, 0x05090636, 0x4041473a,
0x0c2b0407, 0x1a412e21, 0x111a2525, 0x3c111818, 0x19272f56, 0x0a252823, 0x4e2d0906, 0x63362d1e, 0x24241a45, 0x1919111a, 0x1c283811, 0x080c010b,
0x0236259c, 0x020b0503, 0x3a231302, 0x1b03a30b, 0x2f34281e, 0x0a2f4444, 0x3737270a, 0x17223027, 0x0308071d, 0x060a0201, 0x1a1a182e, 0x050a2d18,
0x17270906, 0x17180117, 0x01700428, 0x07031e1e, 0x2020040b, 0x00001004, 0x2205d16a, 0x55eb01da, 0x17230a5b, 0x82372707, 0x37072c03, 0x21250701,
0x78522115, 0x82f2793c, 0x3c5a3003, 0xfe3c2e01, 0xff000177, 0x79360100, 0x82f2783c, 0x3c5a2603, 0x1a3cd2fe, 0x357a182b, 0x000d280b, 0x0029001f,
0x41362500, 0x1726077a, 0x26353315, 0x90181632, 0x26220b53, 0x226f3435, 0x233a0806, 0x3d012622, 0x3f583f2e, 0x6956122e, 0x0c40577c, 0x0c098009,
0x0c805540, 0x0c095609, 0x2c3720e9, 0x372c3f3f, 0x31310d20, 0x4e3e57f9, 0x0c09312c, 0x2c31090c, 0xc2fe3e4e, 0x0b821515, 0x2016bf66, 0x4ba01825,
0x6607200e, 0xab2907bf, 0x80fe111a, 0x111a1a11, 0x27058201, 0x016aaa56, 0x01d4fe2c, 0x2b2a0f84, 0x11191911, 0x00808081, 0x1d680400, 0x00093308,
0x00280024, 0x13000038, 0x27170733, 0x33273707, 0xc7823737, 0x21244c82, 0x23152111, 0x6c06475e, 0x3522089d, 0x3c461523, 0x05fa5908, 0x41ff333f,
0x35341435, 0x15413514, 0x2a1911c0, 0x150180fe, 0x2bab2b2b, 0x19191295, 0x6bc00112, 0x7a6a186b, 0x40013408, 0x27273e26, 0x5540263e, 0x6b6b1218,
0x2b2b00ff, 0x822b2a2a, 0x12002aa5, 0x9680fe18, 0x090cc096, 0x822b83c0, 0x00230804, 0x65000200, 0xa5010000, 0x1c00c001, 0x00002c00, 0x15151625,
0x23060607, 0x27272223, 0x32333637, 0x43173316, 0x15230547, 0x43173233, 0x07200807, 0x08058c41, 0x13920127, 0x0c120110, 0x6a090d91, 0x010a0711,
0x13490103, 0x0311131a, 0x382b7108, 0x202a3850, 0x09ad1f2c, 0x0c710414, 0x081e830f, 0xe50f0126, 0x0e12120e, 0x1c320280, 0x38382834, 0x501b3528,
0x161f1f16, 0x6b000300, 0x95012b00, 0x1300d501, 0x35002d00, 0x33208182, 0xf0827e82, 0x37363439, 0x15060615, 0x32331614, 0x36342736, 0x16153317,
0x33161717, 0x4a272215, 0x23220532, 0x25832335, 0xad5d3420, 0x01500805, 0x3a082c12, 0x303e2c27, 0x26181325, 0x3621151a, 0x0701162a, 0x32241c06,
0x11403238, 0x116b2a19, 0x1924191a, 0x25802419, 0x272c3e30, 0x072c083a, 0x261a1521, 0x1c18d118, 0x0603010d, 0x292a271f, 0x75111a49, 0xd9111a6a,
0x24181824, 0x00020019, 0x2405bf4f, 0x00060095, 0x3393820d, 0x33153727, 0x35072315, 0x23350717, 0x55400135, 0x80959555, 0xeb250482, 0x2a405555,
0x260e8256, 0x00002a40, 0x82400005, 0x82c020c9, 0x770320c9, 0x701806a5, 0x07201e51, 0x2006305d, 0x18078223, 0x2c135170, 0x2a2b2b15, 0xeb552b2b,
0x1a5601eb, 0x05a67311, 0x112b0124, 0x00822a1a, 0x03829620, 0x85450282, 0x821b200e, 0x363632a9, 0x06063337, 0x26263707, 0x16163527, 0x06062717,
0x079f5314, 0x15012408, 0x40074930, 0x80506808, 0x50304907, 0x32ea0868, 0x51324e4e, 0x6c516f6f, 0x50304807, 0x30ea0769, 0x82410748, 0x087f2b1e,
0x08566c56, 0xa67a0841, 0x2358087a, 0x8319200e, 0x92608661, 0x0d1b305f, 0x4f690898, 0x4f1c0c28, 0x11ea0869, 0x83111a1a, 0x08c3335d, 0x076c4d20,
0x980820ea, 0x284d6c07, 0x22282207, 0x5b859807, 0x40000b27, 0xc0015500, 0xc9791801, 0x00272d13, 0x1300002b, 0x17211521, 0x21153335, 0x07830382,
0x9d182320, 0x0b830adf, 0x0f8a3720, 0x8001402f, 0xabd580fe, 0xaaab80fe, 0x802b802b, 0x2b03822a, 0xf56bea2b, 0x016bf56a, 0x2b5556ab, 0xab200082,
0x02860382, 0x3f415620, 0x456a1806, 0x0007240b, 0x850f000b, 0xdffa1873, 0x35252307, 0xc74a1521, 0x56ab280f, 0x9640406a, 0x55401616, 0x002c056f,
0x00026b00, 0x07009501, 0x2f001500, 0x2009a56d, 0x2a9e8227, 0x22232626, 0x33161406, 0x18373632, 0x2a09d552, 0x06062307, 0x34262223, 0x83333336,
0x01270823, 0x2626347b, 0x3cae2634, 0x1421073c, 0x1a26261a, 0x29ff2114, 0x3d5a3e38, 0x08233b06, 0x3e2d2739, 0x2bf72d3e, 0x82955e4c, 0x34262523,
0x17132b05, 0x2a080882, 0x3c039218, 0x3d3d2d2b, 0x3b12142d, 0x5a3d3025, 0x002a2b3e, 0x55000200, 0xab013200, 0x0600ce01, 0x00001100, 0x27342137,
0x55060727, 0x37290824, 0x00018037, 0x265a5a26, 0x05bb75f9, 0x2637d539, 0x48265d5e, 0x64474632, 0x32464764, 0x00050079, 0x012a002b, 0x82c001d5,
0x00333307, 0x0043003b, 0x2500004b, 0x1606071e, 0x06070607, 0xca822326, 0x27262726, 0x37363626, 0x372d0283, 0x33363336, 0x17321732, 0x16161716,
0x06834336, 0x9b48d482, 0x05934306, 0x17860620, 0x72013308, 0x0d040d02, 0x09010c03, 0x0b030503, 0x1c530727, 0x07531c04, 0x14030b27, 0x210a1611,
0x0413120a, 0x0c0b0603, 0x13040305, 0x03220912, 0x1f1f2c1f, 0x05847f2c, 0x0b8a9f20, 0x02c32108, 0x050e040d, 0x0710060e, 0x082a0411, 0x010a0a01,
0x2a142a08, 0x280b1612, 0x0206160b, 0x06020101, 0x51260a82, 0x2c20202c, 0x4183751f, 0x1f230883, 0x8436202c, 0x02002d11, 0x2b00ab00, 0xd5015501,
0x15000d00, 0x1520d782, 0x83056e4c, 0x161521a0, 0x0139b787, 0x2a404055, 0x2a263426, 0x18241995, 0x56eb2418, 0x1a966a6a, 0x111a2626, 0x0514447f,
0x82040021, 0x0140223b, 0x7a4582ea, 0x0120089d, 0x075b1819, 0x06270786, 0x15151632, 0x41343521, 0x2f080713, 0x3e3eac01, 0x232c2c23, 0x0e242020,
0x756cb80e, 0x3256aafe, 0x46323246, 0xab41d501, 0x8333223e, 0x58232530, 0x2d132420, 0x262faa13, 0x8c262b2b, 0x32241b83, 0x000b0000, 0x20057170,
0x08e95dc0, 0x1f001b25, 0x18002300, 0x2d07275f, 0x23150100, 0x23263435, 0x32333523, 0x95660116, 0x5a332006, 0x148206a4, 0x82071521, 0x2003830b,
0x20078227, 0x36038205, 0x23153307, 0x262bc001, 0x2c6a6a1a, 0x2b80fe3f, 0x2a2b2b2a, 0x43802b80, 0x0120060e, 0x2b2b0e82, 0x6a55012b, 0x2b261a6a,
0x85bffe3f, 0x55012116, 0xf4750783, 0x82562008, 0x002b2e32, 0x00550003, 0x01c00100, 0x001a00eb, 0x218f8222, 0x90692500, 0x16352405, 0x50373736,
0x14200624, 0x06231282, 0x5d331707, 0x3d0807dc, 0x07231703, 0x40c00127, 0x0d079740, 0x1e12381a, 0x13011310, 0x144c141d, 0x5120861d, 0x221a1a22,
0x2b36601a, 0x4040204b, 0x01972040, 0x1319012e, 0x141c1021, 0x4c141a7b, 0x860d1131, 0x1f826b01, 0xfe221a26, 0x204a36fa, 0x00327882, 0x01800015,
0x008001eb, 0x00000033, 0x22230614, 0x07580727, 0x27372207, 0x210d8806, 0x56183634, 0x152409b6, 0x36170714, 0x07c45618, 0x1aeb0127, 0x4c030811,
0x25548202, 0x0a063702, 0x09836106, 0x61281283, 0x1a221901, 0x10033601, 0x01311c84, 0x01192266, 0x1105064c, 0x05111919, 0x02023706, 0x820b8261,
0x011926a9, 0x11080361, 0x2330831a, 0x4b010136, 0xef4b1483, 0x0005220a, 0x21a2821e, 0xfe821715, 0x3723172a, 0x06072626, 0x37321614, 0x2305014b,
0x34262722, 0x01398583, 0x5b0f4a0b, 0x2c3b91d5, 0x562b2c7b, 0x2b2b2c7c, 0x38a03838, 0x389e7038, 0x05867b3a, 0x3c2d6a34, 0x2c2b012c, 0x2b2c5878,
0x38374f3d, 0x709d3738, 0x45183c38, 0x25260fd9, 0x23352737, 0x6d432615, 0x5a012406, 0x7a206011, 0xa6250577, 0x806f3a1c, 0x05965dea, 0x15000122,
0xeb248d82, 0x2c000002, 0xbb620782, 0x27272105, 0x4705b843, 0xdc4708d4, 0x36078c07, 0x2333eb01, 0xa819249b, 0x0a07011b, 0x135c0607, 0x1215131a,
0x8215121c, 0x82162007, 0x8b013803, 0x3223cafe, 0x061aab19, 0x0dfe3403, 0x960d1313, 0x12120ecb, 0x83b6cb0e, 0x76b6210b, 0x6e820582, 0x3108bf42,
0x25000027, 0x06173732, 0x27262223, 0x26333523, 0x05823734, 0x47183620, 0x07260818, 0x06231533, 0x05821714, 0x16163f08, 0x27334001, 0x3e4a3626,
0x414b1463, 0x4b410101, 0x4a3e6314, 0x33272636, 0x7b124227, 0x89020289, 0x7541127b, 0x48312622, 0x1c072b38, 0x48382b07, 0x29222631, 0x0e0e2b22,
0x29222b0e, 0x1f610500, 0x00182808, 0x00250021, 0x82550041, 0x34112979, 0x17232326, 0x15333533, 0x06246182, 0x27071707, 0x33330382, 0x16273632,
0x37363617, 0x021f2337, 0x34272637, 0x18152327, 0x23098c7c, 0x27371717, 0x4d09b845, 0x232106b8, 0x08c05527, 0x01174208, 0xbc090cc0, 0x4d172919,
0x3a1f0a1b, 0x11133a0f, 0x0c09962b, 0x0c0f0996, 0x55030210, 0x0c0d0507, 0x5402380e, 0x1416032f, 0x151e1e15, 0x1a020d13, 0x24211902, 0x25243333,
0x1911be2f, 0x15ab1119, 0x08068396, 0x5513803d, 0x0c091601, 0x16161656, 0x10392427, 0x2b3b1339, 0x1113b10c, 0x08081d0e, 0x0b2f1017, 0x040b460f,
0x1f140c21, 0x010d1f2a, 0x33170119, 0x9c303348, 0xeafe1119, 0x19401911, 0x82160111, 0x04002206, 0x2d008200, 0xe501e501, 0x11000700, 0x2d001800,
0x77450000, 0x34262405, 0x82212737, 0x07142eb8, 0x33070607, 0x07072327, 0x27070514, 0x82c18306, 0x08068519, 0x2727372b, 0x1a228437, 0xe119221a,
0x091f01c0, 0x0c4c030c, 0x322b6cc7, 0x4c010113, 0x150d3d1b, 0x1e121a11, 0x0519119f, 0x1b5e2f1d, 0x08248280, 0x85221920, 0x05090dc0, 0x2b168a05,
0x0503232b, 0x123d1ba5, 0x0d161119, 0x0a111a1d, 0x5e63350a, 0x4718001b, 0x17350ae1, 0x00002500, 0x34363225, 0x07222326, 0x27331527, 0x16323336,
0x237e8214, 0x16162327, 0x350ede77, 0x3f3f2c00, 0x1b203a2c, 0x2e142255, 0x1f2c2c1f, 0x0c251627, 0xea774c35, 0x3f802e09, 0x1c313e58, 0x2b282255,
0x1d202c3e, 0xb2461823, 0x0400290d, 0x06000000, 0xdb01d501, 0x1422ff82, 0x45181800, 0x07220a69, 0xbf183327, 0x173d073d, 0x35172733, 0x01031523,
0x07232707, 0xab012711, 0x11181911, 0x15946995, 0x297eaba9, 0x0800822b, 0xba016524, 0x55c07a1b, 0x19d5012b, 0x1100ff11, 0x2b950119, 0x7e292b15,
0x2b6b2bc0, 0xfe06012b, 0x557a1b46, 0x934c6a01, 0x40230806, 0xc0019501, 0x13000700, 0x00001d00, 0x21153301, 0x33373335, 0x17071707, 0x27371737,
0x27072737, 0x43211107, 0x262d0569, 0xfe4a4b01, 0x6a164ad6, 0x1e2d2e81, 0x2002862d, 0xd3471853, 0x86bd200b, 0x1e2e2518, 0x01b62e2e, 0x07dd4718,
0xc7420120, 0x23728208, 0x17231501, 0x1520b682, 0x15270482, 0x27073523, 0x82233537, 0x35232704, 0x17372733, 0x04823533, 0x15333527, 0x15071737,
0x32048233, 0x4559d501, 0x642b631e, 0x452a451f, 0x632b641f, 0x8f59451e, 0x15012110, 0x2b881a98, 0x06000022, 0x08ff5e18, 0x0b00032a, 0x17000f00,
0x2f001b00, 0x2720ed83, 0x20083153, 0xfc681827, 0x3327230a, 0x8e182335, 0x013d1359, 0x15566b40, 0x13131a28, 0x5540131a, 0x12121c4e, 0x5520121c,
0x802b0155, 0x26342636, 0x26038275, 0x0112192b, 0x82e05615, 0x1a13251f, 0x8a565677, 0x2a260886, 0x261a6a80, 0x03831a26, 0x1812c02e, 0x00000100,
0x00028d00, 0x27007301, 0x32250982, 0x22061416, 0x53f88227, 0x072305bb, 0x69070706, 0x1725057f, 0x26270717, 0x056f4522, 0x01373735, 0x4343605d,
0x201b2260, 0x2a3c1619, 0x47153c2a, 0x85213c13, 0x18212111, 0x01311188, 0x445e4473, 0x151c1822, 0x2a3c2a16, 0x35123e15, 0x450f8e21, 0xc73208d9,
0x1b001700, 0x26010000, 0x16360726, 0x26260717, 0x06830637, 0x34373425, 0x82173633, 0x37240809, 0x74010717, 0x303e8332, 0x317a3173, 0x20150631,
0x3f3f3d32, 0x51624601, 0x891f9938, 0x3244011f, 0x31061520, 0x73231a82, 0x82833e30, 0x82b3201a, 0x0608271b, 0x8a1fb838, 0x3156001e, 0x0003230a,
0x3554001d, 0x32332c06, 0x14151516, 0x35232306, 0x18231523, 0x2508c76b, 0x15173337, 0x0b7e3307, 0x352b0809, 0x562b0133, 0x191911d6, 0x80568011,
0x11191812, 0x2b552b55, 0x19955680, 0x12d6fe12, 0x6b019519, 0x111a2a2a, 0x2b1a1140, 0x8212192b, 0x2b2a2e06, 0x15c02a2b, 0x19191255, 0x00005512,
0x08a14506, 0x0965c318, 0x00003723, 0x06c55100, 0x22055f41, 0x86261406, 0x8707870f, 0x07d75a17, 0x2308d152, 0x12121c52, 0xed410287, 0x85058505,
0x15012114, 0x0a9e5a18, 0x13844020, 0x0584d220, 0x058a4e20, 0x01211185, 0x0c0a532e, 0x15000523, 0x05fd6a00, 0x25000530, 0x4b004300, 0x00005300,
0x06063337, 0x8b822622, 0x16323723, 0x05694433, 0x26230627, 0x07062226, 0x08ba4522, 0x25163325, 0x83070606, 0x26272527, 0x34262726, 0x2307b74a,
0x16171632, 0x14210282, 0x069d4a24, 0x2b07a949, 0x340cc0a0, 0x66213440, 0x04010d4f, 0x2305c44f, 0x4f0d0104, 0x01370e8d, 0x1720046b, 0x5e725f16,
0x04211716, 0x21040202, 0x361d1117, 0x845d3a49, 0xc5fe3a0e, 0x0f0f1610, 0x160f5b16, 0xd5161010, 0x4d23231d, 0x1a012f3c, 0x2f011a22, 0x2d08873c,
0x0725184b, 0x2f3f3f2f, 0x08182507, 0x0c82080c, 0x30182624, 0x0d84303e, 0x35831b20, 0x02833882, 0x04000024, 0x4b4e2b00, 0x00072606, 0x0028000f,
0x09594c2d, 0x08097d18, 0x14151622, 0x20055547, 0x08da4506, 0x17333531, 0x32271421, 0x01231516, 0x13131a5e, 0x84ad131a, 0x11013905, 0x1c1f2b19,
0x042d042a, 0x2c1f1c29, 0x4a2f2d27, 0xab370114, 0x55ab6447, 0x02872282, 0x21174534, 0x1b252b1f, 0x1f2b251b, 0x2b5e162c, 0x64f9392b, 0x8d440046,
0x001b2609, 0x07172500, 0x05df7517, 0x07273724, 0x01833727, 0x82371721, 0x82072001, 0xb7012f03, 0x1e1e2d1e, 0x1e1f2d1f, 0x4cb74c1f, 0x0d8c1e1e,
0x1783c320, 0x1e201183, 0x21821b82, 0x0d882582, 0x03000024, 0x6a185500, 0x19270a13, 0x21370000, 0x50012115, 0x8c550bfe, 0x067d5e08, 0x0b299c18,
0x012b6b31, 0x6b404015, 0x11401219, 0x33234019, 0x46d52333, 0xc02b078b, 0x0f00d501, 0x00001700, 0x4d150701, 0x1523097f, 0x41121133, 0x012906f9,
0x3c2e806b, 0x404b6a4b, 0x058e6d2b, 0x4282013a, 0x101802c1, 0x11191911, 0x01250c19, 0x1c7dfe80, 0x121c1212, 0x00080000, 0x3005915b, 0x000e00c0,
0x0022001e, 0x002a0026, 0x0042002e, 0x2e5b824a, 0x23070716, 0x26273637, 0x07333737, 0x86171706, 0x200f870e, 0x20c68213, 0x21038a23, 0x0b6b3337,
0x8232200d, 0x087e4c31, 0x06213928, 0x05032901, 0x06822215, 0x13050227, 0x02062257, 0x20078228, 0x23078602, 0x2b2b2a09, 0x83250283, 0xfe1119e7,
0x3ced82aa, 0x1014131d, 0x1875041d, 0x24191924, 0x2f208301, 0x151b0c09, 0x0d092e22, 0x2101141b, 0x210c822e, 0x0d850114, 0x80d1fe22, 0xab210086,
0x27dc83ab, 0x1c1410ab, 0x64052110, 0x19233783, 0x18050000, 0x200e6f7b, 0x0737640f, 0x15331124, 0x4f181723, 0xab21162b, 0x2000822a, 0x07be5fd5,
0x1a191239, 0x1100ff11, 0x0112191a, 0x00016b00, 0x6b6b1540, 0x01c1c1eb, 0x83121880, 0x111925a8, 0x18125601, 0x200aad58, 0x25618207, 0x00810051,
0x89410000, 0x22073106, 0x37272627, 0x35232627, 0x17171632, 0x23060706, 0x22231082, 0x55050607, 0x0e83064a, 0x0f822320, 0x35280788, 0x33363732,
0x33161732, 0x1520078f, 0x0e87318e, 0x378b308b, 0x2b012708, 0x1f1f2c1f, 0x0d0c912c, 0x15450c04, 0x34293520, 0x03068918, 0x0d0b0c0d, 0x0d163216,
0x17171101, 0x0b0d0e0b, 0x078f1817, 0x23831393, 0x3027278e, 0x0e0d0b17, 0x8a17170b, 0x2012872e, 0x211a8218, 0x7c837501, 0x08552037, 0x16450503,
0x18133520, 0x08010488, 0x080d0d08, 0x07070e60, 0x2003870e, 0x220a892b, 0x988b070e, 0x00002119, 0x2d09b552, 0x0013000f, 0x16160100, 0x36362117,
0xdc4b2637, 0x14340805, 0x21152105, 0x563f2701, 0x0480fe04, 0x1a043f56, 0x00ff1a22, 0x56feaa01, 0x610d5a01, 0x0d614141, 0x1911070a, 0xcf071119,
0x0600002a, 0x15002b00, 0xd501d501, 0x193b5382, 0x2d002900, 0x39003100, 0x27250000, 0x26222733, 0x15333634, 0x14150622, 0x54333316, 0x342405bf,
0x16372326, 0x2b06fa6a, 0x36323523, 0x07143335, 0x37231533, 0x5d080382, 0x07013725, 0x33352327, 0x3f3f6b01, 0x2a2a1d36, 0x1716111d, 0x2c1e2110,
0x3c111920, 0x3120251e, 0x20171024, 0x35202027, 0x76fe2020, 0x1b6b011a, 0xac95d595, 0x3a2b5b3f, 0x1015202a, 0x1c271a11, 0x17141b22, 0x243a0e52,
0x33242c2c, 0x1e111720, 0x404040c2, 0x95fe1bd5, 0x0040961b, 0xa5530500, 0x00d52a06, 0x002c0016, 0x00340030, 0xcda21838, 0x51938208, 0xaa860566,
0x1d82a08d, 0xbb823520, 0x2126a689, 0x56012115, 0x96822b1f, 0xa5872120, 0x9f865d20, 0x1d101723, 0x2ba2872a, 0xc0fe4001, 0x1d262601, 0x17141c23,
0x3527a487, 0x30233a0e, 0x82322430, 0x23cc829e, 0xc51e1d2a, 0x4021a382, 0x0ab34d40, 0x17000722, 0x06309782, 0x36272607, 0x32051637, 0x36361716,
0x07061433, 0x33081083, 0x4a012626, 0x2a20202a, 0xfe434308, 0x217044e7, 0x5f447021, 0x1519114c, 0x015f4c15, 0x22221733, 0x43435f17, 0x33334267,
0x1b865442, 0x08030506, 0x0100861b, 0x20085156, 0x3055824e, 0x07071416, 0x07272306, 0x022f2206, 0x23141707, 0x83078323, 0x37352506, 0x16170723,
0x27210f82, 0x08078527, 0x372735b2, 0x21352635, 0x37263716, 0x36161716, 0x22272627, 0x34372627, 0x17161633, 0x07021e17, 0xff011714, 0x02190101,
0x02070f02, 0x170e0209, 0x1404112f, 0x0a140202, 0x04150419, 0x08238717, 0x03140602, 0x06221c01, 0x04160602, 0x0117150d, 0x082f3012, 0x07081c0e,
0x24090209, 0x020c0201, 0x07291d04, 0x05070304, 0x3e010201, 0x20010301, 0x04160302, 0x70051e04, 0x51030488, 0x04036211, 0x05444287, 0x3c276602,
0x52380205, 0x01150990, 0x140e1622, 0x070b0405, 0x03010e1c, 0x25040305, 0x08040311, 0x0205080f, 0x07000000, 0x03005a00, 0x09040100, 0x60200b82,
0x0b850382, 0x1c000124, 0x17866000, 0x0e000224, 0x0b867c00, 0x52000324, 0x0b868a00, 0x238a0420, 0x1a000524, 0x1786dc00, 0x00062008, 0x00f6002a,
0x006f0043, 0x00790070, 0x00690072, 0x00680067, 0x00200074, 0x00300032, 0x82350031, 0x82472009, 0x826f201d, 0x006c2417, 0x822c0065, 0x0049260f,
0x0063006e, 0x2209822e, 0x826c0041, 0x82202001, 0x20378767, 0x20158273, 0x20278252, 0x22038273, 0x82760072, 0x82642005, 0x004d2229, 0x20538261,
0x205f8465, 0x20318461, 0x20418249, 0x2047826f, 0x203b8273, 0x205b8265, 0x20158275, 0x201f8261, 0x206b8246, 0x832b826e, 0x82722007, 0x84652017,
0x822e2089, 0x0020228b, 0x9b0b823a, 0x22218549, 0x822d0038, 0x830383bb, 0x003622bf, 0x20898456, 0x20d98273, 0x206f826f, 0x20d38220, 0x21d9842e,
0x4b8f0031, 0x2d209389, 0x0023958e, 0x84000300, 0x83ff2100, 0x09845b82, 0x01260490, 0x0200ffff, 0x17820100, 0x03820c20, 0x03821c20, 0x02000222,
0x27203782, 0x28221382, 0x0b82cc03, 0x13820420, 0x03831f83, 0x1e000a2e, 0x01003400, 0x6e74616c, 0x04000800, 0x00201982, 0x1d843f82, 0x7a697323,
0x20138665, 0x881783a0, 0x20378703, 0x2337952c, 0x6167696c, 0x00213782, 0x82458400, 0x086f8553, 0x01000838, 0x1900fc68, 0x54003800, 0xec0ee208,
0x901ca017, 0xe029a81f, 0x4c2d6e2b, 0x6e31b22f, 0x303d8e39, 0xaa400a40, 0x9e4bba4a, 0x5a5e1250, 0xa4623262, 0x8a689266, 0x4782b868, 0xe2020430,
0x11000b00, 0x1f000d00, 0x21001c00, 0x03820e00, 0x09821620, 0x001b9808, 0x00920048, 0x010801ce, 0x01780140, 0x02e401ae, 0x02440216, 0x029e0272,
0x03f002c8, 0x033e0318, 0x03860362, 0x03cc03aa, 0x040c04ec, 0x044c042c, 0x048c046c, 0x04c804aa, 0x050205e6, 0x053a051e, 0x05720556, 0x05a8058e,
0x05dc05c2, 0x061006f6, 0x0644062a, 0x0674065c, 0x06a4068c, 0x06d006ba, 0x07fc06e6, 0x07280712, 0x0752073e, 0x077a0766, 0x07a2078e, 0x07ca07b6,
0x07ee07dc, 0x080e08fe, 0x082e081e, 0x084e083e, 0x0868085c, 0x087e0874, 0x00a40286, 0x8216001d, 0x821920a7, 0x001b2205, 0x20b38212, 0x20058220,
0x20b1820e, 0x2011840d, 0x20058211, 0x22038223, 0x82220011, 0x841920c7, 0x8222201f, 0x0021240f, 0x82a70212, 0x203b97d3, 0x20458219, 0x22ff8414,
0x821a001c, 0x821f2035, 0x2043830f, 0x23078310, 0x1b00a602, 0x398f7598, 0x65821b20, 0x43821f20, 0x19000e24, 0x379aa902, 0x10216183, 0x8bc78900,
0x82a52037, 0x22a9a73f, 0x82250012, 0x001f24fd, 0x9aa8020e, 0x896d8f35, 0x00a32235, 0x20db9818, 0x419f8213, 0x0e20055b, 0x1420c982, 0x12240d82,
0x6a021100, 0x1f2a2f84, 0x24001c00, 0x11000d00, 0x09821f00, 0x09841d20, 0x1b201183, 0x10200982, 0xdd832184, 0xe5021222, 0x10220b82, 0x23821000,
0x43822220, 0x1d822120, 0x0e000f22, 0x0e204982, 0x10220d82, 0x0f821200, 0x0f842420, 0x0b821920, 0xdb002124, 0x3b841500, 0x21861d20, 0xd3821220,
0x63821c20, 0x16202783, 0x0e203182, 0x21204982, 0x23282182, 0xf6021200, 0x20001400, 0x16200182, 0x1b200782, 0x12202782, 0x21225f86, 0x93822200,
0x4f821b20, 0x5d821120, 0x1b001626, 0x1300f502, 0x1f202994, 0x2d897384, 0x2782dc20, 0x3b821620, 0x798a7d93, 0x84b10021, 0x8a5d835b, 0x206b82e9,
0x2079821c, 0x07d34121, 0x82e80221, 0x821120b7, 0x820d2003, 0x0015247b, 0x821d001c, 0x828d8201, 0x820d20ad, 0x820e20c5, 0x02212267, 0x931f82f4,
0x21998ac3, 0x2382a202, 0x41170d42, 0xdb2007a1, 0xb9975182, 0xd5821c20, 0xf3021324, 0x03410f00, 0x00192814, 0x0021000e, 0x888b0112, 0x8220201f,
0x410e200f, 0x1d21064b, 0x24b98300, 0x021c0021, 0x201f8269, 0x41b3821f, 0xdc2017f5, 0x81991f82, 0xbb031b22, 0x1c201f88, 0x21214582, 0x05154100,
0x6b822220, 0x19002126, 0xe4021200, 0x27421f82, 0xe702211a, 0x1f8da782, 0x210a7b41, 0x1d827f02, 0x89429d8b, 0x84242005, 0x02112215, 0x410782f2,
0x16201365, 0x1122e582, 0x8b82bc03, 0x83821920, 0x20054144, 0x22098210, 0x42200022, 0x6b200663, 0xf5931b82, 0x1d002224, 0x1b828801, 0x11001122,
0x21220582, 0x05821c00, 0x23082b41, 0x6c022000, 0x1320378c, 0x1f211f82, 0x208d8700, 0x241b82e3, 0x00100010, 0x068f4112, 0x16000f22, 0x16267382,
0x26002100, 0x1b8cd800, 0xb7820d20, 0xc3841920, 0x53821a20, 0x0c007c23, 0x828b8900, 0x21518781, 0x19820c01, 0x3f822120, 0x55820e20, 0x41821520,
0x6f821a20, 0x5f821b20, 0x66002622, 0xa38b1982, 0x22001e22, 0x03821782, 0x82ef0221, 0x00202219, 0x200d821d, 0x20398210, 0x2059820d, 0x05f7450e,
0x82ee0221, 0x001b2219, 0x2043821b, 0x06a34322, 0x25821a20, 0x21001b24, 0x4d885b02, 0x1d821920, 0x29461020, 0x82d7200a, 0x8ad38919, 0xe60223b7,
0x95820b00, 0x240dff43, 0x0025001c, 0x411786d9, 0x0d200505, 0x67827b84, 0x821f0221, 0x20b18517, 0x0b53410e, 0x820b0121, 0x2ae38b17, 0x00160013,
0x02120019, 0x410a00f1, 0x14200647, 0x4182ad82, 0x21220582, 0x15826802, 0x20092b41, 0x24a9820f, 0x03180010, 0x411582a2, 0x41820d79, 0x82b00021,
0x42718515, 0xf0200b51, 0x20201582, 0x9f855982, 0x01215786, 0x2215828c, 0x82110022, 0x821c207b, 0x851f20b1, 0x4a012157, 0x9b891582, 0x00232b86,
0x4209006a, 0x212006e9, 0x0e260782, 0x18001000, 0x1382eb02, 0x2407d141, 0x001c000d, 0x20018213, 0x8513822b, 0x830e207f, 0x203384d1, 0x20138cda,
0x2213820e, 0x8cea021a, 0x820e203b, 0x02112285, 0x201382f7, 0x20898222, 0x2021821c, 0x24f98212, 0x01240012, 0x2013828a, 0x20b98220, 0x20038216,
0x26a18221, 0x0221001b, 0x820800ec, 0x2047845b, 0x22778300, 0x822d001b, 0x82232011, 0x8221200b, 0x001a28cb, 0x031f0012, 0x8207009a, 0x44192023,
0xb22008c7, 0x1f200f82, 0x1520b582, 0x21050b43, 0x0f82af00, 0x0f20a785, 0x2522b982, 0x0f82ed02, 0x85821b20, 0x0d821f20, 0x07821620, 0x0f825f20,
0x22090144, 0x82ba0326, 0x8210200f, 0x0022224d, 0x2441821b, 0x00890121, 0x22258206, 0x83220017, 0xe9022397, 0x91880500, 0x0b842c20, 0x19820f20,
0x67021a26, 0x1d000400, 0x20240182, 0x0300ae00, 0x8220e384, 0x78080784, 0x0037000f, 0x009c0070, 0x01ec00c4, 0x01380112, 0x0180015c, 0x01c201a2,
0x020202e2, 0x02420222, 0x02820262, 0x02bc02a0, 0x03f402d8, 0x0328030e, 0x035c0342, 0x03900376, 0x03c403aa, 0x04f803de, 0x042c0412, 0x04600446,
0x0494047a, 0x04c604ae, 0x05f604de, 0x0522050c, 0x054e0538, 0x05760562, 0x059a0588, 0x05be05ac, 0x05dc05ce, 0x06f405e8, 0x00de0000, 0x000e0015,
0x24018221, 0x001f0012, 0x20c98226, 0x22118410, 0x8214001f, 0x821b20cf, 0x000d2205, 0x20b38213, 0x20c78219, 0x200982e3, 0x200b8219, 0x222d8212,
0x821c001c, 0x84152005, 0x001c222f, 0x2201821b, 0x84100012, 0x00112245, 0x222794e5, 0x82120020, 0x076b4169, 0x75205983, 0x1f201182, 0x1b221382,
0x6b881100, 0x8d842420, 0x8b821220, 0x2d841a20, 0xe4001822, 0x75912582, 0x20203183, 0x0f202182, 0x12209782, 0xe9203f82, 0x1f200382, 0x14204582,
0x2120bd82, 0x20228d84, 0x9d822000, 0x3d821a20, 0x22242b83, 0x11011a00, 0x1c202382, 0x11205982, 0x0d227784, 0xc3821500, 0x27203383, 0x1b200782,
0x0e24bb82, 0xfb021900, 0x1c20c582, 0x18210f82, 0x207f8700, 0x210d820d, 0xf1460022, 0xe6002408, 0x93000f00, 0x000e2169, 0x1c222583, 0x1f82be03,
0x20002222, 0x1220d184, 0x20200782, 0x10208582, 0x61837182, 0x1f001224, 0x1f821801, 0x2320858b, 0x21208d84, 0x10202f82, 0x1922cf82, 0x5f96e700,
0xdd851520, 0x82830221, 0x110f411f, 0xb1437d83, 0x82e12005, 0x0dd1411f, 0x1b002224, 0x03821800, 0x24001c24, 0xe1821b00, 0xd1820f20, 0x11821c20,
0x1183e189, 0x41001f21, 0xe8200517, 0xdf938582, 0x35821920, 0x0e012422, 0xbd8bcd82, 0x21223983, 0x1b822100, 0x8d011a25, 0x83000d00, 0x491f2099,
0x22200a1d, 0x2006ff42, 0x8d1382dd, 0x08074495, 0x00120123, 0x873f820c, 0x820d207f, 0x821b20e7, 0x001224ad, 0x8297011f, 0x228b9319, 0x8e10010a,
0x82102033, 0x22a18341, 0x900f011f, 0x00192219, 0x21d38312, 0x4d969601, 0x95010922, 0x08221996, 0x19969401, 0x93010722, 0x06221996, 0x19969201,
0x91010522, 0x04221996, 0x1982ba02, 0x0f002222, 0xad830182, 0x10000d24, 0xb3831500, 0x01210023, 0x2c338498, 0x0018001c, 0x001b0012, 0x0016000d,
0x2419821a, 0x03120014, 0x831982bd, 0x202b83d9, 0x2013820d, 0x26358210, 0x00200012, 0x41160120, 0x20250e03, 0x26002100, 0x20598300, 0x411982df,
0x13200d87, 0x2105dd43, 0x338e1501, 0x21087741, 0x198e1401, 0x2605014a, 0x011f0012, 0x410b008e, 0x192208f1, 0x9f821600, 0x1f228f83, 0x17821301,
0x830b2542, 0x82132079, 0x82e02083, 0x207d8d17, 0x24158220, 0x00170111, 0x0c01420a, 0x0d822120, 0x0d011d22, 0x0e20158e, 0x19226b82, 0x1582fc02,
0x1400222a, 0x1f000d00, 0x1d001200, 0x21223784, 0x15842202, 0xfd821f20, 0x19822120, 0x15821a20, 0x1d821120, 0x0900e222, 0xb1449f84, 0x82b3200b,
0x000e2413, 0x82180010, 0x001d212b, 0x12240983, 0x08002302, 0x12202d82, 0x1520bf82, 0x57820782, 0x82fa0221, 0x0c074411, 0x828f0121, 0x07dd4211,
0x13001c22, 0x7c200182, 0xe9431182, 0x9001230c, 0x0f410700, 0x001c2608, 0x00f8021b, 0x28618406, 0x00220018, 0x0099011d, 0x20b38205, 0x22778222,
0x82fd0215, 0x0022280b, 0x00190016, 0x82b40011, 0x0019230b, 0x9382001c, 0x00f90223, 0x20098204, 0x089d821c, 0xae0056b0, 0x0e01de00, 0x62013801,
0xb2018a01, 0x0002da01, 0x48022402, 0x8a026a02, 0xc602a802, 0x0203e402, 0x3e032003, 0x7a035c03, 0xb4039803, 0xec03d003, 0x24040804, 0x5c044004,
0x92047804, 0xc604ac04, 0xfa04e004, 0x2e051405, 0x5e054605, 0x8e057605, 0xbe05a605, 0xee05d605, 0x1e060606, 0x4c063606, 0x78066206, 0xa4068e06,
0xce06ba06, 0xf606e206, 0x1e070a07, 0x46073207, 0x6a075807, 0x8e077c07, 0xb207a007, 0xd607c407, 0xf607e607, 0x12080408, 0x2e082008, 0x48083c08,
0x60085408, 0x78086c08, 0x8c088208, 0xa0089608, 0xa601aa08, 0xb7821700, 0x21001b22, 0x1c20e182, 0x0d22d582, 0x0f821d00, 0x1b001622, 0x0d201182,
0x2222e382, 0x15821d00, 0xe3821620, 0x11820e20, 0xdc021222, 0x15222f82, 0x0f821200, 0x0d001824, 0x3b820f00, 0x5b4c2520, 0x2217840f, 0x820e0019,
0x02182443, 0x82140017, 0x82192023, 0x22338343, 0x82160021, 0x001b220d, 0x41238420, 0x00210ca7, 0x202982ac, 0x2027820e, 0x201b8219, 0x2027821a,
0x20258220, 0x20818212, 0x2231820d, 0x82210022, 0x821c201d, 0x821b2015, 0x00932407, 0x82150013, 0x8421205f, 0x0b7d4345, 0x210ce34c, 0x27829f01,
0x2205774d, 0x821f0012, 0x8213202b, 0x00102249, 0x20578222, 0x2003820d, 0x82f18421, 0xaa02214f, 0x1c202782, 0x1320ad82, 0x1f225f82, 0x394a1a00,
0x820d200a, 0x82222015, 0x820f2011, 0x031f22f1, 0x20058201, 0x20358415, 0x2009821a, 0x2009820d, 0x202b8212, 0x830b8211, 0x06bb425d, 0x82570121,
0x821f20b3, 0x000e2213, 0x20258421, 0x2005821b, 0x207d8624, 0x821b8219, 0xa001218b, 0x1b200784, 0x998f2184, 0x3b842420, 0x95821820, 0xaf821020,
0x9b821b20, 0x69821620, 0x03239592, 0x820f0088, 0x821f207f, 0x820d204b, 0x871220a3, 0x200023a7, 0xc9821500, 0x4e011d22, 0x19201d82, 0x22204382,
0x11202184, 0x24200982, 0x1183cf82, 0x11000e24, 0x1d82ff02, 0x03821520, 0x14001b22, 0x3383a784, 0x91822020, 0x6d821c20, 0x2e002622, 0x20203b86,
0x4b4e1b82, 0x000e2205, 0x201d821d, 0x22458216, 0x82a3031b, 0x821c201d, 0x841d206f, 0x8212207f, 0x4b0e20dd, 0x202208fd, 0x15825901, 0x85820e20,
0x65482120, 0xc1032113, 0x41437784, 0x820d2005, 0x821f20dd, 0x821220ab, 0x00112697, 0x03260019, 0x203b848d, 0x2075821a, 0x2009821f, 0x2007820d,
0x20cd821b, 0x201f820e, 0x200b8210, 0x201d8476, 0x20298219, 0x45a9840d, 0x2120053d, 0x21055542, 0x8d84ae01, 0xa7821c20, 0x21820d20, 0x11203383,
0x10208582, 0x1d241582, 0xa5011200, 0x1c208d82, 0xe9424782, 0x70022112, 0x15201b82, 0x23205f82, 0x2383c582, 0x29480d20, 0x88b8200a, 0x054b4237,
0x5f820d20, 0x1222dd85, 0xf9868703, 0x07821120, 0x85821420, 0x95821320, 0x1f246f83, 0x97001100, 0x0e223788, 0x17821000, 0x15213783, 0x225d8300,
0x82af0112, 0x821f201b, 0x841d200b, 0x05b14523, 0x9b821620, 0xb7820e20, 0x53848220, 0x1f20e385, 0xf7839382, 0x23001622, 0x11220982, 0x378ab001,
0x82064145, 0x820e20a9, 0x00212479, 0x490c0098, 0x6f85080f, 0xf9821a20, 0x19001624, 0x19825101, 0x43090742, 0x1c2005d1, 0x11221b82, 0x19829c01,
0x41000e21, 0x1320096d, 0x2122ff86, 0x4d88b600, 0x1020f587, 0x2622af84, 0x4d8c4c01, 0x200b954c, 0x4119826f, 0x19200d45, 0x1324b582, 0x00032100,
0x10221986, 0x81511800, 0x8903230d, 0xc3420b00, 0x84212008, 0x822320cb, 0x02192233, 0x4117821d, 0xf9530721, 0x01122209, 0x211782a1, 0x4f44001c,
0x9e012110, 0xc9894784, 0x25823383, 0x909d0121, 0x84122017, 0x8292206f, 0x13434417, 0x5f84b720, 0x21001b22, 0x03458582, 0x00102605, 0x01210022,
0x41178250, 0xa94e0943, 0xb1012108, 0x2021a78a, 0x20178300, 0x22c5820e, 0x84040312, 0x00122417, 0x82160011, 0x000d214b, 0x20071542, 0x418f8481,
0xe54405dd, 0xc003250a, 0x15000a00, 0x19202b82, 0x2d873182, 0x83001222, 0x13451582, 0x00202207, 0x82f7821d, 0xa201214d, 0x1c201582, 0x1c200b82,
0x0d206982, 0x12260782, 0x20001b00, 0x15824d01, 0x240ded43, 0x0112001b, 0x4141849b, 0x4d830917, 0x80002122, 0x1b85578a, 0x12001426, 0x09008500,
0xc1834d84, 0x84000d21, 0xad012177, 0x87411382, 0x82132007, 0x8212206f, 0x8aa72053, 0x82042013, 0x000d240b, 0x82db020c, 0x0e174607, 0x829b0321,
0x821c2013, 0x432620b5, 0x0121094d, 0x2163844f, 0x9344001c, 0x001c2205, 0x20018213, 0x4513827f, 0x0e2209f9, 0x8b821100, 0x08008722, 0x220ccd42,
0x84a30120, 0x4be18311, 0x122205fb, 0x1182ab01, 0x0a269b87, 0x08000d00, 0x118aaa01, 0x11820820, 0xa8010722, 0x0620118a, 0x05221182, 0x118aac01,
0x16001126, 0x5a011b00, 0x1a205984, 0x2222a982, 0x7b822100, 0x7e001f22, 0x91871182, 0x1b001228, 0xa4011100, 0x8f820700, 0x0e202383, 0x1222cd82,
0x0f868600, 0x2f821a20, 0x21001b28, 0x06006d02, 0xa5440e00, 0x03192206, 0x200d84bf, 0x825d8320, 0x82b92035, 0x0811460d, 0x849a0121, 0x0575411b,
0xfe020e22, 0x10220d84, 0x47821500, 0x4b011122, 0x24065148, 0x00110022, 0x200b84b5, 0x22558212, 0x8402031f, 0x000e260b, 0x02200020, 0x200b826e,
0x242d8215, 0x02180010, 0x20178471, 0x2417821c, 0x00a90112, 0x20998204, 0x20c5821c, 0x20098284, 0x22378215, 0x82030321, 0x821c2009, 0x0012224b,
0x8409827d, 0xbd0221d1, 0x18240984, 0x58011200, 0x20260984, 0x2f002100, 0xd1826000, 0x00ac5a08, 0x01f800d2, 0x0140011c, 0x01840162, 0x01c601a6,
0x020602e6, 0x02460226, 0x02820264, 0x02be02a0, 0x03fa02dc, 0x03300316, 0x03600348, 0x03900378, 0x03be03a8, 0x04ea03d4, 0x04160400, 0x043e042a,
0x04640452, 0x04840474, 0x04a20494, 0x04be04b0, 0x04d604cc, 0x02e804e0, 0x26af82b5, 0x000d001c, 0x821c001b, 0x820d206d, 0x00162291, 0x20098220,
0x20b18222, 0x2617820f, 0x0013001c, 0x9e850213, 0x22bf8325, 0x822b0221, 0x82162025, 0x0f4f4837, 0x20053d44, 0x2457821b, 0x02210016, 0x2825962a,
0x000e001f, 0x00190016, 0x22078224, 0x84290226, 0x05654589, 0x240b9b48, 0x00220020, 0x2023860f, 0x9d2382b6, 0x821b20bb, 0x821020b9, 0x821120db,
0x0c4d53c9, 0x19208b82, 0x20226782, 0x8f821500, 0x77821020, 0x21206991, 0x0e20c982, 0x1b231982, 0x95002802, 0x82132021, 0x821f20c9, 0x82262025,
0x940f2021, 0x000f2243, 0x2265821c, 0x822c0221, 0x131941b3, 0x1d822420, 0x18001924, 0x1f962502, 0x18245583, 0x5d011200, 0x12221f82, 0x6f822300,
0x51821920, 0x77841d20, 0x13820d20, 0x1f245d83, 0x5c011100, 0x20241f84, 0x21001800, 0x0d221f84, 0x8f822400, 0x11001b22, 0x24240d82, 0x5a022000,
0x7f936782, 0x22001f26, 0x27021b00, 0x10201d96, 0x1f221782, 0x0582eb00, 0x1a207b91, 0x11245982, 0x26021200, 0x0f203b96, 0x20225982, 0x1d828602,
0x2118a141, 0x5984b903, 0xcd821920, 0x41058f49, 0x6b8505a1, 0x86011f24, 0x19820d00, 0xc7822320, 0x07821020, 0x0d822020, 0xdd821c20, 0xfb841520,
0x0c00d522, 0x39890782, 0xef822020, 0x11821220, 0xa6031d22, 0x20062546, 0x242b8222, 0x0020000d, 0x2463821a, 0x01190019, 0x2017825b, 0x410f8212,
0x19830921, 0x07031022, 0x10221786, 0x69821f00, 0x20094749, 0x20478ca5, 0x26458219, 0x0014001f, 0x82420112, 0x821f2017, 0x8214200d, 0x8215208f,
0x001b2307, 0x87820011, 0x00240223, 0x1101420a, 0x82840121, 0x00122115, 0x0d28c387, 0x22001500, 0x88000f00, 0x0e202b84, 0x75823783, 0x1624a583,
0xa4031d00, 0x0e201582, 0x1220b582, 0x61835982, 0x6f831b20, 0x86ea0021, 0x820e2015, 0x82222015, 0x830e20bf, 0x87022315, 0xaf840900, 0xf3822320,
0x03820d20, 0x0e002124, 0x13828402, 0x21821620, 0x29821020, 0x67821320, 0x0321f582, 0x20138205, 0x2013820e, 0x092b4215, 0x000a0327, 0x001c0008,
0x4639841b, 0xb3220549, 0x43850700, 0x82160021, 0x00202293, 0x410f84ec, 0x89200979, 0x16200f82, 0x1922eb82, 0x05821d00, 0xb2011124, 0x2f820600,
0x0b821520, 0x12002724, 0x0d82be02, 0x1a001c22, 0x16200d82, 0xba205582, 0x1f200d82, 0x13200b82, 0x2022c982, 0x29840603, 0x2306a741, 0x04000903,
0x01217985, 0x2609845e, 0x03180010, 0x82030008, 0x00202235, 0x200782ed, 0x08d38223, 0x3e001e40, 0x96006e00, 0xda00b800, 0x1a01fa00, 0x58013a01,
0x92017601, 0xca01ae01, 0xfa01e201, 0x2a021202, 0x56024002, 0x82026c02, 0xaa029602, 0xce02bc02, 0xea02de02, 0x0203f602, 0x8d030e03, 0x4d821700,
0x1b229983, 0xe1841000, 0x15001d22, 0x21207382, 0x0d200382, 0x57419182, 0x82202005, 0x820e20e5, 0x0212240d, 0x8c1300b1, 0x0011222f, 0x2035820d,
0x233b821b, 0x0026001f, 0x21080d42, 0x1182b701, 0x0f822520, 0x20001c24, 0xa5822200, 0x27821220, 0x83001a21, 0x822220ef, 0x000d2411, 0x9eb60105,
0x02042621, 0x000f0088, 0x08bb4823, 0x0b820e20, 0x41820e20, 0x0e001922, 0x2105a150, 0x0782b901, 0x1d20638f, 0x6187a982, 0x1f9cb820, 0xa3820420,
0x8f000e21, 0x821b203f, 0x8214206f, 0x999f83ab, 0x0104221d, 0x8f2382ba, 0x8227203b, 0x001f243b, 0x825c021c, 0x8211201b, 0x822120a9, 0x0fbf5707,
0xaf582920, 0x4e1f2008, 0x02230f6b, 0x840b0072, 0x000e248f, 0x8411001b, 0x0012263b, 0x03200020, 0x2117840c, 0x4f830016, 0x26059741, 0x001d000e,
0x8e73021d, 0x001a282f, 0x001f001c, 0x82b40312, 0x82222017, 0x821c2009, 0x00202643, 0x001a0026, 0x2419820f, 0x00890219, 0x0a4f410a, 0x22000f22,
0x26225d82, 0x158c9303, 0xc3822020, 0x21000e24, 0x15846102, 0x21820d20, 0x434e2120, 0x8a022109, 0x1b202b8c, 0x21205582, 0x2f242f82, 0x1e000900,
0x0e224d82, 0xf5821900, 0x11822720, 0x0e031f22, 0x25201382, 0x1220b182, 0x2020cb82, 0x1c261582, 0xb5011b00, 0x6f410800, 0x8630200e, 0x20378311,
0x24258210, 0x000d0321, 0x20238407, 0x825b8219, 0x8a0023cb, 0x29430500, 0x03192206, 0x200b828c, 0x245d8217, 0x03210010, 0x420b820b, 0x2820071b,
0x1f200b82, 0x1f26ef84, 0x0400b401, 0x49831100, 0x5a002108, 0xee00b600, 0x54012601, 0xac018201, 0x0002d601, 0x52022a02, 0xa2027a02, 0xf002ca02,
0x3c031603, 0x0806555f, 0xf203ce8f, 0x38041604, 0x7a045a04, 0xb8049a04, 0xf404d604, 0x30051205, 0x6c054e05, 0xa4058805, 0xdc05c005, 0x1406f805,
0x4c063006, 0x80066606, 0xb4069a06, 0xe806ce06, 0x1c070207, 0x4c073407, 0x7c076407, 0xac079407, 0xdc07c407, 0x0a08f407, 0x36082008, 0x62084c08,
0x8c087808, 0xb408a008, 0xdc08c808, 0x0209f008, 0x26091409, 0x4a093809, 0x6e095c09, 0x92098009, 0xb609a409, 0xd809c809, 0xf409e609, 0x0e0a020a,
0x240a1a0a, 0x2d012e0a, 0x099f5e00, 0x2405ef41, 0x00250012, 0x12db4721, 0xf1820d20, 0x19820d20, 0x0d001c26, 0x2c011900, 0x192037aa, 0x21213182,
0x24378300, 0x0023011f, 0x08475f16, 0x16206f83, 0x11204782, 0x83087343, 0x8210200d, 0x00122867, 0x0020000e, 0x9c220112, 0x8b37832d, 0x0026222d,
0x205b8c14, 0x213d8219, 0x65830020, 0x22000f24, 0x01821900, 0x0d821220, 0x11001224, 0x298e2b01, 0x1f202583, 0x18202d82, 0x21228982, 0x81821500,
0x31821c20, 0x15001424, 0x298e2701, 0x1b205389, 0x1a222182, 0x31820f00, 0x03821f20, 0x1a011122, 0x9d42298e, 0x82142005, 0x000d22df, 0x222b8217,
0x82210020, 0x00132661, 0x00250126, 0x45a79013, 0x202205ed, 0xf9821d00, 0x27821020, 0x14001b24, 0x278e1901, 0x5d57518b, 0x82c7200b, 0x82162027,
0x842120dd, 0x000d218b, 0x00211b8a, 0x2043840d, 0x207f8410, 0x8527846b, 0x000d22b1, 0x8369821a, 0x205583c3, 0x20f1820d, 0x20378212, 0x2207821c,
0x82200111, 0x20098347, 0x2021821a, 0x20418221, 0x20ad8210, 0x85b18419, 0x221f8327, 0x826c0021, 0x86162025, 0x07c747ff, 0xe3821f20, 0x1c204b8d,
0xc38b4b8e, 0x21086d55, 0x25827700, 0x6d841220, 0x89842220, 0x75821120, 0xd1821d20, 0x26000e22, 0x73410982, 0xcc012406, 0x8b001100, 0x862120e7,
0x207d830d, 0x240b8215, 0x01210013, 0x97238221, 0x822120bb, 0x82252065, 0x8e1b2023, 0x20938b23, 0x83238219, 0x8e2e2047, 0x42222023, 0x1f2006a7,
0x2208d961, 0x8e1f0111, 0x0b274123, 0x9b841320, 0x2e011922, 0x20065541, 0x21dd841a, 0x4790000d, 0x82110321, 0x000e2421, 0x821c0023, 0x001624f9,
0x45120021, 0x21820fa7, 0x3d820f20, 0x0f20218d, 0x23093b56, 0x0f007502, 0x2006df42, 0x204b8220, 0x2041821f, 0x20ad8212, 0x82ed840d, 0xc6012151,
0x37413d82, 0x820f200b, 0x840e2061, 0x000d24cf, 0x82950324, 0x5a19201d, 0x0d200845, 0x0e228182, 0x3b821800, 0x13001c26, 0xc2031300, 0x43821d82,
0x12222d82, 0x01822000, 0x200d5d42, 0x411d8278, 0x23200fb7, 0x11204b82, 0x01213f83, 0x83778ecd, 0x841b2019, 0x0014245f, 0x82c30312, 0x20ab851d,
0x83bf820d, 0x20778309, 0x24158213, 0x02210020, 0x2307828b, 0x0019001c, 0x1f204983, 0x2022af82, 0x53821d00, 0x5b821020, 0x19000e24, 0x1182c501,
0x0c20d18b, 0x1d200f82, 0x22242d82, 0x52012000, 0x12201b86, 0x220ab962, 0x821c0019, 0x0011224f, 0x085752d0, 0x59820d20, 0x24001c22, 0x2109d353,
0x1b842401, 0x1a001f22, 0x99442982, 0x41212005, 0x10220619, 0x1b845601, 0x15208d8b, 0x1122bd86, 0x8b8ec901, 0x1f001322, 0x1a201b82, 0x2022ad82,
0x1b821603, 0xb3821920, 0x07821d20, 0x83822120, 0x83000d21, 0x821c201d, 0x01212275, 0x216f8e43, 0x53830020, 0x2024e583, 0x0c002901, 0x220c2144,
0x8222001e, 0x0021240f, 0x82150312, 0x20518d19, 0x246d820f, 0x01180010, 0x22338e1e, 0x82190010, 0x000e2483, 0x82c8011f, 0x0b2d4119, 0xa1861120,
0x28010e22, 0x1d20338e, 0x16204b82, 0x03219d83, 0x48338414, 0x1f200517, 0x8d434782, 0x82102005, 0x8a132081, 0x212b8319, 0x3583000d, 0x23821420,
0x19823120, 0x20000e24, 0xcb4d2100, 0xcb01230f, 0xb9430b00, 0x001b220c, 0x2265821c, 0x8ebb0012, 0x06e94317, 0x849c0321, 0x001b2117, 0x1f205583,
0x1f205f82, 0x1b243d82, 0x2a012100, 0xdd431782, 0x4720200b, 0x012105ff, 0x41178455, 0x1c20099f, 0x12243382, 0x94031b00, 0xdb421782, 0x8219200b,
0x001b24df, 0x8e1d0111, 0x820f2047, 0x0019248f, 0x82320011, 0x83c18717, 0x842420f5, 0x01112277, 0x5a8f8453, 0x035405a5, 0x7402230a, 0x79430a00,
0x82612012, 0x20a58315, 0x206d8224, 0x2655821f, 0x0006000d, 0x82ca0103, 0x0b854115, 0x19821520, 0xcf011f22, 0x95831582, 0x15002024, 0x2f820d00,
0x21002222, 0x60208b82, 0x04244190, 0x80020300, 0xef594184, 0x821d2007, 0x0014272d, 0x00d00112, 0x41890009, 0x13001c26, 0x2f011300, 0x22241382,
0x10001b00, 0x16204d82, 0x1b244f82, 0x74002000, 0xaf451382, 0x841d2009, 0x8c6820d9, 0x001b2613, 0x00240012, 0x8d138262, 0x000822bd, 0x28278c67,
0x00230011, 0x00c2011f, 0x0cd34108, 0xc1010a22, 0x0922118e, 0x118ec001, 0xbf010822, 0x0722118e, 0x11821203, 0x79821220, 0x42001121, 0xbd2007c9,
0x0622238e, 0x118ebc01, 0xbb010522, 0x0422118e, 0x1182d101, 0x220b0741, 0x8210031b, 0x0c594511, 0x8ec40121, 0x010c2235, 0x24118ec3, 0x00bd000b,
0x0cd56307, 0x06002d23, 0x08434200, 0x82540121, 0x441c200d, 0x01210797, 0x410d82be, 0x8b2209d3, 0x39840500, 0x1a002224, 0x0b82ce01, 0x1f268d83,
0xd2011200, 0x41840400, 0xbc001d22, 0x0e240984, 0x0f031400, 0x0e220982, 0xf7821000, 0x00153208, 0x0048002c, 0x00780060, 0x00a4008e, 0x00cc00b8,
0x01f000de, 0x01100100, 0x01300120, 0x014c0140, 0x01640158, 0x017c0170, 0x00ef0086, 0x001d000d, 0x20058220, 0x2069821b, 0x24078221, 0x00160013,
0x24458225, 0x00c40311, 0x2213820b, 0x82130019, 0x82102015, 0x00222809, 0x0020001f, 0x82b50312, 0x12594d17, 0x00f30023, 0x2021820a, 0x204f820e,
0x20438215, 0x24358210, 0x031e0012, 0x22158419, 0x8222001c, 0x000d2217, 0x24cf8424, 0x00c00218, 0x872b8209, 0x000e2215, 0x20018211, 0x201382ee,
0x888b841d, 0xd5012383, 0x27820800, 0x1d821620, 0x39820d20, 0x13001324, 0x1184d301, 0x16203183, 0x1b26a582, 0xd6012100, 0x238a0700, 0x17031b22,
0x12220f82, 0x7f822100, 0x1d228b83, 0x0f84be00, 0x11822020, 0x1222c183, 0x0f825f01, 0x1a000e22, 0x1d213d82, 0x20478300, 0x850f82f0, 0x821c2077,
0x031324eb, 0x84050018, 0x821120c7, 0x829d20eb, 0x000e220b, 0x222b8223, 0x84330019, 0x821a200b, 0x0120220b, 0x242386d4, 0x021b0016, 0x840b84bf,
0xcc0323cb, 0xa7820400, 0x21000e28, 0x03009703, 0x4f821600, 0x00173208, 0x00520030, 0x00900072, 0x00c600ac, 0x01f800e0, 0x0122010e, 0x01440134,
0x01640154, 0x01840174, 0x01a20194, 0x01ba01ae, 0x01ce01c4, 0x001b03d8, 0x22378210, 0x42150014, 0xc9820923, 0x75821f20, 0x59821a20, 0x03238982,
0x410f001e, 0x1420068d, 0x0e222382, 0x01822000, 0x1f840d20, 0xe3821d20, 0x1f032622, 0x8d83d582, 0x8b001f21, 0x0013221f, 0x202d8222, 0x205f8219,
0x205f920d, 0x24a9821c, 0x00350013, 0x201b860c, 0x0a0f4d0d, 0x26002124, 0x19828e03, 0x19001224, 0x4b481d00, 0x6101230f, 0x7b820b00, 0x11000e22,
0x75418582, 0x821a2005, 0x01102443, 0x820a00d9, 0x821f2013, 0x8220202f, 0x821f2095, 0x001b26b1, 0x00440114, 0x237d8f09, 0x0800da01, 0x24202986,
0x18244984, 0x0700db01, 0x19200984, 0x35822b82, 0x821c0321, 0x8216200f, 0x8221205f, 0x001f2445, 0x86600126, 0x2173861f, 0x0f82c503, 0x65821c20,
0x03820d20, 0x0f002224, 0x0f823400, 0x0e001223, 0x05e54500, 0xd7011422, 0x11200f82, 0x0d200d82, 0x13263f82, 0xd8011300, 0x71860600, 0x1b001c26,
0x05002e02, 0x21201782, 0x19227182, 0x0b822003, 0x45822120, 0x20001d26, 0x04001a03, 0x00231383, 0x8292031d, 0x21158409, 0x09821d03, 0x1a001c22,
0x5d221782, 0x43820200, 0x2c001534, 0x82005c00, 0xca00a600, 0x1201ee00, 0x54013401, 0xbb507401, 0x01e43406, 0x021802fe, 0x023c0230, 0x02540248,
0x0098035e, 0x821b0017, 0x82122033, 0x8212205f, 0x841a208d, 0x840e20dd, 0x000d230d, 0xb1570010, 0xdd01210e, 0x1a206582, 0x1420c582, 0x0d200782,
0x83670782, 0x32012114, 0x1b225182, 0x23822000, 0x83052b4b, 0x001621e7, 0x20052552, 0x20618213, 0x20198219, 0x2023848d, 0x20238823, 0x20ef8210,
0x23038219, 0x0020001f, 0x21061341, 0x2382a003, 0x1d001a22, 0x21201584, 0x1b206d82, 0x0d209782, 0x1552ad84, 0x34012108, 0x16206b8e, 0x1d83cf82,
0x210a614f, 0xc9822403, 0x7f841b20, 0x6b8f8f85, 0xa8001b25, 0x89000f00, 0x20f98369, 0x8347821c, 0x82102043, 0x01202273, 0x8b1f8233, 0x821220d1,
0x821c202d, 0x82162019, 0x21298259, 0x9d843101, 0x6183f189, 0x23821a20, 0x45831220, 0x0d207f82, 0x12219584, 0x207f9100, 0x8bed828c, 0x00122279,
0x23f18725, 0x0c002203, 0x13203782, 0xab64ff82, 0x3601210e, 0x6f891984, 0x15001d22, 0x21242582, 0x30011c00, 0x1020198e, 0x22086f62, 0x820b0035,
0x2233894d, 0x82160019, 0x0318240f, 0x82050023, 0x001d2207, 0x20cf8222, 0x200b84bf, 0x224b820f, 0x82dc0125, 0x06eb410b, 0x00210323, 0x25898504,
0x0300de01, 0x91862000, 0x6e00463e, 0xbc009600, 0x0401e000, 0x46012601, 0x80016401, 0xac019a01, 0x14006501, 0x26001200, 0x5d09ed53, 0x3b5d0cff,
0x6401230a, 0x299c1300, 0x1d821920, 0x21001324, 0x279e6301, 0x91821120, 0x1b002424, 0x2f826701, 0x7147798f, 0x2ab58206, 0x000e001d, 0x01120010,
0x9c110066, 0x00222475, 0x9268011d, 0x82102023, 0x821d203f, 0x82192047, 0x0010246d, 0x83770218, 0x20e78e4d, 0x201b8210, 0x065d441b, 0x6a011924,
0x69900f00, 0x11821f20, 0x22002124, 0xaf821f00, 0x51826c20, 0x2320af8f, 0x16204182, 0x6922a784, 0x3d900d00, 0x16001522, 0x01239983, 0x900c006b,
0x8221201b, 0x010f244d, 0x8d080062, 0xc6032319, 0x35820700, 0xcf432120, 0x1ba60806, 0xa0004f00, 0xfc00d000, 0x4a012401, 0x92016e01, 0xda01b601,
0x2002fe01, 0x64024202, 0xa6028602, 0xe202c402, 0x1e030003, 0x5a033c03, 0x92037603, 0xca03ae03, 0x0204e603, 0x3a041e04, 0x70045604, 0xa4048a04,
0xd804be04, 0x0c05f204, 0x3c052405, 0x6c055405, 0x9c058405, 0xcc05b405, 0xfa05e405, 0x26061006, 0x52063c06, 0x7c066806, 0xa4069006, 0xcc06b806,
0xf406e006, 0x1c070807, 0x40072e07, 0x60075007, 0x80077007, 0xa0079007, 0xbc07ae07, 0xd607ca07, 0xee07e207, 0x0208f807, 0x16080c08, 0x17003702,
0xad821c00, 0x4105b54f, 0x23240551, 0x1b001200, 0x0583c582, 0x0b821020, 0x7b450d20, 0x02122408, 0x8a15003e, 0x0019242f, 0x8222000e, 0x0011262b,
0x0026001f, 0x2027820d, 0x44098212, 0x02230631, 0x8a13003b, 0x8214202b, 0x83698319, 0x452b8521, 0x122205cf, 0x6382f200, 0x21208385, 0x1c207582,
0x49854f82, 0x31820e20, 0x6f821020, 0x11821620, 0x48021424, 0x4d8a1100, 0x0b821d20, 0x21002022, 0x1c207382, 0x13206582, 0x10243782, 0x3a021200,
0x1420238c, 0x20209d82, 0xa1449584, 0xf100210a, 0x6d892388, 0x210e0969, 0x23829e03, 0x14001622, 0x21227b82, 0xe1820f00, 0x05821920, 0x200f1744,
0x2223826e, 0x821d000e, 0x821c2083, 0x000d2205, 0x202d8210, 0x2095821f, 0x20cd821a, 0x2407820f, 0x0218001c, 0x8f15824e, 0x0cdb61d9, 0x88330221,
0x82192021, 0x000e22a9, 0x20018221, 0x4bb7821f, 0x02210869, 0x22218c49, 0x821f001d, 0x059d45eb, 0x71822020, 0x1d001c24, 0x218c4a02, 0x7f821f20,
0x45822020, 0xb7820e20, 0x2b824983, 0x0f204382, 0x870c3b41, 0x20418743, 0x42718236, 0x0e200b05, 0x0d226582, 0x15822400, 0xa3822182, 0x3d8a0e20,
0x2009df70, 0x22658216, 0x8c4c0226, 0x822f823b, 0x08c1709f, 0x8c3c0221, 0x8215201d, 0x00202247, 0x2021821d, 0x22178221, 0x82700119, 0x0b434105,
0x200dc35a, 0x203b8c44, 0x065d451d, 0x15821a20, 0x26001026, 0x0d003902, 0x1322958a, 0x0d821900, 0x59821f20, 0x0221fb82, 0x201b8c43, 0x2231821d,
0x8218001f, 0x001b241b, 0x821e0214, 0x0016221b, 0x200f821b, 0x08df5f12, 0x12001a22, 0x0e22f182, 0x378c3f02, 0x31821920, 0x17830f20, 0x26220382,
0x37843d00, 0x0d260f89, 0x22001a00, 0x23822000, 0x3c001022, 0x0f221b90, 0x01821c00, 0x20001824, 0x5388c102, 0x20096f42, 0x20358210, 0x20c38221,
0x206f8c31, 0x2015820e, 0x0891461f, 0x1b822620, 0x0f000e22, 0x696d9982, 0x05474609, 0x8f001224, 0x576f0c00, 0x820d200e, 0x0013240f, 0x862c0313,
0x49182019, 0x02210fa9, 0x8333884a, 0x8211204f, 0x841b206b, 0x02142203, 0x22198230, 0x8226000e, 0x821f2069, 0x000d21cf, 0x2108e94f, 0x3384d600,
0x4b822420, 0x22057742, 0x861f001c, 0x8c4120b9, 0x821a204d, 0x8223207d, 0x00122419, 0x82450120, 0x00162219, 0x224d821b, 0x821f000e, 0x82202039,
0x000e284f, 0x00120019, 0x920b0090, 0x021b22b5, 0x20178846, 0x22698419, 0x82270016, 0x020e2201, 0x48178c38, 0x1b2405d9, 0x3b001800, 0x16211782,
0x0b894100, 0x11000e26, 0xe1011100, 0x12221782, 0x21820e00, 0x79820d20, 0x85001221, 0x02122295, 0x20478c3d, 0x20838215, 0x228d8221, 0x8c420219,
0x001c2217, 0x24018213, 0x021f0012, 0x21178c45, 0x3183001d, 0x12001b24, 0x7784a803, 0xa5820982, 0x41822420, 0x14001622, 0x21241b82, 0x0a00a703,
0x220a6576, 0x83260021, 0x400221ed, 0x53431582, 0x821a2009, 0x00192497, 0x8c350219, 0x82102015, 0x00132415, 0x826f0112, 0x0b074315, 0x10222d83,
0x2b8c4d02, 0x2b822120, 0x16002524, 0x158c4702, 0x6b821d20, 0x26000e26, 0x09004b02, 0x20065b41, 0x209d8219, 0x229d8220, 0x8c340212, 0x820f2013,
0x021f223f, 0x26138c32, 0x0021000e, 0x5c81021a, 0x21200633, 0x1d203982, 0x14202582, 0xe9209182, 0x1c242784, 0x20001800, 0x21261582, 0x1c002400,
0x13842b03, 0x13821020, 0x6b820d20, 0x63821d20, 0xe8011b22, 0x1c22278c, 0x3b821b00, 0x4f84df20, 0x11001b22, 0xe1833b82, 0x8e202983, 0x16221382,
0x33822300, 0x15000d22, 0x19260582, 0xe0011d00, 0x09820800, 0x2005af41, 0x222d820e, 0x82270311, 0x820e2011, 0x00142243, 0x23878522, 0x07002d03,
0x26206b82, 0x19200d82, 0x2622ab82, 0x0f84e701, 0x09229787, 0x0f8ce601, 0xe5010822, 0x07220f8c, 0x0f82ab02, 0x21247787, 0xe3012300, 0x06241f8c,
0x06002f02, 0xfb425b82, 0x28032106, 0x22200d84, 0x10248182, 0x6d011500, 0xe1450d84, 0xea012306, 0x89820500, 0x82002221, 0xe40121cd, 0x85840b84,
0x82250321, 0x430e200b, 0x012305a7, 0x820400e2, 0x821b20d1, 0x82c020f7, 0x05654409, 0x09823620, 0x39821c20, 0x29031d22, 0x20241384, 0x2a032100,
0x54081384, 0x00180010, 0x00500027, 0x009a0076, 0x01e000be, 0x01240102, 0x01640144, 0x01a00182, 0x01d601bc, 0x020a02f0, 0x023a0222, 0x02660250,
0x0292027c, 0x02bc02a8, 0x02e402d0, 0x030a03f8, 0x032c031c, 0x034a033c, 0x03620356, 0x0376036c, 0x038a0380, 0x039a0392, 0x227f822e, 0x821f000e,
0x82222059, 0x841f20c5, 0x0011240d, 0x821a000d, 0x001622e5, 0x26a78219, 0x0125001c, 0x821100eb, 0x821b2091, 0x0bb54603, 0x4a000d21, 0xc18208db,
0x23829320, 0x07821220, 0xd1842020, 0x05821420, 0x2310f15b, 0x10003c00, 0x43085157, 0xfd440b8f, 0xf3002108, 0x22202182, 0x21227782, 0xd9461600,
0x82182008, 0x096b6f8f, 0x43963d20, 0x21085d45, 0xb5844801, 0x81821b20, 0x27204583, 0x240c136a, 0x021b001c, 0x871f82bb, 0x09277963, 0x0e26d983,
0x21001f00, 0x3182ec01, 0x23001c22, 0x12208182, 0x10207982, 0x12201382, 0x3b20438a, 0x26200b82, 0xed451782, 0x820d200d, 0x00112415, 0x82d10011,
0x833b8319, 0x05bb5c39, 0x1b001622, 0x25248f84, 0x0c00a900, 0x48065541, 0x38200f1b, 0x1c221982, 0xb1821100, 0xdd820d20, 0x1a001c22, 0x12200182,
0x21223782, 0x19842002, 0x13208b87, 0x2309f152, 0x0b005002, 0x48064b41, 0x6d200d31, 0x22201782, 0x20066746, 0x83c5840d, 0x021c2657, 0x000a0077,
0x20cb841c, 0x0985710d, 0x82370121, 0x82122015, 0x84142015, 0x0021287b, 0x001d0026, 0x82ed0112, 0x51438915, 0x122205eb, 0x1582c200, 0x21102b42,
0x5784a903, 0x1f20eb83, 0x2620bb82, 0x19260382, 0x78021200, 0x6d880900, 0x2106494e, 0x13843901, 0x1220e585, 0x1624ed82, 0x41012100, 0x1b201384,
0x26207d82, 0x20089b49, 0x42138292, 0x02230e49, 0x820800c3, 0x821c204f, 0x000d2435, 0x820e000f, 0x82382007, 0x82162011, 0x000d216d, 0x41839f83,
0x07003923, 0x22118500, 0x8213001c, 0x82912001, 0x2247850f, 0x8214000e, 0x007122d5, 0x20678206, 0x2497841a, 0x00720126, 0x83098205, 0x001222e5,
0x200b843a, 0x243d8223, 0x00c20212, 0x20698604, 0x200982c1, 0x2213820e, 0x848d0219, 0x821f2013, 0x827620d7, 0x82122009, 0x02222471, 0x8203004f,
0x021d2287, 0x2407828c, 0x0020001a, 0x83078237, 0x1a36087d, 0x60003600, 0xb0008a00, 0xf600d400, 0x34011601, 0x6e015201, 0xa6018a01, 0xde01c201,
0x1402fa01, 0x48022e02, 0x76026002, 0x9c028a02, 0xba02ac02, 0xd202c802, 0xa182c802, 0x21001c22, 0x13206d82, 0x0e20c384, 0x220a3955, 0x821d000d,
0x22a98569, 0x9cc70211, 0x096d4929, 0xc5021222, 0x5399ed82, 0x23063541, 0x1100c602, 0x7997ef82, 0x13001c24, 0x73821300, 0x239c1020, 0xf0011b24,
0xa3820f00, 0xbb822320, 0x07821420, 0x79822120, 0x11820d20, 0x3d821220, 0x1f001c26, 0x8e021200, 0x12241582, 0x24002100, 0x1f264782, 0x0d001800,
0x09821900, 0x09821020, 0x7f821220, 0x1d823f20, 0x0d20a983, 0x1b203f82, 0x12202582, 0x00213383, 0x22098420, 0x82b30211, 0x611c202d, 0x02211577,
0x941b84c4, 0xb20221bd, 0x738b3384, 0x21083551, 0x1b82f101, 0x8d000e21, 0x821b20af, 0x822520b5, 0x84f72073, 0x7c242053, 0x1d200a41, 0x1d209f82,
0x1f221d82, 0x3784ef01, 0x22002122, 0x0d21a184, 0x20158300, 0x2005821c, 0x221d8219, 0x820c003e, 0x20378305, 0x8307821f, 0x820e2011, 0x821220c3,
0x84f52003, 0x20898b19, 0x06e94124, 0x1990f420, 0x3b841020, 0xf8001927, 0x1c000b00, 0x24858500, 0x00110016, 0x26178214, 0x02200021, 0x410a0051,
0x16200c69, 0x1b242582, 0x0900d300, 0x0d20bd86, 0x12203382, 0x18240b82, 0x08002f03, 0x21201b82, 0x9d440b82, 0x5d022306, 0x67490700, 0x821a2008,
0x00942209, 0x20218206, 0x24a1820d, 0x011a0016, 0x200d82ee, 0x85ff820e, 0x007922db, 0x263d8604, 0x000300f6, 0x84100013, 0x002e2c1d, 0x0064004c,
0x0390007c, 0x840f0030, 0x001b25fd, 0x0016000d, 0x0f220583, 0xb1841f00, 0x59822020, 0xac021f22, 0x1b20a582, 0x1222b782, 0x09861a00, 0x210a8d44,
0xdd823103, 0x5d731d20, 0x203d8308, 0x220d821b, 0x82990324, 0x82132017, 0x0997456d, 0x5d831d20, 0x82320321, 0x202f87df, 0x24118224, 0x03150021,
0x20cd82aa, 0x205b821d, 0x080f8410, 0x5700267e, 0xe200b000, 0x42011201, 0xa2017201, 0xfc01d001, 0x4e022602, 0x9e027602, 0xec02c602, 0x38031203,
0x84035e03, 0xcc03a803, 0x1404f003, 0x5a043804, 0x9e047c04, 0xe004c004, 0x20050005, 0x5e054005, 0x9a057c05, 0xd605b805, 0x1206f405, 0x4e063006,
0x88066c06, 0xc006a406, 0xf806dc06, 0x30071407, 0x66074c07, 0x9a078007, 0xce07b407, 0x0208e807, 0x32081a08, 0x5e084808, 0x8a087408, 0x0806fb60,
0xec08da33, 0x1009fe08, 0x34092209, 0x54094409, 0x74096409, 0x90098209, 0xaa099e09, 0xc209b609, 0xda09ce09, 0xf209e609, 0x060afc09, 0x18001802,
0x1c001500, 0x05274600, 0xc5822020, 0x40182720, 0x19200879, 0x10200982, 0x0d201982, 0x2122df84, 0x07822200, 0x19021924, 0x31a21700, 0x21088b66,
0x2fa41a02, 0x21080367, 0x2f868f02, 0x87841b20, 0x19000f22, 0x79787782, 0x0020220d, 0x201b821d, 0x24b9820e, 0x031f0012, 0x822f8238, 0x1a002207,
0x0dfb5300, 0xcb820d20, 0x3d601b20, 0x8216200c, 0x031b22e7, 0x2217829f, 0x42100016, 0x27850863, 0x53820d20, 0x0e20158d, 0x21227982, 0xeb823603,
0x10205d87, 0x200c516c, 0x08234c0d, 0x11001b2a, 0x1f000e00, 0x14004200, 0x83082345, 0x8216201d, 0x82102013, 0x10cd5e45, 0x00450023, 0x22178213,
0x6e26000e, 0xff4c0dcd, 0x4100210f, 0x0e212782, 0x05754500, 0x1320518f, 0x1920c782, 0x11225d84, 0x2784f701, 0x9f821b20, 0x81821f20, 0x03821a20,
0x24000d22, 0xe7461f82, 0xdf401805, 0xf5012108, 0x0d792792, 0x3f032312, 0x4b821200, 0x3f492420, 0x82202006, 0x00212207, 0x204f8221, 0x20e1821b,
0x20a58220, 0x2211821b, 0x82440024, 0x82192005, 0x8ac5916b, 0xb902219b, 0x16202582, 0xdb760382, 0x22e7900a, 0x886f0011, 0x095d624b, 0x11000e22,
0x67560182, 0x3d03210a, 0xbb414b84, 0x3703211e, 0x11423582, 0x820e2009, 0x820e20b9, 0x21c58c71, 0x23865e02, 0xe7822020, 0x1d821b20, 0xdd841d20,
0x210c6341, 0x2382f601, 0x41000e21, 0xb5790d55, 0x8296200f, 0x001c2223, 0x2263841f, 0x8419000f, 0x452420e7, 0x0d200657, 0x13245b82, 0xf4011300,
0x13204792, 0x20222382, 0x79821500, 0x26001222, 0x44223582, 0x11421000, 0x064b4116, 0x82380321, 0x1ce74221, 0x8a360321, 0x14ab4221, 0x10218982,
0x87d18f00, 0x23878489, 0x0f003503, 0x1f228d82, 0x99821a00, 0xf96f2b83, 0x001a2209, 0x205f8216, 0x4e1f82a3, 0xaf82065b, 0x1b001624, 0xc3841800,
0x57821f20, 0x12002024, 0x1f8a9002, 0x7d430d20, 0x82242006, 0x001f221b, 0x22578211, 0x94a60011, 0x059b413f, 0x1d002224, 0x2b82ad02, 0x1f001223,
0x05974100, 0x63820e20, 0x210ab145, 0x1d82a500, 0x1f207d91, 0x1b249982, 0xcc021400, 0x1c223b84, 0x73431d00, 0xcf022113, 0xfd4a598c, 0x3c03210e,
0x1a201d86, 0x2008fd4f, 0x2009821b, 0x24598224, 0x03160013, 0x4f1d8a3b, 0x1f82085b, 0xa7821a20, 0xa4001422, 0x19289594, 0x10001c00, 0xa7001800,
0x1220fd84, 0x12222982, 0x4f681b00, 0x0019240c, 0x82fc0119, 0x0f77441d, 0x59822020, 0x11001d26, 0xac031300, 0x14203b86, 0x0e203982, 0x24243d86,
0x1a001c00, 0x1b221782, 0x2782b702, 0xa1821f20, 0x8208e150, 0x8215200f, 0x0014240f, 0x82390315, 0x072d420b, 0x4b821620, 0x16267b85, 0x26002100,
0x1b829603, 0x2007b743, 0x204d8213, 0x26e9841f, 0x001f001c, 0x84730118, 0x09796b43, 0x3b821b20, 0x23821f20, 0x01214382, 0x201b8a76, 0x41678219,
0x1c2205fb, 0x01821300, 0x53886920, 0x2009bf43, 0x05d1421d, 0x86fb0121, 0x82212037, 0x820d2047, 0x0a075113, 0x8c910221, 0x05c3476f, 0xdd822120,
0x18001927, 0x0c009402, 0x07ed4100, 0x200d7f4a, 0x20198c93, 0x288b821a, 0x00200020, 0x02110012, 0x20198c92, 0x09df4919, 0x8c740121, 0x00162119,
0x2108c741, 0x1986fa01, 0xf5429f85, 0x8246200b, 0x05294119, 0x210e9544, 0x338c2102, 0x230a134d, 0x0b00f901, 0x200a1f47, 0x26ef820e, 0x0022000f,
0x8285011a, 0x001c2217, 0x20a58224, 0x83f3821f, 0x821d20e9, 0x00212417, 0x430a0043, 0x057708f9, 0x3a032108, 0xbf411582, 0x821a2007, 0x82112033,
0x020e22e3, 0x241586ce, 0x001c0020, 0x2245821b, 0x8211000e, 0x8e4e20f3, 0x821d2015, 0x021b222b, 0x261582ca, 0x001f000e, 0x82260021, 0x821a2029,
0x00112631, 0x00b80212, 0x08534e09, 0x84001521, 0x7501211f, 0x55431382, 0x5202230e, 0x27820800, 0x39821b20, 0x43821120, 0x1d001c24, 0x1182fd01,
0x4f841c20, 0x37821f20, 0x21001624, 0x1182d002, 0x22001924, 0x25822000, 0x1b001c26, 0xf3011200, 0x5f441182, 0xb303210c, 0x0d201186, 0x1c208782,
0x19228382, 0x11843303, 0xd3821420, 0x89842320, 0x34032424, 0x51820700, 0x1a002622, 0x1b241382, 0x3a012100, 0x22240f82, 0x19000f00, 0x20241f82,
0xf2011500, 0x19201f84, 0x21201d82, 0x12224582, 0x0f823e03, 0x1d821c20, 0x1f243185, 0x0600d202, 0x2f858582, 0xcb021022, 0x12200d82, 0x1d206982,
0x12222182, 0x0d84cd02, 0x23064f44, 0x05004003, 0x1620c182, 0x2121ab82, 0x200b8300, 0x22bd840e, 0x82f80112, 0x82152017, 0x00212433, 0x82ae021c,
0x06a7410b, 0x82530221, 0x8219200b, 0x8210209b, 0x8695207b, 0x001b2423, 0x82c90212, 0x000e220b, 0x24158214, 0x00d10220, 0x24398204, 0x03190019,
0x200984c7, 0x2009821c, 0x200982ab, 0x20ab8212, 0x30a98220, 0x003c0010, 0x00840064, 0x00c000a4, 0x009700d8, 0x25738215, 0x00100016, 0x475c0018,
0x20118210, 0x20f38211, 0x82b9830e, 0x009822a7, 0x202b9c13, 0x2099821a, 0x222b8216, 0x820f0070, 0x84122027, 0x000d2103, 0x2005a564, 0x06a54726,
0x21002524, 0x1f864203, 0x91822020, 0x39421620, 0x001b2408, 0x82240020, 0x031f22c1, 0x202b8241, 0x20098322, 0x20358300, 0x2273840f, 0x84110019,
0x00482211, 0x505b8a0b, 0x002308df, 0x88050047, 0x2c5c0817, 0x88005a00, 0xe000b400, 0x34010a01, 0x7c015801, 0xbe019e01, 0xfc01de01, 0x38021a02,
0x70025402, 0xa4028a02, 0xd602be02, 0x0603ee02, 0x32031c03, 0x5a034603, 0x82036e03, 0xa6039403, 0xc603b603, 0xe603d603, 0x0204f403, 0x1e041004,
0x3a042c04, 0x54044804, 0x6a046004, 0x1600dd02, 0x1120e382, 0x1c200582, 0x9983a382, 0xc3822120, 0x1b001c22, 0x1b20b184, 0x200a815e, 0x22af8212,
0x601500c6, 0x59490973, 0xff01211d, 0x2006a343, 0x204f820e, 0x222b8212, 0x8203000c, 0x82112005, 0x0014223f, 0x2205821f, 0x84200012, 0x00102641,
0x00b60324, 0x20578c14, 0x203b8420, 0xf148181d, 0x82de2012, 0x820e2029, 0x00162189, 0xf74daf91, 0x224b8208, 0x82710011, 0x08ed5525, 0x13206982,
0x1c227582, 0x09821a00, 0x57411e20, 0xad032107, 0x10202384, 0x1f204b82, 0x0d210982, 0x08f95b00, 0x2408df51, 0x00dd021f, 0x18214110, 0x13001c29,
0x55021300, 0x83000f00, 0x822120cd, 0x82222027, 0x000e2165, 0x20058546, 0x2415821a, 0x0222001b, 0x971f82de, 0x001c24b3, 0x82ae031b, 0x691c2037,
0x112008b3, 0x91857b82, 0x3f821b20, 0xfe011f22, 0xc78b1d82, 0x15821f20, 0x12262383, 0x12002600, 0x1d844503, 0xc1841d20, 0x39822120, 0xe5841d20,
0x19000f22, 0x1a222582, 0x1182c500, 0x0b7a3b8b, 0x4a00210a, 0x10201b84, 0xad852782, 0xe7820e20, 0x47842120, 0xc8032024, 0x09820c00, 0x20052d41,
0x24218220, 0x0023001f, 0x221f8216, 0x82b70312, 0x20eb8519, 0x081b4f1c, 0x14000e26, 0x01021200, 0x4d181982, 0x122007ff, 0x28063747, 0x00150014,
0x00990021, 0x203d820b, 0x2025821b, 0x2047820d, 0x229b821c, 0x821a0022, 0x82542031, 0x820e2017, 0x202d851f, 0x24638412, 0x02240012, 0x8b178200,
0x00192a49, 0x00130012, 0x00600221, 0x1267410a, 0x15844c20, 0x2005af4c, 0x22778221, 0x821b001c, 0x00c82225, 0x20058209, 0x206b821d, 0x20138226,
0x2207820e, 0x88640019, 0x05174c13, 0x03000624, 0x138e6300, 0x03000424, 0x1382b402, 0x35822320, 0x1c001522, 0x18280182, 0x1d002200, 0x08006500,
0x3b854f86, 0xad000822, 0x20221182, 0x27822000, 0x19821320, 0x11001226, 0x07008f03, 0x41180982, 0x0321089d, 0x200f8446, 0x83e18220, 0x03122213,
0x200f8443, 0x20238210, 0x22518216, 0x84790221, 0x0013220f, 0x24d5841f, 0x00af0315, 0x206f8206, 0x062b4124, 0x0d824b20, 0x27821220, 0x0e001222,
0xc9204182, 0x49830d86, 0xc4002122, 0x2408e352, 0x01120023, 0x20378477, 0x24258222, 0x031f0012, 0x201b8444, 0x22938411, 0x844d001a, 0x07b1440d,
0x0500c722, 0x20081541, 0x220b8249, 0x8211000e, 0x031c246d, 0x84040047, 0x001a22eb, 0x820982c3, 0x080d82cb, 0xec0075fe, 0x7c014401, 0xe001ae01,
0x44021202, 0xa6027602, 0x0403d602, 0x60033203, 0xbc038e03, 0x1604ea03, 0x6e044204, 0xc6049a04, 0x1c05f204, 0x70054605, 0xc4059a05, 0x1406ec05,
0x64063c06, 0xb0068a06, 0xf806d406, 0x40071c07, 0x88076407, 0xd007ac07, 0x1408f207, 0x56083608, 0x96087608, 0xd608b608, 0x1209f408, 0x4e093009,
0x88096c09, 0xc009a409, 0xf809dc09, 0x300a140a, 0x680a4c0a, 0xa00a840a, 0xd60abc0a, 0x0a0bf00a, 0x3c0b240b, 0x680b520b, 0x940b7e0b, 0xc00baa0b,
0xec0bd60b, 0x180c020c, 0x440c2e0c, 0x6c0c580c, 0x940c800c, 0xbc0ca80c, 0xe20cd00c, 0x060df40c, 0x2a0d180d, 0x4a0d3a0d, 0x6a0d5a0d, 0x8a0d7a0d,
0xa60d980d, 0xc20db40d, 0xda0dce0d, 0xf20de60d, 0x060efc0d, 0x1a0e100e, 0x2e0e240e, 0x400e380e, 0x2b000001, 0x14001600, 0x0e001b00, 0x0d001900,
0x12001000, 0x19220782, 0x05822200, 0x1f000e22, 0x8213257f, 0x001b2213, 0x4605821c, 0x122005eb, 0x1b202582, 0x21203582, 0x07201182, 0x0f200382,
0x1f224982, 0x5182d902, 0x03821220, 0x16002123, 0x050d4400, 0x23201f83, 0x20080946, 0x22178211, 0x82200020, 0x2421832b, 0x00130020, 0x241b8216,
0x00fe0011, 0x10114e18, 0x26002022, 0x20062b53, 0x205f821a, 0x20338211, 0xc7401826, 0x031a2208, 0x83319253, 0x05014999, 0x1c20d183, 0x1d208182,
0x2020b182, 0x21246382, 0x52031200, 0xd78331a8, 0x21001b24, 0x3184da02, 0xcd960982, 0x0221c790, 0x2231827e, 0x710f0022, 0x1c220ce7, 0xc9821f00,
0xbf820d20, 0x09821f20, 0x24001c22, 0x240b2b44, 0x17007d02, 0x4431a300, 0x03210613, 0x212f824c, 0x3b4f0012, 0x820f200d, 0x8410205b, 0x841d2079,
0x0aaf445b, 0x00010123, 0x1ee94116, 0x2005d541, 0x22258220, 0x8251031a, 0x415d8f05, 0xe9450b55, 0x00122205, 0x2201821b, 0x829d000e, 0x8221202d,
0x4526207b, 0x16220687, 0xe5841a00, 0x19200f83, 0xfb5a0982, 0x8a9b200d, 0x8210202d, 0x001f22f3, 0x088b451f, 0x01212d90, 0x4fb78e05, 0x6d420901,
0x096d5508, 0x84d60221, 0x0fa941b7, 0x23166d42, 0x15005503, 0x8b106d42, 0x002022e5, 0x204f8223, 0x22238211, 0x924b031c, 0x000e222b, 0x2001821d,
0x10d15619, 0x2b829c20, 0x8f070f41, 0x1b4118e1, 0x82ff200f, 0x1d81432b, 0x9e20e789, 0x1d22578a, 0x77821f00, 0x8f096741, 0x82f92057, 0x8210202b,
0x82122023, 0x411b20bd, 0x09840921, 0x41000e21, 0x01230c91, 0x42140002, 0x2226201b, 0x19001900, 0x29825702, 0x20052b47, 0x21498212, 0x5f46001a,
0x420d2005, 0xfb2012e7, 0x7f952982, 0x0f2d5518, 0x2998fa20, 0x0321d38e, 0x20298267, 0x20738224, 0x517b821d, 0x5f510f2d, 0x0003220d, 0x20d19e13,
0x2221821c, 0x824f0313, 0x0fe74205, 0x128b4b18, 0x92540321, 0x0b294227, 0x11001528, 0x16001a00, 0x2784d802, 0x440f7f42, 0x0323101f, 0x4212004d,
0x0f201079, 0x210f8f54, 0x23826403, 0x1d002222, 0x24088748, 0x001c0020, 0x22fb821f, 0x8210000e, 0x001c2301, 0x69820022, 0x82040121, 0x0b41427b,
0x20132143, 0x202382ab, 0x203d8221, 0x723d821d, 0x20240dc5, 0x0e001500, 0x12225582, 0x23825003, 0x830f0b41, 0x8415200f, 0x821b207f, 0x02212205,
0x0aef4fd7, 0x8309d745, 0x0022221b, 0x24458221, 0x0319000e, 0x21479256, 0xaf41001c, 0x82202005, 0x000e24b7, 0x82b8031b, 0x0a695523, 0x1b209582,
0x21219d82, 0x051b4b00, 0x13001c22, 0x72200182, 0x19202382, 0x24201582, 0x1a201d82, 0x16201d84, 0x1b200582, 0x95430d82, 0x82682009, 0x0b1d4623,
0x1d002222, 0x0e201182, 0x12208b82, 0x8d822782, 0x03210023, 0x8f73824f, 0x001124d7, 0x82200016, 0x8219202b, 0x032622fb, 0x42218267, 0x4f420f57,
0x6803210c, 0x67992182, 0x23002126, 0x0f003c01, 0xe5767582, 0x22898214, 0x82fc0020, 0x0b0f431f, 0x210e0543, 0x1f825d03, 0x0fed5418, 0x9d820f20,
0x18002028, 0x21001200, 0x1f820601, 0x2615e541, 0x0013001c, 0x82590313, 0x20e58f1f, 0x4139821f, 0x12220539, 0x4b829602, 0x7b531620, 0x001f2208,
0x4e958211, 0x2122070d, 0x1d825400, 0x1f002222, 0x1c240182, 0x1b002200, 0x20211d84, 0x210b8600, 0x1d825803, 0x1d205b8f, 0x24201d82, 0x1f225f82,
0x1d945703, 0x1b24cb83, 0x5a031200, 0x6d4c1d92, 0x05022108, 0x24288582, 0x21001600, 0x15001000, 0x210d1754, 0x0f825f03, 0x21162342, 0x1b907d01,
0x416f1420, 0x825e2008, 0x821c201b, 0x8221200d, 0x000f2207, 0x83058226, 0x821d20e7, 0x030e225f, 0x064b42ca, 0x974b1820, 0x821f2008, 0x001c26c7,
0x0220001a, 0x411b829c, 0x032016e3, 0x9d415383, 0x8210200f, 0x821f20d9, 0x825020b9, 0x204f8337, 0x2193841d, 0xcf4b001f, 0x001c2605, 0x00200022,
0x2213826e, 0x820f0022, 0x0e5f7f09, 0x03200023, 0x411b824e, 0x10200f55, 0x21057f49, 0x8b849a02, 0x10001b22, 0x8d670782, 0x8300200e, 0x0d17411b,
0x24086f52, 0x0c000602, 0x0b4f4100, 0x21082943, 0x19829b02, 0x85002621, 0x0c2b4d51, 0x82e10221, 0x84212019, 0x0eb954cb, 0x82aa0021, 0x20b78319,
0x06434612, 0x82082b44, 0x820b2033, 0x05214af9, 0x240a2b77, 0x0a006003, 0x229b8300, 0x4f190019, 0x02210941, 0x22158298, 0x8220001a, 0x821320cb,
0x00162267, 0x224f8219, 0x82650311, 0x07754315, 0x21082958, 0x2b84c903, 0x18001c22, 0x0d242382, 0x1f001300, 0x12220782, 0x15847b01, 0x0d820e20,
0x5d532120, 0xcb002109, 0x12201582, 0x10204d84, 0x0d208d82, 0x77835b82, 0x1582fd20, 0x6b821120, 0x13822020, 0x31821c20, 0x14000e22, 0x9f204382,
0x10206d8a, 0x20222986, 0x15826202, 0x63852120, 0x23222d82, 0x29821600, 0x03022422, 0x0e201586, 0x2408b777, 0x021b0012, 0x831582bc, 0x182420a7,
0x220ad152, 0x86460121, 0x841f2015, 0x06037981, 0x00530027, 0x00220009, 0x2013820f, 0x83038216, 0x022022ef, 0x411382e0, 0x15200767, 0x13228184,
0x13820202, 0x65821920, 0x77821120, 0x84002021, 0x6603215d, 0x8d441382, 0x824f200f, 0x07634213, 0x2b821b20, 0x21002524, 0x13823b01, 0x47821d20,
0x0f821020, 0x6b820d20, 0x1f000e24, 0x13825602, 0x71820e20, 0x8305c54b, 0x0112247b, 0x82080079, 0x82102021, 0x821f208f, 0x00212469, 0x827a0126,
0x0c0b4411, 0x825c0321, 0x05df4211, 0x3d820d20, 0x1c002424, 0x11824803, 0x15001026, 0x11001200, 0x19243982, 0x4a031200, 0x714a4784, 0x6303230a,
0xe5840700, 0x5f841720, 0x4e002122, 0x15200f82, 0x13231182, 0x82001300, 0x95022131, 0x11240f82, 0x10000d00, 0x1f24a582, 0x7c011100, 0xb9420f82,
0x7801210a, 0x1b830f82, 0x1b001b28, 0x1f001200, 0x0f820701, 0x41002121, 0x022308b3, 0x820600d3, 0x8215203b, 0x001c2411, 0x82510019, 0x841b200d,
0x8227200b, 0x8249208d, 0x8412200d, 0x21a58257, 0x0d826302, 0x0f002224, 0x11822400, 0x61032624, 0xc5820500, 0x1f000e26, 0xd4022000, 0x15200b82,
0x12222784, 0x17840402, 0x4b822620, 0x62031222, 0x6b830b84, 0xcd001224, 0x75840400, 0xdf022122, 0x21200982, 0x03212d83, 0x4109825b, 0xcc200511,
0x12200982, 0x1122a182, 0x09829902, 0x09822620, 0xca001022, 0x0e220982, 0xb5822300, 0x31845220, 0x1d001c2c, 0x03009702, 0x20001a00, 0x0782cb03,
0x43821d20, 0x002d3b08, 0x0090005c, 0x00d000b2, 0x010c01ee, 0x01440128, 0x017c0160, 0x01b20198, 0x01e201ca, 0x021002fa, 0x023a0226, 0x0262024e,
0x028a0276, 0x02b2029e, 0x02d602c4, 0x03fa02e8, 0xcf64030c, 0x034c3a05, 0x036a035c, 0x03820376, 0x039a038e, 0x03ae03a4, 0x03c203b8, 0x02d203ca,
0x20c38266, 0x2463821f, 0x0020001b, 0x20858213, 0x0847451f, 0x16001524, 0x0d821b00, 0xe96b0e20, 0x7503250f, 0x1f001000, 0x1b212b82, 0x1b551800,
0x0db94709, 0x51826e20, 0x22001522, 0x0f20c582, 0x0d205782, 0x1d200982, 0x11284582, 0x24001c00, 0x7f011b00, 0x0e221d82, 0x79820f00, 0x21001222,
0x2008e37a, 0x241d821f, 0x03110016, 0x201d866a, 0x8335820d, 0x09974395, 0x1d821220, 0x2f827220, 0x21821f20, 0x18001022, 0x22083d43, 0x8214001b,
0x0220228d, 0x2011829e, 0x64738216, 0x19200953, 0x0e261782, 0x12002300, 0x1b827803, 0x0e955c18, 0x1b201182, 0x21227382, 0x53847403, 0xed821220,
0xab86cf89, 0x0d20eb82, 0x1320eb90, 0x0e26b982, 0x9d022100, 0x89820c00, 0xc1881d20, 0x07480d20, 0x00762208, 0x2035900b, 0x201d8222, 0x221782ce,
0x84250012, 0x821320f5, 0x821f207b, 0x214982ad, 0x178c4701, 0xb5821620, 0x11001929, 0x6c032000, 0x41000a00, 0x0d200747, 0x1c261182, 0x1b002400,
0x15828001, 0x200b3f41, 0x2485821a, 0x00a10310, 0x22518209, 0x82100022, 0x840d2031, 0x021d2297, 0x4113820d, 0x1f220511, 0x1d820d00, 0x13001324,
0x13880902, 0x25841920, 0x12002024, 0x13820702, 0x14000e22, 0x13202382, 0x10261382, 0x20001200, 0x13820f02, 0x20091942, 0x22cf821c, 0x8277031a,
0x0e454113, 0x8a730321, 0x26518327, 0x03120021, 0x8a08006d, 0x002224b7, 0x820e021d, 0x001c2611, 0x000e001b, 0x053b4419, 0x846b0321, 0x82122023,
0x82318211, 0x0220225d, 0x8911820a, 0x000424ad, 0x88b00303, 0x20358311, 0x22a9821b, 0x44070008, 0x002005b5, 0x12228783, 0x0f88a000, 0x1a002022,
0x5920b582, 0xb5830f82, 0x6782e982, 0x0b021022, 0x53890f82, 0x58020622, 0x1f202f84, 0x0e206f82, 0x1b241f82, 0x06007e01, 0x0f208182, 0x12269582,
0x49012100, 0x9d840500, 0x69821920, 0x0b840c20, 0x6d821a20, 0x64021f22, 0x55830b82, 0x1b001624, 0x0b827003, 0x11001c22, 0x26283582, 0x04008101,
0x26001c00, 0x65207782, 0x21830982, 0x10021a22, 0x22200982, 0x1222e982, 0x75577103, 0x006f2208, 0x22278203, 0x82690310, 0x000e2807, 0x0082010f,
0x84230002, 0x00262c79, 0x0052003e, 0x026a0060, 0x820b007b, 0x82132035, 0x82192027, 0x820d205d, 0x821c20cd, 0x021222a5, 0x82178e7a, 0x2000219b,
0xd2220182, 0x2f820900, 0x23820e20, 0x2405cb6f, 0x03120023, 0x4a5382b1, 0xcf2009b7, 0x1b207f82, 0x1c224b82, 0x77820801, 0x0f002038, 0x4c002500,
0xa4007800, 0xec00ca00, 0x2e010e01, 0x68014c01, 0x15698401, 0x02083408, 0x02380220, 0x02680250, 0x02980280, 0x02c402ae, 0x57f002da, 0x962c0e0d,
0xba03a803, 0xde03cc03, 0x15003e01, 0x0e1d5818, 0xdd410d20, 0x82142006, 0x0c7f7e97, 0x9e3d0121, 0x000f242b, 0x8221001c, 0x001c2401, 0x823f011a,
0x82122055, 0x002122d5, 0x083f7116, 0x85053542, 0x82212057, 0x001d222b, 0x201b8255, 0x20db8216, 0x830d8212, 0x2f4f186b, 0x11022110, 0x12232184,
0x85002400, 0x001a211f, 0x20057143, 0x27461821, 0x00872408, 0x8616000f, 0x82142043, 0x001a2215, 0x222b8212, 0x8220000e, 0x00122401, 0x82860321,
0x82162013, 0x8416200b, 0x06b74227, 0x2008d975, 0x2009827f, 0x20318216, 0x20078224, 0x20078215, 0x8349820e, 0x821b2023, 0x8455200b, 0x8211201b,
0x691c2009, 0x03210f01, 0x20378a7c, 0x20618210, 0x085d671f, 0x79031922, 0x12201b82, 0x1620fb82, 0x2208c752, 0x8422000d, 0x021f248d, 0x820c0012,
0x20cf8bad, 0x243d821d, 0x00210010, 0x85198457, 0x2051836d, 0x22a3881a, 0x880b0083, 0x82202033, 0x841f2029, 0x031a22a7, 0x20178a7d, 0x207f8210,
0x24658219, 0x001b001a, 0x8917847b, 0x820e20b7, 0x001224f9, 0x8a810319, 0x821a202f, 0x07c9472f, 0x178a7a20, 0x22051d49, 0x8211001b, 0x82582095,
0x001c2117, 0x12205585, 0x11208d82, 0x2105f945, 0x178e5900, 0x77821a20, 0x12002126, 0x0a008503, 0x2020a782, 0x0f200382, 0x69410382, 0x7b032106,
0xf1851584, 0x43000e21, 0x262205b3, 0x15847a00, 0x1020a387, 0x19246d82, 0xa0021900, 0x1c201582, 0x10203b82, 0x220ac561, 0x8a110221, 0x82102041,
0x001a2683, 0x03260013, 0x20158a82, 0x2081821e, 0x22a98216, 0x825a0021, 0x20b38b15, 0x242b821c, 0x009f0213, 0x20958409, 0x09d96a1f, 0x84840321,
0x20978513, 0x246f8224, 0x03180012, 0x83138a80, 0x002023bf, 0x91450021, 0x00162105, 0x1a209383, 0x67833f82, 0x27825b20, 0x19411c20, 0x00222c0a,
0x001b021d, 0x00160008, 0x5c1b0014, 0x7e20083d, 0x61851184, 0x39821120, 0x56002622, 0xe3411184, 0xa102210a, 0x1d201182, 0x0d203382, 0x1c204d82,
0x18256382, 0x0700a200, 0x20118500, 0x08498218, 0x17002633, 0x54003000, 0x94007400, 0xce00b200, 0x0201ea00, 0x2a011601, 0x52013e01, 0x78016601,
0x9a018a01, 0xba01aa01, 0xd601ca01, 0xea01e001, 0x8803f201, 0x206b8300, 0x08974719, 0x45821a20, 0x0f001a22, 0x1f240582, 0x15002000, 0x1d22a382,
0x0f821502, 0x0d000f22, 0x1b200b82, 0x0e207382, 0x11227f82, 0x1d821200, 0x1b24e383, 0x87032100, 0x0e201f82, 0x08c34518, 0xd5820d20, 0x13001624,
0xb9492100, 0x820a2008, 0x05dd42cd, 0x15820d20, 0x26091550, 0x001b0016, 0x821c0214, 0x225d8559, 0x8216001f, 0x20598b8d, 0x8b1b8289, 0x49531859,
0xb203230a, 0x57820b00, 0x15206583, 0x19202582, 0x24085346, 0x00090073, 0x20918212, 0x2011820d, 0x83a58220, 0x82f7206f, 0x20478513, 0x08ad681d,
0x13824020, 0x0d841f20, 0x25239585, 0x47012100, 0x13200527, 0x61418782, 0x14022108, 0x0f202782, 0x10206182, 0x1c22e182, 0xa1822200, 0xd5022626,
0x15000800, 0x20207184, 0x1c240782, 0x16022100, 0x25831182, 0x21822020, 0xd7821b20, 0xf8002624, 0xcf840700, 0x8d821420, 0x20002124, 0x0f821302,
0x0e202183, 0x21242182, 0xd4001c00, 0x12200f82, 0x18201b82, 0x20065549, 0x240f822a, 0x001f000e, 0x2635821b, 0x0114001b, 0x84050083, 0x00102661,
0x008a0315, 0x24318204, 0x0218001f, 0x220982b0, 0x82130016, 0x005c2223, 0x2e398203, 0x00af020f, 0x00100002, 0x03040001, 0x8214008b, 0x00222225,
0x20618221, 0x751b820f, 0x12220df9, 0xc5821100, 0x22050f45, 0x82080003, 0x02342223, 0x0ab15a5f, 0x97841c20, 0x1a000d22, 0x1d227582, 0x21829103,
0x4d821c20, 0x24055744, 0x03210022, 0x879f8290, 0x82162011, 0x820220a5, 0x00062689, 0x00000006, 0x2c8d820e, 0x00180001, 0x000a0024, 0x00270026,
0xf8fa0517, 0x00f5c3fb,
};
/*
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
|
the_stack_data/37637480.c
|
#include <stdio.h>
#include <stdlib.h>
int colsize = -1; //80;
int indent = 2;
int lfcount = 0;
/*
TXT2HTML
FIRST Unwraps wrapped lines.
Remove all linefeeds except where selected occurences of following occurs
- First word on next line would have fitted on current line
- Spaces in beginning of next line
- More than one linefeed in a row
THEN HTML:izes
*/
int main(int argc, char **argv)
{
char *src, *dst, *inbuf, *outbuf, *linep, *lined;
int l,i;
char *srcfile = NULL;
char *dstfile = NULL;
int spaces = 0;
int lf = 0;
FILE *fp;
for(i=1; i<argc; i++)
{
if(argv[i][0] == '-')
{
switch(argv[i][1])
{
case 'l':
lfcount = atoi(&argv[i][2]);
break;
case 'i':
indent = atoi(&argv[i][2]);;
break;
case 'c':
colsize = atoi(&argv[i][2]);
printf("Column size set to %d\n", colsize);
break;
}
}
else
{
if(!srcfile)
srcfile = argv[i];
else
if(!dstfile)
dstfile = argv[i];
}
}
fp = fopen(srcfile, "rb");
fseek(fp, 0, SEEK_END);
l = ftell(fp);
fseek(fp, 0, SEEK_SET);
src = inbuf = malloc(l*4+1);
dst = outbuf = malloc(l*4);
fread(inbuf, l, 1, fp);
fclose(fp);
inbuf[l] = 0;
src = inbuf;
// PASS 1 - Whitespace strip
while(*src)
{
char c = *src++;
switch(c)
{
case ' ':
spaces++;
break;
case 10:
lf++;
spaces = 0;
break;
case 13:
break;
default:
if(lf)
{
if((indent > 0) && (spaces >= indent))
{
*dst++ = 9;
printf("%d ", spaces);
}
else
if(lfcount && lf >= lfcount)
*dst++ = 13;
*dst++ = 10;
lf = spaces = 0;
}
if(c >= 0x20)
{
if(spaces) { *dst++ = ' '; spaces = 0; }
*dst++ = c;
}
}
}
*dst = 0;
src = outbuf;
dst = inbuf;
printf("Unwrapping\n");
// PASS 2 - Unwrap
while(*src)
{
char *s;
char c = *src++;
//printf("%c ", c);
switch(c)
{
case 10:
s = src;
while(*s && *s != ' ') s++;
if( (colsize > 0) && ((src-linep) + (s-src) < colsize))
*dst++ = 10;
else
*dst++ = ' ';
linep = src;
lined = dst;
break;
case 9:
*dst++ = 10;
src++;
break;
case 13:
*dst++ = 10;
src++;
break;
default:
*dst++ = c;
break;
}
}
*dst = 0;
src = inbuf;
dst = outbuf;
strcpy(dst, "<html>\n<p>");
dst += strlen(dst);
printf("HTML:izing\n");
while(*src)
{
char c = *src++;
if(c == 10)
{
strcpy(dst, "</p>\n<p>");
dst += strlen(dst);
}
else
*dst++ = c;
}
strcpy(dst, "</p>\n</html>\n");
dst += strlen(dst);
*dst = 0;
fp = fopen(dstfile, "wb");
fwrite(outbuf, dst-outbuf, 1, fp);
fclose(fp);
return 0;
}
|
the_stack_data/37636708.c
|
#include<stdio.h>
int main()
{
int b,h;
float area;
printf("\nEnter the values of base and height : ");
scanf("%d%d",&b,&h);
area=(1/2.0)*h*b;
printf("\nArea is %f\n",area);
return 0;
}
|
the_stack_data/92328182.c
|
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
typedef struct Stack
{
int top;
unsigned capacity;
int* array;
}Stack;
Stack* createStack(unsigned capacity)
{
struct Stack* stack = (Stack*) malloc(sizeof(Stack));
stack->capacity = capacity;
stack->top = -1;
stack->array = (int*) malloc(stack->capacity * sizeof(int));
return stack;
}
int Full(Stack* stack)
{ return stack->top == stack->capacity - 1; }
int Empty(Stack* stack)
{ return stack->top == -1; }
void push(Stack* stack, int item)
{
if (Full(stack))
return;
stack->array[++stack->top] = item;
printf("%d pushed to stack\n", item);
}
int pop(Stack* stack)
{
if (Empty(stack))
return INT_MIN;
return stack->array[stack->top--];
}
int peek(Stack* stack)
{
if (Empty(stack))
return INT_MIN;
return stack->array[stack->top];
}
int main()
{
Stack* stack = createStack(100);
push(stack, 14);
push(stack, 25);
push(stack, 38);
push(stack, 48);
printf("%d popped from stack\n", pop(stack));
printf("Top item is %d\n", peek(stack));
return 0;
}
//output
/*14 pushed to stack
25 pushed to stack
38 pushed to stack
48 pushed to stack
48 popped from stack
Top item is 38*/
|
the_stack_data/179829810.c
|
/*Faça um programa para ler 10 valores inteiros. Para cada valor fornecido escrever uma mensagem que indica se cada valor fornecido é PAR ou ÍMPAR*/
#include <stdio.h>
int main(){
int numero;
int cont, cPar,cImpar,aPar,aImpar;
cPar=0;
cImpar=0;
cont=0;
aPar=0;
aImpar=0;
do
{
printf( "%d - Digite o número \n",cont+1);
scanf("%d%*c",&numero);
if(numero==0){
printf( "Número nulo\n");
}else if(numero%2==0){
cPar++;
aPar=aPar+numero;
printf( "Número par\n");
}else{
cImpar++;
aImpar+=numero;
printf( "Número impar\n");
}
cont++;
} while (cont<10);
printf("Foram digitados %d pares\n", cPar);
printf("Foram digitados %d ímpares\n", cImpar);
printf("O acumulado de pares é %d \n", aPar);
printf("O acumulado de ímpares é %d \n", aImpar);
}
|
the_stack_data/464731.c
|
#include <string.h>
#include <stdio.h>
char *_strrchr(const char *s, int c)
{
const char *last = NULL;
/* If the character we're looking for is the terminating null,
we just need to look for that character as there's only one
of them in the string. */
if (c == '\0')
return strchr(s, c);
while ((s = strchr(s, c)) != NULL) {
last = s;
s++;
}
return (char *)last;
}
int main()
{
char *s = "apple";
char c = 'l';
char *p = _strrchr(s, c);
printf("%c\n", *p);
return 0;
}
|
the_stack_data/1173577.c
|
//*****************************************************************************
//
// startup_gcc.c - Startup code for use with GNU tools.
//
// Copyright (c) 2009-2013 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 10636 of the EK-LM3S9D90 Firmware Package.
//
//*****************************************************************************
//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
//*****************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//*****************************************************************************
extern void Timer0IntHandler(void);
extern void Timer1IntHandler(void);
//*****************************************************************************
//
// The entry point for the application.
//
//*****************************************************************************
extern int main(void);
//*****************************************************************************
//
// Reserve space for the system stack.
//
//*****************************************************************************
static unsigned long pulStack[64];
//*****************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000.
//
//*****************************************************************************
__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) =
{
(void (*)(void))((unsigned long)pulStack + sizeof(pulStack)),
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // The MPU fault handler
IntDefaultHandler, // The bus fault handler
IntDefaultHandler, // The usage fault handler
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // SVCall handler
IntDefaultHandler, // Debug monitor handler
0, // Reserved
IntDefaultHandler, // The PendSV handler
IntDefaultHandler, // The SysTick handler
IntDefaultHandler, // GPIO Port A
IntDefaultHandler, // GPIO Port B
IntDefaultHandler, // GPIO Port C
IntDefaultHandler, // GPIO Port D
IntDefaultHandler, // GPIO Port E
IntDefaultHandler, // UART0 Rx and Tx
IntDefaultHandler, // UART1 Rx and Tx
IntDefaultHandler, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0
IntDefaultHandler, // PWM Generator 1
IntDefaultHandler, // PWM Generator 2
IntDefaultHandler, // Quadrature Encoder 0
IntDefaultHandler, // ADC Sequence 0
IntDefaultHandler, // ADC Sequence 1
IntDefaultHandler, // ADC Sequence 2
IntDefaultHandler, // ADC Sequence 3
IntDefaultHandler, // Watchdog timer
Timer0IntHandler, // Timer 0 subtimer A
IntDefaultHandler, // Timer 0 subtimer B
Timer1IntHandler, // Timer 1 subtimer A
IntDefaultHandler, // Timer 1 subtimer B
IntDefaultHandler, // Timer 2 subtimer A
IntDefaultHandler, // Timer 2 subtimer B
IntDefaultHandler, // Analog Comparator 0
IntDefaultHandler, // Analog Comparator 1
IntDefaultHandler, // Analog Comparator 2
IntDefaultHandler, // System Control (PLL, OSC, BO)
IntDefaultHandler, // FLASH Control
IntDefaultHandler, // GPIO Port F
IntDefaultHandler, // GPIO Port G
IntDefaultHandler, // GPIO Port H
IntDefaultHandler, // UART2 Rx and Tx
IntDefaultHandler, // SSI1 Rx and Tx
IntDefaultHandler, // Timer 3 subtimer A
IntDefaultHandler, // Timer 3 subtimer B
IntDefaultHandler, // I2C1 Master and Slave
IntDefaultHandler, // Quadrature Encoder 1
IntDefaultHandler, // CAN0
IntDefaultHandler, // CAN1
IntDefaultHandler, // CAN2
IntDefaultHandler, // Ethernet
IntDefaultHandler, // Hibernate
IntDefaultHandler, // USB0
IntDefaultHandler, // PWM Generator 3
IntDefaultHandler, // uDMA Software Transfer
IntDefaultHandler, // uDMA Error
IntDefaultHandler, // ADC1 Sequence 0
IntDefaultHandler, // ADC1 Sequence 1
IntDefaultHandler, // ADC1 Sequence 2
IntDefaultHandler, // ADC1 Sequence 3
IntDefaultHandler, // I2S0
IntDefaultHandler, // External Bus Interface 0
IntDefaultHandler // GPIO Port J
};
//*****************************************************************************
//
// The following are constructs created by the linker, indicating where the
// the "data" and "bss" segments reside in memory. The initializers for the
// for the "data" segment resides immediately following the "text" segment.
//
//*****************************************************************************
extern unsigned long _etext;
extern unsigned long _data;
extern unsigned long _edata;
extern unsigned long _bss;
extern unsigned long _ebss;
//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
unsigned long *pulSrc, *pulDest;
//
// Copy the data segment initializers from flash to SRAM.
//
pulSrc = &_etext;
for(pulDest = &_data; pulDest < &_edata; )
{
*pulDest++ = *pulSrc++;
}
//
// Zero fill the bss segment.
//
__asm(" ldr r0, =_bss\n"
" ldr r1, =_ebss\n"
" mov r2, #0\n"
" .thumb_func\n"
"zero_loop:\n"
" cmp r0, r1\n"
" it lt\n"
" strlt r2, [r0], #4\n"
" blt zero_loop");
//
// Call the application's entry point.
//
main();
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
|
the_stack_data/198581016.c
|
int add2_c(int a, int b) {
int sum = a + b;
return sum;
}
|
the_stack_data/15762971.c
|
//To know last date of modification of any file.
#include<stdio.h>
#include<time.h>
#include<sys/stat.h>
int main()
{
struct stat status;
FILE *fp;
fp=fopen("ascii.c","r");
fstat(fileno(fp),&status);
printf("Last date of modification:%s",ctime(&status.st_ctime));
return 0;
}
|
the_stack_data/218892985.c
|
/* Copyright (C) 1994, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <time.h>
int
dysize (year)
int year;
{
return __isleap (year) ? 366 : 365;
}
|
the_stack_data/820070.c
|
// Test a procedure with calling convention stack
// Test that comments are handled correctly
#pragma calling(__stackcall)
char* const SCREEN = (char*)0x0400;
char idx = 0;
void main(void) {
// Print "hello"
print("hello", 1);
// Print "world"
print("world", 2);
}
void print(char* str, char spacing) {
while(*str) {
SCREEN[idx++] = *(str++);
for(char c=0;c<spacing;c++)
SCREEN[idx++] = ' ';
}
}
|
the_stack_data/26699589.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_params.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: thbernar <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/08/09 14:44:25 by thbernar #+# #+# */
/* Updated: 2017/08/10 12:28:37 by thbernar ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar (char c);
void ft_putstr(char str[])
{
int i;
i = 0;
while (str[i] != '\0')
{
ft_putchar(str[i]);
i++;
}
}
int main(int argc, char **argv)
{
int i;
argc = 0;
i = 1;
while (argv[i])
{
ft_putstr(argv[i]);
ft_putchar('\n');
i++;
}
return (0);
}
|
the_stack_data/134324.c
|
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)setjmperr.c 5.2 (Berkeley) 3/9/86";
#endif LIBC_SCCS and not lint
#include <setjmp.h> /* include any machine defines */
#define ERRMSG "longjmp botch\n"
/*
* This routine is called from longjmp() when an error occurs.
* Programs that wish to exit gracefully from this error may
* write their own versions.
* If this routine returns, the program is aborted.
*/
longjmperror()
{
write(2, ERRMSG, sizeof(ERRMSG));
}
|
the_stack_data/113462.c
|
#include <errno.h>
int
_kill(int pid, int sig)
{
errno = ENOSYS;
return -1;
}
|
the_stack_data/72819.c
|
/*
* Automatically Tuned Linear Algebra Software v3.10.3
* (C) Copyright 2000 R. Clint Whaley
*
* 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.
* 3. The name of the ATLAS group or the names of its contributers may
* not be used to endorse or promote products derived from this
* software without specific written permission.
*
* 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 ATLAS GROUP OR ITS 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.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
int LineIsCont(char *ln)
{
int i, iret=0;
for(i=0; ln[i]; i++);
if (i)
{
for(i--; isspace(ln[i]); i--);
if (ln[i] == '\\') iret = 1;
}
return(iret);
}
int NumUserCases0(char *nam)
{
int iret=0;
char ln[512];
FILE *fp;
fp = fopen(nam, "r");
if (fp)
{
fgets(ln, 512, fp); /* skip comment line */
assert(fscanf(fp, " %d", &iret) == 1);
fclose(fp);
}
return(iret);
}
int NumUserCases(char pre)
{
char ln[64];
sprintf(ln, "%ccases.dsc", pre);
return(NumUserCases0(ln));
}
void NoEndLineWhiteSpace(char *ln)
{
int i;
for (i=0; ln[i]; i++);
if (i)
for (i--; isspace(ln[i]); i--) ln[i] = '\0';
}
int GetUserCase(char pre, int icase, int *iflag, int *mb, int *nb, int *kb,
int *ma, int *lat, int *mu, int *nu, int *ku,
char *fnam, char *auth, char **MCC, char **MMFLAGS)
/*
* if icase < 0, go to that line in file; if icase > 0 find that ID in file
* return ID of selected line
*/
{
int i, n, ID;
char ln[512];
static char sMCC[1024], sMMFLAGS[2048];
FILE *fp;
*MCC = *MMFLAGS = NULL;
n = NumUserCases(pre);
sprintf(ln, "%ccases.dsc", pre);
fp = fopen(ln, "r");
if (!fp) return(0);
assert(fp);
fgets(ln, 256, fp); /* skip comment line */
fgets(ln, 256, fp); /* skip number of cases */
for (i=0; i < n; i++)
{
if ( fgets(ln, 256, fp) == NULL )
{
fclose(fp);
return(0);
}
assert(sscanf(ln, " %d %d %d %d %d %d %d %d %d %d %s \"%[^\"]", &ID,
iflag, mb, nb, kb, ma, lat, mu, nu, ku, fnam, auth) == 12);
assert(ID > 0);
if (i == -icase || ID == icase)
{
if (LineIsCont(ln))
{
assert( fgets(ln, 256, fp) != NULL );
strcpy(sMCC, ln);
NoEndLineWhiteSpace(sMCC);
assert( fgets(ln, 512, fp) != NULL );
strcpy(sMMFLAGS, ln);
NoEndLineWhiteSpace(sMMFLAGS);
*MCC = sMCC;
*MMFLAGS = sMMFLAGS;
}
else *MCC = *MMFLAGS = NULL;
fclose(fp);
return(ID);
}
if (i != icase && LineIsCont(ln))
{
assert( fgets(ln, 256, fp) != NULL );
assert( fgets(ln, 256, fp) != NULL );
}
}
fclose(fp);
return(0);
}
void CombineFiles(char *fout, int nfiles, char **fnams)
{
char tnam[256], ln[512];
int i, j, n, nn;
FILE *fpout, *fpin;
assert(tmpnam(tnam));
for (n=i=0; i < nfiles; i++) n += NumUserCases0(fnams[i]);
fpout = fopen(tnam, "w");
assert(fpout);
fprintf(fpout, "<ID> <flag> <mb> <nb> <kb> <muladd> <lat> <mu> <nu> <ku> <rout> \"<Contributer>\"\n");
fprintf(fpout, "%d\n", n);
for (i=0; i < nfiles; i++)
{
fpin = fopen(fnams[i], "r");
if (fpin)
{
assert(fgets(ln, 512, fpin));
assert(fgets(ln, 512, fpin));
assert(sscanf(ln, " %d", &nn) == 1);
for (j=0; j < nn; j++)
{
assert(fgets(ln, 512, fpin));
fputs(ln, fpout);
if (LineIsCont(ln))
{
assert(fgets(ln, 512, fpin));
fputs(ln, fpout);
assert(fgets(ln, 512, fpin));
fputs(ln, fpout);
}
}
fclose(fpin);
}
else
{
fprintf(stderr,
"COMBFILES WARNING: file %s not found / not readable!!\n",
fnams[i]);
}
}
fclose(fpout);
remove(fout);
sprintf(ln, "cp %s %s\n", tnam, fout);
assert(system(ln) == 0);
remove(tnam);
}
void PrintUsage(char *nam)
{
fprintf(stderr, "USAGE: %s -o <outfile> -i <Nin> <infile1> ... <infileN>\n",
nam);
exit(-1);
}
void GetFlags(int nargs, char **args, char **fout, int *nfiles, char ***fnams0)
{
int i, j, n;
char **fnams;
*nfiles = -1;
*fout = NULL;
*fnams0 = NULL;
for (i=1; i < nargs; i++)
{
if (args[i][0] != '-') PrintUsage(args[0]);
switch(args[i][1])
{
case 'o': /* outfile */
*fout = args[++i];
break;
case 'i': /* infiles */
n = atoi(args[++i]);
assert(n > 0);
assert(nargs-i >= n);
fnams = malloc(n * sizeof(char *));
assert(fnams);
for(j=0; j < n; j++) fnams[j] = args[++i];
*nfiles = n;
*fnams0 = fnams;
break;
default:
PrintUsage(args[0]);
}
}
assert(*fout);
assert(*fnams0);
}
int main(int nargs, char **args)
{
char *fnamout, **fnams;
int nfiles;
GetFlags(nargs, args, &fnamout, &nfiles, &fnams);
CombineFiles(fnamout, nfiles, fnams);
free(fnams);
return(0);
}
|
the_stack_data/14200866.c
|
// Satvik Choudhary
// 111601021
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Node is the element of the stack
struct Node{
struct Node* next; // Pointer to the next element in stack
char name[30]; // data in the node
};
struct Stack{
struct Node* top; // The top element of the stack
int size; // Size of the stack
};
typedef struct Stack* stack; // typedef for shortening the name to a more convenient one.
stack createStack(); // manually allocates a new stack struct
void stackPush(stack* stk, char* x); // Push a new element on top of the stack
char* stackPop(stack* stk); // Popping an element from top of the stack
int stackIsEmpty(stack stk); // Checking if stack is empty
int stackSize(stack stk); // Returns stack size
void print(stack* stk); // Prints the elements in the stack using stackPop.
int main(){
stack stk = createStack(); // new element is created.
while(1){
printf("Press 0 for exiting.\nPress 1 for pushing.\nPress 2 for popping.\n\
Press 3 for printing size.\nPress 4 to check if stack is empty.\n");
int n;
scanf("%d", &n);
if(n == 0) break;
if(n == 1){
char a[30];
printf("Enter the string: ");
getchar();
scanf("%[^\n]", a);
stackPush(&stk, a);
}
else if(n == 2){
if(stk->size == 0) printf("Cannot pop stack.\n");
else {
stackPop(&stk);
}
}
else if(n == 3) printf("The size of string is %d.\n", stackSize(stk));
else if(n == 4){
if(stackIsEmpty(stk)) printf("The stack is empty.\n");
else printf("The stack is NOT empty.\n");
}
else printf("INVALID Input.\n");
}
print(&stk);
return 0;
}
void print(stack* stk){
while(!stackIsEmpty(*stk)){
printf("%s\n", stackPop(stk));
}
return;
}
stack createStack(){
stack new1 = (stack) malloc (sizeof(stack));
new1->top = NULL;
new1->size = 0;
return new1;
}
void stackPush(stack* stk, char* x){
struct Node* new1 = (struct Node*) malloc (sizeof(struct Node*));
strcpy(new1->name, x);
new1->next = (*stk)->top;
(*stk)->top = new1;
(*stk)->size += 1;
return;
}
char* stackPop(stack* stk){
static char b[30]; // Because returning outside of the function
strcpy(b, "NULL");
if((*stk)->size == 0){
printf("The stack is empty. Cannot pop!\n");
}
else {
struct Node* temp = (*stk)->top;
strcpy(b, temp->name);
(*stk)->top = (*stk)->top->next;
(*stk)->size -= 1;
free(temp);
}
return b;
}
int stackIsEmpty(stack stk){
if(stk->size == 0) return 1;
else return 0;
}
int stackSize(stack stk){
return stk->size;
}
|
the_stack_data/20449430.c
|
//Chris Wells 2015
//956335
//October 28, 2014
//switch1.c
//Purpose: To introduce the switch selection structure.
#include <stdio.h>
//Begin main function
void main()
{
int i, a, j = 0;
for( a = 1; a <= 6; a += 1 )
{
printf("Please enter an integer: ");
scanf("%d", &i);
//Switch structure compares the input i to the four stated cases, otherwise using the default
switch(i)
{
case 7: printf("You entered an 8!\tJust kidding...\tOr am I???\n");
break;
case 44: printf("Best number ever!\n");
j += 1;
break;
case -4: printf("This is a negative four.\n");
break;
case 3: printf("The number of counting shall be three, and three shall be the number to which thou shalt count.\n");
break;
default: printf("Happy Tuesday!!\n");
break;
}
}
printf("You entered 44 %d times.", j);
}
|
the_stack_data/984514.c
|
int k;
|
the_stack_data/396963.c
|
#include <stdlib.h>
int main(void)
{
char *ptr = calloc(0, sizeof(char));
if (ptr == NULL)
return EXIT_SUCCESS;
*ptr = 'A'; /* error */
free(ptr);
}
/**
* @file 0017-test.c
*
* @brief Usage of calloc'd memory with 0 size.
*/
|
the_stack_data/179373.c
|
// [ACM] #492 - Pig-Latin
// Problem Status CPU Date&Time(UTC) ID Best CPU
// 492 Accepted 0.406 2006-11-05 09:46:32 5108468 0.000
#include<stdio.h>
int main(void)
{
char x, y, t = 1, k = 0, n = 0, c = 0;
while(1)
{
x = getchar();
if(x == EOF)
break;
else
{
if(x == ' ')
{
if(c == 0)
printf(" ");
else if(k == 1)
printf("%cay " , y);
else if(n == 1)
printf("ay ");
k = 0;
n = 0;
t = 1;
c = 0;
}
else if(('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
{
c = 1;
if(t == 1)
{
if(x == 'a' || x == 'e' || x == 'i' \
|| x == 'o' || x == 'u')
{
printf("%c" , x);
n = 1;
}
else if(x == 'A' || x == 'E' || x == 'I' \
|| x == 'O' || x == 'U')
{
printf("%c" , x);
n = 1;
}
else
{
y = x;
k = 1;
}
t = 0;
}
else
{
n = 1;
printf("%c" , x);
}
}
else
{
if(c == 0)
printf("%c" , x);
else if(k == 1)
printf("%cay%c" , y, x);
else
printf("ay%c" , x);
k = 0;
t = 1;
n = 0;
c = 0;
}
}
}
return 0;
}
|
the_stack_data/247016979.c
|
#include<stdio.h>
#include<math.h>
int main()
{
int i,j,k,root,n,count=0;
while(scanf("%d",&k)==1){
for(i=1;i<=k;i++){
scanf("%d",&n);
if(n==1 || n==0)
printf("%d nao eh primo\n",n);
else {
count=0;
root=sqrt(n);
for(j=2;j<=root;j++){
if(n%j==0){
count=1;
break;
}
}
if(count==1)
printf("%d nao eh primo\n",n);
else
printf("%d eh primo\n",n);
count=0;
}
}
}
}
|
the_stack_data/56184.c
|
// Adapted from interp.cpp from Caffe util by Pauline Luc
// Originally developed by George Papandreou
#ifndef TH_GENERIC_FILE
#define TH_GENERIC_FILE "generic/VolumetricUpSamplingTrilinear.c"
#else
static inline void THNN_(VolumetricUpSamplingTrilinear_shapeCheck)
(THTensor *input, THTensor *gradOutput,
int nBatch, int nChannels,
int inputDepth, int inputHeight, int inputWidth,
int outputDepth, int outputHeight, int outputWidth) {
THArgCheck(inputDepth > 0 && inputHeight > 0 && inputWidth > 0
&& outputDepth > 0 && outputHeight > 0 && outputWidth > 0, 2,
"input and output sizes should be greater than 0,"
" but got input (D: %d, H: %d, W: %d) output (D: %d, H: %d, W: %d)",
inputDepth, inputHeight, inputWidth, outputDepth, outputHeight, outputWidth);
if (input != NULL) {
THNN_ARGCHECK(input->nDimension == 5, 2, input,
"5D input tensor expected but got: %s");
}
if (gradOutput != NULL) {
THNN_CHECK_DIM_SIZE(gradOutput, 5, 0, nBatch);
THNN_CHECK_DIM_SIZE(gradOutput, 5, 1, nChannels);
THNN_CHECK_DIM_SIZE(gradOutput, 5, 2, outputDepth);
THNN_CHECK_DIM_SIZE(gradOutput, 5, 3, outputHeight);
THNN_CHECK_DIM_SIZE(gradOutput, 5, 4, outputWidth);
}
}
void THNN_(VolumetricUpSamplingTrilinear_updateOutput)(
THNNState *state,
THTensor *input,
THTensor *output,
int outputDepth,
int outputHeight,
int outputWidth){
int nbatch = THTensor_(size)(input, 0);
int channels = THTensor_(size)(input, 1);
int inputDepth = THTensor_(size)(input, 2);
int inputHeight = THTensor_(size)(input, 3);
int inputWidth = THTensor_(size)(input, 4);
THNN_(VolumetricUpSamplingTrilinear_shapeCheck)
(input, NULL,
nbatch, channels,
inputDepth, inputHeight, inputWidth,
outputDepth, outputHeight, outputWidth);
input = THTensor_(newContiguous)(input);
THTensor_(resize5d)(output,
THTensor_(size)(input, 0),
THTensor_(size)(input, 1),
outputDepth, outputHeight, outputWidth);
THTensor_(zero)(output);
real *idata = THTensor_(data)(input);
real *odata = THTensor_(data)(output);
channels = nbatch * channels;
THAssert(inputDepth > 0 && inputHeight > 0 && inputWidth > 0 &&
outputDepth > 0 && outputHeight > 0 && outputWidth > 0);
// special case: just copy
if (inputDepth == outputDepth && inputHeight == outputHeight && inputWidth == outputWidth) {
for (int t2 = 0; t2 < outputDepth; ++t2) {
const int t1 = t2;
for (int h2 = 0; h2 < outputHeight; ++h2) {
const int h1 = h2;
for (int w2 = 0; w2 < outputWidth; ++w2) {
const int w1 = w2;
const real* pos1 = &idata[t1 * inputHeight * inputWidth + h1 * inputWidth + w1];
real* pos2 = &odata[t2 * outputHeight * outputWidth + h2 * outputWidth + w2];
for (int c = 0; c < channels; ++c) {
pos2[0] = pos1[0];
pos1 += inputWidth * inputHeight * inputDepth;
pos2 += outputWidth * outputHeight * outputDepth;
}
}
}
}
return;
}
const float rdepth = (outputDepth > 1) ? (float)(inputDepth - 1)/(outputDepth - 1) : 0.f;
const float rheight = (outputHeight > 1) ? (float)(inputHeight - 1)/(outputHeight - 1) : 0.f;
const float rwidth = (outputWidth > 1) ? (float)(inputWidth - 1) / (outputWidth - 1) : 0.f;
for (int t2 = 0; t2 < outputDepth; ++t2) {
const float t1r = rdepth * t2;
const int t1 = t1r;
const int t1p = (t1 < inputDepth - 1) ? 1 : 0;
const real t1lambda = t1r - t1;
const real t0lambda = (real)1. - t1lambda;
for (int h2 = 0; h2 < outputHeight; ++h2) {
const float h1r = rheight * h2;
const int h1 = h1r;
const int h1p = (h1 < inputHeight - 1) ? 1 : 0;
const real h1lambda = h1r - h1;
const real h0lambda = (real)1. - h1lambda;
for (int w2 = 0; w2 < outputWidth; ++w2) {
const float w1r = rwidth * w2;
const int w1 = w1r;
const int w1p = (w1 < inputWidth - 1) ? 1 : 0;
const real w1lambda = w1r - w1;
const real w0lambda = (real)1. - w1lambda;
const real* pos1 = &idata[t1 * inputHeight * inputWidth + h1 * inputWidth + w1];
real* pos2 = &odata[t2 * outputHeight * outputWidth + h2 * outputWidth + w2];
for (int c = 0; c < channels; ++c) {
pos2[0] = t0lambda * (h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p])
+ h1lambda * (w0lambda * pos1[h1p * inputWidth]
+ w1lambda * pos1[h1p * inputWidth + w1p]))
+ t1lambda * (h0lambda * (w0lambda * pos1[t1p * inputHeight * inputWidth]
+ w1lambda * pos1[t1p * inputHeight * inputWidth
+ w1p])
+ h1lambda * (w0lambda * pos1[t1p * inputHeight * inputWidth
+ h1p * inputWidth]
+ w1lambda * pos1[t1p * inputHeight * inputWidth
+ h1p * inputWidth + w1p]));
pos1 += inputWidth * inputHeight * inputDepth;
pos2 += outputWidth * outputHeight * outputDepth;
}
}
}
}
THTensor_(free)(input);
}
void THNN_(VolumetricUpSamplingTrilinear_updateGradInput)(
THNNState *state,
THTensor *gradOutput,
THTensor *gradInput,
int nbatch,
int channels,
int inputDepth,
int inputHeight,
int inputWidth,
int outputDepth,
int outputHeight,
int outputWidth){
THNN_(VolumetricUpSamplingTrilinear_shapeCheck)
(NULL, gradOutput,
nbatch, channels,
inputDepth, inputHeight, inputWidth,
outputDepth, outputHeight, outputWidth);
THTensor_(resize5d)(gradInput, nbatch, channels, inputDepth, inputHeight, inputWidth);
THTensor_(zero)(gradInput);
gradOutput = THTensor_(newContiguous)(gradOutput);
real *data1 = THTensor_(data)(gradInput);
real *data2 = THTensor_(data)(gradOutput);
channels = nbatch * channels;
// special case: same-size matching grids
if (inputDepth == outputDepth && inputHeight == outputHeight && inputWidth == outputWidth) {
for (int t2 = 0; t2 < outputDepth; ++t2) {
const int t1 = t2;
for (int h2 = 0; h2 < outputHeight; ++h2) {
const int h1 = h2;
for (int w2 = 0; w2 < outputWidth; ++w2) {
const int w1 = w2;
real* pos1 = &data1[t1 * inputHeight * inputWidth + h1 * inputWidth + w1];
const real* pos2 = &data2[t2 * outputHeight * outputWidth + h2 * outputWidth + w2];
for (int c = 0; c < channels; ++c) {
pos1[0] += pos2[0];
pos1 += inputWidth * inputHeight * inputDepth;
pos2 += outputWidth * outputHeight * outputDepth;
}
}
}
}
return;
}
const float rdepth = (outputDepth > 1) ? (float)(inputDepth - 1)/(outputDepth - 1) : 0.f;
const float rheight = (outputHeight > 1) ? (float)(inputHeight - 1)/(outputHeight - 1) : 0.f;
const float rwidth = (outputWidth > 1) ? (float)(inputWidth - 1)/(outputWidth - 1) : 0.f;
for (int t2 = 0; t2 < outputDepth; ++t2) {
const float t1r = rdepth * t2;
const int t1 = t1r;
const int t1p = (t1 < inputDepth - 1) ? 1 : 0;
const real t1lambda = t1r - t1;
const real t0lambda = (real)1. - t1lambda;
for (int h2 = 0; h2 < outputHeight; ++h2) {
const float h1r = rheight * h2;
const int h1 = h1r;
const int h1p = (h1 < inputHeight - 1) ? 1 : 0;
const real h1lambda = h1r - h1;
const real h0lambda = (real)1. - h1lambda;
for (int w2 = 0; w2 < outputWidth; ++w2) {
const float w1r = rwidth * w2;
const int w1 = w1r;
const int w1p = (w1 < inputWidth - 1) ? 1 : 0;
const real w1lambda = w1r - w1;
const real w0lambda = (real)1. - w1lambda;
real* pos1 = &data1[t1 * inputHeight * inputWidth + h1 * inputWidth + w1];
const real* pos2 = &data2[t2 * outputHeight * outputWidth + h2 * outputWidth + w2];
for (int c = 0; c < channels; ++c) {
pos1[0] += t0lambda * h0lambda * w0lambda * pos2[0];
pos1[w1p] += t0lambda * h0lambda * w1lambda * pos2[0];
pos1[h1p * inputWidth] += t0lambda * h1lambda * w0lambda * pos2[0];
pos1[h1p * inputWidth + w1p] += t0lambda * h1lambda * w1lambda * pos2[0];
pos1[t1p * inputHeight * inputWidth] += t1lambda * h0lambda * w0lambda * pos2[0];
pos1[t1p * inputHeight * inputWidth + w1p] += t1lambda * h0lambda * w1lambda * pos2[0];
pos1[t1p * inputHeight * inputWidth + h1p * inputWidth] += t1lambda * h1lambda * w0lambda * pos2[0];
pos1[t1p * inputHeight * inputWidth + h1p * inputWidth + w1p] += t1lambda * h1lambda * w1lambda * pos2[0];
pos1 += inputWidth * inputHeight * inputDepth;
pos2 += outputWidth * outputHeight * outputDepth;
}
}
}
}
THTensor_(free)(gradOutput);
}
#endif
|
the_stack_data/18888543.c
|
//1. Add two complex numbers by passing structure to a function as argument.
#include<stdio.h>
struct complex //definning the structure
{
int real;
int img;
};
void add(struct complex var1,struct complex var2) //function to add two complex numbers
{
printf("\nComplex num 1 : %d+%di",var1.real,var1.img);
printf("\nComplex num 2 : %d+%di",var2.real,var2.img);
printf("\nSum : %d+%di",var1.real+var2.real,var1.img+var2.img);
}
int main()
{
struct complex var1,var2;
printf("\nEnter the first complex number : ");
printf("\nEnter the real part : ");
scanf("%d",&var1.real);
printf("Enter the imaginary part : ");
scanf("%d",&var1.img);
printf("\nEnter the second complex number : ");
printf("\nEnter the real part : ");
scanf("%d",&var2.real);
printf("\nEnter the imaginary part : ");
scanf("%d",&var2.img);
add(var1,var2);
return 0;
}
|
the_stack_data/103265955.c
|
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
char alea (char mondeCarre[30][30], int dim)
{
/*
Cette fonction permet de choisir de manière aléatoire l'une des 7 couleurs comprises entre A et G
*/
char couleur_aleatoire;
couleur_aleatoire = 'A' +rand()%7;
printf("L'ordinateur a joué %c\n", couleur_aleatoire);
return couleur_aleatoire;
}
|
the_stack_data/111931.c
|
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
/*
* Richard Mann
* 31 October 1996
* 18 May 1998
*
* Copyright 1996 and 1997 University of Toronto. All rights reserved.
* Copyright 1998 NEC Research Institute, Inc. All rights reserved.
*
*/
/*
* Macros
*
*/
/*
* Structs
*
*/
void *alloc_XExtData(void) {XExtData *_p = (XExtData *)malloc(sizeof(XExtData)); if (_p==NULL) abort(); return (void *)_p;}
void free_XExtData(void *_p) {if (_p==NULL) abort(); free((XExtData *)_p);}
int get_XExtData_number(void *_p) {return (int)((XExtData *)_p)->number;}
void set_XExtData_number(void *_p, int _v) {((XExtData *)_p)->number = (int)_v;}
void *get_XExtData_next(void *_p) {return (void *)((XExtData *)_p)->next;}
void set_XExtData_next(void *_p, void *_v) {((XExtData *)_p)->next = (XExtData *)_v;}
void *get_XExtData_free_private(void *_p) {return (void *)((XExtData *)_p)->free_private;}
void set_XExtData_free_private(void *_p, void *_v) {((XExtData *)_p)->free_private = (int( *)())_v;}
void *get_XExtData_private_data(void *_p) {return (void *)((XExtData *)_p)->private_data;}
void set_XExtData_private_data(void *_p, void *_v) {((XExtData *)_p)->private_data = (char *)_v;}
void *alloc_XExtCodes(void) {XExtCodes *_p = (XExtCodes *)malloc(sizeof(XExtCodes)); if (_p==NULL) abort(); return (void *)_p;}
void free_XExtCodes(void *_p) {if (_p==NULL) abort(); free((XExtCodes *)_p);}
int get_XExtCodes_extension(void *_p) {return (int)((XExtCodes *)_p)->extension;}
void set_XExtCodes_extension(void *_p, int _v) {((XExtCodes *)_p)->extension = (int)_v;}
int get_XExtCodes_major_opcode(void *_p) {return (int)((XExtCodes *)_p)->major_opcode;}
void set_XExtCodes_major_opcode(void *_p, int _v) {((XExtCodes *)_p)->major_opcode = (int)_v;}
int get_XExtCodes_first_event(void *_p) {return (int)((XExtCodes *)_p)->first_event;}
void set_XExtCodes_first_event(void *_p, int _v) {((XExtCodes *)_p)->first_event = (int)_v;}
int get_XExtCodes_first_error(void *_p) {return (int)((XExtCodes *)_p)->first_error;}
void set_XExtCodes_first_error(void *_p, int _v) {((XExtCodes *)_p)->first_error = (int)_v;}
void *alloc_XPixmapFormatValues(void) {XPixmapFormatValues *_p = (XPixmapFormatValues *)malloc(sizeof(XPixmapFormatValues)); if (_p==NULL) abort(); return (void *)_p;}
void free_XPixmapFormatValues(void *_p) {if (_p==NULL) abort(); free((XPixmapFormatValues *)_p);}
int get_XPixmapFormatValues_depth(void *_p) {return (int)((XPixmapFormatValues *)_p)->depth;}
void set_XPixmapFormatValues_depth(void *_p, int _v) {((XPixmapFormatValues *)_p)->depth = (int)_v;}
int get_XPixmapFormatValues_bits_per_pixel(void *_p) {return (int)((XPixmapFormatValues *)_p)->bits_per_pixel;}
void set_XPixmapFormatValues_bits_per_pixel(void *_p, int _v) {((XPixmapFormatValues *)_p)->bits_per_pixel = (int)_v;}
int get_XPixmapFormatValues_scanline_pad(void *_p) {return (int)((XPixmapFormatValues *)_p)->scanline_pad;}
void set_XPixmapFormatValues_scanline_pad(void *_p, int _v) {((XPixmapFormatValues *)_p)->scanline_pad = (int)_v;}
void *alloc_XGCValues(void) {XGCValues *_p = (XGCValues *)malloc(sizeof(XGCValues)); if (_p==NULL) abort(); return (void *)_p;}
void free_XGCValues(void *_p) {if (_p==NULL) abort(); free((XGCValues *)_p);}
int get_XGCValues_function(void *_p) {return (int)((XGCValues *)_p)->function;}
void set_XGCValues_function(void *_p, int _v) {((XGCValues *)_p)->function = (int)_v;}
unsigned long get_XGCValues_plane_mask(void *_p) {return (unsigned long)((XGCValues *)_p)->plane_mask;}
void set_XGCValues_plane_mask(void *_p, unsigned long _v) {((XGCValues *)_p)->plane_mask = (unsigned long)_v;}
unsigned long get_XGCValues_foreground(void *_p) {return (unsigned long)((XGCValues *)_p)->foreground;}
void set_XGCValues_foreground(void *_p, unsigned long _v) {((XGCValues *)_p)->foreground = (unsigned long)_v;}
unsigned long get_XGCValues_background(void *_p) {return (unsigned long)((XGCValues *)_p)->background;}
void set_XGCValues_background(void *_p, unsigned long _v) {((XGCValues *)_p)->background = (unsigned long)_v;}
int get_XGCValues_line_width(void *_p) {return (int)((XGCValues *)_p)->line_width;}
void set_XGCValues_line_width(void *_p, int _v) {((XGCValues *)_p)->line_width = (int)_v;}
int get_XGCValues_line_style(void *_p) {return (int)((XGCValues *)_p)->line_style;}
void set_XGCValues_line_style(void *_p, int _v) {((XGCValues *)_p)->line_style = (int)_v;}
int get_XGCValues_cap_style(void *_p) {return (int)((XGCValues *)_p)->cap_style;}
void set_XGCValues_cap_style(void *_p, int _v) {((XGCValues *)_p)->cap_style = (int)_v;}
int get_XGCValues_join_style(void *_p) {return (int)((XGCValues *)_p)->join_style;}
void set_XGCValues_join_style(void *_p, int _v) {((XGCValues *)_p)->join_style = (int)_v;}
int get_XGCValues_fill_style(void *_p) {return (int)((XGCValues *)_p)->fill_style;}
void set_XGCValues_fill_style(void *_p, int _v) {((XGCValues *)_p)->fill_style = (int)_v;}
int get_XGCValues_fill_rule(void *_p) {return (int)((XGCValues *)_p)->fill_rule;}
void set_XGCValues_fill_rule(void *_p, int _v) {((XGCValues *)_p)->fill_rule = (int)_v;}
int get_XGCValues_arc_mode(void *_p) {return (int)((XGCValues *)_p)->arc_mode;}
void set_XGCValues_arc_mode(void *_p, int _v) {((XGCValues *)_p)->arc_mode = (int)_v;}
unsigned long get_XGCValues_tile(void *_p) {return (unsigned long)((XGCValues *)_p)->tile;}
void set_XGCValues_tile(void *_p, unsigned long _v) {((XGCValues *)_p)->tile = (unsigned long)_v;}
unsigned long get_XGCValues_stipple(void *_p) {return (unsigned long)((XGCValues *)_p)->stipple;}
void set_XGCValues_stipple(void *_p, unsigned long _v) {((XGCValues *)_p)->stipple = (unsigned long)_v;}
int get_XGCValues_ts_x_origin(void *_p) {return (int)((XGCValues *)_p)->ts_x_origin;}
void set_XGCValues_ts_x_origin(void *_p, int _v) {((XGCValues *)_p)->ts_x_origin = (int)_v;}
int get_XGCValues_ts_y_origin(void *_p) {return (int)((XGCValues *)_p)->ts_y_origin;}
void set_XGCValues_ts_y_origin(void *_p, int _v) {((XGCValues *)_p)->ts_y_origin = (int)_v;}
unsigned long get_XGCValues_font(void *_p) {return (unsigned long)((XGCValues *)_p)->font;}
void set_XGCValues_font(void *_p, unsigned long _v) {((XGCValues *)_p)->font = (unsigned long)_v;}
int get_XGCValues_subwindow_mode(void *_p) {return (int)((XGCValues *)_p)->subwindow_mode;}
void set_XGCValues_subwindow_mode(void *_p, int _v) {((XGCValues *)_p)->subwindow_mode = (int)_v;}
int get_XGCValues_graphics_exposures(void *_p) {return (int)((XGCValues *)_p)->graphics_exposures;}
void set_XGCValues_graphics_exposures(void *_p, int _v) {((XGCValues *)_p)->graphics_exposures = (int)_v;}
int get_XGCValues_clip_x_origin(void *_p) {return (int)((XGCValues *)_p)->clip_x_origin;}
void set_XGCValues_clip_x_origin(void *_p, int _v) {((XGCValues *)_p)->clip_x_origin = (int)_v;}
int get_XGCValues_clip_y_origin(void *_p) {return (int)((XGCValues *)_p)->clip_y_origin;}
void set_XGCValues_clip_y_origin(void *_p, int _v) {((XGCValues *)_p)->clip_y_origin = (int)_v;}
unsigned long get_XGCValues_clip_mask(void *_p) {return (unsigned long)((XGCValues *)_p)->clip_mask;}
void set_XGCValues_clip_mask(void *_p, unsigned long _v) {((XGCValues *)_p)->clip_mask = (unsigned long)_v;}
int get_XGCValues_dash_offset(void *_p) {return (int)((XGCValues *)_p)->dash_offset;}
void set_XGCValues_dash_offset(void *_p, int _v) {((XGCValues *)_p)->dash_offset = (int)_v;}
char get_XGCValues_dashes(void *_p) {return (char)((XGCValues *)_p)->dashes;}
void set_XGCValues_dashes(void *_p, char _v) {((XGCValues *)_p)->dashes = (char)_v;}
void *alloc_Visual(void) {Visual *_p = (Visual *)malloc(sizeof(Visual)); if (_p==NULL) abort(); return (void *)_p;}
void free_Visual(void *_p) {if (_p==NULL) abort(); free((Visual *)_p);}
void *get_Visual_ext_data(void *_p) {return (void *)((Visual *)_p)->ext_data;}
void set_Visual_ext_data(void *_p, void *_v) {((Visual *)_p)->ext_data = (XExtData *)_v;}
unsigned long get_Visual_visualid(void *_p) {return (unsigned long)((Visual *)_p)->visualid;}
void set_Visual_visualid(void *_p, unsigned long _v) {((Visual *)_p)->visualid = (unsigned long)_v;}
int get_Visual_class(void *_p) {return (int)((Visual *)_p)->class;}
void set_Visual_class(void *_p, int _v) {((Visual *)_p)->class = (int)_v;}
unsigned long get_Visual_red_mask(void *_p) {return (unsigned long)((Visual *)_p)->red_mask;}
void set_Visual_red_mask(void *_p, unsigned long _v) {((Visual *)_p)->red_mask = (unsigned long)_v;}
unsigned long get_Visual_green_mask(void *_p) {return (unsigned long)((Visual *)_p)->green_mask;}
void set_Visual_green_mask(void *_p, unsigned long _v) {((Visual *)_p)->green_mask = (unsigned long)_v;}
unsigned long get_Visual_blue_mask(void *_p) {return (unsigned long)((Visual *)_p)->blue_mask;}
void set_Visual_blue_mask(void *_p, unsigned long _v) {((Visual *)_p)->blue_mask = (unsigned long)_v;}
int get_Visual_bits_per_rgb(void *_p) {return (int)((Visual *)_p)->bits_per_rgb;}
void set_Visual_bits_per_rgb(void *_p, int _v) {((Visual *)_p)->bits_per_rgb = (int)_v;}
int get_Visual_map_entries(void *_p) {return (int)((Visual *)_p)->map_entries;}
void set_Visual_map_entries(void *_p, int _v) {((Visual *)_p)->map_entries = (int)_v;}
void *alloc_Depth(void) {Depth *_p = (Depth *)malloc(sizeof(Depth)); if (_p==NULL) abort(); return (void *)_p;}
void free_Depth(void *_p) {if (_p==NULL) abort(); free((Depth *)_p);}
int get_Depth_depth(void *_p) {return (int)((Depth *)_p)->depth;}
void set_Depth_depth(void *_p, int _v) {((Depth *)_p)->depth = (int)_v;}
int get_Depth_nvisuals(void *_p) {return (int)((Depth *)_p)->nvisuals;}
void set_Depth_nvisuals(void *_p, int _v) {((Depth *)_p)->nvisuals = (int)_v;}
void *get_Depth_visuals(void *_p) {return (void *)((Depth *)_p)->visuals;}
void set_Depth_visuals(void *_p, void *_v) {((Depth *)_p)->visuals = (Visual *)_v;}
void *alloc_Screen(void) {Screen *_p = (Screen *)malloc(sizeof(Screen)); if (_p==NULL) abort(); return (void *)_p;}
void free_Screen(void *_p) {if (_p==NULL) abort(); free((Screen *)_p);}
void *get_Screen_ext_data(void *_p) {return (void *)((Screen *)_p)->ext_data;}
void set_Screen_ext_data(void *_p, void *_v) {((Screen *)_p)->ext_data = (XExtData *)_v;}
void *get_Screen_display(void *_p) {return (void *)((Screen *)_p)->display;}
void set_Screen_display(void *_p, void *_v) {((Screen *)_p)->display = (Display *)_v;}
unsigned long get_Screen_root(void *_p) {return (unsigned long)((Screen *)_p)->root;}
void set_Screen_root(void *_p, unsigned long _v) {((Screen *)_p)->root = (unsigned long)_v;}
int get_Screen_width(void *_p) {return (int)((Screen *)_p)->width;}
void set_Screen_width(void *_p, int _v) {((Screen *)_p)->width = (int)_v;}
int get_Screen_height(void *_p) {return (int)((Screen *)_p)->height;}
void set_Screen_height(void *_p, int _v) {((Screen *)_p)->height = (int)_v;}
int get_Screen_mwidth(void *_p) {return (int)((Screen *)_p)->mwidth;}
void set_Screen_mwidth(void *_p, int _v) {((Screen *)_p)->mwidth = (int)_v;}
int get_Screen_mheight(void *_p) {return (int)((Screen *)_p)->mheight;}
void set_Screen_mheight(void *_p, int _v) {((Screen *)_p)->mheight = (int)_v;}
int get_Screen_ndepths(void *_p) {return (int)((Screen *)_p)->ndepths;}
void set_Screen_ndepths(void *_p, int _v) {((Screen *)_p)->ndepths = (int)_v;}
void *get_Screen_depths(void *_p) {return (void *)((Screen *)_p)->depths;}
void set_Screen_depths(void *_p, void *_v) {((Screen *)_p)->depths = (Depth *)_v;}
int get_Screen_root_depth(void *_p) {return (int)((Screen *)_p)->root_depth;}
void set_Screen_root_depth(void *_p, int _v) {((Screen *)_p)->root_depth = (int)_v;}
void *get_Screen_root_visual(void *_p) {return (void *)((Screen *)_p)->root_visual;}
void set_Screen_root_visual(void *_p, void *_v) {((Screen *)_p)->root_visual = (Visual *)_v;}
void *get_Screen_default_gc(void *_p) {return (void *)((Screen *)_p)->default_gc;}
void set_Screen_default_gc(void *_p, void *_v) {((Screen *)_p)->default_gc = (void *)_v;}
unsigned long get_Screen_cmap(void *_p) {return (unsigned long)((Screen *)_p)->cmap;}
void set_Screen_cmap(void *_p, unsigned long _v) {((Screen *)_p)->cmap = (unsigned long)_v;}
unsigned long get_Screen_white_pixel(void *_p) {return (unsigned long)((Screen *)_p)->white_pixel;}
void set_Screen_white_pixel(void *_p, unsigned long _v) {((Screen *)_p)->white_pixel = (unsigned long)_v;}
unsigned long get_Screen_black_pixel(void *_p) {return (unsigned long)((Screen *)_p)->black_pixel;}
void set_Screen_black_pixel(void *_p, unsigned long _v) {((Screen *)_p)->black_pixel = (unsigned long)_v;}
int get_Screen_max_maps(void *_p) {return (int)((Screen *)_p)->max_maps;}
void set_Screen_max_maps(void *_p, int _v) {((Screen *)_p)->max_maps = (int)_v;}
int get_Screen_min_maps(void *_p) {return (int)((Screen *)_p)->min_maps;}
void set_Screen_min_maps(void *_p, int _v) {((Screen *)_p)->min_maps = (int)_v;}
int get_Screen_backing_store(void *_p) {return (int)((Screen *)_p)->backing_store;}
void set_Screen_backing_store(void *_p, int _v) {((Screen *)_p)->backing_store = (int)_v;}
int get_Screen_save_unders(void *_p) {return (int)((Screen *)_p)->save_unders;}
void set_Screen_save_unders(void *_p, int _v) {((Screen *)_p)->save_unders = (int)_v;}
long get_Screen_root_input_mask(void *_p) {return (long)((Screen *)_p)->root_input_mask;}
void set_Screen_root_input_mask(void *_p, long _v) {((Screen *)_p)->root_input_mask = (long)_v;}
void *alloc_ScreenFormat(void) {ScreenFormat *_p = (ScreenFormat *)malloc(sizeof(ScreenFormat)); if (_p==NULL) abort(); return (void *)_p;}
void free_ScreenFormat(void *_p) {if (_p==NULL) abort(); free((ScreenFormat *)_p);}
void *get_ScreenFormat_ext_data(void *_p) {return (void *)((ScreenFormat *)_p)->ext_data;}
void set_ScreenFormat_ext_data(void *_p, void *_v) {((ScreenFormat *)_p)->ext_data = (XExtData *)_v;}
int get_ScreenFormat_depth(void *_p) {return (int)((ScreenFormat *)_p)->depth;}
void set_ScreenFormat_depth(void *_p, int _v) {((ScreenFormat *)_p)->depth = (int)_v;}
int get_ScreenFormat_bits_per_pixel(void *_p) {return (int)((ScreenFormat *)_p)->bits_per_pixel;}
void set_ScreenFormat_bits_per_pixel(void *_p, int _v) {((ScreenFormat *)_p)->bits_per_pixel = (int)_v;}
int get_ScreenFormat_scanline_pad(void *_p) {return (int)((ScreenFormat *)_p)->scanline_pad;}
void set_ScreenFormat_scanline_pad(void *_p, int _v) {((ScreenFormat *)_p)->scanline_pad = (int)_v;}
void *alloc_XSetWindowAttributes(void) {XSetWindowAttributes *_p = (XSetWindowAttributes *)malloc(sizeof(XSetWindowAttributes)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSetWindowAttributes(void *_p) {if (_p==NULL) abort(); free((XSetWindowAttributes *)_p);}
unsigned long get_XSetWindowAttributes_background_pixmap(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->background_pixmap;}
void set_XSetWindowAttributes_background_pixmap(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->background_pixmap = (unsigned long)_v;}
unsigned long get_XSetWindowAttributes_background_pixel(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->background_pixel;}
void set_XSetWindowAttributes_background_pixel(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->background_pixel = (unsigned long)_v;}
unsigned long get_XSetWindowAttributes_border_pixmap(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->border_pixmap;}
void set_XSetWindowAttributes_border_pixmap(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->border_pixmap = (unsigned long)_v;}
unsigned long get_XSetWindowAttributes_border_pixel(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->border_pixel;}
void set_XSetWindowAttributes_border_pixel(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->border_pixel = (unsigned long)_v;}
int get_XSetWindowAttributes_bit_gravity(void *_p) {return (int)((XSetWindowAttributes *)_p)->bit_gravity;}
void set_XSetWindowAttributes_bit_gravity(void *_p, int _v) {((XSetWindowAttributes *)_p)->bit_gravity = (int)_v;}
int get_XSetWindowAttributes_win_gravity(void *_p) {return (int)((XSetWindowAttributes *)_p)->win_gravity;}
void set_XSetWindowAttributes_win_gravity(void *_p, int _v) {((XSetWindowAttributes *)_p)->win_gravity = (int)_v;}
int get_XSetWindowAttributes_backing_store(void *_p) {return (int)((XSetWindowAttributes *)_p)->backing_store;}
void set_XSetWindowAttributes_backing_store(void *_p, int _v) {((XSetWindowAttributes *)_p)->backing_store = (int)_v;}
unsigned long get_XSetWindowAttributes_backing_planes(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->backing_planes;}
void set_XSetWindowAttributes_backing_planes(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->backing_planes = (unsigned long)_v;}
unsigned long get_XSetWindowAttributes_backing_pixel(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->backing_pixel;}
void set_XSetWindowAttributes_backing_pixel(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->backing_pixel = (unsigned long)_v;}
int get_XSetWindowAttributes_save_under(void *_p) {return (int)((XSetWindowAttributes *)_p)->save_under;}
void set_XSetWindowAttributes_save_under(void *_p, int _v) {((XSetWindowAttributes *)_p)->save_under = (int)_v;}
long get_XSetWindowAttributes_event_mask(void *_p) {return (long)((XSetWindowAttributes *)_p)->event_mask;}
void set_XSetWindowAttributes_event_mask(void *_p, long _v) {((XSetWindowAttributes *)_p)->event_mask = (long)_v;}
long get_XSetWindowAttributes_do_not_propagate_mask(void *_p) {return (long)((XSetWindowAttributes *)_p)->do_not_propagate_mask;}
void set_XSetWindowAttributes_do_not_propagate_mask(void *_p, long _v) {((XSetWindowAttributes *)_p)->do_not_propagate_mask = (long)_v;}
int get_XSetWindowAttributes_override_redirect(void *_p) {return (int)((XSetWindowAttributes *)_p)->override_redirect;}
void set_XSetWindowAttributes_override_redirect(void *_p, int _v) {((XSetWindowAttributes *)_p)->override_redirect = (int)_v;}
unsigned long get_XSetWindowAttributes_colormap(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->colormap;}
void set_XSetWindowAttributes_colormap(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->colormap = (unsigned long)_v;}
unsigned long get_XSetWindowAttributes_cursor(void *_p) {return (unsigned long)((XSetWindowAttributes *)_p)->cursor;}
void set_XSetWindowAttributes_cursor(void *_p, unsigned long _v) {((XSetWindowAttributes *)_p)->cursor = (unsigned long)_v;}
void *alloc_XWindowAttributes(void) {XWindowAttributes *_p = (XWindowAttributes *)malloc(sizeof(XWindowAttributes)); if (_p==NULL) abort(); return (void *)_p;}
void free_XWindowAttributes(void *_p) {if (_p==NULL) abort(); free((XWindowAttributes *)_p);}
int get_XWindowAttributes_x(void *_p) {return (int)((XWindowAttributes *)_p)->x;}
void set_XWindowAttributes_x(void *_p, int _v) {((XWindowAttributes *)_p)->x = (int)_v;}
int get_XWindowAttributes_y(void *_p) {return (int)((XWindowAttributes *)_p)->y;}
void set_XWindowAttributes_y(void *_p, int _v) {((XWindowAttributes *)_p)->y = (int)_v;}
int get_XWindowAttributes_width(void *_p) {return (int)((XWindowAttributes *)_p)->width;}
void set_XWindowAttributes_width(void *_p, int _v) {((XWindowAttributes *)_p)->width = (int)_v;}
int get_XWindowAttributes_height(void *_p) {return (int)((XWindowAttributes *)_p)->height;}
void set_XWindowAttributes_height(void *_p, int _v) {((XWindowAttributes *)_p)->height = (int)_v;}
int get_XWindowAttributes_border_width(void *_p) {return (int)((XWindowAttributes *)_p)->border_width;}
void set_XWindowAttributes_border_width(void *_p, int _v) {((XWindowAttributes *)_p)->border_width = (int)_v;}
int get_XWindowAttributes_depth(void *_p) {return (int)((XWindowAttributes *)_p)->depth;}
void set_XWindowAttributes_depth(void *_p, int _v) {((XWindowAttributes *)_p)->depth = (int)_v;}
void *get_XWindowAttributes_visual(void *_p) {return (void *)((XWindowAttributes *)_p)->visual;}
void set_XWindowAttributes_visual(void *_p, void *_v) {((XWindowAttributes *)_p)->visual = (Visual *)_v;}
unsigned long get_XWindowAttributes_root(void *_p) {return (unsigned long)((XWindowAttributes *)_p)->root;}
void set_XWindowAttributes_root(void *_p, unsigned long _v) {((XWindowAttributes *)_p)->root = (unsigned long)_v;}
int get_XWindowAttributes_class(void *_p) {return (int)((XWindowAttributes *)_p)->class;}
void set_XWindowAttributes_class(void *_p, int _v) {((XWindowAttributes *)_p)->class = (int)_v;}
int get_XWindowAttributes_bit_gravity(void *_p) {return (int)((XWindowAttributes *)_p)->bit_gravity;}
void set_XWindowAttributes_bit_gravity(void *_p, int _v) {((XWindowAttributes *)_p)->bit_gravity = (int)_v;}
int get_XWindowAttributes_win_gravity(void *_p) {return (int)((XWindowAttributes *)_p)->win_gravity;}
void set_XWindowAttributes_win_gravity(void *_p, int _v) {((XWindowAttributes *)_p)->win_gravity = (int)_v;}
int get_XWindowAttributes_backing_store(void *_p) {return (int)((XWindowAttributes *)_p)->backing_store;}
void set_XWindowAttributes_backing_store(void *_p, int _v) {((XWindowAttributes *)_p)->backing_store = (int)_v;}
unsigned long get_XWindowAttributes_backing_planes(void *_p) {return (unsigned long)((XWindowAttributes *)_p)->backing_planes;}
void set_XWindowAttributes_backing_planes(void *_p, unsigned long _v) {((XWindowAttributes *)_p)->backing_planes = (unsigned long)_v;}
unsigned long get_XWindowAttributes_backing_pixel(void *_p) {return (unsigned long)((XWindowAttributes *)_p)->backing_pixel;}
void set_XWindowAttributes_backing_pixel(void *_p, unsigned long _v) {((XWindowAttributes *)_p)->backing_pixel = (unsigned long)_v;}
int get_XWindowAttributes_save_under(void *_p) {return (int)((XWindowAttributes *)_p)->save_under;}
void set_XWindowAttributes_save_under(void *_p, int _v) {((XWindowAttributes *)_p)->save_under = (int)_v;}
unsigned long get_XWindowAttributes_colormap(void *_p) {return (unsigned long)((XWindowAttributes *)_p)->colormap;}
void set_XWindowAttributes_colormap(void *_p, unsigned long _v) {((XWindowAttributes *)_p)->colormap = (unsigned long)_v;}
int get_XWindowAttributes_map_installed(void *_p) {return (int)((XWindowAttributes *)_p)->map_installed;}
void set_XWindowAttributes_map_installed(void *_p, int _v) {((XWindowAttributes *)_p)->map_installed = (int)_v;}
int get_XWindowAttributes_map_state(void *_p) {return (int)((XWindowAttributes *)_p)->map_state;}
void set_XWindowAttributes_map_state(void *_p, int _v) {((XWindowAttributes *)_p)->map_state = (int)_v;}
long get_XWindowAttributes_all_event_masks(void *_p) {return (long)((XWindowAttributes *)_p)->all_event_masks;}
void set_XWindowAttributes_all_event_masks(void *_p, long _v) {((XWindowAttributes *)_p)->all_event_masks = (long)_v;}
long get_XWindowAttributes_your_event_mask(void *_p) {return (long)((XWindowAttributes *)_p)->your_event_mask;}
void set_XWindowAttributes_your_event_mask(void *_p, long _v) {((XWindowAttributes *)_p)->your_event_mask = (long)_v;}
long get_XWindowAttributes_do_not_propagate_mask(void *_p) {return (long)((XWindowAttributes *)_p)->do_not_propagate_mask;}
void set_XWindowAttributes_do_not_propagate_mask(void *_p, long _v) {((XWindowAttributes *)_p)->do_not_propagate_mask = (long)_v;}
int get_XWindowAttributes_override_redirect(void *_p) {return (int)((XWindowAttributes *)_p)->override_redirect;}
void set_XWindowAttributes_override_redirect(void *_p, int _v) {((XWindowAttributes *)_p)->override_redirect = (int)_v;}
void *get_XWindowAttributes_screen(void *_p) {return (void *)((XWindowAttributes *)_p)->screen;}
void set_XWindowAttributes_screen(void *_p, void *_v) {((XWindowAttributes *)_p)->screen = (Screen *)_v;}
void *alloc_XHostAddress(void) {XHostAddress *_p = (XHostAddress *)malloc(sizeof(XHostAddress)); if (_p==NULL) abort(); return (void *)_p;}
void free_XHostAddress(void *_p) {if (_p==NULL) abort(); free((XHostAddress *)_p);}
int get_XHostAddress_family(void *_p) {return (int)((XHostAddress *)_p)->family;}
void set_XHostAddress_family(void *_p, int _v) {((XHostAddress *)_p)->family = (int)_v;}
int get_XHostAddress_length(void *_p) {return (int)((XHostAddress *)_p)->length;}
void set_XHostAddress_length(void *_p, int _v) {((XHostAddress *)_p)->length = (int)_v;}
void *get_XHostAddress_address(void *_p) {return (void *)((XHostAddress *)_p)->address;}
void set_XHostAddress_address(void *_p, void *_v) {((XHostAddress *)_p)->address = (char *)_v;}
void *alloc_XImage(void) {XImage *_p = (XImage *)malloc(sizeof(XImage)); if (_p==NULL) abort(); return (void *)_p;}
void free_XImage(void *_p) {if (_p==NULL) abort(); free((XImage *)_p);}
int get_XImage_width(void *_p) {return (int)((XImage *)_p)->width;}
void set_XImage_width(void *_p, int _v) {((XImage *)_p)->width = (int)_v;}
int get_XImage_height(void *_p) {return (int)((XImage *)_p)->height;}
void set_XImage_height(void *_p, int _v) {((XImage *)_p)->height = (int)_v;}
int get_XImage_xoffset(void *_p) {return (int)((XImage *)_p)->xoffset;}
void set_XImage_xoffset(void *_p, int _v) {((XImage *)_p)->xoffset = (int)_v;}
int get_XImage_format(void *_p) {return (int)((XImage *)_p)->format;}
void set_XImage_format(void *_p, int _v) {((XImage *)_p)->format = (int)_v;}
void *get_XImage_data(void *_p) {return (void *)((XImage *)_p)->data;}
void set_XImage_data(void *_p, void *_v) {((XImage *)_p)->data = (char *)_v;}
int get_XImage_byte_order(void *_p) {return (int)((XImage *)_p)->byte_order;}
void set_XImage_byte_order(void *_p, int _v) {((XImage *)_p)->byte_order = (int)_v;}
int get_XImage_bitmap_unit(void *_p) {return (int)((XImage *)_p)->bitmap_unit;}
void set_XImage_bitmap_unit(void *_p, int _v) {((XImage *)_p)->bitmap_unit = (int)_v;}
int get_XImage_bitmap_bit_order(void *_p) {return (int)((XImage *)_p)->bitmap_bit_order;}
void set_XImage_bitmap_bit_order(void *_p, int _v) {((XImage *)_p)->bitmap_bit_order = (int)_v;}
int get_XImage_bitmap_pad(void *_p) {return (int)((XImage *)_p)->bitmap_pad;}
void set_XImage_bitmap_pad(void *_p, int _v) {((XImage *)_p)->bitmap_pad = (int)_v;}
int get_XImage_depth(void *_p) {return (int)((XImage *)_p)->depth;}
void set_XImage_depth(void *_p, int _v) {((XImage *)_p)->depth = (int)_v;}
int get_XImage_bytes_per_line(void *_p) {return (int)((XImage *)_p)->bytes_per_line;}
void set_XImage_bytes_per_line(void *_p, int _v) {((XImage *)_p)->bytes_per_line = (int)_v;}
int get_XImage_bits_per_pixel(void *_p) {return (int)((XImage *)_p)->bits_per_pixel;}
void set_XImage_bits_per_pixel(void *_p, int _v) {((XImage *)_p)->bits_per_pixel = (int)_v;}
unsigned long get_XImage_red_mask(void *_p) {return (unsigned long)((XImage *)_p)->red_mask;}
void set_XImage_red_mask(void *_p, unsigned long _v) {((XImage *)_p)->red_mask = (unsigned long)_v;}
unsigned long get_XImage_green_mask(void *_p) {return (unsigned long)((XImage *)_p)->green_mask;}
void set_XImage_green_mask(void *_p, unsigned long _v) {((XImage *)_p)->green_mask = (unsigned long)_v;}
unsigned long get_XImage_blue_mask(void *_p) {return (unsigned long)((XImage *)_p)->blue_mask;}
void set_XImage_blue_mask(void *_p, unsigned long _v) {((XImage *)_p)->blue_mask = (unsigned long)_v;}
void *get_XImage_obdata(void *_p) {return (void *)((XImage *)_p)->obdata;}
void set_XImage_obdata(void *_p, void *_v) {((XImage *)_p)->obdata = (char *)_v;}
void *get_XImage_f_create_image(void *_p) {return (void *)((XImage *)_p)->f.create_image;}
void set_XImage_f_create_image(void *_p, void *_v) {((XImage *)_p)->f.create_image = (XImage *( *)())_v;}
void *get_XImage_f_destroy_image(void *_p) {return (void *)((XImage *)_p)->f.destroy_image;}
void set_XImage_f_destroy_image(void *_p, void *_v) {((XImage *)_p)->f.destroy_image = (int( *)(XImage *))_v;}
void *get_XImage_f_get_pixel(void *_p) {return (void *)((XImage *)_p)->f.get_pixel;}
void set_XImage_f_get_pixel(void *_p, void *_v) {((XImage *)_p)->f.get_pixel = (unsigned long( *)(XImage *,int,int))_v;}
void *get_XImage_f_put_pixel(void *_p) {return (void *)((XImage *)_p)->f.put_pixel;}
void set_XImage_f_put_pixel(void *_p, void *_v) {((XImage *)_p)->f.put_pixel = (int( *)(XImage *,int,int,unsigned long))_v;}
void *get_XImage_f_sub_image(void *_p) {return (void *)((XImage *)_p)->f.sub_image;}
void set_XImage_f_sub_image(void *_p, void *_v) {((XImage *)_p)->f.sub_image = (XImage *( *)(XImage *,int,int,unsigned,unsigned))_v;}
void *get_XImage_f_add_pixel(void *_p) {return (void *)((XImage *)_p)->f.add_pixel;}
void set_XImage_f_add_pixel(void *_p, void *_v) {((XImage *)_p)->f.add_pixel = (int( *)(XImage *,long))_v;}
void *alloc_XWindowChanges(void) {XWindowChanges *_p = (XWindowChanges *)malloc(sizeof(XWindowChanges)); if (_p==NULL) abort(); return (void *)_p;}
void free_XWindowChanges(void *_p) {if (_p==NULL) abort(); free((XWindowChanges *)_p);}
int get_XWindowChanges_x(void *_p) {return (int)((XWindowChanges *)_p)->x;}
void set_XWindowChanges_x(void *_p, int _v) {((XWindowChanges *)_p)->x = (int)_v;}
int get_XWindowChanges_y(void *_p) {return (int)((XWindowChanges *)_p)->y;}
void set_XWindowChanges_y(void *_p, int _v) {((XWindowChanges *)_p)->y = (int)_v;}
int get_XWindowChanges_width(void *_p) {return (int)((XWindowChanges *)_p)->width;}
void set_XWindowChanges_width(void *_p, int _v) {((XWindowChanges *)_p)->width = (int)_v;}
int get_XWindowChanges_height(void *_p) {return (int)((XWindowChanges *)_p)->height;}
void set_XWindowChanges_height(void *_p, int _v) {((XWindowChanges *)_p)->height = (int)_v;}
int get_XWindowChanges_border_width(void *_p) {return (int)((XWindowChanges *)_p)->border_width;}
void set_XWindowChanges_border_width(void *_p, int _v) {((XWindowChanges *)_p)->border_width = (int)_v;}
unsigned long get_XWindowChanges_sibling(void *_p) {return (unsigned long)((XWindowChanges *)_p)->sibling;}
void set_XWindowChanges_sibling(void *_p, unsigned long _v) {((XWindowChanges *)_p)->sibling = (unsigned long)_v;}
int get_XWindowChanges_stack_mode(void *_p) {return (int)((XWindowChanges *)_p)->stack_mode;}
void set_XWindowChanges_stack_mode(void *_p, int _v) {((XWindowChanges *)_p)->stack_mode = (int)_v;}
void *alloc_XColor(void) {XColor *_p = (XColor *)malloc(sizeof(XColor)); if (_p==NULL) abort(); return (void *)_p;}
void free_XColor(void *_p) {if (_p==NULL) abort(); free((XColor *)_p);}
unsigned long get_XColor_pixel(void *_p) {return (unsigned long)((XColor *)_p)->pixel;}
void set_XColor_pixel(void *_p, unsigned long _v) {((XColor *)_p)->pixel = (unsigned long)_v;}
unsigned short get_XColor_red(void *_p) {return (unsigned short)((XColor *)_p)->red;}
void set_XColor_red(void *_p, unsigned short _v) {((XColor *)_p)->red = (unsigned short)_v;}
unsigned short get_XColor_green(void *_p) {return (unsigned short)((XColor *)_p)->green;}
void set_XColor_green(void *_p, unsigned short _v) {((XColor *)_p)->green = (unsigned short)_v;}
unsigned short get_XColor_blue(void *_p) {return (unsigned short)((XColor *)_p)->blue;}
void set_XColor_blue(void *_p, unsigned short _v) {((XColor *)_p)->blue = (unsigned short)_v;}
char get_XColor_flags(void *_p) {return (char)((XColor *)_p)->flags;}
void set_XColor_flags(void *_p, char _v) {((XColor *)_p)->flags = (char)_v;}
char get_XColor_pad(void *_p) {return (char)((XColor *)_p)->pad;}
void set_XColor_pad(void *_p, char _v) {((XColor *)_p)->pad = (char)_v;}
void *alloc_XSegment(void) {XSegment *_p = (XSegment *)malloc(sizeof(XSegment)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSegment(void *_p) {if (_p==NULL) abort(); free((XSegment *)_p);}
short get_XSegment_x1(void *_p) {return (short)((XSegment *)_p)->x1;}
void set_XSegment_x1(void *_p, short _v) {((XSegment *)_p)->x1 = (short)_v;}
short get_XSegment_y1(void *_p) {return (short)((XSegment *)_p)->y1;}
void set_XSegment_y1(void *_p, short _v) {((XSegment *)_p)->y1 = (short)_v;}
short get_XSegment_x2(void *_p) {return (short)((XSegment *)_p)->x2;}
void set_XSegment_x2(void *_p, short _v) {((XSegment *)_p)->x2 = (short)_v;}
short get_XSegment_y2(void *_p) {return (short)((XSegment *)_p)->y2;}
void set_XSegment_y2(void *_p, short _v) {((XSegment *)_p)->y2 = (short)_v;}
void *alloc_XPoint(void) {XPoint *_p = (XPoint *)malloc(sizeof(XPoint)); if (_p==NULL) abort(); return (void *)_p;}
void free_XPoint(void *_p) {if (_p==NULL) abort(); free((XPoint *)_p);}
short get_XPoint_x(void *_p) {return (short)((XPoint *)_p)->x;}
void set_XPoint_x(void *_p, short _v) {((XPoint *)_p)->x = (short)_v;}
short get_XPoint_y(void *_p) {return (short)((XPoint *)_p)->y;}
void set_XPoint_y(void *_p, short _v) {((XPoint *)_p)->y = (short)_v;}
void *alloc_XRectangle(void) {XRectangle *_p = (XRectangle *)malloc(sizeof(XRectangle)); if (_p==NULL) abort(); return (void *)_p;}
void free_XRectangle(void *_p) {if (_p==NULL) abort(); free((XRectangle *)_p);}
short get_XRectangle_x(void *_p) {return (short)((XRectangle *)_p)->x;}
void set_XRectangle_x(void *_p, short _v) {((XRectangle *)_p)->x = (short)_v;}
short get_XRectangle_y(void *_p) {return (short)((XRectangle *)_p)->y;}
void set_XRectangle_y(void *_p, short _v) {((XRectangle *)_p)->y = (short)_v;}
unsigned short get_XRectangle_width(void *_p) {return (unsigned short)((XRectangle *)_p)->width;}
void set_XRectangle_width(void *_p, unsigned short _v) {((XRectangle *)_p)->width = (unsigned short)_v;}
unsigned short get_XRectangle_height(void *_p) {return (unsigned short)((XRectangle *)_p)->height;}
void set_XRectangle_height(void *_p, unsigned short _v) {((XRectangle *)_p)->height = (unsigned short)_v;}
void *alloc_XArc(void) {XArc *_p = (XArc *)malloc(sizeof(XArc)); if (_p==NULL) abort(); return (void *)_p;}
void free_XArc(void *_p) {if (_p==NULL) abort(); free((XArc *)_p);}
short get_XArc_x(void *_p) {return (short)((XArc *)_p)->x;}
void set_XArc_x(void *_p, short _v) {((XArc *)_p)->x = (short)_v;}
short get_XArc_y(void *_p) {return (short)((XArc *)_p)->y;}
void set_XArc_y(void *_p, short _v) {((XArc *)_p)->y = (short)_v;}
unsigned short get_XArc_width(void *_p) {return (unsigned short)((XArc *)_p)->width;}
void set_XArc_width(void *_p, unsigned short _v) {((XArc *)_p)->width = (unsigned short)_v;}
unsigned short get_XArc_height(void *_p) {return (unsigned short)((XArc *)_p)->height;}
void set_XArc_height(void *_p, unsigned short _v) {((XArc *)_p)->height = (unsigned short)_v;}
short get_XArc_angle1(void *_p) {return (short)((XArc *)_p)->angle1;}
void set_XArc_angle1(void *_p, short _v) {((XArc *)_p)->angle1 = (short)_v;}
short get_XArc_angle2(void *_p) {return (short)((XArc *)_p)->angle2;}
void set_XArc_angle2(void *_p, short _v) {((XArc *)_p)->angle2 = (short)_v;}
void *alloc_XKeyboardControl(void) {XKeyboardControl *_p = (XKeyboardControl *)malloc(sizeof(XKeyboardControl)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeyboardControl(void *_p) {if (_p==NULL) abort(); free((XKeyboardControl *)_p);}
int get_XKeyboardControl_key_click_percent(void *_p) {return (int)((XKeyboardControl *)_p)->key_click_percent;}
void set_XKeyboardControl_key_click_percent(void *_p, int _v) {((XKeyboardControl *)_p)->key_click_percent = (int)_v;}
int get_XKeyboardControl_bell_percent(void *_p) {return (int)((XKeyboardControl *)_p)->bell_percent;}
void set_XKeyboardControl_bell_percent(void *_p, int _v) {((XKeyboardControl *)_p)->bell_percent = (int)_v;}
int get_XKeyboardControl_bell_pitch(void *_p) {return (int)((XKeyboardControl *)_p)->bell_pitch;}
void set_XKeyboardControl_bell_pitch(void *_p, int _v) {((XKeyboardControl *)_p)->bell_pitch = (int)_v;}
int get_XKeyboardControl_bell_duration(void *_p) {return (int)((XKeyboardControl *)_p)->bell_duration;}
void set_XKeyboardControl_bell_duration(void *_p, int _v) {((XKeyboardControl *)_p)->bell_duration = (int)_v;}
int get_XKeyboardControl_led(void *_p) {return (int)((XKeyboardControl *)_p)->led;}
void set_XKeyboardControl_led(void *_p, int _v) {((XKeyboardControl *)_p)->led = (int)_v;}
int get_XKeyboardControl_led_mode(void *_p) {return (int)((XKeyboardControl *)_p)->led_mode;}
void set_XKeyboardControl_led_mode(void *_p, int _v) {((XKeyboardControl *)_p)->led_mode = (int)_v;}
int get_XKeyboardControl_key(void *_p) {return (int)((XKeyboardControl *)_p)->key;}
void set_XKeyboardControl_key(void *_p, int _v) {((XKeyboardControl *)_p)->key = (int)_v;}
int get_XKeyboardControl_auto_repeat_mode(void *_p) {return (int)((XKeyboardControl *)_p)->auto_repeat_mode;}
void set_XKeyboardControl_auto_repeat_mode(void *_p, int _v) {((XKeyboardControl *)_p)->auto_repeat_mode = (int)_v;}
void *alloc_XKeyboardState(void) {XKeyboardState *_p = (XKeyboardState *)malloc(sizeof(XKeyboardState)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeyboardState(void *_p) {if (_p==NULL) abort(); free((XKeyboardState *)_p);}
int get_XKeyboardState_key_click_percent(void *_p) {return (int)((XKeyboardState *)_p)->key_click_percent;}
void set_XKeyboardState_key_click_percent(void *_p, int _v) {((XKeyboardState *)_p)->key_click_percent = (int)_v;}
int get_XKeyboardState_bell_percent(void *_p) {return (int)((XKeyboardState *)_p)->bell_percent;}
void set_XKeyboardState_bell_percent(void *_p, int _v) {((XKeyboardState *)_p)->bell_percent = (int)_v;}
unsigned get_XKeyboardState_bell_pitch(void *_p) {return (unsigned)((XKeyboardState *)_p)->bell_pitch;}
void set_XKeyboardState_bell_pitch(void *_p, unsigned _v) {((XKeyboardState *)_p)->bell_pitch = (unsigned)_v;}
unsigned get_XKeyboardState_bell_duration(void *_p) {return (unsigned)((XKeyboardState *)_p)->bell_duration;}
void set_XKeyboardState_bell_duration(void *_p, unsigned _v) {((XKeyboardState *)_p)->bell_duration = (unsigned)_v;}
unsigned long get_XKeyboardState_led_mask(void *_p) {return (unsigned long)((XKeyboardState *)_p)->led_mask;}
void set_XKeyboardState_led_mask(void *_p, unsigned long _v) {((XKeyboardState *)_p)->led_mask = (unsigned long)_v;}
int get_XKeyboardState_global_auto_repeat(void *_p) {return (int)((XKeyboardState *)_p)->global_auto_repeat;}
void set_XKeyboardState_global_auto_repeat(void *_p, int _v) {((XKeyboardState *)_p)->global_auto_repeat = (int)_v;}
void *get_XKeyboardState_auto_repeats(void *_p) {return (void *)(((XKeyboardState *)_p)->auto_repeats);}
void *alloc_XTimeCoord(void) {XTimeCoord *_p = (XTimeCoord *)malloc(sizeof(XTimeCoord)); if (_p==NULL) abort(); return (void *)_p;}
void free_XTimeCoord(void *_p) {if (_p==NULL) abort(); free((XTimeCoord *)_p);}
unsigned long get_XTimeCoord_time(void *_p) {return (unsigned long)((XTimeCoord *)_p)->time;}
void set_XTimeCoord_time(void *_p, unsigned long _v) {((XTimeCoord *)_p)->time = (unsigned long)_v;}
short get_XTimeCoord_x(void *_p) {return (short)((XTimeCoord *)_p)->x;}
void set_XTimeCoord_x(void *_p, short _v) {((XTimeCoord *)_p)->x = (short)_v;}
short get_XTimeCoord_y(void *_p) {return (short)((XTimeCoord *)_p)->y;}
void set_XTimeCoord_y(void *_p, short _v) {((XTimeCoord *)_p)->y = (short)_v;}
void *alloc_XModifierKeymap(void) {XModifierKeymap *_p = (XModifierKeymap *)malloc(sizeof(XModifierKeymap)); if (_p==NULL) abort(); return (void *)_p;}
void free_XModifierKeymap(void *_p) {if (_p==NULL) abort(); free((XModifierKeymap *)_p);}
int get_XModifierKeymap_max_keypermod(void *_p) {return (int)((XModifierKeymap *)_p)->max_keypermod;}
void set_XModifierKeymap_max_keypermod(void *_p, int _v) {((XModifierKeymap *)_p)->max_keypermod = (int)_v;}
void *get_XModifierKeymap_modifiermap(void *_p) {return (void *)((XModifierKeymap *)_p)->modifiermap;}
void set_XModifierKeymap_modifiermap(void *_p, void *_v) {((XModifierKeymap *)_p)->modifiermap = (unsigned char *)_v;}
void *alloc_XKeyReleasedEvent(void) {XKeyReleasedEvent *_p = (XKeyReleasedEvent *)malloc(sizeof(XKeyReleasedEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeyReleasedEvent(void *_p) {if (_p==NULL) abort(); free((XKeyReleasedEvent *)_p);}
int get_XKeyReleasedEvent_type(void *_p) {return (int)((XKeyReleasedEvent *)_p)->type;}
void set_XKeyReleasedEvent_type(void *_p, int _v) {((XKeyReleasedEvent *)_p)->type = (int)_v;}
unsigned long get_XKeyReleasedEvent_serial(void *_p) {return (unsigned long)((XKeyReleasedEvent *)_p)->serial;}
void set_XKeyReleasedEvent_serial(void *_p, unsigned long _v) {((XKeyReleasedEvent *)_p)->serial = (unsigned long)_v;}
int get_XKeyReleasedEvent_send_event(void *_p) {return (int)((XKeyReleasedEvent *)_p)->send_event;}
void set_XKeyReleasedEvent_send_event(void *_p, int _v) {((XKeyReleasedEvent *)_p)->send_event = (int)_v;}
void *get_XKeyReleasedEvent_display(void *_p) {return (void *)((XKeyReleasedEvent *)_p)->display;}
void set_XKeyReleasedEvent_display(void *_p, void *_v) {((XKeyReleasedEvent *)_p)->display = (Display *)_v;}
unsigned long get_XKeyReleasedEvent_window(void *_p) {return (unsigned long)((XKeyReleasedEvent *)_p)->window;}
void set_XKeyReleasedEvent_window(void *_p, unsigned long _v) {((XKeyReleasedEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XKeyReleasedEvent_root(void *_p) {return (unsigned long)((XKeyReleasedEvent *)_p)->root;}
void set_XKeyReleasedEvent_root(void *_p, unsigned long _v) {((XKeyReleasedEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XKeyReleasedEvent_subwindow(void *_p) {return (unsigned long)((XKeyReleasedEvent *)_p)->subwindow;}
void set_XKeyReleasedEvent_subwindow(void *_p, unsigned long _v) {((XKeyReleasedEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XKeyReleasedEvent_time(void *_p) {return (unsigned long)((XKeyReleasedEvent *)_p)->time;}
void set_XKeyReleasedEvent_time(void *_p, unsigned long _v) {((XKeyReleasedEvent *)_p)->time = (unsigned long)_v;}
int get_XKeyReleasedEvent_x(void *_p) {return (int)((XKeyReleasedEvent *)_p)->x;}
void set_XKeyReleasedEvent_x(void *_p, int _v) {((XKeyReleasedEvent *)_p)->x = (int)_v;}
int get_XKeyReleasedEvent_y(void *_p) {return (int)((XKeyReleasedEvent *)_p)->y;}
void set_XKeyReleasedEvent_y(void *_p, int _v) {((XKeyReleasedEvent *)_p)->y = (int)_v;}
int get_XKeyReleasedEvent_x_root(void *_p) {return (int)((XKeyReleasedEvent *)_p)->x_root;}
void set_XKeyReleasedEvent_x_root(void *_p, int _v) {((XKeyReleasedEvent *)_p)->x_root = (int)_v;}
int get_XKeyReleasedEvent_y_root(void *_p) {return (int)((XKeyReleasedEvent *)_p)->y_root;}
void set_XKeyReleasedEvent_y_root(void *_p, int _v) {((XKeyReleasedEvent *)_p)->y_root = (int)_v;}
unsigned get_XKeyReleasedEvent_state(void *_p) {return (unsigned)((XKeyReleasedEvent *)_p)->state;}
void set_XKeyReleasedEvent_state(void *_p, unsigned _v) {((XKeyReleasedEvent *)_p)->state = (unsigned)_v;}
unsigned get_XKeyReleasedEvent_keycode(void *_p) {return (unsigned)((XKeyReleasedEvent *)_p)->keycode;}
void set_XKeyReleasedEvent_keycode(void *_p, unsigned _v) {((XKeyReleasedEvent *)_p)->keycode = (unsigned)_v;}
int get_XKeyReleasedEvent_same_screen(void *_p) {return (int)((XKeyReleasedEvent *)_p)->same_screen;}
void set_XKeyReleasedEvent_same_screen(void *_p, int _v) {((XKeyReleasedEvent *)_p)->same_screen = (int)_v;}
void *alloc_XKeyPressedEvent(void) {XKeyPressedEvent *_p = (XKeyPressedEvent *)malloc(sizeof(XKeyPressedEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeyPressedEvent(void *_p) {if (_p==NULL) abort(); free((XKeyPressedEvent *)_p);}
int get_XKeyPressedEvent_type(void *_p) {return (int)((XKeyPressedEvent *)_p)->type;}
void set_XKeyPressedEvent_type(void *_p, int _v) {((XKeyPressedEvent *)_p)->type = (int)_v;}
unsigned long get_XKeyPressedEvent_serial(void *_p) {return (unsigned long)((XKeyPressedEvent *)_p)->serial;}
void set_XKeyPressedEvent_serial(void *_p, unsigned long _v) {((XKeyPressedEvent *)_p)->serial = (unsigned long)_v;}
int get_XKeyPressedEvent_send_event(void *_p) {return (int)((XKeyPressedEvent *)_p)->send_event;}
void set_XKeyPressedEvent_send_event(void *_p, int _v) {((XKeyPressedEvent *)_p)->send_event = (int)_v;}
void *get_XKeyPressedEvent_display(void *_p) {return (void *)((XKeyPressedEvent *)_p)->display;}
void set_XKeyPressedEvent_display(void *_p, void *_v) {((XKeyPressedEvent *)_p)->display = (Display *)_v;}
unsigned long get_XKeyPressedEvent_window(void *_p) {return (unsigned long)((XKeyPressedEvent *)_p)->window;}
void set_XKeyPressedEvent_window(void *_p, unsigned long _v) {((XKeyPressedEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XKeyPressedEvent_root(void *_p) {return (unsigned long)((XKeyPressedEvent *)_p)->root;}
void set_XKeyPressedEvent_root(void *_p, unsigned long _v) {((XKeyPressedEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XKeyPressedEvent_subwindow(void *_p) {return (unsigned long)((XKeyPressedEvent *)_p)->subwindow;}
void set_XKeyPressedEvent_subwindow(void *_p, unsigned long _v) {((XKeyPressedEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XKeyPressedEvent_time(void *_p) {return (unsigned long)((XKeyPressedEvent *)_p)->time;}
void set_XKeyPressedEvent_time(void *_p, unsigned long _v) {((XKeyPressedEvent *)_p)->time = (unsigned long)_v;}
int get_XKeyPressedEvent_x(void *_p) {return (int)((XKeyPressedEvent *)_p)->x;}
void set_XKeyPressedEvent_x(void *_p, int _v) {((XKeyPressedEvent *)_p)->x = (int)_v;}
int get_XKeyPressedEvent_y(void *_p) {return (int)((XKeyPressedEvent *)_p)->y;}
void set_XKeyPressedEvent_y(void *_p, int _v) {((XKeyPressedEvent *)_p)->y = (int)_v;}
int get_XKeyPressedEvent_x_root(void *_p) {return (int)((XKeyPressedEvent *)_p)->x_root;}
void set_XKeyPressedEvent_x_root(void *_p, int _v) {((XKeyPressedEvent *)_p)->x_root = (int)_v;}
int get_XKeyPressedEvent_y_root(void *_p) {return (int)((XKeyPressedEvent *)_p)->y_root;}
void set_XKeyPressedEvent_y_root(void *_p, int _v) {((XKeyPressedEvent *)_p)->y_root = (int)_v;}
unsigned get_XKeyPressedEvent_state(void *_p) {return (unsigned)((XKeyPressedEvent *)_p)->state;}
void set_XKeyPressedEvent_state(void *_p, unsigned _v) {((XKeyPressedEvent *)_p)->state = (unsigned)_v;}
unsigned get_XKeyPressedEvent_keycode(void *_p) {return (unsigned)((XKeyPressedEvent *)_p)->keycode;}
void set_XKeyPressedEvent_keycode(void *_p, unsigned _v) {((XKeyPressedEvent *)_p)->keycode = (unsigned)_v;}
int get_XKeyPressedEvent_same_screen(void *_p) {return (int)((XKeyPressedEvent *)_p)->same_screen;}
void set_XKeyPressedEvent_same_screen(void *_p, int _v) {((XKeyPressedEvent *)_p)->same_screen = (int)_v;}
void *alloc_XKeyEvent(void) {XKeyEvent *_p = (XKeyEvent *)malloc(sizeof(XKeyEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeyEvent(void *_p) {if (_p==NULL) abort(); free((XKeyEvent *)_p);}
int get_XKeyEvent_type(void *_p) {return (int)((XKeyEvent *)_p)->type;}
void set_XKeyEvent_type(void *_p, int _v) {((XKeyEvent *)_p)->type = (int)_v;}
unsigned long get_XKeyEvent_serial(void *_p) {return (unsigned long)((XKeyEvent *)_p)->serial;}
void set_XKeyEvent_serial(void *_p, unsigned long _v) {((XKeyEvent *)_p)->serial = (unsigned long)_v;}
int get_XKeyEvent_send_event(void *_p) {return (int)((XKeyEvent *)_p)->send_event;}
void set_XKeyEvent_send_event(void *_p, int _v) {((XKeyEvent *)_p)->send_event = (int)_v;}
void *get_XKeyEvent_display(void *_p) {return (void *)((XKeyEvent *)_p)->display;}
void set_XKeyEvent_display(void *_p, void *_v) {((XKeyEvent *)_p)->display = (Display *)_v;}
unsigned long get_XKeyEvent_window(void *_p) {return (unsigned long)((XKeyEvent *)_p)->window;}
void set_XKeyEvent_window(void *_p, unsigned long _v) {((XKeyEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XKeyEvent_root(void *_p) {return (unsigned long)((XKeyEvent *)_p)->root;}
void set_XKeyEvent_root(void *_p, unsigned long _v) {((XKeyEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XKeyEvent_subwindow(void *_p) {return (unsigned long)((XKeyEvent *)_p)->subwindow;}
void set_XKeyEvent_subwindow(void *_p, unsigned long _v) {((XKeyEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XKeyEvent_time(void *_p) {return (unsigned long)((XKeyEvent *)_p)->time;}
void set_XKeyEvent_time(void *_p, unsigned long _v) {((XKeyEvent *)_p)->time = (unsigned long)_v;}
int get_XKeyEvent_x(void *_p) {return (int)((XKeyEvent *)_p)->x;}
void set_XKeyEvent_x(void *_p, int _v) {((XKeyEvent *)_p)->x = (int)_v;}
int get_XKeyEvent_y(void *_p) {return (int)((XKeyEvent *)_p)->y;}
void set_XKeyEvent_y(void *_p, int _v) {((XKeyEvent *)_p)->y = (int)_v;}
int get_XKeyEvent_x_root(void *_p) {return (int)((XKeyEvent *)_p)->x_root;}
void set_XKeyEvent_x_root(void *_p, int _v) {((XKeyEvent *)_p)->x_root = (int)_v;}
int get_XKeyEvent_y_root(void *_p) {return (int)((XKeyEvent *)_p)->y_root;}
void set_XKeyEvent_y_root(void *_p, int _v) {((XKeyEvent *)_p)->y_root = (int)_v;}
unsigned get_XKeyEvent_state(void *_p) {return (unsigned)((XKeyEvent *)_p)->state;}
void set_XKeyEvent_state(void *_p, unsigned _v) {((XKeyEvent *)_p)->state = (unsigned)_v;}
unsigned get_XKeyEvent_keycode(void *_p) {return (unsigned)((XKeyEvent *)_p)->keycode;}
void set_XKeyEvent_keycode(void *_p, unsigned _v) {((XKeyEvent *)_p)->keycode = (unsigned)_v;}
int get_XKeyEvent_same_screen(void *_p) {return (int)((XKeyEvent *)_p)->same_screen;}
void set_XKeyEvent_same_screen(void *_p, int _v) {((XKeyEvent *)_p)->same_screen = (int)_v;}
void *alloc_XButtonReleasedEvent(void) {XButtonReleasedEvent *_p = (XButtonReleasedEvent *)malloc(sizeof(XButtonReleasedEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XButtonReleasedEvent(void *_p) {if (_p==NULL) abort(); free((XButtonReleasedEvent *)_p);}
int get_XButtonReleasedEvent_type(void *_p) {return (int)((XButtonReleasedEvent *)_p)->type;}
void set_XButtonReleasedEvent_type(void *_p, int _v) {((XButtonReleasedEvent *)_p)->type = (int)_v;}
unsigned long get_XButtonReleasedEvent_serial(void *_p) {return (unsigned long)((XButtonReleasedEvent *)_p)->serial;}
void set_XButtonReleasedEvent_serial(void *_p, unsigned long _v) {((XButtonReleasedEvent *)_p)->serial = (unsigned long)_v;}
int get_XButtonReleasedEvent_send_event(void *_p) {return (int)((XButtonReleasedEvent *)_p)->send_event;}
void set_XButtonReleasedEvent_send_event(void *_p, int _v) {((XButtonReleasedEvent *)_p)->send_event = (int)_v;}
void *get_XButtonReleasedEvent_display(void *_p) {return (void *)((XButtonReleasedEvent *)_p)->display;}
void set_XButtonReleasedEvent_display(void *_p, void *_v) {((XButtonReleasedEvent *)_p)->display = (Display *)_v;}
unsigned long get_XButtonReleasedEvent_window(void *_p) {return (unsigned long)((XButtonReleasedEvent *)_p)->window;}
void set_XButtonReleasedEvent_window(void *_p, unsigned long _v) {((XButtonReleasedEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XButtonReleasedEvent_root(void *_p) {return (unsigned long)((XButtonReleasedEvent *)_p)->root;}
void set_XButtonReleasedEvent_root(void *_p, unsigned long _v) {((XButtonReleasedEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XButtonReleasedEvent_subwindow(void *_p) {return (unsigned long)((XButtonReleasedEvent *)_p)->subwindow;}
void set_XButtonReleasedEvent_subwindow(void *_p, unsigned long _v) {((XButtonReleasedEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XButtonReleasedEvent_time(void *_p) {return (unsigned long)((XButtonReleasedEvent *)_p)->time;}
void set_XButtonReleasedEvent_time(void *_p, unsigned long _v) {((XButtonReleasedEvent *)_p)->time = (unsigned long)_v;}
int get_XButtonReleasedEvent_x(void *_p) {return (int)((XButtonReleasedEvent *)_p)->x;}
void set_XButtonReleasedEvent_x(void *_p, int _v) {((XButtonReleasedEvent *)_p)->x = (int)_v;}
int get_XButtonReleasedEvent_y(void *_p) {return (int)((XButtonReleasedEvent *)_p)->y;}
void set_XButtonReleasedEvent_y(void *_p, int _v) {((XButtonReleasedEvent *)_p)->y = (int)_v;}
int get_XButtonReleasedEvent_x_root(void *_p) {return (int)((XButtonReleasedEvent *)_p)->x_root;}
void set_XButtonReleasedEvent_x_root(void *_p, int _v) {((XButtonReleasedEvent *)_p)->x_root = (int)_v;}
int get_XButtonReleasedEvent_y_root(void *_p) {return (int)((XButtonReleasedEvent *)_p)->y_root;}
void set_XButtonReleasedEvent_y_root(void *_p, int _v) {((XButtonReleasedEvent *)_p)->y_root = (int)_v;}
unsigned get_XButtonReleasedEvent_state(void *_p) {return (unsigned)((XButtonReleasedEvent *)_p)->state;}
void set_XButtonReleasedEvent_state(void *_p, unsigned _v) {((XButtonReleasedEvent *)_p)->state = (unsigned)_v;}
unsigned get_XButtonReleasedEvent_button(void *_p) {return (unsigned)((XButtonReleasedEvent *)_p)->button;}
void set_XButtonReleasedEvent_button(void *_p, unsigned _v) {((XButtonReleasedEvent *)_p)->button = (unsigned)_v;}
int get_XButtonReleasedEvent_same_screen(void *_p) {return (int)((XButtonReleasedEvent *)_p)->same_screen;}
void set_XButtonReleasedEvent_same_screen(void *_p, int _v) {((XButtonReleasedEvent *)_p)->same_screen = (int)_v;}
void *alloc_XButtonPressedEvent(void) {XButtonPressedEvent *_p = (XButtonPressedEvent *)malloc(sizeof(XButtonPressedEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XButtonPressedEvent(void *_p) {if (_p==NULL) abort(); free((XButtonPressedEvent *)_p);}
int get_XButtonPressedEvent_type(void *_p) {return (int)((XButtonPressedEvent *)_p)->type;}
void set_XButtonPressedEvent_type(void *_p, int _v) {((XButtonPressedEvent *)_p)->type = (int)_v;}
unsigned long get_XButtonPressedEvent_serial(void *_p) {return (unsigned long)((XButtonPressedEvent *)_p)->serial;}
void set_XButtonPressedEvent_serial(void *_p, unsigned long _v) {((XButtonPressedEvent *)_p)->serial = (unsigned long)_v;}
int get_XButtonPressedEvent_send_event(void *_p) {return (int)((XButtonPressedEvent *)_p)->send_event;}
void set_XButtonPressedEvent_send_event(void *_p, int _v) {((XButtonPressedEvent *)_p)->send_event = (int)_v;}
void *get_XButtonPressedEvent_display(void *_p) {return (void *)((XButtonPressedEvent *)_p)->display;}
void set_XButtonPressedEvent_display(void *_p, void *_v) {((XButtonPressedEvent *)_p)->display = (Display *)_v;}
unsigned long get_XButtonPressedEvent_window(void *_p) {return (unsigned long)((XButtonPressedEvent *)_p)->window;}
void set_XButtonPressedEvent_window(void *_p, unsigned long _v) {((XButtonPressedEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XButtonPressedEvent_root(void *_p) {return (unsigned long)((XButtonPressedEvent *)_p)->root;}
void set_XButtonPressedEvent_root(void *_p, unsigned long _v) {((XButtonPressedEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XButtonPressedEvent_subwindow(void *_p) {return (unsigned long)((XButtonPressedEvent *)_p)->subwindow;}
void set_XButtonPressedEvent_subwindow(void *_p, unsigned long _v) {((XButtonPressedEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XButtonPressedEvent_time(void *_p) {return (unsigned long)((XButtonPressedEvent *)_p)->time;}
void set_XButtonPressedEvent_time(void *_p, unsigned long _v) {((XButtonPressedEvent *)_p)->time = (unsigned long)_v;}
int get_XButtonPressedEvent_x(void *_p) {return (int)((XButtonPressedEvent *)_p)->x;}
void set_XButtonPressedEvent_x(void *_p, int _v) {((XButtonPressedEvent *)_p)->x = (int)_v;}
int get_XButtonPressedEvent_y(void *_p) {return (int)((XButtonPressedEvent *)_p)->y;}
void set_XButtonPressedEvent_y(void *_p, int _v) {((XButtonPressedEvent *)_p)->y = (int)_v;}
int get_XButtonPressedEvent_x_root(void *_p) {return (int)((XButtonPressedEvent *)_p)->x_root;}
void set_XButtonPressedEvent_x_root(void *_p, int _v) {((XButtonPressedEvent *)_p)->x_root = (int)_v;}
int get_XButtonPressedEvent_y_root(void *_p) {return (int)((XButtonPressedEvent *)_p)->y_root;}
void set_XButtonPressedEvent_y_root(void *_p, int _v) {((XButtonPressedEvent *)_p)->y_root = (int)_v;}
unsigned get_XButtonPressedEvent_state(void *_p) {return (unsigned)((XButtonPressedEvent *)_p)->state;}
void set_XButtonPressedEvent_state(void *_p, unsigned _v) {((XButtonPressedEvent *)_p)->state = (unsigned)_v;}
unsigned get_XButtonPressedEvent_button(void *_p) {return (unsigned)((XButtonPressedEvent *)_p)->button;}
void set_XButtonPressedEvent_button(void *_p, unsigned _v) {((XButtonPressedEvent *)_p)->button = (unsigned)_v;}
int get_XButtonPressedEvent_same_screen(void *_p) {return (int)((XButtonPressedEvent *)_p)->same_screen;}
void set_XButtonPressedEvent_same_screen(void *_p, int _v) {((XButtonPressedEvent *)_p)->same_screen = (int)_v;}
void *alloc_XButtonEvent(void) {XButtonEvent *_p = (XButtonEvent *)malloc(sizeof(XButtonEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XButtonEvent(void *_p) {if (_p==NULL) abort(); free((XButtonEvent *)_p);}
int get_XButtonEvent_type(void *_p) {return (int)((XButtonEvent *)_p)->type;}
void set_XButtonEvent_type(void *_p, int _v) {((XButtonEvent *)_p)->type = (int)_v;}
unsigned long get_XButtonEvent_serial(void *_p) {return (unsigned long)((XButtonEvent *)_p)->serial;}
void set_XButtonEvent_serial(void *_p, unsigned long _v) {((XButtonEvent *)_p)->serial = (unsigned long)_v;}
int get_XButtonEvent_send_event(void *_p) {return (int)((XButtonEvent *)_p)->send_event;}
void set_XButtonEvent_send_event(void *_p, int _v) {((XButtonEvent *)_p)->send_event = (int)_v;}
void *get_XButtonEvent_display(void *_p) {return (void *)((XButtonEvent *)_p)->display;}
void set_XButtonEvent_display(void *_p, void *_v) {((XButtonEvent *)_p)->display = (Display *)_v;}
unsigned long get_XButtonEvent_window(void *_p) {return (unsigned long)((XButtonEvent *)_p)->window;}
void set_XButtonEvent_window(void *_p, unsigned long _v) {((XButtonEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XButtonEvent_root(void *_p) {return (unsigned long)((XButtonEvent *)_p)->root;}
void set_XButtonEvent_root(void *_p, unsigned long _v) {((XButtonEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XButtonEvent_subwindow(void *_p) {return (unsigned long)((XButtonEvent *)_p)->subwindow;}
void set_XButtonEvent_subwindow(void *_p, unsigned long _v) {((XButtonEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XButtonEvent_time(void *_p) {return (unsigned long)((XButtonEvent *)_p)->time;}
void set_XButtonEvent_time(void *_p, unsigned long _v) {((XButtonEvent *)_p)->time = (unsigned long)_v;}
int get_XButtonEvent_x(void *_p) {return (int)((XButtonEvent *)_p)->x;}
void set_XButtonEvent_x(void *_p, int _v) {((XButtonEvent *)_p)->x = (int)_v;}
int get_XButtonEvent_y(void *_p) {return (int)((XButtonEvent *)_p)->y;}
void set_XButtonEvent_y(void *_p, int _v) {((XButtonEvent *)_p)->y = (int)_v;}
int get_XButtonEvent_x_root(void *_p) {return (int)((XButtonEvent *)_p)->x_root;}
void set_XButtonEvent_x_root(void *_p, int _v) {((XButtonEvent *)_p)->x_root = (int)_v;}
int get_XButtonEvent_y_root(void *_p) {return (int)((XButtonEvent *)_p)->y_root;}
void set_XButtonEvent_y_root(void *_p, int _v) {((XButtonEvent *)_p)->y_root = (int)_v;}
unsigned get_XButtonEvent_state(void *_p) {return (unsigned)((XButtonEvent *)_p)->state;}
void set_XButtonEvent_state(void *_p, unsigned _v) {((XButtonEvent *)_p)->state = (unsigned)_v;}
unsigned get_XButtonEvent_button(void *_p) {return (unsigned)((XButtonEvent *)_p)->button;}
void set_XButtonEvent_button(void *_p, unsigned _v) {((XButtonEvent *)_p)->button = (unsigned)_v;}
int get_XButtonEvent_same_screen(void *_p) {return (int)((XButtonEvent *)_p)->same_screen;}
void set_XButtonEvent_same_screen(void *_p, int _v) {((XButtonEvent *)_p)->same_screen = (int)_v;}
void *alloc_XPointerMovedEvent(void) {XPointerMovedEvent *_p = (XPointerMovedEvent *)malloc(sizeof(XPointerMovedEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XPointerMovedEvent(void *_p) {if (_p==NULL) abort(); free((XPointerMovedEvent *)_p);}
int get_XPointerMovedEvent_type(void *_p) {return (int)((XPointerMovedEvent *)_p)->type;}
void set_XPointerMovedEvent_type(void *_p, int _v) {((XPointerMovedEvent *)_p)->type = (int)_v;}
unsigned long get_XPointerMovedEvent_serial(void *_p) {return (unsigned long)((XPointerMovedEvent *)_p)->serial;}
void set_XPointerMovedEvent_serial(void *_p, unsigned long _v) {((XPointerMovedEvent *)_p)->serial = (unsigned long)_v;}
int get_XPointerMovedEvent_send_event(void *_p) {return (int)((XPointerMovedEvent *)_p)->send_event;}
void set_XPointerMovedEvent_send_event(void *_p, int _v) {((XPointerMovedEvent *)_p)->send_event = (int)_v;}
void *get_XPointerMovedEvent_display(void *_p) {return (void *)((XPointerMovedEvent *)_p)->display;}
void set_XPointerMovedEvent_display(void *_p, void *_v) {((XPointerMovedEvent *)_p)->display = (Display *)_v;}
unsigned long get_XPointerMovedEvent_window(void *_p) {return (unsigned long)((XPointerMovedEvent *)_p)->window;}
void set_XPointerMovedEvent_window(void *_p, unsigned long _v) {((XPointerMovedEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XPointerMovedEvent_root(void *_p) {return (unsigned long)((XPointerMovedEvent *)_p)->root;}
void set_XPointerMovedEvent_root(void *_p, unsigned long _v) {((XPointerMovedEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XPointerMovedEvent_subwindow(void *_p) {return (unsigned long)((XPointerMovedEvent *)_p)->subwindow;}
void set_XPointerMovedEvent_subwindow(void *_p, unsigned long _v) {((XPointerMovedEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XPointerMovedEvent_time(void *_p) {return (unsigned long)((XPointerMovedEvent *)_p)->time;}
void set_XPointerMovedEvent_time(void *_p, unsigned long _v) {((XPointerMovedEvent *)_p)->time = (unsigned long)_v;}
int get_XPointerMovedEvent_x(void *_p) {return (int)((XPointerMovedEvent *)_p)->x;}
void set_XPointerMovedEvent_x(void *_p, int _v) {((XPointerMovedEvent *)_p)->x = (int)_v;}
int get_XPointerMovedEvent_y(void *_p) {return (int)((XPointerMovedEvent *)_p)->y;}
void set_XPointerMovedEvent_y(void *_p, int _v) {((XPointerMovedEvent *)_p)->y = (int)_v;}
int get_XPointerMovedEvent_x_root(void *_p) {return (int)((XPointerMovedEvent *)_p)->x_root;}
void set_XPointerMovedEvent_x_root(void *_p, int _v) {((XPointerMovedEvent *)_p)->x_root = (int)_v;}
int get_XPointerMovedEvent_y_root(void *_p) {return (int)((XPointerMovedEvent *)_p)->y_root;}
void set_XPointerMovedEvent_y_root(void *_p, int _v) {((XPointerMovedEvent *)_p)->y_root = (int)_v;}
unsigned get_XPointerMovedEvent_state(void *_p) {return (unsigned)((XPointerMovedEvent *)_p)->state;}
void set_XPointerMovedEvent_state(void *_p, unsigned _v) {((XPointerMovedEvent *)_p)->state = (unsigned)_v;}
char get_XPointerMovedEvent_is_hint(void *_p) {return (char)((XPointerMovedEvent *)_p)->is_hint;}
void set_XPointerMovedEvent_is_hint(void *_p, char _v) {((XPointerMovedEvent *)_p)->is_hint = (char)_v;}
int get_XPointerMovedEvent_same_screen(void *_p) {return (int)((XPointerMovedEvent *)_p)->same_screen;}
void set_XPointerMovedEvent_same_screen(void *_p, int _v) {((XPointerMovedEvent *)_p)->same_screen = (int)_v;}
void *alloc_XMotionEvent(void) {XMotionEvent *_p = (XMotionEvent *)malloc(sizeof(XMotionEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XMotionEvent(void *_p) {if (_p==NULL) abort(); free((XMotionEvent *)_p);}
int get_XMotionEvent_type(void *_p) {return (int)((XMotionEvent *)_p)->type;}
void set_XMotionEvent_type(void *_p, int _v) {((XMotionEvent *)_p)->type = (int)_v;}
unsigned long get_XMotionEvent_serial(void *_p) {return (unsigned long)((XMotionEvent *)_p)->serial;}
void set_XMotionEvent_serial(void *_p, unsigned long _v) {((XMotionEvent *)_p)->serial = (unsigned long)_v;}
int get_XMotionEvent_send_event(void *_p) {return (int)((XMotionEvent *)_p)->send_event;}
void set_XMotionEvent_send_event(void *_p, int _v) {((XMotionEvent *)_p)->send_event = (int)_v;}
void *get_XMotionEvent_display(void *_p) {return (void *)((XMotionEvent *)_p)->display;}
void set_XMotionEvent_display(void *_p, void *_v) {((XMotionEvent *)_p)->display = (Display *)_v;}
unsigned long get_XMotionEvent_window(void *_p) {return (unsigned long)((XMotionEvent *)_p)->window;}
void set_XMotionEvent_window(void *_p, unsigned long _v) {((XMotionEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XMotionEvent_root(void *_p) {return (unsigned long)((XMotionEvent *)_p)->root;}
void set_XMotionEvent_root(void *_p, unsigned long _v) {((XMotionEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XMotionEvent_subwindow(void *_p) {return (unsigned long)((XMotionEvent *)_p)->subwindow;}
void set_XMotionEvent_subwindow(void *_p, unsigned long _v) {((XMotionEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XMotionEvent_time(void *_p) {return (unsigned long)((XMotionEvent *)_p)->time;}
void set_XMotionEvent_time(void *_p, unsigned long _v) {((XMotionEvent *)_p)->time = (unsigned long)_v;}
int get_XMotionEvent_x(void *_p) {return (int)((XMotionEvent *)_p)->x;}
void set_XMotionEvent_x(void *_p, int _v) {((XMotionEvent *)_p)->x = (int)_v;}
int get_XMotionEvent_y(void *_p) {return (int)((XMotionEvent *)_p)->y;}
void set_XMotionEvent_y(void *_p, int _v) {((XMotionEvent *)_p)->y = (int)_v;}
int get_XMotionEvent_x_root(void *_p) {return (int)((XMotionEvent *)_p)->x_root;}
void set_XMotionEvent_x_root(void *_p, int _v) {((XMotionEvent *)_p)->x_root = (int)_v;}
int get_XMotionEvent_y_root(void *_p) {return (int)((XMotionEvent *)_p)->y_root;}
void set_XMotionEvent_y_root(void *_p, int _v) {((XMotionEvent *)_p)->y_root = (int)_v;}
unsigned get_XMotionEvent_state(void *_p) {return (unsigned)((XMotionEvent *)_p)->state;}
void set_XMotionEvent_state(void *_p, unsigned _v) {((XMotionEvent *)_p)->state = (unsigned)_v;}
char get_XMotionEvent_is_hint(void *_p) {return (char)((XMotionEvent *)_p)->is_hint;}
void set_XMotionEvent_is_hint(void *_p, char _v) {((XMotionEvent *)_p)->is_hint = (char)_v;}
int get_XMotionEvent_same_screen(void *_p) {return (int)((XMotionEvent *)_p)->same_screen;}
void set_XMotionEvent_same_screen(void *_p, int _v) {((XMotionEvent *)_p)->same_screen = (int)_v;}
void *alloc_XLeaveWindowEvent(void) {XLeaveWindowEvent *_p = (XLeaveWindowEvent *)malloc(sizeof(XLeaveWindowEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XLeaveWindowEvent(void *_p) {if (_p==NULL) abort(); free((XLeaveWindowEvent *)_p);}
int get_XLeaveWindowEvent_type(void *_p) {return (int)((XLeaveWindowEvent *)_p)->type;}
void set_XLeaveWindowEvent_type(void *_p, int _v) {((XLeaveWindowEvent *)_p)->type = (int)_v;}
unsigned long get_XLeaveWindowEvent_serial(void *_p) {return (unsigned long)((XLeaveWindowEvent *)_p)->serial;}
void set_XLeaveWindowEvent_serial(void *_p, unsigned long _v) {((XLeaveWindowEvent *)_p)->serial = (unsigned long)_v;}
int get_XLeaveWindowEvent_send_event(void *_p) {return (int)((XLeaveWindowEvent *)_p)->send_event;}
void set_XLeaveWindowEvent_send_event(void *_p, int _v) {((XLeaveWindowEvent *)_p)->send_event = (int)_v;}
void *get_XLeaveWindowEvent_display(void *_p) {return (void *)((XLeaveWindowEvent *)_p)->display;}
void set_XLeaveWindowEvent_display(void *_p, void *_v) {((XLeaveWindowEvent *)_p)->display = (Display *)_v;}
unsigned long get_XLeaveWindowEvent_window(void *_p) {return (unsigned long)((XLeaveWindowEvent *)_p)->window;}
void set_XLeaveWindowEvent_window(void *_p, unsigned long _v) {((XLeaveWindowEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XLeaveWindowEvent_root(void *_p) {return (unsigned long)((XLeaveWindowEvent *)_p)->root;}
void set_XLeaveWindowEvent_root(void *_p, unsigned long _v) {((XLeaveWindowEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XLeaveWindowEvent_subwindow(void *_p) {return (unsigned long)((XLeaveWindowEvent *)_p)->subwindow;}
void set_XLeaveWindowEvent_subwindow(void *_p, unsigned long _v) {((XLeaveWindowEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XLeaveWindowEvent_time(void *_p) {return (unsigned long)((XLeaveWindowEvent *)_p)->time;}
void set_XLeaveWindowEvent_time(void *_p, unsigned long _v) {((XLeaveWindowEvent *)_p)->time = (unsigned long)_v;}
int get_XLeaveWindowEvent_x(void *_p) {return (int)((XLeaveWindowEvent *)_p)->x;}
void set_XLeaveWindowEvent_x(void *_p, int _v) {((XLeaveWindowEvent *)_p)->x = (int)_v;}
int get_XLeaveWindowEvent_y(void *_p) {return (int)((XLeaveWindowEvent *)_p)->y;}
void set_XLeaveWindowEvent_y(void *_p, int _v) {((XLeaveWindowEvent *)_p)->y = (int)_v;}
int get_XLeaveWindowEvent_x_root(void *_p) {return (int)((XLeaveWindowEvent *)_p)->x_root;}
void set_XLeaveWindowEvent_x_root(void *_p, int _v) {((XLeaveWindowEvent *)_p)->x_root = (int)_v;}
int get_XLeaveWindowEvent_y_root(void *_p) {return (int)((XLeaveWindowEvent *)_p)->y_root;}
void set_XLeaveWindowEvent_y_root(void *_p, int _v) {((XLeaveWindowEvent *)_p)->y_root = (int)_v;}
int get_XLeaveWindowEvent_mode(void *_p) {return (int)((XLeaveWindowEvent *)_p)->mode;}
void set_XLeaveWindowEvent_mode(void *_p, int _v) {((XLeaveWindowEvent *)_p)->mode = (int)_v;}
int get_XLeaveWindowEvent_detail(void *_p) {return (int)((XLeaveWindowEvent *)_p)->detail;}
void set_XLeaveWindowEvent_detail(void *_p, int _v) {((XLeaveWindowEvent *)_p)->detail = (int)_v;}
int get_XLeaveWindowEvent_same_screen(void *_p) {return (int)((XLeaveWindowEvent *)_p)->same_screen;}
void set_XLeaveWindowEvent_same_screen(void *_p, int _v) {((XLeaveWindowEvent *)_p)->same_screen = (int)_v;}
int get_XLeaveWindowEvent_focus(void *_p) {return (int)((XLeaveWindowEvent *)_p)->focus;}
void set_XLeaveWindowEvent_focus(void *_p, int _v) {((XLeaveWindowEvent *)_p)->focus = (int)_v;}
unsigned get_XLeaveWindowEvent_state(void *_p) {return (unsigned)((XLeaveWindowEvent *)_p)->state;}
void set_XLeaveWindowEvent_state(void *_p, unsigned _v) {((XLeaveWindowEvent *)_p)->state = (unsigned)_v;}
void *alloc_XEnterWindowEvent(void) {XEnterWindowEvent *_p = (XEnterWindowEvent *)malloc(sizeof(XEnterWindowEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XEnterWindowEvent(void *_p) {if (_p==NULL) abort(); free((XEnterWindowEvent *)_p);}
int get_XEnterWindowEvent_type(void *_p) {return (int)((XEnterWindowEvent *)_p)->type;}
void set_XEnterWindowEvent_type(void *_p, int _v) {((XEnterWindowEvent *)_p)->type = (int)_v;}
unsigned long get_XEnterWindowEvent_serial(void *_p) {return (unsigned long)((XEnterWindowEvent *)_p)->serial;}
void set_XEnterWindowEvent_serial(void *_p, unsigned long _v) {((XEnterWindowEvent *)_p)->serial = (unsigned long)_v;}
int get_XEnterWindowEvent_send_event(void *_p) {return (int)((XEnterWindowEvent *)_p)->send_event;}
void set_XEnterWindowEvent_send_event(void *_p, int _v) {((XEnterWindowEvent *)_p)->send_event = (int)_v;}
void *get_XEnterWindowEvent_display(void *_p) {return (void *)((XEnterWindowEvent *)_p)->display;}
void set_XEnterWindowEvent_display(void *_p, void *_v) {((XEnterWindowEvent *)_p)->display = (Display *)_v;}
unsigned long get_XEnterWindowEvent_window(void *_p) {return (unsigned long)((XEnterWindowEvent *)_p)->window;}
void set_XEnterWindowEvent_window(void *_p, unsigned long _v) {((XEnterWindowEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XEnterWindowEvent_root(void *_p) {return (unsigned long)((XEnterWindowEvent *)_p)->root;}
void set_XEnterWindowEvent_root(void *_p, unsigned long _v) {((XEnterWindowEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XEnterWindowEvent_subwindow(void *_p) {return (unsigned long)((XEnterWindowEvent *)_p)->subwindow;}
void set_XEnterWindowEvent_subwindow(void *_p, unsigned long _v) {((XEnterWindowEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XEnterWindowEvent_time(void *_p) {return (unsigned long)((XEnterWindowEvent *)_p)->time;}
void set_XEnterWindowEvent_time(void *_p, unsigned long _v) {((XEnterWindowEvent *)_p)->time = (unsigned long)_v;}
int get_XEnterWindowEvent_x(void *_p) {return (int)((XEnterWindowEvent *)_p)->x;}
void set_XEnterWindowEvent_x(void *_p, int _v) {((XEnterWindowEvent *)_p)->x = (int)_v;}
int get_XEnterWindowEvent_y(void *_p) {return (int)((XEnterWindowEvent *)_p)->y;}
void set_XEnterWindowEvent_y(void *_p, int _v) {((XEnterWindowEvent *)_p)->y = (int)_v;}
int get_XEnterWindowEvent_x_root(void *_p) {return (int)((XEnterWindowEvent *)_p)->x_root;}
void set_XEnterWindowEvent_x_root(void *_p, int _v) {((XEnterWindowEvent *)_p)->x_root = (int)_v;}
int get_XEnterWindowEvent_y_root(void *_p) {return (int)((XEnterWindowEvent *)_p)->y_root;}
void set_XEnterWindowEvent_y_root(void *_p, int _v) {((XEnterWindowEvent *)_p)->y_root = (int)_v;}
int get_XEnterWindowEvent_mode(void *_p) {return (int)((XEnterWindowEvent *)_p)->mode;}
void set_XEnterWindowEvent_mode(void *_p, int _v) {((XEnterWindowEvent *)_p)->mode = (int)_v;}
int get_XEnterWindowEvent_detail(void *_p) {return (int)((XEnterWindowEvent *)_p)->detail;}
void set_XEnterWindowEvent_detail(void *_p, int _v) {((XEnterWindowEvent *)_p)->detail = (int)_v;}
int get_XEnterWindowEvent_same_screen(void *_p) {return (int)((XEnterWindowEvent *)_p)->same_screen;}
void set_XEnterWindowEvent_same_screen(void *_p, int _v) {((XEnterWindowEvent *)_p)->same_screen = (int)_v;}
int get_XEnterWindowEvent_focus(void *_p) {return (int)((XEnterWindowEvent *)_p)->focus;}
void set_XEnterWindowEvent_focus(void *_p, int _v) {((XEnterWindowEvent *)_p)->focus = (int)_v;}
unsigned get_XEnterWindowEvent_state(void *_p) {return (unsigned)((XEnterWindowEvent *)_p)->state;}
void set_XEnterWindowEvent_state(void *_p, unsigned _v) {((XEnterWindowEvent *)_p)->state = (unsigned)_v;}
void *alloc_XCrossingEvent(void) {XCrossingEvent *_p = (XCrossingEvent *)malloc(sizeof(XCrossingEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XCrossingEvent(void *_p) {if (_p==NULL) abort(); free((XCrossingEvent *)_p);}
int get_XCrossingEvent_type(void *_p) {return (int)((XCrossingEvent *)_p)->type;}
void set_XCrossingEvent_type(void *_p, int _v) {((XCrossingEvent *)_p)->type = (int)_v;}
unsigned long get_XCrossingEvent_serial(void *_p) {return (unsigned long)((XCrossingEvent *)_p)->serial;}
void set_XCrossingEvent_serial(void *_p, unsigned long _v) {((XCrossingEvent *)_p)->serial = (unsigned long)_v;}
int get_XCrossingEvent_send_event(void *_p) {return (int)((XCrossingEvent *)_p)->send_event;}
void set_XCrossingEvent_send_event(void *_p, int _v) {((XCrossingEvent *)_p)->send_event = (int)_v;}
void *get_XCrossingEvent_display(void *_p) {return (void *)((XCrossingEvent *)_p)->display;}
void set_XCrossingEvent_display(void *_p, void *_v) {((XCrossingEvent *)_p)->display = (Display *)_v;}
unsigned long get_XCrossingEvent_window(void *_p) {return (unsigned long)((XCrossingEvent *)_p)->window;}
void set_XCrossingEvent_window(void *_p, unsigned long _v) {((XCrossingEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XCrossingEvent_root(void *_p) {return (unsigned long)((XCrossingEvent *)_p)->root;}
void set_XCrossingEvent_root(void *_p, unsigned long _v) {((XCrossingEvent *)_p)->root = (unsigned long)_v;}
unsigned long get_XCrossingEvent_subwindow(void *_p) {return (unsigned long)((XCrossingEvent *)_p)->subwindow;}
void set_XCrossingEvent_subwindow(void *_p, unsigned long _v) {((XCrossingEvent *)_p)->subwindow = (unsigned long)_v;}
unsigned long get_XCrossingEvent_time(void *_p) {return (unsigned long)((XCrossingEvent *)_p)->time;}
void set_XCrossingEvent_time(void *_p, unsigned long _v) {((XCrossingEvent *)_p)->time = (unsigned long)_v;}
int get_XCrossingEvent_x(void *_p) {return (int)((XCrossingEvent *)_p)->x;}
void set_XCrossingEvent_x(void *_p, int _v) {((XCrossingEvent *)_p)->x = (int)_v;}
int get_XCrossingEvent_y(void *_p) {return (int)((XCrossingEvent *)_p)->y;}
void set_XCrossingEvent_y(void *_p, int _v) {((XCrossingEvent *)_p)->y = (int)_v;}
int get_XCrossingEvent_x_root(void *_p) {return (int)((XCrossingEvent *)_p)->x_root;}
void set_XCrossingEvent_x_root(void *_p, int _v) {((XCrossingEvent *)_p)->x_root = (int)_v;}
int get_XCrossingEvent_y_root(void *_p) {return (int)((XCrossingEvent *)_p)->y_root;}
void set_XCrossingEvent_y_root(void *_p, int _v) {((XCrossingEvent *)_p)->y_root = (int)_v;}
int get_XCrossingEvent_mode(void *_p) {return (int)((XCrossingEvent *)_p)->mode;}
void set_XCrossingEvent_mode(void *_p, int _v) {((XCrossingEvent *)_p)->mode = (int)_v;}
int get_XCrossingEvent_detail(void *_p) {return (int)((XCrossingEvent *)_p)->detail;}
void set_XCrossingEvent_detail(void *_p, int _v) {((XCrossingEvent *)_p)->detail = (int)_v;}
int get_XCrossingEvent_same_screen(void *_p) {return (int)((XCrossingEvent *)_p)->same_screen;}
void set_XCrossingEvent_same_screen(void *_p, int _v) {((XCrossingEvent *)_p)->same_screen = (int)_v;}
int get_XCrossingEvent_focus(void *_p) {return (int)((XCrossingEvent *)_p)->focus;}
void set_XCrossingEvent_focus(void *_p, int _v) {((XCrossingEvent *)_p)->focus = (int)_v;}
unsigned get_XCrossingEvent_state(void *_p) {return (unsigned)((XCrossingEvent *)_p)->state;}
void set_XCrossingEvent_state(void *_p, unsigned _v) {((XCrossingEvent *)_p)->state = (unsigned)_v;}
void *alloc_XFocusOutEvent(void) {XFocusOutEvent *_p = (XFocusOutEvent *)malloc(sizeof(XFocusOutEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFocusOutEvent(void *_p) {if (_p==NULL) abort(); free((XFocusOutEvent *)_p);}
int get_XFocusOutEvent_type(void *_p) {return (int)((XFocusOutEvent *)_p)->type;}
void set_XFocusOutEvent_type(void *_p, int _v) {((XFocusOutEvent *)_p)->type = (int)_v;}
unsigned long get_XFocusOutEvent_serial(void *_p) {return (unsigned long)((XFocusOutEvent *)_p)->serial;}
void set_XFocusOutEvent_serial(void *_p, unsigned long _v) {((XFocusOutEvent *)_p)->serial = (unsigned long)_v;}
int get_XFocusOutEvent_send_event(void *_p) {return (int)((XFocusOutEvent *)_p)->send_event;}
void set_XFocusOutEvent_send_event(void *_p, int _v) {((XFocusOutEvent *)_p)->send_event = (int)_v;}
void *get_XFocusOutEvent_display(void *_p) {return (void *)((XFocusOutEvent *)_p)->display;}
void set_XFocusOutEvent_display(void *_p, void *_v) {((XFocusOutEvent *)_p)->display = (Display *)_v;}
unsigned long get_XFocusOutEvent_window(void *_p) {return (unsigned long)((XFocusOutEvent *)_p)->window;}
void set_XFocusOutEvent_window(void *_p, unsigned long _v) {((XFocusOutEvent *)_p)->window = (unsigned long)_v;}
int get_XFocusOutEvent_mode(void *_p) {return (int)((XFocusOutEvent *)_p)->mode;}
void set_XFocusOutEvent_mode(void *_p, int _v) {((XFocusOutEvent *)_p)->mode = (int)_v;}
int get_XFocusOutEvent_detail(void *_p) {return (int)((XFocusOutEvent *)_p)->detail;}
void set_XFocusOutEvent_detail(void *_p, int _v) {((XFocusOutEvent *)_p)->detail = (int)_v;}
void *alloc_XFocusInEvent(void) {XFocusInEvent *_p = (XFocusInEvent *)malloc(sizeof(XFocusInEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFocusInEvent(void *_p) {if (_p==NULL) abort(); free((XFocusInEvent *)_p);}
int get_XFocusInEvent_type(void *_p) {return (int)((XFocusInEvent *)_p)->type;}
void set_XFocusInEvent_type(void *_p, int _v) {((XFocusInEvent *)_p)->type = (int)_v;}
unsigned long get_XFocusInEvent_serial(void *_p) {return (unsigned long)((XFocusInEvent *)_p)->serial;}
void set_XFocusInEvent_serial(void *_p, unsigned long _v) {((XFocusInEvent *)_p)->serial = (unsigned long)_v;}
int get_XFocusInEvent_send_event(void *_p) {return (int)((XFocusInEvent *)_p)->send_event;}
void set_XFocusInEvent_send_event(void *_p, int _v) {((XFocusInEvent *)_p)->send_event = (int)_v;}
void *get_XFocusInEvent_display(void *_p) {return (void *)((XFocusInEvent *)_p)->display;}
void set_XFocusInEvent_display(void *_p, void *_v) {((XFocusInEvent *)_p)->display = (Display *)_v;}
unsigned long get_XFocusInEvent_window(void *_p) {return (unsigned long)((XFocusInEvent *)_p)->window;}
void set_XFocusInEvent_window(void *_p, unsigned long _v) {((XFocusInEvent *)_p)->window = (unsigned long)_v;}
int get_XFocusInEvent_mode(void *_p) {return (int)((XFocusInEvent *)_p)->mode;}
void set_XFocusInEvent_mode(void *_p, int _v) {((XFocusInEvent *)_p)->mode = (int)_v;}
int get_XFocusInEvent_detail(void *_p) {return (int)((XFocusInEvent *)_p)->detail;}
void set_XFocusInEvent_detail(void *_p, int _v) {((XFocusInEvent *)_p)->detail = (int)_v;}
void *alloc_XFocusChangeEvent(void) {XFocusChangeEvent *_p = (XFocusChangeEvent *)malloc(sizeof(XFocusChangeEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFocusChangeEvent(void *_p) {if (_p==NULL) abort(); free((XFocusChangeEvent *)_p);}
int get_XFocusChangeEvent_type(void *_p) {return (int)((XFocusChangeEvent *)_p)->type;}
void set_XFocusChangeEvent_type(void *_p, int _v) {((XFocusChangeEvent *)_p)->type = (int)_v;}
unsigned long get_XFocusChangeEvent_serial(void *_p) {return (unsigned long)((XFocusChangeEvent *)_p)->serial;}
void set_XFocusChangeEvent_serial(void *_p, unsigned long _v) {((XFocusChangeEvent *)_p)->serial = (unsigned long)_v;}
int get_XFocusChangeEvent_send_event(void *_p) {return (int)((XFocusChangeEvent *)_p)->send_event;}
void set_XFocusChangeEvent_send_event(void *_p, int _v) {((XFocusChangeEvent *)_p)->send_event = (int)_v;}
void *get_XFocusChangeEvent_display(void *_p) {return (void *)((XFocusChangeEvent *)_p)->display;}
void set_XFocusChangeEvent_display(void *_p, void *_v) {((XFocusChangeEvent *)_p)->display = (Display *)_v;}
unsigned long get_XFocusChangeEvent_window(void *_p) {return (unsigned long)((XFocusChangeEvent *)_p)->window;}
void set_XFocusChangeEvent_window(void *_p, unsigned long _v) {((XFocusChangeEvent *)_p)->window = (unsigned long)_v;}
int get_XFocusChangeEvent_mode(void *_p) {return (int)((XFocusChangeEvent *)_p)->mode;}
void set_XFocusChangeEvent_mode(void *_p, int _v) {((XFocusChangeEvent *)_p)->mode = (int)_v;}
int get_XFocusChangeEvent_detail(void *_p) {return (int)((XFocusChangeEvent *)_p)->detail;}
void set_XFocusChangeEvent_detail(void *_p, int _v) {((XFocusChangeEvent *)_p)->detail = (int)_v;}
void *alloc_XKeymapEvent(void) {XKeymapEvent *_p = (XKeymapEvent *)malloc(sizeof(XKeymapEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XKeymapEvent(void *_p) {if (_p==NULL) abort(); free((XKeymapEvent *)_p);}
int get_XKeymapEvent_type(void *_p) {return (int)((XKeymapEvent *)_p)->type;}
void set_XKeymapEvent_type(void *_p, int _v) {((XKeymapEvent *)_p)->type = (int)_v;}
unsigned long get_XKeymapEvent_serial(void *_p) {return (unsigned long)((XKeymapEvent *)_p)->serial;}
void set_XKeymapEvent_serial(void *_p, unsigned long _v) {((XKeymapEvent *)_p)->serial = (unsigned long)_v;}
int get_XKeymapEvent_send_event(void *_p) {return (int)((XKeymapEvent *)_p)->send_event;}
void set_XKeymapEvent_send_event(void *_p, int _v) {((XKeymapEvent *)_p)->send_event = (int)_v;}
void *get_XKeymapEvent_display(void *_p) {return (void *)((XKeymapEvent *)_p)->display;}
void set_XKeymapEvent_display(void *_p, void *_v) {((XKeymapEvent *)_p)->display = (Display *)_v;}
unsigned long get_XKeymapEvent_window(void *_p) {return (unsigned long)((XKeymapEvent *)_p)->window;}
void set_XKeymapEvent_window(void *_p, unsigned long _v) {((XKeymapEvent *)_p)->window = (unsigned long)_v;}
void *get_XKeymapEvent_key_vector(void *_p) {return (void *)(((XKeymapEvent *)_p)->key_vector);}
void *alloc_XExposeEvent(void) {XExposeEvent *_p = (XExposeEvent *)malloc(sizeof(XExposeEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XExposeEvent(void *_p) {if (_p==NULL) abort(); free((XExposeEvent *)_p);}
int get_XExposeEvent_type(void *_p) {return (int)((XExposeEvent *)_p)->type;}
void set_XExposeEvent_type(void *_p, int _v) {((XExposeEvent *)_p)->type = (int)_v;}
unsigned long get_XExposeEvent_serial(void *_p) {return (unsigned long)((XExposeEvent *)_p)->serial;}
void set_XExposeEvent_serial(void *_p, unsigned long _v) {((XExposeEvent *)_p)->serial = (unsigned long)_v;}
int get_XExposeEvent_send_event(void *_p) {return (int)((XExposeEvent *)_p)->send_event;}
void set_XExposeEvent_send_event(void *_p, int _v) {((XExposeEvent *)_p)->send_event = (int)_v;}
void *get_XExposeEvent_display(void *_p) {return (void *)((XExposeEvent *)_p)->display;}
void set_XExposeEvent_display(void *_p, void *_v) {((XExposeEvent *)_p)->display = (Display *)_v;}
unsigned long get_XExposeEvent_window(void *_p) {return (unsigned long)((XExposeEvent *)_p)->window;}
void set_XExposeEvent_window(void *_p, unsigned long _v) {((XExposeEvent *)_p)->window = (unsigned long)_v;}
int get_XExposeEvent_x(void *_p) {return (int)((XExposeEvent *)_p)->x;}
void set_XExposeEvent_x(void *_p, int _v) {((XExposeEvent *)_p)->x = (int)_v;}
int get_XExposeEvent_y(void *_p) {return (int)((XExposeEvent *)_p)->y;}
void set_XExposeEvent_y(void *_p, int _v) {((XExposeEvent *)_p)->y = (int)_v;}
int get_XExposeEvent_width(void *_p) {return (int)((XExposeEvent *)_p)->width;}
void set_XExposeEvent_width(void *_p, int _v) {((XExposeEvent *)_p)->width = (int)_v;}
int get_XExposeEvent_height(void *_p) {return (int)((XExposeEvent *)_p)->height;}
void set_XExposeEvent_height(void *_p, int _v) {((XExposeEvent *)_p)->height = (int)_v;}
int get_XExposeEvent_count(void *_p) {return (int)((XExposeEvent *)_p)->count;}
void set_XExposeEvent_count(void *_p, int _v) {((XExposeEvent *)_p)->count = (int)_v;}
void *alloc_XGraphicsExposeEvent(void) {XGraphicsExposeEvent *_p = (XGraphicsExposeEvent *)malloc(sizeof(XGraphicsExposeEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XGraphicsExposeEvent(void *_p) {if (_p==NULL) abort(); free((XGraphicsExposeEvent *)_p);}
int get_XGraphicsExposeEvent_type(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->type;}
void set_XGraphicsExposeEvent_type(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->type = (int)_v;}
unsigned long get_XGraphicsExposeEvent_serial(void *_p) {return (unsigned long)((XGraphicsExposeEvent *)_p)->serial;}
void set_XGraphicsExposeEvent_serial(void *_p, unsigned long _v) {((XGraphicsExposeEvent *)_p)->serial = (unsigned long)_v;}
int get_XGraphicsExposeEvent_send_event(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->send_event;}
void set_XGraphicsExposeEvent_send_event(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->send_event = (int)_v;}
void *get_XGraphicsExposeEvent_display(void *_p) {return (void *)((XGraphicsExposeEvent *)_p)->display;}
void set_XGraphicsExposeEvent_display(void *_p, void *_v) {((XGraphicsExposeEvent *)_p)->display = (Display *)_v;}
unsigned long get_XGraphicsExposeEvent_drawable(void *_p) {return (unsigned long)((XGraphicsExposeEvent *)_p)->drawable;}
void set_XGraphicsExposeEvent_drawable(void *_p, unsigned long _v) {((XGraphicsExposeEvent *)_p)->drawable = (unsigned long)_v;}
int get_XGraphicsExposeEvent_x(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->x;}
void set_XGraphicsExposeEvent_x(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->x = (int)_v;}
int get_XGraphicsExposeEvent_y(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->y;}
void set_XGraphicsExposeEvent_y(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->y = (int)_v;}
int get_XGraphicsExposeEvent_width(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->width;}
void set_XGraphicsExposeEvent_width(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->width = (int)_v;}
int get_XGraphicsExposeEvent_height(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->height;}
void set_XGraphicsExposeEvent_height(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->height = (int)_v;}
int get_XGraphicsExposeEvent_count(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->count;}
void set_XGraphicsExposeEvent_count(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->count = (int)_v;}
int get_XGraphicsExposeEvent_major_code(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->major_code;}
void set_XGraphicsExposeEvent_major_code(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->major_code = (int)_v;}
int get_XGraphicsExposeEvent_minor_code(void *_p) {return (int)((XGraphicsExposeEvent *)_p)->minor_code;}
void set_XGraphicsExposeEvent_minor_code(void *_p, int _v) {((XGraphicsExposeEvent *)_p)->minor_code = (int)_v;}
void *alloc_XNoExposeEvent(void) {XNoExposeEvent *_p = (XNoExposeEvent *)malloc(sizeof(XNoExposeEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XNoExposeEvent(void *_p) {if (_p==NULL) abort(); free((XNoExposeEvent *)_p);}
int get_XNoExposeEvent_type(void *_p) {return (int)((XNoExposeEvent *)_p)->type;}
void set_XNoExposeEvent_type(void *_p, int _v) {((XNoExposeEvent *)_p)->type = (int)_v;}
unsigned long get_XNoExposeEvent_serial(void *_p) {return (unsigned long)((XNoExposeEvent *)_p)->serial;}
void set_XNoExposeEvent_serial(void *_p, unsigned long _v) {((XNoExposeEvent *)_p)->serial = (unsigned long)_v;}
int get_XNoExposeEvent_send_event(void *_p) {return (int)((XNoExposeEvent *)_p)->send_event;}
void set_XNoExposeEvent_send_event(void *_p, int _v) {((XNoExposeEvent *)_p)->send_event = (int)_v;}
void *get_XNoExposeEvent_display(void *_p) {return (void *)((XNoExposeEvent *)_p)->display;}
void set_XNoExposeEvent_display(void *_p, void *_v) {((XNoExposeEvent *)_p)->display = (Display *)_v;}
unsigned long get_XNoExposeEvent_drawable(void *_p) {return (unsigned long)((XNoExposeEvent *)_p)->drawable;}
void set_XNoExposeEvent_drawable(void *_p, unsigned long _v) {((XNoExposeEvent *)_p)->drawable = (unsigned long)_v;}
int get_XNoExposeEvent_major_code(void *_p) {return (int)((XNoExposeEvent *)_p)->major_code;}
void set_XNoExposeEvent_major_code(void *_p, int _v) {((XNoExposeEvent *)_p)->major_code = (int)_v;}
int get_XNoExposeEvent_minor_code(void *_p) {return (int)((XNoExposeEvent *)_p)->minor_code;}
void set_XNoExposeEvent_minor_code(void *_p, int _v) {((XNoExposeEvent *)_p)->minor_code = (int)_v;}
void *alloc_XVisibilityEvent(void) {XVisibilityEvent *_p = (XVisibilityEvent *)malloc(sizeof(XVisibilityEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XVisibilityEvent(void *_p) {if (_p==NULL) abort(); free((XVisibilityEvent *)_p);}
int get_XVisibilityEvent_type(void *_p) {return (int)((XVisibilityEvent *)_p)->type;}
void set_XVisibilityEvent_type(void *_p, int _v) {((XVisibilityEvent *)_p)->type = (int)_v;}
unsigned long get_XVisibilityEvent_serial(void *_p) {return (unsigned long)((XVisibilityEvent *)_p)->serial;}
void set_XVisibilityEvent_serial(void *_p, unsigned long _v) {((XVisibilityEvent *)_p)->serial = (unsigned long)_v;}
int get_XVisibilityEvent_send_event(void *_p) {return (int)((XVisibilityEvent *)_p)->send_event;}
void set_XVisibilityEvent_send_event(void *_p, int _v) {((XVisibilityEvent *)_p)->send_event = (int)_v;}
void *get_XVisibilityEvent_display(void *_p) {return (void *)((XVisibilityEvent *)_p)->display;}
void set_XVisibilityEvent_display(void *_p, void *_v) {((XVisibilityEvent *)_p)->display = (Display *)_v;}
unsigned long get_XVisibilityEvent_window(void *_p) {return (unsigned long)((XVisibilityEvent *)_p)->window;}
void set_XVisibilityEvent_window(void *_p, unsigned long _v) {((XVisibilityEvent *)_p)->window = (unsigned long)_v;}
int get_XVisibilityEvent_state(void *_p) {return (int)((XVisibilityEvent *)_p)->state;}
void set_XVisibilityEvent_state(void *_p, int _v) {((XVisibilityEvent *)_p)->state = (int)_v;}
void *alloc_XCreateWindowEvent(void) {XCreateWindowEvent *_p = (XCreateWindowEvent *)malloc(sizeof(XCreateWindowEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XCreateWindowEvent(void *_p) {if (_p==NULL) abort(); free((XCreateWindowEvent *)_p);}
int get_XCreateWindowEvent_type(void *_p) {return (int)((XCreateWindowEvent *)_p)->type;}
void set_XCreateWindowEvent_type(void *_p, int _v) {((XCreateWindowEvent *)_p)->type = (int)_v;}
unsigned long get_XCreateWindowEvent_serial(void *_p) {return (unsigned long)((XCreateWindowEvent *)_p)->serial;}
void set_XCreateWindowEvent_serial(void *_p, unsigned long _v) {((XCreateWindowEvent *)_p)->serial = (unsigned long)_v;}
int get_XCreateWindowEvent_send_event(void *_p) {return (int)((XCreateWindowEvent *)_p)->send_event;}
void set_XCreateWindowEvent_send_event(void *_p, int _v) {((XCreateWindowEvent *)_p)->send_event = (int)_v;}
void *get_XCreateWindowEvent_display(void *_p) {return (void *)((XCreateWindowEvent *)_p)->display;}
void set_XCreateWindowEvent_display(void *_p, void *_v) {((XCreateWindowEvent *)_p)->display = (Display *)_v;}
unsigned long get_XCreateWindowEvent_parent(void *_p) {return (unsigned long)((XCreateWindowEvent *)_p)->parent;}
void set_XCreateWindowEvent_parent(void *_p, unsigned long _v) {((XCreateWindowEvent *)_p)->parent = (unsigned long)_v;}
unsigned long get_XCreateWindowEvent_window(void *_p) {return (unsigned long)((XCreateWindowEvent *)_p)->window;}
void set_XCreateWindowEvent_window(void *_p, unsigned long _v) {((XCreateWindowEvent *)_p)->window = (unsigned long)_v;}
int get_XCreateWindowEvent_x(void *_p) {return (int)((XCreateWindowEvent *)_p)->x;}
void set_XCreateWindowEvent_x(void *_p, int _v) {((XCreateWindowEvent *)_p)->x = (int)_v;}
int get_XCreateWindowEvent_y(void *_p) {return (int)((XCreateWindowEvent *)_p)->y;}
void set_XCreateWindowEvent_y(void *_p, int _v) {((XCreateWindowEvent *)_p)->y = (int)_v;}
int get_XCreateWindowEvent_width(void *_p) {return (int)((XCreateWindowEvent *)_p)->width;}
void set_XCreateWindowEvent_width(void *_p, int _v) {((XCreateWindowEvent *)_p)->width = (int)_v;}
int get_XCreateWindowEvent_height(void *_p) {return (int)((XCreateWindowEvent *)_p)->height;}
void set_XCreateWindowEvent_height(void *_p, int _v) {((XCreateWindowEvent *)_p)->height = (int)_v;}
int get_XCreateWindowEvent_border_width(void *_p) {return (int)((XCreateWindowEvent *)_p)->border_width;}
void set_XCreateWindowEvent_border_width(void *_p, int _v) {((XCreateWindowEvent *)_p)->border_width = (int)_v;}
int get_XCreateWindowEvent_override_redirect(void *_p) {return (int)((XCreateWindowEvent *)_p)->override_redirect;}
void set_XCreateWindowEvent_override_redirect(void *_p, int _v) {((XCreateWindowEvent *)_p)->override_redirect = (int)_v;}
void *alloc_XDestroyWindowEvent(void) {XDestroyWindowEvent *_p = (XDestroyWindowEvent *)malloc(sizeof(XDestroyWindowEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XDestroyWindowEvent(void *_p) {if (_p==NULL) abort(); free((XDestroyWindowEvent *)_p);}
int get_XDestroyWindowEvent_type(void *_p) {return (int)((XDestroyWindowEvent *)_p)->type;}
void set_XDestroyWindowEvent_type(void *_p, int _v) {((XDestroyWindowEvent *)_p)->type = (int)_v;}
unsigned long get_XDestroyWindowEvent_serial(void *_p) {return (unsigned long)((XDestroyWindowEvent *)_p)->serial;}
void set_XDestroyWindowEvent_serial(void *_p, unsigned long _v) {((XDestroyWindowEvent *)_p)->serial = (unsigned long)_v;}
int get_XDestroyWindowEvent_send_event(void *_p) {return (int)((XDestroyWindowEvent *)_p)->send_event;}
void set_XDestroyWindowEvent_send_event(void *_p, int _v) {((XDestroyWindowEvent *)_p)->send_event = (int)_v;}
void *get_XDestroyWindowEvent_display(void *_p) {return (void *)((XDestroyWindowEvent *)_p)->display;}
void set_XDestroyWindowEvent_display(void *_p, void *_v) {((XDestroyWindowEvent *)_p)->display = (Display *)_v;}
unsigned long get_XDestroyWindowEvent_event(void *_p) {return (unsigned long)((XDestroyWindowEvent *)_p)->event;}
void set_XDestroyWindowEvent_event(void *_p, unsigned long _v) {((XDestroyWindowEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XDestroyWindowEvent_window(void *_p) {return (unsigned long)((XDestroyWindowEvent *)_p)->window;}
void set_XDestroyWindowEvent_window(void *_p, unsigned long _v) {((XDestroyWindowEvent *)_p)->window = (unsigned long)_v;}
void *alloc_XUnmapEvent(void) {XUnmapEvent *_p = (XUnmapEvent *)malloc(sizeof(XUnmapEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XUnmapEvent(void *_p) {if (_p==NULL) abort(); free((XUnmapEvent *)_p);}
int get_XUnmapEvent_type(void *_p) {return (int)((XUnmapEvent *)_p)->type;}
void set_XUnmapEvent_type(void *_p, int _v) {((XUnmapEvent *)_p)->type = (int)_v;}
unsigned long get_XUnmapEvent_serial(void *_p) {return (unsigned long)((XUnmapEvent *)_p)->serial;}
void set_XUnmapEvent_serial(void *_p, unsigned long _v) {((XUnmapEvent *)_p)->serial = (unsigned long)_v;}
int get_XUnmapEvent_send_event(void *_p) {return (int)((XUnmapEvent *)_p)->send_event;}
void set_XUnmapEvent_send_event(void *_p, int _v) {((XUnmapEvent *)_p)->send_event = (int)_v;}
void *get_XUnmapEvent_display(void *_p) {return (void *)((XUnmapEvent *)_p)->display;}
void set_XUnmapEvent_display(void *_p, void *_v) {((XUnmapEvent *)_p)->display = (Display *)_v;}
unsigned long get_XUnmapEvent_event(void *_p) {return (unsigned long)((XUnmapEvent *)_p)->event;}
void set_XUnmapEvent_event(void *_p, unsigned long _v) {((XUnmapEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XUnmapEvent_window(void *_p) {return (unsigned long)((XUnmapEvent *)_p)->window;}
void set_XUnmapEvent_window(void *_p, unsigned long _v) {((XUnmapEvent *)_p)->window = (unsigned long)_v;}
int get_XUnmapEvent_from_configure(void *_p) {return (int)((XUnmapEvent *)_p)->from_configure;}
void set_XUnmapEvent_from_configure(void *_p, int _v) {((XUnmapEvent *)_p)->from_configure = (int)_v;}
void *alloc_XMapEvent(void) {XMapEvent *_p = (XMapEvent *)malloc(sizeof(XMapEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XMapEvent(void *_p) {if (_p==NULL) abort(); free((XMapEvent *)_p);}
int get_XMapEvent_type(void *_p) {return (int)((XMapEvent *)_p)->type;}
void set_XMapEvent_type(void *_p, int _v) {((XMapEvent *)_p)->type = (int)_v;}
unsigned long get_XMapEvent_serial(void *_p) {return (unsigned long)((XMapEvent *)_p)->serial;}
void set_XMapEvent_serial(void *_p, unsigned long _v) {((XMapEvent *)_p)->serial = (unsigned long)_v;}
int get_XMapEvent_send_event(void *_p) {return (int)((XMapEvent *)_p)->send_event;}
void set_XMapEvent_send_event(void *_p, int _v) {((XMapEvent *)_p)->send_event = (int)_v;}
void *get_XMapEvent_display(void *_p) {return (void *)((XMapEvent *)_p)->display;}
void set_XMapEvent_display(void *_p, void *_v) {((XMapEvent *)_p)->display = (Display *)_v;}
unsigned long get_XMapEvent_event(void *_p) {return (unsigned long)((XMapEvent *)_p)->event;}
void set_XMapEvent_event(void *_p, unsigned long _v) {((XMapEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XMapEvent_window(void *_p) {return (unsigned long)((XMapEvent *)_p)->window;}
void set_XMapEvent_window(void *_p, unsigned long _v) {((XMapEvent *)_p)->window = (unsigned long)_v;}
int get_XMapEvent_override_redirect(void *_p) {return (int)((XMapEvent *)_p)->override_redirect;}
void set_XMapEvent_override_redirect(void *_p, int _v) {((XMapEvent *)_p)->override_redirect = (int)_v;}
void *alloc_XMapRequestEvent(void) {XMapRequestEvent *_p = (XMapRequestEvent *)malloc(sizeof(XMapRequestEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XMapRequestEvent(void *_p) {if (_p==NULL) abort(); free((XMapRequestEvent *)_p);}
int get_XMapRequestEvent_type(void *_p) {return (int)((XMapRequestEvent *)_p)->type;}
void set_XMapRequestEvent_type(void *_p, int _v) {((XMapRequestEvent *)_p)->type = (int)_v;}
unsigned long get_XMapRequestEvent_serial(void *_p) {return (unsigned long)((XMapRequestEvent *)_p)->serial;}
void set_XMapRequestEvent_serial(void *_p, unsigned long _v) {((XMapRequestEvent *)_p)->serial = (unsigned long)_v;}
int get_XMapRequestEvent_send_event(void *_p) {return (int)((XMapRequestEvent *)_p)->send_event;}
void set_XMapRequestEvent_send_event(void *_p, int _v) {((XMapRequestEvent *)_p)->send_event = (int)_v;}
void *get_XMapRequestEvent_display(void *_p) {return (void *)((XMapRequestEvent *)_p)->display;}
void set_XMapRequestEvent_display(void *_p, void *_v) {((XMapRequestEvent *)_p)->display = (Display *)_v;}
unsigned long get_XMapRequestEvent_parent(void *_p) {return (unsigned long)((XMapRequestEvent *)_p)->parent;}
void set_XMapRequestEvent_parent(void *_p, unsigned long _v) {((XMapRequestEvent *)_p)->parent = (unsigned long)_v;}
unsigned long get_XMapRequestEvent_window(void *_p) {return (unsigned long)((XMapRequestEvent *)_p)->window;}
void set_XMapRequestEvent_window(void *_p, unsigned long _v) {((XMapRequestEvent *)_p)->window = (unsigned long)_v;}
void *alloc_XReparentEvent(void) {XReparentEvent *_p = (XReparentEvent *)malloc(sizeof(XReparentEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XReparentEvent(void *_p) {if (_p==NULL) abort(); free((XReparentEvent *)_p);}
int get_XReparentEvent_type(void *_p) {return (int)((XReparentEvent *)_p)->type;}
void set_XReparentEvent_type(void *_p, int _v) {((XReparentEvent *)_p)->type = (int)_v;}
unsigned long get_XReparentEvent_serial(void *_p) {return (unsigned long)((XReparentEvent *)_p)->serial;}
void set_XReparentEvent_serial(void *_p, unsigned long _v) {((XReparentEvent *)_p)->serial = (unsigned long)_v;}
int get_XReparentEvent_send_event(void *_p) {return (int)((XReparentEvent *)_p)->send_event;}
void set_XReparentEvent_send_event(void *_p, int _v) {((XReparentEvent *)_p)->send_event = (int)_v;}
void *get_XReparentEvent_display(void *_p) {return (void *)((XReparentEvent *)_p)->display;}
void set_XReparentEvent_display(void *_p, void *_v) {((XReparentEvent *)_p)->display = (Display *)_v;}
unsigned long get_XReparentEvent_event(void *_p) {return (unsigned long)((XReparentEvent *)_p)->event;}
void set_XReparentEvent_event(void *_p, unsigned long _v) {((XReparentEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XReparentEvent_window(void *_p) {return (unsigned long)((XReparentEvent *)_p)->window;}
void set_XReparentEvent_window(void *_p, unsigned long _v) {((XReparentEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XReparentEvent_parent(void *_p) {return (unsigned long)((XReparentEvent *)_p)->parent;}
void set_XReparentEvent_parent(void *_p, unsigned long _v) {((XReparentEvent *)_p)->parent = (unsigned long)_v;}
int get_XReparentEvent_x(void *_p) {return (int)((XReparentEvent *)_p)->x;}
void set_XReparentEvent_x(void *_p, int _v) {((XReparentEvent *)_p)->x = (int)_v;}
int get_XReparentEvent_y(void *_p) {return (int)((XReparentEvent *)_p)->y;}
void set_XReparentEvent_y(void *_p, int _v) {((XReparentEvent *)_p)->y = (int)_v;}
int get_XReparentEvent_override_redirect(void *_p) {return (int)((XReparentEvent *)_p)->override_redirect;}
void set_XReparentEvent_override_redirect(void *_p, int _v) {((XReparentEvent *)_p)->override_redirect = (int)_v;}
void *alloc_XConfigureEvent(void) {XConfigureEvent *_p = (XConfigureEvent *)malloc(sizeof(XConfigureEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XConfigureEvent(void *_p) {if (_p==NULL) abort(); free((XConfigureEvent *)_p);}
int get_XConfigureEvent_type(void *_p) {return (int)((XConfigureEvent *)_p)->type;}
void set_XConfigureEvent_type(void *_p, int _v) {((XConfigureEvent *)_p)->type = (int)_v;}
unsigned long get_XConfigureEvent_serial(void *_p) {return (unsigned long)((XConfigureEvent *)_p)->serial;}
void set_XConfigureEvent_serial(void *_p, unsigned long _v) {((XConfigureEvent *)_p)->serial = (unsigned long)_v;}
int get_XConfigureEvent_send_event(void *_p) {return (int)((XConfigureEvent *)_p)->send_event;}
void set_XConfigureEvent_send_event(void *_p, int _v) {((XConfigureEvent *)_p)->send_event = (int)_v;}
void *get_XConfigureEvent_display(void *_p) {return (void *)((XConfigureEvent *)_p)->display;}
void set_XConfigureEvent_display(void *_p, void *_v) {((XConfigureEvent *)_p)->display = (Display *)_v;}
unsigned long get_XConfigureEvent_event(void *_p) {return (unsigned long)((XConfigureEvent *)_p)->event;}
void set_XConfigureEvent_event(void *_p, unsigned long _v) {((XConfigureEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XConfigureEvent_window(void *_p) {return (unsigned long)((XConfigureEvent *)_p)->window;}
void set_XConfigureEvent_window(void *_p, unsigned long _v) {((XConfigureEvent *)_p)->window = (unsigned long)_v;}
int get_XConfigureEvent_x(void *_p) {return (int)((XConfigureEvent *)_p)->x;}
void set_XConfigureEvent_x(void *_p, int _v) {((XConfigureEvent *)_p)->x = (int)_v;}
int get_XConfigureEvent_y(void *_p) {return (int)((XConfigureEvent *)_p)->y;}
void set_XConfigureEvent_y(void *_p, int _v) {((XConfigureEvent *)_p)->y = (int)_v;}
int get_XConfigureEvent_width(void *_p) {return (int)((XConfigureEvent *)_p)->width;}
void set_XConfigureEvent_width(void *_p, int _v) {((XConfigureEvent *)_p)->width = (int)_v;}
int get_XConfigureEvent_height(void *_p) {return (int)((XConfigureEvent *)_p)->height;}
void set_XConfigureEvent_height(void *_p, int _v) {((XConfigureEvent *)_p)->height = (int)_v;}
int get_XConfigureEvent_border_width(void *_p) {return (int)((XConfigureEvent *)_p)->border_width;}
void set_XConfigureEvent_border_width(void *_p, int _v) {((XConfigureEvent *)_p)->border_width = (int)_v;}
unsigned long get_XConfigureEvent_above(void *_p) {return (unsigned long)((XConfigureEvent *)_p)->above;}
void set_XConfigureEvent_above(void *_p, unsigned long _v) {((XConfigureEvent *)_p)->above = (unsigned long)_v;}
int get_XConfigureEvent_override_redirect(void *_p) {return (int)((XConfigureEvent *)_p)->override_redirect;}
void set_XConfigureEvent_override_redirect(void *_p, int _v) {((XConfigureEvent *)_p)->override_redirect = (int)_v;}
void *alloc_XGravityEvent(void) {XGravityEvent *_p = (XGravityEvent *)malloc(sizeof(XGravityEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XGravityEvent(void *_p) {if (_p==NULL) abort(); free((XGravityEvent *)_p);}
int get_XGravityEvent_type(void *_p) {return (int)((XGravityEvent *)_p)->type;}
void set_XGravityEvent_type(void *_p, int _v) {((XGravityEvent *)_p)->type = (int)_v;}
unsigned long get_XGravityEvent_serial(void *_p) {return (unsigned long)((XGravityEvent *)_p)->serial;}
void set_XGravityEvent_serial(void *_p, unsigned long _v) {((XGravityEvent *)_p)->serial = (unsigned long)_v;}
int get_XGravityEvent_send_event(void *_p) {return (int)((XGravityEvent *)_p)->send_event;}
void set_XGravityEvent_send_event(void *_p, int _v) {((XGravityEvent *)_p)->send_event = (int)_v;}
void *get_XGravityEvent_display(void *_p) {return (void *)((XGravityEvent *)_p)->display;}
void set_XGravityEvent_display(void *_p, void *_v) {((XGravityEvent *)_p)->display = (Display *)_v;}
unsigned long get_XGravityEvent_event(void *_p) {return (unsigned long)((XGravityEvent *)_p)->event;}
void set_XGravityEvent_event(void *_p, unsigned long _v) {((XGravityEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XGravityEvent_window(void *_p) {return (unsigned long)((XGravityEvent *)_p)->window;}
void set_XGravityEvent_window(void *_p, unsigned long _v) {((XGravityEvent *)_p)->window = (unsigned long)_v;}
int get_XGravityEvent_x(void *_p) {return (int)((XGravityEvent *)_p)->x;}
void set_XGravityEvent_x(void *_p, int _v) {((XGravityEvent *)_p)->x = (int)_v;}
int get_XGravityEvent_y(void *_p) {return (int)((XGravityEvent *)_p)->y;}
void set_XGravityEvent_y(void *_p, int _v) {((XGravityEvent *)_p)->y = (int)_v;}
void *alloc_XResizeRequestEvent(void) {XResizeRequestEvent *_p = (XResizeRequestEvent *)malloc(sizeof(XResizeRequestEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XResizeRequestEvent(void *_p) {if (_p==NULL) abort(); free((XResizeRequestEvent *)_p);}
int get_XResizeRequestEvent_type(void *_p) {return (int)((XResizeRequestEvent *)_p)->type;}
void set_XResizeRequestEvent_type(void *_p, int _v) {((XResizeRequestEvent *)_p)->type = (int)_v;}
unsigned long get_XResizeRequestEvent_serial(void *_p) {return (unsigned long)((XResizeRequestEvent *)_p)->serial;}
void set_XResizeRequestEvent_serial(void *_p, unsigned long _v) {((XResizeRequestEvent *)_p)->serial = (unsigned long)_v;}
int get_XResizeRequestEvent_send_event(void *_p) {return (int)((XResizeRequestEvent *)_p)->send_event;}
void set_XResizeRequestEvent_send_event(void *_p, int _v) {((XResizeRequestEvent *)_p)->send_event = (int)_v;}
void *get_XResizeRequestEvent_display(void *_p) {return (void *)((XResizeRequestEvent *)_p)->display;}
void set_XResizeRequestEvent_display(void *_p, void *_v) {((XResizeRequestEvent *)_p)->display = (Display *)_v;}
unsigned long get_XResizeRequestEvent_window(void *_p) {return (unsigned long)((XResizeRequestEvent *)_p)->window;}
void set_XResizeRequestEvent_window(void *_p, unsigned long _v) {((XResizeRequestEvent *)_p)->window = (unsigned long)_v;}
int get_XResizeRequestEvent_width(void *_p) {return (int)((XResizeRequestEvent *)_p)->width;}
void set_XResizeRequestEvent_width(void *_p, int _v) {((XResizeRequestEvent *)_p)->width = (int)_v;}
int get_XResizeRequestEvent_height(void *_p) {return (int)((XResizeRequestEvent *)_p)->height;}
void set_XResizeRequestEvent_height(void *_p, int _v) {((XResizeRequestEvent *)_p)->height = (int)_v;}
void *alloc_XConfigureRequestEvent(void) {XConfigureRequestEvent *_p = (XConfigureRequestEvent *)malloc(sizeof(XConfigureRequestEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XConfigureRequestEvent(void *_p) {if (_p==NULL) abort(); free((XConfigureRequestEvent *)_p);}
int get_XConfigureRequestEvent_type(void *_p) {return (int)((XConfigureRequestEvent *)_p)->type;}
void set_XConfigureRequestEvent_type(void *_p, int _v) {((XConfigureRequestEvent *)_p)->type = (int)_v;}
unsigned long get_XConfigureRequestEvent_serial(void *_p) {return (unsigned long)((XConfigureRequestEvent *)_p)->serial;}
void set_XConfigureRequestEvent_serial(void *_p, unsigned long _v) {((XConfigureRequestEvent *)_p)->serial = (unsigned long)_v;}
int get_XConfigureRequestEvent_send_event(void *_p) {return (int)((XConfigureRequestEvent *)_p)->send_event;}
void set_XConfigureRequestEvent_send_event(void *_p, int _v) {((XConfigureRequestEvent *)_p)->send_event = (int)_v;}
void *get_XConfigureRequestEvent_display(void *_p) {return (void *)((XConfigureRequestEvent *)_p)->display;}
void set_XConfigureRequestEvent_display(void *_p, void *_v) {((XConfigureRequestEvent *)_p)->display = (Display *)_v;}
unsigned long get_XConfigureRequestEvent_parent(void *_p) {return (unsigned long)((XConfigureRequestEvent *)_p)->parent;}
void set_XConfigureRequestEvent_parent(void *_p, unsigned long _v) {((XConfigureRequestEvent *)_p)->parent = (unsigned long)_v;}
unsigned long get_XConfigureRequestEvent_window(void *_p) {return (unsigned long)((XConfigureRequestEvent *)_p)->window;}
void set_XConfigureRequestEvent_window(void *_p, unsigned long _v) {((XConfigureRequestEvent *)_p)->window = (unsigned long)_v;}
int get_XConfigureRequestEvent_x(void *_p) {return (int)((XConfigureRequestEvent *)_p)->x;}
void set_XConfigureRequestEvent_x(void *_p, int _v) {((XConfigureRequestEvent *)_p)->x = (int)_v;}
int get_XConfigureRequestEvent_y(void *_p) {return (int)((XConfigureRequestEvent *)_p)->y;}
void set_XConfigureRequestEvent_y(void *_p, int _v) {((XConfigureRequestEvent *)_p)->y = (int)_v;}
int get_XConfigureRequestEvent_width(void *_p) {return (int)((XConfigureRequestEvent *)_p)->width;}
void set_XConfigureRequestEvent_width(void *_p, int _v) {((XConfigureRequestEvent *)_p)->width = (int)_v;}
int get_XConfigureRequestEvent_height(void *_p) {return (int)((XConfigureRequestEvent *)_p)->height;}
void set_XConfigureRequestEvent_height(void *_p, int _v) {((XConfigureRequestEvent *)_p)->height = (int)_v;}
int get_XConfigureRequestEvent_border_width(void *_p) {return (int)((XConfigureRequestEvent *)_p)->border_width;}
void set_XConfigureRequestEvent_border_width(void *_p, int _v) {((XConfigureRequestEvent *)_p)->border_width = (int)_v;}
unsigned long get_XConfigureRequestEvent_above(void *_p) {return (unsigned long)((XConfigureRequestEvent *)_p)->above;}
void set_XConfigureRequestEvent_above(void *_p, unsigned long _v) {((XConfigureRequestEvent *)_p)->above = (unsigned long)_v;}
int get_XConfigureRequestEvent_detail(void *_p) {return (int)((XConfigureRequestEvent *)_p)->detail;}
void set_XConfigureRequestEvent_detail(void *_p, int _v) {((XConfigureRequestEvent *)_p)->detail = (int)_v;}
unsigned long get_XConfigureRequestEvent_value_mask(void *_p) {return (unsigned long)((XConfigureRequestEvent *)_p)->value_mask;}
void set_XConfigureRequestEvent_value_mask(void *_p, unsigned long _v) {((XConfigureRequestEvent *)_p)->value_mask = (unsigned long)_v;}
void *alloc_XCirculateEvent(void) {XCirculateEvent *_p = (XCirculateEvent *)malloc(sizeof(XCirculateEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XCirculateEvent(void *_p) {if (_p==NULL) abort(); free((XCirculateEvent *)_p);}
int get_XCirculateEvent_type(void *_p) {return (int)((XCirculateEvent *)_p)->type;}
void set_XCirculateEvent_type(void *_p, int _v) {((XCirculateEvent *)_p)->type = (int)_v;}
unsigned long get_XCirculateEvent_serial(void *_p) {return (unsigned long)((XCirculateEvent *)_p)->serial;}
void set_XCirculateEvent_serial(void *_p, unsigned long _v) {((XCirculateEvent *)_p)->serial = (unsigned long)_v;}
int get_XCirculateEvent_send_event(void *_p) {return (int)((XCirculateEvent *)_p)->send_event;}
void set_XCirculateEvent_send_event(void *_p, int _v) {((XCirculateEvent *)_p)->send_event = (int)_v;}
void *get_XCirculateEvent_display(void *_p) {return (void *)((XCirculateEvent *)_p)->display;}
void set_XCirculateEvent_display(void *_p, void *_v) {((XCirculateEvent *)_p)->display = (Display *)_v;}
unsigned long get_XCirculateEvent_event(void *_p) {return (unsigned long)((XCirculateEvent *)_p)->event;}
void set_XCirculateEvent_event(void *_p, unsigned long _v) {((XCirculateEvent *)_p)->event = (unsigned long)_v;}
unsigned long get_XCirculateEvent_window(void *_p) {return (unsigned long)((XCirculateEvent *)_p)->window;}
void set_XCirculateEvent_window(void *_p, unsigned long _v) {((XCirculateEvent *)_p)->window = (unsigned long)_v;}
int get_XCirculateEvent_place(void *_p) {return (int)((XCirculateEvent *)_p)->place;}
void set_XCirculateEvent_place(void *_p, int _v) {((XCirculateEvent *)_p)->place = (int)_v;}
void *alloc_XCirculateRequestEvent(void) {XCirculateRequestEvent *_p = (XCirculateRequestEvent *)malloc(sizeof(XCirculateRequestEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XCirculateRequestEvent(void *_p) {if (_p==NULL) abort(); free((XCirculateRequestEvent *)_p);}
int get_XCirculateRequestEvent_type(void *_p) {return (int)((XCirculateRequestEvent *)_p)->type;}
void set_XCirculateRequestEvent_type(void *_p, int _v) {((XCirculateRequestEvent *)_p)->type = (int)_v;}
unsigned long get_XCirculateRequestEvent_serial(void *_p) {return (unsigned long)((XCirculateRequestEvent *)_p)->serial;}
void set_XCirculateRequestEvent_serial(void *_p, unsigned long _v) {((XCirculateRequestEvent *)_p)->serial = (unsigned long)_v;}
int get_XCirculateRequestEvent_send_event(void *_p) {return (int)((XCirculateRequestEvent *)_p)->send_event;}
void set_XCirculateRequestEvent_send_event(void *_p, int _v) {((XCirculateRequestEvent *)_p)->send_event = (int)_v;}
void *get_XCirculateRequestEvent_display(void *_p) {return (void *)((XCirculateRequestEvent *)_p)->display;}
void set_XCirculateRequestEvent_display(void *_p, void *_v) {((XCirculateRequestEvent *)_p)->display = (Display *)_v;}
unsigned long get_XCirculateRequestEvent_parent(void *_p) {return (unsigned long)((XCirculateRequestEvent *)_p)->parent;}
void set_XCirculateRequestEvent_parent(void *_p, unsigned long _v) {((XCirculateRequestEvent *)_p)->parent = (unsigned long)_v;}
unsigned long get_XCirculateRequestEvent_window(void *_p) {return (unsigned long)((XCirculateRequestEvent *)_p)->window;}
void set_XCirculateRequestEvent_window(void *_p, unsigned long _v) {((XCirculateRequestEvent *)_p)->window = (unsigned long)_v;}
int get_XCirculateRequestEvent_place(void *_p) {return (int)((XCirculateRequestEvent *)_p)->place;}
void set_XCirculateRequestEvent_place(void *_p, int _v) {((XCirculateRequestEvent *)_p)->place = (int)_v;}
void *alloc_XPropertyEvent(void) {XPropertyEvent *_p = (XPropertyEvent *)malloc(sizeof(XPropertyEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XPropertyEvent(void *_p) {if (_p==NULL) abort(); free((XPropertyEvent *)_p);}
int get_XPropertyEvent_type(void *_p) {return (int)((XPropertyEvent *)_p)->type;}
void set_XPropertyEvent_type(void *_p, int _v) {((XPropertyEvent *)_p)->type = (int)_v;}
unsigned long get_XPropertyEvent_serial(void *_p) {return (unsigned long)((XPropertyEvent *)_p)->serial;}
void set_XPropertyEvent_serial(void *_p, unsigned long _v) {((XPropertyEvent *)_p)->serial = (unsigned long)_v;}
int get_XPropertyEvent_send_event(void *_p) {return (int)((XPropertyEvent *)_p)->send_event;}
void set_XPropertyEvent_send_event(void *_p, int _v) {((XPropertyEvent *)_p)->send_event = (int)_v;}
void *get_XPropertyEvent_display(void *_p) {return (void *)((XPropertyEvent *)_p)->display;}
void set_XPropertyEvent_display(void *_p, void *_v) {((XPropertyEvent *)_p)->display = (Display *)_v;}
unsigned long get_XPropertyEvent_window(void *_p) {return (unsigned long)((XPropertyEvent *)_p)->window;}
void set_XPropertyEvent_window(void *_p, unsigned long _v) {((XPropertyEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XPropertyEvent_atom(void *_p) {return (unsigned long)((XPropertyEvent *)_p)->atom;}
void set_XPropertyEvent_atom(void *_p, unsigned long _v) {((XPropertyEvent *)_p)->atom = (unsigned long)_v;}
unsigned long get_XPropertyEvent_time(void *_p) {return (unsigned long)((XPropertyEvent *)_p)->time;}
void set_XPropertyEvent_time(void *_p, unsigned long _v) {((XPropertyEvent *)_p)->time = (unsigned long)_v;}
int get_XPropertyEvent_state(void *_p) {return (int)((XPropertyEvent *)_p)->state;}
void set_XPropertyEvent_state(void *_p, int _v) {((XPropertyEvent *)_p)->state = (int)_v;}
void *alloc_XSelectionClearEvent(void) {XSelectionClearEvent *_p = (XSelectionClearEvent *)malloc(sizeof(XSelectionClearEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSelectionClearEvent(void *_p) {if (_p==NULL) abort(); free((XSelectionClearEvent *)_p);}
int get_XSelectionClearEvent_type(void *_p) {return (int)((XSelectionClearEvent *)_p)->type;}
void set_XSelectionClearEvent_type(void *_p, int _v) {((XSelectionClearEvent *)_p)->type = (int)_v;}
unsigned long get_XSelectionClearEvent_serial(void *_p) {return (unsigned long)((XSelectionClearEvent *)_p)->serial;}
void set_XSelectionClearEvent_serial(void *_p, unsigned long _v) {((XSelectionClearEvent *)_p)->serial = (unsigned long)_v;}
int get_XSelectionClearEvent_send_event(void *_p) {return (int)((XSelectionClearEvent *)_p)->send_event;}
void set_XSelectionClearEvent_send_event(void *_p, int _v) {((XSelectionClearEvent *)_p)->send_event = (int)_v;}
void *get_XSelectionClearEvent_display(void *_p) {return (void *)((XSelectionClearEvent *)_p)->display;}
void set_XSelectionClearEvent_display(void *_p, void *_v) {((XSelectionClearEvent *)_p)->display = (Display *)_v;}
unsigned long get_XSelectionClearEvent_window(void *_p) {return (unsigned long)((XSelectionClearEvent *)_p)->window;}
void set_XSelectionClearEvent_window(void *_p, unsigned long _v) {((XSelectionClearEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XSelectionClearEvent_selection(void *_p) {return (unsigned long)((XSelectionClearEvent *)_p)->selection;}
void set_XSelectionClearEvent_selection(void *_p, unsigned long _v) {((XSelectionClearEvent *)_p)->selection = (unsigned long)_v;}
unsigned long get_XSelectionClearEvent_time(void *_p) {return (unsigned long)((XSelectionClearEvent *)_p)->time;}
void set_XSelectionClearEvent_time(void *_p, unsigned long _v) {((XSelectionClearEvent *)_p)->time = (unsigned long)_v;}
void *alloc_XSelectionRequestEvent(void) {XSelectionRequestEvent *_p = (XSelectionRequestEvent *)malloc(sizeof(XSelectionRequestEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSelectionRequestEvent(void *_p) {if (_p==NULL) abort(); free((XSelectionRequestEvent *)_p);}
int get_XSelectionRequestEvent_type(void *_p) {return (int)((XSelectionRequestEvent *)_p)->type;}
void set_XSelectionRequestEvent_type(void *_p, int _v) {((XSelectionRequestEvent *)_p)->type = (int)_v;}
unsigned long get_XSelectionRequestEvent_serial(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->serial;}
void set_XSelectionRequestEvent_serial(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->serial = (unsigned long)_v;}
int get_XSelectionRequestEvent_send_event(void *_p) {return (int)((XSelectionRequestEvent *)_p)->send_event;}
void set_XSelectionRequestEvent_send_event(void *_p, int _v) {((XSelectionRequestEvent *)_p)->send_event = (int)_v;}
void *get_XSelectionRequestEvent_display(void *_p) {return (void *)((XSelectionRequestEvent *)_p)->display;}
void set_XSelectionRequestEvent_display(void *_p, void *_v) {((XSelectionRequestEvent *)_p)->display = (Display *)_v;}
unsigned long get_XSelectionRequestEvent_owner(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->owner;}
void set_XSelectionRequestEvent_owner(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->owner = (unsigned long)_v;}
unsigned long get_XSelectionRequestEvent_requestor(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->requestor;}
void set_XSelectionRequestEvent_requestor(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->requestor = (unsigned long)_v;}
unsigned long get_XSelectionRequestEvent_selection(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->selection;}
void set_XSelectionRequestEvent_selection(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->selection = (unsigned long)_v;}
unsigned long get_XSelectionRequestEvent_target(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->target;}
void set_XSelectionRequestEvent_target(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->target = (unsigned long)_v;}
unsigned long get_XSelectionRequestEvent_property(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->property;}
void set_XSelectionRequestEvent_property(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->property = (unsigned long)_v;}
unsigned long get_XSelectionRequestEvent_time(void *_p) {return (unsigned long)((XSelectionRequestEvent *)_p)->time;}
void set_XSelectionRequestEvent_time(void *_p, unsigned long _v) {((XSelectionRequestEvent *)_p)->time = (unsigned long)_v;}
void *alloc_XSelectionEvent(void) {XSelectionEvent *_p = (XSelectionEvent *)malloc(sizeof(XSelectionEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSelectionEvent(void *_p) {if (_p==NULL) abort(); free((XSelectionEvent *)_p);}
int get_XSelectionEvent_type(void *_p) {return (int)((XSelectionEvent *)_p)->type;}
void set_XSelectionEvent_type(void *_p, int _v) {((XSelectionEvent *)_p)->type = (int)_v;}
unsigned long get_XSelectionEvent_serial(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->serial;}
void set_XSelectionEvent_serial(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->serial = (unsigned long)_v;}
int get_XSelectionEvent_send_event(void *_p) {return (int)((XSelectionEvent *)_p)->send_event;}
void set_XSelectionEvent_send_event(void *_p, int _v) {((XSelectionEvent *)_p)->send_event = (int)_v;}
void *get_XSelectionEvent_display(void *_p) {return (void *)((XSelectionEvent *)_p)->display;}
void set_XSelectionEvent_display(void *_p, void *_v) {((XSelectionEvent *)_p)->display = (Display *)_v;}
unsigned long get_XSelectionEvent_requestor(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->requestor;}
void set_XSelectionEvent_requestor(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->requestor = (unsigned long)_v;}
unsigned long get_XSelectionEvent_selection(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->selection;}
void set_XSelectionEvent_selection(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->selection = (unsigned long)_v;}
unsigned long get_XSelectionEvent_target(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->target;}
void set_XSelectionEvent_target(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->target = (unsigned long)_v;}
unsigned long get_XSelectionEvent_property(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->property;}
void set_XSelectionEvent_property(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->property = (unsigned long)_v;}
unsigned long get_XSelectionEvent_time(void *_p) {return (unsigned long)((XSelectionEvent *)_p)->time;}
void set_XSelectionEvent_time(void *_p, unsigned long _v) {((XSelectionEvent *)_p)->time = (unsigned long)_v;}
void *alloc_XColormapEvent(void) {XColormapEvent *_p = (XColormapEvent *)malloc(sizeof(XColormapEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XColormapEvent(void *_p) {if (_p==NULL) abort(); free((XColormapEvent *)_p);}
int get_XColormapEvent_type(void *_p) {return (int)((XColormapEvent *)_p)->type;}
void set_XColormapEvent_type(void *_p, int _v) {((XColormapEvent *)_p)->type = (int)_v;}
unsigned long get_XColormapEvent_serial(void *_p) {return (unsigned long)((XColormapEvent *)_p)->serial;}
void set_XColormapEvent_serial(void *_p, unsigned long _v) {((XColormapEvent *)_p)->serial = (unsigned long)_v;}
int get_XColormapEvent_send_event(void *_p) {return (int)((XColormapEvent *)_p)->send_event;}
void set_XColormapEvent_send_event(void *_p, int _v) {((XColormapEvent *)_p)->send_event = (int)_v;}
void *get_XColormapEvent_display(void *_p) {return (void *)((XColormapEvent *)_p)->display;}
void set_XColormapEvent_display(void *_p, void *_v) {((XColormapEvent *)_p)->display = (Display *)_v;}
unsigned long get_XColormapEvent_window(void *_p) {return (unsigned long)((XColormapEvent *)_p)->window;}
void set_XColormapEvent_window(void *_p, unsigned long _v) {((XColormapEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XColormapEvent_colormap(void *_p) {return (unsigned long)((XColormapEvent *)_p)->colormap;}
void set_XColormapEvent_colormap(void *_p, unsigned long _v) {((XColormapEvent *)_p)->colormap = (unsigned long)_v;}
int get_XColormapEvent_new(void *_p) {return (int)((XColormapEvent *)_p)->new;}
void set_XColormapEvent_new(void *_p, int _v) {((XColormapEvent *)_p)->new = (int)_v;}
int get_XColormapEvent_state(void *_p) {return (int)((XColormapEvent *)_p)->state;}
void set_XColormapEvent_state(void *_p, int _v) {((XColormapEvent *)_p)->state = (int)_v;}
void *alloc_XClientMessageEvent(void) {XClientMessageEvent *_p = (XClientMessageEvent *)malloc(sizeof(XClientMessageEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XClientMessageEvent(void *_p) {if (_p==NULL) abort(); free((XClientMessageEvent *)_p);}
int get_XClientMessageEvent_type(void *_p) {return (int)((XClientMessageEvent *)_p)->type;}
void set_XClientMessageEvent_type(void *_p, int _v) {((XClientMessageEvent *)_p)->type = (int)_v;}
unsigned long get_XClientMessageEvent_serial(void *_p) {return (unsigned long)((XClientMessageEvent *)_p)->serial;}
void set_XClientMessageEvent_serial(void *_p, unsigned long _v) {((XClientMessageEvent *)_p)->serial = (unsigned long)_v;}
int get_XClientMessageEvent_send_event(void *_p) {return (int)((XClientMessageEvent *)_p)->send_event;}
void set_XClientMessageEvent_send_event(void *_p, int _v) {((XClientMessageEvent *)_p)->send_event = (int)_v;}
void *get_XClientMessageEvent_display(void *_p) {return (void *)((XClientMessageEvent *)_p)->display;}
void set_XClientMessageEvent_display(void *_p, void *_v) {((XClientMessageEvent *)_p)->display = (Display *)_v;}
unsigned long get_XClientMessageEvent_window(void *_p) {return (unsigned long)((XClientMessageEvent *)_p)->window;}
void set_XClientMessageEvent_window(void *_p, unsigned long _v) {((XClientMessageEvent *)_p)->window = (unsigned long)_v;}
unsigned long get_XClientMessageEvent_message_type(void *_p) {return (unsigned long)((XClientMessageEvent *)_p)->message_type;}
void set_XClientMessageEvent_message_type(void *_p, unsigned long _v) {((XClientMessageEvent *)_p)->message_type = (unsigned long)_v;}
int get_XClientMessageEvent_format(void *_p) {return (int)((XClientMessageEvent *)_p)->format;}
void set_XClientMessageEvent_format(void *_p, int _v) {((XClientMessageEvent *)_p)->format = (int)_v;}
void *get_XClientMessageEvent_data_b(void *_p) {return (void *)(((XClientMessageEvent *)_p)->data.b);}
void *get_XClientMessageEvent_data_s(void *_p) {return (void *)(((XClientMessageEvent *)_p)->data.s);}
void *get_XClientMessageEvent_data_l(void *_p) {return (void *)(((XClientMessageEvent *)_p)->data.l);}
void *alloc_XMappingEvent(void) {XMappingEvent *_p = (XMappingEvent *)malloc(sizeof(XMappingEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XMappingEvent(void *_p) {if (_p==NULL) abort(); free((XMappingEvent *)_p);}
int get_XMappingEvent_type(void *_p) {return (int)((XMappingEvent *)_p)->type;}
void set_XMappingEvent_type(void *_p, int _v) {((XMappingEvent *)_p)->type = (int)_v;}
unsigned long get_XMappingEvent_serial(void *_p) {return (unsigned long)((XMappingEvent *)_p)->serial;}
void set_XMappingEvent_serial(void *_p, unsigned long _v) {((XMappingEvent *)_p)->serial = (unsigned long)_v;}
int get_XMappingEvent_send_event(void *_p) {return (int)((XMappingEvent *)_p)->send_event;}
void set_XMappingEvent_send_event(void *_p, int _v) {((XMappingEvent *)_p)->send_event = (int)_v;}
void *get_XMappingEvent_display(void *_p) {return (void *)((XMappingEvent *)_p)->display;}
void set_XMappingEvent_display(void *_p, void *_v) {((XMappingEvent *)_p)->display = (Display *)_v;}
unsigned long get_XMappingEvent_window(void *_p) {return (unsigned long)((XMappingEvent *)_p)->window;}
void set_XMappingEvent_window(void *_p, unsigned long _v) {((XMappingEvent *)_p)->window = (unsigned long)_v;}
int get_XMappingEvent_request(void *_p) {return (int)((XMappingEvent *)_p)->request;}
void set_XMappingEvent_request(void *_p, int _v) {((XMappingEvent *)_p)->request = (int)_v;}
int get_XMappingEvent_first_keycode(void *_p) {return (int)((XMappingEvent *)_p)->first_keycode;}
void set_XMappingEvent_first_keycode(void *_p, int _v) {((XMappingEvent *)_p)->first_keycode = (int)_v;}
int get_XMappingEvent_count(void *_p) {return (int)((XMappingEvent *)_p)->count;}
void set_XMappingEvent_count(void *_p, int _v) {((XMappingEvent *)_p)->count = (int)_v;}
void *alloc_XErrorEvent(void) {XErrorEvent *_p = (XErrorEvent *)malloc(sizeof(XErrorEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XErrorEvent(void *_p) {if (_p==NULL) abort(); free((XErrorEvent *)_p);}
int get_XErrorEvent_type(void *_p) {return (int)((XErrorEvent *)_p)->type;}
void set_XErrorEvent_type(void *_p, int _v) {((XErrorEvent *)_p)->type = (int)_v;}
void *get_XErrorEvent_display(void *_p) {return (void *)((XErrorEvent *)_p)->display;}
void set_XErrorEvent_display(void *_p, void *_v) {((XErrorEvent *)_p)->display = (Display *)_v;}
unsigned long get_XErrorEvent_resourceid(void *_p) {return (unsigned long)((XErrorEvent *)_p)->resourceid;}
void set_XErrorEvent_resourceid(void *_p, unsigned long _v) {((XErrorEvent *)_p)->resourceid = (unsigned long)_v;}
unsigned long get_XErrorEvent_serial(void *_p) {return (unsigned long)((XErrorEvent *)_p)->serial;}
void set_XErrorEvent_serial(void *_p, unsigned long _v) {((XErrorEvent *)_p)->serial = (unsigned long)_v;}
unsigned char get_XErrorEvent_error_code(void *_p) {return (unsigned char)((XErrorEvent *)_p)->error_code;}
void set_XErrorEvent_error_code(void *_p, unsigned char _v) {((XErrorEvent *)_p)->error_code = (unsigned char)_v;}
unsigned char get_XErrorEvent_request_code(void *_p) {return (unsigned char)((XErrorEvent *)_p)->request_code;}
void set_XErrorEvent_request_code(void *_p, unsigned char _v) {((XErrorEvent *)_p)->request_code = (unsigned char)_v;}
unsigned char get_XErrorEvent_minor_code(void *_p) {return (unsigned char)((XErrorEvent *)_p)->minor_code;}
void set_XErrorEvent_minor_code(void *_p, unsigned char _v) {((XErrorEvent *)_p)->minor_code = (unsigned char)_v;}
void *alloc_XAnyEvent(void) {XAnyEvent *_p = (XAnyEvent *)malloc(sizeof(XAnyEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XAnyEvent(void *_p) {if (_p==NULL) abort(); free((XAnyEvent *)_p);}
int get_XAnyEvent_type(void *_p) {return (int)((XAnyEvent *)_p)->type;}
void set_XAnyEvent_type(void *_p, int _v) {((XAnyEvent *)_p)->type = (int)_v;}
unsigned long get_XAnyEvent_serial(void *_p) {return (unsigned long)((XAnyEvent *)_p)->serial;}
void set_XAnyEvent_serial(void *_p, unsigned long _v) {((XAnyEvent *)_p)->serial = (unsigned long)_v;}
int get_XAnyEvent_send_event(void *_p) {return (int)((XAnyEvent *)_p)->send_event;}
void set_XAnyEvent_send_event(void *_p, int _v) {((XAnyEvent *)_p)->send_event = (int)_v;}
void *get_XAnyEvent_display(void *_p) {return (void *)((XAnyEvent *)_p)->display;}
void set_XAnyEvent_display(void *_p, void *_v) {((XAnyEvent *)_p)->display = (Display *)_v;}
unsigned long get_XAnyEvent_window(void *_p) {return (unsigned long)((XAnyEvent *)_p)->window;}
void set_XAnyEvent_window(void *_p, unsigned long _v) {((XAnyEvent *)_p)->window = (unsigned long)_v;}
void *alloc_XCharStruct(void) {XCharStruct *_p = (XCharStruct *)malloc(sizeof(XCharStruct)); if (_p==NULL) abort(); return (void *)_p;}
void free_XCharStruct(void *_p) {if (_p==NULL) abort(); free((XCharStruct *)_p);}
short get_XCharStruct_lbearing(void *_p) {return (short)((XCharStruct *)_p)->lbearing;}
void set_XCharStruct_lbearing(void *_p, short _v) {((XCharStruct *)_p)->lbearing = (short)_v;}
short get_XCharStruct_rbearing(void *_p) {return (short)((XCharStruct *)_p)->rbearing;}
void set_XCharStruct_rbearing(void *_p, short _v) {((XCharStruct *)_p)->rbearing = (short)_v;}
short get_XCharStruct_width(void *_p) {return (short)((XCharStruct *)_p)->width;}
void set_XCharStruct_width(void *_p, short _v) {((XCharStruct *)_p)->width = (short)_v;}
short get_XCharStruct_ascent(void *_p) {return (short)((XCharStruct *)_p)->ascent;}
void set_XCharStruct_ascent(void *_p, short _v) {((XCharStruct *)_p)->ascent = (short)_v;}
short get_XCharStruct_descent(void *_p) {return (short)((XCharStruct *)_p)->descent;}
void set_XCharStruct_descent(void *_p, short _v) {((XCharStruct *)_p)->descent = (short)_v;}
unsigned short get_XCharStruct_attributes(void *_p) {return (unsigned short)((XCharStruct *)_p)->attributes;}
void set_XCharStruct_attributes(void *_p, unsigned short _v) {((XCharStruct *)_p)->attributes = (unsigned short)_v;}
void *alloc_XFontProp(void) {XFontProp *_p = (XFontProp *)malloc(sizeof(XFontProp)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFontProp(void *_p) {if (_p==NULL) abort(); free((XFontProp *)_p);}
unsigned long get_XFontProp_name(void *_p) {return (unsigned long)((XFontProp *)_p)->name;}
void set_XFontProp_name(void *_p, unsigned long _v) {((XFontProp *)_p)->name = (unsigned long)_v;}
unsigned long get_XFontProp_card32(void *_p) {return (unsigned long)((XFontProp *)_p)->card32;}
void set_XFontProp_card32(void *_p, unsigned long _v) {((XFontProp *)_p)->card32 = (unsigned long)_v;}
void *alloc_XFontStruct(void) {XFontStruct *_p = (XFontStruct *)malloc(sizeof(XFontStruct)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFontStruct(void *_p) {if (_p==NULL) abort(); free((XFontStruct *)_p);}
void *get_XFontStruct_ext_data(void *_p) {return (void *)((XFontStruct *)_p)->ext_data;}
void set_XFontStruct_ext_data(void *_p, void *_v) {((XFontStruct *)_p)->ext_data = (XExtData *)_v;}
unsigned long get_XFontStruct_fid(void *_p) {return (unsigned long)((XFontStruct *)_p)->fid;}
void set_XFontStruct_fid(void *_p, unsigned long _v) {((XFontStruct *)_p)->fid = (unsigned long)_v;}
unsigned get_XFontStruct_direction(void *_p) {return (unsigned)((XFontStruct *)_p)->direction;}
void set_XFontStruct_direction(void *_p, unsigned _v) {((XFontStruct *)_p)->direction = (unsigned)_v;}
unsigned get_XFontStruct_min_char_or_byte2(void *_p) {return (unsigned)((XFontStruct *)_p)->min_char_or_byte2;}
void set_XFontStruct_min_char_or_byte2(void *_p, unsigned _v) {((XFontStruct *)_p)->min_char_or_byte2 = (unsigned)_v;}
unsigned get_XFontStruct_max_char_or_byte2(void *_p) {return (unsigned)((XFontStruct *)_p)->max_char_or_byte2;}
void set_XFontStruct_max_char_or_byte2(void *_p, unsigned _v) {((XFontStruct *)_p)->max_char_or_byte2 = (unsigned)_v;}
unsigned get_XFontStruct_min_byte1(void *_p) {return (unsigned)((XFontStruct *)_p)->min_byte1;}
void set_XFontStruct_min_byte1(void *_p, unsigned _v) {((XFontStruct *)_p)->min_byte1 = (unsigned)_v;}
unsigned get_XFontStruct_max_byte1(void *_p) {return (unsigned)((XFontStruct *)_p)->max_byte1;}
void set_XFontStruct_max_byte1(void *_p, unsigned _v) {((XFontStruct *)_p)->max_byte1 = (unsigned)_v;}
int get_XFontStruct_all_chars_exist(void *_p) {return (int)((XFontStruct *)_p)->all_chars_exist;}
void set_XFontStruct_all_chars_exist(void *_p, int _v) {((XFontStruct *)_p)->all_chars_exist = (int)_v;}
unsigned get_XFontStruct_default_char(void *_p) {return (unsigned)((XFontStruct *)_p)->default_char;}
void set_XFontStruct_default_char(void *_p, unsigned _v) {((XFontStruct *)_p)->default_char = (unsigned)_v;}
int get_XFontStruct_n_properties(void *_p) {return (int)((XFontStruct *)_p)->n_properties;}
void set_XFontStruct_n_properties(void *_p, int _v) {((XFontStruct *)_p)->n_properties = (int)_v;}
void *get_XFontStruct_properties(void *_p) {return (void *)((XFontStruct *)_p)->properties;}
void set_XFontStruct_properties(void *_p, void *_v) {((XFontStruct *)_p)->properties = (XFontProp *)_v;}
short get_XFontStruct_min_bounds_lbearing(void *_p) {return (short)((XFontStruct *)_p)->min_bounds.lbearing;}
void set_XFontStruct_min_bounds_lbearing(void *_p, short _v) {((XFontStruct *)_p)->min_bounds.lbearing = (short)_v;}
short get_XFontStruct_min_bounds_rbearing(void *_p) {return (short)((XFontStruct *)_p)->min_bounds.rbearing;}
void set_XFontStruct_min_bounds_rbearing(void *_p, short _v) {((XFontStruct *)_p)->min_bounds.rbearing = (short)_v;}
short get_XFontStruct_min_bounds_width(void *_p) {return (short)((XFontStruct *)_p)->min_bounds.width;}
void set_XFontStruct_min_bounds_width(void *_p, short _v) {((XFontStruct *)_p)->min_bounds.width = (short)_v;}
short get_XFontStruct_min_bounds_ascent(void *_p) {return (short)((XFontStruct *)_p)->min_bounds.ascent;}
void set_XFontStruct_min_bounds_ascent(void *_p, short _v) {((XFontStruct *)_p)->min_bounds.ascent = (short)_v;}
short get_XFontStruct_min_bounds_descent(void *_p) {return (short)((XFontStruct *)_p)->min_bounds.descent;}
void set_XFontStruct_min_bounds_descent(void *_p, short _v) {((XFontStruct *)_p)->min_bounds.descent = (short)_v;}
unsigned short get_XFontStruct_min_bounds_attributes(void *_p) {return (unsigned short)((XFontStruct *)_p)->min_bounds.attributes;}
void set_XFontStruct_min_bounds_attributes(void *_p, unsigned short _v) {((XFontStruct *)_p)->min_bounds.attributes = (unsigned short)_v;}
short get_XFontStruct_max_bounds_lbearing(void *_p) {return (short)((XFontStruct *)_p)->max_bounds.lbearing;}
void set_XFontStruct_max_bounds_lbearing(void *_p, short _v) {((XFontStruct *)_p)->max_bounds.lbearing = (short)_v;}
short get_XFontStruct_max_bounds_rbearing(void *_p) {return (short)((XFontStruct *)_p)->max_bounds.rbearing;}
void set_XFontStruct_max_bounds_rbearing(void *_p, short _v) {((XFontStruct *)_p)->max_bounds.rbearing = (short)_v;}
short get_XFontStruct_max_bounds_width(void *_p) {return (short)((XFontStruct *)_p)->max_bounds.width;}
void set_XFontStruct_max_bounds_width(void *_p, short _v) {((XFontStruct *)_p)->max_bounds.width = (short)_v;}
short get_XFontStruct_max_bounds_ascent(void *_p) {return (short)((XFontStruct *)_p)->max_bounds.ascent;}
void set_XFontStruct_max_bounds_ascent(void *_p, short _v) {((XFontStruct *)_p)->max_bounds.ascent = (short)_v;}
short get_XFontStruct_max_bounds_descent(void *_p) {return (short)((XFontStruct *)_p)->max_bounds.descent;}
void set_XFontStruct_max_bounds_descent(void *_p, short _v) {((XFontStruct *)_p)->max_bounds.descent = (short)_v;}
unsigned short get_XFontStruct_max_bounds_attributes(void *_p) {return (unsigned short)((XFontStruct *)_p)->max_bounds.attributes;}
void set_XFontStruct_max_bounds_attributes(void *_p, unsigned short _v) {((XFontStruct *)_p)->max_bounds.attributes = (unsigned short)_v;}
void *get_XFontStruct_per_char(void *_p) {return (void *)((XFontStruct *)_p)->per_char;}
void set_XFontStruct_per_char(void *_p, void *_v) {((XFontStruct *)_p)->per_char = (XCharStruct *)_v;}
int get_XFontStruct_ascent(void *_p) {return (int)((XFontStruct *)_p)->ascent;}
void set_XFontStruct_ascent(void *_p, int _v) {((XFontStruct *)_p)->ascent = (int)_v;}
int get_XFontStruct_descent(void *_p) {return (int)((XFontStruct *)_p)->descent;}
void set_XFontStruct_descent(void *_p, int _v) {((XFontStruct *)_p)->descent = (int)_v;}
void *alloc_XTextItem(void) {XTextItem *_p = (XTextItem *)malloc(sizeof(XTextItem)); if (_p==NULL) abort(); return (void *)_p;}
void free_XTextItem(void *_p) {if (_p==NULL) abort(); free((XTextItem *)_p);}
void *get_XTextItem_chars(void *_p) {return (void *)((XTextItem *)_p)->chars;}
void set_XTextItem_chars(void *_p, void *_v) {((XTextItem *)_p)->chars = (char *)_v;}
int get_XTextItem_nchars(void *_p) {return (int)((XTextItem *)_p)->nchars;}
void set_XTextItem_nchars(void *_p, int _v) {((XTextItem *)_p)->nchars = (int)_v;}
int get_XTextItem_delta(void *_p) {return (int)((XTextItem *)_p)->delta;}
void set_XTextItem_delta(void *_p, int _v) {((XTextItem *)_p)->delta = (int)_v;}
unsigned long get_XTextItem_font(void *_p) {return (unsigned long)((XTextItem *)_p)->font;}
void set_XTextItem_font(void *_p, unsigned long _v) {((XTextItem *)_p)->font = (unsigned long)_v;}
void *alloc_XChar2b(void) {XChar2b *_p = (XChar2b *)malloc(sizeof(XChar2b)); if (_p==NULL) abort(); return (void *)_p;}
void free_XChar2b(void *_p) {if (_p==NULL) abort(); free((XChar2b *)_p);}
unsigned char get_XChar2b_byte1(void *_p) {return (unsigned char)((XChar2b *)_p)->byte1;}
void set_XChar2b_byte1(void *_p, unsigned char _v) {((XChar2b *)_p)->byte1 = (unsigned char)_v;}
unsigned char get_XChar2b_byte2(void *_p) {return (unsigned char)((XChar2b *)_p)->byte2;}
void set_XChar2b_byte2(void *_p, unsigned char _v) {((XChar2b *)_p)->byte2 = (unsigned char)_v;}
void *alloc_XTextItem16(void) {XTextItem16 *_p = (XTextItem16 *)malloc(sizeof(XTextItem16)); if (_p==NULL) abort(); return (void *)_p;}
void free_XTextItem16(void *_p) {if (_p==NULL) abort(); free((XTextItem16 *)_p);}
void *get_XTextItem16_chars(void *_p) {return (void *)((XTextItem16 *)_p)->chars;}
void set_XTextItem16_chars(void *_p, void *_v) {((XTextItem16 *)_p)->chars = (XChar2b *)_v;}
int get_XTextItem16_nchars(void *_p) {return (int)((XTextItem16 *)_p)->nchars;}
void set_XTextItem16_nchars(void *_p, int _v) {((XTextItem16 *)_p)->nchars = (int)_v;}
int get_XTextItem16_delta(void *_p) {return (int)((XTextItem16 *)_p)->delta;}
void set_XTextItem16_delta(void *_p, int _v) {((XTextItem16 *)_p)->delta = (int)_v;}
unsigned long get_XTextItem16_font(void *_p) {return (unsigned long)((XTextItem16 *)_p)->font;}
void set_XTextItem16_font(void *_p, unsigned long _v) {((XTextItem16 *)_p)->font = (unsigned long)_v;}
void *alloc_XFontSetExtents(void) {XFontSetExtents *_p = (XFontSetExtents *)malloc(sizeof(XFontSetExtents)); if (_p==NULL) abort(); return (void *)_p;}
void free_XFontSetExtents(void *_p) {if (_p==NULL) abort(); free((XFontSetExtents *)_p);}
short get_XFontSetExtents_max_ink_extent_x(void *_p) {return (short)((XFontSetExtents *)_p)->max_ink_extent.x;}
void set_XFontSetExtents_max_ink_extent_x(void *_p, short _v) {((XFontSetExtents *)_p)->max_ink_extent.x = (short)_v;}
short get_XFontSetExtents_max_ink_extent_y(void *_p) {return (short)((XFontSetExtents *)_p)->max_ink_extent.y;}
void set_XFontSetExtents_max_ink_extent_y(void *_p, short _v) {((XFontSetExtents *)_p)->max_ink_extent.y = (short)_v;}
unsigned short get_XFontSetExtents_max_ink_extent_width(void *_p) {return (unsigned short)((XFontSetExtents *)_p)->max_ink_extent.width;}
void set_XFontSetExtents_max_ink_extent_width(void *_p, unsigned short _v) {((XFontSetExtents *)_p)->max_ink_extent.width = (unsigned short)_v;}
unsigned short get_XFontSetExtents_max_ink_extent_height(void *_p) {return (unsigned short)((XFontSetExtents *)_p)->max_ink_extent.height;}
void set_XFontSetExtents_max_ink_extent_height(void *_p, unsigned short _v) {((XFontSetExtents *)_p)->max_ink_extent.height = (unsigned short)_v;}
short get_XFontSetExtents_max_logical_extent_x(void *_p) {return (short)((XFontSetExtents *)_p)->max_logical_extent.x;}
void set_XFontSetExtents_max_logical_extent_x(void *_p, short _v) {((XFontSetExtents *)_p)->max_logical_extent.x = (short)_v;}
short get_XFontSetExtents_max_logical_extent_y(void *_p) {return (short)((XFontSetExtents *)_p)->max_logical_extent.y;}
void set_XFontSetExtents_max_logical_extent_y(void *_p, short _v) {((XFontSetExtents *)_p)->max_logical_extent.y = (short)_v;}
unsigned short get_XFontSetExtents_max_logical_extent_width(void *_p) {return (unsigned short)((XFontSetExtents *)_p)->max_logical_extent.width;}
void set_XFontSetExtents_max_logical_extent_width(void *_p, unsigned short _v) {((XFontSetExtents *)_p)->max_logical_extent.width = (unsigned short)_v;}
unsigned short get_XFontSetExtents_max_logical_extent_height(void *_p) {return (unsigned short)((XFontSetExtents *)_p)->max_logical_extent.height;}
void set_XFontSetExtents_max_logical_extent_height(void *_p, unsigned short _v) {((XFontSetExtents *)_p)->max_logical_extent.height = (unsigned short)_v;}
void *alloc_XmbTextItem(void) {XmbTextItem *_p = (XmbTextItem *)malloc(sizeof(XmbTextItem)); if (_p==NULL) abort(); return (void *)_p;}
void free_XmbTextItem(void *_p) {if (_p==NULL) abort(); free((XmbTextItem *)_p);}
void *get_XmbTextItem_chars(void *_p) {return (void *)((XmbTextItem *)_p)->chars;}
void set_XmbTextItem_chars(void *_p, void *_v) {((XmbTextItem *)_p)->chars = (char *)_v;}
int get_XmbTextItem_nchars(void *_p) {return (int)((XmbTextItem *)_p)->nchars;}
void set_XmbTextItem_nchars(void *_p, int _v) {((XmbTextItem *)_p)->nchars = (int)_v;}
int get_XmbTextItem_delta(void *_p) {return (int)((XmbTextItem *)_p)->delta;}
void set_XmbTextItem_delta(void *_p, int _v) {((XmbTextItem *)_p)->delta = (int)_v;}
void *get_XmbTextItem_font_set(void *_p) {return (void *)((XmbTextItem *)_p)->font_set;}
void set_XmbTextItem_font_set(void *_p, void *_v) {((XmbTextItem *)_p)->font_set = (void *)_v;}
void *alloc_XwcTextItem(void) {XwcTextItem *_p = (XwcTextItem *)malloc(sizeof(XwcTextItem)); if (_p==NULL) abort(); return (void *)_p;}
void free_XwcTextItem(void *_p) {if (_p==NULL) abort(); free((XwcTextItem *)_p);}
void *get_XwcTextItem_chars(void *_p) {return (void *)((XwcTextItem *)_p)->chars;}
void set_XwcTextItem_chars(void *_p, void *_v) {((XwcTextItem *)_p)->chars = (wchar_t *)_v;}
int get_XwcTextItem_nchars(void *_p) {return (int)((XwcTextItem *)_p)->nchars;}
void set_XwcTextItem_nchars(void *_p, int _v) {((XwcTextItem *)_p)->nchars = (int)_v;}
int get_XwcTextItem_delta(void *_p) {return (int)((XwcTextItem *)_p)->delta;}
void set_XwcTextItem_delta(void *_p, int _v) {((XwcTextItem *)_p)->delta = (int)_v;}
void *get_XwcTextItem_font_set(void *_p) {return (void *)((XwcTextItem *)_p)->font_set;}
void set_XwcTextItem_font_set(void *_p, void *_v) {((XwcTextItem *)_p)->font_set = (void *)_v;}
void *alloc_XIMStyles(void) {XIMStyles *_p = (XIMStyles *)malloc(sizeof(XIMStyles)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMStyles(void *_p) {if (_p==NULL) abort(); free((XIMStyles *)_p);}
unsigned short get_XIMStyles_count_styles(void *_p) {return (unsigned short)((XIMStyles *)_p)->count_styles;}
void set_XIMStyles_count_styles(void *_p, unsigned short _v) {((XIMStyles *)_p)->count_styles = (unsigned short)_v;}
void *get_XIMStyles_supported_styles(void *_p) {return (void *)((XIMStyles *)_p)->supported_styles;}
void set_XIMStyles_supported_styles(void *_p, void *_v) {((XIMStyles *)_p)->supported_styles = (unsigned long *)_v;}
void *alloc_XIMCallback(void) {XIMCallback *_p = (XIMCallback *)malloc(sizeof(XIMCallback)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMCallback(void *_p) {if (_p==NULL) abort(); free((XIMCallback *)_p);}
void *get_XIMCallback_client_data(void *_p) {return (void *)((XIMCallback *)_p)->client_data;}
void set_XIMCallback_client_data(void *_p, void *_v) {((XIMCallback *)_p)->client_data = (char *)_v;}
void *get_XIMCallback_callback(void *_p) {return (void *)((XIMCallback *)_p)->callback;}
void set_XIMCallback_callback(void *_p, void *_v) {((XIMCallback *)_p)->callback = (void( *)())_v;}
void *alloc_XIMText(void) {XIMText *_p = (XIMText *)malloc(sizeof(XIMText)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMText(void *_p) {if (_p==NULL) abort(); free((XIMText *)_p);}
unsigned short get_XIMText_length(void *_p) {return (unsigned short)((XIMText *)_p)->length;}
void set_XIMText_length(void *_p, unsigned short _v) {((XIMText *)_p)->length = (unsigned short)_v;}
void *get_XIMText_feedback(void *_p) {return (void *)((XIMText *)_p)->feedback;}
void set_XIMText_feedback(void *_p, void *_v) {((XIMText *)_p)->feedback = (unsigned long *)_v;}
int get_XIMText_encoding_is_wchar(void *_p) {return (int)((XIMText *)_p)->encoding_is_wchar;}
void set_XIMText_encoding_is_wchar(void *_p, int _v) {((XIMText *)_p)->encoding_is_wchar = (int)_v;}
void *get_XIMText_string_multi_byte(void *_p) {return (void *)((XIMText *)_p)->string.multi_byte;}
void set_XIMText_string_multi_byte(void *_p, void *_v) {((XIMText *)_p)->string.multi_byte = (char *)_v;}
void *get_XIMText_string_wide_char(void *_p) {return (void *)((XIMText *)_p)->string.wide_char;}
void set_XIMText_string_wide_char(void *_p, void *_v) {((XIMText *)_p)->string.wide_char = (wchar_t *)_v;}
void *alloc_XIMPreeditDrawCallbackStruct(void) {XIMPreeditDrawCallbackStruct *_p = (XIMPreeditDrawCallbackStruct *)malloc(sizeof(XIMPreeditDrawCallbackStruct)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMPreeditDrawCallbackStruct(void *_p) {if (_p==NULL) abort(); free((XIMPreeditDrawCallbackStruct *)_p);}
int get_XIMPreeditDrawCallbackStruct_caret(void *_p) {return (int)((XIMPreeditDrawCallbackStruct *)_p)->caret;}
void set_XIMPreeditDrawCallbackStruct_caret(void *_p, int _v) {((XIMPreeditDrawCallbackStruct *)_p)->caret = (int)_v;}
int get_XIMPreeditDrawCallbackStruct_chg_first(void *_p) {return (int)((XIMPreeditDrawCallbackStruct *)_p)->chg_first;}
void set_XIMPreeditDrawCallbackStruct_chg_first(void *_p, int _v) {((XIMPreeditDrawCallbackStruct *)_p)->chg_first = (int)_v;}
int get_XIMPreeditDrawCallbackStruct_chg_length(void *_p) {return (int)((XIMPreeditDrawCallbackStruct *)_p)->chg_length;}
void set_XIMPreeditDrawCallbackStruct_chg_length(void *_p, int _v) {((XIMPreeditDrawCallbackStruct *)_p)->chg_length = (int)_v;}
void *get_XIMPreeditDrawCallbackStruct_text(void *_p) {return (void *)((XIMPreeditDrawCallbackStruct *)_p)->text;}
void set_XIMPreeditDrawCallbackStruct_text(void *_p, void *_v) {((XIMPreeditDrawCallbackStruct *)_p)->text = (XIMText *)_v;}
void *alloc_XIMPreeditCaretCallbackStruct(void) {XIMPreeditCaretCallbackStruct *_p = (XIMPreeditCaretCallbackStruct *)malloc(sizeof(XIMPreeditCaretCallbackStruct)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMPreeditCaretCallbackStruct(void *_p) {if (_p==NULL) abort(); free((XIMPreeditCaretCallbackStruct *)_p);}
int get_XIMPreeditCaretCallbackStruct_position(void *_p) {return (int)((XIMPreeditCaretCallbackStruct *)_p)->position;}
void set_XIMPreeditCaretCallbackStruct_position(void *_p, int _v) {((XIMPreeditCaretCallbackStruct *)_p)->position = (int)_v;}
int get_XIMPreeditCaretCallbackStruct_direction(void *_p) {return (int)((XIMPreeditCaretCallbackStruct *)_p)->direction;}
void set_XIMPreeditCaretCallbackStruct_direction(void *_p, int _v) {((XIMPreeditCaretCallbackStruct *)_p)->direction = (int)_v;}
int get_XIMPreeditCaretCallbackStruct_style(void *_p) {return (int)((XIMPreeditCaretCallbackStruct *)_p)->style;}
void set_XIMPreeditCaretCallbackStruct_style(void *_p, int _v) {((XIMPreeditCaretCallbackStruct *)_p)->style = (int)_v;}
void *alloc_XIMStatusDrawCallbackStruct(void) {XIMStatusDrawCallbackStruct *_p = (XIMStatusDrawCallbackStruct *)malloc(sizeof(XIMStatusDrawCallbackStruct)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIMStatusDrawCallbackStruct(void *_p) {if (_p==NULL) abort(); free((XIMStatusDrawCallbackStruct *)_p);}
int get_XIMStatusDrawCallbackStruct_type(void *_p) {return (int)((XIMStatusDrawCallbackStruct *)_p)->type;}
void set_XIMStatusDrawCallbackStruct_type(void *_p, int _v) {((XIMStatusDrawCallbackStruct *)_p)->type = (int)_v;}
void *get_XIMStatusDrawCallbackStruct_data_text(void *_p) {return (void *)((XIMStatusDrawCallbackStruct *)_p)->data.text;}
void set_XIMStatusDrawCallbackStruct_data_text(void *_p, void *_v) {((XIMStatusDrawCallbackStruct *)_p)->data.text = (XIMText *)_v;}
unsigned long get_XIMStatusDrawCallbackStruct_data_bitmap(void *_p) {return (unsigned long)((XIMStatusDrawCallbackStruct *)_p)->data.bitmap;}
void set_XIMStatusDrawCallbackStruct_data_bitmap(void *_p, unsigned long _v) {((XIMStatusDrawCallbackStruct *)_p)->data.bitmap = (unsigned long)_v;}
void *alloc_XSizeHints(void) {XSizeHints *_p = (XSizeHints *)malloc(sizeof(XSizeHints)); if (_p==NULL) abort(); return (void *)_p;}
void free_XSizeHints(void *_p) {if (_p==NULL) abort(); free((XSizeHints *)_p);}
long get_XSizeHints_flags(void *_p) {return (long)((XSizeHints *)_p)->flags;}
void set_XSizeHints_flags(void *_p, long _v) {((XSizeHints *)_p)->flags = (long)_v;}
int get_XSizeHints_x(void *_p) {return (int)((XSizeHints *)_p)->x;}
void set_XSizeHints_x(void *_p, int _v) {((XSizeHints *)_p)->x = (int)_v;}
int get_XSizeHints_y(void *_p) {return (int)((XSizeHints *)_p)->y;}
void set_XSizeHints_y(void *_p, int _v) {((XSizeHints *)_p)->y = (int)_v;}
int get_XSizeHints_width(void *_p) {return (int)((XSizeHints *)_p)->width;}
void set_XSizeHints_width(void *_p, int _v) {((XSizeHints *)_p)->width = (int)_v;}
int get_XSizeHints_height(void *_p) {return (int)((XSizeHints *)_p)->height;}
void set_XSizeHints_height(void *_p, int _v) {((XSizeHints *)_p)->height = (int)_v;}
int get_XSizeHints_min_width(void *_p) {return (int)((XSizeHints *)_p)->min_width;}
void set_XSizeHints_min_width(void *_p, int _v) {((XSizeHints *)_p)->min_width = (int)_v;}
int get_XSizeHints_min_height(void *_p) {return (int)((XSizeHints *)_p)->min_height;}
void set_XSizeHints_min_height(void *_p, int _v) {((XSizeHints *)_p)->min_height = (int)_v;}
int get_XSizeHints_max_width(void *_p) {return (int)((XSizeHints *)_p)->max_width;}
void set_XSizeHints_max_width(void *_p, int _v) {((XSizeHints *)_p)->max_width = (int)_v;}
int get_XSizeHints_max_height(void *_p) {return (int)((XSizeHints *)_p)->max_height;}
void set_XSizeHints_max_height(void *_p, int _v) {((XSizeHints *)_p)->max_height = (int)_v;}
int get_XSizeHints_width_inc(void *_p) {return (int)((XSizeHints *)_p)->width_inc;}
void set_XSizeHints_width_inc(void *_p, int _v) {((XSizeHints *)_p)->width_inc = (int)_v;}
int get_XSizeHints_height_inc(void *_p) {return (int)((XSizeHints *)_p)->height_inc;}
void set_XSizeHints_height_inc(void *_p, int _v) {((XSizeHints *)_p)->height_inc = (int)_v;}
int get_XSizeHints_min_aspect_x(void *_p) {return (int)((XSizeHints *)_p)->min_aspect.x;}
void set_XSizeHints_min_aspect_x(void *_p, int _v) {((XSizeHints *)_p)->min_aspect.x = (int)_v;}
int get_XSizeHints_min_aspect_y(void *_p) {return (int)((XSizeHints *)_p)->min_aspect.y;}
void set_XSizeHints_min_aspect_y(void *_p, int _v) {((XSizeHints *)_p)->min_aspect.y = (int)_v;}
int get_XSizeHints_max_aspect_x(void *_p) {return (int)((XSizeHints *)_p)->max_aspect.x;}
void set_XSizeHints_max_aspect_x(void *_p, int _v) {((XSizeHints *)_p)->max_aspect.x = (int)_v;}
int get_XSizeHints_max_aspect_y(void *_p) {return (int)((XSizeHints *)_p)->max_aspect.y;}
void set_XSizeHints_max_aspect_y(void *_p, int _v) {((XSizeHints *)_p)->max_aspect.y = (int)_v;}
int get_XSizeHints_base_width(void *_p) {return (int)((XSizeHints *)_p)->base_width;}
void set_XSizeHints_base_width(void *_p, int _v) {((XSizeHints *)_p)->base_width = (int)_v;}
int get_XSizeHints_base_height(void *_p) {return (int)((XSizeHints *)_p)->base_height;}
void set_XSizeHints_base_height(void *_p, int _v) {((XSizeHints *)_p)->base_height = (int)_v;}
int get_XSizeHints_win_gravity(void *_p) {return (int)((XSizeHints *)_p)->win_gravity;}
void set_XSizeHints_win_gravity(void *_p, int _v) {((XSizeHints *)_p)->win_gravity = (int)_v;}
void *alloc_XWMHints(void) {XWMHints *_p = (XWMHints *)malloc(sizeof(XWMHints)); if (_p==NULL) abort(); return (void *)_p;}
void free_XWMHints(void *_p) {if (_p==NULL) abort(); free((XWMHints *)_p);}
long get_XWMHints_flags(void *_p) {return (long)((XWMHints *)_p)->flags;}
void set_XWMHints_flags(void *_p, long _v) {((XWMHints *)_p)->flags = (long)_v;}
int get_XWMHints_input(void *_p) {return (int)((XWMHints *)_p)->input;}
void set_XWMHints_input(void *_p, int _v) {((XWMHints *)_p)->input = (int)_v;}
int get_XWMHints_initial_state(void *_p) {return (int)((XWMHints *)_p)->initial_state;}
void set_XWMHints_initial_state(void *_p, int _v) {((XWMHints *)_p)->initial_state = (int)_v;}
unsigned long get_XWMHints_icon_pixmap(void *_p) {return (unsigned long)((XWMHints *)_p)->icon_pixmap;}
void set_XWMHints_icon_pixmap(void *_p, unsigned long _v) {((XWMHints *)_p)->icon_pixmap = (unsigned long)_v;}
unsigned long get_XWMHints_icon_window(void *_p) {return (unsigned long)((XWMHints *)_p)->icon_window;}
void set_XWMHints_icon_window(void *_p, unsigned long _v) {((XWMHints *)_p)->icon_window = (unsigned long)_v;}
int get_XWMHints_icon_x(void *_p) {return (int)((XWMHints *)_p)->icon_x;}
void set_XWMHints_icon_x(void *_p, int _v) {((XWMHints *)_p)->icon_x = (int)_v;}
int get_XWMHints_icon_y(void *_p) {return (int)((XWMHints *)_p)->icon_y;}
void set_XWMHints_icon_y(void *_p, int _v) {((XWMHints *)_p)->icon_y = (int)_v;}
unsigned long get_XWMHints_icon_mask(void *_p) {return (unsigned long)((XWMHints *)_p)->icon_mask;}
void set_XWMHints_icon_mask(void *_p, unsigned long _v) {((XWMHints *)_p)->icon_mask = (unsigned long)_v;}
unsigned long get_XWMHints_window_group(void *_p) {return (unsigned long)((XWMHints *)_p)->window_group;}
void set_XWMHints_window_group(void *_p, unsigned long _v) {((XWMHints *)_p)->window_group = (unsigned long)_v;}
void *alloc_XTextProperty(void) {XTextProperty *_p = (XTextProperty *)malloc(sizeof(XTextProperty)); if (_p==NULL) abort(); return (void *)_p;}
void free_XTextProperty(void *_p) {if (_p==NULL) abort(); free((XTextProperty *)_p);}
void *get_XTextProperty_value(void *_p) {return (void *)((XTextProperty *)_p)->value;}
void set_XTextProperty_value(void *_p, void *_v) {((XTextProperty *)_p)->value = (unsigned char *)_v;}
unsigned long get_XTextProperty_encoding(void *_p) {return (unsigned long)((XTextProperty *)_p)->encoding;}
void set_XTextProperty_encoding(void *_p, unsigned long _v) {((XTextProperty *)_p)->encoding = (unsigned long)_v;}
int get_XTextProperty_format(void *_p) {return (int)((XTextProperty *)_p)->format;}
void set_XTextProperty_format(void *_p, int _v) {((XTextProperty *)_p)->format = (int)_v;}
unsigned long get_XTextProperty_nitems(void *_p) {return (unsigned long)((XTextProperty *)_p)->nitems;}
void set_XTextProperty_nitems(void *_p, unsigned long _v) {((XTextProperty *)_p)->nitems = (unsigned long)_v;}
void *alloc_XIconSize(void) {XIconSize *_p = (XIconSize *)malloc(sizeof(XIconSize)); if (_p==NULL) abort(); return (void *)_p;}
void free_XIconSize(void *_p) {if (_p==NULL) abort(); free((XIconSize *)_p);}
int get_XIconSize_min_width(void *_p) {return (int)((XIconSize *)_p)->min_width;}
void set_XIconSize_min_width(void *_p, int _v) {((XIconSize *)_p)->min_width = (int)_v;}
int get_XIconSize_min_height(void *_p) {return (int)((XIconSize *)_p)->min_height;}
void set_XIconSize_min_height(void *_p, int _v) {((XIconSize *)_p)->min_height = (int)_v;}
int get_XIconSize_max_width(void *_p) {return (int)((XIconSize *)_p)->max_width;}
void set_XIconSize_max_width(void *_p, int _v) {((XIconSize *)_p)->max_width = (int)_v;}
int get_XIconSize_max_height(void *_p) {return (int)((XIconSize *)_p)->max_height;}
void set_XIconSize_max_height(void *_p, int _v) {((XIconSize *)_p)->max_height = (int)_v;}
int get_XIconSize_width_inc(void *_p) {return (int)((XIconSize *)_p)->width_inc;}
void set_XIconSize_width_inc(void *_p, int _v) {((XIconSize *)_p)->width_inc = (int)_v;}
int get_XIconSize_height_inc(void *_p) {return (int)((XIconSize *)_p)->height_inc;}
void set_XIconSize_height_inc(void *_p, int _v) {((XIconSize *)_p)->height_inc = (int)_v;}
void *alloc_XClassHint(void) {XClassHint *_p = (XClassHint *)malloc(sizeof(XClassHint)); if (_p==NULL) abort(); return (void *)_p;}
void free_XClassHint(void *_p) {if (_p==NULL) abort(); free((XClassHint *)_p);}
void *get_XClassHint_res_name(void *_p) {return (void *)((XClassHint *)_p)->res_name;}
void set_XClassHint_res_name(void *_p, void *_v) {((XClassHint *)_p)->res_name = (char *)_v;}
void *get_XClassHint_res_class(void *_p) {return (void *)((XClassHint *)_p)->res_class;}
void set_XClassHint_res_class(void *_p, void *_v) {((XClassHint *)_p)->res_class = (char *)_v;}
void *alloc_XComposeStatus(void) {XComposeStatus *_p = (XComposeStatus *)malloc(sizeof(XComposeStatus)); if (_p==NULL) abort(); return (void *)_p;}
void free_XComposeStatus(void *_p) {if (_p==NULL) abort(); free((XComposeStatus *)_p);}
void *get_XComposeStatus_compose_ptr(void *_p) {return (void *)((XComposeStatus *)_p)->compose_ptr;}
void set_XComposeStatus_compose_ptr(void *_p, void *_v) {((XComposeStatus *)_p)->compose_ptr = (char *)_v;}
int get_XComposeStatus_chars_matched(void *_p) {return (int)((XComposeStatus *)_p)->chars_matched;}
void set_XComposeStatus_chars_matched(void *_p, int _v) {((XComposeStatus *)_p)->chars_matched = (int)_v;}
void *alloc_XVisualInfo(void) {XVisualInfo *_p = (XVisualInfo *)malloc(sizeof(XVisualInfo)); if (_p==NULL) abort(); return (void *)_p;}
void free_XVisualInfo(void *_p) {if (_p==NULL) abort(); free((XVisualInfo *)_p);}
void *get_XVisualInfo_visual(void *_p) {return (void *)((XVisualInfo *)_p)->visual;}
void set_XVisualInfo_visual(void *_p, void *_v) {((XVisualInfo *)_p)->visual = (Visual *)_v;}
unsigned long get_XVisualInfo_visualid(void *_p) {return (unsigned long)((XVisualInfo *)_p)->visualid;}
void set_XVisualInfo_visualid(void *_p, unsigned long _v) {((XVisualInfo *)_p)->visualid = (unsigned long)_v;}
int get_XVisualInfo_screen(void *_p) {return (int)((XVisualInfo *)_p)->screen;}
void set_XVisualInfo_screen(void *_p, int _v) {((XVisualInfo *)_p)->screen = (int)_v;}
int get_XVisualInfo_depth(void *_p) {return (int)((XVisualInfo *)_p)->depth;}
void set_XVisualInfo_depth(void *_p, int _v) {((XVisualInfo *)_p)->depth = (int)_v;}
int get_XVisualInfo_class(void *_p) {return (int)((XVisualInfo *)_p)->class;}
void set_XVisualInfo_class(void *_p, int _v) {((XVisualInfo *)_p)->class = (int)_v;}
unsigned long get_XVisualInfo_red_mask(void *_p) {return (unsigned long)((XVisualInfo *)_p)->red_mask;}
void set_XVisualInfo_red_mask(void *_p, unsigned long _v) {((XVisualInfo *)_p)->red_mask = (unsigned long)_v;}
unsigned long get_XVisualInfo_green_mask(void *_p) {return (unsigned long)((XVisualInfo *)_p)->green_mask;}
void set_XVisualInfo_green_mask(void *_p, unsigned long _v) {((XVisualInfo *)_p)->green_mask = (unsigned long)_v;}
unsigned long get_XVisualInfo_blue_mask(void *_p) {return (unsigned long)((XVisualInfo *)_p)->blue_mask;}
void set_XVisualInfo_blue_mask(void *_p, unsigned long _v) {((XVisualInfo *)_p)->blue_mask = (unsigned long)_v;}
int get_XVisualInfo_colormap_size(void *_p) {return (int)((XVisualInfo *)_p)->colormap_size;}
void set_XVisualInfo_colormap_size(void *_p, int _v) {((XVisualInfo *)_p)->colormap_size = (int)_v;}
int get_XVisualInfo_bits_per_rgb(void *_p) {return (int)((XVisualInfo *)_p)->bits_per_rgb;}
void set_XVisualInfo_bits_per_rgb(void *_p, int _v) {((XVisualInfo *)_p)->bits_per_rgb = (int)_v;}
void *alloc_XStandardColormap(void) {XStandardColormap *_p = (XStandardColormap *)malloc(sizeof(XStandardColormap)); if (_p==NULL) abort(); return (void *)_p;}
void free_XStandardColormap(void *_p) {if (_p==NULL) abort(); free((XStandardColormap *)_p);}
unsigned long get_XStandardColormap_colormap(void *_p) {return (unsigned long)((XStandardColormap *)_p)->colormap;}
void set_XStandardColormap_colormap(void *_p, unsigned long _v) {((XStandardColormap *)_p)->colormap = (unsigned long)_v;}
unsigned long get_XStandardColormap_red_max(void *_p) {return (unsigned long)((XStandardColormap *)_p)->red_max;}
void set_XStandardColormap_red_max(void *_p, unsigned long _v) {((XStandardColormap *)_p)->red_max = (unsigned long)_v;}
unsigned long get_XStandardColormap_red_mult(void *_p) {return (unsigned long)((XStandardColormap *)_p)->red_mult;}
void set_XStandardColormap_red_mult(void *_p, unsigned long _v) {((XStandardColormap *)_p)->red_mult = (unsigned long)_v;}
unsigned long get_XStandardColormap_green_max(void *_p) {return (unsigned long)((XStandardColormap *)_p)->green_max;}
void set_XStandardColormap_green_max(void *_p, unsigned long _v) {((XStandardColormap *)_p)->green_max = (unsigned long)_v;}
unsigned long get_XStandardColormap_green_mult(void *_p) {return (unsigned long)((XStandardColormap *)_p)->green_mult;}
void set_XStandardColormap_green_mult(void *_p, unsigned long _v) {((XStandardColormap *)_p)->green_mult = (unsigned long)_v;}
unsigned long get_XStandardColormap_blue_max(void *_p) {return (unsigned long)((XStandardColormap *)_p)->blue_max;}
void set_XStandardColormap_blue_max(void *_p, unsigned long _v) {((XStandardColormap *)_p)->blue_max = (unsigned long)_v;}
unsigned long get_XStandardColormap_blue_mult(void *_p) {return (unsigned long)((XStandardColormap *)_p)->blue_mult;}
void set_XStandardColormap_blue_mult(void *_p, unsigned long _v) {((XStandardColormap *)_p)->blue_mult = (unsigned long)_v;}
unsigned long get_XStandardColormap_base_pixel(void *_p) {return (unsigned long)((XStandardColormap *)_p)->base_pixel;}
void set_XStandardColormap_base_pixel(void *_p, unsigned long _v) {((XStandardColormap *)_p)->base_pixel = (unsigned long)_v;}
unsigned long get_XStandardColormap_visualid(void *_p) {return (unsigned long)((XStandardColormap *)_p)->visualid;}
void set_XStandardColormap_visualid(void *_p, unsigned long _v) {((XStandardColormap *)_p)->visualid = (unsigned long)_v;}
unsigned long get_XStandardColormap_killid(void *_p) {return (unsigned long)((XStandardColormap *)_p)->killid;}
void set_XStandardColormap_killid(void *_p, unsigned long _v) {((XStandardColormap *)_p)->killid = (unsigned long)_v;}
void *alloc_XEvent(void) {XEvent *_p = (XEvent *)malloc(sizeof(XEvent)); if (_p==NULL) abort(); return (void *)_p;}
void free_XEvent(void *_p) {if (_p==NULL) abort(); free((XEvent *)_p);}
int get_XEvent_type(void *_p) {return (int)((XEvent *)_p)->type;}
void set_XEvent_type(void *_p, int _v) {((XEvent *)_p)->type = (int)_v;}
int get_XEvent_xany_type(void *_p) {return (int)((XEvent *)_p)->xany.type;}
void set_XEvent_xany_type(void *_p, int _v) {((XEvent *)_p)->xany.type = (int)_v;}
unsigned long get_XEvent_xany_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xany.serial;}
void set_XEvent_xany_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xany.serial = (unsigned long)_v;}
int get_XEvent_xany_send_event(void *_p) {return (int)((XEvent *)_p)->xany.send_event;}
void set_XEvent_xany_send_event(void *_p, int _v) {((XEvent *)_p)->xany.send_event = (int)_v;}
void *get_XEvent_xany_display(void *_p) {return (void *)((XEvent *)_p)->xany.display;}
void set_XEvent_xany_display(void *_p, void *_v) {((XEvent *)_p)->xany.display = (Display *)_v;}
unsigned long get_XEvent_xany_window(void *_p) {return (unsigned long)((XEvent *)_p)->xany.window;}
void set_XEvent_xany_window(void *_p, unsigned long _v) {((XEvent *)_p)->xany.window = (unsigned long)_v;}
int get_XEvent_xkey_type(void *_p) {return (int)((XEvent *)_p)->xkey.type;}
void set_XEvent_xkey_type(void *_p, int _v) {((XEvent *)_p)->xkey.type = (int)_v;}
unsigned long get_XEvent_xkey_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xkey.serial;}
void set_XEvent_xkey_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xkey.serial = (unsigned long)_v;}
int get_XEvent_xkey_send_event(void *_p) {return (int)((XEvent *)_p)->xkey.send_event;}
void set_XEvent_xkey_send_event(void *_p, int _v) {((XEvent *)_p)->xkey.send_event = (int)_v;}
void *get_XEvent_xkey_display(void *_p) {return (void *)((XEvent *)_p)->xkey.display;}
void set_XEvent_xkey_display(void *_p, void *_v) {((XEvent *)_p)->xkey.display = (Display *)_v;}
unsigned long get_XEvent_xkey_window(void *_p) {return (unsigned long)((XEvent *)_p)->xkey.window;}
void set_XEvent_xkey_window(void *_p, unsigned long _v) {((XEvent *)_p)->xkey.window = (unsigned long)_v;}
unsigned long get_XEvent_xkey_root(void *_p) {return (unsigned long)((XEvent *)_p)->xkey.root;}
void set_XEvent_xkey_root(void *_p, unsigned long _v) {((XEvent *)_p)->xkey.root = (unsigned long)_v;}
unsigned long get_XEvent_xkey_subwindow(void *_p) {return (unsigned long)((XEvent *)_p)->xkey.subwindow;}
void set_XEvent_xkey_subwindow(void *_p, unsigned long _v) {((XEvent *)_p)->xkey.subwindow = (unsigned long)_v;}
unsigned long get_XEvent_xkey_time(void *_p) {return (unsigned long)((XEvent *)_p)->xkey.time;}
void set_XEvent_xkey_time(void *_p, unsigned long _v) {((XEvent *)_p)->xkey.time = (unsigned long)_v;}
int get_XEvent_xkey_x(void *_p) {return (int)((XEvent *)_p)->xkey.x;}
void set_XEvent_xkey_x(void *_p, int _v) {((XEvent *)_p)->xkey.x = (int)_v;}
int get_XEvent_xkey_y(void *_p) {return (int)((XEvent *)_p)->xkey.y;}
void set_XEvent_xkey_y(void *_p, int _v) {((XEvent *)_p)->xkey.y = (int)_v;}
int get_XEvent_xkey_x_root(void *_p) {return (int)((XEvent *)_p)->xkey.x_root;}
void set_XEvent_xkey_x_root(void *_p, int _v) {((XEvent *)_p)->xkey.x_root = (int)_v;}
int get_XEvent_xkey_y_root(void *_p) {return (int)((XEvent *)_p)->xkey.y_root;}
void set_XEvent_xkey_y_root(void *_p, int _v) {((XEvent *)_p)->xkey.y_root = (int)_v;}
unsigned get_XEvent_xkey_state(void *_p) {return (unsigned)((XEvent *)_p)->xkey.state;}
void set_XEvent_xkey_state(void *_p, unsigned _v) {((XEvent *)_p)->xkey.state = (unsigned)_v;}
unsigned get_XEvent_xkey_keycode(void *_p) {return (unsigned)((XEvent *)_p)->xkey.keycode;}
void set_XEvent_xkey_keycode(void *_p, unsigned _v) {((XEvent *)_p)->xkey.keycode = (unsigned)_v;}
int get_XEvent_xkey_same_screen(void *_p) {return (int)((XEvent *)_p)->xkey.same_screen;}
void set_XEvent_xkey_same_screen(void *_p, int _v) {((XEvent *)_p)->xkey.same_screen = (int)_v;}
int get_XEvent_xbutton_type(void *_p) {return (int)((XEvent *)_p)->xbutton.type;}
void set_XEvent_xbutton_type(void *_p, int _v) {((XEvent *)_p)->xbutton.type = (int)_v;}
unsigned long get_XEvent_xbutton_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xbutton.serial;}
void set_XEvent_xbutton_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xbutton.serial = (unsigned long)_v;}
int get_XEvent_xbutton_send_event(void *_p) {return (int)((XEvent *)_p)->xbutton.send_event;}
void set_XEvent_xbutton_send_event(void *_p, int _v) {((XEvent *)_p)->xbutton.send_event = (int)_v;}
void *get_XEvent_xbutton_display(void *_p) {return (void *)((XEvent *)_p)->xbutton.display;}
void set_XEvent_xbutton_display(void *_p, void *_v) {((XEvent *)_p)->xbutton.display = (Display *)_v;}
unsigned long get_XEvent_xbutton_window(void *_p) {return (unsigned long)((XEvent *)_p)->xbutton.window;}
void set_XEvent_xbutton_window(void *_p, unsigned long _v) {((XEvent *)_p)->xbutton.window = (unsigned long)_v;}
unsigned long get_XEvent_xbutton_root(void *_p) {return (unsigned long)((XEvent *)_p)->xbutton.root;}
void set_XEvent_xbutton_root(void *_p, unsigned long _v) {((XEvent *)_p)->xbutton.root = (unsigned long)_v;}
unsigned long get_XEvent_xbutton_subwindow(void *_p) {return (unsigned long)((XEvent *)_p)->xbutton.subwindow;}
void set_XEvent_xbutton_subwindow(void *_p, unsigned long _v) {((XEvent *)_p)->xbutton.subwindow = (unsigned long)_v;}
unsigned long get_XEvent_xbutton_time(void *_p) {return (unsigned long)((XEvent *)_p)->xbutton.time;}
void set_XEvent_xbutton_time(void *_p, unsigned long _v) {((XEvent *)_p)->xbutton.time = (unsigned long)_v;}
int get_XEvent_xbutton_x(void *_p) {return (int)((XEvent *)_p)->xbutton.x;}
void set_XEvent_xbutton_x(void *_p, int _v) {((XEvent *)_p)->xbutton.x = (int)_v;}
int get_XEvent_xbutton_y(void *_p) {return (int)((XEvent *)_p)->xbutton.y;}
void set_XEvent_xbutton_y(void *_p, int _v) {((XEvent *)_p)->xbutton.y = (int)_v;}
int get_XEvent_xbutton_x_root(void *_p) {return (int)((XEvent *)_p)->xbutton.x_root;}
void set_XEvent_xbutton_x_root(void *_p, int _v) {((XEvent *)_p)->xbutton.x_root = (int)_v;}
int get_XEvent_xbutton_y_root(void *_p) {return (int)((XEvent *)_p)->xbutton.y_root;}
void set_XEvent_xbutton_y_root(void *_p, int _v) {((XEvent *)_p)->xbutton.y_root = (int)_v;}
unsigned get_XEvent_xbutton_state(void *_p) {return (unsigned)((XEvent *)_p)->xbutton.state;}
void set_XEvent_xbutton_state(void *_p, unsigned _v) {((XEvent *)_p)->xbutton.state = (unsigned)_v;}
unsigned get_XEvent_xbutton_button(void *_p) {return (unsigned)((XEvent *)_p)->xbutton.button;}
void set_XEvent_xbutton_button(void *_p, unsigned _v) {((XEvent *)_p)->xbutton.button = (unsigned)_v;}
int get_XEvent_xbutton_same_screen(void *_p) {return (int)((XEvent *)_p)->xbutton.same_screen;}
void set_XEvent_xbutton_same_screen(void *_p, int _v) {((XEvent *)_p)->xbutton.same_screen = (int)_v;}
int get_XEvent_xmotion_type(void *_p) {return (int)((XEvent *)_p)->xmotion.type;}
void set_XEvent_xmotion_type(void *_p, int _v) {((XEvent *)_p)->xmotion.type = (int)_v;}
unsigned long get_XEvent_xmotion_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xmotion.serial;}
void set_XEvent_xmotion_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xmotion.serial = (unsigned long)_v;}
int get_XEvent_xmotion_send_event(void *_p) {return (int)((XEvent *)_p)->xmotion.send_event;}
void set_XEvent_xmotion_send_event(void *_p, int _v) {((XEvent *)_p)->xmotion.send_event = (int)_v;}
void *get_XEvent_xmotion_display(void *_p) {return (void *)((XEvent *)_p)->xmotion.display;}
void set_XEvent_xmotion_display(void *_p, void *_v) {((XEvent *)_p)->xmotion.display = (Display *)_v;}
unsigned long get_XEvent_xmotion_window(void *_p) {return (unsigned long)((XEvent *)_p)->xmotion.window;}
void set_XEvent_xmotion_window(void *_p, unsigned long _v) {((XEvent *)_p)->xmotion.window = (unsigned long)_v;}
unsigned long get_XEvent_xmotion_root(void *_p) {return (unsigned long)((XEvent *)_p)->xmotion.root;}
void set_XEvent_xmotion_root(void *_p, unsigned long _v) {((XEvent *)_p)->xmotion.root = (unsigned long)_v;}
unsigned long get_XEvent_xmotion_subwindow(void *_p) {return (unsigned long)((XEvent *)_p)->xmotion.subwindow;}
void set_XEvent_xmotion_subwindow(void *_p, unsigned long _v) {((XEvent *)_p)->xmotion.subwindow = (unsigned long)_v;}
unsigned long get_XEvent_xmotion_time(void *_p) {return (unsigned long)((XEvent *)_p)->xmotion.time;}
void set_XEvent_xmotion_time(void *_p, unsigned long _v) {((XEvent *)_p)->xmotion.time = (unsigned long)_v;}
int get_XEvent_xmotion_x(void *_p) {return (int)((XEvent *)_p)->xmotion.x;}
void set_XEvent_xmotion_x(void *_p, int _v) {((XEvent *)_p)->xmotion.x = (int)_v;}
int get_XEvent_xmotion_y(void *_p) {return (int)((XEvent *)_p)->xmotion.y;}
void set_XEvent_xmotion_y(void *_p, int _v) {((XEvent *)_p)->xmotion.y = (int)_v;}
int get_XEvent_xmotion_x_root(void *_p) {return (int)((XEvent *)_p)->xmotion.x_root;}
void set_XEvent_xmotion_x_root(void *_p, int _v) {((XEvent *)_p)->xmotion.x_root = (int)_v;}
int get_XEvent_xmotion_y_root(void *_p) {return (int)((XEvent *)_p)->xmotion.y_root;}
void set_XEvent_xmotion_y_root(void *_p, int _v) {((XEvent *)_p)->xmotion.y_root = (int)_v;}
unsigned get_XEvent_xmotion_state(void *_p) {return (unsigned)((XEvent *)_p)->xmotion.state;}
void set_XEvent_xmotion_state(void *_p, unsigned _v) {((XEvent *)_p)->xmotion.state = (unsigned)_v;}
char get_XEvent_xmotion_is_hint(void *_p) {return (char)((XEvent *)_p)->xmotion.is_hint;}
void set_XEvent_xmotion_is_hint(void *_p, char _v) {((XEvent *)_p)->xmotion.is_hint = (char)_v;}
int get_XEvent_xmotion_same_screen(void *_p) {return (int)((XEvent *)_p)->xmotion.same_screen;}
void set_XEvent_xmotion_same_screen(void *_p, int _v) {((XEvent *)_p)->xmotion.same_screen = (int)_v;}
int get_XEvent_xcrossing_type(void *_p) {return (int)((XEvent *)_p)->xcrossing.type;}
void set_XEvent_xcrossing_type(void *_p, int _v) {((XEvent *)_p)->xcrossing.type = (int)_v;}
unsigned long get_XEvent_xcrossing_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xcrossing.serial;}
void set_XEvent_xcrossing_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xcrossing.serial = (unsigned long)_v;}
int get_XEvent_xcrossing_send_event(void *_p) {return (int)((XEvent *)_p)->xcrossing.send_event;}
void set_XEvent_xcrossing_send_event(void *_p, int _v) {((XEvent *)_p)->xcrossing.send_event = (int)_v;}
void *get_XEvent_xcrossing_display(void *_p) {return (void *)((XEvent *)_p)->xcrossing.display;}
void set_XEvent_xcrossing_display(void *_p, void *_v) {((XEvent *)_p)->xcrossing.display = (Display *)_v;}
unsigned long get_XEvent_xcrossing_window(void *_p) {return (unsigned long)((XEvent *)_p)->xcrossing.window;}
void set_XEvent_xcrossing_window(void *_p, unsigned long _v) {((XEvent *)_p)->xcrossing.window = (unsigned long)_v;}
unsigned long get_XEvent_xcrossing_root(void *_p) {return (unsigned long)((XEvent *)_p)->xcrossing.root;}
void set_XEvent_xcrossing_root(void *_p, unsigned long _v) {((XEvent *)_p)->xcrossing.root = (unsigned long)_v;}
unsigned long get_XEvent_xcrossing_subwindow(void *_p) {return (unsigned long)((XEvent *)_p)->xcrossing.subwindow;}
void set_XEvent_xcrossing_subwindow(void *_p, unsigned long _v) {((XEvent *)_p)->xcrossing.subwindow = (unsigned long)_v;}
unsigned long get_XEvent_xcrossing_time(void *_p) {return (unsigned long)((XEvent *)_p)->xcrossing.time;}
void set_XEvent_xcrossing_time(void *_p, unsigned long _v) {((XEvent *)_p)->xcrossing.time = (unsigned long)_v;}
int get_XEvent_xcrossing_x(void *_p) {return (int)((XEvent *)_p)->xcrossing.x;}
void set_XEvent_xcrossing_x(void *_p, int _v) {((XEvent *)_p)->xcrossing.x = (int)_v;}
int get_XEvent_xcrossing_y(void *_p) {return (int)((XEvent *)_p)->xcrossing.y;}
void set_XEvent_xcrossing_y(void *_p, int _v) {((XEvent *)_p)->xcrossing.y = (int)_v;}
int get_XEvent_xcrossing_x_root(void *_p) {return (int)((XEvent *)_p)->xcrossing.x_root;}
void set_XEvent_xcrossing_x_root(void *_p, int _v) {((XEvent *)_p)->xcrossing.x_root = (int)_v;}
int get_XEvent_xcrossing_y_root(void *_p) {return (int)((XEvent *)_p)->xcrossing.y_root;}
void set_XEvent_xcrossing_y_root(void *_p, int _v) {((XEvent *)_p)->xcrossing.y_root = (int)_v;}
int get_XEvent_xcrossing_mode(void *_p) {return (int)((XEvent *)_p)->xcrossing.mode;}
void set_XEvent_xcrossing_mode(void *_p, int _v) {((XEvent *)_p)->xcrossing.mode = (int)_v;}
int get_XEvent_xcrossing_detail(void *_p) {return (int)((XEvent *)_p)->xcrossing.detail;}
void set_XEvent_xcrossing_detail(void *_p, int _v) {((XEvent *)_p)->xcrossing.detail = (int)_v;}
int get_XEvent_xcrossing_same_screen(void *_p) {return (int)((XEvent *)_p)->xcrossing.same_screen;}
void set_XEvent_xcrossing_same_screen(void *_p, int _v) {((XEvent *)_p)->xcrossing.same_screen = (int)_v;}
int get_XEvent_xcrossing_focus(void *_p) {return (int)((XEvent *)_p)->xcrossing.focus;}
void set_XEvent_xcrossing_focus(void *_p, int _v) {((XEvent *)_p)->xcrossing.focus = (int)_v;}
unsigned get_XEvent_xcrossing_state(void *_p) {return (unsigned)((XEvent *)_p)->xcrossing.state;}
void set_XEvent_xcrossing_state(void *_p, unsigned _v) {((XEvent *)_p)->xcrossing.state = (unsigned)_v;}
int get_XEvent_xfocus_type(void *_p) {return (int)((XEvent *)_p)->xfocus.type;}
void set_XEvent_xfocus_type(void *_p, int _v) {((XEvent *)_p)->xfocus.type = (int)_v;}
unsigned long get_XEvent_xfocus_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xfocus.serial;}
void set_XEvent_xfocus_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xfocus.serial = (unsigned long)_v;}
int get_XEvent_xfocus_send_event(void *_p) {return (int)((XEvent *)_p)->xfocus.send_event;}
void set_XEvent_xfocus_send_event(void *_p, int _v) {((XEvent *)_p)->xfocus.send_event = (int)_v;}
void *get_XEvent_xfocus_display(void *_p) {return (void *)((XEvent *)_p)->xfocus.display;}
void set_XEvent_xfocus_display(void *_p, void *_v) {((XEvent *)_p)->xfocus.display = (Display *)_v;}
unsigned long get_XEvent_xfocus_window(void *_p) {return (unsigned long)((XEvent *)_p)->xfocus.window;}
void set_XEvent_xfocus_window(void *_p, unsigned long _v) {((XEvent *)_p)->xfocus.window = (unsigned long)_v;}
int get_XEvent_xfocus_mode(void *_p) {return (int)((XEvent *)_p)->xfocus.mode;}
void set_XEvent_xfocus_mode(void *_p, int _v) {((XEvent *)_p)->xfocus.mode = (int)_v;}
int get_XEvent_xfocus_detail(void *_p) {return (int)((XEvent *)_p)->xfocus.detail;}
void set_XEvent_xfocus_detail(void *_p, int _v) {((XEvent *)_p)->xfocus.detail = (int)_v;}
int get_XEvent_xexpose_type(void *_p) {return (int)((XEvent *)_p)->xexpose.type;}
void set_XEvent_xexpose_type(void *_p, int _v) {((XEvent *)_p)->xexpose.type = (int)_v;}
unsigned long get_XEvent_xexpose_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xexpose.serial;}
void set_XEvent_xexpose_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xexpose.serial = (unsigned long)_v;}
int get_XEvent_xexpose_send_event(void *_p) {return (int)((XEvent *)_p)->xexpose.send_event;}
void set_XEvent_xexpose_send_event(void *_p, int _v) {((XEvent *)_p)->xexpose.send_event = (int)_v;}
void *get_XEvent_xexpose_display(void *_p) {return (void *)((XEvent *)_p)->xexpose.display;}
void set_XEvent_xexpose_display(void *_p, void *_v) {((XEvent *)_p)->xexpose.display = (Display *)_v;}
unsigned long get_XEvent_xexpose_window(void *_p) {return (unsigned long)((XEvent *)_p)->xexpose.window;}
void set_XEvent_xexpose_window(void *_p, unsigned long _v) {((XEvent *)_p)->xexpose.window = (unsigned long)_v;}
int get_XEvent_xexpose_x(void *_p) {return (int)((XEvent *)_p)->xexpose.x;}
void set_XEvent_xexpose_x(void *_p, int _v) {((XEvent *)_p)->xexpose.x = (int)_v;}
int get_XEvent_xexpose_y(void *_p) {return (int)((XEvent *)_p)->xexpose.y;}
void set_XEvent_xexpose_y(void *_p, int _v) {((XEvent *)_p)->xexpose.y = (int)_v;}
int get_XEvent_xexpose_width(void *_p) {return (int)((XEvent *)_p)->xexpose.width;}
void set_XEvent_xexpose_width(void *_p, int _v) {((XEvent *)_p)->xexpose.width = (int)_v;}
int get_XEvent_xexpose_height(void *_p) {return (int)((XEvent *)_p)->xexpose.height;}
void set_XEvent_xexpose_height(void *_p, int _v) {((XEvent *)_p)->xexpose.height = (int)_v;}
int get_XEvent_xexpose_count(void *_p) {return (int)((XEvent *)_p)->xexpose.count;}
void set_XEvent_xexpose_count(void *_p, int _v) {((XEvent *)_p)->xexpose.count = (int)_v;}
int get_XEvent_xgraphicsexpose_type(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.type;}
void set_XEvent_xgraphicsexpose_type(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.type = (int)_v;}
unsigned long get_XEvent_xgraphicsexpose_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xgraphicsexpose.serial;}
void set_XEvent_xgraphicsexpose_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xgraphicsexpose.serial = (unsigned long)_v;}
int get_XEvent_xgraphicsexpose_send_event(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.send_event;}
void set_XEvent_xgraphicsexpose_send_event(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.send_event = (int)_v;}
void *get_XEvent_xgraphicsexpose_display(void *_p) {return (void *)((XEvent *)_p)->xgraphicsexpose.display;}
void set_XEvent_xgraphicsexpose_display(void *_p, void *_v) {((XEvent *)_p)->xgraphicsexpose.display = (Display *)_v;}
unsigned long get_XEvent_xgraphicsexpose_drawable(void *_p) {return (unsigned long)((XEvent *)_p)->xgraphicsexpose.drawable;}
void set_XEvent_xgraphicsexpose_drawable(void *_p, unsigned long _v) {((XEvent *)_p)->xgraphicsexpose.drawable = (unsigned long)_v;}
int get_XEvent_xgraphicsexpose_x(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.x;}
void set_XEvent_xgraphicsexpose_x(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.x = (int)_v;}
int get_XEvent_xgraphicsexpose_y(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.y;}
void set_XEvent_xgraphicsexpose_y(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.y = (int)_v;}
int get_XEvent_xgraphicsexpose_width(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.width;}
void set_XEvent_xgraphicsexpose_width(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.width = (int)_v;}
int get_XEvent_xgraphicsexpose_height(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.height;}
void set_XEvent_xgraphicsexpose_height(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.height = (int)_v;}
int get_XEvent_xgraphicsexpose_count(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.count;}
void set_XEvent_xgraphicsexpose_count(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.count = (int)_v;}
int get_XEvent_xgraphicsexpose_major_code(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.major_code;}
void set_XEvent_xgraphicsexpose_major_code(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.major_code = (int)_v;}
int get_XEvent_xgraphicsexpose_minor_code(void *_p) {return (int)((XEvent *)_p)->xgraphicsexpose.minor_code;}
void set_XEvent_xgraphicsexpose_minor_code(void *_p, int _v) {((XEvent *)_p)->xgraphicsexpose.minor_code = (int)_v;}
int get_XEvent_xnoexpose_type(void *_p) {return (int)((XEvent *)_p)->xnoexpose.type;}
void set_XEvent_xnoexpose_type(void *_p, int _v) {((XEvent *)_p)->xnoexpose.type = (int)_v;}
unsigned long get_XEvent_xnoexpose_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xnoexpose.serial;}
void set_XEvent_xnoexpose_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xnoexpose.serial = (unsigned long)_v;}
int get_XEvent_xnoexpose_send_event(void *_p) {return (int)((XEvent *)_p)->xnoexpose.send_event;}
void set_XEvent_xnoexpose_send_event(void *_p, int _v) {((XEvent *)_p)->xnoexpose.send_event = (int)_v;}
void *get_XEvent_xnoexpose_display(void *_p) {return (void *)((XEvent *)_p)->xnoexpose.display;}
void set_XEvent_xnoexpose_display(void *_p, void *_v) {((XEvent *)_p)->xnoexpose.display = (Display *)_v;}
unsigned long get_XEvent_xnoexpose_drawable(void *_p) {return (unsigned long)((XEvent *)_p)->xnoexpose.drawable;}
void set_XEvent_xnoexpose_drawable(void *_p, unsigned long _v) {((XEvent *)_p)->xnoexpose.drawable = (unsigned long)_v;}
int get_XEvent_xnoexpose_major_code(void *_p) {return (int)((XEvent *)_p)->xnoexpose.major_code;}
void set_XEvent_xnoexpose_major_code(void *_p, int _v) {((XEvent *)_p)->xnoexpose.major_code = (int)_v;}
int get_XEvent_xnoexpose_minor_code(void *_p) {return (int)((XEvent *)_p)->xnoexpose.minor_code;}
void set_XEvent_xnoexpose_minor_code(void *_p, int _v) {((XEvent *)_p)->xnoexpose.minor_code = (int)_v;}
int get_XEvent_xvisibility_type(void *_p) {return (int)((XEvent *)_p)->xvisibility.type;}
void set_XEvent_xvisibility_type(void *_p, int _v) {((XEvent *)_p)->xvisibility.type = (int)_v;}
unsigned long get_XEvent_xvisibility_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xvisibility.serial;}
void set_XEvent_xvisibility_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xvisibility.serial = (unsigned long)_v;}
int get_XEvent_xvisibility_send_event(void *_p) {return (int)((XEvent *)_p)->xvisibility.send_event;}
void set_XEvent_xvisibility_send_event(void *_p, int _v) {((XEvent *)_p)->xvisibility.send_event = (int)_v;}
void *get_XEvent_xvisibility_display(void *_p) {return (void *)((XEvent *)_p)->xvisibility.display;}
void set_XEvent_xvisibility_display(void *_p, void *_v) {((XEvent *)_p)->xvisibility.display = (Display *)_v;}
unsigned long get_XEvent_xvisibility_window(void *_p) {return (unsigned long)((XEvent *)_p)->xvisibility.window;}
void set_XEvent_xvisibility_window(void *_p, unsigned long _v) {((XEvent *)_p)->xvisibility.window = (unsigned long)_v;}
int get_XEvent_xvisibility_state(void *_p) {return (int)((XEvent *)_p)->xvisibility.state;}
void set_XEvent_xvisibility_state(void *_p, int _v) {((XEvent *)_p)->xvisibility.state = (int)_v;}
int get_XEvent_xcreatewindow_type(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.type;}
void set_XEvent_xcreatewindow_type(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.type = (int)_v;}
unsigned long get_XEvent_xcreatewindow_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xcreatewindow.serial;}
void set_XEvent_xcreatewindow_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xcreatewindow.serial = (unsigned long)_v;}
int get_XEvent_xcreatewindow_send_event(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.send_event;}
void set_XEvent_xcreatewindow_send_event(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.send_event = (int)_v;}
void *get_XEvent_xcreatewindow_display(void *_p) {return (void *)((XEvent *)_p)->xcreatewindow.display;}
void set_XEvent_xcreatewindow_display(void *_p, void *_v) {((XEvent *)_p)->xcreatewindow.display = (Display *)_v;}
unsigned long get_XEvent_xcreatewindow_parent(void *_p) {return (unsigned long)((XEvent *)_p)->xcreatewindow.parent;}
void set_XEvent_xcreatewindow_parent(void *_p, unsigned long _v) {((XEvent *)_p)->xcreatewindow.parent = (unsigned long)_v;}
unsigned long get_XEvent_xcreatewindow_window(void *_p) {return (unsigned long)((XEvent *)_p)->xcreatewindow.window;}
void set_XEvent_xcreatewindow_window(void *_p, unsigned long _v) {((XEvent *)_p)->xcreatewindow.window = (unsigned long)_v;}
int get_XEvent_xcreatewindow_x(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.x;}
void set_XEvent_xcreatewindow_x(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.x = (int)_v;}
int get_XEvent_xcreatewindow_y(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.y;}
void set_XEvent_xcreatewindow_y(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.y = (int)_v;}
int get_XEvent_xcreatewindow_width(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.width;}
void set_XEvent_xcreatewindow_width(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.width = (int)_v;}
int get_XEvent_xcreatewindow_height(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.height;}
void set_XEvent_xcreatewindow_height(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.height = (int)_v;}
int get_XEvent_xcreatewindow_border_width(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.border_width;}
void set_XEvent_xcreatewindow_border_width(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.border_width = (int)_v;}
int get_XEvent_xcreatewindow_override_redirect(void *_p) {return (int)((XEvent *)_p)->xcreatewindow.override_redirect;}
void set_XEvent_xcreatewindow_override_redirect(void *_p, int _v) {((XEvent *)_p)->xcreatewindow.override_redirect = (int)_v;}
int get_XEvent_xdestroywindow_type(void *_p) {return (int)((XEvent *)_p)->xdestroywindow.type;}
void set_XEvent_xdestroywindow_type(void *_p, int _v) {((XEvent *)_p)->xdestroywindow.type = (int)_v;}
unsigned long get_XEvent_xdestroywindow_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xdestroywindow.serial;}
void set_XEvent_xdestroywindow_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xdestroywindow.serial = (unsigned long)_v;}
int get_XEvent_xdestroywindow_send_event(void *_p) {return (int)((XEvent *)_p)->xdestroywindow.send_event;}
void set_XEvent_xdestroywindow_send_event(void *_p, int _v) {((XEvent *)_p)->xdestroywindow.send_event = (int)_v;}
void *get_XEvent_xdestroywindow_display(void *_p) {return (void *)((XEvent *)_p)->xdestroywindow.display;}
void set_XEvent_xdestroywindow_display(void *_p, void *_v) {((XEvent *)_p)->xdestroywindow.display = (Display *)_v;}
unsigned long get_XEvent_xdestroywindow_event(void *_p) {return (unsigned long)((XEvent *)_p)->xdestroywindow.event;}
void set_XEvent_xdestroywindow_event(void *_p, unsigned long _v) {((XEvent *)_p)->xdestroywindow.event = (unsigned long)_v;}
unsigned long get_XEvent_xdestroywindow_window(void *_p) {return (unsigned long)((XEvent *)_p)->xdestroywindow.window;}
void set_XEvent_xdestroywindow_window(void *_p, unsigned long _v) {((XEvent *)_p)->xdestroywindow.window = (unsigned long)_v;}
int get_XEvent_xunmap_type(void *_p) {return (int)((XEvent *)_p)->xunmap.type;}
void set_XEvent_xunmap_type(void *_p, int _v) {((XEvent *)_p)->xunmap.type = (int)_v;}
unsigned long get_XEvent_xunmap_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xunmap.serial;}
void set_XEvent_xunmap_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xunmap.serial = (unsigned long)_v;}
int get_XEvent_xunmap_send_event(void *_p) {return (int)((XEvent *)_p)->xunmap.send_event;}
void set_XEvent_xunmap_send_event(void *_p, int _v) {((XEvent *)_p)->xunmap.send_event = (int)_v;}
void *get_XEvent_xunmap_display(void *_p) {return (void *)((XEvent *)_p)->xunmap.display;}
void set_XEvent_xunmap_display(void *_p, void *_v) {((XEvent *)_p)->xunmap.display = (Display *)_v;}
unsigned long get_XEvent_xunmap_event(void *_p) {return (unsigned long)((XEvent *)_p)->xunmap.event;}
void set_XEvent_xunmap_event(void *_p, unsigned long _v) {((XEvent *)_p)->xunmap.event = (unsigned long)_v;}
unsigned long get_XEvent_xunmap_window(void *_p) {return (unsigned long)((XEvent *)_p)->xunmap.window;}
void set_XEvent_xunmap_window(void *_p, unsigned long _v) {((XEvent *)_p)->xunmap.window = (unsigned long)_v;}
int get_XEvent_xunmap_from_configure(void *_p) {return (int)((XEvent *)_p)->xunmap.from_configure;}
void set_XEvent_xunmap_from_configure(void *_p, int _v) {((XEvent *)_p)->xunmap.from_configure = (int)_v;}
int get_XEvent_xmap_type(void *_p) {return (int)((XEvent *)_p)->xmap.type;}
void set_XEvent_xmap_type(void *_p, int _v) {((XEvent *)_p)->xmap.type = (int)_v;}
unsigned long get_XEvent_xmap_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xmap.serial;}
void set_XEvent_xmap_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xmap.serial = (unsigned long)_v;}
int get_XEvent_xmap_send_event(void *_p) {return (int)((XEvent *)_p)->xmap.send_event;}
void set_XEvent_xmap_send_event(void *_p, int _v) {((XEvent *)_p)->xmap.send_event = (int)_v;}
void *get_XEvent_xmap_display(void *_p) {return (void *)((XEvent *)_p)->xmap.display;}
void set_XEvent_xmap_display(void *_p, void *_v) {((XEvent *)_p)->xmap.display = (Display *)_v;}
unsigned long get_XEvent_xmap_event(void *_p) {return (unsigned long)((XEvent *)_p)->xmap.event;}
void set_XEvent_xmap_event(void *_p, unsigned long _v) {((XEvent *)_p)->xmap.event = (unsigned long)_v;}
unsigned long get_XEvent_xmap_window(void *_p) {return (unsigned long)((XEvent *)_p)->xmap.window;}
void set_XEvent_xmap_window(void *_p, unsigned long _v) {((XEvent *)_p)->xmap.window = (unsigned long)_v;}
int get_XEvent_xmap_override_redirect(void *_p) {return (int)((XEvent *)_p)->xmap.override_redirect;}
void set_XEvent_xmap_override_redirect(void *_p, int _v) {((XEvent *)_p)->xmap.override_redirect = (int)_v;}
int get_XEvent_xmaprequest_type(void *_p) {return (int)((XEvent *)_p)->xmaprequest.type;}
void set_XEvent_xmaprequest_type(void *_p, int _v) {((XEvent *)_p)->xmaprequest.type = (int)_v;}
unsigned long get_XEvent_xmaprequest_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xmaprequest.serial;}
void set_XEvent_xmaprequest_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xmaprequest.serial = (unsigned long)_v;}
int get_XEvent_xmaprequest_send_event(void *_p) {return (int)((XEvent *)_p)->xmaprequest.send_event;}
void set_XEvent_xmaprequest_send_event(void *_p, int _v) {((XEvent *)_p)->xmaprequest.send_event = (int)_v;}
void *get_XEvent_xmaprequest_display(void *_p) {return (void *)((XEvent *)_p)->xmaprequest.display;}
void set_XEvent_xmaprequest_display(void *_p, void *_v) {((XEvent *)_p)->xmaprequest.display = (Display *)_v;}
unsigned long get_XEvent_xmaprequest_parent(void *_p) {return (unsigned long)((XEvent *)_p)->xmaprequest.parent;}
void set_XEvent_xmaprequest_parent(void *_p, unsigned long _v) {((XEvent *)_p)->xmaprequest.parent = (unsigned long)_v;}
unsigned long get_XEvent_xmaprequest_window(void *_p) {return (unsigned long)((XEvent *)_p)->xmaprequest.window;}
void set_XEvent_xmaprequest_window(void *_p, unsigned long _v) {((XEvent *)_p)->xmaprequest.window = (unsigned long)_v;}
int get_XEvent_xreparent_type(void *_p) {return (int)((XEvent *)_p)->xreparent.type;}
void set_XEvent_xreparent_type(void *_p, int _v) {((XEvent *)_p)->xreparent.type = (int)_v;}
unsigned long get_XEvent_xreparent_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xreparent.serial;}
void set_XEvent_xreparent_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xreparent.serial = (unsigned long)_v;}
int get_XEvent_xreparent_send_event(void *_p) {return (int)((XEvent *)_p)->xreparent.send_event;}
void set_XEvent_xreparent_send_event(void *_p, int _v) {((XEvent *)_p)->xreparent.send_event = (int)_v;}
void *get_XEvent_xreparent_display(void *_p) {return (void *)((XEvent *)_p)->xreparent.display;}
void set_XEvent_xreparent_display(void *_p, void *_v) {((XEvent *)_p)->xreparent.display = (Display *)_v;}
unsigned long get_XEvent_xreparent_event(void *_p) {return (unsigned long)((XEvent *)_p)->xreparent.event;}
void set_XEvent_xreparent_event(void *_p, unsigned long _v) {((XEvent *)_p)->xreparent.event = (unsigned long)_v;}
unsigned long get_XEvent_xreparent_window(void *_p) {return (unsigned long)((XEvent *)_p)->xreparent.window;}
void set_XEvent_xreparent_window(void *_p, unsigned long _v) {((XEvent *)_p)->xreparent.window = (unsigned long)_v;}
unsigned long get_XEvent_xreparent_parent(void *_p) {return (unsigned long)((XEvent *)_p)->xreparent.parent;}
void set_XEvent_xreparent_parent(void *_p, unsigned long _v) {((XEvent *)_p)->xreparent.parent = (unsigned long)_v;}
int get_XEvent_xreparent_x(void *_p) {return (int)((XEvent *)_p)->xreparent.x;}
void set_XEvent_xreparent_x(void *_p, int _v) {((XEvent *)_p)->xreparent.x = (int)_v;}
int get_XEvent_xreparent_y(void *_p) {return (int)((XEvent *)_p)->xreparent.y;}
void set_XEvent_xreparent_y(void *_p, int _v) {((XEvent *)_p)->xreparent.y = (int)_v;}
int get_XEvent_xreparent_override_redirect(void *_p) {return (int)((XEvent *)_p)->xreparent.override_redirect;}
void set_XEvent_xreparent_override_redirect(void *_p, int _v) {((XEvent *)_p)->xreparent.override_redirect = (int)_v;}
int get_XEvent_xconfigure_type(void *_p) {return (int)((XEvent *)_p)->xconfigure.type;}
void set_XEvent_xconfigure_type(void *_p, int _v) {((XEvent *)_p)->xconfigure.type = (int)_v;}
unsigned long get_XEvent_xconfigure_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigure.serial;}
void set_XEvent_xconfigure_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigure.serial = (unsigned long)_v;}
int get_XEvent_xconfigure_send_event(void *_p) {return (int)((XEvent *)_p)->xconfigure.send_event;}
void set_XEvent_xconfigure_send_event(void *_p, int _v) {((XEvent *)_p)->xconfigure.send_event = (int)_v;}
void *get_XEvent_xconfigure_display(void *_p) {return (void *)((XEvent *)_p)->xconfigure.display;}
void set_XEvent_xconfigure_display(void *_p, void *_v) {((XEvent *)_p)->xconfigure.display = (Display *)_v;}
unsigned long get_XEvent_xconfigure_event(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigure.event;}
void set_XEvent_xconfigure_event(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigure.event = (unsigned long)_v;}
unsigned long get_XEvent_xconfigure_window(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigure.window;}
void set_XEvent_xconfigure_window(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigure.window = (unsigned long)_v;}
int get_XEvent_xconfigure_x(void *_p) {return (int)((XEvent *)_p)->xconfigure.x;}
void set_XEvent_xconfigure_x(void *_p, int _v) {((XEvent *)_p)->xconfigure.x = (int)_v;}
int get_XEvent_xconfigure_y(void *_p) {return (int)((XEvent *)_p)->xconfigure.y;}
void set_XEvent_xconfigure_y(void *_p, int _v) {((XEvent *)_p)->xconfigure.y = (int)_v;}
int get_XEvent_xconfigure_width(void *_p) {return (int)((XEvent *)_p)->xconfigure.width;}
void set_XEvent_xconfigure_width(void *_p, int _v) {((XEvent *)_p)->xconfigure.width = (int)_v;}
int get_XEvent_xconfigure_height(void *_p) {return (int)((XEvent *)_p)->xconfigure.height;}
void set_XEvent_xconfigure_height(void *_p, int _v) {((XEvent *)_p)->xconfigure.height = (int)_v;}
int get_XEvent_xconfigure_border_width(void *_p) {return (int)((XEvent *)_p)->xconfigure.border_width;}
void set_XEvent_xconfigure_border_width(void *_p, int _v) {((XEvent *)_p)->xconfigure.border_width = (int)_v;}
unsigned long get_XEvent_xconfigure_above(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigure.above;}
void set_XEvent_xconfigure_above(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigure.above = (unsigned long)_v;}
int get_XEvent_xconfigure_override_redirect(void *_p) {return (int)((XEvent *)_p)->xconfigure.override_redirect;}
void set_XEvent_xconfigure_override_redirect(void *_p, int _v) {((XEvent *)_p)->xconfigure.override_redirect = (int)_v;}
int get_XEvent_xgravity_type(void *_p) {return (int)((XEvent *)_p)->xgravity.type;}
void set_XEvent_xgravity_type(void *_p, int _v) {((XEvent *)_p)->xgravity.type = (int)_v;}
unsigned long get_XEvent_xgravity_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xgravity.serial;}
void set_XEvent_xgravity_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xgravity.serial = (unsigned long)_v;}
int get_XEvent_xgravity_send_event(void *_p) {return (int)((XEvent *)_p)->xgravity.send_event;}
void set_XEvent_xgravity_send_event(void *_p, int _v) {((XEvent *)_p)->xgravity.send_event = (int)_v;}
void *get_XEvent_xgravity_display(void *_p) {return (void *)((XEvent *)_p)->xgravity.display;}
void set_XEvent_xgravity_display(void *_p, void *_v) {((XEvent *)_p)->xgravity.display = (Display *)_v;}
unsigned long get_XEvent_xgravity_event(void *_p) {return (unsigned long)((XEvent *)_p)->xgravity.event;}
void set_XEvent_xgravity_event(void *_p, unsigned long _v) {((XEvent *)_p)->xgravity.event = (unsigned long)_v;}
unsigned long get_XEvent_xgravity_window(void *_p) {return (unsigned long)((XEvent *)_p)->xgravity.window;}
void set_XEvent_xgravity_window(void *_p, unsigned long _v) {((XEvent *)_p)->xgravity.window = (unsigned long)_v;}
int get_XEvent_xgravity_x(void *_p) {return (int)((XEvent *)_p)->xgravity.x;}
void set_XEvent_xgravity_x(void *_p, int _v) {((XEvent *)_p)->xgravity.x = (int)_v;}
int get_XEvent_xgravity_y(void *_p) {return (int)((XEvent *)_p)->xgravity.y;}
void set_XEvent_xgravity_y(void *_p, int _v) {((XEvent *)_p)->xgravity.y = (int)_v;}
int get_XEvent_xresizerequest_type(void *_p) {return (int)((XEvent *)_p)->xresizerequest.type;}
void set_XEvent_xresizerequest_type(void *_p, int _v) {((XEvent *)_p)->xresizerequest.type = (int)_v;}
unsigned long get_XEvent_xresizerequest_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xresizerequest.serial;}
void set_XEvent_xresizerequest_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xresizerequest.serial = (unsigned long)_v;}
int get_XEvent_xresizerequest_send_event(void *_p) {return (int)((XEvent *)_p)->xresizerequest.send_event;}
void set_XEvent_xresizerequest_send_event(void *_p, int _v) {((XEvent *)_p)->xresizerequest.send_event = (int)_v;}
void *get_XEvent_xresizerequest_display(void *_p) {return (void *)((XEvent *)_p)->xresizerequest.display;}
void set_XEvent_xresizerequest_display(void *_p, void *_v) {((XEvent *)_p)->xresizerequest.display = (Display *)_v;}
unsigned long get_XEvent_xresizerequest_window(void *_p) {return (unsigned long)((XEvent *)_p)->xresizerequest.window;}
void set_XEvent_xresizerequest_window(void *_p, unsigned long _v) {((XEvent *)_p)->xresizerequest.window = (unsigned long)_v;}
int get_XEvent_xresizerequest_width(void *_p) {return (int)((XEvent *)_p)->xresizerequest.width;}
void set_XEvent_xresizerequest_width(void *_p, int _v) {((XEvent *)_p)->xresizerequest.width = (int)_v;}
int get_XEvent_xresizerequest_height(void *_p) {return (int)((XEvent *)_p)->xresizerequest.height;}
void set_XEvent_xresizerequest_height(void *_p, int _v) {((XEvent *)_p)->xresizerequest.height = (int)_v;}
int get_XEvent_xconfigurerequest_type(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.type;}
void set_XEvent_xconfigurerequest_type(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.type = (int)_v;}
unsigned long get_XEvent_xconfigurerequest_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigurerequest.serial;}
void set_XEvent_xconfigurerequest_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigurerequest.serial = (unsigned long)_v;}
int get_XEvent_xconfigurerequest_send_event(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.send_event;}
void set_XEvent_xconfigurerequest_send_event(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.send_event = (int)_v;}
void *get_XEvent_xconfigurerequest_display(void *_p) {return (void *)((XEvent *)_p)->xconfigurerequest.display;}
void set_XEvent_xconfigurerequest_display(void *_p, void *_v) {((XEvent *)_p)->xconfigurerequest.display = (Display *)_v;}
unsigned long get_XEvent_xconfigurerequest_parent(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigurerequest.parent;}
void set_XEvent_xconfigurerequest_parent(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigurerequest.parent = (unsigned long)_v;}
unsigned long get_XEvent_xconfigurerequest_window(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigurerequest.window;}
void set_XEvent_xconfigurerequest_window(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigurerequest.window = (unsigned long)_v;}
int get_XEvent_xconfigurerequest_x(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.x;}
void set_XEvent_xconfigurerequest_x(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.x = (int)_v;}
int get_XEvent_xconfigurerequest_y(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.y;}
void set_XEvent_xconfigurerequest_y(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.y = (int)_v;}
int get_XEvent_xconfigurerequest_width(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.width;}
void set_XEvent_xconfigurerequest_width(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.width = (int)_v;}
int get_XEvent_xconfigurerequest_height(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.height;}
void set_XEvent_xconfigurerequest_height(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.height = (int)_v;}
int get_XEvent_xconfigurerequest_border_width(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.border_width;}
void set_XEvent_xconfigurerequest_border_width(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.border_width = (int)_v;}
unsigned long get_XEvent_xconfigurerequest_above(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigurerequest.above;}
void set_XEvent_xconfigurerequest_above(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigurerequest.above = (unsigned long)_v;}
int get_XEvent_xconfigurerequest_detail(void *_p) {return (int)((XEvent *)_p)->xconfigurerequest.detail;}
void set_XEvent_xconfigurerequest_detail(void *_p, int _v) {((XEvent *)_p)->xconfigurerequest.detail = (int)_v;}
unsigned long get_XEvent_xconfigurerequest_value_mask(void *_p) {return (unsigned long)((XEvent *)_p)->xconfigurerequest.value_mask;}
void set_XEvent_xconfigurerequest_value_mask(void *_p, unsigned long _v) {((XEvent *)_p)->xconfigurerequest.value_mask = (unsigned long)_v;}
int get_XEvent_xcirculate_type(void *_p) {return (int)((XEvent *)_p)->xcirculate.type;}
void set_XEvent_xcirculate_type(void *_p, int _v) {((XEvent *)_p)->xcirculate.type = (int)_v;}
unsigned long get_XEvent_xcirculate_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculate.serial;}
void set_XEvent_xcirculate_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculate.serial = (unsigned long)_v;}
int get_XEvent_xcirculate_send_event(void *_p) {return (int)((XEvent *)_p)->xcirculate.send_event;}
void set_XEvent_xcirculate_send_event(void *_p, int _v) {((XEvent *)_p)->xcirculate.send_event = (int)_v;}
void *get_XEvent_xcirculate_display(void *_p) {return (void *)((XEvent *)_p)->xcirculate.display;}
void set_XEvent_xcirculate_display(void *_p, void *_v) {((XEvent *)_p)->xcirculate.display = (Display *)_v;}
unsigned long get_XEvent_xcirculate_event(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculate.event;}
void set_XEvent_xcirculate_event(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculate.event = (unsigned long)_v;}
unsigned long get_XEvent_xcirculate_window(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculate.window;}
void set_XEvent_xcirculate_window(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculate.window = (unsigned long)_v;}
int get_XEvent_xcirculate_place(void *_p) {return (int)((XEvent *)_p)->xcirculate.place;}
void set_XEvent_xcirculate_place(void *_p, int _v) {((XEvent *)_p)->xcirculate.place = (int)_v;}
int get_XEvent_xcirculaterequest_type(void *_p) {return (int)((XEvent *)_p)->xcirculaterequest.type;}
void set_XEvent_xcirculaterequest_type(void *_p, int _v) {((XEvent *)_p)->xcirculaterequest.type = (int)_v;}
unsigned long get_XEvent_xcirculaterequest_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculaterequest.serial;}
void set_XEvent_xcirculaterequest_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculaterequest.serial = (unsigned long)_v;}
int get_XEvent_xcirculaterequest_send_event(void *_p) {return (int)((XEvent *)_p)->xcirculaterequest.send_event;}
void set_XEvent_xcirculaterequest_send_event(void *_p, int _v) {((XEvent *)_p)->xcirculaterequest.send_event = (int)_v;}
void *get_XEvent_xcirculaterequest_display(void *_p) {return (void *)((XEvent *)_p)->xcirculaterequest.display;}
void set_XEvent_xcirculaterequest_display(void *_p, void *_v) {((XEvent *)_p)->xcirculaterequest.display = (Display *)_v;}
unsigned long get_XEvent_xcirculaterequest_parent(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculaterequest.parent;}
void set_XEvent_xcirculaterequest_parent(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculaterequest.parent = (unsigned long)_v;}
unsigned long get_XEvent_xcirculaterequest_window(void *_p) {return (unsigned long)((XEvent *)_p)->xcirculaterequest.window;}
void set_XEvent_xcirculaterequest_window(void *_p, unsigned long _v) {((XEvent *)_p)->xcirculaterequest.window = (unsigned long)_v;}
int get_XEvent_xcirculaterequest_place(void *_p) {return (int)((XEvent *)_p)->xcirculaterequest.place;}
void set_XEvent_xcirculaterequest_place(void *_p, int _v) {((XEvent *)_p)->xcirculaterequest.place = (int)_v;}
int get_XEvent_xproperty_type(void *_p) {return (int)((XEvent *)_p)->xproperty.type;}
void set_XEvent_xproperty_type(void *_p, int _v) {((XEvent *)_p)->xproperty.type = (int)_v;}
unsigned long get_XEvent_xproperty_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xproperty.serial;}
void set_XEvent_xproperty_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xproperty.serial = (unsigned long)_v;}
int get_XEvent_xproperty_send_event(void *_p) {return (int)((XEvent *)_p)->xproperty.send_event;}
void set_XEvent_xproperty_send_event(void *_p, int _v) {((XEvent *)_p)->xproperty.send_event = (int)_v;}
void *get_XEvent_xproperty_display(void *_p) {return (void *)((XEvent *)_p)->xproperty.display;}
void set_XEvent_xproperty_display(void *_p, void *_v) {((XEvent *)_p)->xproperty.display = (Display *)_v;}
unsigned long get_XEvent_xproperty_window(void *_p) {return (unsigned long)((XEvent *)_p)->xproperty.window;}
void set_XEvent_xproperty_window(void *_p, unsigned long _v) {((XEvent *)_p)->xproperty.window = (unsigned long)_v;}
unsigned long get_XEvent_xproperty_atom(void *_p) {return (unsigned long)((XEvent *)_p)->xproperty.atom;}
void set_XEvent_xproperty_atom(void *_p, unsigned long _v) {((XEvent *)_p)->xproperty.atom = (unsigned long)_v;}
unsigned long get_XEvent_xproperty_time(void *_p) {return (unsigned long)((XEvent *)_p)->xproperty.time;}
void set_XEvent_xproperty_time(void *_p, unsigned long _v) {((XEvent *)_p)->xproperty.time = (unsigned long)_v;}
int get_XEvent_xproperty_state(void *_p) {return (int)((XEvent *)_p)->xproperty.state;}
void set_XEvent_xproperty_state(void *_p, int _v) {((XEvent *)_p)->xproperty.state = (int)_v;}
int get_XEvent_xselectionclear_type(void *_p) {return (int)((XEvent *)_p)->xselectionclear.type;}
void set_XEvent_xselectionclear_type(void *_p, int _v) {((XEvent *)_p)->xselectionclear.type = (int)_v;}
unsigned long get_XEvent_xselectionclear_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionclear.serial;}
void set_XEvent_xselectionclear_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionclear.serial = (unsigned long)_v;}
int get_XEvent_xselectionclear_send_event(void *_p) {return (int)((XEvent *)_p)->xselectionclear.send_event;}
void set_XEvent_xselectionclear_send_event(void *_p, int _v) {((XEvent *)_p)->xselectionclear.send_event = (int)_v;}
void *get_XEvent_xselectionclear_display(void *_p) {return (void *)((XEvent *)_p)->xselectionclear.display;}
void set_XEvent_xselectionclear_display(void *_p, void *_v) {((XEvent *)_p)->xselectionclear.display = (Display *)_v;}
unsigned long get_XEvent_xselectionclear_window(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionclear.window;}
void set_XEvent_xselectionclear_window(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionclear.window = (unsigned long)_v;}
unsigned long get_XEvent_xselectionclear_selection(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionclear.selection;}
void set_XEvent_xselectionclear_selection(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionclear.selection = (unsigned long)_v;}
unsigned long get_XEvent_xselectionclear_time(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionclear.time;}
void set_XEvent_xselectionclear_time(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionclear.time = (unsigned long)_v;}
int get_XEvent_xselectionrequest_type(void *_p) {return (int)((XEvent *)_p)->xselectionrequest.type;}
void set_XEvent_xselectionrequest_type(void *_p, int _v) {((XEvent *)_p)->xselectionrequest.type = (int)_v;}
unsigned long get_XEvent_xselectionrequest_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.serial;}
void set_XEvent_xselectionrequest_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.serial = (unsigned long)_v;}
int get_XEvent_xselectionrequest_send_event(void *_p) {return (int)((XEvent *)_p)->xselectionrequest.send_event;}
void set_XEvent_xselectionrequest_send_event(void *_p, int _v) {((XEvent *)_p)->xselectionrequest.send_event = (int)_v;}
void *get_XEvent_xselectionrequest_display(void *_p) {return (void *)((XEvent *)_p)->xselectionrequest.display;}
void set_XEvent_xselectionrequest_display(void *_p, void *_v) {((XEvent *)_p)->xselectionrequest.display = (Display *)_v;}
unsigned long get_XEvent_xselectionrequest_owner(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.owner;}
void set_XEvent_xselectionrequest_owner(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.owner = (unsigned long)_v;}
unsigned long get_XEvent_xselectionrequest_requestor(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.requestor;}
void set_XEvent_xselectionrequest_requestor(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.requestor = (unsigned long)_v;}
unsigned long get_XEvent_xselectionrequest_selection(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.selection;}
void set_XEvent_xselectionrequest_selection(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.selection = (unsigned long)_v;}
unsigned long get_XEvent_xselectionrequest_target(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.target;}
void set_XEvent_xselectionrequest_target(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.target = (unsigned long)_v;}
unsigned long get_XEvent_xselectionrequest_property(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.property;}
void set_XEvent_xselectionrequest_property(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.property = (unsigned long)_v;}
unsigned long get_XEvent_xselectionrequest_time(void *_p) {return (unsigned long)((XEvent *)_p)->xselectionrequest.time;}
void set_XEvent_xselectionrequest_time(void *_p, unsigned long _v) {((XEvent *)_p)->xselectionrequest.time = (unsigned long)_v;}
int get_XEvent_xselection_type(void *_p) {return (int)((XEvent *)_p)->xselection.type;}
void set_XEvent_xselection_type(void *_p, int _v) {((XEvent *)_p)->xselection.type = (int)_v;}
unsigned long get_XEvent_xselection_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.serial;}
void set_XEvent_xselection_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.serial = (unsigned long)_v;}
int get_XEvent_xselection_send_event(void *_p) {return (int)((XEvent *)_p)->xselection.send_event;}
void set_XEvent_xselection_send_event(void *_p, int _v) {((XEvent *)_p)->xselection.send_event = (int)_v;}
void *get_XEvent_xselection_display(void *_p) {return (void *)((XEvent *)_p)->xselection.display;}
void set_XEvent_xselection_display(void *_p, void *_v) {((XEvent *)_p)->xselection.display = (Display *)_v;}
unsigned long get_XEvent_xselection_requestor(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.requestor;}
void set_XEvent_xselection_requestor(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.requestor = (unsigned long)_v;}
unsigned long get_XEvent_xselection_selection(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.selection;}
void set_XEvent_xselection_selection(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.selection = (unsigned long)_v;}
unsigned long get_XEvent_xselection_target(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.target;}
void set_XEvent_xselection_target(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.target = (unsigned long)_v;}
unsigned long get_XEvent_xselection_property(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.property;}
void set_XEvent_xselection_property(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.property = (unsigned long)_v;}
unsigned long get_XEvent_xselection_time(void *_p) {return (unsigned long)((XEvent *)_p)->xselection.time;}
void set_XEvent_xselection_time(void *_p, unsigned long _v) {((XEvent *)_p)->xselection.time = (unsigned long)_v;}
int get_XEvent_xcolormap_type(void *_p) {return (int)((XEvent *)_p)->xcolormap.type;}
void set_XEvent_xcolormap_type(void *_p, int _v) {((XEvent *)_p)->xcolormap.type = (int)_v;}
unsigned long get_XEvent_xcolormap_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xcolormap.serial;}
void set_XEvent_xcolormap_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xcolormap.serial = (unsigned long)_v;}
int get_XEvent_xcolormap_send_event(void *_p) {return (int)((XEvent *)_p)->xcolormap.send_event;}
void set_XEvent_xcolormap_send_event(void *_p, int _v) {((XEvent *)_p)->xcolormap.send_event = (int)_v;}
void *get_XEvent_xcolormap_display(void *_p) {return (void *)((XEvent *)_p)->xcolormap.display;}
void set_XEvent_xcolormap_display(void *_p, void *_v) {((XEvent *)_p)->xcolormap.display = (Display *)_v;}
unsigned long get_XEvent_xcolormap_window(void *_p) {return (unsigned long)((XEvent *)_p)->xcolormap.window;}
void set_XEvent_xcolormap_window(void *_p, unsigned long _v) {((XEvent *)_p)->xcolormap.window = (unsigned long)_v;}
unsigned long get_XEvent_xcolormap_colormap(void *_p) {return (unsigned long)((XEvent *)_p)->xcolormap.colormap;}
void set_XEvent_xcolormap_colormap(void *_p, unsigned long _v) {((XEvent *)_p)->xcolormap.colormap = (unsigned long)_v;}
int get_XEvent_xcolormap_new(void *_p) {return (int)((XEvent *)_p)->xcolormap.new;}
void set_XEvent_xcolormap_new(void *_p, int _v) {((XEvent *)_p)->xcolormap.new = (int)_v;}
int get_XEvent_xcolormap_state(void *_p) {return (int)((XEvent *)_p)->xcolormap.state;}
void set_XEvent_xcolormap_state(void *_p, int _v) {((XEvent *)_p)->xcolormap.state = (int)_v;}
int get_XEvent_xclient_type(void *_p) {return (int)((XEvent *)_p)->xclient.type;}
void set_XEvent_xclient_type(void *_p, int _v) {((XEvent *)_p)->xclient.type = (int)_v;}
unsigned long get_XEvent_xclient_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xclient.serial;}
void set_XEvent_xclient_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xclient.serial = (unsigned long)_v;}
int get_XEvent_xclient_send_event(void *_p) {return (int)((XEvent *)_p)->xclient.send_event;}
void set_XEvent_xclient_send_event(void *_p, int _v) {((XEvent *)_p)->xclient.send_event = (int)_v;}
void *get_XEvent_xclient_display(void *_p) {return (void *)((XEvent *)_p)->xclient.display;}
void set_XEvent_xclient_display(void *_p, void *_v) {((XEvent *)_p)->xclient.display = (Display *)_v;}
unsigned long get_XEvent_xclient_window(void *_p) {return (unsigned long)((XEvent *)_p)->xclient.window;}
void set_XEvent_xclient_window(void *_p, unsigned long _v) {((XEvent *)_p)->xclient.window = (unsigned long)_v;}
unsigned long get_XEvent_xclient_message_type(void *_p) {return (unsigned long)((XEvent *)_p)->xclient.message_type;}
void set_XEvent_xclient_message_type(void *_p, unsigned long _v) {((XEvent *)_p)->xclient.message_type = (unsigned long)_v;}
int get_XEvent_xclient_format(void *_p) {return (int)((XEvent *)_p)->xclient.format;}
void set_XEvent_xclient_format(void *_p, int _v) {((XEvent *)_p)->xclient.format = (int)_v;}
void *get_XEvent_xclient_data_b(void *_p) {return (void *)(((XEvent *)_p)->xclient.data.b);}
void *get_XEvent_xclient_data_s(void *_p) {return (void *)(((XEvent *)_p)->xclient.data.s);}
void *get_XEvent_xclient_data_l(void *_p) {return (void *)(((XEvent *)_p)->xclient.data.l);}
int get_XEvent_xmapping_type(void *_p) {return (int)((XEvent *)_p)->xmapping.type;}
void set_XEvent_xmapping_type(void *_p, int _v) {((XEvent *)_p)->xmapping.type = (int)_v;}
unsigned long get_XEvent_xmapping_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xmapping.serial;}
void set_XEvent_xmapping_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xmapping.serial = (unsigned long)_v;}
int get_XEvent_xmapping_send_event(void *_p) {return (int)((XEvent *)_p)->xmapping.send_event;}
void set_XEvent_xmapping_send_event(void *_p, int _v) {((XEvent *)_p)->xmapping.send_event = (int)_v;}
void *get_XEvent_xmapping_display(void *_p) {return (void *)((XEvent *)_p)->xmapping.display;}
void set_XEvent_xmapping_display(void *_p, void *_v) {((XEvent *)_p)->xmapping.display = (Display *)_v;}
unsigned long get_XEvent_xmapping_window(void *_p) {return (unsigned long)((XEvent *)_p)->xmapping.window;}
void set_XEvent_xmapping_window(void *_p, unsigned long _v) {((XEvent *)_p)->xmapping.window = (unsigned long)_v;}
int get_XEvent_xmapping_request(void *_p) {return (int)((XEvent *)_p)->xmapping.request;}
void set_XEvent_xmapping_request(void *_p, int _v) {((XEvent *)_p)->xmapping.request = (int)_v;}
int get_XEvent_xmapping_first_keycode(void *_p) {return (int)((XEvent *)_p)->xmapping.first_keycode;}
void set_XEvent_xmapping_first_keycode(void *_p, int _v) {((XEvent *)_p)->xmapping.first_keycode = (int)_v;}
int get_XEvent_xmapping_count(void *_p) {return (int)((XEvent *)_p)->xmapping.count;}
void set_XEvent_xmapping_count(void *_p, int _v) {((XEvent *)_p)->xmapping.count = (int)_v;}
int get_XEvent_xerror_type(void *_p) {return (int)((XEvent *)_p)->xerror.type;}
void set_XEvent_xerror_type(void *_p, int _v) {((XEvent *)_p)->xerror.type = (int)_v;}
void *get_XEvent_xerror_display(void *_p) {return (void *)((XEvent *)_p)->xerror.display;}
void set_XEvent_xerror_display(void *_p, void *_v) {((XEvent *)_p)->xerror.display = (Display *)_v;}
unsigned long get_XEvent_xerror_resourceid(void *_p) {return (unsigned long)((XEvent *)_p)->xerror.resourceid;}
void set_XEvent_xerror_resourceid(void *_p, unsigned long _v) {((XEvent *)_p)->xerror.resourceid = (unsigned long)_v;}
unsigned long get_XEvent_xerror_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xerror.serial;}
void set_XEvent_xerror_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xerror.serial = (unsigned long)_v;}
unsigned char get_XEvent_xerror_error_code(void *_p) {return (unsigned char)((XEvent *)_p)->xerror.error_code;}
void set_XEvent_xerror_error_code(void *_p, unsigned char _v) {((XEvent *)_p)->xerror.error_code = (unsigned char)_v;}
unsigned char get_XEvent_xerror_request_code(void *_p) {return (unsigned char)((XEvent *)_p)->xerror.request_code;}
void set_XEvent_xerror_request_code(void *_p, unsigned char _v) {((XEvent *)_p)->xerror.request_code = (unsigned char)_v;}
unsigned char get_XEvent_xerror_minor_code(void *_p) {return (unsigned char)((XEvent *)_p)->xerror.minor_code;}
void set_XEvent_xerror_minor_code(void *_p, unsigned char _v) {((XEvent *)_p)->xerror.minor_code = (unsigned char)_v;}
int get_XEvent_xkeymap_type(void *_p) {return (int)((XEvent *)_p)->xkeymap.type;}
void set_XEvent_xkeymap_type(void *_p, int _v) {((XEvent *)_p)->xkeymap.type = (int)_v;}
unsigned long get_XEvent_xkeymap_serial(void *_p) {return (unsigned long)((XEvent *)_p)->xkeymap.serial;}
void set_XEvent_xkeymap_serial(void *_p, unsigned long _v) {((XEvent *)_p)->xkeymap.serial = (unsigned long)_v;}
int get_XEvent_xkeymap_send_event(void *_p) {return (int)((XEvent *)_p)->xkeymap.send_event;}
void set_XEvent_xkeymap_send_event(void *_p, int _v) {((XEvent *)_p)->xkeymap.send_event = (int)_v;}
void *get_XEvent_xkeymap_display(void *_p) {return (void *)((XEvent *)_p)->xkeymap.display;}
void set_XEvent_xkeymap_display(void *_p, void *_v) {((XEvent *)_p)->xkeymap.display = (Display *)_v;}
unsigned long get_XEvent_xkeymap_window(void *_p) {return (unsigned long)((XEvent *)_p)->xkeymap.window;}
void set_XEvent_xkeymap_window(void *_p, unsigned long _v) {((XEvent *)_p)->xkeymap.window = (unsigned long)_v;}
void *get_XEvent_xkeymap_key_vector(void *_p) {return (void *)(((XEvent *)_p)->xkeymap.key_vector);}
void *get_XEvent_pad(void *_p) {return (void *)(((XEvent *)_p)->pad);}
void *alloc_XEDataObject(void) {XEDataObject *_p = (XEDataObject *)malloc(sizeof(XEDataObject)); if (_p==NULL) abort(); return (void *)_p;}
void free_XEDataObject(void *_p) {if (_p==NULL) abort(); free((XEDataObject *)_p);}
void *get_XEDataObject_display(void *_p) {return (void *)((XEDataObject *)_p)->display;}
void set_XEDataObject_display(void *_p, void *_v) {((XEDataObject *)_p)->display = (Display *)_v;}
void *get_XEDataObject_gc(void *_p) {return (void *)((XEDataObject *)_p)->gc;}
void set_XEDataObject_gc(void *_p, void *_v) {((XEDataObject *)_p)->gc = (void *)_v;}
void *get_XEDataObject_visual(void *_p) {return (void *)((XEDataObject *)_p)->visual;}
void set_XEDataObject_visual(void *_p, void *_v) {((XEDataObject *)_p)->visual = (Visual *)_v;}
void *get_XEDataObject_screen(void *_p) {return (void *)((XEDataObject *)_p)->screen;}
void set_XEDataObject_screen(void *_p, void *_v) {((XEDataObject *)_p)->screen = (Screen *)_v;}
void *get_XEDataObject_pixmap_format(void *_p) {return (void *)((XEDataObject *)_p)->pixmap_format;}
void set_XEDataObject_pixmap_format(void *_p, void *_v) {((XEDataObject *)_p)->pixmap_format = (ScreenFormat *)_v;}
void *get_XEDataObject_font(void *_p) {return (void *)((XEDataObject *)_p)->font;}
void set_XEDataObject_font(void *_p, void *_v) {((XEDataObject *)_p)->font = (XFontStruct *)_v;}
void *alloc_int(void) {int *_p = (int *)malloc(sizeof(int)); if (_p==NULL) abort(); return (void *)_p;}
void free_int(void *_p) {if (_p==NULL) abort(); free((int *)_p);}
int get_int(void *_p) {return *((int *)_p);}
void set_int(void *_p, int _v) {*((int *)_p) = _v;}
|
the_stack_data/91384.c
|
char * XXX(char ** strs, int strsSize){
char *s = *strs;
int j = 0;
while (*s) {
for (int i = 1; i < strsSize; i++) {
char ch = *(*(strs + i) + j);
if (*s != ch) {
*s = '\0';
return *strs;
}
}
s++;
j++;
}
return *strs;
}
|
the_stack_data/22012388.c
|
/*
* Copyright (c) 2017-present, Texas Instruments Incorporated
* 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.
*
* * Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* 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 OWNER 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.
*/
/*
* ======== EventCombinerP_tirtos.c ========
*/
#ifdef _TMS320C6X
#include <ti/osal/osal.h>
#include <ti/osal/EventCombinerP.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <xdc/std.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/Memory.h>
#include <ti/osal/src/tirtos/tirtos_config.h>
#include <ti/sysbios/family/c66/tci66xx/CpIntc.h>
#include <ti/sysbios/family/c64p/EventCombiner.h>
#include <ti/sysbios/family/c64p/Hwi.h>
#ifdef __cplusplus
extern "C" {
#endif
/* This is the number of c6x interrupts [0-15] */
#define OSAL_ECM_NUM_INTERRUPTS (Hwi_NUM_INTERRUPTS)
/**************************************************************
Description: Returns the Hwi Handle associated with the event group.
It returns NULL_PTR if the Event combiner is not registered
with an interrupt vector (0-15)
Argument: The Event Combiner group Number [0-3]
Returns: The HwiHandle corresponding to the group number.
NULL_PTR if it doesnt registered yet.
*******************************************************************/
HwiP_Handle EventCombinerP_getHwi(uint32_t groupNum) {
HwiP_Handle handle=NULL_PTR;
int32_t event,i;
for(i=0;i<OSAL_ECM_NUM_INTERRUPTS;i++) {
/* Find out the event associated with the interrupt vector number */
event=Hwi_getEventId((uint32_t)i);
if((uint32_t)event==groupNum) {
/* If the associated event is the ECM group queried (0-3),
* return the handle */
handle=(HwiP_Handle)Hwi_getHandle((uint32_t)i);
break;
}
}
return(handle);
}
/**************************************************************
Description: Returns the interrupt vector id corresponding to a
event combiner group number [0-3)
Argument: The Event Combiner group Number [0-3]
Returns: The interrupt vector id corresponding to a groupNum.
-1 if the event combiner is not registered
*******************************************************************/
int32_t EventCombinerP_getIntNum(int32_t groupNum) {
int32_t event,i,intNum=-1;
for(i=0;i<OSAL_ECM_NUM_INTERRUPTS;i++) {
/* Find out the event associated with the interrupt vector number */
event=Hwi_getEventId((uint32_t)i);
if(event==groupNum) {
/* If the associated event is the ECM group (0-3),
* find out the event associated with the interrupt vector number */
intNum=i;
break;
}
}
return(intNum);
}
/**************************************************************
Description: Register an event combiner interrupt
Argument: groupNum: The group number (0-3).
intNum: The interrupt vector id to register
the event combiner to.
Returns: OSAL_EVTCOMBINE_GROUPREG_SUCCESS if allocated well.
OSAL_EVTCOMBINE_ERR_GROUPREG_REGISTER_ERR if error.
*******************************************************************/
int32_t EventCombinerP_SingleRegisterInt(int32_t groupNum, int32_t intNum)
{
int32_t ret=OSAL_EVTCOMBINE_GROUPREG_SUCCESS;
HwiP_Handle hwiHandle=NULL_PTR;
HwiP_Params hwiInputParams;
if(EventCombinerP_getHwi((uint32_t)groupNum)!=NULL_PTR) {
/* Already registered, nothing to do */
ret = OSAL_EVTCOMBINE_GROUPREG_SUCCESS;
}
else
{
HwiP_Params_init(&hwiInputParams);
hwiInputParams.name = (char *) NULL_PTR;
hwiInputParams.priority = 0x20U;
hwiInputParams.arg = (uintptr_t)groupNum;
hwiInputParams.evtId = (uint32_t)groupNum;
if( (intNum>0) && (intNum <OSAL_ECM_NUM_INTERRUPTS) ) {
hwiHandle = HwiP_create(intNum,&EventCombiner_dispatch, &hwiInputParams);
if(hwiHandle==NULL_PTR) {
ret= OSAL_EVTCOMBINE_ERR_GROUPREG_REGISTER_ERR;
}
} else {
ret = OSAL_EVTCOMBINE_ERR_GROUPREG_INVALID_INTNUM;
}
}
return ret;
}
/**************************************************************
Description: Register all the event combiner interrupts
Argument: intNum[]: The interrupt vector ids to register
the event combiner to
Returns: OSAL_EVTCOMBINE_GROUPREG_SUCCESS if
allocated well.
OSAL_EVTCOMBINE_ERR_GROUPREG_REGISTER_ERR if error.
*******************************************************************/
int32_t EventCombinerP_GroupRegisterInt(int32_t intNum[])
{
int32_t ret=OSAL_EVTCOMBINE_GROUPREG_SUCCESS,i;
for(i=0;i<4;i++) {
if((intNum[i]>0) && (intNum[i]<OSAL_ECM_NUM_INTERRUPTS)) {
ret=EventCombinerP_SingleRegisterInt(i,intNum[i]);
if(ret!=OSAL_EVTCOMBINE_GROUPREG_SUCCESS) {
break;
}
}
}
return ret;
}
/**************************************************************************
Description: Disable a particular event Number inside the Event Combiner
Argument: eventNum: The event number(4-127) to disable inside
the event combiner
Returns: OSAL_EVTCOMBINE_GROUPREG_SUCCESS
****************************************************************************/
int32_t EventCombinerP_disableEvent(uint32_t eventNum)
{
EventCombiner_disableEvent(eventNum);
return OSAL_EVTCOMBINE_GROUPREG_SUCCESS;
}
/**************************************************************************
Description: Enable a particular event Number inside the Event Combiner
Argument: eventNum: The event number(4-127) to enable inside
the event combiner
Returns: OSAL_EVTCOMBINE_GROUPREG_SUCCESS
****************************************************************************/
int32_t EventCombinerP_enableEvent(uint32_t eventNum)
{
EventCombiner_enableEvent(eventNum);
return OSAL_EVTCOMBINE_GROUPREG_SUCCESS;
}
/**************************************************************************
Description: Plugs a event's(4-127) to the EventCombiner's dispatcher
Arguments: eventId: The event number(4-127)
eventIsrRoutine: The event's ISR routine
unmask: TRUE/FALSE: Mask/Unmask the event combiner flag
Returns: OSAL_EVTCOMBINE_GROUPREG_SUCCESS
****************************************************************************/
int32_t EventCombinerP_dispatchPlug(uint32_t eventId, EventCombinerP_FuncPtr eventIsrRoutine,uintptr_t arg,bool unmask )
{
EventCombiner_dispatchPlug (eventId,(EventCombiner_FuncPtr)(eventIsrRoutine),arg,(uint16_t)((unmask==(bool)true)?1U:0U));
return OSAL_EVTCOMBINE_GROUPREG_SUCCESS;
}
#ifdef __cplusplus
}
#endif
#endif /* #ifdef _TMS320C6X */
|
the_stack_data/1010213.c
|
/*
* Copyright (c) 2021-2021 Huawei Device Co., Ltd. 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.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* 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.
*/
#include "stdio.h"
#include "stdlib.h"
void init_test(void) __attribute__((constructor));
void fini_test(void) __attribute((destructor));
int g_param = 10;
static int param = 2;
void init_first(void)
{
g_param = 100;
}
void init_test(void)
{
g_param += param;
}
void fini_end(void)
{
g_param = 0;
}
void fini_test(void)
{
param = 0;
}
int callee(int a, int b)
{
return g_param + a + b;
}
int test_api(int a, int b)
{
int c = callee(a, b);
return c;
}
|
the_stack_data/20902.c
|
#include <stdio.h>
int main(void)
{
printf("Hans Kloss\n");
printf("Hans\nKloss\n");
printf("Hans ");
printf("Kloss\n");
return 0;
}
|
the_stack_data/148576864.c
|
int pof(){
int uV[3][30], uR[3][30];
int lv1, lv0,result1=0,result2=0;
for(lv0=0;lv0<=2;lv0+=1){
for(lv1=0;lv1<=29;lv1+=1){
result1+=uV[lv0][lv1];
result2+=uR[lv0][lv1];
}
}
return result1+result2;
}
|
the_stack_data/141579.c
|
// #include "autopilot.h"
#define PPRZ_MODE_MANUAL 0
#define PPRZ_MODE_AUTO1 1
#define PPRZ_MODE_AUTO2 2
#define PPRZ_MODE_HOME 3
#define PPRZ_MODE_NB 4
#define TRIM_PPRZ(pprz) (pprz < MIN_PPRZ ? MIN_PPRZ : \
(pprz > MAX_PPRZ ? MAX_PPRZ : \
pprz))
#define TRIM_UPPRZ(pprz) (pprz < 0 ? 0 : \
(pprz > MAX_PPRZ ? MAX_PPRZ : \
pprz))
/* from autopilot.h ends */
/* from include/std.h */
#define FALSE 0
#define TRUE (!FALSE)
/* include/std.h */
#define NAV_PITCH 0 /* from var/....h */
/* added by sanjit */
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef unsigned char bool_t;
/* sanjit add ends */
/* from sw/var/include/airframe.h */
#define ROLL_PGAIN 10000.
#define PITCH_OF_ROLL 0.0
#define PITCH_PGAIN 15000.
#define MAX_ROLL 0.35
#define MAX_PITCH 0.35
#define MIN_PITCH -0.35
#define CLIMB_PITCH_PGAIN -0.1
#define CLIMB_PITCH_IGAIN 0.025
#define CLIMB_PGAIN -0.03
#define CLIMB_IGAIN 0.1
#define CLIMB_MAX 1.
#define CLIMB_LEVEL_GAZ 0.31
#define CLIMB_PITCH_OF_VZ_PGAIN 0.05
#define CLIMB_GAZ_OF_CLIMB 0.2
/* airframe.h */
#define VERTICAL_MODE_MANUAL 0
#define VERTICAL_MODE_AUTO_GAZ 1
#define VERTICAL_MODE_AUTO_CLIMB 2
#define VERTICAL_MODE_AUTO_ALT 3
#define VERTICAL_MODE_NB 4
#define MAX_CLIMB_SUM_ERR 100
#define MAX_PITCH_CLIMB_SUM_ERR 100
/*---- from fly_by_wire/link_autopilot.h */
/*
* System clock in MHz.
*/
#define CLOCK 16
/* !!!!!!!!!!!!!!!!!!! Value used in gen_airframe.ml !!!!!!!!!!!!!!!!! */
#define MAX_PPRZ (600 * CLOCK)
#define MIN_PPRZ -MAX_PPRZ
/* --- fly_by_wire/link_autopilot.h */
/* from main.c */
uint8_t pprz_mode;
uint8_t vertical_mode = VERTICAL_MODE_MANUAL;
static bool_t low_battery = FALSE;
/* end of stuff from main.c */
uint16_t nav_desired_gaz;
uint16_t estimator_flight_time;
bool_t launch = FALSE;
float nav_pitch = NAV_PITCH;
float estimator_z_dot;
bool_t auto_pitch = FALSE;
/* below vars from pid.c (mostly) */
float desired_roll = 0.;
float desired_pitch = 0.;
int16_t desired_gaz, desired_aileron, desired_elevator;
float roll_pgain = ROLL_PGAIN;
float pitch_pgain = PITCH_PGAIN;
float pitch_of_roll = PITCH_OF_ROLL;
float pitch_of_vz_pgain = CLIMB_PITCH_OF_VZ_PGAIN;
float pitch_of_vz = 0.;
const float climb_pgain = CLIMB_PGAIN;
const float climb_igain = CLIMB_IGAIN;
float desired_climb = 0., pre_climb = 0.;
static const float level_gaz = CLIMB_LEVEL_GAZ;
float climb_sum_err = 0;
float climb_pitch_pgain = CLIMB_PITCH_PGAIN;
float climb_pitch_igain = CLIMB_PITCH_IGAIN;
float climb_pitch_sum_err = 0.;
float max_pitch = MAX_PITCH;
float min_pitch = MIN_PITCH;
void climb_control_task(void)
{
if (pprz_mode == PPRZ_MODE_AUTO2 || pprz_mode == PPRZ_MODE_HOME)
{
if (vertical_mode >= VERTICAL_MODE_AUTO_CLIMB) {
/* climb_pid_run(); function inlined below */
/* inlined climb_pid_run begins */
float err = estimator_z_dot - desired_climb;
float fgaz;
if (auto_pitch) { /* gaz constant */
desired_gaz = nav_desired_gaz;
desired_pitch = climb_pitch_pgain * (err + climb_pitch_igain * climb_pitch_sum_err);
if (desired_pitch > max_pitch)
desired_pitch = max_pitch;
if (desired_pitch < min_pitch)
desired_pitch = min_pitch;
climb_pitch_sum_err += err;
if (climb_pitch_sum_err > MAX_PITCH_CLIMB_SUM_ERR)
climb_pitch_sum_err = MAX_PITCH_CLIMB_SUM_ERR;
if (climb_pitch_sum_err < - MAX_PITCH_CLIMB_SUM_ERR)
climb_pitch_sum_err = - MAX_PITCH_CLIMB_SUM_ERR;
} else { /* pitch almost constant */
/* pitch offset for climb */
pitch_of_vz = (desired_climb > 0) ? desired_climb * pitch_of_vz_pgain : 0.;
fgaz = climb_pgain * (err + climb_igain * climb_sum_err) + CLIMB_LEVEL_GAZ + CLIMB_GAZ_OF_CLIMB*desired_climb;
climb_sum_err += err;
if (climb_sum_err > MAX_CLIMB_SUM_ERR) climb_sum_err = MAX_CLIMB_SUM_ERR;
if (climb_sum_err < - MAX_CLIMB_SUM_ERR) climb_sum_err = - MAX_CLIMB_SUM_ERR;
desired_gaz = TRIM_UPPRZ(fgaz * MAX_PPRZ);
desired_pitch = nav_pitch + pitch_of_vz;
}
/* inlined climb_pid_run ends */
}
if (vertical_mode == VERTICAL_MODE_AUTO_GAZ)
desired_gaz = nav_desired_gaz;
if (low_battery || (!estimator_flight_time && !launch))
desired_gaz = 0.;
}
}
int main() {
pprz_mode = 2;
vertical_mode = 0;
low_battery = 0;
estimator_flight_time = 0;
launch = 0;
#ifdef PRET
asm(".word 0x22222222");
#endif
}
|
the_stack_data/22013000.c
|
/*C program to product two numbers using functions
of type with no arguments and no return type*/
#include <stdio.h>
void prod();
int main()
{
prod();
}
void prod()
{
int a, b, prod;
printf("Enter first number:");
scanf("%d", &a);
printf("Enter second number:");
scanf("%d", &b);
prod = a * b;
printf("Product of two numbers=%d", prod);
return 0;
}
|
the_stack_data/48340.c
|
// Exercise 7 from chapter 10
// This function inserts a string into another string.
#include<stdio.h>
#include<string.h>
void insertString( char source[], char insert[], int pos )
// source array has to have a size big enough to hold both source and insert characters plus the null character
{
int i, j;
for( i = strlen( source ); i >= pos; i-- ) // move characters forward as many positions as the size of insert
source[i + strlen( insert )] = source[i];
for( i = 0, j = pos; i < strlen( insert ); i++, j++ ) // places insert string inside source string
source [j] = insert[i];
}
|
the_stack_data/151705945.c
|
#include <fenv.h>
|
the_stack_data/1143959.c
|
extern void abort (void);
extern int inside_main;
__attribute__ ((__noinline__))
__SIZE_TYPE__
strcspn (const char *s1, const char *s2)
{
const char *p, *q;
#ifdef __OPTIMIZE__
if (inside_main)
abort();
#endif
for (p = s1; *p; p++)
{
for (q = s2; *q; q++)
if (*p == *q)
goto proceed;
break;
proceed:;
}
return p - s1;
}
|
the_stack_data/43888252.c
|
/*numPass=6, numTotal=6
Verdict:ACCEPTED, Visibility:1, Input:"1 0 0 1", ExpOutput:"(0.000,0.000)
", Output:"(0.000,0.000)"
Verdict:ACCEPTED, Visibility:1, Input:"1 0 1 0", ExpOutput:"INF
", Output:"INF"
Verdict:ACCEPTED, Visibility:1, Input:"100 100 -1 -101", ExpOutput:"(-2.010,102.010)
", Output:"(-2.010,102.010)"
Verdict:ACCEPTED, Visibility:0, Input:"1000 000 1 -1", ExpOutput:"(1.000,0.000)
", Output:"(1.000,0.000)"
Verdict:ACCEPTED, Visibility:0, Input:"-1 -2 -3 -4", ExpOutput:"(3.000,-8.000)
", Output:"(3.000,-8.000)"
Verdict:ACCEPTED, Visibility:0, Input:"0 0 000 0000", ExpOutput:"INF
", Output:"INF"
*/
#include<stdio.h>
int main(){
float a1,b1,a2,b2;
scanf("%f %f %f %f",&a1,&b1,&a2,&b2);
float x;
x=(a1*a2)*(b1-b2)/(a2*b1-a1*b2);
float y;
y=(b1*b2)*(a1-a2)/(a1*b2-a2*b1);
if ((a1*b2)==(a2*b1)){
printf("INF");} //condition of parallel lines
else{
printf("(%.3f,%.3f)",x,y);}
return 0;
}
|
the_stack_data/173404.c
|
/*
* temp.c
*
* Created on: Oct 4, 2014
* Author: etsam
*/
/*
* Test application that data integraty of inter processor
* communication from linux userspace to a remote software
* context. The application sends chunks of data to the
* remote processor. The remote side echoes the data back
* to application which then validates the data returned.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <time.h>
#include <fcntl.h>
#include <string.h>
/* Shutdown message ID */
#define SHUTDOWN_MSG 0xEF56A55A
struct _payload {
unsigned long num;
unsigned long size;
char data[];
};
static int fd, err_cnt;
struct _payload *i_payload;
struct _payload *r_payload;
#define RPMSG_GET_KFIFO_SIZE 1
#define RPMSG_GET_AVAIL_DATA_SIZE 2
#define RPMSG_GET_FREE_SPACE 3
#define RPMSG_HEADER_LEN 16
#define MAX_RPMSG_BUFF_SIZE (512 - RPMSG_HEADER_LEN)
#define PAYLOAD_MIN_SIZE 1
#define PAYLOAD_MAX_SIZE (MAX_RPMSG_BUFF_SIZE - 24)
#define NUM_PAYLOADS (PAYLOAD_MAX_SIZE/PAYLOAD_MIN_SIZE)
int main(int argc, char *argv[])
{
int flag = 1;
int shutdown_msg = SHUTDOWN_MSG;
int cmd, ret, i, expect_rnum;
int size, bytes_rcvd, bytes_sent;
err_cnt = 0;
int opt;
char *rpmsg_dev="/dev/rpmsg0";
while ((opt = getopt(argc, argv, "d:")) != -1) {
switch (opt) {
case 'd':
rpmsg_dev = optarg;
break;
default:
printf("getopt return unsupported option: -%c\n",opt);
break;
}
}
printf("\r\n Echo test start \r\n");
printf("\r\n Open rpmsg dev! \r\n");
fd = open(rpmsg_dev, O_RDWR | O_NONBLOCK);
if (fd < 0) {
perror("Failed to open rpmsg file /dev/rpmsg0.");
return -1;
}
printf("\r\n Query internal info .. \r\n");
ioctl(fd, RPMSG_GET_KFIFO_SIZE, &size);
printf(" rpmsg kernel fifo size = %u \r\n", size);
ioctl(fd, RPMSG_GET_FREE_SPACE, &size);
printf(" rpmsg kernel fifo free space = %u \r\n", size);
i_payload = (struct _payload *)malloc(2 * sizeof(unsigned long) + PAYLOAD_MAX_SIZE);
r_payload = (struct _payload *)malloc(2 * sizeof(unsigned long) + PAYLOAD_MAX_SIZE);
if (i_payload == 0 || r_payload == 0) {
printf("ERROR: Failed to allocate memory for payload.\n");
return -1;
}
while (flag == 1) {
printf("\r\n **************************************** \r\n");
printf(" Please enter command and press enter key\r\n");
printf(" **************************************** \r\n");
printf(" 1 - Send data to remote core, retrieve the echo");
printf(" and validate its integrity .. \r\n");
printf(" 2 - Quit this application .. \r\n");
printf(" CMD>");
ret = scanf("%d", &cmd);
if (!ret) {
while (1) {
if (getchar() == '\n')
break;
}
printf("\r\n invalid command\r\n");
continue;
}
if (cmd == 1) {
expect_rnum = 0;
for (i = 0, size = PAYLOAD_MIN_SIZE; i < NUM_PAYLOADS;
i++, size++) {
i_payload->num = i;
i_payload->size = size;
/* Mark the data buffer. */
memset(&(i_payload->data[0]), 0xA5, size);
printf("\r\n sending payload number");
printf(" %d of size %d \r\n", i_payload->num,
(2 * sizeof(unsigned long)) + size);
bytes_sent = write(fd, i_payload,
(2 * sizeof(unsigned long)) + size);
if (bytes_sent <= 0) {
printf("\r\n Error sending data");
printf(" .. \r\n");
break;
}
expect_rnum++;
printf("echo test: sent : %d\n", bytes_sent);
r_payload->num = 0;
bytes_rcvd = read(fd, r_payload,
(2 * sizeof(unsigned long)) + PAYLOAD_MAX_SIZE);
while (bytes_rcvd <= 0) {
usleep(10000);
bytes_rcvd = read(fd, r_payload,
(2 * sizeof(unsigned long)) + PAYLOAD_MAX_SIZE);
}
printf(" received payload number ");
printf("%d of size %d \r\n", r_payload->num, bytes_rcvd);
/* Validate data buffer integrity. */
for (i = 0; i < r_payload->size; i++) {
if (r_payload->data[i] != 0xA5) {
printf(" \r\n Data corruption");
printf(" at index %d \r\n", i);
err_cnt++;
break;
}
}
bytes_rcvd = read(fd, r_payload,
(2 * sizeof(unsigned long)) + PAYLOAD_MAX_SIZE);
}
printf("\r\n **********************************");
printf("****\r\n");
printf("\r\n Test Results: Error count = %d\r\n",
err_cnt);
printf("\r\n **********************************");
printf("****\r\n");
} else if (cmd == 2) {
flag = 0;
/* Send shutdown message to remote */
write(fd, &shutdown_msg, sizeof(int));
sleep(1);
printf("\r\n Quitting application .. \r\n");
printf(" Echo test end \r\n");
} else {
printf("\r\n invalid command! \r\n");
}
}
free(i_payload);
free(r_payload);
close(fd);
return 0;
}
|
the_stack_data/72012528.c
|
#include <stdio.h>
#define NUM_LINES 100
#define LINE_LEN 25
typedef enum {BEFORE_SONG, IN_SONG_AND_LINE, IN_SONG_BETWEEN} state_t;
state_t state = BEFORE_SONG;
int half = 1;
FILE *fp;
FILE *ofp;
unsigned char prev_ch, curr_ch;
unsigned char lines[NUM_LINES][LINE_LEN];
unsigned char separator[NUM_LINES][LINE_LEN];
unsigned char deltas[NUM_LINES][LINE_LEN];
unsigned char *first_lines,
*second_lines,
*first_separators,
*second_separators,
*first_deltas,
*second_deltas;
int max_lines;
void read1() {
prev_ch = curr_ch;
curr_ch = getc(fp);
// fprintf(ofp, "%X %X\n", prev_ch, curr_ch);
}
void read2() {
prev_ch = getc(fp);
curr_ch = getc(fp);
// fprintf(ofp, "%X %X\n", prev_ch, curr_ch);
}
void printLine(unsigned char *line) {
fprintf(ofp, "%2d: ", (line - lines[0])/LINE_LEN);
int m = 0;
for (m = 0; m < LINE_LEN; m++) {
if (line[m] != 0) {
putc(line[m], ofp);
} else {
putc(' ', ofp);
}
}
}
void printDeltas(unsigned char *deltas) {
int m, max;
for (max = LINE_LEN-1; max >= 0; max--) {
if (deltas[max] != 0)
break;
}
for (m = 0; m <= max; m++) {
fprintf(ofp, "%2X ", deltas[m]);
}
for (m = max+1; m < LINE_LEN; m++) {
fprintf(ofp, " ");
}
}
void printSeparator(unsigned char *sep) {
int m, max;
for (max = LINE_LEN-1; max >= 0; max--) {
if (sep[max] != 0)
break;
}
for (m = 0; m <= max; m++) {
fprintf(ofp, "%2X ", sep[m]);
}
}
int endSection(unsigned char *sep) {
// does this sep end with 00 26, a break in the music?
int m, max;
for (max = LINE_LEN-1; max >= 0; max--) {
if (sep[max] != 0)
break;
}
if ((max >= 1) && (sep[max] == 0x26) && (sep[max-1] == 0))
return 1;
return 0;
}
int main(int argc, char **argv) {
int inSong = 0;
// int lineNo = 0;
int inLine = 0;
bzero(lines, NUM_LINES*LINE_LEN* sizeof(unsigned char));
bzero(separator, NUM_LINES*LINE_LEN* sizeof(unsigned char));
bzero(deltas, NUM_LINES*LINE_LEN* sizeof(unsigned char));
int lineNo = 0;
int charNo = 0;
if (argc == 1) {
fp = stdin;
ofp = stdout;
} else if (argc == 2) {
fp = fopen(argv[1], "r");
ofp = stdout;
} else {
fp = fopen(argv[1], "r");
ofp = fopen(argv[2], "w");
}
int n = 0;
while ((n++ < 6000) && (half <= 2)) {
switch (state) {
case BEFORE_SONG:
read2();
if ((prev_ch == 0) && (curr_ch == '&')) {
state = IN_SONG_AND_LINE;
}
break;
case IN_SONG_AND_LINE:
read2();
if (curr_ch == '^') {
state = IN_SONG_BETWEEN;
putc('\n', ofp);
fprintf(ofp, "%d: ", lineNo);
charNo = 0;
separator[lineNo][charNo++] = prev_ch;
separator[lineNo][charNo++] = curr_ch;
} else {
if (curr_ch != 0) {
putc(curr_ch, ofp);
lines[lineNo][charNo] = curr_ch;
deltas[lineNo][charNo] = prev_ch;
charNo++;
}
}
break;
case IN_SONG_BETWEEN:
read1();
if (curr_ch == '&') {
state = IN_SONG_AND_LINE;
separator[lineNo][charNo++] = curr_ch;
charNo = 0;
lineNo += 1;
} else if (curr_ch == 0xFF) {
if (half == 1) {
// the 2nd half
fprintf(ofp, "\n\nStarting 2nd half\n\n");
// discard extra
//getc(fp);
//lineNo = -1;
max_lines = lineNo;
half = 2;
} else {
half = 3;
}
} else {
separator[lineNo][charNo++] = curr_ch;
}
break;
}
}
fprintf(ofp, "\n\nDumping lines\n\n");
first_lines = lines[0];
second_lines = lines[0] + (max_lines+1) * LINE_LEN;
first_deltas = deltas[0];
second_deltas = deltas[0] + (max_lines+1) * LINE_LEN;
first_separators = separator[0];
second_separators = separator[0] + (max_lines+1) * LINE_LEN;
for (n = 0; n < max_lines; n++) {
fprintf(ofp, "%2d: ", n);
/*
if (lines[n][0] == 0) {
break;
}
*/
//printLine(lines[n]);
printLine(first_lines);
first_lines += LINE_LEN;
fprintf(ofp, "\n ");
//printDeltas(deltas[n]);
printDeltas(first_deltas);
first_deltas += LINE_LEN;
//printSeparator(separator[n]);
printSeparator(first_separators);
first_separators += LINE_LEN;
putc('\n', ofp);
if (endSection(first_separators - LINE_LEN)) {
fprintf(ofp, "Break occurring in first line\n");
//continue;
}
fprintf(ofp, "%2d: ", n + max_lines + 1);
//printLine(lines[n + max_lines + 1]);
printLine(second_lines);
second_lines += LINE_LEN;
fprintf(ofp, "\n ");
//printDeltas(deltas[n + max_lines + 1]);
printDeltas(second_deltas);
second_deltas += LINE_LEN;
//printSeparator(separator[n + max_lines + 1]);
printSeparator(second_separators);
second_separators += LINE_LEN;
if (endSection(second_separators - LINE_LEN)) {
fprintf(ofp, "Break occurring in second line\n");
//continue;
}
/*
for (m = 0; m < LINE_LEN/2; m++) {
fprintf(ofp, "%2X ", separator[n][m]);
}
*/
putc('\n', ofp);
}
fclose(ofp);
exit(0);
}
|
the_stack_data/154342.c
|
// RUN: %clang_asan -O2 %s -o %t
// RUN: %env_asan_opts=check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// FIXME: sprintf is not intercepted on Windows yet.
// XFAIL: win32
#include <stdio.h>
int main() {
volatile char c = '0';
volatile int x = 12;
volatile float f = 1.239;
volatile char s[] = "34";
volatile char buf[2];
fputs("before sprintf\n", stderr);
sprintf((char *)buf, "%c %d %.3f %s\n", c, x, f, s);
fputs("after sprintf", stderr);
fputs((const char *)buf, stderr);
return 0;
// Check that size of output buffer is sanitized.
// CHECK-ON: before sprintf
// CHECK-ON-NOT: after sprintf
// CHECK-ON: stack-buffer-overflow
// CHECK-ON-NOT: 0 12 1.239 34
}
|
the_stack_data/1112699.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_is_negative.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dpearson <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/06/28 16:16:59 by dpearson #+# #+# */
/* Updated: 2017/06/28 16:18:08 by dpearson ### ########.fr */
/* */
/* ************************************************************************** */
int ft_putchar(char c);
void ft_is_negative(int n)
{
if (n < 0)
{
ft_putchar('N');
}
else
{
ft_putchar('P');
}
}
|
the_stack_data/65371.c
|
#include <assert.h>
char tmp[12];
char *first;
char *second;
int array_size;
void initialize()
{
tmp[0] = '1';
tmp[9] = '0';
tmp[10] = 'a';
first = (char *)tmp;
second = first;
array_size = 11;
}
void checkpoint()
{
}
int main()
{
initialize();
checkpoint();
assert(first == second);
assert(second[array_size - 1] == 'a');
assert(first[0] == '1');
assert(second[9] == '0');
return 0;
}
|
the_stack_data/42437.c
|
/* blitter.c
*/
#include <stdio.h>
blitpix(dst, src, x, y, sw, dw)
signed char *dst;
unsigned char *src;
int x, y, sw, dw;
{
int i, j;
for ( j = 0; j < y; j++ ) {
for ( i = 0; i < x; i++ ) {
dst[i] = src[i];
}
src += sw;
dst += dw;
}
return 0;
}
blitwrd(dst, src, x, y, sw, dw)
signed short *dst;
unsigned short *src;
int x, y, sw, dw;
{
int i, j;
for ( j = 0; j < y; j++ ) {
for ( i = 0; i < x; i++ ) {
dst[i] = src[i];
}
src += sw;
dst += dw;
}
return 0;
}
procwrd(dst, src, bias, biasscale, sm, x, y, sw, dw)
signed short *dst;
unsigned short *src;
unsigned short *bias;
double biasscale;
int sm;
int x, y, sw, dw;
{
int i, j;
int check = 1;
if ( sm ) {
smooth(src, dst, x, y, sw, dw, bias, biasscale);
} else {
for ( j = 0; j < y; j++ ) {
for ( i = 0; i < x; i++ ) {
dst[i] = (src[i] - bias[i] * biasscale);
}
src += sw;
bias += sw;
dst += dw;
}
}
return 0;
}
|
the_stack_data/57949797.c
|
#include <stdio.h>
int main (){
int a,b,i;
scanf("%d",&a);
for (i = 1; i <= a; i++)
{
scanf("%d",&b);
printf("resposta %d: %d\n",i,b);
}
return 0;
}
|
the_stack_data/879594.c
|
#include<stdio.h>
main()
{
int i=0;
while(1)
{
printf("%d",i);
i++;
if(i==10000)
{
break;
}
}
getch();
}
|
the_stack_data/70449290.c
|
void api_putchar(int c);
void HariMain(void){
api_putchar('A');
}
|
the_stack_data/85637.c
|
#include<stdio.h>
#include<string.h>
int main()
{
char str[200];
int i,freq[26];
gets(str);
for(i=0;i<26;i++)
{
freq[i]=0;
}
for(i=0;i<strlen(str);i++)
{
if(str[i]>='a' && str[i]<='z')
{
freq[str[i]-97]++;
}
else if(str[i]>='A' && str[i]<='Z')
{
freq[str[i]-65]++;
}
}
for(i=0;i<26;i++)
{
if(freq[i] !=0)
{
printf("%c = %d\n",(i+97),freq[i]);
}
}
return 0;
}
|
the_stack_data/14199329.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <pthread.h>
int port = 6789;
void* listen_command(){
int sin_len;
char message[256];
//检查gpio 13号 是否存在
if (-1 == access("/sys/class/gpio/gpio13", 0)) {
system("gpio export 13 out");
}
int socket_descriptor;
struct sockaddr_in sin;
printf("Waiting for data from sender \n");
bzero(&sin, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(port);
sin_len = sizeof(sin);
socket_descriptor = socket(AF_INET, SOCK_DGRAM, 0);
bind(socket_descriptor, (struct sockaddr *)&sin, sizeof(sin));
//阻塞监听
while(recvfrom(socket_descriptor, message, sizeof(message), 0, (struct sockaddr *)&sin, &sin_len) > -1){
//recvfrom(socket_descriptor, message, sizeof(message), 0, (struct sockaddr *)&sin, &sin_len);
printf("Response from server: %s\n", message);
if(strncmp(message, "low", 3) == 0){
system("echo 0 > /sys/class/gpio/gpio13/value");
}
if(strncmp(message, "high", 4) == 0){
system("echo 1 > /sys/class/gpio/gpio13/value");
}
if(strncmp(message, "stop", 4) == 0){
printf("Sender has told me to end the connection\n");
break;
}
//清空多余的字符
memset(message, 0, sizeof(message));
}
close(socket_descriptor);
return (EXIT_SUCCESS);
}
int main(int argc, char ** argv){
pthread_t thread;
int error = pthread_create(&thread, NULL, listen_command, NULL);
if(0 != error){
printf("%s\n", strerror(error));
exit(-1);
}
error = pthread_join(thread, NULL);
if(0 != error){
printf("%s\n", strerror(error));
exit(-1);
}
return 0;
}
|
the_stack_data/40964.c
|
/* What I would do to test the code would be:
* 1st run the code and look at what errors are given to me
* 2nd find what the error means and try and fix the error
* 3rd trace the code until I can find the problem
* 4th fix the error and run the code again
* 5th repeat until the code works
*/
|
the_stack_data/25139034.c
|
#include <stdlib.h>
struct fptr
{
int (*p_fptr)(int, int);
};
struct fsptr
{
struct fptr * sptr;
};
struct wfsptr
{
struct fsptr * wfptr;
};
int plus(int a, int b) {
return a+b;
}
int minus(int a, int b) {
return a-b;
}
void make_alias(struct wfsptr *a,struct fsptr *b)
{
a->wfptr->sptr->p_fptr=b->sptr->p_fptr;
}
void foo(int x)
{
struct fptr a_fptr;
struct fptr b_fptr;
struct fsptr s_fptr;
struct fsptr m_fptr;
struct wfsptr* w_fptr=(struct wfsptr*)malloc(sizeof(struct wfsptr));
s_fptr.sptr=&a_fptr;
m_fptr.sptr=&b_fptr;
b_fptr.p_fptr=minus;
w_fptr->wfptr=&s_fptr;
if(x>1)
{
a_fptr.p_fptr=plus;
x=s_fptr.sptr->p_fptr(1,x);
make_alias(w_fptr,&m_fptr);
}else
{
w_fptr->wfptr->sptr->p_fptr=minus;
}
x=a_fptr.p_fptr(1,x);
}
// 31 : malloc
// 39 : plus
// 40 : make_alias
// 45 : minus
|
the_stack_data/184518123.c
|
#include<stdio.h>
int main()
{
char a[20], b[20], d[40];
printf("Enter 2 strings to concat");
scanf("%s\n%s",a,b);
string_concat(a,b);
return 0;
}
void string_concat(char a[20], char b[20])
{
int i=0;
char c[40];
int l1=length(a); int l2=length(b);
for(i=0;i<=l1-1;i++)
{
c[i]=a[i];
}
for(i=l1;i<l1+l2;i++)
{
c[i]=b[i];
}
printf("%s",c);
}
|
the_stack_data/48576302.c
|
int function (int a , int b , int c){
return c;
}
int main(){
int a,b,d;
a=2;
b=2;
d=2;
d=function (a,b,d);
printf(d);
}
|
the_stack_data/106259.c
|
/* { dg-do compile } */
/* { dg-options "-O2 -fdump-tree-tailc" } */
void
set_integer (void *dest, int value, int length)
{
int tmp = value;
__builtin_memcpy (dest, (void *) &tmp, length);
}
/* { dg-final { scan-tree-dump-not "tail call" "tailc" } } */
|
the_stack_data/31388254.c
|
//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <stdio.h>
#include <stdio.h>
// Forward declare an enumeration (only works in C, not C++)
typedef enum ops ops;
struct foo {
ops *op;
};
int main (int argc, char const *argv[])
{
enum days {
Monday = -3,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday,
kNumDays
};
enum days day;
struct foo f;
f.op = NULL;
for (day = Monday - 1; day <= kNumDays + 1; day++)
{
printf("day as int is %i\n", (int)day); // Set break point at this line.
}
return 0;
}
|
the_stack_data/90766001.c
|
int main() {
char *shell = getenv("MYSHELL");
if (shell)
printf("%x\n", shell);
return 0;
}
|
the_stack_data/28326.c
|
void Test(long long Val, int Amt) {
printf("0x%llx op %d:\n", Val, Amt);
printf(" ashr: 0x%llx\n lshr: 0x%llx\n shl: 0x%llx\n", Val >> Amt,
(unsigned long long)Val >> Amt, Val << Amt);
}
volatile struct {
long long A; int V;
} Vals[] = {
{ 123, 4},
{ 123, 34},
{-4, 4},
{-5, 34},
{ -6000000000LL, 4},
{ -6000000000LL, 34},
{ 6000000000LL, 4},
{ 6000000000LL, 34}
};
int main(int argc, char**argv) {
for (argc--; argc < sizeof(Vals)/sizeof(Vals[0]); ++argc)
Test(Vals[argc].A, Vals[argc].V);
return 0;
}
|
the_stack_data/120697.c
|
#ifdef WIN32
#include <Windows.h>
#include <wingdi.h>
#include <gdiplus.h>
#include "windowbackend.h"
#include "../render/renderer.h"
#include "../render/texture.h"
#include "../render/pixel.h"
#include "../render/depth.h"
LPCWSTR g_szClassName = L"myWindowClass";
Vec4i rect;
Vec2i totalSize;
Depth * zetaBuffer;
Pixel * frameBuffer;
COLORREF * copyBuffer;
HWND windowHandle;
HDC windowsHDC;
LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_ERASEBKGND:
break;
case WM_PAINT:
{
for (int y = 0; y < rect.z*rect.w; y++ ) {
copyBuffer[y] = pixelToRGBA(&frameBuffer[y]);
}
HBITMAP map = CreateBitmap(rect.z, // width
rect.w, // height
1, // Color Planes
8*4, // Size of memory for one pixel in bits (in win32 4 bytes = 4*8 bits)
copyBuffer); // pointer to array
HDC bitmapHDC = CreateCompatibleDC(windowsHDC);
SelectObject(bitmapHDC, map); // Inserting picture into our temp HDC
PAINTSTRUCT ps;
//BeginPaint(windowHandle, &ps);
FillRect(windowsHDC,&ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));
BitBlt(windowsHDC, // Destination
rect.x, // x dest
rect.y, // y dest
rect.z, //width
rect.w, // height
bitmapHDC, // source bitmap
0, // x source
0, // y source
SRCCOPY); // Defined DWORD to juct copy pixels.
ps.rcPaint = (RECT){0,0, totalSize.x, totalSize.y};
//EndPaint(windowHandle, &ps);
DeleteDC(bitmapHDC);
DeleteObject(map);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
HWND WINAPI winMain(HINSTANCE hInstance, HINSTANCE hINSTANCE, LPSTR lPSTR, int nCmdShow)
{
WNDCLASSEX wc;
HWND hwnd;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = 0;
wc.lpfnWndProc = wndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszMenuName = NULL;
wc.lpszClassName = g_szClassName;
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if(!RegisterClassEx(&wc))
{
MessageBox(NULL, L"Window Registration Failed!", L"Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
// Step 2: Creating the Window
hwnd = CreateWindowEx(
WS_EX_CLIENTEDGE,
g_szClassName,
L"Pingo renderer - Window backend",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
totalSize.x+20, //Adjusted for borders
totalSize.y+41, //Adjusted for borders
NULL, NULL, hInstance, NULL);
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
windowsHDC = GetDC(hwnd);
return hwnd;
}
void init( Renderer * ren, BackEnd * backEnd, Vec4i _rect) {
//Save the rect so the windows drawing code knows whhere and how to copy the rendered buffer on the window
rect = _rect;
}
void beforeRender( Renderer * ren, BackEnd * backEnd) {
WindowBackEnd * this = (WindowBackEnd *) backEnd;
MSG msg;
}
void afterRender( Renderer * ren, BackEnd * backEnd) {
//Dispatch window messages, eventually one of the messages will be a redraw and the window rect will be updated
MSG msg;
if ( GetMessage( &msg, NULL, 0, 0 ) ) {
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
Pixel * getFrameBuffer( Renderer * ren, BackEnd * backEnd) {
return frameBuffer;
}
Depth * getZetaBuffer( Renderer * ren, BackEnd * backEnd) {
return zetaBuffer;
}
void windowBackEndInit( WindowBackEnd * this, Vec2i size) {
totalSize = size;
this->backend.init = &init;
this->backend.beforeRender = &beforeRender;
this->backend.afterRender = &afterRender;
this->backend.getFrameBuffer = &getFrameBuffer;
this->backend.getZetaBuffer = &getZetaBuffer;
this->backend.drawPixel = 0;
zetaBuffer = malloc(size.x*size.y*sizeof (Depth));
frameBuffer = malloc(size.x*size.y*sizeof (Pixel));
copyBuffer = malloc(size.x*size.y*sizeof (COLORREF) * 4);
windowHandle = winMain(0,0,0, SW_NORMAL );
}
#endif
|
the_stack_data/76699329.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* reducepuzzle.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: pcardoso <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/10/13 00:35:01 by pcardoso #+# #+# */
/* Updated: 2019/10/13 02:38:44 by juolivei ### ########.fr */
/* */
/* ************************************************************************** */
void reducepuzzlecolumns2(int n, int puzzle[6][6])
{
if (puzzle[0][n] == 1)
puzzle[1][n] = 4;
if (puzzle[5][n] == 1)
puzzle[4][n] = 4;
if (puzzle[0][n] == 3 && puzzle[5][n] == 2)
puzzle[3][n] = 4;
if (puzzle[5][n] == 3 && puzzle[0][n] == 2)
puzzle[2][n] = 4;
if (puzzle[0][n] == 1 && puzzle[5][n] == 2)
puzzle[4][n] = 3;
if (puzzle[5][n] == 1 && puzzle[0][n] == 2)
puzzle[1][n] = 3;
}
void reducepuzzlerows2(int n, int puzzle[6][6])
{
if (puzzle[n][0] == 1)
puzzle[n][1] = 4;
if (puzzle[n][5] == 1)
puzzle[n][4] = 4;
if (puzzle[n][0] == 3 && puzzle[n][5] == 2)
puzzle[n][3] = 4;
if (puzzle[n][5] == 3 && puzzle[n][0] == 2)
puzzle[n][2] = 4;
if (puzzle[n][0] == 1 && puzzle[n][5] == 2)
puzzle[n][4] = 3;
if (puzzle[n][5] == 1 && puzzle[n][0] == 2)
puzzle[n][1] = 3;
}
void reducepuzzlecolumns(int n, int puzzle[6][6])
{
if (puzzle[0][n] == 4)
{
puzzle[1][n] = 1;
puzzle[2][n] = 2;
puzzle[3][n] = 3;
puzzle[4][n] = 4;
}
reducepuzzlecolumns2(n, puzzle);
if (puzzle[5][n] == 4)
{
puzzle[4][n] = 1;
puzzle[3][n] = 2;
puzzle[2][n] = 3;
puzzle[1][n] = 4;
}
reducepuzzlerows2(n, puzzle);
}
void reducepuzzlerows(int n, int puzzle[6][6])
{
if (puzzle[n][0] == 4)
{
puzzle[n][1] = 1;
puzzle[n][2] = 2;
puzzle[n][3] = 3;
puzzle[n][4] = 4;
}
if (puzzle[n][5] == 4)
{
puzzle[n][4] = 1;
puzzle[n][3] = 2;
puzzle[n][2] = 3;
puzzle[n][1] = 4;
}
}
|
the_stack_data/82950458.c
|
// Automatically generated file.
#include <assert.h>
#include <stdint.h>
#define byte uint8_t
#define bool _Bool
#define CALLCONV
#define Reg uint8_t
#define Reg_r0 0
#define Reg_r1 1
#define Reg_r2 2
#define Reg_r3 3
#define Reg_r4 4
#define Reg_r5 5
#define Reg_r6 6
#define Reg_r7 7
#define Reg_r8 8
#define Reg_r9 9
#define Reg_r10 10
#define Reg_r11 11
#define Reg_r12 12
#define Reg_r13 13
#define Reg_r14 14
#define Reg_r15 15
#define Reg_a1 0
#define Reg_a2 1
#define Reg_a3 2
#define Reg_a4 3
#define Reg_v1 4
#define Reg_v2 5
#define Reg_v3 6
#define Reg_v4 7
#define Reg_v5 8
#define Reg_v6 9
#define Reg_v7 10
#define Reg_v8 11
#define Reg_ip 12
#define Reg_sp 13
#define Reg_lr 14
#define Reg_pc 15
#define Reg_wr 7
#define Reg_sb 9
#define Reg_sl 10
#define Reg_fp 11
///
/// A list of ARM registers, where each register corresponds to a single bit.
typedef enum {
///
/// Register #1.
RLR0 = 0,
///
/// Register #2.
RLR1 = 1,
///
/// Register #3.
RLR2 = 2,
///
/// Register #4.
RLR3 = 3,
///
/// Register #5.
RLR4 = 4,
///
/// Register #6.
RLR5 = 5,
///
/// Register #7.
RLR6 = 6,
///
/// Register #8.
RLR7 = 7,
///
/// Register #9.
RLR8 = 8,
///
/// Register #10.
RLR9 = 9,
///
/// Register #11.
RLR10 = 10,
///
/// Register #12.
RLR11 = 11,
///
/// Register #13.
RLR12 = 12,
///
/// Register #14.
RLR13 = 13,
///
/// Register #15.
RLR14 = 14,
///
/// Register #16.
RLR15 = 15,
///
/// Register A1.
RLA1 = 0,
///
/// Register A2.
RLA2 = 1,
///
/// Register A3.
RLA3 = 2,
///
/// Register A4.
RLA4 = 3,
///
/// Register V1.
RLV1 = 4,
///
/// Register V2.
RLV2 = 5,
///
/// Register V3.
RLV3 = 6,
///
/// Register V4.
RLV4 = 7,
///
/// Register V5.
RLV5 = 8,
///
/// Register V6.
RLV6 = 9,
///
/// Register V7.
RLV7 = 10,
///
/// Register V8.
RLV8 = 11,
///
/// Register IP.
RLIP = 12,
///
/// Register SP.
RLSP = 13,
///
/// Register LR.
RLLR = 14,
///
/// Register PC.
RLPC = 15,
///
/// Register WR.
RLWR = 7,
///
/// Register SB.
RLSB = 9,
///
/// Register SL.
RLSL = 10,
///
/// Register FP.
RLFP = 11,
} RegList;
#define Coprocessor uint8_t
#define Coprocessor_cp0 0
#define Coprocessor_cp1 1
#define Coprocessor_cp2 2
#define Coprocessor_cp3 3
#define Coprocessor_cp4 4
#define Coprocessor_cp5 5
#define Coprocessor_cp6 6
#define Coprocessor_cp7 7
#define Coprocessor_cp8 8
#define Coprocessor_cp9 9
#define Coprocessor_cp10 10
#define Coprocessor_cp11 11
#define Coprocessor_cp12 12
#define Coprocessor_cp13 13
#define Coprocessor_cp14 14
#define Coprocessor_cp15 15
///
/// Condition for an ARM instruction to be executed.
typedef enum {
///
/// Equal.
EQ = 0,
///
/// Not equal.
NE = 1,
///
/// Unsigned higher or same.
HS = 2,
///
/// Unsigned lower.
LO = 3,
///
/// Minus / negative.
MI = 4,
///
/// Plus / positive or zero.
PL = 5,
///
/// Overflow.
VS = 6,
///
/// No overflow.
VC = 7,
///
/// Unsigned higher.
HI = 8,
///
/// Unsigned lower or same.
LS = 9,
///
/// Signed greater than or equal.
GE = 10,
///
/// Signed less than.
LT = 11,
///
/// Signed greater than.
GT = 12,
///
/// Signed less than or equal.
LE = 13,
///
/// Always (unconditional).
AL = 14,
///
/// Unpredictable (ARMv4 or lower).
UN = 15,
///
/// Carry set.
CS = 2,
///
/// Carry clear.
CC = 3,
} Condition;
///
/// Processor mode.
typedef enum {
///
/// User mode.
USRMode = 16,
///
/// FIQ (high-speed data transfer) mode.
FIQMode = 17,
///
/// IRQ (general-purpose interrupt handling) mode.
IRQMode = 18,
///
/// Supervisor mode.
SVCMode = 19,
///
/// Abort mode.
ABTMode = 23,
///
/// Undefined mode.
UNDMode = 27,
///
/// System (privileged) mode.
SYSMode = 31,
} Mode;
///
/// Kind of a shift.
typedef enum {
///
/// Logical shift left.
LogicalShiftLeft = 0,
///
/// Logical shift right.
LogicalShiftRight = 1,
///
/// Arithmetic shift right.
ArithShiftRight = 2,
///
/// Rotate right.
RotateRight = 3,
///
/// Shifted right by one bit.
RRX = 3,
} Shift;
///
/// Kind of a right rotation.
typedef enum {
///
/// Do not rotate.
NoRotation = 0,
///
/// Rotate 8 bits to the right.
RotateRight8 = 1,
///
/// Rotate 16 bits to the right.
RotateRight16 = 2,
///
/// Rotate 24 bits to the right.
RotateRight24 = 3,
} Rotation;
///
/// Field mask bits.
typedef enum {
///
/// Control field mask bit.
CFieldMask = 1,
///
/// Extension field mask bit.
XFieldMask = 2,
///
/// Status field mask bit.
SFieldMask = 4,
///
/// Flags field mask bit.
FFieldMask = 8,
} FieldMask;
///
/// Interrupt flags.
typedef enum {
///
/// FIQ interrupt bit.
InterruptFIQ = 1,
///
/// IRQ interrupt bit.
InterruptIRQ = 2,
///
/// Imprecise data abort bit.
ImpreciseDataAbort = 4,
} InterruptFlags;
///
/// Addressing type.
typedef enum {
///
/// Post-indexed addressing.
PostIndexedIndexing = 0,
///
/// Pre-indexed addressing (or offset addressing if `write` is false).
PreIndexedIndexing = 1,
///
/// Offset addressing (or pre-indexed addressing if `write` is true).
OffsetIndexing = 1,
} Addressing;
///
/// Offset adding or subtracting mode.
typedef enum {
///
/// Subtract offset from the base.
SubtractOffset = 0,
///
/// Add offset to the base.
AddOffset = 1,
} OffsetMode;
void CALLCONV arm_adc(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((10485760 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_add(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((8388608 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_and(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((0 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_eor(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((2097152 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_orr(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((25165824 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_rsb(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((6291456 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_rsc(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((14680064 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_sbc(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((12582912 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_sub(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((4194304 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_bkpt(void** buf, uint16_t immed) {
*(uint32_t*)(*buf) = ((3776970864 | ((immed & 65520) << 8)) | ((immed & 15) << 0));
*(byte*)buf += 4;
}
void CALLCONV arm_b(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (167772160 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_bic(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((29360128 | cond) | (update_cprs << 20)) | (rn << 16)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_blx(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (19922736 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_bx(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (19922704 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_bxj(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (19922720 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_blxun(void** buf) {
*(uint32_t*)(*buf) = 4194304000;
*(byte*)buf += 4;
}
void CALLCONV arm_clz(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((24055568 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_cmn(void** buf, Condition cond, Reg rn) {
*(uint32_t*)(*buf) = ((24117248 | cond) | (rn << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_cmp(void** buf, Condition cond, Reg rn) {
*(uint32_t*)(*buf) = ((22020096 | cond) | (rn << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_cpy(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((27262976 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_cps(void** buf, Mode mode) {
*(uint32_t*)(*buf) = (4043440128 | (mode << 0));
*(byte*)buf += 4;
}
void CALLCONV arm_cpsie(void** buf, InterruptFlags iflags) {
*(uint32_t*)(*buf) = (4043833344 | (iflags << 6));
*(byte*)buf += 4;
}
void CALLCONV arm_cpsid(void** buf, InterruptFlags iflags) {
*(uint32_t*)(*buf) = (4044095488 | (iflags << 6));
*(byte*)buf += 4;
}
void CALLCONV arm_cpsie_mode(void** buf, InterruptFlags iflags, Mode mode) {
*(uint32_t*)(*buf) = ((4043964416 | (iflags << 6)) | (mode << 0));
*(byte*)buf += 4;
}
void CALLCONV arm_cpsid_mode(void** buf, InterruptFlags iflags, Mode mode) {
*(uint32_t*)(*buf) = ((4044226560 | (iflags << 6)) | (mode << 0));
*(byte*)buf += 4;
}
void CALLCONV arm_ldc(void** buf, Condition cond, bool write, Reg rn, Coprocessor cpnum, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((202375168 | cond) | (write << 21)) | (rn << 16)) | (cpnum << 8)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldm(void** buf, Condition cond, Reg rn, OffsetMode offset_mode, Addressing addressing_mode, RegList registers, bool write, bool copy_spsr) {
assert(((copy_spsr == 1) ^ (write == (registers & 32768))));
*(uint32_t*)(*buf) = ((((((((135266304 | cond) | (rn << 16)) | (addressing_mode << 23)) | (offset_mode << 11)) | (addressing_mode << 23)) | registers) | (copy_spsr << 21)) | (write << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_ldr(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((68157440 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrb(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((72351744 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrbt(void** buf, Condition cond, Reg rn, Reg rd, OffsetMode offset_mode) {
*(uint32_t*)(*buf) = ((((74448896 | cond) | (rn << 16)) | (rd << 12)) | (offset_mode << 23));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrd(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((208 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrex(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((26218399 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrh(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((1048752 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrsb(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((1048784 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrsh(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((1048816 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ldrt(void** buf, Condition cond, Reg rn, Reg rd, OffsetMode offset_mode) {
*(uint32_t*)(*buf) = ((((70254592 | cond) | (rn << 16)) | (rd << 12)) | (offset_mode << 23));
*(byte*)buf += 4;
}
void CALLCONV arm_cdp(void** buf, Condition cond, Coprocessor cpnum) {
*(uint32_t*)(*buf) = ((234881024 | cond) | (cpnum << 8));
*(byte*)buf += 4;
}
void CALLCONV arm_mcr(void** buf, Condition cond, Reg rd, Coprocessor cpnum) {
*(uint32_t*)(*buf) = (((234881040 | cond) | (rd << 12)) | (cpnum << 8));
*(byte*)buf += 4;
}
void CALLCONV arm_mrc(void** buf, Condition cond, Reg rd, Coprocessor cpnum) {
*(uint32_t*)(*buf) = (((235929616 | cond) | (rd << 12)) | (cpnum << 8));
*(byte*)buf += 4;
}
void CALLCONV arm_mcrr(void** buf, Condition cond, Reg rn, Reg rd, Coprocessor cpnum) {
*(uint32_t*)(*buf) = ((((205520896 | cond) | (rn << 16)) | (rd << 12)) | (cpnum << 8));
*(byte*)buf += 4;
}
void CALLCONV arm_mla(void** buf, Condition cond, bool update_cprs, Reg rn, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = (((((2097296 | cond) | (update_cprs << 20)) | (rn << 12)) | (rd << 16)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_mov(void** buf, Condition cond, bool update_cprs, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = ((((27262976 | cond) | (update_cprs << 20)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_mrrc(void** buf, Condition cond, Reg rn, Reg rd, Coprocessor cpnum) {
*(uint32_t*)(*buf) = ((((206569472 | cond) | (rn << 16)) | (rd << 12)) | (cpnum << 8));
*(byte*)buf += 4;
}
void CALLCONV arm_mrs(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((17760256 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_mul(void** buf, Condition cond, bool update_cprs, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = ((((144 | cond) | (update_cprs << 20)) | (rd << 16)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_mvn(void** buf, Condition cond, bool update_cprs, Reg rd, bool update_condition) {
*(uint32_t*)(*buf) = ((((31457280 | cond) | (update_cprs << 20)) | (rd << 12)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_msr_imm(void** buf, Condition cond, FieldMask fieldmask) {
*(uint32_t*)(*buf) = ((52490240 | cond) | (fieldmask << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_msr_reg(void** buf, Condition cond, FieldMask fieldmask) {
*(uint32_t*)(*buf) = ((18935808 | cond) | (fieldmask << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_pkhbt(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((109051920 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_pkhtb(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((109051984 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_pld(void** buf, Reg rn, OffsetMode offset_mode) {
*(uint32_t*)(*buf) = ((4115722240 | (rn << 16)) | (offset_mode << 23));
*(byte*)buf += 4;
}
void CALLCONV arm_qadd(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777296 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764304 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764432 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qaddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764336 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qdadd(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((20971600 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qdsub(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((23068752 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qsub(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((18874448 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qsub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764400 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qsub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764528 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_qsubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((102764368 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_rev(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((113184560 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_rev16(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((113184688 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_revsh(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((117378992 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_rfe(void** buf, bool write, Reg rn, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((4161800704 | (write << 21)) | (rn << 16)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_sadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715728 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_sadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715856 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_saddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715760 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_sel(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((109055920 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_setendbe(void** buf) {
*(uint32_t*)(*buf) = 4043375104;
*(byte*)buf += 4;
}
void CALLCONV arm_setendle(void** buf) {
*(uint32_t*)(*buf) = 4043374592;
*(byte*)buf += 4;
}
void CALLCONV arm_shadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103812880 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_shadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103813008 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_shaddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103812912 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_shsub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103812976 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_shsub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103813104 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_shsubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((103812944 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_smlabb(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777344 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlabt(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777376 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlatb(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777408 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlatt(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777440 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlad(void** buf, Condition cond, bool exchange, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = ((((117440528 | cond) | (exchange << 5)) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlal(void** buf, Condition cond, bool update_cprs, bool update_condition) {
*(uint32_t*)(*buf) = (((14680208 | cond) | (update_cprs << 20)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_smlalbb(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (20971648 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_smlalbt(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (20971680 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_smlaltb(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (20971712 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_smlaltt(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (20971744 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_smlald(void** buf, Condition cond, bool exchange) {
*(uint32_t*)(*buf) = ((121634832 | cond) | (exchange << 5));
*(byte*)buf += 4;
}
void CALLCONV arm_smlawb(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((18874496 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlawt(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((18874560 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlsd(void** buf, Condition cond, bool exchange, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = ((((117440592 | cond) | (exchange << 5)) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smlsld(void** buf, Condition cond, bool exchange) {
*(uint32_t*)(*buf) = ((121634896 | cond) | (exchange << 5));
*(byte*)buf += 4;
}
void CALLCONV arm_smmla(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((122683408 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smmls(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((122683600 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smmul(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((122744848 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smuad(void** buf, Condition cond, bool exchange, Reg rd) {
*(uint32_t*)(*buf) = (((117501968 | cond) | (exchange << 5)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smulbb(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((23068800 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smulbt(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((23068832 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smultb(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((23068864 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smultt(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((23068896 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smull(void** buf, Condition cond, bool update_cprs, bool update_condition) {
*(uint32_t*)(*buf) = (((12583056 | cond) | (update_cprs << 20)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_smulwb(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((18874528 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smulwt(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((18874592 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_smusd(void** buf, Condition cond, bool exchange, Reg rd) {
*(uint32_t*)(*buf) = (((117502032 | cond) | (exchange << 5)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_srs(void** buf, bool write, Mode mode, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((4165797120 | (write << 21)) | (mode << 0)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_ssat(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((105906192 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_ssat16(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((111152944 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_ssub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715824 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_ssub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715952 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_ssubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((101715792 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_stc(void** buf, Condition cond, bool write, Reg rn, Coprocessor cpnum, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((201326592 | cond) | (write << 21)) | (rn << 16)) | (cpnum << 8)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_stm(void** buf, Condition cond, Reg rn, OffsetMode offset_mode, Addressing addressing_mode, RegList registers, bool write, bool user_mode) {
assert(((user_mode == 0) || (write == 0)));
*(uint32_t*)(*buf) = ((((((((134217728 | cond) | (rn << 16)) | (addressing_mode << 23)) | (offset_mode << 11)) | (addressing_mode << 23)) | registers) | (user_mode << 21)) | (write << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_str(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((67108864 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_strb(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((71303168 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_strbt(void** buf, Condition cond, Reg rn, Reg rd, OffsetMode offset_mode) {
*(uint32_t*)(*buf) = ((((73400320 | cond) | (rn << 16)) | (rd << 12)) | (offset_mode << 23));
*(byte*)buf += 4;
}
void CALLCONV arm_strd(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((240 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_strex(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((25169808 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_strh(void** buf, Condition cond, bool write, Reg rn, Reg rd, OffsetMode offset_mode, Addressing addressing_mode) {
*(uint32_t*)(*buf) = ((((((176 | cond) | (write << 21)) | (rn << 16)) | (rd << 12)) | (addressing_mode << 23)) | (offset_mode << 11));
*(byte*)buf += 4;
}
void CALLCONV arm_strt(void** buf, Condition cond, Reg rn, Reg rd, OffsetMode offset_mode) {
*(uint32_t*)(*buf) = ((((69206016 | cond) | (rn << 16)) | (rd << 12)) | (offset_mode << 23));
*(byte*)buf += 4;
}
void CALLCONV arm_swi(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (251658240 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_swp(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((16777360 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_swpb(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((20971664 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_sxtab(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((111149168 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_sxtab16(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((109052016 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_sxtah(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((112197744 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_sxtb(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((112132208 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_sxtb16(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((110035056 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_sxth(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((113180784 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_teq(void** buf, Condition cond, Reg rn) {
*(uint32_t*)(*buf) = ((19922944 | cond) | (rn << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_tst(void** buf, Condition cond, Reg rn) {
*(uint32_t*)(*buf) = ((17825792 | cond) | (rn << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_uadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910032 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910160 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uaddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910064 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007184 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007312 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhaddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007216 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhsub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007280 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhsub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007408 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uhsubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((108007248 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_umaal(void** buf, Condition cond) {
*(uint32_t*)(*buf) = (4194448 | cond);
*(byte*)buf += 4;
}
void CALLCONV arm_umlal(void** buf, Condition cond, bool update_cprs, bool update_condition) {
*(uint32_t*)(*buf) = (((10485904 | cond) | (update_cprs << 20)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_umull(void** buf, Condition cond, bool update_cprs, bool update_condition) {
*(uint32_t*)(*buf) = (((8388752 | cond) | (update_cprs << 20)) | (update_condition << 20));
*(byte*)buf += 4;
}
void CALLCONV arm_uqadd16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958608 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uqadd8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958736 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uqaddsubx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958640 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uqsub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958704 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uqsub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958832 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uqsubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((106958672 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_usad8(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((125890576 | cond) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_usada8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((125829136 | cond) | (rn << 12)) | (rd << 16));
*(byte*)buf += 4;
}
void CALLCONV arm_usat(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((115343376 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_usat16(void** buf, Condition cond, Reg rd) {
*(uint32_t*)(*buf) = ((115347248 | cond) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_usub16(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910128 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_usub8(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910256 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_usubaddx(void** buf, Condition cond, Reg rn, Reg rd) {
*(uint32_t*)(*buf) = (((105910096 | cond) | (rn << 16)) | (rd << 12));
*(byte*)buf += 4;
}
void CALLCONV arm_uxtab(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((115343472 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_uxtab16(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((113246320 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_uxtah(void** buf, Condition cond, Reg rn, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = ((((116392048 | cond) | (rn << 16)) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_uxtb(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((116326512 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_uxtb16(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((114229360 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
void CALLCONV arm_uxth(void** buf, Condition cond, Reg rd, Rotation rotate) {
*(uint32_t*)(*buf) = (((117375088 | cond) | (rd << 12)) | (rotate << 10));
*(byte*)buf += 4;
}
|
the_stack_data/32949364.c
|
//Author : Nemuel Wainaina
//This is a Program that takes marks for the seven units from the user
//grades them, and saves the unit name, marks and the grade for the unit in a text file
#include<stdio.h>
#include<stdlib.h>
//this function takes the marks as input and grades it according to the grading system in place
char* grade_for(int marks){
if(marks>=0 && marks<40){
return "F";
}
else if(marks>=40 && marks<50){
return "D";
}
else if(marks>=50 && marks<60){
return "C";
}
else if(marks>=60 && marks<70){
return "B";
}
else if(marks>=70 && marks<=100){
return "A";
}
else{
return "INVALID";
}
}
int main(){
//welcoming text, haha!
printf("Welcome to the Program ... \n");
//the arrays for units, marks and the grades
char* units[7]={"CSC111", "CSC112", "CSC113", "CSC114", "CSC115", "CCS001", "CCS009"};
int marks[7];
char* grades[7];
//let's get the marks from the user
for(int i=0;i<7;i++){
printf("Enter the marks for unit %s : ", units[i]);
scanf("%d", &marks[i]);
}
//let's grade the marks entered above and store the grades in array grades
for(int i=0;i<7;i++){
grades[i]=grade_for(marks[i]);
}
//time to store the values into a file
FILE* fp = fopen("graded marks.txt", "w");
if(fp==NULL){
exit(1);
}
//writing the results to the text file
fprintf(fp, "UNIT\t\tMARKS\t\tGRADE\n");
for(int i=0;i<7;i++){
fprintf(fp, "%s\t\t%d\t\t%s\n", units[i], marks[i], grades[i]);
}
//close the file pointer
fclose(fp);
return 0;
}
|
the_stack_data/119315.c
|
/* { dg-require-effective-target offload_device_nonshared_as } */
#include <stdlib.h>
#include <assert.h>
#define N 32
void test_array_section (int *p)
{
#pragma omp target data map(alloc: p[0:N])
{
int ok = 1;
for (int i = 10; i < 10 + 4; i++)
p[i] = 997 * i;
#pragma omp target map(always to:p[10:4]) map(tofrom: ok)
for (int i = 10; i < 10 + 4; i++)
if (p[i] != 997 * i)
ok = 0;
assert (ok);
#pragma omp target map(always from:p[7:9])
for (int i = 0; i < N; i++)
p[i] = i;
}
}
int main ()
{
int aa = 0, bb = 0, cc = 0, dd = 0;
#pragma omp target data map(tofrom: aa) map(to: bb) map(from: cc, dd)
{
int ok;
aa = bb = cc = 1;
/* Set dd on target to 0 for the further check. */
#pragma omp target map(always to: dd)
;
dd = 1;
#pragma omp target map(tofrom: aa) map(always to: bb) \
map(always from: cc) map(to: dd) map(from: ok)
{
/* bb is always to, aa and dd are not. */
ok = (aa == 0) && (bb == 1) && (dd == 0);
aa = bb = cc = dd = 2;
}
assert (ok);
assert (aa == 1);
assert (bb == 1);
assert (cc == 2); /* cc is always from. */
assert (dd == 1);
dd = 3;
#pragma omp target map(from: cc) map(always to: dd) map(from: ok)
{
ok = (dd == 3); /* dd is always to. */
cc = dd = 4;
}
assert (ok);
assert (cc == 2);
assert (dd == 3);
}
assert (aa == 2);
assert (bb == 1);
assert (cc == 4);
assert (dd == 4);
int *array = calloc (N, sizeof (int));
test_array_section (array);
for (int i = 0; i < 7; i++)
assert (array[i] == 0);
for (int i = 7; i < 7 + 9; i++)
assert (array[i] == i);
for (int i = 7 + 9; i < N; i++)
assert (array[i] == 0);
free (array);
return 0;
}
|
the_stack_data/211079838.c
|
// WARNING: refcount bug in kobject_get
// https://syzkaller.appspot.com/bug?id=06c8522152c9325bf0f1a3dc5b33d1b95a47431f
// status:invalid
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter;
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[1] = {0xffffffffffffffff};
void execute_one(void)
{
intptr_t res = 0;
memcpy((void*)0x20000040, "/dev/vhci\000", 10);
res = syscall(__NR_openat, 0xffffffffffffff9c, 0x20000040, 1, 0);
if (res != -1)
r[0] = res;
*(uint8_t*)0x20000000 = -1;
*(uint8_t*)0x20000001 = 0xc1;
syscall(__NR_write, r[0], 0x20000000, 2);
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
loop();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/97012127.c
|
char *anames[] =
{
"XXX",
"ABCD",
"ADDB",
"ADDL",
"ADDW",
"ADDXB",
"ADDXL",
"ADDXW",
"ADJSP",
"ANDB",
"ANDL",
"ANDW",
"ASLB",
"ASLL",
"ASLW",
"ASRB",
"ASRL",
"ASRW",
"BCASE",
"BCC",
"BCHG",
"BCLR",
"BCS",
"BEQ",
"BFCHG",
"BFCLR",
"BFEXTS",
"BFEXTU",
"BFFFO",
"BFINS",
"BFSET",
"BFTST",
"BGE",
"BGT",
"BHI",
"BKPT",
"BLE",
"BLS",
"BLT",
"BMI",
"BNE",
"BPL",
"BRA",
"BSET",
"BSR",
"BTST",
"BVC",
"BVS",
"CALLM",
"CAS2B",
"CAS2L",
"CAS2W",
"CASB",
"CASEW",
"CASL",
"CASW",
"CHK2B",
"CHK2L",
"CHK2W",
"CHKL",
"CHKW",
"CLRB",
"CLRL",
"CLRW",
"CMP2B",
"CMP2L",
"CMP2W",
"CMPB",
"CMPL",
"CMPW",
"DATA",
"DBCC",
"DBCS",
"DBEQ",
"DBF",
"DBGE",
"DBGT",
"DBHI",
"DBLE",
"DBLS",
"DBLT",
"DBMI",
"DBNE",
"DBPL",
"DBT",
"DBVC",
"DBVS",
"DIVSL",
"DIVSW",
"DIVUL",
"DIVUW",
"END",
"EORB",
"EORL",
"EORW",
"EXG",
"EXTBL",
"EXTBW",
"EXTWL",
"FABSB",
"FABSD",
"FABSF",
"FABSL",
"FABSW",
"FACOSB",
"FACOSD",
"FACOSF",
"FACOSL",
"FACOSW",
"FADDB",
"FADDD",
"FADDF",
"FADDL",
"FADDW",
"FASINB",
"FASIND",
"FASINF",
"FASINL",
"FASINW",
"FATANB",
"FATAND",
"FATANF",
"FATANHB",
"FATANHD",
"FATANHF",
"FATANHL",
"FATANHW",
"FATANL",
"FATANW",
"FBEQ",
"FBF",
"FBGE",
"FBGT",
"FBLE",
"FBLT",
"FBNE",
"FBT",
"FCMPB",
"FCMPD",
"FCMPF",
"FCMPL",
"FCMPW",
"FCOSB",
"FCOSD",
"FCOSF",
"FCOSHB",
"FCOSHD",
"FCOSHF",
"FCOSHL",
"FCOSHW",
"FCOSL",
"FCOSW",
"FDBEQ",
"FDBF",
"FDBGE",
"FDBGT",
"FDBLE",
"FDBLT",
"FDBNE",
"FDBT",
"FDIVB",
"FDIVD",
"FDIVF",
"FDIVL",
"FDIVW",
"FETOXB",
"FETOXD",
"FETOXF",
"FETOXL",
"FETOXM1B",
"FETOXM1D",
"FETOXM1F",
"FETOXM1L",
"FETOXM1W",
"FETOXW",
"FGETEXPB",
"FGETEXPD",
"FGETEXPF",
"FGETEXPL",
"FGETEXPW",
"FGETMANB",
"FGETMAND",
"FGETMANF",
"FGETMANL",
"FGETMANW",
"FINTB",
"FINTD",
"FINTF",
"FINTL",
"FINTRZB",
"FINTRZD",
"FINTRZF",
"FINTRZL",
"FINTRZW",
"FINTW",
"FLOG10B",
"FLOG10D",
"FLOG10F",
"FLOG10L",
"FLOG10W",
"FLOG2B",
"FLOG2D",
"FLOG2F",
"FLOG2L",
"FLOG2W",
"FLOGNB",
"FLOGND",
"FLOGNF",
"FLOGNL",
"FLOGNP1B",
"FLOGNP1D",
"FLOGNP1F",
"FLOGNP1L",
"FLOGNP1W",
"FLOGNW",
"FMODB",
"FMODD",
"FMODF",
"FMODL",
"FMODW",
"FMOVEB",
"FMOVED",
"FMOVEF",
"FMOVEL",
"FMOVEM",
"FMOVEMC",
"FMOVEW",
"FMULB",
"FMULD",
"FMULF",
"FMULL",
"FMULW",
"FNEGB",
"FNEGD",
"FNEGF",
"FNEGL",
"FNEGW",
"FREMB",
"FREMD",
"FREMF",
"FREML",
"FREMW",
"FRESTORE",
"FSAVE",
"FSCALEB",
"FSCALED",
"FSCALEF",
"FSCALEL",
"FSCALEW",
"FSEQ",
"FSF",
"FSGE",
"FSGT",
"FSINB",
"FSIND",
"FSINF",
"FSINHB",
"FSINHD",
"FSINHF",
"FSINHL",
"FSINHW",
"FSINL",
"FSINW",
"FSLE",
"FSLT",
"FSNE",
"FSQRTB",
"FSQRTD",
"FSQRTF",
"FSQRTL",
"FSQRTW",
"FST",
"FSUBB",
"FSUBD",
"FSUBF",
"FSUBL",
"FSUBW",
"FTANB",
"FTAND",
"FTANF",
"FTANHB",
"FTANHD",
"FTANHF",
"FTANHL",
"FTANHW",
"FTANL",
"FTANW",
"FTENTOXB",
"FTENTOXD",
"FTENTOXF",
"FTENTOXL",
"FTENTOXW",
"FTSTB",
"FTSTD",
"FTSTF",
"FTSTL",
"FTSTW",
"FTWOTOXB",
"FTWOTOXD",
"FTWOTOXF",
"FTWOTOXL",
"FTWOTOXW",
"GLOBL",
"GOK",
"HISTORY",
"ILLEG",
"INSTR",
"JMP",
"JSR",
"LEA",
"LINKL",
"LINKW",
"LOCATE",
"LONG",
"LSLB",
"LSLL",
"LSLW",
"LSRB",
"LSRL",
"LSRW",
"MOVB",
"MOVEM",
"MOVEPL",
"MOVEPW",
"MOVESB",
"MOVESL",
"MOVESW",
"MOVL",
"MOVW",
"MULSL",
"MULSW",
"MULUL",
"MULUW",
"NAME",
"NBCD",
"NEGB",
"NEGL",
"NEGW",
"NEGXB",
"NEGXL",
"NEGXW",
"NOP",
"NOTB",
"NOTL",
"NOTW",
"ORB",
"ORL",
"ORW",
"PACK",
"PEA",
"RESET",
"ROTLB",
"ROTLL",
"ROTLW",
"ROTRB",
"ROTRL",
"ROTRW",
"ROXLB",
"ROXLL",
"ROXLW",
"ROXRB",
"ROXRL",
"ROXRW",
"RTD",
"RTE",
"RTM",
"RTR",
"RTS",
"SBCD",
"SCC",
"SCS",
"SEQ",
"SF",
"SGE",
"SGT",
"SHI",
"SLE",
"SLS",
"SLT",
"SMI",
"SNE",
"SPL",
"ST",
"STOP",
"SUBB",
"SUBL",
"SUBW",
"SUBXB",
"SUBXL",
"SUBXW",
"SVC",
"SVS",
"SWAP",
"SYS",
"TAS",
"TEXT",
"TRAP",
"TRAPCC",
"TRAPCS",
"TRAPEQ",
"TRAPF",
"TRAPGE",
"TRAPGT",
"TRAPHI",
"TRAPLE",
"TRAPLS",
"TRAPLT",
"TRAPMI",
"TRAPNE",
"TRAPPL",
"TRAPT",
"TRAPV",
"TRAPVC",
"TRAPVS",
"TSTB",
"TSTL",
"TSTW",
"UNLK",
"UNPK",
"WORD",
"SIGNAME",
"LAST",
};
|
the_stack_data/171957.c
|
/*
* File : rt_low_level_init.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-04-14 ArdaFu first version
*/
/* write register a=address, v=value */
#define write_reg(a,v) (*(volatile unsigned int *)(a) = (v))
/* Processor Reset */
#define AT91_RSTC_PROCRST (1 << 0)
#define AT91_RSTC_PERRST (1 << 2)
#define AT91_RSTC_KEY (0xa5 << 24)
#define AT91_MATRIX_BASE (0XFFFFEE00)
/* Master Remap Control Register */
#define AT91_MATRIX_MRCR (AT91_MATRIX_BASE + 0x100)
/* Remap Command for AHB Master 0 (ARM926EJ-S InSTRuction Master) */
#define AT91_MATRIX_RCB0 (1 << 0)
/* Remap Command for AHB Master 1 (ARM926EJ-S Data Master) */
#define AT91_MATRIX_RCB1 (1 << 1)
#define AT91_AIC_BASE (0XFFFFF000)
/* Interrupt DisaBLe Command Register */
#define AT91_AIC_IDCR (AT91_AIC_BASE + 0x124)
/* Interrupt Clear Command Register */
#define AT91_AIC_ICCR (AT91_AIC_BASE + 0x128)
#define AT91_WDT_BASE (0XFFFFFD40)
#define AT91_WDT_CR (AT91_WDT_BASE + 0x00)
#define AT91_WDT_CR_KEY (0xA5000000)
#define AT91_WDT_CR_WDRSTT (0x00000001)
#define AT91_WDT_MR (AT91_WDT_BASE + 0x04)
#define AT91_WDT_MR_WDDIS (0x00008000)
void rt_low_level_init(void)
{
// Mask all IRQs by clearing all bits in the INTMRS
write_reg(AT91_AIC_IDCR, 0xFFFFFFFF);
write_reg(AT91_AIC_ICCR, 0xFFFFFFFF);
// Remap internal ram to 0x00000000 Address
write_reg(AT91_MATRIX_MRCR, AT91_MATRIX_RCB0 | AT91_MATRIX_RCB1);
// Disable the watchdog
write_reg(AT91_WDT_CR, AT91_WDT_CR_KEY|AT91_WDT_CR_WDRSTT);
write_reg(AT91_WDT_MR, AT91_WDT_MR_WDDIS);
}
|
the_stack_data/1140782.c
|
/* This testcase is part of GDB, the GNU debugger.
Copyright 2012-2014 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
#include <pthread.h>
#ifdef SYMBOL_PREFIX
#define SYMBOL(str) SYMBOL_PREFIX #str
#else
#define SYMBOL(str) #str
#endif
/* Called from asm. */
static void __attribute__((used))
func (void)
{}
static void *
thread_function(void *arg)
{
/* `set_point1' is the label at which to set a fast tracepoint. The
insn at the label must be large enough to fit a fast tracepoint
jump. */
asm (" .global " SYMBOL(set_point1) "\n"
SYMBOL(set_point1) ":\n"
#if (defined __x86_64__ || defined __i386__)
" call " SYMBOL(func) "\n"
#endif
);
}
static void
end (void)
{}
int
main (int argc, char *argv[], char *envp[])
{
pthread_t threads[2];
int i;
for (i = 0; i < 2; i++)
pthread_create (&threads[i], NULL, thread_function, NULL);
for (i = 0; i < 2; i++)
pthread_join (threads[i], NULL);
end ();
return 0;
}
|
the_stack_data/7949681.c
|
//Utilizando o programa cartas.c, modifique-o para que as cartas sejam novamente ordenadas considerando o valor dos números e depois dos naipes (utilize o método bolha)
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
typedef struct {
int num; // 1 - Ás, 2 ... 10, 11 = Valete, 12 = Dama, 13 = Rei
int naipe; // O = Ouros, 1 = Espadas, 2 = Copas, 3 = Paus
} carta;
void preenche(carta baralho[52]);
void imprime(carta baralho[52]);
void embaralha(carta baralho[52], int cartas);
void troca(carta *a, carta *b);
void ordena(carta baralho[52]);
int main() {
carta baralho[52];
preenche(baralho);
imprime(baralho);
embaralha(baralho, 100);
ordena(baralho);
imprime(baralho);
}
void ordena(carta baralho[52]){
int i,j;
for(i=0;i<52;i++){
j=i;
while(j>=0){
if(baralho[j].naipe>baralho[j+1].naipe){
troca(&baralho[j],&baralho[j+1]);
}else if (baralho[j].naipe==baralho[j+1].naipe){
if(baralho[j].num>baralho[j+1].num){
troca(&baralho[j],&baralho[j+1]);
}
}
j--;
}
}
}
void troca(carta *a, carta *b) {
carta aux;
aux.num = a->num;
aux.naipe = a->naipe;
a->num = b->num;
a->naipe = b->naipe;
b->num = aux.num;
b->naipe = aux.naipe;
}
void preenche(carta baralho[52]) {
int i, j, k = 0;
for (i = 1; i<14; i++) {
for (j = 0; j<4; j++) {
baralho[k].num = i;
baralho[k].naipe = j;
k++;
}
}
}
void imprime(carta baralho[52]) {
int i;
char letras[] = {'J', 'Q', 'K'};
char *nipes[] = {"<>"," #", "S2", " &"};
printf("\nSequencia de cartas: \n");
for (i=0; i<52; i++) {
if (baralho[i].num == 1) {
printf("[ A%s ] ", nipes[baralho[i].naipe]);
} else if (baralho[i].num > 10) {
printf("[%2c%s ] ", letras[baralho[i].num - 11], nipes[baralho[i].naipe]);
} else {
printf("[%2d%s ] ", baralho[i].num, nipes[baralho[i].naipe]);
}
if (i % 10 == 9) printf("\n");
}
printf("\n\nLegenda: <> ouro, # espadas, S2 = copas, & paus\n");
}
void embaralha(carta baralho[52], int cartas) {
int i, j;
srand(time(NULL));
while(cartas > 0) {
troca(&baralho[rand() % 52], &baralho[rand() % 52]);
cartas--;
}
}
|
the_stack_data/23574676.c
|
// 此程序使用词典查找
#include <stdio.h>
struct entry
{
char word[15];
char definition[50];
};
void dictionarySort(struct entry dictionary[], int totalWords)
{
int i, j;
struct entry temp;
int compareStrings(const char s1[], const char s2[]);
for (i = 0; i < totalWords - 1; ++i)
for (j = i + 1; j < totalWords; ++j)
if (compareStrings(dictionary[i].word, dictionary[j].word) > 0) {
temp = dictionary[i];
dictionary[i] = dictionary[j];
dictionary[j] = temp;
}
}
int compareStrings (const char s1[], const char s2[])
{
int i = 0, answer;
while (s1[i] == s2[i] &&
s1[i] != '\0' && s2[i] != '\0')
++i;
if (s1[i] == '\0' && s2[i] == '\0')
answer = 0;
else if (s1[i] < s2[i])
answer = -1;
else
answer = 1;
return answer;
}
int main(void)
{
struct entry dictionary[100] = {
{"ajar", "partially opened"},
{"aardvark", "a burrowing African mammal"},
{"abyss", "a bottomless pit"},
{"acumen", "mentally sharp; keen"},
{"aigrette", "an ornamental cluster of feathers"},
{"addle", "to become confused"},
{"aerie", "a high nest"},
{"affix", "to append; attach"},
{"agar", "a jelly made from seaweed"},
{"ahoy", "a nautical call of greeting"},
// {"aigrette", "an ornamental cluster of feathers"},
// {"ajar", "partially opened"}
};
int entries = 10;
int entry;
void dictionarySort(struct entry dict[], int totalWords);
dictionarySort(dictionary, entries);
for (entry = 0; entry < entries; ++entry)
printf("%s: %s\n", dictionary[entry].word, dictionary[entry].definition);
return 0;
}
|
the_stack_data/8939.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jzak <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2014/03/26 15:24:09 by jzak #+# #+# */
/* Updated: 2014/03/26 15:24:10 by jzak ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
void *nb_memmove(void *s1, const void *s2, size_t n)
{
const char *src;
char *dest;
dest = (char*)s1;
src = (const char*)s2;
if (s2 > s1)
{
while (n--)
*dest++ = *src++;
}
else if (s1 != s2)
{
while (n--)
dest[n] = src[n];
}
return (s1);
}
int nb_atoi(const char *str)
{
int result;
int multiply;
while ((*str > 8 && *str < 14) || (*str == ' '))
str++;
multiply = 1;
if (*str == '-' || *str == '+')
multiply = 44 - *str++;
result = 0;
while (*str >= '0' && *str <= '9')
result = (result * 10) + (*str++ - '0');
return (result * multiply);
}
char *nb_itoa(int n)
{
char *new;
size_t size;
int tmp;
tmp = n;
size = 0;
while (++size && tmp)
tmp /= 10;
if ((new = malloc(size + 1)) == NULL)
return (NULL);
if (n == 0)
*new = '0';
else if (n > 0 && (n = -n))
--size;
else
*new = '-';
new[size] = '\0';
while (n != 0)
{
new[--size] = n % -10 * -1 + '0';
n /= -10 * -1;
}
return (new);
}
|
the_stack_data/116303.c
|
// RUN: %clang_cc1 %s -triple i386-apple-darwin -emit-llvm -o - | FileCheck %s
// Misaligned parameter must be memcpy'd to correctly aligned temporary.
struct s { int x; long double y; };
long double foo(struct s x, int i, struct s y) {
// CHECK: foo
// CHECK: %x = alloca %struct._Z1s, align 16
// CHECK: %y = alloca %struct._Z1s, align 16
// CHECK: memcpy
// CHECK: memcpy
// CHECK: bar
return bar(&x, &y);
}
|
the_stack_data/131445.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.
*/
#include <unistd.h>
#include <stdio.h>
#define UNUSED(x) (void)(x)
/* ============================ UTF8 utilities ============================== */
static unsigned long wideCharTable[][2] = {
{ 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x2E99, }, { 0x2E9B, 0x2EF3, },
{ 0x2F00, 0x2FD5, }, { 0x2FF0, 0x2FFB, }, { 0x3000, 0x303E, }, { 0x3041, 0x3096, },
{ 0x3099, 0x30FF, }, { 0x3105, 0x312D, }, { 0x3131, 0x318E, }, { 0x3190, 0x31BA, },
{ 0x31C0, 0x31E3, }, { 0x31F0, 0x321E, }, { 0x3220, 0x3247, }, { 0x3250, 0x4DBF, },
{ 0x4E00, 0xA48C, }, { 0xA490, 0xA4C6, }, { 0xA960, 0xA97C, }, { 0xAC00, 0xD7A3, },
{ 0xF900, 0xFAFF, }, { 0xFE10, 0xFE19, }, { 0xFE30, 0xFE52, }, { 0xFE54, 0xFE66, },
{ 0xFE68, 0xFE6B, }, { 0xFF01, 0xFFE6, },
{ 0x1B000, 0x1B001, }, { 0x1F200, 0x1F202, }, { 0x1F210, 0x1F23A, },
{ 0x1F240, 0x1F248, }, { 0x1F250, 0x1F251, }, { 0x20000, 0x3FFFD, },
};
static size_t wideCharTableSize = sizeof(wideCharTable) / sizeof(wideCharTable[0]);
static unsigned long combiningCharTable[] = {
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,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,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,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,
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,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,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,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,0x1E8D0,0x1E8D1,0x1E8D2,0x1E8D3,
0x1E8D4,0x1E8D5,0x1E8D6,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++)
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++)
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;
}
}
}
return 0;
}
/* 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);
}
|
the_stack_data/371617.c
|
/* Generated by CIL v. 1.7.0 */
/* print_CIL_Input is false */
struct _IO_FILE;
struct timeval;
extern float strtof(char const *str , char const *endptr ) ;
extern void signal(int sig , void *func ) ;
typedef struct _IO_FILE FILE;
extern int atoi(char const *s ) ;
extern double strtod(char const *str , char const *endptr ) ;
extern int fclose(void *stream ) ;
extern void *fopen(char const *filename , char const *mode ) ;
extern void abort() ;
extern void exit(int status ) ;
extern int raise(int sig ) ;
extern int fprintf(struct _IO_FILE *stream , char const *format , ...) ;
extern int strcmp(char const *a , char const *b ) ;
extern int rand() ;
extern unsigned long strtoul(char const *str , char const *endptr , int base ) ;
void RandomFunc(unsigned long input[1] , unsigned long output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
void RandomFunc(unsigned long input[1] , unsigned long output[1] )
{
unsigned long state[1] ;
char copy11 ;
unsigned int copy12 ;
{
state[0UL] = (input[0UL] - 51238316UL) - 339126204UL;
if ((state[0UL] >> 3UL) & 1UL) {
copy11 = *((char *)(& state[0UL]) + 1);
*((char *)(& state[0UL]) + 1) = *((char *)(& state[0UL]) + 6);
*((char *)(& state[0UL]) + 6) = copy11;
copy12 = *((unsigned int *)(& state[0UL]) + 0);
*((unsigned int *)(& state[0UL]) + 0) = *((unsigned int *)(& state[0UL]) + 1);
*((unsigned int *)(& state[0UL]) + 1) = copy12;
copy12 = *((unsigned int *)(& state[0UL]) + 1);
*((unsigned int *)(& state[0UL]) + 1) = *((unsigned int *)(& state[0UL]) + 0);
*((unsigned int *)(& state[0UL]) + 0) = copy12;
} else {
state[0UL] *= state[0UL];
}
output[0UL] = ((state[0UL] << 9UL) | (state[0UL] >> 55UL)) ^ 942792860UL;
}
}
void megaInit(void)
{
{
}
}
int main(int argc , char *argv[] )
{
unsigned long input[1] ;
unsigned long output[1] ;
int randomFuns_i5 ;
unsigned long randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == 4228931814165357208UL) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%lu\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
|
the_stack_data/356151.c
|
const int r=33;
void f(void){
return;
}
int main(void) {
int a = 666;
const char e='e';
int s=3;
{
int a = 5;
int y = a + 1; // 6
const int v=666;
s = y + 1; // 7
}
s = a + 1; // 4
return 0;
}
|
the_stack_data/212643751.c
|
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
void mifuncion(char[][20],int);
int main()
{
char nombres[5][20]= {"jUAN CARLOS","albERtO GabRIEL","anA cLARA","flOr","rOsa"};
mifuncion(nombres,5);
return 0;
}
void mifuncion(char vec[][20], int filas)
{
int i,k;
for(i=0;i<filas;i++)
{
strlwr(vec[i]);
for(k=0;k<20;k++)
{
if(vec[i][k]==' ')
{
vec[i][k+1]=toupper(vec[i][k+1]);
}
}
vec[i][0]=toupper(vec[i][0]);
printf("%s \n",vec[i]);
}
}
|
the_stack_data/150143756.c
|
/*
* mknod - build special file
*
* Gunnar Ritter, Freiburg i. Br., Germany, August 2003.
*/
/*
* Copyright (c) 2003 Gunnar Ritter
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute
* it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/
#define __GLIBC__
#if __GNUC__ >= 3 && __GNUC_MINOR__ >= 4 || __GNUC__ >= 4
#define USED __attribute__ ((used))
#elif defined __GNUC__
#define USED __attribute__ ((unused))
#else
#define USED
#endif
static const char sccsid[] USED = "@(#)mknod.sl 1.8 (gritter) 5/29/05";
#if defined (__GLIBC__) || defined (_AIX)
#include <sys/sysmacros.h>
#endif /* __GLIBC__ || _AIX */
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#ifndef major
#endif /* !major */
#ifndef S_IFNAM
#define S_IFNAM 0x5000
#endif
#ifndef S_INSEM
#define S_INSEM 0x1
#endif
#ifndef S_INSHD
#define S_INSHD 0x2
#endif
static char *progname;
static long max_major;
static long max_minor;
static void
usage(void)
{
fprintf(stderr, "usage: %s name [ b/c major minor ] [ p ]\n",
progname);
exit(2);
}
static int
mnode(const char *name, mode_t type, dev_t dev)
{
if (mknod(name, type|0666, dev) == 0)
return 0;
switch (errno) {
case EPERM:
fprintf(stderr, "%s: must be super-user\n", progname);
break;
default:
fprintf(stderr, "%s: %s\n", progname, strerror(errno));
}
return 1;
}
static dev_t
nu(const char *s, const char *msg, dev_t max)
{
int n;
n = atoi(s);
if (n < 0 || n > max) {
fprintf(stderr, "%s: invalid %s number '%s' - "
"valid range is 0-%d\n",
progname, msg, s, (int)max);
exit(2);
}
return n;
}
static int
mspec(int ac, char **av, mode_t type)
{
dev_t major, minor;
if (ac != 5)
usage();
major = nu(av[3], "major", max_major);
minor = nu(av[4], "minor", max_minor);
return mnode(av[1], type, makedev(major, minor));
}
static int
mfifo(int ac, char **av)
{
if (ac != 3)
usage();
return mnode(av[1], S_IFIFO, 0);
}
static int
mnam(int ac, char **av, mode_t type)
{
if (ac != 3)
usage();
return mnode(av[1], S_IFNAM, type);
}
static void
getlimits(void)
{
#ifdef __linux__
#ifndef WORD_BIT
int WORD_BIT;
for (WORD_BIT = 2; (1<<WORD_BIT) != 1; WORD_BIT++);
#endif /* !WORD_BIT */
max_major = (1<<(WORD_BIT-20)) - 1;
max_minor = (1<<20) - 1;
#else /* !__linux__ */
max_major = (1<<14) - 1;
max_minor = (1<<18) - 1;
#endif /* !__linux__ */
}
int
main(int argc, char **argv)
{
progname = basename(argv[0]);
if (argc < 3)
usage();
if (argv[2][1] != '\0')
usage();
getlimits();
switch (argv[2][0]) {
case 'b':
return mspec(argc, argv, S_IFBLK);
case 'c':
return mspec(argc, argv, S_IFCHR);
case 'p':
return mfifo(argc, argv);
case 'm':
return mnam(argc, argv, S_INSHD);
case 's':
return mnam(argc, argv, S_INSEM);
default:
usage();
}
/*NOTREACHED*/
return 0;
}
|
the_stack_data/27330.c
|
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
void writeFile (const char* fileName)
{
int fd = open (fileName, O_RDWR, S_IWRITE);
if (fd == -1)
return;
const char value [] = "hello \n abc\n";
printf ("File Opened to write with handle %d\n", fd);
write (fd, value, sizeof (value));
write (fd, value, strlen (value));
close (fd);
}
void readFile (const char* fileName)
{
int fd = open (fileName, O_RDONLY, 0);
if (fd == -1)
return;
char data = '\0';
printf ("File Opened with Read Handle %d\n", fd);
while (read (fd, &data, 1) != 0)
printf ("%c", data);
close (fd);
}
void readFileFrom (const char* fileName, int offset)
{
int fd = open (fileName, O_RDONLY, S_IREAD);
if (fd == -1)
return;
char data = '\0';
/*
* 0 -> Begin
* 1 -> Current
* 2-> End
*/
lseek (fd, offset, 0/*Beginning*/);
printf ("File Opened with Read Handle %d to read from %d\n", fd, offset);
while (read (fd, &data, 1) != 0)
printf ("%c", data);
close (fd);
}
void create (const char* fileName)
{
printf ("File Created\n");
creat (fileName, S_IWRITE | S_IREAD | S_IEXEC);
}
int main (int argc, char* argv [])
{
if (argc != 2)
return 1;
const char* fileName = argv[1];
create (fileName);
writeFile (fileName);
readFile (fileName);
readFileFrom (fileName, 2);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.