file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/12637807.c | #include <stdio.h>
void move (int n, char a, char c){
printf("move %d from %c to %c\n", n, a, c);
}
void Hanoi (int n, char a, char c, char b)
{
if (n == 1)
{
move(n, a, c);
return;
}
Hanoi(n-1, a, b, c);
move(n, a, c);
Hanoi(n-1, b, c, a);
return;
}
int main() {
int n = 11;
char a = '1';
char b = '2';
char c = '3';
Hanoi(n, a, b, c);
return 0;
}
|
the_stack_data/1123957.c | //to print gm, ga gn by using functions
#include<stdio.h>
void goodMorning();
void goodAfternoon();
void goodNight();
int main(){
goodMorning();
goodAfternoon();
goodNight();
return 0;
}
void goodMorning(){
printf("Good Morning shreya\n");
}
void goodAfternoon(){
printf("Good Afternoon shreya\n");
}
void goodNight(){
printf("Good Night shreya\n");
}
|
the_stack_data/112782.c | #include<stdio.h>
main()
{
FILE *fp;
fp=fopen("Student.DAT","r");
if(fp==NULL)
{
printf("\n The file could not be open");
exit(1);
}
}
|
the_stack_data/28261689.c | /*
URI Online Judge | 1116
Dividing X by Y
Adapted by Neilor Tonin, URI Brazil
https://www.urionlinejudge.com.br/judge/en/problems/view/1116
Timelimit: 2
Write a program that read two numbers X and Y and print the result of dividing the X by Y. If it's not possible, print the message "divisao impossivel".
Input
The input contains an integer number N. This N is the quantity of pairs of integer numbers X and Y read (dividend and divisor).
Output
For each test case print the result of this division with one digit after the decimal point, or “divisao impossivel” if it isn't possible to perform the calculation.
Obs.: Be carefull. The division between two integers in some languages generates another integer. Use cast:)
@author Marcos Lima
@profile https://www.urionlinejudge.com.br/judge/pt/profile/242402
@status Accepted
@language C (gcc 4.8.5, -O2 -lm) [+0s]
@time 0.004s
@size 327 Bytes
@submission 12/10/19, 9:03:12 AM
*/
#include <stdio.h>
int main()
{
unsigned int n;
int a,b;
scanf("%u", &n);
while (n--) {
scanf("%d %d", &a,&b);
if (b) {
printf("%.1lf\n", ((double)a)/((double)b));
} else {
printf("divisao impossivel\n");
}
}
return 0;
} |
the_stack_data/75138574.c | /*
* zombie.c
*
* Create zombie processes by not cleaning after children right away.
*
* Copyright (c) 2017 James Klassen
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of this Software or works derived from this Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char **argv)
{
int i;
int id;
for(i = 0; i < 100; i++) {
id = fork();
if(id == 0)
return i;
}
sleep(6);
for(i = 0; i < 100; i++) {
wait(&id);
printf("%d ", WEXITSTATUS(id));
}
printf("\n");
return 0;
}
|
the_stack_data/98574865.c | /* Copyright (c) 2011-2012 Xiph.Org Foundation, Mozilla Corporation
Written by Jean-Marc Valin and Timothy B. Terriberry */
/*
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 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.
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define OPUS_PI (3.14159265F)
#define OPUS_COSF(_x) ((float)cos(_x))
#define OPUS_SINF(_x) ((float)sin(_x))
static void *check_alloc(void *_ptr){
if(_ptr==NULL){
fprintf(stderr,"Out of memory.\n");
exit(EXIT_FAILURE);
}
return _ptr;
}
static void *opus_malloc(size_t _size){
return check_alloc(malloc(_size));
}
static void *opus_realloc(void *_ptr,size_t _size){
return check_alloc(realloc(_ptr,_size));
}
static size_t read_pcm16(float **_samples,FILE *_fin,int _nchannels){
unsigned char buf[1024];
float *samples;
size_t nsamples;
size_t csamples;
size_t xi;
size_t nread;
samples=NULL;
nsamples=csamples=0;
for(;;){
nread=fread(buf,2*_nchannels,1024/(2*_nchannels),_fin);
if(nread<=0)break;
if(nsamples+nread>csamples){
do csamples=csamples<<1|1;
while(nsamples+nread>csamples);
samples=(float *)opus_realloc(samples,
_nchannels*csamples*sizeof(*samples));
}
for(xi=0;xi<nread;xi++){
int ci;
for(ci=0;ci<_nchannels;ci++){
int s;
s=buf[2*(xi*_nchannels+ci)+1]<<8|buf[2*(xi*_nchannels+ci)];
s=((s&0xFFFF)^0x8000)-0x8000;
samples[(nsamples+xi)*_nchannels+ci]=s;
}
}
nsamples+=nread;
}
*_samples=(float *)opus_realloc(samples,
_nchannels*nsamples*sizeof(*samples));
return nsamples;
}
static void band_energy(float *_out,float *_ps,const int *_bands,int _nbands,
const float *_in,int _nchannels,size_t _nframes,int _window_sz,
int _step,int _downsample){
float *window;
float *x;
float *c;
float *s;
size_t xi;
int xj;
int ps_sz;
window=(float *)opus_malloc((3+_nchannels)*_window_sz*sizeof(*window));
c=window+_window_sz;
s=c+_window_sz;
x=s+_window_sz;
ps_sz=_window_sz/2;
for(xj=0;xj<_window_sz;xj++){
window[xj]=0.5F-0.5F*OPUS_COSF((2*OPUS_PI/(_window_sz-1))*xj);
}
for(xj=0;xj<_window_sz;xj++){
c[xj]=OPUS_COSF((2*OPUS_PI/_window_sz)*xj);
}
for(xj=0;xj<_window_sz;xj++){
s[xj]=OPUS_SINF((2*OPUS_PI/_window_sz)*xj);
}
for(xi=0;xi<_nframes;xi++){
int ci;
int xk;
int bi;
for(ci=0;ci<_nchannels;ci++){
for(xk=0;xk<_window_sz;xk++){
x[ci*_window_sz+xk]=window[xk]*_in[(xi*_step+xk)*_nchannels+ci];
}
}
for(bi=xj=0;bi<_nbands;bi++){
float p[2]={0};
for(;xj<_bands[bi+1];xj++){
for(ci=0;ci<_nchannels;ci++){
float re;
float im;
int ti;
ti=0;
re=im=0;
for(xk=0;xk<_window_sz;xk++){
re+=c[ti]*x[ci*_window_sz+xk];
im-=s[ti]*x[ci*_window_sz+xk];
ti+=xj;
if(ti>=_window_sz)ti-=_window_sz;
}
re*=_downsample;
im*=_downsample;
_ps[(xi*ps_sz+xj)*_nchannels+ci]=re*re+im*im+100000;
p[ci]+=_ps[(xi*ps_sz+xj)*_nchannels+ci];
}
}
if(_out){
_out[(xi*_nbands+bi)*_nchannels]=p[0]/(_bands[bi+1]-_bands[bi]);
if(_nchannels==2){
_out[(xi*_nbands+bi)*_nchannels+1]=p[1]/(_bands[bi+1]-_bands[bi]);
}
}
}
}
free(window);
}
#define NBANDS (21)
#define NFREQS (240)
/*Bands on which we compute the pseudo-NMR (Bark-derived
CELT bands).*/
static const int BANDS[NBANDS+1]={
0,2,4,6,8,10,12,14,16,20,24,28,32,40,48,56,68,80,96,120,156,200
};
#define TEST_WIN_SIZE (480)
#define TEST_WIN_STEP (120)
int main(int _argc,const char **_argv){
FILE *fin1;
FILE *fin2;
float *x;
float *y;
float *xb;
float *X;
float *Y;
double err;
float Q;
size_t xlength;
size_t ylength;
size_t nframes;
size_t xi;
int ci;
int xj;
int bi;
int nchannels;
unsigned rate;
int downsample;
int ybands;
int yfreqs;
int max_compare;
if(_argc<3||_argc>6){
fprintf(stderr,"Usage: %s [-s] [-r rate2] <file1.sw> <file2.sw>\n",
_argv[0]);
return EXIT_FAILURE;
}
nchannels=1;
if(strcmp(_argv[1],"-s")==0){
nchannels=2;
_argv++;
}
rate=48000;
ybands=NBANDS;
yfreqs=NFREQS;
downsample=1;
if(strcmp(_argv[1],"-r")==0){
rate=atoi(_argv[2]);
if(rate!=8000&&rate!=12000&&rate!=16000&&rate!=24000&&rate!=48000){
fprintf(stderr,
"Sampling rate must be 8000, 12000, 16000, 24000, or 48000\n");
return EXIT_FAILURE;
}
downsample=48000/rate;
switch(rate){
case 8000:ybands=13;break;
case 12000:ybands=15;break;
case 16000:ybands=17;break;
case 24000:ybands=19;break;
}
yfreqs=NFREQS/downsample;
_argv+=2;
}
fin1=fopen(_argv[1],"rb");
if(fin1==NULL){
fprintf(stderr,"Error opening '%s'.\n",_argv[1]);
return EXIT_FAILURE;
}
fin2=fopen(_argv[2],"rb");
if(fin2==NULL){
fprintf(stderr,"Error opening '%s'.\n",_argv[2]);
fclose(fin1);
return EXIT_FAILURE;
}
/*Read in the data and allocate scratch space.*/
xlength=read_pcm16(&x,fin1,2);
if(nchannels==1){
for(xi=0;xi<xlength;xi++)x[xi]=.5*(x[2*xi]+x[2*xi+1]);
}
fclose(fin1);
ylength=read_pcm16(&y,fin2,nchannels);
fclose(fin2);
if(xlength!=ylength*downsample){
fprintf(stderr,"Sample counts do not match (%lu!=%lu).\n",
(unsigned long)xlength,(unsigned long)ylength*downsample);
return EXIT_FAILURE;
}
if(xlength<TEST_WIN_SIZE){
fprintf(stderr,"Insufficient sample data (%lu<%i).\n",
(unsigned long)xlength,TEST_WIN_SIZE);
return EXIT_FAILURE;
}
nframes=(xlength-TEST_WIN_SIZE+TEST_WIN_STEP)/TEST_WIN_STEP;
xb=(float *)opus_malloc(nframes*NBANDS*nchannels*sizeof(*xb));
X=(float *)opus_malloc(nframes*NFREQS*nchannels*sizeof(*X));
Y=(float *)opus_malloc(nframes*yfreqs*nchannels*sizeof(*Y));
/*Compute the per-band spectral energy of the original signal
and the error.*/
band_energy(xb,X,BANDS,NBANDS,x,nchannels,nframes,
TEST_WIN_SIZE,TEST_WIN_STEP,1);
free(x);
band_energy(NULL,Y,BANDS,ybands,y,nchannels,nframes,
TEST_WIN_SIZE/downsample,TEST_WIN_STEP/downsample,downsample);
free(y);
for(xi=0;xi<nframes;xi++){
/*Frequency masking (low to high): 10 dB/Bark slope.*/
for(bi=1;bi<NBANDS;bi++){
for(ci=0;ci<nchannels;ci++){
xb[(xi*NBANDS+bi)*nchannels+ci]+=
0.1F*xb[(xi*NBANDS+bi-1)*nchannels+ci];
}
}
/*Frequency masking (high to low): 15 dB/Bark slope.*/
for(bi=NBANDS-1;bi-->0;){
for(ci=0;ci<nchannels;ci++){
xb[(xi*NBANDS+bi)*nchannels+ci]+=
0.03F*xb[(xi*NBANDS+bi+1)*nchannels+ci];
}
}
if(xi>0){
/*Temporal masking: -3 dB/2.5ms slope.*/
for(bi=0;bi<NBANDS;bi++){
for(ci=0;ci<nchannels;ci++){
xb[(xi*NBANDS+bi)*nchannels+ci]+=
0.5F*xb[((xi-1)*NBANDS+bi)*nchannels+ci];
}
}
}
/* Allowing some cross-talk */
if(nchannels==2){
for(bi=0;bi<NBANDS;bi++){
float l,r;
l=xb[(xi*NBANDS+bi)*nchannels+0];
r=xb[(xi*NBANDS+bi)*nchannels+1];
xb[(xi*NBANDS+bi)*nchannels+0]+=0.01F*r;
xb[(xi*NBANDS+bi)*nchannels+1]+=0.01F*l;
}
}
/* Apply masking */
for(bi=0;bi<ybands;bi++){
for(xj=BANDS[bi];xj<BANDS[bi+1];xj++){
for(ci=0;ci<nchannels;ci++){
X[(xi*NFREQS+xj)*nchannels+ci]+=
0.1F*xb[(xi*NBANDS+bi)*nchannels+ci];
Y[(xi*yfreqs+xj)*nchannels+ci]+=
0.1F*xb[(xi*NBANDS+bi)*nchannels+ci];
}
}
}
}
/* Average of consecutive frames to make comparison slightly less sensitive */
for(bi=0;bi<ybands;bi++){
for(xj=BANDS[bi];xj<BANDS[bi+1];xj++){
for(ci=0;ci<nchannels;ci++){
float xtmp;
float ytmp;
xtmp = X[xj*nchannels+ci];
ytmp = Y[xj*nchannels+ci];
for(xi=1;xi<nframes;xi++){
float xtmp2;
float ytmp2;
xtmp2 = X[(xi*NFREQS+xj)*nchannels+ci];
ytmp2 = Y[(xi*yfreqs+xj)*nchannels+ci];
X[(xi*NFREQS+xj)*nchannels+ci] += xtmp;
Y[(xi*yfreqs+xj)*nchannels+ci] += ytmp;
xtmp = xtmp2;
ytmp = ytmp2;
}
}
}
}
/*If working at a lower sampling rate, don't take into account the last
300 Hz to allow for different transition bands.
For 12 kHz, we don't skip anything, because the last band already skips
400 Hz.*/
if(rate==48000)max_compare=BANDS[NBANDS];
else if(rate==12000)max_compare=BANDS[ybands];
else max_compare=BANDS[ybands]-3;
err=0;
for(xi=0;xi<nframes;xi++){
double Ef;
Ef=0;
for(bi=0;bi<ybands;bi++){
double Eb;
Eb=0;
for(xj=BANDS[bi];xj<BANDS[bi+1]&&xj<max_compare;xj++){
for(ci=0;ci<nchannels;ci++){
float re;
float im;
re=Y[(xi*yfreqs+xj)*nchannels+ci]/X[(xi*NFREQS+xj)*nchannels+ci];
im=re-log(re)-1;
/*Make comparison less sensitive around the SILK/CELT cross-over to
allow for mode freedom in the filters.*/
if(xj>=79&&xj<=81)im*=0.1F;
if(xj==80)im*=0.1F;
Eb+=im;
}
}
Eb /= (BANDS[bi+1]-BANDS[bi])*nchannels;
Ef += Eb*Eb;
}
/*Using a fixed normalization value means we're willing to accept slightly
lower quality for lower sampling rates.*/
Ef/=NBANDS;
Ef*=Ef;
err+=Ef*Ef;
}
err=pow(err/nframes,1.0/16);
Q=100*(1-0.5*log(1+err)/log(1.13));
if(Q<0){
fprintf(stderr,"Test vector FAILS\n");
fprintf(stderr,"Internal weighted error is %f\n",err);
return EXIT_FAILURE;
}
else{
fprintf(stderr,"Test vector PASSES\n");
fprintf(stderr,
"Opus quality metric: %.1f %% (internal weighted error is %f)\n",Q,err);
return EXIT_SUCCESS;
}
}
|
the_stack_data/28262852.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 1000
int array[MAX];
void gen(int arr[], int n) {
int i;
for (i = 0; i < n; i++)
arr[i] = rand() % 10 + 1;
}
int count(int arr[], int n, int target) {
int i, count;
for (i = 0, count = 0; i < n; i++)
if (arr[i] == target)
count++;
return count;
}
void display(int arr[], int n) {
int i;
for (i = 0; i < n; i++)
printf("%d ", arr[i]);
}
int main(void) {
int i;
int targets[10];
srand((unsigned int) time(0));
puts("Generating 100 integers...");
gen(array, MAX);
display(array, MAX);
puts("\nCounts from 1 to 10:");
for (i = 1; i < 11; i++) {
targets[i - 1] = count(array, MAX, i);
printf("%d: %d\n", i, targets[i - 1]);
}
}
|
the_stack_data/57264.c | /*
* refclock_acts - clock driver for the NIST/PTB Automated Computer Time
* Service aka Amalgamated Containerized Trash Service (ACTS)
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#if defined(REFCLOCK) && (defined(CLOCK_ACTS) || defined(CLOCK_PTBACTS))
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_unixtime.h"
#include "ntp_refclock.h"
#include "ntp_stdlib.h"
#include "ntp_control.h"
#include <stdio.h>
#include <ctype.h>
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif /* HAVE_SYS_IOCTL_H */
/* MUST BE AFTER LAST #include <config.h> !!! */
#if defined(CLOCK_ACTS) && defined(CLOCK_PTBACTS)
# if defined(KEEPPTBACTS)
# undef CLOCK_ACTS
# else /* not KEEPPTBACTS */
# undef CLOCK_PTBACTS
# endif /* not KEEPPTBACTS */
#endif /* CLOCK_ACTS && CLOCK_PTBACTS */
/*
* This driver supports the NIST Automated Computer Time Service (ACTS).
* It periodically dials a prespecified telephone number, receives the
* NIST timecode data and calculates the local clock correction. It is
* designed primarily for use as a backup when neither a radio clock nor
* connectivity to Internet time servers is available. For the best
* accuracy, the individual telephone line/modem delay needs to be
* calibrated using outside sources.
*
* The ACTS is located at NIST Boulder, CO, telephone 303 494 4774. A
* toll call from a residence telephone in Newark, DE, costs between 14
* and 27 cents, depending on time of day, and from a campus telephone
* between 3 and 4 cents, although it is not clear what carrier and time
* of day discounts apply in this case. The modem dial string will
* differ depending on local telephone configuration, etc., and is
* specified by the phone command in the configuration file. The
* argument to this command is an AT command for a Hayes compatible
* modem.
*
* The accuracy produced by this driver should be in the range of a
* millisecond or two, but may need correction due to the delay
* characteristics of the individual modem involved. For undetermined
* reasons, some modems work with the ACTS echo-delay measurement scheme
* and some don't. This driver tries to do the best it can with what it
* gets. Initial experiments with a Practical Peripherals 9600SA modem
* here in Delaware suggest an accuracy of a millisecond or two can be
* achieved without the scheme by using a fudge time1 value of 65.0 ms.
* In either case, the dispersion for a single call involving ten
* samples is about 1.3 ms.
*
* The driver can operate in either of three modes, as determined by
* the mode parameter in the server configuration command. In mode 0
* (automatic) the driver operates continuously at intervals depending
* on the prediction error, as measured by the driver, usually in the
* order of several hours. In mode 1 (backup) the driver is enabled in
* automatic mode only when no other source of synchronization is
* available and when more than MAXOUTAGE (3600 s) have elapsed since
* last synchronized by other sources. In mode 2 (manual) the driver
* operates only when enabled using a fudge flags switch, as described
* below.
*
* For reliable call management, this driver requires a 1200-bps modem
* with a Hayes-compatible command set and control over the modem data
* terminal ready (DTR) control line. Present restrictions require the
* use of a POSIX-compatible programming interface, although other
* interfaces may work as well. The modem setup string is hard-coded in
* the driver and may require changes for nonstandard modems or special
* circumstances.
*
* Further information can be found in the README.refclock file in the
* ntp - Version 3 distribution.
*
* Fudge Factors
*
* Ordinarily, the propagation time correction is computed automatically
* by ACTS and the driver. When this is not possible or erratic due to
* individual modem characteristics, the fudge flag2 switch should be
* set to disable the ACTS echo-delay scheme. In any case, the fudge
* time1 parameter can be used to adjust the propagation delay as
* required.
*
* The ACTS call interval is determined in one of three ways. In manual
* mode a call is initiated by setting fudge flag1 using ntpdc, either
* manually or via a cron job. In AUTO mode this flag is set by the peer
* timer, which is controlled by the sys_poll variable in response to
* measured errors. In backup mode the driver is ordinarily asleep, but
* awakes (in auto mode) if all other synchronization sources are lost.
* In either auto or backup modes, the call interval increases as long
* as the measured errors do not exceed the value of the fudge time2
* parameter.
*
* When the fudge flag1 is set, the ACTS calling program is activated.
* This program dials each number listed in the phones command of the
* configuration file in turn. If a call attempt fails, the next number
* in the list is dialed. The fudge flag1 and counter are reset and the
* calling program terminated if (a) a valid clock update has been
* determined, (b) no more numbers remain in the list, (c) a device
* fault or timeout occurs or (d) fudge flag1 is reset manually using
* ntpdc.
*
* In automatic and backup modes, the driver determines the call
* interval using a procedure depending on the measured prediction
* error and the fudge time2 parameter. If the error exceeds time2 for a
* number of times depending on the current interval, the interval is
* decreased, but not less than about 1000 s. If the error is less than
* time2 for some number of times, the interval is increased, but not
* more than about 18 h. With the default value of zero for fudge time2,
* the interval will increase from 1000 s to the 4000-8000-s range, in
* which the expected accuracy should be in the 1-2-ms range. Setting
* fudge time2 to a large value, like 0.1 s, may result in errors of
* that order, but increase the call interval to the maximum. The exact
* value for each configuration will depend on the modem and operating
* system involved, so some experimentation may be necessary.
*/
/*
* DESCRIPTION OF THE AUTOMATED COMPUTER TELEPHONE SERVICE (ACTS)
* (reformatted from ACTS on-line computer help information)
*
* The following is transmitted (at 1200 baud) following completion of
* the telephone connection.
*
* National Institute of Standards and Technology
* Telephone Time Service, Generator 3B
* Enter question mark "?" for HELP
* D L D
* MJD YR MO DA H M S ST S UT1 msADV <OTM>
* 47999 90-04-18 21:39:15 50 0 +.1 045.0 UTC(NIST) *
* 47999 90-04-18 21:39:16 50 0 +.1 045.0 UTC(NIST) *
* 47999 90-04-18 21:39:17 50 0 +.1 045.0 UTC(NIST) *
* 47999 90-04-18 21:39:18 50 0 +.1 045.0 UTC(NIST) *
* 47999 90-04-18 21:39:19 50 0 +.1 037.6 UTC(NIST) #
* 47999 90-04-18 21:39:20 50 0 +.1 037.6 UTC(NIST) #
* etc..etc...etc.......
*
* UTC = Universal Time Coordinated, the official world time referred to
* the zero meridian.
*
* DST Daylight savings time characters, valid for the continental
* U.S., are set as follows:
*
* 00 We are on standard time (ST).
* 01-49 Now on DST, go to ST when your local time is 2:00 am and
* the count is 01. The count is decremented daily at 00
* (UTC).
* 50 We are on DST.
* 51-99 Now on ST, go to DST when your local time is 2:00 am and
* the count is 51. The count is decremented daily at 00
* (UTC).
*
* The two DST characters provide up to 48 days advance notice of a
* change in time. The count remains at 00 or 50 at other times.
*
* LS Leap second flag is set to "1" to indicate that a leap second is
* to be added as 23:59:60 (UTC) on the last day of the current UTC
* month. The LS flag will be reset to "0" starting with 23:59:60
* (UTC). The flag will remain on for the entire month before the
* second is added. Leap seconds are added as needed at the end of
* any month. Usually June and/or December are chosen.
*
* The leap second flag will be set to a "2" to indicate that a
* leap second is to be deleted at 23:59:58--00:00:00 on the last
* day of the current month. (This latter provision is included per
* international recommendation, however it is not likely to be
* required in the near future.)
*
* DUT1 Approximate difference between earth rotation time (UT1) and
* UTC, in steps of 0.1 second: DUT1 = UT1 - UTC.
*
* MJD Modified Julian Date, often used to tag certain scientific data.
*
* The full time format is sent at 1200 baud, 8 bit, 1 stop, no parity.
* The format at 300 Baud is also 8 bit, 1 stop, no parity. At 300 Baud
* the MJD and DUT1 values are deleted and the time is transmitted only
* on even seconds.
*
* Maximum on line time will be 56 seconds. If all lines are busy at any
* time, the oldest call will be terminated if it has been on line more
* than 28 seconds, otherwise, the call that first reaches 28 seconds
* will be terminated.
*
* Current time is valid at the "on-time" marker (OTM), either "*" or
* "#". The nominal on-time marker (*) will be transmitted 45 ms early
* to account for the 8 ms required to send 1 character at 1200 Baud,
* plus an additional 7 ms for delay from NIST to the user, and
* approximately 30 ms "scrambler" delay inherent in 1200 Baud modems.
* If the caller echoes all characters, NIST will measure the round trip
* delay and advance the on-time marker so that the midpoint of the stop
* bit arrives at the user on time. The amount of msADV will reflect the
* actual required advance in milliseconds and the OTM will be a "#".
*
* (The NIST system requires 4 or 5 consecutive delay measurements which
* are consistent before switching from "*" to "#". If the user has a
* 1200 Baud modem with the same internal delay as that used by NIST,
* then the "#" OTM should arrive at the user within +-2 ms of the
* correct time.
*
* However, NIST has studied different brands of 1200 Baud modems and
* found internal delays from 24 ms to 40 ms and offsets of the "#" OTM
* of +-10 ms. For many computer users, +-10 ms accuracy should be more
* than adequate since many computer internal clocks can only be set
* with granularity of 20 to 50 ms. In any case, the repeatability of
* the offset for the "#" OTM should be within +-2 ms, if the dial-up
* path is reciprocal and the user doesn't change the brand or model of
* modem used.
*
* This should be true even if the dial-up path on one day is a land-
* line of less than 40 ms (one way) and on the next day is a satellite
* link of 260 to 300 ms. In the rare event that the path is one way by
* satellite and the other way by land line with a round trip
* measurement in the range of 90 to 260 ms, the OTM will remain a "*"
* indicating 45 ms advance.
*
* For user comments write:
* NIST-ACTS
* Time and Frequency Division
* Mail Stop 847
* 325 Broadway
* Boulder, CO 80303
*
* Software for setting (PC)DOS compatable machines is available on a
* 360-kbyte diskette for $35.00 from: NIST Office of Standard Reference
* Materials B311-Chemistry Bldg, NIST, Gaithersburg, MD, 20899, (301)
* 975-6776
*
* PTB timecode service (+49 531 512038)
* The Physikalisch-Technische Bundesanstalt (Germany)
* also supports a modem time service
* as the data formats are very similar this driver can also be compiled for
* utilizing the PTB time code service.
*
* Data format
* 0000000000111111111122222222223333333333444444444455555555556666666666777777777 7
* 0123456789012345678901234567890123456789012345678901234567890123456789012345678 9
* 1995-01-23 20:58:51 MEZ 10402303260219950123195849740+40000500 *
* A B C D EF G H IJ K L M N O P Q R S T U V W XY Z<CR><LF>
*
* A year
* B month
* C day
* D hour
* E : normally
* A for DST to ST switch first hour
* B for DST to ST switch second hour if not marked in H
* F minute
* G second
* H timezone
* I day of week
* J week of year
* K day of year
* L month for next ST/DST changes
* M day
* N hour
* O UTC year
* P UTC month
* Q UTC day
* R UTC hour
* S UTC minute
* T modified julian day (MJD)
* U DUT1
* V direction and month if leap second
* W signal delay (assumed/measured)
* X sequence number for additional text line in Y
* Y additional text
* Z on time marker (* - assumed delay / # measured delay)
* <CR>!<LF> ! is second change !
*
* This format is also used by the National Physical Laboratory (NPL)'s
* TRUETIME service in the UK. In this case the timezone field is
* UTC+0 or UTC+1 for standard and daylight saving time. The phone
* number for this service (a premium rate number) is 0891 516 333.
* It is not clear whether the echo check is implemented.
*
* For more detail, see http://www.npl.co.uk/npl/cetm/taf/truetime.html.
*/
/*
* Interface definitions
*/
#define SPEED232 B1200 /* uart speed (1200 cowardly baud) */
#define PRECISION (-10) /* precision assumed (about 1 ms) */
#ifdef CLOCK_ACTS
# define REFID "ACTS" /* reference ID */
# define DESCRIPTION "NIST Automated Computer Time Service" /* WRU */
# define LENCODE 50 /* length of valid timecode string */
# define DEVICE "/dev/acts%d" /* device name and unit */
# define REF_ENTRY refclock_acts
#else /* not CLOCK_ACTS */
# define REFID "TPTB" /* reference ID */
# define DESCRIPTION "PTB Automated Computer Time Service"
# define LENCODE 78 /* length of valid timecode string */
# define DEVICE "/dev/ptb%d" /* device name and unit */
# define REF_ENTRY refclock_ptb
#endif /* not CLOCK_ACTS */
#define MODE_AUTO 0 /* automatic mode */
#define MODE_BACKUP 1 /* backup mode */
#define MODE_MANUAL 2 /* manual mode */
#define MSGCNT 10 /* we need this many ACTS messages */
#define SMAX 80 /* max token string length */
#define ACTS_MINPOLL 10 /* log2 min poll interval (1024 s) */
#define ACTS_MAXPOLL 18 /* log2 max poll interval (16384 s) */
#define MAXOUTAGE 3600 /* max before ACTS kicks in (s) */
/*
* Modem control strings. These may have to be changed for some modems.
*
* AT command prefix
* B1 initiate call negotiation using Bell 212A
* &C1 enable carrier detect
* &D2 hang up and return to command mode on DTR transition
* E0 modem command echo disabled
* l1 set modem speaker volume to low level
* M1 speaker enabled untill carrier detect
* Q0 return result codes
* V1 return result codes as English words
*/
#define MODEM_SETUP "ATB1&C1&D2E0L1M1Q0V1" /* modem setup */
#define MODEM_HANGUP "ATH" /* modem disconnect */
/*
* Timeouts
*/
#define IDLE 60 /* idle timeout (s) */
#define WAIT 2 /* wait timeout (s) */
#define ANSWER 30 /* answer timeout (s) */
#define CONNECT 10 /* connect timeout (s) */
#define TIMECODE 15 /* timecode timeout (s) */
/*
* Tables to compute the ddd of year form icky dd/mm timecode. Viva la
* leap.
*/
static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
/*
* Unit control structure
*/
struct actsunit {
int pollcnt; /* poll message counter */
int state; /* the first one was Delaware */
int run; /* call program run switch */
int msgcnt; /* count of ACTS messages received */
long redial; /* interval to next automatic call */
double msADV; /* millisecond advance of last message */
};
/*
* Function prototypes
*/
static int acts_start P((int, struct peer *));
static void acts_shutdown P((int, struct peer *));
static void acts_receive P((struct recvbuf *));
static void acts_poll P((int, struct peer *));
static void acts_timeout P((struct peer *));
static void acts_disc P((struct peer *));
static int acts_write P((struct peer *, const char *));
/*
* Transfer vector (conditional structure name)
*/
struct refclock REF_ENTRY = {
acts_start, /* start up driver */
acts_shutdown, /* shut down driver */
acts_poll, /* transmit poll message */
noentry, /* not used (old acts_control) */
noentry, /* not used (old acts_init) */
noentry, /* not used (old acts_buginfo) */
NOFLAGS /* not used */
};
/*
* acts_start - open the devices and initialize data for processing
*/
static int
acts_start (
int unit,
struct peer *peer
)
{
register struct actsunit *up;
struct refclockproc *pp;
int fd;
char device[20];
int dtr = TIOCM_DTR;
/*
* Open serial port. Use ACTS line discipline, if available. It
* pumps a timestamp into the data stream at every on-time
* character '*' found. Note: the port must have modem control
* or deep pockets for the phone bill. HP-UX 9.03 users should
* have very deep pockets.
*/
(void)sprintf(device, DEVICE, unit);
if (!(fd = refclock_open(device, SPEED232, LDISC_ACTS)))
return (0);
if (ioctl(fd, TIOCMBIS, (char *)&dtr) < 0) {
msyslog(LOG_ERR, "clock %s ACTS no modem control",
ntoa(&peer->srcadr));
return (0);
}
/*
* Allocate and initialize unit structure
*/
if (!(up = (struct actsunit *)
emalloc(sizeof(struct actsunit)))) {
(void) close(fd);
return (0);
}
memset((char *)up, 0, sizeof(struct actsunit));
pp = peer->procptr;
pp->io.clock_recv = acts_receive;
pp->io.srcclock = (caddr_t)peer;
pp->io.datalen = 0;
pp->io.fd = fd;
if (!io_addclock(&pp->io)) {
(void) close(fd);
free(up);
return (0);
}
pp->unitptr = (caddr_t)up;
/*
* Initialize miscellaneous variables
*/
peer->precision = PRECISION;
pp->clockdesc = DESCRIPTION;
memcpy((char *)&pp->refid, REFID, 4);
peer->minpoll = ACTS_MINPOLL;
peer->maxpoll = ACTS_MAXPOLL;
peer->sstclktype = CTL_SST_TS_TELEPHONE;
/*
* Initialize modem and kill DTR. We skedaddle if this comes
* bum.
*/
if (!acts_write(peer, MODEM_SETUP)) {
(void) close(fd);
free(up);
return (0);
}
/*
* Set up the driver timeout
*/
peer->nextdate = current_time + WAIT;
return (1);
}
/*
* acts_shutdown - shut down the clock
*/
static void
acts_shutdown (
int unit,
struct peer *peer
)
{
register struct actsunit *up;
struct refclockproc *pp;
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
io_closeclock(&pp->io);
free(up);
}
/*
* acts_receive - receive data from the serial interface
*/
static void
acts_receive (
struct recvbuf *rbufp
)
{
register struct actsunit *up;
struct refclockproc *pp;
struct peer *peer;
char str[SMAX];
int i;
char hangup = '%'; /* ACTS hangup */
int day; /* day of the month */
int month; /* month of the year */
u_long mjd; /* Modified Julian Day */
double dut1; /* DUT adjustment */
double msADV; /* ACTS transmit advance (ms) */
char flag; /* calibration flag */
#ifndef CLOCK_PTBACTS
char utc[10]; /* this is NIST and you're not */
u_int dst; /* daylight/standard time indicator */
u_int leap; /* leap-second indicator */
#else
char leapdir; /* leap direction */
u_int leapmonth; /* month of leap */
#endif
/*
* Initialize pointers and read the timecode and timestamp. If
* the OK modem status code, leave it where folks can find it.
*/
peer = (struct peer *)rbufp->recv_srcclock;
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX,
&pp->lastrec);
if (pp->lencode == 0) {
if (strcmp(pp->a_lastcode, "OK") == 0)
pp->lencode = 2;
return;
}
#ifdef DEBUG
if (debug)
printf("acts: state %d timecode %d %*s\n", up->state,
pp->lencode, pp->lencode, pp->a_lastcode);
#endif
switch (up->state) {
case 0:
/*
* State 0. We are not expecting anything. Probably
* modem disconnect noise. Go back to sleep.
*/
return;
case 1:
/*
* State 1. We are waiting for the call to be answered.
* All we care about here is CONNECT as the first token
* in the string. If the modem signals BUSY, ERROR, NO
* ANSWER, NO CARRIER or NO DIALTONE, we immediately
* hang up the phone. If CONNECT doesn't happen after
* ANSWER seconds, hang up the phone. If everything is
* okay, start the connect timeout and slide into state
* 2.
*/
if( strcmp(pp->a_lastcode, " ") == 0) {
acts_disc(peer);
return;
}
if( strcmp(sys_phone[0],"DIRECT") != 0 ) {
(void)strncpy(str, strtok(pp->a_lastcode, " "), SMAX);
if (strcmp(str, "BUSY") == 0 || strcmp(str, "ERROR") ==
0 || strcmp(str, "NO") == 0) {
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE,
"clock %s ACTS modem status %s",
ntoa(&peer->srcadr), pp->a_lastcode);
acts_disc(peer);
} else if (strcmp(str, "CONNECT") == 0) {
peer->nextdate = current_time + CONNECT;
up->msgcnt = 0;
up->state++;
}
} else {
(void) strncpy(str,"CONNECT",7);
peer->nextdate = current_time + CONNECT;
up->msgcnt = 0;
up->state++;
}
return;
case 2:
/*
* State 2. The call has been answered and we are
* waiting for the first ACTS message. If this doesn't
* happen within the timecode timeout, hang up the
* phone. We probably got a wrong number or ACTS is
* down.
*/
peer->nextdate = current_time + TIMECODE;
up->state++;
}
/*
* Real yucky things here. Ignore everything except timecode
* messages, as determined by the message length. We told the
* terminal routines to end the line with '*' and the line
* discipline to strike a timestamp on that character. However,
* when the ACTS echo-delay scheme works, the '*' eventually
* becomes a '#'. In this case the message is ended by the <CR>
* that comes about 200 ms after the '#' and the '#' cannot be
* echoed at the proper time. But, this may not be a lose, since
* we already have good data from prior messages and only need
* the millisecond advance calculated by ACTS. So, if the
* message is long enough and has an on-time character at the
* right place, we consider the message (but not neccesarily the
* timestmap) to be valid.
*/
if (pp->lencode != LENCODE)
return;
#ifndef CLOCK_PTBACTS
/*
* We apparently have a valid timecode message, so dismember it
* with sscan(). This routine does a good job in spotting syntax
* errors without becoming overly pedantic.
*
* D L D
* MJD YR MO DA H M S ST S UT1 msADV OTM
* 47222 88-03-02 21:39:15 83 0 +.3 045.0 UTC(NBS) *
*/
if (sscanf(pp->a_lastcode,
"%5ld %2d-%2d-%2d %2d:%2d:%2d %2d %1d %3lf %5lf %s %c",
&mjd, &pp->year, &month, &day, &pp->hour, &pp->minute,
&pp->second, &dst, &leap, &dut1, &msADV, utc, &flag) != 13) {
refclock_report(peer, CEVNT_BADREPLY);
return;
}
#else
/*
* Data format
* 0000000000111111111122222222223333333333444444444455555555556666666666777777777 7
* 0123456789012345678901234567890123456789012345678901234567890123456789012345678 9
* 1995-01-23 20:58:51 MEZ 10402303260219950123195849740+40000500 *
*/
if (sscanf(pp->a_lastcode,
"%*4d-%*2d-%*2d %*2d:%*2d:%2d %*5c%*12c%4d%2d%2d%2d%2d%5ld%2lf%c%2d%3lf%*15c%c",
&pp->second, &pp->year, &month, &day, &pp->hour, &pp->minute, &mjd, &dut1, &leapdir, &leapmonth, &msADV, &flag) != 12) {
refclock_report(peer, CEVNT_BADREPLY);
return;
}
#endif
/*
* Some modems can't be trusted (the Practical Peripherals
* 9600SA comes to mind) and, even if they manage to unstick
* ACTS, the millisecond advance is wrong, so we use CLK_FLAG2
* to disable echoes, if neccessary.
*/
if ((flag == '*' || flag == '#') && !(pp->sloppyclockflag &
CLK_FLAG2))
(void)write(pp->io.fd, &flag, 1);
/*
* The ACTS timecode format croaks in 2000. Life is short.
* Would only the timecode mavens resist the urge to express months
* of the year and days of the month in favor of days of the year.
*/
if (month < 1 || month > 12 || day < 1) {
refclock_report(peer, CEVNT_BADTIME);
return;
}
/*
* Depending on the driver, at this point we have a two-digit year
* or a four-digit year. Make sure we have a four-digit year.
*/
if ( pp->year < YEAR_PIVOT ) pp->year += 100; /* Y2KFixes */
if ( pp->year < YEAR_BREAK ) pp->year += 1900; /* Y2KFixes */
if ( !isleap_4(pp->year) ) { /* Y2KFixes */
if (day > day1tab[month - 1]) {
refclock_report(peer, CEVNT_BADTIME);
return;
}
for (i = 0; i < month - 1; i++)
day += day1tab[i];
} else {
if (day > day2tab[month - 1]) {
refclock_report(peer, CEVNT_BADTIME);
return;
}
for (i = 0; i < month - 1; i++)
day += day2tab[i];
}
pp->day = day;
#ifndef CLOCK_PTBACTS
if (leap == 1)
pp->leap = LEAP_ADDSECOND;
else if (pp->leap == 2)
pp->leap = LEAP_DELSECOND;
#else
if (leapmonth == month) {
if (leapdir == '+')
pp->leap = LEAP_ADDSECOND;
else if (leapdir == '-')
pp->leap = LEAP_DELSECOND;
}
#endif
/*
* Colossal hack here. We process each sample in a trimmed-mean
* filter and determine the reference clock offset and
* dispersion. The fudge time1 value is added to each sample as
* received. If we collect MSGCNT samples before the '#' on-time
* character, we use the results of the filter as is. If the '#'
* is found before that, the adjusted msADV is used to correct
* the propagation delay.
*/
up->msgcnt++;
if (flag == '#') {
pp->offset += (msADV - up->msADV) * 1000 * 1e-6;
} else {
up->msADV = msADV;
if (!refclock_process(pp)) {
refclock_report(peer, CEVNT_BADTIME);
return;
} else if (up->msgcnt < MSGCNT)
return;
}
/*
* We have a filtered sample offset ready for peer processing.
* We use lastrec as both the reference time and receive time in
* order to avoid being cute, like setting the reference time
* later than the receive time, which may cause a paranoid
* protocol module to chuck out the data. Finaly, we unhook the
* timeout, arm for the next call, fold the tent and go home.
* The little dance with the '%' character is an undocumented
* ACTS feature that hangs up the phone real quick without
* waiting for carrier loss or long-space disconnect, but we do
* these clumsy things anyway.
*/
pp->lastref = pp->lastrec;
refclock_receive(peer);
record_clock_stats(&peer->srcadr, pp->a_lastcode);
pp->sloppyclockflag &= ~CLK_FLAG1;
up->pollcnt = 0;
(void)write(pp->io.fd, &hangup, 1);
up->state = 0;
acts_disc(peer);
}
/*
* acts_poll - called by the transmit routine
*/
static void
acts_poll (
int unit,
struct peer *peer
)
{
register struct actsunit *up;
struct refclockproc *pp;
/*
* If the driver is running, we set the enable flag (fudge
* flag1), which causes the driver timeout routine to initiate a
* call to ACTS. If not, the enable flag can be set using
* ntpdc. If this is the sustem peer, then follow the system
* poll interval.
*/
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
if (up->run) {
pp->sloppyclockflag |= CLK_FLAG1;
if (peer == sys_peer)
peer->hpoll = sys_poll;
else
peer->hpoll = peer->minpoll;
}
acts_timeout (peer);
return;
}
/*
* acts_timeout - called by the timer interrupt
*/
static void
acts_timeout (
struct peer *peer
)
{
register struct actsunit *up;
struct refclockproc *pp;
int dtr = TIOCM_DTR;
/*
* If a timeout occurs in other than state 0, the call has
* failed. If in state 0, we just see if there is other work to
* do.
*/
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
if (up->state) {
acts_disc(peer);
return;
}
switch (peer->ttl) {
/*
* In manual mode the ACTS calling program is activated
* by the ntpdc program using the enable flag (fudge
* flag1), either manually or by a cron job.
*/
case MODE_MANUAL:
up->run = 0;
break;
/*
* In automatic mode the ACTS calling program runs
* continuously at intervals determined by the sys_poll
* variable.
*/
case MODE_AUTO:
if (!up->run)
pp->sloppyclockflag |= CLK_FLAG1;
up->run = 1;
break;
/*
* In backup mode the ACTS calling program is disabled,
* unless no system peer has been selected for MAXOUTAGE
* (3600 s). Once enabled, it runs until some other NTP
* peer shows up.
*/
case MODE_BACKUP:
if (!up->run && sys_peer == 0) {
if (current_time - last_time > MAXOUTAGE) {
up->run = 1;
peer->hpoll = peer->minpoll;
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE,
"clock %s ACTS backup started ",
ntoa(&peer->srcadr));
}
} else if (up->run && sys_peer->sstclktype != CTL_SST_TS_TELEPHONE) {
peer->hpoll = peer->minpoll;
up->run = 0;
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE,
"clock %s ACTS backup stopped",
ntoa(&peer->srcadr));
}
break;
default:
msyslog(LOG_ERR,
"clock %s ACTS invalid mode", ntoa(&peer->srcadr));
}
/*
* The fudge flag1 is used as an enable/disable; if set either
* by the code or via ntpdc, the ACTS calling program is
* started; if reset, the phones stop ringing.
*/
if (!(pp->sloppyclockflag & CLK_FLAG1)) {
up->pollcnt = 0;
peer->nextdate = current_time + IDLE;
return;
}
/*
* Initiate a call to the ACTS service. If we wind up here in
* other than state 0, a successful call could not be completed
* within minpoll seconds. We advance to the next modem dial
* string. If none are left, we log a notice and clear the
* enable flag. For future enhancement: call the site RP and
* leave an obscene message in his voicemail.
*/
if (sys_phone[up->pollcnt][0] == '\0') {
refclock_report(peer, CEVNT_TIMEOUT);
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE,
"clock %s ACTS calling program terminated",
ntoa(&peer->srcadr));
pp->sloppyclockflag &= ~CLK_FLAG1;
#ifdef DEBUG
if (debug)
printf("acts: calling program terminated\n");
#endif
up->pollcnt = 0;
peer->nextdate = current_time + IDLE;
return;
}
/*
* Raise DTR, call ACTS and start the answer timeout. We think
* it strange if the OK status has not been received from the
* modem, but plow ahead anyway.
*/
if (strcmp(pp->a_lastcode, "OK") != 0)
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE, "clock %s ACTS no modem status",
ntoa(&peer->srcadr));
(void)ioctl(pp->io.fd, TIOCMBIS, (char *)&dtr);
(void)acts_write(peer, sys_phone[up->pollcnt]);
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE, "clock %s ACTS calling %s\n",
ntoa(&peer->srcadr), sys_phone[up->pollcnt]);
up->state = 1;
up->pollcnt++;
pp->polls++;
peer->nextdate = current_time + ANSWER;
return;
}
/*
* acts_disc - disconnect the call and wait for the ruckus to cool
*/
static void
acts_disc (
struct peer *peer
)
{
register struct actsunit *up;
struct refclockproc *pp;
int dtr = TIOCM_DTR;
/*
* We should never get here other than in state 0, unless a call
* has timed out. We drop DTR, which will reliably get the modem
* off the air, even while ACTS is hammering away full tilt.
*/
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
(void)ioctl(pp->io.fd, TIOCMBIC, (char *)&dtr);
if (up->state > 0) {
NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
msyslog(LOG_NOTICE, "clock %s ACTS call failed %d",
ntoa(&peer->srcadr), up->state);
#ifdef DEBUG
if (debug)
printf("acts: call failed %d\n", up->state);
#endif
up->state = 0;
}
peer->nextdate = current_time + WAIT;
}
/*
* acts_write - write a message to the serial port
*/
static int
acts_write (
struct peer *peer,
const char *str
)
{
register struct actsunit *up;
struct refclockproc *pp;
int len;
int code;
char cr = '\r';
/*
* Not much to do here, other than send the message, handle
* debug and report faults.
*/
pp = peer->procptr;
up = (struct actsunit *)pp->unitptr;
len = strlen(str);
#ifdef DEBUG
if (debug)
printf("acts: state %d send %d %s\n", up->state, len,
str);
#endif
code = write(pp->io.fd, str, (unsigned)len) == len;
code &= write(pp->io.fd, &cr, 1) == 1;
if (!code)
refclock_report(peer, CEVNT_FAULT);
return (code);
}
#else
int refclock_acts_bs;
#endif /* REFCLOCK */
|
the_stack_data/70522.c | /*
* @f pkt-ndntlv.c
* @b CCN lite - NDN pkt decoding and composition (TLV pkt format March 2014)
*
* Copyright (C) 2014-15, Christian Tschudin, University of Basel
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* File history:
* 2014-03-05 created
* 2014-11-05 merged from pkt-ndntlv-enc.c pkt-ndntlv-dec.c
*/
#ifdef USE_SUITE_NDNTLV
#ifndef CCNL_LINUXKERNEL
#include "ccnl-pkt-ndntlv.h"
#include "ccnl-core.h"
#include "ccnl-nfn-requests.h"
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <assert.h>
#else
#include <ccnl-pkt-ndntlv.h>
#include <ccnl-core.h>
#endif
// ----------------------------------------------------------------------
// packet parsing
int
ccnl_ndntlv_varlenint(unsigned char **buf, int *len, int *val)
{
if (**buf < 253 && *len >= 1) {
*val = **buf;
*buf += 1;
*len -= 1;
} else if (**buf == 253 && *len >= 3) { // 2 bytes
/* ORing bytes does not provoke alignment issues */
*val = ((*buf)[1] << 8) | ((*buf)[2] << 0);
*buf += 3;
*len -= 3;
} else if (**buf == 254 && *len >= 5) { // 4 bytes
/* ORing bytes does not provoke alignment issues */
*val = ((*buf)[1] << 24) | ((*buf)[2] << 16) |
((*buf)[3] << 8) | ((*buf)[4] << 0);
*buf += 5;
*len -= 5;
} else {
// not implemented yet (or too short)
return -1;
}
return 0;
}
unsigned long int
ccnl_ndntlv_nonNegInt(unsigned char *cp, int len)
{
unsigned long int val = 0;
while (len-- > 0) {
val = (val << 8) | *cp;
cp++;
}
return val;
}
int
ccnl_ndntlv_dehead(unsigned char **buf, int *len,
int *typ, int *vallen)
{
size_t maxlen = *len;
if (ccnl_ndntlv_varlenint(buf, len, (int*) typ))
return -1;
if (ccnl_ndntlv_varlenint(buf, len, (int*) vallen))
return -1;
if((size_t)*vallen > maxlen)
return -1; //Return failure (-1) if length value in the tlv is longer than the buffer
return 0;
}
// we use one extraction routine for each of interest, data and fragment pkts
struct ccnl_pkt_s*
ccnl_ndntlv_bytes2pkt(unsigned int pkttype, unsigned char *start,
unsigned char **data, int *datalen)
{
struct ccnl_pkt_s *pkt;
int oldpos, len, i;
unsigned int typ;
struct ccnl_prefix_s *p = 0;
#ifdef USE_HMAC256
int validAlgoIsHmac256 = 0;
#endif
DEBUGMSG(DEBUG, "ccnl_ndntlv_bytes2pkt len=%d\n", *datalen);
pkt = (struct ccnl_pkt_s*) ccnl_calloc(1, sizeof(struct ccnl_pkt_s));
if (!pkt)
return NULL;
pkt->type = pkttype;
#ifdef USE_HMAC256
pkt->hmacStart = start;
#endif
switch(pkttype) {
case NDN_TLV_Interest:
pkt->flags |= CCNL_PKT_REQUEST;
break;
case NDN_TLV_Data:
pkt->flags |= CCNL_PKT_REPLY;
break;
#ifdef USE_FRAG
case NDN_TLV_Fragment:
pkt->flags |= CCNL_PKT_FRAGMENT;
break;
#endif
default:
DEBUGMSG(INFO, " ndntlv: unknown packet type %d\n", pkttype);
goto Bail;
}
pkt->suite = CCNL_SUITE_NDNTLV;
pkt->s.ndntlv.scope = 3;
pkt->s.ndntlv.maxsuffix = CCNL_MAX_NAME_COMP;
/* set default lifetime, in case InterestLifetime guider is absent */
pkt->s.ndntlv.interestlifetime = CCNL_INTEREST_TIMEOUT;
oldpos = *data - start;
while (ccnl_ndntlv_dehead(data, datalen, (int*) &typ, &len) == 0) {
unsigned char *cp = *data;
int len2 = len;
switch (typ) {
case NDN_TLV_Name:
if (p) {
DEBUGMSG(WARNING, " ndntlv: name already defined\n");
goto Bail;
}
p = ccnl_prefix_new(CCNL_SUITE_NDNTLV, CCNL_MAX_NAME_COMP);
if (!p)
goto Bail;
p->compcnt = 0;
pkt->pfx = p;
pkt->val.final_block_id = -1;
p->nameptr = start + oldpos;
while (len2 > 0) {
if (ccnl_ndntlv_dehead(&cp, &len2, (int*) &typ, &i))
goto Bail;
if (typ == NDN_TLV_NameComponent &&
p->compcnt < CCNL_MAX_NAME_COMP) {
if(cp[0] == NDN_Marker_SegmentNumber) {
p->chunknum = (int*) ccnl_malloc(sizeof(int));
// TODO: requires ccnl_ndntlv_includedNonNegInt which includes the length of the marker
// it is implemented for encode, the decode is not yet implemented
*p->chunknum = ccnl_ndntlv_nonNegInt(cp + 1, i - 1);
}
p->comp[p->compcnt] = cp;
p->complen[p->compcnt] = i; //FIXME, what if the len value inside the TLV is wrong -> can this lead to overruns inside
p->compcnt++;
} // else unknown type: skip
cp += i;
len2 -= i;
}
p->namelen = *data - p->nameptr;
DEBUGMSG(DEBUG, " check interest type\n");
#ifdef USE_NFN
if (p->compcnt > 0 && p->complen[p->compcnt-1] == 3 &&
!memcmp(p->comp[p->compcnt-1], "NFN", 3)) {
p->nfnflags |= CCNL_PREFIX_NFN;
p->compcnt--;
DEBUGMSG(DEBUG, " is NFN interest\n");
}
#ifdef USE_NFN_REQUESTS
if (p->compcnt > 1 && p->complen[p->compcnt-2] == 3 &&
!memcmp(p->comp[p->compcnt-2], "R2C", 3)) {
p->nfnflags |= CCNL_PREFIX_REQUEST;
p->request = nfn_request_new(p->comp[p->compcnt-1], p->complen[p->compcnt-1]);
p->compcnt -= 2;
DEBUGMSG(DEBUG, " is NFN REQUEST interest\n");
}
#endif // USE_NFN_REQUESTS
#endif // USE_NFN
break;
case NDN_TLV_Selectors:
while (len2 > 0) {
if (ccnl_ndntlv_dehead(&cp, &len2, (int*) &typ, &i))
goto Bail;
switch(typ) {
case NDN_TLV_MinSuffixComponents:
pkt->s.ndntlv.minsuffix = ccnl_ndntlv_nonNegInt(cp, i);
break;
case NDN_TLV_MaxSuffixComponents:
// fprintf(stderr, "setting to %d\n", (int)ccnl_ndntlv_nonNegInt(cp, i));
pkt->s.ndntlv.maxsuffix = ccnl_ndntlv_nonNegInt(cp, i);
break;
case NDN_TLV_MustBeFresh:
pkt->s.ndntlv.mbf = 1;
break;
case NDN_TLV_Exclude:
DEBUGMSG(WARNING, "'Exclude' field ignored\n");
break;
default:
break;
}
cp += i;
len2 -= i;
}
break;
case NDN_TLV_Nonce:
pkt->s.ndntlv.nonce = ccnl_buf_new(*data, len);
break;
case NDN_TLV_Scope:
pkt->s.ndntlv.scope = ccnl_ndntlv_nonNegInt(*data, len);
break;
case NDN_TLV_Content:
case NDN_TLV_NdnlpFragment: // payload
pkt->content = *data;
pkt->contlen = len;
break;
case NDN_TLV_MetaInfo:
while (len2 > 0) {
if (ccnl_ndntlv_dehead(&cp, &len2, (int*) &typ, &i))
goto Bail;
if (typ == NDN_TLV_ContentType) {
// Not used
// = ccnl_ndntlv_nonNegInt(cp, i);
DEBUGMSG(WARNING, "'ContentType' field ignored\n");
}
if (typ == NDN_TLV_FreshnessPeriod) {
pkt->s.ndntlv.freshnessperiod = ccnl_ndntlv_nonNegInt(cp, i);
}
if (typ == NDN_TLV_FinalBlockId) {
if (ccnl_ndntlv_dehead(&cp, &len2, (int*) &typ, &i))
goto Bail;
if (typ == NDN_TLV_NameComponent) {
// TODO: again, includedNonNeg not yet implemented
pkt->val.final_block_id = ccnl_ndntlv_nonNegInt(cp + 1, i - 1);
}
}
cp += i;
len2 -= i;
}
break;
case NDN_TLV_InterestLifetime:
pkt->s.ndntlv.interestlifetime = ccnl_ndntlv_nonNegInt(*data, len);
break;
case NDN_TLV_Frag_BeginEndFields:
pkt->val.seqno = ccnl_ndntlv_nonNegInt(*data, len);
DEBUGMSG(TRACE, " frag: %04x\n", pkt->val.seqno);
if (pkt->val.seqno & 0x4000)
pkt->flags |= CCNL_PKT_FRAG_BEGIN;
if (pkt->val.seqno & 0x8000)
pkt->flags |= CCNL_PKT_FRAG_END;
pkt->val.seqno &= 0x3fff;
break;
#ifdef USE_HMAC256
case NDN_TLV_SignatureInfo:
while (len2 > 0) {
if (ccnl_ndntlv_dehead(&cp, &len2, (int*) &typ, &i))
goto Bail;
if (typ == NDN_TLV_SignatureType && i == 1 &&
*cp == NDN_VAL_SIGTYPE_HMAC256) {
validAlgoIsHmac256 = 1;
break;
}
cp += i;
len2 -= i;
}
break;
case NDN_TLV_SignatureValue:
if (pkt->hmacStart && validAlgoIsHmac256 && len == 32) {
pkt->hmacLen = oldpos;
pkt->hmacSignature = *data;
}
break;
#endif
default:
break;
}
*data += len;
*datalen -= len;
oldpos = *data - start;
}
if (*datalen > 0)
goto Bail;
pkt->pfx = p;
pkt->buf = ccnl_buf_new(start, *data - start);
if (!pkt->buf)
goto Bail;
// carefully rebase ptrs to new buf because of 64bit pointers:
if (pkt->content)
pkt->content = pkt->buf->data + (pkt->content - start);
if (p) {
for (i = 0; i < p->compcnt; i++)
p->comp[i] = pkt->buf->data + (p->comp[i] - start);
if (p->nameptr)
p->nameptr = pkt->buf->data + (p->nameptr - start);
}
return pkt;
Bail:
ccnl_pkt_free(pkt);
return NULL;
}
// ----------------------------------------------------------------------
#ifdef NEEDS_PREFIX_MATCHING
// returns: 0=match, -1=otherwise
int
ccnl_ndntlv_cMatch(struct ccnl_pkt_s *p, struct ccnl_content_s *c)
{
#ifndef CCNL_LINUXKERNEL
assert(p);
assert(p->suite == CCNL_SUITE_NDNTLV);
#endif
if (!ccnl_i_prefixof_c(p->pfx, p->s.ndntlv.minsuffix, p->s.ndntlv.maxsuffix, c))
return -1;
if (p->s.ndntlv.mbf && c->stale) {
DEBUGMSG(DEBUG, "ignore stale content\n");
return -1;
}
DEBUGMSG(DEBUG, " matching content for interest, content %p\n",
(void *) c);
return 0;
}
#endif
// ----------------------------------------------------------------------
// packet composition
#ifdef NEEDS_PACKET_CRAFTING
int
ccnl_ndntlv_prependTLval(unsigned long val, int *offset, unsigned char *buf)
{
int len, i, t;
if (val < 253)
len = 0, t = val;
else if (val <= 0xffff)
len = 2, t = 253;
else if (val <= 0xffffffffL)
len = 4, t = 254;
else
len = 8, t = 255;
if (*offset < (len+1))
return -1;
for (i = 0; i < len; i++) {
buf[--(*offset)] = val & 0xff;
val = val >> 8;
}
buf[--(*offset)] = t;
return len + 1;
}
int
ccnl_ndntlv_prependTL(int type, unsigned int len,
int *offset, unsigned char *buf)
{
int oldoffset = *offset;
if (ccnl_ndntlv_prependTLval(len, offset, buf) < 0)
return -1;
if (ccnl_ndntlv_prependTLval(type, offset, buf) < 0)
return -1;
return oldoffset - *offset;
}
int
ccnl_ndntlv_prependNonNegIntVal(unsigned int val,
int *offset, unsigned char *buf) {
int len = 0, i;
static char fill[] = {1, 0, 0, 1, 0, 3, 2, 1, 0};
while (val) {
if ((*offset)-- < 1)
return -1;
buf[*offset] = (unsigned char) (val & 0xff);
len++;
val = val >> 8;
}
for (i = fill[len]; i > 0; i--) {
if ((*offset)-- < 1)
return -1;
buf[*offset] = 0;
len++;
}
return len;
}
int
ccnl_ndntlv_prependNonNegInt(int type,
unsigned int val,
int *offset, unsigned char *buf)
{
int oldoffset = *offset;
if (ccnl_ndntlv_prependNonNegIntVal(val, offset, buf) < 0)
return -1;
if (ccnl_ndntlv_prependTL(type, oldoffset - *offset, offset, buf) < 0)
return -1;
return oldoffset - *offset;
}
int
ccnl_ndntlv_prependIncludedNonNegInt(int type, unsigned int val,
char marker,
int *offset, unsigned char *buf)
{
int oldoffset = *offset;
if (ccnl_ndntlv_prependNonNegIntVal(val, offset, buf) < 0)
return -1;
if((*offset)-- < 1)
return -1;
buf[*offset] = marker;
if (ccnl_ndntlv_prependTL(type, oldoffset - *offset, offset, buf) < 0)
return -1;
return oldoffset - *offset;
}
int
ccnl_ndntlv_prependBlob(int type, unsigned char *blob, int len,
int *offset, unsigned char *buf)
{
int oldoffset = *offset;
if (*offset < len)
return -1;
memcpy(buf + *offset - len, blob, len);
*offset -= len;
if (ccnl_ndntlv_prependTL(type, len, offset, buf) < 0)
return -1;
return oldoffset - *offset;
}
int
ccnl_ndntlv_prependName(struct ccnl_prefix_s *name,
int *offset, unsigned char *buf)
{
int oldoffset = *offset, cnt;
if(name->chunknum) {
if (ccnl_ndntlv_prependIncludedNonNegInt(NDN_TLV_NameComponent,
*name->chunknum,
NDN_Marker_SegmentNumber,
offset, buf) < 0)
return -1;
}
#ifdef USE_NFN
if (name->nfnflags & CCNL_PREFIX_NFN) {
if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
(unsigned char*) "NFN", 3, offset, buf) < 0)
return -1;
}
// #ifdef USE_TIMEOUT_KEEPALIVE
// if (name->nfnflags & CCNL_PREFIX_INTERMEDIATE) {
// char internum[16];
// snprintf(internum, 16, "%d", name->internum);
// if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
// (unsigned char*) internum, strlen(internum), offset, buf) < 0)
// return -1;
// if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
// (unsigned char*) "INTERMEDIATE", 12, offset, buf) < 0)
// return -1;
// }
// #endif
#ifdef USE_NFN_REQUESTS
if (name->nfnflags & CCNL_PREFIX_REQUEST) {
if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
(unsigned char*) name->request->comp,
name->request->complen, offset, buf) < 0)
return -1;
// if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
// (unsigned char*) "STOP", 4, offset, buf) < 0)
// return -1;
if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent,
(unsigned char*) "R2C", 3, offset, buf) < 0)
return -1;
}
#endif
#endif
for (cnt = name->compcnt - 1; cnt >= 0; cnt--) {
if (ccnl_ndntlv_prependBlob(NDN_TLV_NameComponent, name->comp[cnt],
name->complen[cnt], offset, buf) < 0)
return -1;
}
if (ccnl_ndntlv_prependTL(NDN_TLV_Name, oldoffset - *offset,
offset, buf) < 0)
return -1;
return 0;
}
// ----------------------------------------------------------------------
int
ccnl_ndntlv_prependInterest(struct ccnl_prefix_s *name, int scope, struct ccnl_ndntlv_interest_opts_s *opts,
int *offset, unsigned char *buf)
{
int oldoffset = *offset;
if (scope >= 0) {
if (scope > 2)
return -1;
if (ccnl_ndntlv_prependNonNegInt(NDN_TLV_Scope, scope, offset, buf) < 0)
return -1;
}
/* only include InterestLifetime TLV Guider, if life time > 0 milli seconds */
if (opts->interestlifetime) {
if (ccnl_ndntlv_prependNonNegInt(NDN_TLV_InterestLifetime,
opts->interestlifetime, offset, buf) < 0)
return -1;
}
if (ccnl_ndntlv_prependBlob(NDN_TLV_Nonce, (unsigned char*) &opts->nonce, 4,
offset, buf) < 0)
return -1;
/* MustBeFresh is the only supported Selector for now */
if (opts->mustbefresh) {
int sel_offset = *offset;
if (ccnl_ndntlv_prependTL(NDN_TLV_MustBeFresh, 0, offset, buf) < 0)
return -1;
if (ccnl_ndntlv_prependTL(NDN_TLV_Selectors, sel_offset - *offset, offset, buf) < 0)
return -1;
}
if (ccnl_ndntlv_prependName(name, offset, buf))
return -1;
if (ccnl_ndntlv_prependTL(NDN_TLV_Interest, oldoffset - *offset,
offset, buf) < 0)
return -1;
return oldoffset - *offset;
}
int
ccnl_ndntlv_prependContent(struct ccnl_prefix_s *name,
unsigned char *payload, int paylen,
int *contentpos, struct ccnl_ndntlv_data_opts_s *opts,
int *offset, unsigned char *buf)
{
int oldoffset = *offset, oldoffset2;
unsigned char signatureType = NDN_VAL_SIGTYPE_DIGESTSHA256;
if (contentpos)
*contentpos = *offset - paylen;
// fill in backwards
// mandatory (empty for now)
if (ccnl_ndntlv_prependTL(NDN_TLV_SignatureValue, 0, offset, buf) < 0)
return -1;
// to find length of SignatureInfo
oldoffset2 = *offset;
// KeyLocator is not required for DIGESTSHA256
if (signatureType != NDN_VAL_SIGTYPE_DIGESTSHA256) {
if (ccnl_ndntlv_prependTL(NDN_TLV_KeyLocator, 0, offset, buf) < 0)
return -1;
}
// use NDN_SigTypeVal_SignatureSha256WithRsa because this is default in ndn client libs
if (ccnl_ndntlv_prependBlob(NDN_TLV_SignatureType, &signatureType, 1,
offset, buf) < 0)
return 1;
// Groups KeyLocator and Signature Type with stored len
if (ccnl_ndntlv_prependTL(NDN_TLV_SignatureInfo, oldoffset2 - *offset, offset, buf) < 0)
return -1;
// mandatory
if (ccnl_ndntlv_prependBlob(NDN_TLV_Content, payload, paylen,
offset, buf) < 0)
return -1;
// to find length of optional (?) MetaInfo fields
oldoffset2 = *offset;
if(opts) {
if (opts->finalblockid != UINT32_MAX) {
if (ccnl_ndntlv_prependIncludedNonNegInt(NDN_TLV_NameComponent,
opts->finalblockid,
NDN_Marker_SegmentNumber,
offset, buf) < 0)
return -1;
// optional
if (ccnl_ndntlv_prependTL(NDN_TLV_FinalBlockId, oldoffset2 - *offset,
offset, buf) < 0)
return -1;
}
if (opts->freshnessperiod) {
if (ccnl_ndntlv_prependNonNegInt(NDN_TLV_FreshnessPeriod,
opts->freshnessperiod, offset, buf) < 0)
return -1;
}
}
// mandatory (empty for now)
if (ccnl_ndntlv_prependTL(NDN_TLV_MetaInfo, oldoffset2 - *offset,
offset, buf) < 0)
return -1;
// mandatory
if (ccnl_ndntlv_prependName(name, offset, buf))
return -1;
// mandatory
if (ccnl_ndntlv_prependTL(NDN_TLV_Data, oldoffset - *offset,
offset, buf) < 0)
return -1;
if (contentpos)
*contentpos -= *offset;
return oldoffset - *offset;
}
#ifdef USE_FRAG
// produces a full FRAG packet. It does not write, just read the fields in *fr
struct ccnl_buf_s*
ccnl_ndntlv_mkFrag(struct ccnl_frag_s *fr, unsigned int *consumed)
{
unsigned char test[20];
int offset, hdrlen;
int datalen;
struct ccnl_buf_s *buf;
uint16_t tmp = 0;
DEBUGMSG(TRACE, "ccnl_ndntlv_mkFrag seqno=%d\n", fr->sendseq);
// pre-compute overhead, first
datalen = fr->bigpkt->datalen - fr->sendoffs;
if (datalen > fr->mtu)
datalen = fr->mtu;
offset = sizeof(test);
hdrlen = ccnl_ndntlv_prependTL(NDN_TLV_NdnlpFragment, datalen,
&offset, test);
hdrlen += ccnl_ndntlv_prependTL(NDN_TLV_Frag_BeginEndFields, 2,
&offset, test) + 2;
hdrlen += ccnl_ndntlv_prependTL(NDN_TLV_Fragment, hdrlen + datalen,
&offset, test);
// with real values:
datalen = fr->bigpkt->datalen - fr->sendoffs;
if (datalen > (fr->mtu - hdrlen))
datalen = fr->mtu - hdrlen;
buf = ccnl_buf_new(NULL, datalen + hdrlen);
if (!buf)
return 0;
offset = buf->datalen - datalen;
memcpy(buf->data + offset,
fr->bigpkt->data + fr->sendoffs, datalen);
ccnl_ndntlv_prependTL(NDN_TLV_NdnlpFragment, datalen,
&offset, buf->data);
tmp = fr->sendseq & 0x03fff;
if (datalen >= fr->bigpkt->datalen) { // single
tmp |= CCNL_DTAG_FRAG_FLAG_SINGLE << 14;
} else if (fr->sendoffs == 0) // start
tmp |= CCNL_DTAG_FRAG_FLAG_FIRST << 14;
else if((unsigned) datalen >= (fr->bigpkt->datalen - fr->sendoffs)) { // end
tmp |= CCNL_DTAG_FRAG_FLAG_LAST << 14;
} else
tmp |= CCNL_DTAG_FRAG_FLAG_MID << 14; // middle
offset -= 2;
*(uint16_t*) (buf->data + offset) = htons(tmp);
tmp = ccnl_ndntlv_prependTL(NDN_TLV_Frag_BeginEndFields, 2,
&offset, buf->data);
tmp = ccnl_ndntlv_prependTL(NDN_TLV_Fragment, buf->datalen - offset,
&offset, buf->data);
if (offset > 0) {
buf->datalen -= offset;
memmove(buf->data, buf->data + offset, buf->datalen);
}
*consumed = datalen;
return buf;
}
#endif // USE_FRAG
#endif // NEEDS_PACKET_CRAFTING
#endif // USE_NDNTLV
// eof
|
the_stack_data/111959.c | #include <stdio.h>
void print(int *n, int *sum) {
printf("%d_____\t%d____\t%s\n", *n, *sum, (*n >= 99) ? "YES" : "NO");
}
void add(int *n, int *sum) {
++*n;
*sum += *n;
print(n, sum);
}
void subtract(int *n, int *sum) {
++*n;
*sum -= *n;
print(n, sum);
}
int main(int argc, char **argv) {
int n = 0, sum = 0;
printf("n______\tsum____\tn >= 99\n\n");
subtract(&n, &sum);
while (!(n >= 99)) {
add(&n, &sum);
subtract(&n, &sum);
}
printf("\n%d\n", sum);
getchar();
return 0;
} |
the_stack_data/454.c | /* Dummy Engine
* skin and bones, just whats needed to compile
* compile flags:
* gcc -g -Wall -fPIC -o dummy.o -c dummy.c
* gcc -g -Wall -shared -Wl,-soname,dummy.so -o dummy.so dummy.o
*/
#include <stdio.h>
#include <string.h>
#ifdef WIN32
#include <windows.h>
#endif
#ifndef WIN32
#define WINAPI // empty on *nix
#endif
/* board values */
#define OCCUPIED 0 // un_occupied dark squares
#define WHITE 1
#define BLACK 2
#define MAN 4
#define KING 8
#define FREE 16 // the light squares, always _free
#define CHANGECOLOR 3
/* getmove return values */
#define DRAW 0
#define WIN 1
#define LOSS 2
#define UNKNOWN 3
/* types */
typedef struct // coordinate structure for board coordinates
{
int x;
int y;
} coor;
typedef struct // all the information there is about a move
{
int jumps; // how many jumps are there in this move?
int newpiece; // what type of piece appears on to
int oldpiece; // what disappears on from
coor from, to; // coordinates of the piece in 8x8 notation!
coor path[12]; // intermediate path coordinates
coor del[12]; // squares whose pieces are deleted
int delpiece[12]; // what is on these squares
} CBmove;
/* function prototypes */
int WINAPI getmove (int b[8][8], int color, double maxtime, char str[255],
int *playnow, int info, int unused, CBmove * move);
int WINAPI enginecommand (char command[256], char reply[256]);
int WINAPI islegal (int b[8][8], int color, int from, int to, CBmove * move);
/* dll/dso stuff */
#ifdef WIN32
BOOL WINAPI
DllEntryPoint (HANDLE hDLL, DWORD dwReason, LPVOID lpReserved)
{
/* in a dll you used to have LibMain instead of WinMain in
windows programs, or main in normal C programs win32
replaces LibMain with DllEntryPoint. */
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
/* dll loaded. put initializations here! */
break;
case DLL_PROCESS_DETACH:
/* program is unloading dll. put clean up here! */
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
default:
break;
}
return TRUE;
}
#endif // WIN32
/* CheckerBoard API: enginecommand(), islegal(), getmove() */
int WINAPI
enginecommand (char str[256], char reply[256])
{
/* answer to commands sent by CheckerBoard. This does not
* answer to some of the commands, eg it has no engine
* options. */
char command[256], param1[256], param2[256];
sscanf (str, "%s %s %s", command, param1, param2);
// check for command keywords
// by default, return "i don't understand this"
sprintf (reply, "?");
if (strcmp (command, "name") == 0)
{
sprintf (reply, "dummy engine 1.0");
return 1;
}
if (strcmp (command, "about") == 0)
{
sprintf (reply, "dummy Engine\n\n2003 Public Domain");
return 1;
}
if (strcmp (command, "help") == 0)
{
sprintf (reply, "missing.htm");
return 1;
}
if (strcmp (command, "set") == 0)
{
if (strcmp (param1, "hashsize") == 0)
{
return 0;
}
if (strcmp (param1, "book") == 0)
{
return 0;
}
}
if (strcmp (command, "get") == 0)
{
if (strcmp (param1, "hashsize") == 0)
{
return 0;
}
if (strcmp (param1, "book") == 0)
{
return 0;
}
if (strcmp (param1, "protocolversion") == 0)
{
sprintf (reply, "2");
return 1;
}
if (strcmp (param1, "gametype") == 0)
{
sprintf (reply, "21");
return 1;
}
}
return 0;
}
int WINAPI
islegal (int b[8][8], int color, int from, int to, CBmove * move)
{
/* islegal tells CheckerBoard if a move the user wants to
* make is legal or not. to check this, we generate a
* movelist and compare the moves in the movelist to the
* move the user wants to make with from&to */
return 0;
}
int WINAPI
getmove (int b[8][8], int color, double maxtime, char str[255], int *playnow,
int info, int unused, CBmove * move)
{
/* getmove is what checkerboard calls. you get the parameters:
- b[8][8]
is the current position. the values in the array are
determined by the #defined values of BLACK, WHITE, KING,
MAN. a black king for instance is represented by BLACK|KING.
- color
is the side to make a move. BLACK or WHITE.
- maxtime
is the time your program should use to make a move. this
is what you specify as level in checkerboard. so if you
exceed this time it's not too bad - just don't exceed it
too much...
- str
is a pointer to the output string of the checkerboard status bar.
you can use sprintf(str,"information"); to print any information you
want into the status bar.
- *playnow
is a pointer to the playnow variable of checkerboard. if
the user would like your engine to play immediately, this
value is nonzero, else zero. you should respond to a
nonzero value of *playnow by interrupting your search
IMMEDIATELY.
- CBmove
tells checkerboard what your move is, see above.
*/
strcpy(str, "This is just a dummy");
return 9;
}
|
the_stack_data/758323.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*
forward_diff function receives from the calling program the name fn of
an external function program, the argument x and the step delta
and must return as the forward difference approximation to the
derivative of the function fn calculated at x with step size delta.
*/
double forward_diff(double (*fn)(double), double x, double delta)
{
return (fn(x+delta)-fn(x))/delta;
}
/*
center_diff function receives from the calling program the name fn of
an external function program, the argument x and the step delta
and must return as the central difference approximation to the
derivative of the function fn calculated at x with step size delta
(to avoid any possible confusion, this means that fn will be evaluated
at x-delta and x+delta).
*/
double center_diff(double (*fn)(double), double x, double delta)
{
return (fn(x+delta)-fn(x-delta))/(2*delta);
}
/*
second_deriv function receives from the calling program the name fn of
an external function program, the argument x and the step delta
and must return the approximation to the second derivative
of the function fn at x based on the values taken by fn at x and
at the nearest neighbor points x+dx, x-dx.
*/
double second_deriv(double (*fn)(double), double x, double delta)
{
return (fn(x+delta)+fn(x-delta)-2*fn(x))/(delta*delta);
}
/*
trap_integrate function receives from the calling program the name fn of
an external function program and the lower and upper limits of an
integration domain, x0 and xn, and must return the approximation
to the integral of fn over the interval x0,xn given by the trapezoidal
formula based on a subdivision of the interval of integration into n
equal subintervals.
*/
double trap_integrate(double (*fn)(double), double x0, double xn, int n)
{
double ti=0.;
double delta;
delta = (xn-x0)/(double)n;
for(int i = 1; i < n; i++)
{
ti += delta*fn(x0+i*delta);
}
ti += delta/2*(fn(x0)+fn(xn));
return ti;
}
/*
simpson_integrate function receives from the calling program the name fn of
an external function program and the lower and upper limits of an
integration domain, x0 and xn, and must return the approximation
to the integral of fn over the interval x0, xn given by Simpson's
formula based on a subdivision of the interval of integration into
2*n equal subintervals.
*/
double simpson_integrate(double (*fn)(double), double x0, double xn, int n)
{
double si=0.;
double delta;
delta = (xn-x0)/(2.*(double)n);
for(int i = 1; i < 2*n; i++)
{
if(i & 1)
{
si += 4*fn(x0+i*delta);
}
else
{
si += 2*fn(x0+i*delta);
}
}
si = delta/3.*(si+fn(x0)+fn(xn));
return si;
}
/*
evolve_decay receives from the calling program the initial mass of
matter M, the decay rate lambda, the time step dt, and the number of
steps nsteps to evolve the system. The function should then evolve M by
nsteps steps using the Euler method, and return the final value of M.
*/
double evolve_decay(double M, double lambda, double dt, int nsteps)
{
for(int i = 0; i < nsteps; i++)
{
M = M*(1.-lambda*dt);
}
return M;
}
|
the_stack_data/206392222.c | //
// Created by pedram pakseresht on 2/18/21.
//
// #include <petsc.h>
#include <printf.h>
#include <stdlib.h>
void setNumber(double *zxy);
typedef struct{
double x;
double z;
int g[3];
}Pstruct;
void printStruct(Pstruct str) {
printf("print struct %f %f %d %d %d \n", str.x, str.z, str.g[0], str.g[1], str.g[2]);
// printf("print x %lf \n", str.z );
// printf("print x %lf \n", str.g[1] );
};
void setValues(){
}
int main( int argc, char *argv[] )
{
Pstruct a;
a.x = 7.0;
a.z = 8.0;
a.g[0] = 1;
a.g[1] = 2;
a.g[2] = 3;
Pstruct b;
b.x = 5.0;
b.z = 4.0;
b.g[0] = 3;
b.g[1] = 1;
b.g[2] = 2;
printStruct(a);
printStruct(b);
// printf("x of b is %lf \n",b.x);
//printf("size of struc %lu \n", sizeof(Pstruct));
//printf("size of int %lu", sizeof(int [4]));
}
|
the_stack_data/248579997.c | #include "stdio.h"
int main()
{
int customer_code, sms, time;
float total_cost, fpa;
printf("Insert your customer code,your talk time is seconds and your sms number.\n");
scanf("%d%d%d", &customer_code, &sms, &time);
total_cost = 1.23*(12 + sms*0.14 + 0.02*time);
fpa = 0.23*(12 + sms*0.14 + 0.02*time);
printf("Customer code time\tSMS\tFPA\t\t|\tTOTAL\n%d\t\t%d\t%d\t%f\t|\t%f\n", customer_code,time,sms,fpa,total_cost);
return 0;
}
|
the_stack_data/20449458.c | ///////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT NOTICE
//
// The following open source license statement does not apply to any
// entity in the Exception List published by FMSoft.
//
// For more information, please visit:
//
// https://www.fmsoft.cn/exception-list
//
//////////////////////////////////////////////////////////////////////////////
static const unsigned char rime_kbd_data[] = {
0x89, 0x50, 0x4e, 0x47, 0xd, 0xa,
0x1a, 0xa, 0x0, 0x0, 0x0, 0xd,
0x49, 0x48, 0x44, 0x52, 0x0, 0x0,
0x1, 0x40, 0x0, 0x0, 0x0, 0x78,
0x8, 0x2, 0x0, 0x0, 0x0, 0xc,
0xac, 0xbc, 0x89, 0x0, 0x0, 0x0,
0x9, 0x70, 0x48, 0x59, 0x73, 0x0,
0x0, 0xb, 0x13, 0x0, 0x0, 0xb,
0x13, 0x1, 0x0, 0x9a, 0x9c, 0x18,
0x0, 0x0, 0x0, 0x7, 0x74, 0x49,
0x4d, 0x45, 0x7, 0xd8, 0x7, 0x12,
0x3, 0x0, 0x33, 0xc7, 0x1f, 0xa8,
0xa9, 0x0, 0x0, 0x20, 0x0, 0x49,
0x44, 0x41, 0x54, 0x78, 0xda, 0xec,
0xbd, 0x69, 0xb8, 0x65, 0x57, 0x55,
0x28, 0x3a, 0xc6, 0x6c, 0x56, 0xb7,
0x9b, 0xd3, 0x54, 0x9b, 0xa4, 0x52,
0x29, 0x2a, 0x21, 0x10, 0x42, 0x2,
0x26, 0x21, 0xa4, 0x21, 0x34, 0x31,
0x12, 0xc, 0xe2, 0xa5, 0x13, 0xd,
0x48, 0x4, 0x22, 0x82, 0x82, 0x28,
0xf, 0xae, 0xf2, 0xee, 0x43, 0x9f,
0x22, 0x5e, 0x24, 0xb4, 0x5e, 0x51,
0x11, 0x88, 0xf4, 0x8, 0x1a, 0xc8,
0xe3, 0x89, 0x81, 0x48, 0x77, 0x3,
0x1, 0x4c, 0x94, 0x24, 0x80, 0x10,
0x21, 0x86, 0x10, 0x52, 0x95, 0xea,
0x4e, 0xb3, 0xbb, 0xd5, 0xcd, 0x66,
0x8c, 0xf7, 0x63, 0xee, 0xbd, 0xce,
0xae, 0x73, 0x4e, 0x75, 0x31, 0x82,
0x8f, 0xaf, 0xe6, 0xb7, 0xbf, 0xf5,
0x9d, 0x6f, 0x9e, 0xbd, 0x67, 0xb7,
0xe6, 0xe8, 0x3b, 0xbc, 0xe4, 0xd2,
0xa7, 0x38, 0x67, 0x9c, 0x23, 0x44,
0xd6, 0x3a, 0x16, 0x2, 0xbc, 0x67,
0xef, 0x6d, 0x14, 0x25, 0xc7, 0xd4,
0xf, 0x20, 0x0, 0x48, 0x6b, 0x3d,
0x1c, 0xe, 0xe7, 0xe7, 0xe7, 0x97,
0x96, 0x16, 0xa5, 0x94, 0x33, 0xdd,
0xae, 0xab, 0x3c, 0x0, 0x84, 0xff,
0x4e, 0x3f, 0x93, 0x24, 0x1b, 0xc,
0x7a, 0x71, 0x9c, 0x3a, 0x67, 0xa2,
0x28, 0x19, 0x8d, 0x6, 0x1b, 0x37,
0x6e, 0x3e, 0x70, 0x60, 0x5f, 0x9a,
0xb6, 0x56, 0x7d, 0x33, 0x3c, 0x11,
0xe5, 0xba, 0xfd, 0x87, 0x7a, 0x26,
0x49, 0xd6, 0xef, 0x2f, 0x3, 0x88,
0xd9, 0xd9, 0xae, 0x31, 0xae, 0xaa,
0x8a, 0x28, 0x4a, 0x86, 0xc3, 0x7e,
0xbb, 0xdd, 0x3d, 0xa6, 0x71, 0xe,
0xf3, 0x2c, 0x8a, 0xd1, 0xe6, 0xcd,
0x5b, 0x97, 0x96, 0x16, 0xb2, 0xac,
0x5d, 0xd7, 0x25, 0xa2, 0xd4, 0x5a,
0x3a, 0x6f, 0x60, 0x4d, 0x43, 0x90,
0x3f, 0xb2, 0xf5, 0xc, 0x87, 0xc3,
0xc3, 0x7c, 0x4d, 0x8, 0x95, 0xa6,
0x71, 0x55, 0x99, 0xd1, 0x68, 0xa0,
0x54, 0x14, 0xc7, 0x9a, 0x8, 0x1e,
0xac, 0x5, 0x1c, 0x7e, 0x5e, 0xef,
0x2d, 0x33, 0x4a, 0x89, 0x42, 0x28,
0x66, 0xcf, 0x8c, 0x0, 0x64, 0xad,
0x4f, 0x92, 0x48, 0x4a, 0xcd, 0xec,
0x17, 0x17, 0x97, 0x37, 0x6f, 0xde,
0xd8, 0xeb, 0xd, 0xb2, 0x4e, 0xe6,
0x1c, 0x31, 0x12, 0xb0, 0x80, 0x83,
0x9f, 0x4c, 0x8, 0xeb, 0xf5, 0x23,
0x48, 0x38, 0x96, 0xef, 0x2b, 0x85,
0x75, 0x5d, 0x7b, 0x4f, 0x59, 0x96,
0x2d, 0x2f, 0x2f, 0x6f, 0xdc, 0xb8,
0x11, 0x11, 0xf3, 0xbc, 0x44, 0x44,
0x0, 0x0, 0x16, 0xab, 0xde, 0xa0,
0x90, 0xeb, 0x9f, 0x92, 0xf7, 0x2c,
0x25, 0x4a, 0xa9, 0x89, 0x9c, 0xb5,
0x9e, 0xd9, 0x2b, 0x15, 0x29, 0x25,
0xbc, 0xe7, 0x1f, 0xcd, 0x44, 0xea,
0xe7, 0x9f, 0xfe, 0x6c, 0x63, 0xaa,
0xba, 0xb6, 0xde, 0x5b, 0x29, 0xb5,
0x52, 0x42, 0x8, 0x85, 0xc8, 0xab,
0x7a, 0xc2, 0x40, 0xeb, 0xf6, 0xc7,
0x71, 0xda, 0x8c, 0x20, 0x4, 0x58,
0x6b, 0xa5, 0xc2, 0x76, 0xbb, 0xed,
0xbd, 0x37, 0xa5, 0x49, 0x74, 0xb,
0x0, 0xd7, 0xb9, 0xd3, 0x88, 0x51,
0x14, 0x9, 0x21, 0x96, 0x97, 0x97,
0xa5, 0x94, 0x4a, 0xa9, 0xa5, 0xa5,
0xa5, 0x6d, 0xdb, 0xb6, 0x55, 0x55,
0x5, 0xeb, 0x35, 0x66, 0x86, 0x63,
0x69, 0xcc, 0x9c, 0x24, 0x89, 0x10,
0x62, 0xef, 0xde, 0xbd, 0x69, 0x9a,
0x66, 0x59, 0x76, 0xe0, 0xc0, 0x81,
0xd9, 0xd9, 0xd9, 0xf1, 0xc1, 0xfd,
0x87, 0x9b, 0x10, 0xa2, 0xaa, 0xaa,
0x38, 0x8e, 0x95, 0x52, 0x88, 0xd8,
0xef, 0xf7, 0x67, 0x67, 0x67, 0xeb,
0xba, 0x92, 0xe8, 0x1, 0x69, 0xd5,
0x97, 0x3d, 0x45, 0x3f, 0xb2, 0xf5,
0x1c, 0xfe, 0x6b, 0x5a, 0xeb, 0xb2,
0x2c, 0x85, 0x10, 0x5a, 0xeb, 0xba,
0xae, 0x9d, 0x73, 0x52, 0x4a, 0x66,
0x8e, 0xa2, 0xe8, 0xc1, 0x5a, 0x6,
0x22, 0x32, 0x33, 0x11, 0x81, 0xc0,
0x35, 0x6f, 0x8d, 0x4b, 0x93, 0xeb,
0x48, 0x2a, 0xa5, 0xca, 0xb2, 0x74,
0x96, 0x84, 0x10, 0xad, 0x56, 0x47,
0x29, 0x35, 0x1c, 0xe6, 0xc0, 0xcd,
0x51, 0xac, 0x5c, 0x6b, 0x62, 0xbb,
0xee, 0x85, 0xe, 0x88, 0x9e, 0x8,
0x9c, 0x33, 0xde, 0xb3, 0x10, 0x10,
0xc7, 0x69, 0x14, 0x29, 0x63, 0xcc,
0xda, 0xce, 0x7e, 0x7f, 0xb8, 0xf6,
0x27, 0x69, 0x1a, 0xff, 0x47, 0x7e,
0x7e, 0xf8, 0x9f, 0x4c, 0x77, 0xfe,
0xa7, 0x4e, 0x84, 0xbf, 0xf7, 0xfa,
0xb7, 0xa, 0x21, 0x94, 0x52, 0x5a,
0x6b, 0x44, 0xf4, 0xde, 0x57, 0x55,
0x85, 0x88, 0xab, 0x7a, 0x8c, 0x31,
0x51, 0x14, 0xad, 0xdb, 0xaf, 0xb5,
0x6e, 0x46, 0x60, 0xf6, 0x88, 0x6c,
0x8c, 0x69, 0xb5, 0x53, 0x6b, 0x6d,
0x3e, 0x2a, 0x23, 0x19, 0xe1, 0x1a,
0x34, 0x3, 0x0, 0x4a, 0x29, 0x6b,
0xad, 0x10, 0xc2, 0x18, 0xd3, 0xed,
0x76, 0x9d, 0x73, 0xe1, 0xc5, 0x3b,
0xe7, 0x1e, 0x14, 0x0, 0x46, 0x44,
0x22, 0xa, 0xb, 0x93, 0x52, 0x3a,
0xe7, 0xac, 0xb5, 0x51, 0x14, 0x59,
0x6b, 0x1f, 0x94, 0x9b, 0x4a, 0x44,
0x4a, 0x29, 0xef, 0xbd, 0xd6, 0xda,
0x7b, 0x5f, 0xd7, 0x75, 0xa7, 0xd3,
0x19, 0x8e, 0xfa, 0x69, 0xa4, 0xd7,
0x3, 0x60, 0xfd, 0x23, 0x5b, 0x8f,
0x10, 0xe2, 0x30, 0x5f, 0x53, 0x4a,
0x55, 0x55, 0xa5, 0x94, 0xa, 0x27,
0xaf, 0xb5, 0x4e, 0x92, 0xc4, 0x18,
0xe3, 0xbd, 0x7f, 0x50, 0x96, 0xc1,
0xcc, 0x52, 0x4a, 0x44, 0x74, 0xce,
0x81, 0x58, 0x8b, 0x9b, 0xc8, 0xb1,
0xd3, 0x91, 0xd4, 0x5a, 0x5b, 0x6b,
0x23, 0x9d, 0x54, 0x95, 0xa9, 0xaa,
0x2a, 0xcf, 0xcb, 0xb9, 0xd9, 0xf9,
0x9, 0xdc, 0x4e, 0xd6, 0x1f, 0x48,
0x2b, 0x7a, 0xc0, 0x75, 0x5e, 0x7d,
0x51, 0x14, 0x51, 0x14, 0x5, 0x4,
0xca, 0xcc, 0xd6, 0x5a, 0xe7, 0x1c,
0x11, 0x21, 0xe2, 0xda, 0x4e, 0xad,
0xf5, 0xda, 0x9f, 0x14, 0x45, 0x11,
0xc7, 0x71, 0x5d, 0xd7, 0x87, 0x19,
0xa4, 0x28, 0x8a, 0x43, 0xfd, 0xfc,
0xf0, 0x33, 0x4e, 0x77, 0x86, 0x89,
0x1e, 0xf0, 0x3a, 0x8f, 0x30, 0xd1,
0x6b, 0x5f, 0xff, 0x36, 0x22, 0xa,
0xe0, 0x11, 0x10, 0x73, 0x14, 0x45,
0xa3, 0xd1, 0x68, 0x55, 0x8f, 0x94,
0xd2, 0x7b, 0xbf, 0x6e, 0xff, 0x70,
0x38, 0x6c, 0x46, 0x48, 0xd2, 0x78,
0x66, 0xa6, 0xf3, 0xcc, 0x67, 0x3e,
0x7d, 0xf3, 0xc6, 0x19, 0x0, 0x60,
0x0, 0x24, 0x40, 0xe0, 0xf5, 0x50,
0x35, 0xd6, 0xb5, 0x49, 0xe2, 0xc8,
0x58, 0x27, 0xd7, 0xbe, 0x21, 0xa1,
0xfe, 0xc3, 0xa4, 0x0, 0x11, 0xc0,
0x13, 0x7b, 0xef, 0x8b, 0xa2, 0x48,
0xd3, 0x34, 0x8e, 0xf4, 0x70, 0x94,
0x67, 0x59, 0xf6, 0xa0, 0xdc, 0x54,
0xef, 0x7d, 0xa4, 0xd5, 0xfa, 0x8b,
0x7, 0x10, 0xa8, 0xf, 0xba, 0xb6,
0xc8, 0x3f, 0xba, 0xf5, 0x48, 0x79,
0xc4, 0xaf, 0x39, 0x4f, 0x55, 0x55,
0x65, 0x59, 0xd6, 0x80, 0x98, 0x27,
0x7e, 0x50, 0x96, 0x61, 0xad, 0xd,
0xf8, 0xdd, 0x39, 0x17, 0xa8, 0xf1,
0x41, 0xe0, 0xd, 0xd8, 0x80, 0xe7,
0x81, 0xc5, 0xc1, 0x27, 0x3e, 0xf1,
0xff, 0x2c, 0x2f, 0xf7, 0xbd, 0x23,
0x0, 0x40, 0x94, 0xc0, 0x62, 0x2,
0xbd, 0xb8, 0x82, 0x10, 0x20, 0x50,
0xe0, 0xd5, 0xad, 0xd3, 0xe9, 0x4,
0x24, 0x68, 0xad, 0xd, 0xd8, 0x47,
0x8, 0x21, 0x84, 0x48, 0xd3, 0x74,
0x6d, 0xe7, 0xba, 0x3f, 0xe9, 0x74,
0x3a, 0x61, 0xb5, 0x87, 0x19, 0x84,
0x99, 0xf, 0xf5, 0xf3, 0xc3, 0xcf,
0x38, 0xdd, 0x19, 0x26, 0x7a, 0xc0,
0xeb, 0x3c, 0xfc, 0x4f, 0x14, 0x33,
0xa, 0xa1, 0x84, 0x10, 0x81, 0xed,
0x29, 0xcb, 0x7a, 0x34, 0x2a, 0x2,
0xb3, 0x37, 0xdd, 0xc3, 0xcc, 0x88,
0xb8, 0x6e, 0x7f, 0x92, 0x24, 0xcd,
0x8, 0xcb, 0xcb, 0xcb, 0x45, 0x31,
0xea, 0x74, 0x3a, 0xc, 0xc0, 0x0,
0xce, 0x92, 0x96, 0xc4, 0xb8, 0xe,
0x51, 0x35, 0xd6, 0xa9, 0x48, 0x79,
0x30, 0x84, 0x56, 0xc2, 0x6a, 0xfe,
0x8d, 0xb0, 0xfe, 0x8f, 0x5e, 0x68,
0x62, 0x6b, 0x6d, 0x16, 0x67, 0x40,
0xdc, 0x69, 0xa5, 0x0, 0xe0, 0x9d,
0xcd, 0x92, 0x8, 0xc8, 0x3d, 0x28,
0x37, 0x55, 0x22, 0x78, 0x67, 0xe5,
0x21, 0xf8, 0x5f, 0xe2, 0x83, 0xe8,
0x2a, 0x9, 0xff, 0xa3, 0x5b, 0xcf,
0x61, 0x7, 0xc, 0x5f, 0x43, 0x80,
0x34, 0xd6, 0xec, 0xed, 0x83, 0x43,
0x76, 0xa7, 0x59, 0x74, 0x89, 0x40,
0x8e, 0x1, 0x24, 0x2, 0x70, 0x8d,
0xb0, 0xa, 0x80, 0x55, 0x55, 0x43,
0x12, 0x2b, 0x0, 0x68, 0xb5, 0x5a,
0xbb, 0x77, 0xef, 0x76, 0x8e, 0x10,
0x84, 0x10, 0x22, 0x8a, 0x12, 0xe0,
0x70, 0x6b, 0x0, 0x0, 0xc7, 0xc2,
0x21, 0x12, 0x33, 0xaf, 0x4b, 0x81,
0xf7, 0xed, 0x3b, 0x20, 0x84, 0x8,
0xc2, 0x97, 0xd6, 0x2a, 0x30, 0x38,
0x44, 0xb4, 0xbc, 0xdc, 0x5f, 0xdb,
0x69, 0x8c, 0x91, 0x52, 0xe, 0x6,
0xa3, 0x80, 0x53, 0x10, 0xa5, 0x10,
0x38, 0x1a, 0x15, 0x0, 0x50, 0xd7,
0x16, 0x0, 0xea, 0xba, 0xe, 0xa3,
0x21, 0x4a, 0x44, 0xd1, 0xc, 0x22,
0x4, 0x1e, 0xea, 0xe7, 0xcc, 0xcc,
0xc, 0x45, 0x51, 0x55, 0x95, 0x39,
0xfc, 0x32, 0xea, 0xda, 0x12, 0x11,
0x33, 0x3a, 0x47, 0x61, 0xa, 0x22,
0x5e, 0x77, 0x9d, 0x81, 0xa, 0x1e,
0xd3, 0xd6, 0x94, 0x67, 0x62, 0x62,
0xf0, 0xc0, 0x61, 0x45, 0x0, 0x42,
0x49, 0xeb, 0xdd, 0xaa, 0x9e, 0x31,
0x7e, 0x5d, 0xaf, 0x7f, 0x7a, 0x84,
0x28, 0x8a, 0x80, 0x28, 0x51, 0x42,
0x38, 0x1b, 0xae, 0xb, 0x10, 0x0,
0xac, 0x43, 0x13, 0x22, 0x94, 0xe0,
0x1, 0x0, 0x34, 0xac, 0x23, 0x7d,
0x9, 0x2f, 0x1f, 0x84, 0x3b, 0x2d,
0x15, 0x39, 0x86, 0xff, 0x2, 0x2d,
0x6c, 0xe7, 0xbf, 0xce, 0x7a, 0x7e,
0x54, 0x4d, 0xad, 0x92, 0x7b, 0x10,
0x58, 0x23, 0x80, 0x7, 0x4f, 0x94,
0x28, 0x29, 0x0, 0xa3, 0x28, 0x22,
0xcf, 0x42, 0x49, 0x46, 0xc8, 0x8b,
0x61, 0x60, 0xe9, 0xeb, 0xb2, 0xb2,
0xd6, 0x46, 0x4a, 0x23, 0x22, 0x33,
0x76, 0x3a, 0x9d, 0xe1, 0x70, 0x38,
0x1a, 0x8d, 0x3a, 0xdd, 0x6e, 0x14,
0x45, 0xb5, 0x29, 0x85, 0x10, 0x52,
0x2b, 0x0, 0xf0, 0xec, 0xac, 0x73,
0x12, 0x90, 0x5, 0x8a, 0xa0, 0x36,
0x92, 0xe2, 0x28, 0x3b, 0xc1, 0x81,
0x10, 0x22, 0xc8, 0x35, 0xab, 0x46,
0x6b, 0xbe, 0xaf, 0x50, 0x1c, 0xfe,
0xe7, 0xf, 0x70, 0x19, 0x52, 0x3c,
0x58, 0x63, 0xaa, 0x0, 0x8a, 0x3c,
0x69, 0x8d, 0x0, 0xb9, 0xaa, 0xe7,
0x30, 0xfd, 0xd3, 0x23, 0x8, 0x42,
0x1, 0xc0, 0x7e, 0x5a, 0xd, 0x71,
0xbc, 0x1d, 0x6f, 0x53, 0x30, 0x2d,
0x0, 0xd8, 0x2a, 0x4, 0x0, 0x8f,
0xec, 0x3d, 0x31, 0x11, 0xb2, 0x87,
0xca, 0x38, 0x46, 0x14, 0x42, 0x38,
0xe7, 0x84, 0x80, 0x34, 0x8d, 0x5,
0xa0, 0x31, 0xc6, 0x5a, 0x9f, 0xe7,
0x22, 0x8a, 0xa2, 0x8d, 0x1b, 0x37,
0x7a, 0xa2, 0xe1, 0x70, 0xe8, 0xc9,
0xb6, 0x5a, 0xad, 0x70, 0xeb, 0x3c,
0x30, 0x30, 0x78, 0x4, 0x64, 0x20,
0x44, 0x60, 0x6, 0x3e, 0xda, 0xce,
0xaa, 0xac, 0x5a, 0xad, 0x56, 0x59,
0x96, 0x6b, 0x47, 0x7b, 0xd3, 0xef,
0x3c, 0x8f, 0x6, 0xff, 0xce, 0xd5,
0x3e, 0xb6, 0xa3, 0x1f, 0xd7, 0x41,
0xa1, 0x6e, 0x63, 0xb2, 0x45, 0x74,
0x4f, 0xfb, 0x9d, 0x37, 0x7d, 0xf0,
0x30, 0xbb, 0x50, 0xce, 0xb9, 0x69,
0x8, 0xc, 0x50, 0x1a, 0x44, 0x97,
0xe9, 0x9e, 0x6, 0x80, 0xd7, 0xf6,
0x7, 0xe6, 0x39, 0xf4, 0xab, 0xc0,
0x3f, 0xf2, 0xf1, 0x8b, 0x7a, 0xbc,
0x1d, 0x95, 0xe2, 0xcd, 0x31, 0x79,
0x7, 0xe0, 0x91, 0x51, 0x6, 0x25,
0x9c, 0x31, 0x86, 0xbd, 0x23, 0xa2,
0x4e, 0xab, 0x7d, 0xe2, 0x89, 0x27,
0xee, 0xd9, 0xb3, 0xa7, 0x28, 0x6,
0x52, 0x4a, 0x22, 0xaa, 0x8c, 0xed,
0x76, 0xbb, 0xed, 0x38, 0x5b, 0x58,
0x58, 0x48, 0x5b, 0x19, 0x0, 0xf8,
0x95, 0x1b, 0x2b, 0x1, 0x18, 0x11,
0x81, 0xdc, 0x51, 0x76, 0xce, 0xcc,
0xcc, 0x2c, 0x2c, 0x2c, 0x6c, 0xdc,
0xb8, 0x71, 0xd5, 0x68, 0x6f, 0xff,
0xfd, 0x97, 0xb8, 0xfb, 0xfe, 0xfe,
0xc7, 0x7e, 0x38, 0x6c, 0x47, 0x6c,
0x47, 0x34, 0xbc, 0xfb, 0xd, 0x57,
0x9f, 0xfd, 0xdf, 0xdf, 0xf9, 0xcd,
0x43, 0xed, 0x42, 0x5, 0xce, 0x7b,
0x15, 0x51, 0xd, 0x30, 0x39, 0xdd,
0x33, 0xad, 0x8d, 0x58, 0x58, 0x58,
0x0, 0x8f, 0x75, 0x5d, 0xb7, 0x3b,
0x59, 0x9e, 0xe7, 0x49, 0x92, 0x4,
0xfd, 0xff, 0xdc, 0xdc, 0xc, 0xa2,
0x44, 0x71, 0x1c, 0x7c, 0x8f, 0xb7,
0xa3, 0x55, 0x59, 0x33, 0x8f, 0x25,
0x5f, 0x62, 0xaa, 0xeb, 0x1a, 0x99,
0x93, 0x24, 0x41, 0x29, 0xea, 0xba,
0xde, 0xba, 0x75, 0xeb, 0x13, 0x9e,
0xf0, 0x84, 0x8f, 0x7f, 0xe2, 0xba,
0xda, 0x54, 0x52, 0x89, 0x44, 0xc7,
0x8e, 0x7c, 0x59, 0xe6, 0x44, 0x4e,
0x4a, 0xc, 0xf7, 0x96, 0xc6, 0x9c,
0x1e, 0x23, 0x72, 0xa0, 0x3b, 0xec,
0xfd, 0x51, 0x76, 0x96, 0x65, 0x2e,
0x25, 0x86, 0x67, 0x33, 0xda, 0xff,
0xfa, 0x83, 0x97, 0xb8, 0xdd, 0x37,
0xfe, 0x58, 0x4e, 0xc3, 0x7a, 0xfc,
0xda, 0xf7, 0xb3, 0x41, 0x25, 0x1,
0xa0, 0x9b, 0xf8, 0xb, 0x77, 0x16,
0x5a, 0x32, 0x0, 0x70, 0xb9, 0xf7,
0xad, 0xaf, 0xbd, 0xfa, 0x95, 0x7f,
0xf4, 0xd7, 0xeb, 0xee, 0x42, 0x3e,
0xe6, 0xa2, 0x27, 0xd2, 0x9a, 0x16,
0xd4, 0x54, 0x87, 0xea, 0x34, 0xc6,
0xb4, 0xb3, 0xec, 0x92, 0x4b, 0x1e,
0xf7, 0xc2, 0x17, 0x5c, 0x55, 0x95,
0xc5, 0xc2, 0xe2, 0x82, 0x35, 0x35,
0xa, 0xa9, 0x94, 0x64, 0x4f, 0xe4,
0xdd, 0x45, 0x17, 0x5d, 0x18, 0x47,
0xc7, 0x79, 0xe8, 0xe3, 0xed, 0x8,
0xed, 0x33, 0x37, 0x7e, 0xde, 0x11,
0xfb, 0x31, 0x59, 0x11, 0x52, 0x4a,
0x67, 0xad, 0xf7, 0xde, 0x3b, 0x97,
0xe7, 0xf9, 0x96, 0xcd, 0x5b, 0x2e,
0xba, 0xf8, 0xc2, 0x9f, 0xb9, 0xec,
0xa2, 0xd9, 0xb9, 0xf9, 0xdd, 0xbb,
0xef, 0xdb, 0xbb, 0x77, 0xaf, 0x8a,
0xa4, 0x54, 0xca, 0x39, 0xaf, 0xb5,
0x36, 0xd6, 0x91, 0x7, 0xcf, 0x40,
0xc4, 0xe4, 0x81, 0x9, 0x99, 0x80,
0x9, 0xc8, 0xd9, 0xa3, 0xed, 0xf4,
0x55, 0x50, 0x41, 0x37, 0xa3, 0xfd,
0xd9, 0x1f, 0xfd, 0xba, 0xdb, 0x7d,
0x23, 0xd0, 0x6a, 0x57, 0x9c, 0x51,
0x51, 0x7f, 0xf0, 0x93, 0xb7, 0xdd,
0x75, 0xef, 0xc2, 0x86, 0xd9, 0xac,
0xd3, 0x8a, 0x1, 0xe0, 0xda, 0xeb,
0x6e, 0xdd, 0x73, 0x60, 0x70, 0xfa,
0x8e, 0x4d, 0xf, 0xd6, 0x51, 0xdc,
0xb7, 0xac, 0x6f, 0xfd, 0x41, 0x56,
0xda, 0x31, 0xd4, 0xd4, 0x4e, 0xfc,
0x70, 0x29, 0x8a, 0x15, 0xcf, 0xa4,
0x4, 0x0, 0x7e, 0x78, 0xcf, 0x15,
0x4f, 0xfb, 0x85, 0x4f, 0x7d, 0xf6,
0xd6, 0xb5, 0xbb, 0x10, 0xbc, 0x5e,
0x6b, 0x20, 0x36, 0x58, 0xb1, 0xca,
0xbc, 0x18, 0xf6, 0x7, 0xf9, 0x70,
0x54, 0x97, 0xd5, 0xa8, 0xd7, 0x4b,
0x94, 0x3a, 0xef, 0xbc, 0x73, 0x2e,
0xbf, 0xfc, 0x67, 0x36, 0x6c, 0x98,
0x9, 0x96, 0xdb, 0xa0, 0x7b, 0x8,
0x3f, 0xf4, 0xde, 0x1f, 0xca, 0x96,
0x7b, 0xbc, 0x1d, 0x6f, 0x7, 0x59,
0xa, 0xbc, 0xf7, 0xde, 0x87, 0xcb,
0x16, 0xbc, 0xf, 0x82, 0x7f, 0x41,
0x30, 0x99, 0x68, 0xad, 0x89, 0x68,
0xb9, 0x57, 0x9c, 0x7b, 0xde, 0xd9,
0x57, 0x5c, 0x71, 0xc5, 0xb6, 0x6d,
0x27, 0x96, 0x65, 0x59, 0x96, 0xb9,
0x31, 0xa6, 0xaa, 0x2a, 0xe0, 0xe9,
0xab, 0x8b, 0xeb, 0xdd, 0xe2, 0x23,
0x74, 0x86, 0x71, 0xa6, 0x47, 0x73,
0xf7, 0xfd, 0xfd, 0x2a, 0xe8, 0xfd,
0x87, 0x9b, 0xee, 0xbc, 0xe8, 0xca,
0x77, 0xfc, 0xc6, 0xeb, 0xae, 0xbf,
0xfa, 0xd9, 0xe7, 0x3f, 0xfe, 0xbc,
0x87, 0xbc, 0xfd, 0x3, 0x5f, 0xbe,
0xe8, 0xca, 0x77, 0x0, 0xc0, 0xb5,
0x1f, 0xbf, 0xf5, 0x86, 0x9b, 0xfe,
0xed, 0xc1, 0x22, 0xbc, 0x37, 0x7e,
0xa7, 0xf3, 0x8d, 0x5d, 0x29, 0xbb,
0xfa, 0xbf, 0x3d, 0xed, 0x29, 0x97,
0x3d, 0xe9, 0x71, 0xed, 0x54, 0x87,
0xfe, 0x6f, 0xec, 0x4a, 0x6f, 0xfc,
0x4e, 0xc7, 0x7a, 0x44, 0xb6, 0xee,
0xbe, 0xbf, 0xbf, 0xe6, 0xff, 0x7c,
0xde, 0xda, 0x5d, 0xa8, 0x0, 0x6c,
0xd3, 0x5c, 0xf4, 0x2a, 0xdb, 0x9d,
0x52, 0x2a, 0xd6, 0x2a, 0xcf, 0x73,
0xa9, 0x60, 0x7e, 0xc3, 0xcc, 0x59,
0x67, 0x5e, 0xfc, 0xa4, 0x27, 0x3d,
0x61, 0xd3, 0xc6, 0x76, 0xaf, 0x5f,
0x13, 0x43, 0x51, 0x14, 0xcc, 0x1c,
0xc7, 0xb1, 0xb1, 0x56, 0xca, 0xc8,
0x39, 0x7, 0x64, 0x95, 0x52, 0xc7,
0x6f, 0xe7, 0xf1, 0x76, 0xc4, 0x66,
0x8c, 0x61, 0xa9, 0xa4, 0x88, 0x9c,
0x73, 0x52, 0xea, 0xb2, 0x2c, 0xbd,
0xb5, 0xd6, 0x5a, 0x48, 0x62, 0xe7,
0xdc, 0x68, 0x34, 0x4a, 0x53, 0x5d,
0xd7, 0x34, 0xe8, 0x97, 0x67, 0x9f,
0xf5, 0xb0, 0x13, 0x4e, 0x38, 0xe9,
0xba, 0x4f, 0x7c, 0xfc, 0xb6, 0xdb,
0xee, 0xd0, 0xa, 0xa2, 0x28, 0x72,
0xde, 0x0, 0xb, 0xf, 0x4, 0x0,
0x8, 0x84, 0x28, 0xc7, 0xf7, 0x96,
0xfc, 0x51, 0x76, 0x7a, 0xe7, 0xa2,
0x28, 0x72, 0xe1, 0xe9, 0xd, 0xac,
0xe7, 0x6e, 0x74, 0xed, 0x75, 0xb7,
0xb6, 0xb3, 0xe8, 0x2f, 0x7e, 0xff,
0x19, 0x0, 0x70, 0xc2, 0xa6, 0xee,
0x1b, 0x5f, 0xf5, 0xd4, 0x3d, 0x7,
0x6, 0xab, 0xbe, 0xf0, 0xb1, 0x4f,
0xdf, 0x31, 0x2a, 0xcc, 0x9f, 0xbc,
0xea, 0x8a, 0xc7, 0x9f, 0xb7, 0x13,
0x0, 0xbe, 0xf4, 0x2f, 0xdf, 0x7f,
0xcd, 0x5b, 0x6e, 0xf8, 0xa9, 0x33,
0x4e, 0xfa, 0xed, 0x5f, 0xb9, 0xe4,
0xa1, 0xa7, 0x6c, 0x5c, 0xfb, 0x85,
0x55, 0xed, 0x9e, 0xc5, 0xc8, 0xfa,
0x0, 0x71, 0x58, 0x16, 0x65, 0x67,
0x76, 0xd3, 0x45, 0x17, 0x9e, 0xff,
0xaf, 0xb7, 0xdf, 0x72, 0xff, 0xb2,
0xb, 0x60, 0x7c, 0xcf, 0x62, 0x74,
0xfa, 0xe6, 0x1a, 0x0, 0x86, 0x7b,
0xbf, 0x19, 0xa0, 0x75, 0x7a, 0x17,
0x62, 0x15, 0x93, 0xbc, 0x8a, 0xfc,
0x6, 0x43, 0x36, 0x11, 0x49, 0x29,
0xad, 0xb5, 0x27, 0x9e, 0xb8, 0x75,
0x2, 0xbd, 0xa5, 0x10, 0x20, 0x25,
0x4, 0xbf, 0x22, 0x63, 0x4c, 0x51,
0x14, 0xd6, 0xda, 0xe6, 0x87, 0xc7,
0x6f, 0xe7, 0xf1, 0x76, 0x34, 0x32,
0x70, 0x73, 0xf7, 0x0, 0x20, 0xdc,
0x9f, 0x40, 0x84, 0x8d, 0x31, 0xce,
0x39, 0xef, 0x81, 0x8, 0x66, 0x67,
0xd2, 0x3, 0xb, 0xa3, 0x2f, 0x7e,
0xf1, 0xa6, 0xfb, 0xef, 0xdf, 0x1b,
0xfc, 0xde, 0xc2, 0x9d, 0x24, 0x76,
0xcc, 0x9e, 0x99, 0x89, 0x3d, 0x91,
0x1b, 0x7f, 0x8e, 0xba, 0x33, 0x8c,
0x33, 0x3d, 0xda, 0xda, 0x15, 0xee,
0x5d, 0x18, 0x5e, 0xf1, 0x84, 0x33,
0xda, 0xd9, 0x8a, 0x83, 0xea, 0x9,
0x9b, 0xba, 0xcd, 0xdf, 0x6f, 0xff,
0xc0, 0x97, 0xaf, 0xfd, 0xf8, 0xad,
0xf, 0x3d, 0x65, 0xd3, 0xd5, 0xcf,
0x3a, 0xff, 0x35, 0x6f, 0xb9, 0xe1,
0x4b, 0xff, 0xf2, 0x7d, 0x0, 0x78,
0xfd, 0x5f, 0x7e, 0xee, 0x39, 0x3f,
0xfb, 0xa8, 0xbb, 0xee, 0x3d, 0xf0,
0xbd, 0x1f, 0x1c, 0x8, 0xb4, 0x7a,
0xd5, 0x17, 0x56, 0x4f, 0xd1, 0x1f,
0x53, 0x3b, 0x87, 0xf1, 0x57, 0x6e,
0xfe, 0xf2, 0xe2, 0xbe, 0xdd, 0xad,
0x99, 0xcd, 0xe7, 0x3e, 0xe6, 0x7c,
0x45, 0xc5, 0xaa, 0x2f, 0xb4, 0xe4,
0x68, 0xed, 0x2e, 0xc6, 0x5a, 0xe8,
0xc3, 0xa8, 0xac, 0xb2, 0xb4, 0xcd,
0x64, 0x94, 0x52, 0x52, 0xc1, 0xb7,
0xbe, 0xf5, 0xad, 0xfe, 0xf2, 0xd2,
0x15, 0x57, 0x5c, 0xf1, 0xc8, 0xb3,
0x1e, 0xd6, 0xef, 0x15, 0x65, 0x69,
0xdb, 0xed, 0x76, 0x50, 0x1e, 0x46,
0x51, 0x54, 0xd7, 0xb5, 0x46, 0x29,
0xc0, 0x7b, 0xef, 0x1, 0xf4, 0xf1,
0xb, 0x7a, 0xbc, 0x1d, 0x99, 0x85,
0x26, 0x66, 0x21, 0x3c, 0x53, 0x6d,
0xbd, 0xb5, 0xb6, 0x9d, 0x65, 0x52,
0x4a, 0x53, 0x57, 0x88, 0x18, 0x1c,
0xc5, 0xea, 0xca, 0x7d, 0xf0, 0xff,
0xbd, 0xe1, 0x96, 0x5b, 0x6e, 0x31,
0xc6, 0xe8, 0x38, 0xf1, 0xe, 0xbc,
0xe7, 0xa2, 0xa8, 0x18, 0x81, 0x99,
0x69, 0xe5, 0xc6, 0xca, 0xc0, 0x81,
0xb3, 0xb7, 0x47, 0xd9, 0x19, 0xc6,
0x99, 0x1e, 0x6d, 0xdd, 0x45, 0x76,
0xb2, 0x43, 0xba, 0x97, 0xff, 0xed,
0xa7, 0xbf, 0xf1, 0x53, 0x67, 0x9c,
0xf4, 0xe7, 0xbf, 0xff, 0xc, 0x0,
0xf8, 0xd8, 0xa7, 0xef, 0x78, 0xfb,
0xfb, 0xbf, 0xfc, 0xf8, 0xf3, 0x76,
0xb6, 0xb3, 0xb8, 0x93, 0xc5, 0xef,
0xff, 0x93, 0x5f, 0x3a, 0x61, 0x53,
0x77, 0xcf, 0x81, 0xc1, 0x69, 0xa7,
0x6c, 0xbc, 0xfa, 0xd9, 0xe7, 0x3,
0x40, 0xfb, 0xd3, 0x51, 0xf8, 0xc2,
0xaa, 0x41, 0x82, 0xd6, 0x2a, 0xb4,
0xbc, 0xa6, 0xbb, 0xbf, 0xf9, 0xe5,
0xd9, 0x4b, 0x7e, 0x56, 0xb5, 0xb6,
0x9c, 0x3a, 0x5f, 0x7f, 0xb7, 0x97,
0x4d, 0x7f, 0x21, 0x51, 0xde, 0xda,
0x7a, 0xd5, 0x2e, 0x54, 0x70, 0xcb,
0x5a, 0x11, 0x11, 0xa6, 0x2c, 0x43,
0xa1, 0xd, 0x47, 0xfd, 0xe9, 0xf9,
0x76, 0xed, 0xba, 0xff, 0x86, 0x1b,
0x6e, 0xa8, 0xeb, 0xfa, 0x31, 0xe7,
0x9d, 0x3d, 0x18, 0xfa, 0xba, 0xae,
0xf3, 0x3c, 0x57, 0x52, 0x4a, 0x21,
0x8d, 0xb5, 0x52, 0x20, 0xc0, 0x18,
0xa1, 0x1e, 0x6f, 0xc7, 0xdb, 0xe1,
0x1b, 0x11, 0xb1, 0x40, 0x22, 0x22,
0x26, 0xa9, 0xa2, 0x9, 0xd5, 0xf5,
0xe4, 0x6c, 0x9a, 0xa6, 0x88, 0xb8,
0xb8, 0xd8, 0xff, 0xfc, 0xe7, 0xbf,
0xf8, 0xf5, 0xaf, 0xdf, 0xd6, 0xef,
0xf, 0x83, 0x83, 0x21, 0x33, 0x87,
0x30, 0x8c, 0xe0, 0x44, 0x44, 0x0,
0xe1, 0xd2, 0x6, 0xad, 0x2c, 0x20,
0x1, 0x1d, 0x6d, 0x67, 0x18, 0x27,
0xb8, 0x43, 0x37, 0xae, 0x4a, 0xab,
0xda, 0xd6, 0x8d, 0x9d, 0x6b, 0x3f,
0x7e, 0xeb, 0xe3, 0x1f, 0xb3, 0xf3,
0xa1, 0xa7, 0x6c, 0xc, 0xda, 0xac,
0xdb, 0xbe, 0xb3, 0x7b, 0x5d, 0x4e,
0xb8, 0x69, 0x1f, 0x78, 0xe3, 0x2f,
0xfd, 0xc3, 0x4d, 0xff, 0xf6, 0xac,
0x57, 0x7c, 0xe0, 0x92, 0xf3, 0x1e,
0xf2, 0xdb, 0x57, 0x5d, 0x72, 0xc2,
0xa6, 0xce, 0x39, 0x8f, 0x38, 0x9,
0x0, 0xfe, 0xf1, 0xda, 0x5f, 0x5b,
0xf7, 0xfb, 0xdd, 0xc4, 0x37, 0x20,
0xfa, 0xb3, 0x17, 0x3c, 0x24, 0x39,
0xe1, 0xd1, 0x0, 0xb0, 0xfb, 0x6b,
0xef, 0xb9, 0xfd, 0xbe, 0x28, 0xeb,
0x8c, 0xbf, 0x10, 0xfe, 0x5b, 0x39,
0x19, 0x38, 0xdc, 0xe9, 0x5d, 0x88,
0xa0, 0x76, 0x6a, 0xd4, 0x9, 0x7e,
0xaa, 0x35, 0xfe, 0x99, 0xd3, 0xc8,
0xa9, 0xb2, 0xfc, 0xef, 0xf7, 0xec,
0xfe, 0xbb, 0xbf, 0xbb, 0xfe, 0x8f,
0xff, 0xe7, 0xdb, 0xef, 0xdf, 0xbd,
0x87, 0x88, 0x66, 0x67, 0xe7, 0xb6,
0x6c, 0xdd, 0x32, 0x37, 0x3b, 0x67,
0xeb, 0xba, 0xb2, 0x95, 0x63, 0x3a,
0xce, 0x42, 0x1f, 0x6f, 0x47, 0xd3,
0x1c, 0x91, 0xf7, 0xc1, 0x3d, 0xdc,
0x3, 0xb9, 0x0, 0xbd, 0x0, 0x20,
0x94, 0x36, 0xc6, 0xdd, 0xfc, 0xd5,
0xaf, 0xbd, 0xee, 0xf5, 0x7f, 0x7c,
0xe3, 0x3f, 0x7e, 0x6e, 0x38, 0x2a,
0xa4, 0xd4, 0xb5, 0x71, 0x91, 0x4e,
0x9c, 0xa5, 0x10, 0xbe, 0xd6, 0xdc,
0x55, 0x62, 0xe7, 0xbd, 0xf7, 0x64,
0x3d, 0xd9, 0x63, 0xea, 0xc, 0xe3,
0x4c, 0x8f, 0xb6, 0x76, 0x85, 0xaf,
0xfd, 0xf5, 0xcb, 0x0, 0xe0, 0x65,
0xaf, 0xfb, 0xc4, 0x6d, 0xdf, 0xd9,
0xfd, 0xf, 0x37, 0xdd, 0x79, 0xd5,
0xef, 0x7e, 0xf4, 0x35, 0x6f, 0xb9,
0xa1, 0xf9, 0xef, 0x73, 0x7e, 0xf6,
0x51, 0xb7, 0xdf, 0xb9, 0xfb, 0x65,
0xaf, 0xbb, 0xfe, 0xda, 0xeb, 0x6e,
0x1d, 0x15, 0xe6, 0xb7, 0x7f, 0xe5,
0x92, 0x51, 0x51, 0xff, 0xc6, 0xeb,
0xae, 0xf, 0x72, 0x72, 0x27, 0x8b,
0x4f, 0xd8, 0xd4, 0xfd, 0xf2, 0xbf,
0xdc, 0x13, 0xbe, 0xf0, 0xe4, 0xab,
0xdf, 0x75, 0xdb, 0x77, 0x76, 0xaf,
0x83, 0x23, 0x66, 0x56, 0x58, 0xf7,
0x68, 0xf3, 0x99, 0x0, 0xf0, 0xef,
0x9f, 0x7b, 0xdb, 0x3f, 0x7e, 0xf2,
0xba, 0xac, 0xd3, 0x59, 0xf5, 0x85,
0xa5, 0x42, 0xaf, 0xdd, 0x85, 0xb2,
0xc6, 0x37, 0xf0, 0x36, 0xe5, 0x89,
0x15, 0xb4, 0x59, 0xfe, 0x50, 0xac,
0xf5, 0x52, 0x7f, 0x18, 0x47, 0xc9,
0x17, 0xbe, 0xf0, 0x85, 0x3d, 0x7b,
0xf6, 0xa2, 0x80, 0x5e, 0xbf, 0x8f,
0x52, 0xf5, 0x7, 0xcb, 0xb3, 0xb3,
0xdd, 0xe5, 0x7e, 0x49, 0xf2, 0x38,
0x0, 0x1f, 0x6f, 0x47, 0x6e, 0x4b,
0xbd, 0xe5, 0xf9, 0xf9, 0xf9, 0xa2,
0x18, 0x31, 0xa3, 0xf7, 0x5e, 0x4b,
0xac, 0x6d, 0x13, 0x3d, 0xe, 0x20,
0x93, 0xbc, 0x76, 0x52, 0x2b, 0x47,
0x1e, 0x10, 0xc8, 0xbb, 0xfe, 0x70,
0x0, 0x0, 0x51, 0x9c, 0xd6, 0x66,
0x1c, 0x9d, 0xd3, 0x5c, 0x57, 0x6,
0x0, 0x60, 0x44, 0x68, 0xb8, 0xbf,
0x23, 0x76, 0x86, 0x71, 0xd6, 0x8e,
0x36, 0xdd, 0xce, 0x79, 0xc4, 0x49,
0xef, 0xf8, 0xbd, 0x67, 0xbc, 0xfe,
0x2f, 0x3f, 0xf7, 0xf2, 0x3f, 0xba,
0x3e, 0x10, 0xe4, 0x3f, 0x79, 0xd5,
0x15, 0xcd, 0x7f, 0x7f, 0xfb, 0xaa,
0x4b, 0x3a, 0x59, 0xfc, 0xb1, 0x4f,
0xdf, 0x71, 0xfb, 0x9d, 0xbb, 0x1b,
0x1d, 0xd5, 0x13, 0xce, 0xdb, 0x79,
0xed, 0xc7, 0x6f, 0xd, 0x4a, 0x2c,
0x0, 0xb8, 0xfa, 0x59, 0xe7, 0x87,
0x2f, 0x5c, 0xfd, 0xac, 0xf3, 0x3,
0x29, 0x5e, 0xd5, 0x76, 0x6e, 0x30,
0xf7, 0x2c, 0x8c, 0xf5, 0x58, 0xdf,
0xb8, 0xe3, 0xb6, 0x78, 0xe9, 0x5f,
0x6e, 0xfb, 0xec, 0x87, 0xb2, 0x47,
0xbf, 0x2a, 0xfc, 0x57, 0x4b, 0xde,
0xb9, 0x61, 0xac, 0x18, 0xdf, 0x33,
0x48, 0xc9, 0xd2, 0xaa, 0x5d, 0xe0,
0x73, 0x7e, 0xe5, 0x15, 0xd3, 0x4a,
0x85, 0xf0, 0xc, 0x84, 0xb7, 0xd9,
0xd2, 0x34, 0x84, 0x87, 0x7f, 0x25,
0x69, 0x14, 0x60, 0xdb, 0x7b, 0xf,
0xcc, 0x44, 0x5c, 0xd7, 0x15, 0x20,
0xa6, 0x69, 0x6a, 0xea, 0xc1, 0x9f,
0xfd, 0xaf, 0xb7, 0xcf, 0xb7, 0x93,
0xe3, 0x17, 0xf4, 0x78, 0x3b, 0x7c,
0xfb, 0x95, 0x5f, 0x7b, 0x79, 0xab,
0xd5, 0xea, 0xf5, 0x6, 0xdd, 0xee,
0xec, 0x28, 0x2f, 0x0, 0x80, 0x40,
0xad, 0x0, 0x70, 0xf8, 0x8b, 0xe9,
0x50, 0xa, 0xb0, 0xe6, 0x8a, 0x4e,
0xc3, 0x5e, 0x3, 0x8a, 0x47, 0xec,
0x5c, 0xeb, 0xe, 0xfc, 0x9e, 0xd7,
0x3e, 0x31, 0x13, 0xeb, 0xfb, 0x4e,
0xde, 0xf6, 0x9d, 0xdd, 0x9d, 0x56,
0x1c, 0x18, 0xe9, 0x7, 0xbd, 0xed,
0x5a, 0xd6, 0x77, 0xec, 0x4a, 0xc7,
0x9a, 0xf9, 0xa5, 0x3d, 0x32, 0x9b,
0x91, 0xc9, 0x38, 0x46, 0xed, 0xd1,
0xdb, 0xca, 0x6d, 0x73, 0x16, 0x0,
0x96, 0xcb, 0xe8, 0xb6, 0xdd, 0x73,
0x7f, 0xfd, 0x37, 0x37, 0xac, 0xda,
0x85, 0x6a, 0x38, 0x87, 0x69, 0x28,
0xd, 0x7f, 0x37, 0x81, 0x69, 0xd,
0x60, 0x87, 0xb3, 0x8, 0xea, 0x87,
0xe6, 0x6b, 0x9e, 0xc8, 0x18, 0x83,
0x42, 0x84, 0x80, 0xe1, 0xad, 0x5b,
0xb7, 0x7e, 0xfb, 0x5f, 0xef, 0xbc,
0xe4, 0x82, 0x9f, 0x3a, 0x7e, 0x41,
0x8f, 0xb7, 0xc3, 0xb7, 0xf9, 0xf9,
0x8d, 0x8b, 0x8b, 0x8b, 0x4a, 0x45,
0xfd, 0x7e, 0x1f, 0x50, 0x0, 0x8,
0xa, 0x1, 0x2e, 0x30, 0xd, 0x5a,
0x47, 0x6, 0xe0, 0xe9, 0x3f, 0xe,
0xa6, 0xcc, 0x87, 0xeb, 0x5c, 0xb,
0xc0, 0x2f, 0x7a, 0xdd, 0x17, 0xfe,
0xe0, 0x95, 0xbf, 0x78, 0x6a, 0xe7,
0x7, 0x7a, 0x8d, 0x37, 0xe1, 0xba,
0xc4, 0xf3, 0xc1, 0x6a, 0xdb, 0xe6,
0xec, 0xb6, 0x39, 0xeb, 0x3c, 0x7e,
0xf5, 0xfb, 0xd9, 0x60, 0xfe, 0x84,
0x20, 0xf7, 0x5e, 0xb4, 0xb3, 0x50,
0x13, 0x4e, 0xf6, 0x96, 0x1f, 0xce,
0x8f, 0x8c, 0x9e, 0x9f, 0x9f, 0x6f,
0xa0, 0xb5, 0xd9, 0x85, 0x9a, 0x6,
0xce, 0xb5, 0x30, 0xbc, 0xaa, 0xb3,
0xf9, 0xa5, 0x35, 0x62, 0xaa, 0x13,
0xb5, 0x8a, 0x99, 0x99, 0x9, 0x1d,
0xd1, 0x77, 0xbe, 0xf3, 0x6f, 0xbd,
0xa5, 0xfe, 0xf7, 0xbe, 0xf7, 0xbd,
0xd3, 0x4f, 0x3f, 0xfd, 0x94, 0x53,
0x4e, 0x41, 0x66, 0x67, 0x6a, 0x29,
0xf5, 0xdc, 0xdc, 0x4c, 0xbf, 0x3f,
0x1c, 0x8d, 0x6, 0xed, 0x76, 0x37,
0xcf, 0x87, 0x1b, 0x36, 0x6c, 0xea,
0xf5, 0x96, 0x94, 0x8a, 0xda, 0xed,
0xcc, 0x18, 0x17, 0xb2, 0xae, 0x94,
0x65, 0x9e, 0x65, 0xed, 0x3c, 0x1f,
0xb6, 0x5a, 0x1d, 0x21, 0x60, 0xff,
0xfe, 0x85, 0x4d, 0x9b, 0x36, 0x18,
0xe3, 0xa4, 0xc4, 0x90, 0x81, 0xe5,
0xe8, 0x73, 0xb8, 0xe4, 0x79, 0xc9,
0xec, 0xa3, 0x28, 0xe9, 0x74, 0x5a,
0xc6, 0xb8, 0xba, 0x2e, 0x43, 0xe6,
0x10, 0x29, 0x35, 0x0, 0x45, 0x51,
0x92, 0xe7, 0x43, 0xad, 0x63, 0x63,
0xaa, 0x85, 0x85, 0xa5, 0x6d, 0xdb,
0x4e, 0x74, 0x8e, 0x8e, 0x69, 0x7c,
0x44, 0xd9, 0xef, 0x2f, 0xef, 0xdc,
0x79, 0x5a, 0x55, 0x15, 0xf7, 0xdc,
0x73, 0xef, 0xc6, 0x8d, 0xf3, 0x4a,
0x45, 0x88, 0xdc, 0xef, 0xf, 0xb7,
0x6f, 0xdf, 0x76, 0xe0, 0xc0, 0xa2,
0x10, 0x30, 0x33, 0x33, 0xb7, 0xb8,
0x78, 0x0, 0x40, 0xb4, 0x5a, 0xa9,
0x31, 0xce, 0x7b, 0x6b, 0xad, 0x8f,
0x22, 0x15, 0x32, 0xcb, 0x20, 0xca,
0x24, 0x89, 0x7e, 0xf8, 0xc3, 0x5d,
0x9d, 0x4e, 0x6b, 0xdb, 0xb6, 0xed,
0xfd, 0xfe, 0x72, 0xaf, 0x37, 0x98,
0x9f, 0x9f, 0xd5, 0x3a, 0x6e, 0x52,
0x17, 0xd, 0x6, 0x23, 0x6b, 0xeb,
0x34, 0x6d, 0x49, 0x89, 0xde, 0x73,
0xc8, 0x41, 0xb3, 0x79, 0xf3, 0xc6,
0xb2, 0xac, 0x97, 0x97, 0x17, 0x95,
0x8a, 0x98, 0xbd, 0x94, 0x7a, 0xc3,
0x86, 0xb9, 0x85, 0x85, 0x25, 0x22,
0x67, 0x8c, 0x43, 0xc4, 0x4e, 0xa7,
0xc5, 0x8c, 0xde, 0xdb, 0x24, 0xc9,
0xee, 0xbf, 0x7f, 0xd7, 0x49, 0x27,
0x9d, 0x5c, 0x55, 0x45, 0x59, 0xd6,
0xde, 0xdb, 0x56, 0xab, 0xd3, 0x24,
0x57, 0xf1, 0x9e, 0x89, 0x1c, 0xa2,
0x54, 0x4a, 0x20, 0xca, 0xba, 0x2e,
0x99, 0x31, 0x8a, 0x94, 0x52, 0x11,
0x91, 0x23, 0x2, 0x44, 0x16, 0x42,
0xd5, 0x75, 0x19, 0x45, 0x49, 0x14,
0xa9, 0xe1, 0x30, 0x17, 0x2, 0xc2,
0xc2, 0x94, 0x8a, 0xfa, 0xfd, 0xe5,
0xcd, 0x9b, 0xb7, 0x3a, 0x67, 0x7a,
0xbd, 0xc1, 0xe6, 0xcd, 0x1b, 0x95,
0x8a, 0x16, 0x16, 0xf6, 0x23, 0xa2,
0x52, 0x11, 0x0, 0x84, 0x5c, 0x4b,
0x1, 0x7c, 0x9a, 0x73, 0x63, 0x4,
0x47, 0xb4, 0x77, 0xef, 0xde, 0xbb,
0xee, 0xba, 0xeb, 0x8b, 0x5f, 0xbc,
0x69, 0xcf, 0xbe, 0xbd, 0x52, 0xca,
0x2d, 0x5b, 0x4e, 0x10, 0x28, 0x7d,
0xb8, 0x80, 0x63, 0xd0, 0xe5, 0x75,
0xe9, 0xe4, 0x5a, 0x0, 0x6e, 0xee,
0x64, 0xa3, 0x7f, 0x9d, 0x76, 0x67,
0x38, 0x62, 0xe7, 0xda, 0xd1, 0x4e,
0x79, 0xe8, 0xa3, 0xbf, 0x71, 0x47,
0x7e, 0xde, 0x89, 0xfb, 0x7f, 0xf4,
0xe8, 0x4c, 0x49, 0x7e, 0xfc, 0x43,
0xf3, 0xb5, 0xfd, 0xcb, 0x65, 0x34,
0x32, 0x5a, 0x29, 0xf5, 0xf0, 0x87,
0x3f, 0x3c, 0x90, 0xcf, 0xe9, 0x5d,
0xe0, 0xd3, 0xaf, 0x7c, 0xe9, 0x5a,
0x28, 0xd, 0x5a, 0xe8, 0x90, 0x6c,
0x65, 0xd5, 0x56, 0xc3, 0xcf, 0x42,
0xea, 0x80, 0xb5, 0xe7, 0x8, 0x0,
0xc3, 0xe1, 0x62, 0xac, 0xa3, 0x90,
0x52, 0x60, 0x71, 0xf1, 0x0, 0x12,
0x6e, 0xd8, 0x30, 0x57, 0x96, 0x75,
0x48, 0xbe, 0x13, 0xb2, 0x67, 0xd,
0x87, 0xfd, 0x2c, 0x6b, 0x23, 0xb2,
0x73, 0x94, 0xe7, 0xc3, 0x93, 0x4f,
0x3e, 0x65, 0x34, 0x1a, 0xd4, 0xb5,
0x25, 0x72, 0x21, 0xd3, 0x8f, 0xd6,
0x71, 0x9e, 0xf, 0xd3, 0xb4, 0xd5,
0x64, 0xcc, 0x52, 0x2a, 0x3a, 0x26,
0x0, 0xcb, 0xb2, 0xf6, 0xf2, 0xf2,
0x22, 0xa2, 0x44, 0x64, 0x44, 0x99,
0xa6, 0xb1, 0xf7, 0x1c, 0x0, 0xd8,
0x39, 0x93, 0x65, 0xed, 0x38, 0xd6,
0x7b, 0xf6, 0xec, 0x63, 0xf6, 0x5b,
0xb6, 0x9c, 0x50, 0x14, 0xa3, 0x63,
0xcd, 0xb9, 0x35, 0x1c, 0xe6, 0x9b,
0x36, 0x6d, 0x70, 0x8e, 0x8c, 0xa9,
0x84, 0x50, 0x42, 0x40, 0x5d, 0xdb,
0x34, 0x8d, 0x11, 0x65, 0x59, 0xe6,
0x61, 0xa7, 0xde, 0x73, 0x1c, 0x6b,
0x63, 0x9c, 0xb5, 0x75, 0x14, 0x25,
0x52, 0x22, 0x11, 0x10, 0xb9, 0x38,
0x4e, 0xab, 0xaa, 0x20, 0x82, 0x24,
0x89, 0xe2, 0x38, 0x1d, 0xe, 0xfb,
0x21, 0x49, 0x4a, 0xa7, 0x33, 0x63,
0x4c, 0xd5, 0xef, 0xf, 0x4f, 0x3a,
0xe9, 0x84, 0xd1, 0xa8, 0x20, 0x72,
0x51, 0x94, 0x18, 0x53, 0xd, 0x6,
0xa3, 0x76, 0x3b, 0xcb, 0xb2, 0x76,
0xbf, 0xbf, 0x1c, 0xd0, 0x84, 0xd6,
0x31, 0xb3, 0xaf, 0x2a, 0x83, 0xc8,
0x71, 0x9c, 0x2, 0x50, 0x55, 0x19,
0xa5, 0xc4, 0xcc, 0xcc, 0x5c, 0x5d,
0xd7, 0x4b, 0x4b, 0xb, 0xad, 0x56,
0xa7, 0x2c, 0xf3, 0x28, 0x4a, 0x66,
0x67, 0xbb, 0x7, 0xe, 0x2c, 0x66,
0x59, 0x92, 0xe7, 0x65, 0xbb, 0x9d,
0x39, 0x47, 0x4a, 0x9, 0x22, 0xb0,
0xb6, 0x56, 0x2a, 0x4a, 0x92, 0xc8,
0x5a, 0x3f, 0x1a, 0xd, 0x92, 0x24,
0xb, 0x7, 0x15, 0x78, 0x2c, 0x22,
0x17, 0x80, 0xbc, 0x2c, 0xeb, 0xf9,
0xf9, 0xd9, 0xb2, 0xac, 0x89, 0x5c,
0x98, 0x14, 0x40, 0x58, 0x5b, 0x7,
0x1c, 0x14, 0xc7, 0x69, 0xd8, 0x9a,
0xf7, 0x76, 0x34, 0x2a, 0xb6, 0x6c,
0xd9, 0x54, 0x55, 0x15, 0xa2, 0x1c,
0x95, 0x45, 0xac, 0x64, 0x1c, 0xa7,
0x45, 0x51, 0xac, 0x3a, 0x37, 0x16,
0x32, 0x8e, 0xe3, 0xaa, 0xaa, 0xb4,
0xd6, 0xb5, 0x35, 0xe4, 0xd9, 0x18,
0x33, 0x37, 0x37, 0x57, 0x19, 0xb,
0x0, 0x74, 0x50, 0x14, 0x9b, 0x38,
0x22, 0xb, 0xbd, 0x96, 0x8, 0x37,
0x57, 0xfc, 0x88, 0x9d, 0x6b, 0x1,
0x38, 0xfc, 0xeb, 0x3, 0x7f, 0x75,
0xcd, 0x77, 0x6e, 0xfb, 0xdf, 0x27,
0x74, 0xcb, 0xf9, 0xcc, 0x26, 0xca,
0xff, 0xb8, 0xd8, 0x93, 0xca, 0xc9,
0xa5, 0x42, 0xef, 0x19, 0xa4, 0xbd,
0x2a, 0x52, 0x4a, 0x9d, 0x7f, 0xfe,
0xf9, 0xcf, 0xff, 0xb5, 0xff, 0xbe,
0x76, 0x17, 0xf8, 0xb4, 0xe7, 0xbc,
0xf8, 0x50, 0x43, 0x34, 0x0, 0xbc,
0xf6, 0xbc, 0x82, 0xaf, 0xd5, 0xba,
0xc4, 0xd9, 0xd9, 0x72, 0x25, 0x0,
0x1b, 0x19, 0x18, 0x7f, 0x22, 0x9f,
0x8, 0x62, 0xdd, 0x7e, 0x26, 0x78,
0x50, 0xc6, 0x39, 0xd4, 0xf3, 0x50,
0xe3, 0x37, 0xe3, 0x8c, 0x23, 0xe0,
0x7f, 0x5c, 0xdb, 0x67, 0x4e, 0xe2,
0xb4, 0xaa, 0xaa, 0x71, 0xcf, 0xba,
0x77, 0xa0, 0x1, 0x1b, 0x5c, 0x11,
0x77, 0x43, 0x37, 0xad, 0x9, 0x43,
0xfd, 0xb1, 0x84, 0xc6, 0xbc, 0xf6,
0x55, 0xbf, 0xba, 0xb4, 0xb4, 0xf4,
0x5f, 0x47, 0xd6, 0xb8, 0xe8, 0xa2,
0x8b, 0x7e, 0xf9, 0xc5, 0xaf, 0x5e,
0xf7, 0x5f, 0x87, 0x3, 0xe0, 0xc3,
0x34, 0xad, 0xf5, 0xa1, 0x88, 0xb3,
0xb7, 0xe, 0xa7, 0x18, 0x27, 0x46,
0xf8, 0x89, 0x6c, 0x87, 0x4a, 0x46,
0xf7, 0x0, 0x72, 0x77, 0x1d, 0xd3,
0xf7, 0xf, 0x35, 0xfe, 0xba, 0xa2,
0xdd, 0x8f, 0x7e, 0xfb, 0xd, 0xea,
0x7, 0x80, 0x75, 0x5d, 0xe2, 0x27,
0xc8, 0x5d, 0x1c, 0xc4, 0x28, 0x37,
0x0, 0xbc, 0x66, 0xd4, 0xe3, 0xb1,
0x6d, 0x87, 0x6f, 0xf, 0x30, 0x66,
0xe8, 0x30, 0x71, 0x4b, 0x7, 0x8f,
0x2c, 0xc6, 0x2e, 0xa6, 0x3f, 0x71,
0x4f, 0x26, 0xc, 0x62, 0xff, 0xaa,
0xe7, 0x83, 0x35, 0xce, 0xb1, 0x8e,
0xdf, 0x7c, 0xe7, 0xc7, 0xbb, 0xfd,
0xf0, 0x74, 0x96, 0x9c, 0x73, 0xeb,
0xfe, 0x96, 0x11, 0x18, 0x4, 0x23,
0x31, 0xc0, 0x38, 0xfb, 0x1f, 0x4e,
0xbc, 0x94, 0x19, 0x24, 0x93, 0x24,
0xf0, 0x95, 0xf1, 0x75, 0x25, 0x9,
0x24, 0x8d, 0xfb, 0xc7, 0x4f, 0x6,
0x31, 0xf5, 0xc1, 0xa9, 0xcf, 0xf8,
0x5a, 0xe2, 0xca, 0x67, 0xdd, 0xce,
0xf0, 0xf9, 0x89, 0x22, 0x24, 0xf,
0x8c, 0x2, 0x1f, 0x6e, 0x44, 0x16,
0xcd, 0xd9, 0x5, 0xb4, 0xfa, 0x13,
0x49, 0x84, 0x8f, 0x48, 0x9, 0xff,
0x83, 0xe3, 0x3c, 0x60, 0xca, 0xff,
0x60, 0xe5, 0xa9, 0xfd, 0x11, 0x2f,
0x7b, 0xba, 0x5, 0x5d, 0xeb, 0xba,
0x21, 0x31, 0x82, 0x56, 0x13, 0xed,
0x90, 0xb4, 0x69, 0x2d, 0x1, 0x97,
0xb4, 0x2e, 0x55, 0x27, 0x0, 0x10,
0xfc, 0x93, 0x13, 0xeb, 0xfa, 0x9f,
0x1a, 0x36, 0x84, 0xab, 0x34, 0x8a,
0xc7, 0xdb, 0xf1, 0x76, 0x34, 0x2d,
0x84, 0xc7, 0xac, 0xb, 0xc0, 0xb4,
0xe, 0xe8, 0x9, 0x41, 0xc1, 0xf3,
0x88, 0xc5, 0x14, 0xb5, 0x40, 0x5e,
0xa7, 0x13, 0x40, 0x30, 0xd2, 0xba,
0xbc, 0xfa, 0xb1, 0xc2, 0x36, 0x21,
0x1d, 0x2b, 0x22, 0x20, 0x3c, 0xc2,
0x14, 0xf, 0x60, 0x4c, 0x75, 0x4,
0x8e, 0x3a, 0x28, 0x1e, 0xe0, 0x18,
0x7c, 0x9b, 0x19, 0x21, 0x9c, 0xd1,
0xc1, 0xa, 0x8b, 0x35, 0xe3, 0x1f,
0x82, 0x2e, 0x1f, 0x9a, 0x7c, 0xf0,
0xaa, 0xb3, 0x3e, 0x92, 0x44, 0x70,
0xac, 0x84, 0xe8, 0xd8, 0xc6, 0xc7,
0x43, 0x49, 0x1f, 0x7c, 0x6c, 0xe3,
0xe3, 0xb1, 0xae, 0x9f, 0xe1, 0xf0,
0xe7, 0xc6, 0xeb, 0x2c, 0xfe, 0xc1,
0x3f, 0xf6, 0x63, 0x5f, 0xf6, 0xb1,
0x8d, 0x93, 0x44, 0xc9, 0x21, 0x76,
0xba, 0xce, 0x38, 0x8c, 0xd0, 0x6e,
0xb7, 0x97, 0x97, 0x97, 0xb5, 0x4e,
0xe, 0xbb, 0x51, 0x6a, 0x84, 0x70,
0xb9, 0x8e, 0x66, 0x4d, 0x1d, 0xe2,
0xf2, 0x4f, 0x8b, 0xee, 0x18, 0x72,
0x25, 0x3, 0xb0, 0x64, 0xb9, 0xe6,
0x65, 0xd0, 0xa1, 0x20, 0x22, 0x4c,
0x21, 0x58, 0x1d, 0xf2, 0x7f, 0xc8,
0x1, 0xb6, 0xd7, 0x4e, 0x34, 0x79,
0xae, 0x3f, 0x91, 0x3a, 0x38, 0xf,
0xf8, 0x9a, 0x37, 0x3d, 0x3e, 0x85,
0x23, 0xe5, 0x88, 0x44, 0x3e, 0xba,
0x6b, 0xf1, 0x80, 0x6f, 0x12, 0x1f,
0x1d, 0x40, 0x3e, 0x60, 0x0, 0xfe,
0x49, 0x1a, 0x5f, 0x4c, 0xbf, 0xe0,
0x83, 0x8f, 0xf9, 0xc8, 0xe7, 0x7f,
0xd8, 0xf7, 0x2b, 0x8e, 0x1, 0x81,
0x1e, 0xee, 0xfd, 0xca, 0x23, 0xa1,
0x25, 0x3a, 0x4, 0xa2, 0x12, 0x53,
0xdb, 0xc4, 0xe9, 0x71, 0x8a, 0xa2,
0x8e, 0xe3, 0xec, 0x48, 0x10, 0x25,
0x56, 0xff, 0x81, 0xcd, 0x13, 0xf,
0xb1, 0x6b, 0x1c, 0x8f, 0x33, 0x51,
0x11, 0x6, 0xb7, 0xea, 0x28, 0x4a,
0xd7, 0x5b, 0xff, 0x3a, 0xe7, 0xc3,
0x38, 0x35, 0xc9, 0xa1, 0xe0, 0xb,
0xa7, 0x65, 0x8d, 0x63, 0x23, 0xb,
0xea, 0x60, 0xe1, 0x84, 0xd7, 0x7b,
0x67, 0x47, 0x63, 0x17, 0xe5, 0xa3,
0x43, 0xe8, 0x47, 0x1e, 0x1f, 0xf9,
0x41, 0x1a, 0x1f, 0xfe, 0x93, 0xd7,
0xff, 0xff, 0x93, 0xf1, 0xf1, 0x20,
0x50, 0xfa, 0x89, 0x7f, 0xbf, 0x3c,
0xd6, 0x8a, 0xb1, 0x38, 0xea, 0x71,
0x9a, 0x19, 0x57, 0xad, 0xa, 0x56,
0x17, 0x55, 0x2, 0x0, 0x80, 0x7c,
0x38, 0xd4, 0x5a, 0x23, 0xa6, 0xff,
0x49, 0xe7, 0x7f, 0xac, 0xe7, 0xa3,
0x9c, 0x3d, 0x6c, 0xa, 0xf5, 0x35,
0x55, 0xa1, 0xe, 0xf9, 0x7c, 0x80,
0xca, 0x90, 0x35, 0x55, 0xaa, 0xf8,
0x50, 0xd7, 0xe8, 0x1, 0xab, 0xd9,
0x8f, 0xd2, 0x3d, 0xe3, 0x27, 0x70,
0xfc, 0x23, 0x53, 0xd9, 0x9f, 0xc0,
0xf7, 0xb, 0x93, 0xbf, 0x1f, 0xac,
0x71, 0xe, 0x5a, 0xe1, 0x9, 0x5b,
0x36, 0x97, 0x65, 0x69, 0x6d, 0xfd,
0x9f, 0x74, 0xfe, 0xc7, 0x7a, 0x3e,
0xea, 0x67, 0x2e, 0x7b, 0x12, 0x0,
0x44, 0x51, 0x34, 0x1c, 0xf6, 0xa3,
0x28, 0x52, 0x91, 0xac, 0xaa, 0x2a,
0xa4, 0x1a, 0x39, 0x98, 0x38, 0x37,
0x75, 0x6b, 0x48, 0xa2, 0x20, 0x1a,
0x27, 0xe2, 0xf1, 0x9e, 0xb5, 0xd6,
0x42, 0x49, 0x63, 0x8c, 0x94, 0xba,
0xc9, 0xe9, 0x1, 0x88, 0x42, 0x8,
0xe6, 0xb1, 0x13, 0x8c, 0x64, 0xb4,
0xd6, 0x66, 0xad, 0xb4, 0xae, 0xeb,
0x34, 0x8d, 0xf3, 0x3c, 0x47, 0xe4,
0x28, 0x8a, 0xc6, 0xd1, 0xc8, 0x8,
0x6b, 0x39, 0x10, 0x14, 0xec, 0x1d,
0x6b, 0xad, 0xbd, 0x67, 0xef, 0x7d,
0x92, 0x64, 0xc6, 0x98, 0x49, 0xe9,
0x1d, 0x26, 0x22, 0x20, 0x3f, 0x95,
0x1, 0x17, 0xa5, 0x8e, 0x4c, 0x6d,
0x1, 0x39, 0x8e, 0x63, 0x63, 0x2a,
0x66, 0x4e, 0xe3, 0xa8, 0xaa, 0xaa,
0xe9, 0x52, 0x23, 0x8d, 0x86, 0x80,
0x10, 0x10, 0xd9, 0x91, 0x8f, 0xa2,
0x44, 0x8, 0x51, 0x14, 0x15, 0x22,
0x6a, 0xad, 0x8d, 0x31, 0x4a, 0xea,
0x6, 0x41, 0x22, 0xaf, 0xe2, 0x85,
0x94, 0x23, 0x2f, 0x4, 0xa, 0x21,
0x42, 0x2, 0x7, 0x1, 0x6b, 0x72,
0x21, 0x4c, 0x29, 0x21, 0x84, 0x18,
0x87, 0x7f, 0x18, 0x63, 0xe2, 0x38,
0x25, 0xa2, 0xa2, 0xaa, 0x3b, 0x9d,
0x4e, 0xd8, 0x8, 0x0, 0x8, 0x21,
0x82, 0xa1, 0x33, 0x4, 0x86, 0x0,
0x0, 0x7a, 0xd9, 0xd4, 0x25, 0x89,
0xe3, 0x38, 0x54, 0xc1, 0x9, 0xbb,
0x5e, 0xff, 0xde, 0x9, 0x8, 0xfa,
0x1e, 0xe7, 0x5c, 0xab, 0xd5, 0x32,
0xc6, 0x18, 0x57, 0x87, 0xf4, 0xff,
0x7, 0x53, 0x9c, 0x86, 0x69, 0x24,
0x6f, 0x5d, 0x1c, 0x6b, 0x22, 0x6a,
0x5e, 0x71, 0x48, 0xb0, 0x3e, 0x5d,
0xa5, 0xe9, 0x20, 0xb1, 0xa, 0x55,
0xa8, 0xa2, 0x4, 0x0, 0x42, 0xab,
0xb2, 0x2c, 0x3b, 0x9d, 0x56, 0xaf,
0xd7, 0x8b, 0xe3, 0x34, 0x54, 0xa8,
0x3, 0x80, 0xe5, 0xe5, 0xe5, 0xee,
0xec, 0x5c, 0x60, 0x2f, 0x43, 0xa6,
0xb8, 0xa6, 0xae, 0x4a, 0x13, 0x67,
0x1e, 0x8a, 0x9, 0xac, 0xaf, 0xb5,
0x22, 0x6a, 0x12, 0xbf, 0x78, 0xf0,
0x41, 0x6b, 0x3d, 0x1c, 0xe, 0xdb,
0xed, 0x6e, 0x58, 0x15, 0x22, 0x4a,
0x29, 0x9, 0x50, 0x8, 0x1, 0x8c,
0xd6, 0x5a, 0x25, 0x8f, 0x51, 0xd9,
0xa3, 0x54, 0x5d, 0xd7, 0x5a, 0x8f,
0xd5, 0x63, 0x44, 0x14, 0xca, 0x85,
0x85, 0x83, 0x35, 0xc6, 0x68, 0x1d,
0x7, 0x17, 0x45, 0xa5, 0x94, 0xf7,
0xec, 0x9c, 0x3b, 0x54, 0x90, 0xf0,
0x21, 0x35, 0xea, 0x9e, 0xa4, 0x94,
0x0, 0xe4, 0xbd, 0xf, 0xb5, 0x8,
0xd3, 0x34, 0xe, 0x5b, 0xe, 0x69,
0xa7, 0xbc, 0x67, 0x6b, 0x6d, 0x28,
0x4c, 0x15, 0xce, 0xd8, 0x7a, 0x77,
0x2c, 0x53, 0x10, 0x39, 0xaf, 0xb5,
0xc, 0x27, 0xe9, 0x9c, 0xfb, 0xea,
0x57, 0xbf, 0xaa, 0xd2, 0x34, 0x5,
0x80, 0xb2, 0x2c, 0xc3, 0xeb, 0x24,
0xf0, 0xe3, 0xdc, 0xbc, 0xab, 0x2f,
0x4d, 0xb8, 0xa3, 0x1e, 0x0, 0x9c,
0x37, 0xa1, 0x10, 0x93, 0x52, 0x8a,
0xc8, 0x1a, 0x63, 0xd0, 0xb, 0x22,
0x6a, 0x2e, 0xd, 0x22, 0xf2, 0xc4,
0x4d, 0x5a, 0x0, 0x2, 0x40, 0x96,
0x65, 0x45, 0x99, 0x33, 0xb3, 0x52,
0xa2, 0xae, 0xeb, 0x28, 0x52, 0xa1,
0xd8, 0xd2, 0x78, 0xa1, 0xb8, 0x8a,
0x31, 0x40, 0x14, 0x1c, 0x92, 0xf3,
0x10, 0x91, 0x94, 0x2a, 0xac, 0x24,
0x5c, 0xd3, 0x90, 0x77, 0x9a, 0x99,
0xf1, 0xa0, 0x7d, 0x92, 0xf7, 0x1e,
0x5, 0x24, 0x49, 0x6a, 0x6d, 0xed,
0xbd, 0x8f, 0x22, 0x65, 0xad, 0xd,
0xaf, 0x64, 0xad, 0xd1, 0x82, 0x81,
0x94, 0xd2, 0x9e, 0xa9, 0xaa, 0x2a,
0x66, 0x46, 0x94, 0xa1, 0xce, 0x13,
0x11, 0x1, 0x43, 0xf0, 0x28, 0xa,
0x60, 0xde, 0xfc, 0x90, 0x1, 0x88,
0xc7, 0x59, 0x94, 0xac, 0xab, 0x95,
0x52, 0xcc, 0xde, 0x5a, 0x17, 0xaa,
0x13, 0x4e, 0x31, 0x37, 0x2b, 0x4b,
0x72, 0xce, 0x7, 0x6f, 0xb6, 0x10,
0xfb, 0x11, 0x10, 0x65, 0xa8, 0xe2,
0xd1, 0x7c, 0x67, 0x1c, 0x18, 0x16,
0x5c, 0xd9, 0x18, 0xb4, 0x96, 0x44,
0x94, 0x24, 0x89, 0xf7, 0xd6, 0x18,
0x13, 0xbc, 0x0, 0xb5, 0x96, 0x44,
0x7c, 0x8, 0x97, 0x6c, 0x15, 0xb2,
0x1a, 0x85, 0x5a, 0x73, 0xe1, 0xad,
0x49, 0x29, 0xf, 0x93, 0x52, 0x21,
0x8a, 0x54, 0x0, 0xa7, 0xb0, 0x65,
0x6b, 0xad, 0x33, 0xd6, 0x18, 0x73,
0x78, 0xfb, 0x13, 0x22, 0x5a, 0x6b,
0xc9, 0x3b, 0x63, 0x4c, 0x5d, 0xab,
0x28, 0x8a, 0x9a, 0x3c, 0x38, 0x1,
0x13, 0x85, 0x74, 0xa5, 0x4d, 0x92,
0x1a, 0x66, 0xcf, 0x2c, 0x78, 0x9c,
0xe3, 0x9f, 0x98, 0xf, 0x57, 0x23,
0xb6, 0x89, 0x8d, 0x21, 0x22, 0xe3,
0xd, 0x0, 0x24, 0x49, 0x32, 0x3f,
0x3f, 0x5f, 0x14, 0x55, 0xa3, 0x8b,
0x26, 0x22, 0x2, 0x2c, 0x8a, 0x62,
0xa6, 0x3b, 0x4b, 0xec, 0xf9, 0x90,
0x7, 0xb2, 0xee, 0x14, 0xe3, 0x75,
0x86, 0x4, 0x8c, 0x30, 0x9, 0xee,
0xf, 0x90, 0xc, 0x0, 0xa1, 0x9e,
0x53, 0xc0, 0x95, 0xcc, 0xc, 0x20,
0xa4, 0x94, 0xc4, 0x7c, 0x8, 0x62,
0xb8, 0xfe, 0x14, 0xe1, 0x7e, 0x32,
0xfb, 0x80, 0x23, 0xe2, 0x38, 0xe,
0xef, 0x25, 0x9c, 0x4f, 0x59, 0x96,
0x5a, 0xc7, 0xe1, 0x88, 0x98, 0xb9,
0xae, 0x2b, 0x21, 0x84, 0x8a, 0xf4,
0x21, 0xa6, 0xc0, 0xf5, 0xf6, 0x85,
0x4a, 0x8d, 0x3, 0xf8, 0x9b, 0xf5,
0xab, 0x90, 0xa4, 0xa3, 0xae, 0xcb,
0x99, 0x99, 0x99, 0xaa, 0x2a, 0xca,
0xbc, 0xd0, 0x91, 0xac, 0xea, 0x5a,
0x6b, 0x45, 0xce, 0x1d, 0xa4, 0x1d,
0x99, 0x94, 0xab, 0xd1, 0x52, 0x31,
0xb8, 0xda, 0xb8, 0x70, 0xe2, 0x5a,
0xc5, 0xc8, 0xe4, 0x4c, 0xd, 0x93,
0x5c, 0x5b, 0x1, 0x4d, 0x92, 0xf7,
0xe3, 0xbf, 0x1, 0xca, 0xaa, 0x88,
0xa2, 0x50, 0x55, 0xad, 0x16, 0x42,
0x94, 0x55, 0x15, 0xc7, 0xb1, 0xb5,
0x6, 0x51, 0xac, 0x3b, 0x5, 0x22,
0x80, 0x40, 0xa9, 0x44, 0x5e, 0xc,
0x85, 0x10, 0x5a, 0xc5, 0xde, 0xfb,
0x4e, 0x67, 0x66, 0xc, 0x8, 0xe4,
0x81, 0x19, 0x10, 0xc7, 0xb5, 0x73,
0x0, 0x88, 0x49, 0x9, 0x4d, 0x44,
0xa3, 0xd1, 0x80, 0xc8, 0x49, 0x14,
0xd6, 0x38, 0x22, 0x2, 0x60, 0x29,
0xd5, 0xd8, 0x81, 0x20, 0xa0, 0x9f,
0x31, 0x75, 0xa1, 0xc2, 0xd5, 0x2a,
0xd2, 0xc4, 0xd6, 0x59, 0xd2, 0x5a,
0x97, 0xa5, 0x13, 0x42, 0x74, 0x3a,
0x9d, 0xaa, 0xaa, 0x88, 0x88, 0x3d,
0x21, 0x8e, 0x9, 0x7, 0x0, 0x30,
0x13, 0x79, 0x52, 0x51, 0x5c, 0x9b,
0x12, 0x88, 0xa5, 0x44, 0xf6, 0xce,
0x93, 0x5, 0x4, 0x62, 0xeb, 0x3d,
0x1, 0x30, 0xf2, 0xea, 0x5d, 0x10,
0x11, 0x83, 0x94, 0x52, 0xa2, 0x60,
0x66, 0x9f, 0xe7, 0xe5, 0xdc, 0xdc,
0x9c, 0xb5, 0xd6, 0x7a, 0x17, 0x8e,
0x85, 0xc8, 0x4d, 0x27, 0xd3, 0x47,
0x44, 0xa5, 0xc4, 0x60, 0x38, 0x48,
0x93, 0x56, 0x6d, 0x72, 0x6b, 0x7c,
0xa7, 0xdb, 0xf2, 0xb5, 0x23, 0xf6,
0xde, 0xf3, 0xba, 0x9c, 0xad, 0xab,
0xc, 0xa, 0x36, 0x6, 0xe2, 0x38,
0xb6, 0xd6, 0xc6, 0x71, 0x1c, 0x12,
0x4d, 0x10, 0xf9, 0x43, 0xe8, 0x6f,
0xa8, 0x74, 0x75, 0x9a, 0xa6, 0xc,
0x5c, 0x55, 0xb5, 0x0, 0x44, 0x44,
0x62, 0x82, 0xa6, 0xc0, 0x1d, 0x4f,
0xf0, 0xf4, 0xa4, 0x59, 0x3b, 0x62,
0x66, 0x40, 0xaa, 0xeb, 0x3a, 0x8a,
0xa2, 0xb9, 0x99, 0x4e, 0x35, 0xe6,
0x20, 0x58, 0x6b, 0xed, 0x9c, 0x5,
0x80, 0x24, 0x89, 0x88, 0x1c, 0x0,
0x49, 0x29, 0xcb, 0x72, 0x88, 0x88,
0x42, 0xae, 0x94, 0x1a, 0x6d, 0x28,
0xb0, 0x73, 0xd5, 0xba, 0xaa, 0x22,
0xb2, 0x81, 0x17, 0x10, 0x44, 0x94,
0x65, 0x99, 0xd6, 0x7a, 0x54, 0x14,
0xa1, 0x8a, 0xa2, 0x73, 0x21, 0x63,
0xc, 0xa, 0x21, 0x84, 0xc4, 0x76,
0x3b, 0x1b, 0xe5, 0x7d, 0x21, 0x84,
0x0, 0x5e, 0x97, 0xb1, 0x5f, 0xdf,
0x40, 0xcd, 0x22, 0x90, 0xd6, 0x5e,
0x6f, 0x30, 0x3b, 0xdb, 0xd5, 0x5a,
0x37, 0xbe, 0x48, 0x1, 0xc0, 0x10,
0xd1, 0xda, 0x3a, 0x8e, 0xe3, 0x28,
0x8a, 0xf2, 0x3c, 0xf, 0x48, 0xd3,
0x33, 0x1d, 0xd3, 0x14, 0x1e, 0xb0,
0x2c, 0xcb, 0x6e, 0x77, 0x36, 0xcb,
0x12, 0xe7, 0xc, 0x0, 0x54, 0x95,
0xd, 0xf7, 0x27, 0x40, 0xb2, 0x10,
0x10, 0x45, 0xa, 0x80, 0x7a, 0xbd,
0x7e, 0xa7, 0x33, 0x13, 0x8, 0xc0,
0xba, 0x53, 0x1c, 0x32, 0xec, 0xd1,
0x41, 0xa8, 0x51, 0x28, 0xa5, 0xc,
0xd5, 0x61, 0x95, 0x52, 0x22, 0x70,
0x62, 0x65, 0x99, 0x97, 0x65, 0xd9,
0xee, 0x64, 0xdb, 0xb7, 0x9f, 0xac,
0x94, 0xd2, 0x91, 0x34, 0xb5, 0x9b,
0xd2, 0x7, 0x4c, 0x11, 0x4a, 0x22,
0x21, 0x41, 0xa0, 0xa, 0x9e, 0x3f,
0x42, 0xc8, 0x5e, 0xaf, 0x77, 0xdf,
0x7d, 0xf7, 0x9, 0x64, 0xf2, 0x8e,
0x45, 0x48, 0x1b, 0x1f, 0xb0, 0xef,
0x98, 0x0, 0xd6, 0x55, 0xed, 0xbd,
0x2c, 0xcb, 0x12, 0x90, 0xce, 0x7c,
0xf8, 0x19, 0xc6, 0xd4, 0x9d, 0x4e,
0x47, 0x69, 0x51, 0x57, 0x76, 0xed,
0x14, 0x84, 0x60, 0xdd, 0xb8, 0x4,
0xa6, 0xb3, 0x84, 0x88, 0xce, 0xf9,
0x7d, 0xfb, 0xf6, 0x2d, 0x2d, 0x1c,
0x8, 0x99, 0x56, 0xc6, 0xbb, 0xc2,
0x80, 0xd7, 0xc7, 0x9b, 0x74, 0xa6,
0xe, 0xbe, 0x7b, 0x3b, 0x1f, 0x72,
0xca, 0xcc, 0xcc, 0x4c, 0x5d, 0x57,
0x49, 0x92, 0x38, 0x6f, 0xc8, 0xd0,
0xba, 0xbb, 0x60, 0x1, 0x88, 0x68,
0x8c, 0x61, 0x6, 0x44, 0x5c, 0x5a,
0xec, 0x2d, 0x2e, 0x2e, 0xf6, 0x96,
0x16, 0x93, 0x24, 0x1, 0xa2, 0xf1,
0xc, 0x88, 0x1c, 0x2e, 0x33, 0x32,
0x0, 0x14, 0xc5, 0xc8, 0x18, 0x73,
0xe2, 0x89, 0x27, 0x6e, 0x3d, 0x61,
0xb3, 0xad, 0xd, 0x22, 0x24, 0x49,
0x52, 0x9b, 0x52, 0xa0, 0x2, 0x24,
0x41, 0xab, 0xa7, 0x8, 0x50, 0xa4,
0xb5, 0x76, 0xce, 0x97, 0xa6, 0xbe,
0xf7, 0x7, 0xf7, 0x2d, 0x2f, 0x2f,
0x86, 0xa, 0xa3, 0x0, 0x32, 0xe4,
0x61, 0x1a, 0x83, 0x8d, 0x4, 0x44,
0x20, 0xf2, 0xfb, 0xf6, 0x2f, 0xcd,
0xcf, 0xcc, 0x9c, 0x7c, 0xd2, 0x9,
0x52, 0xa, 0x66, 0x88, 0xe3, 0xa8,
0xaa, 0x6a, 0x66, 0x52, 0x4a, 0xaf,
0xb1, 0x2b, 0x60, 0x83, 0x9e, 0x8a,
0xa2, 0xb4, 0xd6, 0x1e, 0x58, 0x5a,
0x5c, 0x5c, 0x3a, 0x90, 0xa6, 0x69,
0x28, 0xf0, 0x79, 0x10, 0xe7, 0x3c,
0x5, 0x92, 0xde, 0xba, 0x4d, 0xdb,
0x36, 0xcc, 0xcf, 0xcf, 0x87, 0xc,
0x35, 0xa1, 0x9a, 0x89, 0xb5, 0x36,
0x56, 0xfa, 0x10, 0x14, 0x3b, 0x2,
0x80, 0xb2, 0xac, 0xf6, 0xec, 0xd9,
0xb3, 0xb8, 0xb8, 0xc8, 0xec, 0x95,
0x52, 0x2, 0xb1, 0x76, 0x56, 0x2a,
0x9c, 0x4a, 0x64, 0xe1, 0xa4, 0x10,
0xde, 0x1a, 0x89, 0xe2, 0xc4, 0x93,
0xb6, 0x84, 0x68, 0x96, 0x40, 0x90,
0x3, 0x0, 0x8f, 0x19, 0x9c, 0xf5,
0x5a, 0xa2, 0x23, 0x6b, 0xed, 0x70,
0x38, 0xba, 0xf7, 0xde, 0x7b, 0x87,
0xc3, 0xfe, 0xdc, 0xdc, 0x5c, 0xac,
0xa5, 0xf7, 0x5e, 0x45, 0xd2, 0x18,
0x3, 0x0, 0x2, 0xa5, 0x10, 0x90,
0x8f, 0x86, 0x73, 0x73, 0x73, 0xcb,
0x45, 0xbe, 0x7d, 0xfb, 0xf6, 0x4d,
0x1b, 0x66, 0x8f, 0x51, 0x18, 0x17,
0xc6, 0x18, 0x80, 0x5d, 0x55, 0x5d,
0x0, 0x26, 0x28, 0x80, 0xc1, 0x3b,
0x6f, 0x56, 0xbc, 0xfa, 0x91, 0x84,
0x84, 0xda, 0x94, 0xb5, 0x29, 0x37,
0x6d, 0xdc, 0xb2, 0x69, 0xf3, 0x6,
0x79, 0x8c, 0x5c, 0x7a, 0x5d, 0x9b,
0xfd, 0xfb, 0xf7, 0xe7, 0xa3, 0x42,
0x47, 0x72, 0xc2, 0xb5, 0x51, 0x14,
0xc5, 0x0, 0x50, 0x9b, 0x32, 0x8e,
0xe3, 0xba, 0x2e, 0x1, 0xc0, 0x79,
0x97, 0xa4, 0xd1, 0xe9, 0xa7, 0x9f,
0x46, 0xec, 0x8e, 0xc6, 0x4b, 0x62,
0x1a, 0x80, 0xf7, 0xec, 0xd9, 0xdb,
0xef, 0xd, 0xcb, 0xb2, 0x4c, 0x92,
0x24, 0x1c, 0xa6, 0xaa, 0xeb, 0x3a,
0x90, 0xf8, 0x51, 0x3e, 0x38, 0xed,
0xb4, 0xd3, 0x2e, 0xbd, 0xf4, 0x49,
0x73, 0x33, 0x1d, 0x6, 0x30, 0xae,
0x5e, 0xe3, 0x86, 0x2a, 0x26, 0xe2,
0x84, 0x8, 0xcc, 0x46, 0xe0, 0xc5,
0x43, 0xf8, 0x98, 0xa9, 0xdd, 0x7,
0x3e, 0xfc, 0xa1, 0xca, 0x57, 0xde,
0x12, 0xb0, 0x92, 0x42, 0x23, 0x13,
0x13, 0x7, 0x18, 0x8b, 0x94, 0xf0,
0xce, 0x74, 0x5a, 0xe9, 0xcf, 0xff,
0xfc, 0xd3, 0x4e, 0xde, 0x76, 0x2,
0x3, 0x18, 0x6b, 0x8d, 0x39, 0xa8,
0x20, 0x75, 0xb0, 0x84, 0x5, 0x69,
0x33, 0x52, 0xa, 0x80, 0xfa, 0x63,
0x8d, 0x9f, 0x4c, 0xe2, 0xd8, 0x39,
0xfe, 0xfc, 0xe7, 0x3f, 0xff, 0xf5,
0x3b, 0xee, 0x8, 0x68, 0x12, 0x1,
0x88, 0xd8, 0x4f, 0x89, 0x10, 0x4a,
0xb, 0x4f, 0x7c, 0xe9, 0xa5, 0x97,
0x9e, 0xf5, 0xc8, 0x33, 0x82, 0xb5,
0xc1, 0x38, 0xa7, 0x95, 0x34, 0xd6,
0x1c, 0x6c, 0xe7, 0x1a, 0x4f, 0x21,
0x25, 0x4e, 0x98, 0x5b, 0xc, 0xe3,
0xdf, 0x76, 0xdb, 0xed, 0x5f, 0xfa,
0xd2, 0x97, 0x8c, 0x5, 0x29, 0x25,
0xa, 0x4, 0x0, 0x4f, 0x36, 0x1c,
0xb1, 0x10, 0x42, 0x69, 0x31, 0x1c,
0x15, 0x17, 0x5d, 0x74, 0xd1, 0x63,
0x1e, 0xf3, 0x98, 0x76, 0x16, 0x5b,
0xcf, 0x80, 0x84, 0xc4, 0xd6, 0xd6,
0x4d, 0x6c, 0xd6, 0xf4, 0x2e, 0x20,
0x94, 0x7d, 0x63, 0x2f, 0x84, 0x88,
0x74, 0xec, 0x1c, 0xef, 0xda, 0xb5,
0xeb, 0x13, 0x9f, 0xb8, 0x3e, 0x58,
0xfa, 0x82, 0xd0, 0x4b, 0xde, 0x7,
0xe9, 0x40, 0x80, 0x70, 0xd6, 0x56,
0x55, 0x75, 0xe6, 0x19, 0xa7, 0x5d,
0x76, 0xd9, 0x65, 0xed, 0x56, 0xbb,
0xac, 0xca, 0xb0, 0xbc, 0x6e, 0xbb,
0xb, 0x0, 0xf5, 0x21, 0x74, 0x8d,
0xd6, 0xda, 0x24, 0xc9, 0x94, 0x10,
0x0, 0x50, 0xd5, 0xee, 0xfd, 0xef,
0x7f, 0x7f, 0xbf, 0x3f, 0x88, 0x52,
0xe5, 0x99, 0x61, 0x35, 0x29, 0x1d,
0xb7, 0x17, 0x5d, 0xfd, 0x2b, 0xb3,
0xb3, 0x5d, 0x9, 0xd2, 0x92, 0x65,
0xc7, 0x81, 0x6f, 0xa, 0x91, 0x52,
0xeb, 0x6a, 0x41, 0x89, 0x20, 0x89,
0x23, 0x4b, 0x24, 0x84, 0xf8, 0xf4,
0xd, 0x37, 0x7e, 0xeb, 0x5b, 0xdf,
0x9a, 0x9d, 0x9d, 0xb, 0x0, 0xef,
0x8d, 0x15, 0x72, 0x2a, 0xe9, 0x12,
0x52, 0x5d, 0x57, 0x3f, 0xfd, 0xd3,
0x97, 0x3e, 0xe2, 0xe1, 0xa7, 0x9,
0x1, 0xa1, 0x52, 0xfc, 0x4, 0x95,
0x7, 0x46, 0x7a, 0xdd, 0x98, 0xd0,
0xb1, 0x5f, 0x45, 0x14, 0xe9, 0x7f,
0xba, 0xf5, 0xd6, 0x9b, 0xbf, 0xfc,
0xd5, 0x3c, 0x1f, 0x29, 0xa5, 0x1,
0xa0, 0xca, 0x8b, 0x0, 0x60, 0x84,
0x9e, 0x81, 0xd3, 0x2c, 0x1e, 0x8e,
0xfa, 0xe7, 0x3f, 0xf6, 0xbc, 0xcb,
0x2e, 0x7d, 0xc2, 0x7a, 0x6a, 0xa4,
0xc3, 0xb1, 0xd0, 0x91, 0x8a, 0x9c,
0x87, 0x7d, 0xfb, 0xf6, 0xfd, 0xed,
0xdf, 0xfe, 0x2d, 0x59, 0x1b, 0x45,
0x91, 0x4, 0x8c, 0x95, 0xe, 0x5,
0xe5, 0xe3, 0x38, 0x8e, 0xa4, 0xf4,
0xc6, 0xe4, 0x79, 0xbe, 0x63, 0xc7,
0x8e, 0xa7, 0x3d, 0xed, 0x69, 0xad,
0x2c, 0xae, 0xf, 0x31, 0xc5, 0x21,
0x9e, 0x10, 0xeb, 0x78, 0x94, 0x57,
0x1f, 0xfb, 0xd8, 0xc7, 0x96, 0x96,
0x96, 0xa2, 0x28, 0x62, 0x66, 0x29,
0xa4, 0x29, 0xab, 0x40, 0x81, 0x91,
0x18, 0x89, 0x98, 0x39, 0x8e, 0xa2,
0xcb, 0x9f, 0xfa, 0xd4, 0x9d, 0x3b,
0x4f, 0x61, 0x0, 0xe7, 0xcc, 0xa1,
0x76, 0x11, 0xe, 0x6d, 0xfa, 0x9,
0x0, 0x5a, 0x25, 0x9f, 0xfe, 0xf4,
0x8d, 0x77, 0xde, 0x79, 0xa7, 0x33,
0x20, 0x85, 0x50, 0x62, 0x92, 0x56,
0x36, 0x90, 0x78, 0xad, 0x95, 0x52,
0xca, 0x78, 0x57, 0x54, 0x39, 0xae,
0xd3, 0x42, 0x41, 0x7, 0x6, 0x20,
0x66, 0xaf, 0xb5, 0x4e, 0xa2, 0x24,
0x30, 0xe1, 0x42, 0x88, 0x76, 0x2b,
0x9, 0x77, 0x71, 0xba, 0x50, 0xe2,
0x54, 0xbe, 0x4b, 0x72, 0xce, 0x2,
0xf0, 0xa6, 0xcd, 0x1b, 0x7a, 0x83,
0x41, 0x55, 0x97, 0x42, 0x40, 0xbb,
0x95, 0x4d, 0xc6, 0x44, 0x1, 0xcd,
0x14, 0x28, 0x80, 0x7b, 0xfd, 0xc5,
0x20, 0x8, 0x65, 0x49, 0x46, 0x44,
0x55, 0x5d, 0x6b, 0x85, 0x4d, 0xe2,
0xae, 0x9, 0x66, 0xa2, 0xe9, 0x2c,
0xb6, 0xc6, 0x98, 0x3c, 0x1f, 0xcd,
0xcd, 0xcd, 0x32, 0x40, 0x7f, 0x30,
0x8, 0x4, 0x13, 0x80, 0xa4, 0x44,
0x29, 0x51, 0xae, 0x34, 0x94, 0x52,
0x2a, 0x81, 0xa6, 0x2e, 0x85, 0x80,
0x28, 0x8a, 0xbc, 0xb7, 0x61, 0xfc,
0x2c, 0x4b, 0x1b, 0x61, 0x6c, 0xc2,
0xc3, 0x1c, 0x94, 0x2e, 0x7b, 0x30,
0x18, 0x6c, 0xd8, 0x30, 0xdf, 0xce,
0xe2, 0xca, 0x1a, 0x62, 0x27, 0x81,
0xbd, 0xb7, 0x49, 0x12, 0xad, 0xbb,
0xb, 0x44, 0xd6, 0x52, 0x8c, 0xe9,
0x9b, 0x33, 0x5a, 0xe1, 0xa6, 0x4d,
0x9b, 0x0, 0xa0, 0x91, 0xfc, 0x57,
0x71, 0x62, 0x44, 0x14, 0x94, 0xb,
0x71, 0xac, 0x9d, 0x37, 0x0, 0x94,
0xa6, 0x71, 0x1c, 0x6b, 0x0, 0x2a,
0xaa, 0xd1, 0x64, 0x17, 0xab, 0x3f,
0x49, 0x12, 0x19, 0x53, 0xd, 0x46,
0x83, 0xa2, 0xaa, 0x92, 0x58, 0x5,
0x2a, 0x77, 0xd8, 0xc4, 0xfa, 0x9c,
0xa6, 0xa9, 0xf7, 0xde, 0x78, 0x83,
0x88, 0x71, 0xa4, 0x85, 0x10, 0x44,
0x81, 0x83, 0xa5, 0x29, 0x1b, 0xe6,
0xca, 0x53, 0x29, 0x51, 0x94, 0x45,
0xaf, 0xb7, 0x24, 0x0, 0x94, 0x16,
0x55, 0x55, 0x59, 0x6b, 0xab, 0xaa,
0xa, 0xca, 0xb9, 0xc6, 0x1, 0x3e,
0xa4, 0x4a, 0xb7, 0xd6, 0x9e, 0x78,
0xe2, 0x89, 0x49, 0x9c, 0x48, 0x29,
0x43, 0xea, 0x56, 0x66, 0x8f, 0x88,
0xcc, 0x21, 0xdd, 0xff, 0xba, 0x53,
0x90, 0x10, 0x63, 0x19, 0x35, 0x20,
0xf4, 0x46, 0x65, 0x10, 0xaa, 0x6c,
0x4a, 0x29, 0x43, 0x6, 0xf6, 0x56,
0xab, 0xd5, 0xeb, 0x2d, 0xb7, 0x5a,
0x59, 0x0, 0x89, 0xe6, 0x6d, 0x4e,
0x3f, 0xf, 0x35, 0x45, 0x5e, 0xe6,
0x9e, 0xec, 0xec, 0xec, 0xac, 0xf7,
0xde, 0x5a, 0x5b, 0xd7, 0x75, 0x55,
0x55, 0x75, 0x5d, 0xaf, 0x5c, 0xee,
0x49, 0x71, 0xf9, 0x56, 0x3b, 0x55,
0x5a, 0xc, 0x46, 0x83, 0xb5, 0x83,
0x87, 0x67, 0xf3, 0x7e, 0xf, 0x7e,
0x72, 0x59, 0x97, 0x3a, 0x92, 0x81,
0xfd, 0x99, 0xa8, 0x6f, 0x64, 0x73,
0x7f, 0x8a, 0xa2, 0x68, 0x44, 0xe2,
0x13, 0x4f, 0xda, 0xea, 0x89, 0xea,
0xba, 0x3c, 0xc4, 0x50, 0x88, 0xc8,
0x42, 0x88, 0xe6, 0xd9, 0xf4, 0x87,
0x9c, 0xaf, 0x81, 0x75, 0xa, 0x1b,
0x19, 0x1f, 0x90, 0x31, 0xc6, 0x18,
0x53, 0xd7, 0x75, 0x16, 0x27, 0x5a,
0xc8, 0x48, 0x2a, 0x24, 0x66, 0xf6,
0x42, 0x40, 0x59, 0x8c, 0xaa, 0x32,
0x47, 0x20, 0x29, 0x20, 0x52, 0x52,
0x49, 0xcc, 0x47, 0x83, 0x2c, 0x8e,
0xbd, 0x33, 0xbd, 0xfe, 0x62, 0xac,
0x54, 0x3b, 0x4d, 0xcb, 0x32, 0xf,
0xe2, 0x53, 0x3e, 0x18, 0xb6, 0x92,
0x54, 0x2, 0x32, 0xf8, 0xc0, 0xdc,
0x33, 0x78, 0x6, 0x1f, 0xf2, 0x8a,
0x95, 0x55, 0xee, 0x9c, 0xeb, 0x76,
0xdb, 0x42, 0x80, 0xb3, 0x75, 0x9e,
0x8f, 0xa4, 0x0, 0xf2, 0x96, 0x4c,
0x5d, 0x15, 0x23, 0x53, 0x15, 0xce,
0x54, 0xde, 0xd6, 0x4a, 0x40, 0x2b,
0x49, 0x8d, 0x2d, 0xa5, 0x80, 0xaa,
0xce, 0xc9, 0x79, 0x1, 0x48, 0x4,
0x88, 0x8, 0x9e, 0xb4, 0x90, 0x82,
0x81, 0x9d, 0xf, 0x5c, 0x59, 0x38,
0x7d, 0x21, 0x44, 0x24, 0xa5, 0x42,
0x21, 0x80, 0x90, 0xb9, 0xd5, 0x4a,
0xcb, 0x3a, 0xcf, 0xd2, 0xd8, 0x5a,
0x3, 0xec, 0xfb, 0xbd, 0xa5, 0xda,
0x94, 0x4a, 0xa, 0x67, 0xaa, 0x32,
0x1f, 0xda, 0xba, 0x34, 0x55, 0xd1,
0x4a, 0x62, 0x60, 0x9f, 0x8f, 0x6,
0x5a, 0x9, 0xf6, 0xe, 0x1, 0x94,
0x94, 0x75, 0x5d, 0x81, 0xa7, 0x30,
0xfe, 0x44, 0x30, 0x83, 0xe6, 0x4a,
0x29, 0xc4, 0x2a, 0x2f, 0xbc, 0xf7,
0xe0, 0x29, 0x16, 0xc2, 0xd9, 0x1a,
0x81, 0xbc, 0x73, 0x75, 0x55, 0x54,
0x65, 0x4e, 0xa6, 0x6, 0x72, 0x40,
0xce, 0x99, 0xca, 0x54, 0x85, 0xb7,
0x36, 0x92, 0x2, 0x81, 0x62, 0x1d,
0x91, 0xf3, 0xce, 0x79, 0x6b, 0x2a,
0x63, 0x4c, 0x48, 0xfe, 0x4, 0xe4,
0xd8, 0x79, 0x2d, 0x64, 0xc0, 0x4a,
0xce, 0xb9, 0x28, 0x8a, 0xc9, 0x10,
0x7b, 0x2, 0xf6, 0xc0, 0x5e, 0x2b,
0x1, 0xec, 0x63, 0xad, 0x0, 0xbc,
0x40, 0xce, 0x47, 0x3, 0x6b, 0x2a,
0xf2, 0x16, 0x81, 0xac, 0xa9, 0x86,
0x83, 0x1e, 0x2, 0x99, 0xba, 0x4,
0xf6, 0x4a, 0x72, 0x1c, 0x29, 0x1d,
0xf8, 0x3d, 0xe6, 0x20, 0x17, 0x21,
0x21, 0x12, 0x6a, 0xa1, 0x5, 0xb,
0xc1, 0x21, 0x3d, 0xa1, 0x30, 0xa6,
0x96, 0xa, 0xbd, 0xa9, 0x13, 0xa9,
0x5c, 0x5d, 0xd5, 0x45, 0xee, 0xbc,
0x61, 0xf6, 0xc0, 0x9e, 0xbc, 0x95,
0x2, 0xfa, 0xbd, 0x25, 0x21, 0x21,
0xd2, 0xa, 0xc8, 0xb1, 0xb7, 0x89,
0x56, 0xce, 0x54, 0x80, 0x4e, 0x2a,
0x6e, 0xb7, 0x52, 0x66, 0x32, 0x55,
0xd, 0xcc, 0x21, 0x8b, 0xb0, 0x31,
0x2e, 0x8e, 0x53, 0xf0, 0x10, 0x3e,
0x41, 0xc8, 0x74, 0xce, 0xd6, 0x65,
0x2e, 0x80, 0x11, 0x48, 0x49, 0x14,
0xc8, 0xe4, 0x2d, 0xb0, 0xf7, 0xce,
0x38, 0x5b, 0x93, 0xb7, 0x5a, 0x9,
0x25, 0x91, 0xbc, 0x65, 0x72, 0xe5,
0x2e, 0xab, 0xf8, 0x0, 0x0, 0x20,
0x0, 0x49, 0x44, 0x41, 0x54, 0xcd,
0xdf, 0x28, 0x58, 0x69, 0x40, 0x0,
0x25, 0xa4, 0xa9, 0x6b, 0x31, 0x51,
0x2f, 0x9, 0x21, 0xea, 0xba, 0xae,
0xeb, 0x3a, 0x8d, 0x62, 0x9, 0x58,
0x96, 0x85, 0x73, 0x4e, 0x47, 0x92,
0xd9, 0x4b, 0x1, 0xd6, 0x54, 0x75,
0x55, 0x48, 0x1, 0x4a, 0x20, 0x79,
0x5b, 0x95, 0xb9, 0x14, 0x20, 0x5,
0x30, 0x39, 0x29, 0x40, 0x20, 0x7b,
0x67, 0x9a, 0x89, 0xa4, 0x94, 0xb1,
0xd6, 0x65, 0x95, 0x13, 0x3b, 0x6b,
0x6d, 0xa0, 0x90, 0x93, 0x7a, 0xbf,
0x63, 0x49, 0x2a, 0xd4, 0x2e, 0x2d,
0xcb, 0x52, 0x29, 0x11, 0xc7, 0xda,
0x3b, 0xa7, 0x85, 0x68, 0x3e, 0x55,
0x99, 0xf7, 0x96, 0x17, 0x99, 0x5c,
0xa4, 0x64, 0xac, 0x54, 0x18, 0x3c,
0x52, 0x92, 0xbc, 0x75, 0xb6, 0x6,
0xf6, 0x52, 0xca, 0x48, 0xab, 0xda,
0x94, 0x45, 0x39, 0xa, 0x2, 0x60,
0x23, 0xfc, 0x87, 0x13, 0x73, 0xce,
0x7, 0x34, 0x6d, 0xad, 0xf5, 0xde,
0xa, 0x1, 0xde, 0x39, 0x19, 0xca,
0x79, 0xb2, 0x7, 0xf6, 0x65, 0x31,
0x2a, 0x8b, 0x91, 0x77, 0xa6, 0xc8,
0x87, 0x1, 0xee, 0x80, 0x7d, 0xa4,
0x64, 0x0, 0x13, 0x53, 0x97, 0xc,
0x10, 0xce, 0xa4, 0x51, 0xad, 0xab,
0x55, 0x74, 0x80, 0x99, 0x89, 0x18,
0x88, 0x1, 0x40, 0x2a, 0xe1, 0x9d,
0x6b, 0xa7, 0x49, 0xa4, 0x23, 0x0,
0x91, 0x17, 0x39, 0x2b, 0x25, 0xa5,
0x9c, 0xeb, 0xcc, 0x38, 0xef, 0x5c,
0x5d, 0x75, 0xb2, 0x14, 0x0, 0x8a,
0xaa, 0xd0, 0x52, 0x21, 0x0, 0x13,
0xf1, 0x84, 0xfc, 0xca, 0xb1, 0xcc,
0x49, 0x81, 0x77, 0x4d, 0xb3, 0x8c,
0x61, 0x9c, 0x3b, 0x5a, 0x22, 0xc4,
0x89, 0x16, 0x3a, 0x42, 0x60, 0x67,
0x4d, 0xa2, 0x23, 0x92, 0x94, 0xa5,
0x9, 0x42, 0xe0, 0xcc, 0xd1, 0xd6,
0xc6, 0x5a, 0xdb, 0xe9, 0xb6, 0x1,
0x84, 0x16, 0xb2, 0x15, 0x2b, 0xc7,
0x60, 0x8c, 0x3, 0x66, 0xf6, 0xc4,
0x9e, 0x48, 0x6, 0xfd, 0x10, 0xe2,
0x4a, 0x3a, 0x5f, 0x42, 0x40, 0x6b,
0x2a, 0x72, 0x5e, 0x86, 0x9c, 0x5f,
0x93, 0xec, 0x9b, 0xb1, 0xd4, 0xdd,
0x56, 0x3b, 0x89, 0x93, 0xa0, 0x62,
0xc9, 0xd2, 0xc, 0x40, 0x30, 0x78,
0x6b, 0xeb, 0x48, 0x6b, 0x2b, 0x90,
0x9d, 0x97, 0x38, 0xe, 0x7f, 0x23,
0xef, 0x91, 0xa7, 0x9d, 0x40, 0x71,
0xda, 0xa3, 0x1b, 0x5, 0xb7, 0x5b,
0x69, 0x24, 0xa5, 0xa9, 0xea, 0x0,
0xdb, 0x69, 0x14, 0x33, 0xfb, 0xb4,
0x35, 0x4e, 0x20, 0x58, 0x9b, 0x5a,
0x9, 0x9d, 0x64, 0xb1, 0xf7, 0x2c,
0xa4, 0x2c, 0xca, 0x11, 0x0, 0xa0,
0x92, 0x4a, 0x8, 0xa5, 0x24, 0x22,
0xb2, 0x27, 0xe7, 0x3c, 0x10, 0x22,
0x7, 0xed, 0x9d, 0x10, 0x63, 0xd5,
0x91, 0x8, 0x26, 0xae, 0x2c, 0xcb,
0xbc, 0xe7, 0x60, 0xa9, 0x1a, 0x8d,
0xa, 0xef, 0x7d, 0xab, 0xd5, 0xd2,
0x3a, 0x4e, 0xe3, 0x16, 0x0, 0x38,
0x72, 0x42, 0x8, 0xad, 0x31, 0x4b,
0xda, 0x0, 0x50, 0x71, 0x85, 0xc4,
0x48, 0xc, 0xc, 0x28, 0x42, 0xa1,
0x30, 0x6, 0x62, 0x20, 0x4, 0x82,
0xa0, 0xa1, 0x18, 0x9b, 0xf1, 0x82,
0x36, 0xde, 0x33, 0x38, 0x60, 0x4f,
0xce, 0x5b, 0xf2, 0xbe, 0xd5, 0x6a,
0xf5, 0x7a, 0xbd, 0x56, 0xab, 0x95,
0x25, 0x19, 0x0, 0x78, 0x67, 0x67,
0x3b, 0x5d, 0xf0, 0x34, 0x1c, 0xf5,
0xc7, 0x54, 0xda, 0x9a, 0x56, 0xab,
0x65, 0xbc, 0x99, 0xb6, 0x94, 0x8d,
0xa7, 0xc0, 0x71, 0x38, 0xd0, 0x44,
0x63, 0xc7, 0x82, 0x1, 0x43, 0xd2,
0xd, 0x16, 0x95, 0xa9, 0xbc, 0xa9,
0x83, 0x7e, 0x5e, 0x22, 0x6a, 0x21,
0xe3, 0x44, 0x1b, 0x6b, 0x88, 0xc8,
0x1b, 0x4b, 0x44, 0x4a, 0x8, 0xa5,
0x14, 0x32, 0x38, 0xe7, 0x5, 0xc3,
0x34, 0x19, 0x27, 0x22, 0xf2, 0x3c,
0xbe, 0xd2, 0x88, 0xd3, 0xf6, 0xcb,
0x26, 0xe, 0x89, 0x99, 0x9d, 0x77,
0x21, 0x21, 0xf9, 0x4, 0xfd, 0x45,
0x55, 0x55, 0x9, 0x10, 0x8c, 0x1c,
0x4c, 0x59, 0xc1, 0xaa, 0x12, 0x10,
0x81, 0x31, 0x86, 0x59, 0xae, 0xd6,
0x9d, 0x71, 0x48, 0xf3, 0x12, 0xb8,
0x21, 0xf, 0x2b, 0x79, 0x67, 0xc7,
0xfc, 0x91, 0x77, 0xae, 0xb0, 0xa6,
0xd1, 0xae, 0xcf, 0xcd, 0xcd, 0xcd,
0xb4, 0x3a, 0x0, 0xb0, 0x6f, 0xff,
0xbe, 0x2d, 0x9b, 0xb7, 0xa8, 0x70,
0xe2, 0x44, 0x82, 0x21, 0xd2, 0x11,
0x21, 0x38, 0x4f, 0x41, 0x68, 0x6c,
0xf8, 0xce, 0xc9, 0x14, 0x2b, 0xa2,
0xec, 0xaa, 0x1c, 0xec, 0x44, 0x44,
0xd6, 0x85, 0xbb, 0x1a, 0x47, 0x71,
0xd2, 0x19, 0xd7, 0xca, 0x6e, 0xc5,
0x63, 0x4f, 0xaf, 0xbc, 0xc8, 0xd9,
0xf9, 0x24, 0x49, 0x4, 0x43, 0x92,
0xe8, 0xf0, 0x8a, 0xa7, 0xf5, 0x82,
0x82, 0x8, 0x88, 0x80, 0x99, 0x5,
0x8b, 0x60, 0x44, 0x72, 0x6e, 0x9c,
0xe0, 0x53, 0x30, 0xdc, 0xfb, 0xfd,
0x7b, 0x5e, 0xfa, 0x6b, 0xbf, 0x9e,
0xc4, 0xa9, 0x40, 0x39, 0xdb, 0x9d,
0x49, 0xe3, 0x2c, 0x52, 0xf1, 0xf3,
0xaf, 0x7a, 0xfe, 0xdd, 0x77, 0xdf,
0xdd, 0xed, 0x74, 0x7, 0x83, 0x41,
0x59, 0xe4, 0xb1, 0xd2, 0xec, 0x3d,
0xd0, 0x24, 0x45, 0x0, 0x3, 0x10,
0x86, 0x17, 0x40, 0x1e, 0xc2, 0xf8,
0x88, 0xc2, 0x3b, 0xe, 0xc, 0x5e,
0x14, 0x45, 0xbd, 0x5e, 0xef, 0x2f,
0xff, 0xfc, 0xcf, 0x37, 0xcc, 0x6f,
0xb8, 0xf8, 0xe2, 0x8b, 0xbf, 0xfe,
0xf5, 0xaf, 0x6b, 0x19, 0xfd, 0xd3,
0xd7, 0x6e, 0x79, 0xec, 0xf9, 0xe7,
0xb7, 0xb2, 0xec, 0xb5, 0xff, 0xe3,
0xff, 0xca, 0x47, 0xa3, 0x6e, 0xb7,
0xfb, 0xbe, 0xf7, 0xbd, 0x57, 0xa,
0x79, 0xf1, 0x85, 0x17, 0xdd, 0x71,
0xfb, 0x37, 0xc8, 0xba, 0x34, 0x52,
0xfd, 0xa5, 0x1e, 0x40, 0x30, 0xa0,
0x9, 0x44, 0x29, 0x41, 0xa, 0x16,
0xc0, 0x2, 0x58, 0x30, 0x3, 0xd3,
0x58, 0x7, 0x5e, 0xd7, 0x26, 0x30,
0x78, 0xae, 0x36, 0xf7, 0xfc, 0xfb,
0x3d, 0x17, 0x3f, 0xee, 0xe2, 0x2c,
0xed, 0x8, 0xa1, 0x93, 0x34, 0x9b,
0xe9, 0x74, 0x5, 0x4a, 0x81, 0x78,
0xe1, 0x63, 0x2f, 0xf8, 0xde, 0x77,
0xbf, 0x3b, 0x1c, 0xe, 0x4, 0xa2,
0x44, 0x41, 0xce, 0x93, 0x77, 0x64,
0x5d, 0xa2, 0xa3, 0x26, 0x2c, 0x92,
0x28, 0xd0, 0x16, 0x2, 0x4f, 0x44,
0xc, 0x9e, 0x94, 0xd0, 0x83, 0xe5,
0x41, 0x55, 0x54, 0x82, 0x81, 0xbd,
0x57, 0x28, 0x16, 0xf6, 0x1f, 0x78,
0xc5, 0xcb, 0x7f, 0x4b, 0x4a, 0x2d,
0x84, 0x6e, 0xb7, 0x3a, 0x69, 0xdc,
0xd6, 0x3a, 0x46, 0x94, 0xe7, 0x9d,
0x73, 0xee, 0x8d, 0x9f, 0xf9, 0x8c,
0xf7, 0x3e, 0x4b, 0x33, 0xef, 0x7d,
0x59, 0x96, 0xae, 0xb6, 0xae, 0x76,
0x91, 0x52, 0xb1, 0xd6, 0xde, 0x7,
0xd6, 0x72, 0xe5, 0xa0, 0xd8, 0x83,
0x77, 0xec, 0x3d, 0xe5, 0x79, 0x99,
0xe8, 0x44, 0xb0, 0x18, 0xf5, 0x47,
0x91, 0x8c, 0x62, 0x15, 0xbf, 0xe7,
0xaf, 0xde, 0xd3, 0x4e, 0xdb, 0x49,
0x9c, 0x68, 0xa5, 0x13, 0x15, 0xa7,
0x51, 0x3a, 0xdb, 0x99, 0x55, 0x42,
0x26, 0x71, 0xf2, 0x81, 0xf7, 0x7e,
0x80, 0x82, 0xc6, 0x3c, 0xa4, 0xb,
0x26, 0x46, 0x2, 0xc1, 0x2, 0x43,
0x50, 0x21, 0xb, 0x9c, 0x7c, 0x42,
0x1c, 0x5d, 0x0, 0x8f, 0x60, 0x5e,
0xe, 0x46, 0xef, 0xef, 0x7e, 0xf7,
0xbb, 0xaf, 0x78, 0xc5, 0x2b, 0x94,
0x90, 0x8f, 0x3a, 0xfb, 0xac, 0xdb,
0x6f, 0xbf, 0x3d, 0x58, 0x95, 0xfe,
0xf9, 0x9f, 0xff, 0xf9, 0x21, 0xa7,
0xec, 0x68, 0xa5, 0xed, 0xb7, 0xbd,
0xe5, 0xad, 0xc6, 0x54, 0xd6, 0x5a,
0xef, 0xdd, 0x8a, 0xfe, 0x89, 0xc7,
0x57, 0x7f, 0x72, 0x3b, 0xc5, 0x24,
0x68, 0x54, 0x0, 0x8c, 0xb1, 0x88,
0x60, 0xe1, 0x2d, 0x99, 0xca, 0xa,
0x90, 0x9f, 0xb9, 0xe1, 0xc6, 0x6e,
0x7b, 0xe6, 0xa1, 0xa7, 0x9d, 0x7e,
0xdb, 0xbf, 0xdc, 0x2e, 0x51, 0x45,
0x2a, 0x5e, 0xd8, 0xbf, 0xf8, 0xb2,
0x5f, 0x7f, 0x79, 0xa4, 0x92, 0x97,
0xbc, 0xf8, 0xa5, 0xa3, 0x41, 0xae,
0x54, 0xd4, 0xf0, 0xcc, 0x93, 0xf1,
0x83, 0xcc, 0x22, 0x99, 0x30, 0x7c,
0xa6, 0xa0, 0x6e, 0x1c, 0xbe, 0x6a,
0xad, 0xf5, 0xc6, 0x7b, 0xe3, 0x6d,
0x65, 0x23, 0x19, 0x81, 0x87, 0x6e,
0xab, 0xfb, 0x7, 0xff, 0xf7, 0x1f,
0xc4, 0x32, 0x79, 0xf6, 0x33, 0x9e,
0xfd, 0xcd, 0xdb, 0xbf, 0x29, 0x41,
0x26, 0x3a, 0x21, 0x4b, 0xae, 0x76,
0xc6, 0x38, 0xf6, 0x14, 0x4a, 0x1a,
0x20, 0xb, 0x64, 0x1c, 0xe3, 0x50,
0x42, 0x24, 0x85, 0xa4, 0x80, 0x64,
0xc0, 0x7a, 0x21, 0x96, 0x8e, 0x3d,
0x79, 0x4b, 0x82, 0x81, 0x3d, 0x78,
0x4b, 0xb3, 0xdd, 0xb9, 0x3, 0xfb,
0x16, 0xae, 0xfc, 0xc5, 0xe7, 0xa,
0xd4, 0x91, 0x8e, 0x1f, 0x72, 0xca,
0x4e, 0x81, 0x7a, 0x6e, 0x66, 0xfe,
0xe5, 0xbf, 0xf1, 0x9b, 0xff, 0xfa,
0xcd, 0x6f, 0xc7, 0x3a, 0x21, 0xc7,
0xae, 0x76, 0x40, 0x2c, 0x0, 0x25,
0xa, 0x1, 0x32, 0x4c, 0x11, 0x66,
0x41, 0x16, 0xe0, 0x65, 0x98, 0x22,
0xf4, 0xb3, 0x27, 0x72, 0xde, 0x5b,
0x42, 0xe2, 0x48, 0xc5, 0xbb, 0x7e,
0xb8, 0xfb, 0x25, 0x2f, 0x7e, 0xa9,
0x40, 0x2d, 0x50, 0xb7, 0xb2, 0x76,
0x1c, 0x25, 0x69, 0x92, 0xed, 0x38,
0xe5, 0x21, 0x6f, 0xf8, 0x9f, 0x7f,
0x52, 0x8c, 0xca, 0x2c, 0x69, 0x55,
0x45, 0x5d, 0x15, 0xf5, 0x60, 0x79,
0x20, 0x10, 0xc2, 0x7, 0x81, 0x81,
0x89, 0xc9, 0xab, 0x49, 0xb6, 0xbe,
0xa0, 0x37, 0x43, 0xa2, 0x90, 0xb9,
0xe, 0x10, 0xa9, 0xdf, 0x1f, 0xbe,
0xe6, 0x35, 0xaf, 0xf9, 0xfb, 0x4f,
0x7e, 0xea, 0x92, 0x4b, 0x2e, 0x7e,
0xfa, 0xd3, 0x9f, 0x7e, 0xe6, 0x99,
0x67, 0xde, 0x7d, 0xf7, 0xdd, 0xd7,
0x5e, 0x7b, 0xed, 0x87, 0x3f, 0xf4,
0xd1, 0x4d, 0x9b, 0x36, 0xfd, 0xd6,
0x6f, 0xfd, 0xd6, 0xd6, 0xad, 0x5b,
0xad, 0xf5, 0xd6, 0x7a, 0xa6, 0xb1,
0x8d, 0x1e, 0xc7, 0x0, 0xb6, 0x5a,
0xd9, 0x68, 0x8c, 0xc9, 0xf3, 0x9c,
0xc1, 0x97, 0x65, 0x49, 0xdd, 0xce,
0x86, 0xb9, 0x4d, 0xe7, 0x9e, 0x7b,
0xee, 0x8e, 0x1d, 0x3b, 0xee, 0xbd,
0xf7, 0xde, 0x7e, 0xbf, 0xf, 0x0,
0x7b, 0xf6, 0xec, 0xd9, 0xb3, 0x67,
0x8f, 0x73, 0xf4, 0xbd, 0xef, 0x7d,
0x6f, 0xf7, 0xee, 0xdd, 0x33, 0x33,
0x33, 0xbb, 0x76, 0xed, 0xd2, 0x5a,
0x9d, 0x77, 0xde, 0xf9, 0xdb, 0xb7,
0x6f, 0xf7, 0xce, 0x45, 0x91, 0x3a,
0xf1, 0xc4, 0x13, 0xbf, 0x7b, 0xd7,
0xdd, 0x6b, 0x59, 0x6, 0x38, 0x38,
0xba, 0x24, 0xc8, 0xc9, 0x4a, 0xa6,
0xce, 0x53, 0x55, 0x55, 0x9d, 0x4e,
0x7, 0x0, 0x9e, 0x7c, 0xf9, 0xcf,
0x5c, 0x7c, 0xf1, 0xc5, 0xa3, 0xc1,
0x50, 0x4a, 0xa9, 0x75, 0x7c, 0xd2,
0x49, 0x27, 0xcc, 0xcf, 0xcf, 0xb,
0x21, 0x4d, 0xed, 0xa4, 0x64, 0x66,
0x94, 0xa8, 0x82, 0xbc, 0xaa, 0xe3,
0x83, 0xf0, 0x65, 0x63, 0x76, 0xa,
0xb7, 0x7, 0x11, 0x93, 0x24, 0x71,
0xce, 0xd5, 0x75, 0x85, 0x88, 0x9d,
0x4e, 0xa7, 0x2c, 0x4b, 0x44, 0xb8,
0xfc, 0xf2, 0xcb, 0x2e, 0x7f, 0xf2,
0xcf, 0x5a, 0x6b, 0x8b, 0xa2, 0xb8,
0xf9, 0xe6, 0x9b, 0x3f, 0xff, 0xb9,
0x2f, 0xbc, 0xe1, 0xd, 0x6f, 0x78,
0xd7, 0xbb, 0xde, 0x29, 0x4e, 0xde,
0xe6, 0x7d, 0x30, 0xd9, 0xe9, 0xb1,
0x68, 0xe4, 0x3, 0x3d, 0xf1, 0xeb,
0x19, 0x54, 0x84, 0x37, 0x36, 0x98,
0xaf, 0x83, 0x41, 0x8, 0x11, 0x2f,
0xb8, 0xe0, 0x82, 0xdf, 0xfd, 0xdd,
0xdf, 0xb5, 0xd6, 0xee, 0xdb, 0xb7,
0xef, 0xfd, 0xef, 0x7b, 0x5f, 0xbb,
0xdd, 0x7e, 0xee, 0x73, 0x9f, 0x1b,
0xc7, 0x71, 0xbb, 0xdd, 0x3e, 0xff,
0xfc, 0xf3, 0x1b, 0xa5, 0x0, 0x22,
0x4d, 0x90, 0xbd, 0x38, 0x8, 0xdf,
0x13, 0x6, 0xa5, 0x1d, 0x91, 0xf,
0x45, 0xb1, 0x7a, 0xbd, 0x5e, 0xbb,
0x93, 0x5, 0xe5, 0xd0, 0xd9, 0x67,
0x9f, 0xfd, 0xe2, 0x17, 0xbf, 0xf8,
0xbe, 0x1f, 0xdc, 0x7b, 0xf3, 0xcd,
0x37, 0x5f, 0x7f, 0xfd, 0xf5, 0xe7,
0x9e, 0x7b, 0xee, 0x81, 0x3, 0x7,
0xfe, 0xe6, 0x6f, 0xfe, 0xa6, 0xd7,
0xeb, 0x5d, 0x7d, 0xf5, 0xb, 0x9f,
0xfb, 0xdc, 0xe7, 0x4a, 0x21, 0x8c,
0x31, 0x1e, 0x78, 0x62, 0x51, 0x17,
0x93, 0xe2, 0xb4, 0xd0, 0x88, 0x8e,
0xe3, 0x49, 0x19, 0x18, 0x88, 0x79,
0xec, 0x63, 0xd0, 0x6a, 0xb5, 0x82,
0x41, 0x38, 0x8a, 0xa2, 0xa2, 0xa8,
0x8c, 0x31, 0x1b, 0x37, 0x6e, 0xc,
0x8e, 0x13, 0x9b, 0x36, 0x6d, 0xda,
0xbc, 0x79, 0xb3, 0x94, 0x22, 0x8e,
0xe3, 0x34, 0x4d, 0x7b, 0x4b, 0xcb,
0x49, 0x96, 0x7a, 0xe, 0xbe, 0x3,
0xa1, 0xd2, 0x67, 0xc0, 0xe, 0x8c,
0x28, 0x27, 0xba, 0x8, 0x84, 0x49,
0x21, 0xbe, 0x80, 0x5e, 0x15, 0x2a,
0x63, 0xab, 0x60, 0xcd, 0xb6, 0xd6,
0xe, 0x87, 0xc3, 0x2d, 0x9b, 0xb7,
0x58, 0x6b, 0xdb, 0x9d, 0xd6, 0xcc,
0xcc, 0x4c, 0xb7, 0xdb, 0x35, 0xc6,
0xc, 0x87, 0x43, 0x22, 0x6a, 0xb5,
0x5a, 0x69, 0x1c, 0xe7, 0x65, 0x3d,
0x2e, 0xb, 0x46, 0x10, 0x8, 0x0,
0x30, 0x23, 0x8a, 0x9, 0xa3, 0x25,
0x1, 0x11, 0x51, 0x30, 0x5, 0x76,
0x0, 0x2, 0x26, 0x52, 0x4a, 0x75,
0x3a, 0x9d, 0xef, 0x7d, 0xef, 0x7b,
0x6f, 0x7b, 0xdb, 0xdb, 0x3e, 0xf5,
0xa9, 0x4f, 0x9d, 0x73, 0xce, 0xa3,
0x7f, 0xf5, 0x57, 0x7f, 0xf5, 0xd4,
0x53, 0x4f, 0xbd, 0xf3, 0xce, 0x3b,
0x3f, 0xf8, 0xc1, 0xf, 0xbe, 0xf7,
0xbd, 0xef, 0x6f, 0xb5, 0x5a, 0x7f,
0xf8, 0x87, 0x7f, 0xd8, 0xe9, 0x74,
0x8a, 0xaa, 0x8c, 0x22, 0x31, 0x3e,
0xa2, 0x31, 0x2e, 0x23, 0x60, 0x31,
0x89, 0xe2, 0xe0, 0x6, 0xc7, 0x5,
0xc, 0x45, 0x4, 0xcc, 0x24, 0x88,
0x84, 0x10, 0xdd, 0x6e, 0x17, 0x11,
0x85, 0x80, 0x27, 0x3e, 0xf1, 0x89,
0x57, 0x5c, 0x71, 0x45, 0x9a, 0xa6,
0x5f, 0xf9, 0xca, 0x57, 0xae, 0xbf,
0xfe, 0xfa, 0x77, 0xbd, 0xeb, 0x5d,
0xa7, 0x9f, 0x7e, 0xfa, 0xd3, 0x9e,
0xf6, 0xb4, 0xc0, 0x2d, 0xb, 0xb5,
0xba, 0x74, 0x6f, 0xa8, 0xc8, 0x2d,
0x60, 0xa5, 0xa8, 0x77, 0x60, 0x80,
0xc9, 0x3b, 0x27, 0x84, 0x78, 0xf3,
0x9b, 0xdf, 0xfc, 0x4f, 0xff, 0x74,
0xeb, 0x33, 0x9f, 0xfd, 0x8c, 0xbf,
0xfa, 0xcb, 0x77, 0x6e, 0xdc, 0xb8,
0x71, 0xd7, 0xae, 0x5d, 0x17, 0x5e,
0x78, 0xe1, 0x33, 0x9e, 0xf1, 0x8c,
0xd7, 0xfe, 0xfe, 0xef, 0xbd, 0xe7,
0x3d, 0xef, 0x51, 0x4a, 0xbd, 0xe6,
0x35, 0xff, 0x23, 0x8e, 0xd3, 0x40,
0x4f, 0x6a, 0x67, 0x57, 0xd4, 0x57,
0x2, 0x31, 0x38, 0xe2, 0x4c, 0xd9,
0x51, 0x1, 0x40, 0xab, 0xb8, 0xd3,
0xe9, 0xf4, 0x7a, 0x83, 0x28, 0x52,
0x17, 0x5e, 0x70, 0xf1, 0x53, 0x9e,
0xf2, 0x94, 0xb7, 0xbe, 0xf9, 0x2d,
0xff, 0xfb, 0xb, 0x37, 0x3d, 0xfc,
0xf4, 0x33, 0x3e, 0xf9, 0xc9, 0x4f,
0x2e, 0x2d, 0xf6, 0x2e, 0x7d, 0xd2,
0xa5, 0xdf, 0xf8, 0xc6, 0x37, 0xbe,
0x71, 0xc7, 0xb7, 0x4e, 0x3e, 0xf9,
0xe4, 0xbf, 0x7a, 0xe7, 0xbb, 0x67,
0x67, 0xe7, 0x9f, 0xfb, 0xdc, 0x5f,
0x9e, 0x9f, 0x9f, 0x5b, 0x58, 0xec,
0x29, 0x1d, 0x7, 0xd6, 0xbf, 0xd1,
0x3a, 0x8, 0x54, 0xc, 0x3e, 0x5c,
0x26, 0x89, 0xac, 0x95, 0xb2, 0xd6,
0x6, 0xc6, 0xc9, 0x5b, 0x5b, 0xe6,
0x39, 0x0, 0x5, 0xdb, 0xba, 0x8e,
0xc4, 0xa9, 0xf, 0xd9, 0xf9, 0xc8,
0x47, 0x9c, 0x39, 0x1a, 0x15, 0x81,
0xaf, 0x3b, 0xe3, 0x8c, 0x33, 0x66,
0xba, 0x73, 0xce, 0x19, 0xe7, 0x48,
0xeb, 0xb8, 0x2c, 0xeb, 0xda, 0x18,
0x44, 0xb4, 0x9e, 0x32, 0x94, 0x28,
0x95, 0x98, 0xd4, 0x85, 0xa, 0xea,
0x5c, 0x1, 0x2, 0xa4, 0x8, 0x16,
0xa0, 0xd1, 0x68, 0x4, 0x0, 0xed,
0x56, 0xda, 0xef, 0xf7, 0xb5, 0xd6,
0x71, 0x1c, 0x3, 0xc3, 0x5, 0x8f,
0xbd, 0xe8, 0xca, 0x2b, 0xaf, 0x4,
0xe6, 0x76, 0xab, 0xbb, 0x63, 0xfb,
0x43, 0x6e, 0xff, 0xfa, 0x1d, 0xc6,
0x98, 0xb2, 0xae, 0xa4, 0x94, 0x81,
0xa7, 0x31, 0xa6, 0x2e, 0x4d, 0x1d,
0x38, 0xea, 0xc6, 0x3c, 0x8e, 0x42,
0x48, 0xa1, 0x83, 0x8f, 0x98, 0xc,
0x56, 0x53, 0x21, 0xc7, 0xd1, 0xf0,
0x0, 0x4a, 0x32, 0x91, 0x7f, 0xe8,
0x69, 0xf, 0x7b, 0xc5, 0x6f, 0xfe,
0xf6, 0xa6, 0x4d, 0x1b, 0x3e, 0xfe,
0xf1, 0xeb, 0xbf, 0xfc, 0xa5, 0xaf,
0x30, 0xf3, 0xd3, 0xff, 0xdb, 0x33,
0x2f, 0xb8, 0xe0, 0x82, 0xba, 0xae,
0x75, 0x24, 0x27, 0x4e, 0x5d, 0x82,
0x49, 0x4a, 0xe1, 0xad, 0xf7, 0x8e,
0xc9, 0x3, 0x4b, 0xa9, 0x8, 0x58,
0x4a, 0x19, 0xcc, 0x60, 0x42, 0x8,
0x44, 0x2d, 0xd1, 0x4a, 0x94, 0x42,
0x28, 0x29, 0x74, 0x5d, 0x19, 0x29,
0xa5, 0xb7, 0xee, 0x91, 0x67, 0x3c,
0xf2, 0x1d, 0xef, 0xf8, 0x8b, 0x3f,
0xfe, 0xe3, 0x3f, 0xfe, 0xb3, 0x3f,
0xfb, 0xf3, 0xdb, 0x6e, 0xbb, 0x63,
0xd0, 0xeb, 0xdf, 0x72, 0xcb, 0x2d,
0xaf, 0x7f, 0xfd, 0xeb, 0x5f, 0xf9,
0xca, 0x57, 0x6a, 0xad, 0x8b, 0x7c,
0xe4, 0xd9, 0x1, 0x0, 0x4b, 0x9c,
0x40, 0x2f, 0x6, 0x47, 0x9d, 0x89,
0xc6, 0x2e, 0x10, 0x80, 0x31, 0x3,
0x1f, 0x18, 0x60, 0x60, 0x51, 0x55,
0x26, 0x7c, 0xd1, 0x39, 0x2, 0x80,
0x2c, 0x6b, 0x8f, 0x46, 0x5, 0x33,
0x12, 0x41, 0x59, 0xd6, 0xde, 0x73,
0x14, 0x25, 0xde, 0x73, 0x55, 0x19,
0xad, 0x63, 0xef, 0x79, 0x95, 0x52,
0xf, 0x11, 0x51, 0x28, 0x89, 0x82,
0x71, 0x92, 0xad, 0x29, 0x20, 0x6a,
0x62, 0xef, 0xd8, 0x39, 0x87, 0x8e,
0x84, 0x50, 0xd6, 0xda, 0xaa, 0x32,
0xd6, 0xda, 0x6e, 0x77, 0xb6, 0x36,
0x36, 0x49, 0x32, 0x22, 0xb0, 0xd6,
0x2b, 0x15, 0x1, 0x8, 0x29, 0xb5,
0x52, 0x8, 0x20, 0xf2, 0xbc, 0x74,
0x63, 0xff, 0x7, 0x1f, 0xec, 0x4,
0x63, 0x93, 0xb7, 0x18, 0x13, 0x1e,
0x21, 0x43, 0xb1, 0x12, 0x20, 0x22,
0xe7, 0xc6, 0x9e, 0x12, 0x20, 0xa4,
0xb5, 0x7e, 0x34, 0x5a, 0xbc, 0xf6,
0xda, 0xf7, 0x5e, 0x7b, 0xed, 0x7b,
0x5f, 0xf4, 0xa2, 0x17, 0xbd, 0xed,
0x6d, 0x6f, 0xb, 0x4e, 0x69, 0xe7,
0x9e, 0xfb, 0x98, 0xe7, 0x3d, 0xef,
0xf9, 0x57, 0x5f, 0x7d, 0xf5, 0x3b,
0xde, 0xf1, 0x17, 0xf, 0x7b, 0xd8,
0x19, 0x2f, 0x78, 0xc1, 0xb, 0x0,
0x44, 0x59, 0xd7, 0x20, 0x54, 0x40,
0xa9, 0x63, 0x77, 0x10, 0x21, 0xc6,
0x31, 0xc9, 0xce, 0x83, 0x60, 0x9c,
0x54, 0x15, 0x24, 0xa, 0x5a, 0x15,
0x2f, 0xa4, 0xcc, 0xf3, 0x32, 0x20,
0x2c, 0x29, 0xf5, 0xc5, 0x17, 0x5f,
0xf2, 0xd2, 0x97, 0xfe, 0x86, 0xd6,
0xfa, 0x89, 0x4f, 0xbc, 0x34, 0xcb,
0xda, 0x1f, 0xf9, 0xc8, 0x47, 0xee,
0xb8, 0xe3, 0x9b, 0x4f, 0x7d, 0xea,
0xd3, 0xc2, 0x92, 0x84, 0x92, 0x8e,
0x57, 0x94, 0xc4, 0x63, 0xc7, 0x1,
0x64, 0xb, 0x0, 0xec, 0x6d, 0xd0,
0x19, 0x7a, 0xef, 0x94, 0x16, 0x9e,
0x70, 0x54, 0xc, 0xef, 0xdf, 0xbb,
0xd7, 0x33, 0xef, 0x3c, 0xed, 0xf4,
0xda, 0x53, 0x6f, 0x94, 0xcf, 0x6f,
0xde, 0xd2, 0xef, 0xf7, 0xa3, 0xac,
0x35, 0x33, 0x33, 0x63, 0x8c, 0xfb,
0xc1, 0x7d, 0xbb, 0x8, 0x81, 0x0,
0x3c, 0x73, 0x4d, 0x4e, 0x42, 0x4,
0x88, 0x20, 0x80, 0x24, 0x93, 0x27,
0x46, 0x8f, 0x88, 0x84, 0x14, 0x3c,
0xb1, 0x4c, 0x65, 0xb5, 0x8c, 0x81,
0xc0, 0x1b, 0x8e, 0xe3, 0x54, 0x4a,
0xac, 0x9d, 0x7f, 0xf6, 0x73, 0x7e,
0xe9, 0x53, 0x9f, 0xba, 0xe1, 0xb3,
0x9f, 0xff, 0x2, 0x8, 0xf9, 0xd5,
0x7f, 0xba, 0xe5, 0xff, 0xf8, 0x9d,
0x57, 0xff, 0xdc, 0xcf, 0xfd, 0xdc,
0x95, 0x57, 0x5e, 0xf9, 0xa1, 0x8f,
0x7e, 0xe4, 0xae, 0xef, 0xdf, 0xa3,
0xa3, 0xec, 0x99, 0xcf, 0x79, 0xc6,
0x69, 0xf, 0x3f, 0xa3, 0x72, 0xc4,
0x2, 0x3d, 0x70, 0xed, 0xc, 0xa0,
0x67, 0x70, 0xde, 0x87, 0x22, 0x94,
0x6e, 0x25, 0x4e, 0x4d, 0x4a, 0x63,
0x3c, 0x0, 0x58, 0xeb, 0xbd, 0x1f,
0xa7, 0xad, 0x90, 0x52, 0x3b, 0xe7,
0x88, 0x40, 0x4a, 0xbd, 0xef, 0xc0,
0xfe, 0xbb, 0xee, 0xfe, 0x77, 0x64,
0x41, 0x44, 0x0, 0x62, 0xe7, 0xce,
0x9d, 0x45, 0x55, 0x4b, 0x89, 0x24,
0xa4, 0x21, 0xf, 0x4a, 0xca, 0x48,
0xd7, 0xde, 0x33, 0x82, 0xf5, 0x4e,
0xb1, 0x26, 0x0, 0x4f, 0x34, 0x25,
0x63, 0x83, 0xf0, 0x60, 0xac, 0xcd,
0xab, 0x1c, 0x95, 0xac, 0xeb, 0x7a,
0x30, 0xcc, 0x3d, 0x81, 0x64, 0x8c,
0xe2, 0x16, 0x31, 0x7c, 0xf8, 0x6f,
0x3e, 0xfa, 0x8f, 0x9f, 0xfb, 0xfc,
0x68, 0x34, 0x12, 0x80, 0x77, 0xdd,
0x75, 0xd7, 0xe6, 0xcd, 0x9b, 0xaf,
0x79, 0xf3, 0x9b, 0x4e, 0x39, 0xe5,
0x14, 0xe3, 0x5d, 0x65, 0x8c, 0xd6,
0xda, 0x21, 0x33, 0x12, 0x9, 0xb4,
0xb6, 0x4e, 0x20, 0xf5, 0xec, 0x2d,
0x79, 0x26, 0x70, 0x14, 0x5c, 0x32,
0x5, 0xb, 0x76, 0xe3, 0x43, 0x13,
0x42, 0x28, 0x66, 0x36, 0xc6, 0x79,
0xef, 0x5, 0xa0, 0x44, 0xe5, 0x2d,
0x44, 0x2a, 0x26, 0x82, 0x6e, 0x77,
0x26, 0xdc, 0x4e, 0xe3, 0x89, 0x2c,
0x44, 0x4a, 0xb, 0xc1, 0x4, 0x82,
0x90, 0x2c, 0x38, 0x16, 0x9e, 0xa4,
0x27, 0xe9, 0x5d, 0xa8, 0xb3, 0x1,
0x63, 0xb5, 0xa7, 0x6, 0xc9, 0xcc,
0xd6, 0x3b, 0xe9, 0x85, 0x4, 0xe9,
0x6a, 0x2, 0x1a, 0x53, 0x21, 0x53,
0xd3, 0xb6, 0x93, 0x76, 0xfc, 0xc9,
0x1b, 0xde, 0xfc, 0xa8, 0xb3, 0xcf,
0x7d, 0xf5, 0xab, 0x5e, 0xb5, 0x65,
0xeb, 0xd6, 0xf, 0x7e, 0xe8, 0xa3,
0x97, 0x5f, 0x7e, 0xb9, 0xb1, 0xec,
0xc9, 0xd7, 0x86, 0xe2, 0x24, 0xf6,
0xde, 0xd6, 0x95, 0xed, 0x76, 0xc0,
0x3a, 0xc7, 0xc8, 0x35, 0x55, 0x51,
0x14, 0x59, 0xe7, 0xb1, 0xe1, 0xbc,
0x10, 0x5, 0x50, 0xd0, 0x36, 0x7,
0x96, 0xde, 0x1a, 0x93, 0x65, 0x59,
0x50, 0xed, 0x26, 0x49, 0x12, 0xfc,
0x2b, 0x1, 0xa0, 0xd7, 0xeb, 0x49,
0x29, 0xcb, 0xb2, 0xc, 0x9e, 0x7c,
0x71, 0x1c, 0x8f, 0x46, 0x23, 0xa5,
0x83, 0xd3, 0xa8, 0x77, 0xce, 0x79,
0x26, 0xcf, 0xce, 0xb2, 0x73, 0xe4,
0xcc, 0xc4, 0x1d, 0xd0, 0x5a, 0x1f,
0xe4, 0x2f, 0x29, 0xa5, 0x73, 0x1e,
0x41, 0x5a, 0x6b, 0xeb, 0xba, 0xec,
0x74, 0x5b, 0xe3, 0xe2, 0x98, 0xc6,
0x4, 0xfb, 0x62, 0x60, 0xc1, 0xaa,
0xaa, 0x8, 0xb6, 0x12, 0x44, 0xe1,
0x9c, 0x21, 0x4, 0x44, 0xac, 0xad,
0xb1, 0xde, 0x11, 0x78, 0xb, 0xec,
0xd1, 0x92, 0x44, 0xcf, 0x2e, 0x20,
0x8, 0x26, 0x46, 0xa6, 0x28, 0x8a,
0x18, 0x81, 0x18, 0x88, 0xd1, 0x33,
0x54, 0xc3, 0x62, 0x66, 0x66, 0xa6,
0xac, 0xcc, 0x7d, 0xbb, 0xee, 0x27,
0xc6, 0xf9, 0xd, 0x9b, 0x6a, 0xe3,
0xa2, 0x28, 0x41, 0xc4, 0xa2, 0x1c,
0x6c, 0xd8, 0xb0, 0xe1, 0xe4, 0xed,
0x3b, 0x0, 0xc4, 0xfd, 0x7b, 0xf6,
0x79, 0x2, 0xad, 0x62, 0xf6, 0xce,
0x39, 0x47, 0xcc, 0xd6, 0x5b, 0xcb,
0x4, 0x12, 0xca, 0x89, 0xe3, 0xa,
0x3, 0x7b, 0x2f, 0x84, 0x80, 0xca,
0xd7, 0x91, 0xd0, 0xd6, 0xb9, 0x28,
0x52, 0xde, 0x3, 0x48, 0x28, 0xeb,
0xaa, 0xac, 0xab, 0xd9, 0xf9, 0x39,
0xcf, 0xf4, 0xb6, 0x3f, 0x7d, 0xfb,
0xdf, 0x5e, 0xf7, 0x77, 0x4d, 0xbd,
0xde, 0xd7, 0xbd, 0xfe, 0x8f, 0x5e,
0xf8, 0xc2, 0x17, 0xa2, 0x14, 0x75,
0x61, 0x94, 0x52, 0x95, 0x31, 0x59,
0x1b, 0x3c, 0x11, 0x3, 0x70, 0x30,
0x67, 0x8, 0xa1, 0xd6, 0xf5, 0xff,
0x10, 0x42, 0x68, 0xad, 0xb7, 0x6f,
0xdf, 0x4e, 0x44, 0xdf, 0xfa, 0xd6,
0xb7, 0xac, 0xb5, 0x9d, 0x76, 0xe7,
0x96, 0x5b, 0x6f, 0xb9, 0xe9, 0xa6,
0x2f, 0x9f, 0x79, 0xe6, 0x19, 0xbb,
0x76, 0xed, 0x4a, 0xd3, 0x74, 0xe7,
0x43, 0x4e, 0x4b, 0xe2, 0x2c, 0x48,
0x23, 0x51, 0x14, 0x4f, 0xdb, 0xe8,
0x83, 0x9f, 0xe3, 0xb4, 0xb4, 0x2e,
0xa5, 0x14, 0x4a, 0x36, 0xc9, 0xb5,
0xeb, 0xba, 0x96, 0x52, 0x6e, 0xde,
0xbc, 0x79, 0xc7, 0xce, 0x9d, 0x5f,
0xfb, 0xda, 0xd7, 0x86, 0x9f, 0xf8,
0xc4, 0xde, 0xbd, 0x7b, 0x4f, 0x3b,
0xed, 0xb4, 0x93, 0x4e, 0x3a, 0x69,
0xdb, 0x49, 0xdb, 0x77, 0xdd, 0x77,
0xff, 0x77, 0xef, 0xfa, 0x90, 0x27,
0x7f, 0xf1, 0xc5, 0x17, 0x26, 0x49,
0x54, 0x96, 0x39, 0xb3, 0xaf, 0xeb,
0x5a, 0x6b, 0xd, 0x28, 0x0, 0x45,
0xa0, 0x60, 0x13, 0xcf, 0xcd, 0x95,
0x4c, 0x14, 0x2, 0x27, 0x59, 0xf8,
0xa4, 0x8, 0xe, 0x6f, 0x42, 0xa8,
0xc0, 0xc8, 0x5d, 0x71, 0xc5, 0xcf,
0xbd, 0xe8, 0x85, 0x2f, 0xb2, 0xc6,
0x44, 0x51, 0x64, 0xad, 0xd7, 0x5a,
0xe, 0x46, 0x43, 0x44, 0x1e, 0xe6,
0xa5, 0x52, 0x2a, 0xd8, 0x15, 0x42,
0x5e, 0xeb, 0x86, 0xac, 0xac, 0x4a,
0x5, 0x1e, 0xd8, 0xda, 0xe0, 0x49,
0x12, 0x45, 0x91, 0x31, 0xa6, 0xb2,
0x63, 0x27, 0x64, 0x21, 0xe5, 0x93,
0x9f, 0xfc, 0xe4, 0x2b, 0xaf, 0xbc,
0xb2, 0xdd, 0x6e, 0x57, 0x45, 0x79,
0xed, 0xb5, 0xd7, 0x7e, 0xf4, 0xa3,
0x1f, 0x7d, 0xf7, 0xbb, 0xdf, 0xfd,
0xd6, 0xb7, 0xbe, 0xd9, 0x3, 0x7b,
0xef, 0xa7, 0x5d, 0xea, 0x1a, 0xdc,
0x39, 0x35, 0xd5, 0x2a, 0xcf, 0x1b,
0x4f, 0x40, 0xc4, 0x24, 0x19, 0x99,
0x89, 0x11, 0x19, 0x8, 0x90, 0x3c,
0xd9, 0x85, 0x85, 0xfd, 0xcc, 0xde,
0x83, 0x27, 0x24, 0xa5, 0x84, 0x52,
0x2a, 0xf8, 0x3f, 0x31, 0xae, 0xf6,
0x9e, 0x5d, 0x77, 0xfc, 0x46, 0x63,
0x8f, 0x18, 0x5c, 0xaf, 0x85, 0x94,
0x18, 0x3c, 0x84, 0x37, 0x6f, 0xde,
0xf8, 0x88, 0x47, 0x3c, 0x3c, 0xcd,
0x92, 0x2d, 0x5b, 0x36, 0x9d, 0x77,
0xde, 0x39, 0xed, 0x76, 0x36, 0x1c,
0xe, 0xd3, 0x34, 0x8d, 0xa2, 0xa8,
0xc9, 0xcc, 0xbc, 0x56, 0xd, 0x33,
0x3d, 0x7e, 0xf0, 0x21, 0x6d, 0x26,
0xd, 0x80, 0xe7, 0xbd, 0xf, 0x6a,
0x64, 0x63, 0x4c, 0xa7, 0xd3, 0x91,
0x52, 0xb6, 0x5a, 0xad, 0xc6, 0x7,
0x33, 0x70, 0x4c, 0x51, 0x14, 0x11,
0x1f, 0x94, 0x51, 0xa4, 0x51, 0xe,
0x37, 0xe3, 0xaf, 0xdd, 0x57, 0x96,
0x65, 0x88, 0x8c, 0x20, 0xbd, 0x77,
0xcc, 0x3e, 0xcf, 0xf3, 0x34, 0x4d,
0x99, 0x39, 0x14, 0xeb, 0xa, 0x96,
0xf9, 0x30, 0x94, 0xf7, 0xbe, 0x76,
0x56, 0xc9, 0x48, 0x1c, 0x9c, 0x2c,
0x79, 0x95, 0x3f, 0x55, 0xb3, 0x91,
0xa6, 0xaa, 0x41, 0x96, 0x65, 0xbd,
0xfe, 0x52, 0xa7, 0xd3, 0x79, 0xe8,
0xe9, 0xa7, 0x32, 0xbb, 0x7d, 0xfb,
0xf7, 0x78, 0xb2, 0xc, 0x72, 0x34,
0xca, 0x5b, 0xed, 0xb4, 0x3f, 0x58,
0xfe, 0xf6, 0x77, 0xbe, 0x5, 0x48,
0xdb, 0x4e, 0x3e, 0x11, 0x90, 0x6a,
0x53, 0xa3, 0xd4, 0xeb, 0xae, 0x79,
0xd5, 0x2d, 0x3a, 0xe8, 0xd0, 0x10,
0x5b, 0xad, 0x56, 0x5d, 0xd7, 0xc3,
0xe1, 0x50, 0x4a, 0xf9, 0xd4, 0xa7,
0x3e, 0xf5, 0x17, 0x7e, 0xe1, 0x17,
0x82, 0x71, 0x6b, 0xcb, 0x96, 0x2d,
0x67, 0x9f, 0x7d, 0xf6, 0xdc, 0xec,
0xdc, 0xd2, 0xf2, 0xd2, 0xd8, 0xaf,
0xd9, 0x39, 0xe6, 0xd5, 0xd6, 0x47,
0xd5, 0x24, 0x6a, 0xf, 0xa4, 0xd9,
0x39, 0xe7, 0x3d, 0xa2, 0x60, 0x44,
0xf9, 0xb2, 0x97, 0xbd, 0xcc, 0x39,
0x77, 0xcd, 0x1b, 0xdf, 0x78, 0xee,
0xb9, 0xe7, 0x5e, 0x7e, 0xf9, 0xe5,
0x1b, 0x37, 0x6e, 0xbc, 0xee, 0xba,
0x4f, 0xec, 0xd9, 0x7d, 0x5f, 0x14,
0x45, 0xbf, 0xf9, 0x9b, 0x2f, 0x7b,
0xf5, 0xab, 0x5f, 0x6d, 0x8c, 0x41,
0x94, 0x44, 0x30, 0x18, 0xc, 0xe6,
0xe6, 0x82, 0x2f, 0xfb, 0xb8, 0xe,
0x4d, 0xf0, 0x1, 0x22, 0x1a, 0xb,
0xa7, 0xa, 0xd8, 0x5a, 0x2b, 0x25,
0xd6, 0xd6, 0x24, 0x69, 0x6c, 0xad,
0xcf, 0xf3, 0x7c, 0x76, 0x76, 0xfe,
0xaa, 0xab, 0xae, 0xba, 0xfd, 0xf6,
0xdb, 0xff, 0xed, 0xce, 0x3b, 0x9f,
0xf2, 0xd4, 0xa7, 0x3e, 0xea, 0x51,
0x8f, 0x6a, 0xb5, 0x5a, 0x2f, 0x79,
0xc9, 0x4b, 0x5e, 0xf9, 0xca, 0x57,
0xee, 0xdf, 0xbf, 0xe7, 0x97, 0x9e,
0xf7, 0xbc, 0x73, 0xce, 0x79, 0x74,
0xe0, 0x72, 0x89, 0xa8, 0xd5, 0x4a,
0x83, 0x5, 0xd2, 0x5a, 0xb, 0x20,
0xc8, 0x83, 0x10, 0x2b, 0x89, 0xe6,
0x85, 0x10, 0x2, 0xc7, 0x72, 0x5a,
0x0, 0x15, 0x6b, 0x7d, 0x5d, 0xd7,
0x8e, 0x8, 0x0, 0x8a, 0xbc, 0xbc,
0xe6, 0x9a, 0x6b, 0x3e, 0xf2, 0x91,
0x8f, 0x14, 0x45, 0xa1, 0xb5, 0x36,
0xb5, 0xdb, 0xf1, 0x90, 0xed, 0x2f,
0x7c, 0xe1, 0xb, 0x2f, 0xb8, 0xe0,
0xfc, 0x80, 0x4d, 0x92, 0x24, 0x13,
0x42, 0x5, 0x27, 0xca, 0xa0, 0xc3,
0x23, 0x10, 0xde, 0xd3, 0x74, 0x4a,
0x35, 0x4, 0x51, 0x14, 0x5, 0x11,
0x94, 0x65, 0x19, 0x26, 0x8a, 0xa2,
0xa8, 0xa8, 0x2b, 0xe3, 0x1d, 0x82,
0xcc, 0xd2, 0xf6, 0xe9, 0xa7, 0x9f,
0xde, 0xef, 0xf7, 0x4f, 0x3a, 0xe9,
0xa4, 0x5f, 0xbe, 0xea, 0xf9, 0x5f,
0xfe, 0xca, 0xcd, 0x5f, 0xfd, 0xea,
0x57, 0x6f, 0xfb, 0xc6, 0x1d, 0xe7,
0x9c, 0x73, 0x4e, 0x14, 0x45, 0x65,
0x59, 0xce, 0xa6, 0x99, 0x40, 0x95,
0xe7, 0x79, 0xa3, 0x3b, 0xf5, 0x9e,
0x85, 0xe0, 0xa6, 0xb8, 0x5c, 0xf0,
0x8a, 0x61, 0x24, 0xcf, 0xce, 0x7,
0x1f, 0x29, 0x29, 0x27, 0x52, 0xa5,
0x7, 0x20, 0x63, 0x2a, 0x14, 0xc,
0x48, 0x45, 0x31, 0xb2, 0xb6, 0x6,
0xc1, 0xc6, 0x54, 0x4a, 0x4, 0x8f,
0x11, 0xe, 0x37, 0x95, 0xfc, 0x58,
0xd, 0x19, 0x9c, 0x7, 0xc3, 0xdb,
0x1, 0x80, 0x10, 0x21, 0x10, 0x5e,
0x71, 0x59, 0xe6, 0x3a, 0x6a, 0xa3,
0xe0, 0xa2, 0x1c, 0xa5, 0x69, 0xaa,
0xb4, 0xc8, 0x8b, 0x61, 0x14, 0x2b,
0x4f, 0xd6, 0x79, 0xd3, 0x1f, 0x2c,
0xe7, 0xc5, 0xd0, 0x79, 0xa3, 0x23,
0xe9, 0xc9, 0x7a, 0xf2, 0x8d, 0xd8,
0xc9, 0x2b, 0x1c, 0x20, 0x35, 0x82,
0xe2, 0x4a, 0xa6, 0x62, 0x80, 0x60,
0x2f, 0xf1, 0xde, 0x3b, 0x6f, 0xa4,
0xc2, 0xc5, 0xe5, 0x85, 0x2c, 0xcb,
0x2e, 0x7b, 0xf2, 0x4f, 0xbf, 0xe8,
0x57, 0x5f, 0x78, 0xed, 0x7b, 0xfe,
0xfa, 0xc9, 0x4f, 0xf9, 0x99, 0xc7,
0x3f, 0xfe, 0xf1, 0x5b, 0xb7, 0x6e,
0xfd, 0xe6, 0x37, 0xbf, 0xf9, 0xa5,
0x2f, 0x7d, 0x69, 0xcb, 0x96, 0x2d,
0xcf, 0x7c, 0xf6, 0x33, 0xa4, 0x16,
0xf9, 0xa0, 0x50, 0x32, 0x6a, 0x86,
0x6d, 0xd4, 0xa8, 0xa1, 0x68, 0xf0,
0x78, 0xfd, 0xde, 0x3, 0x80, 0x44,
0x15, 0x98, 0x4f, 0x6b, 0x6d, 0x59,
0xd5, 0xc1, 0x7a, 0x6c, 0x8c, 0xc9,
0xb2, 0x2c, 0xd2, 0x49, 0x55, 0x55,
0x45, 0x51, 0x78, 0xe7, 0xac, 0xb5,
0x45, 0x51, 0x19, 0xe3, 0x9c, 0x1b,
0x3b, 0x5a, 0x5, 0x57, 0xed, 0xf1,
0xd5, 0x67, 0x41, 0x64, 0xbd, 0x63,
0x37, 0x36, 0xc8, 0x87, 0x8b, 0xea,
0x89, 0x41, 0x8, 0xdf, 0x2c, 0xc0,
0x58, 0xe3, 0x3c, 0x87, 0x9f, 0xbf,
0xe0, 0x5, 0x2f, 0x40, 0xc4, 0x6b,
0xae, 0xb9, 0xe6, 0x7d, 0xef, 0x7b,
0xdf, 0xf3, 0x9e, 0xf7, 0xbc, 0x53,
0x4e, 0x39, 0xe5, 0xdb, 0xdf, 0xfe,
0xf6, 0xd, 0x37, 0xdc, 0x90, 0x65,
0xd9, 0x35, 0x6f, 0x7a, 0xd3, 0xb3,
0x9e, 0xf5, 0xac, 0x80, 0x71, 0x42,
0x8, 0x4a, 0x83, 0x20, 0xbc, 0xf7,
0x63, 0x61, 0x7b, 0xe2, 0x96, 0xd7,
0xf8, 0xbd, 0x87, 0xcd, 0x11, 0x51,
0xe9, 0xcc, 0xcc, 0xcc, 0x4c, 0x5d,
0xd7, 0xa1, 0xce, 0xf6, 0xc9, 0x27,
0x9f, 0xfc, 0xc4, 0x27, 0x3e, 0xd1,
0x5a, 0x1b, 0x90, 0xbe, 0x73, 0x6e,
0xff, 0x81, 0xfd, 0x61, 0xf0, 0xb2,
0x2c, 0x41, 0x28, 0x66, 0x60, 0x6,
0x22, 0x6e, 0x3e, 0x6a, 0xa, 0x49,
0xc8, 0xc6, 0x73, 0x15, 0x98, 0x98,
0x39, 0x49, 0x92, 0x97, 0xbf, 0xfc,
0xe5, 0x1b, 0x36, 0x6c, 0xb8, 0xee,
0xba, 0xeb, 0x6e, 0xb8, 0xe1, 0x86,
0x24, 0x49, 0x84, 0x50, 0x8f, 0x79,
0xec, 0x85, 0xfd, 0xe5, 0xc5, 0xcf,
0x7e, 0xf6, 0xb3, 0x67, 0x9c, 0x79,
0xd6, 0xa5, 0x97, 0x5e, 0xda, 0x6e,
0x77, 0xbd, 0xf7, 0x69, 0x9a, 0x6a,
0x15, 0xaf, 0xf8, 0x5a, 0xae, 0x20,
0x98, 0x9, 0xee, 0x61, 0x66, 0x66,
0x29, 0x75, 0x38, 0xa0, 0x70, 0xa0,
0xd6, 0xda, 0x1d, 0x3b, 0x76, 0x3c,
0xe9, 0x49, 0x4f, 0xfa, 0xe2, 0x17,
0xbf, 0xb8, 0x73, 0xe7, 0xce, 0x2d,
0x5b, 0xb6, 0x64, 0x59, 0x76, 0xea,
0xa9, 0xa7, 0x5e, 0xfc, 0xb8, 0xb,
0x6f, 0xbb, 0xe3, 0x8e, 0x73, 0xcf,
0xfb, 0xa9, 0x6e, 0xb7, 0x9b, 0xa6,
0xe9, 0x68, 0x54, 0xe4, 0x79, 0x3e,
0x3f, 0xbf, 0x31, 0xec, 0x44, 0x8,
0x25, 0x50, 0x81, 0x8, 0xb9, 0xf6,
0xc5, 0xb4, 0xc7, 0x45, 0x53, 0x8a,
0x2d, 0xdc, 0x86, 0x0, 0x63, 0x5b,
0xb6, 0x6c, 0x39, 0xf3, 0x91, 0x8f,
0xf0, 0x9e, 0xf7, 0xec, 0xd9, 0x13,
0x2c, 0xde, 0x75, 0x65, 0xe7, 0xe6,
0x67, 0xc2, 0x66, 0x83, 0x55, 0x4d,
0x4a, 0xaf, 0x35, 0x7, 0xf9, 0x79,
0x8c, 0xfe, 0x61, 0x2c, 0x67, 0x4f,
0x53, 0x6, 0xa5, 0x74, 0xb0, 0x3c,
0x37, 0xfe, 0x83, 0xce, 0xb9, 0x93,
0x4f, 0x3e, 0xf9, 0xd4, 0x53, 0x4f,
0xd, 0x41, 0xe, 0x73, 0x73, 0x73,
0xad, 0x56, 0x6b, 0x6e, 0x6e, 0xee,
0xac, 0xb3, 0xce, 0x1a, 0xc, 0x6,
0xc1, 0xea, 0x1b, 0x3c, 0x4e, 0x82,
0x32, 0xa9, 0xa9, 0x17, 0x77, 0x18,
0xbf, 0xb9, 0x66, 0xf1, 0x84, 0x93,
0xa0, 0xa, 0xa2, 0xc0, 0x56, 0x9d,
0x7d, 0xf6, 0xd9, 0xed, 0x76, 0x3b,
0xac, 0x21, 0xa8, 0x97, 0x94, 0x90,
0x13, 0x8b, 0x5, 0xc3, 0x94, 0x63,
0xa9, 0x38, 0x38, 0x8a, 0x63, 0x3a,
0xa8, 0x23, 0x14, 0x4, 0xc, 0x7e,
0x17, 0x4a, 0xa9, 0x10, 0x13, 0x16,
0xa6, 0x78, 0xf4, 0xa3, 0x1f, 0xbd,
0x6d, 0xdb, 0x36, 0x66, 0x1e, 0x8d,
0x46, 0xc1, 0xae, 0x1b, 0x18, 0x13,
0x22, 0xf2, 0x9e, 0xa7, 0xab, 0x46,
0x87, 0x48, 0x95, 0x43, 0xe6, 0x16,
0x40, 0xb4, 0xd6, 0x26, 0x49, 0x62,
0x8c, 0x89, 0xa2, 0xe8, 0x45, 0x2f,
0x7a, 0x91, 0xd6, 0xfa, 0x33, 0x9f,
0xf9, 0xcc, 0x4d, 0x37, 0xdd, 0x14,
0xc7, 0x71, 0x59, 0x96, 0x97, 0x5d,
0x76, 0xd9, 0xe5, 0x97, 0x5f, 0x7e,
0xfe, 0xf9, 0xe7, 0x87, 0xfa, 0x80,
0xde, 0x1d, 0xe4, 0x10, 0xde, 0x50,
0xe0, 0xb5, 0x74, 0x6c, 0xc5, 0x47,
0x22, 0xd2, 0xa, 0x21, 0x5c, 0xa7,
0xba, 0xae, 0x99, 0xb9, 0xaa, 0xaa,
0x13, 0x4f, 0x3c, 0xf1, 0x9c, 0x73,
0xcf, 0x3d, 0xe3, 0x8c, 0x33, 0xc2,
0x9b, 0x9d, 0xb0, 0xdf, 0x96, 0x5,
0x6, 0xd7, 0x3a, 0xc, 0x39, 0x0,
0x58, 0xc0, 0x6a, 0xe, 0xab, 0xd1,
0xbc, 0x8a, 0xc6, 0x9a, 0x15, 0x2,
0x71, 0x16, 0x17, 0x17, 0xbb, 0xdd,
0xee, 0x4b, 0x5e, 0xf2, 0x92, 0x2c,
0xcb, 0x3e, 0xf8, 0xc1, 0xf, 0xde,
0x7c, 0xf3, 0xcd, 0x5f, 0xfc, 0xe2,
0x17, 0xad, 0xb5, 0x67, 0x9d, 0x75,
0xd6, 0x8b, 0x5f, 0xfc, 0xe2, 0x2b,
0xae, 0xb8, 0x22, 0x6c, 0xd6, 0x5a,
0xb, 0x2b, 0xfc, 0x6c, 0xa3, 0x18,
0x16, 0x53, 0xd9, 0x42, 0x57, 0x92,
0xfb, 0x35, 0x19, 0x20, 0xbd, 0x1d,
0xfb, 0x5f, 0x6c, 0xdc, 0xb8, 0xf1,
0xac, 0xb3, 0xce, 0x3a, 0xe1, 0x84,
0x13, 0x9a, 0xb0, 0xad, 0x2c, 0xcb,
0x82, 0x81, 0x7a, 0xca, 0xad, 0x65,
0x7c, 0xb6, 0xd3, 0x2b, 0x57, 0xc1,
0xe9, 0x7d, 0xa2, 0xa9, 0x17, 0x44,
0xec, 0x9c, 0x65, 0xf0, 0x88, 0x58,
0x97, 0x45, 0x1c, 0xc7, 0x57, 0x5e,
0x79, 0xe5, 0xf3, 0x9f, 0xff, 0x7c,
0xa5, 0x22, 0x6b, 0x6d, 0x30, 0xf,
0x6a, 0x89, 0xfb, 0xf6, 0xed, 0xeb,
0xcc, 0xcc, 0x38, 0xe7, 0x6, 0x83,
0x81, 0xd6, 0x3a, 0xef, 0x55, 0x91,
0x4e, 0x26, 0x8b, 0x2, 0xf2, 0x80,
0x10, 0x9c, 0x7b, 0x69, 0x92, 0x59,
0x9b, 0x99, 0x82, 0xc2, 0xd0, 0xf7,
0xfa, 0x3, 0xad, 0x95, 0x14, 0x30,
0x1a, 0x8d, 0x76, 0xec, 0xd8, 0xf1,
0xc6, 0x37, 0xbe, 0x31, 0xf0, 0xa5,
0x79, 0x5e, 0x1e, 0x58, 0x5c, 0x3e,
0xf9, 0xe4, 0x93, 0xdf, 0xf9, 0xce,
0x77, 0x26, 0x59, 0x86, 0x82, 0xfb,
0xfd, 0xfe, 0xe2, 0xd2, 0x1, 0x26,
0x8c, 0xe3, 0x78, 0x30, 0x1c, 0x3a,
0xef, 0x43, 0x68, 0xa1, 0x40, 0xcf,
0x8c, 0x8c, 0x8, 0xc0, 0xde, 0x87,
0xd8, 0x43, 0x90, 0x48, 0x4, 0x6c,
0xad, 0x2d, 0xcb, 0x32, 0xd4, 0x41,
0x4e, 0x92, 0x68, 0x76, 0x76, 0xf6,
0x9d, 0xef, 0x7a, 0x8f, 0x10, 0x2,
0x99, 0x95, 0x52, 0xd6, 0xf8, 0xe0,
0xe0, 0x35, 0x1a, 0x8d, 0x84, 0x84,
0xc5, 0xc5, 0x45, 0x1d, 0xa7, 0x52,
0xea, 0x5e, 0xaf, 0x97, 0x24, 0x89,
0x94, 0xba, 0xaa, 0x4c, 0x1c, 0xb1,
0x77, 0xcc, 0x22, 0x58, 0x26, 0xa7,
0xa2, 0x9d, 0x48, 0x28, 0xa5, 0x8a,
0xb2, 0xf4, 0x9e, 0x8d, 0x19, 0x17,
0x55, 0x4e, 0xd3, 0xe4, 0xa5, 0x2f,
0x7d, 0xe9, 0xcb, 0x5e, 0xf6, 0x32,
0xa5, 0xd4, 0xc2, 0xbe, 0xfd, 0x94,
0x82, 0x73, 0x6e, 0xe3, 0xc6, 0x8d,
0x1f, 0xfe, 0xf0, 0x87, 0xfb, 0xfd,
0xbe, 0x50, 0xaa, 0x28, 0x47, 0xd6,
0xf8, 0x24, 0xc9, 0x6, 0x83, 0x41,
0x59, 0x96, 0x59, 0xd6, 0xee, 0xf7,
0xfb, 0x69, 0xd2, 0x21, 0xdf, 0xf0,
0xa2, 0x38, 0xd1, 0xff, 0xaf, 0xd0,
0x9f, 0xb1, 0xa7, 0x6a, 0xa8, 0x5c,
0x3, 0xe0, 0xbc, 0x5b, 0xea, 0x2d,
0x9f, 0x7f, 0xc1, 0x63, 0x6f, 0xbc,
0xf1, 0xc6, 0xca, 0x98, 0xd1, 0x68,
0x64, 0xad, 0x75, 0xe4, 0x1, 0x20,
0x44, 0x20, 0x11, 0x8, 0x29, 0xb5,
0x54, 0x2e, 0x10, 0x61, 0xf2, 0x80,
0x12, 0x1b, 0x82, 0x9, 0x0, 0x4c,
0x62, 0xda, 0x84, 0xd8, 0x1f, 0xe,
0x93, 0x24, 0x41, 0x29, 0x6b, 0x6b,
0xad, 0xf7, 0x79, 0x9e, 0x7b, 0xe6,
0xc7, 0x3d, 0xfe, 0xf1, 0x9f, 0x7a,
0xdc, 0xe3, 0xe2, 0x38, 0x5e, 0x5a,
0x5a, 0x72, 0x81, 0x13, 0x21, 0x52,
0x5a, 0x87, 0xc5, 0x78, 0x6a, 0xd4,
0x27, 0x10, 0x6c, 0x54, 0x44, 0xfe,
0x20, 0xbc, 0x30, 0xc6, 0x3e, 0x18,
0x62, 0x48, 0x87, 0xc3, 0x61, 0x92,
0x24, 0xcc, 0x3c, 0x1c, 0xe, 0x77,
0xec, 0xd8, 0xf1, 0xda, 0xd7, 0xbe,
0xf6, 0x4d, 0x6f, 0x7a, 0x53, 0xf0,
0x7f, 0x9a, 0x9f, 0x9f, 0x1f, 0xe,
0x87, 0xc1, 0x30, 0x11, 0x92, 0xbc,
0x7b, 0xc7, 0x0, 0x42, 0xc5, 0x95,
0x35, 0xce, 0x7b, 0xe, 0xde, 0xd3,
0xa1, 0xe2, 0xd9, 0x4, 0x29, 0x63,
0x43, 0x60, 0x88, 0xc8, 0x39, 0xef,
0x9d, 0x5, 0x20, 0x21, 0x84, 0x8c,
0x74, 0x5e, 0x95, 0x41, 0x36, 0xf9,
0x85, 0x5f, 0xbc, 0xf2, 0x97, 0xaf,
0xba, 0x8a, 0x99, 0x17, 0x17, 0x17,
0x6b, 0x6b, 0x43, 0xec, 0x5e, 0x59,
0x19, 0x29, 0x25, 0x81, 0x65, 0xc6,
0x50, 0xc1, 0xd4, 0x85, 0xfa, 0x7e,
0x2c, 0x9a, 0x98, 0x47, 0x58, 0x59,
0xfc, 0x78, 0x7c, 0x6b, 0xad, 0x7,
0x16, 0x12, 0x84, 0x16, 0xb5, 0xab,
0x41, 0xc0, 0xf3, 0xae, 0x7a, 0xde,
0xb, 0xae, 0x7e, 0x41, 0xe0, 0x95,
0x82, 0x48, 0x9f, 0xe7, 0x39, 0x2a,
0x14, 0x5a, 0x94, 0x75, 0xe9, 0x2c,
0x9, 0xc1, 0x52, 0xea, 0x9, 0x2f,
0xbb, 0xc2, 0x1b, 0x36, 0x4, 0x99,
0x88, 0xbd, 0xf7, 0xce, 0x91, 0xb5,
0xae, 0x16, 0xe3, 0x60, 0x81, 0xa5,
0x5e, 0xaf, 0xd5, 0xe9, 0xbc, 0xee,
0xf5, 0xaf, 0x1f, 0xfb, 0x53, 0x39,
0x57, 0xd5, 0x75, 0x92, 0x24, 0x65,
0x5d, 0x4f, 0x7, 0x69, 0x1, 0x0,
0x5a, 0x9f, 0xb5, 0x2, 0xae, 0xb0,
0xcd, 0xbf, 0x54, 0x13, 0x5, 0x1a,
0xde, 0x53, 0xb8, 0x3d, 0x59, 0x2b,
0x29, 0xcb, 0x52, 0xa2, 0x34, 0xc6,
0x1, 0x80, 0xf7, 0xb6, 0xae, 0x6d,
0xb0, 0x6, 0x1, 0x80, 0x12, 0xd0,
0xe9, 0x74, 0x82, 0x4e, 0x38, 0x4,
0xc1, 0x84, 0xb9, 0x9b, 0x2b, 0x98,
0x24, 0x49, 0x51, 0xd5, 0x81, 0xa9,
0x1b, 0x47, 0x2, 0x4a, 0x69, 0xbc,
0x5b, 0x5a, 0x5a, 0x6a, 0xb5, 0x5a,
0x44, 0xce, 0x7b, 0x67, 0xac, 0x91,
0x52, 0x8e, 0x8a, 0x12, 0x0, 0x8c,
0x19, 0x1e, 0xe4, 0x14, 0xee, 0x28,
0x2f, 0x4b, 0x62, 0x7, 0x28, 0x11,
0x31, 0xdc, 0xfe, 0x34, 0x6b, 0x4f,
0x2, 0xe5, 0xc8, 0x3, 0x13, 0x33,
0x10, 0x37, 0x81, 0xaf, 0xce, 0x1a,
0x9d, 0x8, 0x63, 0x8c, 0x90, 0xaa,
0x28, 0xcb, 0x99, 0xd9, 0x4e, 0x9e,
0xe7, 0x45, 0x51, 0x8, 0x21, 0x82,
0x99, 0x6a, 0x3a, 0x1e, 0xb8, 0xdf,
0x1f, 0x2, 0x50, 0x14, 0x2b, 0xa5,
0x22, 0x44, 0x39, 0x36, 0x1a, 0x3b,
0x17, 0xf8, 0x82, 0xb0, 0x6c, 0x44,
0x29, 0x84, 0xf0, 0x93, 0x52, 0xa9,
0xe1, 0x5f, 0x41, 0x50, 0x29, 0xca,
0xb2, 0x89, 0x1, 0x10, 0xb5, 0x0,
0x0, 0xef, 0xb, 0x0, 0x90, 0x91,
0x36, 0x7e, 0xec, 0xc5, 0x78, 0xff,
0xee, 0xbd, 0x80, 0x64, 0xbd, 0x8f,
0xa2, 0x48, 0xa9, 0x28, 0xcf, 0xf3,
0x38, 0xc9, 0xb4, 0xd6, 0xbd, 0x5e,
0x2f, 0xa8, 0x76, 0x8c, 0x31, 0x32,
0xd2, 0x8d, 0xfb, 0x5e, 0x92, 0x24,
0x0, 0xc8, 0x84, 0xde, 0xfb, 0xe1,
0x70, 0x18, 0xc7, 0x31, 0x3, 0x78,
0x66, 0x63, 0x4c, 0x96, 0x24, 0x21,
0x2a, 0x18, 0x0, 0xf6, 0x2f, 0x2c,
0x84, 0x8d, 0x94, 0xf5, 0x58, 0x3b,
0xe2, 0x6b, 0x33, 0x3b, 0x3b, 0x3b,
0x18, 0x15, 0xcc, 0x2e, 0xdc, 0x2d,
0xe7, 0x9c, 0x94, 0x52, 0x4d, 0xe9,
0xe4, 0x3, 0xb, 0xea, 0xbd, 0x97,
0x42, 0x3b, 0x47, 0x88, 0x28, 0x84,
0x2c, 0xcb, 0x32, 0x78, 0x23, 0x59,
0x6b, 0x5b, 0xad, 0x56, 0x51, 0x14,
0x41, 0x34, 0x8, 0x3a, 0xf6, 0xb0,
0xaa, 0x71, 0x95, 0xd9, 0x31, 0x45,
0x75, 0xd, 0x35, 0x8, 0x61, 0x4f,
0xce, 0x91, 0xd6, 0x3a, 0x48, 0xc8,
0x42, 0x48, 0xef, 0x4c, 0xf3, 0x93,
0x7c, 0x54, 0xa, 0xa1, 0x8c, 0x71,
0x42, 0x88, 0x28, 0xa, 0xeb, 0x77,
0x7b, 0xf7, 0xee, 0xf, 0x4a, 0xa6,
0x3, 0x7, 0x16, 0x1b, 0x71, 0xda,
0xb9, 0x32, 0x10, 0x2b, 0x22, 0xd6,
0x2a, 0xa, 0x81, 0xc4, 0x81, 0x49,
0x9e, 0xe6, 0x20, 0xc2, 0x7b, 0x71,
0xce, 0x55, 0x55, 0x15, 0x82, 0xf2,
0x80, 0x9b, 0x1a, 0x5d, 0xae, 0x71,
0x95, 0x1b, 0xe, 0x87, 0xc3, 0xe1,
0x98, 0x46, 0x85, 0xed, 0x4c, 0x62,
0x1b, 0x19, 0x50, 0x4c, 0x42, 0x82,
0x84, 0x73, 0xb5, 0xd6, 0x1a, 0x3c,
0xd4, 0x75, 0x3d, 0xc5, 0x63, 0xfb,
0x86, 0x37, 0x2c, 0xcb, 0xd2, 0x7b,
0x52, 0x72, 0xac, 0xa2, 0xa3, 0x86,
0xe1, 0x9a, 0x78, 0xa4, 0x97, 0x50,
0x87, 0x48, 0x69, 0xef, 0x38, 0x1f,
0x85, 0x2d, 0x60, 0x43, 0x57, 0x95,
0x52, 0xc6, 0x98, 0x34, 0x4d, 0xab,
0xca, 0x8c, 0x1d, 0x69, 0xa4, 0xf4,
0xde, 0xa7, 0x69, 0x5c, 0xd7, 0xe8,
0xbd, 0xf, 0xaa, 0x13, 0x35, 0xb6,
0x75, 0x20, 0x11, 0xf7, 0xfb, 0xc3,
0x29, 0x2e, 0x43, 0x16, 0x45, 0x35,
0xc5, 0x92, 0x88, 0x46, 0x36, 0x1c,
0x7, 0x30, 0x28, 0x15, 0x74, 0x7,
0xce, 0x39, 0xd1, 0x1c, 0x50, 0xb0,
0xec, 0x67, 0x59, 0xd6, 0x6e, 0x77,
0x16, 0xe, 0x2c, 0x9, 0x54, 0x7e,
0x9d, 0xc6, 0xc1, 0x95, 0x37, 0xcf,
0x73, 0x6b, 0xbd, 0x10, 0x6a, 0x12,
0x6a, 0x82, 0x45, 0x51, 0x0, 0x40,
0x92, 0x64, 0x81, 0x99, 0x99, 0xf8,
0xc1, 0x44, 0xc1, 0x23, 0x22, 0x70,
0x4a, 0x9d, 0x99, 0x99, 0xde, 0x60,
0x90, 0x24, 0x89, 0x73, 0xde, 0x1a,
0xf, 0x2c, 0xc6, 0x22, 0x13, 0x79,
0x47, 0xd3, 0x53, 0x30, 0x4a, 0x61,
0x1d, 0x5, 0x11, 0x68, 0x69, 0xb1,
0x17, 0x47, 0x69, 0xab, 0xd5, 0xae,
0x6b, 0xe3, 0x88, 0x1c, 0x51, 0x98,
0x91, 0x81, 0x88, 0xbd, 0x10, 0x20,
0x4, 0xe8, 0x48, 0x21, 0x48, 0xa5,
0xa2, 0xe1, 0x70, 0x38, 0x37, 0x37,
0x5f, 0x57, 0x16, 0x0, 0x92, 0xac,
0xb5, 0xd4, 0xeb, 0x4f, 0x3b, 0x66,
0x38, 0xa6, 0xe6, 0x33, 0xc9, 0x16,
0x30, 0xf6, 0xe3, 0x71, 0x76, 0xac,
0x8, 0x69, 0x12, 0x15, 0x4, 0xa6,
0x71, 0x5a, 0xb3, 0x12, 0x45, 0xd1,
0x68, 0x94, 0x27, 0x49, 0x22, 0x84,
0x18, 0x8d, 0x46, 0x52, 0x4a, 0x21,
0xa5, 0x54, 0x2a, 0x7c, 0x39, 0xac,
0xde, 0xd2, 0xe4, 0xe3, 0xb9, 0x11,
0xe7, 0x82, 0x63, 0x9d, 0xb5, 0x2e,
0x4d, 0xd3, 0x0, 0x1b, 0x1, 0xf5,
0x34, 0xfa, 0xac, 0xc0, 0xc1, 0xa,
0x21, 0x2a, 0xe3, 0xa2, 0x34, 0x43,
0x94, 0x83, 0xc1, 0x28, 0x90, 0x9d,
0xb2, 0xa8, 0x95, 0x8c, 0x68, 0xca,
0x2b, 0xc6, 0x73, 0xd8, 0xb, 0x10,
0x81, 0x50, 0xaa, 0xd7, 0xeb, 0x1,
0xc0, 0xec, 0xec, 0xac, 0x73, 0xce,
0x7b, 0xa, 0xac, 0xe3, 0x68, 0x34,
0x22, 0x22, 0x21, 0x54, 0x20, 0x65,
0x1, 0x0, 0x2, 0x78, 0x57, 0x55,
0x48, 0xbd, 0x80, 0xe1, 0xd, 0x12,
0x41, 0x28, 0x54, 0x1f, 0x6c, 0x3c,
0xe3, 0x29, 0x3c, 0x37, 0x7f, 0x4b,
0xa1, 0x81, 0x85, 0x94, 0xda, 0x5a,
0x8f, 0x38, 0x36, 0xc6, 0x46, 0x51,
0x14, 0x92, 0xfb, 0x37, 0x58, 0x3b,
0xac, 0x30, 0x6c, 0xd0, 0x78, 0x32,
0x8e, 0xac, 0x67, 0xcf, 0xe8, 0x19,
0x9, 0x4, 0x8, 0x5, 0x42, 0x19,
0x47, 0xe1, 0x63, 0x3d, 0x3b, 0x82,
0xf0, 0x5f, 0xcf, 0x58, 0x55, 0x26,
0x60, 0x87, 0x86, 0x5e, 0x85, 0x70,
0xb9, 0x70, 0xc1, 0x82, 0x21, 0xbd,
0x2c, 0x4b, 0x26, 0x6c, 0xb7, 0xba,
0xa3, 0xd1, 0x28, 0x4d, 0xd3, 0xe9,
0x1b, 0xd3, 0xbc, 0xac, 0x69, 0x43,
0x71, 0x90, 0x96, 0xa7, 0x13, 0x98,
0x87, 0x93, 0x29, 0xcb, 0xaa, 0xd3,
0xe9, 0x10, 0x41, 0xf0, 0xe5, 0xb6,
0xc6, 0x59, 0xe3, 0x8c, 0x31, 0x4a,
0x45, 0x93, 0x60, 0x66, 0xe5, 0xbd,
0x2f, 0x8a, 0xa2, 0x19, 0xf9, 0x28,
0x3f, 0x4b, 0x4b, 0xbd, 0xa0, 0xe0,
0x8, 0x21, 0x68, 0xa1, 0x7c, 0xc,
0x79, 0x26, 0xcf, 0x65, 0x51, 0x5,
0xfb, 0x65, 0x70, 0xf6, 0x1e, 0xe,
0x87, 0xdd, 0x6e, 0x97, 0x8, 0x2,
0x92, 0x9d, 0x4e, 0xab, 0xde, 0xf0,
0x5f, 0xab, 0x8a, 0x75, 0x87, 0xc5,
0x28, 0xa5, 0x27, 0x74, 0x5d, 0x79,
0xcf, 0x0, 0x62, 0x9c, 0xd4, 0xce,
0x39, 0xa7, 0x64, 0xb4, 0xb4, 0xb4,
0xf4, 0xc3, 0x1f, 0xfe, 0x70, 0xcb,
0x96, 0x2d, 0x1, 0x20, 0x95, 0xc4,
0x75, 0xb3, 0x96, 0x15, 0xb6, 0xf2,
0xe4, 0xa4, 0x96, 0x45, 0x51, 0x14,
0x45, 0x15, 0xc7, 0x71, 0xbb, 0xd3,
0x1, 0xc0, 0xc5, 0xc5, 0x65, 0x66,
0x56, 0x51, 0xd4, 0x88, 0x1f, 0x8d,
0xfa, 0x21, 0x8d, 0xe3, 0xe1, 0x70,
0xd8, 0xef, 0xf, 0x7f, 0xf0, 0x83,
0x1f, 0xcc, 0x74, 0x5a, 0xe1, 0xca,
0x56, 0x55, 0x35, 0x6d, 0x99, 0xc6,
0x15, 0x5e, 0xc, 0x4, 0x1, 0x11,
0x4, 0xa4, 0x10, 0xa4, 0xf9, 0xfb,
0xef, 0xbf, 0x7f, 0x61, 0x61, 0x61,
0xc2, 0xf0, 0x50, 0xc3, 0xed, 0x8c,
0xb3, 0x80, 0x21, 0x17, 0x45, 0xe9,
0xbd, 0xdf, 0xb3, 0x67, 0xcf, 0xa9,
0xa7, 0x9e, 0xea, 0x9c, 0x5b, 0x5e,
0xee, 0x7, 0x31, 0x6c, 0x22, 0xaf,
0xae, 0x4a, 0xa7, 0x44, 0x79, 0x6d,
0x74, 0x24, 0x2b, 0xe3, 0x9c, 0x73,
0x59, 0xda, 0x31, 0xc6, 0x8c, 0x46,
0xa3, 0x55, 0x7a, 0x88, 0x49, 0xad,
0xad, 0xb1, 0x87, 0x29, 0x33, 0xde,
0x7f, 0xff, 0xfd, 0xf, 0x7b, 0xd8,
0xe9, 0xb3, 0xb3, 0xb3, 0xe1, 0xac,
0x7, 0x83, 0x1, 0x22, 0x26, 0xe3,
0x98, 0xaa, 0xd5, 0xee, 0x2b, 0x71,
0x1c, 0xf7, 0xfb, 0x7d, 0x22, 0x98,
0x9d, 0x9d, 0xf5, 0x9e, 0xf6, 0xef,
0xdf, 0x1f, 0x3c, 0xda, 0x69, 0x92,
0xac, 0xa0, 0x61, 0x41, 0x1b, 0x3c,
0x9d, 0xe7, 0xf9, 0xc2, 0xc2, 0xc2,
0xc6, 0xb9, 0xf9, 0x24, 0x49, 0xaa,
0xaa, 0xca, 0xf3, 0x5c, 0x30, 0x34,
0xd1, 0xf6, 0x34, 0x95, 0x67, 0x9b,
0x10, 0x4, 0x43, 0x1a, 0x47, 0x65,
0x9e, 0x83, 0xf5, 0x83, 0xc1, 0x60,
0xb9, 0x37, 0xc, 0xc8, 0x22, 0x40,
0x82, 0x94, 0x12, 0x51, 0x8c, 0xb7,
0x3f, 0xd1, 0x72, 0x55, 0x55, 0xb5,
0x77, 0xef, 0xde, 0x87, 0x3e, 0xf4,
0x54, 0xad, 0xf5, 0xd2, 0xd2, 0x92,
0x52, 0x2a, 0x49, 0x92, 0xc3, 0x14,
0x52, 0x0, 0x80, 0xfe, 0xd2, 0xf2,
0xcc, 0xcc, 0x8c, 0xd0, 0xd1, 0xf2,
0xf2, 0x72, 0x50, 0xf0, 0x6, 0xc,
0x4e, 0x4, 0x4a, 0xa9, 0x71, 0xb4,
0xd0, 0xc4, 0x32, 0x69, 0xad, 0xfd,
0xfe, 0xf7, 0xbf, 0xff, 0xa4, 0x27,
0x3e, 0xa1, 0x2c, 0xf3, 0xa2, 0xa8,
0xf2, 0x3c, 0x17, 0x42, 0x5, 0x99,
0x7d, 0x3a, 0x54, 0x68, 0x6c, 0x48,
0x1e, 0xf7, 0x80, 0x10, 0x22, 0xcb,
0xb2, 0xd1, 0x68, 0xb4, 0x7f, 0xff,
0xfe, 0x80, 0x1d, 0x1a, 0x49, 0x38,
0xac, 0xaa, 0x49, 0x42, 0x10, 0x6e,
0x42, 0xaf, 0xd7, 0x93, 0x28, 0xf8,
0x20, 0xbf, 0xc5, 0x49, 0x4a, 0x93,
0x83, 0x24, 0xe7, 0x95, 0x37, 0x62,
0x5c, 0x25, 0x84, 0x58, 0x5c, 0x5c,
0xf2, 0xde, 0x97, 0x65, 0x1d, 0x52,
0xb8, 0xb4, 0x5a, 0x2d, 0xef, 0xc6,
0x4a, 0x38, 0xe7, 0x1c, 0x91, 0x23,
0xf, 0xfd, 0x7e, 0x3f, 0xcf, 0xf3,
0x9d, 0x3b, 0x77, 0xde, 0xbf, 0x7b,
0xd7, 0xba, 0xb9, 0x6c, 0xd6, 0xc6,
0xa2, 0x84, 0x9e, 0xed, 0xdb, 0xb7,
0x2f, 0x2d, 0x2d, 0x95, 0x65, 0x19,
0x32, 0x6f, 0x4, 0xc5, 0x67, 0x38,
0x9f, 0xe0, 0xe, 0xd0, 0xef, 0x97,
0x52, 0xa2, 0x0, 0x5a, 0x58, 0x58,
0xd8, 0x30, 0x3f, 0x57, 0xd7, 0x75,
0xc8, 0x6c, 0x33, 0xed, 0xbf, 0xb9,
0x4a, 0xc9, 0xdc, 0xa8, 0x3, 0x2,
0xad, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e,
0x5e, 0xe, 0xee, 0x49, 0x1, 0x88,
0xf0, 0xcd, 0x6f, 0x7f, 0x37, 0x0,
0x8c, 0x46, 0xa3, 0xd9, 0xd9, 0xee,
0xee, 0xfb, 0xef, 0xdb, 0xbb, 0x77,
0xaf, 0xb5, 0xb5, 0x73, 0xb6, 0xd7,
0xeb, 0xcd, 0xce, 0x74, 0xd6, 0x4d,
0x38, 0x18, 0x94, 0x7, 0x42, 0x7,
0xaa, 0xe2, 0x1, 0x40, 0x2a, 0x2d,
0x84, 0xd8, 0xb1, 0x63, 0x67, 0x96,
0x65, 0x8c, 0x52, 0x8, 0xe1, 0xc8,
0x3b, 0xe7, 0x42, 0x1e, 0x19, 0x0,
0x48, 0xe3, 0x4, 0x11, 0xf, 0x1c,
0xd8, 0xb7, 0x7b, 0xf7, 0x7d, 0x44,
0xe4, 0xc9, 0xda, 0xaa, 0xb2, 0xd6,
0x86, 0xc8, 0xc9, 0xe9, 0x38, 0x78,
0x1c, 0xc7, 0x6, 0x6a, 0xa5, 0x54,
0xbf, 0xdf, 0x77, 0xce, 0xb5, 0xdb,
0x1d, 0x66, 0x4e, 0x5b, 0x9d, 0x56,
0xab, 0xb5, 0x75, 0xeb, 0x56, 0x29,
0x65, 0xb0, 0x7e, 0x11, 0xf0, 0x54,
0x1a, 0x10, 0xa, 0x14, 0xea, 0xfe,
0xfb, 0x77, 0xe5, 0x79, 0xee, 0xbd,
0x2b, 0x8a, 0xc2, 0xd8, 0x2a, 0x8e,
0x63, 0x25, 0xe4, 0xba, 0x71, 0xed,
0xb1, 0xd2, 0xc4, 0xce, 0x38, 0x42,
0x44, 0x60, 0x29, 0x84, 0xd8, 0xb8,
0xe9, 0x84, 0xed, 0xdb, 0xb7, 0x23,
0x4a, 0x66, 0xe, 0x22, 0x2a, 0xad,
0x80, 0x3d, 0x21, 0xb2, 0x12, 0xf2,
0xbe, 0x7b, 0xef, 0xc9, 0xf3, 0x3c,
0x78, 0x62, 0x35, 0x17, 0x57, 0x1c,
0xea, 0xd2, 0x98, 0xa, 0x11, 0x99,
0x31, 0x8e, 0xe3, 0x34, 0xeb, 0x74,
0xbb, 0xdd, 0x56, 0x36, 0x33, 0x3b,
0x3b, 0x1b, 0x2, 0x33, 0x8, 0x57,
0xdd, 0x9, 0x2, 0xa0, 0x5e, 0x7f,
0xe9, 0xc0, 0x81, 0xfd, 0xde, 0x58,
0x63, 0xcc, 0xf2, 0xd2, 0x92, 0x10,
0x62, 0xb6, 0xd3, 0x6d, 0x48, 0xd3,
0x18, 0x80, 0x61, 0x5, 0x80, 0x5,
0x32, 0xb2, 0x67, 0x94, 0x44, 0xd4,
0x9d, 0x99, 0xdf, 0xb6, 0x6d, 0x5b,
0x77, 0x76, 0x63, 0x55, 0x55, 0x8d,
0x32, 0x26, 0x5c, 0x8, 0x2d, 0x42,
0xc8, 0x4a, 0x55, 0x56, 0xf9, 0xdd,
0x77, 0xdf, 0xd5, 0xed, 0x76, 0xca,
0xb2, 0xc, 0x5a, 0xf7, 0x60, 0x9f,
0x8b, 0xe3, 0x78, 0x1a, 0x80, 0xa7,
0xaf, 0x91, 0xaf, 0x2b, 0xa5, 0x94,
0x8a, 0x93, 0x34, 0x4d, 0xb3, 0x56,
0x7b, 0xeb, 0xd6, 0xad, 0x49, 0xd6,
0xd, 0x62, 0x58, 0x3, 0x2d, 0xd6,
0xda, 0x44, 0x47, 0x51, 0x14, 0x1d,
0x58, 0xd8, 0x37, 0x1a, 0x8d, 0x96,
0x17, 0x97, 0x82, 0xa6, 0x26, 0x4,
0xc9, 0x4, 0x98, 0xc, 0x2c, 0xdf,
0xba, 0xf0, 0x80, 0xcc, 0x49, 0x12,
0x5b, 0x4f, 0x73, 0x73, 0x73, 0x3b,
0x76, 0x9e, 0xca, 0xcc, 0xcb, 0xfd,
0x61, 0x50, 0x9a, 0x4e, 0x42, 0x35,
0xa9, 0xaa, 0xaa, 0x56, 0x92, 0x5a,
0x6b, 0xf7, 0x1f, 0xd8, 0x5b, 0x96,
0xf9, 0xf2, 0xf2, 0x32, 0x4f, 0x4,
0x9c, 0x83, 0x54, 0x5c, 0x53, 0x2e,
0x6e, 0xab, 0x80, 0x41, 0x6b, 0x9d,
0xc4, 0xad, 0x53, 0x4f, 0x3d, 0x35,
0xac, 0xbf, 0xd7, 0x1f, 0xcd, 0xce,
0xce, 0x86, 0x70, 0xc2, 0x34, 0x4d,
0x4d, 0x5d, 0x29, 0x25, 0xd2, 0x28,
0xde, 0x7d, 0xff, 0x7d, 0x7b, 0xf6,
0xec, 0xce, 0xb2, 0xac, 0xd7, 0x5b,
0x3e, 0xfa, 0x48, 0x5d, 0x0, 0x98,
0xe9, 0x76, 0x47, 0xa3, 0xd1, 0xce,
0x53, 0x4f, 0xdf, 0xb4, 0x69, 0x53,
0x65, 0x9c, 0x94, 0xba, 0x2c, 0xaa,
0xc6, 0x28, 0xc5, 0xcc, 0x3a, 0x52,
0x49, 0x12, 0x2d, 0x2d, 0xec, 0x3f,
0x70, 0x60, 0x5f, 0x55, 0x94, 0xc3,
0xd1, 0x0, 0xe5, 0x3a, 0xd9, 0x73,
0x2, 0x2a, 0x5c, 0x95, 0xa9, 0x3f,
0x38, 0xd5, 0xcd, 0xcd, 0xcd, 0xb7,
0xdb, 0xdd, 0xcd, 0x9b, 0x37, 0x6b,
0xad, 0xcb, 0xb2, 0xbc, 0xe3, 0x8e,
0x3b, 0xf0, 0x2d, 0x7f, 0xfa, 0x1e,
0x0, 0xa8, 0xac, 0x61, 0x67, 0x6b,
0x67, 0x67, 0xbb, 0x6d, 0xeb, 0x3d,
0x90, 0x2b, 0xcb, 0x32, 0x49, 0xe2,
0x75, 0x13, 0xe1, 0x39, 0x6b, 0xda,
0xed, 0xb6, 0x75, 0xae, 0xaa, 0xaa,
0x38, 0x8e, 0xa5, 0x54, 0xd6, 0x5a,
0x2, 0x21, 0x0, 0x84, 0x52, 0xa3,
0x51, 0x91, 0x24, 0x89, 0x8a, 0xe2,
0xa2, 0x28, 0x9a, 0x94, 0x25, 0x81,
0x12, 0xda, 0xda, 0x80, 0x60, 0x20,
0xdf, 0xed, 0x76, 0xcb, 0x2a, 0x6f,
0x42, 0xde, 0x5, 0x87, 0xeb, 0x88,
0xe1, 0x52, 0x86, 0x6b, 0x1a, 0x98,
0xf0, 0x24, 0x49, 0xea, 0xca, 0x82,
0x40, 0x2d, 0x55, 0xb8, 0x31, 0x2b,
0xba, 0x1, 0xb1, 0x12, 0xab, 0x15,
0x54, 0xa6, 0x55, 0x91, 0x77, 0xbb,
0xdd, 0xb2, 0x2c, 0x19, 0xbc, 0x10,
0x42, 0x29, 0xe9, 0x9c, 0x93, 0x7,
0x29, 0x4b, 0x57, 0xd2, 0x27, 0xcb,
0x10, 0xc2, 0x26, 0x50, 0xc9, 0x8,
0x60, 0xac, 0xd0, 0x36, 0x8e, 0x4,
0xb, 0x1f, 0x42, 0x17, 0x90, 0x19,
0xc7, 0xca, 0xc9, 0x80, 0xe0, 0x85,
0x10, 0x4a, 0xc8, 0xb2, 0x2c, 0x83,
0x86, 0xb0, 0x2c, 0xcb, 0x34, 0x8b,
0x43, 0x70, 0xd2, 0x61, 0x32, 0x1e,
0x7a, 0xef, 0x43, 0x54, 0x77, 0x65,
0x5c, 0x1a, 0xa5, 0xa3, 0xb2, 0x48,
0xa3, 0x14, 0x64, 0x30, 0x6c, 0x8c,
0x3d, 0xc9, 0x42, 0x6a, 0x8e, 0x28,
0x8a, 0x9c, 0x33, 0x1, 0xe9, 0x5a,
0x6b, 0x95, 0x10, 0xc1, 0x39, 0x79,
0xc2, 0xce, 0xac, 0x84, 0x8c, 0x4e,
0x38, 0x7b, 0x62, 0xe7, 0x94, 0x44,
0x1d, 0x25, 0x44, 0x64, 0xad, 0x3,
0xa1, 0x82, 0x68, 0x6a, 0xad, 0x9f,
0x36, 0x39, 0x6, 0x7e, 0x4c, 0xb,
0xd4, 0x5a, 0x3b, 0x3f, 0xce, 0xea,
0x22, 0xb5, 0x66, 0xef, 0x8d, 0x73,
0x91, 0x52, 0x79, 0x59, 0x66, 0x49,
0x42, 0x48, 0x4c, 0x18, 0xf2, 0x1f,
0x8c, 0x85, 0x7f, 0xa0, 0xe0, 0x3,
0x25, 0x95, 0xe, 0xca, 0x2, 0xa1,
0xa2, 0xb1, 0xcf, 0x33, 0x40, 0xb8,
0x0, 0x41, 0x2a, 0xb, 0xf2, 0x3c,
0x12, 0x87, 0x77, 0xc1, 0xe0, 0xc7,
0x59, 0xda, 0x40, 0x4e, 0xf8, 0xee,
0x49, 0x90, 0xe6, 0x64, 0xf0, 0x26,
0x92, 0x5e, 0xa2, 0x40, 0x64, 0xa1,
0x24, 0x33, 0xe6, 0x79, 0xae, 0xa2,
0x24, 0x49, 0x92, 0xe5, 0xe5, 0xe5,
0x6e, 0x77, 0x76, 0x92, 0x31, 0xc6,
0xb6, 0x5a, 0x69, 0x60, 0x38, 0xdb,
0x59, 0xc2, 0x88, 0xe4, 0x8c, 0x7,
0x16, 0x61, 0x1a, 0x6, 0x90, 0x42,
0x2, 0xb2, 0x8, 0x54, 0x9, 0xc2,
0x3e, 0x9a, 0xff, 0x86, 0x1b, 0x45,
0x44, 0x49, 0x92, 0x6, 0x4b, 0x5b,
0x6d, 0x5d, 0xab, 0xd5, 0xc9, 0xf3,
0x3c, 0x88, 0xe5, 0x81, 0xa6, 0x29,
0x81, 0x83, 0x41, 0xf, 0x0, 0xa2,
0x58, 0x21, 0x4e, 0xfb, 0x60, 0xaf,
0x93, 0xf9, 0x2e, 0xd4, 0x99, 0x5b,
0x1, 0x33, 0xc1, 0x91, 0x54, 0x52,
0xca, 0x5e, 0x6f, 0x40, 0x0, 0x1b,
0x37, 0x6e, 0x2e, 0xcb, 0x3a, 0x28,
0x1a, 0x1a, 0x2e, 0x12, 0x11, 0x9d,
0x33, 0xed, 0x76, 0x6, 0x44, 0xa3,
0xd1, 0x60, 0x9c, 0x73, 0x67, 0x6a,
0x17, 0x2c, 0x30, 0x3c, 0x91, 0xd8,
0x3, 0x87, 0xa7, 0x4, 0x6c, 0xf6,
0x12, 0xc9, 0x28, 0xd8, 0xba, 0x3,
0x68, 0x7c, 0xed, 0x6b, 0x5f, 0xc3,
0x6b, 0xfe, 0xf4, 0xdd, 0x63, 0xa5,
0x8, 0xb1, 0x50, 0x92, 0xbd, 0x3,
0x81, 0x12, 0xc5, 0x34, 0x7e, 0x5d,
0x95, 0x59, 0x6b, 0x9a, 0xef, 0xd,
0xd6, 0xb, 0x44, 0x4, 0x21, 0xc9,
0xf9, 0x43, 0xa5, 0xe1, 0x23, 0x2,
0x6, 0x94, 0x28, 0xa4, 0x96, 0x38,
0x56, 0x39, 0xf8, 0x26, 0x45, 0xc3,
0x9a, 0xfa, 0x75, 0x44, 0x21, 0xe9,
0x87, 0x18, 0x6b, 0xde, 0x9, 0x82,
0xc3, 0xc, 0x4c, 0x64, 0xd2, 0x75,
0x72, 0x97, 0x37, 0x7c, 0x63, 0x23,
0x47, 0x4d, 0x42, 0x67, 0xd6, 0xaf,
0x10, 0xe9, 0xc9, 0x6a, 0xad, 0xfe,
0x3f, 0xce, 0xde, 0x3c, 0xde, 0xb2,
0xba, 0xba, 0x13, 0x5d, 0xeb, 0x37,
0xec, 0xe1, 0xc, 0x77, 0xac, 0xb9,
0x8a, 0x82, 0x2, 0x19, 0xb, 0x50,
0x19, 0xb, 0x11, 0x71, 0x8, 0xce,
0x46, 0x1c, 0x62, 0xd4, 0x56, 0x8c,
0x86, 0xd8, 0x46, 0xd3, 0x7e, 0x6c,
0x93, 0x96, 0x17, 0x3a, 0xdd, 0x9f,
0x4f, 0x8c, 0x9d, 0x20, 0x51, 0x3f,
0xc1, 0x17, 0x3a, 0xb1, 0x55, 0x8c,
0x74, 0xbf, 0x4f, 0x62, 0x23, 0x51,
0x71, 0x88, 0xda, 0x3e, 0x15, 0x8d,
0xa0, 0x8c, 0x22, 0x62, 0xb4, 0x40,
0x40, 0xa, 0xa8, 0xf9, 0x4e, 0x67,
0xd8, 0x7b, 0xff, 0x86, 0xb5, 0xde,
0x1f, 0x6b, 0x9f, 0x7d, 0xcf, 0xbd,
0x75, 0x6f, 0x99, 0xbc, 0xc3, 0xe5,
0x7e, 0x4e, 0x55, 0x9d, 0x7b, 0xf7,
0xf4, 0x1b, 0xd6, 0xf0, 0x1d, 0x94,
0x52, 0x92, 0x28, 0xc9, 0xa8, 0x8a,
0x4c, 0x46, 0xd9, 0x31, 0xcf, 0x8e,
0x15, 0xb8, 0x6e, 0x49, 0xc6, 0x9a,
0x35, 0x75, 0xf9, 0x40, 0x74, 0x3c,
0x9b, 0x95, 0x65, 0x76, 0xb, 0x13,
0x10, 0x13, 0xb0, 0x46, 0xb5, 0xf2,
0x10, 0xcd, 0x15, 0x29, 0xa5, 0xc,
0x30, 0x32, 0x50, 0x13, 0x37, 0x1,
0x35, 0x43, 0x7f, 0x85, 0xd1, 0xee,
0x68, 0x48, 0xf1, 0xb2, 0x3e, 0x1e,
0x48, 0x7a, 0x4c, 0xeb, 0xa9, 0xa2,
0xd5, 0x9a, 0xe6, 0xda, 0x52, 0x64,
0x6, 0x2, 0x85, 0xa, 0x58, 0xe2,
0x59, 0x2, 0xae, 0xe1, 0x7e, 0x23,
0x2a, 0x79, 0xd, 0xbf, 0x51, 0xca,
0x57, 0xa5, 0xac, 0x29, 0xd, 0xc0,
0xf0, 0x38, 0xea, 0x59, 0x8d, 0x70,
0xc2, 0x48, 0x22, 0x27, 0x20, 0x6a,
0xa5, 0x6a, 0x4, 0xcb, 0xa8, 0xa6,
0x70, 0x6c, 0x23, 0x2d, 0xac, 0x80,
0x58, 0x20, 0x1c, 0xa3, 0x71, 0xbd,
0xfc, 0x20, 0x64, 0x9c, 0xa4, 0x36,
0x23, 0x40, 0xb9, 0x9f, 0x40, 0x51,
0xec, 0x12, 0x41, 0x61, 0x70, 0x15,
0x28, 0xd4, 0x68, 0x64, 0x18, 0x83,
0x42, 0x8e, 0x24, 0x68, 0xd0, 0x71,
0x61, 0x96, 0xc6, 0x18, 0x71, 0x85,
0x9e, 0xd9, 0x6a, 0x2b, 0x53, 0xd5,
0x94, 0xa6, 0x6a, 0xd, 0x2a, 0x65,
0x41, 0xa1, 0x2, 0x8c, 0x4c, 0x1c,
0x3, 0x1, 0xaf, 0x68, 0x77, 0x8d,
0x46, 0xda, 0x31, 0x22, 0x8d, 0xb0,
0xdc, 0xa0, 0x1d, 0x89, 0xcb, 0x8f,
0x32, 0x2, 0xd2, 0xd6, 0x68, 0x54,
0x32, 0x36, 0x50, 0x2b, 0x5, 0x18,
0x28, 0xca, 0x8, 0x19, 0xcd, 0x8,
0x6a, 0xde, 0x73, 0x5c, 0xb1, 0x27,
0xdf, 0x73, 0xcf, 0x3d, 0x46, 0xa2,
0x44, 0xc9, 0xf7, 0x90, 0x99, 0x0,
0x91, 0x91, 0x10, 0x9, 0x10, 0xd7,
0x6e, 0xf4, 0x69, 0xa, 0xf5, 0xed,
0xd6, 0xda, 0xca, 0x33, 0x1e, 0x3,
0x5d, 0xf1, 0x2a, 0xb1, 0xf9, 0x51,
0xf4, 0xa2, 0x63, 0x8c, 0x44, 0x11,
0x42, 0x43, 0xc2, 0x34, 0x8d, 0xe0,
0x8e, 0xfc, 0x3f, 0xf6, 0x5d, 0x83,
0xc2, 0x48, 0x31, 0x44, 0x29, 0x3c,
0x28, 0xad, 0x14, 0xb2, 0x6a, 0xf2,
0x1c, 0x51, 0x15, 0x1b, 0xd3, 0x8e,
0x0, 0x46, 0x6a, 0x92, 0xb1, 0xf1,
0x11, 0x8c, 0x88, 0xb4, 0x4e, 0xbb,
0x52, 0x9b, 0x8c, 0x81, 0x23, 0xa9,
0x48, 0x35, 0xf5, 0x50, 0x69, 0xa3,
0x46, 0x30, 0xb2, 0xd1, 0x76, 0xdd,
0x28, 0x89, 0x8b, 0x6a, 0xd9, 0x38,
0x20, 0xa9, 0x5e, 0x4d, 0x10, 0x15,
0xad, 0xa3, 0xfa, 0xa9, 0x45, 0x75,
0xa8, 0x2f, 0x4a, 0x7f, 0xd1, 0x0,
0x0, 0x20, 0x0, 0x49, 0x44, 0x41,
0x54, 0x6, 0xc6, 0x22, 0x2a, 0x8d,
0x5a, 0x29, 0xe4, 0x63, 0xe, 0xb1,
0xfc, 0x46, 0xa1, 0x88, 0x81, 0x68,
0x66, 0xe, 0xd1, 0x37, 0x43, 0x47,
0xe1, 0x4a, 0x3d, 0x9d, 0x46, 0xbd,
0x44, 0x69, 0x54, 0x8, 0x8c, 0x91,
0x23, 0x45, 0x6, 0x64, 0x85, 0x56,
0x69, 0x94, 0xf7, 0xcb, 0x4f, 0xa1,
0x7e, 0x23, 0xe6, 0xec, 0x41, 0x29,
0xa5, 0x94, 0x6, 0x6, 0x42, 0x2,
0x12, 0x18, 0xc, 0xb2, 0x66, 0xf9,
0x20, 0x8f, 0x36, 0x58, 0x8e, 0x8c,
0x44, 0xa0, 0x2c, 0x28, 0xc5, 0x8c,
0xa8, 0x35, 0x32, 0xa2, 0x2, 0x26,
0x8, 0xd1, 0x2f, 0x3b, 0x8c, 0x1e,
0xbb, 0x6, 0x83, 0x20, 0xc7, 0x95,
0x52, 0x16, 0x80, 0x0, 0x31, 0xb2,
0x3c, 0x17, 0xb5, 0x3a, 0x48, 0x61,
0x4, 0x0, 0x54, 0x6, 0x70, 0x24,
0x46, 0x1, 0xa, 0x46, 0xa, 0x1e,
0x23, 0x8b, 0xf0, 0x63, 0xb6, 0x40,
0x6, 0x92, 0xa9, 0xa8, 0x40, 0x34,
0x6f, 0x99, 0xc8, 0x13, 0x71, 0x60,
0xad, 0xd, 0xd6, 0x9e, 0x2a, 0xec,
0x62, 0x94, 0xda, 0x95, 0x52, 0x56,
0x14, 0xd4, 0x1a, 0x39, 0x31, 0x1c,
0xbd, 0xaf, 0x27, 0x9d, 0x4, 0x1d,
0x88, 0xe3, 0x7a, 0x63, 0x44, 0x91,
0x99, 0x81, 0x50, 0x6, 0x21, 0x0,
0x44, 0x62, 0xa, 0x51, 0x6a, 0x6c,
0x4a, 0x1b, 0xc5, 0x23, 0xfa, 0x2c,
0x12, 0x22, 0xea, 0x3a, 0x59, 0x53,
0xb8, 0x86, 0x22, 0xac, 0xc2, 0xfa,
0x2, 0x11, 0xe4, 0x94, 0x51, 0x33,
0x80, 0x32, 0xcc, 0xc, 0xcd, 0x79,
0x6a, 0x50, 0x4, 0xc0, 0x8c, 0x81,
0x79, 0xcd, 0x98, 0x6e, 0xb4, 0xa5,
0x2d, 0x77, 0x4, 0xcd, 0xb8, 0x4b,
0xe8, 0x78, 0x44, 0xa, 0xc7, 0xf3,
0xef, 0xd2, 0x88, 0x0, 0x8c, 0x4c,
0xe0, 0x63, 0x68, 0x7e, 0xd7, 0x71,
0x20, 0xa, 0xa2, 0xc6, 0x20, 0xe9,
0x65, 0xc3, 0xfc, 0x3c, 0x9e, 0x4a,
0xaf, 0x32, 0x8c, 0x48, 0x11, 0x62,
0x20, 0x81, 0x25, 0xe1, 0xf8, 0x5,
0xd4, 0xeb, 0x65, 0x1c, 0x57, 0x8d,
0x21, 0xa8, 0x43, 0x86, 0x91, 0x5e,
0xdc, 0x88, 0x99, 0xbc, 0x8e, 0x20,
0xab, 0x90, 0x3c, 0x6b, 0x6, 0x24,
0x3, 0x33, 0xc4, 0xe8, 0x8f, 0xb9,
0x8a, 0x38, 0xfe, 0xa6, 0xd9, 0xeb,
0xea, 0xed, 0x6e, 0x4, 0x5b, 0x5f,
0xd3, 0xc5, 0x7, 0x0, 0x9c, 0xb,
0x8d, 0x96, 0x2, 0x0, 0x50, 0xe4,
0xa6, 0xd9, 0x33, 0xb6, 0xba, 0xad,
0x38, 0x84, 0x50, 0x91, 0x10, 0x94,
0xf0, 0x64, 0xc6, 0xf4, 0x22, 0xe2,
0x9a, 0xea, 0xe4, 0xde, 0x85, 0x91,
0x4, 0x44, 0x3d, 0x1f, 0x42, 0xc,
0xe4, 0x68, 0xbd, 0xab, 0x86, 0xba,
0x82, 0x24, 0x4d, 0xee, 0xba, 0xa,
0x34, 0x2a, 0x8c, 0x63, 0xd3, 0xce,
0x5d, 0x81, 0x2a, 0x9, 0x84, 0x58,
0x3f, 0x32, 0xa5, 0x6a, 0xde, 0x32,
0x30, 0x1a, 0xbb, 0xae, 0xb1, 0x96,
0xf, 0xae, 0x2e, 0x4d, 0x93, 0x8,
0x6e, 0xa8, 0x71, 0x53, 0xf9, 0x63,
0x25, 0xd6, 0xa9, 0xce, 0x41, 0xea,
0x7, 0xca, 0xcc, 0xf2, 0x7e, 0xbd,
0x1b, 0x2b, 0x87, 0x18, 0x47, 0x74,
0x8e, 0x8a, 0x76, 0x48, 0x14, 0x96,
0xc1, 0x79, 0x6a, 0x39, 0x56, 0x97,
0xe, 0xe8, 0x71, 0xe5, 0xe3, 0xe2,
0xaa, 0xef, 0x36, 0x31, 0x31, 0x46,
0xe9, 0x9f, 0xd7, 0xda, 0x77, 0xa0,
0xc6, 0x5, 0x37, 0x46, 0xcb, 0x6b,
0xc3, 0xda, 0xe7, 0x35, 0x7f, 0xcf,
0xd8, 0x1b, 0x39, 0x61, 0x19, 0xa8,
0x71, 0x15, 0xc4, 0x55, 0x6, 0xed,
0x5a, 0x8, 0x16, 0x5c, 0x85, 0xf3,
0xc1, 0x31, 0x25, 0x53, 0xd3, 0x4c,
0xa7, 0xf1, 0xd4, 0xb9, 0x46, 0xa2,
0xac, 0x13, 0x29, 0xc5, 0x40, 0x23,
0x9e, 0x17, 0x35, 0x7a, 0x65, 0x38,
0x52, 0x45, 0x59, 0x2d, 0x68, 0x5d,
0x8f, 0xd4, 0x80, 0x88, 0x44, 0xd1,
0x7b, 0x59, 0xc0, 0x6c, 0x23, 0xbc,
0xb6, 0x66, 0x4c, 0xe5, 0x9c, 0xaf,
0x15, 0x6a, 0x0, 0x98, 0x40, 0xf6,
0x6c, 0x55, 0xeb, 0x92, 0xad, 0x6d,
0xe4, 0xa2, 0x14, 0x79, 0xf6, 0x14,
0x5, 0x32, 0x65, 0xa4, 0x69, 0xdc,
0x14, 0x78, 0x8f, 0x3d, 0x50, 0x62,
0x73, 0xe9, 0xe9, 0x33, 0xd0, 0x58,
0xd4, 0x8a, 0xc7, 0xd1, 0xa3, 0x31,
0x6, 0x42, 0x8, 0x21, 0xb0, 0xd6,
0xb6, 0x1, 0x72, 0x19, 0x63, 0x85,
0x70, 0x73, 0xac, 0xaa, 0xb7, 0xc8,
0x6e, 0x1d, 0x63, 0xbc, 0xa, 0x2b,
0x27, 0x30, 0xac, 0x2c, 0xb4, 0x68,
0xe6, 0xc8, 0x4c, 0x4c, 0x30, 0x3e,
0x50, 0xc6, 0x65, 0xb7, 0x56, 0xac,
0x29, 0x0, 0xc4, 0x10, 0x3d, 0xc9,
0x96, 0x68, 0xac, 0x6, 0xc6, 0x28,
0x62, 0x97, 0xc7, 0xee, 0xc0, 0x8c,
0x80, 0xac, 0xa0, 0x6, 0x42, 0xcb,
0x83, 0xd3, 0x4a, 0x81, 0x56, 0xe3,
0x55, 0x68, 0x59, 0x40, 0x6a, 0x35,
0x95, 0x51, 0xf0, 0x20, 0x19, 0x59,
0x70, 0x1, 0x15, 0x28, 0xd4, 0xc,
0x4, 0x1e, 0xd6, 0xdb, 0x81, 0x9d,
0x1b, 0x4a, 0xe7, 0x4c, 0x29, 0x2d,
0x1d, 0xf5, 0xa6, 0xe0, 0xb7, 0xe6,
0x32, 0xb4, 0xea, 0x9e, 0x8f, 0xb,
0xa1, 0xac, 0xbf, 0xc4, 0xd7, 0xab,
0x8d, 0xc, 0x78, 0xe9, 0x92, 0xc6,
0x18, 0xa5, 0x1a, 0x27, 0xab, 0x2a,
0x22, 0x4b, 0x93, 0x66, 0xc, 0x39,
0x7f, 0xec, 0x60, 0x5e, 0xf7, 0x71,
0x7, 0x5f, 0xc8, 0x58, 0xb5, 0xd6,
0x32, 0x63, 0x8, 0x41, 0xca, 0x1,
0xf5, 0x85, 0x8c, 0x94, 0x6e, 0x98,
0x23, 0x79, 0x22, 0x22, 0x44, 0x7b,
0xfc, 0xa2, 0xd7, 0x5a, 0x5a, 0x93,
0xd4, 0xa4, 0x2a, 0xcc, 0x35, 0x2a,
0x49, 0x29, 0xc5, 0xbc, 0x9e, 0x99,
0x63, 0x6c, 0xc6, 0x7f, 0x8d, 0xc4,
0x3a, 0x16, 0xa7, 0xbe, 0x66, 0x39,
0x7b, 0x45, 0x77, 0xc4, 0x26, 0x21,
0x84, 0x18, 0x2, 0xd7, 0x8b, 0xab,
0xa2, 0x18, 0x38, 0x44, 0xdd, 0xec,
0x5d, 0xc7, 0xda, 0xb5, 0x20, 0x20,
0x2, 0x33, 0x28, 0xa1, 0x22, 0xa0,
0x8e, 0x31, 0x56, 0xce, 0x25, 0x59,
0x3e, 0xb6, 0x3e, 0x2d, 0xcf, 0x2e,
0x6b, 0x74, 0x8c, 0x91, 0x98, 0x10,
0x59, 0x1b, 0x83, 0xc8, 0x14, 0xa2,
0xf7, 0xce, 0xac, 0x50, 0x69, 0x1f,
0xcf, 0xcb, 0x41, 0x69, 0x44, 0xd2,
0xa0, 0xeb, 0xa9, 0xce, 0x4c, 0xc1,
0x85, 0x18, 0xa3, 0x49, 0xec, 0xd8,
0x2f, 0x5f, 0xfe, 0x99, 0xaa, 0x2c,
0x24, 0xcf, 0xb7, 0x56, 0x6b, 0x6d,
0x99, 0x23, 0xd5, 0x7d, 0x9d, 0x75,
0x1f, 0x80, 0x16, 0x21, 0xd, 0x40,
0xa3, 0x15, 0x11, 0xf9, 0xe0, 0x3,
0x51, 0xd4, 0x5a, 0x19, 0xbb, 0x7a,
0x19, 0x62, 0x4, 0x60, 0x57, 0x56,
0xa8, 0x40, 0x6b, 0x6d, 0x8d, 0xc6,
0x3a, 0x9c, 0xa6, 0xb1, 0x84, 0x76,
0x8d, 0x5a, 0x81, 0x2b, 0xb, 0x6d,
0x50, 0x14, 0x3f, 0x63, 0xfd, 0x61,
0x6d, 0xb5, 0x59, 0xf9, 0x44, 0xc7,
0xa, 0xdd, 0x65, 0x99, 0x65, 0x59,
0x9a, 0x24, 0x26, 0x2, 0x11, 0x28,
0x41, 0xc0, 0xb1, 0xe4, 0xe7, 0x74,
0x4c, 0xe, 0x29, 0xdf, 0x19, 0x95,
0x92, 0x26, 0xbc, 0x73, 0x7e, 0x79,
0x3d, 0x55, 0xba, 0xc9, 0xe, 0xc4,
0xbe, 0xb7, 0x5e, 0xc8, 0x43, 0x34,
0x49, 0xa2, 0xa5, 0x30, 0xa5, 0x44,
0x4, 0x4f, 0x52, 0x62, 0x2, 0x1e,
0x45, 0xc5, 0xf2, 0x66, 0xf4, 0x3d,
0x4d, 0x53, 0x9, 0x41, 0xbd, 0xf3,
0xa3, 0x20, 0xd6, 0xc8, 0x81, 0x8e,
0xbd, 0x64, 0x0, 0xd0, 0x2b, 0xc9,
0x18, 0xcb, 0x13, 0x38, 0x78, 0x58,
0xaf, 0xa8, 0xa2, 0x6a, 0xdc, 0x35,
0x22, 0x6a, 0x6d, 0x47, 0xeb, 0x85,
0x1a, 0xed, 0xbe, 0xdc, 0xa0, 0x4a,
0xa4, 0x55, 0x56, 0xc, 0x86, 0x6b,
0xaf, 0x98, 0xeb, 0x86, 0x2a, 0xa4,
0x75, 0x56, 0xb9, 0x22, 0x7a, 0x87,
0xc, 0xda, 0x26, 0x22, 0x96, 0xbc,
0x1c, 0xe5, 0x21, 0xc7, 0x18, 0x39,
0x6, 0x44, 0x36, 0xc6, 0x98, 0x24,
0x15, 0x94, 0xfe, 0x7a, 0xf5, 0xea,
0x55, 0x5b, 0xab, 0x6c, 0xec, 0xca,
0x58, 0x41, 0x56, 0x9, 0xf6, 0x46,
0xb6, 0x9c, 0x31, 0xac, 0xae, 0x3a,
0x76, 0x9, 0x58, 0x51, 0xff, 0x1b,
0x77, 0x64, 0x5b, 0x15, 0x38, 0x1d,
0x67, 0x2, 0xa3, 0x22, 0xef, 0xfa,
0xed, 0x76, 0x7b, 0xf3, 0xe6, 0xcd,
0xcf, 0x7b, 0xde, 0x65, 0x5b, 0xb7,
0x6e, 0x4d, 0x53, 0xe3, 0x43, 0x20,
0xa2, 0x2c, 0x49, 0x8, 0xa0, 0x2c,
0x4b, 0x85, 0xc6, 0x5a, 0x23, 0x1a,
0x3b, 0x22, 0x19, 0xa9, 0x11, 0xbd,
0xc0, 0x62, 0x10, 0x1, 0xc0, 0xb9,
0xb8, 0x7f, 0xff, 0xfe, 0xcf, 0xdf,
0xf2, 0x8f, 0x65, 0x59, 0x6a, 0x9b,
0x38, 0xe7, 0x92, 0x24, 0x93, 0x2b,
0x21, 0xa, 0x89, 0xc1, 0x40, 0x65,
0xa7, 0xd3, 0xf9, 0x8d, 0xdf, 0x78,
0xd1, 0x69, 0xa7, 0x9d, 0x16, 0xc9,
0xe7, 0x49, 0xea, 0xa2, 0x93, 0x92,
0xb2, 0xd5, 0xb6, 0x74, 0x65, 0x96,
0x64, 0xfd, 0xe1, 0x30, 0x4d, 0x72,
0x0, 0xb0, 0x6, 0x3, 0x91, 0xac,
0x20, 0x91, 0x8, 0x95, 0x2, 0x80,
0x23, 0x47, 0x17, 0x6e, 0xbd, 0xf5,
0xd6, 0x83, 0x7, 0xe, 0xa7, 0x69,
0xca, 0x58, 0x63, 0xad, 0x98, 0x99,
0x22, 0x2b, 0x8d, 0x31, 0xfa, 0x89,
0x4e, 0x76, 0xc1, 0x5, 0x17, 0x5c,
0x70, 0xc1, 0xf9, 0x5a, 0xeb, 0x3c,
0xb3, 0x83, 0xa2, 0x68, 0xe7, 0xb9,
0x8f, 0x5e, 0x7e, 0xbf, 0xd6, 0x5a,
0xd0, 0x7c, 0x0, 0x90, 0xa5, 0x69,
0x55, 0x85, 0x24, 0x31, 0xc4, 0xa3,
0xa3, 0x0, 0x78, 0x4f, 0xb7, 0xdd,
0x76, 0xdb, 0x4f, 0x1f, 0xfc, 0x99,
0x95, 0x4d, 0x46, 0x80, 0xd3, 0x35,
0xc8, 0x84, 0x89, 0xa3, 0x32, 0xfe,
0xac, 0xd3, 0x4f, 0x7f, 0xe1, 0xb,
0x5f, 0xd8, 0x6e, 0xb7, 0xd3, 0x44,
0xfb, 0xc0, 0x91, 0xbc, 0xf4, 0x51,
0x9d, 0x73, 0x59, 0x92, 0xf8, 0x58,
0x43, 0xb7, 0xf2, 0x34, 0x65, 0xe0,
0xb2, 0x2a, 0xad, 0x4d, 0x99, 0xd9,
0x6a, 0x4d, 0xc, 0xa5, 0x8f, 0xf7,
0xdd, 0xfb, 0xe3, 0xef, 0x7d, 0xef,
0x9f, 0x7, 0x83, 0x41, 0x9e, 0xb7,
0x47, 0x32, 0x97, 0x5c, 0x43, 0x8,
0xb5, 0x56, 0xa, 0x36, 0x9e, 0xb0,
0xf9, 0x15, 0x2f, 0x7b, 0xc9, 0xa6,
0x4d, 0x9b, 0x52, 0x6b, 0x8b, 0xaa,
0xb2, 0xd6, 0x6a, 0xa5, 0x2a, 0xe7,
0x98, 0x39, 0x4f, 0x53, 0x2, 0x28,
0x8a, 0x42, 0x3a, 0x28, 0x89, 0x31,
0x2, 0xd, 0x8d, 0xd, 0x1, 0x10,
0xf1, 0xb1, 0x27, 0x9e, 0xfa, 0xe2,
0x17, 0x6e, 0x9b, 0x9f, 0x5f, 0x34,
0xc6, 0x50, 0x24, 0x59, 0xef, 0xb4,
0xd6, 0xc3, 0x61, 0x5f, 0xba, 0x3e,
0x1b, 0x36, 0xcc, 0xec, 0xb9, 0xf8,
0x82, 0xf3, 0x9f, 0xfd, 0x4c, 0x5,
0x50, 0x79, 0x9f, 0x58, 0xeb, 0xbc,
0x6f, 0x58, 0x3e, 0x2, 0x96, 0x16,
0xe9, 0x59, 0xad, 0x54, 0x29, 0xc0,
0x26, 0xad, 0x0, 0x40, 0x3, 0x96,
0x2e, 0x14, 0x45, 0xf9, 0xb9, 0x7f,
0xb8, 0xe5, 0xd0, 0xa1, 0x43, 0x1a,
0x15, 0x31, 0x45, 0x1f, 0x24, 0x2a,
0x8e, 0x31, 0x5a, 0xab, 0x87, 0xc3,
0x61, 0xbb, 0xdd, 0xbe, 0xf8, 0xe2,
0xb, 0x9f, 0xfb, 0x9c, 0x8b, 0x1,
0xe9, 0x58, 0x2a, 0xf, 0x22, 0x4a,
0x9b, 0xa7, 0x95, 0x65, 0xc, 0x50,
0x8d, 0xc, 0x22, 0x2, 0x93, 0x52,
0x4a, 0x3, 0x56, 0x3e, 0xde, 0x76,
0xdb, 0x97, 0x7f, 0xf6, 0xd0, 0xcf,
0x4b, 0x57, 0x4d, 0x4c, 0x4c, 0x15,
0x45, 0x91, 0xa6, 0xb9, 0xf, 0xce,
0x18, 0x15, 0x9c, 0x7, 0x20, 0xab,
0xf5, 0xd9, 0xbb, 0xcf, 0xba, 0xe4,
0x39, 0x17, 0x6f, 0x9c, 0x99, 0x62,
0x60, 0x8d, 0x18, 0x99, 0x8b, 0xa2,
0x48, 0xd3, 0xd4, 0x6a, 0x3d, 0x1c,
0x55, 0xd1, 0xa5, 0xc0, 0x2e, 0x15,
0xe3, 0x26, 0x14, 0xd, 0x21, 0x24,
0x36, 0xf9, 0xd1, 0x3d, 0xf7, 0x7d,
0xed, 0xab, 0x5f, 0x27, 0x60, 0xad,
0x6d, 0xe5, 0x9d, 0x61, 0x23, 0xb3,
0x23, 0x4d, 0xac, 0x54, 0x33, 0xb7,
0x6d, 0xdf, 0x7a, 0xf9, 0x73, 0x9f,
0x7b, 0xe2, 0x49, 0x27, 0x2c, 0x63,
0xb9, 0x1, 0x7a, 0x83, 0x41, 0xb7,
0xdd, 0x6, 0x0, 0x17, 0xc2, 0xf8,
0xc4, 0x6b, 0x3e, 0x43, 0x44, 0x91,
0x51, 0x29, 0xf5, 0xf8, 0x63, 0xfb,
0x6e, 0xbb, 0xed, 0xb6, 0xa5, 0xa5,
0x25, 0x59, 0x1e, 0x42, 0x20, 0x63,
0xc, 0xac, 0x10, 0x15, 0x55, 0xe3,
0x11, 0x64, 0x43, 0xdc, 0x6f, 0x24,
0x75, 0x96, 0xa1, 0x2a, 0xcd, 0x9b,
0xe3, 0xbe, 0xa2, 0x2b, 0x87, 0x0,
0x64, 0xad, 0x3e, 0xe5, 0x94, 0x93,
0xb7, 0xef, 0xd8, 0x9a, 0xa4, 0x2a,
0x52, 0x20, 0x72, 0xc6, 0x40, 0xe9,
0xfb, 0x21, 0x94, 0xad, 0x2c, 0x49,
0x52, 0x55, 0xb9, 0x21, 0xb1, 0x4b,
0x13, 0x9d, 0x26, 0xba, 0xaa, 0xa,
0x1f, 0xbd, 0xe4, 0x27, 0x1c, 0x23,
0x3, 0xa7, 0x89, 0xee, 0x76, 0xbb,
0x13, 0x93, 0x9d, 0x26, 0xca, 0xad,
0xab, 0x35, 0x4a, 0x9, 0x98, 0x1e,
0x11, 0x76, 0xed, 0x3a, 0xe9, 0xa4,
0x5d, 0x3b, 0x13, 0xa3, 0x10, 0x63,
0x60, 0xc7, 0xe0, 0x1, 0x3, 0x83,
0x8f, 0x50, 0x85, 0xe0, 0x8, 0x42,
0x96, 0x25, 0xd6, 0xa0, 0x35, 0x58,
0xba, 0x92, 0x39, 0x46, 0xa, 0x91,
0x82, 0xf0, 0x7, 0x10, 0x60, 0x72,
0x72, 0x62, 0xc7, 0x8e, 0x1d, 0xab,
0x2e, 0x70, 0xb9, 0x35, 0x6a, 0xf5,
0xe6, 0xcd, 0x9b, 0x4e, 0x39, 0xe5,
0xe4, 0x4e, 0x3b, 0x43, 0x15, 0x23,
0x7b, 0xc4, 0x48, 0xe0, 0x88, 0x1d,
0x40, 0xd0, 0x46, 0x72, 0x9b, 0x68,
0x8c, 0x32, 0x46, 0x21, 0x80, 0x4d,
0xd0, 0x7, 0x41, 0x5, 0x53, 0x59,
0x55, 0x1c, 0xd8, 0x5a, 0xb5, 0x65,
0xcb, 0x96, 0xbc, 0x95, 0x86, 0xe0,
0x1a, 0x71, 0xa6, 0x1a, 0x68, 0x1b,
0x63, 0x8, 0x6e, 0x6a, 0x6a, 0xf2,
0xec, 0x73, 0xce, 0x98, 0x98, 0x6c,
0x31, 0xf8, 0xca, 0x57, 0x95, 0x1b,
0x68, 0x8d, 0x21, 0x94, 0x44, 0xe,
0x31, 0xba, 0x50, 0x22, 0x46, 0x63,
0xc0, 0x18, 0x18, 0x96, 0xfd, 0xca,
0x15, 0x79, 0x9a, 0xc6, 0x58, 0xc5,
0xe8, 0x5d, 0x70, 0xc, 0x6c, 0x95,
0x9a, 0x9c, 0xea, 0x66, 0x59, 0xd2,
0x94, 0x70, 0x9b, 0x67, 0xd0, 0xc0,
0x74, 0x9e, 0x7d, 0xde, 0x33, 0xb7,
0x6c, 0xd9, 0x0, 0x40, 0x81, 0x9c,
0xd6, 0xc8, 0xec, 0x23, 0x5, 0x6b,
0x51, 0x29, 0x28, 0xdd, 0x90, 0x39,
0xb6, 0xf2, 0xa4, 0x95, 0x27, 0xcc,
0x71, 0x58, 0xf6, 0xbd, 0xaf, 0x7c,
0x28, 0x45, 0xcb, 0x47, 0x20, 0x4,
0xad, 0x56, 0xde, 0x6a, 0x67, 0x2,
0x1d, 0xf7, 0xde, 0xb, 0xc3, 0x44,
0x3a, 0xb7, 0x4a, 0xa9, 0x2c, 0xcb,
0xb6, 0x6d, 0xdb, 0xb6, 0xfb, 0xcc,
0xd3, 0x89, 0x5c, 0x51, 0x15, 0x5a,
0xb3, 0xf, 0x8e, 0xc8, 0x25, 0xc6,
0x28, 0x25, 0x52, 0x92, 0x85, 0x20,
0xe1, 0x10, 0xa3, 0x1c, 0x57, 0x6b,
0xe4, 0xe0, 0x89, 0x82, 0x27, 0x6f,
0xac, 0x9a, 0x98, 0xe8, 0x6c, 0xdc,
0x34, 0x3b, 0x4e, 0x77, 0x6b, 0xa4,
0x45, 0x85, 0xc7, 0xbb, 0x79, 0xf3,
0xe6, 0xd3, 0xcf, 0x38, 0x95, 0x21,
0x32, 0x7b, 0x66, 0x4f, 0xe4, 0x88,
0x5c, 0x8c, 0x95, 0x7c, 0x11, 0x39,
0xa5, 0x48, 0x29, 0xaa, 0x7c, 0x31,
0x2c, 0x7a, 0xd6, 0xa2, 0x46, 0xe,
0xa1, 0x44, 0x8a, 0x21, 0xb8, 0x8,
0x6c, 0xad, 0xde, 0xb2, 0x65, 0x73,
0xde, 0x4a, 0x25, 0xcb, 0x65, 0xe6,
0xa2, 0x28, 0x9a, 0xbb, 0xa4, 0xb5,
0x9e, 0x9c, 0x9c, 0xdc, 0xb5, 0x6b,
0xd7, 0xec, 0xec, 0xd4, 0x52, 0x6f,
0xc1, 0xb9, 0xe1, 0xb0, 0xec, 0xc7,
0x58, 0x75, 0x5a, 0x99, 0xd6, 0x5c,
0x54, 0x83, 0x3c, 0xb3, 0x0, 0x1,
0x20, 0xe4, 0xb9, 0xcd, 0x52, 0x3,
0x10, 0x62, 0xac, 0x10, 0xa3, 0x42,
0x8a, 0xd1, 0x23, 0xb2, 0x42, 0x98,
0xec, 0x74, 0xda, 0x9d, 0x5c, 0xee,
0x58, 0x53, 0x1f, 0x41, 0x84, 0xb2,
0x2c, 0x43, 0x70, 0xad, 0x76, 0x76,
0xda, 0x69, 0xa7, 0x6e, 0xdf, 0xb1,
0xd5, 0x6a, 0x1d, 0xa3, 0x27, 0x72,
0x4b, 0x4b, 0x73, 0x3e, 0x56, 0xdd,
0x76, 0xe, 0x40, 0x8b, 0xbd, 0x79,
0xb9, 0x22, 0x80, 0x80, 0x18, 0x11,
0xa3, 0x1c, 0x8e, 0xd9, 0x3, 0x4,
0x5, 0x41, 0x2b, 0x98, 0x98, 0x98,
0x98, 0x9e, 0x9e, 0x6e, 0x66, 0x9f,
0x52, 0xaa, 0x31, 0x88, 0x38, 0xf6,
0x35, 0x3e, 0x98, 0x97, 0xbb, 0x2f,
0xff, 0xa6, 0x17, 0x85, 0x28, 0x49,
0xe6, 0x81, 0x3, 0xfb, 0x37, 0x6c,
0x9c, 0xd1, 0x1a, 0x7, 0x83, 0x5e,
0xa4, 0x2a, 0x4b, 0x2c, 0x28, 0xaf,
0x34, 0x8b, 0x56, 0x59, 0xa4, 0x2a,
0xcf, 0x6c, 0x6a, 0xad, 0x8f, 0x95,
0x8f, 0x95, 0xd1, 0xac, 0x15, 0x69,
0x45, 0x8, 0xc1, 0xfb, 0x22, 0x54,
0xa5, 0x2, 0xc8, 0x72, 0xbb, 0x65,
0xcb, 0x96, 0xc1, 0xb0, 0xe7, 0x5c,
0xa9, 0x94, 0x12, 0x0, 0x26, 0x31,
0x84, 0x40, 0x59, 0x96, 0x2d, 0x2e,
0x2e, 0x76, 0x27, 0xda, 0x5a, 0x63,
0x59, 0xf6, 0xad, 0x46, 0xe4, 0x60,
0x35, 0x58, 0xa5, 0x7c, 0x28, 0x63,
0xa8, 0x3a, 0xad, 0x8c, 0xa2, 0xf7,
0x6e, 0x48, 0xec, 0x89, 0x7d, 0x9e,
0x24, 0x8, 0x14, 0x83, 0x63, 0xa,
0x5a, 0x51, 0x8c, 0x5e, 0xa8, 0x76,
0x33, 0x33, 0xd3, 0x3e, 0x54, 0xd2,
0x3f, 0x6c, 0x30, 0x6b, 0xb2, 0x8f,
0x2d, 0x2e, 0x2e, 0x32, 0xf3, 0xcc,
0xec, 0x54, 0x51, 0x15, 0x88, 0x1c,
0xa2, 0xcb, 0x32, 0x5b, 0xba, 0x41,
0x62, 0xb4, 0xa3, 0x22, 0x92, 0x33,
0xa, 0xad, 0xd6, 0x91, 0xaa, 0x48,
0x55, 0xe5, 0xb, 0x44, 0x66, 0x72,
0x5a, 0x11, 0x32, 0x1, 0x45, 0x40,
0xe2, 0x18, 0x77, 0xed, 0xdc, 0xd9,
0xeb, 0xf5, 0x24, 0x39, 0x19, 0xf,
0x61, 0x8, 0x10, 0x40, 0x2d, 0x2c,
0xce, 0x6d, 0xda, 0x3c, 0x53, 0xb9,
0x81, 0xf, 0x45, 0x62, 0x55, 0xa7,
0x95, 0x11, 0x3b, 0x86, 0x18, 0xc9,
0x6b, 0x3, 0xce, 0x17, 0xc4, 0xde,
0x68, 0x34, 0x1a, 0x6d, 0xa2, 0x6c,
0xa2, 0x4a, 0x3f, 0xd0, 0x8a, 0xad,
0x81, 0x18, 0x1c, 0x32, 0x1, 0xd2,
0x9, 0xdb, 0xb6, 0x67, 0x49, 0x22,
0xa8, 0x89, 0xf1, 0x27, 0x47, 0x44,
0x2e, 0xf8, 0xb2, 0x1a, 0xb6, 0xdb,
0xb9, 0xd5, 0x9a, 0xc1, 0x97, 0xd5,
0x90, 0xd8, 0xa1, 0x62, 0x62, 0x47,
0x1c, 0x18, 0xbc, 0x36, 0x8, 0x18,
0x22, 0xfb, 0xc8, 0x1e, 0x55, 0xb4,
0x89, 0x56, 0x9a, 0x42, 0x74, 0x91,
0x2a, 0x54, 0x31, 0x4, 0x17, 0xa2,
0xdf, 0xb4, 0x61, 0x66, 0xd3, 0xec,
0x6, 0xc1, 0xb1, 0xd7, 0xb5, 0x3,
0x54, 0x1c, 0x49, 0x90, 0x80, 0x73,
0x73, 0x73, 0x13, 0xdd, 0xb6, 0x31,
0xca, 0x28, 0xa5, 0xd, 0x17, 0xe5,
0x0, 0x30, 0x28, 0xd, 0x55, 0x18,
0x28, 0x80, 0x48, 0x15, 0x43, 0xd4,
0x86, 0xb5, 0x61, 0xe7, 0x4b, 0xad,
0xd8, 0x28, 0x15, 0x62, 0x49, 0xec,
0x94, 0x22, 0xef, 0x65, 0x26, 0xf0,
0x96, 0x2d, 0x9b, 0x8b, 0x72, 0x20,
0xe2, 0xb2, 0x4d, 0xc3, 0x42, 0x36,
0xbd, 0xa5, 0xa5, 0x5, 0xa2, 0x30,
0x35, 0x35, 0x89, 0x18, 0x51, 0x91,
0x7c, 0x1, 0x46, 0xf9, 0xe, 0x18,
0x43, 0xac, 0xe4, 0x2f, 0x53, 0x6b,
0xda, 0x79, 0xa6, 0x90, 0x23, 0xb8,
0x10, 0x2b, 0x54, 0x51, 0x29, 0xa8,
0xaa, 0x82, 0x38, 0x9c, 0xb0, 0x73,
0x7b, 0x55, 0x95, 0x91, 0x7c, 0x53,
0xa6, 0x12, 0x1c, 0x78, 0x8c, 0x71,
0x30, 0x18, 0xc, 0x6, 0x83, 0xad,
0xdb, 0x36, 0x97, 0x55, 0x99, 0x67,
0x89, 0x56, 0xdc, 0xce, 0xd2, 0xc4,
0xa8, 0xfe, 0x60, 0xc1, 0xbb, 0xa2,
0x95, 0x26, 0xcc, 0xde, 0x20, 0x18,
0x4, 0xe0, 0x50, 0x96, 0xfd, 0x18,
0xaa, 0xc4, 0x28, 0x26, 0xef, 0xdc,
0xd0, 0x1a, 0x10, 0xb2, 0xd3, 0x86,
0x8d, 0x33, 0xd3, 0xd3, 0x53, 0xe5,
0xb0, 0x70, 0xce, 0x21, 0x82, 0x18,
0xf, 0xa5, 0x69, 0xaa, 0x14, 0x10,
0xd1, 0xdc, 0xe1, 0x23, 0x1b, 0x67,
0xa7, 0x8d, 0xc2, 0x61, 0xd1, 0x33,
0x9a, 0x9d, 0x2f, 0xd2, 0xcc, 0x0,
0xc6, 0x41, 0xb9, 0xe4, 0xa9, 0x6c,
0xb5, 0xd3, 0x61, 0xd1, 0x1b, 0x16,
0x3d, 0x62, 0xcf, 0x10, 0xe4, 0xa2,
0x22, 0xb9, 0x10, 0x2b, 0x62, 0xcf,
0x1c, 0x23, 0x53, 0xa7, 0xdb, 0x9a,
0x99, 0x9d, 0x2a, 0xab, 0xa1, 0x94,
0x30, 0xb5, 0xc6, 0x18, 0xfd, 0xbf,
0x76, 0x32, 0x12, 0xad, 0xe, 0xa1,
0xc7, 0x73, 0xe0, 0x75, 0x8a, 0x58,
0xca, 0xbb, 0x90, 0x67, 0x89, 0x46,
0x8b, 0xa4, 0x35, 0xea, 0x76, 0xde,
0x61, 0xf0, 0xc3, 0x62, 0x20, 0x71,
0x7c, 0x59, 0x14, 0x44, 0xdc, 0x6d,
0x4f, 0xd6, 0xad, 0x17, 0x25, 0x31,
0x4f, 0xbd, 0x3f, 0x19, 0x63, 0x4c,
0x5d, 0xed, 0x24, 0x88, 0xc4, 0x4c,
0xce, 0xb9, 0x76, 0x67, 0x42, 0x6b,
0x25, 0xd8, 0x3, 0xc1, 0xe2, 0x33,
0x23, 0x92, 0x4a, 0x54, 0x9a, 0x99,
0x3c, 0xc4, 0xa, 0x1, 0x29, 0xfa,
0xe8, 0xe3, 0xa0, 0x1a, 0x4e, 0x4d,
0x4c, 0x9, 0xc, 0xb, 0x0, 0x5a,
0x59, 0x27, 0x78, 0x11, 0x7c, 0x61,
0xb9, 0xa1, 0x75, 0xa, 0x7, 0x4a,
0x2b, 0x40, 0x44, 0x2d, 0xad, 0xd4,
0x91, 0x87, 0x43, 0xd3, 0xe7, 0x63,
0x82, 0x44, 0x27, 0xa, 0x8c, 0x55,
0xa9, 0xd2, 0x8, 0x10, 0x2a, 0x57,
0x58, 0x6d, 0x52, 0x93, 0x55, 0x95,
0xcb, 0xd2, 0xc, 0x15, 0x12, 0x30,
0x51, 0xcc, 0x6d, 0x4b, 0xfa, 0x7,
0xc1, 0x85, 0x24, 0x31, 0xcc, 0xb1,
0x72, 0xde, 0x18, 0xc3, 0xb1, 0x76,
0x96, 0xc9, 0xac, 0xf5, 0x75, 0x11,
0x95, 0x9a, 0x10, 0x9a, 0x0, 0x99,
0xa8, 0x9b, 0x77, 0xab, 0xc2, 0xcd,
0x4e, 0x6e, 0xaa, 0x7c, 0xe1, 0xaa,
0x8, 0x48, 0x44, 0x2c, 0x12, 0x90,
0x81, 0x5c, 0x37, 0x9f, 0x4, 0xa0,
0xc8, 0x11, 0x0, 0x12, 0x95, 0x30,
0x70, 0x15, 0x4a, 0xb2, 0x4c, 0x91,
0x92, 0x24, 0x75, 0xbe, 0x54, 0x98,
0x20, 0x83, 0x0, 0x45, 0x6a, 0xb6,
0x70, 0x8d, 0x30, 0x1, 0x44, 0x64,
0xa, 0x4c, 0x4, 0x91, 0x86, 0xc5,
0x80, 0x19, 0xbb, 0xad, 0x4e, 0xe5,
0x7d, 0x55, 0x94, 0x69, 0x9a, 0x5b,
0xa5, 0x41, 0xa5, 0x0, 0x54, 0x3a,
0x27, 0xce, 0x1b, 0xa9, 0xce, 0x2,
0xb9, 0xa2, 0xa8, 0xb2, 0x2c, 0xf1,
0x54, 0x11, 0x83, 0x36, 0x18, 0x82,
0x13, 0xd2, 0x8c, 0xaf, 0x2a, 0xd3,
0x55, 0xa0, 0x41, 0xb8, 0x4, 0xde,
0xfb, 0x34, 0xb5, 0x56, 0x9b, 0x61,
0xf0, 0xc6, 0x18, 0xab, 0xcd, 0xfc,
0xc2, 0x91, 0xe9, 0xa9, 0xd9, 0xb4,
0x95, 0x54, 0xde, 0x67, 0x36, 0x1,
0x50, 0x3e, 0x56, 0xa9, 0xcd, 0x14,
0x80, 0x8f, 0x11, 0x0, 0x5a, 0x49,
0x5e, 0xff, 0xa5, 0xce, 0x48, 0x87,
0xa2, 0x2a, 0x92, 0x34, 0x11, 0x64,
0xb8, 0xd2, 0x75, 0x59, 0xb1, 0xaa,
0xbc, 0xf0, 0x49, 0x89, 0x48, 0x29,
0x10, 0x26, 0xa3, 0xb1, 0x4a, 0x3,
0x4a, 0x5a, 0xd, 0x63, 0x9a, 0xf2,
0x8, 0x9a, 0x39, 0xe6, 0xb6, 0xdd,
0x1f, 0x2e, 0x1, 0x40, 0x6a, 0x72,
0x4, 0x66, 0xc0, 0xe0, 0x9c, 0x2,
0xa3, 0x51, 0x31, 0x45, 0x54, 0x51,
0x7c, 0x95, 0x84, 0x6b, 0xa9, 0x95,
0xae, 0xaa, 0x2a, 0x49, 0xb2, 0xb2,
0x2c, 0x11, 0xd9, 0x5a, 0x9b, 0x24,
0x26, 0x44, 0xa7, 0x14, 0xa6, 0xc6,
0x6a, 0x45, 0x88, 0xdc, 0x1b, 0xc,
0x93, 0xc4, 0x74, 0xdb, 0x53, 0x0,
0xd4, 0x1f, 0xe, 0x11, 0xb9, 0x28,
0x2a, 0x0, 0xd8, 0x30, 0x33, 0xd3,
0xca, 0x12, 0x82, 0x10, 0x49, 0xfa,
0x11, 0x0, 0x10, 0xd, 0x2a, 0xa,
0xce, 0x28, 0xcd, 0x21, 0x86, 0xe8,
0xb2, 0x56, 0x9b, 0x46, 0x8e, 0x44,
0x83, 0xc1, 0x40, 0x21, 0xa7, 0x89,
0x29, 0x7d, 0x95, 0x18, 0x6d, 0x94,
0x4a, 0xb2, 0x7c, 0x69, 0xd0, 0x4f,
0x12, 0x83, 0xa8, 0x29, 0xc4, 0x4e,
0x36, 0xe1, 0x42, 0x19, 0x2, 0xcd,
0x4e, 0xce, 0x4a, 0x20, 0xcd, 0x14,
0xc5, 0xea, 0x43, 0xa3, 0x45, 0x25,
0x1a, 0x84, 0x64, 0x50, 0x39, 0x8,
0x45, 0x31, 0x4, 0x60, 0xa5, 0x1,
0x22, 0xad, 0xb2, 0xe3, 0x5b, 0x33,
0x7, 0x1e, 0xdf, 0x8d, 0xcd, 0xb1,
0x32, 0xb, 0x2b, 0x39, 0x9f, 0x6b,
0x54, 0xd, 0xb5, 0x32, 0x31, 0xa0,
0xd6, 0xb6, 0x28, 0xaa, 0xaa, 0xa,
0x0, 0xa4, 0x34, 0x8, 0x1e, 0xcb,
0x18, 0x9b, 0xa6, 0x59, 0x8c, 0x7c,
0xe8, 0xf0, 0x91, 0x47, 0x1f, 0x7d,
0x5c, 0x29, 0x75, 0xce, 0x39, 0xbb,
0x1, 0xc0, 0xea, 0x46, 0x20, 0x5a,
0x49, 0x30, 0xb, 0xa8, 0xc7, 0x9b,
0x4f, 0x8d, 0x47, 0x56, 0x88, 0x51,
0x1, 0xc6, 0xc8, 0x46, 0x27, 0x21,
0x90, 0xf7, 0x31, 0x12, 0x79, 0x1f,
0xad, 0x51, 0x4a, 0xe9, 0xa9, 0x89,
0xe9, 0x40, 0xe1, 0xe1, 0x87, 0x1f,
0x5e, 0x58, 0x58, 0xe2, 0x10, 0x93,
0x24, 0x33, 0x3a, 0x1, 0x80, 0x93,
0x76, 0xed, 0x4c, 0x53, 0x8d, 0xa,
0xd0, 0x8, 0x9d, 0x2d, 0x8a, 0x44,
0x59, 0x43, 0x97, 0x7, 0x5c, 0xc6,
0x36, 0x33, 0xa0, 0x8, 0xb8, 0x30,
0x63, 0x8, 0x64, 0x51, 0x47, 0x22,
0xad, 0x2c, 0x11, 0x84, 0x10, 0xe,
0x1e, 0x3c, 0xb4, 0xb8, 0xb8, 0x68,
0x8c, 0x91, 0x3f, 0x8a, 0x66, 0xd5,
0xc4, 0xc4, 0xd4, 0x49, 0x27, 0xee,
0xac, 0xca, 0x9e, 0x4d, 0x8c, 0x4c,
0xd4, 0x18, 0x42, 0x96, 0x65, 0xc2,
0x44, 0x1d, 0x29, 0x52, 0x8c, 0xe5,
0x39, 0x80, 0xc, 0xe0, 0x9c, 0xb,
0x9e, 0x22, 0x71, 0xf0, 0xa4, 0xb5,
0x5, 0x86, 0x56, 0xd6, 0xda, 0xf7,
0xe4, 0xbe, 0xa3, 0x47, 0x8f, 0x86,
0xe8, 0xb2, 0xb4, 0xb5, 0xb8, 0x34,
0x9f, 0x65, 0x99, 0xa8, 0xc9, 0x3a,
0xe7, 0x4e, 0x3b, 0xed, 0x19, 0x1a,
0xc0, 0x55, 0xce, 0x9a, 0xd4, 0x7b,
0xdf, 0xca, 0x53, 0x1a, 0xc3, 0xf7,
0x32, 0x1, 0x31, 0xa3, 0x5a, 0x61,
0x76, 0x9f, 0xe7, 0xed, 0x34, 0xcd,
0x63, 0xe0, 0xca, 0xfb, 0xa5, 0xc5,
0x7e, 0xab, 0x9d, 0x19, 0x9d, 0x2c,
0xf5, 0x17, 0x7f, 0xf5, 0xf8, 0xbe,
0xc5, 0xa5, 0x79, 0x85, 0xa6, 0xd5,
0xce, 0x0, 0x60, 0xa2, 0x3b, 0xb5,
0x7d, 0xc7, 0xd6, 0x6e, 0x7b, 0x72,
0x7e, 0xf1, 0x70, 0xda, 0xb2, 0xce,
0x39, 0x6b, 0x52, 0x41, 0x80, 0xe1,
0x8, 0xa5, 0xa4, 0xb4, 0x1, 0x46,
0x6b, 0x12, 0xc1, 0xd3, 0x37, 0xc9,
0x2a, 0x11, 0xe4, 0x79, 0xdb, 0xfb,
0xe8, 0x7c, 0x19, 0x3c, 0xed, 0x5f,
0xdc, 0x7f, 0xf8, 0xd0, 0xd1, 0xee,
0x44, 0xfb, 0xc4, 0x9d, 0xbb, 0x2a,
0x57, 0x8, 0xc3, 0xb6, 0xd5, 0xce,
0x7e, 0xf6, 0xd0, 0x43, 0xfd, 0xc1,
0xd2, 0x79, 0xcf, 0xbe, 0xc0, 0x87,
0xa, 0x14, 0xa7, 0x80, 0xde, 0xf9,
0x24, 0xc9, 0x34, 0x20, 0x12, 0x53,
0x8, 0x48, 0xac, 0x94, 0x54, 0x33,
0x91, 0x42, 0x20, 0x62, 0x20, 0xe2,
0x10, 0xbd, 0xf7, 0x59, 0xaa, 0x45,
0xda, 0x92, 0x41, 0xf0, 0xab, 0xb5,
0xb8, 0x71, 0xf0, 0x45, 0x9a, 0xe6,
0x0, 0x70, 0xe0, 0xc0, 0xa1, 0x27,
0x9f, 0x7a, 0x62, 0x76, 0x66, 0xe3,
0x8e, 0x13, 0xb6, 0x31, 0x71, 0x59,
0x3a, 0xd4, 0x80, 0xcc, 0x1a, 0x10,
0x29, 0xa6, 0xc6, 0x96, 0x65, 0xa5,
0xb4, 0x31, 0xa8, 0x44, 0x77, 0xd6,
0x1a, 0xe3, 0x2b, 0x97, 0xa4, 0x6,
0x1, 0x7c, 0x59, 0xc5, 0x56, 0x36,
0xe8, 0xd, 0xb2, 0xc4, 0x74, 0xf2,
0xce, 0xa1, 0x43, 0x7, 0x1e, 0x7b,
0xec, 0x81, 0x89, 0x89, 0xce, 0xae,
0x5d, 0xa7, 0x18, 0xad, 0xba, 0x33,
0x93, 0x0, 0x30, 0x37, 0x7f, 0xe4,
0xe1, 0x87, 0x7f, 0xe9, 0x7d, 0x75,
0xf2, 0xc9, 0xcf, 0x98, 0x9d, 0x9d,
0xd6, 0xa0, 0x15, 0x43, 0xa4, 0x28,
0xd, 0xb0, 0xa6, 0x23, 0x13, 0x42,
0xd0, 0xda, 0x18, 0x63, 0x8a, 0xc2,
0x69, 0xab, 0x6b, 0xa2, 0x65, 0x14,
0x3f, 0x40, 0xdf, 0x6a, 0xb5, 0x62,
0x8c, 0xa9, 0xcd, 0x9f, 0x3e, 0xf0,
0xe4, 0x81, 0xfd, 0x7b, 0x93, 0xd4,
0x9c, 0xbc, 0xeb, 0x19, 0xc3, 0xb2,
0x14, 0x1e, 0x32, 0x31, 0x31, 0xb1,
0xd2, 0xa0, 0x95, 0x56, 0x1a, 0x29,
0x42, 0x8c, 0xac, 0x34, 0x65, 0x36,
0x51, 0xc, 0x1a, 0x90, 0x7c, 0xb0,
0x4a, 0x3b, 0x17, 0xb4, 0xd6, 0x14,
0xd7, 0xe8, 0x3, 0xd3, 0x48, 0xe6,
0x6, 0xc6, 0x64, 0x65, 0x8d, 0x7c,
0xb4, 0xfe, 0xe, 0x4c, 0xc4, 0x88,
0x28, 0x53, 0x8c, 0xd6, 0x9c, 0xc0,
0xc8, 0x80, 0x40, 0x1c, 0x2, 0xfa,
0x34, 0xb7, 0xc, 0x10, 0x62, 0x50,
0x91, 0x23, 0x5, 0x88, 0x5c, 0xd,
0x2b, 0x22, 0x7a, 0xe2, 0x89, 0x27,
0xae, 0xfd, 0x2f, 0x7f, 0xf2, 0xd5,
0x2f, 0x7d, 0xc5, 0x66, 0xd9, 0x6f,
0xfd, 0xd6, 0x6f, 0x1, 0xc0, 0x75,
0x7f, 0xfe, 0xa1, 0xa9, 0xa9, 0x89,
0x41, 0xe1, 0xd2, 0x14, 0x8d, 0x4e,
0x62, 0xe4, 0x2c, 0x4f, 0xb4, 0x6a,
0x18, 0x61, 0xec, 0xbd, 0x47, 0x6d,
0x2a, 0x5f, 0x1a, 0x9d, 0xc4, 0x18,
0x14, 0x2a, 0x86, 0x8, 0xc4, 0x1c,
0x49, 0xa1, 0xa6, 0x10, 0x43, 0xc,
0x69, 0x6a, 0xef, 0xf9, 0xd1, 0xdd,
0x7f, 0xfc, 0x9f, 0xaf, 0xfd, 0xf1,
0x7d, 0xf7, 0xbf, 0xfe, 0xd, 0xbf,
0xf5, 0xaa, 0x57, 0xbd, 0xfa, 0xc8,
0x91, 0x47, 0xaf, 0xbf, 0xfe, 0x7a,
0x0, 0xf8, 0xf9, 0xbf, 0xfc, 0xcb,
0xfb, 0xff, 0xf0, 0x3f, 0x7e, 0xe0,
0x3, 0x1f, 0xc8, 0xda, 0x2d, 0x31,
0x2b, 0x73, 0xce, 0xa7, 0xb9, 0x96,
0x99, 0x90, 0xe7, 0xb9, 0xf3, 0xe,
0x40, 0x91, 0xa, 0x14, 0x41, 0x6b,
0x1d, 0x22, 0xb1, 0x62, 0x1f, 0x1d,
0x11, 0x79, 0x2f, 0xd6, 0x5e, 0xd1,
0x6a, 0xed, 0xa, 0xf7, 0x1f, 0xff,
0xe0, 0x7d, 0x5f, 0xfe, 0xca, 0x57,
0x2f, 0xbc, 0xe0, 0xfc, 0x33, 0x77,
0x9f, 0xd5, 0xef, 0xf, 0xf, 0x1d,
0x3a, 0x4, 0x0, 0x77, 0xde, 0x79,
0x67, 0xa7, 0xd3, 0xf9, 0xcb, 0xbf,
0xfc, 0xf0, 0x6b, 0x5f, 0xfb, 0x5a,
0x9d, 0x58, 0x6b, 0x4c, 0x19, 0x2b,
0x1d, 0xc0, 0xa4, 0xa9, 0x67, 0x14,
0x78, 0x15, 0x8c, 0x88, 0xd7, 0x2c,
0x81, 0x40, 0xc, 0x88, 0x36, 0x49,
0xb2, 0xaa, 0xaa, 0x88, 0x0, 0xa2,
0x37, 0xc6, 0xf8, 0xca, 0xff, 0xf4,
0x81, 0x9f, 0xfe, 0xee, 0xd5, 0x6f,
0x1f, 0xc, 0x6, 0x2f, 0x7d, 0xe9,
0x4b, 0x85, 0xd0, 0x3, 0x0, 0x4b,
0x4b, 0x4b, 0x3b, 0xb6, 0x6d, 0x7f,
0xe7, 0xbb, 0x7e, 0xef, 0xac, 0xb3,
0xce, 0x40, 0x30, 0xc3, 0x61, 0x5,
0xac, 0x64, 0xc1, 0x43, 0xad, 0x3,
0x72, 0x20, 0xcf, 0x28, 0xbe, 0x89,
0x44, 0x23, 0x4e, 0x3, 0x92, 0xa2,
0xc0, 0xb1, 0xaa, 0x4d, 0x0, 0xda,
0x79, 0x5e, 0x15, 0xd5, 0xf5, 0x7f,
0xf1, 0x5f, 0x3f, 0xfa, 0xd1, 0x8f,
0x6e, 0xdd, 0xba, 0xf5, 0x8a, 0x2b,
0xae, 0xb8, 0xe8, 0xa2, 0x8b, 0xee,
0xbf, 0xff, 0x7e, 0x0, 0xf8, 0xef,
0xff, 0xfd, 0xaf, 0x67, 0x66, 0x66,
0x3e, 0xfc, 0xe1, 0xf, 0xbf, 0xe6,
0x35, 0xaf, 0xe1, 0x8a, 0x41, 0xa9,
0x40, 0x94, 0xd8, 0x6c, 0x58, 0x78,
0x44, 0x45, 0x0, 0x65, 0xf4, 0x1c,
0x2, 0x20, 0x54, 0xa1, 0x2, 0x85,
0xa8, 0x30, 0x90, 0x47, 0x44, 0x5f,
0x96, 0xc1, 0x95, 0x14, 0x43, 0x92,
0x68, 0xe, 0x51, 0x33, 0xff, 0xdd,
0xa7, 0x6f, 0xfa, 0xd0, 0x7, 0xff,
0xdb, 0x2b, 0x5e, 0xf5, 0xca, 0xff,
0xf9, 0xd9, 0x9b, 0x8d, 0x31, 0x1a,
0xd, 0x0, 0xfc, 0xf0, 0x9f, 0xef,
0x7a, 0xfb, 0xef, 0xfc, 0xce, 0x81,
0x83, 0x7, 0x3f, 0xf7, 0xf, 0xff,
0xf0, 0x92, 0x97, 0xbd, 0xb8, 0xf4,
0x65, 0x39, 0x74, 0x4a, 0x5b, 0x22,
0xd0, 0x36, 0x75, 0x31, 0xa4, 0x0,
0x1e, 0x88, 0x62, 0x60, 0x4, 0x4,
0x2, 0x85, 0x84, 0x42, 0x2c, 0x93,
0x70, 0xda, 0x21, 0x71, 0x9e, 0xe7,
0x4a, 0x99, 0xc3, 0xf3, 0x7, 0xdb,
0xed, 0x36, 0x0, 0x88, 0x10, 0xcf,
0xf6, 0x6d, 0xdb, 0x1, 0xe0, 0xcb,
0x5f, 0xfa, 0xd2, 0xbb, 0x7f, 0xff,
0xf7, 0x5f, 0xfb, 0xba, 0xd7, 0xdc,
0x78, 0xe3, 0x8d, 0x9b, 0x37, 0x6d,
0x3e, 0x3c, 0xdf, 0x4f, 0x93, 0x9c,
0x88, 0x3d, 0x32, 0x93, 0xf6, 0x44,
0x91, 0x11, 0x81, 0x59, 0x6b, 0x4f,
0x11, 0xac, 0xf6, 0x14, 0x59, 0x61,
0xe5, 0x7d, 0xa7, 0xdb, 0x42, 0x44,
0xa, 0x6c, 0x95, 0xf5, 0x55, 0xec,
0xb4, 0xf4, 0x17, 0x6e, 0xbd, 0xed,
0xf, 0xfe, 0xe0, 0xdd, 0x97, 0x5d,
0x76, 0xd9, 0xe7, 0x3e, 0xf7, 0xb9,
0x18, 0xe3, 0xd, 0x37, 0xdc, 0x0,
0x0, 0x7f, 0xfd, 0xd7, 0x7f, 0xfd,
0xac, 0x67, 0x3d, 0xeb, 0x83, 0x1f,
0xfc, 0xe0, 0xc6, 0xd9, 0x19, 0xa1,
0x8e, 0x14, 0x55, 0x50, 0xc6, 0x98,
0xc4, 0x46, 0x2, 0x42, 0x8c, 0x4,
0xa1, 0x56, 0xb4, 0x21, 0x11, 0x24,
0xad, 0x67, 0xb5, 0xd6, 0x65, 0x15,
0x49, 0xe9, 0xe0, 0x23, 0x6, 0x8c,
0x8e, 0xab, 0x50, 0xfd, 0xd3, 0x97,
0xbf, 0xf1, 0x5f, 0xfe, 0xeb, 0x7f,
0xde, 0xbd, 0x7b, 0xf7, 0x27, 0x3e,
0xf1, 0x89, 0x99, 0x99, 0x99, 0x86,
0x4e, 0xe8, 0x9c, 0xcb, 0xb2, 0xc,
0xc, 0x55, 0x45, 0x30, 0xc6, 0x44,
0x46, 0xf4, 0x14, 0x42, 0x4c, 0xf3,
0x4e, 0xe5, 0x29, 0xc9, 0x34, 0x31,
0xb3, 0x4e, 0x3c, 0x8f, 0xa0, 0x41,
0x75, 0x17, 0x70, 0x84, 0x56, 0x4,
0x90, 0xa1, 0x86, 0x0, 0x4a, 0xab,
0x18, 0x62, 0x9a, 0xa6, 0xe6, 0xff,
0x87, 0xa7, 0x72, 0xe4, 0x20, 0x1d,
0xca, 0xc0, 0x44, 0x1c, 0x48, 0xc4,
0xdf, 0x8, 0xf5, 0xa8, 0x32, 0xb9,
0x77, 0xef, 0xde, 0xfb, 0xee, 0xbb,
0xef, 0xe4, 0xd3, 0x4e, 0x59, 0x5a,
0xec, 0xff, 0xe0, 0x7, 0x3f, 0x0,
0x80, 0x87, 0x1e, 0x7a, 0xe8, 0xf2,
0xcb, 0x2f, 0xb7, 0x86, 0x81, 0x95,
0xac, 0x31, 0xc5, 0xb0, 0xa, 0x21,
0x48, 0x43, 0xe2, 0x18, 0xc5, 0xa0,
0xa6, 0x17, 0x1d, 0x22, 0x5, 0x69,
0x17, 0x19, 0xa5, 0x13, 0x93, 0x3e,
0xf8, 0xe0, 0x83, 0xf7, 0xdc, 0x75,
0xf7, 0x49, 0x27, 0x9d, 0xf4, 0xb6,
0xb7, 0x5e, 0x75, 0xd1, 0x9e, 0x4b,
0x8c, 0x36, 0x1b, 0x36, 0x6c, 0x0,
0x80, 0x1b, 0x6f, 0xbc, 0x71, 0x69,
0x69, 0xe9, 0xe0, 0xc1, 0x83, 0xa7,
0x9c, 0x7a, 0x7a, 0x62, 0xd5, 0x60,
0x50, 0x50, 0xbd, 0xa9, 0xd2, 0xca,
0x8e, 0x85, 0xe0, 0x76, 0xf4, 0x58,
0x27, 0x86, 0x58, 0x24, 0xe9, 0x99,
0x38, 0x12, 0x47, 0x18, 0xc, 0x6,
0x89, 0x35, 0x57, 0x5d, 0x75, 0xd5,
0xbb, 0xdf, 0xfd, 0xee, 0xca, 0x87,
0xa7, 0x9e, 0x7a, 0xa, 0x0, 0xfe,
0xf6, 0x6f, 0xff, 0xf6, 0x63, 0x1f,
0xfb, 0xd8, 0xa7, 0x3f, 0xfd, 0xe9,
0x33, 0xcf, 0x3c, 0xf3, 0xac, 0xb3,
0xcf, 0xed, 0xf7, 0xfb, 0xda, 0x64,
0x11, 0xb8, 0x2c, 0x5c, 0x96, 0x65,
0xc3, 0xa1, 0x78, 0x94, 0x8e, 0x1f,
0x2a, 0x82, 0x68, 0xab, 0xaf, 0x90,
0xf9, 0xae, 0xb, 0x51, 0xfd, 0x7e,
0x7f, 0xdb, 0xb6, 0x6d, 0x1f, 0xff,
0xf8, 0xc7, 0x67, 0x66, 0x66, 0xb2,
0x24, 0x1d, 0x57, 0xc3, 0x75, 0xa1,
0x1a, 0x89, 0xaa, 0x12, 0x13, 0x86,
0x3a, 0x50, 0xa, 0x63, 0x9c, 0x8a,
0x51, 0xeb, 0x9f, 0x41, 0xf0, 0xd8,
0x4d, 0xb3, 0x14, 0x11, 0xf7, 0xee,
0xdd, 0xfb, 0xc9, 0x4f, 0x7e, 0x32,
0xc6, 0x78, 0xed, 0xb5, 0xd7, 0xbe,
0xf9, 0xcd, 0x6f, 0xce, 0xb3, 0x7c,
0xe9, 0xf5, 0x4b, 0x0, 0x70, 0xe2,
0x89, 0x27, 0x7c, 0xfc, 0xe3, 0x1f,
0xff, 0xee, 0x77, 0xbf, 0xfb, 0x8a,
0x57, 0xbc, 0x2, 0xd1, 0x42, 0x4,
0x46, 0x34, 0x1a, 0x46, 0xf6, 0x74,
0x46, 0x6b, 0x2d, 0x29, 0xcc, 0xa8,
0xd9, 0xa8, 0x6b, 0x7c, 0x92, 0xa0,
0x26, 0x2a, 0x7, 0xc4, 0x46, 0xe9,
0x40, 0x21, 0xfa, 0x90, 0x65, 0x59,
0x3b, 0x6f, 0x75, 0xbb, 0x5d, 0xd1,
0x97, 0x6, 0x80, 0x13, 0x76, 0xec,
0x60, 0xe6, 0xc4, 0xda, 0xda, 0xcd,
0x2c, 0x30, 0x21, 0x31, 0x98, 0x51,
0x2f, 0x4c, 0x0, 0x98, 0x35, 0xd2,
0x96, 0xc7, 0x2c, 0x65, 0x47, 0x96,
0x88, 0xca, 0x26, 0x5a, 0xf8, 0xdb,
0xa2, 0x8, 0xeb, 0x9c, 0xeb, 0x74,
0x3a, 0x4a, 0xa9, 0x61, 0x31, 0x6c,
0x60, 0x18, 0xa2, 0xb0, 0x5d, 0xb9,
0xaa, 0x93, 0xb7, 0x5c, 0x0, 0x66,
0x64, 0xaa, 0x95, 0x7a, 0x45, 0xc,
0x13, 0x81, 0x5, 0x16, 0x25, 0x2c,
0x65, 0x1c, 0xbb, 0xf3, 0xd6, 0xda,
0xa4, 0xd5, 0x12, 0x71, 0x3c, 0x51,
0x35, 0x5b, 0x58, 0x58, 0xf8, 0xc2,
0x17, 0xbe, 0xf0, 0x91, 0x8f, 0x7c,
0x4, 0x0, 0x2e, 0xbd, 0xf4, 0xd2,
0xeb, 0xae, 0xbb, 0xee, 0x9c, 0x73,
0xce, 0x11, 0x4b, 0x44, 0xe7, 0x9c,
0x31, 0x3a, 0x10, 0x90, 0xa8, 0x19,
0x51, 0xc3, 0x7e, 0xe3, 0x31, 0xd,
0x0, 0x9, 0x64, 0x51, 0xa8, 0xa9,
0x81, 0x22, 0x17, 0x51, 0x28, 0x68,
0x72, 0x54, 0x89, 0xce, 0x1a, 0xb6,
0x5f, 0xbb, 0xdd, 0x96, 0x7f, 0x12,
0xbc, 0x10, 0x11, 0x95, 0x95, 0x6f,
0xab, 0x6c, 0x44, 0x9, 0x6, 0x2,
0x14, 0x54, 0x2e, 0xd3, 0x48, 0xed,
0x44, 0x1e, 0x35, 0xf0, 0x32, 0xb4,
0x42, 0xa1, 0xe0, 0x76, 0x9b, 0x42,
0xa6, 0x89, 0x14, 0x0, 0x40, 0x5a,
0xff, 0x1a, 0x74, 0x83, 0x62, 0x69,
0x18, 0x30, 0x6b, 0x35, 0xee, 0x8,
0x99, 0xc7, 0xb8, 0x96, 0x24, 0xe2,
0x1b, 0xd6, 0x6a, 0x61, 0x93, 0xbd,
0xef, 0x7d, 0xef, 0x4b, 0xd3, 0xfc,
0x4b, 0x5f, 0xfc, 0xf2, 0x2f, 0x7f,
0xf9, 0xcb, 0x2b, 0x5f, 0xf5, 0x2a,
0x0, 0xf8, 0xc8, 0x47, 0x3e, 0x72,
0xc2, 0x9, 0x27, 0x6c, 0xd8, 0xb4,
0xc5, 0x39, 0x37, 0x31, 0x31, 0x25,
0xba, 0x19, 0x22, 0x1d, 0xdc, 0xbc,
0x10, 0x4, 0x88, 0x1e, 0x29, 0x4a,
0x2d, 0x79, 0xa4, 0x87, 0x4a, 0x1c,
0x42, 0xf4, 0xce, 0xc7, 0x18, 0xaf,
0xbc, 0xf2, 0x4a, 0x22, 0xba, 0xe1,
0x86, 0x1b, 0x9e, 0xfb, 0xdc, 0xe7,
0x81, 0xc2, 0x6e, 0xb7, 0x7b, 0xfe,
0xf9, 0xe7, 0x3, 0xc0, 0x8b, 0x5e,
0xf4, 0xa2, 0x7f, 0xf7, 0xef, 0xde,
0x34, 0x3d, 0x3d, 0x2d, 0x14, 0x6d,
0xe9, 0xb2, 0xc, 0x87, 0xc3, 0x46,
0xe3, 0xa2, 0x16, 0xee, 0x0, 0x14,
0xd8, 0x33, 0xc5, 0xb0, 0x8c, 0x57,
0xa9, 0x19, 0xdb, 0xd4, 0xb4, 0xd,
0x85, 0xd2, 0xbc, 0x7f, 0xff, 0xfe,
0x40, 0x3c, 0x39, 0x39, 0x29, 0xaa,
0x48, 0x4f, 0x3f, 0xfd, 0xf4, 0x37,
0xbf, 0xf9, 0xf5, 0xef, 0x7e, 0xf7,
0xbb, 0xa7, 0x9f, 0xb9, 0x3b, 0x4d,
0xd3, 0xc1, 0xb0, 0x2, 0xad, 0xf2,
0x3c, 0x1f, 0xe, 0x87, 0xa3, 0x61,
0xc1, 0xcb, 0x44, 0xb, 0x8a, 0x71,
0x4, 0x84, 0x6c, 0x60, 0x1c, 0x4c,
0xd1, 0xa0, 0x8a, 0x31, 0xce, 0xce,
0xce, 0x3e, 0xf2, 0xf0, 0xc3, 0x2f,
0x7c, 0xe1, 0xb, 0x93, 0x24, 0x99,
0x3b, 0x72, 0x14, 0x0, 0xda, 0xed,
0xf6, 0xd5, 0x57, 0x5f, 0xfd, 0x8e,
0x77, 0xbc, 0xc3, 0xa6, 0x46, 0x2,
0xfe, 0x91, 0x3e, 0xd9, 0xb2, 0x4a,
0xd3, 0x78, 0x61, 0x2, 0x11, 0x81,
0x18, 0xb9, 0x9e, 0x72, 0xc6, 0x98,
0xb2, 0x2c, 0xbb, 0x13, 0xed, 0xaf,
0x7c, 0xe5, 0x2b, 0xf3, 0xf3, 0xf3,
0x6f, 0x7e, 0xf3, 0x9b, 0xdf, 0xf0,
0x86, 0x37, 0xf4, 0x7a, 0xbd, 0xbd,
0x7b, 0xf7, 0x7e, 0xed, 0x6b, 0x5f,
0x13, 0x9b, 0xa8, 0x3f, 0xf9, 0x93,
0x3f, 0xc9, 0xb2, 0xec, 0x91, 0x47,
0x1e, 0x39, 0xef, 0xbc, 0x67, 0x79,
0xef, 0x5d, 0x88, 0x63, 0x5, 0xf3,
0xfa, 0xcd, 0xe8, 0xd1, 0xb, 0x98,
0x89, 0x9a, 0xa3, 0xe7, 0x79, 0x2e,
0x85, 0x2e, 0xa9, 0xf4, 0x96, 0x65,
0xf9, 0xb5, 0xaf, 0x7d, 0x4d, 0xa8,
0xbf, 0x2, 0x90, 0x10, 0xcf, 0xd,
0x11, 0xac, 0x33, 0xc6, 0xb8, 0x10,
0x24, 0x65, 0x11, 0x6a, 0x7e, 0xa3,
0x5f, 0x37, 0x1a, 0x50, 0x34, 0x12,
0x6a, 0xac, 0x8f, 0x9e, 0x6a, 0x23,
0xa, 0x1e, 0xa2, 0x28, 0xa0, 0x94,
0x9a, 0x99, 0x99, 0xe9, 0xf7, 0xfb,
0x8d, 0x5, 0x7c, 0xc3, 0x5a, 0x9f,
0x98, 0x98, 0x90, 0xcd, 0x99, 0xc0,
0xac, 0x90, 0x1f, 0x22, 0x82, 0xd1,
0x27, 0x5, 0x5, 0x20, 0xd8, 0xe6,
0xe6, 0xe5, 0x23, 0xc5, 0x10, 0x64,
0x27, 0xd4, 0x5a, 0x7f, 0xfb, 0xdb,
0xdf, 0xbe, 0xe4, 0x92, 0x4b, 0x16,
0x17, 0x17, 0xcf, 0x3b, 0xef, 0x3c,
0x0, 0xf8, 0xe0, 0x7, 0x3f, 0xb8,
0x7b, 0xf7, 0xee, 0xc5, 0xc5, 0xc5,
0xe9, 0xe9, 0xc9, 0xe1, 0x70, 0x98,
0xe7, 0xb9, 0xb, 0x3e, 0x12, 0x8b,
0xf1, 0xf5, 0x8a, 0x1e, 0xcc, 0xa8,
0x84, 0xae, 0x15, 0x20, 0x8e, 0x58,
0xa6, 0xa3, 0xfe, 0x97, 0xf4, 0xa5,
0xab, 0xaa, 0x9a, 0x9c, 0x9c, 0xac,
0x91, 0xe4, 0x5e, 0xec, 0x57, 0xb3,
0xb2, 0x2c, 0x85, 0xfb, 0x91, 0x24,
0x35, 0x2d, 0x47, 0x66, 0x59, 0x24,
0x1e, 0x57, 0xde, 0x10, 0xc3, 0x91,
0x15, 0x2c, 0x2b, 0x58, 0x86, 0x7c,
0x50, 0x64, 0x66, 0x56, 0x80, 0xd,
0xc8, 0xcc, 0xac, 0x67, 0xa, 0x7e,
0x7c, 0xbb, 0xe7, 0xb5, 0x89, 0xa3,
0x8b, 0x8b, 0x88, 0x78, 0xd7, 0x5d,
0x77, 0x2d, 0x2c, 0x2c, 0xbc, 0xf8,
0xa5, 0xcf, 0x99, 0x9a, 0x9a, 0xda,
0xbc, 0x79, 0xf3, 0x85, 0x7b, 0xf6,
0x0, 0xc0, 0xdd, 0x77, 0xdf, 0xfd,
0xb3, 0x9f, 0xfd, 0xec, 0x45, 0xdb,
0x4f, 0xa8, 0xaa, 0x4a, 0x44, 0x8c,
0x8c, 0xe8, 0x2a, 0xac, 0x4, 0x8d,
0x2c, 0xa3, 0x32, 0x51, 0xad, 0x2,
0x74, 0x35, 0x8c, 0xb0, 0xb7, 0xbe,
0xf5, 0xad, 0x17, 0x5e, 0x78, 0xe1,
0xf7, 0xbf, 0xff, 0xfd, 0x7b, 0xef,
0xff, 0xf1, 0x7d, 0xf7, 0xdd, 0x77,
0xef, 0xfd, 0xf7, 0x3, 0xc0, 0x77,
0xbf, 0xf3, 0x9d, 0x47, 0x1f, 0x7d,
0xe4, 0xbd, 0xef, 0x7d, 0xef, 0x59,
0x67, 0x9f, 0xdb, 0xeb, 0xf5, 0xbc,
0x8f, 0xad, 0x56, 0x8b, 0x98, 0xd6,
0x43, 0x77, 0x36, 0xc5, 0x0, 0x12,
0x2e, 0xcb, 0xd8, 0xfe, 0x2f, 0x23,
0x55, 0x8d, 0xbc, 0x3f, 0x6a, 0x8,
0x94, 0x52, 0x91, 0x79, 0x95, 0xeb,
0xfc, 0x2a, 0x65, 0xc6, 0xd5, 0xc8,
0xf8, 0xb5, 0x6e, 0x60, 0x4, 0x26,
0x84, 0x23, 0x47, 0x8e, 0xb4, 0x3b,
0x9d, 0x93, 0x4e, 0x3a, 0x29, 0xcf,
0xf3, 0x9d, 0x3b, 0x77, 0xca, 0xb2,
0x3d, 0xbb, 0x71, 0x83, 0x49, 0xac,
0x60, 0x73, 0xc7, 0xb0, 0xef, 0xb0,
0x2e, 0xd7, 0x6c, 0x4c, 0x23, 0x67,
0x9c, 0xfc, 0x2d, 0xb3, 0x51, 0x56,
0x96, 0x5f, 0xfc, 0xe2, 0x17, 0x37,
0xdf, 0x7c, 0x33, 0x0, 0x1c, 0x3c,
0xb8, 0x7f, 0x61, 0x61, 0xf1, 0x8c,
0x33, 0x4e, 0xff, 0xb3, 0x3f, 0xfb,
0xb3, 0x91, 0xf, 0x35, 0xad, 0x49,
0x6d, 0x1d, 0x3b, 0xf9, 0x7a, 0xa5,
0x28, 0x9d, 0x4b, 0xad, 0x8e, 0x4c,
0x52, 0x9c, 0x43, 0x6d, 0x92, 0x2c,
0xed, 0x4e, 0x4e, 0xbc, 0xf3, 0x5d,
0xff, 0x5e, 0xb2, 0x65, 0xd1, 0xe5,
0xbf, 0xeb, 0x47, 0xf7, 0x2c, 0x2c,
0x2c, 0xc, 0x86, 0xc3, 0xe6, 0xb1,
0xa, 0x4c, 0xea, 0xd7, 0xe, 0x1b,
0x19, 0xca, 0xd, 0xee, 0x55, 0x88,
0x3b, 0x87, 0xf, 0x1f, 0x16, 0x3c,
0x83, 0xd4, 0x8, 0xca, 0xb2, 0x54,
0x5a, 0xcb, 0x56, 0x2c, 0x5a, 0x2,
0x95, 0xe7, 0x63, 0xf5, 0x37, 0xd7,
0xaf, 0xbc, 0x2, 0x11, 0x81, 0x52,
0x22, 0xc9, 0x1d, 0x62, 0x0, 0x80,
0x1d, 0x3b, 0x4f, 0x78, 0xf6, 0xc6,
0xf3, 0x6e, 0xbf, 0xfd, 0x76, 0x0,
0xf8, 0xf0, 0x5f, 0x5e, 0xff, 0xb1,
0x8f, 0x7d, 0x6c, 0xfb, 0xf6, 0xed,
0xc3, 0xb2, 0x48, 0xd3, 0xb4, 0x37,
0xe8, 0x4f, 0x4e, 0x4e, 0xf6, 0x87,
0xee, 0x38, 0x4, 0x95, 0xda, 0xbf,
0x75, 0xa5, 0x53, 0x64, 0xdd, 0xe0,
0xad, 0xb3, 0x62, 0xd7, 0xb0, 0x9d,
0x44, 0x86, 0x55, 0xa, 0xb4, 0x32,
0x24, 0x47, 0x3a, 0x21, 0x2, 0x8c,
0xe1, 0x7a, 0x5f, 0x44, 0x86, 0x7a,
0x2, 0xaf, 0xcd, 0x6c, 0x5b, 0x3,
0x1d, 0x78, 0xac, 0xec, 0xe8, 0x2a,
0xf1, 0xcb, 0x63, 0x2f, 0x1, 0x40,
0x23, 0x30, 0x80, 0x67, 0x6, 0xf1,
0x64, 0x90, 0xb5, 0xa7, 0xdd, 0xee,
0x7e, 0xfb, 0xdb, 0xdf, 0xfe, 0x8b,
0xbf, 0xf8, 0xf0, 0xd4, 0xd4, 0xcc,
0xbe, 0x7d, 0xfb, 0x5e, 0xf9, 0xca,
0x57, 0x36, 0xdc, 0x20, 0xad, 0xf5,
0xd, 0x37, 0xdc, 0x30, 0x3d, 0xbb,
0xf1, 0xfc, 0xf3, 0xcf, 0x97, 0xeb,
0x94, 0x5a, 0xff, 0x5a, 0x1e, 0x88,
0xa8, 0x94, 0x32, 0xda, 0x54, 0x88,
0x31, 0x46, 0xe7, 0x3d, 0x2, 0x10,
0xb0, 0xb1, 0x26, 0xcd, 0xb3, 0xff,
0xf1, 0xb7, 0x7f, 0x73, 0xcd, 0x35,
0xd7, 0x5c, 0x7a, 0xd9, 0x73, 0x3f,
0xf4, 0xa1, 0xf, 0xbd, 0xeb, 0xdd,
0xef, 0x61, 0xe6, 0x6f, 0x7d, 0xfb,
0xdb, 0x0, 0xf0, 0xc7, 0x7f, 0xfc,
0xc7, 0xb7, 0xdd, 0x76, 0xdb, 0xab,
0x5e, 0xf5, 0xaa, 0xad, 0xdb, 0x4f,
0x68, 0xb5, 0x5a, 0x49, 0xa2, 0x96,
0x96, 0x96, 0x94, 0xb6, 0x22, 0x83,
0xb0, 0xc6, 0x75, 0x89, 0xd0, 0x8c,
0xac, 0x79, 0xc0, 0x12, 0x28, 0x59,
0x8a, 0x91, 0x49, 0xc6, 0x90, 0x8f,
0x81, 0x11, 0x82, 0xf, 0xfb, 0xf6,
0xed, 0x3, 0x80, 0xcf, 0x7c, 0xf6,
0xb3, 0x9f, 0xff, 0xfc, 0xe7, 0xf7,
0x5c, 0x74, 0xc1, 0xf3, 0x9f, 0xff,
0x7c, 0xa1, 0xb3, 0x6b, 0x93, 0xc9,
0x9b, 0x2c, 0xcb, 0x62, 0x2c, 0x4,
0x91, 0xd6, 0x4c, 0x69, 0xf1, 0x3d,
0x22, 0xe6, 0xc8, 0x2b, 0x1a, 0x77,
0xb2, 0xe8, 0x82, 0x52, 0x69, 0x9e,
0xff, 0xd5, 0x5f, 0xfd, 0xd5, 0xb6,
0x6d, 0xdb, 0x1a, 0x55, 0xd0, 0x10,
0x42, 0x55, 0x55, 0x42, 0xdc, 0xc1,
0x31, 0x34, 0xeb, 0x48, 0xca, 0x4f,
0x8d, 0x2f, 0x19, 0x8d, 0x7, 0x89,
0x8, 0xc, 0x85, 0xe0, 0x6d, 0x96,
0xe, 0x8a, 0xe2, 0x15, 0xaf, 0x7a,
0xd5, 0xa7, 0x3f, 0xf3, 0x99, 0x7f,
0xf8, 0xdf, 0xff, 0xfb, 0xb2, 0xcb,
0x2f, 0xbf, 0xe2, 0x8a, 0x2b, 0x5e,
0xff, 0x5b, 0x6f, 0x78, 0xe9, 0xcb,
0x5f, 0xe, 0x0, 0xff, 0xeb, 0xff,
0xb9, 0xf9, 0xba, 0xeb, 0xae, 0x4b,
0xf2, 0xcc, 0x53, 0x3d, 0xb6, 0x9c,
0xa3, 0x24, 0xc9, 0xd4, 0x8a, 0x17,
0xaf, 0x9c, 0xf, 0x4a, 0xf8, 0xfa,
0xed, 0x76, 0xb7, 0x18, 0xf4, 0xd4,
0x88, 0x56, 0x2d, 0x91, 0xe1, 0x65,
0x97, 0x5d, 0xf6, 0x81, 0xf, 0x7c,
0x40, 0xc4, 0x4c, 0x0, 0xe0, 0x89,
0x27, 0x9e, 0x78, 0xe5, 0x2b, 0x5f,
0x89, 0x8a, 0xd3, 0xcc, 0x56, 0x55,
0x15, 0x21, 0x32, 0xb3, 0x36, 0x82,
0xd4, 0xac, 0xd, 0xf4, 0xc6, 0xf8,
0x6d, 0x58, 0xbb, 0x4e, 0x8d, 0x5e,
0xa5, 0x77, 0x69, 0x2b, 0x77, 0x21,
0x78, 0x8a, 0x4, 0x70, 0xff, 0x3,
0xf, 0x5c, 0x7d, 0xf5, 0xd5, 0x45,
0x51, 0x7c, 0xe5, 0x2b, 0x5f, 0xb9,
0xe0, 0x82, 0xb, 0x0, 0x60, 0x58,
0x96, 0x14, 0xa3, 0xb2, 0x86, 0x15,
0xa2, 0xd1, 0x83, 0xc1, 0x0, 0xc1,
0x8e, 0x2f, 0x3d, 0xcd, 0x23, 0x6e,
0xca, 0x4e, 0xe3, 0xa0, 0xe0, 0x48,
0x64, 0x95, 0x92, 0xd8, 0x58, 0x3e,
0x7f, 0xfe, 0x5, 0x17, 0x7c, 0xe3,
0x1b, 0xdf, 0x88, 0x31, 0x7e, 0xe6,
0x33, 0x9f, 0x1, 0x80, 0xeb, 0xae,
0xbb, 0xee, 0xb2, 0xcb, 0x2e, 0xfb,
0xf3, 0x3f, 0xff, 0xf3, 0x37, 0xbc,
0xe1, 0xf5, 0x44, 0x34, 0x35, 0x35,
0x75, 0xe0, 0xf0, 0xa1, 0x3c, 0xeb,
0x8e, 0xbb, 0x10, 0x8d, 0x1e, 0x6b,
0xcd, 0x9d, 0x14, 0x52, 0xa, 0xd5,
0x1a, 0x5a, 0xc1, 0x7b, 0x4f, 0x14,
0xd3, 0x34, 0x2d, 0x5c, 0x85, 0x46,
0x47, 0x66, 0x93, 0x24, 0x83, 0xa2,
0xc8, 0xdb, 0xed, 0x5a, 0x79, 0xca,
0x39, 0x22, 0x6a, 0x19, 0x53, 0x9f,
0x3f, 0x22, 0xb0, 0x8a, 0xa3, 0xed,
0x7d, 0xdc, 0xe6, 0x62, 0xd5, 0x32,
0x84, 0x75, 0xba, 0x87, 0x22, 0x4d,
0x45, 0x44, 0x92, 0x3d, 0xc9, 0xa1,
0x6b, 0x2c, 0x74, 0x93, 0x2b, 0x8e,
0xe0, 0x84, 0xc7, 0xc1, 0x42, 0x93,
0x52, 0x63, 0x36, 0xd9, 0xcc, 0x4c,
0x35, 0xbe, 0xb6, 0xaa, 0xaa, 0xef,
0x7f, 0xff, 0xfb, 0xfb, 0x9e, 0x78,
0xe2, 0x8d, 0x6f, 0x7a, 0xd3, 0x1f,
0xfe, 0xa7, 0xff, 0xd4, 0xed, 0x76,
0xb3, 0x2c, 0xfb, 0xe5, 0x2f, 0x7f,
0x9, 0x0, 0x1f, 0xf8, 0xa3, 0xf7,
0xdf, 0x7b, 0xef, 0xbd, 0x77, 0xdc,
0x71, 0x87, 0x44, 0x2c, 0xd2, 0x70,
0x17, 0x21, 0xdf, 0x15, 0x39, 0xe2,
0x68, 0x57, 0x6c, 0x5c, 0xa1, 0x5,
0xe7, 0x4a, 0x44, 0x3e, 0xc6, 0xb2,
0x2c, 0x4f, 0x3c, 0xf1, 0xc4, 0x93,
0x4f, 0x3e, 0xf9, 0x7b, 0xdf, 0xfb,
0xde, 0x7b, 0xde, 0xf3, 0x9e, 0x57,
0xbc, 0xe2, 0x55, 0xc6, 0x98, 0x6f,
0x7e, 0xeb, 0x5b, 0x0, 0xf0, 0xe0,
0x83, 0xf, 0xbe, 0xfe, 0xb5, 0x57,
0x9e, 0x71, 0xc6, 0x19, 0xa2, 0x26,
0x83, 0xa8, 0x93, 0x24, 0x69, 0xb5,
0xbb, 0x12, 0x45, 0x8f, 0xa9, 0x9f,
0x12, 0x11, 0x21, 0x10, 0xad, 0x24,
0x8e, 0x49, 0xc4, 0x58, 0x27, 0x15,
0xc6, 0x38, 0x17, 0xbe, 0xf0, 0x85,
0x2f, 0xfc, 0xf4, 0xa7, 0x3f, 0x5d,
0x5c, 0xec, 0x1d, 0x39, 0x72, 0x4,
0x0, 0xee, 0xbc, 0xe3, 0xe, 0x50,
0xea, 0xed, 0x6f, 0x7f, 0xfb, 0xe9,
0xa7, 0x9f, 0x2e, 0xfc, 0xef, 0x61,
0xe1, 0xd, 0x27, 0x22, 0x19, 0x3b,
0xba, 0x69, 0xb4, 0xbc, 0x27, 0x33,
0xaf, 0x9, 0x89, 0x91, 0xbf, 0xac,
0xaa, 0x6a, 0xfb, 0xf6, 0xed, 0xb,
0xb, 0xb, 0x5b, 0xb6, 0x6c, 0x39,
0x7a, 0xf4, 0x68, 0xf3, 0xcc, 0xf2,
0x3c, 0x37, 0x46, 0xd5, 0x96, 0x6d,
0x2b, 0x1b, 0x1, 0xe3, 0x96, 0x56,
0xf5, 0x51, 0x84, 0x95, 0x8a, 0xd8,
0xa8, 0x90, 0x12, 0x85, 0x93, 0x4f,
0x3e, 0x59, 0xc, 0x4, 0xae, 0xb9,
0xe6, 0x9a, 0x1f, 0xfd, 0xe8, 0x47,
0xa7, 0x9e, 0x7a, 0xea, 0xa3, 0x8f,
0x3e, 0xa, 0x0, 0xb7, 0x7c, 0xfe,
0x73, 0xb, 0x47, 0xe7, 0x25, 0x7,
0x3b, 0x36, 0xea, 0x21, 0xa2, 0x71,
0x77, 0xa2, 0xd1, 0xbf, 0xd6, 0x47,
0x14, 0x35, 0xdf, 0x51, 0x66, 0x68,
0x64, 0x2c, 0xce, 0xcd, 0xcd, 0xc5,
0x5a, 0xf1, 0xcb, 0x0, 0xc0, 0xfc,
0xfc, 0xbc, 0x52, 0x6a, 0x38, 0x1c,
0xca, 0x27, 0x63, 0x58, 0xc1, 0x45,
0x6d, 0x36, 0x25, 0xa5, 0x70, 0xc,
0xa, 0xba, 0x1c, 0xfd, 0x22, 0x40,
0x59, 0x96, 0x12, 0x30, 0x7b, 0xef,
0x4f, 0x39, 0xe5, 0x94, 0xcd, 0x9b,
0x37, 0x3f, 0xf4, 0xd0, 0x43, 0x9f,
0xfa, 0xd4, 0xa7, 0xee, 0xb8, 0xe3,
0xe, 0x0, 0xb8, 0xe5, 0x96, 0x5b,
0x0, 0xf1, 0xac, 0xb3, 0xce, 0xb2,
0xd6, 0x2e, 0x2d, 0x2d, 0x29, 0xa5,
0x0, 0xd6, 0xa0, 0xdf, 0xac, 0x1a,
0xb1, 0xe3, 0x77, 0x3e, 0xc4, 0xd8,
0xef, 0xf7, 0x25, 0x94, 0x4d, 0xd2,
0xb4, 0x2c, 0xcb, 0x7d, 0xfb, 0xf6,
0xed, 0xda, 0xb5, 0xeb, 0x75, 0xaf,
0x7b, 0x1d, 0x0, 0xfc, 0xec, 0x67,
0x3f, 0xbb, 0xf9, 0xb3, 0x9f, 0xbd,
0xf1, 0xc6, 0x1b, 0xcf, 0x3c, 0xf3,
0xf4, 0x73, 0xcf, 0x3d, 0xf7, 0xc0,
0x81, 0x3, 0x93, 0x33, 0xd3, 0x55,
0x19, 0x8f, 0xed, 0xcb, 0x2c, 0x3f,
0x8, 0xb5, 0x5a, 0xcb, 0x5a, 0x48,
0x8b, 0x52, 0x9a, 0x5e, 0x58, 0x58,
0x38, 0x72, 0xe4, 0xc8, 0xdf, 0xfc,
0xcd, 0xdf, 0x88, 0x24, 0x9b, 0xe4,
0x38, 0x27, 0x9f, 0x7c, 0xf2, 0x6f,
0xff, 0xf6, 0x6f, 0x3f, 0xeb, 0xd9,
0xe7, 0x4a, 0xbb, 0xb4, 0x95, 0x77,
0x56, 0x9d, 0xff, 0xca, 0x1, 0x39,
0xb2, 0xd4, 0x5b, 0x81, 0xba, 0xad,
0xc9, 0xc, 0xd, 0xa7, 0xd5, 0x8c,
0x3b, 0xa9, 0x8e, 0xa8, 0x33, 0x30,
0x32, 0xbc, 0x5d, 0x3b, 0xe4, 0x9,
0xc1, 0x13, 0x91, 0xd5, 0xb6, 0x91,
0xe7, 0xf6, 0x1c, 0x5b, 0xad, 0xd6,
0x93, 0x4f, 0x3c, 0x7e, 0xf1, 0xc5,
0x17, 0xdf, 0xfa, 0x8f, 0xff, 0x78,
0xe6, 0x99, 0x67, 0x9a, 0x24, 0x29,
0xcb, 0x52, 0x6b, 0x7b, 0xc6, 0x19,
0x67, 0x0, 0xc0, 0x4d, 0x37, 0xfd,
0xdd, 0x43, 0xf, 0x3d, 0x38, 0x31,
0x35, 0x33, 0x37, 0x37, 0xd7, 0xe9,
0x4c, 0x10, 0x11, 0x8f, 0x71, 0x4d,
0x6a, 0x84, 0x70, 0x23, 0x8f, 0x1c,
0x29, 0x10, 0xc9, 0xe2, 0x2d, 0x41,
0xa1, 0xd6, 0x8, 0xc, 0x47, 0x8f,
0x1e, 0xbd, 0xf0, 0xe2, 0x8b, 0xbe,
0x73, 0xfb, 0x77, 0xf, 0x1c, 0x38,
0xf0, 0xf8, 0xe3, 0x8f, 0x2f, 0xf5,
0x87, 0x55, 0x55, 0xfd, 0xd1, 0x1f,
0xfd, 0x11, 0x0, 0x7c, 0xfa, 0xd3,
0x9f, 0x6e, 0xe7, 0xa9, 0xdc, 0xa6,
0x10, 0x2, 0x33, 0x76, 0x3a, 0x9d,
0xa2, 0x28, 0xa6, 0xa6, 0xa6, 0x24,
0x3c, 0x93, 0x0, 0x6, 0x98, 0xb5,
0xd6, 0x14, 0x9, 0x15, 0xa6, 0x69,
0x2a, 0xc1, 0x3c, 0x51, 0x94, 0xad,
0x42, 0xb6, 0xca, 0xff, 0xeb, 0xda,
0x3f, 0x7e, 0xfb, 0xef, 0xbe, 0xa3,
0xd5, 0x6a, 0x29, 0xa5, 0x2, 0x81,
0x58, 0x2b, 0x4d, 0x4f, 0x4f, 0x9f,
0x7a, 0xea, 0xa9, 0x47, 0xe, 0x1d,
0x18, 0xe, 0x87, 0x8c, 0x1a, 0x11,
0x6d, 0xd2, 0x92, 0xe1, 0x92, 0x65,
0x59, 0xbf, 0x3f, 0x5c, 0x25, 0xde,
0x2d, 0xb1, 0x4f, 0x5d, 0x4d, 0xf5,
0x4e, 0xd8, 0x8, 0x8b, 0xbd, 0xa5,
0x89, 0x4e, 0x77, 0xd7, 0xae, 0x5d,
0xb7, 0xdc, 0x72, 0x8b, 0x73, 0x6e,
0x7a, 0x76, 0x76, 0x7e, 0x71, 0x51,
0x76, 0x30, 0xd1, 0xc1, 0x9, 0x21,
0x18, 0x93, 0x38, 0xe7, 0x22, 0xfb,
0xc6, 0x88, 0x40, 0xa2, 0xfa, 0x3c,
0x6f, 0x8f, 0xab, 0x1c, 0xc6, 0x18,
0x39, 0xd6, 0x69, 0xaa, 0x94, 0xb2,
0x8c, 0x31, 0x5a, 0xe3, 0x70, 0x38,
0xbc, 0xe6, 0x9a, 0x6b, 0xae, 0xb9,
0xe6, 0x9a, 0xfb, 0xee, 0xbb, 0x6f,
0xef, 0xde, 0xbd, 0x7, 0xf, 0x1e,
0xdc, 0xbd, 0x7b, 0x37, 0x0, 0xfc,
0xfe, 0xbb, 0xbf, 0x9d, 0x24, 0xc9,
0x23, 0x8f, 0x3c, 0x72, 0xd2, 0x49,
0x27, 0x2d, 0x2e, 0x2e, 0x12, 0x91,
0x31, 0x69, 0x8c, 0x35, 0x61, 0x53,
0xa6, 0x8d, 0xf4, 0x84, 0x25, 0x11,
0x95, 0x8a, 0x86, 0xcc, 0x5e, 0x6b,
0x2d, 0x50, 0x22, 0x23, 0x6c, 0x30,
0x18, 0xbc, 0xfa, 0xd5, 0xaf, 0xbe,
0xf8, 0xe2, 0x8b, 0xdb, 0xed, 0x76,
0x2d, 0x56, 0xc, 0x0, 0x0, 0xa7,
0x9c, 0x72, 0xca, 0x8d, 0x37, 0xde,
0x58, 0x14, 0xc5, 0xf9, 0xe7, 0x9f,
0xdf, 0xeb, 0xf5, 0x5a, 0xdd, 0x56,
0xaf, 0xd7, 0x43, 0x15, 0x3b, 0x9d,
0x4e, 0x13, 0xdb, 0x6b, 0xad, 0x93,
0x24, 0x2d, 0x8a, 0x42, 0x2c, 0x6f,
0x80, 0x96, 0xb1, 0x59, 0x89, 0xb5,
0xb2, 0x45, 0xb, 0xde, 0xa6, 0xd3,
0xe9, 0x7c, 0xfe, 0xf3, 0x9f, 0xdf,
0xbf, 0x7f, 0xff, 0xf, 0x7f, 0xf8,
0xc3, 0xf9, 0xf9, 0x79, 0x0, 0x78,
0xef, 0x7b, 0xdf, 0x7b, 0xd1, 0x45,
0x17, 0x6d, 0xda, 0xbc, 0x41, 0xa4,
0xea, 0xbc, 0xf7, 0x89, 0xd5, 0x31,
0x46, 0x86, 0xb2, 0xa1, 0xd3, 0xc8,
0x1a, 0x34, 0x5a, 0x85, 0x55, 0x92,
0x24, 0x31, 0x86, 0x56, 0xab, 0x25,
0xd8, 0x32, 0x84, 0xba, 0xa6, 0x70,
0xc5, 0x15, 0x57, 0x6c, 0xd9, 0xba,
0x69, 0x66, 0x66, 0x66, 0x66, 0x66,
0xe6, 0xe8, 0xd1, 0xa3, 0xad, 0x56,
0xb, 0x0, 0xae, 0xbf, 0xfe, 0xfa,
0xab, 0xae, 0xba, 0x6a, 0x71, 0x71,
0xf1, 0xf0, 0xe1, 0xc3, 0x8f, 0x3e,
0xfa, 0xe8, 0xce, 0x9d, 0x3b, 0x7b,
0xbd, 0x1e, 0xb1, 0x36, 0x89, 0x95,
0xd8, 0x47, 0xe4, 0x75, 0x45, 0x2e,
0x4b, 0x16, 0x29, 0x26, 0x6, 0x20,
0x8a, 0xb1, 0xd1, 0xc1, 0x92, 0xcd,
0xc3, 0x5a, 0xbb, 0x67, 0xcf, 0x9e,
0x9b, 0x6e, 0xba, 0x49, 0xfc, 0x22,
0xe4, 0xa9, 0x59, 0x6b, 0xa5, 0x4c,
0x20, 0xb, 0x77, 0x23, 0x2c, 0xd7,
0x6a, 0x4f, 0x36, 0xfa, 0xd, 0x22,
0x75, 0x48, 0x8c, 0x4d, 0xdc, 0x3a,
0xa, 0x55, 0xf0, 0x58, 0x62, 0xe1,
0x32, 0x45, 0x59, 0x8e, 0xdd, 0x70,
0x68, 0x1b, 0x54, 0xe3, 0xfa, 0x45,
0x2c, 0xf0, 0x3e, 0x26, 0x49, 0xa2,
0x14, 0x6, 0x5f, 0xb, 0x70, 0xb6,
0xf2, 0xf4, 0xe8, 0xd1, 0xa3, 0x93,
0x93, 0x93, 0x97, 0x5f, 0x7e, 0xb9,
0x44, 0x14, 0xa8, 0xad, 0x48, 0x46,
0xb, 0x56, 0x76, 0x6a, 0x6a, 0xea,
0xd2, 0x4b, 0x2f, 0x45, 0x6d, 0x43,
0x8, 0xb2, 0x10, 0x6a, 0x63, 0x96,
0x96, 0x96, 0x64, 0x5d, 0x97, 0xb3,
0x29, 0xcb, 0x32, 0xcf, 0x73, 0xef,
0x7d, 0xa4, 0x88, 0x4a, 0x23, 0xe2,
0xa0, 0x2c, 0xaa, 0xe0, 0x15, 0x83,
0x2b, 0x4a, 0xab, 0x6b, 0xbe, 0x95,
0xd8, 0x64, 0xcd, 0xce, 0xce, 0x6,
0x71, 0xa0, 0x52, 0xd8, 0xf4, 0xa2,
0xca, 0xb2, 0xc, 0x4, 0xc2, 0x1d,
0xa9, 0xaa, 0x8a, 0x58, 0x8c, 0x58,
0x63, 0x8, 0x41, 0xda, 0xce, 0x58,
0xef, 0x6, 0xac, 0x0, 0x96, 0x96,
0x7a, 0x5b, 0xb6, 0x6c, 0x22, 0x4,
0x4f, 0x51, 0x29, 0x95, 0xd9, 0x64,
0xd0, 0x5f, 0xca, 0xb2, 0xec, 0xb4,
0xd3, 0x4e, 0x3b, 0xed, 0xb4, 0xd3,
0xbc, 0xf7, 0xad, 0x56, 0x2b, 0x10,
0x8, 0x16, 0xd7, 0xa6, 0xc9, 0x53,
0xfb, 0x9f, 0x4e, 0xb5, 0x52, 0x4a,
0xd9, 0x34, 0x2b, 0x8a, 0xc2, 0x7b,
0xbf, 0x74, 0xb8, 0x2f, 0x2e, 0x21,
0x52, 0x61, 0x52, 0x6a, 0x79, 0x1f,
0xe0, 0x18, 0x62, 0xc, 0x8b, 0x8b,
0x8b, 0x12, 0xaf, 0xca, 0xbd, 0x96,
0xe4, 0x6a, 0xcb, 0xb6, 0xad, 0x53,
0x53, 0x13, 0x13, 0x13, 0x13, 0x52,
0x74, 0xb5, 0x69, 0x2a, 0x6d, 0x24,
0x6b, 0xad, 0x1d, 0x69, 0xb8, 0x82,
0x32, 0xde, 0xfb, 0xfe, 0xa0, 0xb2,
0x59, 0x2a, 0x93, 0x73, 0x5c, 0xf4,
0xac, 0xb6, 0x3e, 0x50, 0xa, 0x11,
0x7, 0xc3, 0xa1, 0x68, 0x38, 0x33,
0x33, 0xa2, 0x9a, 0x98, 0x98, 0x50,
0x4a, 0x1d, 0x39, 0x72, 0xe4, 0xd4,
0x53, 0x4f, 0x3d, 0xe3, 0x8c, 0x33,
0xa4, 0xdc, 0xa, 0x0, 0x8b, 0x4b,
0xf3, 0x21, 0x84, 0x3d, 0x7b, 0xf6,
0xc, 0x87, 0x43, 0xd1, 0x73, 0x30,
0x2a, 0xe9, 0xf5, 0x7a, 0x36, 0xc9,
0xb2, 0x2c, 0x6b, 0x24, 0xef, 0xe4,
0x4, 0x88, 0x82, 0x5c, 0x17, 0x11,
0x99, 0x34, 0x19, 0xe, 0x4b, 0x69,
0x9c, 0x68, 0x6d, 0xb4, 0xa5, 0xd9,
0x8d, 0x1b, 0x67, 0x36, 0x6c, 0x48,
0xd3, 0xb4, 0x3f, 0x1c, 0x4e, 0x4c,
0x4c, 0xc8, 0xf3, 0x55, 0x88, 0xcf,
0xbe, 0xe0, 0xd9, 0x42, 0x6, 0xf2,
0xde, 0x8b, 0xfc, 0xa8, 0xf, 0xd0,
0x68, 0x68, 0xc9, 0x2f, 0x94, 0x6,
0x44, 0xbd, 0x98, 0x52, 0x14, 0xf8,
0x7e, 0x59, 0x96, 0xde, 0xb9, 0x66,
0xac, 0x89, 0x56, 0x66, 0x92, 0x24,
0x3b, 0x77, 0xee, 0xdc, 0xb9, 0x73,
0xa7, 0xac, 0xf2, 0x12, 0xb2, 0x49,
0xe1, 0x53, 0x14, 0xa0, 0x54, 0x3b,
0x21, 0x22, 0x54, 0xb5, 0xe8, 0x64,
0x51, 0x14, 0x4, 0x7a, 0x72, 0x72,
0x52, 0x94, 0x9, 0xbd, 0xaf, 0x42,
0x8, 0x55, 0x59, 0x36, 0x77, 0xcf,
0x55, 0x45, 0xbb, 0xdd, 0x2e, 0x9d,
0xcb, 0xda, 0xad, 0xe7, 0x3e, 0xef,
0x79, 0x31, 0x46, 0x17, 0x42, 0xbb,
0xdd, 0x96, 0xe7, 0xab, 0x89, 0x4e,
0xdc, 0xb5, 0xab, 0xdd, 0x6e, 0x33,
0xc4, 0xb2, 0x2c, 0x4b, 0xef, 0xe4,
0x4c, 0x8e, 0x1e, 0x3d, 0xaa, 0x4c,
0x2a, 0x92, 0x43, 0x5a, 0x6b, 0xc1,
0xf0, 0x8c, 0x54, 0x2f, 0x87, 0x13,
0x13, 0x9d, 0x2a, 0xc4, 0xaa, 0xaa,
0xfa, 0xfd, 0x7e, 0xe5, 0x8a, 0xd4,
0x26, 0x32, 0x9e, 0x4f, 0x3a, 0xe9,
0xa4, 0xed, 0xdb, 0xb7, 0xe, 0x87,
0xc3, 0x46, 0x92, 0x4d, 0x1c, 0x4f,
0x9b, 0x2c, 0x5d, 0xd4, 0x23, 0xcb,
0xc2, 0x31, 0xf6, 0xac, 0x49, 0xd3,
0xcc, 0x32, 0x44, 0xf1, 0x82, 0xb1,
0x49, 0x5a, 0x14, 0x85, 0x20, 0xfc,
0xa5, 0xb, 0x30, 0xe2, 0xad, 0x11,
0x0, 0xb0, 0xd4, 0x86, 0x88, 0x9b,
0x2a, 0xc9, 0xba, 0x7c, 0xe0, 0xe3,
0xf0, 0x19, 0xea, 0x6a, 0xad, 0x32,
0xc3, 0xe1, 0x50, 0x4c, 0xd9, 0xb1,
0x95, 0x75, 0xbb, 0x5d, 0x24, 0xe,
0x21, 0x78, 0x17, 0x95, 0xd2, 0xa3,
0xa1, 0x40, 0xa2, 0xf3, 0x68, 0xb5,
0x5e, 0x5c, 0x9c, 0x37, 0xca, 0x74,
0xbb, 0xdd, 0x7e, 0x5f, 0x6c, 0x9a,
0x5, 0x31, 0x83, 0xa2, 0x1a, 0x63,
0x8c, 0x89, 0x2c, 0xa9, 0x60, 0x54,
0x5a, 0xf0, 0x58, 0x58, 0x3, 0x74,
0x7d, 0x48, 0x33, 0x3b, 0x31, 0x39,
0x51, 0x1d, 0x3e, 0x6c, 0xad, 0xad,
0xaa, 0x8a, 0x10, 0x94, 0x52, 0xae,
0xac, 0x88, 0x28, 0xcd, 0xb3, 0x5a,
0x96, 0x35, 0xf8, 0x34, 0x4d, 0x3,
0x9, 0xe3, 0x2f, 0x1a, 0x63, 0xf4,
0x32, 0xbd, 0x86, 0xc7, 0x23, 0x2e,
0x99, 0x65, 0x93, 0x93, 0x93, 0xad,
0x4e, 0x5b, 0xf0, 0x95, 0x31, 0xc6,
0xc8, 0x54, 0x79, 0x1f, 0x88, 0xac,
0x46, 0x66, 0x1e, 0x56, 0xa5, 0xb2,
0x46, 0x28, 0x3b, 0x0, 0xd0, 0x49,
0x53, 0x0, 0xb0, 0xd8, 0xb0, 0x88,
0x6b, 0xcb, 0xe6, 0x18, 0xa0, 0x29,
0x21, 0x1e, 0x1b, 0xf1, 0x8a, 0xbe,
0x8f, 0xf8, 0xc, 0x4a, 0x31, 0x4c,
0x50, 0x78, 0xc8, 0x35, 0xe0, 0x46,
0x64, 0x31, 0x1, 0xa0, 0xd3, 0xe9,
0xd4, 0x45, 0x45, 0x6d, 0x44, 0xe7,
0x59, 0x36, 0x6d, 0x42, 0x92, 0x60,
0xae, 0x0, 0x0, 0x20, 0x0, 0x49,
0x44, 0x41, 0x54, 0xb9, 0x3f, 0x55,
0x55, 0x9, 0x9e, 0x61, 0x3c, 0x4d,
0xa, 0x31, 0x30, 0xc7, 0x56, 0xab,
0x65, 0xd3, 0x64, 0x74, 0x4a, 0x7e,
0x30, 0xe8, 0xbb, 0xe0, 0xb3, 0x56,
0x2e, 0xfa, 0xe9, 0xc1, 0x7b, 0x1f,
0x83, 0xf8, 0x33, 0x8b, 0x3e, 0xbb,
0x2c, 0x55, 0x88, 0x58, 0x54, 0x3e,
0x84, 0x98, 0xe5, 0x5a, 0xf2, 0x37,
0xa5, 0x54, 0x55, 0xd5, 0xb0, 0x4,
0x51, 0x90, 0x8b, 0x31, 0xea, 0x11,
0x2e, 0x7d, 0x72, 0xb2, 0x2b, 0xf,
0x3a, 0xcb, 0xf2, 0x24, 0xc9, 0xbc,
0xaf, 0xc4, 0x13, 0x84, 0x88, 0x44,
0xd5, 0x4c, 0x90, 0xb0, 0x12, 0x49,
0xca, 0xc5, 0x1a, 0x53, 0xf3, 0x5b,
0x24, 0x67, 0x16, 0x26, 0x89, 0x68,
0x47, 0x8e, 0x62, 0xab, 0x50, 0x47,
0x6f, 0xcc, 0xc4, 0x2c, 0xa6, 0x61,
0x44, 0x54, 0x55, 0x45, 0x9e, 0xe7,
0x69, 0x96, 0xe, 0x87, 0xc3, 0x10,
0x82, 0xb6, 0x46, 0x76, 0x9e, 0xbc,
0xdd, 0x4a, 0x53, 0x3b, 0x1c, 0xe,
0xcb, 0xb2, 0x9c, 0x9c, 0x9a, 0x2,
0xd2, 0xce, 0x39, 0x1f, 0xea, 0xd8,
0x2a, 0xcf, 0xf3, 0xa2, 0xa, 0x83,
0xc1, 0xa0, 0x9, 0x28, 0x64, 0xd6,
0x29, 0xa5, 0x7a, 0xbd, 0x5e, 0xab,
0x95, 0xa7, 0x49, 0x2d, 0xa, 0x29,
0x65, 0xa4, 0x26, 0x5c, 0x97, 0xf1,
0x29, 0xfb, 0x27, 0x11, 0xf1, 0xa,
0x49, 0x33, 0x67, 0xad, 0x65, 0x54,
0x32, 0x42, 0xbc, 0xf7, 0x42, 0xce,
0x91, 0xda, 0xb2, 0x5c, 0xac, 0x18,
0xc7, 0xb4, 0x5a, 0x2d, 0xe7, 0x4b,
0xd4, 0xca, 0xa6, 0x49, 0xe9, 0xaa,
0x40, 0x51, 0x5b, 0x93, 0xe6, 0x59,
0x96, 0xe7, 0x12, 0xa4, 0x74, 0x27,
0x27, 0x86, 0xc3, 0xa1, 0x10, 0x48,
0xf2, 0x56, 0x5e, 0x39, 0x7, 0x88,
0x49, 0x96, 0x3a, 0xe7, 0xb3, 0xb4,
0x25, 0xf7, 0x41, 0x12, 0xb1, 0x7a,
0x7b, 0x6f, 0x3c, 0xd, 0x97, 0xb7,
0xdd, 0x65, 0xc1, 0xb, 0x18, 0x9b,
0xb3, 0xfa, 0x39, 0xcf, 0x7b, 0x61,
0x43, 0xc8, 0x1c, 0xe7, 0x4c, 0x8c,
0xf3, 0x84, 0x57, 0xbd, 0x44, 0x8c,
0x7b, 0xd0, 0xef, 0x95, 0x65, 0xb9,
0x63, 0xfb, 0xb6, 0xd, 0x1b, 0x36,
0xf4, 0x96, 0x7a, 0x65, 0x59, 0xc,
0xfb, 0x3, 0x59, 0xf2, 0x99, 0xb9,
0x3f, 0x1c, 0x38, 0xe7, 0x44, 0x7d,
0x2e, 0x46, 0xea, 0xf7, 0x96, 0xf2,
0x3c, 0x2b, 0x2b, 0x37, 0x1c, 0xe,
0x1, 0x30, 0x4d, 0x53, 0x40, 0x75,
0xf8, 0xf0, 0xe1, 0xef, 0xde, 0x7e,
0xbb, 0x94, 0x78, 0xac, 0xb5, 0x91,
0xc8, 0x7b, 0xaf, 0xb5, 0x41, 0x5,
0xa, 0xd5, 0xfc, 0xfc, 0xdc, 0xc2,
0xfc, 0xdc, 0xb6, 0x6d, 0x5b, 0x4f,
0xd8, 0xbe, 0xa3, 0xdf, 0xef, 0x2d,
0xcc, 0xcf, 0x31, 0xf3, 0x70, 0xd0,
0x97, 0x6e, 0x98, 0xfc, 0x54, 0x8c,
0xd1, 0xd7, 0xc3, 0xc0, 0x2b, 0x90,
0xde, 0x9a, 0x93, 0xf6, 0xb2, 0x52,
0xea, 0xe8, 0xdc, 0xfc, 0x83, 0xf,
0x3e, 0x78, 0xe8, 0xc8, 0x11, 0xad,
0xb5, 0xa8, 0x8d, 0x4b, 0x12, 0xcc,
0x4, 0xc6, 0xe8, 0x7e, 0xaf, 0x5f,
0x14, 0x43, 0x85, 0xb0, 0x6d, 0xdb,
0x56, 0x85, 0xd8, 0xeb, 0x2f, 0x89,
0x9b, 0x81, 0x93, 0xdd, 0xc6, 0x1a,
0x51, 0x33, 0x96, 0xd1, 0x46, 0xcc,
0xfd, 0x7e, 0x5f, 0x54, 0x2, 0x7c,
0x88, 0xce, 0xb9, 0x76, 0xbb, 0xdb,
0x1b, 0xf4, 0xef, 0xbc, 0xf3, 0x47,
0x73, 0xf3, 0x73, 0xd2, 0x1e, 0x6c,
0x4, 0x46, 0x10, 0x51, 0x21, 0x20,
0xc2, 0x23, 0x8f, 0x3e, 0x6c, 0x53,
0x7b, 0xfa, 0xa9, 0xa7, 0x29, 0xa5,
0x6, 0x83, 0x81, 0x4, 0x4e, 0xfd,
0x7e, 0x3f, 0xc4, 0x10, 0x29, 0x2a,
0xac, 0xf5, 0x5f, 0xa5, 0xb2, 0x22,
0x1d, 0x48, 0x60, 0xa, 0x21, 0x84,
0x48, 0x88, 0xe8, 0x3, 0xdd, 0x75,
0xf7, 0xdd, 0x4f, 0xee, 0x7b, 0xca,
0x87, 0x0, 0x80, 0xe3, 0xae, 0xe,
0xcc, 0x1c, 0xbc, 0xaf, 0xaa, 0xb2,
0xdf, 0x5b, 0x3c, 0xe1, 0x84, 0x1d,
0x69, 0x9a, 0x2e, 0x2c, 0x2c, 0x58,
0x6b, 0x92, 0x24, 0x91, 0x44, 0x54,
0xd0, 0x8, 0x32, 0x69, 0x45, 0x7b,
0x4c, 0x5a, 0x77, 0xc6, 0x98, 0x61,
0xbf, 0xcf, 0xcc, 0x36, 0xc9, 0x5a,
0xad, 0xf6, 0xde, 0xbd, 0xf, 0xdf,
0x77, 0xff, 0xfd, 0xc1, 0xd3, 0xb0,
0x18, 0x36, 0xbe, 0x13, 0x5a, 0x2b,
0x69, 0x84, 0x16, 0xc3, 0xc1, 0xaf,
0x7e, 0xf5, 0xab, 0xb3, 0xcf, 0xda,
0x6d, 0xad, 0x91, 0xf1, 0x2a, 0x6a,
0xdb, 0x49, 0x62, 0x25, 0xe8, 0x28,
0xcb, 0xd2, 0x7b, 0xd7, 0xcc, 0xc3,
0x86, 0x51, 0x20, 0x31, 0x67, 0x8,
0xb4, 0xb4, 0xb4, 0x74, 0xdf, 0xfd,
0x3f, 0xee, 0xf5, 0x7a, 0x8d, 0xc7,
0x6a, 0x8, 0x21, 0x4, 0x8f, 0x88,
0x46, 0xeb, 0xa2, 0x28, 0xfa, 0xbd,
0xa5, 0x18, 0xc3, 0xce, 0x9d, 0x3b,
0xa5, 0x13, 0xd9, 0x14, 0x44, 0x9b,
0xb0, 0x45, 0xe0, 0x1c, 0xb2, 0x4,
0x94, 0x65, 0x61, 0x8c, 0x91, 0x34,
0x18, 0x41, 0xb7, 0x5a, 0xad, 0xa2,
0xac, 0xee, 0xb9, 0xe7, 0x9e, 0x7d,
0x4f, 0x3e, 0x15, 0x42, 0x40, 0x65,
0xb2, 0x2c, 0x93, 0xaa, 0x47, 0x96,
0xa5, 0x21, 0x4, 0x8a, 0x61, 0x6e,
0xee, 0x28, 0x32, 0x9c, 0x71, 0xc6,
0xe9, 0x4c, 0xb1, 0xaa, 0x2a, 0x89,
0xa2, 0x87, 0xc3, 0x41, 0xbd, 0xf1,
0x6a, 0x2d, 0x9b, 0x90, 0xc4, 0xe,
0x22, 0x87, 0x28, 0xcb, 0x19, 0x0,
0x88, 0x2c, 0xf9, 0x83, 0x3f, 0x7d,
0xe8, 0x27, 0x3f, 0xf9, 0x89, 0xc8,
0xca, 0x1b, 0x9b, 0xc8, 0x6e, 0x9f,
0x24, 0x9, 0x2, 0x57, 0x55, 0xe9,
0xaa, 0x6a, 0x30, 0xec, 0x4f, 0x4f,
0x4d, 0x6d, 0xdc, 0xb4, 0x41, 0x22,
0xca, 0x91, 0x51, 0x83, 0x2b, 0xcb,
0xb2, 0xaa, 0x2a, 0x9, 0x10, 0x44,
0x5f, 0xd5, 0x18, 0x53, 0x14, 0x45,
0x59, 0x16, 0x72, 0x39, 0x55, 0xe5,
0x66, 0x67, 0x37, 0xec, 0xfd, 0xc5,
0xc3, 0x77, 0xdf, 0x7b, 0xaf, 0x4c,
0x13, 0x22, 0x72, 0x22, 0x67, 0x29,
0xa2, 0x23, 0x75, 0x6d, 0x28, 0x2e,
0xeb, 0x6f, 0xd6, 0x55, 0xa7, 0x7a,
0x1a, 0x2f, 0x2c, 0x2c, 0x98, 0x31,
0xb2, 0x92, 0x5a, 0x49, 0x1c, 0x8d,
0x12, 0x72, 0xae, 0xa4, 0x92, 0x2a,
0x0, 0x2a, 0x8a, 0xa2, 0xdd, 0xce,
0x7b, 0xc1, 0xff, 0xf8, 0x81, 0xfb,
0xa6, 0x27, 0xbb, 0xcf, 0x7f, 0xfe,
0xe5, 0x33, 0x33, 0x33, 0xd3, 0x93,
0x1d, 0x0, 0x8, 0x91, 0x1a, 0xa2,
0x93, 0xa8, 0x90, 0x94, 0xa5, 0x7,
0x80, 0x24, 0xd9, 0x42, 0x14, 0x36,
0x1b, 0xb, 0x0, 0x83, 0x41, 0x59,
0x56, 0xd5, 0xe1, 0xc3, 0x47, 0xbe,
0xfd, 0xed, 0xef, 0x3c, 0xfd, 0xf4,
0xd3, 0xdd, 0xce, 0xa4, 0x88, 0xa7,
0x44, 0x1f, 0x2, 0xc5, 0xc4, 0xa4,
0x22, 0x7, 0x33, 0x3b, 0x3d, 0xb3,
0xff, 0xe9, 0x83, 0xdf, 0xfa, 0xd6,
0xff, 0xdb, 0x4a, 0xb3, 0x53, 0x4e,
0x39, 0xa5, 0x95, 0xa7, 0x88, 0x1c,
0xbd, 0x4f, 0x93, 0x34, 0x30, 0x49,
0xbf, 0xd7, 0x1a, 0xcb, 0xa3, 0x5c,
0x21, 0xd4, 0xe0, 0x64, 0xb0, 0xd6,
0x56, 0x95, 0x3f, 0x70, 0xf0, 0xe0,
0x83, 0xf, 0xfe, 0xf4, 0x9b, 0xdf,
0xfc, 0x3f, 0x9b, 0xb6, 0x6e, 0xc1,
0x1a, 0xb9, 0xa1, 0x80, 0x58, 0x5a,
0xff, 0xc0, 0xaa, 0xd3, 0xe9, 0xfc,
0xea, 0x57, 0xbf, 0x1a, 0xf6, 0x7,
0xb3, 0xb3, 0xb3, 0x67, 0x9e, 0x76,
0xda, 0xcc, 0xec, 0x54, 0x2b, 0xcb,
0x62, 0x24, 0xf1, 0xfb, 0x12, 0x5c,
0xf7, 0x98, 0xa9, 0x35, 0x6c, 0xd8,
0x40, 0xbe, 0x2a, 0xdb, 0xad, 0x76,
0x24, 0x96, 0xca, 0xd3, 0xbe, 0xc7,
0x9f, 0xb8, 0xe3, 0x8e, 0x3b, 0x94,
0xd1, 0x69, 0x9a, 0x37, 0x6d, 0xbc,
0x86, 0xf5, 0x5, 0xa0, 0x66, 0x66,
0x66, 0xef, 0xbc, 0xe3, 0x47, 0xb9,
0xcd, 0x9f, 0xf3, 0x9c, 0xe7, 0x9c,
0x74, 0xe2, 0x89, 0x65, 0xe9, 0x11,
0x31, 0x49, 0x4c, 0xa4, 0x68, 0xb5,
0xee, 0xf7, 0x7, 0xad, 0x56, 0x6b,
0x76, 0x76, 0x63, 0xb3, 0x83, 0x25,
0x49, 0x22, 0x5d, 0xfe, 0x18, 0xb9,
0x28, 0x8a, 0x83, 0x87, 0x9e, 0xfa,
0xf1, 0xbd, 0xf7, 0xcf, 0x2d, 0x2c,
0xb5, 0x3a, 0xdd, 0x46, 0xee, 0x38,
0x46, 0x2f, 0x43, 0xc1, 0x5a, 0xab,
0x14, 0x3c, 0xf0, 0xc0, 0x4f, 0xba,
0xdd, 0xee, 0xb, 0x5e, 0xf0, 0x82,
0x53, 0x4e, 0x16, 0x4e, 0xf, 0x6f,
0xd9, 0xb4, 0x45, 0xc0, 0xb7, 0x8d,
0xe4, 0x98, 0x40, 0x26, 0x95, 0x52,
0x56, 0xdb, 0xca, 0x57, 0x99, 0x4d,
0xfb, 0x83, 0x7e, 0x51, 0x54, 0x87,
0xf, 0x1f, 0xfd, 0xc1, 0xf, 0xee,
0xf8, 0xc5, 0xcf, 0x7e, 0xb1, 0x6d,
0xc7, 0x4e, 0x55, 0x39, 0x41, 0x14,
0x37, 0xdd, 0xa8, 0x89, 0x89, 0x29,
0x8e, 0x34, 0x37, 0x7f, 0xe4, 0x8b,
0x5f, 0xfa, 0xd2, 0x95, 0xaf, 0x7e,
0xf5, 0xae, 0x5d, 0xbb, 0x92, 0x24,
0x49, 0xac, 0x72, 0x5e, 0xda, 0x1e,
0x10, 0x42, 0xc8, 0xb3, 0x54, 0xf6,
0x4, 0xe7, 0x5c, 0x9a, 0xa4, 0xe2,
0x28, 0x9f, 0x65, 0x99, 0xd8, 0x61,
0x1e, 0x38, 0x78, 0xf8, 0xe7, 0xff,
0xb2, 0xf7, 0xae, 0xbb, 0xee, 0x6a,
0xe5, 0x9d, 0x4e, 0x67, 0x22, 0x50,
0xad, 0xbc, 0x8d, 0x88, 0x65, 0x39,
0x54, 0x69, 0x96, 0xe7, 0xed, 0x5e,
0x7f, 0xe9, 0x81, 0x7, 0x7e, 0xba,
0x75, 0xeb, 0xd6, 0xb3, 0xce, 0x3a,
0x6b, 0x7a, 0x7a, 0x9a, 0x88, 0x12,
0xab, 0x84, 0x91, 0x9a, 0x67, 0x59,
0x88, 0x51, 0xf8, 0xba, 0x4, 0x22,
0xc2, 0x5e, 0x97, 0xe2, 0xb7, 0x6e,
0xde, 0x3e, 0xbf, 0xd0, 0xab, 0xaa,
0xea, 0xd1, 0x47, 0x1f, 0xbb, 0xf3,
0xce, 0x1f, 0x8a, 0xbd, 0x86, 0x8f,
0xa1, 0xdf, 0xef, 0x77, 0xbb, 0xdd,
0x5e, 0xaf, 0x27, 0x3b, 0x64, 0xa7,
0x3b, 0xd9, 0xeb, 0xf5, 0xee, 0xbd,
0xf7, 0xfe, 0x24, 0x49, 0x5e, 0x7c,
0xc5, 0x6f, 0x4c, 0x4c, 0x4c, 0x58,
0x6b, 0x62, 0x24, 0xa5, 0x40, 0x6b,
0x25, 0x1b, 0x80, 0x1e, 0x75, 0xa7,
0xb2, 0x2c, 0x6d, 0xb7, 0xbb, 0xad,
0x3c, 0x93, 0x26, 0x53, 0x20, 0x5e,
0x5a, 0xec, 0x3f, 0xfe, 0xf8, 0xe3,
0xf7, 0xde, 0x7b, 0xef, 0x91, 0xc3,
0x73, 0xdb, 0x76, 0x9c, 0x30, 0x1c,
0x96, 0x21, 0x54, 0x80, 0x98, 0xa5,
0xa9, 0xd1, 0xda, 0xc5, 0x68, 0x8c,
0xce, 0x32, 0x7e, 0xe8, 0xa1, 0x9f,
0x4d, 0x75, 0x27, 0x66, 0x66, 0x66,
0xb6, 0x6d, 0xdb, 0x26, 0x9, 0x8b,
0xe8, 0x18, 0x10, 0x50, 0x55, 0xf9,
0x3c, 0x4d, 0xe5, 0xfc, 0x63, 0xf4,
0x5a, 0xdb, 0x18, 0xeb, 0xce, 0x8b,
0x14, 0x6b, 0x9e, 0xdc, 0xb7, 0xff,
0xee, 0xbb, 0xef, 0xd9, 0xbb, 0x77,
0xef, 0x96, 0xcd, 0xdb, 0x5c, 0xf0,
0xd6, 0xda, 0x24, 0xc9, 0x2, 0x45,
0x8e, 0xb4, 0xac, 0xc5, 0x0, 0xe3,
0x3d, 0x61, 0x10, 0x24, 0xd6, 0x32,
0xa0, 0xf2, 0x3, 0x7f, 0x72, 0x9d,
0xf4, 0x6, 0x9a, 0xce, 0x72, 0xd3,
0x97, 0x5b, 0x4f, 0xb6, 0x2c, 0xc6,
0x4a, 0x1b, 0x1c, 0x11, 0x4a, 0x96,
0x96, 0x96, 0x96, 0xaa, 0xaa, 0x6a,
0xa, 0xf7, 0x6b, 0xc9, 0xe, 0x80,
0x1a, 0xd1, 0xd9, 0x45, 0x49, 0x2b,
0x4d, 0x53, 0xb1, 0x9c, 0x9c, 0x9d,
0x9d, 0xd5, 0x5a, 0x37, 0x2, 0x17,
0xcb, 0x9f, 0x67, 0x94, 0x31, 0x3d,
0x3f, 0x3f, 0x37, 0x1c, 0xe, 0x89,
0x42, 0x24, 0x5f, 0x55, 0x5, 0x10,
0xaf, 0x10, 0x7f, 0x58, 0x29, 0x15,
0x33, 0xf2, 0xe0, 0x40, 0x63, 0x4c,
0xab, 0xd5, 0x6a, 0x77, 0x27, 0x5b,
0xad, 0x96, 0x44, 0xa7, 0x3c, 0xe,
0x2, 0x12, 0xf3, 0x23, 0x62, 0x1f,
0x5c, 0xbf, 0xdf, 0x5f, 0x58, 0x58,
0x18, 0xc, 0x7a, 0x21, 0x38, 0x22,
0x22, 0xe, 0x56, 0x64, 0x9c, 0x9a,
0x75, 0x8d, 0x97, 0xb, 0x1, 0xc4,
0x81, 0x28, 0x28, 0x65, 0x44, 0x24,
0x35, 0xcb, 0xb2, 0xc9, 0xe9, 0xd9,
0xe9, 0xe9, 0xe9, 0x51, 0x73, 0x42,
0x35, 0x87, 0x90, 0xe3, 0xa4, 0x5a,
0xf7, 0x7a, 0x8b, 0xb, 0xb, 0x4b,
0x83, 0x41, 0xaf, 0xb1, 0x35, 0x18,
0x35, 0x0, 0x69, 0x9d, 0xf4, 0xa4,
0xc6, 0x84, 0x27, 0x49, 0xd6, 0x6e,
0xb7, 0x27, 0xba, 0x53, 0xad, 0xee,
0x44, 0x9a, 0xa6, 0xc1, 0x8f, 0x89,
0x1e, 0x23, 0x37, 0x74, 0xe, 0xc3,
0x3c, 0x37, 0x7f, 0x64, 0x24, 0x47,
0x1c, 0x5, 0x72, 0x94, 0xa6, 0xa9,
0x2c, 0xf9, 0xeb, 0xbd, 0xac, 0xb5,
0xd6, 0xa4, 0xd6, 0xda, 0x56, 0xab,
0xd3, 0xed, 0x76, 0xd3, 0xbc, 0xa5,
0xb5, 0xe, 0xb5, 0x42, 0x32, 0x37,
0x65, 0x12, 0x42, 0x62, 0xe6, 0xc1,
0xc2, 0xc2, 0x60, 0xd8, 0x13, 0x33,
0x94, 0x26, 0x7d, 0x90, 0xd9, 0xbe,
0x8e, 0xda, 0xaa, 0x22, 0x2, 0x79,
0xc4, 0x79, 0x9e, 0x76, 0xbb, 0xdd,
0x4e, 0xa7, 0xc3, 0xa, 0xbd, 0xf7,
0xb5, 0x3a, 0x87, 0x28, 0xca, 0x29,
0x83, 0x88, 0x2e, 0xf8, 0xaa, 0x2a,
0x9e, 0xfa, 0xd5, 0x63, 0xc4, 0xa1,
0x1, 0xbd, 0xfc, 0x7a, 0xc8, 0x1,
0xab, 0x8, 0x98, 0x65, 0xd9, 0xe4,
0xe4, 0xe4, 0xd4, 0xd4, 0x54, 0xa7,
0xd3, 0x92, 0xb0, 0x56, 0x58, 0xe5,
0xcb, 0xe3, 0x90, 0x31, 0x84, 0x50,
0x55, 0xde, 0xb9, 0xf2, 0x89, 0xc7,
0x7f, 0x89, 0x6a, 0x8d, 0x4e, 0xfe,
0x78, 0x50, 0xb3, 0xea, 0x20, 0x9d,
0x89, 0x29, 0xa5, 0x54, 0xa7, 0x33,
0x31, 0x3d, 0x3d, 0x9d, 0x67, 0x2d,
0x89, 0xa2, 0x57, 0x4, 0xaa, 0xa,
0x24, 0xe6, 0x2f, 0x8a, 0xa2, 0xaa,
0x8a, 0x23, 0x87, 0xe, 0x1c, 0x5f,
0x8b, 0xe3, 0x98, 0x43, 0xa8, 0xcd,
0x5b, 0xb7, 0x27, 0x49, 0x22, 0x2e,
0x90, 0xe3, 0x2, 0x40, 0xeb, 0x65,
0xaf, 0x92, 0x3, 0xcb, 0x23, 0x8a,
0xd1, 0x3f, 0xfa, 0xe8, 0xa3, 0xf8,
0x47, 0xd7, 0xfe, 0x79, 0x3, 0x55,
0x1b, 0x77, 0xc1, 0x5c, 0xb7, 0x8d,
0x84, 0xa2, 0x1b, 0xaa, 0x1a, 0xb0,
0xbb, 0xa4, 0x91, 0x8d, 0xfa, 0xd4,
0x9a, 0x13, 0xb8, 0xb9, 0xec, 0x51,
0x3b, 0x41, 0x19, 0x93, 0x48, 0x9e,
0xbc, 0xac, 0x5b, 0x4d, 0xcb, 0x1d,
0x30, 0x66, 0x14, 0x89, 0x5, 0xae,
0xf1, 0x40, 0x81, 0xa3, 0x97, 0x38,
0x67, 0x65, 0x38, 0xb0, 0x2c, 0x4d,
0x23, 0x24, 0x41, 0x71, 0x27, 0x91,
0x93, 0x31, 0x69, 0x26, 0xb4, 0xb8,
0x71, 0x1e, 0x52, 0x33, 0xd5, 0x65,
0x1c, 0x2b, 0xa5, 0x22, 0x85, 0xe8,
0x3, 0x0, 0x59, 0x6b, 0xb5, 0x46,
0xe7, 0x42, 0xf3, 0xcb, 0x15, 0xaf,
0x90, 0x92, 0x16, 0x27, 0x68, 0x8a,
0x75, 0xc6, 0x61, 0x8c, 0x61, 0xa5,
0x97, 0xab, 0x7d, 0x63, 0xb, 0x4a,
0x8d, 0x16, 0x8c, 0x24, 0x4d, 0x5c,
0x91, 0x47, 0x6b, 0xaa, 0x8b, 0xd2,
0xb5, 0x5a, 0xeb, 0xde, 0x92, 0xf8,
0xcd, 0x7b, 0xef, 0x11, 0xb4, 0x31,
0x46, 0x29, 0x13, 0x98, 0x82, 0x8f,
0x12, 0xc2, 0x8d, 0xff, 0x94, 0x88,
0xfc, 0x65, 0xba, 0x86, 0xd4, 0x4b,
0xf4, 0xdb, 0xa4, 0x52, 0xc7, 0x51,
0x93, 0x92, 0x40, 0x5a, 0x8c, 0x8,
0x4, 0xda, 0x10, 0x19, 0x9b, 0x36,
0x52, 0xad, 0xe0, 0x35, 0xb6, 0x46,
0xc8, 0x21, 0x46, 0x85, 0x3a, 0xd5,
0x68, 0x21, 0x1d, 0x47, 0xf2, 0x41,
0x58, 0xe9, 0xb5, 0x78, 0xad, 0x54,
0xad, 0x98, 0xa4, 0xa0, 0xa8, 0x94,
0x52, 0xb8, 0xc, 0xf8, 0x43, 0x2d,
0x64, 0xa9, 0x65, 0xfc, 0xc3, 0x48,
0xc1, 0x43, 0x89, 0x97, 0xca, 0xfa,
0x53, 0x58, 0x8f, 0xb7, 0xc1, 0x64,
0xd7, 0x91, 0x1f, 0x11, 0x51, 0x31,
0x19, 0x45, 0xcd, 0x45, 0x49, 0xd,
0x74, 0x55, 0x1d, 0x61, 0x7c, 0xb8,
0x1e, 0x7b, 0x39, 0x85, 0xf3, 0x69,
0x9a, 0x4a, 0x91, 0x99, 0xea, 0x42,
0x7, 0x8a, 0xdd, 0x71, 0xcd, 0x1e,
0xad, 0xd, 0x31, 0x6b, 0xf0, 0x4c,
0xbb, 0x96, 0x97, 0xf9, 0xd7, 0xea,
0x48, 0x3, 0x40, 0xe9, 0xeb, 0xaa,
0x5e, 0xb3, 0x81, 0x8d, 0x37, 0x84,
0xd7, 0x9a, 0xc0, 0x23, 0xfd, 0x22,
0x66, 0xa2, 0xf0, 0xe8, 0xa3, 0x8f,
0xd6, 0x5a, 0x2d, 0xb5, 0xd4, 0x38,
0x35, 0x4a, 0x8b, 0x38, 0xf2, 0xd6,
0x5a, 0x63, 0x94, 0x59, 0x9b, 0x50,
0xa4, 0x2a, 0x34, 0xfd, 0x65, 0xcb,
0x14, 0x89, 0x48, 0x88, 0x41, 0xe3,
0xe8, 0x91, 0x65, 0x15, 0x66, 0x8,
0x22, 0x59, 0x24, 0x3b, 0xb0, 0x2c,
0xc3, 0xde, 0x5, 0x0, 0xac, 0xc9,
0x49, 0xcb, 0x93, 0x1c, 0x1, 0x20,
0x49, 0xf3, 0x10, 0x5d, 0x8, 0x51,
0xae, 0x25, 0x32, 0x20, 0x5a, 0x9b,
0x26, 0x8c, 0xe3, 0x92, 0x3a, 0xb8,
0xe2, 0x18, 0x14, 0x11, 0x18, 0x95,
0x98, 0x1e, 0x4b, 0x3, 0x19, 0x63,
0x20, 0x4, 0x23, 0x8b, 0xe5, 0xaa,
0xbb, 0xe0, 0x3, 0x39, 0xef, 0x90,
0xc1, 0x58, 0x95, 0x24, 0x99, 0xb0,
0x11, 0x5d, 0x88, 0xa0, 0x34, 0x80,
0x46, 0x6, 0x60, 0x5c, 0xb9, 0xc7,
0xab, 0x2c, 0x49, 0x62, 0xc, 0x8c,
0xa4, 0x14, 0x10, 0x71, 0x8, 0x5c,
0xfb, 0x98, 0x47, 0x5c, 0xf3, 0x46,
0x33, 0x81, 0x46, 0x45, 0x91, 0x42,
0x88, 0x4a, 0x29, 0x6d, 0xb5, 0x32,
0x9, 0x51, 0x20, 0xc2, 0x11, 0xd8,
0x75, 0xa5, 0xa6, 0x14, 0x28, 0x57,
0x91, 0xd6, 0x49, 0x9e, 0x65, 0x31,
0x92, 0x73, 0x2e, 0xf8, 0x72, 0x84,
0x55, 0xc6, 0x31, 0xec, 0x14, 0x35,
0xc1, 0x4a, 0x54, 0xa, 0xb4, 0x1,
0x82, 0xc0, 0x44, 0x81, 0x18, 0x50,
0xe9, 0x44, 0x1b, 0xc5, 0xab, 0xb4,
0x41, 0xc7, 0xfe, 0xd8, 0x6a, 0x75,
0x47, 0x4d, 0x69, 0xb1, 0x1f, 0x6,
0xd0, 0x28, 0xe5, 0xd3, 0xe5, 0x38,
0xa8, 0x9e, 0xc0, 0x11, 0x40, 0x41,
0x92, 0x2, 0x31, 0x5, 0xd1, 0x5e,
0x34, 0x11, 0x80, 0x2, 0x47, 0xa,
0x69, 0x92, 0xad, 0xad, 0x89, 0x5,
0x10, 0x63, 0x89, 0x22, 0x41, 0xa4,
0x20, 0x6, 0x20, 0xa, 0x24, 0x36,
0x5, 0x5a, 0x11, 0x51, 0x14, 0x25,
0x48, 0xe4, 0x10, 0xa3, 0x3c, 0x79,
0x8a, 0x1a, 0x11, 0x15, 0x1a, 0x9d,
0x18, 0xd1, 0x89, 0xd, 0x91, 0x29,
0x6, 0xad, 0xcc, 0xb1, 0xe7, 0x2f,
0xdf, 0x25, 0xbd, 0x94, 0x3a, 0xb6,
0x35, 0xc9, 0x72, 0x9, 0x56, 0xdc,
0xd5, 0xc6, 0x8b, 0x40, 0x0, 0xcc,
0xa0, 0xad, 0x66, 0x40, 0x60, 0x14,
0x4e, 0x97, 0xec, 0x64, 0x50, 0x1b,
0x44, 0xac, 0x38, 0x7f, 0xd1, 0x48,
0x3, 0x64, 0x0, 0xef, 0x9c, 0x8b,
0x41, 0xf0, 0x7c, 0xa, 0x11, 0x94,
0xc2, 0xba, 0x84, 0xde, 0x3c, 0x67,
0x4, 0x54, 0xca, 0x98, 0x44, 0x6b,
0x6, 0xb6, 0xc7, 0xdf, 0x81, 0x9b,
0xad, 0xad, 0x99, 0x9f, 0xd6, 0xd4,
0x2c, 0x57, 0x5e, 0xb6, 0xd3, 0xe6,
0xe3, 0xe0, 0x20, 0x5, 0x36, 0x88,
0x23, 0xb8, 0x25, 0x8a, 0x50, 0xd3,
0xbf, 0x55, 0x13, 0xab, 0xb1, 0x6c,
0x6a, 0x70, 0x42, 0xb5, 0x2a, 0xba,
0xb, 0xc7, 0xae, 0x6d, 0x12, 0x92,
0xb5, 0xdb, 0x79, 0x88, 0x7e, 0x5c,
0x7c, 0x83, 0x28, 0x4a, 0x41, 0xf2,
0x58, 0x80, 0x91, 0xf4, 0x9, 0x88,
0x8, 0x50, 0x2a, 0x96, 0x75, 0xd5,
0x2d, 0x46, 0x20, 0x72, 0xa3, 0xf9,
0xa1, 0x46, 0x10, 0xc8, 0x5a, 0x57,
0xd9, 0x5a, 0xcb, 0x10, 0x29, 0x4a,
0xf6, 0x4f, 0x0, 0x40, 0x23, 0x77,
0x82, 0xd5, 0xfd, 0x7d, 0x4, 0x26,
0x4c, 0xb2, 0x7c, 0x24, 0xf0, 0x47,
0xae, 0xa, 0x21, 0x4a, 0xc, 0x82,
0xf5, 0xca, 0xba, 0x5a, 0xd4, 0x5b,
0x1, 0x40, 0xa8, 0x42, 0x24, 0x8f,
0xa0, 0x6d, 0xa2, 0xb5, 0xae, 0x3d,
0xd0, 0xc4, 0x53, 0x6a, 0x2d, 0xad,
0x45, 0x10, 0x63, 0xa, 0xe6, 0xba,
0x28, 0xe2, 0x5c, 0x28, 0x4b, 0x37,
0xd6, 0x9f, 0x5b, 0x63, 0x13, 0x56,
0x0, 0xcc, 0x24, 0x25, 0x2b, 0xad,
0x6c, 0x9a, 0x5a, 0xc2, 0x46, 0x51,
0xb9, 0xd9, 0x81, 0x97, 0x1f, 0x8f,
0x14, 0x4e, 0xe4, 0xa5, 0x4c, 0xcd,
0x88, 0x8, 0x65, 0x38, 0xe, 0x86,
0xd1, 0x8c, 0xf2, 0x23, 0xa5, 0x14,
0x13, 0xb, 0xb4, 0x65, 0x4c, 0xc3,
0x71, 0x79, 0x2, 0xb, 0x80, 0xbf,
0xa8, 0xa9, 0x1a, 0x88, 0xa0, 0x99,
0x19, 0x59, 0x59, 0x6b, 0x52, 0x95,
0x36, 0x4d, 0xe0, 0xb5, 0xc0, 0x7a,
0xba, 0x56, 0x72, 0x8c, 0xb5, 0xd4,
0x41, 0xe0, 0x20, 0x86, 0xb5, 0x4d,
0xb0, 0x26, 0xd6, 0xad, 0x12, 0x37,
0x79, 0x27, 0x53, 0xc2, 0xaf, 0x1a,
0x75, 0x11, 0xe9, 0x38, 0x59, 0x40,
0x8, 0x41, 0x4a, 0x56, 0xa3, 0xd3,
0x57, 0xf2, 0xf7, 0xcd, 0x4e, 0xd6,
0xa0, 0xb2, 0x88, 0x48, 0x6a, 0x31,
0xeb, 0x80, 0x46, 0xd7, 0xde, 0x2d,
0x5, 0x29, 0x0, 0x5c, 0xab, 0xcc,
0x49, 0x12, 0x24, 0xcd, 0xb6, 0xd1,
0xf, 0x6a, 0x10, 0x65, 0x6a, 0xa9,
0xdb, 0xc5, 0x6a, 0x3d, 0x4d, 0xac,
0x35, 0x8f, 0xc2, 0x1c, 0xd1, 0xac,
0x36, 0x91, 0x3f, 0xfe, 0xec, 0xab,
0xe3, 0xe2, 0xb1, 0x7f, 0x34, 0x4d,
0x9f, 0xaa, 0x9, 0x71, 0x1b, 0x85,
0xcb, 0xf5, 0x3, 0x24, 0x37, 0x8a,
0x58, 0x74, 0x1d, 0xfc, 0x12, 0x8d,
0x50, 0x7, 0x30, 0xce, 0xcb, 0x69,
0xce, 0x4c, 0x6a, 0xe8, 0xa3, 0xb4,
0x64, 0x39, 0x4c, 0x22, 0x12, 0x48,
0x6f, 0xd, 0xbe, 0x65, 0x6, 0x91,
0x29, 0x50, 0x4a, 0x69, 0xa3, 0x88,
0xc0, 0x47, 0xa7, 0x49, 0xc2, 0x75,
0xf4, 0x23, 0xaf, 0x3d, 0x64, 0x4,
0xe0, 0x8, 0x6a, 0x39, 0x41, 0x45,
0xc4, 0x40, 0x8d, 0x64, 0xed, 0x88,
0xb9, 0x43, 0xe3, 0xf8, 0xe1, 0xb1,
0x54, 0x96, 0xa5, 0x3f, 0x24, 0x1,
0xa7, 0xc4, 0xea, 0xa8, 0x15, 0x34,
0xa5, 0x3e, 0xf9, 0xf, 0xd4, 0x98,
0x74, 0xa4, 0xe8, 0x60, 0x27, 0x12,
0x1f, 0xe, 0x7, 0x75, 0x13, 0x48,
0xca, 0xad, 0xc7, 0xde, 0xab, 0x7a,
0x93, 0x7, 0x2f, 0xab, 0xb5, 0x52,
0x9a, 0x99, 0x45, 0x65, 0x76, 0xc,
0xa0, 0xaf, 0x57, 0x33, 0xa5, 0x80,
0x98, 0x48, 0x29, 0x2d, 0x25, 0x3,
0xef, 0x23, 0x40, 0x64, 0x85, 0x4d,
0x6a, 0x33, 0x92, 0x23, 0xa5, 0xe5,
0x1c, 0xd8, 0xd4, 0xa7, 0xd4, 0x58,
0x3a, 0x8c, 0x4c, 0x55, 0xd6, 0x7b,
0x7a, 0x34, 0x4a, 0x58, 0x90, 0x89,
0x41, 0x40, 0x6f, 0x4a, 0x23, 0xf2,
0xe8, 0xac, 0x68, 0x59, 0x4b, 0x54,
0xb1, 0x2c, 0x25, 0xce, 0xd5, 0xb5,
0xd9, 0x24, 0x49, 0x10, 0xb5, 0xfc,
0xf1, 0x38, 0xbc, 0x73, 0xad, 0x14,
0x71, 0xe0, 0x88, 0x63, 0x1, 0xa1,
0x42, 0x4, 0xef, 0x63, 0x93, 0x3e,
0x70, 0xa4, 0x18, 0x3d, 0xa3, 0x80,
0x58, 0x58, 0x52, 0x62, 0x91, 0x1f,
0x1d, 0x53, 0x3e, 0x5a, 0x6f, 0x19,
0x22, 0xef, 0xbd, 0xa8, 0xc9, 0xf1,
0x28, 0x80, 0x63, 0x96, 0x22, 0x4e,
0xad, 0x79, 0x30, 0x82, 0x97, 0xc5,
0x46, 0xf3, 0x75, 0xa4, 0x57, 0xb5,
0x22, 0x23, 0x1d, 0xbf, 0x51, 0x2b,
0xa7, 0xd, 0x4b, 0x2d, 0x53, 0xa1,
0x72, 0xce, 0xc9, 0x13, 0x16, 0x51,
0xbe, 0x46, 0x3e, 0x76, 0xb9, 0x64,
0xa3, 0xc4, 0x2b, 0x67, 0x9d, 0xcc,
0x68, 0xfd, 0x28, 0x5a, 0x91, 0x1a,
0x9f, 0xae, 0xbf, 0x16, 0x3a, 0xce,
0x75, 0x52, 0x87, 0xcd, 0xc2, 0x54,
0x9b, 0x53, 0x49, 0xf7, 0x49, 0x3c,
0x4, 0x25, 0x57, 0x91, 0xa2, 0xe8,
0xb1, 0xe, 0x3, 0x0, 0xa4, 0x8d,
0xd8, 0x52, 0x91, 0x70, 0x94, 0x97,
0x19, 0xf3, 0x20, 0xa2, 0x56, 0xe3,
0x39, 0x70, 0x5d, 0xd9, 0xea, 0xf7,
0x8b, 0x34, 0xc9, 0x24, 0xcd, 0x96,
0x5f, 0x1b, 0x42, 0x70, 0xce, 0xa5,
0x69, 0xbe, 0x2a, 0x9, 0x41, 0x44,
0x83, 0x1a, 0x14, 0x13, 0xc8, 0xed,
0x60, 0x40, 0xe, 0xb1, 0xaa, 0x25,
0xe9, 0x48, 0x42, 0x8, 0x29, 0x84,
0xa8, 0x55, 0x9b, 0x17, 0x73, 0xed,
0xf4, 0x63, 0xad, 0x5, 0x40, 0xad,
0x1a, 0x70, 0xf2, 0xb2, 0xbe, 0xac,
0x68, 0x41, 0x33, 0x73, 0xe5, 0x6,
0x59, 0x96, 0x55, 0x85, 0x43, 0x50,
0x65, 0x51, 0xa5, 0x59, 0x12, 0x28,
0x84, 0xe0, 0xea, 0x4c, 0x9e, 0xd7,
0xd0, 0xbb, 0xa5, 0x50, 0xd5, 0xde,
0x7c, 0x69, 0xa2, 0x94, 0x72, 0xae,
0x14, 0xc1, 0x5b, 0xad, 0xf5, 0xaa,
0x4f, 0x72, 0xed, 0xe, 0x53, 0xd6,
0x2d, 0x9f, 0xc0, 0x82, 0x57, 0x49,
0x52, 0x2b, 0x8a, 0x73, 0x6b, 0x4a,
0x4c, 0x8a, 0x16, 0x9c, 0x73, 0x41,
0x8a, 0x40, 0xc6, 0x58, 0x1, 0x75,
0x10, 0x5, 0x66, 0x52, 0x4a, 0x59,
0x6b, 0xbc, 0xaf, 0x41, 0x17, 0x55,
0x59, 0x24, 0x49, 0x2, 0x8a, 0x4,
0x23, 0x81, 0x32, 0x82, 0x88, 0xa4,
0x9b, 0x7a, 0x9c, 0x0, 0xca, 0x57,
0x43, 0x22, 0xb2, 0x36, 0x1d, 0xed,
0x33, 0x19, 0x8f, 0xe2, 0x31, 0x44,
0xc, 0x81, 0xc5, 0x7a, 0x21, 0xc6,
0x8, 0x8c, 0x88, 0x54, 0xb9, 0x12,
0x0, 0xb4, 0x81, 0x18, 0xfd, 0xb0,
0xa8, 0xea, 0x2a, 0xab, 0xd6, 0x3e,
0xf8, 0x75, 0x36, 0x16, 0x76, 0xc1,
0x4b, 0x50, 0x40, 0x4, 0xa, 0x95,
0xd2, 0x3a, 0x46, 0x1a, 0xc3, 0x14,
0x2b, 0x40, 0x8e, 0x41, 0x94, 0x9f,
0x15, 0x22, 0x8b, 0x98, 0xd9, 0xbf,
0x85, 0x3f, 0x53, 0x2f, 0x58, 0x22,
0xde, 0x62, 0x6d, 0xaa, 0x95, 0x9,
0xa1, 0xd6, 0xfa, 0x1b, 0x39, 0xc5,
0x6, 0x66, 0xa, 0xd1, 0xcb, 0x90,
0x1e, 0x73, 0xaa, 0xfb, 0x35, 0x79,
0xe9, 0xf8, 0x46, 0x95, 0xe7, 0x79,
0xe5, 0x8b, 0x34, 0xcd, 0x11, 0xc8,
0x68, 0x5b, 0x14, 0x55, 0x9a, 0xa6,
0x92, 0x5a, 0x8f, 0x64, 0xa8, 0x89,
0x99, 0x43, 0x70, 0x4a, 0x23, 0xe2,
0xaf, 0xe7, 0x1e, 0xd4, 0x55, 0xc8,
0xd1, 0x95, 0x86, 0xe0, 0x61, 0x2d,
0x5, 0xd9, 0xc6, 0xa5, 0x40, 0xf8,
0xf, 0x12, 0xa8, 0x26, 0x49, 0x52,
0xb8, 0x42, 0x6b, 0x8d, 0xa3, 0x86,
0xa5, 0x31, 0xc6, 0xc, 0x87, 0x7d,
0xd9, 0x81, 0xa5, 0x52, 0xba, 0x6d,
0xdb, 0xb6, 0x6e, 0xb7, 0xdd, 0x78,
0x1a, 0xad, 0x31, 0x81, 0x91, 0x63,
0xf4, 0xd, 0x31, 0x75, 0x3c, 0x66,
0x6e, 0x9a, 0xc9, 0x2b, 0xef, 0x8e,
0x2, 0x80, 0xd, 0x1b, 0x36, 0x9,
0x99, 0x73, 0x38, 0x1c, 0x56, 0xae,
0x6c, 0x18, 0x7f, 0xe2, 0x9, 0xb4,
0xf2, 0x86, 0x8a, 0x7b, 0x80, 0xcb,
0xf2, 0x34, 0xcd, 0xd2, 0xd, 0x1b,
0xb6, 0xce, 0xce, 0xce, 0x2a, 0x55,
0xaf, 0x3a, 0xa3, 0xf, 0x4b, 0x85,
0x49, 0xad, 0xbc, 0x35, 0xdc, 0x10,
0x71, 0x10, 0x71, 0x61, 0x61, 0x69,
0x6e, 0x71, 0xe1, 0xe9, 0xa7, 0x9f,
0xd6, 0x5a, 0xe3, 0x98, 0x3, 0xa0,
0xe4, 0xce, 0xcc, 0x4c, 0xc1, 0x1b,
0x9d, 0x6d, 0xd8, 0xb6, 0x79, 0xd3,
0xa6, 0xd, 0x12, 0x81, 0x36, 0x16,
0xc1, 0xcb, 0x13, 0x77, 0xe5, 0x21,
0x9a, 0x9d, 0xd0, 0x18, 0x33, 0x1c,
0xe, 0x8f, 0x1e, 0x9d, 0x3f, 0x74,
0xf4, 0x48, 0x59, 0x96, 0xa8, 0x56,
0x55, 0xc9, 0xea, 0x87, 0xa2, 0x35,
0x76, 0x5b, 0xed, 0x1d, 0x3b, 0x76,
0x74, 0x3a, 0x9d, 0x10, 0xdc, 0x38,
0x60, 0x60, 0x9c, 0x6d, 0xbb, 0x86,
0xfe, 0x28, 0xe8, 0x18, 0xe3, 0xc2,
0xc2, 0xd2, 0x53, 0x4f, 0x3d, 0xb5,
0x28, 0x76, 0xc1, 0x35, 0x16, 0x42,
0x52, 0x12, 0xc, 0x21, 0x30, 0x90,
0x4d, 0x4c, 0xa7, 0x95, 0x6f, 0xdf,
0xba, 0x59, 0x1c, 0x4f, 0x1b, 0x1b,
0x61, 0x31, 0xa7, 0x5d, 0x5f, 0xdd,
0xda, 0x28, 0xa5, 0x28, 0xc2, 0xc2,
0xc2, 0xc2, 0xd1, 0xa3, 0x47, 0x17,
0x16, 0x96, 0x44, 0xac, 0xcf, 0x5a,
0x4b, 0xc4, 0xc, 0x14, 0x23, 0x48,
0x45, 0x40, 0x6b, 0xd3, 0xe9, 0x74,
0xa6, 0x26, 0xba, 0x93, 0xdd, 0xae,
0x40, 0xa0, 0xc6, 0xf1, 0x2, 0xc7,
0x52, 0xaf, 0xc6, 0x77, 0x24, 0x63,
0xcc, 0x70, 0x58, 0x1e, 0x38, 0x70,
0xe0, 0xe0, 0x81, 0xc3, 0x31, 0xb2,
0x8, 0xb6, 0x8, 0x90, 0xa3, 0x9e,
0xc1, 0xcc, 0x88, 0x90, 0xe7, 0xf9,
0xc4, 0xc4, 0xc4, 0x96, 0x4d, 0x9b,
0xd5, 0xa, 0x15, 0x7b, 0x5e, 0x33,
0xf7, 0x59, 0xb1, 0x5c, 0x5b, 0x55,
0x96, 0xe5, 0xe2, 0xe2, 0xe2, 0x93,
0xfb, 0x9e, 0x1e, 0xe, 0xcb, 0x3c,
0xcf, 0x99, 0xeb, 0x2d, 0xb7, 0xd9,
0x78, 0x23, 0x85, 0x89, 0x89, 0x4e,
0xa7, 0xd3, 0xd9, 0xb8, 0x71, 0xb6,
0x95, 0x65, 0xff, 0xca, 0xc2, 0xd2,
0xf2, 0x21, 0x8c, 0x59, 0x5c, 0x5c,
0x7c, 0xec, 0xb1, 0xc7, 0x8a, 0xa2,
0xb4, 0x36, 0xd5, 0x46, 0x29, 0x25,
0x2e, 0x56, 0x42, 0xe0, 0x11, 0x15,
0x58, 0x72, 0xae, 0xb2, 0xd6, 0xe6,
0xad, 0x2c, 0xcf, 0xd3, 0x5f, 0xbb,
0x3, 0xaf, 0xbc, 0xa2, 0xda, 0x49,
0x67, 0x3d, 0xd7, 0x81, 0xf1, 0x99,
0x35, 0x1c, 0xe, 0x97, 0x96, 0x96,
0x5c, 0x74, 0x79, 0x9e, 0x27, 0xc6,
0x36, 0xd5, 0x3b, 0x23, 0xd0, 0x13,
0x54, 0x10, 0xa2, 0xdf, 0xbc, 0x65,
0xd3, 0xb9, 0xcf, 0x3c, 0x67, 0x30,
0x18, 0x8, 0x6c, 0xfd, 0x58, 0xad,
0xac, 0x91, 0x3c, 0xff, 0xda, 0xb7,
0x60, 0xd5, 0x9b, 0xf1, 0x73, 0x6d,
0xb7, 0xdb, 0x52, 0xc6, 0xdc, 0xb7,
0x6f, 0xdf, 0xc1, 0x83, 0x7, 0xc5,
0x5d, 0xb2, 0xa6, 0x4e, 0xe1, 0x8a,
0x51, 0x2f, 0xa1, 0x74, 0x28, 0xcb,
0xce, 0xec, 0xc4, 0xf9, 0xe7, 0x9f,
0xff, 0x9c, 0x4b, 0xf7, 0x6c, 0x9c,
0x9d, 0xa2, 0x91, 0x14, 0xc5, 0xca,
0x43, 0xaf, 0xa8, 0x42, 0x73, 0xad,
0x46, 0x8e, 0x91, 0xc8, 0x28, 0x55,
0xb9, 0x78, 0x64, 0x7e, 0xfe, 0xd6,
0x5b, 0x6f, 0x7d, 0x78, 0xef, 0x2f,
0x51, 0x19, 0x49, 0x89, 0x6a, 0x8c,
0xa, 0x3, 0x3, 0xb5, 0x5b, 0xf6,
0xcc, 0x53, 0x4f, 0x7a, 0xe1, 0xb,
0x5f, 0xb0, 0x7d, 0xfb, 0x76, 0x6b,
0x90, 0x0, 0x9c, 0x2b, 0xb3, 0x24,
0x8b, 0x1c, 0xc7, 0x56, 0xd2, 0x15,
0xc7, 0xb, 0xe4, 0xc5, 0xd7, 0x57,
0x1, 0x38, 0x4f, 0xc3, 0xe1, 0xf0,
0xb6, 0xaf, 0x7e, 0xf5, 0xce, 0x3b,
0xef, 0x14, 0xad, 0xdd, 0x26, 0x7c,
0x1d, 0xe9, 0x72, 0xf1, 0x19, 0xa7,
0xed, 0xba, 0x64, 0xcf, 0xc5, 0xbb,
0x77, 0xef, 0x26, 0xa2, 0x18, 0x7d,
0x2b, 0xcf, 0x18, 0x40, 0xa, 0x5a,
0xeb, 0xed, 0xc0, 0xa8, 0xc0, 0xf9,
0xc0, 0x8c, 0xc6, 0x98, 0x18, 0xf8,
0xce, 0x3b, 0x7f, 0xf8, 0xe5, 0xaf,
0xfe, 0x53, 0xbf, 0x3f, 0xec, 0x76,
0xbb, 0x55, 0xe5, 0x89, 0x23, 0xd7,
0xe5, 0x29, 0x6a, 0xb5, 0x5a, 0x9b,
0x37, 0xce, 0xfc, 0xc6, 0xb, 0x2f,
0x3f, 0xe7, 0xec, 0x33, 0x12, 0x9b,
0x44, 0xaa, 0xb9, 0x84, 0xb5, 0xa3,
0xfa, 0xfa, 0x55, 0x68, 0x50, 0x5a,
0xd5, 0xe6, 0x6, 0xfc, 0xf0, 0xc3,
0x8f, 0xdc, 0x7a, 0xeb, 0x17, 0xe,
0x1d, 0x39, 0x92, 0x65, 0xb9, 0x64,
0xf2, 0x49, 0x92, 0x8e, 0xc2, 0x7e,
0x9c, 0x9c, 0x9c, 0xbc, 0xf0, 0xfc,
0xf3, 0x2e, 0x7f, 0xde, 0x9e, 0x56,
0x96, 0xa, 0x7b, 0x4c, 0x76, 0xf8,
0x9a, 0x53, 0xb5, 0x6e, 0x6a, 0xc7,
0xa8, 0x41, 0x81, 0x22, 0x80, 0x43,
0x87, 0x8e, 0xfc, 0xe3, 0xad, 0x5f,
0xda, 0xbb, 0xf7, 0x11, 0x40, 0xad,
0x34, 0x82, 0xd0, 0x33, 0x6b, 0xc1,
0x86, 0x98, 0x65, 0xf9, 0xee, 0xdd,
0xbb, 0x2f, 0x7f, 0xde, 0x73, 0x37,
0x6f, 0x9c, 0x51, 0xd0, 0x78, 0xee,
0xe0, 0xaf, 0x53, 0x65, 0x3, 0x46,
0x29, 0x4b, 0xe2, 0x60, 0x58, 0xfe,
0xd3, 0x3f, 0x7d, 0xfd, 0x87, 0x77,
0xde, 0x85, 0x8, 0x34, 0xa2, 0xe9,
0x1, 0x40, 0x88, 0xde, 0x18, 0x85,
0x18, 0x4f, 0xda, 0xb5, 0xe3, 0xc2,
0xb, 0x2f, 0x3c, 0xef, 0x59, 0xe7,
0x30, 0xf3, 0x31, 0xd6, 0x47, 0xc7,
0xcd, 0x81, 0x51, 0x55, 0x3e, 0x2,
0xc0, 0xdd, 0x77, 0xdf, 0xf3, 0x8d,
0xaf, 0xff, 0x9f, 0xb9, 0xb9, 0xb9,
0x18, 0xbd, 0xd2, 0x1a, 0x15, 0x18,
0xa5, 0xbd, 0xa7, 0x18, 0x3d, 0x73,
0x34, 0xc6, 0x30, 0xd0, 0xce, 0x13,
0x4f, 0xd8, 0xb4, 0x69, 0x93, 0x18,
0xa3, 0xad, 0xb7, 0x68, 0xae, 0x79,
0xb8, 0xf5, 0x4, 0xdc, 0x47, 0x86,
0xd2, 0x5e, 0xf6, 0x5e, 0xd9, 0x8a,
0xf7, 0xed, 0xdb, 0xb7, 0xef, 0xa9,
0x27, 0xf3, 0x3c, 0x97, 0x28, 0x43,
0xb6, 0x2b, 0x23, 0x4b, 0xb5, 0xb4,
0x73, 0x4, 0x68, 0x26, 0x21, 0xf4,
0xda, 0xdb, 0x2f, 0xc0, 0x88, 0xa3,
0xbc, 0xec, 0xf5, 0x5a, 0xdb, 0x6d,
0x71, 0x34, 0x26, 0x69, 0x40, 0x20,
0xe3, 0x1e, 0xb0, 0x4d, 0x51, 0x4a,
0xcc, 0xe9, 0x5, 0xe6, 0xb6, 0x46,
0x2b, 0x82, 0x97, 0x8f, 0xd2, 0x6a,
0x65, 0xc, 0x71, 0x76, 0xc3, 0xf4,
0xd4, 0xd4, 0xa4, 0x58, 0x4, 0x50,
0x94, 0x8a, 0x34, 0x2e, 0x6f, 0x5c,
0x2b, 0xb7, 0xc7, 0x10, 0xa2, 0xb5,
0x16, 0x1, 0xbd, 0x77, 0x3a, 0xcd,
0xd2, 0x44, 0x6f, 0xdc, 0x34, 0x63,
0x8c, 0x8e, 0x24, 0xbd, 0x3b, 0xd9,
0xf7, 0x94, 0x52, 0x8a, 0x18, 0x22,
0x45, 0x46, 0x9e, 0x9e, 0x99, 0xd8,
0xb6, 0x7d, 0xb, 0x83, 0x2f, 0x1d,
0x65, 0x49, 0x62, 0xad, 0x76, 0x71,
0xa8, 0x97, 0xbd, 0xdb, 0xd4, 0x98,
0x35, 0x6, 0x8c, 0x14, 0xa4, 0x98,
0xd9, 0x2b, 0x65, 0xb4, 0xc1, 0xa9,
0xc9, 0x4e, 0xbb, 0x93, 0x69, 0xad,
0x88, 0x3, 0x82, 0x66, 0xae, 0x2f,
0xb9, 0xae, 0x2, 0x71, 0x40, 0x84,
0x2d, 0x5b, 0x36, 0x58, 0x83, 0x65,
0xe5, 0x95, 0x82, 0xc8, 0x5e, 0xa1,
0x21, 0x76, 0x8, 0x7a, 0x2d, 0x99,
0x4, 0x5, 0x40, 0xc, 0x8, 0x18,
0x10, 0x14, 0xa2, 0x4e, 0x13, 0xdd,
0xed, 0x76, 0x8c, 0x55, 0x69, 0x6a,
0x65, 0xb8, 0x8c, 0x9b, 0x86, 0x3a,
0xe7, 0x8a, 0xa2, 0x68, 0x77, 0x52,
0xa5, 0xc9, 0xc7, 0xaa, 0xaa, 0x8a,
0x76, 0xab, 0x9b, 0x58, 0x5, 0xa0,
0x18, 0x62, 0x14, 0x49, 0x90, 0x35,
0x84, 0xdd, 0x81, 0x62, 0x28, 0x7d,
0x44, 0xc4, 0x34, 0xcd, 0x67, 0x66,
0xa6, 0xb5, 0x46, 0x1f, 0x44, 0x3b,
0xc2, 0x8c, 0x95, 0x18, 0x6b, 0x15,
0x81, 0x76, 0xbb, 0xdd, 0x6a, 0x65,
0x5a, 0x11, 0x43, 0x44, 0x15, 0xb5,
0x52, 0xa8, 0xc4, 0x21, 0xa8, 0xd2,
0xda, 0x32, 0x8f, 0xd9, 0xbb, 0xca,
0xf9, 0x33, 0x2, 0x50, 0x51, 0x54,
0x59, 0x96, 0x29, 0x34, 0xd3, 0xd3,
0x93, 0xc6, 0x68, 0xe7, 0x4a, 0x6d,
0xb1, 0xbe, 0x33, 0x35, 0x9, 0x8f,
0x25, 0x87, 0x32, 0xc6, 0xcc, 0xce,
0xce, 0x22, 0x12, 0x40, 0x0, 0x94,
0xed, 0x44, 0x8f, 0xee, 0x3, 0xf1,
0xda, 0xc2, 0xf4, 0xa, 0x18, 0xca,
0x72, 0x68, 0xd2, 0x2c, 0x6f, 0xa5,
0x49, 0x62, 0x7d, 0xa8, 0x10, 0x34,
0x11, 0x18, 0x93, 0xc4, 0x18, 0x51,
0xd5, 0x6c, 0x1c, 0x86, 0x18, 0x82,
0x9f, 0x9c, 0x9c, 0x50, 0x0, 0x91,
0x3d, 0xaf, 0x85, 0x4a, 0x62, 0x56,
0xe3, 0xe7, 0xbf, 0xc2, 0x7e, 0x29,
0xc4, 0x2c, 0xcf, 0xd3, 0x34, 0x75,
0xbe, 0x14, 0xc8, 0x87, 0xc8, 0x30,
0xc7, 0x51, 0x30, 0x15, 0x63, 0xd4,
0x46, 0x9, 0x50, 0xcc, 0x7b, 0x9f,
0x24, 0xd9, 0x9a, 0xc0, 0x27, 0x0,
0xa8, 0xaa, 0x35, 0xa6, 0xcc, 0x71,
0x96, 0xf, 0x59, 0x88, 0x25, 0x8d,
0x95, 0x70, 0x5d, 0x1a, 0xc5, 0xab,
0x8, 0x64, 0x44, 0x54, 0xb, 0x73,
0x8f, 0xb0, 0x35, 0x4e, 0x20, 0xd,
0x82, 0xa4, 0x1d, 0xe1, 0xc8, 0x57,
0x6f, 0xc2, 0xa3, 0x7a, 0x80, 0x94,
0xbb, 0x68, 0x99, 0xfe, 0x5a, 0x3f,
0xfe, 0xc8, 0x42, 0x14, 0x56, 0x80,
0xc0, 0x30, 0xd2, 0x4c, 0xab, 0xaa,
0x42, 0xba, 0xb2, 0xa2, 0x78, 0x0,
0xb0, 0xbc, 0x5d, 0x48, 0x11, 0xbb,
0x4e, 0xa5, 0x11, 0x81, 0x49, 0x23,
0x1f, 0xda, 0xbf, 0x3f, 0xb3, 0x36,
0xd5, 0xd8, 0x1f, 0xf6, 0xf3, 0x3c,
0x75, 0xd1, 0x5b, 0x23, 0x39, 0x30,
0xaf, 0xf4, 0x16, 0xa9, 0x6b, 0xd7,
0x5a, 0x29, 0xe7, 0xb, 0xad, 0xd,
0x60, 0x20, 0xe, 0x44, 0x60, 0xb4,
0x1d, 0xa3, 0x1c, 0x4b, 0xcb, 0x5e,
0x89, 0xcb, 0x14, 0x22, 0xbb, 0xe8,
0x97, 0x96, 0x16, 0x28, 0xf8, 0x34,
0xb3, 0x0, 0xe0, 0x7c, 0xe1, 0xbd,
0x13, 0x95, 0x89, 0x51, 0x8f, 0x2a,
0xae, 0x28, 0x37, 0x20, 0x21, 0xb0,
0x88, 0x4, 0x68, 0xc5, 0x95, 0x73,
0x98, 0x64, 0x82, 0x7f, 0xf4, 0x3e,
0x88, 0x44, 0x55, 0x53, 0x97, 0x12,
0xa0, 0x4c, 0x6f, 0x69, 0xa1, 0xd3,
0x6d, 0x79, 0x57, 0x20, 0x87, 0x3c,
0xcb, 0x97, 0x7a, 0x4b, 0x79, 0x9e,
0xa7, 0x46, 0x4b, 0x41, 0xfe, 0x98,
0x35, 0x9f, 0x0, 0x39, 0x52, 0x54,
0x5a, 0x1, 0x73, 0xe5, 0x6, 0xad,
0xb4, 0x3, 0x48, 0x55, 0x55, 0x32,
0x90, 0xf7, 0xf5, 0xdc, 0x88, 0x51,
0x92, 0x22, 0x8c, 0x4c, 0xce, 0x97,
0x1c, 0xc9, 0xa0, 0x2, 0x84, 0x88,
0xa, 0xb9, 0x46, 0x1a, 0xa4, 0x49,
0x3a, 0x8a, 0xd8, 0x57, 0x79, 0xf3,
0x44, 0x0, 0xf0, 0x31, 0x24, 0x59,
0xaa, 0xd0, 0x10, 0x5, 0x1f, 0xaa,
0xe1, 0x70, 0xa0, 0xb5, 0x6e, 0xb5,
0x5a, 0x55, 0xe5, 0x43, 0x20, 0xad,
0x83, 0x84, 0xd3, 0x62, 0x84, 0x4d,
0x1c, 0xac, 0x32, 0x21, 0xc, 0x82,
0x8f, 0x62, 0xaa, 0x12, 0x89, 0x11,
0x54, 0x62, 0x74, 0xc, 0x1, 0x70,
0xf4, 0x38, 0x90, 0xe5, 0xfc, 0xc5,
0x78, 0x33, 0x4b, 0x12, 0x85, 0x18,
0xa2, 0x3, 0xd0, 0x45, 0x51, 0x44,
0xe0, 0x3c, 0x49, 0x8a, 0xa2, 0x42,
0x44, 0x22, 0x64, 0x20, 0x1, 0xba,
0xc5, 0xe8, 0xab, 0xa2, 0x64, 0x26,
0xad, 0x84, 0xd9, 0x1e, 0xeb, 0xe,
0x2, 0x8a, 0xd9, 0x20, 0x33, 0xd1,
0xa8, 0x8d, 0x44, 0xcb, 0x87, 0x60,
0x22, 0x84, 0x2c, 0xcb, 0x5c, 0x24,
0xa9, 0xbd, 0x85, 0x10, 0x12, 0x6b,
0x4, 0x2d, 0xdb, 0x8, 0xcb, 0x48,
0xb8, 0x3e, 0x18, 0xc, 0x36, 0x6d,
0xde, 0x50, 0x54, 0x85, 0xd1, 0xac,
0x80, 0x57, 0xfd, 0x9e, 0xfa, 0xfb,
0xf8, 0xf9, 0x8f, 0x1d, 0x42, 0x2a,
0x5c, 0xe2, 0x22, 0x9a, 0x66, 0x36,
0xf8, 0x28, 0xdd, 0x56, 0xa5, 0x8c,
0x34, 0x87, 0xcb, 0xb2, 0x32, 0x56,
0x4b, 0x39, 0xcd, 0xb9, 0x32, 0xac,
0x32, 0xa9, 0x1c, 0x1b, 0x42, 0xc4,
0x75, 0x91, 0x6, 0x46, 0xed, 0x68,
0x35, 0xb2, 0xb0, 0x5d, 0xb7, 0x5c,
0xa5, 0xb4, 0x2c, 0x43, 0xde, 0x8b,
0x89, 0x75, 0xda, 0x1b, 0x2c, 0x8d,
0xb5, 0xeb, 0x6b, 0x3b, 0x28, 0x5,
0xa8, 0x0, 0x55, 0x20, 0xf6, 0x21,
0x56, 0x3e, 0x4, 0xe2, 0xc8, 0x50,
0x3a, 0xf, 0x4a, 0x33, 0x63, 0x51,
0x54, 0x52, 0x14, 0x11, 0x25, 0x4,
0x89, 0x6a, 0xca, 0xb2, 0xbf, 0xb4,
0x34, 0x37, 0x18, 0x2c, 0x1a, 0x3,
0xc3, 0x61, 0x3f, 0x46, 0x1f, 0xa3,
0xf, 0xc1, 0x49, 0xd6, 0x4d, 0x14,
0x0, 0x8, 0x15, 0x10, 0x5, 0x1f,
0x5c, 0x8, 0x2e, 0x4, 0x87, 0xda,
0x24, 0x59, 0xee, 0x23, 0xa1, 0x36,
0x8c, 0xa, 0xb5, 0x9, 0xc4, 0x4,
0x38, 0xfa, 0xe2, 0xc8, 0x24, 0x5f,
0x81, 0x62, 0xa0, 0xe8, 0x2, 0xa5,
0xad, 0xbc, 0x28, 0x8a, 0xc8, 0x9c,
0x18, 0x1b, 0xbc, 0xd7, 0x4a, 0x41,
0x24, 0xc5, 0x90, 0x99, 0x54, 0x83,
0x4a, 0xb4, 0xd5, 0xda, 0x58, 0x93,
0x94, 0xa5, 0x2b, 0x4b, 0x97, 0x98,
0xd4, 0xea, 0x54, 0x81, 0xe2, 0x8,
0xa, 0x34, 0xb2, 0x92, 0x44, 0x25,
0x54, 0xb5, 0xe4, 0xba, 0x8f, 0xe4,
0x23, 0xf9, 0x18, 0x7c, 0x88, 0x81,
0x62, 0x8c, 0xc, 0x80, 0x4, 0x26,
0x10, 0x3, 0x18, 0xef, 0x98, 0xa2,
0x4a, 0x4d, 0x66, 0x31, 0x49, 0xb4,
0xb5, 0xca, 0xa4, 0x49, 0xae, 0x94,
0xe9, 0xd, 0xb, 0x9b, 0xe4, 0x36,
0xc9, 0x23, 0x63, 0x6a, 0xdb, 0x59,
0x92, 0x45, 0x1f, 0x5d, 0xe9, 0x14,
0x68, 0x29, 0xc6, 0x1a, 0x30, 0x48,
0xa2, 0x6a, 0x0, 0x81, 0x38, 0x10,
0xcb, 0xf9, 0x4b, 0xac, 0xeb, 0x3,
0x85, 0xc8, 0x8c, 0x9a, 0x95, 0x5e,
0x1a, 0xe, 0x3b, 0xdd, 0xa9, 0x85,
0xde, 0x92, 0xdc, 0x6d, 0x63, 0xd2,
0xc4, 0xa4, 0xa, 0x75, 0x62, 0x52,
0xf9, 0xa, 0x81, 0x62, 0x20, 0xf6,
0x80, 0xa4, 0x15, 0x98, 0xe8, 0x44,
0xc1, 0x97, 0x10, 0x4c, 0x59, 0x45,
0xd4, 0x9, 0xa3, 0x22, 0x40, 0x46,
0x15, 0x19, 0x62, 0xdd, 0x2a, 0x45,
0x22, 0x20, 0x54, 0x9e, 0x58, 0xd9,
0x64, 0x58, 0x39, 0x65, 0x13, 0x6b,
0x53, 0x0, 0x95, 0x26, 0xf9, 0x28,
0x97, 0x17, 0xdb, 0xe6, 0xc4, 0xda,
0x14, 0x8, 0x95, 0x32, 0x56, 0xd9,
0xe8, 0xc9, 0x95, 0x5e, 0x81, 0x46,
0xd0, 0x0, 0x18, 0x3, 0xf6, 0x87,
0x95, 0x8f, 0xc4, 0x8, 0x3e, 0x86,
0xc8, 0xe4, 0x42, 0x85, 0x1a, 0x82,
0xab, 0x34, 0x60, 0xa4, 0x18, 0x7c,
0x4c, 0xd3, 0x1c, 0x18, 0x95, 0x32,
0x89, 0x4d, 0x8d, 0x49, 0x28, 0x72,
0x9a, 0xe4, 0x5a, 0x19, 0xa5, 0x8c,
0x24, 0x72, 0x89, 0xcd, 0xbc, 0xb,
0x88, 0x9a, 0x22, 0x2, 0x68, 0x57,
0x5, 0xa3, 0x33, 0x0, 0x5, 0x5a,
0x2b, 0x34, 0xce, 0x39, 0x50, 0x8,
0xa, 0x3, 0xcb, 0x85, 0xd6, 0x2d,
0x0, 0xad, 0xb5, 0x62, 0x40, 0xd0,
0x4b, 0x8b, 0x3d, 0x44, 0xd, 0x8c,
0x31, 0xb2, 0x35, 0x9, 0x33, 0x5a,
0x9d, 0xc4, 0xc8, 0x5a, 0x19, 0xad,
0x4c, 0x8c, 0x8c, 0xa0, 0x62, 0xe4,
0xc4, 0xa4, 0x89, 0xcd, 0x14, 0x2b,
0x26, 0x22, 0x1f, 0x12, 0x54, 0xd1,
0x79, 0x60, 0x15, 0x23, 0x83, 0xc2,
0x48, 0xcc, 0x80, 0x3e, 0x6, 0x50,
0x5a, 0x40, 0x4b, 0x5a, 0x6b, 0x5f,
0x56, 0x49, 0x92, 0x68, 0x6d, 0x63,
0x20, 0xef, 0xa3, 0xfc, 0x6, 0x26,
0x40, 0xd4, 0xa, 0xb5, 0x28, 0x90,
0x5, 0x1f, 0x13, 0x9b, 0x59, 0x93,
0x68, 0x6d, 0x13, 0x93, 0x2, 0x28,
0x88, 0xc0, 0x11, 0xc, 0x0, 0x7,
0x72, 0x45, 0xe5, 0x5d, 0xd4, 0x5a,
0xa3, 0x56, 0xda, 0x26, 0x8c, 0xe0,
0x82, 0x97, 0x75, 0xd0, 0x5, 0x8f,
0x5a, 0x55, 0x95, 0xd8, 0xa3, 0xb0,
0xf7, 0x85, 0xf7, 0x95, 0x4c, 0x84,
0x48, 0x1, 0x81, 0x65, 0x5c, 0x3,
0x13, 0x2, 0x1b, 0xad, 0x14, 0xb0,
0xaf, 0xca, 0x62, 0xd0, 0x2f, 0xfa,
0xbd, 0xb2, 0x1c, 0x3a, 0xe7, 0xe6,
0xe6, 0xe6, 0x7a, 0xbd, 0x5e, 0x59,
0x96, 0xce, 0xb9, 0x85, 0x85, 0x85,
0x40, 0x31, 0x32, 0x81, 0xc2, 0xc8,
0x44, 0xc0, 0x8c, 0x60, 0x12, 0xab,
0xad, 0x71, 0xa1, 0xa6, 0x4f, 0x48,
0xd7, 0x6a, 0x54, 0x1c, 0x75, 0xa,
0xb0, 0x6e, 0xfa, 0xa1, 0x82, 0xa6,
0x81, 0x34, 0xe2, 0xf7, 0xd, 0x85,
0xff, 0x21, 0xd5, 0xb6, 0xb2, 0x2c,
0xdb, 0xed, 0xf6, 0x91, 0x23, 0x87,
0x3a, 0xad, 0xd6, 0x55, 0x6f, 0x79,
0xf3, 0x5b, 0xde, 0xfc, 0xe6, 0x3d,
0x17, 0x5d, 0xf4, 0xfe, 0xf7, 0xfd,
0x87, 0x9d, 0x3b, 0xb6, 0xcd, 0x1d,
0x39, 0x44, 0xc1, 0x19, 0x5, 0x40,
0x21, 0x54, 0xce, 0x97, 0x55, 0x74,
0x15, 0x87, 0x88, 0x23, 0xc7, 0x54,
0xef, 0xbd, 0xe0, 0x63, 0x9b, 0xda,
0x58, 0x3, 0x9d, 0x59, 0xf3, 0x55,
0xe3, 0x92, 0x88, 0x6a, 0x3d, 0xf6,
0x8, 0x10, 0x29, 0x46, 0xbe, 0xe9,
0xa6, 0x9b, 0x66, 0x66, 0x67, 0xd2,
0xa4, 0x95, 0xe7, 0x79, 0x6a, 0x32,
0xab, 0x93, 0x13, 0x4f, 0x3c, 0xf1,
0xc4, 0x13, 0x4f, 0x9c, 0x98, 0x9a,
0xba, 0xfc, 0x79, 0x97, 0x3d, 0x70,
0xdf, 0x3, 0xb2, 0x2c, 0x39, 0x17,
0x90, 0x21, 0x6, 0x6e, 0xb7, 0xdb,
0xa, 0xa5, 0x60, 0x66, 0x95, 0x12,
0xfa, 0x80, 0x56, 0x4a, 0xa1, 0x52,
0x14, 0xc1, 0x18, 0x1b, 0x3c, 0x2d,
0x2d, 0xd, 0x10, 0x75, 0x9e, 0xe5,
0xfb, 0xf7, 0x1f, 0xfc, 0xd2, 0x6d,
0x5f, 0x3e, 0xf5, 0xd4, 0xd3, 0xa7,
0xa7, 0x67, 0xaf, 0xfb, 0xf0, 0xf5,
0xbd, 0xde, 0x20, 0xb1, 0xd9, 0xd7,
0xbf, 0xf1, 0xcd, 0xaf, 0x7f, 0xe3,
0x9b, 0x17, 0x5e, 0x78, 0x71, 0x9a,
0xa5, 0xd7, 0x5d, 0x7f, 0xfd, 0x91,
0x23, 0x47, 0x3a, 0xad, 0x89, 0xc8,
0x31, 0x4, 0x4a, 0x93, 0x44, 0x2a,
0x2f, 0x4a, 0x89, 0x31, 0x8f, 0x19,
0xbf, 0x4, 0xd4, 0xca, 0x18, 0xd3,
0xeb, 0xd, 0x7c, 0xc, 0x80, 0x1a,
0x0, 0xe, 0x1c, 0x3a, 0xd0, 0x6a,
0xb5, 0xbe, 0xf9, 0xad, 0x6f, 0xbe,
0xf4, 0xa5, 0x2f, 0xcd, 0x5a, 0x59,
0xbb, 0xd3, 0x4e, 0x6c, 0xde, 0x9d,
0x98, 0xec, 0x4e, 0x4c, 0xbe, 0xe1,
0xb7, 0xdf, 0xf8, 0x8b, 0x5f, 0x3c,
0xbc, 0xb4, 0xd4, 0x8f, 0x31, 0xfa,
0xb2, 0x72, 0x55, 0x90, 0xec, 0xa8,
0xf4, 0x2e, 0x46, 0xb6, 0xd6, 0x2,
0x8b, 0xe3, 0xd8, 0xb2, 0x3d, 0x4f,
0xa3, 0x86, 0xa5, 0xc0, 0xc, 0xfa,
0x45, 0xc, 0x6c, 0x74, 0x72, 0xd3,
0xa7, 0xff, 0x6e, 0x72, 0x72, 0xfa,
0x59, 0xcf, 0x3e, 0xef, 0x9e, 0x7b,
0xef, 0x9b, 0x9b, 0x5b, 0x28, 0x8a,
0xaa, 0xd7, 0x1b, 0xf4, 0x7a, 0x83,
0xb7, 0xbd, 0xed, 0xed, 0x33, 0x33,
0x1b, 0xde, 0xfe, 0xf6, 0xdf, 0x7d,
0xf4, 0x91, 0xc7, 0x42, 0x8, 0x1c,
0x22, 0xd5, 0xe3, 0x0, 0x5, 0x1b,
0xc3, 0xcc, 0x5a, 0x19, 0xa3, 0xad,
0xd4, 0x3c, 0xeb, 0x4b, 0x40, 0x16,
0x74, 0x57, 0x8, 0x52, 0xde, 0x4f,
0xad, 0xb1, 0xf7, 0xde, 0x7b, 0xff,
0xee, 0xdd, 0xbb, 0xb3, 0xb4, 0xbd,
0x71, 0xd3, 0xc6, 0xc9, 0xc9, 0xe9,
0x8d, 0x1b, 0x37, 0x6e, 0xdc, 0xb8,
0xb1, 0xd5, 0xea, 0xbc, 0xe4, 0xa5,
0x2f, 0xb9, 0xf9, 0xe6, 0xff, 0x35,
0x37, 0x37, 0x47, 0x44, 0xc1, 0x53,
0xc, 0x1c, 0x23, 0xc7, 0x30, 0x12,
0x36, 0x40, 0x35, 0xfe, 0xd0, 0xb5,
0xae, 0x9b, 0xb4, 0xc8, 0x91, 0x88,
0x86, 0xfd, 0x7e, 0x9e, 0xb7, 0xbd,
0xf7, 0x89, 0xcd, 0x9e, 0x7c, 0xf2,
0xc9, 0xab, 0xaf, 0x7e, 0xe7, 0x89,
0x27, 0x9e, 0xf8, 0xdc, 0xcb, 0x9e,
0xf7, 0xc0, 0x3, 0xf, 0xf4, 0xfb,
0xc3, 0x7e, 0x7f, 0xb8, 0xb8, 0xb8,
0x78, 0xdf, 0x7d, 0x3f, 0xbe, 0xf8,
0xe2, 0x8b, 0x9f, 0x71, 0xea, 0x69,
0x5f, 0xf9, 0xea, 0x57, 0x12, 0x9b,
0x8, 0x23, 0x9a, 0xc6, 0xfb, 0x40,
0x4d, 0x3e, 0xc9, 0xcb, 0x96, 0xf6,
0x44, 0x14, 0x3, 0x87, 0x10, 0xc8,
0xd3, 0x60, 0x50, 0x5c, 0x7b, 0xed,
0xb5, 0xdb, 0x77, 0x9c, 0xd0, 0x9d,
0xe8, 0xbe, 0xec, 0x65, 0xaf, 0x78,
0xec, 0xb1, 0xc7, 0xe6, 0xe7, 0x17,
0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7,
0x8f, 0x1e, 0x9d, 0xff, 0xbd, 0x77,
0xfe, 0xde, 0xf4, 0xf4, 0x6c, 0x96,
0x65, 0xbf, 0xfd, 0xc6, 0x37, 0x1d,
0x38, 0x70, 0x20, 0x4b, 0x5b, 0x31,
0xae, 0x6, 0xe8, 0x10, 0x41, 0x8c,
0x91, 0x96, 0xb9, 0x5, 0x2b, 0x24,
0x9a, 0x87, 0xfd, 0x81, 0x2, 0x34,
0xa, 0x29, 0x78, 0xa, 0x91, 0x63,
0xf0, 0xbe, 0x92, 0xed, 0x2d, 0xba,
0xca, 0x2a, 0x3c, 0x7c, 0x60, 0x7f,
0x2b, 0x4b, 0x5e, 0x7b, 0xe5, 0x6f,
0xbe, 0xed, 0xad, 0x6f, 0x7a, 0xeb,
0x55, 0x6f, 0x7a, 0xff, 0xfb, 0xde,
0xfd, 0x8e, 0xdf, 0xb9, 0xea, 0xf7,
0xff, 0xfd, 0xef, 0xfd, 0xc1, 0xbb,
0xdf, 0xf5, 0x1f, 0xde, 0xf3, 0xae,
0x77, 0xbd, 0xeb, 0x9d, 0x6f, 0x7b,
0xdb, 0x5b, 0x2f, 0xb9, 0x78, 0xf,
0x85, 0x58, 0x15, 0xa5, 0xaf, 0x9c,
0x10, 0xc5, 0x9c, 0x13, 0xe7, 0xf,
0xe, 0x81, 0xea, 0xd6, 0x3c, 0x51,
0x53, 0xfd, 0x35, 0xc7, 0x14, 0x81,
0x79, 0xa4, 0x2f, 0x11, 0x95, 0x52,
0xc2, 0xdd, 0xf5, 0xde, 0x67, 0x59,
0x16, 0x42, 0x78, 0xfc, 0xf1, 0xc7,
0x27, 0x27, 0xbb, 0x57, 0x5e, 0x79,
0x25, 0x0, 0x7d, 0xf7, 0xbb, 0xb7,
0x8b, 0x8, 0xd6, 0x45, 0x17, 0x5d,
0xd4, 0xe9, 0x74, 0xbe, 0xf3, 0x9d,
0xef, 0x88, 0xe6, 0x58, 0xf0, 0xa5,
0xf7, 0xbe, 0xd3, 0xe9, 0x94, 0x65,
0xd9, 0xef, 0xf7, 0x27, 0xa6, 0xa7,
0x0, 0x80, 0x7c, 0x64, 0x58, 0x2d,
0x52, 0x71, 0x1c, 0xd1, 0x8f, 0x46,
0xf6, 0x4f, 0x4, 0x7, 0x95, 0xaa,
0x35, 0xd0, 0xf2, 0x3c, 0xdf, 0xb3,
0x67, 0x8f, 0x68, 0x32, 0xa0, 0xb1,
0x87, 0xf, 0x1f, 0x7e, 0xe4, 0x91,
0x47, 0x0, 0x20, 0x78, 0xdf, 0x6a,
0xb5, 0xf2, 0x3c, 0x97, 0xdc, 0x60,
0xd0, 0xaf, 0x26, 0x26, 0x26, 0xbc,
0xf, 0x47, 0x8e, 0x1c, 0x69, 0x2e,
0x67, 0x94, 0x9a, 0xd6, 0x15, 0x69,
0x2d, 0xdf, 0x75, 0x8d, 0xc4, 0x70,
0xce, 0x75, 0xbb, 0xdd, 0xf3, 0xce,
0x3b, 0xef, 0x2d, 0x6f, 0x79, 0xcb,
0x87, 0xfe, 0xec, 0xbf, 0x7d, 0xf9,
0xcb, 0x5f, 0xfe, 0xcd, 0xdf, 0xfc,
0xcd, 0xac, 0xd5, 0xfa, 0xe2, 0x17,
0xbf, 0x8, 0x0, 0x4f, 0x3d, 0xf5,
0xd4, 0xcb, 0x5f, 0xfe, 0xf2, 0xb7,
0xbc, 0xe5, 0x2d, 0x9b, 0x36, 0x6d,
0x98, 0x5f, 0x9c, 0xef, 0xf7, 0xfb,
0xad, 0xf6, 0x64, 0x3b, 0xcf, 0x99,
0x79, 0x30, 0x18, 0x68, 0x9b, 0xd7,
0x60, 0xa1, 0x15, 0x89, 0x7d, 0xad,
0xef, 0xa1, 0x94, 0x71, 0xae, 0x4a,
0x4c, 0x2, 0x0, 0xdf, 0xff, 0xfe,
0xf, 0x6e, 0xb8, 0xe1, 0x86, 0x7f,
0xfe, 0xfe, 0xf, 0xce, 0xbf, 0xe0,
0xbc, 0x8b, 0x2f, 0xb8, 0x70, 0x7e,
0x7e, 0xfe, 0x7, 0x3f, 0xb8, 0x13,
0x0, 0x6e, 0xbb, 0xed, 0xb6, 0x4d,
0x9b, 0xb6, 0xbc, 0xeb, 0x5d, 0xef,
0xdc, 0xb5, 0x6b, 0x57, 0x8c, 0x9e,
0xa8, 0x36, 0x88, 0x6d, 0x44, 0x3c,
0xd6, 0xc5, 0xe2, 0x95, 0xe5, 0xb0,
0x18, 0xa6, 0x69, 0x2a, 0xcd, 0xb9,
0x67, 0x3c, 0xe3, 0x19, 0x53, 0x53,
0x53, 0x3f, 0x79, 0xe0, 0x81, 0xa7,
0x9e, 0x7a, 0x6a, 0xd7, 0xae, 0x5d,
0x21, 0x84, 0x83, 0x7, 0xf, 0x2,
0xc0, 0x3d, 0xf7, 0xdc, 0xe3, 0x9c,
0xdb, 0xb3, 0x67, 0xcf, 0xae, 0x5d,
0xbb, 0x4a, 0x57, 0x20, 0x22, 0xe3,
0xda, 0xd2, 0x1c, 0x23, 0xb8, 0x90,
0xe8, 0xab, 0xb1, 0x5c, 0x2, 0x90,
0x11, 0x34, 0x65, 0xbb, 0xdd, 0xd6,
0x5a, 0x1f, 0x3e, 0x7c, 0x58, 0x8e,
0x95, 0x24, 0x89, 0xc8, 0xa6, 0x3e,
0xf4, 0xd0, 0x43, 0xdf, 0xfb, 0xde,
0xf7, 0x9e, 0x7e, 0xfa, 0xe9, 0x73,
0xcf, 0x3d, 0xf7, 0x92, 0x4b, 0x2e,
0x19, 0x8e, 0xa0, 0x3e, 0xc7, 0xd6,
0xb7, 0xc6, 0x2f, 0x61, 0xd9, 0xcd,
0x27, 0x46, 0x6b, 0x75, 0x51, 0x14,
0xa2, 0x4a, 0x39, 0x39, 0x39, 0x39,
0x37, 0x37, 0x77, 0xf0, 0xc0, 0xa1,
0x5b, 0x6f, 0xbd, 0xf5, 0xda, 0x6b,
0xaf, 0x15, 0x78, 0xc6, 0x8e, 0x1d,
0x3b, 0x7a, 0xbd, 0x9e, 0x48, 0xe7,
0x2d, 0xf5, 0x96, 0xd0, 0xe8, 0xd5,
0x9a, 0x27, 0xc0, 0x63, 0xf7, 0x7f,
0x99, 0x40, 0x2a, 0xe1, 0x74, 0x2b,
0xcb, 0x4a, 0x6b, 0x27, 0x26, 0x26,
0x6, 0x83, 0xc1, 0xa0, 0x3f, 0x7c,
0xfc, 0xf1, 0xc7, 0x7f, 0xf1, 0x8b,
0x5f, 0x5c, 0x7a, 0xe9, 0xa5, 0xe2,
0x8d, 0xf4, 0xf3, 0x9f, 0xff, 0xfc,
0xce, 0x3b, 0xef, 0x5c, 0x5a, 0xec,
0xa1, 0x82, 0x18, 0x63, 0xa7, 0xd3,
0x29, 0xab, 0xb2, 0xbe, 0x5, 0xab,
0xee, 0x8f, 0x4, 0xbe, 0xc7, 0x28,
0xa5, 0xc8, 0x4e, 0x2e, 0xe9, 0xab,
0xf7, 0x5e, 0x84, 0x3e, 0x9b, 0x9a,
0x5c, 0xab, 0xdd, 0x7e, 0x7a, 0xff,
0x93, 0xa7, 0x9f, 0x7e, 0xfa, 0xa5,
0x97, 0x5e, 0x32, 0x3b, 0x3b, 0x9b,
0x65, 0xa9, 0xd6, 0x30, 0x1c, 0x56,
0xed, 0x76, 0xc6, 0x9c, 0x79, 0x1f,
0x87, 0xc3, 0x22, 0x6b, 0xe5, 0x5b,
0xb7, 0xce, 0x76, 0xbb, 0x93, 0x4f,
0x3c, 0xf1, 0xc4, 0x23, 0x8f, 0x3c,
0xa2, 0x94, 0xe2, 0x28, 0x7b, 0x1e,
0x2c, 0xc3, 0x8d, 0x8f, 0x21, 0xae,
0x9a, 0x6, 0x17, 0xc6, 0x1c, 0x89,
0x82, 0x44, 0xbc, 0x44, 0xa, 0x0,
0xa2, 0x77, 0x13, 0x13, 0x13, 0xa2,
0xa6, 0xb7, 0xb8, 0x38, 0xbf, 0x75,
0xeb, 0xd6, 0xd7, 0xbd, 0xee, 0x35,
0x93, 0x93, 0x93, 0x5f, 0xfa, 0xd2,
0x97, 0x44, 0xb, 0x8a, 0x99, 0xbf,
0xf7, 0xbd, 0xef, 0x19, 0x63, 0xce,
0x3d, 0xf7, 0xdc, 0x3f, 0xfc, 0xc3,
0x3f, 0xfc, 0xe7, 0xef, 0xdf, 0x71,
0xff, 0xfd, 0xf7, 0x33, 0xf3, 0xc6,
0x8d, 0x1b, 0x45, 0x48, 0x61, 0x62,
0x62, 0x62, 0xb0, 0xd4, 0x3, 0x0,
0x9d, 0xa4, 0x4, 0x2c, 0x4d, 0x9a,
0x86, 0x98, 0xbe, 0x3e, 0x56, 0x84,
0x14, 0xb0, 0x42, 0x68, 0x44, 0x0,
0x11, 0xb5, 0xf, 0xa1, 0xaa, 0x8a,
0x97, 0xbf, 0xfc, 0x95, 0x2f, 0x79,
0xc9, 0xcb, 0x24, 0xa1, 0xff, 0xbb,
0xff, 0x79, 0xf3, 0x47, 0x3e, 0xf2,
0x11, 0xc1, 0x6f, 0xfe, 0xc1, 0x7b,
0xde, 0xfb, 0x47, 0xef, 0x7f, 0x9f,
0x58, 0x4b, 0xe6, 0x79, 0x3e, 0xe8,
0x57, 0x83, 0xc1, 0x80, 0x47, 0xe,
0xeb, 0x52, 0x7c, 0xe3, 0x3a, 0xc5,
0x1e, 0x9, 0x6, 0x1, 0x79, 0xef,
0xcb, 0xb2, 0x24, 0x22, 0xa3, 0x51,
0x6b, 0x3d, 0xf4, 0x7e, 0x71, 0x71,
0xf1, 0xea, 0xab, 0xaf, 0xbe, 0xfc,
0xf2, 0xcb, 0xdf, 0xfb, 0xde, 0xf7,
0x5d, 0x72, 0xc9, 0x25, 0x13, 0x53,
0x53, 0x82, 0x37, 0xfa, 0xd3, 0x3f,
0xfd, 0xd3, 0x2b, 0xaf, 0xfc, 0x4d,
0x6b, 0xcd, 0xe2, 0xe2, 0xa2, 0xb5,
0xe9, 0xd4, 0xd4, 0xd4, 0x60, 0xe8,
0x86, 0x65, 0x29, 0x1b, 0x14, 0xa8,
0x4, 0x71, 0x15, 0xee, 0x12, 0x98,
0x23, 0xa2, 0x62, 0xc2, 0xe1, 0x70,
0x28, 0x78, 0x83, 0xa7, 0x9f, 0x3a,
0xf0, 0xfe, 0xf7, 0xbf, 0xff, 0xe1,
0x87, 0x1f, 0xfe, 0x1f, 0x9f, 0xfc,
0xc4, 0x8b, 0x5f, 0xfc, 0x62, 0xf2,
0x34, 0x39, 0x39, 0x29, 0x37, 0xea,
0x81, 0x7, 0x1e, 0x38, 0x70, 0xe0,
0xd0, 0x60, 0x30, 0x68, 0x0, 0x37,
0x42, 0x2d, 0x90, 0xe6, 0x90, 0x73,
0x8e, 0xcd, 0xb2, 0xae, 0x88, 0x92,
0xfc, 0x2c, 0x86, 0x26, 0xc3, 0x17,
0x25, 0xc7, 0xd9, 0x99, 0xd9, 0x73,
0xce, 0x39, 0xe7, 0x1d, 0xef, 0x78,
0xc7, 0x47, 0x3f, 0xfa, 0xd1, 0x4f,
0x7e, 0xf2, 0x93, 0x5b, 0xb6, 0x6c,
0xd9, 0xb0, 0x61, 0xc3, 0xdf, 0xff,
0xfd, 0xdf, 0x3, 0xc0, 0x63, 0x8f,
0x3d, 0xf6, 0xda, 0xd7, 0xbe, 0xf6,
0x8d, 0x6f, 0x7c, 0xe3, 0x91, 0x23,
0x47, 0xda, 0x5d, 0xf1, 0x9a, 0x88,
0x8d, 0xea, 0x25, 0x11, 0x29, 0x55,
0xc3, 0xd4, 0x41, 0x5c, 0x3, 0x6a,
0x85, 0x4d, 0x16, 0x3c, 0x89, 0xab,
0x3c, 0x33, 0x87, 0xe0, 0xad, 0x4d,
0xb5, 0xb6, 0x31, 0x72, 0x96, 0xe7,
0xef, 0x79, 0xcf, 0x7f, 0x78, 0xc1,
0xb, 0x5e, 0x20, 0x27, 0xfc, 0xc3,
0x1f, 0xfe, 0xf0, 0xaa, 0xab, 0xae,
0x12, 0x9, 0xf8, 0x10, 0x24, 0x6e,
0xa, 0xb2, 0x75, 0xcb, 0x7b, 0x50,
0xa1, 0x51, 0x6b, 0x92, 0xea, 0x6b,
0xc, 0x61, 0x59, 0x9, 0x14, 0x8d,
0x73, 0x41, 0x29, 0xd3, 0xef, 0xf,
0x97, 0x96, 0xfa, 0xd6, 0xa6, 0x79,
0xde, 0xde, 0xb0, 0xa1, 0x7d, 0xcb,
0x2d, 0xb7, 0xde, 0x75, 0xd7, 0x3d,
0x0, 0xf0, 0xa9, 0x4f, 0x7d, 0xaa,
0xdb, 0xed, 0x2a, 0x65, 0xbc, 0x1f,
0x1a, 0x93, 0x28, 0x65, 0x42, 0xc,
0x72, 0xee, 0xcb, 0xfb, 0x1, 0xd3,
0x38, 0xad, 0x57, 0xf4, 0x15, 0x9a,
0x12, 0x6e, 0x7f, 0xd0, 0x7, 0x50,
0x87, 0xf, 0x1f, 0xcd, 0xb2, 0xd6,
0xc6, 0x8d, 0x9b, 0xf, 0x1d, 0x3a,
0x74, 0xc3, 0xd, 0xff, 0xf7, 0xd6,
0xad, 0xdb, 0x4f, 0x3e, 0xf9, 0x64,
0x0, 0xf8, 0xcc, 0x67, 0x3e, 0xfb,
0xe4, 0x93, 0x4f, 0x3f, 0xf3, 0x59,
0xcf, 0xfa, 0xc9, 0x4f, 0x7e, 0x32,
0x1c, 0x96, 0x0, 0xd2, 0xe3, 0x4,
0x51, 0x29, 0x19, 0xf1, 0x1c, 0x91,
0x8, 0x99, 0x19, 0x5, 0x5f, 0x30,
0x92, 0x37, 0x6a, 0xa, 0x7e, 0xd2,
0x86, 0xf4, 0x3e, 0x10, 0x71, 0xa2,
0x95, 0xaf, 0x5c, 0xc3, 0x37, 0x9e,
0xd8, 0x38, 0xfb, 0xe2, 0x97, 0x5c,
0x75, 0xf2, 0x49, 0x3b, 0xe6, 0xe6,
0x97, 0x8c, 0x86, 0xde, 0xd2, 0xdc,
0x2d, 0xb7, 0xdc, 0xf2, 0xc0, 0x3,
0xf, 0x9c, 0x77, 0xde, 0x5, 0xdd,
0xee, 0xe4, 0x8f, 0xee, 0xba, 0x6b,
0x30, 0x18, 0xbc, 0xf1, 0x8d, 0x6f,
0xba, 0xe4, 0x92, 0x4b, 0x14, 0x90,
0x2, 0x2a, 0x7, 0x43, 0x49, 0x5e,
0xc0, 0x41, 0x8, 0xa4, 0xb5, 0x36,
0xda, 0x72, 0xe0, 0x46, 0x6c, 0xa3,
0x49, 0x86, 0x4d, 0xa3, 0x39, 0x3c,
0x7e, 0xb5, 0x7a, 0x24, 0x7f, 0x21,
0xa4, 0x96, 0x34, 0x4d, 0x5f, 0xf4,
0xa2, 0x17, 0x9d, 0x7f, 0xfe, 0xb3,
0xf6, 0x1f, 0x38, 0x70, 0xf0, 0xe0,
0xc1, 0x67, 0x3e, 0xf3, 0x99, 0xbf,
0x7a, 0xec, 0xf1, 0x27, 0x9e, 0x78,
0x42, 0xb2, 0xe2, 0xe7, 0x3c, 0xff,
0x92, 0xa5, 0xa5, 0xfe, 0x91, 0x43,
0x47, 0x5f, 0xfe, 0xb2, 0x97, 0x5c,
0xb2, 0x67, 0xcf, 0xed, 0xb7, 0xdf,
0xfe, 0xd0, 0x43, 0xf, 0x4d, 0x74,
0xa7, 0x8c, 0x31, 0xb, 0x73, 0x8b,
0x59, 0xab, 0xae, 0x72, 0x33, 0x8e,
0x6e, 0xee, 0x58, 0x16, 0xbe, 0xce,
0x1c, 0x26, 0x66, 0x71, 0x18, 0xc4,
0x71, 0x39, 0x4f, 0xe7, 0x2, 0x22,
0xe7, 0x79, 0x7e, 0xfb, 0xed, 0xb7,
0x5f, 0x7f, 0xfd, 0xf5, 0xf7, 0x3d,
0xf0, 0xe3, 0x2b, 0xae, 0xb8, 0xe2,
0x83, 0x7f, 0xfa, 0x21, 0x0, 0xd8,
0xba, 0x75, 0x2b, 0x47, 0x7f, 0xf4,
0xe8, 0xd1, 0xad, 0x3b, 0xb6, 0xf7,
0x7a, 0xbd, 0x56, 0xab, 0x15, 0x42,
0xe8, 0xf5, 0x87, 0x53, 0x53, 0x53,
0x8f, 0xfd, 0xea, 0xc9, 0xc6, 0xf7,
0x64, 0x7c, 0x2, 0x2b, 0x64, 0x61,
0x9f, 0x1b, 0x63, 0x98, 0xc2, 0x68,
0xa5, 0x40, 0xef, 0xfd, 0xd9, 0x67,
0x9f, 0xfd, 0xfa, 0xd7, 0xbf, 0xfe,
0xba, 0xeb, 0xae, 0xeb, 0x3f, 0xfd,
0xf4, 0x6b, 0x5e, 0xf3, 0x1a, 0x0,
0x78, 0xc1, 0xb, 0x5e, 0xd0, 0x6a,
0xb5, 0x8e, 0xce, 0x1d, 0xde, 0xb9,
0x73, 0x87, 0x70, 0xfd, 0xf2, 0xbc,
0x25, 0x8, 0x8a, 0x3c, 0xcf, 0x9d,
0xc0, 0xc2, 0xd5, 0xaa, 0xd6, 0x1a,
0x8d, 0xd8, 0x57, 0xda, 0x18, 0xe3,
0xbd, 0x7b, 0xec, 0xb1, 0xc7, 0xe,
0x1c, 0x38, 0x30, 0x35, 0x35, 0x75,
0xfa, 0xe9, 0xa7, 0xb7, 0x5a, 0xad,
0xc1, 0xd2, 0x60, 0x7e, 0x7e, 0xbe,
0xd5, 0xea, 0x0, 0xc0, 0xf9, 0xe7,
0x5f, 0x28, 0x3c, 0x8d, 0xc5, 0xc5,
0xc5, 0x56, 0x2b, 0xb3, 0x36, 0xf5,
0xbe, 0xf4, 0x81, 0xc7, 0xfb, 0xae,
0x63, 0xfe, 0x66, 0x30, 0xde, 0x68,
0x91, 0x42, 0x60, 0x9e, 0xe7, 0xc3,
0x62, 0x38, 0x3f, 0x3f, 0xff, 0xd6,
0xb7, 0xbe, 0xf5, 0xc9, 0x27, 0x9f,
0xfc, 0xcc, 0x4d, 0x37, 0x9d, 0x71,
0xc6, 0x19, 0x97, 0x5f, 0x7e, 0xf9,
0x27, 0x3e, 0xf1, 0x9, 0x0, 0x38,
0xeb, 0xac, 0xb3, 0xde, 0xf9, 0xce,
0x77, 0xa, 0xd0, 0xbf, 0xd1, 0xc7,
0x6b, 0xc4, 0x6e, 0x9a, 0x66, 0x23,
0x8d, 0x8a, 0x46, 0xf5, 0x1, 0xa1,
0xe6, 0xeb, 0xc8, 0xb2, 0x28, 0x7,
0x15, 0xad, 0x92, 0xc5, 0x85, 0x85,
0x1b, 0x6e, 0xb8, 0xe1, 0xe6, 0x9b,
0x6f, 0x96, 0xa3, 0x1f, 0x3e, 0x7c,
0xb8, 0xdd, 0x6e, 0x9f, 0x7d, 0xf6,
0xd9, 0x87, 0xf, 0xff, 0x7f, 0xbd,
0x7d, 0x7b, 0xb4, 0x5d, 0x55, 0x79,
0xef, 0x37, 0x1f, 0xeb, 0xb1, 0xdf,
0xe7, 0x99, 0x9c, 0x93, 0x7, 0x49,
0x80, 0x4, 0x12, 0xa0, 0x4a, 0x4,
0x41, 0x12, 0x24, 0x80, 0x58, 0x1a,
0xaf, 0x58, 0x15, 0x8c, 0x14, 0x95,
0x6a, 0x91, 0x3b, 0xfa, 0x18, 0xb7,
0xd7, 0xd6, 0xeb, 0xd5, 0x81, 0xd7,
0x81, 0x62, 0x5b, 0x5a, 0x70, 0xd8,
0xa1, 0x15, 0xbc, 0xbd, 0xe, 0xb0,
0x5a, 0xad, 0x20, 0xf4, 0x1a, 0x15,
0x10, 0x14, 0x51, 0x4a, 0xbd, 0x2,
0x42, 0x93, 0xd0, 0xc4, 0x80, 0xa,
0x81, 0x93, 0x73, 0x92, 0xf3, 0xde,
0xcf, 0xf5, 0x98, 0x6b, 0x3e, 0xee,
0x1f, 0xdf, 0xda, 0x6b, 0xaf, 0xfd,
0x3a, 0x39, 0x27, 0xd0, 0xee, 0x91,
0xb1, 0xc7, 0xc9, 0x7e, 0xad, 0xb5,
0xe6, 0x9a, 0xdf, 0x9c, 0xdf, 0xe3,
0xf7, 0xfd, 0x7e, 0xb3, 0x96, 0x65,
0x99, 0xa6, 0xc2, 0x98, 0x6e, 0x7f,
0x24, 0x45, 0x11, 0x4c, 0xe7, 0x22,
0x80, 0x89, 0x52, 0xca, 0x29, 0x11,
0x11, 0xca, 0x41, 0x9a, 0x5c, 0x2e,
0x87, 0x9, 0xd4, 0x9b, 0x6e, 0xba,
0x69, 0xc3, 0x86, 0xd, 0x37, 0xde,
0x78, 0x23, 0x0, 0xbc, 0xfb, 0xdd,
0xef, 0xbe, 0xf9, 0xe6, 0x9b, 0x19,
0x63, 0xd8, 0x8b, 0x6e, 0x59, 0x96,
0x14, 0x32, 0xbd, 0x1, 0xe2, 0x6e,
0xd9, 0xd2, 0xe6, 0x24, 0x6d, 0x62,
0xd7, 0xc6, 0x18, 0xc6, 0x39, 0x12,
0x6, 0x9, 0x21, 0xde, 0xf9, 0xce,
0x77, 0xe6, 0x72, 0xb9, 0x4f, 0xdf,
0x7c, 0xf3, 0xde, 0xbd, 0x7b, 0x37,
0x6e, 0xdc, 0x8, 0x0, 0x8f, 0x3c,
0xf2, 0xc8, 0x7b, 0xde, 0xf3, 0x9e,
0x6d, 0xdb, 0xb6, 0xfd, 0xd9, 0x47,
0x3e, 0x92, 0x69, 0x3a, 0x56, 0x69,
0xa3, 0x68, 0x7a, 0x8b, 0xac, 0x35,
0xf2, 0xed, 0x4e, 0x84, 0xd6, 0x9a,
0xa2, 0x86, 0x8f, 0x34, 0x60, 0x40,
0x29, 0xa3, 0x94, 0x29, 0x14, 0xa,
0xa7, 0x9d, 0x76, 0x1a, 0x0, 0x5c,
0x76, 0xe9, 0x25, 0x94, 0xc2, 0xf4,
0xcc, 0x7c, 0x26, 0xe3, 0x34, 0x1a,
0xd, 0xc6, 0xc8, 0x87, 0xfe, 0xe0,
0xf7, 0x7f, 0xfe, 0xf3, 0x9f, 0x7f,
0xfb, 0xde, 0xfb, 0x9, 0x21, 0xc3,
0xc3, 0xa3, 0xbf, 0x77, 0xed, 0x9e,
0xf3, 0xde, 0xb0, 0x3d, 0x14, 0x4a,
0x4, 0xbe, 0x96, 0x51, 0x24, 0xca,
0xfd, 0x9f, 0x94, 0x0, 0x0, 0x20,
0x0, 0x49, 0x44, 0x41, 0x54, 0x43,
0x63, 0xb2, 0xd4, 0x50, 0x50, 0x60,
0xa4, 0x26, 0x84, 0xa1, 0x42, 0xd,
0x49, 0xb1, 0x8b, 0xc7, 0x6, 0x8c,
0x3d, 0xf7, 0x58, 0x38, 0x96, 0x52,
0x62, 0xef, 0xe, 0x92, 0x4c, 0x58,
0x8c, 0x21, 0x9d, 0x42, 0x2e, 0x97,
0x7b, 0xe1, 0x85, 0x17, 0x90, 0x27,
0x85, 0x31, 0x76, 0xe1, 0x85, 0x6f,
0xb4, 0x2c, 0x6b, 0xea, 0xf8, 0x31,
0x2f, 0xf0, 0xc7, 0xc7, 0xd6, 0x6e,
0xdd, 0x76, 0xf6, 0xe4, 0xe4, 0xe4,
0xf4, 0xf4, 0xf4, 0xc4, 0xd1, 0xa3,
0xb, 0xb, 0xb, 0xb3, 0xb3, 0xf3,
0x8e, 0x9b, 0xd, 0x44, 0xc8, 0xb5,
0xb2, 0x5d, 0x27, 0x86, 0x6a, 0x6a,
0xc5, 0xed, 0x98, 0x2f, 0x26, 0x21,
0xcb, 0xed, 0xae, 0x24, 0x35, 0xa3,
0x3b, 0xaa, 0x22, 0xc9, 0x98, 0x85,
0xe8, 0x53, 0x4a, 0x48, 0xb3, 0x81,
0x89, 0x13, 0x62, 0x26, 0x26, 0x26,
0xfe, 0xe6, 0x6f, 0xfe, 0xe6, 0xc9,
0x9f, 0x3f, 0xf5, 0x8e, 0x77, 0xbd,
0xeb, 0x53, 0x9f, 0xfa, 0xd4, 0xd8,
0xd8, 0x18, 0x7a, 0x92, 0x19, 0xc7,
0x4a, 0x2, 0xf8, 0x72, 0xad, 0xbc,
0x6a, 0xd5, 0x2a, 0xa5, 0xc1, 0xf3,
0xbc, 0x74, 0x51, 0xda, 0x98, 0x36,
0x6, 0x43, 0xac, 0x6d, 0xa, 0x21,
0x6c, 0x8b, 0x21, 0x7e, 0x6b, 0x78,
0x78, 0x38, 0xc, 0xfd, 0x27, 0x9f,
0x7c, 0xf2, 0x4b, 0x5f, 0xfa, 0x92,
0xe3, 0x38, 0x19, 0xce, 0xff, 0xf9,
0xdb, 0xdf, 0x6, 0x80, 0xb, 0x2e,
0x78, 0xd3, 0xb5, 0xd7, 0xee, 0xc9,
0xe5, 0x72, 0x8b, 0x8b, 0x8b, 0x85,
0x42, 0x9, 0xfb, 0xa8, 0x8a, 0xf9,
0x7c, 0x4c, 0x74, 0x48, 0x6d, 0x94,
0x4d, 0x4d, 0xf0, 0x4c, 0x5a, 0x6b,
0x64, 0xa2, 0x8e, 0xa2, 0xc8, 0x18,
0x27, 0xc, 0x43, 0x4e, 0xc9, 0x9a,
0x35, 0x6b, 0x8a, 0xc5, 0xe2, 0xd4,
0xd4, 0xd4, 0xf4, 0xf4, 0xec, 0xeb,
0x5e, 0x77, 0x6e, 0x45, 0x56, 0x12,
0x96, 0xb9, 0x7f, 0xfd, 0xd7, 0x7f,
0xfd, 0xe9, 0x4f, 0x7f, 0xfa, 0xae,
0x77, 0xfd, 0xee, 0x5, 0x17, 0x5c,
0x20, 0xa5, 0xd0, 0x10, 0x61, 0x10,
0xda, 0xcc, 0x55, 0x48, 0x6a, 0x59,
0x69, 0xf9, 0x76, 0x24, 0x82, 0xc3,
0x19, 0x8f, 0xd4, 0x2d, 0x8, 0xee,
0x77, 0x5d, 0x17, 0xb4, 0xbe, 0xe8,
0xa2, 0x8b, 0xee, 0xbe, 0xeb, 0xae,
0x5f, 0xfc, 0xe2, 0x17, 0x33, 0x33,
0x33, 0xf3, 0x73, 0x73, 0x0, 0xf0,
0x9e, 0xf7, 0xbc, 0x67, 0xc3, 0x86,
0xd, 0x48, 0x5a, 0xd4, 0x9c, 0x1,
0x4, 0xd7, 0x53, 0x74, 0x5b, 0x98,
0x15, 0x53, 0x73, 0xe9, 0x26, 0xf6,
0x50, 0x6b, 0x6d, 0xd9, 0x16, 0x76,
0x2f, 0x65, 0xb3, 0xd9, 0x6a, 0xb5,
0x8a, 0x9d, 0x52, 0x78, 0xed, 0x85,
0x62, 0xf1, 0xb6, 0xdb, 0x6e, 0xdb,
0x75, 0xc9, 0xae, 0x48, 0x46, 0x0,
0xb0, 0xb0, 0xb0, 0xf0, 0xb1, 0x8f,
0x7d, 0xec, 0xeb, 0x5f, 0xfb, 0xda,
0xda, 0xb5, 0x6b, 0x2f, 0xbe, 0xf8,
0x62, 0x2c, 0xba, 0x20, 0x2c, 0x17,
0x41, 0x41, 0xc9, 0x42, 0x93, 0x44,
0xd7, 0xc9, 0x4a, 0xa7, 0x94, 0xa2,
0xdc, 0xe, 0x82, 0x20, 0x9b, 0xcd,
0x96, 0x4a, 0xa5, 0xc9, 0xc9, 0xc9,
0x30, 0xc, 0xa3, 0x28, 0xa, 0xc3,
0xf0, 0xbc, 0xf3, 0xce, 0xbb, 0xe1,
0x86, 0x1b, 0x0, 0xe0, 0x73, 0x9f,
0xfb, 0xdc, 0x1d, 0x77, 0xdc, 0x31,
0x33, 0x33, 0x53, 0x28, 0x14, 0x90,
0x7, 0x43, 0x37, 0xbb, 0xaf, 0x93,
0xe, 0x41, 0x5c, 0xb, 0x70, 0xc5,
0x34, 0x10, 0xbb, 0xf, 0xc9, 0x88,
0xe1, 0x26, 0x99, 0xc9, 0x64, 0x1c,
0xc7, 0xd1, 0x5a, 0x6f, 0xdf, 0xbe,
0x7d, 0xd3, 0xa9, 0xa7, 0x7e, 0xf5,
0xab, 0x5f, 0xdd, 0xb6, 0x6d, 0x1b,
0x7e, 0x77, 0xd7, 0xae, 0x5d, 0x95,
0x4a, 0x85, 0x5b, 0x96, 0x52, 0xca,
0xf3, 0xbc, 0xf1, 0xf1, 0xf1, 0xb9,
0x85, 0x6a, 0x7a, 0x75, 0x23, 0x84,
0x10, 0xc6, 0xd3, 0xd0, 0x7d, 0xb4,
0x1a, 0x84, 0x30, 0x22, 0xfd, 0xad,
0x14, 0x11, 0xa1, 0x4, 0x91, 0x36,
0x84, 0x10, 0xcf, 0xf3, 0x9e, 0x7b,
0xee, 0x39, 0x0, 0x18, 0x19, 0x1d,
0xda, 0xb4, 0x69, 0xc3, 0xe0, 0xe0,
0xa0, 0xef, 0x37, 0x1c, 0xc7, 0x89,
0xa2, 0xf0, 0x7, 0x3f, 0xf8, 0xc1,
0x83, 0xf, 0x3e, 0xc8, 0x99, 0x3d,
0x3e, 0x3e, 0x7e, 0xf8, 0xf0, 0xb,
0xf, 0x3c, 0xf0, 0x0, 0x63, 0xd6,
0xe9, 0xa7, 0x9f, 0x8e, 0x4e, 0x56,
0x13, 0x29, 0x9, 0x89, 0x48, 0x3d,
0xe6, 0x14, 0xf0, 0x8a, 0x94, 0x52,
0x8c, 0xc5, 0x55, 0x62, 0xde, 0xc4,
0x91, 0x62, 0x1, 0x93, 0x20, 0x49,
0x3c, 0x16, 0x75, 0x94, 0x8a, 0xa5,
0xe8, 0x85, 0x90, 0x47, 0x8f, 0x4e,
0xbd, 0xfc, 0xf2, 0x4, 0x9e, 0xfd,
0xda, 0xb5, 0xeb, 0x6b, 0xd, 0xff,
0xe8, 0xd4, 0x71, 0xc7, 0x71, 0x86,
0x95, 0xf4, 0xc2, 0xe0, 0xdf, 0xe,
0xec, 0x3f, 0x70, 0xe0, 0x80, 0xe3,
0x64, 0xe2, 0x8e, 0x39, 0x46, 0x8d,
0xd6, 0x41, 0x24, 0x5a, 0x57, 0xcb,
0x28, 0xd5, 0xac, 0x43, 0x19, 0xb1,
0x9b, 0x92, 0x2f, 0xd5, 0xff, 0x40,
0xc1, 0xd0, 0x4, 0x20, 0xad, 0x94,
0xd4, 0x46, 0x49, 0x29, 0x6f, 0xbd,
0xf5, 0xd6, 0xbf, 0xff, 0xfb, 0xbf,
0x97, 0x51, 0x74, 0xf1, 0x9b, 0xdf,
0x7c, 0xd6, 0x59, 0x67, 0x7d, 0xfd,
0xeb, 0x5f, 0xc7, 0x2d, 0x5c, 0x4a,
0x61, 0x31, 0xf2, 0xe1, 0xf, 0x7f,
0x18, 0xa9, 0x6a, 0xf2, 0xf9, 0xfc,
0xe2, 0xe2, 0xa2, 0xe3, 0x66, 0xa1,
0xa5, 0xa4, 0xaa, 0x91, 0xc9, 0x20,
0x59, 0x35, 0x28, 0xa3, 0x58, 0x42,
0xc3, 0xd2, 0x77, 0xc2, 0x5, 0xff,
0xa5, 0x2f, 0x7d, 0xe9, 0xf6, 0xdb,
0x3e, 0xf7, 0x5f, 0xde, 0xfe, 0xf6,
0x2f, 0x7e, 0xf1, 0x8b, 0x61, 0x14,
0xdd, 0x74, 0xd3, 0x4d, 0x0, 0xf0,
0x3f, 0x3f, 0xfa, 0xd1, 0x1f, 0xfd,
0xe8, 0x91, 0x9b, 0x3f, 0xfd, 0xa9,
0x33, 0xcf, 0xdc, 0x82, 0x94, 0x82,
0x4a, 0x11, 0x2f, 0x8, 0x12, 0xb8,
0x8c, 0xd6, 0xda, 0x10, 0x48, 0x1b,
0x30, 0x1a, 0x9, 0xa5, 0x54, 0x46,
0x9a, 0x32, 0x88, 0x22, 0xbd, 0x61,
0xc3, 0x86, 0x4f, 0xdf, 0x7c, 0xcb,
0xe7, 0x3e, 0xf7, 0xb9, 0x3d, 0x7b,
0xf6, 0xec, 0xd9, 0xb3, 0xe7, 0xca,
0x2b, 0xae, 0x6c, 0x34, 0x1a, 0xdf,
0xfa, 0xd6, 0xb7, 0x0, 0xe0, 0x5f,
0x1e, 0x7f, 0xfc, 0x8a, 0x2b, 0xae,
0x5c, 0xb5, 0x6a, 0x2c, 0x5e, 0x5c,
0xb5, 0x46, 0xf7, 0x16, 0x9a, 0xf2,
0xed, 0x6d, 0x88, 0x1a, 0xd3, 0x36,
0x7a, 0x8c, 0x31, 0x21, 0x4, 0xd6,
0xe4, 0x84, 0x10, 0xc5, 0x7c, 0xfe,
0x92, 0x4b, 0x2e, 0xf9, 0x9d, 0xdd,
0xbb, 0x1f, 0x7a, 0xf0, 0x41, 0x0,
0x58, 0x3d, 0x36, 0x6, 0x0, 0xd7,
0x5c, 0x73, 0x4d, 0x26, 0x93, 0x9,
0xfd, 0xc0, 0xf7, 0x7d, 0xdb, 0xb5,
0x10, 0x3e, 0x9c, 0xde, 0x1b, 0x95,
0x52, 0xb8, 0x85, 0x69, 0xd3, 0xa2,
0x25, 0xc5, 0xd7, 0xb3, 0xd9, 0x7c,
0x65, 0x61, 0xde, 0xe2, 0x4e, 0x24,
0xa4, 0xd1, 0x4, 0xc, 0x55, 0xd2,
0xd4, 0x2a, 0xf5, 0xbd, 0xdf, 0xf9,
0xde, 0x13, 0xff, 0xf2, 0x33, 0x8c,
0x21, 0xa7, 0xa7, 0xa7, 0xff, 0xf9,
0xfe, 0xef, 0x0, 0xb0, 0xb1, 0xd5,
0x6b, 0x64, 0x94, 0xf4, 0xf4, 0xaa,
0xb8, 0xe9, 0xb1, 0x2b, 0x72, 0x6b,
0xfa, 0xb7, 0xf1, 0xd0, 0xf9, 0xbe,
0xef, 0x3a, 0x59, 0x11, 0x4a, 0x46,
0x85, 0xd1, 0x44, 0x46, 0x5a, 0x2b,
0x10, 0xa1, 0xac, 0xd7, 0xbc, 0x3f,
0xff, 0xb3, 0xff, 0x1, 0x0, 0xab,
0x57, 0x8d, 0x7f, 0xf6, 0xb3, 0x9f,
0xad, 0x96, 0x6b, 0x83, 0x3, 0xc3,
0x91, 0x50, 0x9, 0xd3, 0x65, 0xf2,
0x8c, 0x2e, 0x16, 0x1a, 0x73, 0xb3,
0xd1, 0xaf, 0x8d, 0x2e, 0xdb, 0x80,
0xe5, 0x3a, 0x59, 0xad, 0xa0, 0x52,
0xae, 0x79, 0x8d, 0x60, 0xe7, 0x8e,
0x37, 0xdf, 0xf0, 0x7, 0x37, 0xde,
0x7a, 0xeb, 0xad, 0x3f, 0x7c, 0xf8,
0x47, 0x0, 0xf0, 0xc7, 0x7f, 0xf2,
0x27, 0x97, 0xbc, 0xf9, 0xd2, 0xfb,
0xee, 0xbb, 0x4f, 0xa, 0x5, 0x86,
0x6a, 0x5, 0xf5, 0x9a, 0xd7, 0x4d,
0xb1, 0x9c, 0x24, 0x50, 0x12, 0xd8,
0x64, 0x5b, 0xff, 0x4f, 0x73, 0x53,
0x6e, 0xd6, 0x8d, 0x20, 0x29, 0x14,
0xdd, 0xff, 0x7f, 0xf7, 0xae, 0x5d,
0x3b, 0x7e, 0xce, 0x59, 0x5b, 0xb7,
0x6d, 0xdb, 0xba, 0x6a, 0xd5, 0x88,
0x88, 0xac, 0x73, 0x7e, 0x6b, 0xfb,
0xf8, 0x9a, 0x53, 0x36, 0x9f, 0xb6,
0xa5, 0x54, 0xcc, 0x1d, 0x9d, 0x9a,
0x5e, 0x58, 0x58, 0x1c, 0x1c, 0x1c,
0xa4, 0xcc, 0xd6, 0x51, 0xa0, 0xd,
0x8b, 0x84, 0xa, 0x79, 0x14, 0x69,
0xc5, 0x39, 0x57, 0x52, 0x33, 0xad,
0xb1, 0xe5, 0xb3, 0xd9, 0xf4, 0x6e,
0x12, 0xe7, 0xb4, 0x99, 0xc4, 0x6a,
0xc2, 0x54, 0x52, 0xde, 0x2, 0x6e,
0xcb, 0xa9, 0x19, 0xdf, 0x24, 0xf8,
0xf5, 0x3c, 0x6f, 0xeb, 0xd6, 0xad,
0x43, 0x43, 0x43, 0xb8, 0x18, 0x78,
0x9e, 0x87, 0x8b, 0x74, 0x2, 0x39,
0xc6, 0x81, 0x4b, 0x40, 0xb3, 0x58,
0x7b, 0x4c, 0x4, 0x11, 0xfb, 0xe1,
0xb7, 0x3a, 0x68, 0xb7, 0x92, 0xb9,
0x5, 0x46, 0x2b, 0x65, 0xa8, 0x1,
0xad, 0xf5, 0xc4, 0xc4, 0x4, 0xe7,
0x3c, 0x93, 0xc9, 0xec, 0xdb, 0xb7,
0xef, 0xdf, 0xf, 0x1d, 0x4a, 0xc8,
0xa2, 0x82, 0xc0, 0xdb, 0x7a, 0xc6,
0x19, 0x57, 0x5d, 0x75, 0xd5, 0xaa,
0xf1, 0x31, 0xad, 0x75, 0x24, 0x2,
0x74, 0x5c, 0xd3, 0x7d, 0x42, 0x69,
0x70, 0xbc, 0x31, 0xc6, 0xf7, 0x3,
0x2c, 0x91, 0x27, 0xba, 0xac, 0xc7,
0x8f, 0xcf, 0x3e, 0xf3, 0xcc, 0x33,
0x7b, 0xf7, 0xee, 0x1d, 0x1b, 0x5f,
0x7d, 0xd5, 0x55, 0x57, 0x39, 0x8e,
0xc3, 0x6d, 0xfb, 0xea, 0xab, 0xaf,
0x6, 0x80, 0x3, 0x7, 0xfe, 0xfd,
0xb1, 0xc7, 0x1e, 0xbb, 0xec, 0xf2,
0x5d, 0x83, 0x83, 0xa5, 0xd1, 0xd1,
0xd5, 0x4a, 0x29, 0x63, 0x18, 0x36,
0xa6, 0x68, 0xad, 0x81, 0x9a, 0x34,
0xa2, 0x3b, 0xf9, 0x9b, 0x73, 0xee,
0x79, 0xbe, 0x65, 0x59, 0x94, 0x5a,
0x4a, 0x9, 0xad, 0x61, 0xe7, 0xce,
0x9d, 0xbe, 0xef, 0xff, 0xd5, 0xad,
0x7f, 0x71, 0xcf, 0x3d, 0xf7, 0xfc,
0xec, 0x5f, 0x7e, 0x16, 0x45, 0x11,
0x26, 0x99, 0xae, 0x78, 0xeb, 0x5b,
0x3f, 0xf1, 0xf1, 0x4f, 0xc, 0xe,
0xe, 0x22, 0xe5, 0x7a, 0x92, 0xb0,
0xe8, 0xb7, 0xd2, 0x25, 0xb3, 0x5,
0x4d, 0x17, 0x3d, 0x14, 0xbc, 0x96,
0x30, 0xc, 0xf3, 0xf9, 0xfc, 0x85,
0x17, 0x5e, 0x78, 0xf0, 0xe0, 0xc1,
0x4a, 0xa5, 0x72, 0xd9, 0x65, 0x97,
0x1, 0xc0, 0xc6, 0x8d, 0x1b, 0x31,
0xb, 0x85, 0x24, 0x3b, 0x71, 0xce,
0xa5, 0xf, 0xa7, 0x69, 0xc7, 0x41,
0x1b, 0x8d, 0x46, 0xc2, 0x74, 0x8f,
0x7d, 0x29, 0x23, 0x23, 0x23, 0x9e,
0xe7, 0x7d, 0xf3, 0x9b, 0xdf, 0x44,
0xa7, 0xb4, 0xc9, 0x68, 0xe1, 0xde,
0x78, 0xe3, 0x8d, 0x57, 0x5f, 0x7d,
0x75, 0x18, 0x86, 0x86, 0xc4, 0x7e,
0x32, 0xf4, 0xe9, 0xb9, 0xed, 0x68,
0x21, 0xa0, 0x8c, 0x7, 0x81, 0x67,
0x8c, 0x41, 0x5e, 0x51, 0x63, 0xcc,
0xf0, 0xf0, 0x30, 0xca, 0x17, 0xd6,
0xeb, 0x75, 0x0, 0xb8, 0xf8, 0xe2,
0x8b, 0xaf, 0xb9, 0xe6, 0x9a, 0x6f,
0x7c, 0xe3, 0x1b, 0xe8, 0x74, 0x50,
0x4a, 0x41, 0x52, 0xd2, 0xa6, 0x9,
0x8e, 0x9a, 0x8d, 0xa4, 0x27, 0x2e,
0x50, 0x6b, 0x2d, 0x8d, 0xac, 0xd5,
0x6a, 0x5a, 0xeb, 0xd1, 0xd1, 0x51,
0xc, 0x94, 0xce, 0x3c, 0xf3, 0xcc,
0x2d, 0x5b, 0xb6, 0x1c, 0x39, 0x72,
0x4, 0x0, 0xce, 0x3f, 0xff, 0xfc,
0x81, 0x81, 0x81, 0x30, 0xc, 0x4b,
0x3, 0x3, 0x28, 0x18, 0xd2, 0x21,
0xc6, 0xdb, 0xc1, 0x7c, 0x8c, 0xdd,
0x2d, 0x9, 0xcb, 0x6f, 0x1c, 0x92,
0xa4, 0xd1, 0xc7, 0xa6, 0xd, 0xa4,
0x31, 0x38, 0x38, 0x7c, 0xfc, 0xf8,
0x8c, 0xdf, 0x68, 0x84, 0x61, 0xb8,
0x75, 0xeb, 0xd6, 0x62, 0xb1, 0x30,
0x3c, 0x34, 0xba, 0x6e, 0xed, 0x7a,
0xaf, 0xee, 0x2f, 0x2c, 0xd4, 0x38,
0x77, 0xb6, 0x6d, 0x3b, 0x53, 0x4a,
0x28, 0x2f, 0x56, 0x67, 0x66, 0x66,
0xe6, 0xe6, 0xe6, 0x18, 0xb3, 0xc,
0x25, 0x46, 0x99, 0x9e, 0xc9, 0xbf,
0xf4, 0xd5, 0xc5, 0xfd, 0xc0, 0xc6,
0x10, 0x0, 0xaa, 0x24, 0x44, 0x42,
0x86, 0x81, 0x88, 0xb3, 0x5e, 0x28,
0xb8, 0x2, 0xba, 0xd9, 0x39, 0xa4,
0x85, 0x90, 0x5a, 0xeb, 0xbb, 0xff,
0xe1, 0xab, 0x42, 0x8, 0xa4, 0xb,
0x5e, 0xb5, 0x6a, 0x15, 0x16, 0x69,
0x2c, 0xcb, 0x2, 0x90, 0x1d, 0x30,
0x7a, 0xd4, 0x43, 0x1, 0x0, 0xc6,
0x69, 0xc2, 0x86, 0x97, 0x7c, 0x0,
0xa7, 0xc5, 0xd2, 0xad, 0x1b, 0x68,
0xc0, 0x71, 0xeb, 0x23, 0xb3, 0xbf,
0xf2, 0x95, 0xaf, 0x70, 0xce, 0x5d,
0xd7, 0xcd, 0xb8, 0x99, 0x20, 0x12,
0x84, 0x10, 0x94, 0x87, 0xcc, 0xe5,
0x32, 0x8d, 0x5a, 0xad, 0x56, 0xab,
0x60, 0x3f, 0x86, 0x2, 0x3, 0x0,
0xb5, 0x5a, 0xd, 0x11, 0xbc, 0xa9,
0x66, 0xe3, 0xd6, 0x8f, 0xa3, 0xb4,
0x8f, 0xe7, 0x79, 0x8c, 0x31, 0xa3,
0x95, 0x94, 0x72, 0x6c, 0x6c, 0xec,
0xad, 0x6f, 0x7d, 0xeb, 0xee, 0xdd,
0x57, 0x3a, 0x8e, 0xb3, 0xb0, 0x50,
0xf6, 0x3c, 0x8f, 0x72, 0x7e, 0xfe,
0xf9, 0xe7, 0x3, 0xc0, 0x13, 0x4f,
0x3c, 0x51, 0x2a, 0x15, 0xa6, 0x67,
0x8e, 0x15, 0x8b, 0xf9, 0x20, 0x10,
0x94, 0x52, 0x4a, 0x38, 0xd2, 0x11,
0xda, 0xb6, 0x2d, 0xe4, 0x52, 0xd0,
0x3c, 0x24, 0x5b, 0xb2, 0x2d, 0x86,
0xbd, 0x23, 0x57, 0x5d, 0x75, 0xd5,
0xef, 0x5d, 0xf7, 0x5e, 0x21, 0x44,
0xd0, 0x8, 0x3c, 0xcf, 0x5b, 0xbd,
0x7a, 0x35, 0x1a, 0x80, 0x8, 0xa5,
0x88, 0x82, 0x98, 0xdb, 0x1d, 0x38,
0x9a, 0x25, 0x8e, 0x40, 0x14, 0x45,
0x8c, 0xda, 0xa9, 0x69, 0xd4, 0x62,
0x54, 0xc1, 0x9, 0x9d, 0xb8, 0xac,
0xae, 0xeb, 0x8a, 0x30, 0xb4, 0x2c,
0xeb, 0x83, 0x1f, 0xfc, 0xe0, 0x47,
0x3f, 0xfa, 0x51, 0x6c, 0x96, 0x2,
0x80, 0x99, 0x99, 0x19, 0xd7, 0x75,
0x73, 0xb9, 0x1c, 0xc6, 0x44, 0x31,
0x39, 0x4f, 0x73, 0x95, 0x4c, 0x91,
0xd1, 0x77, 0x4e, 0x4a, 0xbc, 0xa1,
0xe8, 0xd1, 0xa0, 0xd, 0x6f, 0xda,
0xb4, 0xe9, 0xc9, 0x27, 0x9f, 0xcc,
0xe7, 0xf3, 0x28, 0xb2, 0x81, 0xbd,
0x75, 0xe8, 0xc2, 0x60, 0xce, 0xdf,
0x75, 0xdd, 0x9a, 0x57, 0xc3, 0xae,
0x37, 0xec, 0x2b, 0x6c, 0xaf, 0x6e,
0xb4, 0xda, 0x8c, 0xd0, 0x55, 0x91,
0x52, 0x82, 0x8c, 0xc9, 0x59, 0x6b,
0xb5, 0x5a, 0xb1, 0x58, 0xfc, 0xdb,
0xbf, 0xfd, 0x5b, 0x9c, 0x2a, 0x48,
0x3, 0x82, 0xac, 0xa6, 0x9f, 0xfd,
0xec, 0x67, 0x51, 0x56, 0xa2, 0x52,
0xa9, 0x54, 0x2a, 0x15, 0xca, 0x79,
0x5a, 0xf3, 0x39, 0xcd, 0xe8, 0xd2,
0x14, 0x85, 0x68, 0xb, 0x50, 0x43,
0x29, 0x6d, 0xdb, 0xfe, 0xe4, 0x27,
0x3f, 0xf9, 0x99, 0xcf, 0x7c, 0xa6,
0x52, 0xa9, 0x78, 0x9e, 0xb7, 0x73,
0xe7, 0xce, 0xc7, 0x1e, 0x7b, 0x2c,
0x9f, 0xcf, 0x2, 0xc0, 0xf4, 0xf4,
0xec, 0xe4, 0xe4, 0xe4, 0xd, 0x37,
0xdc, 0xf0, 0xa7, 0x7f, 0xfa, 0xa7,
0xe5, 0x72, 0xb9, 0x99, 0x81, 0x6b,
0x69, 0x91, 0x2f, 0xd1, 0xdf, 0xa7,
0xe3, 0xdc, 0x6f, 0x84, 0xbc, 0xd0,
0x8, 0x10, 0xa4, 0xed, 0x20, 0xdc,
0x20, 0x14, 0x84, 0x5a, 0x95, 0x6a,
0xf0, 0xd8, 0x4f, 0xff, 0xdf, 0x8f,
0x7f, 0xf2, 0x44, 0x92, 0x7f, 0x70,
0xb8, 0xe3, 0x38, 0xe, 0x21, 0xcc,
0xf7, 0xfd, 0x20, 0x8a, 0x69, 0xb7,
0x31, 0xeb, 0x8e, 0x4, 0x55, 0x94,
0x19, 0x65, 0xb4, 0x94, 0x4a, 0x83,
0x11, 0x32, 0x84, 0x16, 0x99, 0x4e,
0x8c, 0x5a, 0xe1, 0x5d, 0x6, 0x83,
0x40, 0x2b, 0x20, 0x4, 0x1c, 0xcb,
0x4a, 0x7b, 0x6e, 0x5a, 0x69, 0xa5,
0xb4, 0x36, 0xca, 0x75, 0xdd, 0x5c,
0x21, 0x8f, 0x31, 0x33, 0x32, 0x9b,
0x1, 0x61, 0x2a, 0xc, 0x71, 0x7,
0x68, 0x66, 0x83, 0x28, 0xfa, 0x7e,
0x1c, 0x3b, 0xb0, 0xd0, 0xaf, 0x4a,
0x8d, 0xc5, 0x92, 0x22, 0xa6, 0x6d,
0x6b, 0xa7, 0x56, 0x52, 0x6b, 0x4d,
0x59, 0xec, 0x8c, 0x45, 0x51, 0x34,
0x3b, 0x3b, 0xcb, 0x18, 0xd3, 0x40,
0xb1, 0xbf, 0x14, 0x0, 0xe6, 0xe7,
0x67, 0xad, 0x66, 0x33, 0xa3, 0x10,
0x42, 0xc9, 0xb8, 0x5, 0xf, 0x97,
0xf3, 0xd4, 0xda, 0x99, 0xea, 0x98,
0x11, 0x2, 0x17, 0x17, 0xcb, 0xb2,
0xb4, 0x82, 0x7a, 0xbd, 0x6e, 0x54,
0xe4, 0x38, 0x4e, 0xb5, 0xda, 0xc0,
0x35, 0xb8, 0x50, 0x28, 0x18, 0x42,
0x90, 0x98, 0xbb, 0x5e, 0xaf, 0x7,
0x81, 0x67, 0xd9, 0xd6, 0xe2, 0xe2,
0x22, 0x8a, 0x80, 0x31, 0xee, 0x22,
0xe9, 0x34, 0xe7, 0x3c, 0x44, 0x49,
0x75, 0xe8, 0xdc, 0x33, 0x71, 0xf2,
0xe1, 0x73, 0x93, 0x62, 0x4e, 0x2a,
0xa5, 0xa6, 0x8f, 0xcf, 0x5a, 0x96,
0x95, 0xcf, 0x66, 0x9, 0x21, 0xd5,
0x4a, 0x1d, 0xdf, 0x75, 0x5d, 0x97,
0x32, 0xd0, 0x5a, 0x22, 0xe3, 0x39,
0xce, 0xa1, 0xe, 0xbe, 0xf5, 0x6e,
0x17, 0x3a, 0x95, 0x20, 0xd5, 0xc8,
0x58, 0x82, 0xab, 0x94, 0xeb, 0xba,
0x53, 0x53, 0x53, 0x51, 0x14, 0xa1,
0x98, 0x50, 0xa9, 0x54, 0xe2, 0x9c,
0x4b, 0x11, 0x25, 0x13, 0x5d, 0x69,
0xd5, 0xb1, 0x9e, 0xb6, 0x97, 0xf7,
0x52, 0x94, 0xe8, 0x52, 0xca, 0x30,
0x48, 0xda, 0x6b, 0x31, 0x6b, 0x30,
0x37, 0x37, 0x97, 0xcd, 0x66, 0x2b,
0x95, 0xa, 0xfe, 0x7e, 0xb3, 0x5c,
0x2c, 0x4b, 0xa5, 0x52, 0xb9, 0x5c,
0xc6, 0x36, 0x57, 0x30, 0x40, 0x5b,
0xd1, 0x44, 0xcc, 0x47, 0x9, 0x90,
0x76, 0x9e, 0xe3, 0xf3, 0xb7, 0xdd,
0x8c, 0xd6, 0xb2, 0x29, 0x73, 0xa1,
0xb0, 0xcb, 0x17, 0x4f, 0x3e, 0x11,
0x6a, 0xa9, 0x56, 0xab, 0xf5, 0x7a,
0x1d, 0xf9, 0xa8, 0xa5, 0x92, 0x34,
0xe5, 0xa6, 0xa5, 0x69, 0xe8, 0x53,
0x7c, 0x8e, 0x6d, 0x45, 0x5a, 0x6a,
0xc, 0x26, 0x44, 0x30, 0x1a, 0x47,
0x2, 0xe3, 0xc5, 0xc5, 0x45, 0x9c,
0x3f, 0x3, 0x3, 0x3, 0xc5, 0x62,
0x71, 0x76, 0x76, 0xb6, 0x5c, 0x2e,
0x27, 0xf2, 0x4b, 0x91, 0x36, 0x89,
0x6a, 0x54, 0x73, 0xa5, 0xd3, 0x98,
0x85, 0xee, 0xde, 0x66, 0xb4, 0xd6,
0x48, 0xc1, 0xde, 0x44, 0x66, 0xb6,
0xda, 0xe0, 0x0, 0x80, 0x72, 0x16,
0x4, 0x1e, 0x5, 0x92, 0xc9, 0x65,
0x19, 0x63, 0x42, 0x4, 0x58, 0x9f,
0xe3, 0xd4, 0x9a, 0x99, 0x99, 0xc9,
0x66, 0x72, 0xd9, 0x7c, 0x81, 0xb,
0x61, 0xdb, 0xb6, 0x6, 0xd3, 0x68,
0x34, 0x18, 0xb7, 0x64, 0xf3, 0xe,
0x49, 0x54, 0xdb, 0x31, 0x5a, 0x83,
0xe9, 0xb5, 0x3, 0x2b, 0x9, 0x0,
0x91, 0xf0, 0x8d, 0x32, 0x94, 0xe8,
0x7a, 0xb5, 0xc2, 0x2d, 0x26, 0x31,
0xff, 0x1f, 0x75, 0xea, 0x6, 0xc6,
0xb7, 0x2a, 0x94, 0x88, 0x94, 0x30,
0x4, 0x40, 0x1b, 0x42, 0xa8, 0x12,
0x91, 0x21, 0x20, 0xfc, 0xa0, 0x89,
0x80, 0x26, 0x4, 0x8c, 0x32, 0xba,
0x89, 0x73, 0x4, 0xad, 0xb5, 0xc5,
0xb8, 0x51, 0x5a, 0x45, 0xd2, 0xe6,
0x56, 0xe8, 0x23, 0x5d, 0x78, 0x8b,
0x8b, 0xa3, 0x69, 0xb8, 0xe8, 0x9c,
0x68, 0x8b, 0x19, 0x23, 0x43, 0xdf,
0x6b, 0x34, 0xb9, 0x47, 0x23, 0x96,
0xcf, 0x4b, 0x3, 0x32, 0x54, 0x0,
0xda, 0xc9, 0x14, 0x92, 0xc2, 0x7a,
0x2c, 0x23, 0xce, 0xed, 0x28, 0x14,
0x85, 0x62, 0xae, 0x52, 0xae, 0xe5,
0x72, 0x39, 0xa5, 0x64, 0x14, 0x29,
0xd0, 0xc0, 0xb9, 0x65, 0x54, 0x44,
0x19, 0xa3, 0x46, 0x62, 0xae, 0x98,
0x5a, 0x1c, 0x34, 0x51, 0x32, 0x54,
0x84, 0x80, 0x8e, 0x28, 0x3, 0xcf,
0xaf, 0xc6, 0x3b, 0x9, 0x61, 0x81,
0x8c, 0x28, 0xb7, 0x3d, 0x11, 0x11,
0x80, 0x7a, 0xe0, 0x3, 0x0, 0xb7,
0x91, 0x66, 0xc1, 0x48, 0xad, 0x64,
0x60, 0x18, 0xcb, 0x58, 0x44, 0x83,
0xa1, 0x51, 0x14, 0x19, 0x4d, 0xd1,
0xd2, 0x28, 0x68, 0xd0, 0x9a, 0x18,
0x6a, 0x8, 0x10, 0x43, 0x35, 0x1,
0x6a, 0x80, 0x2, 0xe5, 0x9c, 0xc8,
0x28, 0xa8, 0xd7, 0x0, 0x40, 0x3b,
0x76, 0x51, 0x88, 0x38, 0x66, 0xc6,
0x9a, 0x6d, 0x3, 0x1b, 0xe2, 0x9b,
0x1b, 0x76, 0x23, 0x68, 0x60, 0x67,
0xef, 0xc0, 0xd0, 0xe0, 0xdc, 0xdc,
0x9c, 0xd1, 0xc4, 0x18, 0xe0, 0x84,
0x72, 0xaa, 0x8d, 0x92, 0xae, 0x5,
0x9e, 0xd2, 0x5a, 0x4, 0xc0, 0xb8,
0x11, 0xb1, 0xad, 0x1a, 0xa5, 0x90,
0x54, 0x11, 0x11, 0x9d, 0xb6, 0x6d,
0x57, 0xab, 0x55, 0xd7, 0x75, 0xa5,
0xd6, 0x41, 0xa3, 0x41, 0x39, 0x77,
0x38, 0xf, 0x93, 0x7c, 0x21, 0xae,
0x23, 0x9c, 0x35, 0xfc, 0x90, 0xdb,
0x56, 0x10, 0x6, 0x4e, 0xc6, 0x8d,
0xa2, 0xc8, 0xe6, 0x9c, 0x1, 0x89,
0xc2, 0x0, 0x94, 0x36, 0x96, 0xed,
0x32, 0xab, 0xee, 0x7b, 0xf9, 0x8c,
0x2b, 0xb4, 0xd2, 0x91, 0x8e, 0x22,
0x25, 0x44, 0x80, 0xb0, 0x1, 0xa5,
0x14, 0x3, 0x6, 0x14, 0xb4, 0xd6,
0x84, 0x13, 0x69, 0x64, 0xae, 0x98,
0x53, 0x88, 0x16, 0x34, 0x40, 0x38,
0xb1, 0xb9, 0xed, 0xb, 0x1f, 0x28,
0x55, 0x12, 0x42, 0x11, 0xd, 0xe,
0xe6, 0xeb, 0xf5, 0x3a, 0x28, 0x50,
0x51, 0x94, 0x2d, 0xb2, 0x72, 0xb5,
0xa1, 0x43, 0x62, 0x67, 0x6c, 0xa2,
0x8d, 0x56, 0x31, 0xc9, 0x5e, 0x14,
0xa9, 0x5a, 0xad, 0xae, 0xa4, 0xa0,
0x14, 0x2c, 0xd7, 0x8a, 0x74, 0xa4,
0x8d, 0x8e, 0x82, 0x88, 0x31, 0xc6,
0x2c, 0x56, 0xf7, 0xeb, 0xe9, 0xe9,
0xe1, 0xe6, 0x5c, 0x5, 0xa, 0xc,
0x0, 0xa5, 0xae, 0xeb, 0xce, 0xcc,
0xcd, 0xe7, 0x84, 0xca, 0xe7, 0xf3,
0x2a, 0x8a, 0x2c, 0x4e, 0xa9, 0x31,
0x5a, 0x2b, 0x8b, 0x31, 0xa9, 0x35,
0x68, 0x65, 0x3b, 0x56, 0x23, 0xf2,
0x74, 0x24, 0xeb, 0xf5, 0xba, 0x65,
0x33, 0xa, 0x6, 0x9a, 0xf1, 0xa0,
0x2, 0x15, 0x89, 0xc8, 0x18, 0xc3,
0x1d, 0xec, 0x28, 0x82, 0x50, 0x86,
0xf8, 0xfb, 0xc9, 0x8d, 0x40, 0x60,
0x93, 0x61, 0x4c, 0x19, 0xc2, 0x6d,
0x57, 0x7b, 0x41, 0x2c, 0x8c, 0x46,
0xa9, 0xd1, 0x46, 0x29, 0x5, 0x84,
0xc5, 0x8c, 0xc8, 0x84, 0xfb, 0x9e,
0xc8, 0x66, 0xb4, 0x50, 0x22, 0x61,
0xed, 0x49, 0x1, 0x84, 0x5b, 0xf6,
0xa6, 0x1, 0x1a, 0x8d, 0x5a, 0x5a,
0x4b, 0x89, 0x82, 0xc8, 0xe5, 0x72,
0xc6, 0x18, 0x3f, 0xf0, 0x0, 0xc0,
0xf3, 0x23, 0x0, 0x60, 0x94, 0x78,
0x8d, 0xba, 0xeb, 0xba, 0x9c, 0x51,
0xdf, 0x6b, 0x10, 0x42, 0xb8, 0x6d,
0xf9, 0xf5, 0x7a, 0xc6, 0xb6, 0x3d,
0xe9, 0x69, 0x25, 0x19, 0x63, 0x52,
0x46, 0xb8, 0x83, 0xc6, 0xea, 0x84,
0x8, 0x7f, 0x22, 0x84, 0x18, 0x40,
0xed, 0x15, 0x9d, 0x46, 0x59, 0x74,
0xf4, 0x33, 0xf4, 0x73, 0xc7, 0xd1,
0x9d, 0x8b, 0x7b, 0xb5, 0x1, 0xb0,
0x6c, 0x95, 0x5e, 0xa5, 0x70, 0xd3,
0x4b, 0xfa, 0x1b, 0xfb, 0xbb, 0xd0,
0xa6, 0x5c, 0x2e, 0xaf, 0x5b, 0xbb,
0xa6, 0x58, 0x2c, 0x62, 0x90, 0x89,
0xba, 0x41, 0xb8, 0x42, 0xb7, 0x43,
0x7c, 0xdb, 0xce, 0x3, 0x51, 0x1f,
0x35, 0xaf, 0x61, 0xdb, 0xae, 0xe3,
0x38, 0xd5, 0x4a, 0xd, 0x77, 0x6c,
0xc6, 0x18, 0x80, 0x45, 0x8c, 0x8a,
0x54, 0x5c, 0x17, 0x21, 0x84, 0xb8,
0x96, 0xed, 0x38, 0x56, 0xb3, 0xf2,
0x8e, 0x1d, 0x42, 0x54, 0x29, 0xd9,
0x13, 0x8c, 0x1e, 0x37, 0x30, 0x12,
0xaa, 0xa4, 0xa4, 0x94, 0x6, 0x81,
0x97, 0xc9, 0x64, 0x71, 0x87, 0x4c,
0x4a, 0x41, 0xb8, 0x3e, 0xb6, 0x74,
0x2e, 0x40, 0x13, 0x0, 0xdb, 0xe6,
0xc5, 0x62, 0xb1, 0x5e, 0xaf, 0x56,
0xab, 0x75, 0x21, 0x2, 0xd7, 0xcd,
0x2a, 0x15, 0x51, 0xca, 0x3b, 0x40,
0xed, 0xc9, 0x1f, 0xa1, 0x90, 0xb,
0xf3, 0x65, 0x19, 0xe9, 0xa1, 0xa1,
0x21, 0xcb, 0xb2, 0x6a, 0xb5, 0x9a,
0xe7, 0x79, 0xc4, 0xa8, 0x7a, 0xbd,
0x4e, 0x8, 0xb1, 0xb8, 0x43, 0x29,
0x8d, 0x74, 0xbc, 0x8d, 0x50, 0xc2,
0xb3, 0xd9, 0xbc, 0xe3, 0x38, 0x42,
0x48, 0x21, 0x44, 0xdc, 0xab, 0xa0,
0x21, 0xc, 0x3d, 0x6c, 0x2c, 0x69,
0xa2, 0xe7, 0xe3, 0x9a, 0x25, 0x0,
0x35, 0x46, 0x7, 0x22, 0x64, 0x4a,
0x12, 0xc2, 0x38, 0xb3, 0x13, 0x2,
0x57, 0x87, 0x71, 0x60, 0x10, 0x45,
0x91, 0x34, 0x40, 0xd, 0xe0, 0xa5,
0x15, 0xa, 0x85, 0x42, 0xa1, 0x80,
0x89, 0x39, 0x63, 0x88, 0x52, 0x12,
0x9, 0xc3, 0x8, 0x61, 0x84, 0x98,
0x20, 0x10, 0x5d, 0xe7, 0x1f, 0xff,
0xd7, 0xb2, 0x33, 0x0, 0x54, 0x6b,
0x20, 0x84, 0x61, 0xa6, 0x3d, 0x8,
0x2, 0x4e, 0xa9, 0x9b, 0x75, 0x85,
0x10, 0x22, 0x12, 0x31, 0xd1, 0x94,
0xd6, 0xb6, 0x6d, 0xaf, 0x5d, 0xbb,
0x76, 0x6e, 0xf6, 0xb8, 0x31, 0x40,
0x29, 0x32, 0x1f, 0x2, 0xb6, 0xe2,
0x13, 0x12, 0x61, 0x72, 0xaa, 0x47,
0x33, 0x3, 0x80, 0x17, 0x84, 0x85,
0x7c, 0x49, 0x4a, 0xb5, 0xb0, 0x50,
0x96, 0x91, 0xe6, 0x8c, 0x18, 0x63,
0x38, 0x63, 0x78, 0xbb, 0x3, 0x21,
0x8c, 0x51, 0xb6, 0x6d, 0x97, 0x4a,
0x3, 0x99, 0x4c, 0xc6, 0xb2, 0xac,
0x7a, 0xb5, 0x86, 0xc0, 0xb2, 0xe,
0xd6, 0xb, 0x2c, 0x88, 0xf4, 0xec,
0x46, 0xa2, 0xdc, 0x41, 0x1f, 0x13,
0x3f, 0xa6, 0x94, 0x2, 0xa0, 0x38,
0xce, 0x9, 0x37, 0x18, 0xd6, 0x8a,
0xf1, 0x76, 0x18, 0x69, 0xda, 0xe5,
0xc8, 0x54, 0x93, 0xa9, 0xa2, 0x2f,
0x3d, 0x86, 0xd6, 0xa6, 0x5f, 0xf0,
0x88, 0xae, 0x7, 0xa5, 0x14, 0xd9,
0xad, 0x3, 0xcf, 0x4f, 0x53, 0xa0,
0xb4, 0xf2, 0xbe, 0x1f, 0xfa, 0xc3,
0x3f, 0xc7, 0x3, 0xf8, 0xbe, 0x5f,
0xad, 0x56, 0xb1, 0x41, 0xc4, 0x4a,
0x39, 0xcf, 0xdd, 0x6d, 0x9f, 0xfd,
0x68, 0xeb, 0xfa, 0x23, 0xab, 0x20,
0x91, 0x14, 0xc8, 0x64, 0x32, 0x99,
0x4c, 0x26, 0x91, 0x1a, 0xe8, 0xc3,
0xea, 0xa0, 0xb, 0x39, 0xe7, 0xe5,
0x97, 0x8f, 0x8, 0x11, 0x6d, 0xdc,
0xb8, 0x61, 0x7c, 0x7c, 0xd, 0x63,
0x94, 0x10, 0xea, 0x38, 0xb6, 0x10,
0x11, 0x0, 0x46, 0x50, 0xe9, 0x67,
0x0, 0x30, 0x58, 0x6d, 0x42, 0xdd,
0x5c, 0x21, 0xc4, 0xe2, 0xe2, 0xe2,
0xf4, 0xf4, 0x74, 0x10, 0x88, 0x7c,
0xb1, 0x18, 0x43, 0x61, 0x55, 0x2,
0x46, 0xa7, 0x0, 0xda, 0x6f, 0x54,
0x16, 0x17, 0x17, 0x56, 0xaf, 0x1e,
0x5b, 0xb3, 0x66, 0x3c, 0x9f, 0x2f,
0x48, 0x19, 0x49, 0xa9, 0xa, 0x85,
0xbc, 0x94, 0xaa, 0xeb, 0x10, 0xb8,
0x51, 0x1a, 0xce, 0x2d, 0x8c, 0xab,
0xa3, 0x28, 0xaa, 0x54, 0x2a, 0x47,
0x8f, 0x4e, 0x35, 0x1a, 0x8d, 0x52,
0xa9, 0x14, 0xf3, 0xe8, 0xb7, 0x85,
0x3d, 0x4, 0xc0, 0x1c, 0x3b, 0x3e,
0xb1, 0x7a, 0xf5, 0x48, 0xb1, 0x58,
0x1a, 0x1a, 0x1a, 0xb4, 0x2c, 0x5b,
0x88, 0xd0, 0xb6, 0x1d, 0xad, 0x15,
0xa5, 0xac, 0xfb, 0xfc, 0xf1, 0xbf,
0x5a, 0x1b, 0x2c, 0x6e, 0xd5, 0x6a,
0xb5, 0xf9, 0xf9, 0xf9, 0xc5, 0xc5,
0xa, 0x63, 0x6c, 0x78, 0x78, 0x58,
0x2b, 0x2c, 0x84, 0x68, 0x9c, 0xf4,
0x8c, 0x31, 0xdf, 0xf, 0xea, 0xf5,
0x9a, 0x36, 0x62, 0xf3, 0xe6, 0x53,
0x73, 0xb9, 0x3c, 0x63, 0x14, 0x80,
0x68, 0xad, 0x32, 0x99, 0x2c, 0x80,
0x69, 0xf6, 0x57, 0xd0, 0xf4, 0xf9,
0xe3, 0x73, 0xc2, 0xf0, 0xbc, 0xb0,
0xb0, 0x78, 0xf4, 0xe8, 0x94, 0x94,
0x72, 0xcd, 0xf8, 0x3a, 0xc6, 0x58,
0xbd, 0xee, 0x61, 0xc, 0x96, 0x90,
0xce, 0xcf, 0xcf, 0xcf, 0xfa, 0xbe,
0xbf, 0xe5, 0x8c, 0x53, 0x33, 0x19,
0x37, 0x97, 0xcb, 0x73, 0xce, 0xb4,
0x36, 0x52, 0x46, 0x4a, 0x69, 0x42,
0x80, 0x73, 0xab, 0xfb, 0xfc, 0xf1,
0xbf, 0x52, 0x6a, 0x2, 0xac, 0x5c,
0x2e, 0x1f, 0x3d, 0x7a, 0x14, 0x87,
0x8, 0x95, 0x28, 0x90, 0xa7, 0x26,
0x31, 0xa1, 0x46, 0xa3, 0x21, 0xa5,
0xcc, 0x64, 0x9d, 0xf5, 0xeb, 0xd7,
0x72, 0xce, 0x38, 0xb7, 0xf0, 0x2a,
0x92, 0x5f, 0x6b, 0x66, 0x8b, 0xa0,
0xeb, 0x8e, 0x1b, 0x21, 0x44, 0x14,
0xc9, 0x23, 0x47, 0x8e, 0xd4, 0x6a,
0x8d, 0xa1, 0xc1, 0x11, 0xdb, 0x76,
0xa3, 0x48, 0x62, 0xb2, 0x46, 0x29,
0x25, 0x65, 0x54, 0x28, 0xe4, 0x82,
0xd0, 0x9b, 0x9e, 0x3e, 0x56, 0x2a,
0x95, 0x56, 0xaf, 0x5e, 0x55, 0x2a,
0x95, 0x3a, 0x34, 0xf4, 0x4e, 0xd8,
0x7c, 0xef, 0x85, 0xe1, 0xe4, 0xd1,
0x63, 0x8b, 0x8b, 0x8b, 0x48, 0x1c,
0x19, 0x73, 0x25, 0x33, 0x6, 0x40,
0xa3, 0x28, 0xd2, 0xca, 0x60, 0x56,
0x2f, 0x8, 0x2, 0xdf, 0xf, 0xa3,
0x28, 0xb4, 0x5d, 0x7, 0xfa, 0x34,
0x27, 0xf4, 0xb5, 0xb, 0xa9, 0x3a,
0x3e, 0xd0, 0x2a, 0x13, 0x36, 0xb,
0x6f, 0x9, 0x44, 0xc4, 0xb2, 0x2c,
0xd7, 0x75, 0x6d, 0xdb, 0x46, 0x12,
0x7f, 0x0, 0x38, 0x7e, 0x7c, 0x8a,
0x5c, 0x7d, 0xdd, 0x87, 0x93, 0xfe,
0xc3, 0x74, 0x13, 0x66, 0x87, 0x75,
0x75, 0x47, 0xaa, 0xdd, 0xaf, 0x2c,
0x91, 0x91, 0x42, 0x8b, 0x4d, 0xe7,
0x45, 0x12, 0xf2, 0x84, 0x7e, 0xec,
0xaa, 0xb9, 0x5c, 0x6, 0x91, 0x12,
0x48, 0x1, 0x8d, 0x1, 0xf6, 0x12,
0xe3, 0x9e, 0x70, 0x17, 0x34, 0x45,
0x1c, 0x69, 0x14, 0x29, 0xdc, 0xc0,
0x51, 0xfd, 0xb9, 0x25, 0x5d, 0xa7,
0x8c, 0xd2, 0x32, 0xeb, 0x3a, 0xb8,
0x32, 0x72, 0x4e, 0x7d, 0x3f, 0x74,
0x1c, 0x4b, 0x29, 0x23, 0x44, 0x60,
0x59, 0x4e, 0x9f, 0x1d, 0x38, 0x4e,
0x56, 0x63, 0x2e, 0xa, 0x80, 0xa2,
0xf8, 0x4d, 0xa2, 0x91, 0xdb, 0x89,
0xc8, 0x25, 0x86, 0x52, 0x60, 0x8c,
0x20, 0x99, 0x33, 0x63, 0x16, 0xe7,
0x54, 0x6b, 0x8, 0x43, 0xbf, 0xff,
0xe, 0xac, 0x51, 0x41, 0x7, 0x47,
0xc, 0x99, 0x28, 0x71, 0x6d, 0x45,
0xf2, 0xad, 0x58, 0x3e, 0x5b, 0xc7,
0xb5, 0x25, 0x3, 0xda, 0xb2, 0x98,
0xef, 0x37, 0x94, 0x32, 0xae, 0x6b,
0x33, 0x66, 0x49, 0x29, 0xa4, 0xd4,
0xed, 0xad, 0x9d, 0xba, 0x99, 0xa4,
0x8c, 0xff, 0xcb, 0x18, 0xc3, 0xfe,
0x3b, 0xe4, 0xc7, 0x41, 0xae, 0x1f,
0xdf, 0xf7, 0xf3, 0xb9, 0x42, 0x82,
0x66, 0x21, 0xcd, 0xde, 0x5a, 0xce,
0xb9, 0x94, 0x42, 0x6b, 0x89, 0x9b,
0x21, 0xd2, 0xeb, 0x31, 0x66, 0x11,
0x62, 0xa4, 0xd4, 0xfd, 0x76, 0xe0,
0x44, 0x9a, 0x7, 0x13, 0xcb, 0x98,
0x1b, 0x47, 0x99, 0xa2, 0x8e, 0x2,
0x18, 0x5e, 0x20, 0x63, 0xcc, 0x18,
0x65, 0xc, 0x69, 0xb6, 0x4c, 0xc6,
0xbe, 0x43, 0xe2, 0x41, 0xf4, 0x74,
0x8b, 0x12, 0xfc, 0xb9, 0xe7, 0x5,
0x91, 0x90, 0x99, 0x4c, 0xe, 0x23,
0x76, 0xc7, 0x71, 0x94, 0x8a, 0x44,
0x14, 0x32, 0xc6, 0x2c, 0x8b, 0x51,
0xa, 0xa9, 0x99, 0xd6, 0xea, 0x7e,
0x4d, 0xf5, 0x3f, 0x42, 0xcf, 0x36,
0x40, 0xac, 0x78, 0x37, 0x89, 0x32,
0x39, 0x26, 0x5c, 0x6a, 0xb5, 0x9a,
0xeb, 0x66, 0x91, 0xf8, 0x32, 0x69,
0x8a, 0x8e, 0xeb, 0x7c, 0x64, 0xb9,
0x54, 0x1, 0x6d, 0x2d, 0x68, 0xbd,
0x8c, 0x1c, 0x43, 0x74, 0xc4, 0x4d,
0xa4, 0x3b, 0x79, 0x91, 0xcd, 0x17,
0x55, 0xc2, 0x9, 0x21, 0x33, 0x33,
0xc7, 0x79, 0x3e, 0x9f, 0x6f, 0x36,
0x1b, 0xc8, 0x64, 0x64, 0x9b, 0x64,
0x25, 0xa6, 0xe7, 0xd9, 0xe0, 0x8d,
0xe9, 0xa9, 0x4, 0xd7, 0xef, 0xec,
0x2b, 0x95, 0xa, 0x72, 0x29, 0x27,
0xc, 0x9a, 0xe8, 0x51, 0xf7, 0xb3,
0x79, 0x6e, 0x5b, 0x95, 0x5a, 0x1d,
0x13, 0xce, 0x2e, 0xe3, 0x4a, 0x29,
0xca, 0xb9, 0xd5, 0xdf, 0xe0, 0x1,
0xc0, 0x62, 0xbc, 0x29, 0xde, 0xc9,
0x34, 0x10, 0x0, 0xc2, 0x6d, 0x27,
0x8, 0x43, 0xdb, 0xb6, 0x1, 0x8,
0xd5, 0xcd, 0x1, 0x32, 0x40, 0x8,
0x70, 0x66, 0x5, 0x22, 0x52, 0x2a,
0x2, 0xa0, 0x83, 0xd9, 0x12, 0x11,
0x2a, 0x10, 0x11, 0x21, 0x2c, 0x93,
0xcb, 0xf7, 0xa2, 0xb3, 0x8f, 0x6f,
0xbc, 0xcd, 0x58, 0x10, 0x4, 0x40,
0x99, 0x32, 0x40, 0x88, 0x39, 0x3e,
0x33, 0x9d, 0xc9, 0xe4, 0x12, 0x30,
0x6, 0x74, 0xb0, 0x64, 0x2, 0x9,
0x44, 0x68, 0xdb, 0x1c, 0x80, 0x86,
0x91, 0xe4, 0x86, 0x6a, 0x30, 0x4a,
0x19, 0xca, 0xad, 0x25, 0xc, 0xd8,
0xb, 0x42, 0xcc, 0xab, 0x11, 0xc6,
0x94, 0x52, 0x4a, 0x2a, 0xc6, 0x2c,
0x24, 0x76, 0x97, 0x52, 0x86, 0x22,
0xc2, 0xda, 0x15, 0xce, 0x48, 0x21,
0x84, 0x6, 0xcb, 0x10, 0xea, 0x66,
0x5d, 0x42, 0x4c, 0x20, 0x22, 0x0,
0xc3, 0x6d, 0xc7, 0xb6, 0x79, 0x8a,
0x1c, 0x57, 0x37, 0xcf, 0xad, 0xd9,
0x1, 0x4b, 0xc, 0xb7, 0x1c, 0x0,
0x2a, 0xa4, 0xd2, 0x31, 0x9d, 0xa8,
0xb5, 0x7a, 0x6c, 0xbc, 0x52, 0xa9,
0x11, 0xca, 0x0, 0x8c, 0x65, 0xdb,
0x8, 0x42, 0x20, 0x54, 0x59, 0x8e,
0xad, 0x22, 0xa0, 0x8c, 0x5b, 0x16,
0xa7, 0x14, 0x8c, 0x21, 0x5a, 0xcb,
0x30, 0x92, 0x4a, 0x45, 0x96, 0xe5,
0xa0, 0x48, 0x68, 0x73, 0x87, 0x4c,
0xfe, 0x81, 0x1, 0xb0, 0xdd, 0x8c,
0x65, 0x59, 0xe5, 0x72, 0x59, 0x48,
0x95, 0xcf, 0xe7, 0x95, 0x1, 0xec,
0x45, 0x8b, 0xe1, 0x7, 0x78, 0x75,
0xc6, 0x70, 0xc6, 0x2c, 0xcb, 0x96,
0x52, 0x2, 0xa1, 0x6, 0x8, 0xa1,
0xa8, 0xfa, 0x4, 0xe8, 0xa5, 0xb,
0x21, 0x7b, 0xfd, 0x3e, 0xc1, 0x46,
0x17, 0xa, 0x86, 0x82, 0x92, 0x22,
0xa2, 0x8c, 0xe7, 0xa, 0xae, 0x94,
0x5a, 0x69, 0xe5, 0x66, 0x33, 0xbe,
0xef, 0x53, 0xa, 0xb9, 0x42, 0x9e,
0x10, 0x12, 0x86, 0x7e, 0x10, 0x44,
0x8, 0x19, 0x4c, 0x82, 0xb9, 0x84,
0x50, 0x32, 0x45, 0x9d, 0x4a, 0x7a,
0xfd, 0x43, 0xd7, 0x97, 0xda, 0x36,
0xa, 0x12, 0x34, 0x8, 0x21, 0x85,
0x42, 0x1, 0x15, 0x9e, 0xe2, 0x50,
0x51, 0xa6, 0xc2, 0x40, 0x4a, 0xfa,
0xd5, 0x47, 0x97, 0xae, 0xb6, 0x24,
0x5e, 0x6a, 0x6b, 0xf3, 0xf7, 0xbc,
0x14, 0x8f, 0x3a, 0x43, 0x8b, 0xc3,
0xc9, 0x9f, 0xd6, 0xa9, 0x4, 0x0,
0xf2, 0xde, 0xeb, 0xff, 0x30, 0xcd,
0x17, 0x45, 0x53, 0x94, 0x85, 0x1d,
0x48, 0xa9, 0x13, 0x52, 0x6f, 0x75,
0xd3, 0x73, 0x75, 0x54, 0xc0, 0x57,
0x40, 0x68, 0x42, 0x89, 0x6a, 0xaf,
0x48, 0xe1, 0x3a, 0x87, 0x1e, 0x3e,
0x6, 0x6, 0x88, 0x7d, 0x17, 0x42,
0xe0, 0xa2, 0xd0, 0xef, 0xdd, 0xe4,
0x15, 0x4c, 0x4a, 0xa3, 0xdb, 0xc3,
0x18, 0x93, 0x7d, 0x82, 0x9f, 0xa6,
0x9d, 0x93, 0x7e, 0xa7, 0xda, 0x8f,
0x2e, 0xbb, 0x73, 0x7, 0x3e, 0x89,
0xc7, 0x32, 0x48, 0x95, 0xd2, 0xdd,
0x36, 0xcb, 0x60, 0x60, 0x22, 0xbd,
0xe, 0x91, 0xde, 0x39, 0x69, 0xef,
0x73, 0x4e, 0x9f, 0xc9, 0xa, 0x87,
0x22, 0x21, 0xb5, 0x5c, 0xbe, 0x27,
0xb9, 0xe2, 0x41, 0x8b, 0xaf, 0xa2,
0x3, 0xbf, 0x4a, 0x7a, 0x5e, 0x82,
0x31, 0xaa, 0xc9, 0x99, 0x16, 0x53,
0x55, 0xa2, 0x53, 0x8a, 0xdb, 0x3,
0x5a, 0x5, 0x2e, 0x2b, 0x9, 0xd3,
0x8, 0x63, 0xc, 0x88, 0xc1, 0xfc,
0x6e, 0x37, 0x39, 0xe9, 0x6b, 0x76,
0x15, 0xfd, 0xef, 0x38, 0x9e, 0xf,
0x6e, 0x75, 0x49, 0x85, 0x1f, 0x5b,
0x7a, 0x9b, 0x76, 0xae, 0x8d, 0x31,
0xd3, 0xd3, 0xc7, 0x62, 0x52, 0xbb,
0x4, 0xd7, 0x9e, 0x86, 0x9e, 0xa4,
0x6b, 0xc, 0xed, 0x8c, 0x47, 0xf4,
0x84, 0xbc, 0x7b, 0x1d, 0xf7, 0x78,
0x59, 0xee, 0x44, 0xdb, 0x8f, 0x0,
0x69, 0xe6, 0x9, 0xd2, 0xa8, 0x20,
0x2c, 0xf0, 0xa0, 0x50, 0x1d, 0xd2,
0x3b, 0xe6, 0x72, 0x39, 0xe4, 0x8b,
0xeb, 0xf7, 0x6e, 0xf2, 0x4a, 0x12,
0x20, 0x61, 0x91, 0xc0, 0xee, 0x23,
0x2c, 0xd0, 0xdc, 0x4e, 0x97, 0x4b,
0x2c, 0xd8, 0x51, 0xfa, 0x2, 0x3,
0xaf, 0xe2, 0xb1, 0x4c, 0x3, 0x5e,
0xd6, 0x62, 0xda, 0x87, 0x56, 0xca,
0xa4, 0xfe, 0x41, 0xbb, 0x7c, 0x56,
0x6a, 0x56, 0x99, 0x76, 0x1e, 0x36,
0x43, 0xfa, 0x81, 0x3d, 0x7a, 0xdc,
0xe5, 0xfe, 0xcb, 0x50, 0xdf, 0x69,
0x60, 0x4e, 0x62, 0xa0, 0x4c, 0xe7,
0x37, 0x4d, 0xdf, 0x4b, 0x0, 0x0,
0xad, 0xc, 0x63, 0x14, 0x51, 0x74,
0x98, 0x8b, 0xd1, 0x5a, 0x63, 0xb3,
0x5d, 0xb2, 0xcb, 0x25, 0x24, 0x72,
0xc6, 0x98, 0x48, 0x44, 0x8c, 0x92,
0x9e, 0x1c, 0x57, 0x7d, 0xc7, 0x5c,
0xbf, 0x66, 0x4b, 0x36, 0x72, 0xd7,
0xa8, 0xd4, 0x23, 0x1, 0x81, 0x35,
0x3, 0xc9, 0x66, 0x19, 0x9, 0xc3,
0x92, 0x84, 0xce, 0x3f, 0xdd, 0x60,
0xd0, 0x3f, 0x75, 0xa6, 0x97, 0x58,
0x5f, 0x3b, 0xa8, 0xa1, 0x7b, 0x2a,
0x2f, 0x9f, 0xf0, 0x8e, 0xda, 0x8e,
0x93, 0x60, 0x18, 0xd2, 0x74, 0xf5,
0x22, 0xc, 0x1, 0x20, 0xe3, 0xba,
0x61, 0x18, 0x62, 0x96, 0x43, 0x84,
0x61, 0x52, 0xc7, 0xef, 0xf9, 0x6e,
0xf2, 0xa, 0xe2, 0x87, 0x65, 0xbb,
0x3a, 0x46, 0xf7, 0x60, 0x76, 0x12,
0x7f, 0xb6, 0x30, 0x71, 0x5d, 0x5c,
0xd1, 0x6d, 0x37, 0x4f, 0x75, 0x2f,
0xd5, 0x2b, 0x5e, 0x94, 0xd, 0x10,
0xa3, 0x97, 0xde, 0xbb, 0x52, 0xa7,
0x17, 0x77, 0x4d, 0xf7, 0x3c, 0x84,
0x81, 0x4e, 0xcc, 0x53, 0xd3, 0xb3,
0xd0, 0xb4, 0xdb, 0x5c, 0x4c, 0xf3,
0xb6, 0xc6, 0xf3, 0x49, 0xa7, 0xc9,
0xba, 0x8, 0xe5, 0x86, 0x50, 0xf4,
0x34, 0xfb, 0xf1, 0x2a, 0xc7, 0x87,
0x23, 0x71, 0x99, 0xfa, 0x84, 0x57,
0xd1, 0xbd, 0xb3, 0xf5, 0xbe, 0x8a,
0xfe, 0x6, 0x4f, 0x7b, 0x30, 0x8a,
0xb5, 0x38, 0x7d, 0xc0, 0xd0, 0xe,
0xb2, 0xb, 0x2, 0x31, 0xe3, 0x1f,
0xba, 0x96, 0x89, 0x19, 0xe3, 0x8b,
0x58, 0x1c, 0x69, 0xe2, 0xb4, 0x49,
0x37, 0x74, 0x2f, 0x3d, 0x52, 0xfd,
0xce, 0x8a, 0x0, 0x85, 0xd7, 0xe8,
0xe1, 0xfb, 0x7e, 0x42, 0xbd, 0x9c,
0x70, 0x15, 0x26, 0x89, 0xa4, 0x74,
0xdf, 0x3e, 0x4f, 0xf4, 0x50, 0x2,
0x3f, 0x54, 0x52, 0x87, 0x61, 0x88,
0x80, 0xef, 0x4a, 0xa5, 0x92, 0x4e,
0x62, 0xa5, 0x23, 0xe9, 0xb4, 0x98,
0x45, 0xab, 0xdb, 0x83, 0x31, 0x80,
0x36, 0x90, 0x86, 0x6, 0x43, 0x29,
0x6f, 0xf8, 0x1e, 0x22, 0xe6, 0x13,
0x58, 0x65, 0x1b, 0x22, 0x9f, 0x10,
0xac, 0x28, 0xb8, 0xdc, 0xae, 0xd7,
0xeb, 0xb9, 0x5c, 0xc1, 0x75, 0xed,
0x4a, 0xa5, 0x12, 0xf8, 0x75, 0xdb,
0xb6, 0xc3, 0xd0, 0x6f, 0x91, 0xb3,
0xb5, 0xee, 0x47, 0x4c, 0x6d, 0x87,
0x4, 0xff, 0x49, 0x1f, 0x10, 0x16,
0xe2, 0x2d, 0x6e, 0xe7, 0xf3, 0xf9,
0xf2, 0x7c, 0xb9, 0x58, 0x2c, 0xe6,
0x72, 0xb9, 0xe9, 0x99, 0x85, 0x7c,
0xd1, 0x72, 0x5d, 0x97, 0x31, 0x82,
0xed, 0xa, 0x98, 0x8b, 0x67, 0x8c,
0xa9, 0x48, 0xf5, 0x64, 0x96, 0xa3,
0xa6, 0xc7, 0xde, 0x60, 0x4e, 0xcc,
0xd9, 0xab, 0x3a, 0x18, 0x51, 0xf4,
0x49, 0xb9, 0xd2, 0x7d, 0x77, 0x2f,
0xda, 0xc2, 0xa0, 0x9c, 0xe4, 0x21,
0x5a, 0x6c, 0xdd, 0x29, 0x2b, 0x35,
0x29, 0x47, 0xba, 0xb5, 0x2e, 0xb7,
0x48, 0x33, 0x75, 0xfc, 0x5f, 0xdd,
0xd7, 0xa8, 0xba, 0x52, 0x21, 0x10,
0x6b, 0xbb, 0x2d, 0x77, 0xab, 0xd5,
0x4, 0xfa, 0x91, 0x39, 0x2e, 0xe9,
0xb8, 0x75, 0x38, 0xcc, 0x1a, 0xc,
0x5, 0xa2, 0x41, 0x93, 0xe6, 0xdf,
0x24, 0x7d, 0x8, 0xc6, 0x2c, 0x4,
0x95, 0x50, 0x2, 0x8c, 0x12, 0x74,
0x53, 0x7d, 0xaf, 0xd1, 0x84, 0x6d,
0x68, 0x4a, 0x80, 0x33, 0xaa, 0x95,
0x14, 0x61, 0xd0, 0x64, 0x95, 0x58,
0x7a, 0x7c, 0xf5, 0xab, 0x75, 0x23,
0xfa, 0x7f, 0xc7, 0xb6, 0xed, 0xc4,
0x29, 0x46, 0x1b, 0x49, 0x12, 0xb4,
0x49, 0x3f, 0x19, 0x8e, 0xf, 0x4f,
0x62, 0x0, 0xc4, 0x0, 0xac, 0x5b,
0xb7, 0x6e, 0x7c, 0x7c, 0x7c, 0x64,
0x64, 0x64, 0x70, 0x70, 0xb0, 0x1f,
0xb3, 0x61, 0x3a, 0xd7, 0xd5, 0x93,
0x40, 0x30, 0xfe, 0x75, 0x2, 0xf5,
0xba, 0x47, 0x39, 0x2b, 0x95, 0x4a,
0xd3, 0xd3, 0xd3, 0x73, 0x73, 0x73,
0x13, 0x13, 0x13, 0x87, 0xf, 0x1f,
0x1e, 0x1d, 0x1d, 0x45, 0x18, 0x8a,
0x6d, 0xdb, 0x28, 0xc1, 0x38, 0x3c,
0x3c, 0x7c, 0xfe, 0xb9, 0xe7, 0xbb,
0x4e, 0x16, 0x2b, 0x58, 0xb9, 0x5c,
0xe, 0x88, 0xf6, 0x3c, 0xf, 0xd9,
0xb9, 0x3a, 0xc7, 0x8b, 0x98, 0x66,
0x54, 0xd3, 0xb6, 0xd7, 0xe5, 0xb2,
0xf9, 0x46, 0xa3, 0xf1, 0xd2, 0x4b,
0x2f, 0x3d, 0xf3, 0xcc, 0x33, 0x8e,
0x93, 0x51, 0xca, 0xcc, 0xcf, 0x2f,
0x96, 0x6, 0xa, 0x94, 0x48, 0x4e,
0x99, 0x57, 0x6f, 0x8c, 0x8f, 0x8f,
0xef, 0xda, 0xb5, 0xb, 0xfb, 0x3f,
0xc7, 0xc7, 0xc7, 0x31, 0xd9, 0xdb,
0x6d, 0xb4, 0x24, 0x75, 0xb8, 0xe4,
0x75, 0x4d, 0x52, 0xd9, 0xe5, 0x7e,
0x81, 0x5f, 0xef, 0x3d, 0xe1, 0x3f,
0xe2, 0x91, 0x26, 0xac, 0x67, 0xfd,
0xee, 0xd1, 0x92, 0x2b, 0x4e, 0x33,
0x6, 0x36, 0xbd, 0xce, 0x90, 0xb4,
0xef, 0xc0, 0x84, 0x2d, 0x61, 0x4e,
0xa4, 0x97, 0x1, 0xaf, 0xd4, 0xe1,
0x5a, 0x41, 0xc, 0xbf, 0xd4, 0x4f,
0xe9, 0xd4, 0x9, 0xb0, 0x8e, 0xda,
0x8c, 0xd1, 0x31, 0x38, 0x6f, 0x72,
0x72, 0xf2, 0xe9, 0xa7, 0x9f, 0x7e,
0xf6, 0xd9, 0x67, 0x1b, 0xbe, 0x97,
0xcb, 0xe5, 0xfc, 0x7a, 0x2d, 0x76,
0xa1, 0x9, 0x84, 0x5e, 0xc3, 0x18,
0x33, 0x32, 0x38, 0x38, 0x3a, 0x3a,
0xea, 0x38, 0x4e, 0x71, 0x70, 0x68,
0x45, 0x6, 0x4c, 0xb4, 0x59, 0xe9,
0x85, 0x68, 0x42, 0xfb, 0xc5, 0xc0,
0xa8, 0x54, 0x8a, 0x97, 0x13, 0x4,
0xc1, 0xb1, 0x63, 0xc7, 0x62, 0x8e,
0xe4, 0x94, 0x83, 0x60, 0x8c, 0xe1,
0x4d, 0x68, 0x4, 0x8, 0x21, 0x2e,
0xbf, 0xfc, 0x72, 0x4, 0xb5, 0x2e,
0x2c, 0x2c, 0xcc, 0xcd, 0xcd, 0x2d,
0x41, 0xbd, 0xbf, 0x1c, 0xbf, 0xda,
0x10, 0xa0, 0x94, 0x1b, 0x2, 0x93,
0x93, 0x93, 0x78, 0xd, 0xa8, 0xb9,
0xfe, 0xe8, 0xa3, 0x8f, 0x8e, 0x8c,
0x8c, 0x20, 0x7e, 0x40, 0x6b, 0xfd,
0xc6, 0x37, 0xbe, 0xd1, 0x18, 0xb3,
0xb8, 0xb8, 0xa8, 0xe4, 0x2, 0xe3,
0x44, 0x49, 0x4c, 0x35, 0xa0, 0xdb,
0xdc, 0xea, 0x96, 0xd6, 0x5a, 0x62,
0x11, 0x8c, 0x73, 0xce, 0x6c, 0x86,
0x1c, 0x42, 0x49, 0x5d, 0xc7, 0xb6,
0x1c, 0xac, 0x95, 0x51, 0xca, 0x5f,
0x77, 0xee, 0xf6, 0x47, 0x1e, 0x79,
0x64, 0x78, 0x68, 0xd4, 0xcd, 0xd8,
0x42, 0x8, 0x8b, 0x1b, 0xa4, 0x92,
0x38, 0xfb, 0xec, 0xb3, 0x77, 0xec,
0x78, 0x13, 0x96, 0xb8, 0x51, 0x91,
0xa4, 0xb7, 0x9d, 0xe9, 0xa4, 0xf0,
0xa8, 0xd, 0xa1, 0x0, 0x9a, 0x1a,
0x4a, 0x88, 0x6, 0x43, 0xc, 0xd1,
0xed, 0x6c, 0x9b, 0x3d, 0x39, 0x13,
0xc9, 0xab, 0x5c, 0x94, 0x97, 0x33,
0xb1, 0x53, 0xe9, 0xcd, 0x7e, 0xb7,
0xc3, 0x2c, 0xe9, 0x31, 0xc4, 0x3c,
0x84, 0xbd, 0x76, 0x7c, 0xdd, 0x75,
0xe6, 0xba, 0x63, 0xaf, 0x6d, 0xf,
0x7d, 0x4d, 0xc7, 0x7e, 0x6c, 0x9a,
0xd2, 0x43, 0xaf, 0x3e, 0xd8, 0x5d,
0xf2, 0x12, 0xcc, 0x92, 0x2b, 0x57,
0x1c, 0x28, 0x26, 0x7a, 0x3d, 0x96,
0x6d, 0x57, 0x2a, 0x95, 0x6c, 0x26,
0x7f, 0xf6, 0x39, 0xdb, 0x5c, 0xd7,
0x5d, 0x5c, 0x5c, 0x3c, 0x78, 0xf0,
0x60, 0x52, 0x98, 0x44, 0x62, 0xed,
0xa4, 0x79, 0x76, 0x68, 0x68, 0x88,
0x70, 0xd6, 0x68, 0x34, 0x3a, 0x14,
0xa6, 0xda, 0x2f, 0x5f, 0xf7, 0xb4,
0x52, 0x6a, 0x0, 0xa1, 0x78, 0xc9,
0x33, 0x0, 0x30, 0x20, 0x1d, 0x2f,
0x26, 0x6f, 0xf5, 0x5c, 0xe8, 0x31,
0x3, 0x85, 0xf, 0xd7, 0x75, 0x1d,
0xc7, 0x41, 0x2e, 0x91, 0x6a, 0xb5,
0x9a, 0x34, 0x6f, 0x60, 0x7, 0x21,
0xf, 0x44, 0x88, 0x58, 0x4d, 0xac,
0x3b, 0x25, 0xd2, 0x2a, 0x71, 0x63,
0xf4, 0xa, 0xd2, 0x4e, 0xa6, 0xdb,
0x80, 0x8d, 0x51, 0xdd, 0xb1, 0x4d,
0xbd, 0x5e, 0x2f, 0x95, 0x4a, 0x9,
0xdc, 0x44, 0x4a, 0x89, 0x45, 0x40,
0x20, 0xa0, 0x14, 0x0, 0x1, 0x83,
0x72, 0x4f, 0x4, 0xe6, 0xe7, 0x8e,
0xbd, 0xf2, 0xca, 0x2b, 0xbe, 0xef,
0x13, 0x6a, 0x28, 0xb3, 0x36, 0x6c,
0xdc, 0x5c, 0x2c, 0x16, 0xb3, 0xd9,
0x6c, 0x75, 0xa6, 0x3a, 0x30, 0x30,
0x24, 0x4, 0x38, 0xe, 0xb, 0x43,
0xe3, 0x38, 0x4c, 0x8, 0x41, 0x8,
0xc3, 0xc6, 0x7, 0xa5, 0x94, 0x8,
0x25, 0x66, 0xa7, 0x2d, 0x1e, 0x2b,
0xc1, 0xb, 0x11, 0x6c, 0xdc, 0xb4,
0xce, 0xf3, 0xeb, 0xaa, 0x2e, 0x31,
0xe6, 0xd1, 0x92, 0xad, 0x28, 0xc2,
0xa7, 0x2b, 0x9f, 0x4d, 0x6, 0xd4,
0x32, 0xd7, 0xe3, 0x56, 0x82, 0xb0,
0x2d, 0xca, 0xa2, 0x7d, 0x60, 0x33,
0x34, 0xed, 0x5a, 0x77, 0x37, 0x54,
0x2f, 0xbd, 0xf, 0x60, 0x83, 0x41,
0x53, 0x20, 0xb3, 0xad, 0xd3, 0xa0,
0xe7, 0xbc, 0xa4, 0xb0, 0xe2, 0x60,
0xc0, 0xac, 0x30, 0x1f, 0xbb, 0x12,
0x4d, 0x86, 0xbe, 0x1b, 0xe0, 0x92,
0xd3, 0x92, 0x12, 0xca, 0x19, 0x23,
0x7e, 0x50, 0x8b, 0x66, 0xfc, 0xd2,
0x40, 0x6e, 0x60, 0x30, 0x3f, 0x33,
0x3f, 0xb3, 0x7e, 0xfd, 0xfa, 0x48,
0x2b, 0x0, 0xf0, 0xc2, 0x0, 0xc1,
0x40, 0x9e, 0x17, 0x6a, 0x42, 0x3,
0xa5, 0x84, 0xef, 0x4b, 0x1d, 0xb5,
0x90, 0x4b, 0x86, 0x42, 0x13, 0x5c,
0x92, 0xe6, 0xaf, 0x8e, 0x97, 0xc,
0xcc, 0x0, 0x30, 0x83, 0x3b, 0x67,
0x24, 0x22, 0x2c, 0x47, 0x27, 0x1f,
0xb, 0x9b, 0xa6, 0xd4, 0x61, 0x26,
0x9c, 0x92, 0x54, 0xf2, 0xa8, 0x8d,
0x34, 0x27, 0xc9, 0x28, 0x61, 0xc3,
0x86, 0xe3, 0x38, 0xf5, 0x7a, 0xdd,
0x68, 0x60, 0xdc, 0xd2, 0xa, 0xdb,
0xc, 0xc1, 0xe2, 0x2e, 0x4f, 0x8a,
0xd1, 0xb8, 0xd1, 0x61, 0xbe, 0xeb,
0x24, 0x52, 0xc7, 0x3d, 0x26, 0x25,
0x80, 0xd6, 0x3d, 0xc, 0x18, 0xd7,
0x95, 0x4, 0x55, 0xdf, 0xad, 0xe7,
0x90, 0x7c, 0xbd, 0xd1, 0x68, 0xfc,
0xf7, 0xff, 0xf6, 0x27, 0x6b, 0xd6,
0xac, 0xf1, 0x7d, 0x7f, 0x76, 0x7a,
0x6e, 0x6e, 0x6e, 0xee, 0xdc, 0x37,
0x6c, 0x6f, 0xf8, 0x3e, 0xa5, 0xf4,
0xb, 0x5f, 0xf8, 0xbb, 0xd5, 0xe3,
0x63, 0xbe, 0xcf, 0x18, 0xe5, 0x94,
0x65, 0x62, 0xcd, 0xfb, 0x26, 0x4e,
0x55, 0x19, 0xad, 0x81, 0x30, 0x0,
0xa5, 0x14, 0x65, 0xad, 0x39, 0x9a,
0x96, 0x9f, 0x5d, 0xa2, 0xa4, 0xbc,
0xb4, 0x89, 0xf6, 0x76, 0xa1, 0x57,
0x12, 0xd1, 0x2e, 0x51, 0x30, 0xef,
0x4e, 0x93, 0xa4, 0xf3, 0x5, 0x4d,
0x91, 0xd1, 0xd6, 0x17, 0xb5, 0x34,
0xe9, 0x9d, 0x27, 0xee, 0xa9, 0x23,
0xa4, 0xcf, 0xa8, 0x62, 0xa7, 0x51,
0xd4, 0xfa, 0x65, 0x1d, 0x2f, 0x34,
0x29, 0xa5, 0xdc, 0x4e, 0x33, 0x56,
0x27, 0x91, 0x5c, 0x85, 0x95, 0x95,
0x91, 0x56, 0xea, 0x5a, 0x2f, 0x73,
0x23, 0xc1, 0x9d, 0xa, 0x62, 0xa9,
0x24, 0x83, 0xd2, 0xd, 0xc9, 0xf8,
0x24, 0x5b, 0x5c, 0xf2, 0xad, 0xa4,
0xc1, 0xb8, 0x49, 0x3, 0x94, 0x8a,
0x19, 0xb1, 0x40, 0xd3, 0x4c, 0x7f,
0x26, 0xc9, 0x24, 0x5c, 0xdd, 0x10,
0xa2, 0xa4, 0x22, 0x99, 0xe0, 0x52,
0x92, 0x54, 0x51, 0xa2, 0x44, 0xdb,
0xcf, 0x55, 0x4e, 0xbb, 0xfd, 0x29,
0xb5, 0x40, 0xe8, 0x68, 0x8d, 0x4c,
0xb5, 0x6d, 0xb4, 0x71, 0x77, 0xf3,
0x24, 0x9a, 0x4d, 0x5e, 0x82, 0x5e,
0xda, 0x19, 0xcd, 0xd4, 0x7c, 0x97,
0x96, 0x64, 0xf2, 0xac, 0x49, 0xf7,
0xeb, 0x29, 0xeb, 0xa5, 0xc9, 0x3b,
0xe8, 0xdc, 0x37, 0xc5, 0xd0, 0x88,
0xd6, 0x3a, 0x22, 0x6, 0x94, 0x1,
0x4a, 0x40, 0xc7, 0xcf, 0x9e, 0xdf,
0x38, 0x73, 0xcb, 0x69, 0x6f, 0xd8,
0x7e, 0xce, 0x3, 0xf, 0x7c, 0xff,
0xdc, 0x73, 0xcf, 0x7d, 0xfe, 0x97,
0xcf, 0x7, 0x81, 0x18, 0x1c, 0x1c,
0x7e, 0xea, 0xa9, 0xa7, 0xb6, 0x9e,
0x75, 0xe6, 0xdc, 0xdc, 0xdc, 0xee,
0xdd, 0x57, 0xbe, 0xf0, 0xc2, 0xb,
0x61, 0x18, 0x49, 0xad, 0xb4, 0x54,
0x8c, 0x50, 0x65, 0x92, 0xce, 0x2f,
0x40, 0x21, 0x69, 0xc6, 0x98, 0x8,
0x1b, 0xe, 0xe3, 0xe9, 0x98, 0xa1,
0x55, 0x5f, 0xe9, 0x93, 0xa3, 0xe8,
0xdb, 0x38, 0x96, 0xae, 0x71, 0x2d,
0x6f, 0x6a, 0x92, 0x13, 0x55, 0xbf,
0xbb, 0x11, 0x7d, 0xba, 0x29, 0x9e,
0xd3, 0xec, 0x89, 0x8b, 0xeb, 0x21,
0xda, 0x10, 0x30, 0x40, 0x69, 0x4c,
0xc5, 0x4, 0xed, 0x5, 0xfd, 0xb4,
0x28, 0x49, 0x32, 0x17, 0xbb, 0x31,
0x83, 0x26, 0xd5, 0x81, 0x98, 0xf8,
0x1a, 0x28, 0x56, 0x44, 0x62, 0x2,
0xe4, 0x1e, 0x5e, 0xba, 0x79, 0xed,
0x2, 0x1, 0x2, 0xff, 0xe1, 0x8f,
0xe4, 0x6c, 0x93, 0xa1, 0x83, 0x26,
0x48, 0x15, 0x4e, 0x24, 0xbb, 0xd9,
0x31, 0x50, 0x5a, 0x9a, 0x44, 0x6c,
0x4d, 0xab, 0xd8, 0xe, 0x51, 0x75,
0x29, 0x2e, 0xc4, 0x26, 0xf7, 0xab,
0xe9, 0xbb, 0xe5, 0x72, 0xb9, 0x6a,
0xb5, 0x8a, 0x1a, 0xeb, 0x8d, 0x46,
0x3, 0x33, 0x4f, 0x90, 0x42, 0x5c,
0x77, 0x0, 0x93, 0x4d, 0x9b, 0xc0,
0x45, 0xeb, 0xc6, 0xb5, 0x35, 0x7e,
0x37, 0x3b, 0xba, 0xb4, 0xd6, 0xc6,
0x74, 0x4c, 0x2f, 0xcd, 0x93, 0xdc,
0x32, 0x73, 0x9c, 0x50, 0x29, 0x11,
0x8a, 0xc1, 0xc1, 0x41, 0xcf, 0xab,
0x7b, 0x9e, 0x7, 0x46, 0x8f, 0x8d,
0x8d, 0xcd, 0xcf, 0xcf, 0x87, 0x61,
0x98, 0xcf, 0xb8, 0x9, 0x81, 0x23,
0x76, 0x7e, 0xfa, 0xbe, 0x5f, 0x28,
0x14, 0x8e, 0x1c, 0x39, 0x72, 0xde,
0x79, 0xe7, 0x69, 0xa5, 0x2d, 0xcb,
0xf2, 0x3c, 0x1f, 0x3f, 0x7f, 0xe4,
0xc8, 0x91, 0xc1, 0xc1, 0x41, 0x6d,
0xe4, 0xf0, 0xf0, 0x70, 0x10, 0x78,
0xeb, 0xd6, 0x6e, 0x3c, 0x74, 0xf8,
0x57, 0xa3, 0xa3, 0xa3, 0xc8, 0x8,
0xf, 0x8a, 0x10, 0x4d, 0x89, 0xd1,
0xa0, 0x71, 0x4, 0x34, 0x21, 0x24,
0x9b, 0x2b, 0x78, 0x41, 0x3d, 0x79,
0xe, 0x42, 0xff, 0x8c, 0x33, 0xce,
0x38, 0xe5, 0x94, 0x53, 0xb6, 0x9d,
0xb9, 0x39, 0x8, 0x82, 0x47, 0x7f,
0xf8, 0xe8, 0xe1, 0xc3, 0x2f, 0x48,
0xa9, 0x2f, 0xba, 0xe8, 0xc2, 0x77,
0xbf, 0xfb, 0xdd, 0x2f, 0xbe, 0xf8,
0x62, 0xc3, 0xf, 0x7, 0x7, 0x7,
0xf7, 0xee, 0xfd, 0x5e, 0x26, 0x97,
0xf, 0x48, 0xc4, 0x39, 0x7, 0x23,
0x1, 0x8, 0x68, 0xd0, 0x4a, 0x6a,
0x23, 0x8c, 0x51, 0x9a, 0x0, 0x73,
0x1c, 0x63, 0xe2, 0x4e, 0x1a, 0x64,
0x69, 0xd1, 0xcd, 0x7a, 0xf, 0xe9,
0xb3, 0xb3, 0xf4, 0xab, 0x72, 0x9f,
0x54, 0x8e, 0xd1, 0x9c, 0xe8, 0x10,
0xdd, 0x71, 0x87, 0xee, 0xcc, 0x6,
0x99, 0x36, 0x8d, 0x9c, 0xe, 0x73,
0x68, 0x5a, 0xa3, 0xe9, 0x90, 0x89,
0xa5, 0x94, 0xea, 0xf6, 0x66, 0xaf,
0xc4, 0x9e, 0xa3, 0x48, 0xb6, 0x3,
0x6c, 0xc, 0x21, 0x40, 0x29, 0x55,
0x52, 0x77, 0xe5, 0xb1, 0x4e, 0xda,
0x8c, 0x5e, 0x9b, 0x18, 0x78, 0xc9,
0xc5, 0x40, 0xaf, 0x68, 0x5b, 0x26,
0xc0, 0x63, 0xc5, 0x53, 0x68, 0x71,
0xb3, 0x75, 0x20, 0x90, 0x21, 0x45,
0x19, 0x87, 0xce, 0xb0, 0x6e, 0x1a,
0x58, 0x13, 0x96, 0x2c, 0x84, 0xd0,
0x14, 0x48, 0x2, 0x79, 0x4a, 0xd4,
0xe4, 0x31, 0x45, 0x5c, 0xad, 0x56,
0x4f, 0x39, 0xe5, 0x14, 0x14, 0x9d,
0x2a, 0x16, 0x8b, 0x61, 0x18, 0x62,
0xae, 0x14, 0xfb, 0xcf, 0x3a, 0xb6,
0x10, 0x0, 0x60, 0x24, 0xf6, 0x49,
0x9b, 0xab, 0x77, 0x6b, 0x21, 0x4e,
0x95, 0x60, 0x5b, 0x4c, 0xcf, 0x84,
0xe2, 0xa6, 0x8f, 0x5c, 0x9, 0x29,
0x46, 0xe, 0xc, 0x47, 0x39, 0xe7,
0x3c, 0xcb, 0x90, 0xe, 0x36, 0x9b,
0xcd, 0x66, 0x5c, 0xe7, 0xc0, 0x81,
0x3, 0x97, 0x5d, 0x76, 0xd9, 0x7,
0x3f, 0xf8, 0xde, 0xe9, 0xa9, 0x85,
0x2f, 0x7f, 0xf9, 0xcb, 0x61, 0x18,
0x2e, 0x2e, 0x2e, 0x4a, 0x29, 0x6f,
0xbb, 0xed, 0xb6, 0x81, 0x1, 0xa7,
0x5e, 0x57, 0x8e, 0xc3, 0x2c, 0xb,
0x1e, 0x7c, 0xf0, 0xb1, 0xaf, 0x7d,
0xed, 0x6b, 0x5b, 0xb7, 0x6e, 0x7d,
0xf2, 0xc9, 0x27, 0xdf, 0xfb, 0xde,
0xf7, 0x7e, 0xfa, 0xd3, 0x1f, 0xc7,
0xe1, 0x38, 0xf0, 0xdc, 0xf3, 0xf7,
0xdc, 0xf3, 0x4f, 0xaf, 0xbc, 0xf2,
0xa, 0xee, 0xb7, 0xba, 0xa9, 0x73,
0x9e, 0xbe, 0xc, 0x5c, 0x72, 0x5e,
0x79, 0xe5, 0x95, 0xc1, 0xe1, 0x52,
0xf2, 0x7c, 0xd6, 0xd9, 0x67, 0xde,
0x7f, 0xff, 0xfd, 0xb6, 0x6d, 0xff,
0xee, 0x55, 0x6f, 0xdb, 0xb6, 0x6d,
0xdb, 0xed, 0xb7, 0xdf, 0x5e, 0x2c,
0xe6, 0x8d, 0x81, 0x23, 0x47, 0x26,
0xe6, 0xe7, 0xe7, 0x83, 0x20, 0xf8,
0xf1, 0x8f, 0x1f, 0x13, 0x42, 0xac,
0x5b, 0xb7, 0x6e, 0x76, 0x7e, 0xc1,
0xb5, 0x2d, 0x63, 0x88, 0xc0, 0xa5,
0x4b, 0x43, 0x7, 0xdb, 0x28, 0xa1,
0xbd, 0x5b, 0xa9, 0xc8, 0xa, 0xc1,
0x6, 0xfa, 0x24, 0xdc, 0x3c, 0x63,
0x96, 0x5d, 0xd4, 0x6d, 0x5a, 0x2c,
0xeb, 0x7a, 0xd1, 0x40, 0x7, 0xa5,
0x68, 0xf3, 0x47, 0x68, 0x62, 0xc0,
0x69, 0xf6, 0xd9, 0xb4, 0x71, 0xa6,
0x29, 0x50, 0x9a, 0xa4, 0x62, 0x24,
0xe1, 0xf, 0x4a, 0xed, 0x48, 0xa6,
0xb3, 0x30, 0xfe, 0x6a, 0xd, 0xf8,
0x35, 0xcb, 0x36, 0xaf, 0xd4, 0x80,
0x7b, 0xb1, 0x7f, 0x18, 0x0, 0x20,
0xa0, 0x93, 0x51, 0x4a, 0xc6, 0xaa,
0x7b, 0xfc, 0xdb, 0xc9, 0x3, 0xe3,
0xf8, 0x33, 0xc1, 0x42, 0x5, 0x81,
0x17, 0x4, 0x1, 0x85, 0x16, 0x62,
0x2, 0x71, 0xa, 0x58, 0x3d, 0x51,
0x4a, 0xad, 0x5d, 0xbf, 0xee, 0xea,
0xab, 0xaf, 0x3e, 0x70, 0xe0, 0xc0,
0xb7, 0xbe, 0xf5, 0x2d, 0x24, 0x3c,
0x45, 0x4a, 0x9, 0xe4, 0x15, 0xe9,
0xf8, 0x71, 0x63, 0x4c, 0x3e, 0x9b,
0x41, 0x48, 0x2c, 0x22, 0xea, 0x6d,
0xdb, 0x46, 0x86, 0xe0, 0x76, 0x69,
0xc1, 0x16, 0xcb, 0x4d, 0x92, 0x9a,
0x6e, 0xf1, 0xba, 0xa1, 0xf5, 0xb,
0x21, 0x90, 0x29, 0x5f, 0x8a, 0xa8,
0x56, 0xab, 0xad, 0x5e, 0x3d, 0x7a,
0xed, 0xb5, 0xd7, 0x6e, 0xdc, 0x30,
0x66, 0x71, 0x0, 0x80, 0x7a, 0x23,
0xc6, 0xa6, 0x37, 0x1a, 0x8d, 0x8f,
0x7c, 0xe4, 0x23, 0x5b, 0xb6, 0xac,
0xff, 0xf5, 0xaf, 0x27, 0x6f, 0xba,
0xe9, 0xf3, 0x43, 0x43, 0x43, 0xc6,
0x98, 0xd3, 0x4e, 0x3b, 0xed, 0xfd,
0xef, 0x7f, 0xef, 0xa5, 0x97, 0x5e,
0x7a, 0xfb, 0xed, 0xb7, 0xdf, 0x72,
0xcb, 0x2d, 0x8d, 0x46, 0xe3, 0xf3,
0x9f, 0xff, 0xf2, 0xe4, 0xe4, 0xe4,
0xaf, 0x7e, 0xfd, 0xfc, 0xde, 0xef,
0xdc, 0xfb, 0x5b, 0xe7, 0xdc, 0x7c,
0xdb, 0x6d, 0x7f, 0x27, 0xf5, 0x7c,
0xad, 0x56, 0xe3, 0xdc, 0x46, 0x44,
0x38, 0x76, 0x3f, 0x27, 0x31, 0xba,
0x31, 0x66, 0x68, 0x68, 0x28, 0x14,
0x7e, 0xf2, 0x7c, 0xf1, 0xc5, 0x17,
0x4f, 0x1d, 0x7d, 0xb9, 0x5e, 0xaf,
0xaf, 0x59, 0xb3, 0xe6, 0xae, 0xbb,
0xee, 0x9a, 0x78, 0x79, 0x22, 0x9b,
0xcd, 0x4b, 0xa9, 0x1d, 0xc7, 0x72,
0x32, 0xf6, 0x87, 0x3e, 0xf4, 0x21,
0x5c, 0x62, 0x2e, 0xb9, 0xe4, 0x92,
0x7b, 0xef, 0xbb, 0x3f, 0x10, 0x11,
0x76, 0xf0, 0xa0, 0xfe, 0x70, 0x42,
0x2a, 0x80, 0x61, 0x63, 0x47, 0x14,
0x91, 0x64, 0xe6, 0x94, 0xd2, 0xdd,
0x79, 0xa9, 0xbe, 0x41, 0xda, 0x92,
0x46, 0xde, 0xef, 0x5b, 0xfd, 0x66,
0x65, 0xdf, 0x16, 0xb6, 0x4e, 0x91,
0xd2, 0x36, 0x1d, 0xf0, 0x62, 0xb1,
0x78, 0xef, 0xbd, 0xdf, 0xde, 0xb7,
0x6f, 0xdf, 0xee, 0xdd, 0xbb, 0x8d,
0x31, 0xcf, 0x3c, 0xf3, 0xcc, 0x79,
0xe7, 0x9d, 0x57, 0x2a, 0x95, 0x1e,
0x7a, 0xe8, 0x21, 0xa5, 0xd4, 0xce,
0x9d, 0x3b, 0xb1, 0x4a, 0x87, 0xa5,
0xb2, 0x6f, 0x7e, 0xf3, 0x9b, 0x9b,
0x36, 0x6d, 0x3a, 0xe7, 0x9c, 0x73,
0x9e, 0x7a, 0xea, 0x29, 0x0, 0x58,
0x58, 0x58, 0x78, 0xc7, 0x3b, 0xde,
0x31, 0x3f, 0x3f, 0xff, 0xdd, 0xef,
0x7e, 0xf7, 0x4d, 0x6f, 0xda, 0x31,
0x34, 0x34, 0xb4, 0x77, 0xef, 0xde,
0x2d, 0x5b, 0xb6, 0x5c, 0x71, 0xc5,
0xe5, 0x8f, 0x3f, 0xfe, 0xb8, 0xe7,
0x79, 0x17, 0x5c, 0x70, 0xc1, 0xaf,
0x7f, 0xfd, 0xeb, 0xdf, 0xfc, 0xe6,
0x37, 0x97, 0x5c, 0xf2, 0xe6, 0x1d,
0x3b, 0x76, 0xcc, 0xce, 0xce, 0x4a,
0x29, 0x7, 0x7, 0x7, 0x83, 0x20,
0x50, 0x4a, 0xad, 0xd4, 0x9e, 0x97,
0x5e, 0x1c, 0x97, 0x6f, 0xae, 0x4b,
0xb8, 0xbb, 0x84, 0x9a, 0x15, 0x79,
0x4, 0xc6, 0xc8, 0x24, 0x5, 0x83,
0x53, 0x2e, 0xdd, 0x1e, 0x83, 0xc8,
0x4a, 0xb4, 0x55, 0xdf, 0xf7, 0x65,
0xf3, 0x81, 0x1b, 0xf, 0x63, 0xcc,
0xf3, 0xea, 0x51, 0x14, 0x5d, 0xb6,
0xeb, 0xd2, 0xb7, 0xbc, 0xe5, 0x2d,
0x0, 0xf0, 0xd2, 0x4b, 0x2f, 0x3d,
0xf2, 0xc8, 0xf, 0x2e, 0xbb, 0xec,
0xb2, 0x7c, 0x36, 0xfb, 0xcc, 0x33,
0xcf, 0xbc, 0xf1, 0x8d, 0x6f, 0xc,
0xc3, 0xf0, 0x27, 0x8f, 0x3f, 0xbe,
0x6d, 0xdb, 0x36, 0xd7, 0xb6, 0xb6,
0x9c, 0x7e, 0xda, 0xc5, 0x3b, 0x2e,
0x1a, 0x18, 0x18, 0xd8, 0xb1, 0x63,
0x7, 0xb2, 0x82, 0x2e, 0x2c, 0x2c,
0x5c, 0x79, 0xe5, 0x95, 0xdb, 0xb7,
0x6f, 0xbf, 0xeb, 0xae, 0xbb, 0x76,
0xed, 0xda, 0xf5, 0xba, 0xd7, 0x9d,
0x35, 0x3d, 0x3d, 0x7f, 0xf8, 0xf0,
0xe1, 0x43, 0x87, 0xe, 0xbd, 0xed,
0x6d, 0x6f, 0x1b, 0x1f, 0x1f, 0x3f,
0x70, 0xe0, 0xc0, 0xe8, 0xe8, 0xea,
0xf5, 0xeb, 0xc7, 0x1e, 0x7a, 0xe8,
0x47, 0x8f, 0x3c, 0xf2, 0x48, 0x3e,
0x9f, 0x8f, 0x1b, 0x57, 0x8c, 0x41,
0xdd, 0xcc, 0xe, 0xca, 0x71, 0xad,
0xd, 0x2a, 0x75, 0xb5, 0x44, 0xd3,
0x5c, 0xd7, 0xf5, 0x3c, 0x8f, 0x53,
0x66, 0xdb, 0xb6, 0xef, 0xfb, 0x77,
0xde, 0x79, 0x67, 0x36, 0xe3, 0x46,
0x51, 0xf4, 0xfe, 0xf7, 0xbf, 0xff,
0xec, 0xb3, 0x36, 0x3d, 0xb7, 0x6f,
0x2, 0x9d, 0xfb, 0x3b, 0xee, 0xb8,
0x83, 0x10, 0x32, 0x34, 0x34, 0x14,
0x45, 0xd1, 0xb3, 0xcf, 0x3e, 0xfb,
0xbe, 0xf7, 0xbd, 0xef, 0xda, 0x6b,
0x7f, 0x17, 0x0, 0xfe, 0xf1, 0x1f,
0xef, 0x59, 0x5c, 0x5c, 0xfc, 0xc2,
0x17, 0xbe, 0x80, 0x4b, 0xc8, 0xeb,
0x5f, 0xff, 0xfa, 0xbf, 0xfc, 0xab,
0x5b, 0xa4, 0x82, 0xf, 0x7e, 0xf0,
0x43, 0x83, 0x3, 0xa3, 0xb9, 0xc2,
0x80, 0xef, 0xfb, 0x99, 0x4c, 0xe,
0xc9, 0x34, 0xa4, 0x94, 0xb6, 0x13,
0xb3, 0xc6, 0xe0, 0xce, 0x8f, 0x2b,
0x59, 0xf2, 0x7c, 0xf6, 0xb6, 0x4d,
0xe7, 0xdc, 0xf2, 0xbf, 0x30, 0xdf,
0xfa, 0x47, 0x7f, 0xf4, 0x47, 0xb9,
0x8c, 0xdd, 0x68, 0x48, 0xce, 0xb9,
0xe3, 0x80, 0x1, 0x88, 0x24, 0xdc,
0x72, 0xcb, 0x2d, 0x8e, 0xd, 0x6,
0xe0, 0x9f, 0xee, 0xb9, 0x17, 0x77,
0x60, 0xa5, 0x94, 0x6d, 0xdb, 0x5e,
0xc3, 0x47, 0xc0, 0x86, 0xd6, 0xda,
0x18, 0xda, 0x51, 0x34, 0x6b, 0x93,
0x86, 0xc0, 0xd4, 0x77, 0x87, 0x11,
0x2e, 0xb9, 0x75, 0x68, 0xd2, 0xc7,
0x80, 0x4f, 0x34, 0x9d, 0xfa, 0xa1,
0xca, 0x7b, 0xe5, 0xc0, 0xd3, 0xd5,
0x85, 0x34, 0xba, 0xdd, 0xb7, 0x33,
0x99, 0x35, 0xeb, 0xd7, 0x1d, 0x38,
0xf8, 0xef, 0x2f, 0x1f, 0x9d, 0x38,
0xeb, 0xac, 0xb3, 0x76, 0x5e, 0xf2,
0xe6, 0xed, 0xdb, 0xb7, 0xef, 0x7f,
0x76, 0xbf, 0xef, 0x87, 0x3b, 0x77,
0xee, 0xdc, 0xb5, 0xeb, 0xb2, 0x4a,
0xa5, 0x2, 0xf0, 0xdd, 0x63, 0xc7,
0xa6, 0x37, 0x6f, 0x3e, 0x63, 0xcf,
0x9e, 0x6b, 0xb3, 0xd9, 0xac, 0x10,
0xc2, 0xb6, 0x5d, 0xfc, 0x59, 0x29,
0xf5, 0xa1, 0x43, 0x87, 0xd7, 0xaf,
0xdf, 0x70, 0xe9, 0xa5, 0x97, 0xe,
0xd, 0xd, 0xad, 0x5f, 0xbf, 0x5e,
0x8, 0x71, 0xfc, 0xf8, 0xcc, 0xe4,
0xe4, 0xb1, 0x81, 0x81, 0x81, 0x5c,
0xae, 0x90, 0xcf, 0xe7, 0x85, 0x10,
0xc7, 0x8f, 0x4f, 0xcf, 0xcf, 0x2f,
0x18, 0x3, 0x94, 0x32, 0xcf, 0xf3,
0x2b, 0x95, 0x72, 0xb6, 0x90, 0x5f,
0xa9, 0xe7, 0x4b, 0xc8, 0x92, 0xc0,
0xc, 0xb3, 0x94, 0x27, 0xb2, 0xdc,
0x87, 0x5a, 0xd9, 0xa7, 0x59, 0x4b,
0x38, 0xd2, 0x74, 0xbb, 0xb2, 0x1d,
0x2c, 0x31, 0x49, 0xaf, 0x2b, 0x5a,
0x78, 0x18, 0x86, 0x16, 0xe3, 0x5e,
0xbd, 0x1, 0x0, 0xf9, 0x1c, 0xbb,
0xe7, 0xde, 0xef, 0xfc, 0xf0, 0x87,
0x3f, 0xfc, 0x9d, 0xdf, 0xfe, 0xed,
0x33, 0x36, 0x6f, 0x7e, 0xfc, 0xf1,
0x9f, 0x3c, 0xff, 0xfc, 0x2f, 0x5d,
0xd7, 0x7e, 0xe7, 0x3b, 0xdf, 0xfe,
0xd0, 0xc3, 0xf, 0x3f, 0xfd, 0xf4,
0xd3, 0xa7, 0x9f, 0x7e, 0xfa, 0xa1,
0x43, 0x87, 0x9e, 0x7d, 0xf6, 0xd9,
0x8b, 0x14, 0x53, 0x9c, 0x8a, 0x0,
0x0, 0xc, 0x5, 0x49, 0x44, 0x41,
0x54, 0x2e, 0xba, 0x88, 0x31, 0x86,
0x65, 0x5a, 0xfc, 0xb5, 0x58, 0xb6,
0x42, 0x4a, 0xcf, 0x13, 0x77, 0xdd,
0x75, 0xd7, 0xaf, 0x7e, 0xf5, 0xab,
0xcd, 0x9b, 0x37, 0x97, 0xcb, 0xe5,
0xa9, 0xa9, 0xa9, 0x7b, 0xee, 0xb9,
0xe7, 0x94, 0x53, 0x36, 0xee, 0xd9,
0xb3, 0xa7, 0x58, 0x2c, 0xc6, 0x3c,
0xa1, 0x8c, 0x35, 0x33, 0xca, 0x2a,
0x11, 0xbe, 0xa5, 0x34, 0x86, 0x76,
0xb7, 0x80, 0x1c, 0x38, 0x88, 0x49,
0x87, 0xbd, 0x6, 0x92, 0xf0, 0x0,
0x21, 0xbb, 0x27, 0x52, 0x43, 0xa3,
0x87, 0x80, 0x3f, 0x34, 0x31, 0x31,
0x31, 0x3c, 0x3c, 0xfc, 0xd7, 0x7f,
0xfd, 0xd7, 0x83, 0x83, 0xee, 0xfe,
0xfd, 0x2f, 0xfc, 0xe5, 0x5f, 0x7e,
0xfe, 0x37, 0xbf, 0xf9, 0xd, 0x92,
0xc5, 0x9e, 0x72, 0xca, 0x29, 0x8d,
0x46, 0x3, 0x89, 0xb9, 0x8e, 0xbc,
0xfc, 0xe2, 0x7, 0x3e, 0xf0, 0x81,
0xaf, 0x7f, 0xed, 0xae, 0x87, 0x1e,
0xfa, 0xc9, 0xf7, 0x1f, 0x7c, 0x38,
0xce, 0x83, 0x77, 0xd1, 0xe8, 0xe0,
0x60, 0x59, 0x16, 0x8d, 0xa2, 0xd6,
0xf3, 0xcb, 0x13, 0x73, 0x5f, 0xbe,
0xe3, 0x8b, 0xf9, 0x7c, 0xfe, 0x3,
0xef, 0xbb, 0xf6, 0xee, 0xbb, 0xef,
0xae, 0x2c, 0x56, 0x90, 0x2e, 0x33,
0xc, 0xfd, 0x91, 0x55, 0xc3, 0x37,
0xdd, 0x74, 0xd3, 0xa7, 0x6f, 0xf9,
0xb, 0xdf, 0xf7, 0x3f, 0xf2, 0x91,
0x3f, 0x97, 0x52, 0x6, 0x22, 0x72,
0x6d, 0xab, 0x54, 0x1c, 0x20, 0x84,
0xe5, 0xb2, 0xc5, 0x85, 0x85, 0xb9,
0x1e, 0x9, 0x89, 0x16, 0x49, 0x8d,
0x84, 0x65, 0x60, 0x3c, 0x97, 0xb9,
0x39, 0xb4, 0x0, 0x6a, 0xbd, 0x66,
0xa0, 0xec, 0x85, 0xa6, 0x48, 0xe5,
0x7b, 0x57, 0x10, 0x25, 0x5a, 0x96,
0xf5, 0xd2, 0x4b, 0x2f, 0x79, 0x9e,
0xb7, 0x63, 0xc7, 0x8e, 0x5d, 0xbb,
0x76, 0x1d, 0x3d, 0x7a, 0xf4, 0x1b,
0xdf, 0xf8, 0xc6, 0xfe, 0xfd, 0xfb,
0xb7, 0x9d, 0xb1, 0x6d, 0x70, 0x60,
0x78, 0x66, 0x7a, 0xee, 0xe5, 0x23,
0x13, 0x41, 0x10, 0x4c, 0x4d, 0x1e,
0x1f, 0x1f, 0x1f, 0x3f, 0x74, 0xf0,
0xf0, 0xa3, 0x8f, 0x3e, 0x7a, 0xfd,
0xf5, 0xd7, 0x8f, 0x8d, 0x8d, 0x65,
0xdc, 0x1c, 0x0, 0x30, 0x6a, 0xf9,
0x5e, 0x98, 0xcd, 0xe4, 0xa7, 0x8f,
0xcf, 0x1e, 0x9b, 0x9a, 0xae, 0x56,
0xea, 0x8f, 0xfd, 0xf8, 0xa7, 0x23,
0x23, 0x23, 0xc3, 0x23, 0x83, 0xb9,
0x5c, 0x6e, 0xd3, 0xa6, 0x4d, 0x1b,
0x37, 0x6e, 0x1c, 0x1e, 0x1e, 0xde,
0xb0, 0x61, 0x93, 0xe3, 0x58, 0x61,
0x18, 0xe2, 0x69, 0xd7, 0xeb, 0x75,
0x42, 0xe8, 0x4a, 0xd3, 0xf5, 0x2b,
0x4a, 0x57, 0x9d, 0x1c, 0x54, 0xfe,
0x24, 0xc2, 0x69, 0x6d, 0x5a, 0xa9,
0xdd, 0xb4, 0x1f, 0x1b, 0x33, 0x5a,
0xa6, 0xf8, 0x9e, 0x30, 0x0, 0x8e,
0xa2, 0x28, 0xa, 0x85, 0xe3, 0x38,
0x9c, 0xf1, 0x6a, 0xb5, 0xea, 0xba,
0x36, 0x4e, 0xa1, 0x5a, 0x5d, 0x1e,
0x9b, 0x9c, 0xc, 0x3c, 0x4f, 0xa9,
0xa8, 0x5a, 0x2d, 0x4f, 0x4d, 0x4d,
0x1d, 0x3a, 0x74, 0x70, 0x62, 0xe2,
0x95, 0xa3, 0x47, 0x8f, 0x4e, 0x4e,
0x4e, 0xe6, 0x72, 0xb9, 0xb5, 0x6b,
0x46, 0xf6, 0xed, 0x13, 0xe5, 0x72,
0xb9, 0x54, 0x2a, 0x25, 0xee, 0x1e,
0x42, 0xf1, 0x57, 0xad, 0x5a, 0x25,
0x84, 0x20, 0x84, 0x4c, 0x4c, 0x4c,
0x2c, 0x2e, 0x2e, 0x62, 0x81, 0xd7,
0x71, 0x9c, 0x72, 0xb9, 0xdc, 0x68,
0x34, 0xb0, 0xdb, 0x9, 0x19, 0x7c,
0xb3, 0xd9, 0x6c, 0xca, 0xd3, 0x8e,
0x12, 0x3, 0xc6, 0x26, 0xad, 0xe6,
0xd0, 0x19, 0x42, 0xc, 0x4f, 0x53,
0xcc, 0x29, 0xa5, 0x40, 0x1b, 0x29,
0xa5, 0x94, 0x4c, 0x4a, 0x29, 0x23,
0x8d, 0x59, 0x2b, 0xcf, 0x7, 0xd7,
0x75, 0xf3, 0xf9, 0x3c, 0x32, 0x6,
0xdd, 0x77, 0xdf, 0x3f, 0x12, 0x2,
0xff, 0xf0, 0xf, 0xf7, 0xee, 0xdb,
0xb7, 0xf, 0xd5, 0x6, 0xf1, 0x78,
0xc3, 0xc3, 0xc3, 0x9f, 0xf9, 0xcc,
0x27, 0x1a, 0xd, 0xbd, 0x77, 0xef,
0xde, 0xaf, 0x7c, 0xe5, 0x2b, 0xa1,
0xf0, 0x47, 0x46, 0x46, 0x0, 0x0,
0x27, 0x44, 0x10, 0x4, 0x52, 0x6a,
0xf4, 0xba, 0xd3, 0x36, 0x8c, 0x17,
0x99, 0x71, 0xa8, 0x94, 0x32, 0x79,
0xbe, 0xff, 0xfe, 0xfb, 0x17, 0x17,
0x17, 0x7f, 0xf6, 0xb3, 0x9f, 0x5d,
0x7e, 0xe9, 0x9b, 0xaf, 0xbb, 0xee,
0xba, 0xc0, 0xb, 0xb6, 0x6c, 0x39,
0x53, 0x8, 0x19, 0x4, 0xde, 0xb,
0xbf, 0x7e, 0x7e, 0x72, 0x72, 0xf2,
0xe0, 0xc1, 0x83, 0x85, 0x42, 0x61,
0xef, 0xde, 0xbd, 0x52, 0x4a, 0xd7,
0xb6, 0xd0, 0x8b, 0xc6, 0x4a, 0x12,
0xae, 0x5b, 0xdd, 0x54, 0x52, 0x9,
0xc9, 0x68, 0xb7, 0xdd, 0xf6, 0xa3,
0x28, 0x38, 0x61, 0xe0, 0xba, 0x74,
0xd0, 0xa7, 0xfb, 0x4c, 0xd3, 0xfe,
0x92, 0x14, 0x7d, 0xa1, 0xb, 0x96,
0x65, 0x6f, 0xd8, 0xb0, 0xa1, 0x5a,
0xad, 0x3e, 0xfc, 0xf0, 0xc3, 0xfb,
0xf6, 0xed, 0xcb, 0x64, 0x32, 0x3,
0x3, 0x3, 0x6f, 0xba, 0x70, 0x87,
0xc3, 0x9d, 0xc5, 0xc5, 0xc5, 0x6a,
0xb5, 0x5a, 0xa9, 0x54, 0xa6, 0xa6,
0xa6, 0xa, 0x85, 0xc2, 0x85, 0x17,
0x5e, 0x8, 0x0, 0x7, 0xf, 0x1e,
0x7c, 0xf0, 0xc1, 0x7, 0x47, 0x47,
0x47, 0xab, 0xd5, 0x2a, 0x34, 0xb9,
0x9d, 0x77, 0xef, 0xde, 0xbd, 0x77,
0xef, 0xde, 0xfb, 0xee, 0xbb, 0x2f,
0x97, 0xcb, 0x79, 0x9e, 0xb7, 0x79,
0xf3, 0xe6, 0x37, 0xbc, 0xe1, 0xd,
0x41, 0x10, 0x3c, 0xf9, 0xe4, 0x93,
0xfb, 0xf7, 0xef, 0xaf, 0xd5, 0x6a,
0xeb, 0xd6, 0xad, 0xdb, 0xb9, 0xf3,
0x22, 0x84, 0xd9, 0x60, 0xed, 0x91,
0x73, 0xee, 0x85, 0xfe, 0x6b, 0x1b,
0x2, 0x9f, 0xf4, 0xa2, 0xf9, 0xaa,
0xf2, 0x61, 0xed, 0xf5, 0xcc, 0x6e,
0x86, 0xb6, 0x8e, 0xe5, 0x5e, 0x29,
0x45, 0x81, 0xf8, 0xbe, 0x8f, 0xf4,
0xa6, 0xc9, 0x8a, 0x36, 0x3b, 0x3b,
0x1b, 0x45, 0xd1, 0x86, 0xd, 0x1b,
0x9e, 0x78, 0xe2, 0x89, 0xb1, 0xb1,
0xb1, 0x2b, 0xae, 0x78, 0xcb, 0x85,
0x17, 0x5e, 0xb0, 0x71, 0xe3, 0xc6,
0xe7, 0x9f, 0x7f, 0x7e, 0x62, 0xf2,
0x7e, 0x4a, 0xe9, 0xa1, 0x5f, 0xfe,
0xe6, 0xf2, 0xcb, 0x2f, 0xd7, 0x5a,
0xef, 0xdf, 0xbf, 0xff, 0x82, 0xb,
0x2e, 0x40, 0x5e, 0xeb, 0x63, 0xc7,
0x8e, 0xd, 0xf, 0xf, 0xbf, 0xf4,
0xd2, 0x4b, 0xd9, 0x6c, 0x76, 0x71,
0x71, 0x31, 0x9f, 0xcf, 0xa3, 0xd7,
0xe9, 0x79, 0x1e, 0x72, 0xe8, 0xd,
0xf, 0xf, 0x17, 0x8b, 0x45, 0xdf,
0xf7, 0x51, 0xc6, 0x28, 0x5d, 0x67,
0x8d, 0x65, 0x6e, 0x8c, 0x31, 0x46,
0x11, 0x62, 0xa7, 0x2b, 0x44, 0x84,
0x10, 0xf2, 0xf6, 0xf7, 0x5c, 0xf,
0x0, 0xb9, 0x5c, 0xee, 0x97, 0x87,
0x7f, 0x75, 0xde, 0x79, 0xe7, 0x51,
0x20, 0x51, 0x14, 0x65, 0x32, 0x8e,
0x10, 0xc2, 0xf7, 0x1a, 0x6b, 0xd6,
0xac, 0xd9, 0xb3, 0x67, 0xcf, 0xd6,
0xad, 0xa7, 0x1d, 0x3e, 0xf8, 0xc2,
0xdd, 0x77, 0xdf, 0x5d, 0x2e, 0x97,
0xbf, 0xfa, 0xd5, 0x3b, 0xa3, 0x8,
0xb0, 0x93, 0xc7, 0xf7, 0x1, 0x85,
0xe0, 0x6b, 0x35, 0x59, 0x28, 0xf0,
0xdf, 0xff, 0xfd, 0x3f, 0xcc, 0x64,
0x32, 0xbb, 0x77, 0xef, 0xde, 0xb9,
0x73, 0xe7, 0xe0, 0xa0, 0xeb, 0x7,
0xfa, 0xf9, 0xe7, 0x9f, 0xff, 0xfe,
0xf7, 0xbf, 0x5b, 0xad, 0x78, 0x95,
0x9a, 0x67, 0x8c, 0x19, 0x19, 0x59,
0xf5, 0xca, 0x2b, 0xaf, 0xfc, 0xf2,
0xf0, 0xb, 0xc3, 0xc3, 0xc3, 0x6e,
0xc6, 0x36, 0xc6, 0x4, 0xc2, 0x3f,
0xf5, 0xd4, 0x4d, 0x94, 0xd2, 0x46,
0xcd, 0xcf, 0x15, 0x32, 0xc9, 0x73,
0x36, 0xe7, 0x6c, 0x7f, 0xfd, 0x39,
0xab, 0x57, 0xaf, 0x3e, 0x63, 0xf3,
0xa9, 0x94, 0xd2, 0x7b, 0xfe, 0xe9,
0x1e, 0xd4, 0xdd, 0x58, 0xb5, 0x6a,
0xe4, 0x86, 0x1b, 0xff, 0x60, 0x6a,
0x6a, 0xea, 0xdf, 0xf6, 0x3f, 0x17,
0x4, 0xc1, 0x53, 0x4f, 0xfd, 0x42,
0x19, 0x18, 0x5d, 0x35, 0x4e, 0xc1,
0x0, 0x25, 0x18, 0xdb, 0x2f, 0xcc,
0xcd, 0x3e, 0xf9, 0xf4, 0x2f, 0x6,
0x7, 0x86, 0x1d, 0xd7, 0x22, 0x84,
0x70, 0xa2, 0x38, 0xa7, 0xf5, 0x7a,
0xfd, 0xba, 0xf7, 0x5d, 0xbb, 0x61,
0xc3, 0x86, 0x26, 0xdf, 0x2d, 0x91,
0x5a, 0x2d, 0x1, 0x6, 0xec, 0x91,
0x3a, 0x6, 0xd2, 0xb1, 0x22, 0x74,
0x7c, 0xb7, 0x1b, 0x67, 0x43, 0x48,
0x8c, 0xd1, 0x5f, 0xfe, 0x3e, 0xd3,
0xab, 0xf2, 0xd4, 0x2a, 0xe8, 0x63,
0xa4, 0x93, 0xcf, 0xe7, 0x6d, 0xdb,
0xf6, 0x3c, 0xaf, 0x5a, 0xa9, 0x4f,
0x4d, 0x4d, 0xfd, 0xfc, 0xe7, 0x3f,
0x3f, 0xe7, 0xac, 0xb3, 0x2e, 0xbc,
0xe8, 0x22, 0xa, 0x50, 0xad, 0xd7,
0xeb, 0xd5, 0x6a, 0x36, 0x9f, 0xcf,
0x67, 0xb3, 0x94, 0x73, 0x46, 0x48,
0xb5, 0x5e, 0x7, 0x0, 0xd7, 0xb6,
0x85, 0x94, 0x8d, 0x5a, 0xad, 0x50,
0x2a, 0x59, 0x8c, 0x65, 0x72, 0x39,
0xaf, 0xe6, 0xcd, 0x2e, 0xcc, 0x5a,
0xd4, 0x72, 0x73, 0xae, 0x6b, 0xdb,
0x86, 0x10, 0x46, 0x48, 0xad, 0xd1,
0x20, 0xc6, 0x84, 0x51, 0x64, 0x31,
0xc2, 0x1d, 0x5b, 0x89, 0x8, 0x18,
0xd2, 0xc, 0xbd, 0x36, 0x3b, 0x70,
0x3f, 0xcc, 0xc9, 0x49, 0xd5, 0x87,
0x57, 0x9a, 0x27, 0xa3, 0xc6, 0x18,
0x6a, 0x80, 0x5a, 0x9c, 0x1a, 0x78,
0xe4, 0xd1, 0x1f, 0x3d, 0xf2, 0xf0,
0x8f, 0xd6, 0xae, 0x5d, 0x2b, 0x9a,
0xa, 0xf, 0xb6, 0x6d, 0x23, 0xbb,
0xd8, 0xe8, 0xe8, 0xea, 0x91, 0x55,
0xa3, 0x88, 0x99, 0xb7, 0x2c, 0x4b,
0x45, 0x92, 0x72, 0x26, 0x45, 0x8,
0x94, 0x50, 0x20, 0xb5, 0x5a, 0x8d,
0x10, 0x52, 0x2a, 0x15, 0x6c, 0xdb,
0xae, 0xd5, 0x6a, 0xa1, 0xf0, 0x31,
0x3b, 0xe8, 0xba, 0xae, 0x8, 0x63,
0x35, 0x2, 0x21, 0x4, 0x5a, 0x63,
0xc2, 0xc8, 0x83, 0x64, 0x9d, 0xc6,
0x18, 0x4, 0x81, 0x15, 0xa, 0x85,
0xa4, 0x98, 0x27, 0xa5, 0x88, 0x22,
0x85, 0x41, 0x2f, 0x36, 0x20, 0x94,
0x4a, 0x25, 0xdf, 0xf7, 0x11, 0x32,
0xa8, 0xb5, 0xa6, 0x94, 0x23, 0x6b,
0xef, 0x8b, 0x2f, 0xbe, 0x98, 0xc9,
0x38, 0xae, 0x6b, 0xe3, 0x15, 0x35,
0x1a, 0x8d, 0x72, 0xb9, 0xcc, 0xa5,
0x52, 0x0, 0x10, 0x49, 0x49, 0x98,
0xe5, 0x5, 0xc2, 0xb6, 0x6d, 0xc2,
0xad, 0x86, 0x27, 0x28, 0x3, 0x27,
0x9b, 0x9f, 0x2f, 0x57, 0xef, 0xf8,
0xdf, 0xff, 0x27, 0x19, 0x5, 0x3b,
0x5f, 0xfa, 0xaf, 0x7f, 0xfc, 0xb1,
0x7e, 0x63, 0x6d, 0x67, 0xf3, 0xa,
0xe0, 0x7b, 0xf, 0x3d, 0xfc, 0xbd,
0x87, 0x1e, 0xee, 0xba, 0x1, 0xd4,
0x50, 0x32, 0x3b, 0x3f, 0xe7, 0xe6,
0xb3, 0xdc, 0x61, 0xc0, 0x8c, 0x32,
0x31, 0x32, 0x41, 0x6b, 0xa2, 0x94,
0xcc, 0x64, 0xed, 0x28, 0x6a, 0x3d,
0x8b, 0xc0, 0x77, 0x9c, 0x8c, 0x94,
0xfa, 0x53, 0x37, 0xdf, 0x72, 0xfd,
0xf5, 0xd7, 0xcf, 0x2c, 0x54, 0xfc,
0x7a, 0x63, 0xd5, 0xaa, 0x55, 0x3f,
0x7b, 0xea, 0xe9, 0xf5, 0xa7, 0x6e,
0x79, 0xe0, 0x81, 0x7, 0xae, 0xb9,
0xe6, 0x1a, 0xa1, 0xe6, 0xa9, 0xe5,
0x44, 0x61, 0x48, 0xc1, 0x30, 0x6a,
0xb4, 0x56, 0x6, 0x8, 0x0, 0x9,
0x44, 0x44, 0x29, 0xe2, 0xda, 0x15,
0x80, 0x91, 0xd4, 0x88, 0x20, 0xa4,
0x9c, 0x79, 0x7e, 0x8, 0x84, 0xd5,
0xea, 0x35, 0x2c, 0xe8, 0x71, 0x46,
0xfa, 0x35, 0x97, 0x90, 0x5e, 0xc9,
0x2d, 0x45, 0xc8, 0x12, 0x7b, 0x8d,
0xe9, 0xd5, 0x7f, 0x73, 0x12, 0x18,
0x26, 0xd5, 0xa7, 0x8f, 0x87, 0x31,
0x6, 0x14, 0xc, 0x18, 0x2f, 0xf0,
0xbc, 0xc0, 0x4b, 0xce, 0x6a, 0xed,
0x29, 0xe3, 0xd7, 0x6c, 0x7c, 0x37,
0x21, 0x64, 0xb1, 0x3a, 0x8f, 0x39,
0x5, 0xb0, 0xc0, 0x17, 0x8d, 0x20,
0xf2, 0xda, 0xd0, 0x6f, 0x3e, 0x32,
0x92, 0x40, 0xb9, 0xb6, 0x40, 0x8,
0x35, 0xe5, 0x39, 0x0, 0x20, 0x1c,
0x14, 0x91, 0x8d, 0xa0, 0xde, 0x8,
0xda, 0xd1, 0x91, 0x4, 0x42, 0xd,
0xa1, 0x2f, 0x8d, 0x31, 0x20, 0xb1,
0xe8, 0x65, 0x56, 0x64, 0x5d, 0x27,
0xf4, 0x62, 0x3a, 0x7, 0x4a, 0x99,
0x95, 0xef, 0xd5, 0xa4, 0x5f, 0x69,
0xbd, 0xfb, 0x75, 0x4c, 0x2b, 0x28,
0xa3, 0x29, 0xa5, 0x44, 0x4b, 0xce,
0x39, 0xb3, 0x38, 0x50, 0x12, 0x46,
0x22, 0xd6, 0xaf, 0x36, 0x5a, 0x83,
0x2, 0x6a, 0xc, 0xd1, 0x91, 0xa,
0xc2, 0xd0, 0x8f, 0xa2, 0x50, 0x69,
0x8, 0x91, 0x9, 0x30, 0xc2, 0xef,
0x83, 0x31, 0x86, 0x3b, 0x2e, 0x21,
0xa4, 0x11, 0x44, 0x8d, 0x20, 0x2,
0xa0, 0xcc, 0xca, 0x19, 0x63, 0xa4,
0x86, 0xba, 0x27, 0x29, 0x65, 0x52,
0x6a, 0xc2, 0x2c, 0x3b, 0x63, 0x5,
0x91, 0x22, 0xdc, 0xb6, 0xb8, 0xdd,
0xda, 0xd8, 0x1, 0x0, 0x20, 0x88,
0x54, 0x26, 0x5f, 0x94, 0x6, 0x50,
0xfb, 0xa, 0x8c, 0x26, 0x84, 0x5b,
0x8e, 0x15, 0x46, 0x92, 0x10, 0xe2,
0x64, 0xb2, 0x0, 0x50, 0xf7, 0x7c,
0x14, 0xc4, 0xc5, 0x65, 0xc5, 0xf7,
0x3d, 0x4a, 0x69, 0x20, 0x42, 0x3c,
0x7f, 0x4a, 0xb9, 0x31, 0xad, 0x22,
0x3f, 0xe7, 0x8c, 0x1, 0x0, 0x67,
0x4c, 0x47, 0x32, 0xa, 0x42, 0xc4,
0xdd, 0x60, 0x77, 0x15, 0xac, 0x4,
0x1e, 0xb8, 0xfc, 0x1b, 0x99, 0xc8,
0x9a, 0x25, 0xdc, 0xab, 0x4a, 0x29,
0x90, 0x1a, 0x38, 0x4d, 0x9e, 0x7,
0x87, 0x8a, 0xf, 0x3f, 0xfc, 0xc3,
0xf1, 0xf1, 0xf1, 0x8f, 0x7f, 0xfc,
0x93, 0x8c, 0xb1, 0xeb, 0xae, 0x7b,
0xff, 0xfd, 0xf7, 0xdf, 0x5f, 0x18,
0x18, 0xfc, 0xc4, 0x4d, 0x9f, 0x94,
0xa, 0x3e, 0x74, 0xc3, 0x87, 0xef,
0xbc, 0xf3, 0xce, 0x6c, 0x36, 0x3b,
0x3d, 0x3d, 0xbd, 0x6a, 0xd5, 0x2a,
0x46, 0x8d, 0x32, 0xf0, 0xe2, 0x91,
0xa3, 0x48, 0x76, 0x93, 0x74, 0x32,
0xe3, 0xee, 0x67, 0x5b, 0x96, 0x31,
0x1c, 0xcb, 0xd7, 0x41, 0x53, 0x4b,
0xc1, 0x75, 0xdd, 0xc0, 0x6f, 0x74,
0xef, 0xa8, 0x4b, 0xec, 0xc, 0x86,
0xac, 0x18, 0x36, 0x74, 0x12, 0x6,
0xac, 0xa1, 0x1f, 0xff, 0x70, 0xef,
0xb5, 0x46, 0x4a, 0x95, 0xc8, 0x11,
0x24, 0x38, 0xb3, 0x44, 0xa2, 0xb5,
0x27, 0x35, 0x3c, 0xa3, 0x56, 0xa,
0x1, 0x2, 0x4b, 0x67, 0xd7, 0x8,
0x35, 0x27, 0x11, 0x3, 0xff, 0x27,
0x18, 0x30, 0x69, 0xaa, 0xa2, 0x2e,
0x27, 0xa8, 0xd6, 0x0, 0x84, 0x1a,
0x66, 0xf1, 0x98, 0x25, 0x37, 0xd2,
0xbe, 0x17, 0x97, 0x67, 0x53, 0x21,
0x15, 0x45, 0xce, 0x59, 0xad, 0x63,
0xba, 0x7c, 0xdb, 0x76, 0x7b, 0xa6,
0x30, 0xfa, 0x5, 0x5c, 0x58, 0x48,
0xef, 0x89, 0xd8, 0xeb, 0x1b, 0x34,
0x91, 0xb6, 0xca, 0x5f, 0x92, 0x9a,
0x49, 0x48, 0xf3, 0xd2, 0xc0, 0x81,
0xd4, 0x3d, 0xa5, 0x28, 0xae, 0x66,
0xc, 0xe1, 0x51, 0x14, 0x2, 0x0,
0x21, 0x19, 0x3, 0x4a, 0x1b, 0x89,
0xb1, 0xbe, 0x36, 0x8a, 0x24, 0x62,
0x8a, 0xaf, 0xe2, 0x9e, 0xf5, 0x6b,
0xdc, 0xe9, 0x40, 0x7b, 0x6a, 0xad,
0x43, 0x3f, 0x74, 0x72, 0x4e, 0xf2,
0x1c, 0x4c, 0x1d, 0x2f, 0x95, 0x4a,
0x33, 0xd3, 0xf3, 0xb7, 0xdf, 0xf6,
0x79, 0x4a, 0x61, 0x70, 0x70, 0xb0,
0x5c, 0xae, 0xd6, 0x6b, 0xfe, 0x97,
0xfe, 0xee, 0xcb, 0x7e, 0x18, 0x94,
0x4a, 0x25, 0x54, 0x9a, 0x5c, 0xbf,
0x7e, 0x7d, 0xbd, 0x5e, 0x3f, 0xfc,
0xab, 0x97, 0xf0, 0x4e, 0x60, 0x19,
0xa0, 0xed, 0xa0, 0x86, 0x10, 0x43,
0xc3, 0xc0, 0x3, 0x80, 0xd0, 0x17,
0x16, 0xb3, 0x89, 0x45, 0x1, 0xa0,
0xbc, 0xb0, 0x48, 0xf8, 0x72, 0x43,
0xdc, 0x26, 0x48, 0x7d, 0xa9, 0xa6,
0x9c, 0x9e, 0xeb, 0x5a, 0x3f, 0x44,
0xf0, 0x12, 0x49, 0x2c, 0xa3, 0xfa,
0x96, 0x37, 0xbb, 0x4b, 0x97, 0x1d,
0x25, 0xc1, 0x74, 0xe4, 0x9f, 0xe6,
0x66, 0xe8, 0xf8, 0x43, 0x36, 0x73,
0x4, 0x1d, 0x7c, 0x29, 0x9, 0x29,
0x5a, 0xba, 0x9e, 0x4c, 0x8, 0x31,
0x2b, 0x4c, 0xf8, 0x9e, 0x44, 0xf4,
0xbb, 0x62, 0xc2, 0x16, 0x0, 0x2,
0xec, 0x84, 0x9e, 0x79, 0xfa, 0x75,
0xce, 0xb9, 0x8c, 0x4, 0x46, 0x8b,
0x42, 0x8, 0x29, 0x22, 0x9b, 0x5b,
0xa0, 0x8d, 0x8, 0xe2, 0x26, 0x61,
0xd0, 0x12, 0xb4, 0xe1, 0x94, 0xa9,
0x48, 0xaa, 0x48, 0xe6, 0x32, 0xd9,
0xba, 0xd7, 0x58, 0x4e, 0xd5, 0x30,
0x79, 0x17, 0x37, 0xd5, 0x9e, 0xd7,
0xd8, 0xef, 0x8e, 0x13, 0x13, 0x3,
0x31, 0x3b, 0x8e, 0x62, 0x59, 0x96,
0x4, 0x68, 0x66, 0x9e, 0x29, 0x68,
0x52, 0xab, 0xd7, 0xa5, 0x8, 0x21,
0x9f, 0x5, 0xda, 0x56, 0xb1, 0xe7,
0xc9, 0xf1, 0x2c, 0xc6, 0x8f, 0x4f,
0x1d, 0x1b, 0x1d, 0x1d, 0xb5, 0x6d,
0x5b, 0x49, 0xd9, 0xa1, 0xd, 0x71,
0xc2, 0x49, 0xd9, 0x1b, 0x4b, 0xd8,
0xdc, 0xc, 0xd1, 0xc0, 0x12, 0x86,
0xba, 0x4, 0x47, 0xa9, 0x94, 0x3a,
0x7e, 0xfc, 0xf8, 0xd0, 0xd0, 0x90,
0xeb, 0xba, 0x4a, 0xab, 0xe4, 0x99,
0x10, 0x12, 0x4, 0x48, 0xba, 0x6f,
0xa4, 0x34, 0x8b, 0x8b, 0x35, 0x0,
0x52, 0xab, 0x35, 0x0, 0x80, 0x2,
0xad, 0x2d, 0xd6, 0x8a, 0xb9, 0x12,
0x10, 0x5d, 0x2e, 0x97, 0xa1, 0xc9,
0x2a, 0x8e, 0x75, 0x60, 0x5c, 0x50,
0x51, 0xec, 0xcb, 0xb2, 0x2c, 0x29,
0xc2, 0x52, 0xb1, 0xd0, 0x68, 0xd4,
0x72, 0xb9, 0xdc, 0x73, 0xcf, 0x3d,
0x37, 0x32, 0x32, 0x32, 0x30, 0x30,
0x0, 0x0, 0xab, 0x57, 0x8f, 0xb,
0x19, 0x62, 0x79, 0xb3, 0x83, 0x6a,
0xb3, 0xbd, 0x86, 0x9e, 0xda, 0x8d,
0x35, 0x5d, 0x29, 0xae, 0xe0, 0xb5,
0xa3, 0x58, 0xe9, 0x1b, 0x45, 0x9f,
0x30, 0x80, 0xef, 0x71, 0x5f, 0x52,
0xd0, 0xae, 0x34, 0x0, 0xb3, 0x37,
0xc9, 0x1, 0x21, 0x40, 0x56, 0xdc,
0xac, 0xfb, 0x1a, 0xa5, 0xa9, 0x4e,
0x6c, 0xc0, 0xcb, 0xdc, 0x81, 0x13,
0x88, 0xa2, 0x94, 0xb2, 0xd1, 0x68,
0x1c, 0x39, 0x72, 0x64, 0x62, 0x62,
0x22, 0xad, 0xed, 0x88, 0x6, 0x86,
0x23, 0xe0, 0xfb, 0x7e, 0x22, 0x67,
0x8f, 0x7a, 0x57, 0x27, 0x2c, 0xfb,
0x9b, 0x98, 0x4c, 0xdf, 0x5e, 0x61,
0x9a, 0x5d, 0x73, 0xca, 0x7a, 0x2a,
0x84, 0x61, 0x34, 0x94, 0xf4, 0xcf,
0x47, 0x51, 0x54, 0xaf, 0xd7, 0xd3,
0xae, 0x50, 0xeb, 0xc3, 0x97, 0x5e,
0x79, 0x15, 0x0, 0xac, 0x5d, 0xbb,
0x76, 0x72, 0x6a, 0x76, 0x76, 0x76,
0x56, 0x6b, 0x5d, 0x2a, 0x95, 0x5c,
0xd7, 0xc5, 0x60, 0xba, 0xd7, 0xa4,
0x5c, 0x41, 0x8f, 0x2b, 0xae, 0x76,
0x41, 0x10, 0xd4, 0x6a, 0x35, 0x6c,
0x86, 0x6a, 0x34, 0x1a, 0x9b, 0x36,
0x6d, 0x4a, 0xa3, 0x82, 0xe6, 0xe7,
0xe7, 0xa3, 0x28, 0x5a, 0x37, 0xb6,
0xe6, 0xe8, 0xf1, 0xa9, 0x75, 0x63,
0x6b, 0x28, 0x5, 0xa4, 0x3e, 0xa4,
0x94, 0x27, 0x8d, 0x7b, 0xed, 0x4c,
0x91, 0x90, 0x10, 0x38, 0xa4, 0x2d,
0xa4, 0x52, 0xa9, 0x68, 0xad, 0xf1,
0x28, 0xc5, 0x62, 0xb1, 0x50, 0x28,
0x58, 0x96, 0xd5, 0x68, 0xd4, 0xb2,
0x9c, 0x15, 0xa, 0x5, 0xcc, 0xef,
0x1d, 0x3b, 0x76, 0x2c, 0x9b, 0xcd,
0x2, 0xc0, 0xdc, 0xdc, 0x9c, 0x9d,
0xb1, 0xd, 0xe9, 0xe1, 0x42, 0xf7,
0xbc, 0x1, 0xc4, 0xb4, 0xd2, 0x4b,
0x27, 0xea, 0x7, 0x6e, 0xf3, 0xdc,
0x56, 0x64, 0xc3, 0xc4, 0x0, 0x3b,
0x51, 0x7, 0x6c, 0x37, 0x4f, 0x58,
0x7, 0x9c, 0xa8, 0xa3, 0x3d, 0x7b,
0xe9, 0x4d, 0xaf, 0x3, 0x41, 0xdd,
0x1, 0xe4, 0x4a, 0x77, 0x7d, 0xff,
0x87, 0xc6, 0xc0, 0xca, 0x98, 0x57,
0xb9, 0x10, 0x2c, 0x1d, 0x3, 0x3,
0x80, 0x51, 0xa, 0xf3, 0xc9, 0x8,
0x54, 0xc6, 0xac, 0x6f, 0xb5, 0x5a,
0xb5, 0xb8, 0x3, 0x29, 0x1a, 0x4d,
0x14, 0x5b, 0xae, 0xd5, 0x6a, 0xc6,
0x18, 0xa4, 0x95, 0x37, 0x27, 0x72,
0x45, 0x53, 0x87, 0x66, 0xcb, 0x5f,
0x58, 0x71, 0x82, 0xd0, 0xf6, 0x8b,
0x4d, 0xfa, 0x9c, 0x2c, 0xcb, 0x42,
0x15, 0x55, 0x44, 0x5f, 0x21, 0x13,
0xe5, 0xea, 0xd5, 0xab, 0x9d, 0x4c,
0xce, 0x76, 0x1d, 0x4c, 0x4a, 0x7b,
0xf5, 0x46, 0xb9, 0x5c, 0x26, 0xe7,
0xbd, 0xe9, 0x62, 0x0, 0x18, 0x1e,
0x1e, 0xe, 0x5, 0x45, 0x72, 0xc,
0xcf, 0xf3, 0x6a, 0xb5, 0x1a, 0xf6,
0xd0, 0xf6, 0x34, 0xe0, 0xe5, 0x4f,
0xca, 0x24, 0x3c, 0x43, 0x92, 0xae,
0x6c, 0x36, 0x8b, 0xd4, 0x1c, 0x49,
0x90, 0x86, 0xbc, 0x73, 0x41, 0xe0,
0x45, 0x41, 0x10, 0xb, 0x49, 0x34,
0x13, 0x77, 0xf8, 0xdd, 0xee, 0x36,
0xe, 0x83, 0x14, 0x4d, 0x5d, 0xeb,
0x48, 0xb9, 0x5c, 0xc6, 0xdf, 0x47,
0x95, 0x50, 0x54, 0x7f, 0x4, 0xd0,
0x19, 0xe, 0x60, 0x68, 0xf7, 0x80,
0x4a, 0x23, 0x97, 0x6, 0x18, 0x75,
0x96, 0x9a, 0x74, 0x6b, 0x8b, 0xee,
0x35, 0xb1, 0x7a, 0xbc, 0xd8, 0x1,
0xfc, 0x38, 0xa1, 0x51, 0x41, 0xaf,
0xa6, 0xf0, 0xe, 0x2b, 0x5a, 0x9a,
0x69, 0xf0, 0x84, 0x5c, 0x59, 0x4b,
0x6c, 0xe, 0x4b, 0xec, 0x15, 0xcb,
0x7f, 0xb1, 0x6d, 0xd5, 0xeb, 0xf2,
0x66, 0x97, 0xa0, 0xd, 0xef, 0xf8,
0xf0, 0x9, 0xf3, 0xf6, 0x69, 0x16,
0xe4, 0x34, 0xd4, 0x94, 0x76, 0xe9,
0x9e, 0xf4, 0x1f, 0x10, 0xda, 0x23,
0xe5, 0x91, 0x42, 0x71, 0x6b, 0x23,
0x97, 0xd9, 0xb4, 0x98, 0x80, 0x70,
0xfa, 0x5d, 0x6c, 0x22, 0xd, 0x9b,
0x76, 0x73, 0x9a, 0x11, 0x90, 0xe9,
0x26, 0x7f, 0x4f, 0x13, 0xbf, 0xe2,
0x1f, 0xae, 0xeb, 0xba, 0x6e, 0x96,
0xdb, 0x2e, 0xbe, 0xab, 0x94, 0xaa,
0x56, 0xcb, 0xe5, 0x72, 0x99, 0x6c,
0xfb, 0xad, 0x73, 0x21, 0x66, 0x21,
0x26, 0xb8, 0x31, 0xc6, 0xa2, 0xe9,
0x9c, 0xa7, 0x64, 0xaf, 0xa0, 0x63,
0xb0, 0xe0, 0xb5, 0x7e, 0xf4, 0xbe,
0x61, 0x49, 0x7, 0x53, 0xef, 0x79,
0x40, 0xd3, 0x1f, 0x44, 0x55, 0xa1,
0xe5, 0xac, 0xe2, 0xf1, 0xb1, 0x94,
0x59, 0xfe, 0x89, 0xa5, 0xfc, 0x49,
0xb3, 0x44, 0xd8, 0xdc, 0x36, 0xb,
0x4f, 0x14, 0xa1, 0xad, 0x8, 0x0,
0x61, 0xfa, 0x60, 0x42, 0xba, 0xcb,
0xda, 0x9, 0xe5, 0x32, 0xac, 0xf0,
0xa7, 0x5a, 0xc2, 0x1a, 0xed, 0x97,
0xb3, 0xa2, 0xb6, 0xf0, 0x56, 0xce,
0xbc, 0x6b, 0x7c, 0x96, 0x98, 0x36,
0xe9, 0xae, 0xba, 0x4e, 0xc, 0x33,
0x21, 0x3d, 0x27, 0x61, 0xda, 0x71,
0xe8, 0x78, 0x17, 0x96, 0x3f, 0xf2,
0x7d, 0xf6, 0x22, 0xe4, 0xa3, 0xee,
0x47, 0xaf, 0xb9, 0x34, 0x2b, 0x65,
0xcf, 0x83, 0xa2, 0x3, 0x9f, 0xce,
0x2c, 0x26, 0x32, 0xb4, 0x84, 0x42,
0x87, 0xcb, 0x93, 0xbc, 0x95, 0x1e,
0xa, 0x4a, 0x29, 0x65, 0xbc, 0x9,
0x3d, 0x26, 0x96, 0xc5, 0xd0, 0xd3,
0xfe, 0xff, 0x8e, 0x90, 0x24, 0xf7,
0xc9, 0x4, 0xb0, 0xc8, 0x0, 0x0,
0x0, 0x0, 0x49, 0x45, 0x4e, 0x44,
0xae, 0x42, 0x60, 0x82,
};
|
the_stack_data/176706592.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct S {
int x;
int y;
};
int main(void){
struct S s1;
s1.x = 5;
struct S *s2 = malloc(sizeof(struct S)) ;
memcpy(s2, &s1, sizeof(struct S));
printf("%d\n", s2->x);
return 0;
}
|
the_stack_data/215767493.c | /* PR optimization/11841 */
/* Originator: Andrey Panov <[email protected]> */
/* Reduced testcase by Volker Reichelt <[email protected]> */
/* Verify that the (old) loop unroller doesn't wrongly mark a pseudo
referenced in a note as local. */
/* { dg-do run } */
/* { dg-options "-O2 -funroll-loops" } */
int *a;
int main()
{
double d[6];
int i, j;
for (i=0; i<4; ++i)
for (j=0; j<3; ++j)
d[i+j] = 0;
a = &i;
return 0;
}
|
the_stack_data/90064.c | // I wanted to try SML, but it will be some other day...
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* F10
* N3
* F7
* R90
* F11
* => east 10, north 3, east 7, turn right=>south, forward=>south11
* => end in east 17, south 8 => 17+8 = 25 ("Manhattan distance")
*/
#ifdef NDEBUG
#define dbg(...)
#else
#define dbg(...) do { \
fprintf(stderr, "line %u: ", __LINE__); \
fprintf(stderr, __VA_ARGS__); \
} while(0)
#endif
static void chomp(char *s)
{
size_t len = strlen(s);
while (len > 0 && s[len - 1] == '\n')
len--;
s[len] = '\0';
}
/*
--- Part Two ---
Before you can give the destination to the captain, you realize that the actual action meanings were printed on the back of the instructions the whole time.
Almost all of the actions indicate how to move a waypoint which is relative to the ship's position:
Action N means to move the waypoint north by the given value.
Action S means to move the waypoint south by the given value.
Action E means to move the waypoint east by the given value.
Action W means to move the waypoint west by the given value.
Action L means to rotate the waypoint around the ship left (counter-clockwise) the given number of degrees.
Action R means to rotate the waypoint around the ship right (clockwise) the given number of degrees.
Action F means to move forward to the waypoint a number of times equal to the given value.
The waypoint starts 10 units east and 1 unit north relative to the ship. The waypoint is relative to the ship; that is, if the ship moves, the waypoint moves with it.
*/
enum Direction {
N = 'N',
S = 'S',
E = 'E',
W = 'W',
L = 'L',
R = 'R',
F = 'F',
};
static const enum Direction directions[] = {
N, E, S, W // +1 => turn right, -1 => turn left
};
struct Pos {
int x, y;
};
static void move(struct Pos *p, unsigned int delta, enum Direction d)
{
dbg("move %d,%d by %u in direction %c\n", p->x, p->y, delta, d);
switch (d) {
case N:
p->y += delta;
break;
case E:
p->x += delta;
break;
case S:
p->y -= delta;
break;
case W:
p->x -= delta;
break;
default:
fprintf(stderr, "move %c???\n", d);
exit(100);
}
}
// waypoint = "unit vector" => move by it n times;
// eg wp=(1,2), n=3 => move by (3,6)
static void move2waypoint(struct Pos *p, unsigned int n,
struct Pos waypoint)
{
enum Direction x = waypoint.x > 0 ? E : W;
enum Direction y = waypoint.y > 0 ? N : S;
int dx = abs(waypoint.x);
int dy = abs(waypoint.y);
while (n-- > 0) {
move(p, dx, x);
move(p, dy, y);
}
}
static struct Pos rotate(struct Pos waypoint, int clockwise)
{
if (!clockwise) {
for (int i = 0; i < 3; i++)
waypoint = rotate(waypoint, 1);
return waypoint;
} else {
// matrix multiplication:
// newx = x * cos - y * sin
// newy = x * sin + y * cos
//
// clockwise => sin = -1, cos = 0
struct Pos old = waypoint;
waypoint.x = old.y;
waypoint.y = 0 - old.x;
return waypoint;
}
}
static void part1(const char *filename)
{
FILE *fp = fopen(filename, "rb");
if (!fp) {
perror(filename);
exit(111);
}
/*
int diridx = 0;
// we start east
while (directions[diridx] != E) {
diridx++;
diridx &= 3;
}
enum Direction dir = directions[diridx];
*/
struct Pos waypoint = { 10, 1 };
struct Pos ship = { 0, 0 };
char line[123];
while (fgets(line, sizeof line, fp)) {
if (strlen(line) < 2) {
fprintf(stderr, "dafuk %s?\n", line);
exit(100);
}
chomp(line);
unsigned mov = 0;
char dummy = '!';
if (sscanf(&line[1], "%u%c", &mov, &dummy) != 1) {
fprintf(stderr, "bad line(%s)\n", line);
exit(100);
}
if (mov > 0x1234) {
fprintf(stderr, "move too big in %s!\n", line);
exit(100);
}
int clockwise = 1;
// goto case N would make things easier...
switch (line[0]) {
case N:
case E:
case S:
case W:
move(&waypoint, mov, line[0]);
break;
case L:
// L,R: L90 means "change left 90 degrees"
// now ROTATE THE WAYPOINT!
clockwise = 0; // fallthru
case R:
if (mov % 90) {
fprintf(stderr, "turn %c by %u degrees?\n",
line[0], mov);
exit(100);
}
while (mov > 0) {
mov -= 90;
waypoint = rotate(waypoint, clockwise);
}
dbg("%s => waypoint rotated to %d,%d\n", line,
waypoint.x, waypoint.y);
break;
case F:
//Action F means to move forward to the waypoint a number of times equal to the given value.
move2waypoint(&ship, mov, waypoint);
break;
default:
fprintf(stderr, "unknown direction(%s)\n", line);
exit(123);
}
dbg("%d,%d\n", ship.x, ship.y);
}
fclose(fp);
printf("x=%d,y=%d => Manhattan dist is %d\n", ship.x, ship.y,
abs(ship.x) + abs(ship.y));
}
int main(int argc, char *argv[])
{
if (argc < 2) {
fprintf(stderr, "usage: $0 file...\n");
return 100;
}
for (int i = 1; i < argc; i++)
part1(argv[i]);
return 0;
}
|
the_stack_data/411104.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};
static bool traverse(struct TreeNode *node, int *k, int *val)
{
if (node == NULL) {
return false;
}
if (traverse(node->left, k, val)) {
return true;
}
if (--*k == 0) {
*val = node->val;
return true;
}
if (traverse(node->right, k, val)) {
return true;
}
return false;
}
static int kthSmallest(struct TreeNode* root, int k)
{
int value = 0;
traverse(root, &k, &value);
return value;
}
int main(void)
{
#if 1
struct TreeNode root, n10, n11, n20, n21, n22, n23;
root.val = 1;
n10.val = 2;
n11.val = 2;
n20.val = 3;
n21.val = 4;
n22.val = 4;
n23.val = 3;
root.left = &n10;
root.right = &n11;
n10.left = &n20;
n10.right = &n21;
n11.left = &n22;
n11.right = &n23;
n20.left = NULL;
n20.right = NULL;
n21.left = NULL;
n21.right = NULL;
n22.left = NULL;
n22.right = NULL;
n23.left = NULL;
n23.right = NULL;
#else
struct TreeNode root, n10, n11, n21, n22;
root.val = 1;
n10.val = 2;
n11.val = 2;
n21.val = 3;
n22.val = 4;
root.left = &n10;
root.right = &n11;
n10.left = NULL;
n10.right = &n21;
n11.left = &n22;
n11.right = NULL;
n21.left = NULL;
n21.right = NULL;
n22.left = NULL;
n22.right = NULL;
#endif
int k = 1;
printf("%d\n", kthSmallest(&root, k));
return 0;
}
|
the_stack_data/247016911.c | //*****************************************************************************
//
// startup_codered.c - Startup code for use with code_red tools.
//
// Copyright (c) 2009-2012 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 9107 of the EK-LM3S9B92 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 EthernetIntHandler(void);
extern void SysTickIntHandler(void);
//*****************************************************************************
//
// The entry point for the application.
//
//*****************************************************************************
#if defined(__REDLIB__)
#define __MAIN__ __main
#else
#define __MAIN__ main
#endif
extern int __MAIN__(void);
//*****************************************************************************
//
// Reserve space for the system stack.
//
//*****************************************************************************
extern unsigned long _vStackTop;
//*****************************************************************************
//
// 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)&_vStackTop),
// 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
SysTickIntHandler, // 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
IntDefaultHandler, // Timer 0 subtimer A
IntDefaultHandler, // Timer 0 subtimer B
IntDefaultHandler, // 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
EthernetIntHandler, // 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/22013068.c | //选择排序法排序
#include <stdio.h>
int main(void)
{
int buf[10];
int i, j, temp;
for(i = 0; i < 10; i++) {
scanf("%d", &buf[i]);
}
for (i = 0; i < 9; i++) {
for(j = i + 1; j < 10; j++) {
if (buf[i] > buf[j]) {
temp = buf[i];
buf[i] = buf[j];
buf[j] = temp;
}
}
}
for (i = 0; i < 10; i++) {
printf("%d ", buf[i]);
}
return 0;
}
|
the_stack_data/93888466.c | /* { dg-do run } */
/* { dg-options "-mno-plt" } */
extern void abort (void);
struct lispstruct
{
int e;
int t;
};
struct lispstruct Cnil_body;
struct lispstruct Ct_body;
int nvalues;
struct lispstruct * __attribute__ ((noinline))
fLlistp (struct lispstruct *x0)
{
if (x0 == &Cnil_body
|| (((unsigned long) x0 >= 0x80000000) ? 0
: (!x0->e ? (x0 != &Cnil_body) : x0->t)))
x0 = &Ct_body;
else
x0 = &Cnil_body;
nvalues = 1;
return x0;
}
int main ()
{
if (fLlistp ((struct lispstruct *) 0xa0000001) != &Cnil_body)
abort ();
return 0;
}
|
the_stack_data/48328.c | /*
This program generates the "times.h" file with the zulu-times of the first of
every month of a decade.
*/
/****************************************************************
* 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, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
****************************************************************/
#include <time.h>
#include <stdio.h>
static time_t GetDay(int D,int M,int Y)
{
struct tm TM;
TM.tm_sec = 0;
TM.tm_min = 0;
TM.tm_hour = 0;
TM.tm_mday = D;
TM.tm_mon = M;
TM.tm_wday = 0;
TM.tm_yday = 0;
TM.tm_year = Y-1900;
TM.tm_isdst = 0;
return mktime(&TM);
}
static int WeekGetDay(int D,int M,int Y)
{
struct tm TM;
TM.tm_sec = 0;
TM.tm_min = 0;
TM.tm_hour = 0;
TM.tm_mday = D;
TM.tm_mon = M;
TM.tm_year = Y-1900;
TM.tm_isdst = 0;
TM.tm_wday = 0;
TM.tm_yday = 0;
(void)mktime(&TM);
return TM.tm_wday;
}
int main(void)
{
int M,Y;
FILE *file;
file=fopen("times.h","w");
if (file==NULL)
return 0;
fprintf(file,"static time_t TimeDays[10][13] = { \n");
Y=1997;
while (Y<2007)
{
M=0;
fprintf(file," { ");
while (M<12)
{
fprintf(file,"%i",(int)GetDay(1,M,Y));
fprintf(file,",\t");
M++;
}
fprintf(file,"%i } ",(int)GetDay(1,0,Y+1));
if (Y!=2006) fprintf(file,",");
fprintf(file,"\n");
Y++;
}
fprintf(file,"};\n");
fprintf(file,"static int WeekDays[10][13] = { \n");
Y=1997;
while (Y<2007)
{
M=0;
fprintf(file," { ");
while (M<12)
{
fprintf(file,"%i",(int)WeekGetDay(1,M,Y));
fprintf(file,",\t");
M++;
}
fprintf(file,"%i } ",(int)WeekGetDay(1,0,Y+1));
if (Y!=2006) fprintf(file,",");
fprintf(file,"\n");
Y++;
}
fprintf(file,"};\n");
fprintf(file,"#define KHTTPD_YEAROFFSET 1997\n");
fprintf(file,"#define KHTTPD_NUMYEARS 10\n");
(void)fclose(file);
return 0;
}
|
the_stack_data/140699.c | /******************************
* Tisma Miroslav 2006/0395
* Multiprocesorski sistemi
* domaci zadatak 2 - 4. zadatak
*******************************/
/*
* 4. Resiti prethodni problem primenom brava (pthread_mutex), bez koriscenja uslovnih promenljivih.
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define N 4 // broj niti u programu, pored glavne niti
pthread_mutex_t mutex[N]; // niz mutex-a za sinhronizaciju
int sum = 0; // zbir svih brojeva koje smo uneli
void* thread(void* arg) {
int thread_id = (int)arg;
int local_num;
pthread_mutex_lock(&mutex[thread_id]);
printf("Zdravo, ja sam nit broj: %d\nUnesite jedan ceo broj:\n", thread_id);
scanf("%d", &local_num);
sum += local_num;
if (thread_id == N-1) {
pthread_mutex_unlock(&mutex[0]);
} else {
pthread_mutex_unlock(&mutex[thread_id+1]);
}
pthread_exit(NULL);
return 0;
}
int main(int argc, char* argv[]) {
int i, rc, num;
pthread_t threads[N];
pthread_attr_t attribute;
for (i = 0; i < N; i++) {
pthread_mutex_init(&mutex[i], NULL);
pthread_mutex_lock(&mutex[i]);
}
pthread_attr_init(&attribute);
pthread_attr_setdetachstate(&attribute, PTHREAD_CREATE_JOINABLE);
for (i = 1; i < N; i++) {
rc = pthread_create(&threads[i-1], &attribute, thread, (void*)i);
if (rc) {
printf("GRESKA! Povratni kod iz pthread_create() je: %d", rc);
exit(EXIT_FAILURE);
}
}
printf("Zdravo, ja sam glavna nit.\nUnesite jedan ceo broj:\n");
scanf("%d", &num);
sum += num;
pthread_mutex_unlock(&mutex[1]);
pthread_mutex_lock(&mutex[0]);
printf("Zbir svih brojeva je: %d\n", sum);
pthread_mutex_unlock(&mutex[0]);
pthread_attr_destroy(&attribute);
for (i = 0; i < N; i++)
pthread_mutex_destroy(&mutex[i]);
return EXIT_SUCCESS;
}
|
the_stack_data/190767887.c | /*
* Derived from:
* http://www.kernel.org/pub/linux/libs/klibc/
*/
/*
* strncpy.c
*/
#include <string.h>
char *strncpy(char *dst, const char *src, size_t n)
{
char *q = dst;
const char *p = src;
char ch;
while (n) {
n--;
*q++ = ch = *p++;
if (!ch) {
break;
}
}
/* The specs say strncpy() fills the entire buffer with NUL. Sigh. */
memset(q, 0, n);
return dst;
}
|
the_stack_data/326005.c | /*
BLIS
An object-based framework for developing high-performance BLAS-like
libraries.
Copyright (C) 2014, The University of Texas at Austin
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(s) of the copyright holder(s) 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.
*/
// Guard the function definitions so that they are only compiled when
// #included from files that define the object API macros.
#ifdef BLIS_ENABLE_OAPI
//
// Define object-based interfaces.
//
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* a, \
const obj_t* x, \
const obj_t* beta, \
const obj_t* y \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
trans_t transa = bli_obj_conjtrans_status( a ); \
conj_t conjx = bli_obj_conj_status( x ); \
dim_t m = bli_obj_length( a ); \
dim_t n = bli_obj_width( a ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
void* buf_y = bli_obj_buffer_at_off( y ); \
inc_t incy = bli_obj_vector_inc( y ); \
\
void* buf_alpha; \
void* buf_beta; \
\
obj_t alpha_local; \
obj_t beta_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, a, x, beta, y ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
beta, &beta_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
buf_beta = bli_obj_buffer_for_1x1( dt, &beta_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
transa, \
conjx, \
m, \
n, \
buf_alpha, \
buf_a, rs_a, cs_a, \
buf_x, incx, \
buf_beta, \
buf_y, incy, \
cntx, \
rntm \
); \
}
GENFRONT( gemv )
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* x, \
const obj_t* y, \
const obj_t* a \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
conj_t conjx = bli_obj_conj_status( x ); \
conj_t conjy = bli_obj_conj_status( y ); \
dim_t m = bli_obj_length( a ); \
dim_t n = bli_obj_width( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
void* buf_y = bli_obj_buffer_at_off( y ); \
inc_t incy = bli_obj_vector_inc( y ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
\
void* buf_alpha; \
\
obj_t alpha_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, x, y, a ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
conjx, \
conjy, \
m, \
n, \
buf_alpha, \
buf_x, incx, \
buf_y, incy, \
buf_a, rs_a, cs_a, \
cntx, \
rntm \
); \
}
GENFRONT( ger )
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* a, \
const obj_t* x, \
const obj_t* beta, \
const obj_t* y \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
uplo_t uploa = bli_obj_uplo( a ); \
conj_t conja = bli_obj_conj_status( a ); \
conj_t conjx = bli_obj_conj_status( x ); \
dim_t m = bli_obj_length( a ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
void* buf_y = bli_obj_buffer_at_off( y ); \
inc_t incy = bli_obj_vector_inc( y ); \
\
void* buf_alpha; \
void* buf_beta; \
\
obj_t alpha_local; \
obj_t beta_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, a, x, beta, y ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
beta, &beta_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
buf_beta = bli_obj_buffer_for_1x1( dt, &beta_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
uploa, \
conja, \
conjx, \
m, \
buf_alpha, \
buf_a, rs_a, cs_a, \
buf_x, incx, \
buf_beta, \
buf_y, incy, \
cntx, \
rntm \
); \
}
GENFRONT( hemv )
GENFRONT( symv )
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* x, \
const obj_t* a \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
uplo_t uploa = bli_obj_uplo( a ); \
conj_t conjx = bli_obj_conj_status( x ); \
dim_t m = bli_obj_length( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
\
void* buf_alpha; \
\
obj_t alpha_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, x, a ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
uploa, \
conjx, \
m, \
buf_alpha, \
buf_x, incx, \
buf_a, rs_a, cs_a, \
cntx, \
rntm \
); \
}
GENFRONT( her )
GENFRONT( syr )
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* x, \
const obj_t* y, \
const obj_t* a \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
uplo_t uploa = bli_obj_uplo( a ); \
conj_t conjx = bli_obj_conj_status( x ); \
conj_t conjy = bli_obj_conj_status( y ); \
dim_t m = bli_obj_length( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
void* buf_y = bli_obj_buffer_at_off( y ); \
inc_t incy = bli_obj_vector_inc( y ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
\
void* buf_alpha; \
\
obj_t alpha_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, x, y, a ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
uploa, \
conjx, \
conjy, \
m, \
buf_alpha, \
buf_x, incx, \
buf_y, incy, \
buf_a, rs_a, cs_a, \
cntx, \
rntm \
); \
}
GENFRONT( her2 )
GENFRONT( syr2 )
#undef GENFRONT
#define GENFRONT( opname ) \
\
void PASTEMAC(opname,EX_SUF) \
( \
const obj_t* alpha, \
const obj_t* a, \
const obj_t* x \
BLIS_OAPI_EX_PARAMS \
) \
{ \
bli_init_once(); \
\
BLIS_OAPI_EX_DECLS \
\
num_t dt = bli_obj_dt( a ); \
\
uplo_t uploa = bli_obj_uplo( a ); \
trans_t transa = bli_obj_conjtrans_status( a ); \
diag_t diaga = bli_obj_diag( a ); \
dim_t m = bli_obj_length( a ); \
void* buf_a = bli_obj_buffer_at_off( a ); \
inc_t rs_a = bli_obj_row_stride( a ); \
inc_t cs_a = bli_obj_col_stride( a ); \
void* buf_x = bli_obj_buffer_at_off( x ); \
inc_t incx = bli_obj_vector_inc( x ); \
\
void* buf_alpha; \
\
obj_t alpha_local; \
\
if ( bli_error_checking_is_enabled() ) \
PASTEMAC(opname,_check)( alpha, a, x ); \
\
/* Create local copy-casts of scalars (and apply internal conjugation
as needed). */ \
bli_obj_scalar_init_detached_copy_of( dt, BLIS_NO_CONJUGATE, \
alpha, &alpha_local ); \
buf_alpha = bli_obj_buffer_for_1x1( dt, &alpha_local ); \
\
/* Query a type-specific function pointer, except one that uses
void* for function arguments instead of typed pointers. */ \
PASTECH2(opname,BLIS_TAPI_EX_SUF,_vft) f = \
PASTEMAC2(opname,BLIS_TAPI_EX_SUF,_qfp)( dt ); \
\
f \
( \
uploa, \
transa, \
diaga, \
m, \
buf_alpha, \
buf_a, rs_a, cs_a, \
buf_x, incx, \
cntx, \
rntm \
); \
}
GENFRONT( trmv )
GENFRONT( trsv )
#endif
|
the_stack_data/389847.c | //
// Created by Bugen Zhao on 2020/2/17.
//
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char **argv) {
if (argc != 2) return -1;
int fd = open(argv[1], O_RDONLY); // open file and get file descriptor
struct stat file_stat;
fstat(fd, &file_stat); // get file information
char *buf = mmap(NULL, file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0); // map file to virtual memory
write(1, buf, file_stat.st_size); // write to stdout
exit(0);
} |
the_stack_data/141511.c | #ifdef NVML_EXISTS
#include <nvml.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <sys/sysinfo.h>
#include <X11/Xlib.h>
#define DATE_LEN 64
#define STATUS_LEN 256
#define LOAD_SCALE 1.0f / (1 << SI_LOAD_SHIFT)
#define REFRESH_RATE 60
#define CPU_TEMP_FILE "/sys/class/thermal/thermal_zone1/temp"
#define BAT_CAP_FILE "/sys/class/power_supply/BAT0/capacity"
struct syst_stats {
double free_ram; // in GiB
double load1;
double load5;
double load15;
};
void set_sysinfo(struct syst_stats *sys)
{
struct sysinfo info;
if (sysinfo(&info) < 0)
return;
sys->free_ram = (double) info.freeram / (1 << 30);
sys->load1 = info.loads[0] * LOAD_SCALE;
sys->load5 = info.loads[1] * LOAD_SCALE;
sys->load15 = info.loads[2] * LOAD_SCALE;
}
#ifdef NVML_EXISTS
unsigned int get_GPU_temp(nvmlDevice_t *device)
{
nvmlReturn_t result;
unsigned int temp;
result = nvmlDeviceGetTemperature(*device, NVML_TEMPERATURE_GPU, &temp);
if (NVML_SUCCESS != result)
return 0;
return temp;
}
#endif
unsigned int read_uint_file(char *path)
{
FILE *fd = fopen(path, "r");
if (fd == NULL)
return 0;
char line[16];
if (fgets(line, sizeof(line)-1, fd) == NULL)
return 0;
fclose(fd);
return atoi(line);
}
#ifdef BAT_EXISTS
unsigned int get_BAT_cap(void)
{
return read_uint_file(BAT_CAP_FILE);
}
#endif
unsigned int get_CPU_temp()
{
return read_uint_file(CPU_TEMP_FILE) / 1000;
}
void set_time(char *datetime)
{
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
if (timeinfo == NULL)
return;
strftime(datetime, DATE_LEN - 1, "%a %d %b %R", timeinfo);
return;
}
int main(int argc, char *argv[])
{
Display *dpy = NULL;
Window win = 0;
dpy = XOpenDisplay(getenv("DISPLAY"));
if (dpy == NULL)
{
fprintf(stderr, "Can't open display, exiting.\n");
return 1;
}
win = DefaultRootWindow(dpy);
#ifdef NVML_EXISTS
nvmlReturn_t result;
nvmlDevice_t device;
result = nvmlInit();
if(NVML_SUCCESS != result){
fprintf(stderr, "failed to initialize nvml \n");
return 1;
}
result = nvmlDeviceGetHandleByIndex(0, &device);
if(NVML_SUCCESS != result){
fprintf(stderr, "failed to load device \n");
return 1;
}
#endif
char *datetime = malloc(DATE_LEN);
datetime[0] = '\0';
struct syst_stats *sys = malloc(sizeof(struct syst_stats));
memset(sys, 0, sizeof(struct syst_stats));
#ifdef NVML_EXISTS
unsigned int GPU_temp;
#endif
unsigned int CPU_temp;
#ifdef BAT_EXISTS
unsigned int BAT_cap;
#endif
char status[STATUS_LEN];
int offset = 0;
while (1)
{
offset = 0;
set_time(datetime);
set_sysinfo(sys);
CPU_temp = get_CPU_temp();
#ifdef BAT_EXISTS
BAT_cap = get_BAT_cap();
offset += snprintf(status + offset, STATUS_LEN - offset,
"B: %u%% ", BAT_cap);
#endif
#ifdef NVML_EXISTS
GPU_temp = get_GPU_temp(&device);
offset += snprintf(status, STATUS_LEN - offset,
"TG: %u\u00B0C ", GPU_temp);
#endif
snprintf(status + offset, STATUS_LEN - offset,
"TC: %u\u00B0C M: %.2fGiB L: %.2f %.2f %.2f %s",
CPU_temp,
sys->free_ram,
sys->load1, sys->load5, sys->load15,
datetime
);
XStoreName(dpy, win, status);
XFlush(dpy);
sleep(REFRESH_RATE);
}
XCloseDisplay(dpy);
free(datetime);
free(sys);
return 0;
}
|
the_stack_data/92039.c | #include<stdio.h>
int main ()
{
int year, Modulus;
// Declare Local Variables to store values.
printf("\n Enter the Year : \n");
//Ask the User to enter a Number.
scanf("%d", &year);
// Transfer the Number into a variable declared.
Modulus = year % 4;
if (Modulus == 0)
{
printf("The Year %d is a Leap Year. \n", year);
}
else
{
printf("The Number %d is NOT a Leap Year. \n", year);
}
return 0;
} |
the_stack_data/12637509.c | #include <stdio.h>
#include <stdlib.h>
int foo(int val);
int main(int argc, char * argv[])
{
int res;
int val = 3; //default
if (argc == 2)
val = atoi(argv[1]);
res = foo(val);
printf("%d-factorial: %d\n", val, res);
return 0;
}
|
the_stack_data/55239.c | /*
* If not stated otherwise in this file or this component's Licenses.txt file the
* following copyright and licenses apply:
*
* Copyright 2015 RDK Management
*
* 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.
*/
/**********************************************************************
Copyright [2014] [Cisco Systems, Inc.]
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.
**********************************************************************/
/**********************************************************************
module: tls_cpo_states.c
For Transport Layer Security Implementation (TLS),
BroadWay Service Delivery System
---------------------------------------------------------------
description:
This module implements the advanced state-access functions
of the TLS Crypto Provider Object.
---------------------------------------------------------------
environment:
platform independent
---------------------------------------------------------------
author:
Xuechen Yang
---------------------------------------------------------------
revision:
06/21/03 initial revision.
**********************************************************************/
|
the_stack_data/12636681.c | //
// ball16 (352 uncompressed bytes)
//
const unsigned char ball16_Bitmap[352] = {
0x80, 0x33, 0x12, 0x06, 0x58, 0x56, 0x23, 0x51, 0x63, 0x67, 0x23, 0x41, 0x53, 0x56, 0x23, 0x41,
0x32, 0x33, 0x12, 0x44, 0x21, 0x22, 0x41, 0x44, 0x16, 0x11, 0x44, 0x54, 0x50, 0x44, 0x44, 0x05,
0x90, 0x55, 0x23, 0x07, 0x69, 0x66, 0x25, 0x61, 0x65, 0x68, 0x35, 0x41, 0x65, 0x66, 0x25, 0x41,
0x53, 0x55, 0x23, 0x41, 0x22, 0x23, 0x12, 0x44, 0x17, 0x11, 0x41, 0x64, 0x60, 0x44, 0x44, 0x06,
0x90, 0x55, 0x33, 0x08, 0x69, 0x67, 0x35, 0x72, 0x75, 0x79, 0x35, 0x12, 0x65, 0x67, 0x35, 0x12,
0x53, 0x55, 0x33, 0x11, 0x33, 0x33, 0x23, 0x41, 0x28, 0x22, 0x11, 0x71, 0x70, 0x11, 0x41, 0x07,
0xa0, 0x66, 0x35, 0x09, 0x7a, 0x78, 0x56, 0x83, 0x86, 0x8a, 0x56, 0x23, 0x76, 0x78, 0x56, 0x23,
0x65, 0x66, 0x35, 0x12, 0x53, 0x55, 0x33, 0x12, 0x39, 0x33, 0x22, 0x81, 0x80, 0x22, 0x11, 0x08,
0xb0, 0x77, 0x56, 0x0a, 0x9b, 0x99, 0x57, 0x95, 0x97, 0x9b, 0x67, 0x35, 0x97, 0x99, 0x57, 0x35,
0x76, 0x77, 0x56, 0x33, 0x55, 0x56, 0x35, 0x23, 0x5a, 0x55, 0x33, 0x92, 0x90, 0x33, 0x23, 0x09,
0xc0, 0x89, 0x67, 0x0b, 0xac, 0xaa, 0x78, 0xa5, 0xa9, 0xac, 0x79, 0x56, 0xa8, 0xaa, 0x78, 0x55,
0x87, 0x89, 0x67, 0x55, 0x76, 0x77, 0x56, 0x35, 0x5b, 0x56, 0x55, 0xa3, 0xa0, 0x55, 0x35, 0x0a,
0xd0, 0xaa, 0x89, 0x0c, 0xbd, 0xbb, 0x9a, 0xb7, 0xba, 0xbc, 0x9a, 0x67, 0xba, 0xbb, 0x9a, 0x67,
0xa9, 0xaa, 0x89, 0x66, 0x98, 0x99, 0x78, 0x56, 0x7c, 0x77, 0x66, 0xb5, 0xb0, 0x66, 0x56, 0x0b,
0xd0, 0xbc, 0xab, 0x0d, 0xcd, 0xcd, 0xab, 0xc9, 0xdc, 0xdd, 0xbc, 0x89, 0xcb, 0xcd, 0xab, 0x89,
0xbb, 0xbc, 0xab, 0x89, 0xaa, 0xab, 0x9a, 0x78, 0x9d, 0x99, 0x89, 0xc8, 0xc0, 0x88, 0x78, 0x0c,
0xe0, 0xdd, 0xcc, 0x0e, 0xde, 0xde, 0xcd, 0xeb, 0xed, 0xee, 0xcd, 0xbb, 0xdd, 0xde, 0xcd, 0xbb,
0xdc, 0xdd, 0xcc, 0xab, 0xcc, 0xcc, 0xbc, 0xab, 0xbe, 0xbb, 0xbb, 0xea, 0xe0, 0xbb, 0xaa, 0x0e,
0xf0, 0xee, 0xee, 0x0f, 0xff, 0xff, 0xee, 0xfe, 0xfe, 0xff, 0xee, 0xde, 0xfe, 0xff, 0xee, 0xde,
0xee, 0xee, 0xee, 0xdd, 0xee, 0xee, 0xee, 0xdd, 0xef, 0xee, 0xdd, 0xfd, 0xf0, 0xdd, 0xdd, 0x0f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
|
the_stack_data/113904.c | #include<stdio.h>
void itoa(int);
int main()
{
int a;
printf("Enter the value of a: ");
scanf("%d",&a);
itoa(a);
printf("\n");
return 0;
}
void itoa(int a)
{
if(a!=0)
{
char b;
b=(a%10)+48;
itoa(a/10);
printf("%c",b);
}
else
return;
}
|
the_stack_data/176705647.c | int _start(double v) {
return v <= 1;
}
|
the_stack_data/22937.c | #include <stdio.h>
#include <stdlib.h>
void unique_string(char *iStr);
/* Sequentially parses the passed in string and returns if atleast one character is
* duplicate. For example, string 'hello' has character 'l' twice
*/
void unique_string(char *iStr)
{
int i = 0, j = 0;
while (*iStr != '\0') {
j=i+1;
while (*(iStr+j) != '\0') {
if (*(iStr+i) == *(iStr+j)) {
printf("The string is not unique\n");
return;
}
j++;
}
i++;
}
printf("The string is unique\n");
}
main()
{
char input_string[16];
printf("Enter the string\n");
scanf("%s", input_string);
printf("%s\n", input_string);
unique_string(input_string);
}
|
the_stack_data/50138495.c |
void scilab_rt_min_i2s0_i2(int sin00, int sin01, int in0[sin00][sin01],
char * in1,
int sout00, int sout01, int out0[sout00][sout01])
{
int i,j;
int val0=0;
if (in1) {
for (i = 0; i < sin00; ++i) {
for (j = 0; j < sin01; ++j) {
val0 += in0[i][j];
}
}
for (i = 0 ; i < sout00 ; ++i){
for(j = 0 ; j < sout01 ; ++j){
out0[i][j] = val0;
}
}
}
}
|
the_stack_data/1035560.c | /*程序4.10 模拟投骰子的第四种实现方法。
以6点为目标，投中目标2次获胜，最多投10次。
方法6：用goto语句控制循环
*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
int count=0,y=0,dice;
srand(time(0));
repeat: //repeat为语句标号
dice=1+rand()%6;
count++;
if(dice==6)
y++;
if (count<10&&y<2)
goto repeat; //goto语句
printf("%d,%d\n",count,y);
return 0;
}
|
the_stack_data/1012226.c | #include <stdio.h>
#include <stdlib.h>
// Lesson 2 - Part 1
int main(){
printf("Hello world!\n"); // string
printf("%d\n",128); // %d for integer
printf("%ld\n",192727); // %ld for large integer
printf("%f\n",29.2368); // %f for float or decimal
printf("%lf\n",3726.27364839); // %lf for large float or decimal
printf("%c\n",'a'); // %c for char
printf("%s\n\n","Hello, this is string"); // %s for string
printf("2020 - Palguno Wicaksono");
return 0;
} |
the_stack_data/179829576.c | int setbits(unsigned long long n){
return __builtin_popcountll(n);
} |
the_stack_data/11075178.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
printf("hello, world. this is pid: %i\n", getpid());
printf("---\n");
int rc = fork();
if (rc < 0) {
fprintf(stderr, "fork() failed\n");
exit(1);
} else if (rc == 0) {
printf("I am a child process. pid: %i\n\n", getpid());
} else {
int rc_wait = wait(NULL);
printf("I am the parent process of %d, and my pid is %d\n",
rc_wait, getpid());
printf("The child process has pid: %i\n\n", rc);
}
return 0;
}
|
the_stack_data/15762417.c | /**
* Wrapper module for source code compatibility with esp-open-rtos.
*/
#ifdef ESP_PLATFORM // ESP32 (ESP-IDF)
#include <sys/time.h>
#include <string.h>
#include "driver/spi_master.h"
#include "driver/spi_common.h"
#include "driver/i2c.h"
#include "driver/gpio.h"
#include "esp8266_wrapper.h"
// esp-open-rtos SDK function wrapper
uint32_t sdk_system_get_time ()
{
struct timeval time;
gettimeofday(&time,0);
return time.tv_sec*1e6 + time.tv_usec;
}
bool gpio_isr_service_installed = false;
bool auto_pull_up = false;
bool auto_pull_down = true;
esp_err_t gpio_set_interrupt(gpio_num_t gpio,
gpio_int_type_t type,
gpio_interrupt_handler_t handler)
{
if (!gpio_isr_service_installed)
gpio_isr_service_installed = (gpio_install_isr_service(0) == ESP_OK);
gpio_config_t gpio_cfg = {
.pin_bit_mask = ((uint64_t)(((uint64_t)1)<< gpio)),
.mode = GPIO_MODE_INPUT,
.pull_up_en = auto_pull_up,
.pull_down_en = auto_pull_down,
.intr_type = type
};
gpio_config(&gpio_cfg);
// set interrupt handler
gpio_isr_handler_add(gpio, (gpio_isr_t)handler, (void*)gpio);
return ESP_OK;
}
void gpio_enable (gpio_num_t gpio, const gpio_mode_t mode)
{
gpio_config_t gpio_cfg = {
.pin_bit_mask = ((uint64_t)(((uint64_t)1)<< gpio)),
.mode = mode,
.pull_up_en = auto_pull_up,
.pull_down_en = auto_pull_down,
};
gpio_config(&gpio_cfg);
}
// esp-open-rtos I2C interface wrapper
#define I2C_ACK_VAL 0x0
#define I2C_NACK_VAL 0x1
void i2c_init (int bus, gpio_num_t scl, gpio_num_t sda, uint32_t freq)
{
i2c_config_t conf;
conf.mode = I2C_MODE_MASTER;
conf.sda_io_num = sda;
conf.scl_io_num = scl;
conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
conf.master.clk_speed = freq;
i2c_param_config(bus, &conf);
i2c_driver_install(bus, I2C_MODE_MASTER, 0, 0, 0);
}
int i2c_slave_write (uint8_t bus, uint8_t addr, const uint8_t *reg,
uint8_t *data, uint32_t len)
{
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, addr << 1 | I2C_MASTER_WRITE, true);
if (reg)
i2c_master_write_byte(cmd, *reg, true);
if (data)
i2c_master_write(cmd, data, len, true);
i2c_master_stop(cmd);
esp_err_t err = i2c_master_cmd_begin(bus, cmd, 1000 / portTICK_RATE_MS);
i2c_cmd_link_delete(cmd);
return err;
}
int i2c_slave_read (uint8_t bus, uint8_t addr, const uint8_t *reg,
uint8_t *data, uint32_t len)
{
if (len == 0) return true;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
if (reg)
{
i2c_master_start(cmd);
i2c_master_write_byte(cmd, ( addr << 1 ) | I2C_MASTER_WRITE, true);
i2c_master_write_byte(cmd, *reg, true);
if (!data)
i2c_master_stop(cmd);
}
if (data)
{
i2c_master_start(cmd);
i2c_master_write_byte(cmd, ( addr << 1 ) | I2C_MASTER_READ, true);
if (len > 1) i2c_master_read(cmd, data, len-1, I2C_ACK_VAL);
i2c_master_read_byte(cmd, data + len-1, I2C_NACK_VAL);
i2c_master_stop(cmd);
}
esp_err_t err = i2c_master_cmd_begin(bus, cmd, 1000 / portTICK_RATE_MS);
i2c_cmd_link_delete(cmd);
return err;
}
// esp-open-rtos SPI interface wrapper
#define SPI_MAX_BUS 3 // ESP32 features three SPIs (SPI_HOST, HSPI_HOST and VSPI_HOST)
#define SPI_MAX_CS 34 // GPIO 33 is the last port that can be used as output
spi_device_handle_t spi_handles[SPI_MAX_CS] = { 0 };
bool spi_bus_init (spi_host_device_t host, uint8_t sclk , uint8_t miso, uint8_t mosi)
{
spi_bus_config_t spi_bus_cfg = {
.miso_io_num=miso,
.mosi_io_num=mosi,
.sclk_io_num=sclk,
.quadwp_io_num=-1,
.quadhd_io_num=-1
};
return (spi_bus_initialize(host, &spi_bus_cfg, 1) == ESP_OK);
}
bool spi_device_init (uint8_t bus, uint8_t cs)
{
if (bus >= SPI_MAX_BUS || cs >= SPI_MAX_CS)
return false;
if ((spi_handles[cs] = malloc (sizeof(spi_device_handle_t))) == 0)
return false;
spi_device_interface_config_t dev_cfg = {
.clock_speed_hz = 1e6, // 1 MHz clock
.mode = 0, // SPI mode 0
.spics_io_num = cs, // CS GPIO
.queue_size = 1,
.flags = 0, // no flags set
.command_bits = 0, // no command bits used
.address_bits = 0, // register address is first byte in MOSI
.dummy_bits = 0 // no dummy bits used
};
if (spi_bus_add_device(bus, &dev_cfg, &(spi_handles[cs])) != ESP_OK)
{
free (spi_handles[cs]);
return false;
}
return true;
}
bool spi_device_remove(uint8_t bus, uint8_t cs){
if (spi_bus_remove_device(spi_handles[cs]) != ESP_OK){
return false;
}
//free (spi_handles[cs]);
spi_bus_free(bus);
return true;
}
size_t spi_transfer_pf (uint8_t bus, uint8_t cs, const uint8_t *mosi, uint8_t *miso, uint16_t len)
{
spi_transaction_t spi_trans;
if (cs >= SPI_MAX_CS)
return 0;
memset(&spi_trans, 0, sizeof(spi_trans)); // zero out spi_trans;
spi_trans.tx_buffer = mosi;
spi_trans.rx_buffer = miso;
spi_trans.length=len*8;
if (spi_device_transmit(spi_handles[cs], &spi_trans) != ESP_OK)
return 0;
return len;
}
#endif // ESP32 (ESP-IDF)
|
the_stack_data/234518202.c | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
#if defined(ARDUINO_ARCH_NRF5) && defined(NRF52_SERIES)
#include <stdint.h>
#include <assert.h>
#include <string.h>
#include "nimble/porting/nimble/include/syscfg/syscfg.h"
#include "nimble/porting/nimble/include/os/os.h"
#include "../include/ble/xcvr.h"
#include "nimble/nimble/include/nimble/ble.h"
#include "nimble/nimble/include/nimble/nimble_opt.h"
#include "nrf.h"
#include "nimble/nimble/controller/include/controller/ble_hw.h"
#if MYNEWT
#include "mcu/cmsis_nvic.h"
#else
#include "core_cm4.h"
#include "nimble/porting/npl/freertos/include/nimble/nimble_npl_os.h"
#endif
#include "nimble/porting/nimble/include/os/os_trace_api.h"
/* Total number of resolving list elements */
#define BLE_HW_RESOLV_LIST_SIZE (16)
/* We use this to keep track of which entries are set to valid addresses */
static uint8_t g_ble_hw_whitelist_mask;
/* Random number generator isr callback */
ble_rng_isr_cb_t g_ble_rng_isr_cb;
/* If LL privacy is enabled, allocate memory for AAR */
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
/* The NRF51 supports up to 16 IRK entries */
#if (MYNEWT_VAL(BLE_LL_RESOLV_LIST_SIZE) < 16)
#define NRF_IRK_LIST_ENTRIES (MYNEWT_VAL(BLE_LL_RESOLV_LIST_SIZE))
#else
#define NRF_IRK_LIST_ENTRIES (16)
#endif
/* NOTE: each entry is 16 bytes long. */
uint32_t g_nrf_irk_list[NRF_IRK_LIST_ENTRIES * 4];
/* Current number of IRK entries */
uint8_t g_nrf_num_irks;
#endif
/* Returns public device address or -1 if not present */
int
ble_hw_get_public_addr(ble_addr_t *addr)
{
uint32_t addr_high;
uint32_t addr_low;
/* Does FICR have a public address */
if ((NRF_FICR->DEVICEADDRTYPE & 1) != 0) {
return -1;
}
/* Copy into device address. We can do this because we know platform */
addr_low = NRF_FICR->DEVICEADDR[0];
addr_high = NRF_FICR->DEVICEADDR[1];
memcpy(addr->val, &addr_low, 4);
memcpy(&addr->val[4], &addr_high, 2);
addr->type = BLE_ADDR_PUBLIC;
return 0;
}
/* Returns random static address or -1 if not present */
int
ble_hw_get_static_addr(ble_addr_t *addr)
{
int rc;
if ((NRF_FICR->DEVICEADDRTYPE & 1) == 1) {
memcpy(addr->val, (void *)&NRF_FICR->DEVICEADDR[0], 4);
memcpy(&addr->val[4], (void *)&NRF_FICR->DEVICEADDR[1], 2);
addr->val[5] |= 0xc0;
addr->type = BLE_ADDR_RANDOM;
rc = 0;
} else {
rc = -1;
}
return rc;
}
/**
* Clear the whitelist
*
* @return int
*/
void
ble_hw_whitelist_clear(void)
{
NRF_RADIO->DACNF = 0;
g_ble_hw_whitelist_mask = 0;
}
/**
* Add a device to the hw whitelist
*
* @param addr
* @param addr_type
*
* @return int 0: success, BLE error code otherwise
*/
int
ble_hw_whitelist_add(const uint8_t *addr, uint8_t addr_type)
{
int i;
uint32_t mask;
/* Find first ununsed device address match element */
mask = 0x01;
for (i = 0; i < BLE_HW_WHITE_LIST_SIZE; ++i) {
if ((mask & g_ble_hw_whitelist_mask) == 0) {
NRF_RADIO->DAB[i] = get_le32(addr);
NRF_RADIO->DAP[i] = get_le16(addr + 4);
if (addr_type == BLE_ADDR_RANDOM) {
NRF_RADIO->DACNF |= (mask << 8);
}
g_ble_hw_whitelist_mask |= mask;
return BLE_ERR_SUCCESS;
}
mask <<= 1;
}
return BLE_ERR_MEM_CAPACITY;
}
/**
* Remove a device from the hw whitelist
*
* @param addr
* @param addr_type
*
*/
void
ble_hw_whitelist_rmv(const uint8_t *addr, uint8_t addr_type)
{
int i;
uint8_t cfg_addr;
uint16_t dap;
uint16_t txadd;
uint32_t dab;
uint32_t mask;
/* Find first ununsed device address match element */
dab = get_le32(addr);
dap = get_le16(addr + 4);
txadd = NRF_RADIO->DACNF >> 8;
mask = 0x01;
for (i = 0; i < BLE_HW_WHITE_LIST_SIZE; ++i) {
if (mask & g_ble_hw_whitelist_mask) {
if ((dab == NRF_RADIO->DAB[i]) && (dap == NRF_RADIO->DAP[i])) {
cfg_addr = txadd & mask;
if (addr_type == BLE_ADDR_RANDOM) {
if (cfg_addr != 0) {
break;
}
} else {
if (cfg_addr == 0) {
break;
}
}
}
}
mask <<= 1;
}
if (i < BLE_HW_WHITE_LIST_SIZE) {
g_ble_hw_whitelist_mask &= ~mask;
NRF_RADIO->DACNF &= ~mask;
}
}
/**
* Returns the size of the whitelist in HW
*
* @return int Number of devices allowed in whitelist
*/
uint8_t
ble_hw_whitelist_size(void)
{
return BLE_HW_WHITE_LIST_SIZE;
}
/**
* Enable the whitelisted devices
*/
void
ble_hw_whitelist_enable(void)
{
/* Enable the configured device addresses */
NRF_RADIO->DACNF |= g_ble_hw_whitelist_mask;
}
/**
* Disables the whitelisted devices
*/
void
ble_hw_whitelist_disable(void)
{
/* Disable all whitelist devices */
NRF_RADIO->DACNF &= 0x0000ff00;
}
/**
* Boolean function which returns true ('1') if there is a match on the
* whitelist.
*
* @return int
*/
int
ble_hw_whitelist_match(void)
{
return (int)NRF_RADIO->EVENTS_DEVMATCH;
}
/* Encrypt data */
int
ble_hw_encrypt_block(struct ble_encryption_block *ecb)
{
int rc;
uint32_t end;
uint32_t err;
/* Stop ECB */
NRF_ECB->TASKS_STOPECB = 1;
/* XXX: does task stop clear these counters? Anyway to do this quicker? */
NRF_ECB->EVENTS_ENDECB = 0;
NRF_ECB->EVENTS_ERRORECB = 0;
NRF_ECB->ECBDATAPTR = (uint32_t)ecb;
/* Start ECB */
NRF_ECB->TASKS_STARTECB = 1;
/* Wait till error or done */
rc = 0;
while (1) {
end = NRF_ECB->EVENTS_ENDECB;
err = NRF_ECB->EVENTS_ERRORECB;
if (end || err) {
if (err) {
rc = -1;
}
break;
}
}
return rc;
}
/**
* Random number generator ISR.
*/
static void
ble_rng_isr(void)
{
uint8_t rnum;
os_trace_isr_enter();
/* No callback? Clear and disable interrupts */
if (g_ble_rng_isr_cb == NULL) {
NRF_RNG->INTENCLR = 1;
NRF_RNG->EVENTS_VALRDY = 0;
(void)NRF_RNG->SHORTS;
os_trace_isr_exit();
return;
}
/* If there is a value ready grab it */
if (NRF_RNG->EVENTS_VALRDY) {
NRF_RNG->EVENTS_VALRDY = 0;
rnum = (uint8_t)NRF_RNG->VALUE;
(*g_ble_rng_isr_cb)(rnum);
}
os_trace_isr_exit();
}
/**
* Initialize the random number generator
*
* @param cb
* @param bias
*
* @return int
*/
int
ble_hw_rng_init(ble_rng_isr_cb_t cb, int bias)
{
/* Set bias */
if (bias) {
NRF_RNG->CONFIG = 1;
} else {
NRF_RNG->CONFIG = 0;
}
/* If we were passed a function pointer we need to enable the interrupt */
if (cb != NULL) {
#ifndef RIOT_VERSION
NVIC_SetPriority(RNG_IRQn, (1 << __NVIC_PRIO_BITS) - 1);
#endif
#if MYNEWT
NVIC_SetVector(RNG_IRQn, (uint32_t)ble_rng_isr);
#else
ble_npl_hw_set_isr(RNG_IRQn, ble_rng_isr);
#endif
NVIC_EnableIRQ(RNG_IRQn);
g_ble_rng_isr_cb = cb;
}
return 0;
}
/**
* Start the random number generator
*
* @return int
*/
int
ble_hw_rng_start(void)
{
os_sr_t sr;
/* No need for interrupt if there is no callback */
OS_ENTER_CRITICAL(sr);
NRF_RNG->EVENTS_VALRDY = 0;
if (g_ble_rng_isr_cb) {
NRF_RNG->INTENSET = 1;
}
NRF_RNG->TASKS_START = 1;
OS_EXIT_CRITICAL(sr);
return 0;
}
/**
* Stop the random generator
*
* @return int
*/
int
ble_hw_rng_stop(void)
{
os_sr_t sr;
/* No need for interrupt if there is no callback */
OS_ENTER_CRITICAL(sr);
NRF_RNG->INTENCLR = 1;
NRF_RNG->TASKS_STOP = 1;
NRF_RNG->EVENTS_VALRDY = 0;
OS_EXIT_CRITICAL(sr);
return 0;
}
/**
* Read the random number generator.
*
* @return uint8_t
*/
uint8_t
ble_hw_rng_read(void)
{
uint8_t rnum;
/* Wait for a sample */
while (NRF_RNG->EVENTS_VALRDY == 0) {
}
NRF_RNG->EVENTS_VALRDY = 0;
rnum = (uint8_t)NRF_RNG->VALUE;
return rnum;
}
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
/**
* Clear the resolving list
*
* @return int
*/
void
ble_hw_resolv_list_clear(void)
{
g_nrf_num_irks = 0;
}
/**
* Add a device to the hw resolving list
*
* @param irk Pointer to IRK to add
*
* @return int 0: success, BLE error code otherwise
*/
int
ble_hw_resolv_list_add(uint8_t *irk)
{
uint32_t *nrf_entry;
/* Find first ununsed device address match element */
if (g_nrf_num_irks == NRF_IRK_LIST_ENTRIES) {
return BLE_ERR_MEM_CAPACITY;
}
/* Copy into irk list */
nrf_entry = &g_nrf_irk_list[4 * g_nrf_num_irks];
memcpy(nrf_entry, irk, 16);
/* Add to total */
++g_nrf_num_irks;
return BLE_ERR_SUCCESS;
}
/**
* Remove a device from the hw resolving list
*
* @param index Index of IRK to remove
*/
void
ble_hw_resolv_list_rmv(int index)
{
uint32_t *irk_entry;
if (index < g_nrf_num_irks) {
--g_nrf_num_irks;
irk_entry = &g_nrf_irk_list[index];
if (g_nrf_num_irks > index) {
memmove(irk_entry, irk_entry + 4, 16 * (g_nrf_num_irks - index));
}
}
}
/**
* Returns the size of the resolving list. NOTE: this returns the maximum
* allowable entries in the HW. Configuration options may limit this.
*
* @return int Number of devices allowed in resolving list
*/
uint8_t
ble_hw_resolv_list_size(void)
{
return BLE_HW_RESOLV_LIST_SIZE;
}
/**
* Called to determine if the address received was resolved.
*
* @return int Negative values indicate unresolved address; positive values
* indicate index in resolving list of resolved address.
*/
int
ble_hw_resolv_list_match(void)
{
uint32_t index;
if (NRF_AAR->EVENTS_END) {
if (NRF_AAR->EVENTS_RESOLVED) {
index = NRF_AAR->STATUS;
return (int)index;
}
}
return -1;
}
#endif
#endif
|
the_stack_data/760827.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from evoapprox8b dataset. Note that a new version of library was already published.
***/
#include <stdint.h>
#include <stdlib.h>
/// Approximate function mul8_084
/// Library = EvoApprox8b
/// Circuit = mul8_084
/// Area (180) = 9179
/// Delay (180) = 3.260
/// Power (180) = 4106.80
/// Area (45) = 670
/// Delay (45) = 1.190
/// Power (45) = 351.90
/// Nodes = 166
/// HD = 278214
/// MAE = 96.07550
/// MSE = 17090.32227
/// MRE = 2.95 %
/// WCE = 766
/// WCRE = 200 %
/// EP = 97.2 %
uint16_t mul8_084(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n0 = (a >> 0) & 0x1;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n16 = (b >> 0) & 0x1;
uint8_t n18 = (b >> 1) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n33;
uint8_t n34;
uint8_t n35;
uint8_t n37;
uint8_t n38;
uint8_t n41;
uint8_t n42;
uint8_t n43;
uint8_t n45;
uint8_t n46;
uint8_t n47;
uint8_t n49;
uint8_t n50;
uint8_t n51;
uint8_t n54;
uint8_t n55;
uint8_t n57;
uint8_t n62;
uint8_t n67;
uint8_t n69;
uint8_t n70;
uint8_t n71;
uint8_t n73;
uint8_t n76;
uint8_t n77;
uint8_t n78;
uint8_t n80;
uint8_t n83;
uint8_t n85;
uint8_t n86;
uint8_t n89;
uint8_t n91;
uint8_t n93;
uint8_t n95;
uint8_t n99;
uint8_t n106;
uint8_t n107;
uint8_t n109;
uint8_t n110;
uint8_t n121;
uint8_t n131;
uint8_t n134;
uint8_t n137;
uint8_t n138;
uint8_t n139;
uint8_t n141;
uint8_t n142;
uint8_t n144;
uint8_t n150;
uint8_t n153;
uint8_t n169;
uint8_t n181;
uint8_t n193;
uint8_t n224;
uint8_t n229;
uint8_t n238;
uint8_t n239;
uint8_t n252;
uint8_t n254;
uint8_t n285;
uint8_t n343;
uint8_t n356;
uint8_t n372;
uint8_t n393;
uint8_t n406;
uint8_t n414;
uint8_t n416;
uint8_t n432;
uint8_t n446;
uint8_t n460;
uint8_t n476;
uint8_t n480;
uint8_t n490;
uint8_t n510;
uint8_t n533;
uint8_t n534;
uint8_t n550;
uint8_t n564;
uint8_t n566;
uint8_t n580;
uint8_t n581;
uint8_t n594;
uint8_t n608;
uint8_t n617;
uint8_t n638;
uint8_t n654;
uint8_t n668;
uint8_t n682;
uint8_t n686;
uint8_t n698;
uint8_t n712;
uint8_t n728;
uint8_t n729;
uint8_t n756;
uint8_t n772;
uint8_t n786;
uint8_t n802;
uint8_t n816;
uint8_t n832;
uint8_t n846;
uint8_t n860;
uint8_t n869;
uint8_t n876;
uint8_t n890;
uint8_t n902;
uint8_t n906;
uint8_t n920;
uint8_t n934;
uint8_t n950;
uint8_t n964;
uint8_t n965;
uint8_t n980;
uint8_t n1009;
uint8_t n1038;
uint8_t n1054;
uint8_t n1055;
uint8_t n1068;
uint8_t n1069;
uint8_t n1082;
uint8_t n1098;
uint8_t n1129;
uint8_t n1136;
uint8_t n1143;
uint8_t n1156;
uint8_t n1157;
uint8_t n1172;
uint8_t n1173;
uint8_t n1186;
uint8_t n1187;
uint8_t n1191;
uint8_t n1202;
uint8_t n1203;
uint8_t n1232;
uint8_t n1233;
uint8_t n1246;
uint8_t n1276;
uint8_t n1277;
uint8_t n1291;
uint8_t n1306;
uint8_t n1320;
uint8_t n1321;
uint8_t n1334;
uint8_t n1335;
uint8_t n1350;
uint8_t n1351;
uint8_t n1365;
uint8_t n1380;
uint8_t n1381;
uint8_t n1394;
uint8_t n1395;
uint8_t n1408;
uint8_t n1409;
uint8_t n1424;
uint8_t n1425;
uint8_t n1427;
uint8_t n1438;
uint8_t n1439;
uint8_t n1454;
uint8_t n1455;
uint8_t n1468;
uint8_t n1482;
uint8_t n1498;
uint8_t n1499;
uint8_t n1513;
uint8_t n1529;
uint8_t n1542;
uint8_t n1543;
uint8_t n1556;
uint8_t n1557;
uint8_t n1572;
uint8_t n1573;
uint8_t n1586;
uint8_t n1587;
uint8_t n1602;
uint8_t n1603;
uint8_t n1616;
uint8_t n1632;
uint8_t n1646;
uint8_t n1660;
uint8_t n1676;
uint8_t n1691;
uint8_t n1706;
uint8_t n1707;
uint8_t n1720;
uint8_t n1721;
uint8_t n1734;
uint8_t n1735;
uint8_t n1750;
uint8_t n1751;
uint8_t n1764;
uint8_t n1765;
uint8_t n1780;
uint8_t n1781;
uint8_t n1794;
uint8_t n1795;
uint8_t n1808;
uint8_t n1809;
uint8_t n1824;
uint8_t n1838;
uint8_t n1854;
uint8_t n1869;
uint8_t n1882;
uint8_t n1898;
uint8_t n1899;
uint8_t n1912;
uint8_t n1913;
uint8_t n1928;
uint8_t n1929;
uint8_t n1942;
uint8_t n1943;
uint8_t n1956;
uint8_t n1957;
uint8_t n1972;
uint8_t n1973;
uint8_t n1986;
uint8_t n1987;
uint8_t n2016;
n32 = n18 & n12;
n33 = n18 & n12;
n34 = ~(n30 & n12 & n10);
n35 = ~(n30 & n12 & n10);
n37 = n2;
n38 = n28 ^ n0;
n41 = ~(n18 | n12 | n35);
n42 = ~(n33 | n34 | n6);
n43 = ~(n33 | n34 | n6);
n45 = (n18 & n20) | (n20 & n35) | (n18 & n35);
n46 = n33 & n12;
n47 = n33 & n12;
n49 = ~(n41 & n38 & n0);
n50 = n22;
n51 = n22;
n54 = ~(n22 & n46);
n55 = ~(n22 & n46);
n57 = ~(n33 | n54 | n0);
n62 = n43 ^ n0;
n67 = n10;
n69 = ~(n33 ^ n20);
n70 = n47;
n71 = n47;
n73 = ~(n70 & n62 & n6);
n76 = ~(n18 | n54);
n77 = ~(n18 | n54);
n78 = ~(n37 & n28);
n80 = ~(n18 & n71);
n83 = ~n45;
n85 = ~(n69 | n4);
n86 = n49 | n32;
n89 = ~(n18 ^ n78);
n91 = ~((n45 | n16) & n37);
n93 = n89;
n95 = (n73 & n80) | (~n73 & n67);
n99 = ~((n43 & n54) | n18);
n106 = n10 & n70;
n107 = n10 & n70;
n109 = ~(n77 ^ n86);
n110 = ~n95;
n121 = n12 & n16;
n131 = (n107 & n50) | (~n107 & n99);
n134 = n14 & n16;
n137 = ~(n73 | n28 | n91);
n138 = n41;
n139 = n41;
n141 = ~(n85 | n46 | n55);
n142 = ~((n99 & n86) | n49);
n144 = ~(n73 & n134);
n150 = ~(n93 & n20);
n153 = ~(n57 | n38 | n144);
n169 = ~(n49 & n110 & n139);
n181 = ~(n169 & n142);
n193 = ~((n18 & n12) | n83);
n224 = n10 & n18;
n229 = n109 ^ n42;
n238 = n12 & n18;
n239 = n12 & n18;
n252 = ~(n181 | n46);
n254 = n14 & n18;
n285 = n229;
n343 = n10 & n20;
n356 = n12 & n20;
n372 = n14 & n20;
n393 = n153 & n150;
n406 = ~n239;
n414 = (n33 & n252) | (~n33 & n37);
n416 = ~(n4 & n22 & n6);
n432 = n6 & n22;
n446 = n8 & n22;
n460 = n10 & n22;
n476 = n12 & n22;
n480 = ~n393;
n490 = n14 & n22;
n510 = (n131 ^ n480) ^ n93;
n533 = n193 & n4;
n534 = n4 & n24;
n550 = n6 & n24;
n564 = n8 & n24;
n566 = n141;
n580 = n10 & n24;
n581 = n10 & n24;
n594 = n12 & n24;
n608 = n14 & n24;
n617 = ~n137;
n638 = n2 & n26;
n654 = n4 & n26;
n668 = n6 & n26;
n682 = n8 & n26;
n686 = n139;
n698 = n10 & n26;
n712 = n12 & n26;
n728 = n14 & n26;
n729 = n14 & n26;
n756 = n2 & n138;
n772 = n4 & n28;
n786 = n6 & n28;
n802 = n8 & n28;
n816 = n10 & n28;
n832 = n12 & n28;
n846 = n14 & n28;
n860 = n0 & n30;
n869 = n533 & n414;
n876 = n2 & n30;
n890 = n4 & n30;
n902 = n869;
n906 = n6 & n30;
n920 = n8 & n30;
n934 = n10 & n30;
n950 = n12 & n30;
n964 = n14 & n30;
n965 = n14 & n30;
n980 = n46;
n1009 = (n51 & n566) | (~n51 & n76);
n1038 = ~(n106 & n16);
n1054 = n121 | n224;
n1055 = n121 | n224;
n1068 = (n134 ^ n238) ^ n343;
n1069 = (n134 & n238) | (n238 & n343) | (n134 & n343);
n1082 = n254 & n356;
n1098 = n254 ^ n356;
n1129 = n416 & n638;
n1136 = ~(n393 ^ n902);
n1143 = n432 ^ n534;
n1156 = (n446 ^ n550) ^ n654;
n1157 = (n446 & n550) | (n550 & n654) | (n446 & n654);
n1172 = (n460 ^ n564) ^ n668;
n1173 = (n460 & n564) | (n564 & n668) | (n460 & n668);
n1186 = (n476 ^ n580) ^ n682;
n1187 = (n476 & n580) | (n580 & n682) | (n476 & n682);
n1191 = n617 ^ n510;
n1202 = (n490 ^ n594) ^ n698;
n1203 = (n490 & n594) | (n594 & n698) | (n490 & n698);
n1232 = n608 ^ n712;
n1233 = n608 & n712;
n1246 = n533;
n1276 = n581 & n1009;
n1277 = n581 & n1009;
n1291 = n1038;
n1306 = n1054 & n686;
n1320 = (n1068 ^ n1055) ^ n1156;
n1321 = (n1068 & n1055) | (n1055 & n1156) | (n1068 & n1156);
n1334 = (n1098 ^ n1069) ^ n1172;
n1335 = (n1098 & n1069) | (n1069 & n1172) | (n1098 & n1172);
n1350 = (n372 ^ n1082) ^ n1186;
n1351 = (n372 & n1082) | (n1082 & n1186) | (n372 & n1186);
n1365 = n1129 & n406;
n1380 = (n1143 ^ n756) ^ n860;
n1381 = (n1143 & n756) | (n756 & n860) | (n1143 & n860);
n1394 = (n1157 ^ n772) ^ n876;
n1395 = (n1157 & n772) | (n772 & n876) | (n1157 & n876);
n1408 = (n1173 ^ n786) ^ n890;
n1409 = (n1173 & n786) | (n786 & n890) | (n1173 & n890);
n1424 = (n1187 ^ n802) ^ n906;
n1425 = (n1187 & n802) | (n802 & n906) | (n1187 & n906);
n1427 = ~((n1191 & n1136) | n285);
n1438 = (n1203 ^ n816) ^ n920;
n1439 = (n1203 & n816) | (n816 & n920) | (n1203 & n920);
n1454 = (n1233 ^ n832) ^ n934;
n1455 = (n1233 & n832) | (n832 & n934) | (n1233 & n934);
n1468 = n846 & n950;
n1482 = n846 ^ n950;
n1498 = n965;
n1499 = n965;
n1513 = n1276;
n1529 = n729 & n1277;
n1542 = n1306 & n1291;
n1543 = n1306 & n1291;
n1556 = (n1320 ^ n1082) ^ n1380;
n1557 = (n1320 & n1082) | (n1082 & n1380) | (n1320 & n1380);
n1572 = (n1334 ^ n1321) ^ n1394;
n1573 = (n1334 & n1321) | (n1321 & n1394) | (n1334 & n1394);
n1586 = (n1350 ^ n1335) ^ n1408;
n1587 = (n1350 & n1335) | (n1335 & n1408) | (n1350 & n1408);
n1602 = (n1202 ^ n1351) ^ n1424;
n1603 = (n1202 & n1351) | (n1351 & n1424) | (n1202 & n1424);
n1616 = n1232 & n1438;
n1632 = n1232 ^ n1438;
n1646 = n728 & n1454;
n1660 = n728 ^ n1454;
n1676 = n1529 | n1499;
n1691 = n343 & n1513;
n1706 = n1542 ^ n1529;
n1707 = n1542 & n1529;
n1720 = (n1556 ^ n1543) ^ n1365;
n1721 = (n1556 & n1543) | (n1543 & n1365) | (n1556 & n1365);
n1734 = (n1572 ^ n1557) ^ n1381;
n1735 = (n1572 & n1557) | (n1557 & n1381) | (n1572 & n1381);
n1750 = (n1586 ^ n1573) ^ n1395;
n1751 = (n1586 & n1573) | (n1573 & n1395) | (n1586 & n1395);
n1764 = (n1602 ^ n1587) ^ n1409;
n1765 = (n1602 & n1587) | (n1587 & n1409) | (n1602 & n1409);
n1780 = (n1632 ^ n1603) ^ n1425;
n1781 = (n1632 & n1603) | (n1603 & n1425) | (n1632 & n1425);
n1794 = (n1660 ^ n1616) ^ n1439;
n1795 = (n1660 & n1616) | (n1616 & n1439) | (n1660 & n1439);
n1808 = (n1482 ^ n1646) ^ n1455;
n1809 = (n1482 & n1646) | (n1646 & n1455) | (n1482 & n1455);
n1824 = n964 & n1468;
n1838 = n964 ^ n1468;
n1854 = n1427 ^ n756;
n1869 = n1706 & n1691;
n1882 = (n1720 ^ n1707) ^ n1869;
n1898 = n1734 ^ n1721;
n1899 = n1734 & n1721;
n1912 = (n1750 ^ n1735) ^ n1899;
n1913 = (n1750 & n1735) | (n1735 & n1899) | (n1750 & n1899);
n1928 = (n1764 ^ n1751) ^ n1913;
n1929 = (n1764 & n1751) | (n1751 & n1913) | (n1764 & n1913);
n1942 = (n1780 ^ n1765) ^ n1929;
n1943 = (n1780 & n1765) | (n1765 & n1929) | (n1780 & n1929);
n1956 = (n1794 ^ n1781) ^ n1943;
n1957 = (n1794 & n1781) | (n1781 & n1943) | (n1794 & n1943);
n1972 = (n1808 ^ n1795) ^ n1957;
n1973 = (n1808 & n1795) | (n1795 & n1957) | (n1808 & n1957);
n1986 = (n1838 ^ n1809) ^ n1973;
n1987 = (n1838 & n1809) | (n1809 & n1973) | (n1838 & n1973);
n2016 = n1824 | n1987;
c |= (n32 & 0x1) << 0;
c |= (n980 & 0x1) << 1;
c |= (n1246 & 0x1) << 2;
c |= (n1498 & 0x1) << 3;
c |= (n1676 & 0x1) << 4;
c |= (n1854 & 0x1) << 5;
c |= (n1943 & 0x1) << 6;
c |= (n1882 & 0x1) << 7;
c |= (n1898 & 0x1) << 8;
c |= (n1912 & 0x1) << 9;
c |= (n1928 & 0x1) << 10;
c |= (n1942 & 0x1) << 11;
c |= (n1956 & 0x1) << 12;
c |= (n1972 & 0x1) << 13;
c |= (n1986 & 0x1) << 14;
c |= (n2016 & 0x1) << 15;
return c;
}
|
the_stack_data/7951099.c | // Greatest number using nested if
#include <stdio.h>
int main(void)
{
int a, b, c;
printf("enter three integer number\n");
scanf("%d%d%d", &a, &b, &c);
if(a > b)
if(a > c)
printf("a is greatest");
else
printf("c is greatest");
else if(b > c)
printf("b is greatest");
else
printf("c is greatest");
printf("\n");
return 0;
}
|
the_stack_data/125139634.c | /* Making a system call from C */
#include<stdio.h>
#include<stdlib.h>
int main() {
printf("Starting system call . . .\n");
system("ls -l"); /* execute UNIX command to list directory contents */
printf("Done with system call\n");
return 0;
}
|
the_stack_data/1191004.c |
int age=10;
void printer(){
printf("hellp printer");
}
|
the_stack_data/20464.c | // RUN: %cml %s -o %t && %t | FileCheck %s
#include <stdio.h>
int main() {
int a[6] = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < 6; ++i) {
switch (a[i]) {
case 1:
// CHECK: ONE
printf("ONE\n");
break;
case 2:
// CHECK: TWO
printf("TWO\n");
break;
case 3:
// CHECK: THREE
printf("THREE\n");
break;
case 4:
// CHECK: FOUR
printf("FOUR\n");
default:
// CHECK: UNKNOWN
// CHECK: UNKNOWN
// CHECK: UNKNOWN
printf("UNKNOWN\n");
}
}
return 0;
}
|
the_stack_data/93888968.c | /**
* Chapter: 4
* Exercise: 4-06 - Add commands for handling variables. (It's easy to provide twenty-six variables with single-letter names)
* Add a variable for the most recently printed value.
**/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXOP 100 /* max size of operand or operator */
#define MAXVAL 100 /* maximum depth of val stack */
#define NUMBER '0' /* signal that a number was found */
#define BUFSIZE 100 /* buffer for ungetch */
int getop(char []);
int getch(void);
void ungetch(int);
void push(double);
double pop(void);
char buf[BUFSIZE];
double stack[MAXVAL];
int sp = 0; /* next free stack position */
int bufp = 0;
/* reverse polish calculator */
int main() {
int type, i, var;
double op2, v, variable[26];
char s[MAXOP];
var = 0;
while ((type = getop(s)) != EOF){
switch(type){
case NUMBER:
push(atof(s));
break;
case '+':
push(pop() + pop());
break;
case '*':
push(pop() * pop());
break;
case '-':
op2 = pop();
push(pop() - op2);
break;
case '/':
op2 = pop();
if(op2 != 0){
push(pop() / op2);
} else {
printf("error: zero divisor.\n");
}
break;
case '=':
pop();
if(var >= 'A' && var <= 'Z') {
variable[var - 'A'] = pop();
} else {
printf("error: no variable name.\n");
}
break;
case '\n':
v = pop();
printf("\t%.8g\n", pop());
break;
default:
if(type >= 'A' && type <= 'Z'){
push(variable[type - 'A']);
} else if (type == 'v') {
push(v);
} else {
printf("error: unknown command %s\n", s);
}
break;
}
var = type;
}
return 0;
}
/* push: push f onto value stack */
void push(double f){
if (sp < MAXVAL){
stack[sp++] = f;
} else {
printf("error: stack full, can't push %f\n", f);
}
}
/* pop: pop and return top value from stack */
double pop(void){
if(sp > 0){
return stack[--sp];
} else {
printf("error: stack empty.\n");
return 0.0;
}
}
/* getop: get next operator of numeric operand */
int getop(char s[]){
int i, c;
while((s[0] = c = getch()) == ' ' || c == '\t')
;
s[1] = '\0';
if(!isdigit(c) && c != '.'){
return c;
}
i = 0;
if(isdigit(c)){
while (isdigit(s[++i] = c = getch()))
;
}
if(c == '.'){
while (isdigit(s[++i] = c = getch()))
;
}
s[i] = '\0';
if(c != EOF){
ungetch(c);
}
return NUMBER;
}
/* getch: get a character */
int getch(void){
return (bufp > 0) ? buf[--bufp] : getchar();
}
/* ungetch: push character back on input */
void ungetch(int c){
if(bufp >= BUFSIZE){
printf("ungetch: too many characters\n");
} else {
buf[bufp++] = c;
}
} |
the_stack_data/151705423.c | #include <stdio.h>
/* count characters in input; 2nd version */
int main()
{
double nc; /* long 형으로 모자랄 만큼 큰 파일이 있을 것에 대비 */
for (nc = 0; getchar() != EOF; ++nc) {
;
}
printf("%.0f\n", nc);
return 0;
}
|
the_stack_data/190767589.c | /*Exercise 3 - Repetition
Write a C program to calculate the sum of the numbers from 1 to n.
Where n is a keyboard input.
e.g.
n -> 100
sum = 1+2+3+....+ 99+100 = 5050
n -> 1-
sum = 1+2+3+...+10 = 55 */
#include <stdio.h>
int main() {
int n, i, sum = 0;
printf("n ->");
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
sum += i;
}
printf("Sum = %d", sum);
return 0;
}
|
the_stack_data/466704.c | /*
* something issue
* while can't work
*/
#include <stdio.h>
int main()
{
char ch;
printf("Enter yout degree(from 'A' to 'E'): ");
scanf("%c", &ch);
while(ch >= 'A' && ch <= 'E'){
switch (ch){
case 'A': printf("You fraction big than 90\n"); break;
case 'B': printf("You fraction between 80 and 89\n"); break;
case 'C': printf("You fraction between 70 and 79\n"); break;
case 'D': printf("You fraction between 60 and 69\n"); break;
case 'E': printf("You fraction between 1 and 59\n"); break;
default: printf("this is default\n"); break;
}
printf("Enter yout degree(from 'A' to 'E'): ");
scanf("%c", &ch);
}
return 0;
}
|
the_stack_data/7950311.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
char *env;
env = getenv("HOME");
printf("%s\n", env);
return 0;
}
|
the_stack_data/20449956.c | #include<stdio.h>
#include<stdlib.h>
// Function should be declared before using in c to avoid implicit error.
struct node* rem(struct node* root,int data);
struct node* goleft(struct node *root,int add);
struct node* goright(struct node *root,int add);
struct node* insert(struct node *root,int add);
void inorder(struct node* root);
struct node //node declaration for BST
{
int data;
struct node *left;
struct node *right;
};
struct node* createnode(int data) //Empty node
{
struct node *a;
a=(struct node*)malloc(sizeof(struct node));
a->data=data;
a->left=NULL;
a->right=NULL;
return a;
}
struct node* goleft(struct node *root,int add) //Insertion using recursion.
{
if(root==NULL)
{ struct node* temp;
temp = createnode(add);
return temp;
}
else
{
root=insert(root,add);
return root;
}
}
struct node* goright(struct node *root, int add)
{
if(root==NULL)
{ struct node* temp;
temp = createnode(add);
return temp;
}
else
{
root=insert(root,add);
return root;
}
}
struct node* insert(struct node *root,int add) //function that returns pointer to node.(adding at start)
{
if(root==NULL)
root=createnode(add);
else
{
if(add > root->data)
root->right = goright(root->right,add);
if(add < root->data)
root->left=goleft(root->left,add);
}
return root;
}
void printleft(struct node* root)
{
if(root->left==NULL)
return;
else
inorder(root->left);
}
void printright(struct node* root)
{
if(root->right==NULL)
return;
else
inorder(root->right);
}
void printroot(struct node* root)
{
printf("%d ",root->data);
return;
}
void inorder(struct node* root) // prints root followed by lift then right child.
{
if(root==NULL)
return;
printleft(root);
printroot(root);
printright(root);
}
int min(struct node* root)
{
while(root->left!=NULL)
root=root->left;
return root->data;
}
struct node* rem(struct node* root,int data) //returns root after removing data.
{
if(root==NULL)
return root;
if(root->data == data)
{
if(root->left == NULL && root->right==NULL)
return(NULL);
else
{
if(root->right==NULL)
return root->left;
if(root->left==NULL)
return root->right;
if(root->left != NULL && root->right != NULL)
{
root->data=min(root->right);
root->right=rem(root->right,min(root->right));
//printf("%d",min(root->right));
return root;
}
}
}
else
{
if(root->data > data)
{
root->left=rem(root->left,data);
return root;
}
if(root->data < data)
{
root->right=rem(root->right,data);
return root;
}
}
}
int main()
{ struct node* start;
start=NULL; //inputting the tree.
int i,x;
printf("Enter the number of elements you want to add\n");
scanf("%d",&i);
printf("Enter %d elements-\n",i);
for(;i>0;--i)
{
scanf("%d",&x);
start=insert(start,x);
}
inorder(start);
printf("\nEnter the element you want to delete\n");
scanf("%d",&x);
start=rem(start,x);
printf("Hopefully, your element is deleted!\n");
inorder(start);
return 0;
}
|
the_stack_data/36074094.c | /*
* Copyright (c) 1987 Regents of the University of California.
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University 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 REGENTS 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 REGENTS 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 <sys/cdefs.h>
#include <string.h>
#if defined(LIBC_SCCS) && !defined(lint)
static const char sccsid[] = "@(#)strcasecmp.c 5.10 (Berkeley) 1/26/91";
#endif /* LIBC_SCCS and not lint */
typedef unsigned char u_char;
/*
* This array is designed for mapping upper and lower case letter
* together for a case independent comparison. The mappings are
* based upon ascii character sequences.
*/
static const u_char charmap[] = {
'\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
'\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
'\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
'\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
'\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
'\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
'\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
'\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
'\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
'\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
'\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
'\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
'\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
'\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
'\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
'\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
'\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
'\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
'\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
'\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
'\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
'\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
'\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
'\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
'\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
'\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
};
int
strcasecmp(s1, s2)
const char *s1, *s2;
{
register const u_char *cm = charmap,
*us1 = (const u_char *)s1,
*us2 = (const u_char *)s2;
while (cm[*us1] == cm[*us2++])
if (*us1++ == '\0')
return (0);
return (cm[*us1] - cm[*--us2]);
}
int
strncasecmp(s1, s2, n)
const char *s1, *s2;
register size_t n;
{
if (n != 0) {
register const u_char *cm = charmap,
*us1 = (const u_char *)s1,
*us2 = (const u_char *)s2;
do {
if (cm[*us1] != cm[*us2++])
return (cm[*us1] - cm[*--us2]);
if (*us1++ == '\0')
break;
} while (--n != 0);
}
return (0);
}
|
the_stack_data/14200500.c | /*???*/
|
the_stack_data/248579499.c | foo (a)
{
if (a >= 0)
return (unsigned) a << 10;
else
return (int) a << 10;
}
|
the_stack_data/137099.c | // This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
/********************
NSBlock support
We allocate space and export a symbol to be used as the Class for the on-stack and malloc'ed copies until ObjC arrives on the scene. These data areas are set up by Foundation to link in as real classes post facto.
We keep these in a separate file so that we can include the runtime code in test subprojects but not include the data so that compiled code that sees the data in libSystem doesn't get confused by a second copy. Somehow these don't get unified in a common block.
**********************/
#define BLOCK_EXPORT extern __attribute__((visibility("default")))
BLOCK_EXPORT void * _NSConcreteStackBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteMallocBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteAutoBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteGlobalBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32] = { 0 };
|
the_stack_data/212644005.c | /*
Producer-consumer example with pthreads
Both processes could try to modify the shared variable counter
concurrently and cause loss of information, but this is avoided by
a pthreads mutex
Jim Teresco, Williams College
March, 2005
Updated for CSIS 330, Siena College, Spring 2012
*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define BUFFER_SIZE 5
#define NUMBER_OF_ITEMS 30
/* the shared data structures -- just global variables in this case */
int buffer[BUFFER_SIZE];
int in;
int out;
int counter;
/* mutex to protect access to the counter variable */
pthread_mutex_t mutex;
/* producer thread */
void producer(void *args) {
int i;
long spin;
for (i=0; i<NUMBER_OF_ITEMS; i++) {
/* simulate the cost of producing the item by
sleeping for a small random number of seconds */
sleep(rand()%4+1);
/* put the produced value in the buffer when there's space */
printf("P: produced %d\n", i);
spin = 0;
while (counter == BUFFER_SIZE) {
if (spin == 0) {
printf("P: waiting for open slot\n");
}
spin++;
}
if (spin > 0) {
printf("P: done waiting (cycled %ld times)\n", spin);
}
printf("P: adding item %d at slot %d (counter=%d->%d)\n", i, in,
counter, counter+1);
buffer[in] = i;
in = (in + 1)%BUFFER_SIZE;
/* Need to protect this modification of counter with mutual exclusion */
if (pthread_mutex_lock(&mutex) != 0) {
perror("pthread_mutex_lock");
exit(1);
}
/* we can now modify counter */
counter++;
if (pthread_mutex_unlock(&mutex) != 0) {
perror("pthread_mutex_unlock");
exit(1);
}
}
}
/* consumer thread */
void consumer(void *args) {
long spin;
int i;
for (i=0; i<NUMBER_OF_ITEMS; i++) {
/* look for a value */
spin = 0;
while (counter == 0) {
if (spin == 0) {
printf("C: waiting for item\n");
}
spin++;
}
if (spin > 0) {
printf("C: done waiting (cycled %ld times)\n", spin);
}
/* consume the next available item */
printf("C: consuming value %d from slot %d (counter=%d->%d)\n",
buffer[out], out, counter, counter-1);
out = (out + 1)%BUFFER_SIZE;
/* Need to protect this modification of counter with mutual exclusion */
if (pthread_mutex_lock(&mutex) != 0) {
perror("pthread_mutex_lock");
exit(1);
}
/* we can now modify counter */
counter--;
if (pthread_mutex_unlock(&mutex) != 0) {
perror("pthread_mutex_unlock");
exit(1);
}
/* simulate the cost of consuming the item */
/* this is slightly longer than the producer to increase the
chances of filling up the buffer */
sleep(rand()%5+1);
}
}
/* main program, just starts up the threads */
int main(int argc, char *argv[]) {
pthread_t producer_id, consumer_id;
int rc;
/* initialize shared data */
in = 0;
out = 0;
counter = 0;
/* seed the random number generator on pid */
srand(getpid());
/* initialize our mutex */
if (pthread_mutex_init(&mutex, NULL) != 0) {
perror("pthread_mutex_init");
exit(1);
}
/* create the consumer */
rc = pthread_create(&consumer_id, NULL, (void *)&consumer, NULL);
if (rc != 0) {
fprintf(stderr, "Could not create consumer child thread\n");
exit(1);
}
/* create the producer */
rc = pthread_create(&producer_id, NULL, (void *)&producer, NULL);
if (rc != 0) {
fprintf(stderr, "Could not create producer child thread\n");
exit(1);
}
/* wait for the child threads to exit */
pthread_join(producer_id,NULL);
pthread_join(consumer_id,NULL);
/* destroy our semaphore */
if (pthread_mutex_destroy(&mutex) != 0) {
perror("pthread_mutex_destroy");
exit(1);
}
printf("Final counter is %d\n", counter);
return 0;
}
|
the_stack_data/258670.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
/* Titulo: hydrogen
* Descripción: Your name is not usually a good password :(
* Categoria: reversing
* Puntuación: 250
* Flag: moonCTF{0661de560d0fbe73ecf5d894e24f0982}
* Autor: iordic
* Pista: break the flow!
* Solución: Usar debugger para obligar a entrar en el if que imprime la pista,
* también se puede parchear sin debugger y luego lanzar, de este modo
* nos devuelve la pista. Se puede apreciar que esta está con rotación 13.
* Decodificamos la url y en la noticia obtenemos la contraseña.
*
*/
void show_hint();
uint8_t genkey(char *password);
void encrypt(char *ctext, uint8_t key);
int main() {
char password[16];
int want_hint = 0;
if (want_hint) {
printf("Good, here's your hint: ");
show_hint();
} else {
printf("you don't want a hint? Uhm... OK\n");
}
//char c_flag[] = "moonCTF{0661de560d0fbe73ecf5d894e24f0982}";
char c_flag[] = "\x60\x62\x62\x63\x4e\x59\x4b\x76\x3d\x3b\x3b" \
"\x3c\x69\x68\x38\x3b\x3d\x69\x3d\x6b\x6f\x68" \
"\x3a\x3e\x68\x6e\x6b\x38\x69\x35\x34\x39\x68" \
"\x3f\x39\x6b\x3d\x34\x35\x3f\x70";
int size = strlen(c_flag);
printf("What's the password?: ");
scanf("%s", password);
if (check_password(password)) {
uint8_t key = genkey(password);
encrypt(c_flag, key);
printf("Oh, well... Here's your flag: %s\n", c_flag);
} else {
printf("Sorry, bad password :(\n");
}
return 0;
}
/* Un poco de complejidad y ruido adicional, ni siquiera hace falta entrar a mirar */
int check_password(char *password) {
char fake[] = "P@ssw0rd"; // :)
if (!strcmp(fake, password)) {
printf("Good try xD\n");
}
int size = strlen(password);
int result = 0;
for (int i = 0; i < size; i++) {
result += password[i];
}
result += size;
if (result == 1257)
return 1;
return 0;
}
void show_hint() {
/* Algoritmo usado:
* 1. rot-13 de: https://thehackernews.com/2021/03/solarwinds-blame-intern-for-weak.html
* char hint[] = "uggcf://gurunpxrearjf.pbz/2021/03/fbynejvaqf-oynzr-vagrea-sbe-jrnx.ugzy";
* 2. for i in rango(0, tamaño(hint)) => xor(hint[i], i)
*/
char hint[] = "\x75\x66\x65\x60\x62\x3f\x29\x28\x6f\x7c\x78\x7e\x62\x7d" \
"\x76\x7d\x75\x70\x60\x79\x72\x3b\x66\x75\x62\x36\x28\x2b" \
"\x2e\x2c\x31\x2f\x13\x0e\x44\x41\x5d\x4b\x43\x4d\x5e\x48" \
"\x5b\x4d\x01\x42\x57\x41\x4a\x43\x1f\x45\x55\x52\x44\x52" \
"\x59\x14\x49\x59\x59\x10\x54\x4d\x2e\x39\x6c\x36\x23\x3f" \
"\x3f";
int h_size = strlen(hint);
for (int i = 0; i < h_size; i++) {
hint[i] ^= i;
}
printf("%s\n", hint);
}
/* XOR de cada letra de la contraseña 'solarwinds123' */
uint8_t genkey(char *password) {
uint8_t key = 0;
for (int i = 0; i < strlen(password); i++) {
key ^= password[i];
}
}
/* xor de cada letra con la clave generada */
void encrypt(char *ctext, uint8_t key) {
int size = strlen(ctext);
for (int i = 0; i < size; i++) {
ctext[i] = ctext[i] ^ key;
}
}
|
the_stack_data/18888825.c | // Entab
#include <stdio.h>
#define MAXLINE 1000
int myGetline(char s[], int lim) {
int c, i;
for(i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
s[i] = c;
if(c == '\n') {
s[i] = c;
++i;
}
s[i] = '\0';
return i;
}
int main(void) {
int c, i, len;
int spaceCount;
int tabstop = 8;
char line[MAXLINE];
while((len = myGetline(line, MAXLINE)) > 0) {
spaceCount = 0;
for(i = 0; i < len; ++i) {
if(line[i] == ' ')
spaceCount++;
else
spaceCount = 0;
}
printf("%s", line);
}
return 0;
}
|
the_stack_data/150144002.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from evoapprox8b dataset. Note that a new version of library was already published.
***/
#include <stdint.h>
#include <stdlib.h>
/// Approximate function add8_097
/// Library = EvoApprox8b
/// Circuit = add8_097
/// Area (180) = 792
/// Delay (180) = 1.390
/// Power (180) = 193.40
/// Area (45) = 60
/// Delay (45) = 0.510
/// Power (45) = 18.70
/// Nodes = 14
/// HD = 176512
/// MAE = 3.45312
/// MSE = 22.50000
/// MRE = 1.76 %
/// WCE = 15
/// WCRE = 300 %
/// EP = 85.9 %
uint16_t add8_097(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n39;
uint8_t n40;
uint8_t n52;
uint8_t n75;
uint8_t n114;
uint8_t n127;
uint8_t n132;
uint8_t n182;
uint8_t n213;
uint8_t n232;
uint8_t n233;
uint8_t n282;
uint8_t n283;
uint8_t n332;
uint8_t n333;
uint8_t n382;
uint8_t n383;
n32 = ~(n22 & n2);
n39 = ~(n32 | n30);
n40 = n20 ^ n20;
n52 = n6 & n39;
n75 = n52;
n114 = n75;
n127 = ~n40;
n132 = n4 | n20;
n182 = n6 | n22;
n213 = n114;
n232 = (n8 ^ n24) ^ n213;
n233 = (n8 & n24) | (n24 & n213) | (n8 & n213);
n282 = (n10 ^ n26) ^ n233;
n283 = (n10 & n26) | (n26 & n233) | (n10 & n233);
n332 = (n12 ^ n28) ^ n283;
n333 = (n12 & n28) | (n28 & n283) | (n12 & n283);
n382 = (n14 ^ n30) ^ n333;
n383 = (n14 & n30) | (n30 & n333) | (n14 & n333);
c |= (n127 & 0x1) << 0;
c |= (n127 & 0x1) << 1;
c |= (n132 & 0x1) << 2;
c |= (n182 & 0x1) << 3;
c |= (n232 & 0x1) << 4;
c |= (n282 & 0x1) << 5;
c |= (n332 & 0x1) << 6;
c |= (n382 & 0x1) << 7;
c |= (n383 & 0x1) << 8;
return c;
}
|
the_stack_data/111457.c |
//////////////////////////////////////////////////////////////////////////////
//
// int FAR PASCAL LibMain (hInst, wDataSeg, cbHeapSize, lpszCmdLine)
//
// The main library entry point. This routine is called when the library
// is loaded.
//
// Arguments:
//
// hInst -
// wDataSeg -
// cbHeapSize -
// lpszCmdLine -
//
// Returns:
//
// Effects:
//
//////////////////////////////////////////////////////////////////////////////
|
the_stack_data/136311.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]/df(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 doublereal c_b9 = 1.;
static doublereal c_b11 = -1.;
/* > \brief \b DPOTRF2 */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* Definition: */
/* =========== */
/* SUBROUTINE DPOTRF2( UPLO, N, A, LDA, INFO ) */
/* CHARACTER UPLO */
/* INTEGER INFO, LDA, N */
/* REAL A( LDA, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > DPOTRF2 computes the Cholesky factorization of a real symmetric */
/* > positive definite matrix A using the recursive algorithm. */
/* > */
/* > The factorization has the form */
/* > A = U**T * U, if UPLO = 'U', or */
/* > A = L * L**T, if UPLO = 'L', */
/* > where U is an upper triangular matrix and L is lower triangular. */
/* > */
/* > This is the recursive version of the algorithm. It divides */
/* > the matrix into four submatrices: */
/* > */
/* > [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 */
/* > A = [ -----|----- ] with n1 = n/2 */
/* > [ A21 | A22 ] n2 = n-n1 */
/* > */
/* > The subroutine calls itself to factor A11. Update and scale A21 */
/* > or A12, update A22 then calls itself to factor A22. */
/* > */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > = 'U': Upper triangle of A is stored; */
/* > = 'L': Lower triangle of A is stored. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is DOUBLE PRECISION array, dimension (LDA,N) */
/* > On entry, the symmetric matrix A. If UPLO = 'U', the leading */
/* > N-by-N upper triangular part of A contains the upper */
/* > triangular part of the matrix A, and the strictly lower */
/* > triangular part of A is not referenced. If UPLO = 'L', the */
/* > leading N-by-N lower triangular part of A contains the lower */
/* > triangular part of the matrix A, and the strictly upper */
/* > triangular part of A is not referenced. */
/* > */
/* > On exit, if INFO = 0, the factor U or L from the Cholesky */
/* > factorization A = U**T*U or A = L*L**T. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > > 0: if INFO = i, the leading minor of order i is not */
/* > positive definite, and the factorization could not be */
/* > completed. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup doublePOcomputational */
/* ===================================================================== */
/* Subroutine */ int dpotrf2_(char *uplo, integer *n, doublereal *a, integer *
lda, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1;
/* Local variables */
extern logical lsame_(char *, char *);
integer iinfo;
extern /* Subroutine */ int dtrsm_(char *, char *, char *, char *,
integer *, integer *, doublereal *, doublereal *, integer *,
doublereal *, integer *);
logical upper;
extern /* Subroutine */ int dsyrk_(char *, char *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, doublereal *,
integer *);
integer n1, n2;
extern logical disnan_(doublereal *);
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
/* -- LAPACK computational routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input parameters */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
/* Function Body */
*info = 0;
upper = lsame_(uplo, "U");
if (! upper && ! lsame_(uplo, "L")) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < f2cmax(1,*n)) {
*info = -4;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DPOTRF2", &i__1, (ftnlen)7);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* N=1 case */
if (*n == 1) {
/* Test for non-positive-definiteness */
if (a[a_dim1 + 1] <= 0. || disnan_(&a[a_dim1 + 1])) {
*info = 1;
return 0;
}
/* Factor */
a[a_dim1 + 1] = sqrt(a[a_dim1 + 1]);
/* Use recursive code */
} else {
n1 = *n / 2;
n2 = *n - n1;
/* Factor A11 */
dpotrf2_(uplo, &n1, &a[a_dim1 + 1], lda, &iinfo);
if (iinfo != 0) {
*info = iinfo;
return 0;
}
/* Compute the Cholesky factorization A = U**T*U */
if (upper) {
/* Update and scale A12 */
dtrsm_("L", "U", "T", "N", &n1, &n2, &c_b9, &a[a_dim1 + 1], lda, &
a[(n1 + 1) * a_dim1 + 1], lda);
/* Update and factor A22 */
dsyrk_(uplo, "T", &n2, &n1, &c_b11, &a[(n1 + 1) * a_dim1 + 1],
lda, &c_b9, &a[n1 + 1 + (n1 + 1) * a_dim1], lda);
dpotrf2_(uplo, &n2, &a[n1 + 1 + (n1 + 1) * a_dim1], lda, &iinfo);
if (iinfo != 0) {
*info = iinfo + n1;
return 0;
}
/* Compute the Cholesky factorization A = L*L**T */
} else {
/* Update and scale A21 */
dtrsm_("R", "L", "T", "N", &n2, &n1, &c_b9, &a[a_dim1 + 1], lda, &
a[n1 + 1 + a_dim1], lda);
/* Update and factor A22 */
dsyrk_(uplo, "N", &n2, &n1, &c_b11, &a[n1 + 1 + a_dim1], lda, &
c_b9, &a[n1 + 1 + (n1 + 1) * a_dim1], lda);
dpotrf2_(uplo, &n2, &a[n1 + 1 + (n1 + 1) * a_dim1], lda, &iinfo);
if (iinfo != 0) {
*info = iinfo + n1;
return 0;
}
}
}
return 0;
/* End of DPOTRF2 */
} /* dpotrf2_ */
|
the_stack_data/247017797.c | /*
* Copyright (C) 2015-2018 Alibaba Group Holding Limited
*/
#ifdef AIOT_DEVICE_TIMER_ENABLE
#include "stdio.h"
#include "iot_export_timer.h"
#include "iot_import.h"
#include "cJSON.h"
#include "ccronexpr.h"
#define SDK_VER_16X
#define DAYS_OF_WEEK 7
typedef struct device_timer {
char timer[28]; // cron格式表达式
uint8_t enable; // 是否启用
uint8_t runTime; // 循环开时长
uint8_t sleepTime; // 循环关时长
uint8_t repeat; // 是否为重复执行定时
uint8_t type; // 定时类型
char endTime[6]; // 结束时间
char *targets; // malloc分配,最大128字节
int timezone; // 时区
int offset_start[DAYS_OF_WEEK]; // 转换后定时触发时间
int offset_end[DAYS_OF_WEEK]; // 转换后循环结束时间
int event_ready[DAYS_OF_WEEK]; // 确保定时时间能被执行
} device_timer_t;
extern int linkkit_ntp_time_request(void (*ntp_reply)(const char *ntp_offset_time_ms));
static uint32_t utc = 0, uptime_on_get_utc= 0, ntp_time_s=0;
static int utc_week_second_offset = -1, g_inited = 0;
#define WEEK_START 1609603200 // 2021.01.03 00:00(北京时间 时区+8) 纽约时区-5
device_timer_t g_device_timer[DeviceTimerSize];
static void *check_timer = NULL;
static uint32_t pre_ticket = 0;
static void device_timer_runner(void);
int aiot_device_timer_inited(void) {
return g_inited;
}
static uint32_t _get_uptime(void) {
#ifndef SDK_VER_16X
return (uint32_t)(aiot_al_time_ms()/1000);
#else
return (uint32_t)(HAL_UptimeMs()/1000);
#endif
}
static void get_timer_from_kv(void) {
int len = 1536; // kv max len; ITEM_MAX_VAL_LEN=1536 in kvmgr.c
char* tmp = NULL;
#ifndef SDK_VER_16X
tmp = aiot_al_malloc(len, LINKKIT_DEMO_MODULE_NAME);
#else
tmp = (char *)HAL_Malloc(len);
#endif
if (tmp == NULL) {
printf("get_timer malloc failed!\r\n");
return;
}
memset(tmp, 0, len);
#ifndef SDK_VER_16X
if (0 == aiot_kv_get(DEVICETIMER, tmp, &len)) {
#else
if (0 == HAL_Kv_Get(DEVICETIMER, tmp, &len)) {
#endif
DS_DEBUG("get %s\r\n", tmp);
deviceTimerParse(tmp, 1, 0);
}
#ifndef SDK_VER_16X
aiot_al_free(tmp);
#else
HAL_Free(tmp);
#endif
}
void _ntp_update(const char *str)
{
if (strlen(str) < 4)
return;
char str_time[16] = {0};
int str_len = strlen(str);
memset(str_time, 0, sizeof(str_time));
memcpy(str_time, str, str_len);
str_time[str_len - 3] = 0;
str_time[str_len - 2] = 0;
str_time[str_len - 1] = 0;
ntp_time_s = (uint32_t)atoi(str_time);
utc = (ntp_time_s - WEEK_START) % (86400 * 7); // 当前UTC,转换为以周为周期的余数;
uptime_on_get_utc = _get_uptime();
pre_ticket = 0;
// EXAMPLE_TRACE("utc=%s,ntp_time_s=%d utc_week_offset=%d \n", str, ntp_time_s, utc);
printf("TS_utc=%s,ntp_time_s=%d utc_week_offset=%d %d\r\n", str, ntp_time_s, utc, uptime_on_get_utc);
if (check_timer == NULL) {
#ifndef SDK_VER_16X
check_timer = aiot_al_timer_create("device_timer", (void (*)(void *))device_timer_runner, NULL);
#else
check_timer = HAL_Timer_Create("device_timer", (void (*)(void *))device_timer_runner, NULL);
#endif
}
if (g_inited == 0)
get_timer_from_kv();
g_inited = 1;
}
static const char** g_devicetimer_target_list = NULL;
static int g_num_devicetimer_list = 0;
static devicetimer_callback g_timer_service_cb = NULL;
int aiot_device_timer_init(const char **devicetimer_list, uint8_t num_devicetimer_list, devicetimer_callback timer_service_cb) {
if (devicetimer_list == NULL || timer_service_cb == NULL)
return -1;
g_devicetimer_target_list = devicetimer_list;
g_num_devicetimer_list = num_devicetimer_list;
g_timer_service_cb = timer_service_cb;
linkkit_ntp_time_request(_ntp_update);
#ifndef SDK_VER_16X
aiot_al_sleep_ms(100);
#else
HAL_SleepMs(100);
#endif
if (aiot_device_timer_inited() == 1)
return 1;
else {
#ifndef SDK_VER_16X
aiot_al_sleep_ms(500);
#else
HAL_SleepMs(500);
#endif
return aiot_device_timer_inited();
}
}
int aiot_device_timer_deinit() {
g_inited = 0;
int j = 0;
for (j = 0; j < DeviceTimerSize; j++) {
if (g_device_timer[j].targets != NULL) {
#ifndef SDK_VER_16X
aiot_al_free(g_device_timer[j].targets);
#else
HAL_Free(g_device_timer[j].targets);
#endif
}
}
memset(g_device_timer, 0, sizeof(g_device_timer));
return 0;
}
int aiot_device_timer_clear(void) {
aiot_device_timer_deinit();
#ifndef SDK_VER_16X
aiot_kv_del(DEVICETIMER);
#else
HAL_Kv_Del(DEVICETIMER);
#endif
return 0;
}
static int parse_action(int type, const char* action, int post) {
int i = 0;
char *p = NULL, *val = NULL;
DS_DEBUG("parse_action=%s\r\n", action);
for (i = 0; i < g_num_devicetimer_list; i++) {
p = strstr(action, g_devicetimer_target_list[i]);
if (p != NULL && action[strlen(g_devicetimer_target_list[i])] == ':') {
// val = atoi(&action[strlen(g_devicetimer_target_list[i])] + 1);
val = (char*)(&action[strlen(g_devicetimer_target_list[i])] + 1);
g_timer_service_cb(NULL, g_devicetimer_target_list[i], val);
}
}
return 0;
}
static void device_timer_action(int type, const char* action, int run_sleep, int post) {
char* p = NULL;
int count = 0, i = 0, pre_str_start = 0;
for (i = 0; i < strlen(action); i++) {
if (action[i] == ',')
count++;
}
DS_DEBUG("count=%d\r\n", count);
if (type == 1 || type == 2) { // 倒计时、普通定时
if (strchr(action, '|') != NULL || strlen(action) < 3)
return;
if (count == 0) { // 只设置一个属性
parse_action(type, action, post);
} else {
for (i = 0; i < strlen(action) + 1; i++) {
if (action[i] == ',' || action[i] == '\0') {
DS_DEBUG("loc=%d %d \r\n", i, pre_str_start);
#ifndef SDK_VER_16X
p = aiot_al_malloc(i + 1 - pre_str_start, LINKKIT_DEMO_MODULE_NAME);
#else
p = (char *)HAL_Malloc(i + 1 - pre_str_start);
#endif
memset(p, 0, i + 1 - pre_str_start);
memcpy(p, &action[pre_str_start], i - pre_str_start);
parse_action(type, p, post);
#ifndef SDK_VER_16X
aiot_al_free(p);
#else
HAL_Free(p);
#endif
pre_str_start = i + 1;
}
}
}
} else if (type == 3) { // 循环定时
if (strchr(action, '|') == NULL)
return;
if (run_sleep == 0) { //run
if (count == 0) {
for (i = 0; i < strlen(action) + 1; i++) {
if (action[i] == '|') {
#ifndef SDK_VER_16X
p = aiot_al_malloc(i + 1, LINKKIT_DEMO_MODULE_NAME);
#else
p = (char *)HAL_Malloc(i + 1);
#endif
memset(p, 0, i + 1);
memcpy(p, action, i);
parse_action(type, p, post);
#ifndef SDK_VER_16X
aiot_al_free(p);
#else
HAL_Free(p);
#endif
}
}
}
} else { //sleep
if (count == 0) {
for (i = 0; i < strlen(action) + 1; i++) {
if (action[i] == '|') {
#ifndef SDK_VER_16X
p = aiot_al_malloc(strlen(action) - i, LINKKIT_DEMO_MODULE_NAME);
#else
p = (char *)HAL_Malloc(strlen(action) - i);
#endif
memset(p, 0, strlen(action) - i);
memcpy(p, &action[i+1], strlen(action) - i - 1);
parse_action(type, p, post);
#ifndef SDK_VER_16X
aiot_al_free(p);
#else
HAL_Free(p);
#endif
}
}
}
}
} else { // 随机定时
// todo
}
}
static int _sec_next_event = -1;
static void device_timer_runner(void) {
int i = 0, j = 0;
int current_time = -1;
int n_run_and_sleep = 0;
int mod_run_and_sleep = 0;
// int tmp = 0;
uint32_t ticket = _get_uptime() - uptime_on_get_utc;
if (ntp_time_s == 0 || (ticket > 24*60*60/4 && (_sec_next_event == -1 || _sec_next_event - utc_week_second_offset > 10))) {
if (ntp_time_s == 0 || ticket < 0){
// EXAMPLE_TRACE("ERR: must sync ntp time. ticket=%d, %d now=%d!\n", ticket, uptime_on_get_utc, _get_uptime());
DS_ERR("TS_ERR: must sync ntp time. ticket=%d, %d now=%d!\r\n", ticket, uptime_on_get_utc, _get_uptime());
linkkit_ntp_time_request(_ntp_update);
return;
}
linkkit_ntp_time_request(_ntp_update);
if (pre_ticket == 0 || ticket - pre_ticket > 24*60*60/6) {
pre_ticket = ticket;
get_timer_from_kv();
}
}
_sec_next_event = -1;
utc_week_second_offset = (utc + ticket) % 604800;
DS_INFO("TS_offset = %d uptime=%d uptime_on_get_utc=%d\r\n", utc_week_second_offset, ticket, uptime_on_get_utc);
for (i = 0; i < DeviceTimerSize; i++){
if (g_device_timer[i].enable == 1 && g_device_timer[i].type > 0){
for ( j = 0; j < DAYS_OF_WEEK; j++){
// 倒计时和普通定时 type == 1 or type == 2
if (g_device_timer[i].type == 1 || g_device_timer[i].type == 2) {
if ((_sec_next_event == -1 || g_device_timer[i].offset_start[j] <= _sec_next_event) &&
g_device_timer[i].offset_start[j] > utc_week_second_offset) {
_sec_next_event = g_device_timer[i].offset_start[j];
g_device_timer[i].event_ready[j] = 1;
}
if (g_device_timer[i].offset_start[j] == utc_week_second_offset ||
(g_device_timer[i].event_ready[j] == 1 && utc_week_second_offset > g_device_timer[i].offset_start[j] &&
utc_week_second_offset - g_device_timer[i].offset_start[j] < 5 )){
if (g_device_timer[i].repeat == 0)
g_device_timer[i].enable = 0;
g_device_timer[i].event_ready[j] = 0;
// todo 本地定时
DS_DEBUG("DO: repeat=%d %s %d %d\r\n", g_device_timer[i].repeat, g_device_timer[i].targets, i, j);
device_timer_action(g_device_timer[i].type, g_device_timer[i].targets, 0, 0);
continue;
}
}
// 循环定时 type == 3
if (g_device_timer[i].type == 3) {
int offset_start = g_device_timer[i].offset_start[j], offset_end = g_device_timer[i].offset_end[j];
//未进入循环定时窗口期，设置起始时间为定时配置
if (utc_week_second_offset < offset_start && offset_end > offset_start && (_sec_next_event >= offset_start || _sec_next_event == -1)){
// printf("TS_period00 next = %d weed = %d\r\n", _sec_next_event, utc_week_second_offset);
// printf("TS_period00 set = %d end = %d\r\n", offset_start, offset_end);
_sec_next_event = offset_start;
g_device_timer[i].event_ready[j] = 1;
} else if ((offset_start <= utc_week_second_offset && offset_end >= utc_week_second_offset) ||
(offset_start >= 518460 && offset_end < offset_start && (utc_week_second_offset >= offset_start || utc_week_second_offset <= offset_end))) {
// 进入窗口期，分当天、夸天（夸周六、周日需特殊处理）
// printf("TS_period next = %d weed = %d\r\n", _sec_next_event, utc_week_second_offset);
// printf("TS_period set = %d end = %d\r\n", offset_start, offset_end);
if (offset_start >= 518460 && utc_week_second_offset < offset_start && offset_end < offset_start) // 周六且夸天的循环定时
n_run_and_sleep = (utc_week_second_offset + 604800 - offset_start)/(g_device_timer[i].runTime + g_device_timer[i].sleepTime);
else
n_run_and_sleep = (utc_week_second_offset - offset_start)/(g_device_timer[i].runTime + g_device_timer[i].sleepTime);
// mod_run_and_sleep = (utc_week_second_offset - offset_start)%(g_device_timer[i].runTime + g_device_timer[i].sleepTime);
mod_run_and_sleep = (offset_start + (g_device_timer[i].runTime + g_device_timer[i].sleepTime) * n_run_and_sleep)%604800;
if (utc_week_second_offset >= offset_start && (offset_start >= 518460 || utc_week_second_offset <= offset_end))
current_time = utc_week_second_offset - (offset_start + (g_device_timer[i].runTime + g_device_timer[i].sleepTime) * n_run_and_sleep);
else if (utc_week_second_offset < offset_start && (offset_start >= 518460 && offset_start > offset_end && utc_week_second_offset <= offset_end + 5))
current_time = utc_week_second_offset + 604800 - (offset_start + (g_device_timer[i].runTime + g_device_timer[i].sleepTime) * n_run_and_sleep);
// printf("TS_period next = %d weed = %d\r\n", _sec_next_event, utc_week_second_offset);
printf("TS_period curr = %d mod = %d ready=%d\r\n", current_time, mod_run_and_sleep, g_device_timer[i].event_ready[j]);
if (current_time >= 0 && current_time <= 5 && g_device_timer[i].event_ready[j] && (utc_week_second_offset >= offset_start ||
(utc_week_second_offset < offset_start && offset_start >= 518460 && offset_start > offset_end && utc_week_second_offset <= offset_end + 5))){
g_device_timer[i].event_ready[j] = 0;
printf("DO: %s run %d %d\r\n", g_device_timer[i].targets, i, j);
device_timer_action(g_device_timer[i].type, g_device_timer[i].targets, 0, 0);
}
else if (current_time >= g_device_timer[i].runTime && current_time <= g_device_timer[i].runTime + 5 && g_device_timer[i].event_ready[j] && (utc_week_second_offset >= offset_start ||
(utc_week_second_offset < offset_start && offset_start >= 518460 && offset_start > offset_end && utc_week_second_offset <= offset_end + 5)) ) {
g_device_timer[i].event_ready[j] = 0;
printf("DO: %s sleep %d %d\r\n", g_device_timer[i].targets, i, j);
device_timer_action(g_device_timer[i].type, g_device_timer[i].targets, 1, 0);
}
if ((_sec_next_event >= (mod_run_and_sleep + g_device_timer[i].runTime)%604800 || _sec_next_event == -1)
&& utc_week_second_offset >= mod_run_and_sleep + g_device_timer[i].runTime) {
_sec_next_event = mod_run_and_sleep + g_device_timer[i].runTime + g_device_timer[i].sleepTime;
g_device_timer[i].event_ready[j] = 1;
} else if ((_sec_next_event >= mod_run_and_sleep || _sec_next_event == -1) && utc_week_second_offset >= mod_run_and_sleep) {
_sec_next_event = mod_run_and_sleep + g_device_timer[i].runTime;
g_device_timer[i].event_ready[j] = 1;
}
}
}
// 循环定时 type == 4
//todo
}
}
}
ticket = _get_uptime()- uptime_on_get_utc;
utc_week_second_offset = (utc + ticket) % (86400 * 7);
int delay_sec = _sec_next_event - utc_week_second_offset;
DS_INFO("TS_delay=%d\r\n", delay_sec);
#ifndef SDK_VER_16X
if (delay_sec == 0) {
aiot_al_sleep_ms(400);
device_timer_runner();
} else if (delay_sec > 0 && delay_sec < 5*60){
aiot_al_timer_stop(check_timer);
aiot_al_timer_start(check_timer, delay_sec * 1000);
} else {
aiot_al_timer_stop(check_timer);
aiot_al_timer_start(check_timer, 5*60 * 1000);
}
#else
if (delay_sec == 0) {
HAL_SleepMs(400);
device_timer_runner();
} else if (delay_sec > 0 && delay_sec < 5*60){
HAL_Timer_Stop(check_timer);
HAL_Timer_Start(check_timer, delay_sec * 1000);
} else {
HAL_Timer_Stop(check_timer);
HAL_Timer_Start(check_timer, 5*60 * 1000);
}
#endif
}
int string2minute(const char *string)
{
char hour[3], min[3];
int offset;
if (string[0] > '9' || string[1] > '9' || string[3] > '9' || string[4] > '9')
return -1;
strncpy(&hour[0], &string[0], 2);
strncpy(&min[0], &string[3], 2);
offset = atoi(hour) * 60;
offset += atoi(min);
return offset;
}
static int days_calc(int years, int months, int day) {
int i = 0, days = 0;
for (i = 0; i <= months % 12; i++){
if (i == 0) // 1月份
days = day - 3;
else if (i == 1) // 2月份
days = days + 31;
else if (i == 2) // 3月份
days = days + 28;
else if (i == 3) // 4月份
days = days + 31;
else if (i == 4) // 5月份
days = days + 30;
else if (i == 5) // 6月份
days = days + 31;
else if (i == 6) // 7月份
days = days + 30;
else if (i == 7) // 8月份
days = days + 31;
else if (i == 8) // 9月份
days = days + 31;
else if (i == 9) // 10月份
days = days + 30;
else if (i == 10) // 11月份
days = days + 31;
else if (i == 11) // 12月份
days = days + 30;
}
// 计算年
if (months % 12 >= 3) {// 2024年3月1日及之后
if (years < 3) // 未经历闰年
days += years * 365;
else {
days += years * 365 + (years + 1) / 4;
}
} else {// 2024年2月29日及之前
if (years <= 3) // 未经历闰年
days += years * 365;
else {
days += years * 365 + (years) / 4;
}
}
DS_DEBUG("days=%d\r\n", days);
return days;
}
static int cron_parse(char *data, uint8_t index, uint8_t type, char* end){
const char *err = NULL;
char cron_str[32];
cron_expr target;
cron_str[0] = '*';
cron_str[1] = ' ';
int offset_end = 0;
strcpy(g_device_timer[index].timer, data);
memset(cron_str, 0, sizeof(cron_str));
snprintf(cron_str, sizeof(cron_str), "* %s", data);
memset(&target, 0, sizeof(cron_expr));
cron_parse_expr(cron_str, &target, &err);
if (err){
DS_ERR("TS_parse err:%s\r\n", err);
// aiot_kv_del(DeviceTimer);
return -10;
}
int i = 0, hour = 0, minute = 0, day = 0, month = 0, year = 0, offset = 0;
for (i = 0; i < 24; i++) {
if (cron_get_bit(target.hours, i)) {
hour = i;
DS_DEBUG("hour:%d\r\n", hour);
break;
}
}
for (i = 0; i < 60; i++) {
if (cron_get_bit(target.minutes, i)) {
minute = i;
DS_DEBUG("minute:%d\r\n", minute);
break;
}
}
// 最后一个cron字段为年，*表示未指定年
if (cron_str[strlen(cron_str) - 1] == '*'){
g_device_timer[index].repeat = 0;
for (i = 0; i < DAYS_OF_WEEK; i++) {
if (cron_get_bit(target.days_of_week, i)) {
offset = ((i * 24 + hour) * 60 * 60 + minute * 60 + 28800 - g_device_timer[index].timezone)%604800;
if (type == 3 || type == 4) {
offset_end = ((i * 24) * 60 * 60 + string2minute(g_device_timer[index].endTime) * 60
+ 28800 - g_device_timer[index].timezone)%604800;
if (offset_end < offset) // 结束时间小于起始时间，跨天配置
g_device_timer[index].offset_end[g_device_timer[index].repeat] = (offset_end + 24*60*60)%604800;
else
g_device_timer[index].offset_end[g_device_timer[index].repeat] = offset_end;
}
DS_DEBUG("offset=%d end=%d repeat=%d\r\n", offset, g_device_timer[index].offset_end[g_device_timer[index].repeat], g_device_timer[index].repeat);
g_device_timer[index].offset_start[g_device_timer[index].repeat++] = offset;
}
}
if (g_device_timer[index].repeat == 0) {
for (i = 0; i <= DAYS_OF_WEEK; i++) {
offset = (((i * 24 + hour) * 60 * 60 + minute * 60 ) + 28800 - g_device_timer[index].timezone) % 604800;
if (offset > 0) { // 大于当前时间
g_device_timer[index].offset_start[0] = offset;
DS_DEBUG("TS_offset=%d\r\n", g_device_timer[index].offset_start[0]);
break;
} else { // 小于当前时间，第二天执行
g_device_timer[index].offset_start[0] = (offset + 24*60*60) % 604800;
DS_DEBUG("TS_offset=%d\r\n", g_device_timer[index].offset_start[0]);
break;
}
}
}
} else { // 指定了年，以指定日期，单次定时执行
for (i = 0; i <= 31; i++) {
if (cron_get_bit(target.days_of_month, i)) {
day = i;
DS_DEBUG("day:%d\r\n", day);
break;
}
}
for (i = 0; i < 12; i++) {
if (cron_get_bit(target.months, i)) {
month = i + 1;
DS_DEBUG("month:%d\r\n", month);
break;
}
}
year = atoi(&cron_str[strlen(cron_str) - 4]);
if (year < 2021 || (year == 2021 && month == 1 && day < 4) || month > 12 || day > 31)
return -2;
// printf("year:%d\r\n", year);
// 计算指定日期的utc值。先月份差. 1609574400=2021.01.03 16:00(北京时间) 1609603200 2021.01.03 00:00(北京时间)
// 31: 1,3,5,7,8,10,12; 30: 4,6,9,11; 28:28/29 31*7+30*5+28=365
int months = 0, days = 0;
months = (year - 2021) * 12 + month - 1;
days = days_calc(year - 2021, months, day);
int day_2_utc = days * 86400 + hour * 3600 + minute * 60 + 28800 - g_device_timer[index].timezone + WEEK_START;
DS_DEBUG("uptime=%d up_on_get=%d\r\n", _get_uptime(), uptime_on_get_utc);
int timer_once = day_2_utc - ntp_time_s - (_get_uptime() - uptime_on_get_utc);
if ( timer_once > 0 && timer_once < 604800) { // 指定日期大于当前时间，且小于一周的，可以配置。
g_device_timer[index].offset_start[0] = (day_2_utc - (ntp_time_s - utc))%604800;
DS_DEBUG("TS_offset=%d\r\n", g_device_timer[index].offset_start[0]);
} else {
g_device_timer[index].enable = 0;
}
}
return 0;
}
// input: json数据；
// src: 数据来源：0 --云端； 1--KV
// save:是否更新kv数据
int deviceTimerParse(const char *input, uint8_t src, int save){
cJSON *root, *item_JSON, *list, *prop;
int ret = 0, j = 0;
root = cJSON_Parse(input);
if (root == NULL && !cJSON_IsObject(root)) {
ret = -1;
goto err;
}
list = cJSON_GetObjectItem(root, DEVICETIMER);
int local_timer_arrySize = cJSON_GetArraySize(list);
if (DeviceTimerSize != local_timer_arrySize) {
ret = -3;
goto err;
}
utc_week_second_offset = (utc + _get_uptime() - uptime_on_get_utc) % (86400 * 7);
for (j = 0; j < DeviceTimerSize; j++) {
if (g_device_timer[j].targets != NULL) {
#ifndef SDK_VER_16X
aiot_al_free(g_device_timer[j].targets);
#else
HAL_Free(g_device_timer[j].targets);
#endif
}
}
memset(g_device_timer, 0, sizeof(g_device_timer));
for (j = 0; j < local_timer_arrySize; j++) {
prop = cJSON_GetArrayItem(list, j);
item_JSON = cJSON_GetObjectItem(prop, "Z"); //TimeZone
if (item_JSON != NULL && cJSON_IsNumber(item_JSON)) {
g_device_timer[j].timezone = item_JSON->valueint;
// DS_DEBUG("TimeZone:%d", item_JSON->valueint);
}
item_JSON = cJSON_GetObjectItem(prop, "E"); //Enable
if (item_JSON != NULL && cJSON_IsNumber(item_JSON)) {
g_device_timer[j].enable = item_JSON->valueint;
// DS_DEBUG("Enable:%d", item_JSON->valueint);
}
item_JSON = cJSON_GetObjectItem(prop, "A"); // Targets
if (item_JSON != NULL && strlen(item_JSON->valuestring)) {
#ifndef SDK_VER_16X
g_device_timer[j].targets = aiot_al_malloc(strlen(item_JSON->valuestring) + 1, LINKKIT_DEMO_MODULE_NAME);
#else
g_device_timer[j].targets = (char *)HAL_Malloc(strlen(item_JSON->valuestring) + 1);
#endif
memset(g_device_timer[j].targets, 0, strlen(item_JSON->valuestring) + 1);
strcpy(g_device_timer[j].targets, item_JSON->valuestring);
// DS_DEBUG("Targets:%s\r\n", item_JSON->valuestring);
}
item_JSON = cJSON_GetObjectItem(prop, "Y"); //Type
if (item_JSON != NULL && cJSON_IsNumber(item_JSON)) {
g_device_timer[j].type = item_JSON->valueint;
// DS_DEBUG("Type:%d", item_JSON->valueint);
}
if (g_device_timer[j].type == 3 || g_device_timer[j].type == 4) {// period or random timer
item_JSON = cJSON_GetObjectItem(prop, "N"); // EndTime
if (item_JSON != NULL && strlen(item_JSON->valuestring)) {
strcpy(g_device_timer[j].endTime, item_JSON->valuestring);
// DS_DEBUG("EndTime:%s\r\n", item_JSON->valuestring);
}
}
if (g_device_timer[j].type == 3) { // period or random timer
item_JSON = cJSON_GetObjectItem(prop, "R"); //RunTime
if (item_JSON != NULL && cJSON_IsNumber(item_JSON)) {
g_device_timer[j].runTime = item_JSON->valueint;
// DS_DEBUG("RunTime:%d\r\n", item_JSON->valueint);
}
item_JSON = cJSON_GetObjectItem(prop, "S"); //SleepTime
if (item_JSON != NULL && cJSON_IsNumber(item_JSON)) {
g_device_timer[j].sleepTime = item_JSON->valueint;
// DS_DEBUG("SleepTime:%d\r\n", item_JSON->valueint);
}
}
if (g_device_timer[j].type == 4) { // random timer
// todo
// g_device_timer[j].runTime = 300; // 随机值 todo
// g_device_timer[j].sleepTime = 600; // 随机值 todo
}
item_JSON = cJSON_GetObjectItem(prop, "T"); //Timer
if (item_JSON != NULL && strlen(item_JSON->valuestring) > 5) {
ret = cron_parse(item_JSON->valuestring, j, g_device_timer[j].type, g_device_timer[j].endTime);
if (ret != 0) {
goto err;
}
strcpy(g_device_timer[j].timer, item_JSON->valuestring);
DS_DEBUG("Timer:%s\r\n", item_JSON->valuestring);
}
}
cJSON_Delete(root);
if (ret == 0 && save == 1){
#ifndef SDK_VER_16X
aiot_kv_set(DEVICETIMER, input, strlen(input), 1);
#else
HAL_Kv_Set(DEVICETIMER, input, strlen(input), 1);
#endif
}
device_timer_runner();
return 0;
err:
DS_ERR("deviceTimerParse err=%d", ret);
cJSON_Delete(root);
aiot_device_timer_clear();
return ret;
}
char* device_timer_post(int save) {
cJSON *root = NULL, *list = NULL, *items[DeviceTimerSize] = {NULL};
int ret = 0, i = 0;
root = cJSON_CreateObject();
if (root == NULL){
ret = -1;
goto err;
}
list = cJSON_CreateArray();
if (list == NULL){
cJSON_Delete(root);
ret = -2;
goto err;
}
for (i =0; i < DeviceTimerSize; i++) {
items[i] = cJSON_CreateObject();
if (items[i] == NULL){
cJSON_Delete(list);
cJSON_Delete(root);
ret = -3;
goto err;
}
cJSON_AddStringToObject(items[i], "T", g_device_timer[i].timer); // Timer
cJSON_AddNumberToObject(items[i], "E", g_device_timer[i].enable); // Enable
cJSON_AddNumberToObject(items[i], "Y", g_device_timer[i].type); // Type
cJSON_AddStringToObject(items[i], "A", g_device_timer[i].targets); // Targets
cJSON_AddNumberToObject(items[i], "Z", g_device_timer[i].timezone); // TimeZone
cJSON_AddStringToObject(items[i], "N", g_device_timer[i].endTime); // EndTime
cJSON_AddNumberToObject(items[i], "R", g_device_timer[i].runTime); // RunTime
cJSON_AddNumberToObject(items[i], "S", g_device_timer[i].sleepTime); // SleepTime
cJSON_AddItemToArray(list, items[i]);
}
cJSON_AddItemToObject(root, DEVICETIMER, list);
char *property = cJSON_PrintUnformatted(root);
if (property == NULL) {
cJSON_Delete(root);
ret = -8;
goto err;
}
cJSON_Delete(root);
DS_INFO("TS_post:%s\r\n", property);
if (save) {
#ifndef SDK_VER_16X
aiot_kv_set(DEVICETIMER, property, strlen(property), 1);
#else
HAL_Kv_Set(DEVICETIMER, property, strlen(property), 1);
#endif
}
return property;
err:
DS_ERR("err ret=%d", ret);
return NULL;
}
#endif
|
the_stack_data/103265433.c | #include <stdio.h>
#include <stdlib.h>
typedef struct {
char *name;
int size;
void (*(*_vtable)[])();
} metadata;
typedef struct {
metadata *clazz;
} object;
object *alloc(metadata *clazz) {
object *p = malloc(clazz->size);
p->clazz = clazz;
return p;
}
// D e f i n e C l a s s T
typedef struct {
metadata *clazz;
} T;
#define T_f_SLOT 0
float T_f(T *this)
{
return 3.14;
}
void (*T_vtable[])() = {
(void (*)())&T_f
};
metadata T_metadata = {"T", sizeof(T), &T_vtable};
int main(int argc, char *argv[])
{
T * t;
float q;
t = ((T *)alloc(&T_metadata));
q = (*(float (*)(T *))(*(t)->clazz->_vtable)[T_f_SLOT])(((T *)t));
printf("%f\n", q);
} |
the_stack_data/18887833.c | /*
(c) Copyright 2019 Joel Sherrill <[email protected]
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 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 <fenv.h>
#include <errno.h>
/*
FUNCTION
<<fegetround>>---get current rounding direction
INDEX
fegetround
SYNOPSIS
#include <fenv.h>
int fegetround(void);
Link with -lm.
DESCRIPTION
This method returns the current rounding direction.
RETURNS
This method returns the rounding direction, corresponding to the value
of the respective rouding macro. If the current rounding direction cannot
be determined, then a negative value is returned.
PORTABILITY
ANSI C requires <<fegetround>>.
Not all Newlib targets have a working implementation. Refer to
the file <<sys/fenv.h>> to see the status for your target.
*/
/*
* This is a non-functional implementation that should be overridden
* by an architecture specific implementation in newlib/libm/machine/ARCH.
*/
int fegetround(void)
{
return -ENOTSUP;
}
|
the_stack_data/247018781.c | #include<stdio.h>
int main()
{int n,k,i,j,x,a[100005],y,z,c=1,b=0,d=0,p,q,m,s;
scanf("%d%d",&n,&k);
for(i=0;i<n;i++)
{scanf("%d",&x);
a[i]=x;}
for(j=1;j<=k;j++)
{scanf("%d%d",&y,&z);
b=0;
for(s=y;s<=z;s++)
{b=b+a[s]%n;
b=b%n;}
c=1;
for(s=y;s<=z;s++)
{c=(c*(a[s]%n))%n;
c=c%n;}
if(b<=c)
p=b,q=c;
else
p=c,q=b;
m=p;
d=a[p];
for(m=p+1;m<=q;m++)
d=d^a[m];
printf("%d\n",d);
}
} |
the_stack_data/139307.c | // EXPECT: 42
int main() {
return 12 + 35 - 5;
} |
the_stack_data/95451087.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc , char *argv[])
{
//socket的建立
int sockfd = 0;
FILE * file_to_send;
int count1=1,count2=1, percent;
char toSEND[1];
char ch ;
char remoteFILE[65536];
sockfd = socket(AF_INET , SOCK_STREAM , 0);
if (sockfd == -1){
printf("Fail to create a socket.");
}
//socket的連線
struct sockaddr_in info;
bzero(&info,sizeof(info));
info.sin_family = PF_INET;
//localhost test
info.sin_addr.s_addr = inet_addr("127.0.0.1");
info.sin_port = htons(8080);
int err = connect(sockfd,(struct sockaddr *)&info,sizeof(info));
if(err==-1){
printf("Connection error");
}
//Send a message to server
char message[20] = "Requester: fanfan";
char receiveMessage[100] = {};
send(sockfd,message,sizeof(message),0);
recv(sockfd,receiveMessage,sizeof(receiveMessage),0);
printf("%s",receiveMessage);
printf("close Socket\n");
close(sockfd);
return 0;
}
|
the_stack_data/17278.c | /* Copyright (c) 2020 Dennis Wölfing
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* libc/src/signal/sigwait.c
* Wait for signals.
*/
#include <errno.h>
#include <signal.h>
#include <stddef.h>
int sigwait(const sigset_t* restrict set, int* restrict sig) {
int result;
do {
result = sigwaitinfo(set, NULL);
} while (result < 0 && errno == EINTR);
if (result < 0) return result;
*sig = result;
return 0;
}
|
the_stack_data/637784.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int convert_char_to_int( char character );
int main(int argc, char *argv[]) {
FILE *fp;
char buff[255];
fp = fopen("input.txt", "r");
int sum =0;
//read each line from the file
while(fgets(buff, 255, (FILE*)fp)){
// convert string to integer
int lengthOfLine = strlen(buff) -1;
int i = 0;
bool currentIntegerPositiveSign=true;
int currentInteger =0;
//iterate over the string
while(i<lengthOfLine){
//first char is always sign
if(i==0){
if(buff[i]=='+'){
currentIntegerPositiveSign=true;
}else{
currentIntegerPositiveSign=false;
}
}else{
currentInteger = currentInteger *10;
int charToint = convert_char_to_int(buff[i]);
currentInteger = (currentInteger +charToint);
}
i=i+1;
}
if(currentIntegerPositiveSign){
sum = sum + currentInteger;
}else{
sum = sum - currentInteger;
}
}
printf("sum: %i ", sum);
fclose(fp);
return 0;
}
int convert_char_to_int( char character ) {
switch(character) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default :
return 0;
}
}
|
the_stack_data/247019409.c | //===-- SystemZMCTargetDesc.cpp - SystemZ target descriptions -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2015 */
#ifdef CAPSTONE_HAS_SYSZ
#include "SystemZMCTargetDesc.h"
#include <capstone/platform.h>
#define GET_REGINFO_ENUM
#include "SystemZGenDisassemblerTables.inc"
const unsigned SystemZMC_GR32Regs[16] = {
SystemZ_R0L, SystemZ_R1L, SystemZ_R2L, SystemZ_R3L,
SystemZ_R4L, SystemZ_R5L, SystemZ_R6L, SystemZ_R7L,
SystemZ_R8L, SystemZ_R9L, SystemZ_R10L, SystemZ_R11L,
SystemZ_R12L, SystemZ_R13L, SystemZ_R14L, SystemZ_R15L};
const unsigned SystemZMC_GRH32Regs[16] = {
SystemZ_R0H, SystemZ_R1H, SystemZ_R2H, SystemZ_R3H,
SystemZ_R4H, SystemZ_R5H, SystemZ_R6H, SystemZ_R7H,
SystemZ_R8H, SystemZ_R9H, SystemZ_R10H, SystemZ_R11H,
SystemZ_R12H, SystemZ_R13H, SystemZ_R14H, SystemZ_R15H};
const unsigned SystemZMC_GR64Regs[16] = {
SystemZ_R0D, SystemZ_R1D, SystemZ_R2D, SystemZ_R3D,
SystemZ_R4D, SystemZ_R5D, SystemZ_R6D, SystemZ_R7D,
SystemZ_R8D, SystemZ_R9D, SystemZ_R10D, SystemZ_R11D,
SystemZ_R12D, SystemZ_R13D, SystemZ_R14D, SystemZ_R15D};
const unsigned SystemZMC_GR128Regs[16] = {
SystemZ_R0Q, 0, SystemZ_R2Q, 0, SystemZ_R4Q, 0, SystemZ_R6Q, 0,
SystemZ_R8Q, 0, SystemZ_R10Q, 0, SystemZ_R12Q, 0, SystemZ_R14Q, 0};
const unsigned SystemZMC_FP32Regs[16] = {
SystemZ_F0S, SystemZ_F1S, SystemZ_F2S, SystemZ_F3S,
SystemZ_F4S, SystemZ_F5S, SystemZ_F6S, SystemZ_F7S,
SystemZ_F8S, SystemZ_F9S, SystemZ_F10S, SystemZ_F11S,
SystemZ_F12S, SystemZ_F13S, SystemZ_F14S, SystemZ_F15S};
const unsigned SystemZMC_FP64Regs[16] = {
SystemZ_F0D, SystemZ_F1D, SystemZ_F2D, SystemZ_F3D,
SystemZ_F4D, SystemZ_F5D, SystemZ_F6D, SystemZ_F7D,
SystemZ_F8D, SystemZ_F9D, SystemZ_F10D, SystemZ_F11D,
SystemZ_F12D, SystemZ_F13D, SystemZ_F14D, SystemZ_F15D};
const unsigned SystemZMC_FP128Regs[16] = {
SystemZ_F0Q, SystemZ_F1Q, 0, 0, SystemZ_F4Q, SystemZ_F5Q, 0, 0,
SystemZ_F8Q, SystemZ_F9Q, 0, 0, SystemZ_F12Q, SystemZ_F13Q, 0, 0};
const unsigned SystemZMC_VR32Regs[32] = {
SystemZ_F0S, SystemZ_F1S, SystemZ_F2S, SystemZ_F3S, SystemZ_F4S,
SystemZ_F5S, SystemZ_F6S, SystemZ_F7S, SystemZ_F8S, SystemZ_F9S,
SystemZ_F10S, SystemZ_F11S, SystemZ_F12S, SystemZ_F13S, SystemZ_F14S,
SystemZ_F15S, SystemZ_F16S, SystemZ_F17S, SystemZ_F18S, SystemZ_F19S,
SystemZ_F20S, SystemZ_F21S, SystemZ_F22S, SystemZ_F23S, SystemZ_F24S,
SystemZ_F25S, SystemZ_F26S, SystemZ_F27S, SystemZ_F28S, SystemZ_F29S,
SystemZ_F30S, SystemZ_F31S};
const unsigned SystemZMC_VR64Regs[32] = {
SystemZ_F0D, SystemZ_F1D, SystemZ_F2D, SystemZ_F3D, SystemZ_F4D,
SystemZ_F5D, SystemZ_F6D, SystemZ_F7D, SystemZ_F8D, SystemZ_F9D,
SystemZ_F10D, SystemZ_F11D, SystemZ_F12D, SystemZ_F13D, SystemZ_F14D,
SystemZ_F15D, SystemZ_F16D, SystemZ_F17D, SystemZ_F18D, SystemZ_F19D,
SystemZ_F20D, SystemZ_F21D, SystemZ_F22D, SystemZ_F23D, SystemZ_F24D,
SystemZ_F25D, SystemZ_F26D, SystemZ_F27D, SystemZ_F28D, SystemZ_F29D,
SystemZ_F30D, SystemZ_F31D};
const unsigned SystemZMC_VR128Regs[32] = {
SystemZ_V0, SystemZ_V1, SystemZ_V2, SystemZ_V3, SystemZ_V4,
SystemZ_V5, SystemZ_V6, SystemZ_V7, SystemZ_V8, SystemZ_V9,
SystemZ_V10, SystemZ_V11, SystemZ_V12, SystemZ_V13, SystemZ_V14,
SystemZ_V15, SystemZ_V16, SystemZ_V17, SystemZ_V18, SystemZ_V19,
SystemZ_V20, SystemZ_V21, SystemZ_V22, SystemZ_V23, SystemZ_V24,
SystemZ_V25, SystemZ_V26, SystemZ_V27, SystemZ_V28, SystemZ_V29,
SystemZ_V30, SystemZ_V31};
const unsigned SystemZMC_AR32Regs[16] = {
SystemZ_A0, SystemZ_A1, SystemZ_A2, SystemZ_A3, SystemZ_A4, SystemZ_A5,
SystemZ_A6, SystemZ_A7, SystemZ_A8, SystemZ_A9, SystemZ_A10, SystemZ_A11,
SystemZ_A12, SystemZ_A13, SystemZ_A14, SystemZ_A15};
const unsigned SystemZMC_CR64Regs[16] = {
SystemZ_C0, SystemZ_C1, SystemZ_C2, SystemZ_C3, SystemZ_C4, SystemZ_C5,
SystemZ_C6, SystemZ_C7, SystemZ_C8, SystemZ_C9, SystemZ_C10, SystemZ_C11,
SystemZ_C12, SystemZ_C13, SystemZ_C14, SystemZ_C15};
/* All register classes that have 0-15. */
#define DEF_REG16(N) \
[SystemZ_R##N##L] = N, [SystemZ_R##N##H] = N, [SystemZ_R##N##D] = N, \
[SystemZ_F##N##S] = N, [SystemZ_F##N##D] = N, [SystemZ_V##N] = N, \
[SystemZ_A##N] = N, [SystemZ_C##N] = N
/* All register classes that (also) have 16-31. */
#define DEF_REG32(N) \
[SystemZ_F##N##S] = N, [SystemZ_F##N##D] = N, [SystemZ_V##N] = N
static const uint8_t Map[SystemZ_NUM_TARGET_REGS] = {
DEF_REG16(0),
DEF_REG16(1),
DEF_REG16(2),
DEF_REG16(3),
DEF_REG16(4),
DEF_REG16(5),
DEF_REG16(6),
DEF_REG16(8),
DEF_REG16(9),
DEF_REG16(10),
DEF_REG16(11),
DEF_REG16(12),
DEF_REG16(13),
DEF_REG16(14),
DEF_REG16(15),
DEF_REG32(16),
DEF_REG32(17),
DEF_REG32(18),
DEF_REG32(19),
DEF_REG32(20),
DEF_REG32(21),
DEF_REG32(22),
DEF_REG32(23),
DEF_REG32(24),
DEF_REG32(25),
DEF_REG32(26),
DEF_REG32(27),
DEF_REG32(28),
DEF_REG32(29),
DEF_REG32(30),
DEF_REG32(31),
/* The float Q registers are non-sequential. */
[SystemZ_F0Q] = 0,
[SystemZ_F1Q] = 1,
[SystemZ_F4Q] = 4,
[SystemZ_F5Q] = 5,
[SystemZ_F8Q] = 8,
[SystemZ_F9Q] = 9,
[SystemZ_F12Q] = 12,
[SystemZ_F13Q] = 13,
/* The integer Q registers are all even. */
[SystemZ_R0Q] = 0,
[SystemZ_R2Q] = 2,
[SystemZ_R4Q] = 4,
[SystemZ_R6Q] = 6,
[SystemZ_R8Q] = 8,
[SystemZ_R10Q] = 10,
[SystemZ_R12Q] = 12,
[SystemZ_R14Q] = 14,
};
unsigned SystemZMC_getFirstReg(unsigned Reg) {
// assert(Reg < SystemZ_NUM_TARGET_REGS);
return Map[Reg];
}
#endif
|
the_stack_data/1160790.c | #include<stdio.h>
#include<string.h>
#define LEN 100
#define WID 80
int main()
{
int choice;
printf("1.Do You Want to Sort Train Numbers using Bubble Sort\n");
printf("2.Do You Want to Sort Train Names using Selection Sort\n");
printf("3.Do You Want to Sort Passenger Names using Inseertion Sort\n");
printf("4.Do You Want to Sort PNR Numbers using Quick Sort\n");
printf("Enter the Choice:\n");
scanf("%d",&choice);
if(choice==1)
bsort();
if(choice==2)
ssort();
if (choice==3)
{
int n, i,j;
char s[LEN][WID],tname[10][10],temp[10][10];
printf("Enter the How many passengers were travelling?\n");
scanf("%d", &n);
long long int pnr[n],tnum[n];
for (i = 0; i < n; i++)
{
printf("Enter the Pasenger name\n");
scanf(" %s", s[i]);
strcpy(temp[i],s[i]);
printf("Enter the PNR Number\n");
scanf("%lld",&pnr[i]);
printf("Enter the train number:-\n");
scanf("%lld",&tnum[i]);
printf("Enter The train name:\n");
scanf("%s",tname[i]);
}
isort(s, n);
for(i=0;i<n;i++)
{
printf("%s ",s[i]);
for(j=0;j<n;j++)
{
if(strcmp(temp[j],s[i]) == 0)
printf("%lld %lld %s\n",pnr[i],tnum[i],tname);
}
}
}
if(choice==4)
{
int size, i,j;
printf("Enter the How many passengers were travelling?\n");
scanf("%d", &size);
int list[size],f,l,man[size];
long long int tnum[size];
char tname[10][10],pname[10][10];
for (i = 0; i < size; i++)
{
printf("Enter the PNR Number\n");
scanf("%d", &list[i]);
man[i]=list[i];
printf("Enter the train number:-\n");
scanf("%lld",&tnum[i]);
printf("Enter the train name:-\n");
scanf("%s",tname[i]);
printf("Enter the passenger name:-\n");
scanf("%s",pname[i]);
}
quicksort(list, 0, size - 1);
printf("The sorted Oder is:-\n");
for (i = 0; i < size; i++)
{
printf("%d ", list[i]);
for(j=0;j<size;j++)
{
if(man[j]==list[i])
printf("%lld %s %s\n",tnum[j],tname[j],pname[j]);
}
}
printf("\n");
}
}
|
the_stack_data/151945.c | /*
* Copyright 2014 The Native Client Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/*
* Stub routine for `listen' for porting support.
*/
#include <errno.h>
int listen(int sockfd, int backlog) {
errno = ENOSYS;
return -1;
}
|
the_stack_data/60976.c | //
// begin license header
//
// This file is part of Pixy CMUcam5 or "Pixy" for short
//
// All Pixy source code is provided under the terms of the
// GNU General Public License v2 (http://www.gnu.org/licenses/gpl-2.0.html).
// Those wishing to use Pixy source code, software and/or
// technologies under different licensing terms should contact us at
// [email protected]. Such licensing terms are available for
// all portions of the Pixy codebase presented here.
//
// end license header
//
/***********************************************************************
* $Id: fpu_init.c
*
* Project: LPC43xx
*
* Description: fpu initialization routine
*
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
**********************************************************************/
#define LPC_CPACR 0xE000ED88
#define SCB_MVFR0 0xE000EF40
#define SCB_MVFR0_RESET 0x10110021
#define SCB_MVFR1 0xE000EF44
#define SCB_MVFR1_RESET 0x11000011
#include "stdint.h"
void fpuInit(void)
{
// from arm trm manual:
// ; CPACR is located at address 0xE000ED88
// LDR.W R0, =0xE000ED88
// ; Read CPACR
// LDR R1, [R0]
// ; Set bits 20-23 to enable CP10 and CP11 coprocessors
// ORR R1, R1, #(0xF << 20)
// ; Write back the modified value to the CPACR
// STR R1, [R0]
volatile uint32_t* regCpacr = (uint32_t*) LPC_CPACR;
volatile uint32_t* regMvfr0 = (uint32_t*) SCB_MVFR0;
volatile uint32_t* regMvfr1 = (uint32_t*) SCB_MVFR1;
volatile uint32_t Cpacr;
volatile uint32_t Mvfr0;
volatile uint32_t Mvfr1;
char vfpPresent = 0;
Mvfr0 = *regMvfr0;
Mvfr1 = *regMvfr1;
vfpPresent = ((SCB_MVFR0_RESET == Mvfr0) && (SCB_MVFR1_RESET == Mvfr1));
if(vfpPresent)
{
Cpacr = *regCpacr;
Cpacr |= (0xF << 20);
*regCpacr = Cpacr; // enable CP10 and CP11 for full access
}
}
|
the_stack_data/1159212.c | /*
* CS:APP Data Lab
*
* <Please put your name and userid here>
*
* bits.c - Source file with your solutions to the Lab.
* This is the file you will hand in to your instructor.
*
* WARNING: Do not include the <stdio.h> header; it confuses the dlc
* compiler. You can still use printf for debugging without including
* <stdio.h>, although you might get a compiler warning. In general,
* it's not good practice to ignore compiler warnings, but in this
* case it's OK.
*/
#if 0
/*
* Instructions to Students:
*
* STEP 1: Read the following instructions carefully.
*/
You will provide your solution to the Data Lab by
editing the collection of functions in this source file.
INTEGER CODING RULES:
Replace the "return" statement in each function with one
or more lines of C code that implements the function. Your code
must conform to the following style:
int Funct(arg1, arg2, ...) {
/* brief description of how your implementation works */
int var1 = Expr1;
...
int varM = ExprM;
varJ = ExprJ;
...
varN = ExprN;
return ExprR;
}
Each "Expr" is an expression using ONLY the following:
1. Integer constants 0 through 255 (0xFF), inclusive. You are
not allowed to use big constants such as 0xffffffff.
2. Function arguments and local variables (no global variables).
3. Unary integer operations ! ~
4. Binary integer operations & ^ | + << >>
Some of the problems restrict the set of allowed operators even further.
Each "Expr" may consist of multiple operators. You are not restricted to
one operator per line.
You are expressly forbidden to:
1. Use any control constructs such as if, do, while, for, switch, etc.
2. Define or use any macros.
3. Define any additional functions in this file.
4. Call any functions.
5. Use any other operations, such as &&, ||, -, or ?:
6. Use any form of casting.
7. Use any data type other than int. This implies that you
cannot use arrays, structs, or unions.
You may assume that your machine:
1. Uses 2s complement, 32-bit representations of integers.
2. Performs right shifts arithmetically.
3. Has unpredictable behavior when shifting an integer by more
than the word size.
EXAMPLES OF ACCEPTABLE CODING STYLE:
/*
* pow2plus1 - returns 2^x + 1, where 0 <= x <= 31
*/
int pow2plus1(int x) {
/* exploit ability of shifts to compute powers of 2 */
return (1 << x) + 1;
}
/*
* pow2plus4 - returns 2^x + 4, where 0 <= x <= 31
*/
int pow2plus4(int x) {
/* exploit ability of shifts to compute powers of 2 */
int result = (1 << x);
result += 4;
return result;
}
FLOATING POINT CODING RULES
For the problems that require you to implent floating-point operations,
the coding rules are less strict. You are allowed to use looping and
conditional control. You are allowed to use both ints and unsigneds.
You can use arbitrary integer and unsigned constants.
You are expressly forbidden to:
1. Define or use any macros.
2. Define any additional functions in this file.
3. Call any functions.
4. Use any form of casting.
5. Use any data type other than int or unsigned. This means that you
cannot use arrays, structs, or unions.
6. Use any floating point data types, operations, or constants.
NOTES:
1. Use the dlc (data lab checker) compiler (described in the handout) to
check the legality of your solutions.
2. Each function has a maximum number of operators (! ~ & ^ | + << >>)
that you are allowed to use for your implementation of the function.
The max operator count is checked by dlc. Note that '=' is not
counted; you may use as many of these as you want without penalty.
3. Use the btest test harness to check your functions for correctness.
4. Use the BDD checker to formally verify your functions
5. The maximum number of ops for each function is given in the
header comment for each function. If there are any inconsistencies
between the maximum ops in the writeup and in this file, consider
this file the authoritative source.
/*
* STEP 2: Modify the following functions according the coding rules.
*
* IMPORTANT. TO AVOID GRADING SURPRISES:
* 1. Use the dlc compiler to check that your solutions conform
* to the coding rules.
* 2. Use the BDD checker to formally verify that your solutions produce
* the correct answers.
*/
#endif
/* 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 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, 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 ISO/IEC 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 */
/* We do not support C11 <threads.h>. */
/*
* bitAnd - x&y using only ~ and |
* Example: bitAnd(6, 5) = 4
* Legal ops: ~ |
* Max ops: 8
* Rating: 1
*/
int bitAnd(int x, int y) {
return ~((~x)|(~y));
}
/*
* getByte - Extract byte n from word x
* Bytes numbered from 0 (LSB) to 3 (MSB)
* Examples: getByte(0x12345678,1) = 0x56
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 6
* Rating: 2
*/
int getByte(int x, int n) {
return ((x & (0xFF << (n << 3))) >> (n << 3)) & 0xFF;
}
/*
* logicalShift - shift x to the right by n, using a logical shift
* Can assume that 0 <= n <= 31
* Examples: logicalShift(0x87654321,4) = 0x08765432
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int logicalShift(int x, int n) {
return (x >> n) & ~(((~0) << 1) << (n ^ 0x1F));
}
/*
* bitCount - returns count of number of 1's in word
* Examples: bitCount(5) = 2, bitCount(7) = 3
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 40
* Rating: 4
*/
int bitCount(int x) {
/* This is an interesting approach */
int t;
t = 0x55 | (0x55 << 8);
int mask_1 = t | (t << 16); // Mask 1 = 0x55555555
t = 0x33 | (0x33 << 8);
int mask_2 = t | (t << 16); // Mask 2 = 0x33333333
t = 0x0F | (0x0F << 8);
int mask_3 = t | (t << 16); // Mask 3 = 0x0F0F0F0F
x = (x & mask_1) + ((x >> 1) & mask_1);
x = (x & mask_2) + ((x >> 2) & mask_2);
x = (x & mask_3) + ((x >> 4) & mask_3);
x += x >> 8;
return (x + (x >> 16)) & 0xFF;
}
/*
* bang - Compute !x without using !
* Examples: bang(3) = 0, bang(0) = 1
* Legal ops: ~ & ^ | + << >>
* Max ops: 12
* Rating: 4
*/
int bang(int x) {
int y = 1 + ~x; // y = -x
return ~((x | y) >> 31) & 1;
}
/*
* tmin - return minimum two's complement integer
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 4
* Rating: 1
*/
int tmin(void) {
return 1 << 31;
}
/*
* fitsBits - return 1 if x can be represented as an
* n-bit, two's complement integer.
* 1 <= n <= 32
* Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 15
* Rating: 2
*/
int fitsBits(int x, int n) {
n = 1 + (n ^ 31);
int y = (x << n) >> n;
return !(x ^ y);
}
/*
* divpwr2 - Compute x/(2^n), for 0 <= n <= 30
* Round toward zero
* Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 15
* Rating: 2
*/
int divpwr2(int x, int n) {
int y = (x >> 31) & !!(x & ~((~0) << n));
return (x >> n) + y;
}
/*
* negate - return -x
* Example: negate(1) = -1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 2
*/
int negate(int x) {
return 1 + ~x;
}
/*
* isPositive - return 1 if x > 0, return 0 otherwise
* Example: isPositive(-1) = 0.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 8
* Rating: 3
*/
int isPositive(int x) {
return !!x & (~x >> 31) & 1;
}
/*
* isLessOrEqual - if x <= y then return 1, else return 0
* Example: isLessOrEqual(4,5) = 1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 24
* Rating: 3
*/
int isLessOrEqual(int x, int y) {
return (!(x ^ y) | ((x >> 31) & !(y >> 31)) | (((1 + x + ~y) >> 31))) & !(!(x >> 31) & (y >> 31));
}
/*
* ilog2 - return floor(log base 2 of x), where x > 0
* Example: ilog2(16) = 4
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 90
* Rating: 4
*/
int ilog2(int x) {
int mask_1 = (~0) << 16; // 0xFFFF0000
int mask_2 = mask_1 ^ (mask_1 >> 8) ^ (mask_1 << 8); // 0xFF00FF00
int mask_3 = mask_2 ^ (mask_2 >> 4) ^ (mask_1 << 12); // 0xF0F0F0F0
int mask_4 = mask_3 ^ (mask_3 >> 2) ^ (mask_1 << 14); // 0xCCCCCCCC
int mask_5 = mask_4 ^ (mask_4 >> 1) ^ (mask_1 << 15); // 0xAAAAAAAA
int r = 0, m = ~0, t = 0;
t = !!(x & m & mask_1);
r += t << 4;
m &= mask_1 ^ ~((t << 31) >> 31);
t = !!(x & m & mask_2);
r += t << 3;
m &= mask_2 ^ ~((t << 31) >> 31);
t = !!(x & m & mask_3);
r += t << 2;
m &= mask_3 ^ ~((t << 31) >> 31);
t = !!(x & m & mask_4);
r += t << 1;
m &= mask_4 ^ ~((t << 31) >> 31);
t = !!(x & m & mask_5);
r += t << 0;
m &= mask_5 ^ ~((t << 31) >> 31);
return r;
}
/*
* float_neg - Return bit-level equivalent of expression -f for
* floating point argument f.
* Both the argument and result are passed as unsigned int's, but
* they are to be interpreted as the bit-level representations of
* single-precision floating point values.
* When argument is NaN, return argument.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 10
* Rating: 2
*/
unsigned float_neg(unsigned uf) {
if ((uf & 0x7F800000) == 0x7F800000 && uf & 0x007FFFFF) {
return uf; // NaN
}
return uf ^ 0x80000000;
}
/*
* float_i2f - Return bit-level equivalent of expression (float) x
* Result is returned as unsigned int, but
* it is to be interpreted as the bit-level representation of a
* single-precision floating point values.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_i2f(int x) {
if (x == 0)
return 0;
unsigned sign = x >> 31, abs = sign ? -x : x, exp = 158;
while ((abs & 0x80000000) == 0) {
abs <<= 1;
exp -= 1;
}
unsigned frac = (abs >> 8) & 0x7FFFFF;
// Round up
if (((abs & 0xFF) > 0x80) || (abs & 0x180) == 0x180) {
frac += 1;
if (frac > 0x7FFFFF) {
exp += 1;
frac = (frac & 0x7FFFFF) >> 1;
}
}
return (sign << 31) | (exp << 23) | frac;
}
/*
* float_twice - Return bit-level equivalent of expression 2*f for
* floating point argument f.
* Both the argument and result are passed as unsigned int's, but
* they are to be interpreted as the bit-level representation of
* single-precision floating point values.
* When argument is NaN, return argument
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_twice(unsigned uf) {
unsigned sign = uf >> 31, exp = (uf >> 23) & 0xFF, frac = uf & 0x7FFFFF;
if (exp == 0) { // Denormalized
frac *= 2;
if (frac > 0x7FFFFF) { // Overflow
exp = 1;
frac &= 0x7FFFFF;
}
} else if (exp < 0xFE) {
exp += 1;
} else if (exp == 0xFE) { // Going to overflow
return (sign << 31) | 0x7F800000;
} else { // Inf or NaN
return uf;
}
return (sign << 31) | (exp << 23) | frac;
}
|
the_stack_data/90761755.c | #include <stdio.h> /* header file */
#define NOTFINISHED 0
/**********************************************/
/* A bar like the one above can be used to */
/* separate functions visibly in a program */
main ()
{ int i; /* declarations */
do
{
/* Nothing !!! */
}
while (NOTFINISHED);
}
|
the_stack_data/234517214.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
int search_substr(int n, char *b)
{
int x , p, buf, r;
for (x = n - 2;(b[x] >= b[x + 1]) && (x >= 0);x--);
if(x == -1)
return 0;
for (p = n - 1;(p >= x + 1) && (b[x] >= b[p]);p--);
buf = b[x];
b[x] = b[p];
b[p] = buf;
for (r = x + 1;r <= (x + n) / 2;r++)
{
p = x + n - r;
buf = b[r];
b[r] = b[p];
b[p] = buf;
}
return r;
}
int substr_num(int n,char *b)
{
int j , len, len2, h, i, k, subs, l=0, suml;
char a[n][n];
char **string = (char**) calloc(n,sizeof(char*));
for (k = 0;k < n;k++)
{
string[k] = (char*) calloc(15,sizeof(char));
gets(string[k]);
}
for (i = 0;i < n;i++)
l += strlen(string[i]);
for (i = 0;i < n;i++)
for(k = 0;k < n;k++)
a[i][k] = 0;
for (i = 0; i < n; i++)
{
len = strlen(string[i]);
char s1[len];
for(k = 0; k < n;k++)
{
if(i == k)
a[i][k] = 0;
len2 = strlen(string[k]);
char s2[len2];
for (j = 1 ,h = len - 1;(len2 > j) && (h > 0);j++, h--)
{
strcpy(s1, string[i]+ h);
strncpy(s2, string[k], j);
s2[j] = 0;
if (strcmp(s1, s2) == 0)
a[i][k] = j;
}
}
}
subs = l;
while(search_substr(n , b) != 0)
{
for(i = 0;i < n-1;i++)
{
suml = 0;
for(i = 0;i < n-1;i++)
suml += a[b[i]][b[i+1]];
}
if (l - suml < subs)
subs = l-suml;
}
for (k = 0;k < n;k++)
free(string[k]);
free(string);
return subs;
}
int main()
{
int n, i, k, substr;
scanf("%d", &n);
char b[n];
char a[n][n];
for (i = 0;i < n;i++)
b[i] = i;
substr = substr_num(n , b);
printf("%d", substr);
return 0;
} |
the_stack_data/145452366.c | #include <stdio.h>
#include <string.h>
#include <errno.h>
//getaddrinfo
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
//socket, bind, recv, send, listen, accept
#include <sys/types.h>
#include <sys/socket.h>
//getnameinfo
#include <sys/socket.h>
#include <netdb.h>
//wait
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char *argv[]) {
if (argc != 3) {
printf("Introduzca correctamente los parámetros\n");
printf("Uso: %s <direccion> <puerto>\n");
return -1;
}
printf("argc[0]: %s, argv[1]: %s, argv[2]: %s\n", argv[0], argv[1], argv[2]);
struct addrinfo hints;
struct addrinfo *result;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; // Allow IPv4 or IPv6
hints.ai_socktype = SOCK_STREAM; // Stream socket
hints.ai_flags = AI_PASSIVE; // For wildcard IP address
hints.ai_protocol = 0; // Any protocol
hints.ai_canonname = NULL;
hints.ai_addr = NULL;
hints.ai_next = NULL;
if (getaddrinfo(argv[1], argv[2], &hints, &result) != 0) {
printf("Error getaddrinfo() %d: %s\n", errno, strerror(errno));
return -1;
}
int socketfd = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (socketfd == -1) {
printf("Error socket() %d: %s\n", errno, strerror(errno));
return -1;
}
if (bind(socketfd, result->ai_addr, result->ai_addrlen) == -1) {
printf("Error bind() %d: %s\n", errno, strerror(errno));
return -1;
}
if (listen(socketfd, 16) == -1) {
printf("Error listen() %d: %s\n", errno, strerror(errno));
return -1;
}
/*struct sigaction sa;
sa.sa_handler=SIG_IGN;
sa.sa_flags = SA_RESTART;*/
while (1) {
struct sockaddr_storage client;
socklen_t client_len;
client_len = sizeof(struct sockaddr_storage);
int accfd = accept(socketfd, (struct sockaddr *) &client, &client_len);
if (accfd == -1) {
printf("Error accept() %d: %s\n", errno, strerror(errno));
return -1;
}
pid_t pid;
pid = fork();
if (pid == -1) {
printf("Error fork() %d: %s\n", errno, strerror(errno));
return -1;
}
else if (pid == 0) {
printf("Hijo %d (Padre %d)\n", getpid(), getppid());
char host[NI_MAXHOST];
char serv[NI_MAXSERV];
int nameInfo = getnameinfo((struct sockaddr *) &client, client_len,
host, NI_MAXHOST,
serv, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV);
if (nameInfo == -1) {
printf("Error getnameinfo() %d: %s\n", errno, strerror(errno));
return -1;
}
printf("Conexión desde Host: %s Puerto: %s\n", host, serv);
char buf[80];
int bytes;
bytes = recv(accfd, buf, 80, 0);
while (bytes > 0) {
buf[bytes] = '\0';
printf("Recibido: %s\n", buf);
int bytes_send = send(accfd, buf, bytes, 0);
if (bytes_send == -1) {
printf("Error send() %d: %s\n", errno, strerror(errno));
return -1;
}
bytes = recv(accfd, buf, 80, 0);
}
if (bytes == -1) {
printf("Error revcfrom() %d: %s\n", errno, strerror(errno));
return -1;
}
printf("Conexión terminada\n");
close(accfd);
return 0;
}
else {
printf("Padre %d (Hijo %d)\n", getpid(), pid);
}
}
while(wait(NULL)>0);
/*int status;
pid_t pidTerminado = wait(&status);
if (WIFEXITED(status)) {
printf("Terminado hijo %d\n", pidTerminado);
}*/
freeaddrinfo(result);
close(socketfd);
return 0;
} |
the_stack_data/100685.c | /* Test __atomic routines for existence and proper execution on 1 byte
values with each valid memory model. */
/* { dg-do run } */
/* { dg-require-effective-target sync_char_short } */
/* Test the execution of the __atomic_store_n builtin for a char. */
extern void abort(void);
char v, count;
int
main ()
{
v = 0;
count = 0;
__atomic_store_n (&v, count + 1, __ATOMIC_RELAXED);
if (v != ++count)
abort ();
__atomic_store_n (&v, count + 1, __ATOMIC_RELEASE);
if (v != ++count)
abort ();
__atomic_store_n (&v, count + 1, __ATOMIC_SEQ_CST);
if (v != ++count)
abort ();
/* Now test the generic variant. */
count++;
__atomic_store (&v, &count, __ATOMIC_RELAXED);
if (v != count++)
abort ();
__atomic_store (&v, &count, __ATOMIC_RELEASE);
if (v != count++)
abort ();
__atomic_store (&v, &count, __ATOMIC_SEQ_CST);
if (v != count)
abort ();
return 0;
}
|
the_stack_data/148579514.c | #include <stdio.h>
int main(void)
{
int S[6],i,j,k,min,max;
for(i=0;i<6;i++)
{
printf("Please enter S[%d]:",i);
scanf("%d",&S[i]);
}
printf("\n");
for(j=0;j<6;j++)
{
printf("S[%d]=%d\n",j,S[j]);
}
printf("\n");
min=max=S[0]; /* give a value */
for(k=0;k<6;k++)
{
if(S[k]>max)
{
max=S[k];
}
if(S[k]<min)
{
min=S[k];
}
}
printf("maximum value is: %d, minimux value is: %d.\n",max,min);
return 0;
}
|
the_stack_data/188981.c | int main(void)
{
return 0;
} |
the_stack_data/92324229.c | /* vim: set ts=4 sw=4: */
/* Filename : omp_pi_num_integration.c
* Description : calculate pi
* Author : SunYoung Kim <[email protected]>
* Notes : numerical integration method
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
int num_steps=800000000; /* integration 횟수: 8억번 (너무 많으면 줄이자.) */
int main()
{
int i;
double x, step, sum = 0.0;
step = 1.0/(double) num_steps;
omp_set_num_threads(2);
#pragma omp parallel
#pragma omp for private(x) reduction(+:sum) schedule(static) nowait
for (i=0; i<num_steps; i++) {
x = (i+0.5) * step;
sum += 4.0/(1.0 + x*x);
}
printf("pi = %.8f (sum = %.8f), 4*atan(1) = %.8f\n", step*sum, sum, atan(1)*4);
return EXIT_SUCCESS;
}
|
the_stack_data/684051.c | #include <stdio.h>
int main (){
/*
49. Faca um programa para leia o horario (hora, minuto e segundo) de inicio e a duracao, em
segundos, de uma experiencia biologica. O programa deve resultar com o novo horario
(hora, minuto e segundo) do termino da mesma.
*/
int tempo;
printf ("Digite um tempo em segundos: ");
scanf ("%d", &tempo);
return 0;
} |
the_stack_data/62425.c | /* Verify that we include -Wno- variants when considering hints
for misspelled options (PR driver/69453). */
/* { dg-do compile } */
/* { dg-options "-fmo-unroll-loops" } */
/* { dg-error "unrecognized command line option '-fmo-unroll-loops'; did you mean '-fno-unroll-loops'?" "" { target *-*-* } 0 } */
|
the_stack_data/45363.c | /**
******************************************************************************
* @file stm32f4xx_ll_adc.c
* @author MCD Application Team
* @version V1.7.0
* @date 17-February-2017
* @brief ADC LL module driver
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
*
* 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 STMicroelectronics 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.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_ll_adc.h"
#include "stm32f4xx_ll_bus.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32F4xx_LL_Driver
* @{
*/
#if defined (ADC1) || defined (ADC2) || defined (ADC3)
/** @addtogroup ADC_LL ADC
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup ADC_LL_Private_Macros
* @{
*/
/* Check of parameters for configuration of ADC hierarchical scope: */
/* common to several ADC instances. */
#define IS_LL_ADC_COMMON_CLOCK(__CLOCK__) \
( ((__CLOCK__) == LL_ADC_CLOCK_SYNC_PCLK_DIV2) \
|| ((__CLOCK__) == LL_ADC_CLOCK_SYNC_PCLK_DIV4) \
|| ((__CLOCK__) == LL_ADC_CLOCK_SYNC_PCLK_DIV6) \
|| ((__CLOCK__) == LL_ADC_CLOCK_SYNC_PCLK_DIV8) \
)
/* Check of parameters for configuration of ADC hierarchical scope: */
/* ADC instance. */
#define IS_LL_ADC_RESOLUTION(__RESOLUTION__) \
( ((__RESOLUTION__) == LL_ADC_RESOLUTION_12B) \
|| ((__RESOLUTION__) == LL_ADC_RESOLUTION_10B) \
|| ((__RESOLUTION__) == LL_ADC_RESOLUTION_8B) \
|| ((__RESOLUTION__) == LL_ADC_RESOLUTION_6B) \
)
#define IS_LL_ADC_DATA_ALIGN(__DATA_ALIGN__) \
( ((__DATA_ALIGN__) == LL_ADC_DATA_ALIGN_RIGHT) \
|| ((__DATA_ALIGN__) == LL_ADC_DATA_ALIGN_LEFT) \
)
#define IS_LL_ADC_SCAN_SELECTION(__SCAN_SELECTION__) \
( ((__SCAN_SELECTION__) == LL_ADC_SEQ_SCAN_DISABLE) \
|| ((__SCAN_SELECTION__) == LL_ADC_SEQ_SCAN_ENABLE) \
)
#define IS_LL_ADC_SEQ_SCAN_MODE(__SEQ_SCAN_MODE__) \
( ((__SCAN_MODE__) == LL_ADC_SEQ_SCAN_DISABLE) \
|| ((__SCAN_MODE__) == LL_ADC_SEQ_SCAN_ENABLE) \
)
/* Check of parameters for configuration of ADC hierarchical scope: */
/* ADC group regular */
#define IS_LL_ADC_REG_TRIG_SOURCE(__REG_TRIG_SOURCE__) \
( ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_SOFTWARE) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM1_CH1) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM1_CH2) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM1_CH3) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM2_CH2) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM2_CH3) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM2_CH4) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM2_TRGO) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM3_CH1) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM3_TRGO) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM4_CH4) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM5_CH1) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM5_CH2) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM5_CH3) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM8_CH1) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_TIM8_TRGO) \
|| ((__REG_TRIG_SOURCE__) == LL_ADC_REG_TRIG_EXT_EXTI_LINE11) \
)
#define IS_LL_ADC_REG_CONTINUOUS_MODE(__REG_CONTINUOUS_MODE__) \
( ((__REG_CONTINUOUS_MODE__) == LL_ADC_REG_CONV_SINGLE) \
|| ((__REG_CONTINUOUS_MODE__) == LL_ADC_REG_CONV_CONTINUOUS) \
)
#define IS_LL_ADC_REG_DMA_TRANSFER(__REG_DMA_TRANSFER__) \
( ((__REG_DMA_TRANSFER__) == LL_ADC_REG_DMA_TRANSFER_NONE) \
|| ((__REG_DMA_TRANSFER__) == LL_ADC_REG_DMA_TRANSFER_LIMITED) \
|| ((__REG_DMA_TRANSFER__) == LL_ADC_REG_DMA_TRANSFER_UNLIMITED) \
)
#define IS_LL_ADC_REG_FLAG_EOC_SELECTION(__REG_FLAG_EOC_SELECTION__) \
( ((__REG_FLAG_EOC_SELECTION__) == LL_ADC_REG_FLAG_EOC_SEQUENCE_CONV) \
|| ((__REG_FLAG_EOC_SELECTION__) == LL_ADC_REG_FLAG_EOC_UNITARY_CONV) \
)
#define IS_LL_ADC_REG_SEQ_SCAN_LENGTH(__REG_SEQ_SCAN_LENGTH__) \
( ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_DISABLE) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_3RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_4RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_5RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_6RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_7RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_8RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_9RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_10RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_11RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_12RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_13RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_14RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_15RANKS) \
|| ((__REG_SEQ_SCAN_LENGTH__) == LL_ADC_REG_SEQ_SCAN_ENABLE_16RANKS) \
)
#define IS_LL_ADC_REG_SEQ_SCAN_DISCONT_MODE(__REG_SEQ_DISCONT_MODE__) \
( ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_DISABLE) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_1RANK) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_2RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_3RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_4RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_5RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_6RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_7RANKS) \
|| ((__REG_SEQ_DISCONT_MODE__) == LL_ADC_REG_SEQ_DISCONT_8RANKS) \
)
/* Check of parameters for configuration of ADC hierarchical scope: */
/* ADC group injected */
#define IS_LL_ADC_INJ_TRIG_SOURCE(__INJ_TRIG_SOURCE__) \
( ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_SOFTWARE) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM1_CH4) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM1_TRGO) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM2_CH1) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM2_TRGO) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM3_CH2) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM3_CH4) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM4_CH1) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM4_CH2) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM4_CH3) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM4_TRGO) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM5_CH4) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM5_TRGO) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM8_CH2) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM8_CH3) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_TIM8_CH4) \
|| ((__INJ_TRIG_SOURCE__) == LL_ADC_INJ_TRIG_EXT_EXTI_LINE15) \
)
#define IS_LL_ADC_INJ_TRIG_EXT_EDGE(__INJ_TRIG_EXT_EDGE__) \
( ((__INJ_TRIG_EXT_EDGE__) == LL_ADC_INJ_TRIG_EXT_RISING) \
|| ((__INJ_TRIG_EXT_EDGE__) == LL_ADC_INJ_TRIG_EXT_FALLING) \
|| ((__INJ_TRIG_EXT_EDGE__) == LL_ADC_INJ_TRIG_EXT_RISINGFALLING) \
)
#define IS_LL_ADC_INJ_TRIG_AUTO(__INJ_TRIG_AUTO__) \
( ((__INJ_TRIG_AUTO__) == LL_ADC_INJ_TRIG_INDEPENDENT) \
|| ((__INJ_TRIG_AUTO__) == LL_ADC_INJ_TRIG_FROM_GRP_REGULAR) \
)
#define IS_LL_ADC_INJ_SEQ_SCAN_LENGTH(__INJ_SEQ_SCAN_LENGTH__) \
( ((__INJ_SEQ_SCAN_LENGTH__) == LL_ADC_INJ_SEQ_SCAN_DISABLE) \
|| ((__INJ_SEQ_SCAN_LENGTH__) == LL_ADC_INJ_SEQ_SCAN_ENABLE_2RANKS) \
|| ((__INJ_SEQ_SCAN_LENGTH__) == LL_ADC_INJ_SEQ_SCAN_ENABLE_3RANKS) \
|| ((__INJ_SEQ_SCAN_LENGTH__) == LL_ADC_INJ_SEQ_SCAN_ENABLE_4RANKS) \
)
#define IS_LL_ADC_INJ_SEQ_SCAN_DISCONT_MODE(__INJ_SEQ_DISCONT_MODE__) \
( ((__INJ_SEQ_DISCONT_MODE__) == LL_ADC_INJ_SEQ_DISCONT_DISABLE) \
|| ((__INJ_SEQ_DISCONT_MODE__) == LL_ADC_INJ_SEQ_DISCONT_1RANK) \
)
#if defined(ADC_MULTIMODE_SUPPORT)
/* Check of parameters for configuration of ADC hierarchical scope: */
/* multimode. */
#if defined(ADC3)
#define IS_LL_ADC_MULTI_MODE(__MULTI_MODE__) \
( ((__MULTI_MODE__) == LL_ADC_MULTI_INDEPENDENT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_INTERL) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_INJ_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_INJ_ALTERN) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIM_INJ_SIM) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIM_INJ_ALT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_INT_INJ_SIM) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_REG_SIM_INJ_SIM) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_REG_SIM_INJ_ALT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_INJ_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_REG_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_REG_INTERL) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_TRIPLE_INJ_ALTERN) \
)
#else
#define IS_LL_ADC_MULTI_MODE(__MULTI_MODE__) \
( ((__MULTI_MODE__) == LL_ADC_MULTI_INDEPENDENT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_INTERL) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_INJ_SIMULT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_INJ_ALTERN) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIM_INJ_SIM) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_SIM_INJ_ALT) \
|| ((__MULTI_MODE__) == LL_ADC_MULTI_DUAL_REG_INT_INJ_SIM) \
)
#endif
#define IS_LL_ADC_MULTI_DMA_TRANSFER(__MULTI_DMA_TRANSFER__) \
( ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_EACH_ADC) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_LIMIT_1) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_LIMIT_2) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_LIMIT_3) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_UNLMT_1) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_UNLMT_2) \
|| ((__MULTI_DMA_TRANSFER__) == LL_ADC_MULTI_REG_DMA_UNLMT_3) \
)
#define IS_LL_ADC_MULTI_TWOSMP_DELAY(__MULTI_TWOSMP_DELAY__) \
( ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_5CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_6CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_7CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_8CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_9CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_10CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_11CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_12CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_13CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_14CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_15CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_16CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_17CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_18CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_19CYCLES) \
|| ((__MULTI_TWOSMP_DELAY__) == LL_ADC_MULTI_TWOSMP_DELAY_20CYCLES) \
)
#define IS_LL_ADC_MULTI_MASTER_SLAVE(__MULTI_MASTER_SLAVE__) \
( ((__MULTI_MASTER_SLAVE__) == LL_ADC_MULTI_MASTER) \
|| ((__MULTI_MASTER_SLAVE__) == LL_ADC_MULTI_SLAVE) \
|| ((__MULTI_MASTER_SLAVE__) == LL_ADC_MULTI_MASTER_SLAVE) \
)
#endif /* ADC_MULTIMODE_SUPPORT */
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup ADC_LL_Exported_Functions
* @{
*/
/** @addtogroup ADC_LL_EF_Init
* @{
*/
/**
* @brief De-initialize registers of all ADC instances belonging to
* the same ADC common instance to their default reset values.
* @param ADCxy_COMMON ADC common instance
* (can be set directly from CMSIS definition or by using helper macro @ref __LL_ADC_COMMON_INSTANCE() )
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC common registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_ADC_CommonDeInit(ADC_Common_TypeDef *ADCxy_COMMON)
{
/* Check the parameters */
assert_param(IS_ADC_COMMON_INSTANCE(ADCxy_COMMON));
/* Force reset of ADC clock (core clock) */
LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_ADC);
/* Release reset of ADC clock (core clock) */
LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_ADC);
return SUCCESS;
}
/**
* @brief Initialize some features of ADC common parameters
* (all ADC instances belonging to the same ADC common instance)
* and multimode (for devices with several ADC instances available).
* @note The setting of ADC common parameters is conditioned to
* ADC instances state:
* All ADC instances belonging to the same ADC common instance
* must be disabled.
* @param ADCxy_COMMON ADC common instance
* (can be set directly from CMSIS definition or by using helper macro @ref __LL_ADC_COMMON_INSTANCE() )
* @param ADC_CommonInitStruct Pointer to a @ref LL_ADC_CommonInitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC common registers are initialized
* - ERROR: ADC common registers are not initialized
*/
ErrorStatus LL_ADC_CommonInit(ADC_Common_TypeDef *ADCxy_COMMON, LL_ADC_CommonInitTypeDef *ADC_CommonInitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_ADC_COMMON_INSTANCE(ADCxy_COMMON));
assert_param(IS_LL_ADC_COMMON_CLOCK(ADC_CommonInitStruct->CommonClock));
#if defined(ADC_MULTIMODE_SUPPORT)
assert_param(IS_LL_ADC_MULTI_MODE(ADC_CommonInitStruct->Multimode));
if(ADC_CommonInitStruct->Multimode != LL_ADC_MULTI_INDEPENDENT)
{
assert_param(IS_LL_ADC_MULTI_DMA_TRANSFER(ADC_CommonInitStruct->MultiDMATransfer));
assert_param(IS_LL_ADC_MULTI_TWOSMP_DELAY(ADC_CommonInitStruct->MultiTwoSamplingDelay));
}
#endif /* ADC_MULTIMODE_SUPPORT */
/* Note: Hardware constraint (refer to description of functions */
/* "LL_ADC_SetCommonXXX()" and "LL_ADC_SetMultiXXX()"): */
/* On this STM32 serie, setting of these features is conditioned to */
/* ADC state: */
/* All ADC instances of the ADC common group must be disabled. */
if(__LL_ADC_IS_ENABLED_ALL_COMMON_INSTANCE(ADCxy_COMMON) == 0U)
{
/* Configuration of ADC hierarchical scope: */
/* - common to several ADC */
/* (all ADC instances belonging to the same ADC common instance) */
/* - Set ADC clock (conversion clock) */
/* - multimode (if several ADC instances available on the */
/* selected device) */
/* - Set ADC multimode configuration */
/* - Set ADC multimode DMA transfer */
/* - Set ADC multimode: delay between 2 sampling phases */
#if defined(ADC_MULTIMODE_SUPPORT)
if(ADC_CommonInitStruct->Multimode != LL_ADC_MULTI_INDEPENDENT)
{
MODIFY_REG(ADCxy_COMMON->CCR,
ADC_CCR_ADCPRE
| ADC_CCR_MULTI
| ADC_CCR_DMA
| ADC_CCR_DDS
| ADC_CCR_DELAY
,
ADC_CommonInitStruct->CommonClock
| ADC_CommonInitStruct->Multimode
| ADC_CommonInitStruct->MultiDMATransfer
| ADC_CommonInitStruct->MultiTwoSamplingDelay
);
}
else
{
MODIFY_REG(ADCxy_COMMON->CCR,
ADC_CCR_ADCPRE
| ADC_CCR_MULTI
| ADC_CCR_DMA
| ADC_CCR_DDS
| ADC_CCR_DELAY
,
ADC_CommonInitStruct->CommonClock
| LL_ADC_MULTI_INDEPENDENT
);
}
#else
LL_ADC_SetCommonClock(ADCxy_COMMON, ADC_CommonInitStruct->CommonClock);
#endif
}
else
{
/* Initialization error: One or several ADC instances belonging to */
/* the same ADC common instance are not disabled. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_ADC_CommonInitTypeDef field to default value.
* @param ADC_CommonInitStruct Pointer to a @ref LL_ADC_CommonInitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_ADC_CommonStructInit(LL_ADC_CommonInitTypeDef *ADC_CommonInitStruct)
{
/* Set ADC_CommonInitStruct fields to default values */
/* Set fields of ADC common */
/* (all ADC instances belonging to the same ADC common instance) */
ADC_CommonInitStruct->CommonClock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;
#if defined(ADC_MULTIMODE_SUPPORT)
/* Set fields of ADC multimode */
ADC_CommonInitStruct->Multimode = LL_ADC_MULTI_INDEPENDENT;
ADC_CommonInitStruct->MultiDMATransfer = LL_ADC_MULTI_REG_DMA_EACH_ADC;
ADC_CommonInitStruct->MultiTwoSamplingDelay = LL_ADC_MULTI_TWOSMP_DELAY_5CYCLES;
#endif /* ADC_MULTIMODE_SUPPORT */
}
/**
* @brief De-initialize registers of the selected ADC instance
* to their default reset values.
* @note To reset all ADC instances quickly (perform a hard reset),
* use function @ref LL_ADC_CommonDeInit().
* @param ADCx ADC instance
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC registers are de-initialized
* - ERROR: ADC registers are not de-initialized
*/
ErrorStatus LL_ADC_DeInit(ADC_TypeDef *ADCx)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_ADC_ALL_INSTANCE(ADCx));
/* Disable ADC instance if not already disabled. */
if(LL_ADC_IsEnabled(ADCx) == 1U)
{
/* Set ADC group regular trigger source to SW start to ensure to not */
/* have an external trigger event occurring during the conversion stop */
/* ADC disable process. */
LL_ADC_REG_SetTriggerSource(ADCx, LL_ADC_REG_TRIG_SOFTWARE);
/* Set ADC group injected trigger source to SW start to ensure to not */
/* have an external trigger event occurring during the conversion stop */
/* ADC disable process. */
LL_ADC_INJ_SetTriggerSource(ADCx, LL_ADC_INJ_TRIG_SOFTWARE);
/* Disable the ADC instance */
LL_ADC_Disable(ADCx);
}
/* Check whether ADC state is compliant with expected state */
/* (hardware requirements of bits state to reset registers below) */
if(READ_BIT(ADCx->CR2, ADC_CR2_ADON) == 0U)
{
/* ========== Reset ADC registers ========== */
/* Reset register SR */
CLEAR_BIT(ADCx->SR,
( LL_ADC_FLAG_STRT
| LL_ADC_FLAG_JSTRT
| LL_ADC_FLAG_EOCS
| LL_ADC_FLAG_OVR
| LL_ADC_FLAG_JEOS
| LL_ADC_FLAG_AWD1 )
);
/* Reset register CR1 */
CLEAR_BIT(ADCx->CR1,
( ADC_CR1_OVRIE | ADC_CR1_RES | ADC_CR1_AWDEN
| ADC_CR1_JAWDEN
| ADC_CR1_DISCNUM | ADC_CR1_JDISCEN | ADC_CR1_DISCEN
| ADC_CR1_JAUTO | ADC_CR1_AWDSGL | ADC_CR1_SCAN
| ADC_CR1_JEOCIE | ADC_CR1_AWDIE | ADC_CR1_EOCIE
| ADC_CR1_AWDCH )
);
/* Reset register CR2 */
CLEAR_BIT(ADCx->CR2,
( ADC_CR2_SWSTART | ADC_CR2_EXTEN | ADC_CR2_EXTSEL
| ADC_CR2_JSWSTART | ADC_CR2_JEXTEN | ADC_CR2_JEXTSEL
| ADC_CR2_ALIGN | ADC_CR2_EOCS
| ADC_CR2_DDS | ADC_CR2_DMA
| ADC_CR2_CONT | ADC_CR2_ADON )
);
/* Reset register SMPR1 */
CLEAR_BIT(ADCx->SMPR1,
( ADC_SMPR1_SMP18 | ADC_SMPR1_SMP17 | ADC_SMPR1_SMP16
| ADC_SMPR1_SMP15 | ADC_SMPR1_SMP14 | ADC_SMPR1_SMP13
| ADC_SMPR1_SMP12 | ADC_SMPR1_SMP11 | ADC_SMPR1_SMP10)
);
/* Reset register SMPR2 */
CLEAR_BIT(ADCx->SMPR2,
( ADC_SMPR2_SMP9
| ADC_SMPR2_SMP8 | ADC_SMPR2_SMP7 | ADC_SMPR2_SMP6
| ADC_SMPR2_SMP5 | ADC_SMPR2_SMP4 | ADC_SMPR2_SMP3
| ADC_SMPR2_SMP2 | ADC_SMPR2_SMP1 | ADC_SMPR2_SMP0)
);
/* Reset register JOFR1 */
CLEAR_BIT(ADCx->JOFR1, ADC_JOFR1_JOFFSET1);
/* Reset register JOFR2 */
CLEAR_BIT(ADCx->JOFR2, ADC_JOFR2_JOFFSET2);
/* Reset register JOFR3 */
CLEAR_BIT(ADCx->JOFR3, ADC_JOFR3_JOFFSET3);
/* Reset register JOFR4 */
CLEAR_BIT(ADCx->JOFR4, ADC_JOFR4_JOFFSET4);
/* Reset register HTR */
SET_BIT(ADCx->HTR, ADC_HTR_HT);
/* Reset register LTR */
CLEAR_BIT(ADCx->LTR, ADC_LTR_LT);
/* Reset register SQR1 */
CLEAR_BIT(ADCx->SQR1,
( ADC_SQR1_L
| ADC_SQR1_SQ16
| ADC_SQR1_SQ15 | ADC_SQR1_SQ14 | ADC_SQR1_SQ13)
);
/* Reset register SQR2 */
CLEAR_BIT(ADCx->SQR2,
( ADC_SQR2_SQ12 | ADC_SQR2_SQ11 | ADC_SQR2_SQ10
| ADC_SQR2_SQ9 | ADC_SQR2_SQ8 | ADC_SQR2_SQ7)
);
/* Reset register JSQR */
CLEAR_BIT(ADCx->JSQR,
( ADC_JSQR_JL
| ADC_JSQR_JSQ4 | ADC_JSQR_JSQ3
| ADC_JSQR_JSQ2 | ADC_JSQR_JSQ1 )
);
/* Reset register DR */
/* bits in access mode read only, no direct reset applicable */
/* Reset registers JDR1, JDR2, JDR3, JDR4 */
/* bits in access mode read only, no direct reset applicable */
/* Reset register CCR */
CLEAR_BIT(ADC->CCR, ADC_CCR_TSVREFE | ADC_CCR_ADCPRE);
}
return status;
}
/**
* @brief Initialize some features of ADC instance.
* @note These parameters have an impact on ADC scope: ADC instance.
* Affects both group regular and group injected (availability
* of ADC group injected depends on STM32 families).
* Refer to corresponding unitary functions into
* @ref ADC_LL_EF_Configuration_ADC_Instance .
* @note The setting of these parameters by function @ref LL_ADC_Init()
* is conditioned to ADC state:
* ADC instance must be disabled.
* This condition is applied to all ADC features, for efficiency
* and compatibility over all STM32 families. However, the different
* features can be set under different ADC state conditions
* (setting possible with ADC enabled without conversion on going,
* ADC enabled with conversion on going, ...)
* Each feature can be updated afterwards with a unitary function
* and potentially with ADC in a different state than disabled,
* refer to description of each function for setting
* conditioned to ADC state.
* @note After using this function, some other features must be configured
* using LL unitary functions.
* The minimum configuration remaining to be done is:
* - Set ADC group regular or group injected sequencer:
* map channel on the selected sequencer rank.
* Refer to function @ref LL_ADC_REG_SetSequencerRanks().
* - Set ADC channel sampling time
* Refer to function LL_ADC_SetChannelSamplingTime();
* @param ADCx ADC instance
* @param ADC_InitStruct Pointer to a @ref LL_ADC_REG_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC registers are initialized
* - ERROR: ADC registers are not initialized
*/
ErrorStatus LL_ADC_Init(ADC_TypeDef *ADCx, LL_ADC_InitTypeDef *ADC_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_ADC_ALL_INSTANCE(ADCx));
assert_param(IS_LL_ADC_RESOLUTION(ADC_InitStruct->Resolution));
assert_param(IS_LL_ADC_DATA_ALIGN(ADC_InitStruct->DataAlignment));
assert_param(IS_LL_ADC_SCAN_SELECTION(ADC_InitStruct->SequencersScanMode));
/* Note: Hardware constraint (refer to description of this function): */
/* ADC instance must be disabled. */
if(LL_ADC_IsEnabled(ADCx) == 0U)
{
/* Configuration of ADC hierarchical scope: */
/* - ADC instance */
/* - Set ADC data resolution */
/* - Set ADC conversion data alignment */
MODIFY_REG(ADCx->CR1,
ADC_CR1_RES
| ADC_CR1_SCAN
,
ADC_InitStruct->Resolution
| ADC_InitStruct->SequencersScanMode
);
MODIFY_REG(ADCx->CR2,
ADC_CR2_ALIGN
,
ADC_InitStruct->DataAlignment
);
}
else
{
/* Initialization error: ADC instance is not disabled. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_ADC_InitTypeDef field to default value.
* @param ADC_InitStruct Pointer to a @ref LL_ADC_InitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_ADC_StructInit(LL_ADC_InitTypeDef *ADC_InitStruct)
{
/* Set ADC_InitStruct fields to default values */
/* Set fields of ADC instance */
ADC_InitStruct->Resolution = LL_ADC_RESOLUTION_12B;
ADC_InitStruct->DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;
/* Enable scan mode to have a generic behavior with ADC of other */
/* STM32 families, without this setting available: */
/* ADC group regular sequencer and ADC group injected sequencer depend */
/* only of their own configuration. */
ADC_InitStruct->SequencersScanMode = LL_ADC_SEQ_SCAN_ENABLE;
}
/**
* @brief Initialize some features of ADC group regular.
* @note These parameters have an impact on ADC scope: ADC group regular.
* Refer to corresponding unitary functions into
* @ref ADC_LL_EF_Configuration_ADC_Group_Regular
* (functions with prefix "REG").
* @note The setting of these parameters by function @ref LL_ADC_Init()
* is conditioned to ADC state:
* ADC instance must be disabled.
* This condition is applied to all ADC features, for efficiency
* and compatibility over all STM32 families. However, the different
* features can be set under different ADC state conditions
* (setting possible with ADC enabled without conversion on going,
* ADC enabled with conversion on going, ...)
* Each feature can be updated afterwards with a unitary function
* and potentially with ADC in a different state than disabled,
* refer to description of each function for setting
* conditioned to ADC state.
* @note After using this function, other features must be configured
* using LL unitary functions.
* The minimum configuration remaining to be done is:
* - Set ADC group regular or group injected sequencer:
* map channel on the selected sequencer rank.
* Refer to function @ref LL_ADC_REG_SetSequencerRanks().
* - Set ADC channel sampling time
* Refer to function LL_ADC_SetChannelSamplingTime();
* @param ADCx ADC instance
* @param ADC_REG_InitStruct Pointer to a @ref LL_ADC_REG_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC registers are initialized
* - ERROR: ADC registers are not initialized
*/
ErrorStatus LL_ADC_REG_Init(ADC_TypeDef *ADCx, LL_ADC_REG_InitTypeDef *ADC_REG_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_ADC_ALL_INSTANCE(ADCx));
assert_param(IS_LL_ADC_REG_TRIG_SOURCE(ADC_REG_InitStruct->TriggerSource));
assert_param(IS_LL_ADC_REG_SEQ_SCAN_LENGTH(ADC_REG_InitStruct->SequencerLength));
if(ADC_REG_InitStruct->SequencerLength != LL_ADC_REG_SEQ_SCAN_DISABLE)
{
assert_param(IS_LL_ADC_REG_SEQ_SCAN_DISCONT_MODE(ADC_REG_InitStruct->SequencerDiscont));
}
assert_param(IS_LL_ADC_REG_CONTINUOUS_MODE(ADC_REG_InitStruct->ContinuousMode));
assert_param(IS_LL_ADC_REG_DMA_TRANSFER(ADC_REG_InitStruct->DMATransfer));
/* Note: Hardware constraint (refer to description of this function): */
/* ADC instance must be disabled. */
if(LL_ADC_IsEnabled(ADCx) == 0U)
{
/* Configuration of ADC hierarchical scope: */
/* - ADC group regular */
/* - Set ADC group regular trigger source */
/* - Set ADC group regular sequencer length */
/* - Set ADC group regular sequencer discontinuous mode */
/* - Set ADC group regular continuous mode */
/* - Set ADC group regular conversion data transfer: no transfer or */
/* transfer by DMA, and DMA requests mode */
/* Note: On this STM32 serie, ADC trigger edge is set when starting */
/* ADC conversion. */
/* Refer to function @ref LL_ADC_REG_StartConversionExtTrig(). */
if(ADC_REG_InitStruct->SequencerLength != LL_ADC_REG_SEQ_SCAN_DISABLE)
{
MODIFY_REG(ADCx->CR1,
ADC_CR1_DISCEN
| ADC_CR1_DISCNUM
,
ADC_REG_InitStruct->SequencerLength
| ADC_REG_InitStruct->SequencerDiscont
);
}
else
{
MODIFY_REG(ADCx->CR1,
ADC_CR1_DISCEN
| ADC_CR1_DISCNUM
,
ADC_REG_InitStruct->SequencerLength
| LL_ADC_REG_SEQ_DISCONT_DISABLE
);
}
MODIFY_REG(ADCx->CR2,
ADC_CR2_EXTSEL
| ADC_CR2_EXTEN
| ADC_CR2_CONT
| ADC_CR2_DMA
| ADC_CR2_DDS
,
(ADC_REG_InitStruct->TriggerSource & ADC_CR2_EXTSEL)
| ADC_REG_InitStruct->ContinuousMode
| ADC_REG_InitStruct->DMATransfer
);
/* Set ADC group regular sequencer length and scan direction */
/* Note: Hardware constraint (refer to description of this function): */
/* Note: If ADC instance feature scan mode is disabled */
/* (refer to ADC instance initialization structure */
/* parameter @ref SequencersScanMode */
/* or function @ref LL_ADC_SetSequencersScanMode() ), */
/* this parameter is discarded. */
LL_ADC_REG_SetSequencerLength(ADCx, ADC_REG_InitStruct->SequencerLength);
}
else
{
/* Initialization error: ADC instance is not disabled. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_ADC_REG_InitTypeDef field to default value.
* @param ADC_REG_InitStruct Pointer to a @ref LL_ADC_REG_InitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_ADC_REG_StructInit(LL_ADC_REG_InitTypeDef *ADC_REG_InitStruct)
{
/* Set ADC_REG_InitStruct fields to default values */
/* Set fields of ADC group regular */
/* Note: On this STM32 serie, ADC trigger edge is set when starting */
/* ADC conversion. */
/* Refer to function @ref LL_ADC_REG_StartConversionExtTrig(). */
ADC_REG_InitStruct->TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;
ADC_REG_InitStruct->SequencerLength = LL_ADC_REG_SEQ_SCAN_DISABLE;
ADC_REG_InitStruct->SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;
ADC_REG_InitStruct->ContinuousMode = LL_ADC_REG_CONV_SINGLE;
ADC_REG_InitStruct->DMATransfer = LL_ADC_REG_DMA_TRANSFER_NONE;
}
/**
* @brief Initialize some features of ADC group injected.
* @note These parameters have an impact on ADC scope: ADC group injected.
* Refer to corresponding unitary functions into
* @ref ADC_LL_EF_Configuration_ADC_Group_Regular
* (functions with prefix "INJ").
* @note The setting of these parameters by function @ref LL_ADC_Init()
* is conditioned to ADC state:
* ADC instance must be disabled.
* This condition is applied to all ADC features, for efficiency
* and compatibility over all STM32 families. However, the different
* features can be set under different ADC state conditions
* (setting possible with ADC enabled without conversion on going,
* ADC enabled with conversion on going, ...)
* Each feature can be updated afterwards with a unitary function
* and potentially with ADC in a different state than disabled,
* refer to description of each function for setting
* conditioned to ADC state.
* @note After using this function, other features must be configured
* using LL unitary functions.
* The minimum configuration remaining to be done is:
* - Set ADC group injected sequencer:
* map channel on the selected sequencer rank.
* Refer to function @ref LL_ADC_INJ_SetSequencerRanks().
* - Set ADC channel sampling time
* Refer to function LL_ADC_SetChannelSamplingTime();
* @param ADCx ADC instance
* @param ADC_INJ_InitStruct Pointer to a @ref LL_ADC_INJ_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: ADC registers are initialized
* - ERROR: ADC registers are not initialized
*/
ErrorStatus LL_ADC_INJ_Init(ADC_TypeDef *ADCx, LL_ADC_INJ_InitTypeDef *ADC_INJ_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_ADC_ALL_INSTANCE(ADCx));
assert_param(IS_LL_ADC_INJ_TRIG_SOURCE(ADC_INJ_InitStruct->TriggerSource));
assert_param(IS_LL_ADC_INJ_SEQ_SCAN_LENGTH(ADC_INJ_InitStruct->SequencerLength));
if(ADC_INJ_InitStruct->SequencerLength != LL_ADC_INJ_SEQ_SCAN_DISABLE)
{
assert_param(IS_LL_ADC_INJ_SEQ_SCAN_DISCONT_MODE(ADC_INJ_InitStruct->SequencerDiscont));
}
assert_param(IS_LL_ADC_INJ_TRIG_AUTO(ADC_INJ_InitStruct->TrigAuto));
/* Note: Hardware constraint (refer to description of this function): */
/* ADC instance must be disabled. */
if(LL_ADC_IsEnabled(ADCx) == 0U)
{
/* Configuration of ADC hierarchical scope: */
/* - ADC group injected */
/* - Set ADC group injected trigger source */
/* - Set ADC group injected sequencer length */
/* - Set ADC group injected sequencer discontinuous mode */
/* - Set ADC group injected conversion trigger: independent or */
/* from ADC group regular */
/* Note: On this STM32 serie, ADC trigger edge is set when starting */
/* ADC conversion. */
/* Refer to function @ref LL_ADC_INJ_StartConversionExtTrig(). */
if(ADC_INJ_InitStruct->SequencerLength != LL_ADC_REG_SEQ_SCAN_DISABLE)
{
MODIFY_REG(ADCx->CR1,
ADC_CR1_JDISCEN
| ADC_CR1_JAUTO
,
ADC_INJ_InitStruct->SequencerDiscont
| ADC_INJ_InitStruct->TrigAuto
);
}
else
{
MODIFY_REG(ADCx->CR1,
ADC_CR1_JDISCEN
| ADC_CR1_JAUTO
,
LL_ADC_REG_SEQ_DISCONT_DISABLE
| ADC_INJ_InitStruct->TrigAuto
);
}
MODIFY_REG(ADCx->CR2,
ADC_CR2_JEXTSEL
| ADC_CR2_JEXTEN
,
(ADC_INJ_InitStruct->TriggerSource & ADC_CR2_JEXTSEL)
);
/* Note: Hardware constraint (refer to description of this function): */
/* Note: If ADC instance feature scan mode is disabled */
/* (refer to ADC instance initialization structure */
/* parameter @ref SequencersScanMode */
/* or function @ref LL_ADC_SetSequencersScanMode() ), */
/* this parameter is discarded. */
LL_ADC_INJ_SetSequencerLength(ADCx, ADC_INJ_InitStruct->SequencerLength);
}
else
{
/* Initialization error: ADC instance is not disabled. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_ADC_INJ_InitTypeDef field to default value.
* @param ADC_INJ_InitStruct Pointer to a @ref LL_ADC_INJ_InitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_ADC_INJ_StructInit(LL_ADC_INJ_InitTypeDef *ADC_INJ_InitStruct)
{
/* Set ADC_INJ_InitStruct fields to default values */
/* Set fields of ADC group injected */
ADC_INJ_InitStruct->TriggerSource = LL_ADC_INJ_TRIG_SOFTWARE;
ADC_INJ_InitStruct->SequencerLength = LL_ADC_INJ_SEQ_SCAN_DISABLE;
ADC_INJ_InitStruct->SequencerDiscont = LL_ADC_INJ_SEQ_DISCONT_DISABLE;
ADC_INJ_InitStruct->TrigAuto = LL_ADC_INJ_TRIG_INDEPENDENT;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* ADC1 || ADC2 || ADC3 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/64199965.c | #include <stdlib.h>
#define REPS (100000)
int sizes[] = {
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50,
100000, 1024, 42000, 350, 100, 80, 3 ,3,3,3,3,3,3,3,3,3,3,3,3,50
};
#define NUM (sizeof sizes / sizeof sizes[0])
int main ()
{
int i, j;
void *allocs[NUM];
for (i = 0; i < REPS; i++) {
for (j = 0; j < NUM; j++) {
allocs[j] = malloc(sizes[j]);
}
for (j = 0; j < NUM; j++) {
free(allocs[j]);
}
}
return 0;
}
|
the_stack_data/664517.c | /* -----------------------------------------------------------------------
get_cmd.c
get command from terminal after prompt.
coded by Naotoshi Osaka 4/28/'00
----------------------------------------------------------------------- */
#include <string.h>
#include <math.h>
#include <stdio.h>
void get_cmd(char prompt[],char cmdline[],int maxline)
{ int getaline(char s[],int lim);
int i;
printf(prompt);
for(i=0;i<maxline;i++){cmdline[i]=' ';} /* null */
getaline(cmdline,maxline);
}
/* get a line from keyboard -- page 31 in textbook */
int getaline(char s[],int lim)
{int c, i;
for(i=0;i<lim-1 && (c=getchar())!=EOF && c!='\n'; ++i) s[i]=c;
s[i]='\0'; return(i);
}
|
the_stack_data/82163.c | /*
* Copyright (c) 2011 Google Inc. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <stdio.h>
void foo(void) {
printf("foo\n");
}
|
the_stack_data/107952292.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>
#include <assert.h>
#include <error.h>
#include <errno.h>
/*
Tests that there is still input to the terminal.
When this goes to 0, the terminal exits on the
next disconnect.
*/
int INPUT_OPEN=1;
int confd, kbdfd; /* The pipe file descriptors */
/* Polling array */
struct pollfd fds[4] = {
{ 0, POLLIN, 0 },
{ 1, POLLOUT, 0 },
{ 0, POLLOUT, 0 },
{ 0, POLLIN, 0 },
};
/* some operations on the polling array */
/* Flip/negate fd field; poll ignores negative fds */
#define flip(i) (fds[i].fd = - fds[i].fd - 1)
#define ready(i) (fds[i].revents & fds[i].events)
#define err(i) (fds[i].revents & (POLLERR|POLLHUP))
#define polled(i) (fds[i].fd>=0)
int state[4]; /* Last poll result */
int errst[4]; /* Whether error was detected */
/* Mnemonic macros */
#define IN state[0]
#define OUT state[1]
#define KBD state[2]
#define CON state[3]
#define INERR errst[0]
#define OUTERR errst[1]
#define KBDERR errst[2]
#define CONERR errst[3]
/* Helper */
void transfer_byte(int from, int to, int fromfd, int tofd)
{
int rc;
char buf;
rc=read(fromfd, &buf, 1);
if(rc==1) rc=write(tofd, &buf, 1);
#if EXIT_ON_STDIN_CLOSE
if(rc==0) {
assert(fromfd==0);
if(! isatty(0)) {
INPUT_OPEN=0; close(0);
}
fprintf(stderr, "Stdin closed\n");
}
#endif
flip(from); flip(to); /* They are not ready any more */
}
/* Loop transferring bytes between the streams */
void io_loop()
{
/* acquire fds */
fds[2].fd = kbdfd;
fds[3].fd = confd;
while(1) {
/* Poll the files */
poll(fds, 4, -1);
/* Update indicators */
for(int i=0; i<4; i++) {
if(polled(i)) {
state[i]=ready(i);
if(state[i]) flip(i); /* Flip ready files */
errst[i]=err(i);
}
}
if(errst[0]) fprintf(stderr,"Error in 0\n");
if(errst[1]) fprintf(stderr,"Error in 1\n");
int XKBD = IN && KBD;
int XCON = OUT && CON;
/* Break if we have no transfers and some error */
if(!XKBD && !XCON && (KBDERR||CONERR)) break;
/* Do ready transfers */
if( XKBD ) transfer_byte(0, 2, 0, kbdfd);
if( XCON ) transfer_byte(3, 1, confd, 1);
}
close(confd);
close(kbdfd);
}
const char* disconnected = "\n\033[5;41;1;37m *** DISCONNECTED *** \033[0m\n";
const char* connected = "\033[5;40;1;37m *** CONNECTED *** \033[0m\n";
/* This call will block until the pipe is opened by the peer */
int open_pipe(const char* fname, int flags) {
int fd = open(fname, flags);
if(fd==-1) error(1, errno, "opening %s", fname);
return fd;
}
void mainloop(char* arg)
{
char confname[10], kbdfname[10];
sprintf(confname, "con%s", arg);
sprintf(kbdfname, "kbd%s", arg);
/* We close and re-open on every disconnect, in order to
sleep */
while(INPUT_OPEN) {
printf(disconnected); fflush(stdout);
confd = open_pipe(confname, O_RDONLY);
kbdfd = open_pipe(kbdfname, O_WRONLY);
printf(connected); fflush(stdout);
io_loop();
}
}
void usage()
{
printf("usage: terminal <n> where n = 0..3\n");
exit(1);
}
int main(int argc, char** argv)
{
if(argc!=2 || strlen(argv[1])!=1 || argv[1][0]<'0' || argv[1][0]>'3')
usage();
//signal(SIGPIPE, SIG_IGN);
mainloop(argv[1]);
return -1; /* Does not return */
}
|
the_stack_data/424745.c | /* DataToC output of file <prepass_vert_glsl> */
extern int datatoc_prepass_vert_glsl_size;
extern char datatoc_prepass_vert_glsl[];
int datatoc_prepass_vert_glsl_size = 970;
char datatoc_prepass_vert_glsl[] = {
13, 10,117,110,105,102,111,114,109, 32,109, 97,116, 52, 32, 77,111,100,101,108, 86,105,101,119, 80,114,111,106,101, 99,116,105,111,110, 77, 97,116,114,105,120, 59, 13, 10,117,110,105,102,111,114,109, 32,109, 97,116, 52, 32, 77,111,100,101,108, 77, 97,116,114,105,120, 59, 13, 10,117,110,105,102,111,114,109, 32,109, 97,116, 52, 32, 77,111,100,101,108, 77, 97,116,114,105,120, 73,110,118,101,114,115,101, 59, 13, 10, 13, 10, 35,105,102,100,101,102, 32, 67, 76, 73, 80, 95, 80, 76, 65, 78, 69, 83, 13, 10, 47, 42, 32,107,101,101,112, 32,105,110, 32,115,121,110, 99, 32,119,105,116,104, 32, 68, 82, 87, 77, 97,110, 97,103,101,114, 46,118,105,101,119, 95,100, 97,116, 97, 32, 42, 47, 13, 10,108, 97,121,111,117,116, 40,115,116,100, 49, 52, 48, 41, 32,117,110,105,102,111,114,109, 32, 99,108,105,112, 95, 98,108,111, 99,107, 32,123, 13, 10, 9,118,101, 99, 52, 32, 67,108,105,112, 80,108, 97,110,101,115, 91, 49, 93, 59, 13, 10,125, 59, 13, 10, 35,101,110,100,105,102, 13, 10, 13, 10, 35,105,102,110,100,101,102, 32, 72, 65, 73, 82, 95, 83, 72, 65, 68, 69, 82, 13, 10,105,110, 32,118,101, 99, 51, 32,112,111,115, 59, 13, 10, 35,101,110,100,105,102, 13, 10, 13, 10,118,111,105,100, 32,109, 97,105,110, 40, 41, 13, 10,123, 13, 10, 35,105,102,100,101,102, 32, 72, 65, 73, 82, 95, 83, 72, 65, 68, 69, 82, 13, 10, 9,102,108,111, 97,116, 32,116,105,109,101, 44, 32,116,104,105, 99,107, 95,116,105,109,101, 44, 32,116,104,105, 99,107,110,101,115,115, 59, 13, 10, 9,118,101, 99, 51, 32,112,111,115, 44, 32,116, 97,110, 44, 32, 98,105,110,111,114, 59, 13, 10, 9,104, 97,105,114, 95,103,101,116, 95,112,111,115, 95,116, 97,110, 95, 98,105,110,111,114, 95,116,105,109,101, 40, 13, 10, 9, 32, 32, 32, 32, 32, 32, 32, 32, 40, 80,114,111,106,101, 99,116,105,111,110, 77, 97,116,114,105,120, 91, 51, 93, 91, 51, 93, 32, 61, 61, 32, 48, 46, 48, 41, 44, 13, 10, 9, 32, 32, 32, 32, 32, 32, 32, 32, 77,111,100,101,108, 77, 97,116,114,105,120, 73,110,118,101,114,115,101, 44, 13, 10, 9, 32, 32, 32, 32, 32, 32, 32, 32, 86,105,101,119, 77, 97,116,114,105,120, 73,110,118,101,114,115,101, 91, 51, 93, 46,120,121,122, 44, 32, 86,105,101,119, 77, 97,116,114,105,120, 73,110,118,101,114,115,101, 91, 50, 93, 46,120,121,122, 44, 13, 10, 9, 32, 32, 32, 32, 32, 32, 32, 32,112,111,115, 44, 32,116, 97,110, 44, 32, 98,105,110,111,114, 44, 32,116,105,109,101, 44, 32,116,104,105, 99,107,110,101,115,115, 44, 32,116,104,105, 99,107, 95,116,105,109,101, 41, 59, 13, 10, 13, 10, 9,103,108, 95, 80,111,115,105,116,105,111,110, 32, 61, 32, 86,105,101,119, 80,114,111,106,101, 99,116,105,111,110, 77, 97,116,114,105,120, 32, 42, 32,118,101, 99, 52, 40,112,111,115, 44, 32, 49, 46, 48, 41, 59, 13, 10, 9,118,101, 99, 52, 32,119,111,114,108,100, 80,111,115,105,116,105,111,110, 32, 61, 32,118,101, 99, 52, 40,112,111,115, 44, 32, 49, 46, 48, 41, 59, 13, 10, 35,101,108,115,101, 13, 10, 9,103,108, 95, 80,111,115,105,116,105,111,110, 32, 61, 32, 77,111,100,101,108, 86,105,101,119, 80,114,111,106,101, 99,116,105,111,110, 77, 97,116,114,105,120, 32, 42, 32,118,101, 99, 52, 40,112,111,115, 44, 32, 49, 46, 48, 41, 59, 13, 10, 9,118,101, 99, 52, 32,119,111,114,108,100, 80,111,115,105,116,105,111,110, 32, 61, 32, 40, 77,111,100,101,108, 77, 97,116,114,105,120, 32, 42, 32,118,101, 99, 52, 40,112,111,115, 44, 32, 49, 46, 48, 41, 41, 59, 13, 10, 35,101,110,100,105,102, 13, 10, 13, 10, 35,105,102,100,101,102, 32, 67, 76, 73, 80, 95, 80, 76, 65, 78, 69, 83, 13, 10, 9,103,108, 95, 67,108,105,112, 68,105,115,116, 97,110, 99,101, 91, 48, 93, 32, 61, 32,100,111,116, 40,118,101, 99, 52, 40,119,111,114,108,100, 80,111,115,105,116,105,111,110, 46,120,121,122, 44, 32, 49, 46, 48, 41, 44, 32, 67,108,105,112, 80,108, 97,110,101,115, 91, 48, 93, 41, 59, 13, 10, 35,101,110,100,105,102, 13, 10, 9, 47, 42, 32, 84, 79, 68, 79, 32,109,111,116,105,111,110, 32,118,101, 99,116,111,114,115, 32, 42, 47, 13, 10,125, 13, 10,0
};
|
the_stack_data/51700824.c | // RUN: rm -rf %t*
// RUN: 3c -base-dir=%S -alltypes -addcr %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_ALL","CHECK" %s
// RUN: 3c -base-dir=%S -addcr %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_NOALL","CHECK" %s
// RUN: 3c -base-dir=%S -addcr %s -- | %clang -c -fcheckedc-extension -x c -o /dev/null -
// RUN: 3c -base-dir=%S -alltypes -output-dir=%t.checked %s --
// RUN: 3c -base-dir=%t.checked -alltypes %t.checked/b30_structprotocastunsafeexplicit.c -- | diff %t.checked/b30_structprotocastunsafeexplicit.c -
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct np {
int x;
int y;
};
struct p {
int *x;
//CHECK: _Ptr<int> x;
char *y;
//CHECK: _Ptr<char> y;
};
struct r {
int data;
struct r *next;
//CHECK: struct r *next;
};
struct r *sus(struct r *, struct r *);
//CHECK: _Ptr<struct r> sus(_Ptr<struct r> x, _Ptr<struct r> y);
struct r *foo() {
//CHECK: _Ptr<struct r> foo(void) {
struct r *x;
//CHECK: struct r *x;
struct r *y;
//CHECK: struct r *y;
x->data = 2;
y->data = 1;
x->next = &y;
y->next = &x;
struct r *z = (struct r *)sus(x, y);
//CHECK: _Ptr<struct r> z = (_Ptr<struct r>)sus(_Assume_bounds_cast<_Ptr<struct r>>(x), _Assume_bounds_cast<_Ptr<struct r>>(y));
return z;
}
struct np *bar() {
//CHECK: struct np *bar(void) : itype(_Ptr<struct np>) {
struct r *x;
//CHECK: struct r *x;
struct r *y;
//CHECK: struct r *y;
x->data = 2;
y->data = 1;
x->next = &y;
y->next = &x;
struct np *z = (struct np *)sus(x, y);
//CHECK: struct np *z = (struct np *)sus(_Assume_bounds_cast<_Ptr<struct r>>(x), _Assume_bounds_cast<_Ptr<struct r>>(y));
return z;
}
struct r *sus(struct r *x, struct r *y) {
//CHECK: _Ptr<struct r> sus(_Ptr<struct r> x, _Ptr<struct r> y) {
x->next += 1;
struct r *z = malloc(sizeof(struct r));
//CHECK: _Ptr<struct r> z = malloc<struct r>(sizeof(struct r));
z->data = 1;
z->next = 0;
return z;
}
|
the_stack_data/122016161.c | #include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
while(1){
for(int i = 0; i< 20;i++){
printf(" \n");
ps_udelay(100*130);
}
printf(" _ _ _ \n");ps_udelay(100*130);
printf(" | | | || | \n");ps_udelay(100*130);
printf(" ___ ___| | | || |_ \n");ps_udelay(100*130);
printf(" / __|/ _ \\ | |__ _| \n");ps_udelay(100*130);
printf(" \\__ \\ __/ |____| | \n");ps_udelay(100*130);
printf(" _|___/\\___|______|_| _ \n");ps_udelay(100*130);
printf(" |__ __| (_) (_) \n");ps_udelay(100*130);
printf(" | |_ __ __ _ _ _ __ _ _ __ __ _ \n");ps_udelay(100*130);
printf(" | | '__/ _` | | '_ \\| | '_ \\ / _` | \n");ps_udelay(100*130);
printf(" | | | | (_| | | | | | | | | | (_| | \n");ps_udelay(100*130);
printf(" |_|_| \\__,_|_|_| |_|_|_| |_|\\__, | \n");ps_udelay(100*130);
printf(" ___ ___ __ ___ __/ | \n");ps_udelay(100*130);
printf(" |__ \\ / _ \\/_ |/ _ \\|___/ \n");ps_udelay(100*130);
printf(" ______ ______ ) | | | || | (_) |______ ______ \n");ps_udelay(100*130);
printf(" |______|______/ /| | | || |\\__, |______|______|\n");ps_udelay(100*130);
printf(" / /_| |_| || | / / \n");ps_udelay(100*130);
printf(" |____|\\___/ |_| /_/ \n");ps_udelay(100*130);
}
}
|
the_stack_data/859586.c | #include <stdio.h>
#include <stdlib.h>
#define WYNAGRODZENIE35 35
#define WYNAGRODZENIE37 37
#define WYNAGRODZENIE40 40
#define WYNAGRODZENIE45 45
#define PODATEK15 0.15
#define PODATEK20 0.20
#define PODATEK25 0.25
void menu(void);
int main(void)
{
int opcja;
menu();
while (scanf("%d", &opcja) == 1)
{
int godziny, suma;
int pom;
float podatek;
switch (opcja)
{
case 1:
case WYNAGRODZENIE35:
{
printf("Podaj ilosc przepracowanych godzin w tygodniu: ");
scanf("%d", &godziny);
if (godziny > 40)
{
suma = 40 * WYNAGRODZENIE35;
godziny -= 40;
suma += godziny * WYNAGRODZENIE35 * 1.5;
}
else suma = godziny * WYNAGRODZENIE35;
if (suma > 0 && suma <= 1200)
podatek = suma * PODATEK15;
else if (suma > 1200 && suma <= 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
}
else if (suma > 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
pom -= 600;
podatek += pom * PODATEK25;
}
printf("Wynagrodzenie brutto: %d\nPodatek: %.2f\nWynagrodzenie netto: %.2f\n", suma, podatek, suma - podatek);
break;
}
case 2:
case WYNAGRODZENIE37:
{
printf("Podaj ilosc przepracowanych godzin w tygodniu: ");
scanf("%d", &godziny);
if (godziny > 40)
{
suma = 40 * WYNAGRODZENIE37;
godziny -= 40;
suma += godziny * WYNAGRODZENIE37 * 1.5;
}
else suma = godziny * WYNAGRODZENIE37;
if (suma > 0 && suma <= 1200)
podatek = suma * PODATEK15;
else if (suma > 1200 && suma <= 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
}
else if (suma > 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
pom -= 600;
podatek += pom * PODATEK25;
}
printf("Wynagrodzenie brutto: %d\nPodatek: %.2f\nWynagrodzenie netto: %.2f\n", suma, podatek, suma - podatek);
break;
}
case 3:
case WYNAGRODZENIE40:
{
printf("Podaj ilosc przepracowanych godzin w tygodniu: ");
scanf("%d", &godziny);
if (godziny > 40)
{
suma = 40 * WYNAGRODZENIE40;
godziny -= 40;
suma += godziny * WYNAGRODZENIE40 * 1.5;
}
else suma = godziny * WYNAGRODZENIE40;
if (suma > 0 && suma <= 1200)
podatek = suma * PODATEK15;
else if (suma > 1200 && suma <= 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
}
else if (suma > 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
pom -= 600;
podatek += pom * PODATEK25;
}
printf("Wynagrodzenie brutto: %d\nPodatek: %.2f\nWynagrodzenie netto: %.2f\n", suma, podatek, suma - podatek);
break;
}
case 4:
case WYNAGRODZENIE45:
{
printf("Podaj ilosc przepracowanych godzin w tygodniu: ");
scanf("%d", &godziny);
if (godziny > 40)
{
suma = 40 * WYNAGRODZENIE45;
godziny -= 40;
suma += godziny * WYNAGRODZENIE45 * 1.5;
}
else suma = godziny * WYNAGRODZENIE45;
if (suma > 0 && suma <= 1200)
podatek = suma * PODATEK15;
else if (suma > 1200 && suma <= 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
}
else if (suma > 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
pom -= 1200;
podatek += 600 * PODATEK20;
pom -= 600;
podatek += pom * PODATEK25;
}
printf("Wynagrodzenie brutto: %d\nPodatek: %.2f\nWynagrodzenie netto: %.2f\n", suma, podatek, suma - podatek);
break;
}
case 5:
{
printf("Koniec!\n");
exit(0);
}
default: break;
}
menu();
}
return 0;
}
void menu(void)
{
printf("Podaj liczbe odpowiadajaca zadanej stawce wynagrodzenia lub opcji\n");
printf("1) 35 zl/godz. 2) 37 zl/godz\n");
printf("3) 40 zl/godz. 4) 45 zl/godz\n");
printf("5) wyjscie\n");
}
|
the_stack_data/50137483.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from evoapprox8b dataset. Note that a new version of library was already published.
***/
#include <stdint.h>
#include <stdlib.h>
/// Approximate function mul8_207
/// Library = EvoApprox8b
/// Circuit = mul8_207
/// Area (180) = 5344
/// Delay (180) = 2.300
/// Power (180) = 1836.00
/// Area (45) = 404
/// Delay (45) = 0.880
/// Power (45) = 154.70
/// Nodes = 117
/// HD = 384844
/// MAE = 575.91360
/// MSE = 643073.83203
/// MRE = 8.15 %
/// WCE = 2886
/// WCRE = 700 %
/// EP = 99.1 %
uint16_t mul8_207(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n0 = (a >> 0) & 0x1;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n16 = (b >> 0) & 0x1;
uint8_t n18 = (b >> 1) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n35;
uint8_t n37;
uint8_t n40;
uint8_t n41;
uint8_t n42;
uint8_t n45;
uint8_t n46;
uint8_t n49;
uint8_t n51;
uint8_t n53;
uint8_t n54;
uint8_t n55;
uint8_t n57;
uint8_t n61;
uint8_t n64;
uint8_t n65;
uint8_t n66;
uint8_t n67;
uint8_t n68;
uint8_t n69;
uint8_t n73;
uint8_t n76;
uint8_t n82;
uint8_t n87;
uint8_t n91;
uint8_t n118;
uint8_t n120;
uint8_t n126;
uint8_t n137;
uint8_t n157;
uint8_t n167;
uint8_t n190;
uint8_t n201;
uint8_t n203;
uint8_t n258;
uint8_t n261;
uint8_t n277;
uint8_t n297;
uint8_t n301;
uint8_t n306;
uint8_t n325;
uint8_t n382;
uint8_t n386;
uint8_t n409;
uint8_t n420;
uint8_t n460;
uint8_t n476;
uint8_t n481;
uint8_t n482;
uint8_t n484;
uint8_t n491;
uint8_t n532;
uint8_t n564;
uint8_t n580;
uint8_t n595;
uint8_t n608;
uint8_t n675;
uint8_t n682;
uint8_t n698;
uint8_t n712;
uint8_t n728;
uint8_t n802;
uint8_t n816;
uint8_t n817;
uint8_t n832;
uint8_t n846;
uint8_t n854;
uint8_t n891;
uint8_t n906;
uint8_t n920;
uint8_t n921;
uint8_t n934;
uint8_t n950;
uint8_t n965;
uint8_t n982;
uint8_t n1033;
uint8_t n1054;
uint8_t n1069;
uint8_t n1107;
uint8_t n1142;
uint8_t n1143;
uint8_t n1172;
uint8_t n1186;
uint8_t n1187;
uint8_t n1202;
uint8_t n1203;
uint8_t n1216;
uint8_t n1232;
uint8_t n1307;
uint8_t n1321;
uint8_t n1334;
uint8_t n1335;
uint8_t n1350;
uint8_t n1351;
uint8_t n1424;
uint8_t n1425;
uint8_t n1438;
uint8_t n1439;
uint8_t n1454;
uint8_t n1455;
uint8_t n1468;
uint8_t n1482;
uint8_t n1483;
uint8_t n1572;
uint8_t n1586;
uint8_t n1587;
uint8_t n1602;
uint8_t n1603;
uint8_t n1616;
uint8_t n1632;
uint8_t n1646;
uint8_t n1660;
uint8_t n1678;
uint8_t n1706;
uint8_t n1712;
uint8_t n1720;
uint8_t n1734;
uint8_t n1750;
uint8_t n1764;
uint8_t n1765;
uint8_t n1780;
uint8_t n1781;
uint8_t n1794;
uint8_t n1795;
uint8_t n1808;
uint8_t n1809;
uint8_t n1824;
uint8_t n1838;
uint8_t n1869;
uint8_t n1882;
uint8_t n1898;
uint8_t n1912;
uint8_t n1928;
uint8_t n1942;
uint8_t n1943;
uint8_t n1956;
uint8_t n1957;
uint8_t n1972;
uint8_t n1973;
uint8_t n1986;
uint8_t n1987;
uint8_t n2016;
n32 = n18 & n12;
n35 = (n14 & n16) | (n16 & n26) | (n14 & n26);
n37 = n18;
n40 = ~(n12 ^ n12);
n41 = ~(n12 ^ n12);
n42 = ~(n6 & n28);
n45 = (n30 & n4) | (~n30 & n18);
n46 = n45 & n8;
n49 = ~((n18 & n14) | n32);
n51 = (n41 & n0) | (n0 & n2) | (n41 & n2);
n53 = ~((n12 | n51) & n30);
n54 = n41 | n28;
n55 = n41 | n28;
n57 = n2 | n54;
n61 = ~(n12 & n28 & n14);
n64 = n41;
n65 = n41;
n66 = n65;
n67 = n65;
n68 = ~(n65 | n66);
n69 = ~(n65 | n66);
n73 = n65 & n46;
n76 = ~(n57 | n4);
n82 = ~(n6 | n4 | n14);
n87 = n30 | n24;
n91 = ~(n87 | n28 | n35);
n118 = n55 & n20;
n120 = n12 & n118;
n126 = ~((n30 | n64) & n91);
n137 = ~n57;
n157 = ~((n53 & n82) | n91);
n167 = ~(n67 & n82);
n190 = ~((n69 | n76) & n30);
n201 = ~(n137 | n190);
n203 = (n167 & n40) | (~n167 & n2);
n258 = n203 & n28;
n261 = ~n61;
n277 = ~((n37 | n126) & n51);
n297 = ~n49;
n301 = n69;
n306 = n22 | n20;
n325 = n301 | n42;
n382 = ~n277;
n386 = n6 | n8;
n409 = n297;
n420 = n26 & n386;
n460 = n10 & n306;
n476 = n12 & n22;
n481 = n41;
n482 = ~n53;
n484 = ~n49;
n491 = n14 & n22;
n532 = ~n325;
n564 = n8 & n24;
n580 = n10 & n24;
n595 = n12 & n24;
n608 = n14 & n24;
n675 = ~n409;
n682 = n8 & n306;
n698 = n10 & n26;
n712 = n12 & n26;
n728 = n14 & n26;
n802 = n8 & n28;
n816 = n10 & n28;
n817 = n10 & n28;
n832 = n12 & n28;
n846 = n14 & n28;
n854 = n595;
n891 = n4 & n30;
n906 = n6 & n30;
n920 = n8 & n30;
n921 = n8 & n30;
n934 = n10 & n30;
n950 = n12 & n30;
n965 = n14 & n30;
n982 = ~(n675 & n54);
n1033 = n201;
n1054 = n120;
n1069 = n481 & n682;
n1107 = n491;
n1142 = n157;
n1143 = n157;
n1172 = n460 | n564;
n1186 = n476 ^ n580;
n1187 = n476 & n580;
n1202 = (n1107 ^ n854) ^ n698;
n1203 = (n1107 & n854) | (n854 & n698) | (n1107 & n698);
n1216 = n608 & n712;
n1232 = n608 ^ n712;
n1307 = n157 | n1054;
n1321 = n1033;
n1334 = (n817 ^ n1069) ^ n1172;
n1335 = (n817 & n1069) | (n1069 & n1172) | (n817 & n1172);
n1350 = (n891 ^ n420) ^ n1186;
n1351 = (n891 & n420) | (n420 & n1186) | (n891 & n1186);
n1424 = (n1187 ^ n802) ^ n906;
n1425 = (n1187 & n802) | (n802 & n906) | (n1187 & n906);
n1438 = (n1203 ^ n816) ^ n920;
n1439 = (n1203 & n816) | (n816 & n920) | (n1203 & n920);
n1454 = (n1216 ^ n832) ^ n934;
n1455 = (n1216 & n832) | (n832 & n934) | (n1216 & n934);
n1468 = n261 & n482;
n1482 = n846 ^ n950;
n1483 = n846 & n950;
n1572 = n1334;
n1586 = n1350 ^ n1335;
n1587 = n1350 & n1335;
n1602 = (n1202 ^ n1216) ^ n1424;
n1603 = (n1202 & n1216) | (n1216 & n1424) | (n1202 & n1424);
n1616 = n1232 & n1438;
n1632 = n1232 | n1438;
n1646 = n728 & n1454;
n1660 = n728 ^ n1454;
n1678 = n1483;
n1706 = (n921 ^ n68) ^ n1321;
n1712 = n921 | n982;
n1720 = (n1307 & n190) | (~n1307 & n1425);
n1734 = n1572 | n484;
n1750 = n1586 | n532;
n1764 = (n1602 ^ n1587) ^ n1351;
n1765 = (n1602 & n1587) | (n1587 & n1351) | (n1602 & n1351);
n1780 = (n1632 ^ n1603) ^ n1425;
n1781 = (n1632 & n1603) | (n1603 & n1425) | (n1632 & n1425);
n1794 = (n1660 ^ n1616) ^ n1439;
n1795 = (n1660 & n1616) | (n1616 & n1439) | (n1660 & n1439);
n1808 = (n1482 ^ n1646) ^ n1455;
n1809 = (n1482 & n1646) | (n1646 & n1455) | (n1482 & n1455);
n1824 = n41 & n1468;
n1838 = n965 ^ n1678;
n1869 = n1706 | n382;
n1882 = n1720;
n1898 = n1734 | n258;
n1912 = n1750;
n1928 = n1764;
n1942 = n1780 ^ n1765;
n1943 = n1780 & n1765;
n1956 = (n1794 ^ n1781) ^ n1943;
n1957 = (n1794 & n1781) | (n1781 & n1943) | (n1794 & n1943);
n1972 = (n1808 ^ n1795) ^ n1957;
n1973 = (n1808 & n1795) | (n1795 & n1957) | (n1808 & n1957);
n1986 = (n1838 ^ n1809) ^ n1973;
n1987 = (n1838 & n1809) | (n1809 & n1973) | (n1838 & n1973);
n2016 = n1824 | n1987;
c |= (n73 & 0x1) << 0;
c |= (n1142 & 0x1) << 1;
c |= (n1603 & 0x1) << 2;
c |= (n1712 & 0x1) << 3;
c |= (n1869 & 0x1) << 4;
c |= (n1882 & 0x1) << 5;
c |= (n1143 & 0x1) << 6;
c |= (n1882 & 0x1) << 7;
c |= (n1898 & 0x1) << 8;
c |= (n1912 & 0x1) << 9;
c |= (n1928 & 0x1) << 10;
c |= (n1942 & 0x1) << 11;
c |= (n1956 & 0x1) << 12;
c |= (n1972 & 0x1) << 13;
c |= (n1986 & 0x1) << 14;
c |= (n2016 & 0x1) << 15;
return c;
}
|
the_stack_data/115765543.c | #ifdef _HAS_GETRESUID
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#ifdef _HAS_GETRESUID
static uid_t getsuid(void)
{
uid_t dummy, suid;
getresuid(&dummy, &dummy, &suid);
/* No errors checks... see manpages */
return suid;
}
static gid_t getsgid(void)
{
gid_t dummy, sgid;
getresgid(&dummy, &dummy, &sgid);
/* No errors checks... see manpages */
return sgid;
}
#endif
int main(int argc, char *argv[])
{
int ret;
printf("real user/group ID: %d/%d\n", getuid(), getgid());
printf("effective user/group ID: %d/%d\n", geteuid(), getegid());
#ifdef _HAS_GETRESUID
printf("saved user/group ID: %d/%d\n", getsuid(), getsgid());
#endif
if (argc > 1) {
ret = open(argv[1], O_RDONLY);
printf("file %s can%s be read\n",
argv[1], ret < 0 ? "'t" : "");
}
return 0;
}
|
the_stack_data/2328.c | #include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <math.h>
#include <time.h>
#define q 11 /* for 2^11 points */
#define N (1<<q) /* N-point FFT, iFFT */
#ifndef PI
# define PI 3.14159265358979323846264338327950288
#endif
typedef float real;
typedef struct{real Re; real Im;} complex;
void fft( complex *v, int n, complex *tmp );
void* calcThread(void *par);
void* readThread(void* par);
void manager(int sig);
int values[N], sigRead, sigCalc;
sem_t dataLock;
sem_t readyFlag;
int main(int argc, char **argv){
char *app_name = argv[0];
char *dev_name = "/dev/ppgmod_dev";
int fd = -1;
sigRead = 1;
sigCalc = 1;
pthread_t tRead, tCalc;
setbuf(stdout, 0);
if ((fd = open(dev_name, O_RDWR)) < 0) {
fprintf(stderr, "%s: unable to open %s: %s\n", app_name, dev_name, strerror(errno));
return( 1 );
}
printf("To terminate the app type ctrl-C\n");
//Uses function manager to handle SIGINT signal
signal(SIGINT, manager);
/* Uses two semaphores:
* dataLock to avoid changes on data while computing fft
* readyFlag to indicates that 2048 samples are ready */
sem_init(&dataLock, 0, 1);
sem_init(&readyFlag, 0, 0);
pthread_create(&tRead, NULL, readThread, (void*)&fd);
pthread_create(&tCalc, NULL, calcThread, NULL);
pause();
pthread_join(tRead, NULL);
pthread_join(tCalc, NULL);
sem_destroy(&dataLock);
sem_destroy(&readyFlag);
close( fd );
}
void manager(int sig){
sigRead = 0;
sigCalc = 0;
}
void* readThread(void* par){
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 20000000; //Set sleeptime to 20ms between reads
int fd = *((int*)par);
int counter = 0;
int val = 0;
while (sigRead){
sem_wait(&dataLock);
val = read(fd, (char*)&values[counter], sizeof(int));
sem_post(&dataLock);
counter++;
if (counter == N-1){
counter = 0;
sem_post(&readyFlag);
}
nanosleep(&ts, &ts);
}
sem_post(&readyFlag);
return NULL;
}
void fft( complex *v, int n, complex *tmp ){
if (n > 1){ /* otherwise, do nothing and return */
int k,m;
complex z, w, *vo, *ve;
ve = tmp;
vo = tmp+n/2;
for(k = 0; k < n/2; k++) {
ve[k] = v[2*k];
vo[k] = v[2*k+1];
}
fft(ve, n/2, v); /* FFT on even-indexed elements of v[] */
fft(vo, n/2, v); /* FFT on odd-indexed elements of v[] */
for(m = 0; m < n/2; m++) {
w.Re = cos(2*PI*m/(double)n);
w.Im = -sin(2*PI*m/(double)n);
z.Re = w.Re*vo[m].Re - w.Im*vo[m].Im; /* Re(w*vo[m]) */
z.Im = w.Re*vo[m].Im + w.Im*vo[m].Re; /* Im(w*vo[m]) */
v[ m ].Re = ve[m].Re + z.Re;
v[ m ].Im = ve[m].Im + z.Im;
v[m+n/2].Re = ve[m].Re - z.Re;
v[m+n/2].Im = ve[m].Im - z.Im;
}
}
return;
}
void* calcThread(void *par){
complex v[N], scratch[N];
float abs[N];
int k, m, i;
int minIdx, maxIdx;
sem_wait(&readyFlag); //Waits until 2048 samples are ready
while(sigCalc) {
sem_wait(&dataLock); //To avoid changes on data while copying, acquire the lock
// Initialize the complex array for FFT computation
for(k=0; k<N; k++) {
v[k].Re = values[k];
v[k].Im = 0;
}
sem_post(&dataLock);
// FFT computation
fft( v, N, scratch );
// PSD computation
for(k=0; k<N; k++) {
abs[k] = (50.0/2048)*((v[k].Re*v[k].Re)+(v[k].Im*v[k].Im));
}
minIdx = (0.5*2048)/50; // position in the PSD of the spectral line corresponding to 30 bpm
maxIdx = 3*2048/50; // position in the PSD of the spectral line corresponding to 180 bpm
// Find the peak in the PSD from 30 bpm to 180 bpm
m = minIdx;
for(k = minIdx; k < maxIdx; k++) {
if (abs[k] > abs[m])
m = k;
}
// Print the heart beat in bpm
printf( "\n\n\n%d bpm\n\n\n", (m)*60*50/2048 );
sem_wait(&readyFlag);
};
return NULL;
}
|
the_stack_data/70450700.c | /*!
* @file main.c
* @brief 11. Arreglos Multidimensionales - 11. Arreglos de N dimensiones
* @author Javier Balloffet <[email protected]>
* @date Sep 7, 2018
*/
#include <stdio.h>
int main() {
// Declaro un arreglo multidimensional (3D array) de enteros (int) de 2x3x4 elementos.
int array3D[2][3][4];
int i, j, k;
// Cargo el arreglo.
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 4; k++) {
printf("Ingrese un numero: ");
scanf("%d", &array3D[i][j][k]);
}
}
}
// Imprimo el contenido del arreglo.
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 4; k++) {
printf("Valor de array3D[%d][%d][%d] = %d\n", i, j, k, array3D[i][j][k]);
}
}
}
return 0;
}
|
the_stack_data/57950207.c | // WARNING: kmalloc bug in kmsan_get_shadow_address
// https://syzkaller.appspot.com/bug?id=d19f5183fc28bf7be8c8d1deb1b1966a0f0a9113
// status:invalid
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <stdint.h>
#include <string.h>
#include <sys/syscall.h>
#include <unistd.h>
uint64_t r[1] = {0xffffffffffffffff};
void loop()
{
long res = 0;
res = syscall(__NR_socket, 0xa, 1, 0);
if (res != -1)
r[0] = res;
memcpy((void*)0x200002c0,
"\x29\x1e\xe1\x31\x1f\x16\xf4\x77\x38\xc2\x5f\xdb\xff\xff\xff\xff\x64"
"\xe0\xbb\x22\xdf\xaf\x27\x3a\x10\x70\x15\x6d\x9c\x57\xdc\x2e\xf3\x34"
"\x2d\x77\x6b\x8c\xbe\x14\x82\x6d\xbe\x56\xf6\x12\x48\xc4\x09\x09\xe5"
"\x9a\x9e\xf6\xc3\xaf\xcd\x07\xa7\x71\xee",
61);
syscall(__NR_ioctl, r[0], 0x4000008912, 0x200002c0);
syscall(__NR_mmap, 0x20ffa000, 0x3000, 0x1000000, 0x2010, -1, 0);
}
int main()
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
loop();
return 0;
}
|
the_stack_data/792168.c | /*
* FreeRTOS V202111.00
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* https://www.FreeRTOS.org
* https://github.com/FreeRTOS
*
*/
/**
* @brief Mem fault handler.
*/
void MemManage_Handler( void ) __attribute__ (( naked ));
/*-----------------------------------------------------------*/
void MemManage_Handler( void )
{
__asm volatile
(
" tst lr, #4 \n"
" ite eq \n"
" mrseq r0, msp \n"
" mrsne r0, psp \n"
" ldr r1, handler_address_const \n"
" bx r1 \n"
" \n"
" handler_address_const: .word vHandleMemoryFault \n"
);
}
/*-----------------------------------------------------------*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.