file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/6388618.c
|
#include <stdio.h>
#include <string.h>
void display_message(char * message)
{
printf("%s", message);
}
// declare functions before using them
char isCharInteger(char c);
char charToInteger(char c);
char isStringInteger(char * c);
char stringToInteger(char * c);
char stringLength(char * c);
int main(int argc, char *argv[]) {
// first, check that the number of parameters is correct
if(argc!=3)
{
display_message("Wrong usage, 2 parameters expected: ./sum param1 param2");
return -1;
}
// now, check that parameters represent integer values
// declare, implement, and use function isCharInteger
int i;
for(i=1; i<argc;i++)
{
char * arg = argv[i];
if(!isStringInteger(arg))
{
display_message("Wrong usage, parameters param1 and param2 should be integers when executing ./sum param1 param2\n");
return -2;
}
}
/* arguments have been checked, we can proceed to the sum:
1 - convert string into an integer value
2 - sum obtained values
*/
char first_integer = stringToInteger(argv[1]);
char second_integer = stringToInteger(argv[2]);
printf("Result: %d\n", first_integer+second_integer);
return 0;
}
char isCharInteger(char c)
{
switch (c) {
case '0':
return 1;
case '1':
return 1;
case '2':
return 1;
case '3':
return 1;
case '4':
return 1;
case '5':
return 1;
case '6':
return 1;
case '7':
return 1;
case '8':
return 1;
case '9':
return 1;
}
return 0;
}
char charToInteger(char c)
{
switch (c) {
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;
}
return -1;
}
char isStringInteger(char * s)
{
int j=0;
if(s[j]=='-')
j=1;
while(s[j]!='\0')
{
char c = s[j];
if(isCharInteger(c)==0)
{
return 0;
}
j++;
}
return 1;
}
char stringToInteger(char * c)
{
char sign = 1;
char result=0;
char i;
if(c[0]=='-')
{
sign = -1;
}
char length = stringLength(c);
for(i=length-1; i>=0; i--)
{
if(isCharInteger(c[i]))
{
char current_integer = charToInteger(c[i]);
char factor = 1;
int j;
for(j=0;j<length-i-1;j++)
{
factor = factor*10;
}
current_integer = current_integer * factor;
result = result+current_integer;
}
}
return sign*result;
}
char stringLength(char * c)
{
char j=0;
while(c[j]!='\0')
{
j++;
}
return j;
}
|
the_stack_data/150141527.c
|
#include <stdio.h>
int main()
{
printf("C programming is apowerful all-purpose language.\n");
printf("It is an excellent program to learn to code.\n");
return 0;
}
|
the_stack_data/23574954.c
|
const unsigned char backgroundpalette_bin[] = {
0x00,0x2a,0x3f,0x03,0x02,0x38,0x05,0x0a,0x0c,0x2f,0x01,0x04,0x06,0x0b,0x0f};
const unsigned char backgroundtilemap_bin[] = {
0x00,0x00,0x01,0x00,0x02,0x00,0x03,0x00,0x04,0x00,0x05,0x00,0x06,0x00,0x07,0x00,
0x08,0x00,0x09,0x00,0x0a,0x00,0x0b,0x00,0x0c,0x00,0x0d,0x00,0x06,0x00,0x07,0x00,
0x08,0x00,0x09,0x00,0x02,0x00,0x03,0x00,0x04,0x00,0x05,0x00,0x06,0x00,0x07,0x00,
0x08,0x00,0x09,0x00,0x02,0x00,0x03,0x00,0x04,0x00,0x05,0x00,0x09,0x00,0x00,0x00,
0x09,0x00,0x0e,0x00,0x09,0x00,0x00,0x00,0x0f,0x00,0x01,0x00,0x02,0x00,0x03,0x00,
0x04,0x00,0x05,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x02,0x00,0x03,0x00,
0x04,0x00,0x05,0x00,0x09,0x00,0x00,0x00,0x0f,0x00,0x01,0x00,0x02,0x00,0x03,0x00,
0x04,0x00,0x05,0x00,0x09,0x00,0x00,0x00,0x0f,0x00,0x01,0x00,0x14,0x00,0x09,0x00,
0x15,0x00,0x16,0x00,0x14,0x00,0x09,0x00,0x17,0x00,0x0e,0x00,0x09,0x00,0x00,0x00,
0x0f,0x00,0x01,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x09,0x00,0x00,0x00,
0x0f,0x00,0x01,0x00,0x14,0x00,0x09,0x00,0x17,0x00,0x0e,0x00,0x09,0x00,0x00,0x00,
0x0f,0x00,0x01,0x00,0x14,0x00,0x09,0x00,0x17,0x00,0x0e,0x00,0x1c,0x00,0x15,0x00,
0x16,0x00,0x16,0x00,0x1c,0x00,0x15,0x00,0x1d,0x00,0x16,0x00,0x14,0x00,0x09,0x00,
0x17,0x00,0x0e,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x14,0x00,0x09,0x00,
0x17,0x00,0x0e,0x00,0x1c,0x00,0x15,0x00,0x1d,0x00,0x16,0x00,0x14,0x00,0x09,0x00,
0x17,0x00,0x0e,0x00,0x1c,0x00,0x15,0x00,0x1d,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x1c,0x00,0x15,0x00,
0x1d,0x00,0x16,0x00,0x0a,0x00,0x0b,0x00,0x0c,0x00,0x0d,0x00,0x1c,0x00,0x15,0x00,
0x1d,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x1c,0x00,0x15,0x00,
0x1d,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x16,0x00,0x16,0x00,
0x22,0x00,0x23,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x16,0x00,0x24,0x00,
0x25,0x00,0x26,0x00,0x27,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x16,0x00,0x28,0x00,
0x29,0x00,0x2a,0x00,0x2b,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x0a,0x00,0x0b,0x00,0x0c,0x00,0x0d,0x00,0x16,0x00,0x2c,0x00,
0x2d,0x00,0x2e,0x00,0x2f,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x30,0x00,0x31,0x00,
0x32,0x00,0x33,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x16,0x00,0x34,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x35,0x00,0x36,0x00,
0x37,0x00,0x38,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x39,0x00,0x3a,0x00,
0x3b,0x00,0x3c,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x3d,0x00,0x3e,0x00,
0x3f,0x00,0x40,0x00,0x40,0x02,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x0a,0x00,0x0b,0x00,0x0c,0x00,0x0d,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x41,0x00,0x42,0x00,0x43,0x00,0x44,0x00,0x45,0x00,0x46,0x00,
0x47,0x00,0x44,0x00,0x48,0x00,0x49,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,
0x4c,0x00,0x4d,0x00,0x4e,0x00,0x4f,0x00,0x40,0x02,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x16,0x00,0x16,0x00,
0x41,0x00,0x42,0x00,0x43,0x00,0x44,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,
0x50,0x00,0x51,0x00,0x50,0x00,0x54,0x00,0x48,0x00,0x49,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,0x16,0x00,
0x16,0x00,0x16,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x16,0x00,0x16,0x00,
0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,
0x55,0x00,0x56,0x00,0x55,0x00,0x56,0x00,0x4e,0x00,0x4f,0x00,0x40,0x02,0x16,0x00,
0x16,0x00,0x16,0x00,0x43,0x00,0x44,0x00,0x43,0x00,0x44,0x00,0x43,0x00,0x44,0x00,
0x43,0x00,0x44,0x00,0x43,0x00,0x44,0x00,0x43,0x00,0x44,0x00,0x43,0x00,0x44,0x00,
0x43,0x00,0x44,0x00,0x50,0x00,0x51,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,
0x52,0x00,0x53,0x00,0x50,0x00,0x51,0x00,0x50,0x00,0x54,0x00,0x48,0x00,0x49,0x00,
0x16,0x00,0x16,0x00,0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,
0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,0x4c,0x00,0x4d,0x00,
0x4c,0x00,0x4d,0x00,0x55,0x00,0x56,0x00,0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,
0x57,0x00,0x58,0x00,0x55,0x00,0x56,0x00,0x55,0x00,0x56,0x00,0x4e,0x00,0x4f,0x00,
0x16,0x00,0x16,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x50,0x00,0x51,0x00,
0x52,0x00,0x53,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x52,0x00,0x53,0x00,
0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,
0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x50,0x00,0x51,0x00,0x52,0x00,0x53,0x00,
0x16,0x00,0x16,0x00,0x59,0x00,0x5a,0x00,0x57,0x00,0x58,0x00,0x55,0x00,0x56,0x00,
0x57,0x00,0x58,0x00,0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,0x57,0x00,0x58,0x00,
0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,
0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,0x55,0x00,0x56,0x00,0x57,0x00,0x58,0x00,
0x5b,0x00,0x5c,0x00,0x5d,0x00,0x5d,0x00,0x5d,0x00,0x5e,0x00,0x5f,0x00,0x60,0x00,
0x61,0x00,0x62,0x00,0x5d,0x00,0x5d,0x00,0x63,0x00,0x64,0x00,0x62,0x00,0x65,0x00,
0x61,0x00,0x66,0x00,0x63,0x00,0x67,0x00,0x68,0x00,0x69,0x00,0x6a,0x00,0x6b,0x00,
0x6c,0x00,0x63,0x00,0x64,0x00,0x65,0x00,0x6d,0x00,0x61,0x00,0x5c,0x02,0x5b,0x00,
0x5b,0x00,0x6e,0x00,0x6f,0x00,0x6f,0x02,0x6f,0x00,0x6f,0x02,0x70,0x00,0x70,0x02,
0x5b,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x71,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,
0x5b,0x00,0x5b,0x00,0x71,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,
0x5b,0x00,0x71,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x6e,0x02,0x5b,0x00,
0x5b,0x00,0x6e,0x00,0x72,0x00,0x72,0x02,0x72,0x00,0x72,0x02,0x73,0x00,0x73,0x02,
0x5b,0x00,0x5b,0x00,0x5b,0x00,0x5b,0x00,0x71,0x00,0x5b,0x00,0x5b,0x00,0x5f,0x00,
0x74,0x00,0x5b,0x00,0x71,0x00,0x5f,0x00,0x5f,0x00,0x5f,0x00,0x5f,0x00,0x5f,0x00,
0x5f,0x00,0x71,0x00,0x5b,0x00,0x75,0x00,0x76,0x00,0x75,0x00,0x6e,0x02,0x5b,0x00,
0x5b,0x00,0x5c,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,
0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x63,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,
0x5d,0x04,0x5d,0x04,0x63,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,
0x5d,0x04,0x63,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5d,0x04,0x5c,0x06,0x5b,0x00};
const unsigned char backgroundtiles_psgcompr[] = {
0x77,0x00,0xe1,0xe0,0x33,0x0e,0x1e,0xbd,0xfc,0xfc,0xff,0x00,0xe1,0x1f,0xff,0xff,
0x77,0x31,0x33,0x37,0x3f,0x00,0xe1,0x77,0x11,0x08,0x08,0x19,0xbb,0xff,0xff,0x00,
0xe1,0xf2,0xf1,0x71,0x6f,0xc4,0x80,0x80,0xc0,0x00,0xa1,0x3c,0x00,0x0f,0x82,0x20,
0xa0,0x00,0xe1,0xff,0x3f,0x0f,0x1e,0x31,0x11,0x0b,0x07,0x00,0xe1,0x3f,0x07,0x07,
0x83,0x81,0x80,0xc0,0xe0,0x00,0xe1,0xf7,0xf1,0xf0,0xf0,0xe0,0xe0,0x78,0x37,0x00,
0xe1,0xff,0xff,0x7e,0x18,0x71,0x41,0x91,0x1f,0x00,0x51,0x26,0x0f,0xfe,0xbb,0xbb,
0xbf,0xbf,0x11,0xa6,0xf0,0x0b,0x02,0x02,0x02,0x0a,0xf0,0x28,0x22,0x62,0x62,0x6a,
0x11,0xa6,0xf0,0xfc,0xf8,0xf8,0xf9,0xf9,0x38,0x48,0x18,0x18,0x40,0xc0,0xc0,0x11,
0xa6,0x0f,0xdc,0xf8,0xf8,0xfc,0xfc,0x07,0x00,0x83,0x83,0x85,0x85,0x01,0x11,0x7a,
0xff,0xdf,0xef,0xe3,0xf0,0xf0,0xc0,0xc0,0x11,0x01,0xe1,0x10,0x10,0x39,0xe5,0xe2,
0x6c,0x38,0xf8,0x00,0x26,0x8f,0xef,0xed,0xed,0xed,0x11,0xb6,0x7c,0x03,0x0a,0x01,
0x01,0x6a,0x63,0xe3,0xa3,0xb3,0xb3,0xb1,0xb1,0x11,0xa6,0xf8,0xfd,0xff,0xff,0xff,
0x0f,0x70,0xe0,0xe0,0xe0,0xe0,0x11,0xa6,0x0f,0xd6,0x9e,0x9e,0x9e,0xde,0x0f,0x40,
0x02,0x02,0x02,0x42,0x11,0xaa,0x83,0xff,0xfd,0xf9,0xf0,0xf0,0xfe,0x20,0xe0,0x70,
0x70,0x7e,0x7f,0x67,0x1e,0x80,0x00,0x00,0x00,0x98,0x12,0xaa,0x1f,0xff,0xfc,0xf8,
0xfe,0x20,0xf8,0xe7,0xc3,0x80,0xf8,0x00,0x18,0x3c,0x7f,0x12,0x44,0xea,0x37,0x63,
0xc3,0x81,0x81,0xf1,0xff,0xff,0x20,0xfe,0xfe,0xfe,0x00,0x01,0x12,0x26,0x0f,0xf9,
0xfb,0xfb,0xfb,0xfb,0x11,0xb6,0xe3,0x00,0x02,0x02,0x02,0xe0,0xe0,0x68,0x6a,0xca,
0xca,0xc0,0xc0,0x11,0xa6,0xf8,0xef,0xcf,0xcf,0xcf,0xe0,0xe0,0x60,0x60,0x40,0x41,
0x41,0x11,0xa6,0x0f,0xe0,0xf2,0xf2,0xf0,0xf0,0x38,0x80,0x00,0x00,0x84,0x84,0x84,
0x11,0x6a,0x07,0x00,0x07,0x0f,0x0f,0x0f,0x0c,0x11,0x01,0xba,0xf0,0x7f,0xff,0xff,
0xff,0xff,0x7c,0x7c,0x7e,0x7e,0x9e,0x86,0x00,0x00,0x41,0x0f,0x03,0x03,0x01,0x01,
0x12,0x26,0xf0,0xfd,0xf7,0xf7,0xb3,0xb3,0x11,0xa6,0x38,0x05,0x04,0x04,0x07,0x07,
0x07,0x1f,0xa0,0xc4,0xc4,0xa4,0x11,0xa6,0xf0,0xe7,0xf6,0xf6,0xf6,0xf6,0x0f,0x10,
0x01,0x41,0x41,0x41,0x11,0xb6,0xf0,0xf0,0xf8,0xf8,0xf8,0xf8,0xc4,0xc4,0xc0,0xc0,
0xc9,0xc9,0xcb,0xc3,0x11,0x88,0x0f,0xf8,0xff,0xff,0xff,0xfc,0x00,0x8a,0xe0,0xff,
0x3f,0x1f,0x1f,0x07,0x13,0x00,0xfe,0x00,0x10,0x88,0xfe,0xff,0xee,0x00,0xea,0xc4,
0x80,0x80,0x81,0x83,0xb3,0x03,0xc1,0xfe,0x00,0x20,0x20,0xf8,0x83,0x07,0x03,0xe0,
0x00,0x01,0x03,0x03,0x03,0x01,0xea,0x3b,0x35,0x35,0xb2,0x77,0xbf,0x9e,0xa0,0xfe,
0x00,0x20,0x20,0xe4,0xb7,0xff,0x9f,0x86,0x20,0x1e,0x3a,0x34,0x34,0x80,0x88,0x0d,
0x7f,0xff,0xbf,0x3f,0x3f,0xff,0x20,0xf3,0xff,0xff,0xc8,0xf5,0xf5,0xe5,0xee,0xe7,
0xf0,0xfc,0xff,0x20,0x1f,0xf4,0xf4,0xe4,0xfe,0x80,0x00,0x20,0xc0,0x18,0x30,0x70,
0x7a,0x50,0xb0,0xc0,0x00,0x18,0x35,0x75,0x7a,0x01,0x00,0x00,0x18,0x26,0xc5,0x85,
0x80,0xf9,0x00,0x05,0x05,0xee,0x49,0x32,0x0a,0x7d,0xa6,0x04,0x03,0xa4,0xb6,0x00,
0x01,0x80,0x83,0xcc,0x78,0x28,0x7c,0x66,0x47,0x47,0x6f,0x3c,0x00,0x48,0x30,0x03,
0x07,0xaa,0x51,0x1f,0x3f,0x5f,0x3f,0x7f,0x3f,0x2c,0x00,0x80,0x80,0xc0,0x80,0xc0,
0x20,0xd8,0x1f,0xff,0xff,0xff,0xfc,0x00,0x80,0xc0,0xe6,0xff,0xff,0xf8,0xf2,0xe8,
0xea,0xe9,0xe9,0xe0,0x00,0x04,0x05,0x04,0x06,0x06,0xe0,0x00,0x06,0x0d,0x0e,0x0f,
0x0f,0xa8,0x07,0x7f,0x3e,0x98,0xb3,0x07,0x0f,0x1f,0x00,0x3e,0x18,0x30,0x41,0xa3,
0xe5,0x07,0x0f,0x7f,0xa6,0x0f,0xff,0x68,0xd1,0xdc,0xe3,0x3f,0x00,0x07,0x0e,0x1f,
0x00,0x0f,0x1f,0x1c,0xa6,0x3f,0xff,0x5f,0x3f,0x7f,0x00,0x80,0x7f,0x00,0xc0,0xaa,
0xf2,0xff,0xfc,0xfe,0xfe,0xe8,0x00,0x01,0x02,0x01,0x02,0x41,0xf2,0xfc,0xfc,0xfc,
0x12,0xaa,0x1f,0x00,0xff,0xff,0xa0,0x91,0x00,0x0e,0x20,0x54,0xa8,0x84,0x21,0x1f,
0xff,0xf1,0x80,0x40,0x9f,0x0e,0x7f,0xbe,0x1c,0x01,0xff,0xb7,0x03,0x00,0x00,0x00,
0x30,0x02,0x01,0x95,0x09,0x10,0x00,0xff,0x87,0x01,0x00,0x94,0x08,0x10,0x00,0x1f,
0xff,0x00,0x78,0xfe,0xaa,0xfd,0xff,0x7f,0xfe,0x00,0x80,0x20,0xfe,0x7f,0x12,0xa6,
0x1f,0xff,0xe8,0xe6,0xf1,0x7f,0x00,0x06,0x3f,0x00,0x0e,0x06,0xaa,0x3f,0xff,0xfe,
0xfe,0x1f,0x00,0x02,0x02,0x01,0x41,0x3f,0xfc,0xfc,0x12,0xca,0x00,0x00,0x10,0x54,
0x4c,0x59,0x5b,0x7f,0x20,0x91,0x40,0x54,0x4d,0x5b,0x7b,0x20,0x07,0xff,0x7e,0x44,
0x44,0x4d,0xef,0x05,0x02,0x37,0x2b,0x8b,0x93,0x63,0xc4,0x1f,0x00,0x05,0x02,0x16,
0x00,0x00,0xa1,0xab,0x8b,0x9b,0xfb,0xf4,0xff,0xa7,0x96,0x88,0x88,0x98,0xf0,0xe3,
0x6a,0x7e,0x00,0x80,0x80,0x11,0x01,0xca,0xfe,0xfe,0xfc,0xfa,0xf6,0xec,0xe8,0xcc,
0x20,0xfa,0xee,0xdd,0xe0,0x00,0x02,0x06,0x0e,0x08,0x1d,0xee,0x93,0x93,0xdf,0xb3,
0x27,0x0f,0xfe,0xbb,0xf7,0x00,0x40,0xb7,0x93,0xdf,0xbf,0x67,0x9f,0xff,0xff,0x22,
0xfe,0xbb,0xef,0x88,0x01,0x77,0x38,0x0c,0x14,0x14,0x0d,0x9f,0x00,0x01,0x06,0x88,
0x70,0x79,0x7e,0x8e,0xd6,0xd6,0xcd,0x87,0x77,0x7e,0x7c,0x0e,0x86,0x86,0x8c,0x6a,
0x7f,0x00,0x80,0x11,0x01,0xcf,0xd1,0xd5,0xc9,0xf7,0xe6,0xec,0xc9,0xd1,0xd9,0xd5,
0xcb,0xf7,0xef,0xee,0xdd,0xd9,0x19,0x11,0x03,0x07,0x0f,0x0e,0x1d,0x19,0xca,0xc7,
0xff,0xc7,0xff,0x7f,0xe6,0xc3,0x19,0x58,0xff,0xc7,0xef,0xfe,0xe7,0x9b,0x22,0xfe,
0x83,0xcf,0x09,0x8d,0xca,0xe1,0xf3,0x79,0x19,0x04,0xc9,0xcd,0xea,0xe1,0xfb,0xfd,
0x7d,0x1e,0x88,0xcc,0xea,0xe0,0xf8,0xfc,0x7c,0x1e,0xaa,0xf0,0xff,0xfc,0xf8,0x88,
0x16,0xfe,0x00,0x16,0x20,0xfe,0x00,0x12,0xfa,0xcf,0xbf,0x27,0x47,0x1f,0x7e,0x7e,
0xff,0x39,0x7a,0xfe,0xfd,0xfd,0xff,0xe3,0xec,0x21,0x3f,0xf9,0xfa,0x12,0xba,0x19,
0xfb,0xff,0x1f,0xef,0xfe,0x7c,0x0c,0xe2,0x12,0x05,0x85,0x83,0xd7,0xef,0x21,0x07,
0x0f,0x03,0x03,0x01,0x81,0x41,0x1f,0xf0,0x1c,0xec,0xea,0x08,0x80,0x00,0x04,0x40,
0x04,0x0c,0x0e,0x20,0xf0,0xce,0xce,0xde,0xda,0x21,0x2f,0x00,0x00,0x00,0x12,0xea,
0x62,0x40,0x00,0x00,0x0c,0x1c,0x5e,0x77,0x20,0xe0,0x08,0x3c,0x75,0xff,0xff,0x21,
0x3f,0x00,0x00,0x12,0xea,0x00,0x80,0x00,0x04,0x40,0x04,0x0c,0x0e,0x20,0xf0,0xce,
0xce,0xde,0xda,0x21,0x2f,0x1b,0x00,0x00,0x42,0x7f,0xdb,0xea,0x60,0x40,0x00,0x00,
0x0c,0x1c,0x5e,0x77,0x20,0xe0,0x08,0x3c,0x75,0xff,0xff,0x21,0x3f,0x01,0x00,0x42,
0x7f,0x7d,0xea,0x00,0x80,0x00,0x04,0x40,0x04,0x0c,0x0e,0x20,0xf0,0xce,0xce,0xde,
0xda,0x21,0x2f,0x8e,0x00,0x00,0x42,0x7f,0xae,0xea,0x1e,0xd1,0x40,0xa0,0x24,0x58,
0x18,0x09,0x20,0xb0,0xd0,0xa4,0xf8,0xf8,0xe9,0xb0,0x00,0x01,0x80,0xa0,0xe8,0xe8,
0x12,0xaa,0xe0,0xff,0xc3,0x09,0x1d,0xcf,0x87,0xfc,0x00,0xc0,0x80,0x20,0xfc,0x0f,
0x07,0x12,0xba,0x38,0x3f,0xff,0xfe,0x9f,0x8f,0xc0,0xda,0xf1,0xe0,0xf4,0xfc,0x78,
0x7f,0x3f,0x21,0xb8,0xf0,0xf8,0xff,0xff,0x42,0xbf,0x0e,0xfa,0xfd,0xff,0xdf,0xfb,
0xf2,0xf4,0xc1,0x03,0x3e,0x18,0xac,0x2f,0xdf,0xbf,0xfe,0xfc,0x21,0x5c,0x3c,0x8c,
0xff,0xff,0x41,0xfc,0x00,0x00,0xea,0x07,0x05,0x03,0x0b,0x09,0x00,0x00,0x27,0x0f,
0xff,0xfd,0xfd,0xfe,0xfe,0x01,0x11,0xea,0x77,0x6d,0xdf,0xfe,0xf0,0x00,0xf8,0x58,
0x9e,0xff,0xcf,0x9f,0x7f,0x01,0x11,0xea,0x06,0x06,0x0b,0x20,0x20,0x36,0x17,0x07,
0x1c,0xfe,0xf6,0xf6,0xfb,0xff,0xff,0x21,0x3d,0xf0,0xf2,0xfe,0x12,0xee,0x03,0x1b,
0x33,0x00,0xe0,0xc4,0x98,0xb8,0x20,0x1f,0x00,0x18,0x32,0x03,0x03,0x01,0x00,0x00,
0x40,0x80,0x88,0x12,0xea,0x06,0x61,0x49,0x0d,0x1e,0x1f,0x17,0x1d,0xf1,0xff,0xf7,
0xf5,0xf6,0x01,0x11,0xfa,0xdc,0xfc,0x7a,0xfa,0xfe,0x77,0xef,0xed,0xf7,0x77,0x5b,
0xdb,0xdf,0xff,0xeb,0xe5,0x01,0x11,0xea,0x06,0x61,0x49,0x1c,0x2e,0x33,0xbf,0x9d,
0xf3,0xff,0xe3,0xf1,0x01,0x11,0xea,0xfc,0xec,0xf0,0x00,0x1e,0x3d,0xb9,0x9f,0xf8,
0xff,0xf1,0xf8,0xfe,0x01,0x11,0xfa,0xb0,0xe4,0xec,0xee,0xf6,0x77,0xff,0xff,0xb0,
0x64,0xcd,0xce,0xd7,0xff,0xfb,0xf7,0x21,0x0f,0x90,0x60,0xc1,0xc6,0x12,0xea,0x0d,
0x0e,0x0f,0x21,0x20,0x37,0x17,0x07,0xbf,0xff,0xfe,0x01,0x11,0xea,0xfd,0xdf,0xeb,
0xee,0x0e,0xc0,0x70,0xe8,0x3c,0xff,0x7d,0x7f,0x3f,0xef,0x01,0x11,0xea,0xdd,0xdf,
0x8e,0x01,0x60,0xb7,0xd5,0x37,0x79,0xff,0x7f,0x9f,0xdc,0x01,0x11,0xea,0xd7,0xce,
0xe3,0xe4,0x06,0xc0,0xf0,0x28,0xbc,0xff,0x7f,0x3f,0x0f,0x01,0x11,0xda,0x0d,0x0f,
0x0f,0x01,0x00,0x07,0x37,0x07,0xe6,0x7f,0x3f,0x1f,0xff,0x12,0xea,0xff,0xdf,0xeb,
0xee,0x0e,0xc0,0x70,0xe8,0x3c,0xff,0x7f,0x7f,0x3f,0xef,0x01,0x11,0x00,0x80,0xf0,
0x00,0x03,0x06,0x04,0x04,0x80,0xf7,0x00,0xff,0x20,0x38,0x66,0x00,0xfc,0x7c,0x60,
0xf0,0x20,0x3e,0xc6,0x00,0x7c,0x7c,0x20,0x32,0x66,0x00,0xe7,0x7e,0x7e,0x42,0x30,
0x00,0xfc,0x62,0x60,0x78,0x60,0x62,0xfc,0x20,0x36,0x66,0x00,0xfc,0x7c,0xf7,0x80,
0xf0,0x00,0xc3,0x66,0x24,0x24,0x20,0x1e,0x18,0x00,0x7e,0x99,0x3c,0x20,0x3e,0x18,
0x00,0x3c,0x3c,0x20,0x49,0x7c,0x00,0xc6,0xc0,0x06,0xc6,0xa0,0xf7,0x00,0xe0,0x49,
0x07,0x00,0x0c,0x0c,0x00,0x0c,0x20,0x26,0x6c,0x00,0xc7,0x0c,0xcc,0xc7,0x20,0x36,
0x6c,0x00,0xc7,0x0c,0xc7,0x20,0x36,0x66,0x00,0xcf,0x67,0xcf,0x20,0x36,0x66,0x00,
0xcf,0xc7,0x7f,0xa0,0xf7,0x00,0x07,0x94,0x00,0xc0,0x20,0x80,0x20,0xc0,0x20,0x26,
0x66,0x00,0xc3,0x7e,0x7e,0xe7,0x80,0xff,0x04,0xa0,0x70,0x01,0x00,0x03,0x03,0x7f,
0x3f,0x00,0x08,0x70,0x01,0x00,0x02,0x02,0x7c,0x20,0x80,0xff,0x24,0xa0,0x70,0x0f,
0x1f,0x1e,0x18,0x20,0x00,0x00,0x0c,0x10,0x08,0x08,0x09,0x16,0x18,0x20,0x00,0x30,
0x00,0x7c,0xc6,0x06,0x1c,0x70,0xc0,0xfe,0x30,0x00,0x7c,0xc6,0x06,0x3c,0x06,0xc6,
0x7c,0x20,0x36,0xc6,0x00,0x7c,0x7c,0x7c};
const unsigned char fx_psg[] = {
0xe4,0xf0,0x38,0xf2,0x38,0xf4,0x38,0xf6,0x38,0xf8,0x38,0xff,0x3c,0x01,0x39,0x00};
const unsigned char music_psg[] = {
0x8a,0x50,0x94,0xa0,0x40,0xbf,0xc0,0x40,0xdf,0xe0,0xff,0x38,0x95,0x3a,0x96,0x38,
0xa0,0x4e,0xb4,0x38,0xb5,0x38,0x97,0x39,0xb6,0x38,0x98,0x39,0x99,0xb7,0xe6,0xf4,
0x38,0xf5,0x39,0x9a,0xb8,0x38,0xf6,0x38,0x8e,0x49,0x94,0xb9,0x38,0x95,0x38,0xf7,
0x38,0xba,0x38,0x96,0x38,0xf8,0x39,0x97,0xa5,0x48,0xb4,0xf9,0x38,0xb5,0x39,0x98,
0xfa,0x38,0xb6,0x38,0x99,0xe7,0xf4,0x38,0xf5,0x38,0xb7,0x38,0x9a,0x38,0xf6,0x38,
0xb8,0x39,0x8e,0x45,0x94,0xb9,0xf7,0x38,0x95,0x39,0xba,0xf8,0x38,0x96,0x38,0xaf,
0x44,0x08,0x3a,0x00,0x38,0x97,0x38,0x08,0x40,0x00,0x08,0x1a,0x00,0x3a,0x9a,0xb8,
0x39,0xb9,0x38,0xfb,0x39,0xba,0x3c,0x9b,0x3a,0xfc,0x39,0xbb,0x3c,0x9c,0x3b,0xfd,
0x38,0xbc,0x3d,0x9d,0x3b,0xfe,0x38,0xbd,0x3d,0x9e,0x3a,0x01,0x87,0x5f,0x95,0xab,
0x4f,0xb6,0xe6,0xf7,0x39,0x96,0x38,0xb7,0xf8,0x38,0x97,0x38,0xa8,0x4a,0xb6,0x39,
0x98,0xf9,0x38,0xb7,0x38,0x99,0x38,0xfa,0x38,0xb8,0x38,0x95,0xad,0x47,0xb6,0xe7,
0x0d,0x93,0x00,0xad,0x48,0x12,0x9e,0x00,0xac,0x4b,0xb6,0xe5,0x1e,0x93,0x00,0x48,
0xb6,0xfe,0x38,0xff,0x38,0x96,0x38,0xb7,0x38,0x97,0x38,0xad,0x47,0xb6,0x39,0x98,
0x08,0xa2,0x00,0x39,0xb8,0x38,0x08,0x8e,0x00,0x08,0x94,0x00,0x0c,0x99,0x00,0x08,
0xa2,0x00,0x39,0x0a,0xa9,0x00,0x0e,0x92,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,
0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,0xa2,0x00,0x39,0xb8,0x38,0x85,0x63,0x26,
0x8e,0x00,0x0d,0x93,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,
0x15,0xbf,0x00,0x08,0xa2,0x00,0x39,0xb8,0x38,0x08,0x8e,0x00,0x08,0x94,0x00,0x0c,
0x99,0x00,0x08,0xa2,0x00,0x39,0x0a,0xa9,0x00,0x0e,0x92,0x00,0xad,0x48,0x12,0x9e,
0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,0x48,0xb6,0xe5,0x0d,0x93,0x00,0x09,0xcb,0x00,
0x0e,0xa1,0x00,0x89,0x57,0x26,0x8e,0x00,0x0d,0x93,0x00,0xad,0x48,0x12,0x9e,0x00,
0x08,0xb8,0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,0xa2,0x00,0x39,0xb8,0x38,0x08,
0x8e,0x00,0x08,0x94,0x00,0x0c,0x99,0x00,0x08,0xa2,0x00,0x39,0x0a,0xa9,0x00,0x0e,
0x92,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,
0x08,0xa2,0x00,0x39,0xb8,0x38,0x8a,0x67,0x95,0x08,0x92,0x00,0xb9,0x38,0xf8,0x38,
0x97,0x38,0xa9,0x46,0x12,0x9e,0x00,0xb6,0xe7,0x0d,0x93,0x00,0x12,0x9e,0x00,0xe5,
0xf7,0x39,0x96,0xb9,0x38,0xf8,0x38,0x97,0x38,0x12,0x9e,0x00,0x09,0xc1,0x00,0xb9,
0x39,0x97,0x38,0xb6,0x39,0x98,0x08,0xa2,0x00,0x09,0xfa,0x00,0x95,0xae,0x45,0xb6,
0x39,0x0a,0xc5,0x00,0xa0,0x08,0xcc,0x00,0x08,0xa2,0x00,0x39,0xb8,0x38,0x95,0xad,
0x48,0x0f,0x91,0x00,0xa9,0x46,0x15,0x9e,0x00,0x08,0x9f,0x01,0x0a,0x96,0x00,0xae,
0x49,0x12,0x9e,0x00,0xa0,0x47,0xb6,0xe5,0x0d,0x93,0x00,0xad,0x48,0xb6,0x38,0x98,
0x38,0xf9,0x38,0x99,0xb7,0x39,0x9a,0xfa,0x38,0xb8,0x38,0x28,0x8c,0x00,0x0d,0x93,
0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,
0xa2,0x00,0x08,0xcb,0x01,0xab,0x4f,0xb6,0x39,0x0a,0xc5,0x00,0x09,0x9c,0x00,0x08,
0xa2,0x00,0x09,0xcb,0x01,0x47,0x0f,0x91,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,
0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,0xa2,0x00,0x09,0xfa,0x00,0x26,0x8e,0x00,
0x0d,0x93,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,0x15,0xbf,
0x00,0x08,0xa2,0x00,0x08,0xcb,0x01,0x08,0x15,0x02,0x0a,0xc5,0x00,0x09,0x9c,0x00,
0x08,0xa2,0x00,0x09,0xcb,0x01,0x47,0x0f,0x91,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,
0xb8,0x00,0x1e,0x93,0x00,0x48,0xb6,0xe5,0x0d,0x93,0x00,0x09,0xcb,0x00,0x0e,0xa1,
0x00,0x89,0x57,0x26,0x8e,0x00,0x0d,0x93,0x00,0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,
0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,0xa2,0x00,0x08,0xcb,0x01,0x08,0x15,0x02,
0x0a,0xc5,0x00,0x09,0x9c,0x00,0x08,0xa2,0x00,0x09,0xcb,0x01,0x47,0x0f,0x91,0x00,
0xad,0x48,0x12,0x9e,0x00,0x08,0xb8,0x00,0x1e,0x93,0x00,0x15,0xbf,0x00,0x08,0xa2,
0x00,0x0a,0x83,0x01,0x08,0x92,0x00,0x0c,0x8c,0x01,0x12,0x9e,0x00,0xb6,0xe7,0x0d,
0x93,0x00,0x12,0x9e,0x00,0x0e,0x9f,0x01,0x12,0x9e,0x00,0x09,0xc1,0x00,0x0b,0xaf,
0x01,0x08,0xa2,0x00,0x09,0xfa,0x00,0x09,0xbc,0x01,0x0a,0xc5,0x00,0xa0,0x08,0xcc,
0x00,0x08,0xa2,0x00,0x0a,0xcb,0x01,0x0f,0x91,0x00,0xa9,0x46,0x15,0x9e,0x00,0x08,
0x9f,0x01,0x0a,0x96,0x00,0xae,0x49,0x12,0x9e,0x00,0x08,0xe4,0x01,0x0d,0x93,0x00,
0x14,0xeb,0x01,0x8a,0x67,0x95,0xae,0x49,0xb6,0xe6,0xf6,0x08,0x94,0x00,0xf7,0x0a,
0xc8,0x00,0x38,0x98,0xf8,0x39,0x99,0xb7,0x38,0xf9,0x38,0x9a,0x08,0xa8,0x00,0xa9,
0x46,0xb6,0xe7,0xf6,0x08,0x94,0x00,0xf7,0x38,0x97,0x38,0xaf,0x44,0xb6,0x0e,0x22,
0x03,0x08,0xa8,0x00,0xa6,0xb6,0xe5,0xf6,0x08,0x94,0x00,0x08,0x37,0x03,0xa9,0x45,
0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0xa6,0x47,0x10,0xc0,0x00,0x08,0xec,0x01,0x39,
0x08,0xf3,0x01,0x08,0xa8,0x00,0xae,0x49,0xb6,0x39,0x0d,0xc5,0x00,0x09,0x19,0x00,
0x39,0x9a,0x08,0xa8,0x00,0xa9,0x46,0xb6,0xe6,0xf6,0x08,0x94,0x00,0x0b,0x37,0x03,
0x0e,0x22,0x03,0x08,0xa8,0x00,0x08,0x44,0x03,0x08,0x94,0x00,0x08,0x37,0x03,0xa9,
0x45,0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0xa6,0x47,0x10,0xc0,0x00,0x08,0xec,0x01,
0x39,0x08,0xf3,0x01,0x08,0xa8,0x00,0xa8,0x54,0xb6,0xe6,0xf6,0x38,0xa2,0x55,0x38,
0x96,0xae,0x38,0xa9,0x56,0xb7,0xf7,0x38,0x97,0xa5,0x57,0x38,0xa6,0x53,0xb6,0x38,
0x98,0xa2,0x54,0xf8,0x38,0xad,0x38,0x99,0xaa,0x55,0xb7,0x38,0xa6,0x56,0xf9,0x38,
0x9a,0xa4,0x57,0x38,0xa1,0x58,0xb8,0x38,0x95,0xa6,0x52,0xb6,0xe7,0xf6,0x38,0xa2,
0x53,0x08,0xaf,0x03,0xab,0x54,0x08,0xb5,0x03,0xa9,0x55,0x38,0xa6,0x51,0xb6,0x38,
0x98,0xa3,0x52,0xf8,0x38,0xa0,0x53,0x38,0x99,0xad,0xb7,0x38,0xab,0x54,0xf9,0x38,
0x9a,0xaa,0x55,0x38,0xa9,0x56,0xb8,0x38,0x95,0xa8,0x50,0xb6,0xe5,0xf6,0x38,0xa4,
0x51,0x38,0x96,0xa2,0x52,0x38,0xa0,0x53,0x08,0xb5,0x03,0xae,0x38,0xaa,0x4f,0xb6,
0x38,0x98,0xa7,0x50,0xf8,0x08,0x0e,0x04,0x99,0xa3,0x52,0xb7,0x38,0xa2,0x53,0xf9,
0x38,0x9a,0xa2,0x54,0x38,0xa2,0x55,0xb8,0x38,0x95,0xac,0x4e,0xb6,0xfe,0x38,0xaa,
0x4f,0xff,0x38,0x96,0xa8,0x50,0x38,0xa6,0x51,0xb7,0x38,0x97,0xa6,0x52,0x38,0xa0,
0x4e,0xb6,0x38,0x98,0xad,0x38,0xab,0x4f,0x38,0x99,0xaa,0x50,0xb7,0x38,0xaa,0x51,
0x38,0x9a,0xab,0x52,0x38,0xad,0x53,0xb8,0x38,0x95,0xa4,0x4d,0xb6,0x38,0xa2,0x4e,
0x38,0x96,0xa0,0x4f,0x38,0xaf,0xb7,0x38,0x97,0xaf,0x50,0x38,0xa9,0x4c,0xb6,0x38,
0x98,0xa6,0x4d,0x38,0xa5,0x4e,0x38,0x99,0xa4,0x4f,0xb7,0x38,0xa5,0x50,0x38,0x9a,
0xa6,0x51,0x38,0xa9,0x52,0xb8,0x38,0x95,0xae,0x4b,0x08,0xa9,0x03,0xac,0x4c,0x38,
0x96,0xaa,0x4d,0x38,0xaa,0x4e,0x08,0xb5,0x03,0xab,0x4f,0x38,0xa4,0x4b,0x08,0xbe,
0x03,0x4c,0xf8,0x38,0xa0,0x4d,0x38,0x99,0xa0,0x4e,0xb7,0x38,0xa1,0x4f,0xf9,0x38,
0x9a,0xa3,0x08,0x45,0x04,0xb8,0x38,0x95,0xab,0x4a,0x08,0x0b,0x04,0xa8,0x4b,0x38,
0x96,0xa7,0x4c,0x38,0xa6,0x4d,0x08,0xb5,0x03,0xa7,0x4e,0x38,0xa2,0x4a,0xb6,0x38,
0x98,0xaf,0xf8,0x38,0xae,0x4b,0x38,0x99,0xad,0x4c,0xb7,0x38,0xae,0x4d,0xf9,0x38,
0x9a,0xa1,0x4f,0x38,0xa5,0x50,0xb8,0x38,0x95,0xa9,0x49,0x08,0x0b,0x04,0xa6,0x4a,
0x38,0x96,0xa5,0x4b,0x38,0xa5,0x4c,0x08,0xb5,0x03,0xa6,0x4d,0x38,0xa1,0x49,0xb6,
0x38,0x98,0xae,0xf8,0x38,0xad,0x4a,0x38,0x99,0xac,0x4b,0xb7,0x38,0xad,0x4c,0xf9,
0x38,0x9a,0xa0,0x4e,0x38,0xa4,0x4f,0x08,0xfb,0x00,0x95,0xad,0x48,0xb6,0xe6,0xf6,
0x08,0x94,0x00,0x08,0x37,0x03,0xa0,0x47,0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0xae,
0x45,0xb6,0xe7,0xf6,0x08,0x94,0x00,0x08,0x37,0x03,0xa6,0x44,0xb6,0x0e,0x22,0x03,
0x08,0xa8,0x00,0xae,0x43,0xb6,0xe5,0xf6,0x08,0x94,0x00,0x0b,0x37,0x03,0x0e,0x22,
0x03,0x08,0xa8,0x00,0xa9,0x46,0x12,0xc0,0x00,0x09,0x19,0x00,0x39,0x9a,0x09,0xa8,
0x00,0x48,0xb6,0x39,0x0a,0xc5,0x00,0xa0,0x47,0x0a,0x18,0x00,0x39,0x9a,0x08,0xa8,
0x00,0xae,0x45,0xb6,0xe6,0xf6,0x08,0x94,0x00,0x08,0x37,0x03,0xa6,0x44,0xb6,0x0e,
0x22,0x03,0x08,0xa8,0x00,0x09,0x53,0x05,0x08,0x94,0x00,0x0b,0x37,0x03,0x0e,0x22,
0x03,0x08,0xa8,0x00,0xa9,0x46,0x12,0xc0,0x00,0x09,0x19,0x00,0x39,0x9a,0x08,0xa8,
0x00,0xa4,0x52,0x08,0xa9,0x03,0xad,0x38,0x96,0xa7,0x53,0x38,0xa2,0x54,0x08,0xb5,
0x03,0xac,0x38,0xa4,0x51,0x0a,0x0f,0x05,0xa9,0x52,0x38,0x99,0xa4,0x53,0xb7,0x38,
0xaf,0xf9,0x38,0x9a,0xab,0x54,0x38,0xa7,0x08,0x36,0x04,0xa6,0x50,0x08,0xdb,0x03,
0xa0,0x51,0x38,0x96,0xab,0x38,0xa7,0x52,0x08,0xb5,0x03,0xa3,0x53,0x38,0xa8,0x08,
0x1e,0x04,0xa3,0x50,0xf8,0x38,0xae,0x38,0x99,0xaa,0x51,0xb7,0x38,0xa7,0x52,0x08,
0xce,0x03,0x08,0xba,0x05,0x08,0xc5,0x04,0x4e,0x08,0x0b,0x04,0xa6,0x4f,0x38,0x96,
0xa2,0x50,0x38,0xae,0x08,0xb5,0x03,0xab,0x51,0x38,0xae,0x4d,0xb6,0x38,0x98,0xaa,
0x4e,0xf8,0x38,0xa6,0x4f,0x38,0x99,0xa3,0x50,0xb7,0x38,0xa0,0x51,0xf9,0x38,0x9a,
0xae,0x38,0xad,0x08,0x94,0x04,0xa3,0x4d,0xb6,0xfe,0x38,0xae,0xff,0x38,0x96,0xab,
0x4e,0x38,0xa8,0x4f,0x08,0x49,0x04,0x50,0x38,0xa7,0x08,0x7d,0x04,0xa3,0x4d,0x38,
0xa0,0x4e,0x0a,0xf7,0x03,0x4f,0x38,0x9a,0xaa,0x50,0x38,0xaa,0x51,0x08,0xa9,0x00,
0x4b,0xb6,0x38,0xa9,0x4c,0x38,0x96,0xa6,0x4d,0x38,0xa3,0x4e,0xb7,0x38,0x97,0xa2,
0x4f,0x38,0xa3,0x4b,0x08,0xde,0x04,0x38,0xac,0x4c,0x38,0x99,0xaa,0x4d,0xb7,0x38,
0xa8,0x4e,0x38,0x9a,0xa8,0x4f,0x38,0xa9,0x08,0xf5,0x04,0xaa,0x4a,0x08,0xa9,0x03,
0xa6,0x4b,0x38,0x96,0xa3,0x4c,0x38,0xa0,0x4d,0x08,0xb5,0x03,0xaf,0x38,0xa1,0x08,
0xdd,0x04,0xad,0xf8,0x38,0xaa,0x4b,0x38,0x99,0xa7,0x4c,0xb7,0x38,0xa6,0x08,0xed,
0x04,0xa7,0x08,0x40,0x06,0x08,0x06,0x04,0x49,0x09,0x0b,0x04,0x4a,0x38,0x96,0xa1,
0x4b,0x38,0xaf,0x08,0xb5,0x03,0xae,0x4c,0x38,0xa0,0x08,0x0e,0x05,0xac,0xf8,0x38,
0xa9,0x4a,0x38,0x99,0xa7,0x4b,0xb7,0x38,0xa6,0x08,0x1e,0x05,0xa6,0x4d,0x38,0xa8,
0x4e,0x08,0x06,0x04,0x48,0x09,0x0b,0x04,0x49,0x38,0x96,0xa1,0x4a,0x38,0xaf,0x08,
0xb5,0x03,0xae,0x4b,0x38,0xa1,0x08,0xec,0x01,0x08,0xa2,0x06,0x49,0x38,0x99,0xa8,
0x4a,0xb7,0x38,0xa7,0x4b,0xf9,0x38,0x9a,0xa7,0x4c,0x38,0xaa,0x4d,0xb8,0x38,0x0c,
0x13,0x03,0x08,0x94,0x00,0x08,0x37,0x03,0xad,0x47,0xb6,0x0e,0x22,0x03,0x08,0xa8,
0x00,0x09,0x2f,0x03,0x08,0x94,0x00,0x0b,0x37,0x03,0x0e,0x22,0x03,0x08,0xa8,0x00,
0x08,0x44,0x03,0x08,0x94,0x00,0x08,0x37,0x03,0xa9,0x45,0xb6,0x0e,0x22,0x03,0x08,
0xa8,0x00,0xa6,0x47,0x10,0xc0,0x00,0x08,0xec,0x01,0x39,0x08,0xf3,0x01,0x08,0xa8,
0x00,0x08,0x66,0x03,0x0d,0xc5,0x00,0x09,0x19,0x00,0x39,0x9a,0x08,0xa8,0x00,0x09,
0x75,0x03,0x08,0x94,0x00,0x0b,0x37,0x03,0x0e,0x22,0x03,0x08,0xa8,0x00,0x08,0x44,
0x03,0x08,0x94,0x00,0x08,0x37,0x03,0xa9,0x45,0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,
0xa6,0x47,0x10,0xc0,0x00,0x08,0xec,0x01,0x39,0x99,0xb7,0x39,0x9a,0x38,0xb8,0x38,
0x95,0x37,0xa7,0x03,0x0b,0xda,0x03,0x08,0xaf,0x03,0xab,0x54,0xb7,0xf7,0x38,0x97,
0x33,0xe9,0x03,0x08,0xb5,0x03,0x0e,0x1b,0x04,0x08,0x0e,0x04,0x37,0x28,0x04,0x37,
0x5b,0x04,0x10,0x8e,0x04,0x08,0xa9,0x03,0x0d,0x9d,0x04,0x08,0xb5,0x03,0x09,0xa9,
0x04,0x08,0xbe,0x03,0x15,0xb1,0x04,0x08,0x45,0x04,0x09,0xc5,0x04,0x08,0x0b,0x04,
0x0d,0xcd,0x04,0x08,0xb5,0x03,0x26,0xd9,0x04,0x08,0x0b,0x04,0x0d,0xfe,0x04,0x08,
0xb5,0x03,0x21,0x0a,0x05,0x08,0xfb,0x00,0x0a,0x2a,0x05,0x08,0x94,0x00,0x08,0x37,
0x03,0xa0,0x47,0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0x09,0x3f,0x05,0x08,0x94,0x00,
0x08,0x37,0x03,0xa6,0x44,0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0x09,0x53,0x05,0x08,
0x94,0x00,0x0b,0x37,0x03,0x0e,0x22,0x03,0x08,0xa8,0x00,0xa9,0x46,0x12,0xc0,0x00,
0x09,0x19,0x00,0x0a,0x8b,0x07,0xad,0x48,0xb6,0x39,0x0a,0xc5,0x00,0xa0,0x47,0x0a,
0x18,0x00,0x0a,0x8b,0x07,0x09,0x81,0x05,0x08,0x94,0x00,0x08,0x37,0x03,0xa6,0x44,
0xb6,0x0e,0x22,0x03,0x08,0xa8,0x00,0x09,0x53,0x05,0x08,0x94,0x00,0x0b,0x37,0x03,
0x0e,0x22,0x03,0x08,0xa8,0x00,0xa9,0x46,0x12,0xc0,0x00,0x09,0x19,0x00,0x0a,0x8b,
0x07,0xa4,0x52,0x08,0xa9,0x03,0x0c,0xb6,0x05,0x08,0xb5,0x03,0x08,0xc1,0x05,0x0a,
0x0f,0x05,0x14,0xc8,0x05,0x08,0x36,0x04,0xa6,0x50,0x08,0xdb,0x03,0x0c,0xe0,0x05,
0x08,0xb5,0x03,0x08,0xeb,0x05,0x08,0x1e,0x04,0x11,0xf2,0x05,0x08,0xce,0x03,0x08,
0xba,0x05,0x08,0xc5,0x04,0x4e,0xb6,0xe5,0xf6,0x38,0xa6,0x4f,0x38,0x96,0xa2,0x50,
0x38,0xae,0xb7,0xf7,0x38,0x97,0x20,0x17,0x06,0x08,0x94,0x04,0x12,0x36,0x06,0x08,
0x49,0x04,0x50,0x38,0xa7,0x08,0x7d,0x04,0x09,0x4d,0x06,0x0a,0xf7,0x03,0x0c,0x55,
0x06,0x08,0xa9,0x00,0x18,0x60,0x06,0x08,0xde,0x04,0x15,0x77,0x06,0x08,0xf5,0x04,
0xaa,0x4a,0xb6,0xe6,0xf6,0x38,0x0d,0x90,0x06,0x08,0xb5,0x03,0xaf,0x38,0xa1,0x4a,
0xb6,0x38,0x98,0x10,0xa2,0x06,0x08,0xed,0x04,0xa7,0x08,0x40,0x06,0x08,0x06,0x04,
0x49,0x09,0x0b,0x04,0x0b,0xbc,0x06,0x08,0xb5,0x03,0x08,0xc6,0x06,0x08,0x0e,0x05,
0x10,0xcd,0x06,0x08,0x1e,0x05,0x09,0xdc,0x06,0x08,0x06,0x04,0x48,0x09,0x0b,0x04,
0x0b,0xe8,0x06,0x08,0xb5,0x03,0x08,0xf2,0x06,0x08,0xec,0x01,0x08,0xa2,0x06,0x17,
0xfc,0x06,0x87,0x5a,0x95,0xaa,0x51,0xb6,0xe6,0xf6,0x08,0x94,0x00,0xf7,0x38,0x97,
0x39,0x98,0xb8,0xf8,0x39,0x99,0x38,0xb9,0xf9,0x38,0x9a,0x39,0x95,0xba,0xe7,0xf6,
0x39,0x96,0x38,0x08,0x37,0x03,0xbb,0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0xe5,
0x08,0x3f,0x09,0x08,0x37,0x03,0xbc,0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0x09,
0xc1,0x00,0x39,0x97,0x39,0x98,0xbd,0x39,0x99,0x39,0x9a,0x39,0x95,0x39,0x96,0x39,
0x97,0x38,0x8d,0x53,0x95,0x39,0x96,0xbe,0x08,0x62,0x09,0x38,0x8a,0x51,0x95,0xe6,
0x08,0x3f,0x09,0x08,0x37,0x03,0x8d,0x4e,0x95,0x38,0xf8,0x38,0x96,0xbf,0x39,0x97,
0xf9,0x39,0x98,0x38,0x83,0x4d,0x95,0xe5,0x08,0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,
0x09,0x08,0x38,0x09,0x87,0x5a,0x95,0x09,0xc1,0x00,0x08,0x62,0x09,0x0a,0x67,0x09,
0xad,0x53,0xb6,0xe6,0xf6,0x39,0x96,0x38,0xb7,0x1a,0x2d,0x09,0x08,0x37,0x03,0xbb,
0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0xe5,0x08,0x3f,0x09,0x08,0x37,0x03,0xbc,
0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0xfe,0x38,0xff,0x38,0x96,0x1a,0x62,0x09,
0x08,0x62,0x09,0x09,0x7b,0x09,0x08,0x3f,0x09,0x08,0x37,0x03,0x16,0x86,0x09,0x08,
0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,0x09,0x08,0x38,0x09,0x87,0x5a,0x95,0xe5,0x08,
0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,0x09,0x09,0x38,0x09,0xa3,0x4d,0x0b,0xb2,0x09,
0x1a,0x2d,0x09,0x08,0x37,0x03,0xbb,0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0xaa,
0xe5,0xf6,0x09,0x6d,0x04,0xa9,0x38,0xa1,0x4f,0xf7,0x38,0x97,0xa9,0x38,0xa0,0xbc,
0x38,0x98,0xa7,0x4e,0xf8,0x38,0xaf,0x4d,0x38,0x99,0xa7,0x38,0xa0,0xf9,0x38,0x9a,
0xa8,0x4c,0x38,0xa1,0x38,0x95,0xa9,0xfe,0x38,0xa1,0x4d,0xff,0x38,0x96,0xaa,0x08,
0x6d,0x04,0x97,0xac,0x38,0xa2,0x38,0x98,0xa8,0x4d,0xbd,0x38,0xaf,0x4c,0x38,0x99,
0xa6,0x08,0xe3,0x04,0x9a,0xa6,0x38,0xae,0x4a,0x38,0x95,0xa6,0x4b,0x38,0xaf,0x38,
0x96,0xa8,0x4c,0x38,0xa2,0x4d,0x38,0x97,0xac,0x08,0x71,0x09,0xa1,0x38,0xa7,0x4c,
0x38,0x96,0xad,0x4b,0xbe,0x38,0xa4,0x38,0x97,0xab,0x4a,0x08,0x54,0x0a,0xaa,0x49,
0x08,0x7b,0x09,0xa3,0x4a,0xe6,0xf6,0x38,0xac,0x38,0x96,0xa6,0x4b,0x38,0xa0,0x4c,
0xf7,0x38,0x97,0xaa,0x38,0x8d,0x4e,0x95,0xaf,0x4b,0x38,0xa4,0xf8,0x38,0x96,0xaa,
0x4a,0xbf,0x38,0xa1,0x38,0x97,0xa8,0x49,0xf9,0x38,0xaf,0x48,0x38,0x98,0xa7,0x08,
0x93,0x09,0xa0,0x49,0xe5,0xf6,0x38,0xa9,0x38,0x96,0xa2,0x4a,0x38,0xad,0xf7,0x38,
0x97,0xa8,0x4b,0x38,0xac,0x4a,0x38,0x98,0xa1,0xf8,0x38,0xa7,0x49,0x38,0x99,0xad,
0x48,0x38,0xa4,0xf9,0x38,0x9a,0xac,0x47,0x38,0xa4,0x38,0x87,0x5a,0x95,0xad,0xfe,
0x38,0xa5,0x48,0xff,0x38,0x96,0xaf,0x38,0xa9,0x49,0x38,0x97,0xa4,0x4a,0x08,0xf7,
0x0a,0x98,0xae,0x48,0x38,0xa4,0x38,0x99,0xab,0x47,0x38,0xa2,0x38,0x9a,0xaa,0x46,
0x38,0xa3,0x38,0x85,0x63,0x95,0xa0,0x4e,0xb6,0xe6,0xf6,0x39,0x96,0x38,0xb7,0x1a,
0x2d,0x09,0x08,0x37,0x03,0xbb,0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0xe5,0x08,
0x3f,0x09,0x08,0x37,0x03,0xbc,0x09,0x22,0x03,0x08,0x28,0x03,0x39,0x95,0x0e,0xc0,
0x00,0x39,0x98,0xb8,0x08,0x34,0x09,0x09,0x39,0x09,0x09,0x6d,0x09,0xbb,0x08,0x19,
0x00,0x08,0x69,0x09,0x09,0xb3,0x09,0x08,0x37,0x03,0xbc,0x09,0x22,0x03,0x08,0x28,
0x03,0x39,0x95,0xe5,0x08,0x3f,0x09,0x09,0x2d,0x09,0xbd,0x08,0x33,0x09,0x09,0x38,
0x09,0xe5,0x08,0x3f,0x09,0x09,0x2d,0x09,0xf8,0x38,0xbe,0x38,0x99,0x38,0xf9,0x38,
0x9a,0x39,0x87,0x5a,0x95,0xaa,0x51,0xb6,0xe6,0xf6,0x39,0x96,0x38,0xb7,0x1a,0x2d,
0x09,0x08,0x37,0x03,0xbb,0x09,0x22,0x03,0x09,0x7d,0x0b,0x95,0xe5,0x08,0x3f,0x09,
0x08,0x37,0x03,0xbc,0x09,0x22,0x03,0x09,0x7d,0x0b,0x0a,0xd7,0x09,0x1a,0x62,0x09,
0x08,0x62,0x09,0x09,0x7b,0x09,0x08,0x3f,0x09,0x08,0x37,0x03,0x16,0x86,0x09,0x08,
0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,0x09,0x0b,0x7e,0x0b,0x09,0xc1,0x00,0x08,0x62,
0x09,0x0a,0x67,0x09,0x0d,0xb0,0x09,0x1a,0x2d,0x09,0x08,0x37,0x03,0xbb,0x09,0x22,
0x03,0x09,0x7d,0x0b,0x95,0xe5,0x08,0x3f,0x09,0x08,0x37,0x03,0xbc,0x09,0x22,0x03,
0x09,0x7d,0x0b,0x0a,0xd7,0x09,0x1a,0x62,0x09,0x08,0x62,0x09,0x09,0x7b,0x09,0x08,
0x3f,0x09,0x08,0x37,0x03,0x16,0x86,0x09,0x08,0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,
0x09,0x0b,0x7e,0x0b,0xe5,0x08,0x3f,0x09,0x09,0x2d,0x09,0x08,0x33,0x09,0x09,0x38,
0x09,0xa3,0x4d,0x0b,0xb2,0x09,0x1a,0x2d,0x09,0x08,0x37,0x03,0xbb,0x09,0x22,0x03,
0x09,0x7d,0x0b,0x08,0x1e,0x0a,0x09,0x6d,0x04,0x2e,0x25,0x0a,0x08,0x6d,0x04,0x13,
0x52,0x0a,0x08,0xe3,0x04,0x19,0x64,0x0a,0x08,0x71,0x09,0x13,0x7c,0x0a,0x08,0x54,
0x0a,0xaa,0x49,0x38,0x8a,0x51,0x95,0x30,0x93,0x0a,0x08,0x93,0x09,0x37,0xc2,0x0a,
0x0d,0xf5,0x0a,0x08,0xf7,0x0a,0x22,0x01,0x0b,0x1a,0x2d,0x09,0x08,0x37,0x03,0xbb,
0x09,0x22,0x03,0x09,0x7d,0x0b,0x95,0xe5,0x08,0x3f,0x09,0x08,0x37,0x03,0xbc,0x09,
0x22,0x03,0x09,0x7d,0x0b,0x95,0x0e,0xc0,0x00,0x39,0x98,0xb8,0x08,0x34,0x09,0x09,
0x39,0x09,0x09,0x6d,0x09,0xbb,0x08,0x19,0x00,0x08,0x69,0x09,0x09,0xb3,0x09,0x08,
0x37,0x03,0xbc,0x09,0x22,0x03,0x09,0x7d,0x0b,0x95,0xe5,0x08,0x3f,0x09,0x09,0x2d,
0x09,0xbd,0x08,0x33,0x09,0x09,0x38,0x09,0xe5,0x08,0x3f,0x09,0x09,0x2d,0x09,0x0e,
0x78,0x0b,0x00};
const unsigned char spritepalette_bin[] = {
0x33,0x00,0x3f,0x2b,0x13,0x2a};
const unsigned char spritetiles_psgcompr[] = {
0x24,0x00,0xe0,0x00,0x03,0x04,0x04,0x07,0x0f,0x17,0x27,0x37,0x03,0x00,0x00,0x00,
0xe0,0x00,0x08,0xb0,0xc0,0xe0,0xf0,0xf8,0xfc,0xf0,0x00,0xc0,0xa0,0xf0,0x38,0xe0,
0x06,0x09,0x09,0x0f,0x1f,0x2f,0x4f,0x07,0x62,0x06,0x00,0x01,0x07,0x07,0x03,0xe0,
0x10,0x60,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xe0,0x00,0x80,0x40,0xe0,0x70,0x38,0xe0,
0x06,0x09,0x09,0x0f,0x1f,0x2f,0x4f,0x07,0x62,0x06,0x00,0x01,0x07,0x07,0x03,0xe0,
0x10,0x60,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xe0,0x00,0x80,0x40,0xe0,0x70,0x38,0xe0,
0x00,0x10,0x0d,0x03,0x07,0x0f,0x1f,0x3f,0xf0,0x00,0x03,0x05,0x0f,0x1c,0xe0,0x00,
0xc0,0x20,0x20,0xe0,0xf0,0xe8,0xe4,0x37,0xc0,0x00,0x00,0x00,0xe0,0x08,0x06,0x01,
0x03,0x07,0x0f,0x1f,0x3f,0xe0,0x00,0x01,0x02,0x07,0x0e,0x1c,0xe0,0x60,0x90,0x90,
0xf0,0xf8,0xf4,0xf2,0xe0,0x62,0x60,0x00,0x80,0xe0,0xe0,0xc0,0xe0,0x08,0x06,0x01,
0x03,0x07,0x0f,0x1f,0x3f,0xe0,0x00,0x01,0x02,0x07,0x0e,0x1c,0xe0,0x60,0x90,0x90,
0xf0,0xf8,0xf4,0xf2,0xe0,0x62,0x60,0x00,0x80,0xe0,0xe0,0xc0,0xa0,0x1c,0x09,0x03,
0x05,0x08,0x0f,0x0f,0x1d,0x06,0x01,0x02,0x07,0x00,0xf8,0xfe,0xdf,0xa7,0xa0,0x60,
0x20,0x20,0xa0,0x9c,0x86,0x00,0x00,0x80,0xc0,0xc0,0x40,0xc7,0x00,0x40,0xc0,0x40,
0xe0,0x0b,0x11,0x12,0x12,0x09,0x09,0x0d,0x13,0x31,0x0d,0x05,0x0e,0x06,0x06,0x03,
0xa8,0x38,0x40,0xbe,0x4e,0xc0,0xe0,0xe0,0x1b,0x80,0x0c,0x00,0x00,0x00,0x9f,0x00,
0x80,0x80,0xf0,0x0b,0x11,0x10,0x24,0x24,0x2c,0x7a,0x78,0x05,0x0e,0x0f,0x1b,0x1b,
0x13,0x35,0x37,0xa8,0x1c,0xa0,0xbe,0x4e,0x40,0x70,0xf0,0x1c,0x40,0x0c,0x00,0x00,
0xa0,0x20,0x9f,0x00,0x80,0x80,0xf8,0x7f,0xfb,0xe5,0x05,0x06,0x04,0x04,0x05,0x39,
0x61,0x00,0x00,0x01,0x03,0x03,0x02,0xc7,0x00,0x02,0x03,0x02,0xa0,0x1c,0x90,0xc0,
0xa0,0x10,0xf0,0xf0,0x1d,0x60,0x80,0x40,0xe0,0x00,0xa8,0x38,0x02,0x7d,0x72,0x03,
0x07,0x07,0x1b,0x01,0x30,0x00,0x00,0x00,0x9f,0x00,0x01,0x01,0xe0,0xd0,0x88,0x48,
0x48,0x90,0x90,0xb0,0xc8,0x31,0xb0,0xa0,0x70,0x60,0x60,0xc0,0xa8,0x1c,0x05,0x7d,
0x72,0x02,0x0e,0x0f,0x1c,0x02,0x30,0x00,0x00,0x05,0x04,0x9f,0x00,0x01,0x01,0xf0,
0xd0,0x88,0x08,0x24,0x24,0x34,0x5e,0x1e,0xa0,0x70,0xf0,0xd8,0xd8,0xc8,0xac,0xec,
0xa0,0x1f,0x03,0x0f,0x0c,0x0f,0x3f,0x00,0x06,0x03,0xa0,0x1c,0x40,0x20,0x60,0xe0,
0x58,0xf8,0x5e,0x80,0xc0,0x00,0x00,0xe0,0x21,0x1f,0x0a,0x0c,0x34,0x58,0x60,0x70,
0x53,0x00,0x1e,0x04,0x08,0x20,0xe0,0xa0,0x40,0xa2,0x56,0x2e,0x1c,0x0c,0x00,0x07,
0x00,0x40,0x80,0x40,0x20,0x10,0xe0,0x31,0x1f,0x0a,0x6c,0x74,0xdc,0x80,0x00,0x57,
0x00,0x0e,0x04,0x08,0xe0,0xe0,0x40,0xa0,0x50,0x29,0x17,0x0e,0x0c,0x83,0x00,0x80,
0x40,0x20,0x10,0x08,0xa0,0x1c,0x02,0x04,0x06,0x07,0x1a,0x1f,0x5e,0x01,0x03,0x00,
0x00,0xa0,0x1f,0xc0,0xf0,0x30,0xf0,0x3f,0x00,0x60,0xc0,0xe0,0x05,0x02,0x45,0x6a,
0x74,0x38,0x30,0x00,0x07,0x00,0x02,0x01,0x02,0x04,0x08,0xe0,0x84,0xf8,0x50,0x30,
0x2c,0x1a,0x06,0x0e,0x53,0x00,0x78,0x20,0x10,0x04,0xe0,0x07,0x02,0x05,0x0a,0x94,
0xe8,0x70,0x30,0x83,0x00,0x01,0x02,0x04,0x08,0x10,0xe0,0x8c,0xf8,0x50,0x36,0x2e,
0x3b,0x01,0x00,0x57,0x00,0x70,0x20,0x10};
|
the_stack_data/9593.c
|
/*
Autor (usuario): mynorjrv
Fecha: jue 06 may 2021 16:36:15 CST
compilador: gcc (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0
Para Compilar: gcc -o Ejercicio3 Ejercicio3.c -lm
Version: 1.0
librerias: stdio, math
Resumen: Operaciones con vectores
Entradas: Dos vecotres
Salidas: Resultado de operaciones
*/
//Librerias
//Recuerde añadirlas al header
#include <stdio.h>
#include <math.h>
//Varibales
char names[]="xyz";
float V1[3];
float V2[3];
int dim = sizeof(V1)/sizeof(V1[0]);
/*no puedo definir suma ni producto punto porque las funciones
no devulven arrays :( creo de hecho que no vlae la pena
definir funciones*/
//va pueees, definire magnitud y producto puuuunto
float magnitud(float A[], int lenght);
float punto(float A[], float B[], int lenght);
int main(void){
puts("Ingrese dos vectores.");
//Entrada de vectores
for( int i=0; i<dim; i++){
printf("Ingrese %c de V1: ", names[i]);
scanf("%f", &V1[i]);
}
for( int i=0; i<dim; i++){
printf("Ingrese %c de V2: ", names[i]);
scanf("%f", &V2[i]);
}
//Esto no lo ped[ia pero impresion de vectores
printf("V1 = (%.2f, %.2f, %.2f)\n", V1[0], V1[1], V1[2]);
printf("V2 = (%.2f, %.2f, %.2f)\n", V2[0], V2[1], V2[2]);
//Magnitud de vectores
printf("|V1| = %f\n", magnitud(V1, dim) );
printf("|V2| = %f\n", magnitud(V2, dim) );
//Suma de vectores
//la verdad no me termina de agradar... pude solo sumar en el argumentoxd
//Lo que podria hacer es una suma de componentes... pero meh, aguanta
float Suma[dim];
for(int i=0; i<dim; i++)
Suma[i] = V1[i] + V2[i];
printf("V1+V2 = (%.2f, %.2f, %.2f)\n", Suma[0], Suma[1], Suma[2]);
//Producto punto
printf("V1 * V2 = %f\n", punto(V1, V2, dim));
//Producto cruz
//esto servira en el determinante :)
float Cruz[dim];
for(int i=0; i<dim; i++)
Cruz[i] = V1[(i+1)%3]*V2[(i+2)%3] - V2[(i+1)%3]*V1[(i+2)%3];
printf("V1 x V2 = (%.2f, %.2f, %.2f)\n", Cruz[0], Cruz[1], Cruz[2]);
return 0;
}
float magnitud(float A[], int lenght){
int suma = 0;
for(int i=0; i<lenght; i++)
suma += pow( A[i], 2);
return sqrt( suma );
}
float punto(float A[], float B[], int lenght){
int suma = 0;
for(int i=0; i<lenght; i++)
suma += A[i]*B[i];
return suma;
}
|
the_stack_data/51494.c
|
#include <stdio.h>
int main(void) {
int equipa, adversario, jornadas;
//input das variaveis ex. 30 22 3
printf("insira pontos: \n");
scanf("%d %d %d", &equipa, &adversario, &jornadas);
//chamar funcao
input_inline(equipa, adversario, jornadas);
return 0;
}
//funcao para fazer inline do input
int input_inline (int equipa, int adversario, int jornada) {
if (equipa >=30 && adversario >=22) {
//30 22 3
// :-)
printf(":-)");
} else if (equipa >= 30 && adversario <=22) {
//30 20 3
// :-D
//30 21 3
// :-D
printf(":-D");
} else if (equipa >=22 && adversario >= 30) {
//22 30 3
// :-|
printf(":-|");
} else if (equipa >=20 && adversario >= 30) {
//21 30 3
// :-(
//20 30 3
// :-(
printf(":-(");
}
}
|
the_stack_data/170452371.c
|
//
// Created by xupeng on 2021/2/26.
//
#include <stdio.h>
#include <stdbool.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode* next;
}LNode,*LinkLine;
void initLine(LinkLine L);
void createLine(LinkLine L);
int main(){
LinkLine L;
initLine(L);
createLine(L);
printf("111\n");
while (L!= NULL){
printf("data:%d\n",L->data);
L=L->next;
}
return 0;
}
void initLine(LinkLine L){
L = NULL;
printf("不带头结点的线性链表初始化成功\n");
}
void createLine(LinkLine L){
LNode *S;ElemType x = 1;
L = (LinkLine)malloc((sizeof(LinkLine)));
while (x++<=10){
S=(LNode*)malloc(sizeof (LNode));
S->data =x;
S->next = NULL;
L->next =S;
}
}
|
the_stack_data/154827306.c
|
#include <stdio.h>
#include <stdlib.h>
char* scilab_rt_date__(){
char *s = (char*)malloc(128);
scanf("%s", s);
return s;
}
|
the_stack_data/150143874.c
|
#include <stdio.h>
#define SWAP(x, y, temp) ( temp=x, x=y, y=temp )
int time = 0;
void show(int* data, int size) {
for(int i = 0; i < size; i++) {
printf("%d ",data[i]);
}
printf("\n");
return;
}
void quicksort( int* data, int start, int end ) {
if ( start >= end ) {
return;
}
int key = start;
int i = start + 1, j = end, temp;
while( i <= j ) {
time++;
while( i <= end && data[i] <= data[key] ) {
time++;
i++;
}
while( j > start && data[j] >= data[key] ) {
time++;
j--;
}
if(i > j) {
SWAP(data[j], data[key], temp);
} else {
SWAP(data[i],data[j],temp);
}
}
quicksort( data , start , j - 1 );
quicksort( data, j + 1, end );
return;
}
int main(int argc,char* args) {
int array[10] = {1,10,5,8,7,6,4,3,2,9};
const int size = sizeof(array) / sizeof(int);
quicksort(array, 0, size - 1);
show(array, size);
printf("Time Complexity: %d\n",time);
return 0;
}
|
the_stack_data/212643873.c
|
/* whotofile.c
* purpose: show how to redirect output for another program
* idea: fork, then in the child, redirect output, then exec
*/
#include "stdio.h"
#include "stdlib.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/wait.h"
#include "fcntl.h"
int main()
{
int pid, fd;
printf( "About to run who into a file\n" );
// create a new process or quit
if( ( pid = fork() ) == -1 )
{
perror( "fork" );
exit(1);
}
// child does the work
if( pid == 0 )
{
close(1); // close
fd = creat( "userlist", 0644 ); // then open
execlp( "who", "who", NULL ); // and run
perror( "execlp" );
exit(1);
}
// parent waits then reports
if( pid != 0 )
{
wait( NULL );
printf( "Done running who. results in userlist\n" );
}
return 0;
}
|
the_stack_data/167331783.c
|
// RUN: %clang %s -mllvm -pre-RA-sched=fast -c -o %t-fast.o 2>&1 | FileCheck --allow-empty %s
// RUN: %clang %s -mllvm -pre-RA-sched=linearize -c -o %t-linearize.o 2>&1 | FileCheck --allow-empty %s
// CHECK-NOT: clang (LLVM option parsing): for the --pre-RA-sched option: Cannot find option named
|
the_stack_data/62637067.c
|
/*
* This font was extracted from the ROM of the
* SIEMENS/Commodore "Universal Btx Decoder"
* cartridge for the Commodore 64 (software V3.3)
* Commodore Artikel Nr. 606491
*/
unsigned char raw_font[] = {
/* raw 'primary graphic' set */
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x21 */ 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x22 */ 0, 0, 29, 48, 12, 48, 25, 32, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x23 */ 0, 0, 12, 48, 12, 48, 63, 60, 12, 48, 63, 60,
12, 48, 12, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x24 */ 0, 0, 48, 12, 31, 56, 56, 28, 48, 12, 56, 28,
31, 56, 48, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x25 */ 0, 0, 28, 28, 54, 48, 29, 32, 3, 0, 6, 56,
13, 44, 56, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x26 */ 0, 0, 15, 0, 25, 32, 25, 32, 31, 38, 48, 60,
48, 28, 15, 54, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x27 */ 0, 0, 28, 0, 12, 0, 24, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 0, 12, 0, 48, 3, 0, 3, 0, 3, 0,
0, 48, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x29 */ 0, 0, 12, 0, 3, 0, 0, 48, 0, 48, 0, 48,
3, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2a */ 0, 0, 3, 0, 51, 12, 15, 48, 3, 0, 15, 48,
51, 12, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2b */ 0, 0, 0, 0, 3, 0, 3, 0, 31, 56, 3, 0,
3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
14, 0, 6, 0, 12, 0, 0, 0, 0, 0, 0, 0,
/* 0x2d */ 0, 0, 0, 0, 0, 0, 0, 0, 31, 56, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2f */ 0, 0, 0, 24, 0, 48, 1, 32, 3, 0, 6, 0,
12, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x30 */ 0, 0, 15, 48, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x31 */ 0, 0, 3, 0, 15, 0, 3, 0, 3, 0, 3, 0,
3, 0, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x32 */ 0, 0, 15, 56, 24, 12, 0, 12, 7, 56, 12, 0,
24, 0, 31, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x33 */ 0, 0, 15, 56, 24, 12, 0, 12, 1, 56, 0, 12,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x34 */ 0, 0, 3, 48, 6, 48, 12, 48, 24, 48, 63, 60,
0, 48, 1, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x35 */ 0, 0, 31, 60, 24, 0, 31, 56, 0, 12, 0, 12,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x36 */ 0, 0, 15, 56, 24, 12, 24, 0, 31, 56, 24, 12,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x37 */ 0, 0, 31, 60, 24, 12, 0, 24, 0, 48, 1, 32,
3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x38 */ 0, 0, 15, 56, 24, 12, 24, 12, 15, 56, 24, 12,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x39 */ 0, 0, 15, 56, 24, 12, 24, 12, 15, 60, 0, 12,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3a */ 0, 0, 0, 0, 0, 0, 14, 0, 14, 0, 0, 0,
14, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3b */ 0, 0, 0, 0, 0, 0, 14, 0, 14, 0, 0, 0,
14, 0, 6, 0, 12, 0, 0, 0, 0, 0, 0, 0,
/* 0x3c */ 0, 0, 1, 48, 3, 0, 6, 0, 12, 0, 6, 0,
3, 0, 1, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3d */ 0, 0, 0, 0, 0, 0, 31, 56, 0, 0, 31, 56,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3e */ 0, 0, 14, 0, 3, 0, 1, 32, 0, 48, 1, 32,
3, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3f */ 0, 0, 15, 32, 24, 24, 0, 48, 3, 0, 3, 0,
0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x40 */ 0, 0, 31, 56, 48, 12, 51, 60, 54, 12, 51, 60,
48, 0, 31, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x41 */ 0, 0, 3, 32, 12, 24, 24, 12, 24, 12, 31, 60,
24, 12, 24, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x42 */ 0, 0, 63, 48, 24, 12, 24, 12, 31, 48, 24, 12,
24, 12, 63, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x43 */ 0, 0, 15, 60, 24, 12, 24, 0, 24, 0, 24, 0,
24, 12, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x44 */ 0, 0, 63, 48, 24, 24, 24, 12, 24, 12, 24, 12,
24, 24, 63, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x45 */ 0, 0, 63, 60, 24, 12, 24, 0, 31, 32, 24, 0,
24, 12, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x46 */ 0, 0, 63, 60, 24, 12, 24, 0, 31, 32, 24, 0,
24, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x47 */ 0, 0, 15, 60, 24, 12, 24, 0, 24, 62, 24, 12,
24, 12, 15, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x48 */ 0, 0, 60, 30, 24, 12, 24, 12, 31, 60, 24, 12,
24, 12, 60, 30, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x49 */ 0, 0, 15, 48, 3, 0, 3, 0, 3, 0, 3, 0,
3, 0, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4a */ 0, 0, 7, 60, 0, 24, 0, 24, 0, 24, 0, 24,
48, 24, 31, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4b */ 0, 0, 60, 28, 24, 48, 25, 32, 31, 0, 25, 32,
24, 48, 60, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4c */ 0, 0, 60, 0, 24, 0, 24, 0, 24, 0, 24, 0,
24, 12, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4d */ 0, 0, 56, 14, 28, 28, 30, 60, 27, 44, 25, 12,
24, 12, 60, 30, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4e */ 0, 0, 60, 30, 30, 12, 31, 12, 25, 44, 24, 60,
24, 28, 60, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4f */ 0, 0, 7, 48, 12, 24, 24, 12, 24, 12, 24, 12,
12, 24, 7, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x50 */ 0, 0, 63, 48, 24, 12, 24, 12, 31, 48, 24, 0,
24, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x51 */ 0, 0, 7, 48, 12, 24, 24, 12, 24, 12, 24, 12,
12, 24, 7, 48, 0, 60, 0, 0, 0, 0, 0, 0,
/* 0x52 */ 0, 0, 63, 48, 24, 24, 24, 24, 31, 48, 25, 32,
24, 48, 60, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x53 */ 0, 0, 15, 60, 24, 12, 24, 0, 15, 56, 0, 12,
24, 12, 31, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x54 */ 0, 0, 63, 60, 51, 12, 3, 0, 3, 0, 3, 0,
3, 0, 7, 32, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x55 */ 0, 0, 60, 60, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x56 */ 0, 0, 60, 60, 24, 24, 24, 24, 24, 24, 12, 48,
7, 32, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x57 */ 0, 0, 60, 60, 24, 24, 24, 24, 27, 24, 27, 24,
27, 24, 12, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x58 */ 0, 0, 56, 28, 24, 24, 12, 48, 3, 0, 12, 48,
24, 24, 56, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x59 */ 0, 0, 56, 28, 24, 24, 12, 48, 3, 0, 3, 0,
3, 0, 7, 32, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5a */ 0, 0, 31, 60, 24, 12, 0, 24, 1, 32, 6, 0,
24, 12, 31, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5b */ 15, 48, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0,
12, 0, 12, 0, 15, 48, 0, 0, 0, 0, 0, 0,
/* 0x5c */ 0, 0, 56, 0, 12, 0, 6, 0, 3, 0, 1, 32,
0, 48, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5d */ 15, 48, 0, 48, 0, 48, 0, 48, 0, 48, 0, 48,
0, 48, 0, 48, 15, 48, 0, 0, 0, 0, 0, 0,
/* 0x5e */ 7, 0, 13, 32, 24, 48, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 63, 60, 0, 0, 0, 0,
/* 0x60 */ 0, 0, 24, 0, 12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x61 */ 0, 0, 0, 0, 0, 0, 7, 48, 0, 12, 15, 60,
24, 12, 15, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x62 */ 0, 0, 56, 0, 24, 0, 31, 56, 24, 12, 24, 12,
24, 12, 63, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x63 */ 0, 0, 0, 0, 0, 0, 15, 60, 24, 12, 24, 0,
24, 0, 15, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x64 */ 0, 0, 0, 28, 0, 12, 15, 60, 24, 12, 24, 12,
24, 12, 15, 62, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x65 */ 0, 0, 0, 0, 0, 0, 15, 56, 24, 12, 31, 60,
24, 0, 15, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x66 */ 0, 0, 1, 56, 3, 0, 15, 48, 3, 0, 3, 0,
3, 0, 7, 32, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x67 */ 0, 0, 0, 0, 0, 0, 15, 60, 24, 24, 24, 24,
24, 24, 15, 56, 0, 24, 7, 48, 0, 0, 0, 0,
/* 0x68 */ 0, 0, 56, 0, 24, 0, 31, 48, 24, 24, 24, 24,
24, 24, 60, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x69 */ 0, 0, 1, 32, 0, 0, 7, 32, 1, 32, 1, 32,
1, 32, 7, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6a */ 0, 0, 0, 48, 0, 0, 0, 0, 7, 48, 0, 48,
0, 48, 0, 48, 48, 48, 31, 32, 0, 0, 0, 0,
/* 0x6b */ 0, 0, 56, 0, 24, 0, 24, 28, 25, 48, 31, 0,
25, 48, 56, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6c */ 0, 0, 15, 0, 3, 0, 3, 0, 3, 0, 3, 0,
3, 0, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6d */ 0, 0, 0, 0, 0, 0, 60, 48, 51, 12, 51, 12,
51, 12, 51, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6e */ 0, 0, 0, 0, 0, 0, 59, 48, 28, 24, 24, 24,
24, 24, 60, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6f */ 0, 0, 0, 0, 0, 0, 15, 48, 24, 24, 24, 24,
24, 24, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 63, 48, 24, 24, 24, 24,
24, 24, 31, 48, 24, 0, 60, 0, 0, 0, 0, 0,
/* 0x71 */ 0, 0, 0, 0, 0, 0, 15, 60, 24, 24, 24, 24,
24, 24, 15, 56, 0, 24, 0, 60, 0, 0, 0, 0,
/* 0x72 */ 0, 0, 0, 0, 0, 0, 61, 56, 14, 12, 12, 0,
12, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x73 */ 0, 0, 0, 0, 0, 0, 15, 56, 24, 0, 15, 48,
0, 24, 31, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x74 */ 0, 0, 3, 0, 3, 0, 31, 56, 3, 0, 3, 0,
3, 0, 1, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x75 */ 0, 0, 0, 0, 0, 0, 56, 56, 24, 24, 24, 24,
24, 56, 15, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x76 */ 0, 0, 0, 0, 0, 0, 60, 60, 24, 24, 12, 48,
7, 32, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x77 */ 0, 0, 0, 0, 0, 0, 48, 12, 51, 12, 55, 44,
60, 60, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 0, 0, 0, 0, 0, 0, 56, 56, 13, 32, 7, 0,
13, 32, 56, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x79 */ 0, 0, 0, 0, 0, 0, 60, 60, 24, 24, 12, 48,
7, 32, 3, 0, 6, 0, 28, 0, 0, 0, 0, 0,
/* 0x7a */ 0, 0, 0, 0, 0, 0, 31, 60, 16, 24, 3, 32,
12, 4, 31, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7b */ 1, 56, 3, 0, 3, 0, 3, 0, 6, 0, 3, 0,
3, 0, 3, 0, 1, 56, 0, 0, 0, 0, 0, 0,
/* 0x7c */ 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
3, 0, 3, 0, 3, 0, 3, 0, 0, 0, 0, 0,
/* 0x7d */ 15, 0, 1, 32, 1, 32, 1, 32, 0, 48, 1, 32,
1, 32, 1, 32, 15, 0, 0, 0, 0, 0, 0, 0,
/* 0x7e */ 63, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7f */ 0, 0, 31, 62, 31, 62, 31, 62, 31, 62, 31, 62,
31, 62, 31, 62, 31, 62, 0, 0, 0, 0, 0, 0,
/* raw '2nd supplementary mosaic' set */
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x21 */ 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x22 */ 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x23 */ 63, 63, 63, 63, 63, 63, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x24 */ 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63, 0,
63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x25 */ 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x26 */ 0, 63, 0, 63, 0, 63, 63, 0, 63, 0, 63, 0,
63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x27 */ 63, 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0,
63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63,
0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x29 */ 63, 0, 63, 0, 63, 0, 0, 63, 0, 63, 0, 63,
0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2a */ 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63,
0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2b */ 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0, 63,
0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2c */ 0, 0, 0, 0, 0, 0, 63, 63, 63, 63, 63, 63,
63, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2d */ 63, 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63,
63, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2e */ 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63, 63,
63, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2f */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x31 */ 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0, 0,
0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x32 */ 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0,
0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x33 */ 63, 63, 63, 63, 63, 63, 0, 0, 0, 0, 0, 0,
0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x34 */ 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63, 0,
63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x35 */ 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x36 */ 0, 63, 0, 63, 0, 63, 63, 0, 63, 0, 63, 0,
63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x37 */ 63, 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0,
63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63,
0, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x39 */ 63, 0, 63, 0, 63, 0, 0, 63, 0, 63, 0, 63,
0, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3a */ 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63,
0, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3b */ 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0, 63,
0, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3c */ 0, 0, 0, 0, 0, 0, 63, 63, 63, 63, 63, 63,
63, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3d */ 63, 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63,
63, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3e */ 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x3f */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0,
/* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 48, 0, 56, 0, 62, 0, 0, 0, 0, 0,
/* 0x41 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 56, 0, 63, 0, 63, 60, 0, 0, 0, 0,
/* 0x42 */ 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 48, 0,
56, 0, 60, 0, 62, 0, 63, 0, 0, 0, 0, 0,
/* 0x43 */ 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 60, 0,
63, 0, 63, 48, 63, 56, 63, 62, 0, 0, 0, 0,
/* 0x44 */ 0, 0, 32, 0, 32, 0, 48, 0, 56, 0, 56, 0,
60, 0, 60, 0, 62, 0, 63, 0, 0, 0, 0, 0,
/* 0x45 */ 0, 0, 48, 0, 56, 0, 60, 0, 63, 0, 63, 32,
63, 48, 63, 60, 63, 62, 63, 63, 0, 0, 0, 0,
/* 0x46 */ 1, 63, 7, 63, 31, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x47 */ 0, 3, 0, 63, 7, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x48 */ 0, 63, 1, 63, 3, 63, 7, 63, 15, 63, 31, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x49 */ 0, 1, 0, 7, 0, 31, 0, 63, 3, 63, 15, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x4a */ 0, 63, 1, 63, 1, 63, 3, 63, 7, 63, 7, 63,
15, 63, 15, 63, 31, 63, 63, 63, 0, 0, 0, 0,
/* 0x4b */ 0, 0, 0, 0, 0, 0, 0, 1, 0, 15, 3, 63,
31, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x4c */ 31, 63, 15, 63, 7, 63, 3, 63, 1, 63, 1, 63,
3, 63, 7, 63, 15, 63, 31, 63, 0, 0, 0, 0,
/* 0x4d */ 32, 1, 48, 3, 56, 7, 60, 15, 62, 31, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x4e */ 0, 0, 24, 0, 24, 0, 24, 0, 24, 0, 24, 0,
24, 0, 24, 0, 24, 0, 0, 0, 0, 0, 0, 0,
/* 0x4f */ 51, 12, 12, 51, 12, 51, 51, 12, 51, 12, 12, 51,
12, 51, 51, 12, 51, 12, 12, 51, 0, 0, 0, 0,
/* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 3, 0, 7, 0, 31, 0, 0, 0, 0,
/* 0x51 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 7, 0, 63, 15, 63, 0, 0, 0, 0,
/* 0x52 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3,
0, 7, 0, 15, 0, 31, 0, 63, 0, 0, 0, 0,
/* 0x53 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 15,
0, 63, 3, 63, 7, 63, 31, 63, 0, 0, 0, 0,
/* 0x54 */ 0, 0, 0, 1, 0, 1, 0, 3, 0, 3, 0, 7,
0, 7, 0, 15, 0, 15, 0, 31, 0, 0, 0, 0,
/* 0x55 */ 0, 1, 0, 3, 0, 7, 0, 31, 0, 63, 1, 63,
3, 63, 15, 63, 31, 63, 63, 63, 0, 0, 0, 0,
/* 0x56 */ 63, 32, 63, 56, 63, 60, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x57 */ 48, 0, 63, 0, 63, 56, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x58 */ 63, 0, 63, 32, 63, 48, 63, 56, 63, 60, 63, 62,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x59 */ 32, 0, 56, 0, 62, 0, 63, 0, 63, 0, 63, 48,
63, 60, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x5a */ 63, 0, 63, 32, 63, 32, 63, 48, 63, 56, 63, 56,
63, 60, 63, 60, 63, 62, 63, 63, 0, 0, 0, 0,
/* 0x5b */ 0, 0, 0, 0, 0, 0, 32, 0, 60, 0, 63, 48,
63, 62, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x5c */ 63, 62, 63, 60, 63, 56, 63, 48, 63, 32, 63, 32,
63, 48, 63, 56, 63, 60, 63, 62, 0, 0, 0, 0,
/* 0x5d */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 62, 31,
60, 15, 56, 7, 48, 3, 32, 1, 0, 0, 0, 0,
/* 0x5e */ 0, 0, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6,
0, 6, 0, 6, 0, 6, 0, 0, 0, 0, 0, 0,
/* 0x5f */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x61 */ 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x62 */ 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0,
0, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x63 */ 63, 63, 63, 63, 63, 63, 0, 0, 0, 0, 0, 0,
0, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x64 */ 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63, 0,
63, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x65 */ 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
63, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x66 */ 0, 63, 0, 63, 0, 63, 63, 0, 63, 0, 63, 0,
63, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x67 */ 63, 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0,
63, 0, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x68 */ 0, 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63,
0, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x69 */ 63, 0, 63, 0, 63, 0, 0, 63, 0, 63, 0, 63,
0, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6a */ 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63,
0, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6b */ 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0, 63,
0, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6c */ 0, 0, 0, 0, 0, 0, 63, 63, 63, 63, 63, 63,
63, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6d */ 63, 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63,
63, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6e */ 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63, 63,
63, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x6f */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 0, 63, 0, 63, 0, 63, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x71 */ 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0, 0,
0, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x72 */ 0, 63, 0, 63, 0, 63, 0, 0, 0, 0, 0, 0,
0, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x73 */ 63, 63, 63, 63, 63, 63, 0, 0, 0, 0, 0, 0,
0, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x74 */ 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63, 0,
63, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x75 */ 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
63, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x76 */ 0, 63, 0, 63, 0, 63, 63, 0, 63, 0, 63, 0,
63, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x77 */ 63, 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0,
63, 0, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x78 */ 0, 0, 0, 0, 0, 0, 0, 63, 0, 63, 0, 63,
0, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x79 */ 63, 0, 63, 0, 63, 0, 0, 63, 0, 63, 0, 63,
0, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7a */ 0, 63, 0, 63, 0, 63, 0, 63, 0, 63, 0, 63,
0, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7b */ 63, 63, 63, 63, 63, 63, 0, 63, 0, 63, 0, 63,
0, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7c */ 0, 0, 0, 0, 0, 0, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7d */ 63, 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7e */ 0, 63, 0, 63, 0, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 0, 0, 0, 0,
/* 0x7f */ 0, 0, 31, 62, 31, 62, 31, 62, 31, 62, 31, 62,
31, 62, 31, 62, 31, 62, 0, 0, 0, 0, 0, 0,
/* raw 'supplementary graphic' set */
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x21 */ 0, 0, 3, 0, 0, 0, 3, 0, 3, 0, 3, 0,
3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x22 */ 0, 0, 1, 32, 1, 32, 15, 60, 25, 44, 25, 32,
25, 32, 15, 60, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x23 */ 0, 0, 1, 56, 3, 12, 3, 0, 15, 48, 3, 0,
3, 0, 31, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x24 */ 3, 0, 15, 48, 51, 12, 51, 0, 15, 48, 3, 12,
51, 12, 15, 48, 3, 0, 0, 0, 0, 0, 0, 0,
/* 0x25 */ 0, 0, 48, 12, 48, 12, 48, 12, 12, 48, 3, 0,
15, 48, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0,
/* 0x26 */ 0, 0, 12, 48, 12, 48, 63, 60, 12, 48, 63, 60,
12, 48, 12, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x27 */ 0, 0, 15, 60, 24, 0, 15, 56, 24, 12, 15, 56,
0, 12, 31, 56, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 48, 12, 31, 56, 56, 28, 48, 12, 56, 28,
31, 56, 48, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x29 */ 0, 0, 6, 0, 12, 0, 14, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2a */ 0, 0, 6, 24, 12, 48, 14, 56, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2b */ 0, 0, 6, 12, 12, 24, 24, 48, 49, 32, 24, 48,
12, 24, 6, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2c */ 0, 0, 4, 0, 12, 0, 28, 0, 63, 63, 28, 0,
12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2d */ 1, 32, 3, 48, 7, 56, 15, 60, 1, 32, 1, 32,
1, 32, 1, 32, 1, 32, 0, 0, 0, 0, 0, 0,
/* 0x2e */ 0, 0, 0, 32, 0, 48, 0, 56, 63, 60, 0, 56,
0, 48, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x2f */ 0, 0, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32,
15, 60, 7, 56, 3, 48, 1, 32, 0, 0, 0, 0,
/* 0x30 */ 7, 32, 12, 48, 7, 32, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x31 */ 0, 0, 3, 0, 3, 0, 63, 60, 3, 0, 3, 0,
0, 0, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x32 */ 15, 0, 49, 32, 3, 0, 12, 0, 63, 32, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x33 */ 62, 0, 3, 0, 6, 0, 3, 0, 62, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x34 */ 0, 0, 0, 0, 0, 0, 12, 24, 6, 48, 3, 32,
6, 48, 12, 24, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x35 */ 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24,
24, 24, 31, 44, 24, 0, 24, 0, 0, 0, 0, 0,
/* 0x36 */ 0, 0, 15, 60, 51, 12, 51, 12, 15, 60, 3, 12,
3, 12, 3, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x37 */ 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x38 */ 0, 0, 0, 0, 3, 0, 0, 0, 31, 56, 0, 0,
3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x39 */ 0, 0, 14, 0, 6, 0, 12, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3a */ 0, 0, 14, 56, 6, 24, 12, 48, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3b */ 0, 0, 49, 32, 24, 48, 12, 24, 6, 12, 12, 24,
24, 48, 49, 32, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x3c */ 12, 0, 60, 0, 12, 12, 12, 48, 3, 30, 12, 54,
49, 38, 1, 62, 0, 6, 0, 0, 0, 0, 0, 0,
/* 0x3d */ 12, 0, 60, 0, 12, 12, 12, 48, 3, 30, 13, 35,
48, 12, 0, 48, 1, 63, 0, 0, 0, 0, 0, 0,
/* 0x3e */ 60, 0, 6, 2, 12, 12, 6, 48, 59, 30, 12, 54,
49, 38, 3, 62, 0, 6, 0, 0, 0, 0, 0, 0,
/* 0x3f */ 0, 0, 3, 0, 0, 0, 3, 0, 3, 0, 6, 0,
12, 0, 12, 24, 7, 48, 0, 0, 0, 0, 0, 0,
/* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x41 */ 3, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x42 */ 3, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x43 */ 3, 0, 12, 48, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x44 */ 7, 12, 12, 56, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x45 */ 31, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x46 */ 12, 48, 7, 32, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x47 */ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x48 */ 12, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x49 */ 12, 24, 12, 24, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4a */ 7, 32, 12, 48, 7, 32, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 1, 0, 7, 0, 0, 0, 0, 0,
/* 0x4c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4d */ 12, 48, 25, 32, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 2, 0, 3, 32, 0, 0, 0, 0,
/* 0x4f */ 12, 48, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 63, 63, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x51 */ 12, 0, 60, 0, 12, 0, 12, 0, 12, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x52 */ 31, 62, 48, 3, 55, 51, 54, 27, 55, 35, 54, 51,
54, 27, 48, 3, 31, 60, 0, 0, 0, 0, 0, 0,
/* 0x53 */ 31, 60, 48, 6, 51, 54, 54, 54, 54, 6, 54, 54,
51, 38, 48, 6, 31, 60, 0, 0, 0, 0, 0, 0,
/* 0x54 */ 0, 0, 0, 0, 63, 4, 9, 44, 9, 60, 9, 20,
9, 4, 9, 4, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x55 */ 3, 32, 3, 48, 3, 24, 3, 12, 3, 0, 15, 0,
63, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x56 */ 6, 12, 6, 12, 0, 0, 7, 48, 0, 12, 15, 60,
24, 12, 15, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x57 */ 12, 48, 12, 48, 0, 0, 15, 48, 24, 24, 24, 24,
24, 24, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x58 */ 24, 24, 24, 24, 0, 0, 56, 56, 24, 24, 24, 24,
24, 56, 15, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x59 */ 12, 48, 0, 0, 7, 48, 12, 24, 24, 12, 31, 60,
24, 12, 24, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5a */ 12, 48, 0, 0, 7, 48, 12, 24, 24, 12, 24, 12,
12, 24, 7, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5b */ 12, 48, 0, 0, 60, 60, 24, 24, 24, 24, 24, 24,
24, 24, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5c */ 0, 0, 24, 8, 56, 16, 24, 32, 25, 60, 26, 36,
4, 60, 8, 36, 16, 60, 0, 0, 0, 0, 0, 0,
/* 0x5d */ 60, 0, 6, 8, 28, 16, 6, 32, 61, 60, 2, 36,
4, 60, 8, 36, 16, 60, 0, 0, 0, 0, 0, 0,
/* 0x5e */ 60, 0, 32, 8, 60, 16, 6, 32, 61, 60, 2, 36,
4, 60, 8, 36, 16, 60, 0, 0, 0, 0, 0, 0,
/* 0x5f */ 62, 0, 34, 8, 4, 16, 8, 32, 9, 60, 2, 36,
4, 60, 8, 36, 16, 60, 0, 0, 0, 0, 0, 0,
/* 0x60 */ 0, 0, 15, 48, 24, 24, 48, 12, 48, 12, 24, 24,
12, 48, 60, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x61 */ 0, 0, 7, 56, 15, 0, 25, 32, 25, 60, 31, 32,
48, 48, 48, 62, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x62 */ 0, 0, 15, 48, 12, 12, 12, 12, 63, 12, 12, 12,
12, 12, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x63 */ 0, 0, 15, 48, 0, 24, 15, 56, 24, 24, 15, 60,
0, 0, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x64 */ 12, 48, 63, 60, 12, 48, 12, 48, 15, 48, 12, 48,
12, 48, 12, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x65 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x66 */ 0, 0, 48, 60, 48, 12, 48, 12, 48, 12, 48, 12,
48, 12, 48, 12, 3, 48, 0, 0, 0, 0, 0, 0,
/* 0x67 */ 0, 0, 48, 0, 48, 0, 48, 0, 48, 48, 48, 0,
48, 0, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x68 */ 0, 0, 12, 0, 12, 0, 15, 0, 12, 0, 60, 0,
12, 0, 15, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x69 */ 0, 12, 7, 56, 24, 60, 25, 44, 25, 12, 27, 12,
30, 12, 15, 48, 24, 0, 0, 0, 0, 0, 0, 0,
/* 0x6a */ 0, 0, 15, 62, 49, 32, 49, 32, 49, 60, 49, 0,
49, 32, 15, 62, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6b */ 0, 0, 15, 48, 24, 24, 24, 24, 24, 24, 15, 48,
0, 0, 63, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6c */ 0, 0, 63, 0, 12, 0, 15, 48, 12, 12, 15, 48,
12, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6d */ 0, 0, 63, 60, 3, 0, 3, 0, 15, 48, 3, 0,
3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6e */ 0, 0, 51, 48, 60, 12, 48, 12, 48, 12, 48, 12,
51, 12, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6f */ 0, 0, 48, 0, 48, 0, 15, 48, 12, 12, 12, 12,
12, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 48, 48, 51, 0, 60, 0,
51, 12, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x71 */ 0, 0, 14, 24, 49, 38, 1, 38, 15, 62, 49, 32,
49, 38, 14, 60, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x72 */ 0, 0, 0, 48, 3, 60, 0, 48, 15, 48, 48, 48,
48, 48, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x73 */ 3, 0, 1, 56, 3, 48, 0, 24, 0, 12, 15, 60,
48, 12, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x74 */ 0, 0, 12, 0, 63, 0, 12, 0, 15, 48, 12, 12,
12, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x75 */ 0, 0, 0, 0, 0, 0, 7, 48, 0, 48, 0, 48,
0, 48, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x76 */ 0, 0, 48, 48, 0, 0, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 1, 32, 0, 0, 0, 0, 0, 0,
/* 0x77 */ 0, 0, 15, 0, 3, 0, 3, 0, 3, 12, 3, 0,
3, 0, 15, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 3, 0, 3, 0, 3, 48, 3, 0, 15, 0, 3, 0,
3, 0, 1, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x79 */ 0, 0, 0, 12, 7, 56, 24, 60, 25, 44, 27, 12,
30, 12, 15, 48, 24, 0, 0, 0, 0, 0, 0, 0,
/* 0x7a */ 0, 0, 0, 0, 14, 24, 49, 38, 49, 60, 49, 32,
49, 38, 14, 28, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7b */ 0, 0, 7, 32, 24, 24, 24, 24, 25, 32, 24, 24,
24, 24, 27, 48, 24, 0, 24, 0, 0, 0, 0, 0,
/* 0x7c */ 0, 0, 12, 0, 12, 0, 15, 48, 12, 12, 15, 48,
12, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7d */ 0, 0, 3, 0, 63, 60, 3, 0, 15, 48, 3, 0,
3, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7e */ 0, 0, 0, 0, 0, 0, 51, 48, 60, 12, 48, 12,
51, 12, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7f */ 0, 0, 31, 62, 31, 62, 31, 62, 31, 62, 31, 62,
31, 62, 31, 62, 31, 62, 0, 0, 0, 0, 0, 0,
/* raw '3rd supplementary mosaic' set */
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x21 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x22 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x23 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x24 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x25 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x26 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x27 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x28 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x29 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2a */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2b */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2c */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2d */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2e */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x2f */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x30 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x31 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x32 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x33 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x34 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x35 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x36 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x37 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x38 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x39 */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3a */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3b */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3c */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3d */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3e */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x3f */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x40 */ 1, 32, 1, 32, 1, 32, 63, 63, 63, 63, 63, 63,
63, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x41 */ 0, 0, 0, 0, 0, 0, 63, 63, 63, 63, 63, 63,
63, 63, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x42 */ 1, 32, 1, 32, 1, 32, 1, 63, 1, 63, 1, 63,
1, 63, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x43 */ 1, 32, 1, 32, 1, 32, 63, 32, 63, 32, 63, 32,
63, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x44 */ 3, 0, 6, 0, 12, 0, 24, 0, 48, 0, 48, 0,
24, 0, 12, 0, 6, 0, 3, 0, 0, 0, 0, 0,
/* 0x45 */ 0, 48, 0, 24, 0, 12, 0, 6, 0, 3, 0, 3,
0, 6, 0, 12, 0, 24, 0, 48, 0, 0, 0, 0,
/* 0x46 */ 0, 0, 0, 0, 0, 0, 0, 0, 32, 1, 48, 3,
24, 6, 12, 12, 6, 24, 3, 48, 0, 0, 0, 0,
/* 0x47 */ 3, 48, 6, 24, 12, 12, 24, 6, 48, 3, 32, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x48 */ 3, 0, 6, 0, 12, 0, 24, 0, 48, 0, 32, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x49 */ 0, 48, 0, 24, 0, 12, 0, 6, 0, 3, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4a */ 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 48, 0,
24, 0, 12, 0, 6, 0, 3, 0, 0, 0, 0, 0,
/* 0x4b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3,
0, 6, 0, 12, 0, 24, 0, 48, 0, 0, 0, 0,
/* 0x4c */ 1, 32, 1, 32, 1, 32, 63, 63, 63, 63, 63, 63,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x4d */ 0, 0, 0, 0, 0, 0, 3, 48, 7, 56, 7, 56,
3, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4e */ 0, 0, 7, 56, 31, 62, 63, 63, 63, 63, 63, 63,
63, 63, 31, 62, 7, 56, 0, 0, 0, 0, 0, 0,
/* 0x4f */ 0, 0, 7, 56, 28, 14, 48, 3, 48, 3, 48, 3,
48, 3, 28, 14, 7, 56, 0, 0, 0, 0, 0, 0,
/* 0x50 */ 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x51 */ 0, 0, 0, 0, 0, 0, 0, 0, 63, 63, 63, 63,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x52 */ 0, 0, 0, 0, 0, 0, 0, 0, 1, 63, 1, 63,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x53 */ 0, 0, 0, 0, 0, 0, 0, 0, 63, 32, 63, 32,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x54 */ 1, 32, 1, 32, 1, 32, 1, 32, 1, 63, 1, 63,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x55 */ 1, 32, 1, 32, 1, 32, 1, 32, 63, 32, 63, 32,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x56 */ 1, 32, 1, 32, 1, 32, 1, 32, 1, 63, 1, 63,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x57 */ 1, 32, 1, 32, 1, 32, 1, 32, 63, 32, 63, 32,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0, 63, 63, 63, 63,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x59 */ 1, 32, 1, 32, 1, 32, 1, 32, 63, 63, 63, 63,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5a */ 1, 32, 1, 32, 1, 32, 1, 32, 63, 63, 63, 63,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x5b */ 0, 0, 0, 0, 3, 0, 3, 48, 63, 60, 63, 60,
3, 48, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5c */ 0, 0, 0, 0, 0, 48, 3, 48, 15, 63, 15, 63,
3, 48, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5d */ 0, 0, 1, 32, 3, 48, 7, 56, 15, 60, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 0, 0, 0, 0,
/* 0x5e */ 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 15, 60,
7, 56, 3, 48, 1, 32, 0, 0, 0, 0, 0, 0,
/* 0x5f */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x60 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 15, 63, 7, 63, 1, 63, 0, 0, 0, 0,
/* 0x61 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 7, 63, 0, 63, 0, 3, 0, 0, 0, 0,
/* 0x62 */ 63, 63, 63, 63, 63, 63, 63, 63, 31, 63, 15, 63,
7, 63, 3, 63, 1, 63, 0, 63, 0, 0, 0, 0,
/* 0x63 */ 63, 63, 63, 63, 63, 63, 63, 63, 15, 63, 3, 63,
0, 63, 0, 15, 0, 7, 0, 1, 0, 0, 0, 0,
/* 0x64 */ 63, 63, 31, 63, 31, 63, 15, 63, 7, 63, 7, 63,
3, 63, 3, 63, 1, 63, 0, 63, 0, 0, 0, 0,
/* 0x65 */ 31, 63, 15, 63, 7, 63, 3, 63, 1, 63, 0, 31,
0, 15, 0, 7, 0, 3, 0, 1, 0, 0, 0, 0,
/* 0x66 */ 62, 0, 56, 0, 48, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x67 */ 63, 60, 63, 0, 56, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x68 */ 63, 0, 62, 0, 60, 0, 56, 0, 48, 0, 32, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x69 */ 63, 62, 63, 56, 63, 32, 63, 0, 60, 0, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6a */ 63, 0, 62, 0, 62, 0, 60, 0, 56, 0, 56, 0,
48, 0, 48, 0, 32, 0, 0, 0, 0, 0, 0, 0,
/* 0x6b */ 63, 63, 63, 63, 63, 63, 63, 62, 63, 48, 60, 0,
32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6c */ 32, 0, 48, 0, 56, 0, 60, 0, 62, 0, 62, 0,
60, 0, 56, 0, 48, 0, 32, 0, 0, 0, 0, 0,
/* 0x6d */ 31, 62, 15, 60, 7, 56, 3, 48, 1, 32, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6e */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x6f */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x70 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 60, 63, 56, 63, 32, 0, 0, 0, 0,
/* 0x71 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 56, 63, 0, 48, 0, 0, 0, 0, 0,
/* 0x72 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 62, 63, 60,
63, 56, 63, 48, 63, 32, 63, 0, 0, 0, 0, 0,
/* 0x73 */ 63, 63, 63, 63, 63, 63, 63, 63, 63, 60, 63, 48,
63, 0, 60, 0, 56, 0, 32, 0, 0, 0, 0, 0,
/* 0x74 */ 63, 63, 63, 62, 63, 62, 63, 60, 63, 56, 63, 56,
63, 48, 63, 48, 63, 32, 63, 0, 0, 0, 0, 0,
/* 0x75 */ 63, 62, 63, 60, 63, 56, 63, 48, 63, 32, 62, 0,
60, 0, 56, 0, 48, 0, 32, 0, 0, 0, 0, 0,
/* 0x76 */ 0, 31, 0, 7, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x77 */ 15, 63, 0, 63, 0, 7, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 0, 63, 0, 31, 0, 15, 0, 7, 0, 3, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x79 */ 31, 63, 7, 63, 1, 63, 0, 63, 0, 15, 0, 3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7a */ 0, 63, 0, 31, 0, 31, 0, 15, 0, 7, 0, 7,
0, 3, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0,
/* 0x7b */ 63, 63, 63, 63, 63, 63, 31, 63, 3, 63, 0, 15,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7c */ 0, 3, 0, 7, 0, 15, 0, 31, 0, 63, 0, 63,
0, 31, 0, 15, 0, 7, 0, 3, 0, 0, 0, 0,
/* 0x7d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 32,
3, 48, 7, 56, 15, 60, 31, 62, 0, 0, 0, 0,
/* 0x7e */ 63, 63, 60, 63, 63, 63, 60, 63, 60, 63, 57, 63,
51, 63, 51, 39, 56, 15, 63, 63, 0, 0, 0, 0,
/* 0x7f */ 0, 0, 31, 62, 31, 62, 31, 62, 31, 62, 31, 62,
31, 62, 31, 62, 31, 62, 0, 0, 0, 0, 0, 0,
};
|
the_stack_data/96694.c
|
#include <stdbool.h>
#include <string.h>
#include <strings.h>
#include "clif.h"
inline
const char *clif_token_str(const unsigned int i)
{
return clif_token_get(i);
}
const char *clif_token_str_default(const unsigned int i, const char *def_val)
{
const char *result;
result = clif_token_get(i);
if (strlen(result) == 0)
{
return def_val;
}
return result;
}
char clif_token_char_default(const unsigned int i, char def_val)
{
char result;
if (sscanf(clif_token_get(i), "%c", &result) == 1)
return result;
else
return def_val;
}
int clif_token_int_default(const unsigned int i, int def_val)
{
int result;
if (sscanf(clif_token_get(i), "%d", &result) == 1)
return result;
else
return def_val;
}
unsigned int clif_token_uint_default(const unsigned int i, unsigned int def_val)
{
unsigned int result;
if (sscanf(clif_token_get(i), "%u", &result) == 1)
return result;
else
return def_val;
}
long int clif_token_lint_default(const unsigned int i, long int def_val)
{
long int result;
if (sscanf(clif_token_get(i), "%ld", &result) == 1)
return result;
else
return def_val;
}
unsigned long int clif_token_ulint_default(const unsigned int i, unsigned long int def_val)
{
unsigned long int result;
if (sscanf(clif_token_get(i), "%lu", &result) == 1)
return result;
else
return def_val;
}
unsigned int clif_token_hex_default(const unsigned int i, unsigned int def_val)
{
unsigned int result;
if (sscanf(clif_token_get(i), "%x", &result) == 1)
return result;
else
return def_val;
}
unsigned int clif_token_oct_default(const unsigned int i, unsigned int def_val)
{
unsigned int result;
if (sscanf(clif_token_get(i), "%o", &result) == 1)
return result;
else
return def_val;
}
int clif_token_num_default(const unsigned int i, int def_val)
{
int result;
if (sscanf(clif_token_get(i), "%i", &result) == 1)
return result;
else
return def_val;
}
float clif_token_float_default(const unsigned int i, float def_val)
{
float result;
if (sscanf(clif_token_get(i), "%f", &result) == 1)
return result;
else
return def_val;
}
double clif_token_double_default(const unsigned int i, double def_val)
{
double result;
if (sscanf(clif_token_get(i), "%lf", &result) == 1)
return result;
else
return def_val;
}
bool clif_token_bool_default(const unsigned int i, bool def_val)
{
const char *tk_value;
tk_value = clif_token_get(i);
if (def_val)
{
if (strcmp(tk_value, "0") == 0)
return false;
if (strcasecmp(tk_value, "false") == 0)
return false;
if (strcasecmp(tk_value, "no") == 0)
return false;
if (strcasecmp(tk_value, "n") == 0)
return false;
return true;
}
else
{
if (strcmp(tk_value, "1") == 0)
return true;
if (strcasecmp(tk_value, "true") == 0)
return true;
if (strcasecmp(tk_value, "yes") == 0)
return true;
if (strcasecmp(tk_value, "y") == 0)
return true;
return false;
}
}
|
the_stack_data/175142713.c
|
/* This file auto-generated from standard.mac by genmacro.c - don't edit it */
#include <stddef.h>
static const char *nasm_standard_mac[] = {
"%define __FILE__",
"%define __LINE__",
"%define __SECT__ [section .text]",
"%imacro section 1+.nolist",
"%define __SECT__ [section %1]",
"__SECT__",
"%endmacro",
"%imacro segment 1+.nolist",
"%define __SECT__ [segment %1]",
"__SECT__",
"%endmacro",
"%imacro absolute 1+.nolist",
"%define __SECT__ [absolute %1]",
"__SECT__",
"%endmacro",
"%imacro struc 1-2.nolist 0",
"%push struc",
"%define %$strucname %1",
"[absolute %2]",
"%$strucname:",
"%endmacro",
"%imacro endstruc 0.nolist",
"%{$strucname}_size EQU $ - %$strucname",
"%pop",
"__SECT__",
"%endmacro",
"%imacro istruc 1.nolist",
"%push istruc",
"%define %$strucname %1",
"%$strucstart:",
"%endmacro",
"%imacro at 1-2+.nolist",
"times %1-($-%$strucstart) db 0",
"%2",
"%endmacro",
"%imacro iend 0.nolist",
"times %{$strucname}_size-($-%$strucstart) db 0",
"%pop",
"%endmacro",
"%imacro align 1-2+.nolist nop",
"%ifidni %2,nop",
"[align %1]",
"%else",
"times ($$-$) & ((%1)-1) %2",
"%endif",
"%endmacro",
"%imacro alignb 1-2+.nolist resb 1",
"times ($$-$) & ((%1)-1) %2",
"%endmacro",
"%imacro extern 1-*.nolist",
"%rep %0",
"[extern %1]",
"%rotate 1",
"%endrep",
"%endmacro",
"%imacro bits 1+.nolist",
"[bits %1]",
"%endmacro",
"%imacro use16 0.nolist",
"[bits 16]",
"%endmacro",
"%imacro use32 0.nolist",
"[bits 32]",
"%endmacro",
"%imacro use64 0.nolist",
"[bits 64]",
"%endmacro",
"%imacro global 1-*.nolist",
"%rep %0",
"[global %1]",
"%rotate 1",
"%endrep",
"%endmacro",
"%imacro common 1-*.nolist",
"%rep %0",
"[common %1]",
"%rotate 1",
"%endrep",
"%endmacro",
"%imacro cpu 1+.nolist",
"[cpu %1]",
"%endmacro",
"%imacro default 1+.nolist",
"[default %1]",
"%endmacro",
"%define __OUTPUT_FORMAT__ __YASM_OBJFMT__",
NULL
};
|
the_stack_data/237642714.c
|
#include<stdio.h>
int delete_element(int );
void print();
int elements,index;
int arr[]={0};
int main(){
int i;
printf("Enter the Size of Array: ");
scanf("%d",&elements);
printf("Enter element One by One: ");
for(i=0;i<elements;i++){
scanf("%d",&arr[i]);
}
printf("Enter the apropriate Index: ");
scanf("%d",&index);
delete_element(index);
printf("Element is deleted that was at index %d",index);
int test;
printf("==============================================================\nPress 1 if you want to print updated array otherwise press 0 :");
scanf("%d",&test);
if(test==1){
print();
}
return 0;
}
int delete_element(int index){
int j;
int deleted_element=arr[index];
for(j=index;j<elements;j++){
arr[j]=arr[j+1];
}
return deleted_element;
}
void print(){
int j;
for(j=0;j<elements-1;j++){
printf("%d\t",arr[j]);
}
}
|
the_stack_data/88450.c
|
#include <stdio.h>
#include <assert.h>
void mainQ(int guess, int t, int n, int m, int d, int secret) {
int p = 0;
int i = 0;
assert(guess > secret);
if(guess <= secret){
if(t == 1){
p += 1;
}
else if(t == 2){
for(i = 0; i<n;i++){
p += 1;
}
}
else{
for(i = 0; i<n*n*n;i++){
p += 1;
}
}
}
else{
if(t == 1){
p += 1;
}
else if(t == 2){
for(i = 0; i<n*n;i++){
p += 1;
}
}
else{
for(i = 0; i<n*n*n;i++){
p += 1;
}
}
}
//%%%traces: int n, int p
}
int main(int argc, char **argv) {
mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]), atoi(argv[4]), atoi(argv[5]), atoi(argv[6]));
return 0;
}
|
the_stack_data/61075416.c
|
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
void pre_exit(int);
int main(int argc, char *argv[]) {
pid_t pid;
int status;
// normal exit
if ((pid = fork()) < 0) {
printf("fork occurs error.\n");
exit(0);
} else if (pid == 0) {
exit(7);
}
if (wait(&status) != pid) {
printf("wait occurs error.\n");
}
pre_exit(status);
// abnormal exit
if ((pid = fork()) < 0) {
printf("fork occurs error.\n");
} else if (pid == 0) {
abort();
}
if (wait(&status) != pid) {
printf("wait occurs error.\n");
}
pre_exit(status);
// signal exit
if ((pid = fork()) <0) {
printf("fork occurs error.\n");
} else if (pid == 0) {
status /= 0;
}
if (wait(&status) != pid) {
printf("wait occurs error.\n");
}
pre_exit(status);
return 0;
}
void pre_exit(int status) {
if (WIFEXITED(status)) {
printf("normal termination, exit status = %d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("abnormal termination, signal number = %d%s\n", WTERMSIG(status),
#ifdef WCOREDUMP
WCOREDUMP(status) ? " (core file generated)" : "");
#else
"");
#endif
} else if (WIFSTOPPED(status)) {
printf("child stoped, signal number = %d\n", WSTOPSIG(status));
}
}
|
the_stack_data/649762.c
|
/* Create macros so that the matrices are stored in column-major order */
#define A(i,j) a[ (j)*lda + (i) ]
#define B(i,j) b[ (j)*ldb + (i) ]
#define C(i,j) c[ (j)*ldc + (i) ]
/* Routine for computing C = A * B + C */
void AddDot1x4( int, double *, int, double *, int, double *, int );
void MY_MMult( int m, int n, int k, double *a, int lda,
double *b, int ldb,
double *c, int ldc )
{
int i, j;
for ( j=0; j<n; j+=4 ){ /* Loop over the columns of C, unrolled by 4 */
for ( i=0; i<m; i+=1 ){ /* Loop over the rows of C */
/* Update C( i,j ), C( i,j+1 ), C( i,j+2 ), and C( i,j+3 ) in
one routine (four inner products) */
AddDot1x4( k, &A( i,0 ), lda, &B( 0,j ), ldb, &C( i,j ), ldc );
}
}
}
void AddDot1x4( int k, double *a, int lda, double *b, int ldb, double *c, int ldc )
{
/* So, this routine computes four elements of C:
C( 0, 0 ), C( 0, 1 ), C( 0, 2 ), C( 0, 3 ).
Notice that this routine is called with c = C( i, j ) in the
previous routine, so these are actually the elements
C( i, j ), C( i, j+1 ), C( i, j+2 ), C( i, j+3 )
in the original matrix C.
We next use indirect addressing */
int p;
register double
/* hold contributions to
C( 0, 0 ), C( 0, 1 ), C( 0, 2 ), C( 0, 3 ) */
c_00_reg, c_01_reg, c_02_reg, c_03_reg,
/* holds A( 0, p ) */
a_0p_reg;
double
/* Point to the current elements in the four columns of B */
*bp0_pntr, *bp1_pntr, *bp2_pntr, *bp3_pntr;
bp0_pntr = &B( 0, 0 );
bp1_pntr = &B( 0, 1 );
bp2_pntr = &B( 0, 2 );
bp3_pntr = &B( 0, 3 );
c_00_reg = 0.0;
c_01_reg = 0.0;
c_02_reg = 0.0;
c_03_reg = 0.0;
for ( p=0; p<k; p+=4 ){
a_0p_reg = A( 0, p );
c_00_reg += a_0p_reg * *bp0_pntr;
c_01_reg += a_0p_reg * *bp1_pntr;
c_02_reg += a_0p_reg * *bp2_pntr;
c_03_reg += a_0p_reg * *bp3_pntr;
a_0p_reg = A( 0, p+1 );
c_00_reg += a_0p_reg * *(bp0_pntr+1);
c_01_reg += a_0p_reg * *(bp1_pntr+1);
c_02_reg += a_0p_reg * *(bp2_pntr+1);
c_03_reg += a_0p_reg * *(bp3_pntr+1);
a_0p_reg = A( 0, p+2 );
c_00_reg += a_0p_reg * *(bp0_pntr+2);
c_01_reg += a_0p_reg * *(bp1_pntr+2);
c_02_reg += a_0p_reg * *(bp2_pntr+2);
c_03_reg += a_0p_reg * *(bp3_pntr+2);
a_0p_reg = A( 0, p+3 );
c_00_reg += a_0p_reg * *(bp0_pntr+3);
c_01_reg += a_0p_reg * *(bp1_pntr+3);
c_02_reg += a_0p_reg * *(bp2_pntr+3);
c_03_reg += a_0p_reg * *(bp3_pntr+3);
bp0_pntr+=4;
bp1_pntr+=4;
bp2_pntr+=4;
bp3_pntr+=4;
}
C( 0, 0 ) += c_00_reg;
C( 0, 1 ) += c_01_reg;
C( 0, 2 ) += c_02_reg;
C( 0, 3 ) += c_03_reg;
}
|
the_stack_data/146069.c
|
// gcc make_fill_rules.c -o make_fill_rules
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//# zoning road variant height sidelen err major minor angle agb agb fac fac fac agb fac ags fil
//# min max min max min max min max min max min slop width depth extra
// FILL_RULE ind_high_solid 2 -1 0 0 0 0 0 0 0 0 0 0 0 56 2 15 30 7.5 ind_high.agb ind_high.fac NO_VALUE parking.fac
float block_widths[8] = { 7.5, 15, 22.5, 30, 45, 60, 75, 90 };
float arch_heights[8] = { 24, 24, 24, 32, 999, 999, 999, 999 };
float block_heights[8] = { 10, 16, 24, 32, 40, 80, 120, 999 };
float block_chance_30[64]= { 10, 21, 30, 20, 10, 5, 3, 1,
12, 30, 30, 20, 5, 2, 1, 0,
10, 25, 30, 25, 5, 3, 2, 0,
1, 20, 25, 28, 10, 7, 7, 2,
0, 10, 25, 30, 15, 10, 5, 5,
0, 0, 15, 35, 25, 20, 5, 0,
0, 0, 0, 35, 40, 20, 5, 0,
0, 0, 0, 35, 40, 20, 5, 0 };
float block_width_60[8] = { 7.5, 15, 22.5, 30, 45, 60, 75, 90 };
float block_chance_60[64]= { 0, 21, 30, 30, 10, 5, 3, 1,
0, 35, 35, 25, 5, 0, 0, 0,
10, 25, 30, 25, 5, 5, 0, 0,
1, 20, 25, 35, 15, 4, 0, 0,
0, 15, 30, 35, 15, 5, 0, 0,
0, 5, 15, 35, 40, 5, 0, 0,
0, 0, 10, 35, 35, 15, 5, 0,
0, 0, 0, 0, 25, 50, 25, 0 };
// 0-10 10-16 16-24 24-32 32-40 40-80 80-120 120+
float block_height_table[64]={ 100, 0, 0, 0, 0, 0, 0, 0, // 0-10
50, 50, 0, 0, 0, 0, 0, 0, // 10-16
20, 30, 50, 0, 0, 0, 0, 0, // 16-24
5, 25, 35, 35, 0, 0, 0, 0, // 24-32
5, 10, 20, 35, 30, 0, 0, 0, // 32-40
5, 10, 15, 15, 20, 35, 0, 0, // 40-80
0, 10, 10, 10, 10, 20, 40, 0, // 80-120
0, 0, 15, 15, 10, 10, 10, 40 };//120+
float random_percent(void)
{
return random() % 100;
}
int pick_histo(float * table)
{
// int i;
// float s = 0;
// for(i = 0; i < 8; ++i)
// s += table[i];
// if(s != 100.0)
// {
// for(i = 0; i < 8; ++i)
// printf("%f\n",table[i]);
// abort();
// }
float percent = random_percent();
int idx = 0;
while(percent > table[idx])
{
percent -= table[idx];
++idx;
}
if(idx > 7) return 7;
// if(idx >= 8)
// {
// for(i = 0; i < 8; ++i)
// printf("%f\n",table[i]);
// abort();
// }
return idx;
}
float bldg_width_for_height_depth(int height_idx, int depth)
{
int pick;
if(depth >=60) pick = pick_histo(block_chance_30 + 8 * height_idx);
else pick = pick_histo(block_chance_60 + 8 * height_idx);
return block_widths[pick];
}
int block_height_for_zoning(int zone_height_idx)
{
return pick_histo(block_height_table + zone_height_idx * 8);
}
int height_max[] = { 999, 120, 80, 40, 32, 24, 16, 10, 0, 0 };
int road_codes[] = { 2, 1, 0 };
const char * road_suffix[] = { "_f", "_h", NULL };
int is_lib = 0;
struct depth_info_t {
int block_min;
int block_max;
int sub_div;
int agb;
int fac;
float min_div;
};
struct depth_info_t depth_residential [] = {
30, 45, 1, 30, 60, 10.0,
45, 60, 2, 30, 30, 7.5,
60, 120,2, 60, 60, 15.0,
0, 0, 0, 0, 0, 0.0
};
struct depth_info_t depth_industrial [] = {
30, 45, 1, 30, 60, 10.0,
45, 60, 2, 30, 30, 7.5,
60, 90, 2, 60, 60, 15.0,
90, 180, 2, 90, 90, 22.5,
0, 0, 0, 0, 0, 0.0
};
int facade_schedule[] = { 25, 30, 35, 40, 45, 50, 80, 9999, 0 };
void output_one_rule(int h, int r, int v, const struct depth_info_t * ds, const char * zoning)
{
int w, fac_height, s;
int d1 = ds->block_min;
int d2 = ds->block_max;
int splits = ds->sub_div;
int df1 = ds->fac / 2;
int df2 = ds->fac;
if(!is_lib)
{
printf("FILL_RULE\t%s\t",zoning); // Fill rule and zoning
printf("%d\t%d\t%d\t%d\t0\t0\t0\t\t",road_codes[r],v,height_max[h+1], height_max[h ]); // road code, variant code, height codes, sidelen, block err,
printf("%d\t9999\t%d\t%d\t0\t0\t\t",ds->agb,d1,d2); // range for major, minor, angle
printf("%d\t2\t%d\t\%d\t%.1f\t\t",ds->agb,30,splits,ds->min_div); // AGB params: width, slop,fac min unused, fac_split, fac_extra
}
if(is_lib)
{
if(height_max[h] == height_max[h+1])
{
printf("EXPORT lib/g10/autogen/%s%s_%d_v%d.agb\t\t\tfoo.agb\n",zoning, road_suffix[r], ds->agb, v);
} else {
printf("EXPORT lib/g10/autogen/%s%s_%dx%d_v%d.agbt\t\tfoo.agb\n",zoning, road_suffix[r], ds->agb, height_max[h], v);
}
}
else
{
if(height_max[h] == height_max[h+1])
{
printf("%s%s_%d_v%d.agb\t",zoning, road_suffix[r], ds->agb, v);
// printf("%s%s_%d_v%d.fac\t",zoning, road_suffix[r], ds->fac, v);
printf("NO_VALUE\t");
printf("NO_VALUE %s_parking.fac\n",zoning);
} else {
printf("%s%s_%dx%d_v%d.agb\t",zoning, road_suffix[r], ds->agb, height_max[h], v);
// printf("%s%s_%dx%d_v%d.fac\t",zoning, road_suffix[r], ds->fac, height_max[h], v);
printf("NO_VALUE\t");
printf("NO_VALUE %s_parking.fac\n",zoning);
}
}
fac_height = 7 - h;
if(height_max[h] == height_max[h+1]) fac_height = 0;
if(r == 1 && splits > 1)
{
int bh_bottom = (height_max[h] == height_max[h+1] || fac_height == 0) ? 0 : block_heights[fac_height-1];
int bh_top = (height_max[h] == height_max[h+1] ) ? 0 : block_heights[fac_height ];
int tiles, tries;
for(tiles = 1; tiles < 15; ++tiles)
{
int num_tries = (tiles < 4) ? 8 : 4;
if (tiles > 10) num_tries = 2;
for(tries = 1; tries <= num_tries; ++ tries)
{
printf("FACADE_SPELLING\t%s\t%d\t\t%d\t%d\t%d\t%d\n",
zoning,v,bh_bottom, bh_top,df1,df2);
// printf("%s %f %d\n", zoning, block_heights[fac_height], d1);
for(s = 0; s < tiles; ++s)
{
int fh = block_height_for_zoning(fac_height);
int ah = arch_heights[fac_height];
int pick;
float width;
if(df2 > 30) pick = pick_histo(block_chance_30 + 8 * fac_height);
else pick = pick_histo(block_chance_60 + 8 * fac_height);
if(tiles == 1) pick = tries - 1;
width = block_widths[pick];
printf("FACADE_TILE\t%f\t%f\t%f\t%d\t\t",
width, fh ? block_heights[fh-1] : 8.0f, block_heights[fh], df2);
if(height_max[h] != height_max[h+1])
{
printf("%s_%d_%dx%dx%d%c.fac\t",
zoning, ah, (int) width, (int) block_heights[fh], df2, s % 2 ? 'b' : 'a');
printf("%s_%d_%dx%dx%d%c.fac\n",
zoning, ah, (int) width, (int) block_heights[fh], df2, s % 2 ? 'a' : 'b');
}
else
{
printf("%s_%dx%d%c.fac\t",
zoning, (int) width, df2, s % 2 ? 'b' : 'a');
printf("%s_%dx%d%c.fac\n",
zoning, (int) width, df2, s % 2 ? 'a' : 'b');
}
}
}
}
}
}
void output_rule_with_height(const char * zoning, const struct depth_info_t * depth_schedule)
{
int h , r, v, d;
for(h = 0; height_max[h]; ++h)
for(r = 0; road_suffix[r]; ++r)
for(d = 0; depth_schedule[d].block_min; ++d)
for(v = 0; v < 4; ++v)
{
output_one_rule(h,r,v,depth_schedule+d, zoning);
}
}
void output_rule_basic(const char * zoning, const struct depth_info_t * depth_schedule)
{
int h , r, v, d;
for(h = 0; height_max[h]; ++h) { }
for(r = 0; road_suffix[r]; ++r)
for(d = 0; depth_schedule[d].block_min; ++d)
for(v = 0; v < 4; ++v)
{
output_one_rule(h,r,v, depth_schedule+d, zoning);
}
}
void adjust_table(float table[64],float widths[8])
{
int i, j;
// for(i = 0; i < 64; ++i)
// {
// if(i % 8 == 0) printf("\n");
// printf(" %f",table[i]);
//
// }
for(i = 0; i < 64; ++i)
{
table[i] /= widths[i % 8];
}
for(i = 0; i < 8; ++i)
{
float s = 0;
for(j = 0; j < 8; ++j)
s += table[i*8+j];
s = 100.0 / s;
for(j = 0; j < 8; ++j)
table[i*8+j] *= s;
}
// for(i = 0; i < 64; ++i)
// {
// if(i % 8 == 0) printf("\n");
// printf(" %f",table[i]);
//
// }
}
int main(int argc, const char * argv[])
{
adjust_table(block_chance_30, block_widths);
adjust_table(block_chance_60, block_widths);
int p = 1;
int h = 0;
int i = 0;
if(strcmp(argv[p],"-l")==0)
{
is_lib =1;
++p;
}
if(strcmp(argv[p],"-h")==0)
{
h = 1;
++p;
}
if(strcmp(argv[p],"-i")==0)
{
i = 1;
++p;
}
const char * zoning = argv[p];
if(h) output_rule_with_height(zoning, i ? depth_industrial : depth_residential);
else output_rule_basic(zoning, i ? depth_industrial : depth_residential);
return 0;
}
|
the_stack_data/68116.c
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int frist_matrix[10][10], second_matrix[10][10], multiply[10][10], row, coloum, i, j, k;
system("cls");
printf("enter the number of row=");
scanf("%d", &row);
printf("enter the number of column=");
scanf("%d", &coloum);
printf("enter the first matrix element=\n");
for (i = 0; i < row; i++)
{
for (j = 0; j < coloum; j++)
{
scanf("%d", &frist_matrix[i][j]);
}
}
printf("enter the second matrix element=\n");
for (i = 0; i < row; i++)
{
for (j = 0; j < coloum; j++)
{
scanf("%d", &second_matrix[i][j]);
}
}
printf("multiply of the matrix=\n");
for (i = 0; i < row; i++)
{
for (j = 0; j < coloum; j++)
{
multiply[i][j] = 0;
for (k = 0; k < coloum; k++)
{
multiply[i][j] += frist_matrix[i][k] * second_matrix[k][j];
}
}
}
for (i = 0; i < row; i++)
{
for (j = 0; j < coloum; j++)
{
printf("%d\t", multiply[i][j]);
}
printf("\n");
}
return 0;
}
|
the_stack_data/175141883.c
|
#include <stdio.h>
int main (int arg, char* argv[])
{
int num, suma, numf;
num=0;
suma=0;
numf=0;
printf("Este programa hace la suma de todos los n%cmeros anteriores de un n%cmero y el mismo n%cumero (Factorial)\n",163,163,163);
printf("NOTA: Solo n%cmeros enteros\n\n",163);
printf("\nIngrese el n%cmero inicial: ",163);
scanf("%d", &num);
printf("\nIngrese el n%cmero final: ",163);
scanf("%d", &numf);
for (num; num<=numf; num++ )
{
suma=suma + num;
printf("\n %d ", suma);
}
printf("Suma = %d \n", suma);
return 0;
}
|
the_stack_data/117328914.c
|
// --------------------------------------------------------------------------------
// AUTHOR: Elias Howell
// FILENAME: rbs.c
// SPECIFICATION: Program utilizes binary search and recursion to search an array for a specified number
// FOR: CS 1412 Programming Principles II Section 002
#include <stdio.h>
void sort(int array[], int arraySize);
void getData(int *elements, int array[], int *number);
int findNumber(int *elements, int array[], int *number, int *halfway);
int main()
{
int *array, elements, number; //Array, number of elements, and number to find in array
getData(&elements, array, &number);
sort(array, elements);
int halfway = (elements - 1) / 2; //Halfway index of an array
int index = findNumber(&elements, array, &number, &halfway); //Index the provided number was found at
printf("Found number %d in index %d.\n", number, index);
return 0;
}
//Sorts an arrays integers in ascending order (least to greatest), compares one integer at a time
void sort(int array[], int arraySize)
{
int ph; //Placeholder
for(int i = 0; i < arraySize; i++)
{
for(int j = 1 + i; j < arraySize; j++)
{
if(array[i] > array[j])
{
ph = array[i];
array[i] = array[j];
array[j] = ph;
}
}
}
}
//Gets required user data: the number of elements in the array, the integers in the array, and the number to find
void getData(int *elements, int array[], int *number)
{
printf("Input the number of elements to store in the array: ");
scanf("%d", &*elements);
printf("Input %d elements to the array:\n", *elements);
//Iterates through the number of elements provided so the user can assign each element an integer value
for(int i = 0; i < *elements; i++)
{
printf("element - %d:", i);
scanf(" %d", &array[i]);
}
printf("Input the number to search : ");
scanf("%d", &*number);
}
//Recursive binary search. Gets halfway index and compares content of halfway to the number being searched
//Utilizes the fact that the array was presorted in ascending order
int findNumber(int *elements, int array[], int *number, int *halfway)
{
if(array[*halfway] == *number)
{
return *halfway;
}
else if(array[*halfway] > *number) //If halfway index value is larger than search number: subtract one from halfway index, call itself
{
*halfway -= 1;
return findNumber(elements, array, number, halfway);
}
else //If halfway index value is smaller than search number: add one to halfway index, call itself
{
*halfway += 1;
return findNumber(elements, array, number, halfway);
}
}
|
the_stack_data/242352.c
|
/* names2.c */
#include <stdio.h>
#include <string.h>
#define NLEN 30
struct namect {
char fname[NLEN];
char lname[NLEN];
int letters;
};
struct namect getinfo(void);
struct namect makeinfo(struct namect);
void showinfo(struct namect);
char * s_gets(char *st, int n);
int main(void)
{
struct namect person;
person = getinfo();
person = makeinfo(person);
showinfo(person);
return 0;
}
struct namect getinfo(void)
{
struct namect temp;
printf("Please enter your first name.\n");
s_gets(temp.fname, NLEN);
printf("Please enter your last name.\n");
s_gets(temp.lname, NLEN);
return temp;
}
struct namect makeinfo(struct namect info)
{
info.letters = strlen(info.fname) + strlen(info.lname);
return info;
}
void showinfo(struct namect info)
{
printf("%s %s, your name contains %d letters.\n",
info.fname, info.lname, info.letters);
}
char * s_gets(char * st, int n)
{
char * ret_val;
char * find;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
find = strchr(st, '\n');
if (find)
*find = '\0';
else
while (getchar() != '\n')
continue;
}
return ret_val;
}
|
the_stack_data/237641884.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): PRABAKARAN B. S., MRAZEK V., VASICEK Z., SEKANINA L., SHAFIQUE M. ApproxFPGAs: Embracing ASIC-based Approximate Arithmetic Components for FPGA-Based Systems. DAC 2020.
***/
// MAE% = 0.0034 %
// MAE = 144782
// WCE% = 0.019 %
// WCE = 813901
// WCRE% = 103.12 %
// EP% = 99.99 %
// MRE% = 0.18 %
// MSE = 31960.408e6
// FPGA_POWER = 3.0
// FPGA_DELAY = 14
// FPGA_LUT = 179
#include <stdint.h>
#include <stdlib.h>
uint16_t trun8_tam00b(uint8_t A, uint8_t B)
{
uint16_t P, P_;
uint8_t tmp, C_1_0,C_1_1,C_1_2,C_1_3,C_1_4,C_1_5,C_1_6,C_2_0,C_2_1,C_2_2,C_2_3,C_2_4,C_2_5,C_2_6,C_3_0,C_3_1,C_3_2,C_3_3,C_3_4,C_3_5,C_3_6,C_4_0,C_4_1,C_4_2,C_4_3,C_4_4,C_4_5,C_4_6,C_5_0,C_5_1,C_5_2,C_5_3,C_5_4,C_5_5,C_5_6,C_6_0,C_6_1,C_6_2,C_6_3,C_6_4,C_6_5,C_6_6,C_7_0,C_7_1,C_7_2,C_7_3,C_7_4,C_7_5,C_7_6,S_0_0,S_0_1,S_0_2,S_0_3,S_0_4,S_0_5,S_0_6,S_0_7,S_1_0,S_1_1,S_1_2,S_1_3,S_1_4,S_1_5,S_1_6,S_1_7,S_2_0,S_2_1,S_2_2,S_2_3,S_2_4,S_2_5,S_2_6,S_2_7,S_3_0,S_3_1,S_3_2,S_3_3,S_3_4,S_3_5,S_3_6,S_3_7,S_4_0,S_4_1,S_4_2,S_4_3,S_4_4,S_4_5,S_4_6,S_4_7,S_5_0,S_5_1,S_5_2,S_5_3,S_5_4,S_5_5,S_5_6,S_5_7,S_6_0,S_6_1,S_6_2,S_6_3,S_6_4,S_6_5,S_6_6,S_6_7,S_7_0,S_7_1,S_7_2,S_7_3,S_7_4,S_7_5,S_7_6,S_7_7,S_8_0,S_8_1,S_8_2,S_8_3,S_8_4,S_8_5,S_8_6,S_8_7;
S_0_0 = (((A>>0)&1) & ((B>>0)&1));
S_0_1 = (((A>>0)&1) & ((B>>1)&1));
S_0_2 = (((A>>0)&1) & ((B>>2)&1));
S_0_3 = (((A>>0)&1) & ((B>>3)&1));
S_0_4 = (((A>>0)&1) & ((B>>4)&1));
S_0_5 = (((A>>0)&1) & ((B>>5)&1));
S_0_6 = (((A>>0)&1) & ((B>>6)&1));
S_0_7 = (((A>>0)&1) & ((B>>7)&1));
S_1_0 = S_0_1^(((A>>1)&1) & ((B>>0)&1));
C_1_0 = S_0_1&(((A>>1)&1) & ((B>>0)&1));
S_1_1 = S_0_2^(((A>>1)&1) & ((B>>1)&1));
C_1_1 = S_0_2&(((A>>1)&1) & ((B>>1)&1));
S_1_2 = S_0_3^(((A>>1)&1) & ((B>>2)&1));
C_1_2 = S_0_3&(((A>>1)&1) & ((B>>2)&1));
S_1_3 = S_0_4^(((A>>1)&1) & ((B>>3)&1));
C_1_3 = S_0_4&(((A>>1)&1) & ((B>>3)&1));
S_1_4 = S_0_5^(((A>>1)&1) & ((B>>4)&1));
C_1_4 = S_0_5&(((A>>1)&1) & ((B>>4)&1));
S_1_5 = S_0_6^(((A>>1)&1) & ((B>>5)&1));
C_1_5 = S_0_6&(((A>>1)&1) & ((B>>5)&1));
S_1_6 = S_0_7^(((A>>1)&1) & ((B>>6)&1));
C_1_6 = S_0_7&(((A>>1)&1) & ((B>>6)&1));
S_1_7 = (((A>>1)&1) & ((B>>7)&1));
tmp = S_1_1^C_1_0;
S_2_0 = tmp^(((A>>2)&1) & ((B>>0)&1));
C_2_0 = (tmp&(((A>>2)&1) & ((B>>0)&1)))|(S_1_1&C_1_0);
tmp = S_1_2^C_1_1;
S_2_1 = tmp^(((A>>2)&1) & ((B>>1)&1));
C_2_1 = (tmp&(((A>>2)&1) & ((B>>1)&1)))|(S_1_2&C_1_1);
tmp = S_1_3^C_1_2;
S_2_2 = tmp^(((A>>2)&1) & ((B>>2)&1));
C_2_2 = (tmp&(((A>>2)&1) & ((B>>2)&1)))|(S_1_3&C_1_2);
tmp = S_1_4^C_1_3;
S_2_3 = tmp^(((A>>2)&1) & ((B>>3)&1));
C_2_3 = (tmp&(((A>>2)&1) & ((B>>3)&1)))|(S_1_4&C_1_3);
tmp = S_1_5^C_1_4;
S_2_4 = tmp^(((A>>2)&1) & ((B>>4)&1));
C_2_4 = (tmp&(((A>>2)&1) & ((B>>4)&1)))|(S_1_5&C_1_4);
tmp = S_1_6^C_1_5;
S_2_5 = tmp^(((A>>2)&1) & ((B>>5)&1));
C_2_5 = (tmp&(((A>>2)&1) & ((B>>5)&1)))|(S_1_6&C_1_5);
tmp = S_1_7^C_1_6;
S_2_6 = tmp^(((A>>2)&1) & ((B>>6)&1));
C_2_6 = (tmp&(((A>>2)&1) & ((B>>6)&1)))|(S_1_7&C_1_6);
S_2_7 = (((A>>2)&1) & ((B>>7)&1));
tmp = S_2_1^C_2_0;
S_3_0 = tmp^(((A>>3)&1) & ((B>>0)&1));
C_3_0 = (tmp&(((A>>3)&1) & ((B>>0)&1)))|(S_2_1&C_2_0);
tmp = S_2_2^C_2_1;
S_3_1 = tmp^(((A>>3)&1) & ((B>>1)&1));
C_3_1 = (tmp&(((A>>3)&1) & ((B>>1)&1)))|(S_2_2&C_2_1);
tmp = S_2_3^C_2_2;
S_3_2 = tmp^(((A>>3)&1) & ((B>>2)&1));
C_3_2 = (tmp&(((A>>3)&1) & ((B>>2)&1)))|(S_2_3&C_2_2);
tmp = S_2_4^C_2_3;
S_3_3 = tmp^(((A>>3)&1) & ((B>>3)&1));
C_3_3 = (tmp&(((A>>3)&1) & ((B>>3)&1)))|(S_2_4&C_2_3);
tmp = S_2_5^C_2_4;
S_3_4 = tmp^(((A>>3)&1) & ((B>>4)&1));
C_3_4 = (tmp&(((A>>3)&1) & ((B>>4)&1)))|(S_2_5&C_2_4);
tmp = S_2_6^C_2_5;
S_3_5 = tmp^(((A>>3)&1) & ((B>>5)&1));
C_3_5 = (tmp&(((A>>3)&1) & ((B>>5)&1)))|(S_2_6&C_2_5);
tmp = S_2_7^C_2_6;
S_3_6 = tmp^(((A>>3)&1) & ((B>>6)&1));
C_3_6 = (tmp&(((A>>3)&1) & ((B>>6)&1)))|(S_2_7&C_2_6);
S_3_7 = (((A>>3)&1) & ((B>>7)&1));
tmp = S_3_1^C_3_0;
S_4_0 = tmp^(((A>>4)&1) & ((B>>0)&1));
C_4_0 = (tmp&(((A>>4)&1) & ((B>>0)&1)))|(S_3_1&C_3_0);
tmp = S_3_2^C_3_1;
S_4_1 = tmp^(((A>>4)&1) & ((B>>1)&1));
C_4_1 = (tmp&(((A>>4)&1) & ((B>>1)&1)))|(S_3_2&C_3_1);
tmp = S_3_3^C_3_2;
S_4_2 = tmp^(((A>>4)&1) & ((B>>2)&1));
C_4_2 = (tmp&(((A>>4)&1) & ((B>>2)&1)))|(S_3_3&C_3_2);
tmp = S_3_4^C_3_3;
S_4_3 = tmp^(((A>>4)&1) & ((B>>3)&1));
C_4_3 = (tmp&(((A>>4)&1) & ((B>>3)&1)))|(S_3_4&C_3_3);
tmp = S_3_5^C_3_4;
S_4_4 = tmp^(((A>>4)&1) & ((B>>4)&1));
C_4_4 = (tmp&(((A>>4)&1) & ((B>>4)&1)))|(S_3_5&C_3_4);
tmp = S_3_6^C_3_5;
S_4_5 = tmp^(((A>>4)&1) & ((B>>5)&1));
C_4_5 = (tmp&(((A>>4)&1) & ((B>>5)&1)))|(S_3_6&C_3_5);
tmp = S_3_7^C_3_6;
S_4_6 = tmp^(((A>>4)&1) & ((B>>6)&1));
C_4_6 = (tmp&(((A>>4)&1) & ((B>>6)&1)))|(S_3_7&C_3_6);
S_4_7 = (((A>>4)&1) & ((B>>7)&1));
tmp = S_4_1^C_4_0;
S_5_0 = tmp^(((A>>5)&1) & ((B>>0)&1));
C_5_0 = (tmp&(((A>>5)&1) & ((B>>0)&1)))|(S_4_1&C_4_0);
tmp = S_4_2^C_4_1;
S_5_1 = tmp^(((A>>5)&1) & ((B>>1)&1));
C_5_1 = (tmp&(((A>>5)&1) & ((B>>1)&1)))|(S_4_2&C_4_1);
tmp = S_4_3^C_4_2;
S_5_2 = tmp^(((A>>5)&1) & ((B>>2)&1));
C_5_2 = (tmp&(((A>>5)&1) & ((B>>2)&1)))|(S_4_3&C_4_2);
tmp = S_4_4^C_4_3;
S_5_3 = tmp^(((A>>5)&1) & ((B>>3)&1));
C_5_3 = (tmp&(((A>>5)&1) & ((B>>3)&1)))|(S_4_4&C_4_3);
tmp = S_4_5^C_4_4;
S_5_4 = tmp^(((A>>5)&1) & ((B>>4)&1));
C_5_4 = (tmp&(((A>>5)&1) & ((B>>4)&1)))|(S_4_5&C_4_4);
tmp = S_4_6^C_4_5;
S_5_5 = tmp^(((A>>5)&1) & ((B>>5)&1));
C_5_5 = (tmp&(((A>>5)&1) & ((B>>5)&1)))|(S_4_6&C_4_5);
tmp = S_4_7^C_4_6;
S_5_6 = tmp^(((A>>5)&1) & ((B>>6)&1));
C_5_6 = (tmp&(((A>>5)&1) & ((B>>6)&1)))|(S_4_7&C_4_6);
S_5_7 = (((A>>5)&1) & ((B>>7)&1));
tmp = S_5_1^C_5_0;
S_6_0 = tmp^(((A>>6)&1) & ((B>>0)&1));
C_6_0 = (tmp&(((A>>6)&1) & ((B>>0)&1)))|(S_5_1&C_5_0);
tmp = S_5_2^C_5_1;
S_6_1 = tmp^(((A>>6)&1) & ((B>>1)&1));
C_6_1 = (tmp&(((A>>6)&1) & ((B>>1)&1)))|(S_5_2&C_5_1);
tmp = S_5_3^C_5_2;
S_6_2 = tmp^(((A>>6)&1) & ((B>>2)&1));
C_6_2 = (tmp&(((A>>6)&1) & ((B>>2)&1)))|(S_5_3&C_5_2);
tmp = S_5_4^C_5_3;
S_6_3 = tmp^(((A>>6)&1) & ((B>>3)&1));
C_6_3 = (tmp&(((A>>6)&1) & ((B>>3)&1)))|(S_5_4&C_5_3);
tmp = S_5_5^C_5_4;
S_6_4 = tmp^(((A>>6)&1) & ((B>>4)&1));
C_6_4 = (tmp&(((A>>6)&1) & ((B>>4)&1)))|(S_5_5&C_5_4);
tmp = S_5_6^C_5_5;
S_6_5 = tmp^(((A>>6)&1) & ((B>>5)&1));
C_6_5 = (tmp&(((A>>6)&1) & ((B>>5)&1)))|(S_5_6&C_5_5);
tmp = S_5_7^C_5_6;
S_6_6 = tmp^(((A>>6)&1) & ((B>>6)&1));
C_6_6 = (tmp&(((A>>6)&1) & ((B>>6)&1)))|(S_5_7&C_5_6);
S_6_7 = (((A>>6)&1) & ((B>>7)&1));
tmp = S_6_1^C_6_0;
S_7_0 = tmp^(((A>>7)&1) & ((B>>0)&1));
C_7_0 = (tmp&(((A>>7)&1) & ((B>>0)&1)))|(S_6_1&C_6_0);
tmp = S_6_2^C_6_1;
S_7_1 = tmp^(((A>>7)&1) & ((B>>1)&1));
C_7_1 = (tmp&(((A>>7)&1) & ((B>>1)&1)))|(S_6_2&C_6_1);
tmp = S_6_3^C_6_2;
S_7_2 = tmp^(((A>>7)&1) & ((B>>2)&1));
C_7_2 = (tmp&(((A>>7)&1) & ((B>>2)&1)))|(S_6_3&C_6_2);
tmp = S_6_4^C_6_3;
S_7_3 = tmp^(((A>>7)&1) & ((B>>3)&1));
C_7_3 = (tmp&(((A>>7)&1) & ((B>>3)&1)))|(S_6_4&C_6_3);
tmp = S_6_5^C_6_4;
S_7_4 = tmp^(((A>>7)&1) & ((B>>4)&1));
C_7_4 = (tmp&(((A>>7)&1) & ((B>>4)&1)))|(S_6_5&C_6_4);
tmp = S_6_6^C_6_5;
S_7_5 = tmp^(((A>>7)&1) & ((B>>5)&1));
C_7_5 = (tmp&(((A>>7)&1) & ((B>>5)&1)))|(S_6_6&C_6_5);
tmp = S_6_7^C_6_6;
S_7_6 = tmp^(((A>>7)&1) & ((B>>6)&1));
C_7_6 = (tmp&(((A>>7)&1) & ((B>>6)&1)))|(S_6_7&C_6_6);
S_7_7 = (((A>>7)&1) & ((B>>7)&1));
P_ = (((C_7_0 & 1)<<0)|((C_7_1 & 1)<<1)|((C_7_2 & 1)<<2)|((C_7_3 & 1)<<3)|((C_7_4 & 1)<<4)|((C_7_5 & 1)<<5)|((C_7_6 & 1)<<6)) + (((S_7_1 & 1)<<0)|((S_7_2 & 1)<<1)|((S_7_3 & 1)<<2)|((S_7_4 & 1)<<3)|((S_7_5 & 1)<<4)|((S_7_6 & 1)<<5)|((S_7_7 & 1)<<6));
S_8_0 = (P_ >> 0) & 1;
S_8_1 = (P_ >> 1) & 1;
S_8_2 = (P_ >> 2) & 1;
S_8_3 = (P_ >> 3) & 1;
S_8_4 = (P_ >> 4) & 1;
S_8_5 = (P_ >> 5) & 1;
S_8_6 = (P_ >> 6) & 1;
S_8_7 = (P_ >> 7) & 1;
P = 0;
P |= (S_0_0 & 1) << 0;
P |= (S_1_0 & 1) << 1;
P |= (S_2_0 & 1) << 2;
P |= (S_3_0 & 1) << 3;
P |= (S_4_0 & 1) << 4;
P |= (S_5_0 & 1) << 5;
P |= (S_6_0 & 1) << 6;
P |= (S_7_0 & 1) << 7;
P |= (S_8_0 & 1) << 8;
P |= (S_8_1 & 1) << 9;
P |= (S_8_2 & 1) << 10;
P |= (S_8_3 & 1) << 11;
P |= (S_8_4 & 1) << 12;
P |= (S_8_5 & 1) << 13;
P |= (S_8_6 & 1) << 14;
P |= (S_8_7 & 1) << 15;
return P;
}
uint64_t mult8_cgp14zr_wc1577_csamrca(const uint64_t B,const uint64_t A)
{
uint64_t O, dout_52, dout_53, dout_85, dout_95, dout_96, dout_127, dout_128, dout_130, dout_137, dout_138, dout_139, dout_165, dout_166, dout_170, dout_171, dout_173, dout_174, dout_180, dout_181, dout_182, dout_199, dout_208, dout_209, dout_210, dout_211, dout_212, dout_213, dout_214, dout_215, dout_216, dout_217, dout_222, dout_223, dout_224, dout_225, dout_239, dout_246, dout_247, dout_248, dout_249, dout_250, dout_251, dout_252, dout_253, dout_254, dout_255, dout_256, dout_257, dout_258, dout_259, dout_260, dout_263, dout_264, dout_265, dout_266, dout_267, dout_268, dout_284, dout_285, dout_286, dout_287, dout_288, dout_289, dout_290, dout_291, dout_292, dout_293, dout_294, dout_295, dout_296, dout_297, dout_298, dout_299, dout_300, dout_301, dout_302, dout_303, dout_309, dout_313, dout_316, dout_317, dout_318, dout_319, dout_320, dout_321, dout_322, dout_323, dout_324, dout_325, dout_326, dout_327, dout_328, dout_329, dout_330, dout_331, dout_332, dout_333, dout_334, dout_335; int avg=0;
dout_52=((B >> 7)&1)&((A >> 2)&1);
dout_53=((B >> 7)&1)&((A >> 2)&1);
dout_85=((A >> 3)&1)&dout_52;
dout_95=((B >> 6)&1)&((A >> 3)&1);
dout_96=((B >> 7)&1)&((A >> 3)&1);
dout_127=dout_53^dout_95;
dout_128=dout_53&((A >> 3)&1);
dout_130=dout_127^dout_85;
dout_137=((B >> 5)&1)&((A >> 4)&1);
dout_138=((B >> 6)&1)&((A >> 4)&1);
dout_139=((B >> 7)&1)&((A >> 4)&1);
dout_165=dout_130|dout_137;
dout_166=dout_130&dout_137;
dout_170=dout_96^dout_138;
dout_171=dout_96&dout_138;
dout_173=dout_170^dout_85;
dout_174=dout_171|dout_128;
dout_180=((B >> 5)&1)&((A >> 5)&1);
dout_181=((B >> 6)&1)&((A >> 5)&1);
dout_182=((B >> 7)&1)&((A >> 5)&1);
dout_199=((B >> 3)&1)&((A >> 6)&1);
dout_208=dout_173^dout_180;
dout_209=dout_173&dout_180;
dout_210=dout_208&dout_166;
dout_211=dout_208^dout_166;
dout_212=dout_209|dout_210;
dout_213=dout_139^dout_181;
dout_214=dout_139&dout_181;
dout_215=dout_213&dout_174;
dout_216=dout_213^dout_174;
dout_217=dout_214|dout_215;
dout_222=((B >> 4)&1)&((A >> 6)&1);
dout_223=((B >> 5)&1)&((A >> 6)&1);
dout_224=((B >> 6)&1)&((A >> 6)&1);
dout_225=((B >> 7)&1)&((A >> 6)&1);
dout_239=((A >> 5)&1)&((B >> 4)&1);
dout_246=dout_211^dout_222;
dout_247=dout_211&dout_222;
dout_248=dout_246&dout_165;
dout_249=dout_246^dout_165;
dout_250=dout_247|dout_248;
dout_251=dout_216^dout_223;
dout_252=dout_216&dout_223;
dout_253=dout_251&dout_212;
dout_254=dout_251^dout_212;
dout_255=dout_252|dout_253;
dout_256=dout_182^dout_224;
dout_257=dout_182&dout_224;
dout_258=dout_256&dout_217;
dout_259=dout_256^dout_217;
dout_260=dout_257|dout_258;
dout_263=((B >> 2)&1)&((A >> 7)&1);
dout_264=((B >> 3)&1)&((A >> 7)&1);
dout_265=((B >> 4)&1)&((A >> 7)&1);
dout_266=((B >> 5)&1)&((A >> 7)&1);
dout_267=((B >> 6)&1)&((A >> 7)&1);
dout_268=((B >> 7)&1)&((A >> 7)&1);
dout_284=dout_249^dout_264;
dout_285=dout_249&dout_264;
dout_286=dout_284&dout_199;
dout_287=dout_284^dout_199;
dout_288=dout_285|dout_286;
dout_289=dout_254^dout_265;
dout_290=dout_254&dout_265;
dout_291=dout_289&dout_250;
dout_292=dout_289^dout_250;
dout_293=dout_290|dout_291;
dout_294=dout_259^dout_266;
dout_295=dout_259&dout_266;
dout_296=dout_294&dout_255;
dout_297=dout_294^dout_255;
dout_298=dout_295|dout_296;
dout_299=dout_225^dout_267;
dout_300=dout_225&dout_267;
dout_301=dout_299&dout_260;
dout_302=dout_299^dout_260;
dout_303=dout_300|dout_301;
dout_309=dout_239^dout_263;
dout_313=dout_239&dout_263;
dout_316=dout_292^dout_288;
dout_317=dout_292&dout_288;
dout_318=dout_316&dout_313;
dout_319=dout_316^dout_313;
dout_320=dout_317|dout_318;
dout_321=dout_297^dout_293;
dout_322=dout_297&dout_293;
dout_323=dout_321&dout_320;
dout_324=dout_321^dout_320;
dout_325=dout_322|dout_323;
dout_326=dout_302^dout_298;
dout_327=dout_302&dout_298;
dout_328=dout_326&dout_325;
dout_329=dout_326^dout_325;
dout_330=dout_327|dout_328;
dout_331=dout_268^dout_303;
dout_332=((A >> 7)&1)&dout_303;
dout_333=dout_268&dout_330;
dout_334=dout_331^dout_330;
dout_335=dout_332|dout_333;
O = 0;
O |= (dout_217&1) << 0;
O |= (dout_291&1) << 1;
O |= (dout_309&1) << 2;
O |= (0&1) << 3;
O |= (dout_127&1) << 4;
O |= (dout_225&1) << 5;
O |= (dout_254&1) << 6;
O |= (dout_214&1) << 7;
O |= (dout_309&1) << 8;
O |= (dout_309&1) << 9;
O |= (dout_287&1) << 10;
O |= (dout_319&1) << 11;
O |= (dout_324&1) << 12;
O |= (dout_329&1) << 13;
O |= (dout_334&1) << 14;
O |= (dout_335&1) << 15;
return O;
}
uint64_t mult8_cgp14ep_ep65536_wc16384_2_csamcsa(const uint64_t B,const uint64_t A)
{
uint64_t O, dout_225, dout_267, dout_268, dout_299, dout_300, dout_302, dout_328, dout_331; int avg=0;
dout_225=((B >> 7)&1)&((A >> 6)&1);
dout_267=((B >> 6)&1)&((A >> 7)&1);
dout_268=((B >> 7)&1)&((A >> 7)&1);
dout_299=dout_225|dout_267;
dout_300=dout_225&dout_267;
dout_302=dout_299|dout_268;
dout_328=dout_268^dout_300;
dout_331=dout_328^dout_302;
O = 0;
O |= (0&1) << 0;
O |= (0&1) << 1;
O |= (0&1) << 2;
O |= (0&1) << 3;
O |= (0&1) << 4;
O |= (0&1) << 5;
O |= (0&1) << 6;
O |= (0&1) << 7;
O |= (0&1) << 8;
O |= (0&1) << 9;
O |= (0&1) << 10;
O |= (0&1) << 11;
O |= (0&1) << 12;
O |= (0&1) << 13;
O |= (dout_331&1) << 14;
O |= (dout_268&1) << 15;
return O;
}
uint32_t mul16u_82M (uint16_t a, uint16_t b) {
static uint16_t * cacheLL = NULL;
static uint16_t * cacheLH = NULL;
static uint16_t * cacheHL = NULL;
static uint16_t * cacheHH = NULL;
int fillData = cacheLL == NULL || cacheLH == NULL || cacheHL == NULL || cacheHH == NULL;
if(!cacheLL) cacheLL = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheLH) cacheLH = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheHL) cacheHL = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(!cacheHH) cacheHH = (uint16_t *)malloc(256 * 256 * sizeof(uint16_t));
if(fillData) {
for(int i = 0; i < 256; i++) {
for(int j = 0; j < 256; j++) {
cacheLL[i * 256 + j] = mult8_cgp14ep_ep65536_wc16384_2_csamcsa(i, j);
cacheLH[i * 256 + j] = mult8_cgp14zr_wc1577_csamrca(i, j);
cacheHL[i * 256 + j] = mult8_cgp14zr_wc1577_csamrca(i, j);
cacheHH[i * 256 + j] = trun8_tam00b(i, j);
}
}
}
uint32_t opt = 0;
opt += (uint32_t)cacheLL[(a & 0xFF ) * 256 + (b & 0xFF )];
opt += (uint32_t)cacheLH[(a & 0xFF ) * 256 + ((b >> 8) & 0xFF )] << 8;
opt += (uint32_t)cacheHL[((a >> 8) & 0xFF) * 256 + (b & 0xFF )] << 8;
opt += (uint32_t)cacheHH[((a >> 8) & 0xFF) * 256 + ((b >> 8) & 0xFF )] << 16;
return opt;
}
|
the_stack_data/86076102.c
|
/* Steps */
#include <stdio.h>
#include <math.h>
float find_min(float diff) {
float root, min;
root = floor(sqrt(diff));
min = (2 * root) - 1 + ceil((diff - (root * root))/ root);
return (min);
}
int main() {
int n, x, y;
float steps;
scanf("%d", &n);
while (n) {
scanf("%d %d", &x, &y);
if (x == y)
printf("0\n");
else {
steps = find_min(y-x);
printf("%.0f\n", steps);
}
n--;
}
return 0;
}
|
the_stack_data/89199520.c
|
/* Generated by CIL v. 1.7.0 */
/* print_CIL_Input is false */
struct _IO_FILE;
struct timeval;
extern void signal(int sig , void *func ) ;
extern float strtof(char const *str , char const *endptr ) ;
typedef struct _IO_FILE FILE;
extern int atoi(char const *s ) ;
extern double strtod(char const *str , char const *endptr ) ;
extern int fclose(void *stream ) ;
extern void *fopen(char const *filename , char const *mode ) ;
extern void abort() ;
extern void exit(int status ) ;
extern int raise(int sig ) ;
extern int fprintf(struct _IO_FILE *stream , char const *format , ...) ;
extern int strcmp(char const *a , char const *b ) ;
extern int rand() ;
extern unsigned long strtoul(char const *str , char const *endptr , int base ) ;
void RandomFunc(unsigned short input[1] , unsigned short output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
void megaInit(void)
{
{
}
}
int main(int argc , char *argv[] )
{
unsigned short input[1] ;
unsigned short output[1] ;
int randomFuns_i5 ;
unsigned short randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = (unsigned short )strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == 50010) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%u\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
void RandomFunc(unsigned short input[1] , unsigned short output[1] )
{
unsigned short state[1] ;
unsigned short local1 ;
char copy11 ;
char copy12 ;
{
state[0UL] = (input[0UL] + 51238316UL) + (unsigned short)8426;
local1 = 0UL;
while (local1 < input[1UL]) {
if (state[0UL] < local1) {
copy11 = *((char *)(& state[local1]) + 1);
*((char *)(& state[local1]) + 1) = *((char *)(& state[local1]) + 0);
*((char *)(& state[local1]) + 0) = copy11;
} else {
state[0UL] = state[local1] * state[local1];
}
if (state[0UL] <= local1) {
copy12 = *((char *)(& state[local1]) + 1);
*((char *)(& state[local1]) + 1) = *((char *)(& state[local1]) + 0);
*((char *)(& state[local1]) + 0) = copy12;
} else {
state[local1] += state[0UL];
}
local1 += 2UL;
}
output[0UL] = state[0UL] * 787080526UL + (unsigned short)56844;
}
}
|
the_stack_data/24382.c
|
#include <pthread.h>
#include <assert.h>
extern void* magic(void* arg);
int g;
int main() {
pthread_t id;
pthread_create(&id, NULL, magic, NULL);
assert(g == 0); // UNKNOWN! (magic may invalidate)
return 0;
}
|
the_stack_data/184514187.c
|
#define NR_BMPS 6
static int sz_bmps [] =
{
1848, 4152, 184, 248, 152, 248
};
static const unsigned char bmps_data[] = {
0x42, 0x4d, 0x38, 0x07, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x0e, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x12, 0x0b,
0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0x37, 0x67,
0x13, 0x63, 0x09, 0x42, 0x27, 0x4a, 0x27, 0x4a,
0x09, 0x46, 0x13, 0x63, 0x37, 0x6b, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0x37, 0x63,
0x13, 0x5b, 0x09, 0x36, 0x27, 0x3a, 0x28, 0x3a,
0x0a, 0x3a, 0x13, 0x5b, 0x37, 0x63, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0x37, 0x63,
0x13, 0x5b, 0x09, 0x36, 0x27, 0x3a, 0x28, 0x3a,
0x0a, 0x3a, 0x13, 0x5b, 0x37, 0x63, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xf7, 0x66,
0x94, 0x62, 0x6a, 0x41, 0x49, 0x45, 0x49, 0x45,
0x6b, 0x41, 0xb4, 0x62, 0xf7, 0x66, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0x14, 0x67, 0xe7, 0x45,
0xc9, 0x5e, 0x4d, 0x6f, 0x90, 0x73, 0x90, 0x73,
0x6e, 0x6f, 0xe9, 0x62, 0x07, 0x4a, 0x14, 0x6b,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0x35, 0x5f, 0x07, 0x32,
0xe9, 0x46, 0x4e, 0x5b, 0x90, 0x63, 0x90, 0x63,
0x6f, 0x5b, 0xea, 0x4a, 0x27, 0x36, 0x35, 0x5f,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0x35, 0x5f, 0x07, 0x32,
0xe9, 0x46, 0x4e, 0x5b, 0x90, 0x63, 0x90, 0x63,
0x6f, 0x5b, 0xea, 0x4a, 0x27, 0x36, 0x35, 0x5f,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xd5, 0x66, 0x29, 0x45,
0xac, 0x5d, 0x30, 0x6a, 0x72, 0x6e, 0x93, 0x72,
0x51, 0x6a, 0xac, 0x5d, 0x49, 0x45, 0xb5, 0x66,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x14, 0x6b, 0x05, 0x56, 0xea, 0x6e,
0x8e, 0x7b, 0xd0, 0x7b, 0xf2, 0x7f, 0xf2, 0x7f,
0xd1, 0x7b, 0xaf, 0x7b, 0x0a, 0x73, 0x25, 0x56,
0x14, 0x6b, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x14, 0x5b, 0x45, 0x2e, 0x2a, 0x4b,
0xaf, 0x5f, 0xd1, 0x67, 0xf2, 0x6f, 0xf2, 0x6f,
0xd1, 0x67, 0xcf, 0x5f, 0x6b, 0x4f, 0x45, 0x32,
0x14, 0x5b, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x14, 0x5b, 0x25, 0x2a, 0xc9, 0x3e,
0x0c, 0x4b, 0x2e, 0x4f, 0x2e, 0x53, 0x2f, 0x57,
0x4e, 0x53, 0xaf, 0x5f, 0x6b, 0x4f, 0x45, 0x32,
0x14, 0x5b, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xb5, 0x66, 0xc5, 0x4c, 0xcd, 0x69,
0x52, 0x76, 0xb3, 0x7a, 0xd5, 0x7a, 0xd5, 0x7a,
0xb4, 0x7a, 0x72, 0x76, 0xcd, 0x6d, 0xe6, 0x50,
0x31, 0x4a, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0x16, 0x6b, 0xa5, 0x4d, 0xa7, 0x6e, 0xa7, 0x6a,
0xa7, 0x66, 0xc8, 0x66, 0xc8, 0x66, 0xc8, 0x66,
0xc8, 0x66, 0xc8, 0x66, 0xc8, 0x6e, 0xa7, 0x72,
0xa6, 0x4d, 0x16, 0x6b, 0xbd, 0x77, 0xbd, 0x77,
0xf4, 0x56, 0xc5, 0x25, 0xe8, 0x42, 0x6c, 0x57,
0xcf, 0x5f, 0xf0, 0x67, 0xf1, 0x67, 0xf1, 0x6b,
0xf0, 0x67, 0xef, 0x5f, 0x8d, 0x57, 0xe8, 0x42,
0xc5, 0x29, 0x16, 0x5f, 0xbd, 0x77, 0xbd, 0x77,
0xf4, 0x56, 0xc5, 0x25, 0x87, 0x36, 0xc7, 0x21,
0xe7, 0x25, 0xe7, 0x25, 0xe8, 0x25, 0xe7, 0x21,
0xcb, 0x42, 0xef, 0x5f, 0x8d, 0x57, 0xe8, 0x42,
0xc5, 0x29, 0x16, 0x5f, 0xbd, 0x77, 0xbd, 0x77,
0xd6, 0x66, 0xe6, 0x40, 0x6a, 0x61, 0x0f, 0x76,
0x6a, 0x61, 0xcd, 0x65, 0xd4, 0x7e, 0xd4, 0x7e,
0xed, 0x65, 0x6a, 0x61, 0x0f, 0x7a, 0x6a, 0x65,
0xc6, 0x40, 0xb5, 0x62, 0xbd, 0x77, 0xbd, 0x77,
0xb1, 0x62, 0xe3, 0x61, 0xc8, 0x76, 0x03, 0x5a,
0xe1, 0x51, 0x44, 0x5a, 0x24, 0x5a, 0x44, 0x5a,
0x44, 0x5a, 0xc1, 0x4d, 0x65, 0x66, 0xc8, 0x76,
0xe3, 0x61, 0xb1, 0x62, 0xbd, 0x77, 0xbd, 0x77,
0xee, 0x39, 0x23, 0x2a, 0xe8, 0x46, 0x6b, 0x4f,
0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21,
0xc7, 0x21, 0xc7, 0x21, 0x6b, 0x53, 0x09, 0x47,
0x23, 0x2a, 0xb1, 0x4e, 0xbd, 0x77, 0xbd, 0x77,
0xee, 0x39, 0x23, 0x2a, 0x88, 0x3a, 0xe7, 0x25,
0x2b, 0x4b, 0x4d, 0x4f, 0x8e, 0x57, 0x29, 0x2e,
0xaa, 0x3e, 0xad, 0x57, 0x4b, 0x4f, 0x09, 0x47,
0x23, 0x2a, 0xb1, 0x4e, 0xbd, 0x77, 0xbd, 0x77,
0x51, 0x5a, 0xa4, 0x4c, 0x8b, 0x69, 0xed, 0x75,
0xa4, 0x4c, 0xc5, 0x4c, 0xcd, 0x65, 0xcd, 0x65,
0xe5, 0x4c, 0xa4, 0x4c, 0xed, 0x75, 0x8b, 0x6d,
0xa4, 0x50, 0x31, 0x5a, 0xbd, 0x77, 0xbd, 0x77,
0x47, 0x3d, 0x05, 0x66, 0xa6, 0x76, 0x02, 0x5a,
0x66, 0x66, 0x4c, 0x7f, 0x4d, 0x7f, 0x6d, 0x7f,
0x4c, 0x7f, 0x23, 0x5a, 0x44, 0x66, 0xa7, 0x7a,
0x05, 0x66, 0x47, 0x41, 0xbd, 0x77, 0xbd, 0x77,
0x67, 0x21, 0x44, 0x2e, 0xe7, 0x42, 0x29, 0x4b,
0xe7, 0x25, 0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21,
0xe7, 0x21, 0xe7, 0x25, 0x29, 0x4b, 0xe7, 0x42,
0x44, 0x2e, 0x67, 0x21, 0xbd, 0x77, 0xbd, 0x77,
0x67, 0x21, 0x44, 0x2e, 0x87, 0x36, 0xe7, 0x25,
0x2a, 0x4b, 0x8d, 0x57, 0x8d, 0x5b, 0x28, 0x2e,
0x49, 0x32, 0xa9, 0x3a, 0xc8, 0x3e, 0xe7, 0x42,
0x44, 0x2e, 0x67, 0x21, 0xbd, 0x77, 0xbd, 0x77,
0xe7, 0x34, 0xc5, 0x54, 0x49, 0x65, 0xab, 0x6d,
0x6a, 0x69, 0xa4, 0x4c, 0xe5, 0x48, 0xe5, 0x48,
0xa4, 0x4c, 0x8a, 0x69, 0xac, 0x71, 0x49, 0x69,
0xc5, 0x54, 0xe7, 0x34, 0xbd, 0x77, 0xbd, 0x77,
0xc2, 0x3c, 0xe5, 0x61, 0x64, 0x72, 0xe1, 0x59,
0x44, 0x66, 0xea, 0x7e, 0x0b, 0x7b, 0x0b, 0x7f,
0x0a, 0x7f, 0x02, 0x5a, 0x23, 0x66, 0x64, 0x76,
0xe5, 0x61, 0xc2, 0x3c, 0xbd, 0x77, 0xbd, 0x77,
0xe2, 0x0c, 0x25, 0x2a, 0xa5, 0x3a, 0xe6, 0x3e,
0x09, 0x47, 0x4a, 0x4f, 0x4b, 0x4f, 0x4b, 0x4f,
0x4b, 0x4f, 0x29, 0x47, 0xe6, 0x42, 0xc5, 0x3a,
0x25, 0x2a, 0x02, 0x0d, 0xbd, 0x77, 0xbd, 0x77,
0xe2, 0x0c, 0x25, 0x2a, 0x65, 0x32, 0xc7, 0x21,
0x68, 0x32, 0x68, 0x32, 0x89, 0x36, 0x08, 0x2a,
0x07, 0x26, 0xc7, 0x21, 0x86, 0x36, 0xc5, 0x3a,
0x25, 0x2a, 0x02, 0x0d, 0xbd, 0x77, 0xbd, 0x77,
0x42, 0x2c, 0xa5, 0x50, 0x07, 0x61, 0x49, 0x69,
0xab, 0x71, 0x6a, 0x65, 0xa4, 0x48, 0xc4, 0x48,
0x6a, 0x69, 0xab, 0x71, 0x49, 0x69, 0x07, 0x65,
0xa5, 0x50, 0x42, 0x2c, 0xbd, 0x77, 0xbd, 0x77,
0x83, 0x34, 0x85, 0x59, 0x03, 0x6e, 0xe1, 0x55,
0x02, 0x62, 0x86, 0x76, 0xa7, 0x76, 0xa7, 0x76,
0xa6, 0x76, 0xe1, 0x55, 0x01, 0x62, 0x23, 0x6e,
0xa5, 0x59, 0x83, 0x34, 0xbd, 0x77, 0xbd, 0x77,
0xc3, 0x0c, 0xe5, 0x1d, 0x63, 0x2e, 0xa3, 0x36,
0xc5, 0x3a, 0xe8, 0x42, 0x08, 0x47, 0x08, 0x47,
0xe7, 0x42, 0xc5, 0x3e, 0xa3, 0x36, 0x63, 0x2e,
0xe5, 0x1d, 0xc2, 0x0c, 0xbd, 0x77, 0xbd, 0x77,
0xc3, 0x0c, 0xe5, 0x1d, 0x24, 0x2a, 0xc7, 0x21,
0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21,
0x87, 0x36, 0xe7, 0x25, 0x44, 0x2e, 0x63, 0x2e,
0xe5, 0x1d, 0xc2, 0x0c, 0xbd, 0x77, 0xbd, 0x77,
0x43, 0x24, 0xa5, 0x48, 0xa4, 0x58, 0xe6, 0x5c,
0x48, 0x69, 0x28, 0x5d, 0x83, 0x40, 0x83, 0x40,
0x28, 0x5d, 0x48, 0x69, 0xe6, 0x60, 0xa5, 0x58,
0xa5, 0x48, 0x43, 0x24, 0xbd, 0x77, 0xbd, 0x77,
0x08, 0x31, 0x04, 0x45, 0xc5, 0x61, 0xc1, 0x55,
0xe1, 0x59, 0x43, 0x6a, 0x44, 0x6a, 0x44, 0x6a,
0x43, 0x6a, 0xc1, 0x55, 0xe1, 0x59, 0xc5, 0x61,
0x25, 0x4d, 0x08, 0x35, 0xbd, 0x77, 0xbd, 0x77,
0x28, 0x21, 0x65, 0x15, 0x04, 0x22, 0x63, 0x2a,
0x83, 0x36, 0xa5, 0x3a, 0xc5, 0x3a, 0xa5, 0x3a,
0xa5, 0x3a, 0x84, 0x36, 0x63, 0x2a, 0x24, 0x22,
0x65, 0x15, 0x28, 0x21, 0xbd, 0x77, 0xbd, 0x77,
0x28, 0x21, 0x65, 0x15, 0xe5, 0x21, 0x05, 0x26,
0x06, 0x26, 0xe7, 0x21, 0x46, 0x2e, 0x46, 0x2e,
0x65, 0x32, 0xe6, 0x21, 0x24, 0x26, 0x24, 0x22,
0x65, 0x15, 0x28, 0x21, 0xbd, 0x77, 0xbd, 0x77,
0x08, 0x29, 0x85, 0x38, 0x84, 0x4c, 0xa4, 0x58,
0xa3, 0x50, 0x41, 0x38, 0x62, 0x38, 0x62, 0x38,
0x41, 0x38, 0xa3, 0x54, 0x84, 0x58, 0x84, 0x4c,
0xa5, 0x38, 0x08, 0x2d, 0xbd, 0x77, 0xbd, 0x77,
0x51, 0x56, 0x83, 0x30, 0x67, 0x55, 0xc2, 0x51,
0xa0, 0x49, 0xc1, 0x4d, 0xa0, 0x4d, 0xa0, 0x4d,
0xc1, 0x4d, 0xa0, 0x49, 0xe4, 0x59, 0x67, 0x55,
0x84, 0x38, 0x51, 0x56, 0xbd, 0x77, 0xbd, 0x77,
0x51, 0x46, 0xc4, 0x10, 0xc7, 0x21, 0x48, 0x2e,
0xa9, 0x3a, 0xc9, 0x42, 0xca, 0x42, 0xca, 0x42,
0xc9, 0x42, 0xa8, 0x3a, 0x48, 0x2e, 0xc7, 0x1d,
0xe4, 0x10, 0x51, 0x4a, 0xbd, 0x77, 0xbd, 0x77,
0x51, 0x46, 0xc4, 0x10, 0xc7, 0x21, 0x48, 0x2e,
0x48, 0x2e, 0xc7, 0x21, 0x08, 0x2a, 0x08, 0x2a,
0x07, 0x2a, 0xc7, 0x21, 0x27, 0x2a, 0xc7, 0x1d,
0xe4, 0x10, 0x51, 0x4a, 0xbd, 0x77, 0xbd, 0x77,
0x31, 0x4e, 0x64, 0x24, 0xc7, 0x44, 0xe8, 0x54,
0x00, 0x30, 0x61, 0x34, 0xe5, 0x4c, 0xe5, 0x4c,
0x41, 0x34, 0x00, 0x30, 0xe8, 0x54, 0xe7, 0x44,
0x84, 0x24, 0x31, 0x4e, 0xbd, 0x77, 0xbd, 0x77,
0xd6, 0x62, 0xc6, 0x24, 0xe7, 0x3c, 0xc6, 0x51,
0x06, 0x56, 0x26, 0x56, 0x26, 0x56, 0x26, 0x56,
0x26, 0x56, 0x06, 0x56, 0xc8, 0x55, 0x07, 0x41,
0xc6, 0x28, 0xd6, 0x62, 0xbd, 0x77, 0xbd, 0x77,
0xf6, 0x5a, 0xc6, 0x18, 0x27, 0x1d, 0x2d, 0x36,
0xf3, 0x4e, 0x56, 0x5f, 0x56, 0x63, 0x56, 0x63,
0x56, 0x5f, 0xf3, 0x4e, 0x2d, 0x36, 0x27, 0x1d,
0xc6, 0x18, 0xf6, 0x5a, 0xbd, 0x77, 0xbd, 0x77,
0xf6, 0x5a, 0xc6, 0x18, 0x27, 0x1d, 0x2d, 0x36,
0x4d, 0x36, 0xc7, 0x21, 0xc7, 0x21, 0xc7, 0x21,
0xc7, 0x21, 0xc7, 0x21, 0x0b, 0x2e, 0x27, 0x1d,
0xc6, 0x18, 0xf6, 0x5a, 0xbd, 0x77, 0xbd, 0x77,
0xd6, 0x5e, 0xc6, 0x20, 0xe7, 0x2c, 0xad, 0x4d,
0x53, 0x62, 0xb6, 0x6e, 0xd6, 0x6e, 0xd6, 0x6e,
0xb6, 0x6e, 0x53, 0x66, 0xad, 0x4d, 0xe7, 0x2c,
0xc6, 0x20, 0xd6, 0x5e, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x94, 0x5a, 0x84, 0x20, 0x4b, 0x41,
0x73, 0x5e, 0x39, 0x6f, 0x7b, 0x73, 0x7b, 0x73,
0x39, 0x6f, 0x73, 0x5e, 0x4b, 0x41, 0x84, 0x20,
0x94, 0x5a, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x94, 0x52, 0x84, 0x10, 0x6b, 0x2d,
0x93, 0x4e, 0x39, 0x67, 0x7b, 0x6f, 0x7b, 0x6f,
0x39, 0x67, 0x93, 0x4e, 0x6b, 0x2d, 0x84, 0x10,
0x94, 0x52, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x94, 0x52, 0x84, 0x10, 0x6a, 0x29,
0x4f, 0x3e, 0xb3, 0x4e, 0xf4, 0x52, 0xf4, 0x52,
0xb3, 0x4e, 0x4f, 0x3e, 0x8a, 0x29, 0x84, 0x10,
0x94, 0x52, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0x94, 0x52, 0x63, 0x10, 0x4a, 0x35,
0x73, 0x56, 0x39, 0x6b, 0x7b, 0x73, 0x7b, 0x73,
0x39, 0x6b, 0x73, 0x56, 0x4a, 0x35, 0x63, 0x10,
0x94, 0x52, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xb5, 0x5a, 0xe7, 0x24,
0x08, 0x31, 0xce, 0x45, 0x52, 0x52, 0x52, 0x52,
0xce, 0x45, 0x09, 0x31, 0xe7, 0x24, 0xb5, 0x5a,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xb5, 0x56, 0xe7, 0x1c,
0x29, 0x25, 0xce, 0x39, 0x52, 0x4a, 0x52, 0x4a,
0xce, 0x39, 0x29, 0x25, 0xe7, 0x1c, 0xb5, 0x56,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xb5, 0x56, 0xe7, 0x1c,
0x29, 0x25, 0xce, 0x39, 0x52, 0x4a, 0x52, 0x4a,
0xce, 0x39, 0x29, 0x25, 0xe7, 0x1c, 0xb5, 0x56,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0x94, 0x56, 0xe7, 0x1c,
0x09, 0x25, 0xce, 0x3d, 0x52, 0x4e, 0x52, 0x4a,
0xce, 0x3d, 0x09, 0x25, 0xe7, 0x1c, 0x94, 0x56,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0x73, 0x52, 0x08, 0x25, 0x43, 0x14, 0x43, 0x14,
0x08, 0x25, 0x73, 0x52, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0x73, 0x4e, 0x08, 0x21, 0x63, 0x0c, 0x63, 0x0c,
0x08, 0x21, 0x73, 0x4e, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0x73, 0x4e, 0x08, 0x21, 0x63, 0x0c, 0x63, 0x0c,
0x08, 0x21, 0x73, 0x4e, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0xd7, 0x5e,
0x53, 0x4e, 0x08, 0x21, 0x63, 0x0c, 0x63, 0x0c,
0x08, 0x21, 0x52, 0x4e, 0xd7, 0x5e, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0x00, 0x00,
0x42, 0x4d, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x20, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x9b, 0x0e,
0x00, 0x00, 0x9b, 0x0e, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x6f,
0x7b, 0x6f, 0x39, 0x67, 0xb5, 0x56, 0x73, 0x4e,
0x52, 0x4a, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x73, 0x4e, 0x94, 0x52, 0xd6, 0x5a,
0x7b, 0x6f, 0xde, 0x7b, 0xbd, 0x77, 0x7b, 0x6f,
0x7b, 0x6f, 0x7b, 0x6f, 0x9c, 0x73, 0xbd, 0x77,
0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xde, 0x7b,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xde, 0x7b, 0x5a, 0x6b, 0xd6, 0x5a,
0x73, 0x4e, 0x52, 0x4a, 0x52, 0x4a, 0x52, 0x4a,
0x52, 0x4a, 0x52, 0x4a, 0x94, 0x52, 0xd6, 0x5a,
0x7b, 0x6f, 0xde, 0x7b, 0xbd, 0x77, 0xbd, 0x77,
0xde, 0x7b, 0x7b, 0x6f, 0xd6, 0x5a, 0x94, 0x52,
0x52, 0x4a, 0x52, 0x4a, 0x52, 0x4a, 0x52, 0x4a,
0x52, 0x4a, 0x73, 0x4e, 0xd6, 0x5a, 0x5a, 0x6b,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0x7b, 0x6f,
0xb5, 0x56, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x94, 0x52, 0x73, 0x4e, 0x73, 0x4e, 0x52, 0x4a,
0x52, 0x4a, 0x52, 0x4a, 0x31, 0x46, 0x52, 0x4a,
0x52, 0x4a, 0x18, 0x63, 0xde, 0x7b, 0x5a, 0x6b,
0x7b, 0x6f, 0x39, 0x67, 0xb5, 0x56, 0x73, 0x4e,
0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x52, 0x4a, 0x94, 0x52, 0xf7, 0x5e,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0x18, 0x63, 0x73, 0x4e, 0xd6, 0x5a,
0xd6, 0x5a, 0xd6, 0x5a, 0xd6, 0x5a, 0xd6, 0x5a,
0xb5, 0x56, 0xb5, 0x56, 0x94, 0x52, 0x94, 0x52,
0x52, 0x4a, 0x18, 0x63, 0xde, 0x7b, 0xde, 0x7b,
0x18, 0x63, 0x52, 0x4a, 0x94, 0x52, 0x94, 0x52,
0xb5, 0x56, 0xb5, 0x56, 0xd6, 0x5a, 0xd6, 0x5a,
0xd6, 0x5a, 0xd6, 0x5a, 0xd6, 0x5a, 0x73, 0x4e,
0x18, 0x63, 0xde, 0x7b, 0xde, 0x7b, 0x18, 0x63,
0x52, 0x4a, 0xd6, 0x5a, 0x18, 0x63, 0x5a, 0x6b,
0x5a, 0x6b, 0x5a, 0x6b, 0x5a, 0x6b, 0x39, 0x67,
0x39, 0x67, 0x18, 0x63, 0xf7, 0x5e, 0xb5, 0x56,
0x73, 0x4e, 0x52, 0x4a, 0x7b, 0x6f, 0x7b, 0x6f,
0xd6, 0x5a, 0x52, 0x4a, 0x94, 0x52, 0x94, 0x52,
0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e,
0x52, 0x4a, 0x52, 0x4a, 0x52, 0x4a, 0x52, 0x4a,
0x73, 0x4e, 0xf7, 0x5e, 0xbd, 0x77, 0xde, 0x7b,
0x7b, 0x6f, 0x73, 0x4e, 0x5a, 0x6b, 0x5a, 0x6b,
0x5a, 0x6b, 0x39, 0x67, 0x39, 0x67, 0x39, 0x67,
0x39, 0x67, 0x18, 0x63, 0x18, 0x63, 0xd6, 0x5a,
0x73, 0x4e, 0x52, 0x4a, 0x9c, 0x73, 0x9c, 0x73,
0x52, 0x4a, 0x73, 0x4e, 0xd6, 0x5a, 0x18, 0x63,
0x18, 0x63, 0x39, 0x67, 0x39, 0x67, 0x39, 0x67,
0x39, 0x67, 0x39, 0x67, 0x5a, 0x6b, 0x5a, 0x6b,
0x73, 0x4e, 0x7b, 0x6f, 0xde, 0x7b, 0x94, 0x52,
0xd6, 0x5a, 0x5a, 0x6b, 0x9c, 0x73, 0xde, 0x7b,
0xbd, 0x77, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x9c, 0x73, 0x5a, 0x6b, 0x5a, 0x6b, 0x18, 0x63,
0xd6, 0x5a, 0x94, 0x52, 0xd6, 0x5a, 0x18, 0x63,
0x52, 0x4a, 0xd6, 0x5a, 0x18, 0x63, 0x5a, 0x6b,
0x5a, 0x6b, 0x5a, 0x6b, 0x5a, 0x6b, 0x39, 0x67,
0x39, 0x67, 0x18, 0x63, 0xd6, 0x5a, 0xb5, 0x56,
0x73, 0x4e, 0x73, 0x4e, 0x5a, 0x6b, 0xff, 0x7f,
0xf7, 0x5e, 0x18, 0x63, 0x9c, 0x73, 0x9c, 0x73,
0x5a, 0x6b, 0x5a, 0x6b, 0x5a, 0x6b, 0x5a, 0x6b,
0xe7, 0x1c, 0x5a, 0x6b, 0x5a, 0x6b, 0x18, 0x63,
0xb5, 0x56, 0x52, 0x4a, 0xd6, 0x5a, 0xd6, 0x5a,
0x52, 0x4a, 0xb5, 0x56, 0x18, 0x63, 0x5a, 0x6b,
0x5a, 0x6b, 0xe7, 0x1c, 0x5a, 0x6b, 0x5a, 0x6b,
0x5a, 0x6b, 0x5a, 0x6b, 0x9c, 0x73, 0x9c, 0x73,
0x18, 0x63, 0xf7, 0x5e, 0xff, 0x7f, 0x52, 0x4a,
0x18, 0x63, 0xbd, 0x77, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x9c, 0x73, 0x7b, 0x6f, 0x5a, 0x6b, 0x5a, 0x6b,
0x18, 0x63, 0x94, 0x52, 0x94, 0x52, 0x94, 0x52,
0xd6, 0x5a, 0x5a, 0x6b, 0x9c, 0x73, 0xde, 0x7b,
0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77, 0x9c, 0x73,
0x7b, 0x6f, 0x5a, 0x6b, 0x5a, 0x6b, 0x18, 0x63,
0xd6, 0x5a, 0x73, 0x4e, 0xd6, 0x5a, 0xff, 0x7f,
0x94, 0x52, 0x7b, 0x6f, 0xde, 0x7b, 0x7b, 0x6f,
0x5a, 0x6b, 0x7b, 0x6f, 0x5a, 0x6b, 0xe7, 0x1c,
0x08, 0x21, 0xe7, 0x1c, 0x5a, 0x6b, 0x5a, 0x6b,
0xf7, 0x5e, 0x31, 0x46, 0x94, 0x52, 0x94, 0x52,
0x31, 0x46, 0xf7, 0x5e, 0x5a, 0x6b, 0x5a, 0x6b,
0xe7, 0x1c, 0x08, 0x21, 0xe7, 0x1c, 0x5a, 0x6b,
0x7b, 0x6f, 0x5a, 0x6b, 0x7b, 0x6f, 0xde, 0x7b,
0x7b, 0x6f, 0x94, 0x52, 0xff, 0x7f, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f,
0x08, 0x21, 0xbd, 0x77, 0xbd, 0x77, 0x9c, 0x73,
0x7b, 0x6f, 0x9c, 0x73, 0xe7, 0x1c, 0x5a, 0x6b,
0x18, 0x63, 0xb5, 0x56, 0x52, 0x4a, 0x52, 0x4a,
0x39, 0x67, 0x9c, 0x73, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0x9c, 0x73, 0xe7, 0x1c,
0x9c, 0x73, 0x7b, 0x6f, 0x5a, 0x6b, 0x39, 0x67,
0xf7, 0x5e, 0xb5, 0x56, 0x73, 0x4e, 0xff, 0x7f,
0x52, 0x4a, 0xbd, 0x77, 0xde, 0x7b, 0x7b, 0x6f,
0x7b, 0x6f, 0x7b, 0x6f, 0xe7, 0x1c, 0x08, 0x21,
0x08, 0x21, 0x9c, 0x73, 0x7b, 0x6f, 0x5a, 0x6b,
0x18, 0x63, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x52, 0x4a, 0x18, 0x63, 0x5a, 0x6b, 0x7b, 0x6f,
0x7b, 0x6f, 0x08, 0x21, 0x08, 0x21, 0xe7, 0x1c,
0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f, 0xde, 0x7b,
0xbd, 0x77, 0x73, 0x4e, 0xff, 0x7f, 0x31, 0x46,
0x5a, 0x6b, 0xde, 0x7b, 0xff, 0x7f, 0xe7, 0x1c,
0x08, 0x21, 0xe7, 0x1c, 0xbd, 0x77, 0x9c, 0x73,
0x7b, 0x6f, 0xe7, 0x1c, 0x08, 0x21, 0xe7, 0x1c,
0x39, 0x67, 0xb5, 0x56, 0x52, 0x4a, 0x31, 0x46,
0x5a, 0x6b, 0xde, 0x7b, 0xff, 0x7f, 0xbd, 0x77,
0xde, 0x7b, 0xbd, 0x77, 0xe7, 0x1c, 0x29, 0x25,
0xe7, 0x1c, 0x7b, 0x6f, 0x5a, 0x6b, 0x7b, 0x6f,
0x39, 0x67, 0xb5, 0x56, 0x52, 0x4a, 0xff, 0x7f,
0x73, 0x4e, 0xde, 0x7b, 0xbd, 0x77, 0x7b, 0x6f,
0x9c, 0x73, 0xe7, 0x1c, 0x08, 0x21, 0xe7, 0x1c,
0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f, 0x9c, 0x73,
0x18, 0x63, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x52, 0x4a, 0x18, 0x63, 0x9c, 0x73, 0x9c, 0x73,
0x7b, 0x6f, 0x7b, 0x6f, 0xe7, 0x1c, 0x08, 0x21,
0xe7, 0x1c, 0x9c, 0x73, 0x7b, 0x6f, 0xbd, 0x77,
0xbd, 0x77, 0x73, 0x4e, 0xff, 0x7f, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0x08, 0x21, 0xe7, 0x1c, 0x08, 0x21, 0x9c, 0x73,
0xe7, 0x1c, 0x08, 0x21, 0xe7, 0x1c, 0x5a, 0x6b,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xbd, 0x77, 0xe7, 0x1c, 0x08, 0x21, 0xe7, 0x1c,
0x08, 0x21, 0x08, 0x21, 0x5a, 0x6b, 0x5a, 0x6b,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0xff, 0x7f,
0x73, 0x4e, 0xbd, 0x77, 0xde, 0x7b, 0x9c, 0x73,
0xe7, 0x1c, 0x08, 0x21, 0x08, 0x21, 0x9c, 0x73,
0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73,
0x39, 0x67, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x52, 0x4a, 0x39, 0x67, 0x9c, 0x73, 0x9c, 0x73,
0x9c, 0x73, 0x9c, 0x73, 0x9c, 0x73, 0x08, 0x21,
0x08, 0x21, 0xe7, 0x1c, 0x9c, 0x73, 0xff, 0x7f,
0xbd, 0x77, 0x73, 0x4e, 0xff, 0x7f, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0xde, 0x7b, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21,
0x08, 0x21, 0xe7, 0x1c, 0x5a, 0x6b, 0x5a, 0x6b,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0x31, 0x46,
0x5a, 0x6b, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x9c, 0x73,
0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x5a, 0x6b,
0x18, 0x63, 0xd6, 0x5a, 0x52, 0x4a, 0xde, 0x7b,
0x73, 0x4e, 0xbd, 0x77, 0xde, 0x7b, 0xbd, 0x77,
0xbd, 0x77, 0xe7, 0x1c, 0x08, 0x21, 0x08, 0x21,
0xbd, 0x77, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x5a, 0x6b, 0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x5a, 0x6b, 0x9c, 0x73, 0x9c, 0x73,
0xbd, 0x77, 0xbd, 0x77, 0x08, 0x21, 0x08, 0x21,
0xe7, 0x1c, 0xbd, 0x77, 0xbd, 0x77, 0xde, 0x7b,
0xde, 0x7b, 0x73, 0x4e, 0xff, 0x7f, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0xe7, 0x1c, 0x08, 0x21,
0xe7, 0x1c, 0x7b, 0x6f, 0x7b, 0x6f, 0x5a, 0x6b,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0x08, 0x21,
0x08, 0x21, 0xe7, 0x1c, 0xbd, 0x77, 0x9c, 0x73,
0x7b, 0x6f, 0x08, 0x21, 0x08, 0x21, 0xe7, 0x1c,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0xde, 0x7b,
0x73, 0x4e, 0xde, 0x7b, 0xde, 0x7b, 0xbd, 0x77,
0x9c, 0x73, 0xbd, 0x77, 0x08, 0x21, 0xe7, 0x1c,
0xe7, 0x1c, 0xbd, 0x77, 0xbd, 0x77, 0xbd, 0x77,
0x5a, 0x6b, 0x73, 0x4e, 0x52, 0x4a, 0x52, 0x4a,
0x73, 0x4e, 0x5a, 0x6b, 0xbd, 0x77, 0xbd, 0x77,
0xbd, 0x77, 0xe7, 0x1c, 0xe7, 0x1c, 0x08, 0x21,
0xbd, 0x77, 0x9c, 0x73, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0x73, 0x4e, 0xde, 0x7b, 0x52, 0x4a,
0x7b, 0x6f, 0xff, 0x7f, 0xde, 0x7b, 0xff, 0x7f,
0xbd, 0x77, 0x9c, 0x73, 0xbd, 0x77, 0xe7, 0x1c,
0x7b, 0x6f, 0x7b, 0x6f, 0x5a, 0x6b, 0x5a, 0x6b,
0x5a, 0x6b, 0xd6, 0x5a, 0x73, 0x4e, 0x31, 0x46,
0x7b, 0x6f, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0x08, 0x21, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x7b, 0x6f, 0x7b, 0x6f, 0xe7, 0x1c, 0x7b, 0x6f,
0x39, 0x67, 0xd6, 0x5a, 0x52, 0x4a, 0xde, 0x7b,
0x73, 0x4e, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0xbd, 0x77, 0xde, 0x7b, 0xbd, 0x77, 0x08, 0x21,
0x08, 0x21, 0x08, 0x21, 0xde, 0x7b, 0xbd, 0x77,
0x5a, 0x6b, 0x94, 0x52, 0x52, 0x4a, 0x52, 0x4a,
0x94, 0x52, 0x5a, 0x6b, 0xbd, 0x77, 0xde, 0x7b,
0x08, 0x21, 0x29, 0x25, 0x08, 0x21, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0xbd, 0x77, 0xff, 0x7f,
0xde, 0x7b, 0x73, 0x4e, 0xde, 0x7b, 0x94, 0x52,
0x39, 0x67, 0xff, 0x7f, 0xff, 0x7f, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0xbd, 0x77, 0x9c, 0x73,
0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f, 0x9c, 0x73,
0x5a, 0x6b, 0xd6, 0x5a, 0xd6, 0x5a, 0x31, 0x46,
0x5a, 0x6b, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f, 0x5a, 0x6b,
0x39, 0x67, 0xf7, 0x5e, 0x52, 0x4a, 0xbd, 0x77,
0x73, 0x4e, 0xbd, 0x77, 0xff, 0x7f, 0xde, 0x7b,
0xff, 0x7f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xe7, 0x1c, 0xff, 0x7f, 0xbd, 0x77, 0xde, 0x7b,
0x5a, 0x6b, 0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x5a, 0x6b, 0xbd, 0x77, 0xde, 0x7b,
0xff, 0x7f, 0xe7, 0x1c, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b, 0xff, 0x7f,
0xbd, 0x77, 0x73, 0x4e, 0xbd, 0x77, 0x18, 0x63,
0x52, 0x4a, 0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xbd, 0x77, 0xde, 0x7b, 0xde, 0x7b, 0x9c, 0x73,
0x5a, 0x6b, 0x73, 0x4e, 0x5a, 0x6b, 0x94, 0x52,
0x39, 0x67, 0xff, 0x7f, 0xff, 0x7f, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73,
0x9c, 0x73, 0x7b, 0x6f, 0x7b, 0x6f, 0x9c, 0x73,
0x39, 0x67, 0xd6, 0x5a, 0xd6, 0x5a, 0x9c, 0x73,
0xb5, 0x56, 0x5a, 0x6b, 0xde, 0x7b, 0xff, 0x7f,
0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0xff, 0x7f, 0xde, 0x7b, 0xde, 0x7b, 0x9c, 0x73,
0x18, 0x63, 0x73, 0x4e, 0xb5, 0x56, 0xb5, 0x56,
0x73, 0x4e, 0x18, 0x63, 0xbd, 0x77, 0xde, 0x7b,
0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b, 0xff, 0x7f,
0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0x5a, 0x6b, 0xb5, 0x56, 0xbd, 0x77, 0x5a, 0x6b,
0xd6, 0x5a, 0x73, 0x4e, 0x5a, 0x6b, 0xbd, 0x77,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xbd, 0x77,
0xbd, 0x77, 0xbd, 0x77, 0x7b, 0x6f, 0x18, 0x63,
0x73, 0x4e, 0x18, 0x63, 0xde, 0x7b, 0xf7, 0x5e,
0x73, 0x4e, 0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f,
0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xde, 0x7b, 0xbd, 0x77, 0xbd, 0x77,
0x39, 0x67, 0x73, 0x4e, 0x5a, 0x6b, 0x9c, 0x73,
0x39, 0x67, 0x73, 0x4e, 0xde, 0x7b, 0xff, 0x7f,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xbd, 0x77, 0xbd, 0x77, 0x5a, 0x6b,
0xd6, 0x5a, 0x52, 0x4a, 0x39, 0x67, 0x39, 0x67,
0x52, 0x4a, 0xd6, 0x5a, 0x5a, 0x6b, 0xbd, 0x77,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xde, 0x7b, 0xff, 0x7f, 0xff, 0x7f, 0xde, 0x7b,
0x73, 0x4e, 0x39, 0x67, 0x9c, 0x73, 0x5a, 0x6b,
0x7b, 0x6f, 0x39, 0x67, 0xb5, 0x56, 0x73, 0x4e,
0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x73, 0x4e, 0x94, 0x52, 0xf7, 0x5e,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0x7b, 0x6f,
0xd6, 0x5a, 0x52, 0x4a, 0x7b, 0x6f, 0xbd, 0x77,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b,
0xbd, 0x77, 0x9c, 0x73, 0x9c, 0x73, 0x18, 0x63,
0x73, 0x4e, 0x18, 0x63, 0xde, 0x7b, 0x7b, 0x6f,
0x7b, 0x6f, 0xd6, 0x5a, 0x52, 0x4a, 0x39, 0x67,
0x5a, 0x6b, 0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f,
0x7b, 0x6f, 0x7b, 0x6f, 0x18, 0x63, 0xd6, 0x5a,
0x52, 0x4a, 0xb5, 0x56, 0x7b, 0x6f, 0x7b, 0x6f,
0xb5, 0x56, 0x52, 0x4a, 0xd6, 0x5a, 0x18, 0x63,
0x7b, 0x6f, 0x5a, 0x6b, 0x7b, 0x6f, 0x7b, 0x6f,
0x7b, 0x6f, 0x5a, 0x6b, 0x39, 0x67, 0x52, 0x4a,
0xd6, 0x5a, 0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f,
0x7b, 0x6f, 0x9c, 0x73, 0x9c, 0x73, 0xbd, 0x77,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f,
0xde, 0x7b, 0xde, 0x7b, 0xde, 0x7b, 0x7b, 0x6f,
0x7b, 0x6f, 0x39, 0x67, 0xb5, 0x56, 0x73, 0x4e,
0x73, 0x4e, 0x52, 0x4a, 0x73, 0x4e, 0x73, 0x4e,
0x73, 0x4e, 0x73, 0x4e, 0x94, 0x52, 0xf7, 0x5e,
0x7b, 0x6f, 0xde, 0x7b, 0xde, 0x7b, 0x7b, 0x6f,
0x5a, 0x6b, 0x5a, 0x6b, 0x18, 0x63, 0x94, 0x52,
0x52, 0x4a, 0x31, 0x46, 0x31, 0x46, 0x31, 0x46,
0x31, 0x46, 0x10, 0x42, 0x52, 0x4a, 0x94, 0x52,
0x18, 0x63, 0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f,
0x7b, 0x6f, 0x18, 0x63, 0x94, 0x52, 0x52, 0x4a,
0x10, 0x42, 0x31, 0x46, 0x31, 0x46, 0x31, 0x46,
0x31, 0x46, 0x52, 0x4a, 0x94, 0x52, 0x18, 0x63,
0x5a, 0x6b, 0x5a, 0x6b, 0x7b, 0x6f, 0x7f, 0x63,
0x7f, 0x63, 0x5d, 0x57, 0xb9, 0x4a, 0x78, 0x42,
0x76, 0x3e, 0x77, 0x3e, 0x97, 0x3e, 0x98, 0x3e,
0x77, 0x3e, 0x97, 0x3e, 0x98, 0x46, 0xfa, 0x52,
0x9e, 0x67, 0xdf, 0x73, 0xbe, 0x73, 0x7e, 0x63,
0x7e, 0x67, 0x9f, 0x6b, 0xbf, 0x6f, 0xbf, 0x73,
0xdf, 0x77, 0xdf, 0x7b, 0xdf, 0x7f, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7b, 0xff, 0x7b,
0xdf, 0x7b, 0xdf, 0x77, 0xde, 0x77, 0xdf, 0x77,
0xde, 0x73, 0xdf, 0x77, 0x7c, 0x67, 0xda, 0x4e,
0x78, 0x3e, 0x76, 0x3a, 0x56, 0x3e, 0x57, 0x3a,
0x77, 0x3e, 0x77, 0x3a, 0xb9, 0x42, 0xd9, 0x4a,
0x7d, 0x67, 0xdf, 0x73, 0xbe, 0x73, 0xbe, 0x73,
0xdf, 0x73, 0x7d, 0x67, 0xd9, 0x4a, 0xb9, 0x42,
0x77, 0x3a, 0x77, 0x3e, 0x57, 0x3a, 0x56, 0x3e,
0x76, 0x3a, 0x78, 0x3e, 0xda, 0x4e, 0x7c, 0x67,
0xdf, 0x77, 0xde, 0x73, 0xdf, 0x77, 0x7e, 0x5f,
0xd9, 0x4a, 0x79, 0x3a, 0x75, 0x4e, 0x75, 0x4e,
0x96, 0x4e, 0x74, 0x4e, 0x75, 0x46, 0x74, 0x46,
0x55, 0x46, 0x54, 0x42, 0x55, 0x3e, 0x55, 0x3e,
0x76, 0x3e, 0x3b, 0x5b, 0xdf, 0x73, 0x7e, 0x63,
0x9f, 0x5f, 0x3d, 0x5b, 0xda, 0x4a, 0x97, 0x3e,
0x77, 0x3e, 0x77, 0x3e, 0x77, 0x3e, 0x77, 0x42,
0x78, 0x42, 0x77, 0x3e, 0x98, 0x46, 0xfa, 0x52,
0x7d, 0x67, 0xdf, 0x77, 0xde, 0x77, 0xdf, 0x77,
0xdf, 0x77, 0x1b, 0x57, 0x98, 0x3e, 0xfb, 0x4a,
0xfb, 0x4a, 0xdb, 0x4a, 0xfa, 0x4a, 0xdc, 0x4a,
0xda, 0x4a, 0xd9, 0x4a, 0xb9, 0x46, 0x99, 0x42,
0x56, 0x3e, 0x3b, 0x5b, 0xdf, 0x73, 0xdf, 0x73,
0x3b, 0x5b, 0x56, 0x3e, 0x99, 0x42, 0xb9, 0x46,
0xd9, 0x4a, 0xda, 0x4a, 0xdc, 0x4a, 0xfa, 0x4a,
0xdb, 0x4a, 0xfb, 0x4a, 0xfb, 0x4a, 0x98, 0x3e,
0x1b, 0x57, 0xdf, 0x77, 0xdf, 0x77, 0x1d, 0x53,
0x77, 0x3a, 0xd7, 0x5a, 0x1a, 0x5f, 0x5a, 0x6b,
0x5d, 0x67, 0x7b, 0x63, 0x5b, 0x67, 0x5c, 0x5f,
0x3c, 0x5b, 0x1b, 0x5b, 0x1b, 0x53, 0xb9, 0x46,
0x98, 0x3e, 0x56, 0x3e, 0x7d, 0x67, 0x9f, 0x5b,
0xda, 0x4e, 0x57, 0x36, 0x95, 0x4e, 0x95, 0x4e,
0x96, 0x4a, 0x75, 0x4a, 0x74, 0x4a, 0x76, 0x46,
0x74, 0x42, 0x55, 0x3e, 0x54, 0x3e, 0x55, 0x3a,
0x77, 0x3e, 0x1b, 0x57, 0xdf, 0x77, 0xff, 0x77,
0x7d, 0x67, 0x99, 0x42, 0x7e, 0x53, 0x5e, 0x57,
0x5f, 0x5b, 0x5e, 0x57, 0x5f, 0x57, 0x5e, 0x57,
0x5e, 0x57, 0x3f, 0x57, 0x1d, 0x53, 0xdb, 0x46,
0x98, 0x3e, 0x76, 0x3e, 0x9e, 0x67, 0x9e, 0x67,
0x76, 0x3e, 0x98, 0x3e, 0xdb, 0x46, 0x1d, 0x53,
0x3f, 0x57, 0x5e, 0x57, 0x5e, 0x57, 0x5f, 0x57,
0x5e, 0x57, 0x5f, 0x5b, 0x5e, 0x57, 0x7e, 0x53,
0x99, 0x42, 0x7d, 0x67, 0xff, 0x77, 0x9a, 0x3e,
0xd8, 0x52, 0x7a, 0x67, 0xbc, 0x77, 0xdf, 0x73,
0xdf, 0x6f, 0xdf, 0x73, 0xbf, 0x6b, 0xbf, 0x63,
0xbf, 0x63, 0x7f, 0x5f, 0x7d, 0x5f, 0x1e, 0x53,
0xdb, 0x46, 0x99, 0x42, 0xd9, 0x4a, 0x1d, 0x53,
0x57, 0x3a, 0xd8, 0x5a, 0x19, 0x63, 0x5a, 0x6b,
0x7c, 0x67, 0x7c, 0x67, 0x5b, 0x67, 0x3b, 0x63,
0x3c, 0x5f, 0x1a, 0x5b, 0xfa, 0x52, 0xd9, 0x46,
0x76, 0x3a, 0x77, 0x42, 0x7d, 0x63, 0xff, 0x7b,
0xfb, 0x56, 0x3c, 0x5b, 0x9f, 0x67, 0xbf, 0x6b,
0x7e, 0x5f, 0x7f, 0x5f, 0x7f, 0x5b, 0x7f, 0x5b,
0xf0, 0x04, 0x7f, 0x57, 0x5e, 0x5f, 0x1e, 0x53,
0xb9, 0x46, 0x55, 0x3e, 0xfa, 0x52, 0xfa, 0x52,
0x55, 0x3e, 0xb9, 0x46, 0x1e, 0x53, 0x5e, 0x5f,
0x7f, 0x57, 0xf0, 0x04, 0x7f, 0x5b, 0x7f, 0x5b,
0x7f, 0x5f, 0x7e, 0x5f, 0xbf, 0x6b, 0x9f, 0x67,
0x3c, 0x5b, 0xfb, 0x56, 0xff, 0x7b, 0x58, 0x36,
0x19, 0x63, 0xbd, 0x73, 0xdd, 0x7f, 0xde, 0x73,
0xdf, 0x77, 0xbe, 0x73, 0xbe, 0x73, 0x9d, 0x6f,
0x9e, 0x6b, 0x7e, 0x67, 0x7e, 0x63, 0x5e, 0x5f,
0x1d, 0x53, 0xb9, 0x46, 0xb9, 0x42, 0x99, 0x3e,
0xd7, 0x5a, 0x5b, 0x6b, 0x9d, 0x73, 0xdf, 0x73,
0xdf, 0x6f, 0xbf, 0x6f, 0xbf, 0x6f, 0x9f, 0x6b,
0x9f, 0x67, 0x7f, 0x5f, 0x7f, 0x5f, 0x1d, 0x53,
0xfb, 0x4e, 0x97, 0x42, 0xda, 0x4a, 0xff, 0x7b,
0x98, 0x46, 0x7e, 0x67, 0xdf, 0x77, 0x7d, 0x67,
0x7d, 0x5f, 0x7f, 0x5f, 0x7f, 0x5b, 0x0e, 0x05,
0x10, 0x01, 0xee, 0x04, 0x7e, 0x63, 0x7d, 0x5f,
0x1b, 0x53, 0x55, 0x3e, 0x98, 0x46, 0x98, 0x46,
0x55, 0x3e, 0x1b, 0x53, 0x7d, 0x5f, 0x7e, 0x63,
0xee, 0x04, 0x10, 0x01, 0x0e, 0x05, 0x7f, 0x5b,
0x7f, 0x5f, 0x7d, 0x5f, 0x7d, 0x67, 0xdf, 0x77,
0x7e, 0x67, 0x98, 0x46, 0xff, 0x7b, 0x37, 0x32,
0x7a, 0x6b, 0xde, 0x77, 0xdf, 0x77, 0xff, 0x77,
0x10, 0x01, 0xbf, 0x6f, 0xdf, 0x6b, 0x9e, 0x6b,
0x9f, 0x63, 0xbf, 0x5f, 0xee, 0x04, 0x7f, 0x57,
0x3f, 0x57, 0xd9, 0x4a, 0x77, 0x3a, 0x79, 0x32,
0x39, 0x63, 0x9c, 0x6f, 0xdf, 0x77, 0xff, 0x77,
0xdf, 0x77, 0xdf, 0x73, 0xbf, 0x6b, 0xed, 0x00,
0xbf, 0x63, 0x9f, 0x63, 0x7f, 0x5f, 0x5f, 0x57,
0x1d, 0x53, 0xb9, 0x46, 0x99, 0x3e, 0xff, 0x7b,
0x77, 0x3e, 0xbf, 0x6f, 0xdf, 0x77, 0x7f, 0x67,
0x9f, 0x63, 0x7f, 0x5f, 0xef, 0x04, 0x10, 0x01,
0x0f, 0x01, 0xbf, 0x5f, 0x7e, 0x67, 0x7f, 0x5f,
0x1b, 0x5b, 0x54, 0x42, 0x97, 0x3e, 0x97, 0x3e,
0x54, 0x42, 0x1b, 0x5b, 0x7f, 0x5f, 0x7e, 0x67,
0xbf, 0x5f, 0x0f, 0x01, 0x10, 0x01, 0xef, 0x04,
0x7f, 0x5f, 0x9f, 0x63, 0x7f, 0x67, 0xdf, 0x77,
0xbf, 0x6f, 0x77, 0x3e, 0xff, 0x7b, 0x36, 0x32,
0x7c, 0x6b, 0xde, 0x77, 0xff, 0x7f, 0xee, 0x04,
0x31, 0x01, 0xef, 0x04, 0xbf, 0x6b, 0xbf, 0x6b,
0x9f, 0x5f, 0x0f, 0x01, 0x10, 0x01, 0xf0, 0x04,
0x5e, 0x57, 0xda, 0x4a, 0x77, 0x3e, 0x37, 0x2e,
0x5b, 0x6b, 0xde, 0x77, 0xff, 0x7b, 0xbc, 0x7b,
0xdf, 0x77, 0xbe, 0x73, 0x0e, 0x05, 0x32, 0x01,
0xee, 0x04, 0x9f, 0x5f, 0x7f, 0x5b, 0x7f, 0x5b,
0x3d, 0x57, 0xba, 0x46, 0x78, 0x3e, 0xff, 0x7b,
0x78, 0x42, 0xdf, 0x6f, 0xdf, 0x73, 0x9f, 0x67,
0x9f, 0x5f, 0xef, 0x04, 0x10, 0x05, 0x0e, 0x01,
0x9f, 0x5f, 0x9f, 0x63, 0x9e, 0x6b, 0xbf, 0x63,
0x3c, 0x5b, 0x55, 0x46, 0x77, 0x3e, 0x77, 0x3e,
0x55, 0x46, 0x3c, 0x5b, 0xbf, 0x63, 0x9e, 0x6b,
0x9f, 0x63, 0x9f, 0x5f, 0x0e, 0x01, 0x10, 0x05,
0xef, 0x04, 0x9f, 0x5f, 0x9f, 0x67, 0xdf, 0x73,
0xdf, 0x6f, 0x78, 0x42, 0xff, 0x7b, 0x38, 0x2e,
0x7b, 0x6f, 0xdf, 0x77, 0xde, 0x7b, 0xdf, 0x77,
0x0f, 0x01, 0xef, 0x04, 0x10, 0x01, 0xbf, 0x63,
0x0e, 0x01, 0x10, 0x01, 0x0e, 0x05, 0x7f, 0x5b,
0x5e, 0x57, 0xdc, 0x4a, 0x57, 0x3a, 0x57, 0x32,
0x7a, 0x6f, 0xde, 0x7b, 0xdf, 0x7b, 0xdf, 0x7b,
0xdf, 0x73, 0x0f, 0x01, 0x10, 0x01, 0xf0, 0x00,
0x0f, 0x05, 0x0f, 0x05, 0x7f, 0x57, 0x7f, 0x5b,
0x5f, 0x57, 0xda, 0x4a, 0x77, 0x3a, 0xff, 0x7b,
0x77, 0x42, 0xdf, 0x6f, 0xfe, 0x7b, 0x9f, 0x6b,
0xee, 0x08, 0x12, 0x01, 0x10, 0x01, 0xbf, 0x63,
0xbf, 0x6b, 0x9e, 0x6b, 0x9d, 0x6f, 0xbf, 0x63,
0x5c, 0x5f, 0x74, 0x46, 0x98, 0x3e, 0x98, 0x3e,
0x74, 0x46, 0x5c, 0x5f, 0xbf, 0x63, 0x9d, 0x6f,
0x9e, 0x6b, 0xbf, 0x6b, 0xbf, 0x63, 0x10, 0x01,
0x12, 0x01, 0xee, 0x08, 0x9f, 0x6b, 0xfe, 0x7b,
0xdf, 0x6f, 0x77, 0x42, 0xff, 0x7b, 0x37, 0x2e,
0x7b, 0x6f, 0xde, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0xdf, 0x73, 0x10, 0x05, 0x10, 0x01, 0x10, 0x01,
0x10, 0x05, 0xef, 0x04, 0x7f, 0x5b, 0x7f, 0x5b,
0x5f, 0x57, 0xfa, 0x4a, 0x56, 0x3e, 0x57, 0x2e,
0x5a, 0x6f, 0xdf, 0x7b, 0xff, 0x7f, 0xdf, 0x77,
0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x9f, 0x67,
0x0f, 0x05, 0x10, 0x01, 0x0f, 0x05, 0x5f, 0x5b,
0x3d, 0x57, 0xdc, 0x4a, 0x78, 0x3a, 0xff, 0x7b,
0x77, 0x3e, 0xdf, 0x77, 0xde, 0x7b, 0xbe, 0x6f,
0xbf, 0x6b, 0x0f, 0x01, 0x10, 0x01, 0x10, 0x01,
0xbf, 0x6b, 0xdf, 0x6b, 0xbe, 0x73, 0xbf, 0x6b,
0x5b, 0x67, 0x75, 0x46, 0x97, 0x3e, 0x97, 0x3e,
0x75, 0x46, 0x5b, 0x67, 0xbf, 0x6b, 0xbe, 0x73,
0xdf, 0x6b, 0xbf, 0x6b, 0x10, 0x01, 0x10, 0x01,
0x0f, 0x01, 0xbf, 0x6b, 0xbe, 0x6f, 0xde, 0x7b,
0xdf, 0x77, 0x77, 0x3e, 0xff, 0x7b, 0x57, 0x2e,
0x7b, 0x6f, 0xdf, 0x7b, 0xdf, 0x7b, 0xdd, 0x7b,
0xdf, 0x6f, 0xdf, 0x73, 0x0f, 0x01, 0x12, 0x01,
0xef, 0x04, 0x7f, 0x5f, 0x7f, 0x5f, 0x7f, 0x5f,
0x5e, 0x57, 0xdb, 0x4a, 0x76, 0x3a, 0x36, 0x32,
0x7b, 0x6b, 0xff, 0x77, 0xdf, 0x7b, 0x0e, 0x09,
0x11, 0x01, 0xef, 0x04, 0xbf, 0x6b, 0x9e, 0x6b,
0x9f, 0x63, 0x0e, 0x05, 0x10, 0x01, 0xef, 0x00,
0x5f, 0x57, 0xdb, 0x4a, 0x78, 0x3a, 0xff, 0x7b,
0x78, 0x3a, 0xdf, 0x77, 0xde, 0x7b, 0xdf, 0x73,
0xbf, 0x6f, 0xdf, 0x73, 0x10, 0x05, 0xef, 0x04,
0xef, 0x04, 0xbf, 0x6f, 0xbe, 0x73, 0xdf, 0x73,
0x7b, 0x63, 0x74, 0x4e, 0x77, 0x3e, 0x77, 0x3e,
0x74, 0x4e, 0x7b, 0x63, 0xdf, 0x73, 0xbe, 0x73,
0xbf, 0x6f, 0xef, 0x04, 0xef, 0x04, 0x10, 0x05,
0xdf, 0x73, 0xbf, 0x6f, 0xdf, 0x73, 0xde, 0x7b,
0xdf, 0x77, 0x78, 0x3a, 0xff, 0x7b, 0x78, 0x32,
0x5b, 0x6b, 0xff, 0x7b, 0xff, 0x77, 0xff, 0x77,
0xdf, 0x73, 0xbf, 0x6f, 0xbf, 0x6b, 0xee, 0x08,
0x9f, 0x5f, 0x9f, 0x63, 0x7d, 0x5f, 0x7e, 0x5f,
0x5f, 0x5b, 0xfb, 0x4a, 0x78, 0x3e, 0x39, 0x36,
0x7c, 0x6f, 0xde, 0x7b, 0xff, 0x7b, 0xdf, 0x73,
0x10, 0x01, 0xdf, 0x73, 0xbf, 0x6b, 0x9f, 0x6b,
0x9f, 0x63, 0x9f, 0x5b, 0x0e, 0x05, 0x7f, 0x5b,
0x3d, 0x57, 0xfb, 0x4e, 0x56, 0x3a, 0xdf, 0x77,
0x78, 0x3a, 0xdf, 0x77, 0xff, 0x7f, 0xdf, 0x73,
0xdf, 0x73, 0xdf, 0x6f, 0xdf, 0x73, 0x0f, 0x01,
0x31, 0x01, 0x10, 0x01, 0xdf, 0x77, 0xdf, 0x6f,
0x5d, 0x67, 0x96, 0x4e, 0x76, 0x3e, 0x76, 0x3e,
0x96, 0x4e, 0x5d, 0x67, 0xdf, 0x6f, 0xdf, 0x77,
0x10, 0x01, 0x31, 0x01, 0x0f, 0x01, 0xdf, 0x73,
0xdf, 0x6f, 0xdf, 0x73, 0xdf, 0x73, 0xff, 0x7f,
0xdf, 0x77, 0x78, 0x3a, 0xdf, 0x77, 0x99, 0x3e,
0x3a, 0x63, 0xff, 0x7b, 0xff, 0x7b, 0xdf, 0x77,
0xdf, 0x73, 0xdf, 0x73, 0xbe, 0x6f, 0x9f, 0x6b,
0x9f, 0x67, 0x7f, 0x67, 0x7d, 0x67, 0xbf, 0x6b,
0x5e, 0x57, 0xfb, 0x4a, 0xda, 0x4e, 0x37, 0x36,
0x5c, 0x6b, 0xdf, 0x7b, 0xdd, 0x7f, 0xff, 0x77,
0xde, 0x73, 0xbe, 0x73, 0xbe, 0x73, 0xbf, 0x6b,
0x9f, 0x63, 0x7f, 0x5f, 0x7f, 0x5f, 0x7f, 0x5b,
0x5f, 0x57, 0xfc, 0x4a, 0x77, 0x3a, 0xdf, 0x73,
0x98, 0x3e, 0xbe, 0x77, 0xff, 0x7f, 0xdf, 0x77,
0xff, 0x77, 0xdd, 0x7b, 0xde, 0x7b, 0xdf, 0x77,
0xee, 0x04, 0xff, 0x77, 0xde, 0x73, 0xdf, 0x73,
0x5a, 0x6b, 0x75, 0x4e, 0x78, 0x42, 0x78, 0x42,
0x75, 0x4e, 0x5a, 0x6b, 0xdf, 0x73, 0xde, 0x73,
0xff, 0x77, 0xee, 0x04, 0xdf, 0x77, 0xde, 0x7b,
0xdd, 0x7b, 0xff, 0x77, 0xdf, 0x77, 0xff, 0x7f,
0xbe, 0x77, 0x98, 0x3e, 0xdf, 0x73, 0x3d, 0x57,
0x78, 0x3a, 0xdf, 0x77, 0xff, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xde, 0x7b, 0xde, 0x7b, 0xfe, 0x7b,
0xdf, 0x73, 0xdf, 0x77, 0xdf, 0x77, 0x9f, 0x67,
0x7e, 0x53, 0x98, 0x3e, 0x7c, 0x67, 0x9a, 0x42,
0x3b, 0x63, 0xff, 0x77, 0xfe, 0x7f, 0xdf, 0x7b,
0xdf, 0x73, 0xbf, 0x73, 0xbf, 0x6b, 0x9f, 0x6b,
0x9f, 0x67, 0x9e, 0x67, 0x9e, 0x67, 0xbf, 0x6b,
0x5f, 0x57, 0xdb, 0x4a, 0xfa, 0x4e, 0xbf, 0x6f,
0xda, 0x4a, 0x5c, 0x67, 0xff, 0x7b, 0xff, 0x7b,
0xff, 0x77, 0xdf, 0x7b, 0xff, 0x7f, 0xde, 0x7b,
0xff, 0x7f, 0xdf, 0x77, 0xdd, 0x7f, 0xbc, 0x77,
0x1a, 0x5f, 0x75, 0x4e, 0xb9, 0x4a, 0xb9, 0x4a,
0x75, 0x4e, 0x1a, 0x5f, 0xbc, 0x77, 0xdd, 0x7f,
0xdf, 0x77, 0xff, 0x7f, 0xde, 0x7b, 0xff, 0x7f,
0xdf, 0x7b, 0xff, 0x77, 0xff, 0x7b, 0xff, 0x7b,
0x5c, 0x67, 0xda, 0x4a, 0xbf, 0x6f, 0x7f, 0x5b,
0xda, 0x4e, 0x99, 0x3a, 0x5c, 0x67, 0xbe, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x6f,
0xdf, 0x6f, 0xbf, 0x6f, 0x7e, 0x67, 0x3c, 0x5b,
0x99, 0x42, 0x1b, 0x57, 0xdf, 0x77, 0x1d, 0x53,
0x98, 0x3e, 0xdf, 0x77, 0xdf, 0x77, 0xff, 0x7f,
0xdf, 0x7b, 0xff, 0x7b, 0xde, 0x77, 0xde, 0x7b,
0xdf, 0x77, 0xdf, 0x77, 0xbf, 0x73, 0xbf, 0x6b,
0x3e, 0x57, 0x98, 0x42, 0x5d, 0x63, 0x9f, 0x67,
0x3d, 0x5f, 0x99, 0x3a, 0xdf, 0x77, 0xff, 0x7b,
0xff, 0x7b, 0xdf, 0x7b, 0xde, 0x7b, 0xdf, 0x77,
0xde, 0x77, 0xde, 0x77, 0xbd, 0x73, 0x7a, 0x67,
0xd7, 0x5a, 0x79, 0x3a, 0x5d, 0x57, 0x5d, 0x57,
0x79, 0x3a, 0xd7, 0x5a, 0x7a, 0x67, 0xbd, 0x73,
0xde, 0x77, 0xde, 0x77, 0xdf, 0x77, 0xde, 0x7b,
0xdf, 0x7b, 0xff, 0x7b, 0xff, 0x7b, 0xdf, 0x77,
0x99, 0x3a, 0x3d, 0x5f, 0x9f, 0x67, 0x7e, 0x63,
0x7f, 0x5f, 0x3d, 0x5f, 0xda, 0x4a, 0x98, 0x3e,
0x78, 0x3a, 0x78, 0x3a, 0x77, 0x3e, 0x77, 0x42,
0x78, 0x42, 0x77, 0x3e, 0x98, 0x46, 0xfb, 0x56,
0x7d, 0x67, 0xdf, 0x77, 0xde, 0x73, 0x9e, 0x5b,
0xd9, 0x4e, 0x79, 0x3a, 0x7c, 0x6b, 0xbe, 0x77,
0xdf, 0x77, 0xdd, 0x7b, 0xdf, 0x77, 0xdf, 0x73,
0xbf, 0x6f, 0xbf, 0x6b, 0x9f, 0x67, 0x3c, 0x57,
0x97, 0x42, 0x3c, 0x5b, 0xdf, 0x73, 0x7f, 0x63,
0x7f, 0x5f, 0xda, 0x4e, 0x78, 0x3a, 0x3a, 0x63,
0x5b, 0x6b, 0x7b, 0x6f, 0x7b, 0x6f, 0x7b, 0x6f,
0x7c, 0x6b, 0x7a, 0x6b, 0x19, 0x63, 0xd8, 0x52,
0x77, 0x3a, 0xd9, 0x4a, 0x7f, 0x63, 0x7f, 0x63,
0xd9, 0x4a, 0x77, 0x3a, 0xd8, 0x52, 0x19, 0x63,
0x7a, 0x6b, 0x7c, 0x6b, 0x7b, 0x6f, 0x7b, 0x6f,
0x7b, 0x6f, 0x5b, 0x6b, 0x3a, 0x63, 0x78, 0x3a,
0xda, 0x4e, 0x7f, 0x5f, 0x7f, 0x63, 0x7f, 0x63,
0x7f, 0x63, 0x9f, 0x67, 0xbf, 0x6f, 0xdf, 0x73,
0xdf, 0x77, 0xff, 0x7b, 0xff, 0x7b, 0xff, 0x7b,
0xff, 0x7b, 0xff, 0x7b, 0xff, 0x7b, 0xff, 0x7b,
0xff, 0x77, 0xdf, 0x77, 0xdf, 0x77, 0x7e, 0x5f,
0x7f, 0x63, 0x5d, 0x5b, 0xb9, 0x4a, 0x98, 0x42,
0x77, 0x3e, 0x77, 0x3e, 0x78, 0x3e, 0x98, 0x3e,
0x77, 0x42, 0x76, 0x42, 0x97, 0x46, 0xfa, 0x52,
0x7d, 0x67, 0xdf, 0x77, 0xdf, 0x77, 0x7f, 0x63,
0x7e, 0x63, 0x7f, 0x5b, 0x3d, 0x57, 0x99, 0x3e,
0x78, 0x32, 0x57, 0x2e, 0x37, 0x2e, 0x38, 0x2e,
0x36, 0x32, 0x37, 0x32, 0x58, 0x36, 0x9a, 0x3e,
0x1d, 0x53, 0x7e, 0x5f, 0x7f, 0x63, 0x7f, 0x63,
0x7e, 0x5f, 0x1d, 0x53, 0x9a, 0x3e, 0x58, 0x36,
0x37, 0x32, 0x36, 0x32, 0x38, 0x2e, 0x37, 0x2e,
0x57, 0x2e, 0x78, 0x32, 0x99, 0x3e, 0x3d, 0x57,
0x7f, 0x5b, 0x7e, 0x63, 0x7f, 0x63, 0x00, 0x00,
0x42, 0x4d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x12, 0x0b,
0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x5f,
0x7f, 0x5f, 0x7f, 0x5f, 0x00, 0x00, 0x9f, 0x63,
0x9f, 0x63, 0x9f, 0x63, 0x00, 0x00, 0x9f, 0x67,
0x9f, 0x67, 0x9f, 0x67, 0x00, 0x00, 0xbf, 0x6f,
0xbf, 0x6f, 0xbf, 0x6f, 0x00, 0x00, 0xbf, 0x73,
0xbf, 0x73, 0xbf, 0x73, 0x00, 0x00, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0x00, 0x00, 0xdf, 0x7b,
0xdf, 0x7b, 0xdf, 0x7b, 0x00, 0x00, 0xff, 0x7b,
0xff, 0x7b, 0xff, 0x7b, 0x00, 0x00, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0x00, 0x00, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0x00, 0x00, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0x00, 0x00, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0x00, 0x00, 0xdf, 0x7b,
0xdf, 0x7b, 0xdf, 0x7b, 0x00, 0x00, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0x00, 0x00, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0x00, 0x00, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0x00, 0x00, 0x00, 0x00,
0x42, 0x4d, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0x9b, 0x0e,
0x00, 0x00, 0x9b, 0x0e, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x5f,
0x7f, 0x5b, 0x3e, 0x4f, 0x3e, 0x4f, 0x7f, 0x5b,
0x7f, 0x5f, 0x9f, 0x67, 0xfb, 0x4a, 0x77, 0x42,
0x77, 0x42, 0xfb, 0x4a, 0x9f, 0x67, 0x5c, 0x5b,
0x77, 0x3e, 0xde, 0x73, 0xde, 0x73, 0x77, 0x3e,
0x5c, 0x5b, 0xba, 0x4a, 0x7d, 0x63, 0xff, 0x7b,
0xff, 0x7b, 0x7d, 0x63, 0xba, 0x4a, 0x98, 0x42,
0xde, 0x73, 0xff, 0x7b, 0xff, 0x7b, 0xde, 0x73,
0x98, 0x42, 0x78, 0x3a, 0xdf, 0x7b, 0xdd, 0x7b,
0xdd, 0x7b, 0xdf, 0x7b, 0x78, 0x3a, 0x78, 0x3e,
0xfe, 0x7b, 0xff, 0x7b, 0xff, 0x7b, 0xfe, 0x7b,
0x78, 0x3e, 0x77, 0x3e, 0xbf, 0x73, 0xff, 0x7b,
0xff, 0x7b, 0xbf, 0x73, 0x77, 0x3e, 0x76, 0x3e,
0xdf, 0x6f, 0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x6f,
0x76, 0x3e, 0x78, 0x42, 0xdf, 0x6f, 0xbf, 0x7b,
0xbf, 0x7b, 0xdf, 0x6f, 0x78, 0x42, 0x77, 0x42,
0xbe, 0x6f, 0xdf, 0x7b, 0xdf, 0x7b, 0xbe, 0x6f,
0x77, 0x42, 0x99, 0x46, 0x9e, 0x67, 0xbf, 0x73,
0xbf, 0x73, 0x9e, 0x67, 0x99, 0x46, 0xfa, 0x56,
0x3b, 0x57, 0xdf, 0x6b, 0xdf, 0x6b, 0x3b, 0x57,
0xfa, 0x56, 0x9e, 0x6b, 0x97, 0x42, 0x1e, 0x53,
0x1e, 0x53, 0x97, 0x42, 0x9e, 0x6b, 0xbf, 0x73,
0x1a, 0x57, 0x98, 0x42, 0x98, 0x42, 0x1a, 0x57,
0xbf, 0x73, 0xdf, 0x77, 0xdf, 0x73, 0x7d, 0x5f,
0x7d, 0x5f, 0xdf, 0x73, 0xdf, 0x77, 0x00, 0x00,
0x42, 0x4d, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x12, 0x0b,
0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7b,
0xdf, 0x7b, 0xdf, 0x77, 0xbf, 0x73, 0xbf, 0x6f,
0x9f, 0x67, 0x9f, 0x63, 0x7f, 0x5f, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7b,
0xdf, 0x7b, 0xdf, 0x77, 0xbf, 0x73, 0xbf, 0x6f,
0x9f, 0x67, 0x9f, 0x63, 0x7f, 0x5f, 0xdf, 0x77,
0xdf, 0x77, 0xdf, 0x77, 0xdf, 0x7b, 0xff, 0x7f,
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7b,
0xdf, 0x7b, 0xdf, 0x77, 0xbf, 0x73, 0xbf, 0x6f,
0x9f, 0x67, 0x9f, 0x63, 0x7f, 0x5f, 0x00, 0x00,
0x42, 0x4d, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00,
0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0x12, 0x0b,
0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x5f,
0x9f, 0x67, 0x5c, 0x5b, 0xba, 0x4a, 0x98, 0x42,
0x78, 0x3a, 0x78, 0x3e, 0x77, 0x3e, 0x76, 0x3e,
0x78, 0x42, 0x77, 0x42, 0x99, 0x46, 0xfa, 0x56,
0x9e, 0x6b, 0xbf, 0x73, 0xdf, 0x77, 0x7f, 0x5b,
0xfb, 0x4a, 0x77, 0x3e, 0x7d, 0x63, 0xde, 0x73,
0xdf, 0x7b, 0xfe, 0x7b, 0xbf, 0x73, 0xdf, 0x6f,
0xdf, 0x6f, 0xbe, 0x6f, 0x9e, 0x67, 0x3b, 0x57,
0x97, 0x42, 0x1a, 0x57, 0xdf, 0x73, 0x3e, 0x4f,
0x77, 0x42, 0xde, 0x73, 0xff, 0x7b, 0xff, 0x7b,
0xdd, 0x7b, 0xff, 0x7b, 0xff, 0x7b, 0xdf, 0x77,
0xbf, 0x7b, 0xdf, 0x7b, 0xbf, 0x73, 0xdf, 0x6b,
0x1e, 0x53, 0x98, 0x42, 0x7d, 0x5f, 0x3e, 0x4f,
0x77, 0x42, 0xde, 0x73, 0xff, 0x7b, 0xff, 0x7b,
0xdd, 0x7b, 0xff, 0x7b, 0xff, 0x7b, 0xdf, 0x77,
0xbf, 0x7b, 0xdf, 0x7b, 0xbf, 0x73, 0xdf, 0x6b,
0x1e, 0x53, 0x98, 0x42, 0x7d, 0x5f, 0x7f, 0x5b,
0xfb, 0x4a, 0x77, 0x3e, 0x7d, 0x63, 0xde, 0x73,
0xdf, 0x7b, 0xfe, 0x7b, 0xbf, 0x73, 0xdf, 0x6f,
0xdf, 0x6f, 0xbe, 0x6f, 0x9e, 0x67, 0x3b, 0x57,
0x97, 0x42, 0x1a, 0x57, 0xdf, 0x73, 0x7f, 0x5f,
0x9f, 0x67, 0x5c, 0x5b, 0xba, 0x4a, 0x98, 0x42,
0x78, 0x3a, 0x78, 0x3e, 0x77, 0x3e, 0x76, 0x3e,
0x78, 0x42, 0x77, 0x42, 0x99, 0x46, 0xfa, 0x56,
0x9e, 0x6b, 0xbf, 0x73, 0xdf, 0x77, 0x00, 0x00
};
|
the_stack_data/156393886.c
|
/*************************************************************
*************************spi_test****************************
**************************************************************/
#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
static void pabort(const char *s)
{
perror(s);
abort();
}
static const char *device = "/dev/spidev1.1";
static uint8_t mode=3;
static uint8_t bits = 8;
static uint32_t speed = 50000;
static uint16_t delay;
int fd;
int fd_cs;
int ret = 0;
int pullup = 1;
int pulldown = 2;
void _delay_ms( unsigned int x)
{
unsigned int i,j;
for(i=0;i<x;i++)
for(j=0;j<100;j++);
}
void ee_write(unsigned int BufferOffset,unsigned char data)
{
//cs=0;
ret = write(fd_cs, &pulldown, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
//spi_transmit_byte(0x84);
uint8_t txb[1] = {
0x84,
};
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte(0xff);
txb[0] = 0xff;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte((unsigned char)(BufferOffset>>8));
txb[0] = (unsigned char)(BufferOffset>>8);
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte((unsigned char)BufferOffset);
txb[0] = (unsigned char)BufferOffset;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte(data);
txb[0] = data;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//cs=1;
ret = write(fd_cs, &pullup, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
}
unsigned char ee_read(unsigned int BufferOffset)
{
uint8_t txb[1] = {
0,
};
uint8_t rxb[ARRAY_SIZE(txb)] = {0,
};
//cs=0;
ret = write(fd_cs, &pulldown, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
//spi_transmit_byte(0xD4);
txb[0] = 0xD4;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte(0xff);
txb[0] = 0xff;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte((unsigned char)(BufferOffset>>8));
txb[0] = (unsigned char)(BufferOffset>>8);
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte((unsigned char)BufferOffset);
txb[0] = (unsigned char)BufferOffset;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte(0xff);
txb[0] = 0xff;
ret = write(fd,txb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't write");
//spi_transmit_byte(0xff);
ret = read(fd,rxb,ARRAY_SIZE(txb));
if (ret <1)
pabort("can't read");
//cs=1;
ret = write(fd_cs, &pullup, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
//temp=SSPBUF;
return rxb[0];
}
int main(int argc, char *argv[])
{
unsigned int i, num;
fd_cs = open("/dev/ctl_io",O_RDWR);
if(fd_cs < 0)
{
perror("open error");
exit(1);
}
fd = open(device, O_RDWR);
if (fd < 0)
pabort("can't open device");
/*
* spi mode
*/
ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
if (ret == -1)
pabort("can't set spi mode");
ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
if (ret == -1)
pabort("can't get spi mode");
/*
* bits per word
*/
ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't set bits per word");
ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't get bits per word");
/*
* max speed hz
*/
ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't set max speed hz");
ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't get max speed hz");
printf("spi mode: %d\n", mode);
printf("bits per word: %d\n", bits);
printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
//cs=1
ret = write(fd_cs, &pullup, 4);
if(ret < 0)
{
perror("error to write\n");
exit(1);
}
sleep(1);
/* Write and read */
printf(">>>>>>>>Start to write [0-255]<<<<<<<<<\n");
for(num=0;num<256;num++)
{
ee_write((unsigned int)num,num);
printf("%d ",num);
for(i=0;i<40;i++);
}
printf("\n");
printf(">>>>>>>>Start to read [0-255]<<<<<<<<<\n");
for(num=0;num<256;num++)
{
printf("%d ",ee_read((unsigned int)num));
_delay_ms(50);
}
printf("\n");
close(fd);
close(fd_cs);
return ret;
}
|
the_stack_data/132953046.c
|
extern int __VERIFIER_nondet_int();
extern void __VERIFIER_assume(int);
int nondet_signed_int() {
int r = __VERIFIER_nondet_int();
__VERIFIER_assume ((-0x7fffffff - 1) <= r && r <= 0x7fffffff);
return r;
}
signed int main()
{
signed int x;
signed int y;
x = nondet_signed_int();
y = nondet_signed_int();
for( ; x >= 1; x = x - 1)
{
for( ; y >= 1; y = y - 1)
while(!(!(y - 1 < (-0x7fffffff - 1) || 0x7fffffff < y - 1)));
while(!(!(x - 1 < (-0x7fffffff - 1) || 0x7fffffff < x - 1)));
}
return 0;
}
|
the_stack_data/1045753.c
|
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#include<ctype.h>
#define TElemType int
#define MAXL 42
int top = 0;
int Biarr[MAXL];
char c;
void getArr(int arr[]);
int getnum(void);
int getTop(int a[]);
void Initialize(int arr[]);
void push(int a[],int pos);
void pop(void);
void displayElem(int pos);
void PreOrderTraverse(void);
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void Initialize(int arr[]){
memset(arr,0,MAXL*sizeof(int));
}
void getArr(int arr[]){
extern char c;
int i = 1;
int mid;
while (c!=EOF && c!='\n')
{
if(c==',')
i++;
mid = getnum();
while(mid!=0 && i!=1&& arr[i/2]==0)
i++;
arr[i] = mid;
}
arr[0] = i;
}
int getnum(void){
extern char c;
char m;
int num = 0;
int sign = 1;
while((c=getchar())!=EOF && c!='\n' && (isdigit(c)||c=='-')){
if(c=='-')
sign = -1;
num = num*10 + c - '0';
}
if(c=='n'){
m = getchar();
m = getchar();
m = getchar();
return 0;
}
return num*sign;
}
void push(int a[],int pos){
a[top++]=pos;
}
void pop(void){
if (top==0) {
return;
}
top--;
}
void displayElem(int pos){
printf(",%d",Biarr[pos]);
}
int getTop(int a[]){
if(top!=0)
return a[top-1];
else
return 0;
}
//先序遍历非递归算法
void PreOrderTraverse(void){
int a[MAXL];
int k = 0;
int temp;
push(a,1);
while(top!=0){
temp = getTop(a);
pop();
while(Biarr[temp]){
if(k==0){
printf("%d",Biarr[temp]);
k++;
}
else
displayElem(temp);
if(Biarr[2*temp+1])
push(a,2*temp+1);
temp *= 2;
}
}
}
int main(){
Initialize(Biarr);
getArr(Biarr);
//printf("先序遍历: \n");
PreOrderTraverse();
return 0;
}
|
the_stack_data/64200125.c
|
#include <stdlib.h>
#include <string.h>
//cmp function don't consider overflow
int cmp(const void* lhs, const void* rhs)
{
return *(int*)lhs - *(int*)rhs;
}
int maxSumRangeQuery(int* nums, int numsSize, int** requests, int requestsSize, int* requestsColSize)
{
static const int MOD = 1e9 + 7;
int count[numsSize + 1];
memset(count, 0, sizeof(count));
for (int i = 0; i < requestsSize; ++i)
{
++count[requests[i][0]];
--count[requests[i][1] + 1];
}
qsort(nums, numsSize, sizeof(int), cmp);
for (int i = 1; i < numsSize; ++i)
count[i] += count[i - 1];
qsort(count, numsSize, sizeof(int), cmp);
long res = 0;
for (int i = 0; i < numsSize; ++i)
res = (res + (long)count[i] * nums[i]) % MOD;
return res;
}
|
the_stack_data/552515.c
|
#include<stdio.h>
int main(){
int j=4,a[5],temp=0;
/*
get arr
swap first to last
dec i and inc i upto it is equal or i<j
*/
for(int increment=0;increment<5;increment++){
scanf("%d",&a[increment]);
}
for(int i=0;i<5;i++){
if(i<=j&&j>=0){
temp=a[i];
a[i]=a[j];
a[j]=temp;
j--;
}
}
for(int i=0;i<5;i++){
printf("%d",a[i]);
}
return 0;
}
|
the_stack_data/712747.c
|
#include<stdio.h>
int main()
{
int n;
unsigned int tek,min,pom;
pom=2;
min=1;
printf("%u\n",pom);
printf("%u\n",min);
for(n=2;n<100;n++)
{
tek=min+pom;
printf("%u\n",tek);
pom=min;
min=tek;
}
return 0;
}
|
the_stack_data/200144420.c
|
#ifdef TACACS_AUTH
/*
/*
** tacacs_auth.c
**
** TACACS support for pop3d password authentication
**
** Author: Filippo Grassilli ([email protected])
** Date: 14-Jun-97
**
** This patch was written for systems that use TACACS authentication:
** although when a mbx resides on a host this entry must be present in
** users file, can be useful to keep authentication on another server.
** I use it also for logging reason.
** It works under Linux, *should* be portable!
**
*/
#include <stdio.h>
#include <signal.h>
#include <netdb.h>
#include <netinet/in.h>
typedef unsigned char uchar;
/* typedef unsigned long ulong; */
#include "tacacs.h"
/************************************************************************/
/* PROTO */
/************************************************************************/
void alrm(int sig);
int get_servername(char sname[]);
void get_myaddress(struct in_addr *addr);
/************************************************************************/
/* TACACS_VERIFY_USER */
/************************************************************************/
int tacacs_verify_user(char *user, char *pass)
{
int s,len,r;
struct hostent *he;
struct servent *se;
struct sockaddr_in sa;
char buf[256];
char tacacs_server[48];
struct in_addr my_hostaddress, server_addr;
xtacacstype *tp;
if(!get_servername(tacacs_server)) {
/*
printf("tacacs server not found\n");
*/
return(-1);
}
he=gethostbyname(tacacs_server);
if(!he) {
/*
printf("gethostbyname() failed [%s]\n",sys_errlist[errno]);
*/
return(-1);
}
memcpy((char *)&server_addr.s_addr,he->h_addr,4);
bzero((caddr_t)&sa,sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = server_addr.s_addr;
/* Tries to get svc name from services, else uses default */
se=getservbyname(TACACS_SVC_NAME,"udp");
if(se) sa.sin_port = se->s_port;
else sa.sin_port = htons(TACACS_PORT);
/*
printf("Server: %s Port: %d\n",inet_ntoa(server_addr),ntohs(sa.sin_port));
*/
if((s=socket(AF_INET,SOCK_DGRAM,0))<0) {
/* printf("socket() failed [%s]\n",sys_errlist[errno]); */
return(-1);
}
/* My address to tell tac-server the host contacted */
get_myaddress(&my_hostaddress);
bzero(buf,sizeof(buf));
tp=(xtacacstype *)&buf[0];
tp->type=XTA_LOGIN; /* Can be used also XTA_CONNECT */
tp->version=XTA_VERSION;
tp->trans=htons(getpid()); /* Haven't better idea?? */
tp->reason=XTA_A_NONE;
tp->dhost=my_hostaddress.s_addr; /* Already in network order */
tp->dport=htons(110); /* Use pop3 port number */
tp->lport=htons(0); /* Is it used by your server? */
tp->namelen=(char)strlen(user);
tp->pwlen=(char)strlen(pass);
len=XTACACSSIZE+tp->namelen+tp->pwlen;
memcpy(&buf[XTACACSSIZE],user,tp->namelen);
memcpy(&buf[XTACACSSIZE+tp->namelen],pass,tp->pwlen);
sendto(s,buf,len,0,(struct sockaddr *)&sa,sizeof(struct sockaddr_in));
/* Prepare to receive the answer */
memset(buf,0,sizeof(buf));
/* Set an appropriate timeout */
signal(SIGALRM,alrm);
alarm(ANSWER_TIMEOUT);
len=sizeof(struct sockaddr_in);
r=recvfrom(s,buf,sizeof(buf),0,(struct sockaddr *)&sa,&len);
alarm(0);
/* Probably timeout... */
if(r==-1) {
/*
printf(">>> XTACACS Timeout\n");
*/
return(-1);
}
/*
printf(">>> XTACACS response (%d bytes): [V%02x %s]\n",r,tp->version,tp->response==1?"Accepted":"Rejected");
printf(">>> V%02x Type:%d Answer:%d %s (reason %d)\n",tp->version,tp->type,tp->response,tp->response==1?"Accepted":"Rejected",tp->reason);
*/
close(s);
return(tp->response==1?0:-1);
}
/************************************************************************/
/* ALRM */
/************************************************************************/
void alrm(int sig)
{
return;
}
/************************************************************************/
/* GET_SERVERNAME */
/************************************************************************/
int get_servername(char sname[])
{
FILE *FP;
char buf[80];
int ok=0;
FP=fopen(SERVER_FILE,"r");
if(!FP) {
fprintf(stdout,"-ERR %s unavailable\r\n",SERVER_FILE);
return(0);
}
while(fgets(buf,sizeof(buf),FP)) {
buf[strlen(buf)-1]='\0';
if(!strncmp(buf,"server ",7)) {
strcpy(sname,&buf[7]);
ok=1;
break;
}
}
fclose(FP);
if(!ok) {
fprintf(stdout,"-ERR server not found in %s\r\n",SERVER_FILE);
}
return(ok);
}
/************************************************************************/
/* GET_MYADDRESS */
/************************************************************************/
void get_myaddress(struct in_addr *addr)
{
char name[48];
struct hostent *he;
gethostname(name,sizeof(name));
strncat(name,".",sizeof(name)-strlen(name)-1);
if(getdomainname(&name[strlen(name)],sizeof(name)-strlen(name-1))!=0) {
gethostname(name,sizeof(name));
}
he=gethostbyname(name);
memcpy((char *)&addr->s_addr,he->h_addr,4);
/* printf("%s\n",inet_ntoa(*addr)); */
}
/* EOF ******************************************************************/
#endif
|
the_stack_data/114039.c
|
extern int printf(const char *, ...);
enum { SUCCESS = 0, FAILURE = 1 };
void dummy() {}
int testee_AND_operator_2branches(int a, int b, int c) {
if (a < b && b < c) {
printf("left branch\n");
return a;
} else {
printf("right branch\n");
return b;
}
}
int testee_AND_operator_1branch(int a, int b, int c) {
if (a < b && b < c) {
printf("left branch\n");
return a;
}
printf("right branch\n");
return b;
}
/// Edge case: AND expression that always evaluates to a scalar value but also
/// contains a dummy function call (presence of a dummy function makes the
/// Branch instruction to be generated).
/// This case is based on https://github.com/mull-project/mull/issues/501.
/// The code below is based on the code generated by the csmith:
/// a() { ((b(), 9) || 9, 0) || a; }
int testee_AND_operator_always_scalars_case_with_function_call_pattern1(int A) {
if ((((dummy(), 0) && 1), 1) && A) {
printf("left branch\n");
return 1;
} else {
printf("right branch\n");
return 0;
}
}
int testee_AND_operator_always_scalars_case_with_function_call_pattern3(int A) {
if (((dummy(), 9) && 9), A) {
return 1;
} else {
printf("right branch\n");
return 0;
}
}
int test_AND_operator_2branches() {
if (testee_AND_operator_2branches(1, 3, 2) == 3) {
return SUCCESS;
}
return FAILURE;
}
int test_AND_operator_1branch() {
if (testee_AND_operator_1branch(1, 3, 2) == 3) {
return SUCCESS;
}
return FAILURE;
}
int test_AND_operator_always_scalars_case_with_function_call_pattern1() {
if (testee_AND_operator_always_scalars_case_with_function_call_pattern1(1) == 1) {
return SUCCESS;
}
return FAILURE;
}
int test_AND_operator_always_scalars_case_with_function_call_pattern3() {
if (testee_AND_operator_always_scalars_case_with_function_call_pattern3(1) == 1) {
return SUCCESS;
}
return FAILURE;
}
int main() {
if (test_AND_operator_2branches())
return 1;
if (test_AND_operator_1branch())
return 1;
if (test_AND_operator_always_scalars_case_with_function_call_pattern1())
return 1;
if (test_AND_operator_always_scalars_case_with_function_call_pattern3())
return 1;
return 0;
}
// clang-format off
// RUN: cd / && %clang_cc -fembed-bitcode -g -O0 %s -o %s.exe
// RUN: cd %CURRENT_DIR
// RUN: unset TERM; %MULL_EXEC -keep-executable -output=%s.mutated.exe -linker=%clang_cc -mutators=cxx_logical_and_to_or -ide-reporter-show-killed -reporters=IDE %s.exe | %FILECHECK_EXEC %s --dump-input=fail
// RUN: unset TERM; %mull_runner -ide-reporter-show-killed -reporters=IDE %s.mutated.exe | %FILECHECK_EXEC %s --dump-input=fail
// CHECK:[info] Killed mutants (2/5):
// CHECK:{{.*}}main.c:8:13: warning: Killed: Replaced && with || [cxx_logical_and_to_or]
// CHECK: if (a < b && b < c) {
// CHECK: ^
// CHECK:{{.*}}main.c:18:13: warning: Killed: Replaced && with || [cxx_logical_and_to_or]
// CHECK: if (a < b && b < c) {
// CHECK: ^
// CHECK:[info] Survived mutants (3/5):
// CHECK:{{.*}}main.c:34:22: warning: Survived: Replaced && with || [cxx_logical_and_to_or]
// CHECK: if ((((dummy(), 0) && 1), 1) && A) {
// CHECK: ^
// CHECK:{{.*}}main.c:34:32: warning: Survived: Replaced && with || [cxx_logical_and_to_or]
// CHECK: if ((((dummy(), 0) && 1), 1) && A) {
// CHECK: ^
// CHECK:{{.*}}main.c:44:21: warning: Survived: Replaced && with || [cxx_logical_and_to_or]
// CHECK: if (((dummy(), 9) && 9), A) {
// CHECK: ^
// CHECK:[info] Mutation score: 40%
|
the_stack_data/87637523.c
|
extern void __VERIFIER_error() __attribute__ ((__noreturn__));
void __VERIFIER_assert(int cond) {
if (!(cond)) {
ERROR: __VERIFIER_error();
}
return;
}
_Bool __VERIFIER_nondet_bool();
int __VERIFIER_nondet_int();
//x is an input variable
int x;
void foo() {
x--;
}
int main() {
x=__VERIFIER_nondet_int();
while (x > 0) {
_Bool c = __VERIFIER_nondet_bool();
if(c) foo();
else foo();
}
__VERIFIER_assert(x==0);
}
|
the_stack_data/6388753.c
|
#include<stdio.h>
int main()
{
int n,K,a[10001],b[101],c[101],d[101],e[101],J[101],i,j,A,B;
scanf("%d%d",&n,&K);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
int N(int l,int r)
{
int Add=0,i;
for(i=l;i<=r;i++){
Add=(Add+a[i])%n;
}
return Add;
}
int M(int l,int r)
{
int Mul=1,i;
for(i=l;i<=r;i++){
Mul=(Mul*a[i])%n;
}
return Mul;
}
int H(int l,int r)
{
int Or=a[l],i;
for(i=l;i<r;i++){
Or=Or^a[i+1];
}
return Or;
}
for(i=0;i<K;i++){
scanf("%d%d",&b[i],&c[i]);
}
for(i=0;i<K;i++){
d[i]=N(b[i],c[i]);
e[i]=M(b[i],c[i]);
if(d[i]<=e[i]){
A=d[i];
B=e[i];
}
else {
A=e[i];
B=d[i];
}
J[i]=H(A,B);
}
for(i=0;i<K;i++){
printf("%d\n",J[i]);
}
return 0;
}
|
the_stack_data/1204689.c
|
#include <ctype.h>
#undef isalnum
int isalnum(int c)
{
return isalpha(c) || isdigit(c);
}
#undef isalpha
int isalpha(int c)
{
return islower(c) || isupper(c);
}
#undef isblank
int isblank(int c)
{
return (c == ' ' || c == '\t');
}
#undef iscntrl
int iscntrl(int c)
{
return c >= 0x0 && c <= 0x8;
}
#undef isdigit
int isdigit(int c)
{
return c >= '0' && c <= '9';
}
#undef isgraph
int isgraph(int c)
{
return ispunct(c) || isalnum(c);
}
#undef islower
int islower(int c)
{
return c >= 'a' && c <= 'z';
}
#undef isprint
int isprint(int c)
{
return isgraph(c) || isspace(c);
}
#undef ispunct
int ispunct(int c)
{
return (c >= 0x21 && c <= 0x2F) || (c >= 0x3A && c <= 0x40) || (c >= 0x5B && c <= 0x60) || (c >= 0x7B && c <= 0x7E);
}
#undef isspace
int isspace(int c)
{
return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f' || c == '\v';
}
#undef isupper
int isupper(int c)
{
return c >= 'A' && c <= 'Z';
}
#undef isxdigit
int isxdigit(int c)
{
return isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
}
#undef tolower
int tolower(int c)
{
if (isupper(c))
return c + 'a' - 'A';
return c;
}
#undef toupper
int toupper(int c)
{
if (islower(c))
return c - 'a' + 'A';
return c;
}
|
the_stack_data/59512327.c
|
#include <stdio.h>
int int_high_prod(int x, int y){
return 0;
}
unsigned unsigned_high_prod(unsigned x, unsigned y){
int w = sizeof(int) << 3;
return int_high_prod(x, y);
}
|
the_stack_data/95904.c
|
/**
******************************************************************************
* @file stm32l5xx_ll_exti.c
* @author MCD Application Team
* @brief EXTI LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32l5xx_ll_exti.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32L5xx_LL_Driver
* @{
*/
#if defined (EXTI)
/** @defgroup EXTI_LL EXTI
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup EXTI_LL_Private_Macros
* @{
*/
#define IS_LL_EXTI_LINE_0_31(__VALUE__) (((__VALUE__) & ~LL_EXTI_LINE_ALL_0_31) == 0x00000000U)
#define IS_LL_EXTI_LINE_32_63(__VALUE__) (((__VALUE__) & ~LL_EXTI_LINE_ALL_32_63) == 0x00000000U)
#define IS_LL_EXTI_MODE(__VALUE__) (((__VALUE__) == LL_EXTI_MODE_IT) \
|| ((__VALUE__) == LL_EXTI_MODE_EVENT) \
|| ((__VALUE__) == LL_EXTI_MODE_IT_EVENT))
#define IS_LL_EXTI_TRIGGER(__VALUE__) (((__VALUE__) == LL_EXTI_TRIGGER_NONE) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_FALLING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING_FALLING))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup EXTI_LL_Exported_Functions
* @{
*/
/** @addtogroup EXTI_LL_EF_Init
* @{
*/
/**
* @brief De-initialize the EXTI registers to their default reset values.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_EXTI_DeInit(void)
{
/* Interrupt mask register set to default reset values */
LL_EXTI_WriteReg(IMR1, 0xFF9E0000U);
/* Event mask register set to default reset values */
LL_EXTI_WriteReg(EMR1, 0x00000000U);
/* Rising Trigger selection register set to default reset values */
LL_EXTI_WriteReg(RTSR1, 0x00000000U);
/* Falling Trigger selection register set to default reset values */
LL_EXTI_WriteReg(FTSR1, 0x00000000U);
/* Software interrupt event register set to default reset values */
LL_EXTI_WriteReg(SWIER1, 0x00000000U);
/* Pending register set to default reset values */
LL_EXTI_WriteReg(RPR1, 0x0031FFFFU);
LL_EXTI_WriteReg(FPR1, 0x0031FFFFU);
/* Privilege register set to default reset values */
LL_EXTI_WriteReg(PRIVCFGR1, 0x00000000U);
#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
/* Secure register set to default reset values */
LL_EXTI_WriteReg(SECCFGR1, 0x00000000U);
#endif
/* Interrupt mask register 2 set to default reset values */
LL_EXTI_WriteReg(IMR2, 0x00000787U);
/* Event mask register 2 set to default reset values */
LL_EXTI_WriteReg(EMR2, 0x00000000U);
/* Rising Trigger selection register 2 set to default reset values */
LL_EXTI_WriteReg(RTSR2, 0x00000000U);
/* Falling Trigger selection register 2 set to default reset values */
LL_EXTI_WriteReg(FTSR2, 0x00000000U);
/* Software interrupt event register 2 set to default reset values */
LL_EXTI_WriteReg(SWIER2, 0x00000000U);
/* Pending register 2 set to default reset values */
LL_EXTI_WriteReg(RPR2, 0x00000078U);
LL_EXTI_WriteReg(FPR2, 0x00000078U);
/* Privilege register set to default reset values */
LL_EXTI_WriteReg(PRIVCFGR2, 0x00000000U);
#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
/* Secure register set to default reset values */
LL_EXTI_WriteReg(SECCFGR2, 0x00000000U);
#endif
return SUCCESS;
}
/**
* @brief Initialize the EXTI registers according to the specified parameters in EXTI_InitStruct.
* @param EXTI_InitStruct pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are initialized
* - ERROR: not applicable
*/
ErrorStatus LL_EXTI_Init(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_LL_EXTI_LINE_0_31(EXTI_InitStruct->Line_0_31));
assert_param(IS_LL_EXTI_LINE_32_63(EXTI_InitStruct->Line_32_63));
assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->LineCommand));
assert_param(IS_LL_EXTI_MODE(EXTI_InitStruct->Mode));
/* ENABLE LineCommand */
if (EXTI_InitStruct->LineCommand != DISABLE)
{
assert_param(IS_LL_EXTI_TRIGGER(EXTI_InitStruct->Trigger));
/* Configure EXTI Lines in range from 0 to 31 */
if (EXTI_InitStruct->Line_0_31 != LL_EXTI_LINE_NONE)
{
switch (EXTI_InitStruct->Mode)
{
case LL_EXTI_MODE_IT:
/* First Disable Event on provided Lines */
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable IT on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_EVENT:
/* First Disable IT on provided Lines */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Event on provided Lines */
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_IT_EVENT:
/* Directly Enable IT & Event on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
if (EXTI_InitStruct->Trigger != LL_EXTI_TRIGGER_NONE)
{
switch (EXTI_InitStruct->Trigger)
{
case LL_EXTI_TRIGGER_RISING:
/* First Disable Falling Trigger on provided Lines */
LL_EXTI_DisableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Rising Trigger on provided Lines */
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_FALLING:
/* First Disable Rising Trigger on provided Lines */
LL_EXTI_DisableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Falling Trigger on provided Lines */
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_RISING_FALLING:
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
}
}
/* Configure EXTI Lines in range from 32 to 63 */
if (EXTI_InitStruct->Line_32_63 != LL_EXTI_LINE_NONE)
{
switch (EXTI_InitStruct->Mode)
{
case LL_EXTI_MODE_IT:
/* First Disable Event on provided Lines */
LL_EXTI_DisableEvent_32_63(EXTI_InitStruct->Line_32_63);
/* Then Enable IT on provided Lines */
LL_EXTI_EnableIT_32_63(EXTI_InitStruct->Line_32_63);
break;
case LL_EXTI_MODE_EVENT:
/* First Disable IT on provided Lines */
LL_EXTI_DisableIT_32_63(EXTI_InitStruct->Line_32_63);
/* Then Enable Event on provided Lines */
LL_EXTI_EnableEvent_32_63(EXTI_InitStruct->Line_32_63);
break;
case LL_EXTI_MODE_IT_EVENT:
/* Directly Enable IT & Event on provided Lines */
LL_EXTI_EnableIT_32_63(EXTI_InitStruct->Line_32_63);
LL_EXTI_EnableEvent_32_63(EXTI_InitStruct->Line_32_63);
break;
default:
status = ERROR;
break;
}
if (EXTI_InitStruct->Trigger != LL_EXTI_TRIGGER_NONE)
{
switch (EXTI_InitStruct->Trigger)
{
case LL_EXTI_TRIGGER_RISING:
/* First Disable Falling Trigger on provided Lines */
LL_EXTI_DisableFallingTrig_32_63(EXTI_InitStruct->Line_32_63);
/* Then Enable IT on provided Lines */
LL_EXTI_EnableRisingTrig_32_63(EXTI_InitStruct->Line_32_63);
break;
case LL_EXTI_TRIGGER_FALLING:
/* First Disable Rising Trigger on provided Lines */
LL_EXTI_DisableRisingTrig_32_63(EXTI_InitStruct->Line_32_63);
/* Then Enable Falling Trigger on provided Lines */
LL_EXTI_EnableFallingTrig_32_63(EXTI_InitStruct->Line_32_63);
break;
case LL_EXTI_TRIGGER_RISING_FALLING:
LL_EXTI_EnableRisingTrig_32_63(EXTI_InitStruct->Line_32_63);
LL_EXTI_EnableFallingTrig_32_63(EXTI_InitStruct->Line_32_63);
break;
default:
status = ERROR;
break;
}
}
}
}
/* DISABLE LineCommand */
else
{
/* De-configure EXTI Lines in range from 0 to 31 */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
/* De-configure EXTI Lines in range from 32 to 63 */
LL_EXTI_DisableIT_32_63(EXTI_InitStruct->Line_32_63);
LL_EXTI_DisableEvent_32_63(EXTI_InitStruct->Line_32_63);
}
return status;
}
/**
* @brief Set each @ref LL_EXTI_InitTypeDef field to default value.
* @param EXTI_InitStruct Pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval None
*/
void LL_EXTI_StructInit(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
EXTI_InitStruct->Line_0_31 = LL_EXTI_LINE_NONE;
EXTI_InitStruct->Line_32_63 = LL_EXTI_LINE_NONE;
EXTI_InitStruct->LineCommand = DISABLE;
EXTI_InitStruct->Mode = LL_EXTI_MODE_IT;
EXTI_InitStruct->Trigger = LL_EXTI_TRIGGER_FALLING;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* defined (EXTI) */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/50657.c
|
//1789 - A Corrida de Lesmas
#include <stdio.h>
int main(){
int nLesmas, max, i, velo;
while((scanf("%d", &nLesmas)) != EOF){
//prenchimento do vetor
max = 0;
for(i = 0; i < nLesmas; i++){
scanf("%d", &velo);
if(velo > max){
max = velo;
}
}
//comparação
if(max < 10){
printf("1\n");
}
else if(max >= 10 && max < 20){
printf("2\n");
}
else{
printf("3\n");
}
}
return 0;
}
|
the_stack_data/77111.c
|
// %%cpp test_call.c
// %run arm-linux-gnueabi-gcc -marm test_call.c -O2 -o test_call.exe
// %run qemu-arm ./test_call.exe
#include <stdio.h>
int print_a(int a);
__asm__(R"(
.text
.global print_a
print_a:
push {lr}
mov r2, r0
ldr r0, =stdout // load address of variable 'stdout'
ldr r0, [r0] // load variable by address (value is FILE* pointer)
ldr r1, =.format_string // load address
ldr r3, .const_number // load value
bl fprintf
pop {pc}
.format_string:
.ascii "Your number is %d, const number is %d\n" // заметьте, оно конкатенируется со слеюущим литералом
.ascii "\0" // а \0 тут надо писать! Можете попытаться закомментировать эту строчку
.const_number:
.word 100200300
)");
int main() {
fprintf(stdout, "Your number is %d, const number is %d\n", 100500, 100200300);
print_a(100500);
}
|
the_stack_data/8750.c
|
#include <stdio.h>
int main(){
int n;
int i, cont=1, aux;
int ganhador;
while (scanf (" %d", &n) && n!=0){
for(i=1; i<=n; i++){
scanf (" %d", &aux);
if (aux == i)
ganhador=i;
}
printf ("Teste %d\n%d\n",cont,ganhador);
cont++;
}
return 0;
}
|
the_stack_data/212643938.c
|
/* { dg-do run } */
/* { dg-options "-O1 -ftree-loop-linear" } */
extern void abort (void);
#define K 32
int cond_array[2*K][K];
int a[K][K];
int out[K];
int check_result[K] = {2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
__attribute__ ((noinline)) void
foo (int c)
{
int res, i, j, k, next;
for (k = 0; k < K; k++)
{
res = 0;
for (j = 0; j < K; j++)
for (i = 0; i < K; i++)
{
next = a[i][j];
res = c > cond_array[i+k][j] ? next : res;
}
out[k] = res;
}
}
int main ()
{
int i, j, k;
for (j = 0; j < K; j++)
{
for (i = 0; i < 2*K; i++)
cond_array[i][j] = i+j;
for (i = 0; i < K; i++)
a[i][j] = i+2;
}
foo(5);
for (k = 0; k < K; k++)
if (out[k] != check_result[k])
abort ();
return 0;
}
|
the_stack_data/97457.c
|
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
#ifndef THZ_GENERIC_FILE
#define THZ_GENERIC_FILE "generic/THZTensorMath.c"
#else
#define THZ_OMP_OVERHEAD_THZRESHOLD 100000
void THZTensor_(fill)(THZTensor *r_, real value)
{
TH_TENSOR_APPLY(real, r_,
THZVector_(fill)(r__data, value, r__size); break;);
}
void THZTensor_(zero)(THZTensor *r_)
{
TH_TENSOR_APPLY(real, r_,
THZVector_(fill)(r__data, 0, r__size); break;);
}
void THZTensor_(maskedFill)(THZTensor *tensor, THByteTensor *mask, real value)
{
TH_TENSOR_APPLY2(real, tensor, unsigned char, mask,
if (*mask_data > 1) THError("Mask tensor can take 0 and 1 values only");
else if (*mask_data == 1) *tensor_data = value;);
}
void THZTensor_(maskedCopy)(THZTensor *tensor, THByteTensor *mask, THZTensor* src )
{
THZTensor *srct = THZTensor_(newContiguous)(src);
real *src_data = THZTensor_(data)(srct);
long cntr = 0;
long nelem = THZTensor_(nElement)(srct);
TH_TENSOR_APPLY2(real, tensor, unsigned char, mask,
if (*mask_data > 1)
{
THError("Mask tensor can take 0 and 1 values only");
}
else if (*mask_data == 1)
{
*tensor_data = *src_data;
src_data++;
cntr++;
if (cntr > nelem)
THError("Number of elements of src != mask");
});
if (cntr != nelem)
THError("Number of elements of src != mask");
THZTensor_(free)(srct);
}
void THZTensor_(maskedSelect)(THZTensor *tensor, THZTensor *src, THByteTensor *mask)
{
long numel = THByteTensor_sumall(mask);
real *tensor_data;
THZTensor_(resize1d)(tensor,numel);
tensor_data = THZTensor_(data)(tensor);
TH_TENSOR_APPLY2(real, src, unsigned char, mask,
if (*mask_data > 1)
{
THError("Mask tensor can take 0 and 1 values only");
}
else if (*mask_data == 1)
{
*tensor_data = *src_data;
tensor_data++;
});
}
void THZTensor_(indexSelect)(THZTensor *tensor, THZTensor *src, int dim, THLongTensor *index)
{
long i, numel;
THLongStorage *newSize;
THZTensor *tSlice, *sSlice;
long *index_data;
THArgCheck(index->nDimension == 1, 3, "Index is supposed to be a vector");
THArgCheck(dim < src->nDimension,4,"Indexing dim is out of bounds");
THArgCheck(src->nDimension > 0,2,"Source tensor is empty");
numel = THLongTensor_nElement(index);
newSize = THLongStorage_newWithSize(src->nDimension);
THLongStorage_rawCopy(newSize,src->size);
newSize->data[dim] = numel;
THZTensor_(resize)(tensor,newSize,NULL);
THLongStorage_free(newSize);
index = THLongTensor_newContiguous(index);
index_data = THLongTensor_data(index);
for (i=0; i<numel; i++)
{
if (src->nDimension > 1)
{
tSlice = THZTensor_(new)();
sSlice = THZTensor_(new)();
THZTensor_(select)(tSlice, tensor, dim, i);
THZTensor_(select)(sSlice, src, dim, index_data[i]-1);
THZTensor_(copy)(tSlice, sSlice);
THZTensor_(free)(tSlice);
THZTensor_(free)(sSlice);
}
else
{
THZTensor_(set1d)(tensor,i,THZTensor_(get1d)(src,index_data[i]-1));
}
}
THLongTensor_free(index);
}
void THZTensor_(indexCopy)(THZTensor *tensor, int dim, THLongTensor *index, THZTensor *src)
{
long i, numel;
THZTensor *tSlice, *sSlice;
long *index_data;
numel = THLongTensor_nElement(index);
THArgCheck(index->nDimension == 1, 3, "Index is supposed to be a vector");
THArgCheck(dim < src->nDimension,4,"Indexing dim is out of bounds");
THArgCheck(numel == src->size[dim],4,"Number of indices should be equal to source:size(dim)");
index = THLongTensor_newContiguous(index);
index_data = THLongTensor_data(index);
for (i=0; i<numel; i++)
{
if (tensor->nDimension > 1 )
{
tSlice = THZTensor_(new)();
sSlice = THZTensor_(new)();
THZTensor_(select)(tSlice, tensor, dim, index_data[i]-1);
THZTensor_(select)(sSlice, src, dim, i);
THZTensor_(copy)(tSlice, sSlice);
THZTensor_(free)(tSlice);
THZTensor_(free)(sSlice);
}
else
{
THZTensor_(set1d)(tensor,index_data[i]-1,THZTensor_(get1d)(src,i));
}
}
THLongTensor_free(index);
}
void THZTensor_(indexFill)(THZTensor *tensor, int dim, THLongTensor *index, real val)
{
long i, numel;
THZTensor *tSlice;
long *index_data;
numel = THLongTensor_nElement(index);
THArgCheck(index->nDimension == 1, 3, "Index is supposed to be a vector");
THArgCheck(dim < tensor->nDimension,4,"Indexing dim is out of bounds");
index = THLongTensor_newContiguous(index);
index_data = THLongTensor_data(index);
for (i=0; i<numel; i++)
{
if (tensor->nDimension > 1 )
{
tSlice = THZTensor_(new)();
THZTensor_(select)(tSlice, tensor,dim,index_data[i]-1);
THZTensor_(fill)(tSlice, val);
THZTensor_(free)(tSlice);
}
else
{
THZTensor_(set1d)(tensor,index_data[i]-1,val);
}
}
THLongTensor_free(index);
}
accreal THZTensor_(dot)(THZTensor *tensor, THZTensor *src)
{
accreal sum = 0;
/* we use a trick here. careful with that. */
TH_TENSOR_APPLY2(real, tensor, real, src,
long sz = (tensor_size-tensor_i < src_size-src_i ? tensor_size-tensor_i : src_size-src_i);
sum += THZBlas_(dot)(sz, src_data, src_stride, tensor_data, tensor_stride);
tensor_i += sz;
src_i += sz;
tensor_data += sz*tensor_stride;
src_data += sz*src_stride;
break;);
return sum;
}
real THZTensor_(minall)(THZTensor *tensor)
{
real theMin;
THArgCheck(tensor->nDimension > 0, 1, "tensor must have one dimension");
theMin = THZTensor_(data)(tensor)[0];
TH_TENSOR_APPLY(real, tensor, if(CABS(*tensor_data) < CABS(theMin)) theMin = *tensor_data;);
return theMin;
}
real THZTensor_(maxall)(THZTensor *tensor)
{
real theMax;
THArgCheck(tensor->nDimension > 0, 1, "tensor must have one dimension");
theMax = THZTensor_(data)(tensor)[0];
TH_TENSOR_APPLY(real, tensor, if(CABS(*tensor_data) > CABS(theMax)) theMax = *tensor_data;);
return theMax;
}
accreal THZTensor_(sumall)(THZTensor *tensor)
{
accreal sum = 0;
TH_TENSOR_APPLY(real, tensor, sum += *tensor_data;);
return sum;
}
void THZTensor_(add)(THZTensor *r_, THZTensor *t, real value)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(t)) {
real *tp = THZTensor_(data)(t);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i<sz; i++)
rp[i] = tp[i] + value;
} else {
TH_TENSOR_APPLY2(real, r_, real, t, *r__data = *t_data + value;);
}
}
void THZTensor_(mul)(THZTensor *r_, THZTensor *t, real value)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(t)) {
real *tp = THZTensor_(data)(t);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i<sz; i++)
rp[i] = tp[i] * value;
} else {
TH_TENSOR_APPLY2(real, r_, real, t, *r__data = *t_data * value;);
}
}
void THZTensor_(div)(THZTensor *r_, THZTensor *t, real value)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(t)) {
real *tp = THZTensor_(data)(t);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i<sz; i++)
rp[i] = tp[i] / value;
} else {
TH_TENSOR_APPLY2(real, r_, real, t, *r__data = *t_data / value;);
}
}
void THZTensor_(cadd)(THZTensor *r_, THZTensor *t, real value, THZTensor *src)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(isContiguous)(src) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(src)) {
if(r_ == t) {
THZBlas_(axpy)(THZTensor_(nElement)(t), value, THZTensor_(data)(src), 1, THZTensor_(data)(r_), 1);
} else {
real *tp = THZTensor_(data)(t);
real *sp = THZTensor_(data)(src);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i< sz; i++)
rp[i] = tp[i] + value * sp[i];
}
} else {
TH_TENSOR_APPLY3(real, r_, real, t, real, src, *r__data = *t_data + value * *src_data;);
}
}
void THZTensor_(cmul)(THZTensor *r_, THZTensor *t, THZTensor *src)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(isContiguous)(src) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(src)) {
real *tp = THZTensor_(data)(t);
real *sp = THZTensor_(data)(src);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i<sz; i++)
rp[i] = tp[i] * sp[i];
} else {
TH_TENSOR_APPLY3(real, r_, real, t, real, src, *r__data = *t_data * *src_data;);
}
}
void THZTensor_(cdiv)(THZTensor *r_, THZTensor *t, THZTensor *src)
{
THZTensor_(resizeAs)(r_, t);
if (THZTensor_(isContiguous)(r_) && THZTensor_(isContiguous)(t) && THZTensor_(isContiguous)(src) && THZTensor_(nElement)(r_) == THZTensor_(nElement)(src)) {
real *tp = THZTensor_(data)(t);
real *sp = THZTensor_(data)(src);
real *rp = THZTensor_(data)(r_);
long sz = THZTensor_(nElement)(t);
long i;
#pragma omp parallel for if(sz > THZ_OMP_OVERHEAD_THZRESHOLD) private(i)
for (i=0; i<sz; i++)
rp[i] = tp[i] / sp[i];
} else {
TH_TENSOR_APPLY3(real, r_, real, t, real, src, *r__data = *t_data / *src_data;);
}
}
void THZTensor_(addcmul)(THZTensor *r_, THZTensor *t, real value, THZTensor *src1, THZTensor *src2)
{
if(r_ != t)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
TH_TENSOR_APPLY3(real, r_, real, src1, real, src2, *r__data += value * *src1_data * *src2_data;);
}
void THZTensor_(addcdiv)(THZTensor *r_, THZTensor *t, real value, THZTensor *src1, THZTensor *src2)
{
if(r_ != t)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
TH_TENSOR_APPLY3(real, r_, real, src1, real, src2, *r__data += value * *src1_data / *src2_data;);
}
void THZTensor_(addmv)(THZTensor *r_, real beta, THZTensor *t, real alpha, THZTensor *mat, THZTensor *vec)
{
if( (mat->nDimension != 2) || (vec->nDimension != 1) )
THError("matrix and vector expected");
if( mat->size[1] != vec->size[0] )
THError("size mismatch");
if(t->nDimension != 1)
THError("size mismatch");
if(t->size[0] != mat->size[0])
THError("size mismatch");
if(r_ != t)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
if(mat->stride[0] == 1)
{
THZBlas_(gemv)('n', mat->size[0], mat->size[1],
alpha, THZTensor_(data)(mat), mat->stride[1],
THZTensor_(data)(vec), vec->stride[0],
beta, THZTensor_(data)(r_), r_->stride[0]);
}
else if(mat->stride[1] == 1)
{
THZBlas_(gemv)('t', mat->size[1], mat->size[0],
alpha, THZTensor_(data)(mat), mat->stride[0],
THZTensor_(data)(vec), vec->stride[0],
beta, THZTensor_(data)(r_), r_->stride[0]);
}
else
{
THZTensor *cmat = THZTensor_(newContiguous)(mat);
THZBlas_(gemv)('t', mat->size[1], mat->size[0],
alpha, THZTensor_(data)(cmat), cmat->stride[0],
THZTensor_(data)(vec), vec->stride[0],
beta, THZTensor_(data)(r_), r_->stride[0]);
THZTensor_(free)(cmat);
}
}
void THZTensor_(addmm)(THZTensor *r_, real beta, THZTensor *t, real alpha, THZTensor *m1, THZTensor *m2)
{
char transpose_r, transpose_m1, transpose_m2;
THZTensor *r__, *m1_, *m2_;
if( (m1->nDimension != 2) || (m2->nDimension != 2) )
THError("matrix and matrix expected");
if(t->nDimension != 2)
THError("size mismatch");
if( (t->size[0] != m1->size[0]) || (t->size[1] != m2->size[1]) || (m1->size[1] != m2->size[0]) )
THError("size mismatch");
if(t != r_)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
/* printf("%ldx%ld = %ldx%ld X %ldx%ld\n", r_->size[0], r_->size[1], m1->size[0], m1->size[1], m2->size[0], m2->size[1]); */
/* r_ */
if(r_->stride[0] == 1)
{
transpose_r = 'n';
r__ = r_;
}
else if(r_->stride[1] == 1)
{
THZTensor *swap = m2;
m2 = m1;
m1 = swap;
transpose_r = 't';
r__ = r_;
}
else
{
transpose_r = 'n';
r__ = THZTensor_(newWithSize2d)(r_->size[1], r_->size[0]);
THZTensor_(copy)(r__, r_);
THZTensor_(transpose)(r__, NULL, 0, 1);
}
/* m1 */
if(m1->stride[(transpose_r == 'n' ? 0 : 1)] == 1)
{
transpose_m1 = 'n';
m1_ = m1;
}
else if(m1->stride[(transpose_r == 'n' ? 1 : 0)] == 1)
{
transpose_m1 = 't';
m1_ = m1;
}
else
{
transpose_m1 = (transpose_r == 'n' ? 't' : 'n');
m1_ = THZTensor_(newContiguous)(m1);
}
/* m2 */
if(m2->stride[(transpose_r == 'n' ? 0 : 1)] == 1)
{
transpose_m2 = 'n';
m2_ = m2;
}
else if(m2->stride[(transpose_r == 'n' ? 1 : 0)] == 1)
{
transpose_m2 = 't';
m2_ = m2;
}
else
{
transpose_m2 = (transpose_r == 'n' ? 't' : 'n');
m2_ = THZTensor_(newContiguous)(m2);
}
/* do the operation */
THZBlas_(gemm)(transpose_m1,
transpose_m2,
r__->size[(transpose_r == 'n' ? 0 : 1)],
r__->size[(transpose_r == 'n' ? 1 : 0)],
m1_->size[(transpose_r == 'n' ? 1 : 0)],
alpha,
THZTensor_(data)(m1_),
(transpose_m1 == 'n' ? m1_->stride[(transpose_r == 'n' ? 1 : 0)] : m1_->stride[(transpose_r == 'n' ? 0 : 1)]),
THZTensor_(data)(m2_),
(transpose_m2 == 'n' ? m2_->stride[(transpose_r == 'n' ? 1 : 0)] : m2_->stride[(transpose_r == 'n' ? 0 : 1)]),
beta,
THZTensor_(data)(r__),
r__->stride[(transpose_r == 'n' ? 1 : 0)]);
/* free intermediate variables */
if(m1_ != m1)
THZTensor_(free)(m1_);
if(m2_ != m2)
THZTensor_(free)(m2_);
if(r__ != r_)
THZTensor_(freeCopyTo)(r__, r_);
}
void THZTensor_(addr)(THZTensor *r_, real beta, THZTensor *t, real alpha, THZTensor *vec1, THZTensor *vec2)
{
if( (vec1->nDimension != 1) || (vec2->nDimension != 1) )
THError("vector and vector expected");
if(t->nDimension != 2)
THError("size mismatch");
if( (t->size[0] != vec1->size[0]) || (t->size[1] != vec2->size[0]) )
THError("size mismatch");
if(r_ != t)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
if(beta != 1)
THZTensor_(mul)(r_, r_, beta);
if(r_->stride[0] == 1)
{
THZBlas_(gerc)(vec1->size[0], vec2->size[0],
alpha, THZTensor_(data)(vec1), vec1->stride[0],
THZTensor_(data)(vec2), vec2->stride[0],
THZTensor_(data)(r_), r_->stride[1]);
}
else
{
THZTensor *cr = r_;
if(r_->stride[1] != 1)
cr = THZTensor_(newClone)(r_);
THZTensor *cvec2 = THZTensor_(new)();
THZTensor_(conj)(cvec2, vec2);
THZBlas_(geru)(cvec2->size[0], vec1->size[0],
alpha, THZTensor_(data)(cvec2), cvec2->stride[0],
THZTensor_(data)(vec1), vec1->stride[0],
THZTensor_(data)(cr), cr->stride[0]);
THZTensor_(free)(cvec2);
if (cr != r_)
THZTensor_(freeCopyTo)(cr, r_);
}
}
void THZTensor_(addru)(THZTensor *r_, real beta, THZTensor *t, real alpha, THZTensor *vec1, THZTensor *vec2)
{
if( (vec1->nDimension != 1) || (vec2->nDimension != 1) )
THError("vector and vector expected");
if(t->nDimension != 2)
THError("size mismatch");
if( (t->size[0] != vec1->size[0]) || (t->size[1] != vec2->size[0]) )
THError("size mismatch");
if(r_ != t)
{
THZTensor_(resizeAs)(r_, t);
THZTensor_(copy)(r_, t);
}
if(beta != 1)
THZTensor_(mul)(r_, r_, beta);
if(r_->stride[0] == 1)
{
THZBlas_(geru)(vec1->size[0], vec2->size[0],
alpha, THZTensor_(data)(vec1), vec1->stride[0],
THZTensor_(data)(vec2), vec2->stride[0],
THZTensor_(data)(r_), r_->stride[1]);
}
else if(r_->stride[0] == 1)
{
THZBlas_(geru)(vec2->size[0], vec1->size[0],
alpha, THZTensor_(data)(vec2), vec2->stride[0],
THZTensor_(data)(vec1), vec1->stride[0],
THZTensor_(data)(r_), r_->stride[0]);
}
else
{
THZTensor *cr = THZTensor_(newClone)(r_);
THZBlas_(geru)(vec2->size[0], vec1->size[0],
alpha, THZTensor_(data)(vec2), vec2->stride[0],
THZTensor_(data)(vec1), vec1->stride[0],
THZTensor_(data)(cr), cr->stride[0]);
THZTensor_(freeCopyTo)(cr, r_);
}
}
long THZTensor_(numel)(THZTensor *t)
{
return THZTensor_(nElement)(t);
}
void THZTensor_(max)(THZTensor *values_, THLongTensor *indices_, THZTensor *t, int dimension)
{
THLongStorage *dim;
long i;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(values_, dim, NULL);
THLongTensor_resize(indices_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY3(real, t, real, values_, long, indices_, dimension,
long theIndex = 0;
real theMax = t_data[0];
for(i = 1; i < t_size; i++)
{
if(CABS(t_data[i*t_stride]) > CABS(theMax))
{
theIndex = i;
theMax = t_data[i*t_stride];
}
}
*indices__data = theIndex;
*values__data = theMax;);
}
void THZTensor_(min)(THZTensor *values_, THLongTensor *indices_, THZTensor *t, int dimension)
{
THLongStorage *dim;
long i;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(values_, dim, NULL);
THLongTensor_resize(indices_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY3(real, t, real, values_, long, indices_, dimension,
long theIndex = 0;
real theMin = t_data[0];
for(i = 1; i < t_size; i++)
{
if(CABS(t_data[i*t_stride]) < CABS(theMin))
{
theIndex = i;
theMin = t_data[i*t_stride];
}
}
*indices__data = theIndex;
*values__data = theMin;);
}
void THZTensor_(sum)(THZTensor *r_, THZTensor *t, int dimension)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
long i;
for(i = 0; i < t_size; i++)
sum += t_data[i*t_stride];
*r__data = (real)sum;);
}
void THZTensor_(prod)(THZTensor *r_, THZTensor *t, int dimension)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal prod = 1;
long i;
for(i = 0; i < t_size; i++)
prod *= t_data[i*t_stride];
*r__data = (real)prod;);
}
void THZTensor_(cumsum)(THZTensor *r_, THZTensor *t, int dimension)
{
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
THZTensor_(resizeAs)(r_, t);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal cumsum = 0;
long i;
for(i = 0; i < t_size; i++)
{
cumsum += t_data[i*t_stride];
r__data[i*r__stride] = (real)cumsum;
});
}
void THZTensor_(cumprod)(THZTensor *r_, THZTensor *t, int dimension)
{
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "dimension out of range");
THZTensor_(resizeAs)(r_, t);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal cumprod = 1;
long i;
for(i = 0; i < t_size; i++)
{
cumprod *= t_data[i*t_stride];
r__data[i*r__stride] = (real)cumprod;
});
}
accreal THZTensor_(trace)(THZTensor *t)
{
real *t_data = THZTensor_(data)(t);
accreal sum = 0;
long i = 0;
long t_stride_0, t_stride_1, t_diag_size;
THArgCheck(THZTensor_(nDimension)(t) == 2, 1, "not a matrix");
t_stride_0 = THZTensor_(stride)(t, 0);
t_stride_1 = THZTensor_(stride)(t, 1);
t_diag_size = THMin(THZTensor_(size)(t, 0), THZTensor_(size)(t, 1));
while(i < t_diag_size)
{
sum += t_data[i*(t_stride_0+t_stride_1)];
i++;
}
return sum;
}
void THZTensor_(cross)(THZTensor *r_, THZTensor *a, THZTensor *b, int dimension)
{
int i;
if(THZTensor_(nDimension)(a) != THZTensor_(nDimension)(b))
THError("inconsitent tensor sizes");
for(i = 0; i < THZTensor_(nDimension)(a); i++)
{
if(THZTensor_(size)(a, i) != THZTensor_(size)(b, i))
THError("inconsistent tensor sizes");
}
if(dimension < 0)
{
for(i = 0; i < THZTensor_(nDimension)(a); i++)
{
if(THZTensor_(size)(a, i) == 3)
{
dimension = i;
break;
}
}
if(dimension < 0)
THError("no dimension of size 3");
}
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(a), 3, "dimension out of range");
THArgCheck(THZTensor_(size)(a, dimension) == 3, 3, "dimension size is not 3");
THZTensor_(resizeAs)(r_, a);
TH_TENSOR_DIM_APPLY3(real, a, real, b, real, r_, dimension,
r__data[0*r__stride] = a_data[1*a_stride]*b_data[2*b_stride] - a_data[2*a_stride]*b_data[1*b_stride];
r__data[1*r__stride] = a_data[2*a_stride]*b_data[0*b_stride] - a_data[0*a_stride]*b_data[2*b_stride];
r__data[2*r__stride] = a_data[0*a_stride]*b_data[1*b_stride] - a_data[1*a_stride]*b_data[0*b_stride];);
}
void THZTensor_(zeros)(THZTensor *r_, THLongStorage *size)
{
THZTensor_(resize)(r_, size, NULL);
THZTensor_(zero)(r_);
}
void THZTensor_(ones)(THZTensor *r_, THLongStorage *size)
{
THZTensor_(resize)(r_, size, NULL);
THZTensor_(fill)(r_, 1);
}
void THZTensor_(diag)(THZTensor *r_, THZTensor *t, int k)
{
THArgCheck(THZTensor_(nDimension)(t) == 1 || THZTensor_(nDimension)(t) == 2, 1, "matrix or a vector expected");
if(THZTensor_(nDimension)(t) == 1)
{
real *t_data = THZTensor_(data)(t);
long t_stride_0 = THZTensor_(stride)(t, 0);
long t_size = THZTensor_(size)(t, 0);
long sz = t_size + (k >= 0 ? k : -k);
real *r__data;
long r__stride_0;
long r__stride_1;
long i;
THZTensor_(resize2d)(r_, sz, sz);
THZTensor_(zero)(r_);
r__data = THZTensor_(data)(r_);
r__stride_0 = THZTensor_(stride)(r_, 0);
r__stride_1 = THZTensor_(stride)(r_, 1);
r__data += (k >= 0 ? k*r__stride_1 : -k*r__stride_0);
for(i = 0; i < t_size; i++)
r__data[i*(r__stride_0+r__stride_1)] = t_data[i*t_stride_0];
}
else
{
real *t_data = THZTensor_(data)(t);
long t_stride_0 = THZTensor_(stride)(t, 0);
long t_stride_1 = THZTensor_(stride)(t, 1);
long sz;
real *r__data;
long r__stride_0;
long i;
if(k >= 0)
sz = THMin(THZTensor_(size)(t, 0), THZTensor_(size)(t, 1)-k);
else
sz = THMin(THZTensor_(size)(t, 0)+k, THZTensor_(size)(t, 1));
THZTensor_(resize1d)(r_, sz);
r__data = THZTensor_(data)(r_);
r__stride_0 = THZTensor_(stride)(r_, 0);
t_data += (k >= 0 ? k*t_stride_1 : -k*t_stride_0);
for(i = 0; i < sz; i++)
r__data[i*r__stride_0] = t_data[i*(t_stride_0+t_stride_1)];
}
}
void THZTensor_(eye)(THZTensor *r_, long n, long m)
{
real *r__data;
long i, sz;
THArgCheck(n > 0, 1, "invalid argument");
if(m <= 0)
m = n;
THZTensor_(resize2d)(r_, n, m);
THZTensor_(zero)(r_);
i = 0;
r__data = THZTensor_(data)(r_);
sz = THMin(THZTensor_(size)(r_, 0), THZTensor_(size)(r_, 1));
for(i = 0; i < sz; i++)
r__data[i*(r_->stride[0]+r_->stride[1])] = 1;
}
void THZTensor_(reshape)(THZTensor *r_, THZTensor *t, THLongStorage *size)
{
THZTensor_(resize)(r_, size, NULL);
THZTensor_(copy)(r_, t);
}
/* I cut and pasted (slightly adapted) the quicksort code from
http://www.alienryderflex.com/quicksort/
This public-domain C implementation by Darel Rex Finley.
Thanks man :)
Updated Oct 16 2013: change choice of pivot to avoid worst-case being a pre-sorted input - Daniel and Julien
Updated Oct 24 2013: change pivot comparison to strict inequality to avoid worst-case on constant input, see Sedgewick, Algorithms in C, Addison Wesley, 1990, p. 120 - Julien
*/
#define MAX_LEVELS 300
static void THZTensor_(quicksortascend)(real *arr, long *idx, long elements, long stride)
{
long beg[MAX_LEVELS], end[MAX_LEVELS], i=0, L, R, P, swap, pid;
real rswap, piv;
beg[0]=0; end[0]=elements;
while (i>=0) {
L=beg[i]; R=end[i]-1;
if (L<R) {
P=(L+R)>>1; /* Choose pivot as middle element of the current block */
piv=arr[P*stride];
pid=idx[P*stride];
rswap=arr[L*stride];
swap=idx[L*stride];
arr[L*stride]=piv;
idx[L*stride]=pid;
arr[P*stride]=rswap;
idx[P*stride]=swap;
while (L<R) {
while (CABS(arr[R*stride])>CABS(piv) && L<R)
R--;
if (L<R) {
idx[L*stride]=idx[R*stride];
arr[L*stride]=arr[R*stride];
L++;
}
while (CABS(arr[L*stride])<CABS(piv) && L<R)
L++;
if (L<R) {
idx[R*stride]=idx[L*stride];
arr[R*stride]=arr[L*stride];
R--;
}
}
idx[L*stride]=pid;
arr[L*stride]=piv;
beg[i+1]=L+1;
end[i+1]=end[i];
end[i++]=L;
if (end[i]-beg[i]>end[i-1]-beg[i-1]) {
swap=beg[i]; beg[i]=beg[i-1]; beg[i-1]=swap;
swap=end[i]; end[i]=end[i-1]; end[i-1]=swap;
}
}
else {
i--;
}
}
}
static void THZTensor_(quicksortdescend)(real *arr, long *idx, long elements, long stride)
{
long beg[MAX_LEVELS], end[MAX_LEVELS], i=0, L, R, P, swap, pid;
real rswap, piv;
beg[0]=0; end[0]=elements;
while (i>=0) {
L=beg[i]; R=end[i]-1;
if (L<R) {
P=(L+R)>>1; /* Choose pivot as middle element of the current block */
piv=arr[P*stride];
pid=idx[P*stride];
rswap=arr[L*stride];
swap=idx[L*stride];
arr[L*stride]=piv;
idx[L*stride]=pid;
arr[P*stride]=rswap;
idx[P*stride]=swap;
while (L<R) {
while (CABS(arr[R*stride])<CABS(piv) && L<R)
R--;
if (L<R) {
idx[L*stride]=idx[R*stride];
arr[L*stride]=arr[R*stride];
L++;
}
while (CABS(arr[L*stride])>CABS(piv) && L<R)
L++;
if (L<R) {
idx[R*stride]=idx[L*stride];
arr[R*stride]=arr[L*stride];
R--;
}
}
idx[L*stride]=pid;
arr[L*stride]=piv;
beg[i+1]=L+1;
end[i+1]=end[i];
end[i++]=L;
if (end[i]-beg[i]>end[i-1]-beg[i-1]) {
swap=beg[i]; beg[i]=beg[i-1]; beg[i-1]=swap;
swap=end[i]; end[i]=end[i-1]; end[i-1]=swap;
}
}
else {
i--;
}
}
}
void THZTensor_(sort)(THZTensor *rt_, THLongTensor *ri_, THZTensor *t, int dimension, int descendingOrder)
{
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "invalid dimension");
THZTensor_(resizeAs)(rt_, t);
THZTensor_(copy)(rt_, t);
{
THLongStorage *size = THZTensor_(newSizeOf)(t);
THLongTensor_resize(ri_, size, NULL);
THLongStorage_free(size);
}
if(descendingOrder)
{
TH_TENSOR_DIM_APPLY2(real, rt_, long, ri_, dimension,
long i;
for(i = 0; i < ri__size; i++)
ri__data[i*ri__stride] = i;
THZTensor_(quicksortdescend)(rt__data, ri__data, rt__size, rt__stride);)
}
else
{
TH_TENSOR_DIM_APPLY2(real, rt_, long, ri_, dimension,
long i;
for(i = 0; i < ri__size; i++)
ri__data[i*ri__stride] = i;
THZTensor_(quicksortascend)(rt__data, ri__data, rt__size, rt__stride);)
}
}
void THZTensor_(tril)(THZTensor *r_, THZTensor *t, long k)
{
long t_size_0, t_size_1;
long t_stride_0, t_stride_1;
long r__stride_0, r__stride_1;
real *t_data, *r__data;
long r, c;
THArgCheck(THZTensor_(nDimension)(t) == 2, 1, "not a matrix");
THZTensor_(resizeAs)(r_, t);
t_size_0 = THZTensor_(size)(t, 0);
t_size_1 = THZTensor_(size)(t, 1);
t_stride_0 = THZTensor_(stride)(t, 0);
t_stride_1 = THZTensor_(stride)(t, 1);
r__stride_0 = THZTensor_(stride)(r_, 0);
r__stride_1 = THZTensor_(stride)(r_, 1);
r__data = THZTensor_(data)(r_);
t_data = THZTensor_(data)(t);
for(r = 0; r < t_size_0; r++)
{
long sz = THMin(r+k+1, t_size_1);
for(c = THMax(0, r+k); c < t_size_1; c++)
r__data[r*r__stride_0+c*r__stride_1] = 0;
for(c = 0; c < sz; c++)
r__data[r*r__stride_0+c*r__stride_1] = t_data[r*t_stride_0+c*t_stride_1];
}
}
void THZTensor_(triu)(THZTensor *r_, THZTensor *t, long k)
{
long t_size_0, t_size_1;
long t_stride_0, t_stride_1;
long r__stride_0, r__stride_1;
real *t_data, *r__data;
long r, c;
THArgCheck(THZTensor_(nDimension)(t) == 2, 1, "not a matrix");
THZTensor_(resizeAs)(r_, t);
t_size_0 = THZTensor_(size)(t, 0);
t_size_1 = THZTensor_(size)(t, 1);
t_stride_0 = THZTensor_(stride)(t, 0);
t_stride_1 = THZTensor_(stride)(t, 1);
r__stride_0 = THZTensor_(stride)(r_, 0);
r__stride_1 = THZTensor_(stride)(r_, 1);
r__data = THZTensor_(data)(r_);
t_data = THZTensor_(data)(t);
for(r = 0; r < t_size_0; r++)
{
long sz = THMin(r+k, t_size_1);
for(c = THMax(0, r+k); c < t_size_1; c++)
r__data[r*r__stride_0+c*r__stride_1] = t_data[r*t_stride_0+c*t_stride_1];
for(c = 0; c < sz; c++)
r__data[r*r__stride_0+c*r__stride_1] = 0;
}
}
void THZTensor_(cat)(THZTensor *r_, THZTensor *ta, THZTensor *tb, int dimension)
{
THLongStorage *size;
int i;
int ndim = THMax(ta->nDimension, tb->nDimension);
ndim = THMax(ndim, dimension+1);
THArgCheck(dimension >= 0, 4, "invalid dimension");
size = THLongStorage_newWithSize(ndim);
for(i = 0; i < ndim; i++)
{
int tadi = (i < ta->nDimension ? ta->size[i] : 1);
int tbdi = (i < tb->nDimension ? tb->size[i] : 1);
if(i == dimension)
size->data[i] = tadi+tbdi;
else
{
if(tadi != tbdi)
{
THLongStorage_free(size);
THError("inconsistent tensor sizes");
}
size->data[i] = tadi;
}
}
THZTensor_(resize)(r_, size, NULL);
THLongStorage_free(size);
{
THZTensor *nta = THZTensor_(newWithTensor)(r_);
THZTensor_(narrow)(nta, NULL, dimension, 0, (dimension < ta->nDimension ? ta->size[dimension] : 1));
THZTensor_(copy)(nta, ta);
THZTensor_(free)(nta);
}
{
THZTensor *ntb = THZTensor_(newWithTensor)(r_);
THZTensor_(narrow)(ntb, NULL, dimension, (dimension < ta->nDimension ? ta->size[dimension] : 1), (dimension < tb->nDimension ? tb->size[dimension] : 1));
THZTensor_(copy)(ntb, tb);
THZTensor_(free)(ntb);
}
}
#define TENSOR_IMPLEMENT_LOGICAL(NAME,OP) \
void THZTensor_(NAME##Value)(THByteTensor *r_, THZTensor* t, real value) \
{ \
THLongStorage *tsz = THZTensor_(newSizeOf)(t); \
THByteTensor_resize(r_, tsz, NULL); \
THLongStorage_free(tsz); \
THByteTensor_zero(r_); \
TH_TENSOR_APPLY2(unsigned char, r_, real, t, \
if (CABS(*t_data) OP CABS(value)) *r__data = 1;); \
} \
void THZTensor_(NAME##Tensor)(THByteTensor *r_, THZTensor *ta, THZTensor *tb) \
{ \
THLongStorage *tsz = THZTensor_(newSizeOf)(ta); \
THByteTensor_resize(r_, tsz, NULL); \
THLongStorage_free(tsz); \
THByteTensor_zero(r_); \
TH_TENSOR_APPLY3(unsigned char, r_, real, ta, real, tb, \
if(CABS(*ta_data) OP CABS(*tb_data)) *r__data = 1;); \
} \
TENSOR_IMPLEMENT_LOGICAL(lt,<)
TENSOR_IMPLEMENT_LOGICAL(gt,>)
TENSOR_IMPLEMENT_LOGICAL(le,<=)
TENSOR_IMPLEMENT_LOGICAL(ge,>=)
TENSOR_IMPLEMENT_LOGICAL(eq,==)
TENSOR_IMPLEMENT_LOGICAL(ne,!=)
#define LAB_IMPLEMENT_BASIC_FUNCTION(NAME, CFUNC) \
void THZTensor_(NAME)(THZTensor *r_, THZTensor *t) \
{ \
THZTensor_(resizeAs)(r_, t); \
TH_TENSOR_APPLY2(real, t, real, r_, *r__data = CFUNC(*t_data);); \
} \
#define LAB_IMPLEMENT_BASIC_FUNCTION_VALUE(NAME, CFUNC) \
void THZTensor_(NAME)(THZTensor *r_, THZTensor *t, real value) \
{ \
THZTensor_(resizeAs)(r_, t); \
TH_TENSOR_APPLY2(real, t, real, r_, *r__data = CFUNC(*t_data, value);); \
} \
LAB_IMPLEMENT_BASIC_FUNCTION(log,CLOG)
LAB_IMPLEMENT_BASIC_FUNCTION(exp,CEXP)
LAB_IMPLEMENT_BASIC_FUNCTION(cos,CCOS)
LAB_IMPLEMENT_BASIC_FUNCTION(acos,CACOS)
LAB_IMPLEMENT_BASIC_FUNCTION(cosh,CACOSH)
LAB_IMPLEMENT_BASIC_FUNCTION(sin,CSIN)
LAB_IMPLEMENT_BASIC_FUNCTION(asin,CASIN)
LAB_IMPLEMENT_BASIC_FUNCTION(sinh,CSINH)
LAB_IMPLEMENT_BASIC_FUNCTION(tan,CTAN)
LAB_IMPLEMENT_BASIC_FUNCTION(atan,CATAN)
LAB_IMPLEMENT_BASIC_FUNCTION(tanh,CTANH)
LAB_IMPLEMENT_BASIC_FUNCTION_VALUE(pow,CPOW)
LAB_IMPLEMENT_BASIC_FUNCTION(sqrt,CSQRT)
LAB_IMPLEMENT_BASIC_FUNCTION(conj,CONJ)
LAB_IMPLEMENT_BASIC_FUNCTION(proj,CPROJ)
LAB_IMPLEMENT_BASIC_FUNCTION(zabs,CABS)
LAB_IMPLEMENT_BASIC_FUNCTION(zarg,CARG)
LAB_IMPLEMENT_BASIC_FUNCTION(zre,CREAL)
LAB_IMPLEMENT_BASIC_FUNCTION(zim,CIMAG)
#define LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_FLOAT(NAME, CFUNC) \
void THZTensor_(NAME)(THFloatTensor *r, THZTensor *t) \
{ \
THLongStorage *tsz = THZTensor_(newSizeOf)(t); \
THFloatTensor_resize(r, tsz, NULL); \
THLongStorage_free(tsz); \
TH_TENSOR_APPLY2(real, t, float, r, *r_data = CFUNC(*t_data);); \
}
#define LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_DOUBLE(NAME, CFUNC) \
void THZTensor_(NAME)(THDoubleTensor *r, THZTensor *t) \
{ \
THLongStorage *tsz = THZTensor_(newSizeOf)(t); \
THDoubleTensor_resize(r, tsz, NULL); \
THLongStorage_free(tsz); \
TH_TENSOR_APPLY2(real, t, double, r, *r_data = CFUNC(*t_data);); \
}
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_FLOAT(Float_abs,CABS)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_FLOAT(Float_arg,CARG)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_FLOAT(Float_re,CREAL)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_FLOAT(Float_im,CIMAG)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_DOUBLE(Double_abs,CABS)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_DOUBLE(Double_arg,CARG)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_DOUBLE(Double_re,CREAL)
LAB_IMPLEMENT_BASIC_FUNCTION_RETURN_DOUBLE(Double_im,CIMAG)
void THZTensor_(mean)(THZTensor *r_, THZTensor *t, int dimension)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 2, "invalid dimension");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
long i;
for(i = 0; i < t_size; i++)
sum += t_data[i*t_stride];
*r__data = (real)sum/t_size;);
}
void THZTensor_(std)(THZTensor *r_, THZTensor *t, int dimension, int flag)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 3, "invalid dimension");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
accreal sum2 = 0;
long i;
for(i = 0; i < t_size; i++)
{
real z = t_data[i*t_stride];
sum += z;
sum2 += z*z;
}
if(flag)
{
sum /= t_size;
sum2 /= t_size;
sum2 -= sum*sum;
sum2 = (cabs(sum2) < 0 ? 0 : sum2);
*r__data = (real)csqrt(sum2);
}
else
{
sum /= t_size;
sum2 /= t_size-1;
sum2 -= ((real)t_size)/((real)(t_size-1))*sum*sum;
sum2 = (cabs(sum2) < 0 ? 0 : sum2);
*r__data = (real)csqrt(sum2);
});
}
void THZTensor_(var)(THZTensor *r_, THZTensor *t, int dimension, int flag)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 3, "invalid dimension");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
accreal sum2 = 0;
long i;
for(i = 0; i < t_size; i++)
{
real z = t_data[i*t_stride];
sum += z;
sum2 += z*z;
}
if(flag)
{
sum /= t_size;
sum2 /= t_size;
sum2 -= sum*sum;
sum2 = (cabs(sum2) < 0 ? 0 : sum2);
*r__data = sum2;
}
else
{
sum /= t_size;
sum2 /= t_size-1;
sum2 -= ((real)t_size)/((real)(t_size-1))*sum*sum;
sum2 = (cabs(sum2) < 0 ? 0 : sum2);
*r__data = (real)sum2;
});
}
void THZTensor_(norm)(THZTensor *r_, THZTensor *t, real value, int dimension)
{
THLongStorage *dim;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(t), 3, "invalid dimension");
dim = THZTensor_(newSizeOf)(t);
THLongStorage_set(dim, dimension, 1);
THZTensor_(resize)(r_, dim, NULL);
THLongStorage_free(dim);
if(value == 0) {
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
long i;
for(i = 0; i < t_size; i++)
sum += t_data[i*t_stride] != 0.0;
*r__data = sum;)
} else {
TH_TENSOR_DIM_APPLY2(real, t, real, r_, dimension,
accreal sum = 0;
long i;
for(i = 0; i < t_size; i++)
sum += pow(CABS(t_data[i*t_stride]), value);
*r__data = (real)cpow(sum, 1.0/value);)
}
}
accreal THZTensor_(normall)(THZTensor *tensor, real value)
{
accreal sum = 0;
if(value == 0) {
TH_TENSOR_APPLY(real, tensor, sum += *tensor_data != 0.0;);
return sum;
} else if(value == 1) {
TH_TENSOR_APPLY(real, tensor, sum += CABS(*tensor_data););
return sum;
} else if(value == 2) {
TH_TENSOR_APPLY(real, tensor, accreal z = *tensor_data; sum += z*z;);
return csqrt(sum);
} else {
TH_TENSOR_APPLY(real, tensor, sum += pow(CABS(*tensor_data), value););
return cpow(sum, 1.0/value);
}
}
void THZTensor_(renorm)(THZTensor *res, THZTensor *src, real value, int dimension, real maxnorm)
{
int i;
THZTensor *rowR, *rowS;
THArgCheck(dimension >= 0 && dimension < THZTensor_(nDimension)(src), 3, "invalid dimension");
THArgCheck(CABS(value) > 0, 2, "non-positive-norm not supported");
THArgCheck(THZTensor_(nDimension)(src) > 1, 1, "need at least 2 dimensions");
rowR = THZTensor_(new)();
rowS = THZTensor_(new)();
THZTensor_(resizeAs)(res, src);
for (i=0; i<src->size[dimension]; i++)
{
real norm = 0;
real new_norm;
THZTensor_(select)(rowS, src, dimension, i);
THZTensor_(select)(rowR, res, dimension, i);
if (value == 1) {
TH_TENSOR_APPLY(real, rowS, norm += CABS(*rowS_data););
} else if (value == 2) {
TH_TENSOR_APPLY(real, rowS, accreal z = *rowS_data; norm += z*z;);
} else {
TH_TENSOR_APPLY(real, rowS, norm += pow(CABS(*rowS_data), value););
}
norm = CPOW(norm, 1/value);
if (CABS(norm) > CABS(maxnorm))
{
new_norm = maxnorm / (norm + 1e-7);
TH_TENSOR_APPLY2(
real, rowR, real, rowS,
*rowR_data = (*rowS_data) * new_norm;
)
}
else
THZTensor_(copy)(rowR, rowS);
}
THZTensor_(free)(rowR);
THZTensor_(free)(rowS);
}
accreal THZTensor_(dist)(THZTensor *tensor, THZTensor *src, real value)
{
real sum = 0;
TH_TENSOR_APPLY2(real, tensor, real, src,
sum += pow(CABS(*tensor_data - *src_data), value);)
return CPOW(sum, 1.0/value);
}
accreal THZTensor_(meanall)(THZTensor *tensor)
{
THArgCheck(tensor->nDimension > 0, 1, "empty Tensor");
return THZTensor_(sumall)(tensor)/THZTensor_(nElement)(tensor);
}
accreal THZTensor_(varall)(THZTensor *tensor)
{
accreal mean = THZTensor_(meanall)(tensor);
accreal sum = 0;
TH_TENSOR_APPLY(real, tensor, sum += (*tensor_data - mean)*(*tensor_data - mean););
sum /= (THZTensor_(nElement)(tensor)-1);
return sum;
}
accreal THZTensor_(stdall)(THZTensor *tensor)
{
return csqrt(THZTensor_(varall)(tensor));
}
#endif
|
the_stack_data/76299.c
|
/*
* Many studies suggest that smiling has benefits. Write a program that produces
* the following output:
*
* Smile!Smile!Smile!
* Smile!Smile!
* Smile!
*
* Have the proram define a function that displays the string Smile! once, and
* have the program use the function as often as needed.
*/
#include <stdio.h>
void smile(void)
{
printf("Smile!");
}
int main(void)
{
smile();
smile();
smile();
printf("\n");
smile();
smile();
printf("\n");
smile();
printf("\n");
return 0;
}
|
the_stack_data/161082015.c
|
// RUN: %clang -fsyntax-only -ffreestanding %s
// RUN: %clang -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s
// RUN: %clangxx -fsyntax-only -ffreestanding -x c++ %s
#if defined(i386) || defined(__x86_64__)
#ifdef __SSE4_2__
// nmmintrin forwards to smmintrin.
#include <nmmintrin.h>
#endif
// immintrin includes all other intel intrinsic headers.
#include <immintrin.h>
#endif
|
the_stack_data/167330540.c
|
/* { dg-do compile } */
/* { dg-options "-W -fdiagnostics-show-caret" } */
double val;
_Atomic double val0() {return val;} /* { dg-warning "qualifiers ignored" } */
/* { dg-begin-multiline-output "" }
_Atomic double val0() {return val;}
^~~~~~~
{ dg-end-multiline-output "" } */
|
the_stack_data/778056.c
|
#include <stdio.h>
int main(){
char c[4];int i;
printf("输入要解密的字符串\n");
for(i=0;i<4;i++){
c[i]=getchar();
if('A'<=c[i]&&c[i]<='D')
c[i]-=22;
else
c[i]-=4;
printf("%c",c[i]);
}
return 0;
}
|
the_stack_data/825978.c
|
//
// Created by yurir on 3/6/16.
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_PARAMS 50
#define MAX_OUTPUT 256
int formatBinary(int num) {
/*
* formatBinary - return an binary represent of @num
* @num - positive value integer
*/
int i = 1, binary = 0;
while (num != 0) {
binary += (num % 2) * i;
num /= 2;
i *= 10;
}
return binary;
}
char *romanChars(int num) {
/*
* return an roman Digit representing the num.
* @str - pointer
*/
char *str = (char *) malloc(MAX_PARAMS * sizeof(char));
int tempNum = num;
while (tempNum > 0) {
char chPrint;
int chValue = 0;
if (tempNum - 1000 >= 0) {
chPrint = 'M';
chValue = 1000;
} else if (tempNum - 500 >= 0) {
chPrint = 'D';
chValue = 500;
} else if (tempNum - 100 >= 0) {
chPrint = 'C';
chValue = 100;
} else if (tempNum - 50 >= 0) {
chPrint = 'L';
chValue = 50;
} else if (tempNum - 10 >= 0) {
chPrint = 'X';
chValue = 10;
} else if (tempNum - 9 == 0) {
chPrint = 'I';
chValue = 0;
tempNum = 10;
} else if (tempNum - 5 >= 0) {
chPrint = 'V';
chValue = 5;
} else if (tempNum - 4 == 0) {
chPrint = 'I';
chValue = 0;
tempNum = 5;
} else {
chPrint = 'I';
chValue = 1;
}
tempNum = tempNum - chValue;
strncat(str, &chPrint, 1);
}
return str;
}
int getArgsList(char *numbers, int args[]) {
/*
* Convert @numbers string to separate numbers array
* @numbers - string of number separate by " "(whitespace)
* @args - pointer to int array to be filled
*
* return - function return the real size of the array
*/
int i = 0;
char *token;
token = strtok(numbers, " ");
while (token != NULL) {
args[i++] = atoi(token);
token = strtok(NULL, " ");
}
free(token);
return i;
}
void printFormattedIntegers(char *format, char *numbers) {
char *pos;
char output[MAX_OUTPUT] = "";
int args[MAX_PARAMS];
int i = 0;
int j = 0;
int bin = 0;
getArgsList(numbers, args);
pos = strstr(format, "%");
while (pos != NULL) {
char str[100] = "";
// lets copy all chars until % sign
strncat(output, format, pos - format);
if (pos[1] == 'b') {
// if binary output required we will use formatBinary helper
bin = formatBinary(args[i++]);
j = sprintf(str, "%d", bin);
strncat(output, str, j);
} else if (pos[1] == 'r') {
// if roman numeric output required we will use rommanChars helper
strcat(output, romanChars(args[i++]));
} else {
// not special format is required we will use sprinf function
char formatToPrint[3] = "";
// lets set formatToPrint
strncpy(formatToPrint, pos, 2);
j = sprintf(str, formatToPrint, args[i++]);
strncat(output, str, j);
}
// we will move the pointer to memory cells to right (to skip %X)
pos += 2;
// will assign this pointer to @format
format = pos;
// make strstr search for the nex %
pos = strstr(pos, "%");
}
strncat(output, format, strlen(format));
printf("%s", output);
free(pos);
}
int main() {
char format[100];
char numbers[100];
gets(format);
gets(numbers);
printFormattedIntegers(format, numbers);
return 0;
}
|
the_stack_data/89693.c
|
#include <stdio.h>
#include <stdlib.h>
//Creates a doubly linked list where you can see the position
struct Node
{
int data;
struct Node *next;
struct Node *prev;
}Node;
void InsertFront(int i);
struct Node* getNode(int i);
void Print();
void Push(int n);
void PrintBackwards();
void Pop();
void movePosition(int n);
void Menu();
struct Node *head;
struct Node *tail;
int main()
{
head=NULL;
tail=NULL;
int i;
for(i=0;i<60;i=i+4) //Mixes up the data with i+4
{
Push(i);
if(i>25) //Learning how to use Que data structure
{
Pop();
}
Print();
}
PrintBackwards();
printf("\n\n");
Menu();
}
void Menu()
{
struct Node *temp;
temp=head;
int pos=3;
movePosition(pos); //Print current position at the middle
printf("Press 1 to go backward\nPress 2 to go forward\nPress 3 exit\n");
int ans=0;
while(1)
{
scanf("%d",&ans);
if(ans==2)
{
if(pos==6)//Doesnt go beyond the end of the list
{
movePosition(pos);
}
else
{
pos++;
movePosition(pos);
}
}
if(ans==1)
{
if(pos==0)//Doesnt go beyond the start of the list
{
movePosition(pos);
}
else
{
pos--;
movePosition(pos);
}
}
if(ans==3)
{
return;
}
}
}
void movePosition(int n)
{
struct Node *temp;
temp=head;
int pos=0;
while(temp != NULL)
{
if(n==pos)
{
printf("|");
}
printf("%d",temp->data);
temp=temp->next;
if(n==pos)
{
printf("|");
}
else
{
printf(" ");
}
pos++;
}
printf("\n");
}
void Pop()
{
struct Node *temp;
temp=head;
head=temp->next;
head->prev=NULL;
free(temp);
}
void PrintBackwards()
{
struct Node *temp;
temp=head;
while(temp->next != NULL)
{
temp=temp->next;
}
while(temp != NULL)
{
printf("%d ",temp->data);
temp=temp->prev;
}
}
void Push(int n)
{
struct Node *newNode=getNode(n);
struct Node *temp;
if(head==NULL)
{
head=newNode;
tail=newNode;
return;
}
temp=tail;
tail->next=newNode;
newNode->prev=tail;
tail=newNode;
}
void Print()
{
struct Node *temp;
temp=head;
while(temp != NULL)
{
printf("%d ",temp->data);
temp=temp->next;
}
printf("\n");
}
void InsertFront(int i)
{
struct Node *newNode=getNode(i);
struct Node *temp;
if(head==NULL)
{
head=newNode;
return;
}
newNode->next=head;
head->prev=newNode;
head=newNode;
}
struct Node* getNode(int i)
{
struct Node *temp;
temp=(struct Node*)malloc(sizeof(struct Node));
temp->data=i;
temp->next=NULL;
temp->prev=NULL;
return temp;
}
|
the_stack_data/111078454.c
|
//Program that calculate the integer division among two numbers
#include <stdio.h>
void read_data(int* number1, int* number2);
int calculate_rest(int number1, int number2);
int main(void){
int number1, number2, rest, choice;
do
{
read_data(&number1, &number2);
rest = calculate_rest(number1, number2);
printf("The rest of integer division is: %d\n\n", rest);
printf("Do you want to calculate again?\n");
printf("Yes - any number\n NO - 0\n> ");
scanf("%d", &choice);
} while(choice != 0);
return 0;
}
void read_data(int* number1, int* number2)
{
printf("Type the first number: ");
scanf("%d", number1);
printf("Type the second number: ");
scanf("%d", number2);
}
int calculate_rest(int number1, int number2)
{
int rest;
rest = number1 % number2;
return rest;
}
|
the_stack_data/146122.c
|
/*
Copyright (c) 2019 chaoticgd
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.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void show_usage();
int main(int argc, char** argv) {
if(argc != 2) {
fprintf(stderr, "Invalid number of arguments.\n");
show_usage();
return 1;
}
if(strcmp(argv[1], "-h") == 0|| strcmp(argv[1], "--help") == 0) {
show_usage();
return 0;
}
FILE* src = fopen("/tmp/cppevalsrc.cpp", "w");
fprintf(src, R"(
#include <cstdlib>
#include <csignal>
#include <csetjmp>
#include <cstdarg>
#include <typeinfo>
#include <typeindex>
#include <type_traits>
#include <bitset>
#include <functional>
#include <utility>
#include <ctime>
#include <chrono>
#include <cstddef>
#include <initializer_list>
#include <tuple>
#include <new>
#include <memory>
#include <scoped_allocator>
#include <climits>
#include <cfloat>
#include <cstdint>
#include <cinttypes>
#include <limits>
#include <exception>
#include <stdexcept>
#include <cassert>
#include <system_error>
#include <cerrno>
#include <cctype>
#include <cwctype>
#include <cstring>
#include <cwchar>
#include <cuchar>
#include <string>
#include <array>
#include <vector>
#include <deque>
#include <list>
#include <forward_list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <complex>
#include <valarray>
#include <random>
#include <numeric>
#include <ratio>
#include <cfenv>
#include <iosfwd>
#include <ios>
#include <istream>
#include <ostream>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <streambuf>
#include <cstdio>
#include <locale>
#include <clocale>
#include <codecvt>
#include <regex>
#include <atomic>
#include <thread>
#include <mutex>
#include <future>
#include <condition_variable>
#include <ciso646>
#include <ccomplex>
#include <ctgmath>
#include <cstdalign>
#include <cstdbool>
int main() {
std::cout << (%s) << std::endl;
}
)", argv[1]);
fclose(src);
system("g++ /tmp/cppevalsrc.cpp -o /tmp/cppevalbin -std=c++11 && /tmp/cppevalbin");
}
void show_usage() {
printf("usage: ./cppeval \"<c++ expression to evaluate>\"\n");
}
|
the_stack_data/175142658.c
|
#include <stdbool.h>
//max heap function series
void push_heap(int *ptr, int size)
{
if (size <= 1)
return;
int val = ptr[size - 1], hole = size - 1;
for (int i = (hole - 1) >> 1; hole > 0 && val > ptr[i]; i = (hole - 1) >> 1)
{
ptr[hole] = ptr[i];
hole = i;
}
ptr[hole] = val;
}
void pop_heap(int *ptr, int size)
{
if (size <= 0)
return;
int val = *ptr, non_leaf = (size - 1) >> 1, hole = 0, i = 0;
while (i < non_leaf)
{
i = 2 * i + 2;
if (ptr[i] < ptr[i - 1])
--i;
ptr[hole] = ptr[i];
hole = i;
}
if (i == non_leaf && size % 2 == 0)
{
ptr[hole] = ptr[size - 1];
hole = size - 1;
}
ptr[hole] = ptr[size - 1];
push_heap(ptr, hole + 1);
ptr[size - 1] = val;
}
void make_heap(int *ptr, int size)
{
for (int i = 1; i < size; ++i)
push_heap(ptr, i + 1);
}
/********end of max heap********/
bool containsDuplicate(int *nums, int numsSize)
{
if (numsSize == 0)
return false;
push_heap(nums, numsSize);
pop_heap(nums, numsSize - 1);
for (int i = numsSize - 2; i >= 0; --i)
{
pop_heap(nums, i);
if (nums[i] == nums[i + 1])
return true;
}
return false;
}
|
the_stack_data/20451127.c
|
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* (C) 2001 by Argonne National Laboratory.
* See COPYRIGHT in top-level directory.
*/
#include <stdio.h>
int main( int argc, char *argv[] )
{
int i, print_flag = 1;
if (argc > 1 && strcmp(argv[1],"-p") == 0)
print_flag = 0;
for (i=0; ; i++)
{
if (i % 100000000 == 0)
{
if (print_flag)
{
printf("i=%d\n",i);
fflush(stdout);
}
}
}
return 0;
}
|
the_stack_data/41485.c
|
/*
* io handler
*
* Auther : Yasuhiro ISHII
*/
int __sys_seek(int fd, int position) {
return 0;
}
int __sys_istty(int handle) {
return 0;
}
int __sys_flen(int handle) {
return 0;
}
int __sys_write(int iFileHandle, char *pcBuffer, int iLength) {
return 0;
}
void __sys_appexit(void) {
}
void *_sbrk(void) {
return (void*) 0;
}
int __sys_readc(void) {
return 0;
}
int __sys_read(int iFileHandle, char *pcBuffer, int iLen){
return 0;
}
|
the_stack_data/126704060.c
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int s[4][2]=
{
{1234, 56},
{1212, 33},
{1434, 80},
{1312, 78}
};
int (*p)[2];
int i,j,*pint;
for(i=0;i<=3;i++)
{
p=&s[i];
pint=*p;
for(j=0;j<=1;j++)
{
printf("%d ",*(pint+j));
}
printf("\n");
}
return 0;
}
|
the_stack_data/149134.c
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAXSIZE 254
#define DIMENTION 15
#define NUMOFFILE 100
#define FNAME_OUTPUT "./output001.txt"
typedef struct {
char name[20];
char onso[50];
int flame;
double mcepdata[MAXSIZE][DIMENTION];
} mcepdata_t;
int main(void)
{
int h0, h, i, j, k;
FILE *fp_temp, *fp_miti, *fp_output;
mcepdata_t city_temp, city_miti; //テンプレートのデータと未知入力データ
char ch0[200];
double d[MAXSIZE][MAXSIZE]; //局所距離
double g[MAXSIZE][MAXSIZE]; //累積距離
double tangokankyori[NUMOFFILE]; //単語間距離
double tangokankyori_min;
int num_matchfname = 0;
int count = 0;
int TEMP_NUM, MITI_NUM;
printf("ファイルを選択してください\n");
printf("city0");
scanf("%03d", &TEMP_NUM);
printf("city0");
scanf("%03d", &MITI_NUM);
printf("city%03dとcity%03dの認識実験を開始します。\n", TEMP_NUM, MITI_NUM);
for (h0 = 0; h0 < NUMOFFILE; h0++) {
sprintf(ch0, "./city%03d/city%03d_%03d.txt",TEMP_NUM, TEMP_NUM, h0 + 1);
if ((fp_temp = fopen(ch0, "r")) == NULL) {
printf("temp file open error!!\n");
exit(EXIT_FAILURE);
}
fgets(city_temp.name, sizeof(city_temp.name), fp_temp);
fgets(city_temp.onso, sizeof(city_temp.onso), fp_temp);
fgets(ch0,sizeof(ch0), fp_temp);
city_temp.flame = atoi(ch0);
for (i = 0; i < city_temp.flame; i++) {
for (j = 0; j < DIMENTION; j++) {
fscanf(fp_temp, "%lf", &city_temp.mcepdata[i][j]);
}
}
for (h = 0; h < NUMOFFILE; h++) {
sprintf(ch0, "./city%03d/city%03d_%03d.txt",MITI_NUM, MITI_NUM, h + 1);
if ((fp_miti = fopen(ch0, "r")) == NULL) {
printf("miti file open error!!\n");
exit(EXIT_FAILURE);
}
fgets(city_miti.name, sizeof(city_miti.name), fp_miti);
fgets(city_miti.onso, sizeof(city_miti.onso), fp_miti);
fgets(ch0,sizeof(ch0), fp_miti);
city_miti.flame = atoi(ch0);
for (i = 0; i < city_miti.flame; i++) {
for (j = 0; j < DIMENTION; j++) {
fscanf(fp_miti, "%lf", &city_miti.mcepdata[i][j]);
}
}
for (i = 0; i < city_temp.flame; i++) {
for (j = 0; j < city_miti.flame; j++) {
d[i][j] = 0;
for (int k = 0; k < DIMENTION; k++) {
//printf("%f\n", kyokusyokyori);
d[i][j] += (city_temp.mcepdata[i][k] - city_miti.mcepdata[j][k]) * (city_temp.mcepdata[i][k] - city_miti.mcepdata[j][k]);
}
sqrtl(d[i][j]);
}
}
g[0][0] = d[0][0];
for (i = 1; i < city_temp.flame; i++) {
g[i][0] = g[i - 1][0] + d[i][0];
}
for (j = 1; j < city_miti.flame; j++) {
g[0][j] = g[0][j - 1] + d[0][j];
}
for (i = 1; i < city_temp.flame; i++) {
for (j = 1; j < city_miti.flame; j++) {
double a = g[i][j - 1] + d[i][j];
double b = g[i - 1][j - 1] + 2 * d[i][j];
double c = g[i - 1][j] + d[i][j];
g[i][j] = a;
if (b < g[i][j]) {
g[i][j] = b;
}
if (c < g[i][j]) {
g[i][j] = c;
}
}
}
tangokankyori[h] = g[city_temp.flame - 1][city_miti.flame - 1] / (city_temp.flame + city_miti.flame);
fclose(fp_miti);
}
tangokankyori_min = tangokankyori[0];
num_matchfname = 0;
for (h = 1; h < NUMOFFILE; h++) {
if (tangokankyori_min > tangokankyori[h] ) {
tangokankyori_min = tangokankyori[h];
num_matchfname = h;
}
}
fclose(fp_temp);
if (num_matchfname == h0 ) {
count++;
}
if (num_matchfname != h0 ) {
printf("----------Result NOT Matchng----------\n");
printf("city_temp : city%03d/city%03d_%03d.txt\n", TEMP_NUM, TEMP_NUM, h0 + 1);
printf("city_miti : city%03d/city%03d_%03d.txt\n", MITI_NUM, MITI_NUM, num_matchfname + 1);
printf("tangokankyori : %f\n", tangokankyori_min);
}
}
sprintf(ch0, FNAME_OUTPUT);
if ((fp_output = fopen(ch0, "a")) == NULL) {
printf("output file open error!!\n");
exit(EXIT_FAILURE);
}
fprintf(fp_output, "正答率%d%%です。\n", count);
printf("\nファイルを作成しました。\n");
printf("正答率 %d%% です。\n", count);
fclose(fp_output);
return 0;
}
|
the_stack_data/993015.c
|
/* Ensure replicated constants don't make things worse. */
/* { dg-options "-mthumb -O2" } */
/* { dg-require-effective-target arm_thumb2_ok } */
int
foo1 (int a)
{
/* It might be tempting to use 0x01000100, but it wouldn't help. */
return a + 0x01f001e0;
}
/* { dg-final { scan-assembler "add.*#32505856" } } */
/* { dg-final { scan-assembler "add.*#480" } } */
int
foo2 (int a)
{
return a + 0x0f100e10;
}
/* { dg-final { scan-assembler "add.*#252706816" } } */
/* { dg-final { scan-assembler "add.*#3600" } } */
|
the_stack_data/111077442.c
|
#include<stdio.h>
#include<string.h>
int main()
{
int i,n,num,t=0,max=0;
scanf("%d",&n);
char a[n][80];
for(i=0;i<n;i++)
{
scanf("\n%s",&a[i]);
num=strlen(a[i]);
if(max<num)
{max=num;t=i;}
}
printf("The longest is: %s",a[t]);
return 0;
}
|
the_stack_data/9512231.c
|
#include <stdio.h>
#define B 0
#define HELLO(a) B
int main() { printf("%d\n", HELLO(12)); }
|
the_stack_data/86685.c
|
/*Nicolle Canuto Nunes - 20.1.4022 -
*Questão 1*/
#include <stdio.h>
void preenche(int m[10][10], int *l, int *c);
void preenche(int m[10][10], int *l, int *c){
int i, j;
for (i=0; i<*l; i++){
for (j=0;j<*c;j++){
printf("\nDigite o valor (Linha %d, Coluna %d):",i+1,j+1);
scanf("%d",&m[i][j]);
}
}
}
void imprime(int r[10][10], int l, int c);
void imprime(int r[10][10], int l, int c){
int i,j;
for(i=0; i<l; i++) {
for(j=0; j<c; j++) {
printf("%d ", r[i][j]);
}
printf("\n\n");
}
printf("\n");
}
int main(){
int l1,c1,l2,c2,i,j,aux=0,x;
int m1[10][10],m2[10][10],r[10][10];;
printf("Digite o número de linhas e colunas da Matriz I (nessa ordem): ");
scanf("%d%d",&l1,&c1);
printf("Digite o número de linhas e colunas da Matriz II (nessa ordem): ");
scanf("%d%d",&l2,&c2);
if (l1!=c2){
printf("Essas matrizes não podem ser multiplicadas!");
return 0;
}else{
printf("\n\n======PREENCHENDO A MATRIZ I======\n");
preenche(m1, &l1, &c1);
printf("\n\n======PREENCHENDO A MATRIZ II======\n");
preenche(m2, &l2, &c2);
printf("\n\n======RESULTADO:======\n");
for(i=0; i<l1; i++) {
for(j=0; j<c2; j++) {
r[i][j] = 0;
for(x=0; x<l2; x++) {
aux = aux + m1[i][x] * m2[x][j];
}
r[i][j] = aux;
aux = 0;
}
}
imprime(r, l1, c2);
}
return 0;
}
|
the_stack_data/165765166.c
|
typedef int node;
main()
{
typedef int node;
//int node;
struct node
{
int node;
};
node n;
n = 5;
printf("Test\n");
}
node n=5;
foo()
{
typedef int node;
//int node;
struct node
{
int node;
};
}
|
the_stack_data/242330822.c
|
//===-- truncdfsf2vfp_test.c - Test __truncdfsf2vfp -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file tests __truncdfsf2vfp for the compiler_rt library.
//
//===----------------------------------------------------------------------===//
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
extern float __truncdfsf2vfp(double a);
#if __arm__
int test__truncdfsf2vfp(double a)
{
float actual = __truncdfsf2vfp(a);
float expected = a;
if (actual != expected)
printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n",
a, actual, expected);
return actual != expected;
}
#endif
int main()
{
#if __arm__
if (test__truncdfsf2vfp(0.0))
return 1;
if (test__truncdfsf2vfp(1.0))
return 1;
if (test__truncdfsf2vfp(-1.0))
return 1;
if (test__truncdfsf2vfp(3.1415926535))
return 1;
if (test__truncdfsf2vfp(123.456))
return 1;
#else
printf("skipped\n");
#endif
return 0;
}
|
the_stack_data/98441.c
|
/*
* Copyright 1993, 1995 Christopher Seiwald.
*
* This file is part of Jam - see jam.c for Copyright information.
*/
/* This file is ALSO:
* (C) Copyright David Abrahams 2001. Permission to copy, use,
* modify, sell and distribute this software is granted provided this
* copyright notice appears in all copies. This software is provided
* "as is" without express or implied warranty, and with no claim as
* to its suitability for any purpose.
*/
/*
* mkjambase.c - turn Jambase into a big C structure
*
* Usage: mkjambase jambase.c Jambase ...
*
* Results look like this:
*
* char *jambase[] = {
* "...\n",
* ...
* 0 };
*
* Handles \'s and "'s specially; knows to delete blank and comment lines.
*
*/
# include <stdio.h>
# include <string.h>
int main( int argc, char **argv, char **envp )
{
char buf[ 1024 ];
FILE *fin;
FILE *fout;
char *p;
int doDotC = 0;
if( argc < 3 )
{
fprintf( stderr, "usage: %s jambase.c Jambase ...\n", argv[0] );
return -1;
}
if( !( fout = fopen( argv[1], "w" ) ) )
{
perror( argv[1] );
return -1;
}
/* If the file ends in .c generate a C source file */
if( ( p = strrchr( argv[1], '.' ) ) && !strcmp( p, ".c" ) )
doDotC++;
/* Now process the files */
argc -= 2, argv += 2;
if( doDotC )
{
fprintf( fout, "/* Generated by mkjambase from Jambase */\n" );
fprintf( fout, "char *jambase[] = {\n" );
}
for( ; argc--; argv++ )
{
if( !( fin = fopen( *argv, "r" ) ) )
{
perror( *argv );
return -1;
}
if( doDotC )
{
fprintf( fout, "/* %s */\n", *argv );
}
else
{
fprintf( fout, "### %s ###\n", *argv );
}
while( fgets( buf, sizeof( buf ), fin ) )
{
if( doDotC )
{
char *p = buf;
/* Strip leading whitespace. */
while( *p == ' ' || *p == '\t' || *p == '\n' )
p++;
/* Drop comments and empty lines. */
if( *p == '#' || !*p )
continue;
/* Copy */
putc( '"', fout );
for( ; *p && *p != '\n'; p++ )
switch( *p )
{
case '\\': putc( '\\', fout ); putc( '\\', fout ); break;
case '"': putc( '\\', fout ); putc( '"', fout ); break;
case '\r': break;
default: putc( *p, fout ); break;
}
fprintf( fout, "\\n\",\n" );
}
else
{
fprintf( fout, "%s", buf );
}
}
fclose( fin );
}
if( doDotC )
fprintf( fout, "0 };\n" );
fclose( fout );
return 0;
}
|
the_stack_data/1129021.c
|
//Potrebno je napisati funkciju SORTIRAJ koja slaže po veličini niz realnih brojeva, pri čemu
//se dužina niza funkciji prosljeđuje kao argument. Nakon pisanja funkcije, napraviti kratki
//program koji je testira. Primjer algoritma za sortiranje je mogude nadi u tutorijalu 6.
//Za rješavanje je obavezno korištenje pokazivačke aritmetike.
#include <stdio.h>
#include <stdlib.h>
void sort (int *ptr, int n)
{
int *i, *j, swap;
for(i = ptr; i < (ptr + n); i++)
{
for(j = i + 1; j < (ptr + n) ; j++)
{
if(*j > *i)
{
swap = *i;
*i = *j;
*j = swap;
}
}
}
}
int main()
{
int n, i;
int *p;
int niz[100];
do
{
printf("Unesite n: ");
scanf("%d", &n);
}while (n >= 100);
for (i = 0; i < n; i++)
{
scanf("%d", &niz[i]);
}
p = &niz[0];
sort(p, n);
for (i = 0; i < n; i++)
printf("%d", *(p+i));
return 0;
}
|
the_stack_data/1020054.c
|
#include<stdio.h>
#include<sys/wait.h>
#include<unistd.h>
#include <signal.h>
int main() {
pid_t pid = fork();
int wstats;
if (pid == 0) {
printf("HC: hello from child\n");
sleep(1);
} else {
printf("HP: hello from parent\n");
kill(pid, SIGTERM);
wait(&wstats);
printf("CT: child has terminated: %x\n", WEXITSTATUS(wstats));
}
printf("Bye\n");
return 0;
}
|
the_stack_data/1247540.c
|
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
int Nvogal(char *string){
int i, count = 0;
for(i = 0; i < strlen(string); i++){
if(string[i] == 'a' || string[i] == 'e' || string[i] == 'i' || string[i] == 'o' || string[i] == 'u' || string[i] == 'A' || string[i] == 'E' || string[i] == 'I' || string[i] == 'O' || string[i] == 'U'){
count ++;
}
}
return count;
}
int main(){
char string[20];
int c;
scanf("%s", string);
c = Nvogal(string);
printf("%d\n", c);
return 0;
}
|
the_stack_data/7746.c
|
// EXPECT: 8
int main() {
int a[2][2];
a[0][0] = 3;
a[1][0] = 5;
return add_arr(a);
}
|
the_stack_data/3263256.c
|
#include <stdio.h>
#include <ctype.h>
/*
* Liczy ilosc wystapien znaku "spacja"
*
* Warunki wstepne:
* Wskaznik 'Tekst' nie moze miec wartosc NULL i musi byc
* poprawnym (zakonczonym znakiem 0) tekstem.
*
* Parametry:
* Tekst - wskaznik na tekst, dla ktorego ma byc wyznaczona
* ilosc spacji.
*/
int PoliczSpacje(char* Tekst)
{
int Ilosc = 0;
for (; *Tekst; ++Tekst)
if (*Tekst == ' ') ++Ilosc;
return Ilosc;
}
/*
* Wyznacza dlugosc najdluzszego slowa w tekscie.
*
* Warunki wstepne:
* Wskaznik 'Tekst' nie moze miec wartosc NULL i musi byc
* poprawnym (zakonczonym znakiem 0) tekstem.
*
* Parametry:
* Tekst - wskaznik na tekst, dla ktorego ma byc wyznaczona
* dlugosc najdluzszego slowa, ktore w nim sie znajduje.
*/
int RozmiarNajdluzszegoSlowa(char* Tekst)
{
int DlugoscMaks = 0, DlugoscRob;
char *Slowo = NULL;
for (; *Tekst; ++Tekst) {
if (isspace(*Tekst)) {
if (!Slowo) continue;
DlugoscRob = Tekst - Slowo;
if (DlugoscMaks < DlugoscRob) DlugoscMaks = DlugoscRob;
Slowo = 0L;
continue;
}
if (!Slowo) Slowo = Tekst;
}
return DlugoscMaks;
}
/*
* Zamienia wszystkie spacje znajdujace sie w tekscie na znak podkreslenia.
*
* Warunki wstepne:
* Wskaznik 'Tekst' nie moze miec wartosc NULL i musi byc
* poprawnym (zakonczonym znakiem 0) oraz modyfikowalnym tekstem.
*
* Parametry:
* Tekst - wskaznik na tekst, dla ktorego ma byc wyznaczona
* dlugosc najdluzszego slowa, ktore w nim sie znajduje.
*/
void ZamienNaPodkreslenie(char* Tekst)
{
for (; *Tekst; ++Tekst)
if (*Tekst == ' ') *Tekst = '_';
}
/*
* Oblicza ilosc wystapien malych liter.
*
* Warunki wstepne:
* Wskaznik 'Tekst' nie moze miec wartosc NULL i musi byc
* poprawnym (zakonczonym znakiem 0) oraz modyfikowalnym tekstem.
*
* Parametry:
* Tekst - wskaznik na tekst, dla ktorego ma byc wyznaczona
* dlugosc najdluzszego slowa, ktore w nim sie znajduje.
*
* Wartosc zwracana:
* Ilosc malych liter.
*/
int IloscMalychLiter(char *Tekst)
{
int Ilosc = 0;
for (; *Tekst; ++Tekst)
if (islower(*Tekst)) ++Ilosc;
return Ilosc;
}
/*
* Oblicza ilosc wystapien wielkich liter.
*
* Warunki wstepne:
* Wskaznik 'Tekst' nie moze miec wartosc NULL i musi byc
* poprawnym (zakonczonym znakiem 0) oraz modyfikowalnym tekstem.
*
* Parametry:
* Tekst - wskaznik na tekst, dla ktorego ma byc wyznaczona
* dlugosc najdluzszego slowa, ktore w nim sie znajduje.
*
* Wartosc zwracana:
* Ilosc wielkich liter.
*/
int IloscWielkichLiter(char *Tekst)
{
int Ilosc = 0;
for (; *Tekst; ++Tekst)
if (isupper(*Tekst)) ++Ilosc;
return Ilosc;
}
int main()
{
char *Napis = "Jak dobrze jest wstac skoro swit. Jutrzenki blask ...";
int IloscSpacji;
int DlugoscSlowaXXX;
int IloscMaLiter = 0;
int IloscWiLiter = 0;
printf("\n------------------------------\n");
printf(" Statystyka dla tekstu: '%s'\n\n",Napis);
IloscSpacji = PoliczSpacje(Napis);
DlugoscSlowaXXX = RozmiarNajdluzszegoSlowa(Napis);
ZamienNaPodkreslenie(Napis);
IloscMaLiter = IloscMalychLiter(Napis);
IloscWiLiter = IloscWielkichLiter(Napis);
printf(" Ilosc spacji: %i\n",IloscSpacji);
printf(" Ilosc malych liter: %i\n",IloscMaLiter);
printf(" Ilosc wielkich liter: %i\n",IloscWiLiter);
printf(" Rozmiar najdluzszego slowa: %i\n",DlugoscSlowaXXX);
printf(" Tekst z podkresleniami: '%s'\n",Napis);
printf("\n");
return 0;
}
|
the_stack_data/78107.c
|
/**
* There's Always a Slight Duplication of Efforts 2.
*
* By walking through this example you’ll learn:
* - How to preserve consistency.
*
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
int stick_this_thread_to_core(int core_id);
#define NUM_THREADS 100
#define NUM_TASKS 100000
static int cnt = 0;
pthread_mutex_t counter;
void* worker(void* arg){
stick_this_thread_to_core(arg);
int progress;
for(int i = 0; i < NUM_TASKS; i++){
// The mutex `counter` should be locked.
pthread_mutex_lock(&counter);
progress = cnt++;
// The mutex `counter` should be released.
pthread_mutex_unlock(&counter);
}
pthread_exit(progress);
}
int main(int argc, char* argv[]){
pthread_t tids[NUM_THREADS];
int status;
int progress = 0;
// The mutex `counter` should be initiated.
pthread_mutex_init(&counter, NULL);
for(int i = 0; i < NUM_THREADS; i++){
// HINT: The thread that runs `worker` should be created.
// HINT: The address of variable `i` should be passed when thread created.
// HINT: Each thread descriptor should be stored appropriately.
status = pthread_create(&tids[i],NULL,worker,(void*)&i);
if(status != 0){
printf("WTF?");
return -1;
}
}
// HINT: The main thread should not be exited until all `worker`s have finished.
for(int i = 0; i < NUM_THREADS; i++){
pthread_jion(tids[i],&progress);
// HINT: The variable `progress` should not be 0.
printf("\r%d ", progress);
fflush(stdout);
usleep(10*1000); // 10ms
}
printf("\nexpectd: %d\n", NUM_THREADS * NUM_TASKS);
printf("result: %d\n", cnt);
return 0;
}
int stick_this_thread_to_core(int core_id) {
int num_cores = sysconf(_SC_NPROCESSORS_ONLN);
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(core_id % num_cores, &cpuset);
pthread_t current_thread = pthread_self();
return pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
}
|
the_stack_data/211079651.c
|
enum e1 {
FIRST = 0,
SECOND,
} x2;
|
the_stack_data/243893375.c
|
/*-
* Copyright (c) 2002-2018 The UbixOS Project.
* All rights reserved.
*
* This was developed by Christopher W. Olsen for the UbixOS Project.
*
* 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, the following disclaimer and the list of authors.
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions, the following disclaimer and the list of authors in the documentation and/or
* other materials provided with the distribution.
* 3) Neither the name of the UbixOS Project 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 AUTHOR 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.
*/
int kern_execve(const char *file, char **argv, char **envp) {
return(0);
}
|
the_stack_data/1245813.c
|
#include <unistd.h>
int strncmp(const char *_l, const char *_r, size_t n)
{
const unsigned char *l=(void *)_l, *r=(void *)_r;
if (!n--) return 0;
for (; *l && *r && n && *l == *r ; l++, r++, n--);
return *l - *r;
}
|
the_stack_data/140766352.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
void read_file(char *file, int n)
{
int fd, sz;
struct stat s;
char c;
if (stat(file, &s) < 0) {
perror("stat");
exit(EXIT_FAILURE);
}
sz = (int)s.st_size;
char buf[sz];
fd = open(file, O_RDONLY);
if (!fd) {
perror("open");
exit(EXIT_FAILURE);
}
if (lseek(fd, 0, SEEK_END) == -1) {
perror("lseek");
exit(EXIT_FAILURE);
}
while (n > 0) {
if (read(fd, &c, 1) == -1) {
perror("read");
exit(EXIT_FAILURE);
}
if (c == '\n') n--;
if (lseek(fd, -2, SEEK_CUR) == -1) {
perror("lseek2:");
exit(EXIT_FAILURE);
}
}
memset(buf, 0, sz);
if (read(fd, buf, sz) == -1) {
perror("read");
exit(EXIT_FAILURE);
}
printf("%s", buf);
close(fd);
}
void usage(char *prog) {
fprintf(stderr, "usage: %s [lines] <file>\n", prog);
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
if (argc == 1 || argc > 3)
usage(argv[0]);
else if (argc == 2)
// we can assume the second arg is a file
read_file(argv[1], 10); // 10 lines by default
else read_file(argv[2], atoi(argv[1]));
exit(EXIT_SUCCESS);
}
|
the_stack_data/35150.c
|
/* { dg-skip-if "test AVX support" { ! { i?86-*-* x86_64-*-* } } } */
/* { dg-require-effective-target avx_runtime } */
/* Test compatibility of vector types: layout between separately-compiled
modules, parameter passing, and function return. This test uses
vectors of floating points values. */
extern void vector_2_x (void);
extern void exit (int);
int fails;
int
main ()
{
vector_2_x ();
exit (0);
}
|
the_stack_data/1184530.c
|
#include <math.h>
void array_sqrt(int n, double * a_in, double * a_out) {
int i;
for (i = 0; i < n; i++) {
a_out[i] = sqrt(a_in[i]);
}
return;
}
|
the_stack_data/12616.c
|
#ifdef OC_SECURITY
#include "port/oc_log.h"
#include "port/oc_storage.h"
#include "sdfat.h"
#include <errno.h>
#include <stdio.h>
#include <string.h>
#define STORE_PATH_SIZE 20
// SD chip select pin
#if defined(__AVR__) || defined(__SAM3X8E__)
const uint8_t chipSelect = 4;
#elif defined(__SAMD21G18A__)
const uint8_t chipSelect = SDCARD_SS_PIN;
#else
#warning Please update Eth shield chip select
#endif
static char store_path[STORE_PATH_SIZE];
static int8_t store_path_len;
void
list_dir()
{
// Initialize at the highest speed supported by the board that is
// not over 50 MHz. Try a lower speed if SPI errors occur.
if (!sdfile_open_read(_file_holder, "/", O_RDONLY)) {
sdfat_errorHalt(_sd_holder, "open root failed");
}
// list all files in the card with date and size
sdfile_ls(_file_holder);
}
int
oc_storage_config(const char *store)
{
store_path_len = strlen(store);
if (store_path_len > STORE_PATH_SIZE) {
return -ENOENT;
}
strncpy(store_path, store, store_path_len);
store_path[store_path_len] = '\0';
_sd_holder = sdfat_create();
/* Initialize at the highest speed supported by the board that is
not over 50 MHz. Try a lower speed if SPI errors occur.*/
if (!sdfat_begin(_sd_holder, chipSelect)) {
sdfat_initErrorHalt(_sd_holder);
return -1;
}
OC_WRN("initialization done.");
if (!sdfat_exists(_sd_holder, store_path)) {
if (!sdfat_mkdir(_sd_holder, store_path)) {
OC_ERR("Error creating sec dir");
}
}
_file_holder = sdfile_create();
list_dir();
sdfile_close(_file_holder);
return 0;
}
long
oc_storage_write(const char *store, uint8_t *buf, size_t len)
{
size_t store_len = strlen(store);
store_path[store_path_len] = '/';
strncpy(store_path + store_path_len + 1, store, store_len);
store_path[1 + store_path_len + store_len] = '\0';
sdfile_open_write(_file_holder, store_path, O_WRONLY | O_CREAT | O_TRUNC);
if (!sdfile_isOpen(_file_holder)) {
return -1;
} else {
if ((len = sdfile_write(_file_holder, buf, len)) == -1) {
OC_ERR("Error writing to: %s", store_path);
return -1;
}
sdfile_close(_file_holder);
}
return len;
}
long
oc_storage_read(const char *store, uint8_t *buf, size_t len)
{
size_t store_len = strlen(store);
store_path[store_path_len] = '/';
strncpy(store_path + store_path_len + 1, store, store_len);
store_path[1 + store_path_len + store_len] = '\0';
sdfile_open_read(_file_holder, store_path, O_RDONLY);
if (!sdfile_isOpen(_file_holder)) {
OC_ERR("error opening %s", store_path);
return -1;
}
while (sdfile_available(_file_holder)) {
if ((len = sdfile_read(_file_holder, buf, len)) == -1) {
OC_ERR("Error reading from: %s", store_path);
}
}
sdfile_close(_file_holder);
return len;
}
#endif /* OC_SECURITY */
|
the_stack_data/159515273.c
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#if MICROPY_PY_MINICV
#include "py/obj.h"
#include "py/runtime.h"
#include "py/builtin.h"
#include "ulog/ulog.h"
extern const mp_obj_type_t minicv_datainput_type;
extern const mp_obj_type_t minicv_imagecodec_type;
extern const mp_obj_type_t minicv_imageproc_type;
extern const mp_obj_type_t minicv_ml_type;
extern const mp_obj_type_t minicv_ui_type;
extern const mp_obj_type_t minicv_videocodec_type;
STATIC const mp_rom_map_elem_t minicv_module_globals_table[] = {
{MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_minicv)},
{MP_OBJ_NEW_QSTR(MP_QSTR_DataInput), MP_ROM_PTR(&minicv_datainput_type)},
{MP_OBJ_NEW_QSTR(MP_QSTR_ImageCodec), MP_ROM_PTR(&minicv_imagecodec_type)},
{MP_OBJ_NEW_QSTR(MP_QSTR_ImageProc), MP_ROM_PTR(&minicv_imageproc_type)},
{MP_OBJ_NEW_QSTR(MP_QSTR_ML), MP_ROM_PTR(&minicv_ml_type)},
{MP_OBJ_NEW_QSTR(MP_QSTR_UI), MP_ROM_PTR(&minicv_ui_type)},
{MP_OBJ_NEW_QSTR(MP_QSTR_VideoCodec), MP_ROM_PTR(&minicv_videocodec_type)},
};
STATIC MP_DEFINE_CONST_DICT(minicv_module_globals, minicv_module_globals_table);
const mp_obj_module_t minicv_module = {
.base = {&mp_type_module},
.globals = (mp_obj_dict_t *)&minicv_module_globals,
};
MP_REGISTER_MODULE(MP_QSTR_minicv, minicv_module, MICROPY_PY_MINICV);
#endif // MICROPY_PY_MINICV
|
the_stack_data/867939.c
|
# include<stdio.h>
#include<math.h>
int main()
{
long long int n;
while(1)
{
scanf("%lld",&n);
if(n==-1)
break;
double an=(n-1.00)/3;
long long int t;
int flag=0;
for(t=0;;t++)
{
if((double)(t*(t+1))==an)
{flag=1;
break;
}
if((t*(t+1))>an)break;
}
if(flag==0)
printf("N\n");
else
printf("Y\n");
}
return 0;
}
|
the_stack_data/6387745.c
|
#include <stdio.h>
void decode(char *str, unsigned int length)
{
unsigned int i = 0;
while(i < length)
{
char chr = str[i];
for(int j=0; j<str[i+1]; j++)
putchar(chr);
i+=2;
}
}
int main()
{
char code[270] =
{
0x20, 0xe, 0x76, 0x20, 0xa, 0x1, 0x20, 0x12, 0x76, 0x1c, 0xa, 0x1, 0x72, 0xd, 0x20, 0x7, 0x76, 0x1a,
0xa, 0x1, 0x72, 0x10, 0x20, 0x6, 0x76, 0x18, 0xa, 0x1, 0x72, 0x12, 0x20, 0x4, 0x76, 0x18, 0xa, 0x1,
0x72, 0x12, 0x20, 0x4, 0x76, 0x18, 0xa, 0x1, 0x72, 0x12, 0x20, 0x4, 0x76, 0x18, 0xa, 0x1, 0x72, 0x10,
0x20, 0x6, 0x76, 0x16, 0x20, 0x2, 0xa, 0x1, 0x72, 0xd, 0x20, 0x7, 0x76, 0x16, 0x20, 0x4, 0xa, 0x1,
0x72, 0x2, 0x20, 0x10, 0x76, 0x16, 0x20, 0x6, 0xa, 0x1, 0x72, 0x2, 0x20, 0xc, 0x76, 0x18, 0x20, 0x6,
0x72, 0x2, 0xa, 0x1, 0x72, 0x4, 0x20, 0x6, 0x76, 0x1a, 0x20, 0x6, 0x72, 0x4, 0xa, 0x1, 0x72, 0x6,
0x20, 0x6, 0x76, 0x16, 0x20, 0x6, 0x72, 0x6, 0xa, 0x1, 0x72, 0x8, 0x20, 0x6, 0x76, 0x12, 0x20, 0x6,
0x72, 0x8, 0xa, 0x1, 0x72, 0xa, 0x20, 0x6, 0x76, 0xe, 0x20, 0x6, 0x72, 0xa, 0xa, 0x1, 0x72, 0xc,
0x20, 0x6, 0x76, 0xa, 0x20, 0x6, 0x72, 0xc, 0xa, 0x1, 0x72, 0xe, 0x20, 0x6, 0x76, 0x6, 0x20, 0x6,
0x72, 0xe, 0xa, 0x1, 0x72, 0x10, 0x20, 0x6, 0x76, 0x2, 0x20, 0x6, 0x72, 0x10, 0xa, 0x1, 0x72, 0x12,
0x20, 0xa, 0x72, 0x12, 0xa, 0x1, 0x72, 0x14, 0x20, 0x6, 0x72, 0x14, 0xa, 0x1, 0x72, 0x16, 0x20, 0x2,
0x72, 0x16, 0xa, 0x2, 0x20, 0x7, 0x49, 0x1, 0x4e, 0x1, 0x53, 0x1, 0x54, 0x1, 0x52, 0x1, 0x55, 0x1,
0x43, 0x1, 0x54, 0x1, 0x49, 0x1, 0x4f, 0x1, 0x4e, 0x1, 0x20, 0x1, 0x53, 0x1, 0x45, 0x1, 0x54, 0x1,
0x53, 0x1, 0x20, 0x1, 0x57, 0x1, 0x41, 0x1, 0x4e, 0x1, 0x54, 0x1, 0x20, 0x1, 0x54, 0x1, 0x4f, 0x1,
0x20, 0x1, 0x42, 0x1, 0x45, 0x1, 0x20, 0x1, 0x46, 0x1, 0x52, 0x1, 0x45, 0x2, 0xa, 0x2, 0x0, 0x1
};
decode(code, 270);
}
|
the_stack_data/87638535.c
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <math.h>
#define squaret(A) (A)*(A)
#define N 5000
#define DELTA 4
# define IM1 2147483563
# define IM2 2147483399
# define AM (1.0/IM1)
# define IMM1 (IM1-1)
# define IA1 40014
# define IA2 40692
# define IQ1 53668
# define IQ2 52774
# define IR1 12211
# define IR2 3791
# define NTAB 32
# define NDIV (1+IMM1/NTAB)
# define EPS 1.2e-7
# define RNMX (1.0-EPS)
typedef double(* function)(double, double);
typedef struct system{
function f, E_coeff;
long seed;
double coeff;
double energy;
}class_system;
class_system *builder_class(function f, function E_coeff, double coeff);
double f(double x, double coeff);
double E_coeff(double x, double coeff);
void metropolis(class_system *sys);
float ran2(long *idum);
void main(){
class_system *sys;
double coeff;
FILE *folder = fopen("energy.txt", "w");
assert(folder);
for(coeff = 0.4; coeff <= 0.6; coeff += 0.01){
sys = builder_class(f, E_coeff, coeff);
metropolis(sys);
fprintf(folder,"%lf\t%lf\n", sys -> energy / N, coeff);
free(sys);
}
fclose(folder);
}
class_system *builder_class(function f, function E_coeff, double coeff){
class_system *sys = (class_system *)malloc(sizeof(class_system));
assert(sys);
sys -> f = f;
sys -> E_coeff = E_coeff;
sys -> coeff = coeff;
sys -> seed = -time(NULL);
return sys;
}
double f(double x, double coeff){
return exp(-coeff * squaret(x));
}
double E_coeff(double x, double coeff){
return coeff + squaret(x) * (0.5 - 2 * squaret(coeff));
}
void metropolis(class_system *sys){
double x_old = 0;
double x_new, p_new, p_old, k;
int i;
sys -> energy = 0.0;
for(i = 0; i < N; i++){
x_new = x_old + (ran2(&sys -> seed) - 0.5) * DELTA;
p_new = squaret(sys -> f(x_new, sys -> coeff));
p_old = squaret(sys -> f(x_old, sys -> coeff));
k = (double)(p_new / p_old);
if(k >= ran2(&sys -> seed)){
sys -> energy += sys -> E_coeff(x_new, sys -> coeff);
x_old = x_new;
} else
sys -> energy += sys -> E_coeff(x_old, sys -> coeff);
}
}
float ran2(long *idum){
int j;
long k;
static long idum2=123456789;
static long iy=0;
static long iv[NTAB];
float temp;
if(*idum <= 0){ //Initialize.
if(-(*idum) < 1) *idum = 1; //Be sure to prevent idum = 0.
else *idum = -(*idum);
idum2 = (*idum);
for (j = NTAB + 7; j >= 0; j--){ //Load the shuffle table (after 8 warm-ups).
k = (*idum) / IQ1;
*idum = IA1 * (*idum - k * IQ1) - k * IR1;
if (*idum < 0) *idum += IM1;
if (j < NTAB) iv[j] = *idum;
}
iy=iv[0];
}
k = (*idum) / IQ1; //Start here when not initializing.
*idum = IA1 * (*idum - k * IQ1) - k * IR1; //Compute idum=(IA1*idum) % IM1 without
if (*idum < 0) *idum += IM1; //overflows by Schrage’s method.
k=idum2/IQ2;
idum2 = IA2 * (idum2 - k * IQ2) - k * IR2; //Compute idum2=(IA2*idum) % IM2 likewise.
if (idum2 < 0) idum2 += IM2;
j = iy / NDIV; //Will be in the range 0..NTAB-1.
iy = iv[j] - idum2; //Here idum is shuffled, idum and idum2 are
iv[j] = *idum; //combined to generate output.
if (iy < 1) iy += IMM1;
if ((temp=AM*iy) > RNMX) return RNMX; //Because users don’t expect endpoint values.
else return temp;
}
|
the_stack_data/1054581.c
|
/*
* Scaled down version of printf(3).
* Based on FreeBSD sources, heavily rewritten.
*
* Copyright (C) 2000-2002 Serge Vakulenko, <[email protected]>
*
* This file 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.
*
* You can redistribute this file and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software Foundation;
* either version 2 of the License, or (at your discretion) any later version.
* See the accompanying file "COPYING.txt" for more details.
*
* As a special exception to the GPL, permission is granted for additional
* uses of the text contained in this file. See the accompanying file
* "COPY-UOS.txt" for details.
*/
/*
* Two additional formats:
*
* The format %b is supported to decode error registers.
* Its usage is:
*
* printf("reg=%b\n", regval, "<base><arg>*");
*
* where <base> is the output base expressed as a control character, e.g.
* \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
* the first of which gives the bit number to be inspected (origin 1), and
* the next characters (up to a control character, i.e. a character <= 32),
* give the name of the register. Thus:
*
* kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
*
* would produce output:
*
* reg=3<BITTWO,BITONE>
*
* The format %D -- Hexdump, takes a pointer. Sharp flag - use `:' as
* a separator, instead of a space. For example:
*
* ("%6D", ptr) -> XX XX XX XX XX XX
* ("%#*D", len, ptr) -> XX:XX:XX:XX ...
*/
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
/* Max number conversion buffer length: a long in base 2, plus NUL byte. */
#define MAXNBUF (sizeof(long) * 8 + 1)
static unsigned char *ksprintn (unsigned char *buf, unsigned long v, unsigned char base,
int width, unsigned char *lp);
static unsigned char mkhex (unsigned char ch);
static void PUTC (char ch)
{
if (write (1, &ch, 1) < 0)
/*ignore*/;
}
void
debug_vprintf (unsigned char const *fmt, va_list ap)
{
unsigned char nbuf [MAXNBUF], padding, *q;
const unsigned char *s;
unsigned char c, base, lflag, ladjust, sharpflag, neg, dot, size;
int n, width, dwidth, uppercase, extrazeros, sign;
unsigned long ul;
if (! fmt)
fmt = (unsigned char*) "(null)\n";
for (;;) {
while ((c = *(fmt++)) != '%') {
if (! c)
return;
PUTC (c);
}
padding = ' ';
width = 0; extrazeros = 0;
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
sign = 0; dot = 0; uppercase = 0; dwidth = -1;
reswitch: switch (c = *(fmt++)) {
case '.':
dot = 1;
padding = ' ';
dwidth = 0;
goto reswitch;
case '#':
sharpflag = 1;
goto reswitch;
case '+':
sign = -1;
goto reswitch;
case '-':
ladjust = 1;
goto reswitch;
case '%':
PUTC (c);
break;
case '*':
if (! dot) {
width = va_arg (ap, int);
if (width < 0) {
ladjust = !ladjust;
width = -width;
}
} else {
dwidth = va_arg (ap, int);
}
goto reswitch;
case '0':
if (! dot) {
padding = '0';
goto reswitch;
}
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
for (n=0; ; ++fmt) {
n = n * 10 + c - '0';
c = *(fmt);
if (c < '0' || c > '9')
break;
}
if (dot)
dwidth = n;
else
width = n;
goto reswitch;
case 'b':
ul = va_arg (ap, int);
s = va_arg (ap, const unsigned char*);
q = ksprintn (nbuf, ul, *s++, -1, 0);
while (*q)
PUTC (*q--);
if (! ul)
break;
size = 0;
while (*s) {
n = *s++;
if ((char) (ul >> (n-1)) & 1) {
PUTC (size ? ',' : '<');
for (; (n = *s) > ' '; ++s)
PUTC (n);
size = 1;
} else
while (*s > ' ')
++s;
}
if (size)
PUTC ('>');
break;
case 'c':
if (! ladjust && width > 0)
while (width--)
PUTC (' ');
PUTC (va_arg (ap, int));
if (ladjust && width > 0)
while (width--)
PUTC (' ');
break;
case 'D':
s = va_arg (ap, const unsigned char*);
if (! width)
width = 16;
if (sharpflag)
padding = ':';
while (width--) {
c = *s++;
PUTC (mkhex (c >> 4));
PUTC (mkhex (c));
if (width)
PUTC (padding);
}
break;
case 'd':
ul = lflag ? va_arg (ap, long) : va_arg (ap, int);
if (! sign) sign = 1;
base = 10;
goto number;
case 'l':
lflag = 1;
goto reswitch;
case 'o':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 8;
goto nosign;
case 'p':
ul = (size_t) va_arg (ap, void*);
if (! ul) {
s = (const unsigned char*) "(nil)";
goto const_string;
}
base = 16;
sharpflag = (width == 0);
goto nosign;
case 'n':
ul = lflag ? va_arg (ap, unsigned long) :
sign ? (unsigned long) va_arg (ap, int) :
va_arg (ap, unsigned int);
base = 10;
goto number;
case 'S':
#if __AVR__
s = va_arg (ap, const unsigned char*);
if (! s)
s = (const unsigned char*) "(null)";
const_string:
n = 0;
if (! dot)
while (*(s+n))
++n;
else
while (n<dwidth && *(s+n))
++n;
width -= n;
if (! ladjust && width > 0)
while (width--)
PUTC (' ');
while (n--)
PUTC (*(s++));
if (ladjust && width > 0)
while (width--)
PUTC (' ');
break;
#endif /* LY: AVR, and no break here! */
case 's':
s = va_arg (ap, unsigned char*);
#ifdef __AVR__
if (! s) {
s = (const unsigned char*) "(null)";
goto const_string;
}
#else
if (! s)
s = (const unsigned char*) "(null)";
const_string:
#endif
if (! dot)
n = strlen ((char*) s);
else
for (n=0; n<dwidth && s[n]; n++)
continue;
width -= n;
if (! ladjust && width > 0)
while (width--)
PUTC (' ');
while (n--)
PUTC (*s++);
if (ladjust && width > 0)
while (width--)
PUTC (' ');
break;
case 'r':
/* Saturated counters. */
base = 10;
if (lflag) {
ul = va_arg (ap, unsigned long);
if (ul == -1) {
cnt_unknown: if (ladjust)
PUTC ('-');
while (--width > 0)
PUTC (' ');
if (! ladjust)
PUTC ('-');
break;
}
if (ul >= -2) {
ul = -3;
neg = '>';
goto nosign;
}
} else {
ul = va_arg (ap, unsigned int);
if (ul == (unsigned short) -1)
goto cnt_unknown;
if (ul >= (unsigned short) -2) {
ul = (unsigned short) -3;
neg = '>';
goto nosign;
}
}
goto nosign;
case 'u':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 10;
goto nosign;
case 'x':
case 'X':
ul = lflag ? va_arg (ap, unsigned long) :
va_arg (ap, unsigned int);
base = 16;
uppercase = (c == 'X');
goto nosign;
case 'z':
case 'Z':
ul = lflag ? va_arg (ap, unsigned long) :
sign ? (unsigned long) va_arg (ap, int) :
va_arg (ap, unsigned int);
base = 16;
uppercase = (c == 'Z');
goto number;
nosign: sign = 0;
number: if (sign && ((long) ul != 0L)) {
if ((long) ul < 0L) {
neg = '-';
ul = -(long) ul;
} else if (sign < 0)
neg = '+';
}
if (dwidth >= (int) sizeof(nbuf)) {
extrazeros = dwidth - sizeof(nbuf) + 1;
dwidth = sizeof(nbuf) - 1;
}
s = ksprintn (nbuf, ul, base, dwidth, &size);
if (sharpflag && ul != 0) {
if (base == 8)
size++;
else if (base == 16)
size += 2;
}
if (neg)
size++;
if (! ladjust && width && padding == ' ' &&
(width -= size) > 0)
do {
PUTC (' ');
} while (--width > 0);
if (neg)
PUTC (neg);
if (sharpflag && ul != 0) {
if (base == 8) {
PUTC ('0');
} else if (base == 16) {
PUTC ('0');
PUTC (uppercase ? 'X' : 'x');
}
}
if (extrazeros)
do {
PUTC ('0');
} while (--extrazeros > 0);
if (! ladjust && width && (width -= size) > 0)
do {
PUTC (padding);
} while (--width > 0);
for (; *s; --s) {
if (uppercase && *s>='a' && *s<='z') {
PUTC (*s + 'A' - 'a');
} else {
PUTC (*s);
}
}
if (ladjust && width && (width -= size) > 0)
do {
PUTC (' ');
} while (--width > 0);
break;
default:
PUTC ('%');
if (lflag)
PUTC ('l');
PUTC (c);
break;
}
}
}
/*
* Put a NUL-terminated ASCII number (base <= 16) in a buffer in reverse
* order; return an optional length and a pointer to the last character
* written in the buffer (i.e., the first character of the string).
* The buffer pointed to by `nbuf' must have length >= MAXNBUF.
*/
static unsigned char *
ksprintn (unsigned char *nbuf, unsigned long ul, unsigned char base, int width,
unsigned char *lenp)
{
unsigned char *p;
p = nbuf;
*p = 0;
for (;;) {
*++p = mkhex (ul % base);
ul /= base;
if (--width > 0)
continue;
if (! ul)
break;
}
if (lenp)
*lenp = p - nbuf;
return (p);
}
static unsigned char
mkhex (unsigned char ch)
{
ch &= 15;
if (ch > 9)
return ch + 'a' - 10;
return ch + '0';
}
void
debug_printf (const char *fmt, ...)
{
va_list args;
va_start (args, fmt);
debug_vprintf ((unsigned char*) fmt, args);
va_end (args);
}
|
the_stack_data/231393373.c
|
//
// This file is part of the µOS++ III distribution.
// Copyright (c) 2014 Liviu Ionescu.
//
// ----------------------------------------------------------------------------
#if defined(TRACE)
#include "cmsis_device.h"
#include "diag/Trace.h"
// ----------------------------------------------------------------------------
// One of these definitions must be passed via the compiler command line
// Note: small Cortex-M0/M0+ might implement a simplified debug interface.
//#define OS_USE_TRACE_ITM
//#define OS_USE_TRACE_SEMIHOSTING_DEBUG
//#define OS_USE_TRACE_SEMIHOSTING_STDOUT
#if !(defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
#if defined(OS_USE_TRACE_ITM)
#undef OS_USE_TRACE_ITM
#warning "ITM unavailable"
#endif // defined(OS_USE_TRACE_ITM)
#endif // !(defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
#if defined(OS_DEBUG_SEMIHOSTING_FAULTS)
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT) || defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
#error "Cannot debug semihosting using semihosting trace; use OS_USE_TRACE_ITM"
#endif
#endif
// ----------------------------------------------------------------------------
// Forward definitions.
#if defined(OS_USE_TRACE_ITM)
static ssize_t
_trace_write_itm (const char* buf, size_t nbyte);
#endif
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
static ssize_t
_trace_write_semihosting_stdout(const char* buf, size_t nbyte);
#endif
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
static ssize_t
_trace_write_semihosting_debug(const char* buf, size_t nbyte) __attribute__((unused));
#endif
// ----------------------------------------------------------------------------
void
trace_initialize(void)
{
// For regular ITM / semihosting, no inits required.
}
// ----------------------------------------------------------------------------
// This function is called from _write() for fd==1 or fd==2 and from some
// of the trace_* functions.
ssize_t
trace_write (const char* buf __attribute__((unused)),
size_t nbyte __attribute__((unused)))
{
#if defined(OS_USE_TRACE_ITM)
return _trace_write_itm (buf, nbyte);
#elif defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
return _trace_write_semihosting_stdout(buf, nbyte);
#elif defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
return _trace_write_semihosting_debug(buf, nbyte);
#endif
return -1;
}
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_ITM)
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
// ITM is the ARM standard mechanism, running over SWD/SWO on Cortex-M3/M4
// devices, and is the recommended setting, if available.
//
// The JLink probe and the GDB server fully support SWD/SWO
// and the JLink Debugging plug-in enables it by default.
// The current OpenOCD does not include support to parse the SWO stream,
// so this configuration will not work on OpenOCD (will not crash, but
// nothing will be displayed in the output console).
#if !defined(OS_INTEGER_TRACE_ITM_STIMULUS_PORT)
#define OS_INTEGER_TRACE_ITM_STIMULUS_PORT (0)
#endif
static ssize_t
_trace_write_itm (const char* buf, size_t nbyte)
{
for (size_t i = 0; i < nbyte; i++)
{
// Check if ITM or the stimulus port are not enabled
if (((ITM->TCR & ITM_TCR_ITMENA_Msk) == 0)
|| ((ITM->TER & (1UL << OS_INTEGER_TRACE_ITM_STIMULUS_PORT)) == 0))
{
return (ssize_t)i; // return the number of sent characters (may be 0)
}
// Wait until STIMx is ready...
while (ITM->PORT[OS_INTEGER_TRACE_ITM_STIMULUS_PORT].u32 == 0)
;
// then send data, one byte at a time
ITM->PORT[OS_INTEGER_TRACE_ITM_STIMULUS_PORT].u8 = (uint8_t) (*buf++);
}
return (ssize_t)nbyte; // all characters successfully sent
}
#endif // defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
#endif // OS_USE_TRACE_ITM
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG) || defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
#include "arm/semihosting.h"
// Semihosting is the other output channel that can be used for the trace
// messages. It comes in two flavours: STDOUT and DEBUG. The STDOUT channel
// is the equivalent of the stdout in POSIX and in most cases it is forwarded
// to the GDB server stdout stream. The debug channel is a separate
// channel. STDOUT is buffered, so nothing is displayed until a \n;
// DEBUG is not buffered, but can be slow.
//
// Choosing between semihosting stdout and debug depends on the capabilities
// of your GDB server, and also on specific needs. It is recommended to test
// DEBUG first, and if too slow, try STDOUT.
//
// The JLink GDB server fully support semihosting, and both configurations
// are available; to activate it, use "monitor semihosting enable" or check
// the corresponding button in the JLink Debugging plug-in.
// In OpenOCD, support for semihosting can be enabled using
// "monitor arm semihosting enable".
//
// Note: Applications built with semihosting output active normally cannot
// be executed without the debugger connected and active, since they use
// BKPT to communicate with the host. However, with a carefully written
// HardFault_Handler, the semihosting BKPT calls can be processed, making
// possible to run semihosting applications as standalone, without being
// terminated with hardware faults.
#endif // OS_USE_TRACE_SEMIHOSTING_DEBUG_*
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
static ssize_t
_trace_write_semihosting_stdout (const char* buf, size_t nbyte)
{
static int handle;
void* block[3];
int ret;
if (handle == 0)
{
// On the first call get the file handle from the host
block[0] = ":tt"; // special filename to be used for stdin/out/err
block[1] = (void*) 4; // mode "w"
// length of ":tt", except null terminator
block[2] = (void*) (sizeof(":tt") - 1);
ret = call_host (SEMIHOSTING_SYS_OPEN, (void*) block);
if (ret == -1)
return -1;
handle = ret;
}
block[0] = (void*) handle;
block[1] = (void*) buf;
block[2] = (void*) nbyte;
// send character array to host file/device
ret = call_host (SEMIHOSTING_SYS_WRITE, (void*) block);
// this call returns the number of bytes NOT written (0 if all ok)
// -1 is not a legal value, but SEGGER seems to return it
if (ret == -1)
return -1;
// The compliant way of returning errors
if (ret == (int) nbyte)
return -1;
// Return the number of bytes written
return (ssize_t) (nbyte) - (ssize_t) ret;
}
#endif // OS_USE_TRACE_SEMIHOSTING_STDOUT
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
#define OS_INTEGER_TRACE_TMP_ARRAY_SIZE (16)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
static ssize_t
_trace_write_semihosting_debug (const char* buf, size_t nbyte)
{
// Since the single character debug channel is quite slow, try to
// optimise and send a null terminated string, if possible.
if (buf[nbyte] == '\0')
{
// send string
call_host (SEMIHOSTING_SYS_WRITE0, (void*) buf);
}
else
{
// If not, use a local buffer to speed things up
char tmp[OS_INTEGER_TRACE_TMP_ARRAY_SIZE];
size_t togo = nbyte;
while (togo > 0)
{
unsigned int n = ((togo < sizeof(tmp)) ? togo : sizeof(tmp));
unsigned int i = 0;
for (; i < n; ++i, ++buf)
{
tmp[i] = *buf;
}
tmp[i] = '\0';
call_host (SEMIHOSTING_SYS_WRITE0, (void*) tmp);
togo -= n;
}
}
// All bytes written
return (ssize_t) nbyte;
}
#pragma GCC diagnostic pop
#endif // OS_USE_TRACE_SEMIHOSTING_DEBUG
#endif // TRACE
// ----------------------------------------------------------------------------
|
the_stack_data/117327902.c
|
#include <stdio.h>
/*
int *f1(int i) {
return &i; /// cim szerint probal lokalis valtozot visszaadni, az a valtozo csak a fuggvenyen belul letezik
}
int main(void) {
int *p;
p = f1(10);
printf("%d\n", *p);
printf("%d\n", *p);
return 0;
}
*/
int *f1(int i) {
return &i; /// cim szerint probal lokalis valtozot visszaadni, az a valtozo csak a fuggvenyen belul letezik
}
int main(void) {
int x = 10;
int *p = f1(x);
printf("%d\n", *p);
printf("%d\n", *p);
return 0;
}
|
the_stack_data/123625.c
|
#ifdef STM32F2xx
#include "stm32f2xx_hal_cryp.c"
#endif
#ifdef STM32F4xx
#include "stm32f4xx_hal_cryp.c"
#endif
#ifdef STM32F7xx
#include "stm32f7xx_hal_cryp.c"
#endif
#ifdef STM32G0xx
#include "stm32g0xx_hal_cryp.c"
#endif
#ifdef STM32G4xx
#include "stm32g4xx_hal_cryp.c"
#endif
#ifdef STM32H7xx
#include "stm32h7xx_hal_cryp.c"
#endif
#ifdef STM32L0xx
#include "stm32l0xx_hal_cryp.c"
#endif
#ifdef STM32L1xx
#include "stm32l1xx_hal_cryp.c"
#endif
#ifdef STM32L4xx
#include "stm32l4xx_hal_cryp.c"
#endif
#ifdef STM32WBxx
#include "stm32wbxx_hal_cryp.c"
#endif
|
the_stack_data/48574038.c
|
char char_lit_num()
{
return '5';
}
|
the_stack_data/192329705.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memalloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erli <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/08 09:02:50 by erli #+# #+# */
/* Updated: 2018/11/09 13:05:27 by erli ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include <string.h>
void *ft_memalloc(size_t n)
{
void *memzone;
char *s;
size_t i;
if (!(memzone = malloc(n)))
return (NULL);
s = (char *)memzone;
i = 0;
while (i < n)
{
s[i] = 0;
i++;
}
return (memzone);
}
|
the_stack_data/104163.c
|
//stdlib.h
//example shows the usage of div() function.
#include <stdio.h>
#include <stdlib.h>
int main () {
div_t output;
output = div(27, 4);
printf("Quotient part of (27/ 4) = %d\n", output.quot);
printf("Remainder part of (27/4) = %d\n", output.rem);
output = div(27, 3);
printf("Quotient part of (27/ 3) = %d\n", output.quot);
printf("Remainder part of (27/3) = %d\n", output.rem);
return(0);
}
|
the_stack_data/72011894.c
|
int
foo(int i)
{
return i + 3;
}
int
main(int argc, char **argv)
{
return foo(argc);
}
|
the_stack_data/359220.c
|
/* Win32 termcap emulation.
Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
Contributed by CodeSourcery, LLC.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdlib.h>
/* Each of the files below is a minimal implementation of the standard
termcap function with the same name, suitable for use in a Windows
console window. */
int
tgetent (char *buffer, char *termtype)
{
return -1;
}
int
tgetnum (char *name)
{
return -1;
}
int
tgetflag (char *name)
{
return -1;
}
char *
tgetstr (char *name, char **area)
{
return NULL;
}
int
tputs (char *string, int nlines, int (*outfun) ())
{
while (*string)
outfun (*string++);
return 0;
}
char *
tgoto (const char *cap, int col, int row)
{
return NULL;
}
|
the_stack_data/119072.c
|
#include <stdio.h>
int funcPrimo(int a)
{
int i, vezes = 0, valor;
for (i = 1; i <= a && vezes <= 3; i++)
//for (i = 1; i <= num; i++)
{ //5 / 1 = 5 resto = 0
// 5 / 2 = 2 resto = 1
// 5 / 3 = 1 resto = 2
// 5 / 4 = 1 resto = 1
// 5 / 5 = 1 resto = 0
if (a % i == 0)
vezes ++;
}
if (vezes == 2)
{
valor = 1;
}
else
{
valor = 0;
}
return valor;
}
int main()
{
// Declaração das Variáveis
int i, num, primo;
while (num != -1) {
printf("Digite um n%cmero inteiro: \n", 163);
scanf("%d", &num);
if (num == -1) {
return 0;
}
primo = funcPrimo(num);
if (primo == 1) {
printf("1\n");
} else {
printf("0\n");
}
}
return 0;
}
|
the_stack_data/36285.c
|
/******************************************************************************
* Copyright (c) 1990, 1991, 1992,
* National Aeronautics and Space Administration
* ALL RIGHTS RESERVED
*
* The software (programs, data bases and/or documentation) on or in
* any media can not be reproduced, disclosed or used except under
* terms of the license between COSMIC and your organization.
*****************************************************************************/
#ifndef FORTRAN
static int dummy; /* prevent ranlib from complaining */
#else
C ***** DO NOT USE TABS OF FORMFEEDS IN ANY UNIX FORTRAN FILES *****
C
C XZINIT. FORTRAN CALLABLE ROUTINE .
C WRITTEN IN FORTRAN TO AVOID PROBLEM OF CONVERTING A C STRING
C TO A FORTRAN-77 STRING (FOR THE STANDARD OUTPUT FILE NAME ).
C
C
C CHANGE LOG:
C
C 29-MAR-83 HARDCODE PGMINC.FIN...DM
C 30-SEP-83 STORE TERMINAL TYPE, GETTERM -> XUGETT...peb
C 15-NOV-83 LIMIT VARIABLE NAMES TO 6 CHARS FOR PORTABILITY...dm
C 17-NOV-83 Add call to xzcall...palm
C 30-NOV-83 MODIFY FOR UNIX/F77 COMPATIBILITY
C 02-DEC-83 Fix bug in XRSTR calling sequence...dm
C 06-DEC-83 Save XZSAVL common block explicitely...dm
C 08-DEC-83 Do not open terminal as stdout using LUN 6...dm
C 10-MAY-84 Position file at the end in APPEND mode...dm
C 22-MAY-84 Convert file name to lower case...dm
C 21-AUG-84 Make xzinit portable, Isolate non-portable
C routines to different source module...dm
C 01-APR-88 - APOLLO conversion requires all Fortran files to have
C ** NO TABS ** and ** NO FORMFEEDS **!!!
C - Fortran files now go through C pre-processor...ljn
C 23-JUL-91 PR325: Change STDLUN to LUN in PREOPN...ljn
C
C
SUBROUTINE XZINIT(BLOCK, DIM, STDLUN, MODE, STATUS)
#include "pgminc.fin"
INTEGER BLOCK(1)
INTEGER DIM
INTEGER STDLUN
INTEGER MODE
INTEGER STATUS
CHARACTER*(xfssiz) STDREC(2)
CHARACTER*(xfssiz) TERMNM
INTEGER LENGTH(2)
INTEGER COUNT
LOGICAL NEWFIL
LOGICAL OPENED
INTEGER L
INTEGER LINES, COLS
LOGICAL TERMNL
INTEGER TTYPE
STATUS = xsucc
CALL SETLUN(STDLUN)
CALL XRINIM(BLOCK, DIM, MODE, STATUS)
IF (STATUS .NE. xsucc) RETURN
CALL XZCALL(BLOCK)
CALL XRSTR(BLOCK, '_STDOUT', 2, STDREC, LENGTH,
+ COUNT, STATUS)
IF (STATUS. NE. xsucc) RETURN
NEWFIL = .TRUE.
IF (STDREC(2) .NE. 'CREATE') NEWFIL = .FALSE.
C
CALL XUGETT(TERMNM)
IF (TERMNM .EQ. STDREC(1)) THEN
TERMNL = .TRUE.
ELSE
TERMNL = .FALSE.
ENDIF
CALL SETSTD(TERMNL)
CALL XTINIT(TTYPE, LINES, COLS)
C
C Prepare to open the standard output file, and make sure that
C it is not already open.
C
OPENED = .FALSE.
CALL PREOPN(LUN, STDREC(1), OPENED)
IF (OPENED) RETURN
CALL OPNSTD(STDREC(1), NEWFIL, OPENED)
IF (.NOT. OPENED) THEN
c Don't fail simply because stdout couldn't be opened, so that we can
c run from something other than a terminal without triggering shell-vicar
ccccc STATUS = xfail
IF (MODE .EQ. xabort) THEN
CALL XTWRIT('Could not open standard output file '
1 / / STDREC(1)(1:L), xccstd)
CALL XZEXIT(-1, 'TAE-STDOPN')
ENDIF
ENDIF
RETURN
END
C
C OPNSTD. Fortran open for an output file.
C
SUBROUTINE OPNSTD(FILENM, NEWFIL, OPENED)
CHARACTER*(*) FILENM
LOGICAL NEWFIL
LOGICAL OPENED
CHARACTER*132 DUMMY
CHARACTER*4 STAT
INTEGER LUN
LOGICAL TERMNL
CALL GETLUN_TAE(LUN)
CALL GETSTD(TERMNL)
IF (NEWFIL) THEN
STAT = 'NEW'
ELSE
STAT = 'OLD'
ENDIF
OPEN (FILE=FILENM, UNIT=LUN, STATUS=STAT, ERR=200)
OPENED = .TRUE.
IF (NEWFIL .OR. TERMNL) THEN
RETURN
ENDIF
C
C IF OLD FILE, POSITION AT THE END.
C
999 CONTINUE
READ(UNIT=LUN, FMT=101, END=150, ERR=150) DUMMY
101 FORMAT (A)
GOTO 999
150 RETURN
200 CONTINUE
OPENED = .FALSE.
RETURN
END
#endif
|
the_stack_data/140765087.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, L. Sekanina, Z. Vasicek "Libraries of Approximate Circuits: Automated Design and Application in CNN Accelerators" IEEE Journal on Emerging and Selected Topics in Circuits and Systems, Vol 10, No 4, 2020
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mse parameters
***/
// MAE% = 0.0092 %
// MAE = 0.75
// WCE% = 0.024 %
// WCE = 2.0
// WCRE% = 100.00 %
// EP% = 50.00 %
// MRE% = 0.28 %
// MSE = 1.2
// PDK45_PWR = 0.190 mW
// PDK45_AREA = 400.8 um2
// PDK45_DELAY = 1.40 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t mul8x5u_5R9(const uint64_t A,const uint64_t B)
{
uint64_t dout_14, dout_15, dout_16, dout_17, dout_18, dout_19, dout_20, dout_22, dout_23, dout_24, dout_25, dout_26, dout_27, dout_28, dout_29, dout_31, dout_32, dout_34, dout_35, dout_36, dout_37, dout_38, dout_39, dout_40, dout_41, dout_42, dout_43, dout_44, dout_45, dout_46, dout_47, dout_48, dout_49, dout_50, dout_51, dout_53, dout_54, dout_55, dout_56, dout_57, dout_58, dout_59, dout_60, dout_61, dout_62, dout_63, dout_64, dout_65, dout_66, dout_67, dout_68, dout_69, dout_70, dout_71, dout_72, dout_73, dout_74, dout_75, dout_76, dout_77, dout_78, dout_79, dout_80, dout_81, dout_82, dout_83, dout_84, dout_85, dout_86, dout_87, dout_88, dout_89, dout_90, dout_91, dout_92, dout_93, dout_94, dout_95, dout_96, dout_97, dout_98, dout_99, dout_100, dout_101, dout_102, dout_103, dout_104, dout_105, dout_106, dout_107, dout_108, dout_109, dout_110, dout_111, dout_112, dout_113, dout_114, dout_115, dout_116, dout_117, dout_118, dout_119, dout_120, dout_121, dout_122, dout_123, dout_124, dout_125, dout_126, dout_127, dout_128, dout_129, dout_130, dout_131, dout_132, dout_133, dout_134, dout_135, dout_136, dout_137, dout_138, dout_139, dout_140, dout_141, dout_142, dout_143, dout_144, dout_145, dout_146, dout_147, dout_148, dout_149, dout_150, dout_151, dout_152, dout_153, dout_154, dout_155, dout_156, dout_157, dout_158, dout_159, dout_160, dout_161, dout_162, dout_163, dout_164, dout_165, dout_166, dout_167, dout_168, dout_169, dout_170, dout_171, dout_172, dout_173, dout_174, dout_175, dout_176, dout_177, dout_178, dout_179, dout_180, dout_181, dout_182, dout_183, dout_184, dout_185, dout_186, dout_187, dout_188, dout_189, dout_190, dout_191, dout_192, dout_193, dout_194, dout_195, dout_196, dout_197;
uint64_t O;
dout_14=((A >> 0)&1)&((B >> 0)&1);
dout_15=((A >> 2)&1)&((B >> 0)&1);
dout_16=((A >> 3)&1)&((B >> 0)&1);
dout_17=((A >> 4)&1)&((B >> 0)&1);
dout_18=((A >> 5)&1)&((B >> 0)&1);
dout_19=((A >> 6)&1)&((B >> 0)&1);
dout_20=((A >> 7)&1)&((B >> 0)&1);
dout_22=((A >> 1)&1)&((B >> 1)&1);
dout_23=((A >> 2)&1)&((B >> 1)&1);
dout_24=((A >> 3)&1)&((B >> 1)&1);
dout_25=((A >> 4)&1)&((B >> 1)&1);
dout_26=((A >> 5)&1)&((B >> 1)&1);
dout_27=((A >> 6)&1)&((B >> 1)&1);
dout_28=((A >> 7)&1)&((B >> 1)&1);
dout_29=((B >> 0)&1)&dout_22;
dout_31=dout_15|dout_22;
dout_32=((B >> 0)&1)&dout_22;
dout_34=dout_31^dout_32;
dout_35=dout_26&dout_19;
dout_36=dout_16^dout_23;
dout_37=dout_16&dout_23;
dout_38=dout_36&dout_29;
dout_39=dout_36^dout_29;
dout_40=dout_37|dout_38;
dout_41=dout_17^dout_24;
dout_42=dout_17&dout_24;
dout_43=dout_41&dout_40;
dout_44=dout_41^dout_40;
dout_45=dout_42|dout_43;
dout_46=dout_18^dout_25;
dout_47=dout_18&dout_25;
dout_48=dout_46&dout_45;
dout_49=dout_46^dout_45;
dout_50=dout_47|dout_48;
dout_51=dout_19^dout_26;
dout_53=dout_51&dout_50;
dout_54=dout_51^dout_50;
dout_55=dout_35|dout_53;
dout_56=dout_20^dout_27;
dout_57=dout_20&dout_27;
dout_58=dout_56&dout_55;
dout_59=dout_56^dout_55;
dout_60=dout_57|dout_58;
dout_61=dout_60&dout_20;
dout_62=dout_60^dout_28;
dout_63=((A >> 0)&1)&((B >> 2)&1);
dout_64=((A >> 1)&1)&((B >> 2)&1);
dout_65=((A >> 2)&1)&((B >> 2)&1);
dout_66=((A >> 3)&1)&((B >> 2)&1);
dout_67=((A >> 4)&1)&((B >> 2)&1);
dout_68=((A >> 5)&1)&((B >> 2)&1);
dout_69=((A >> 6)&1)&((B >> 2)&1);
dout_70=((A >> 7)&1)&((B >> 2)&1);
dout_71=dout_34&dout_63;
dout_72=dout_34^dout_63;
dout_73=dout_39^dout_64;
dout_74=dout_39&dout_64;
dout_75=dout_73&dout_71;
dout_76=dout_73^dout_71;
dout_77=dout_74|dout_75;
dout_78=dout_44^dout_65;
dout_79=dout_44&dout_65;
dout_80=dout_78&dout_77;
dout_81=dout_78^dout_77;
dout_82=dout_79|dout_80;
dout_83=dout_49^dout_66;
dout_84=dout_49&dout_66;
dout_85=dout_83&dout_82;
dout_86=dout_83^dout_82;
dout_87=dout_84|dout_85;
dout_88=dout_54^dout_67;
dout_89=dout_54&dout_67;
dout_90=dout_88&dout_87;
dout_91=dout_88^dout_87;
dout_92=dout_89|dout_90;
dout_93=dout_59^dout_68;
dout_94=dout_59&dout_68;
dout_95=dout_93&dout_92;
dout_96=dout_93^dout_92;
dout_97=dout_94|dout_95;
dout_98=dout_62^dout_69;
dout_99=dout_62&dout_69;
dout_100=dout_98&dout_97;
dout_101=dout_98^dout_97;
dout_102=dout_99|dout_100;
dout_103=dout_61^dout_70;
dout_104=dout_61&dout_70;
dout_105=dout_70&dout_102;
dout_106=dout_103^dout_102;
dout_107=dout_104|dout_105;
dout_108=((A >> 0)&1)&((B >> 3)&1);
dout_109=((A >> 1)&1)&((B >> 3)&1);
dout_110=((A >> 2)&1)&((B >> 3)&1);
dout_111=((A >> 3)&1)&((B >> 3)&1);
dout_112=((A >> 4)&1)&((B >> 3)&1);
dout_113=((A >> 5)&1)&((B >> 3)&1);
dout_114=((A >> 6)&1)&((B >> 3)&1);
dout_115=((A >> 7)&1)&((B >> 3)&1);
dout_116=dout_76&dout_108;
dout_117=dout_76^dout_108;
dout_118=dout_81^dout_109;
dout_119=dout_81&dout_109;
dout_120=dout_118&dout_116;
dout_121=dout_118^dout_116;
dout_122=dout_119|dout_120;
dout_123=dout_86^dout_110;
dout_124=dout_86&dout_110;
dout_125=dout_123&dout_122;
dout_126=dout_123^dout_122;
dout_127=dout_124|dout_125;
dout_128=dout_91^dout_111;
dout_129=dout_91&dout_111;
dout_130=dout_128&dout_127;
dout_131=dout_128^dout_127;
dout_132=dout_129|dout_130;
dout_133=dout_96^dout_112;
dout_134=dout_96&dout_112;
dout_135=dout_133&dout_132;
dout_136=dout_133^dout_132;
dout_137=dout_134|dout_135;
dout_138=dout_101^dout_113;
dout_139=dout_101&dout_113;
dout_140=dout_138&dout_137;
dout_141=dout_138^dout_137;
dout_142=dout_139|dout_140;
dout_143=dout_106^dout_114;
dout_144=dout_106&dout_114;
dout_145=dout_143&dout_142;
dout_146=dout_143^dout_142;
dout_147=dout_144|dout_145;
dout_148=dout_107^dout_115;
dout_149=dout_107&((B >> 3)&1);
dout_150=dout_148&dout_147;
dout_151=dout_148^dout_147;
dout_152=dout_149|dout_150;
dout_153=((A >> 0)&1)&((B >> 4)&1);
dout_154=((A >> 1)&1)&((B >> 4)&1);
dout_155=((A >> 2)&1)&((B >> 4)&1);
dout_156=((A >> 3)&1)&((B >> 4)&1);
dout_157=((A >> 4)&1)&((B >> 4)&1);
dout_158=((A >> 5)&1)&((B >> 4)&1);
dout_159=((A >> 6)&1)&((B >> 4)&1);
dout_160=((A >> 7)&1)&((B >> 4)&1);
dout_161=dout_121&dout_153;
dout_162=dout_121^dout_153;
dout_163=dout_126^dout_154;
dout_164=dout_126&dout_154;
dout_165=dout_163&dout_161;
dout_166=dout_163^dout_161;
dout_167=dout_164|dout_165;
dout_168=dout_131^dout_155;
dout_169=dout_131&dout_155;
dout_170=dout_168&dout_167;
dout_171=dout_168^dout_167;
dout_172=dout_169|dout_170;
dout_173=dout_136^dout_156;
dout_174=dout_136&dout_156;
dout_175=dout_173&dout_172;
dout_176=dout_173^dout_172;
dout_177=dout_174|dout_175;
dout_178=dout_141^dout_157;
dout_179=dout_141&dout_157;
dout_180=dout_178&dout_177;
dout_181=dout_178^dout_177;
dout_182=dout_179|dout_180;
dout_183=dout_146^dout_158;
dout_184=dout_146&dout_158;
dout_185=dout_183&dout_182;
dout_186=dout_183^dout_182;
dout_187=dout_184|dout_185;
dout_188=dout_151^dout_159;
dout_189=dout_151&dout_159;
dout_190=dout_188&dout_187;
dout_191=dout_188^dout_187;
dout_192=dout_189|dout_190;
dout_193=dout_152^dout_160;
dout_194=dout_152&((B >> 4)&1);
dout_195=dout_160&dout_192;
dout_196=dout_193^dout_192;
dout_197=dout_194|dout_195;
O = 0;
O |= (dout_15&1) << 0;
O |= (dout_14&1) << 1;
O |= (dout_72&1) << 2;
O |= (dout_117&1) << 3;
O |= (dout_162&1) << 4;
O |= (dout_166&1) << 5;
O |= (dout_171&1) << 6;
O |= (dout_176&1) << 7;
O |= (dout_181&1) << 8;
O |= (dout_186&1) << 9;
O |= (dout_191&1) << 10;
O |= (dout_196&1) << 11;
O |= (dout_197&1) << 12;
return O;
}
|
the_stack_data/97012240.c
|
main ()
{
char audio[8192];
int i;
for (i = 0; i < 4095; i += 1)
audio[i] = i / 8,
audio[8191 - i] = i / 8;
for (;;)
write (1, audio, 8192);
}
|
the_stack_data/184518244.c
|
//sum01_bug02.c
int main() {
int i, j, n, sn;
(i = 1);
(j = 10);
(sn = 0);
assume(n >= 0);
while(i <= n){
if(i < j)sn = sn + 2;
j = j - 1;
i = i + 1;
}
assert(((sn == (n * 2)) || sn == 0));
}
|
the_stack_data/121678.c
|
/***********************************************************
lagrange.c -- Lagrange (ラグランジュ) 補間
***********************************************************/
#define N 5 /* データ点の数 */
double x[N] = { 0, 10, 20, 30, 40 },
y[N] = { 610.66, 1227.4, 2338.1, 4244.9, 7381.2 }; /* データ */
double lagrange(double t)
{
int i, j;
double sum, prod;
sum = 0;
for (i = 0; i < N; i++) {
prod = y[i];
for (j = 0; j < N; j++)
if (j != i) prod *= (t - x[j]) / (x[i] - x[j]);
sum += prod;
}
return sum;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i;
for (i = 10; i <= 30; i++)
printf("%3d %6.1f\n", i, lagrange(i));
return 0;
}
|
the_stack_data/48576065.c
|
#include <stdio.h>
void scilab_rt_barh_d0d0i0s0_(double scalarin0,
double scalarin1,
int scalarin2,
char* scalarin3)
{
printf("%f", scalarin0);
printf("%f", scalarin1);
printf("%d", scalarin2);
printf("%s", scalarin3);
}
|
the_stack_data/90766366.c
|
//CSL201 DATA STRUCTURES LAB ----- VISHRUTH S, CS3A, 61
//CYCLE 3 QUESTION 4
//To implement a Circular Linked List and perform the necessary operations
#include <stdio.h>
#include <stdlib.h>
// Node contains data and link to next node
struct Node
{
int data;
struct Node *link;
};
// Last pointer to linked list, pointing to last element
struct Node *last = NULL;
// Function to insert element at the beginning
// Time complexity: O(1)
void insertAtBeginning(int data)
{
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
if (last == NULL)
last = newNode;
else
newNode->link = last->link;
last->link = newNode;
printf("\nInsertion successful");
}
// Function to insert element at the end
// Time complexity: O(1)
void insertAtEnd(int data)
{
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
if (last == NULL)
{
last = newNode;
last->link = newNode;
}
else
{
newNode->link = last->link;
last->link = newNode;
last = newNode;
}
printf("\nInsertion successful");
}
// Function to insert element after a particular position
// Time complexity: Worst case O(n), Best case O(1)
void insertAfterPosition(int position, int data)
{
if (last == NULL)
{
printf("\nList empty");
return;
}
struct Node *curr = last->link;
while (--position)
{
curr = curr->link;
if (curr == last->link)
{
printf("\nPosition exceeded list size");
return;
}
}
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->link = curr->link;
curr->link = newNode;
if (curr == last)
last = newNode;
printf("\nInsertion successful");
}
// Function to delete a particular node
// Time complexity: Worst case O(n), Best case O(1)
void deleteElement(int element)
{
if (last == NULL)
{
printf("\nList empty");
return;
}
struct Node *prev = last;
struct Node *curr = last->link;
while (curr->data != element)
{
prev = curr;
curr = curr->link;
if (curr == last->link)
{
printf("\nElement not found");
return;
}
}
prev->link = curr->link;
if (curr == last)
last = prev;
if (curr == prev)
last = NULL;
free(curr);
printf("\nDeletion successful");
}
void display();
// MAIN FUNCTION
int main()
{
insertAtBeginning(10);
insertAtBeginning(20);
display();
insertAfterPosition(1, 25);
insertAfterPosition(2, 15);
insertAfterPosition(3, 45);
display();
deleteElement(10);
display();
deleteElement(15);
display();
deleteElement(45);
display();
insertAfterPosition(5, 13);
deleteElement(13);
display();
return 0;
}
// Function to display elements
void display()
{
if (last == NULL)
{
printf("\nList empty");
return;
}
struct Node *ptr = last->link;
printf("\n");
do
{
printf("%d ", ptr->data);
ptr = ptr->link;
} while (ptr != last->link);
}
|
the_stack_data/31388133.c
|
#include <stdio.h>
int is_happy_number(int n)
{
int sum=0,prod=1,t;
while(n!=0)
{
t=n%10;
sum+=t;
prod*=t;
n/=10;
}
// printf("%d %d\n",sum,prod);
return (sum==prod);
}
int main()
{
int n;
scanf("%d",&n);
if(is_happy_number(n))
printf("YES");
else
printf("NO");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.