file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/89201373.c | #include <assert.h>
#include <stdio.h>
int main(void)
{
FILE *f;
unsigned long i;
static char *ws = " \f\t\v";
static char *al = "abcdefghijklmnopqrstuvwxyz";
static char *i5 = "a b c d e f g h i j k l m "
"n o p q r s t u v w x y z "
"a b c d e f g h i j k l m "
"n o p q r s t u v w x y z "
"a b c d e f g h i j k l m "
"n\n";
/* Generate the following: */
/* 0. input file contains zero words */
f = fopen("test0", "w");
assert(f != NULL);
fclose(f);
/* 1. input file contains 1 enormous word without any newlines */
f = fopen("test1", "w");
assert(f != NULL);
for (i = 0; i < ((66000ul / 26) + 1); i++)
fputs(al, f);
fclose(f);
/* 2. input file contains all white space without newlines */
f = fopen("test2", "w");
assert(f != NULL);
for (i = 0; i < ((66000ul / 4) + 1); i++)
fputs(ws, f);
fclose(f);
/* 3. input file contains 66000 newlines */
f = fopen("test3", "w");
assert(f != NULL);
for (i = 0; i < 66000; i++)
fputc('\n', f);
fclose(f);
/* 4. input file contains word/
* {huge sequence of whitespace of different kinds}
* /word
*/
f = fopen("test4", "w");
assert(f != NULL);
fputs("word", f);
for (i = 0; i < ((66000ul / 26) + 1); i++)
fputs(ws, f);
fputs("word", f);
fclose(f);
/* 5. input file contains 66000 single letter words,
* 66 to the line
*/
f = fopen("test5", "w");
assert(f != NULL);
for (i = 0; i < 1000; i++)
fputs(i5, f);
fclose(f);
/* 6. input file contains 66000 words without any newlines */
f = fopen("test6", "w");
assert(f != NULL);
for (i = 0; i < 66000; i++)
fputs("word ", f);
fclose(f);
return 0;
}
|
the_stack_data/34512205.c | #include <stdio.h>
#include <stdlib.h>
union Uni_J {
char isim[32];
float puan;
int TC_no;
}Uni_J;
struct Stu_J {
char isim[32]; //32
float puan; //4 byte
int TC_no; //4 byte
}Stu_J;
int main()
{
printf("union byte buyuklugu: %d\n\n", sizeof(Uni_J) );
printf("struct byte buyuklugu: %d\n\n",sizeof(Stu_J) );
}
|
the_stack_data/613382.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
const char INPUT_FILE[] = "input";
// store graph vertex names, the index is used in the graph
char name_index[100][20] = {0};
size_t top = 0;
// store the visited caves
int caves[100] = {0};
size_t cave_top = 0;
// sets the adjacency matrix to 0
void init_mat(int n, int mat[][n]) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
mat[i][j] = 0;
}
}
}
// adds an edge to the adjacency matrix
void add_edge(int n, int mat[][n], int i, int j) {
mat[i][j] = 1;
mat[j][i] = 1;
}
// prints the adjacency matrix
void print_mat(int n, int mat[][n]) {
for (int i = 0; i < n; i++) {
printf("%5s: ", name_index[i]);
for (int j = 0; j < n; j++) {
printf("%d ", mat[i][j]);
}
printf("\n");
}
}
// checks if the cave exists in the name index
int check_cave_exists(char* cave) {
for (int i = 0; i < top; i++) {
if (strcmp(cave, name_index[i]) == 0) {
return 1;
}
}
return 0;
}
// returns the index of a cave by name
int get_cave_index(char* cave) {
for (int i = 0; i < top; i++) {
if (strcmp(cave, name_index[i]) == 0) {
return i;
}
}
return -1;
}
// adds the cave to the name index, if it exists already just returns the index
int add_cave_index(char* cave) {
if (check_cave_exists(cave)) return get_cave_index(cave);
strcpy(name_index[top++], cave);
return top-1;
}
int paths = 0;
void count_paths(int n, int mat[][n], int src) {
// if end print all caves
if (src == get_cave_index("end")) {
// adding the final cave to the stack just for printing
caves[cave_top++] = src;
for (int i = 0; i < cave_top; i++) {
printf("%s ", name_index[caves[i]]);
}
printf("\n");
paths++;
cave_top--;
return;
}
// if smol cave
if (name_index[src][0] > 'Z') {
// check if smol cave exists in visited caves
for (int i = 0; i < cave_top; i++) {
if (strcmp(name_index[src], name_index[caves[i]]) == 0) {
return;
}
}
}
// add current cave to stack
caves[cave_top++] = src;
// count paths for adjacent nodes
for (int i = 0; i < n; i++) {
if (mat[src][i] == 1 || mat[i][src]) count_paths(n, mat, i);
}
// remove the current cave from the stack
cave_top--;
}
int main() {
FILE* fp = fopen(INPUT_FILE, "r");
if (fp == NULL) return 1;
// load all cave indices
char buff[20];
while (fgets(buff, 20, fp) != NULL) {
char* a = strtok(buff, "-\n\r");
int ind_a = add_cave_index(a);
char* b = strtok(NULL, "-\n\r");
int ind_b = add_cave_index(b);
}
rewind(fp);
int adj[top][top];
init_mat(top, adj);
// load the caves into the adjacency matrix
while (fgets(buff, 20, fp) != NULL) {
char* a = strtok(buff, "-\n\r");
int ind_a = get_cave_index(a);
char* b = strtok(NULL, "-\n\r");
int ind_b = get_cave_index(b);
add_edge(top, adj, ind_a, ind_b);
}
print_mat(top, adj);
printf("---\n");
count_paths(top, adj, get_cave_index("start"));
printf("paths: %d\n", paths);
return 0;
} |
the_stack_data/14138.c | #include <stdio.h>
#include <stdlib.h>
// struct node {
// int data;
// struct node* next;
// struct node* prev;
// }*head, *next_node;
// void depan(int x){
// struct node *new_node;
// new_node = (struct node*) malloc (sizeof(struct node));
// new_node->data = x;
// new_node->next = head;
// new_node->prev = NULL;
// if (head != NULL)
// {
// head->prev = new_node;
// head = new_node;
// }
// }
// void insertBefore(int y){
// if (next_node == NULL)
// {
// printf("next node tidak boleh kosong");
// return;
// }
// struct node *new_node;
// new_node = (struct node*) malloc (sizeof(struct node));
// new_node ->data = y;
// new_node ->prev = next_node->prev;
// next_node ->prev = new_node;
// new_node ->next = next_node;
// if (new_node->prev == NULL)
// {
// new_node->prev->next = new_node;
// }
// else
// {
// head = new_node;
// }
// }
// void tampilkan(){
// struct node *l;
// printf("dari arah depan");
// while (head == NULL){}
// {
// printf("%d", head->data);
// l = head;
// head = head->next;
// }
// printf("dari arah depan");
// while (l == NULL){}
// {
// printf("%d", l->data);
// l = l-> prev;
// }
// }
// int main(){
// struct node *head = NULL;
// depan(2);
// depan(3);
// depan(4);
// depan(5);
// insertBefore(7);
// printf("double linked list");
// tampilkan(head);
// getchar();
// return 0;
// }
// mendefinisikan data struct
struct Node{
int data;
struct Node* next;
struct Node* prev;
};
// menyisipkan node baru di bagian depan list
void push(struct Node** head_refrensi, int new_data){
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_refrensi);
new_node->prev = NULL;
if((*head_refrensi) != NULL)
(*head_refrensi)->prev = new_node;
(*head_refrensi) = new_node;
}
// masukkan node baru sebelum node yang ada
void insertBefore(struct Node** head_refrensi, struct Node* next_node, int new_data){
// 1. cek jika next_node bukan NULL
if (next_node == NULL){
printf("Next Node Tidak Boleh NULL!");
return;
}
// 2. alokasi node baru
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
// 3. input ke data
new_node->data = new_data;
// 4. buat prev dari simpul baru sebagai prev dari next_node
new_node->prev = next_node->prev;
// 5. jadikan prev next_node sebagai new_node
next_node->prev = new_node;
// 6. jadikan next_node sebagai next dari new_node
new_node->next = next_node;
// 7. ubah prev pada new_node menjadi next
if(new_node->prev != NULL)
new_node->prev->next = new_node;
// 8. jika prev new_node adalah NULL, maka akan menjadi head node yang baru
else
(*head_refrensi) = new_node;
}
// print list
void printList(struct Node* node){
struct Node* last;
printf("\nTampil dari arah depan : \n");
while (node != NULL){
printf("%d", node->data);
last = node;
node = node->next;
}
printf("\nTampil dari arah belakang : \n");
while (last != NULL){
printf("%d", last->data);
last = last->prev;
}
}
int main(){
struct Node* head = NULL; //mulai dengan head = NULL
push(&head, 2);
push(&head, 3);
push(&head, 5);
push(&head, 1);
// insert 8 sebelum 5, maka linked list menjadi 1->8->5->3->2->NULL
insertBefore(&head, head->next, 8);
printf("Double Linked List : ");
printList(head);
getchar();
return 0;
} |
the_stack_data/54824964.c | #include <stdio.h>
int main()
{
int number;
int reminder;
printf("Please enter a valid unsigned integer!");
scanf("%d", &number);
reminder = number % 3;
if(number % 3 == 0){
printf("The number you entered is div. by 3!\n");
}
else{
printf("The number you entered is not div. by 3!\n");
}
printf("The reminder of the operatio nis: %d\n",reminder);
return 0;
}
|
the_stack_data/12638884.c | #include<stdio.h>
long long sum(long long m,long long n)
{
if(n==m||n==0)
return 1;
if(n==1)
return m;
else
return sum(m-1,n)+sum(m-1,n-1);
}
int main()
{
long long m,n;
scanf("%lld",&m);
scanf("%lld",&n);
long long t=sum(m,n);
printf("%lld",t);
return 0;
} |
the_stack_data/1162758.c | // Exercise 13 from chapter 8
// This program is a rewrite of program 8.12. It sorts arrays in ascending or descending order.
#include<stdio.h>
void sort( int a[], int n, _Bool order )
{
int i, j, temp;
if( order == 0 ) // ascending
{
for( i = 0; i < n - 1; ++i )
for( j = i + 1; j < n; ++j )
if( a[i] > a[j] )
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
if( order == 1 ) // descending
{
for( i = 0; i < n - 1; ++i )
for( j = i + 1; j < n; ++j )
if( a[i] < a[j] )
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
int main( void )
{
int i;
int array[16] = { 34, -5, 6, 0, 12, 100, 56, 22, 44, -3, -9, 12, 17, 22, 6, 11 };
void sort( int a[], int n, _Bool order );
printf( "The array before the sort:\n" );
for( i = 0; i < 16; ++i )
printf( "%i ", array[i] );
sort( array, 16, 1 );
printf( "\n\nThe array after the sort:\n" );
for( i = 0; i < 16; ++i )
printf( "%i ", array[i] );
printf( "\n" );
return 0;
}
|
the_stack_data/192330167.c | int arrayPairSum(int* nums, int numsSize)
{
int sum;
int i;
quickSort(nums, 0, numsSize-1);
sum = 0;
for(i = 0;i < numsSize;i+=2)
{
sum+=nums[i];
}
return sum;
}
void quickSort(int* A, int left, int right)
{
int i, j;
if(left < right)
{
Middle(A, left, right);
i = left;
j = right - 1;
while(i < j)
{
while(A[++i] < A[right-1]);
while(A[--j] > A[right-1]);
if(i < j)
Swap(&A[i],&A[j]);
else
break;
}
Swap(&A[i],&A[right-1]);
quickSort(A, left, i-1);
quickSort(A, i+1, right);
}
}
void Middle(int*A, int left, int right)
{
int center;
center = (left + right)/2;
if(A[left] > A[center])
Swap(&A[left], &A[center]);
if(A[left] > A[right])
Swap(&A[left], &A[right]);
if(A[center] > A[right])
Swap(&A[center], &A[right]);
Swap(&A[center], &A[right-1]);
}
void Swap(int* p, int* q)
{
int temp;
temp = *p;
*p = *q;
*q = temp;
}
|
the_stack_data/162642283.c | /*
C-file generated by Bin2C
Compiled: Aug 9 2004 at 15:18:55
Copyright (C) 2004
Segger Microcontroller Systeme GmbH
www.segger.com
Solutions for real time microcontroller applications
*/
const unsigned char acchujiao[] = {
0x42, 0x4D, 0x36, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0xC3, 0x0E,
0x00, 0x00, 0xC3, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x29, 0x29, 0x29, 0x0D, 0x4C, 0x4C, 0x4C, 0x35, 0x60, 0x60,
0x60, 0x78, 0x68, 0x68, 0x68, 0x9E, 0x6C, 0x6C, 0x6C, 0xA5, 0x63, 0x63, 0x63, 0x8C, 0x59, 0x59, 0x59, 0x4D, 0x3A, 0x3A, 0x3A, 0x1C, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x03, 0x00, 0x00, 0x00, 0x09, 0x19, 0x19, 0x19, 0x13, 0x31, 0x31, 0x31, 0x1A, 0x17, 0x17, 0x17, 0x12, 0x01, 0x01, 0x01, 0x0A,
0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x21, 0x21, 0x21, 0x11,
0x69, 0x69, 0x69, 0x84, 0x86, 0x86, 0x86, 0xD4, 0x97, 0x97, 0x97, 0xF8, 0x9B, 0x9B, 0x9B, 0xFC, 0x9C, 0x9C, 0x9C, 0xFD, 0x97, 0x97, 0x97, 0xFB, 0x88, 0x88, 0x88, 0xE8, 0x7C, 0x7C, 0x7C, 0xB4, 0x3C, 0x3C, 0x3C, 0x31, 0x0E, 0x0E, 0x0E, 0x03,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x0E, 0x0E, 0x0E, 0x0A,
0x2F, 0x2F, 0x2F, 0x29, 0x55, 0x55, 0x55, 0x70, 0x6A, 0x6A, 0x6A, 0x95, 0x73, 0x73, 0x73, 0xAC, 0x79, 0x79, 0x79, 0xBA, 0x72, 0x72, 0x72, 0xAA, 0x6D, 0x6D, 0x6D, 0x99, 0x54, 0x54, 0x54, 0x68, 0x33, 0x33, 0x33, 0x2F, 0x04, 0x04, 0x04, 0x08,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x48, 0x48, 0x48, 0x1F, 0x78, 0x78, 0x78, 0xA4, 0x9F, 0x9F, 0x9F, 0xFD, 0xA7, 0xA7, 0xA7, 0xFF, 0xA3, 0xA5, 0xA3, 0xFF,
0x97, 0x9E, 0x9A, 0xFE, 0x95, 0x9F, 0x99, 0xFE, 0x9A, 0x9F, 0x9C, 0xFE, 0xA0, 0xA0, 0xA0, 0xFF, 0xA3, 0xA3, 0xA3, 0xFF, 0x8B, 0x8B, 0x8B, 0xD8, 0x5E, 0x5E, 0x5E, 0x51, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x28, 0x28, 0x28, 0x0F, 0x55, 0x55, 0x55, 0x48, 0x72, 0x72, 0x72, 0xB8, 0x82, 0x82, 0x82, 0xED, 0x91, 0x91, 0x91, 0xFE,
0x91, 0x91, 0x91, 0xFF, 0x90, 0x90, 0x90, 0xFF, 0x90, 0x90, 0x90, 0xFF, 0x8F, 0x8F, 0x8F, 0xFF, 0x90, 0x90, 0x90, 0xFF, 0x90, 0x90, 0x90, 0xFD, 0x83, 0x83, 0x83, 0xF1, 0x6F, 0x6F, 0x6F, 0xAA, 0x58, 0x58, 0x58, 0x52, 0x0E, 0x0E, 0x0E, 0x0A,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x72, 0x72, 0x72, 0x7D, 0x9F, 0x9F, 0x9F, 0xF4, 0xAA, 0xAA, 0xAA, 0xFF, 0x98, 0x9E, 0x9B, 0xFF, 0x5C, 0xA4, 0x7D, 0xFF, 0x56, 0xC1, 0x88, 0xFE, 0x5A, 0xC8, 0x8E, 0xFE,
0x59, 0xB9, 0x85, 0xFE, 0x7F, 0x9B, 0x8C, 0xFE, 0xA6, 0xA8, 0xA7, 0xFF, 0xA5, 0xA5, 0xA5, 0xFD, 0x8A, 0x8A, 0x8A, 0xCB, 0x23, 0x23, 0x23, 0x14, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x21, 0x21, 0x21, 0x13, 0x6C, 0x6C, 0x6C, 0x91, 0x85, 0x85, 0x85, 0xE1, 0x91, 0x91, 0x91, 0xFE, 0x99, 0x99, 0x99, 0xFF, 0x9C, 0x9C, 0x9C, 0xFF, 0x9F, 0x9F, 0x9F, 0xFF, 0xA0, 0xA0, 0xA0, 0xFF,
0xA0, 0xA0, 0xA0, 0xFF, 0x9F, 0x9F, 0x9F, 0xFF, 0x9F, 0x9F, 0x9F, 0xFF, 0x94, 0x94, 0x94, 0xFF, 0x8E, 0x8E, 0x8E, 0xFF, 0x90, 0x90, 0x90, 0xFC, 0x86, 0x86, 0x86, 0xE8, 0x66, 0x66, 0x66, 0x7F, 0x30, 0x30, 0x30, 0x17, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x42, 0x42, 0x42, 0x1F, 0x99, 0x99, 0x99, 0xE8, 0xAE, 0xAE, 0xAE, 0xFF, 0x8A, 0x9C, 0x93, 0xFF, 0x47, 0xAE, 0x77, 0xFF, 0x52, 0xED, 0x9B, 0xFF, 0x6E, 0xF7, 0xB0, 0xFF, 0x7E, 0xFA, 0xB9, 0xFF, 0x69, 0xF7, 0xAC, 0xFF, 0x4A, 0xD5, 0x8B, 0xFF,
0x69, 0x9F, 0x82, 0xFF, 0xAC, 0xAD, 0xAD, 0xFF, 0xA7, 0xA7, 0xA7, 0xFD, 0x73, 0x73, 0x73, 0x83, 0x27, 0x27, 0x27, 0x0B, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x4F, 0x4F, 0x4F, 0x2E,
0x79, 0x79, 0x79, 0xB2, 0x94, 0x94, 0x94, 0xFD, 0x9B, 0x9B, 0x9B, 0xFF, 0xA3, 0xA3, 0xA3, 0xFF, 0xA3, 0xA3, 0xA3, 0xFF, 0xA0, 0x9E, 0x9D, 0xFE, 0x9A, 0x94, 0x92, 0xFE, 0x9B, 0x8D, 0x86, 0xFE, 0x9D, 0x8D, 0x84, 0xFE, 0x9B, 0x8E, 0x88, 0xFE,
0x9B, 0x95, 0x92, 0xFE, 0x9C, 0x9B, 0x9A, 0xFF, 0x9A, 0x9A, 0x9A, 0xFF, 0xA2, 0xA2, 0xA2, 0xFF, 0x9B, 0x9B, 0x9B, 0xFF, 0x91, 0x91, 0x91, 0xF9, 0x7A, 0x7A, 0x7A, 0xBB, 0x40, 0x40, 0x40, 0x21, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x65, 0x65, 0x65, 0x53, 0xAC, 0xAC, 0xAC, 0xFD,
0xAD, 0xAD, 0xAD, 0xFF, 0x58, 0x97, 0x76, 0xFF, 0x3E, 0xD3, 0x85, 0xFF, 0x5E, 0xF5, 0xA5, 0xFF, 0x74, 0xF9, 0xB3, 0xFF, 0x7E, 0xFB, 0xB9, 0xFF, 0x70, 0xF8, 0xB1, 0xFF, 0x53, 0xEF, 0x9D, 0xFF, 0x3E, 0xBB, 0x78, 0xFF, 0x9B, 0xA1, 0x9E, 0xFF,
0xB1, 0xB1, 0xB1, 0xFF, 0x94, 0x94, 0x94, 0xDE, 0x5A, 0x5A, 0x5A, 0x5C, 0x05, 0x05, 0x05, 0x06, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x04, 0x04, 0x03, 0x27, 0x27, 0x27, 0x21, 0x7D, 0x7D, 0x7D, 0xB8, 0x93, 0x93, 0x93, 0xF8, 0xA2, 0xA2, 0xA2, 0xFF,
0xA6, 0xA6, 0xA6, 0xFF, 0xA1, 0xA1, 0xA1, 0xFF, 0x98, 0x90, 0x8D, 0xFF, 0x96, 0x6C, 0x58, 0xFE, 0xA9, 0x74, 0x47, 0xFE, 0xBB, 0x83, 0x43, 0xFE, 0xC6, 0x8F, 0x44, 0xFE, 0xBB, 0x85, 0x44, 0xFE, 0xB0, 0x7C, 0x49, 0xFE, 0x97, 0x73, 0x5E, 0xFF,
0x9B, 0x90, 0x8B, 0xFF, 0xA2, 0xA1, 0xA1, 0xFF, 0xA4, 0xA4, 0xA4, 0xFF, 0xA0, 0xA0, 0xA0, 0xFF, 0x95, 0x95, 0x95, 0xFB, 0x76, 0x76, 0x76, 0x98, 0x35, 0x35, 0x35, 0x15, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x03, 0x85, 0x85, 0x85, 0x7E, 0xB4, 0xB4, 0xB4, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF, 0x3A, 0x9B, 0x69, 0xFF,
0x40, 0xDF, 0x8B, 0xFF, 0x5A, 0xF4, 0xA3, 0xFF, 0x68, 0xF6, 0xAC, 0xFF, 0x6E, 0xF7, 0xAF, 0xFF, 0x66, 0xF6, 0xAA, 0xFF, 0x52, 0xF1, 0x9D, 0xFF, 0x3D, 0xDA, 0x87, 0xFF, 0x78, 0x90, 0x83, 0xFE, 0xB3, 0xB3, 0xB3, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF,
0x9A, 0x9A, 0x9A, 0xF8, 0x79, 0x79, 0x79, 0xB8, 0x6A, 0x6A, 0x6A, 0x93, 0x73, 0x73, 0x73, 0xAB, 0x87, 0x87, 0x87, 0xE3, 0x9B, 0x9B, 0x9B, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xA8, 0xA8, 0xA8, 0xFF, 0x9E, 0x9B, 0x9A, 0xFF, 0x99, 0x6F, 0x5B, 0xFF,
0xB2, 0x6D, 0x33, 0xFF, 0xE2, 0xA9, 0x42, 0xFF, 0xEE, 0xC4, 0x4C, 0xFF, 0xF4, 0xD3, 0x50, 0xFF, 0xF5, 0xD6, 0x51, 0xFF, 0xF4, 0xD4, 0x51, 0xFF, 0xF1, 0xCC, 0x4E, 0xFF, 0xE2, 0xAF, 0x44, 0xFF, 0xBD, 0x7D, 0x37, 0xFF, 0x9D, 0x7B, 0x67, 0xFF,
0x9F, 0x99, 0x97, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0x95, 0x95, 0x95, 0xF8, 0x74, 0x74, 0x74, 0x8A, 0x15, 0x15, 0x15, 0x04, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x03, 0x8D, 0x8D, 0x8D, 0x80, 0xB7, 0xB7, 0xB7, 0xFF, 0xA5, 0xA7, 0xA6, 0xFF, 0x34, 0x95, 0x63, 0xFF, 0x3C, 0xD9, 0x86, 0xFF, 0x53, 0xF0, 0x9E, 0xFF,
0x67, 0xF5, 0xAB, 0xFF, 0x6A, 0xF6, 0xAD, 0xFF, 0x5F, 0xF4, 0xA6, 0xFF, 0x4B, 0xEC, 0x97, 0xFF, 0x38, 0xD1, 0x80, 0xFF, 0x75, 0x91, 0x82, 0xFE, 0xB6, 0xB6, 0xB6, 0xFF, 0xA9, 0xA9, 0xA9, 0xFF, 0xA3, 0xA3, 0xA3, 0xFF, 0xA2, 0xA2, 0xA2, 0xFE,
0xA0, 0xA0, 0xA0, 0xFB, 0x9F, 0x9F, 0x9F, 0xFD, 0x9D, 0x9D, 0x9D, 0xFE, 0xA4, 0xA4, 0xA4, 0xFF, 0xAC, 0xAC, 0xAC, 0xFF, 0xA0, 0x9C, 0x9B, 0xFF, 0x93, 0x6B, 0x5B, 0xFF, 0xC4, 0x7A, 0x34, 0xFF, 0xE2, 0xAA, 0x42, 0xFF, 0xF2, 0xCD, 0x4E, 0xFF,
0xF6, 0xD6, 0x52, 0xFF, 0xF9, 0xDD, 0x53, 0xFF, 0xFA, 0xE0, 0x54, 0xFF, 0xF9, 0xDD, 0x54, 0xFF, 0xF7, 0xD9, 0x52, 0xFF, 0xF3, 0xD1, 0x50, 0xFF, 0xEA, 0xBC, 0x48, 0xFF, 0xC5, 0x85, 0x3B, 0xFF, 0x9D, 0x72, 0x59, 0xFF, 0xA3, 0xA3, 0xA2, 0xFF,
0xAA, 0xAA, 0xAA, 0xFF, 0xA3, 0xA3, 0xA3, 0xFE, 0x90, 0x90, 0x90, 0xE5, 0x4A, 0x4A, 0x4A, 0x29, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x80, 0x80, 0x61, 0xB1, 0xB1, 0xB1, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0x45, 0x87, 0x65, 0xFF, 0x2F, 0xBD, 0x74, 0xFF, 0x54, 0xE6, 0x99, 0xFF, 0x64, 0xF0, 0xA7, 0xFF, 0x5B, 0xF2, 0xA3, 0xFF,
0x5E, 0xEF, 0xA3, 0xFF, 0x43, 0xDC, 0x8B, 0xFF, 0x2C, 0xAA, 0x68, 0xFF, 0x8E, 0x99, 0x93, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0xA9, 0xA9, 0xA9, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xA1, 0xA1, 0xA1, 0xFF,
0xA0, 0xA0, 0xA0, 0xFF, 0xB1, 0xB1, 0xB1, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF, 0x93, 0x6C, 0x5D, 0xFF, 0xBB, 0x6E, 0x30, 0xFF, 0xE4, 0xAB, 0x43, 0xFF, 0xF0, 0xCB, 0x4E, 0xFF, 0xF6, 0xD7, 0x51, 0xFF, 0xF8, 0xDC, 0x53, 0xFF, 0xFB, 0xE1, 0x55, 0xFF,
0xFC, 0xE4, 0x56, 0xFF, 0xFB, 0xE2, 0x55, 0xFF, 0xF9, 0xDD, 0x54, 0xFF, 0xF6, 0xD8, 0x52, 0xFF, 0xF4, 0xD2, 0x50, 0xFF, 0xE8, 0xB5, 0x46, 0xFF, 0xC9, 0x82, 0x35, 0xFF, 0x98, 0x78, 0x69, 0xFF, 0xA5, 0xA4, 0xA3, 0xFF, 0xAD, 0xAD, 0xAD, 0xFF,
0xA2, 0xA2, 0xA2, 0xFF, 0x7F, 0x7F, 0x7F, 0x91, 0x3B, 0x3B, 0x3B, 0x0B, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x6A, 0x6A, 0x6A, 0x29, 0xAF, 0xAF, 0xAF, 0xF3, 0xB7, 0xB7, 0xB7, 0xFF, 0x74, 0x8D, 0x81, 0xFF, 0x2B, 0x8C, 0x5C, 0xFF, 0x50, 0xD2, 0x8E, 0xFF, 0x6E, 0xE8, 0xA8, 0xFF, 0x68, 0xEA, 0xA6, 0xFF, 0x64, 0xE4, 0xA1, 0xFF, 0x3A, 0xB6, 0x76, 0xFF,
0x4C, 0x8D, 0x6B, 0xFF, 0xAD, 0xAE, 0xAE, 0xFF, 0xC0, 0xC0, 0xC0, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA0, 0xA0, 0xA0, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xAE, 0xAE, 0xAE, 0xFF,
0x9B, 0x93, 0x92, 0xFE, 0x9E, 0x57, 0x2F, 0xFE, 0xD5, 0x8B, 0x38, 0xFF, 0xEB, 0xBD, 0x49, 0xFF, 0xF3, 0xD2, 0x50, 0xFF, 0xF6, 0xD8, 0x52, 0xFF, 0xF9, 0xDC, 0x53, 0xFF, 0xFB, 0xE1, 0x55, 0xFF, 0xFB, 0xE2, 0x56, 0xFF, 0xFB, 0xE1, 0x55, 0xFF,
0xFA, 0xDE, 0x54, 0xFF, 0xF7, 0xD9, 0x52, 0xFF, 0xF5, 0xD5, 0x51, 0xFF, 0xEE, 0xC5, 0x4C, 0xFF, 0xE1, 0xA4, 0x40, 0xFF, 0xA8, 0x69, 0x3D, 0xFF, 0x9E, 0x90, 0x8C, 0xFF, 0xAE, 0xAE, 0xAE, 0xFF, 0xAA, 0xAA, 0xAA, 0xFF, 0x92, 0x92, 0x92, 0xC8,
0x63, 0x63, 0x63, 0x24, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x2C, 0x2C, 0x2C, 0x03, 0x9F, 0x9F, 0x9F, 0x98,
0xC3, 0xC3, 0xC3, 0xFA, 0xAF, 0xB1, 0xB0, 0xFF, 0x7A, 0x8F, 0x85, 0xFF, 0x41, 0x88, 0x66, 0xFF, 0x55, 0xA8, 0x80, 0xFF, 0x57, 0xB2, 0x84, 0xFF, 0x4C, 0x9F, 0x76, 0xFF, 0x5E, 0x8A, 0x74, 0xFF, 0x95, 0x9B, 0x98, 0xFF, 0xC0, 0xC0, 0xC0, 0xFF,
0xB4, 0xB4, 0xB4, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF, 0xA7, 0xA7, 0xA7, 0xFF, 0xA5, 0xA5, 0xA5, 0xFF, 0xA4, 0xA4, 0xA4, 0xFF, 0x9F, 0x9F, 0x9F, 0xFF, 0xA3, 0xA3, 0xA3, 0xFF, 0x89, 0x63, 0x58, 0xFF, 0xBE, 0x6D, 0x2D, 0xFF,
0xDE, 0x9D, 0x3E, 0xFF, 0xEF, 0xC6, 0x4C, 0xFF, 0xF4, 0xD3, 0x50, 0xFF, 0xF7, 0xD8, 0x52, 0xFF, 0xF8, 0xDB, 0x53, 0xFF, 0xF9, 0xDE, 0x54, 0xFF, 0xFA, 0xDF, 0x54, 0xFF, 0xF9, 0xDE, 0x54, 0xFF, 0xF9, 0xDD, 0x53, 0xFF, 0xF7, 0xD9, 0x52, 0xFF,
0xF5, 0xD6, 0x51, 0xFF, 0xF1, 0xCC, 0x4E, 0xFF, 0xE6, 0xB1, 0x45, 0xFF, 0xC3, 0x79, 0x33, 0xFF, 0x98, 0x71, 0x5F, 0xFF, 0xAB, 0xAB, 0xAB, 0xFF, 0xB4, 0xB4, 0xB4, 0xFF, 0x9D, 0x9D, 0x9D, 0xEF, 0x7A, 0x7A, 0x7A, 0x52, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x86, 0x86, 0x86, 0x2F, 0xAD, 0xAD, 0xAD, 0xC7, 0xC8, 0xC8, 0xC8, 0xFE,
0xBA, 0xBA, 0xBA, 0xFF, 0x8B, 0x97, 0x91, 0xFF, 0x7D, 0x92, 0x87, 0xFF, 0x7A, 0x92, 0x86, 0xFF, 0x82, 0x93, 0x8A, 0xFF, 0xAC, 0xAF, 0xAE, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0xB2, 0xB2, 0xB2, 0xFE, 0xAA, 0xAA, 0xAA, 0xFC, 0xA8, 0xA8, 0xA8, 0xFD,
0xA8, 0xA8, 0xA8, 0xFE, 0xA8, 0xA8, 0xA8, 0xFF, 0xA6, 0xA6, 0xA6, 0xFF, 0xA9, 0xA9, 0xA9, 0xFF, 0xB7, 0xB7, 0xB7, 0xFF, 0xA1, 0x9C, 0x9B, 0xFF, 0x8A, 0x53, 0x3F, 0xFF, 0xCB, 0x7B, 0x32, 0xFF, 0xE0, 0xA2, 0x40, 0xFF, 0xEF, 0xC7, 0x4C, 0xFF,
0xF4, 0xD3, 0x50, 0xFF, 0xF6, 0xD7, 0x52, 0xFF, 0xF7, 0xDA, 0x53, 0xFF, 0xF8, 0xDC, 0x53, 0xFF, 0xF9, 0xDD, 0x54, 0xFF, 0xF9, 0xDC, 0x53, 0xFF, 0xF8, 0xDB, 0x53, 0xFF, 0xF6, 0xD8, 0x52, 0xFF, 0xF5, 0xD5, 0x51, 0xFF, 0xF1, 0xCC, 0x4E, 0xFF,
0xE7, 0xB4, 0x46, 0xFF, 0xCD, 0x84, 0x35, 0xFF, 0x98, 0x5C, 0x3E, 0xFF, 0xAA, 0xAA, 0xAA, 0xFF, 0xB6, 0xB6, 0xB6, 0xFF, 0xA5, 0xA5, 0xA5, 0xF8, 0x80, 0x80, 0x80, 0x71, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x75, 0x75, 0x75, 0x1E, 0xAB, 0xAB, 0xAB, 0xB0, 0xC4, 0xC4, 0xC4, 0xEC, 0xCE, 0xCE, 0xCE, 0xFE,
0xCB, 0xCB, 0xCB, 0xFF, 0xC6, 0xC6, 0xC6, 0xFF, 0xCE, 0xCE, 0xCE, 0xFF, 0xC8, 0xC8, 0xC8, 0xF6, 0xB7, 0xB7, 0xB7, 0xD4, 0x98, 0x98, 0x98, 0x7B, 0x8B, 0x8B, 0x8B, 0x45, 0x8B, 0x8B, 0x8B, 0x43, 0x9A, 0x9A, 0x9A, 0x86, 0xA5, 0xA5, 0xA5, 0xE8,
0xA7, 0xA7, 0xA7, 0xFE, 0xAE, 0xAE, 0xAE, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0x9E, 0x93, 0x92, 0xFF, 0x8F, 0x51, 0x35, 0xFF, 0xCD, 0x7F, 0x33, 0xFF, 0xE0, 0xA1, 0x3F, 0xFF, 0xED, 0xC4, 0x4C, 0xFF, 0xF3, 0xD2, 0x50, 0xFF, 0xF5, 0xD6, 0x51, 0xFF,
0xF6, 0xD8, 0x52, 0xFF, 0xF7, 0xD9, 0x52, 0xFF, 0xF7, 0xDA, 0x53, 0xFF, 0xF7, 0xD9, 0x52, 0xFF, 0xF7, 0xD8, 0x52, 0xFF, 0xF5, 0xD6, 0x51, 0xFF, 0xF4, 0xD4, 0x51, 0xFF, 0xF0, 0xC9, 0x4D, 0xFF, 0xE7, 0xB2, 0x45, 0xFF, 0xD1, 0x89, 0x37, 0xFF,
0x98, 0x53, 0x2D, 0xFF, 0xAA, 0xA9, 0xA9, 0xFF, 0xB8, 0xB8, 0xB8, 0xFF, 0xAE, 0xAE, 0xAE, 0xFC, 0x87, 0x87, 0x87, 0x94, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x88, 0x88, 0x88, 0x1A, 0x9E, 0x9E, 0x9E, 0x57, 0xAF, 0xAF, 0xAF, 0xA7, 0xB6, 0xB6, 0xB6, 0xCF, 0xB9, 0xB9, 0xB9, 0xD6,
0xB2, 0xB2, 0xB2, 0xBC, 0xA6, 0xA6, 0xA6, 0x74, 0x91, 0x91, 0x91, 0x30, 0x67, 0x67, 0x67, 0x05, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x6B, 0x6B, 0x6B, 0x08, 0x93, 0x93, 0x93, 0x71, 0xA5, 0xA5, 0xA5, 0xED, 0xB1, 0xB1, 0xB1, 0xFF,
0xBD, 0xBD, 0xBD, 0xFF, 0x9E, 0x92, 0x90, 0xFF, 0x8C, 0x4E, 0x32, 0xFF, 0xCA, 0x7A, 0x32, 0xFF, 0xDD, 0x9C, 0x3D, 0xFF, 0xEB, 0xBC, 0x49, 0xFF, 0xF2, 0xCE, 0x4F, 0xFF, 0xF4, 0xD4, 0x51, 0xFF, 0xF5, 0xD6, 0x51, 0xFF, 0xF6, 0xD7, 0x52, 0xFF,
0xF6, 0xD8, 0x52, 0xFF, 0xF6, 0xD8, 0x52, 0xFF, 0xF5, 0xD6, 0x52, 0xFF, 0xF5, 0xD4, 0x51, 0xFF, 0xF3, 0xD2, 0x50, 0xFF, 0xED, 0xC2, 0x4B, 0xFF, 0xE4, 0xAB, 0x43, 0xFF, 0xCE, 0x84, 0x35, 0xFF, 0x96, 0x4F, 0x2A, 0xFF, 0xA8, 0xA6, 0xA5, 0xFF,
0xB9, 0xB9, 0xB9, 0xFF, 0xB1, 0xB1, 0xB1, 0xFD, 0x8D, 0x8D, 0x8D, 0x9F, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x6C, 0x6C, 0x6C, 0x11, 0x9A, 0x9A, 0x9A, 0xAA, 0xB3, 0xB3, 0xB3, 0xFF, 0xC1, 0xC1, 0xC1, 0xFF, 0xA1, 0x97, 0x95, 0xFE,
0x8A, 0x4E, 0x34, 0xFE, 0xBD, 0x6C, 0x2C, 0xFF, 0xDA, 0x92, 0x3A, 0xFF, 0xE5, 0xAF, 0x44, 0xFF, 0xED, 0xC2, 0x4B, 0xFF, 0xF2, 0xD1, 0x50, 0xFF, 0xF4, 0xD5, 0x59, 0xFF, 0xF6, 0xDA, 0x65, 0xFF, 0xF7, 0xDB, 0x67, 0xFF, 0xF6, 0xDA, 0x63, 0xFF,
0xF5, 0xD6, 0x5A, 0xFF, 0xF3, 0xD1, 0x51, 0xFF, 0xF0, 0xCA, 0x4D, 0xFF, 0xE7, 0xB5, 0x46, 0xFF, 0xE0, 0xA0, 0x3F, 0xFF, 0xC4, 0x77, 0x30, 0xFF, 0x90, 0x4B, 0x2C, 0xFF, 0xAD, 0xAD, 0xAD, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0xB2, 0xB2, 0xB2, 0xFB,
0x8B, 0x8B, 0x8B, 0x8E, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x39, 0x39, 0x39, 0x02, 0x8E, 0x8E, 0x8E, 0x6F, 0xB3, 0xB3, 0xB3, 0xFE, 0xC5, 0xC5, 0xC5, 0xFF, 0xA9, 0xA4, 0xA4, 0xFE, 0x87, 0x53, 0x40, 0xFE, 0xAB, 0x5B, 0x25, 0xFF,
0xD2, 0x86, 0x36, 0xFF, 0xE0, 0xA3, 0x40, 0xFF, 0xE7, 0xB4, 0x46, 0xFF, 0xEF, 0xC9, 0x56, 0xFF, 0xF4, 0xD6, 0x68, 0xFF, 0xF6, 0xD9, 0x65, 0xFF, 0xF6, 0xD9, 0x60, 0xFF, 0xF6, 0xD9, 0x63, 0xFF, 0xF5, 0xD8, 0x66, 0xFF, 0xF0, 0xCC, 0x57, 0xFF,
0xEB, 0xBC, 0x49, 0xFF, 0xE2, 0xA8, 0x42, 0xFF, 0xDA, 0x95, 0x3B, 0xFF, 0xB3, 0x64, 0x29, 0xFF, 0x8F, 0x55, 0x3E, 0xFF, 0xB0, 0xB0, 0xB0, 0xFF, 0xC1, 0xC1, 0xC1, 0xFF, 0xB1, 0xB1, 0xB1, 0xF7, 0x8E, 0x8E, 0x8E, 0x6B, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x6F, 0x6F, 0x6F, 0x34, 0xB0, 0xB0, 0xB0, 0xFA, 0xC5, 0xC5, 0xC5, 0xFF, 0xBA, 0xBA, 0xBA, 0xFF, 0x8F, 0x6E, 0x67, 0xFF, 0x90, 0x44, 0x1D, 0xFF, 0xBC, 0x6B, 0x2C, 0xFF, 0xD9, 0x92, 0x3C, 0xFF,
0xE0, 0xA3, 0x45, 0xFF, 0xEB, 0xBF, 0x61, 0xFF, 0xEF, 0xCA, 0x65, 0xFF, 0xF1, 0xCD, 0x5A, 0xFF, 0xF1, 0xCD, 0x53, 0xFF, 0xF1, 0xCE, 0x58, 0xFF, 0xF0, 0xCC, 0x5F, 0xFF, 0xEC, 0xC1, 0x5E, 0xFF, 0xE4, 0xAD, 0x4C, 0xFF, 0xDB, 0x98, 0x40, 0xFF,
0xC9, 0x7D, 0x32, 0xFF, 0x98, 0x4E, 0x24, 0xFF, 0x97, 0x76, 0x6C, 0xFF, 0xB8, 0xB8, 0xB8, 0xFF, 0xC5, 0xC5, 0xC5, 0xFF, 0xAB, 0xAB, 0xAB, 0xE5, 0x89, 0x89, 0x89, 0x40, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x2A, 0x2A, 0x2A, 0x09, 0xA7, 0xA7, 0xA7, 0xDD, 0xC2, 0xC2, 0xC2, 0xFE, 0xC4, 0xC4, 0xC4, 0xFF, 0xA6, 0x9E, 0x9D, 0xFF, 0x82, 0x41, 0x27, 0xFF, 0x9D, 0x4F, 0x20, 0xFF, 0xCC, 0x7F, 0x38, 0xFF, 0xDC, 0x9A, 0x4A, 0xFF, 0xE8, 0xB7, 0x64, 0xFF,
0xED, 0xC5, 0x72, 0xFF, 0xEE, 0xC8, 0x6B, 0xFF, 0xEC, 0xC1, 0x55, 0xFF, 0xEF, 0xCA, 0x6F, 0xFF, 0xED, 0xC8, 0x72, 0xFF, 0xE8, 0xB8, 0x60, 0xFF, 0xE1, 0xA6, 0x55, 0xFF, 0xD0, 0x87, 0x3F, 0xFF, 0xAF, 0x61, 0x29, 0xFF, 0x8E, 0x50, 0x36, 0xFF,
0xA3, 0x97, 0x94, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0xC1, 0xC1, 0xC1, 0xFF, 0xA6, 0xA6, 0xA6, 0xC0, 0x7E, 0x7E, 0x7E, 0x1E, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x99, 0x99, 0x99, 0x77,
0xB5, 0xB5, 0xB5, 0xF6, 0xCD, 0xCD, 0xCD, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0x94, 0x79, 0x72, 0xFF, 0x84, 0x40, 0x23, 0xFF, 0xA2, 0x56, 0x28, 0xFF, 0xC2, 0x78, 0x3D, 0xFF, 0xDD, 0xA3, 0x5C, 0xFF, 0xE6, 0xB7, 0x72, 0xFF, 0xEA, 0xBE, 0x75, 0xFF,
0xE6, 0xB2, 0x58, 0xFF, 0xEB, 0xC3, 0x7E, 0xFF, 0xE8, 0xBC, 0x76, 0xFF, 0xDE, 0xA5, 0x5B, 0xFF, 0xCC, 0x88, 0x4A, 0xFF, 0xA7, 0x5B, 0x2A, 0xFF, 0x8E, 0x45, 0x22, 0xFF, 0x9B, 0x84, 0x7F, 0xFF, 0xB5, 0xB5, 0xB5, 0xFF, 0xA9, 0xA9, 0xA9, 0xFF,
0xB2, 0xB2, 0xB2, 0xFC, 0x96, 0x96, 0x96, 0x67, 0x18, 0x18, 0x18, 0x02, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x8F, 0x8F, 0x8F, 0x2C, 0xAB, 0xAB, 0xAB, 0xCB, 0xC6, 0xC6, 0xC6, 0xFF,
0xCD, 0xCD, 0xCD, 0xFF, 0xB1, 0xAD, 0xAC, 0xFF, 0x91, 0x6D, 0x64, 0xFF, 0x88, 0x40, 0x20, 0xFF, 0xA0, 0x5A, 0x32, 0xFF, 0xC0, 0x81, 0x4D, 0xFF, 0xD5, 0x9F, 0x65, 0xFF, 0xDF, 0xAC, 0x6E, 0xFF, 0xDB, 0xA1, 0x56, 0xFF, 0xE0, 0xB1, 0x74, 0xFF,
0xD8, 0xA2, 0x65, 0xFF, 0xC5, 0x88, 0x52, 0xFF, 0xAB, 0x66, 0x3A, 0xFF, 0x8D, 0x47, 0x27, 0xFF, 0x93, 0x6D, 0x61, 0xFF, 0xB4, 0xB2, 0xB2, 0xFF, 0xC9, 0xC9, 0xC9, 0xFF, 0xC5, 0xC5, 0xC5, 0xFF, 0xAB, 0xAB, 0xAB, 0xD4, 0x73, 0x73, 0x73, 0x18,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x3A, 0x3A, 0x3A, 0x01, 0x91, 0x91, 0x91, 0x49, 0xB5, 0xB5, 0xB5, 0xF0, 0xCB, 0xCB, 0xCB, 0xFF, 0xCD, 0xCD, 0xCD, 0xFF,
0xBB, 0xBB, 0xBB, 0xFF, 0x96, 0x7A, 0x75, 0xFF, 0x88, 0x50, 0x3C, 0xFF, 0x8E, 0x48, 0x28, 0xFF, 0xA7, 0x6A, 0x44, 0xFF, 0xBE, 0x8C, 0x66, 0xFF, 0xB8, 0x7F, 0x50, 0xFF, 0xC1, 0x92, 0x6D, 0xFF, 0xAD, 0x72, 0x4A, 0xFF, 0x93, 0x4F, 0x2E, 0xFF,
0x8B, 0x50, 0x39, 0xFF, 0x9D, 0x85, 0x80, 0xFF, 0xB6, 0xB5, 0xB4, 0xFF, 0xCD, 0xCD, 0xCD, 0xFF, 0xCD, 0xCD, 0xCD, 0xFF, 0xB5, 0xB5, 0xB5, 0xF7, 0x95, 0x95, 0x95, 0x69, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x62, 0x62, 0x62, 0x05, 0xA2, 0xA2, 0xA2, 0x82, 0xBA, 0xBA, 0xBA, 0xF3, 0xD0, 0xD0, 0xD0, 0xFF, 0xD3, 0xD3, 0xD3, 0xFF, 0xBF, 0xBE, 0xBE, 0xFF,
0xA8, 0x9E, 0x9D, 0xFF, 0x96, 0x76, 0x6E, 0xFF, 0x8B, 0x5A, 0x4A, 0xFF, 0x8C, 0x53, 0x3D, 0xFF, 0x8C, 0x4F, 0x34, 0xFF, 0x8E, 0x56, 0x41, 0xFF, 0x8D, 0x5A, 0x4A, 0xFF, 0x99, 0x7D, 0x75, 0xFF, 0xA7, 0x9C, 0x9A, 0xFF, 0xC0, 0xBF, 0xBF, 0xFF,
0xCF, 0xCF, 0xCF, 0xFF, 0xCF, 0xCF, 0xCF, 0xFF, 0xBE, 0xBE, 0xBE, 0xFF, 0xAD, 0xAD, 0xAD, 0xE4, 0x91, 0x91, 0x91, 0x40, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x6E, 0x6E, 0x6E, 0x09, 0x9E, 0x9E, 0x9E, 0x7D, 0xBA, 0xBA, 0xBA, 0xFC, 0xCB, 0xCB, 0xCB, 0xFF, 0xD6, 0xD6, 0xD6, 0xFF, 0xD2, 0xD2, 0xD2, 0xFF, 0xB4, 0xB4, 0xB4, 0xFF,
0xBA, 0xBA, 0xBA, 0xFF, 0xB5, 0xB2, 0xB2, 0xFF, 0xB2, 0xAE, 0xAE, 0xFF, 0xB6, 0xB3, 0xB3, 0xFF, 0xBC, 0xBB, 0xBB, 0xFF, 0xC5, 0xC5, 0xC5, 0xFF, 0xD1, 0xD1, 0xD1, 0xFF, 0xD5, 0xD5, 0xD5, 0xFF, 0xCD, 0xCD, 0xCD, 0xFF, 0xBA, 0xBA, 0xBA, 0xFF,
0xB5, 0xB5, 0xB5, 0xFF, 0xAE, 0xAE, 0xAE, 0xEA, 0x86, 0x86, 0x86, 0x4E, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x6B, 0x6B, 0x6B, 0x1D, 0xAB, 0xAB, 0xAB, 0xE3, 0xB8, 0xB8, 0xB8, 0xFF, 0xC6, 0xC6, 0xC6, 0xFF, 0xCE, 0xCE, 0xCE, 0xFF, 0xB7, 0xB7, 0xB7, 0xFF, 0xD2, 0xD2, 0xD2, 0xFF, 0xD5, 0xD5, 0xD5, 0xFF,
0xD5, 0xD5, 0xD5, 0xFF, 0xD5, 0xD5, 0xD5, 0xFF, 0xD6, 0xD6, 0xD6, 0xFF, 0xD8, 0xD8, 0xD8, 0xFF, 0xD3, 0xD3, 0xD3, 0xFF, 0xC4, 0xC4, 0xC4, 0xFF, 0xBA, 0xBA, 0xBA, 0xFF, 0xB6, 0xB6, 0xB6, 0xFF, 0xB7, 0xB7, 0xB7, 0xFF, 0xB5, 0xB5, 0xB5, 0xFC,
0x8B, 0x8B, 0x8B, 0x8C, 0x04, 0x04, 0x04, 0x03, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x00, 0x00, 0x00, 0x04, 0x9E, 0x9E, 0x9E, 0xC1, 0xB9, 0xB9, 0xB9, 0xFF, 0xB6, 0xB6, 0xB6, 0xFF, 0xB7, 0xB7, 0xB7, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xC4, 0xC4, 0xC4, 0xFF, 0xCA, 0xCA, 0xCA, 0xFE, 0xCC, 0xCC, 0xCC, 0xFD, 0xC9, 0xC9, 0xC9, 0xF7,
0xC4, 0xC4, 0xC4, 0xEE, 0xBB, 0xBB, 0xBB, 0xE5, 0xB5, 0xB5, 0xB5, 0xE9, 0xB5, 0xB5, 0xB5, 0xFB, 0xB8, 0xB8, 0xB8, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xAD, 0xAD, 0xAD, 0xF1, 0x69, 0x69, 0x69, 0x4F,
0x29, 0x29, 0x29, 0x08, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x08, 0xA0, 0xA0, 0xA0, 0xCD,
0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB8, 0xB8, 0xB8, 0xFF, 0xB7, 0xB7, 0xB7, 0xFB, 0xAD, 0xAD, 0xAD, 0xC1, 0xAB, 0xAB, 0xAB, 0x87, 0xA8, 0xA8, 0xA8, 0x6C, 0xA7, 0xA7, 0xA7, 0x54, 0xA0, 0xA0, 0xA0, 0x3F,
0xA3, 0xA3, 0xA3, 0x48, 0xAA, 0xAA, 0xAA, 0x96, 0xB5, 0xB5, 0xB5, 0xED, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xB9, 0xB9, 0xB9, 0xFE, 0xA2, 0xA2, 0xA2, 0xD2, 0x6E, 0x6E, 0x6E, 0x6A, 0x25, 0x25, 0x25, 0x19,
0x00, 0x00, 0x00, 0x04, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x5B, 0x5B, 0x5B, 0x3C, 0xB3, 0xB3, 0xB3, 0xF1, 0xBB, 0xBB, 0xBB, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF,
0xBB, 0xBB, 0xBB, 0xFF, 0xB8, 0xB8, 0xB8, 0xF1, 0xA6, 0xA6, 0xA6, 0x82, 0x5D, 0x5D, 0x5D, 0x08, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x64, 0x64, 0x64, 0x05,
0x99, 0x99, 0x99, 0x59, 0xB8, 0xB8, 0xB8, 0xF5, 0xBB, 0xBB, 0xBB, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xBA, 0xBA, 0xBA, 0xFD, 0xA0, 0xA0, 0xA0, 0xD9, 0x86, 0x86, 0x86, 0x97, 0x56, 0x56, 0x56, 0x2A,
0x00, 0x00, 0x00, 0x02, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x41, 0x41, 0x41, 0x24, 0x96, 0x96, 0x96, 0xAB, 0xBA, 0xBA, 0xBA, 0xFE, 0xBC, 0xBC, 0xBC, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0xAE, 0xAE, 0xAE, 0xB8,
0x7D, 0x7D, 0x7D, 0x19, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x4C, 0x4C, 0x4C, 0x05, 0xA9, 0xA9, 0xA9, 0xAA,
0xBB, 0xBB, 0xBB, 0xFC, 0xBD, 0xBD, 0xBD, 0xFF, 0xB8, 0xB8, 0xB8, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xBB, 0xBC, 0xBD, 0xFF, 0xBE, 0xBE, 0xBE, 0xFF, 0xBC, 0xBC, 0xBC, 0xFC, 0x9D, 0x9D, 0x9D, 0xB9, 0x67, 0x67, 0x67, 0x2F, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x2F, 0x2F, 0x2F, 0x0E, 0x52, 0x52, 0x52, 0x2C, 0x70, 0x70, 0x70, 0x59,
0x7C, 0x7C, 0x7C, 0x84, 0xA0, 0xA0, 0xA0, 0xD8, 0xBA, 0xBA, 0xBA, 0xFC, 0xBD, 0xBD, 0xBD, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xBD, 0xBD, 0xBD, 0xFE, 0x98, 0x98, 0x98, 0x6C, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x93, 0x93, 0x93, 0x4D, 0xB7, 0xB7, 0xB7, 0xED, 0xBE, 0xBF, 0xBF, 0xFF,
0x8E, 0xA2, 0xAC, 0xFE, 0x36, 0xA4, 0xC4, 0xFE, 0x1A, 0xB5, 0xD8, 0xFE, 0x35, 0xAB, 0xC8, 0xFE, 0x85, 0xAB, 0xB9, 0xFF, 0xBD, 0xBD, 0xBD, 0xFD, 0x9C, 0x9C, 0x9C, 0xAC, 0x23, 0x23, 0x23, 0x08, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x0C, 0x0C, 0x0C, 0x04, 0x3E, 0x3E, 0x3E, 0x32, 0x8D, 0x8D, 0x8D, 0x99, 0xA4, 0xA4, 0xA4, 0xD0, 0xAB, 0xAB, 0xAB, 0xED, 0xB1, 0xB1, 0xB1, 0xF8, 0xB8, 0xB8, 0xB8, 0xFE,
0xB8, 0xB8, 0xB8, 0xFF, 0xBB, 0xBB, 0xBB, 0xFF, 0xBE, 0xBE, 0xBE, 0xFF, 0xBE, 0xBE, 0xBE, 0xFF, 0xBD, 0xBD, 0xBD, 0xFE, 0x8E, 0x8E, 0x8E, 0x53, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x89, 0x89, 0x89, 0x41, 0xB3, 0xB3, 0xB3, 0xE5, 0xAF, 0xB4, 0xB9, 0xFF, 0x40, 0xA1, 0xC4, 0xFE, 0x00, 0xCF, 0xF5, 0xFF,
0x00, 0xDA, 0xFD, 0xFF, 0x01, 0xD5, 0xF9, 0xFF, 0x21, 0xB0, 0xD4, 0xFE, 0xB0, 0xB4, 0xB8, 0xFE, 0xB0, 0xB0, 0xB0, 0xEA, 0x5B, 0x5B, 0x5B, 0x21, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0x3D, 0x3D, 0x3D, 0x11, 0x83, 0x83, 0x83, 0x86, 0xAE, 0xAE, 0xAE, 0xEB, 0xBC, 0xBC, 0xBC, 0xFF, 0xBE, 0xBE, 0xBE, 0xFF, 0xC5, 0xC5, 0xC5, 0xFF, 0xC6, 0xC6, 0xC6, 0xFF, 0xC6, 0xC6, 0xC6, 0xFF, 0xC5, 0xC5, 0xC5, 0xFF, 0xB6, 0xB6, 0xB6, 0xFF,
0xAE, 0xAE, 0xAE, 0xFF, 0xBD, 0xBD, 0xBD, 0xFF, 0xBF, 0xBF, 0xBF, 0xFF, 0x92, 0x92, 0x92, 0x85, 0x1F, 0x1F, 0x1F, 0x07, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x8A, 0x8A, 0x8A, 0x42, 0xAF, 0xAF, 0xAF, 0xE6, 0x90, 0xA4, 0xAF, 0xFF, 0x16, 0xA1, 0xCD, 0xFF, 0x03, 0xD3, 0xF8, 0xFF, 0x09, 0xDB, 0xFA, 0xFF, 0x02, 0xD7, 0xFA, 0xFF,
0x02, 0xBF, 0xEA, 0xFE, 0x8F, 0xA6, 0xB2, 0xFE, 0xB9, 0xB9, 0xB9, 0xFE, 0x82, 0x82, 0x82, 0x38, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x3E, 0x3E, 0x3E, 0x10, 0x86, 0x86, 0x86, 0x7B, 0xB6, 0xB6, 0xB6, 0xF4,
0xC2, 0xC2, 0xC2, 0xFE, 0xC7, 0xC7, 0xC7, 0xFF, 0xCA, 0xCA, 0xCA, 0xFF, 0xBF, 0xB8, 0xBF, 0xFF, 0xBE, 0xAF, 0xBD, 0xFF, 0xBD, 0xAC, 0xBB, 0xFF, 0xBD, 0xB4, 0xBD, 0xFE, 0xBC, 0xBB, 0xBC, 0xFF, 0xB9, 0xB9, 0xB9, 0xFF, 0xC4, 0xC4, 0xC4, 0xFF,
0xBF, 0xBF, 0xBF, 0xFF, 0xAA, 0xAA, 0xAA, 0xCF, 0x67, 0x67, 0x67, 0x33, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0x90, 0x90, 0x90, 0x3B, 0xAD, 0xAD, 0xAD, 0xE1, 0x93, 0xA0, 0xA9, 0xFE, 0x1F, 0x93, 0xBF, 0xFE, 0x14, 0xCB, 0xED, 0xFF, 0x23, 0xDB, 0xEB, 0xFF, 0x15, 0xD2, 0xEF, 0xFF, 0x0A,
0xAF, 0xDC, 0xFF, 0x92, 0xA2, 0xAC, 0xFF, 0xB4, 0xB4, 0xB4, 0xFB, 0x82, 0x82, 0x82, 0x31, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x89, 0x89, 0x89, 0x78, 0xB8, 0xB8, 0xB8, 0xF1, 0xC8, 0xC8, 0xC8, 0xFF, 0xCC,
0xCC, 0xCC, 0xFF, 0xBA, 0xA5, 0xBA, 0xFF, 0xB1, 0x6E, 0xAE, 0xFF, 0xC3, 0x50, 0xBF, 0xFF, 0xD4, 0x56, 0xCF, 0xFF, 0xD9, 0x5B, 0xD4, 0xFF, 0xCD, 0x55, 0xC8, 0xFE, 0xB8, 0x65, 0xB5, 0xFF, 0xB7, 0x92, 0xB5, 0xFF, 0xC9, 0xC7, 0xC8, 0xFF, 0xCB,
0xCB, 0xCB, 0xFF, 0xC0, 0xC0, 0xC0, 0xFD, 0x9D, 0x9D, 0x9D, 0xB7, 0x43, 0x43, 0x43, 0x12, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0x8A, 0x8A, 0x8A, 0x18, 0xA9, 0xA9, 0xA9, 0xB2, 0xA7, 0xA9, 0xAA, 0xFE, 0x61, 0x87, 0x9E, 0xFE, 0x37, 0xA1, 0xC4, 0xFF, 0x51, 0xC1, 0xD6, 0xFF, 0x41, 0xAE, 0xCC, 0xFF, 0x4E, 0x90, 0xAC, 0xFF, 0xAA, 0xAA, 0xAB, 0xFE, 0xA8,
0xA8, 0xA8, 0xC5, 0x67, 0x67, 0x67, 0x0D, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x3B, 0x3B, 0x3B, 0x1E, 0xB0, 0xB0, 0xB0, 0xE0, 0xC8, 0xC8, 0xC8, 0xFE, 0xCE, 0xCE, 0xCE, 0xFF, 0xB5, 0xA0, 0xB5, 0xFF, 0xB8, 0x4D, 0xB4, 0xFF, 0xDF,
0x56, 0xDA, 0xFF, 0xF4, 0x79, 0xEF, 0xFF, 0xF8, 0x91, 0xF4, 0xFF, 0xF9, 0x99, 0xF6, 0xFF, 0xF7, 0x87, 0xF3, 0xFF, 0xEC, 0x68, 0xE8, 0xFF, 0xD0, 0x53, 0xCB, 0xFF, 0xAE, 0x83, 0xAC, 0xFF, 0xC9, 0xC6, 0xC8, 0xFF, 0xCC, 0xCC, 0xCC, 0xFF, 0xBF,
0xBF, 0xBF, 0xF9, 0x82, 0x82, 0x82, 0x5F, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x5A, 0x5A, 0x5A, 0x03, 0x9C,
0x9C, 0x9C, 0x47, 0xA7, 0xA7, 0xA7, 0xF0, 0x9F, 0xA1, 0xA4, 0xFF, 0x7C, 0x92, 0x9F, 0xFF, 0x70, 0x93, 0xA3, 0xFF, 0x7A, 0x92, 0x9F, 0xFF, 0x90, 0x97, 0x9B, 0xFF, 0xA7, 0xA7, 0xA7, 0xED, 0x9D, 0x9D, 0x9D, 0x62, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0x37, 0x37, 0x37, 0x06, 0x94, 0x94, 0x94, 0x7E, 0xC7, 0xC7, 0xC7, 0xFE, 0xD1, 0xD1, 0xD1, 0xFF, 0xB8, 0xA6, 0xB7, 0xFF, 0xAD, 0x46, 0xAA, 0xFF, 0xE6, 0x58, 0xE1, 0xFF, 0xF4, 0x75, 0xF0, 0xFF, 0xF9, 0x97, 0xF6, 0xFF, 0xFB,
0xAE, 0xF8, 0xFF, 0xFC, 0xB7, 0xFA, 0xFF, 0xFA, 0xA3, 0xF7, 0xFF, 0xF7, 0x84, 0xF3, 0xFF, 0xF1, 0x6A, 0xEC, 0xFF, 0xC8, 0x4B, 0xC5, 0xFF, 0xAE, 0x83, 0xAD, 0xFF, 0xD0, 0xD0, 0xD0, 0xFF, 0xCC, 0xCC, 0xCC, 0xFF, 0xAD, 0xAD, 0xAD, 0xBE, 0x6B,
0x6B, 0x6B, 0x1F, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xA0, 0xA0, 0xA0, 0x52, 0xA3,
0xA3, 0xA3, 0xC0, 0xA2, 0xA2, 0xA2, 0xF3, 0xA2, 0xA2, 0xA2, 0xF8, 0xA3, 0xA3, 0xA3, 0xF3, 0xA4, 0xA4, 0xA4, 0xD5, 0xA0, 0xA0, 0xA0, 0x51, 0x69, 0x69, 0x69, 0x04, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x61, 0x61, 0x61, 0x17, 0xB0,
0xB0, 0xB0, 0xBA, 0xCF, 0xCF, 0xCF, 0xFF, 0xD1, 0xD1, 0xD1, 0xFF, 0xA0, 0x69, 0x9F, 0xFF, 0xC6, 0x3F, 0xC2, 0xFF, 0xEE, 0x64, 0xE9, 0xFF, 0xF6, 0x7D, 0xF2, 0xFF, 0xF9, 0x99, 0xF6, 0xFF, 0xFA, 0xA8, 0xF7, 0xFF, 0xFB, 0xAD, 0xF9, 0xFF, 0xFA,
0xA2, 0xF7, 0xFF, 0xF7, 0x8B, 0xF4, 0xFF, 0xF5, 0x74, 0xF0, 0xFF, 0xDF, 0x52, 0xDB, 0xFF, 0xA9, 0x49, 0xA8, 0xFF, 0xC7, 0xC4, 0xC7, 0xFF, 0xD4, 0xD4, 0xD4, 0xFF, 0xBB, 0xBB, 0xBB, 0xE6, 0x89, 0x89, 0x89, 0x44, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x81, 0x81, 0x81, 0x04, 0x9A, 0x9A, 0x9A, 0x20, 0xA4, 0xA4, 0xA4, 0x5A, 0xA6,
0xA6, 0xA6, 0x70, 0xA6, 0xA6, 0xA6, 0x5B, 0xA1, 0xA1, 0xA1, 0x30, 0x70, 0x70, 0x70, 0x04, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x81, 0x81, 0x81, 0x35, 0xBA, 0xBA, 0xBA, 0xDB, 0xD7, 0xD7, 0xD7, 0xFF, 0xC8,
0xC4, 0xC8, 0xFF, 0x93, 0x36, 0x93, 0xFF, 0xD8, 0x48, 0xD4, 0xFF, 0xF0, 0x68, 0xEB, 0xFF, 0xF6, 0x7C, 0xF2, 0xFF, 0xF8, 0x90, 0xF4, 0xFF, 0xF9, 0x9A, 0xF6, 0xFF, 0xFA, 0x9D, 0xF6, 0xFF, 0xF9, 0x96, 0xF5, 0xFF, 0xF7, 0x86, 0xF3, 0xFF, 0xF6,
0x74, 0xF1, 0xFF, 0xE8, 0x59, 0xE3, 0xFF, 0xBC, 0x3B, 0xBA, 0xFF, 0xB0, 0x9C, 0xB0, 0xFF, 0xD5, 0xD5, 0xD5, 0xFF, 0xCB, 0xCB, 0xCB, 0xF8, 0x99, 0x99, 0x99, 0x70, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x96, 0x96, 0x96, 0x40, 0xC2, 0xC2, 0xC2, 0xE4, 0xD8, 0xD8, 0xD8, 0xFF, 0xC1, 0xBA, 0xC2, 0xFF, 0x91, 0x27, 0x92, 0xFF, 0xDB,
0x4A, 0xD6, 0xFF, 0xEF, 0x64, 0xEA, 0xFF, 0xF5, 0x76, 0xF1, 0xFF, 0xF7, 0x86, 0xF3, 0xFF, 0xF8, 0x8D, 0xF4, 0xFF, 0xF9, 0x90, 0xF5, 0xFF, 0xF8, 0x8B, 0xF4, 0xFF, 0xF7, 0x7E, 0xF2, 0xFF, 0xF5, 0x70, 0xF0, 0xFF, 0xE6, 0x58, 0xE1, 0xFF, 0xC1,
0x3B, 0xBF, 0xFF, 0xA1, 0x7F, 0xA2, 0xFF, 0xD5, 0xD5, 0xD5, 0xFF, 0xD0, 0xD0, 0xD0, 0xFB, 0x9E, 0x9E, 0x9E, 0x89, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x9A, 0x9A, 0x9A, 0x3F, 0xC5, 0xC5, 0xC5, 0xE4, 0xDB, 0xDB, 0xDB, 0xFF, 0xC1, 0xBA, 0xC1, 0xFF, 0x89, 0x23, 0x8B, 0xFF, 0xD4, 0x43, 0xCF, 0xFF, 0xE9, 0x5B, 0xE4, 0xFF, 0xF3,
0x6A, 0xEE, 0xFF, 0xF6, 0x7A, 0xF2, 0xFF, 0xF7, 0x84, 0xF3, 0xFF, 0xF7, 0x85, 0xF4, 0xFF, 0xF6, 0x7F, 0xF2, 0xFF, 0xF5, 0x72, 0xF0, 0xFF, 0xF0, 0x65, 0xEB, 0xFF, 0xE1, 0x51, 0xDC, 0xFF, 0xB7, 0x35, 0xB6, 0xFF, 0x9F, 0x7B, 0x9F, 0xFF, 0xD7,
0xD7, 0xD7, 0xFF, 0xD3, 0xD3, 0xD3, 0xFB, 0xA2, 0xA2, 0xA2, 0x89, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0x93, 0x93, 0x93, 0x33, 0xC5, 0xC5, 0xC5, 0xDA, 0xD7, 0xD7, 0xD7, 0xFF, 0xC5, 0xC0, 0xC5, 0xFF, 0x7F, 0x2B, 0x81, 0xFF, 0xC3, 0x3A, 0xC1, 0xFF, 0xE2, 0x52, 0xDD, 0xFF, 0xEC, 0x60, 0xE7, 0xFF, 0xF5, 0x7A, 0xF1, 0xFF, 0xF6,
0x7C, 0xF3, 0xFF, 0xF6, 0x79, 0xF4, 0xFF, 0xF5, 0x7B, 0xF3, 0xFF, 0xF1, 0x69, 0xEC, 0xFF, 0xE9, 0x5B, 0xE4, 0xFF, 0xD7, 0x47, 0xD3, 0xFF, 0xA1, 0x2C, 0xA3, 0xFF, 0xAF, 0x99, 0xAF, 0xFF, 0xD9, 0xD9, 0xD9, 0xFF, 0xD4, 0xD4, 0xD4, 0xF7, 0xA7,
0xA7, 0xA7, 0x6B, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x7B, 0x7B, 0x7B, 0x13, 0xBF,
0xBF, 0xBF, 0xB5, 0xBB, 0xBB, 0xBB, 0xFF, 0xC6, 0xC6, 0xC6, 0xFF, 0x8D, 0x5F, 0x8F, 0xFF, 0x95, 0x27, 0x98, 0xFF, 0xD5, 0x47, 0xD2, 0xFF, 0xE4, 0x5F, 0xE0, 0xFF, 0xEE, 0x76, 0xEB, 0xFF, 0xF0, 0x6D, 0xEE, 0xFF, 0xF0, 0x67, 0xEE, 0xFF, 0xEF,
0x71, 0xED, 0xFF, 0xE9, 0x69, 0xE5, 0xFF, 0xE0, 0x56, 0xDB, 0xFF, 0xB7, 0x35, 0xB5, 0xFF, 0x88, 0x35, 0x8A, 0xFF, 0xC7, 0xC3, 0xC7, 0xFF, 0xE0, 0xE0, 0xE0, 0xFF, 0xCD, 0xCD, 0xCD, 0xE6, 0xA0, 0xA0, 0xA0, 0x42, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x5D, 0x5D, 0x5D, 0x05, 0xAD, 0xAD, 0xAD, 0x7A, 0xD7, 0xD7, 0xD7, 0xFE, 0xDF,
0xDF, 0xDF, 0xFF, 0xB0, 0x9E, 0xB0, 0xFF, 0x78, 0x2E, 0x7D, 0xFF, 0xAF, 0x36, 0xAF, 0xFF, 0xD9, 0x5A, 0xD5, 0xFF, 0xE9, 0x7B, 0xE7, 0xFF, 0xEB, 0x79, 0xE9, 0xFF, 0xEA, 0x72, 0xE9, 0xFF, 0xEB, 0x80, 0xEA, 0xFF, 0xE1, 0x66, 0xDE, 0xFF, 0xC8,
0x4A, 0xC5, 0xFF, 0x8C, 0x29, 0x8F, 0xFF, 0x9C, 0x72, 0x9C, 0xFF, 0xD8, 0xD8, 0xD8, 0xFF, 0xE2, 0xE2, 0xE2, 0xFF, 0xC3, 0xC3, 0xC3, 0xBD, 0x90, 0x90, 0x90, 0x1D, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x65, 0x65, 0x65, 0x15, 0xCC, 0xCC, 0xCC, 0xDF, 0xE4, 0xE4, 0xE4, 0xFE, 0xDB, 0xDB, 0xDB, 0xFF, 0xAA,
0x96, 0xAB, 0xFF, 0x78, 0x31, 0x7D, 0xFF, 0x96, 0x3B, 0x9A, 0xFF, 0xC8, 0x61, 0xC9, 0xFF, 0xD8, 0x6F, 0xD7, 0xFF, 0xD9, 0x6A, 0xD8, 0xFF, 0xD1, 0x6A, 0xD1, 0xFF, 0xAE, 0x49, 0xAF, 0xFF, 0x87, 0x30, 0x8C, 0xFF, 0x95, 0x6D, 0x96, 0xFF, 0xC7,
0xC3, 0xC7, 0xFF, 0xE6, 0xE6, 0xE6, 0xFF, 0xD9, 0xD9, 0xD9, 0xF8, 0xAC, 0xAC, 0xAC, 0x58, 0x20, 0x20, 0x20, 0x01, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xB6, 0xB6, 0xB6, 0x72, 0xD9, 0xD9, 0xD9, 0xF0, 0xE7, 0xE7, 0xE7, 0xFF, 0xD9, 0xD8, 0xD9, 0xFF, 0xA9, 0x94, 0xAA, 0xFF, 0x87,
0x54, 0x8A, 0xFF, 0x84, 0x39, 0x89, 0xFF, 0x9C, 0x51, 0xA0, 0xFF, 0x9F, 0x4F, 0xA3, 0xFF, 0x90, 0x42, 0x94, 0xFF, 0x83, 0x43, 0x87, 0xFF, 0x9D, 0x7A, 0x9E, 0xFF, 0xC4, 0xC0, 0xC4, 0xFF, 0xBC, 0xBC, 0xBC, 0xFF, 0xDC, 0xDC, 0xDC, 0xFD, 0xC4,
0xC4, 0xC4, 0xB4, 0x7C, 0x7C, 0x7C, 0x0E, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x8D, 0x8D, 0x8D, 0x0B, 0xBB, 0xBB, 0xBB, 0x75, 0xDE, 0xDE, 0xDE, 0xF3, 0xEA, 0xEA, 0xEA, 0xFF, 0xE2, 0xE2, 0xE2, 0xFF, 0xD2, 0xD2, 0xD2, 0xFF, 0xBD, 0xB0, 0xBD, 0xFF, 0xB0,
0x9F, 0xB1, 0xFF, 0xAA, 0x96, 0xAB, 0xFF, 0xB8, 0xA9, 0xB8, 0xFF, 0xCC, 0xC9, 0xCB, 0xFF, 0xDB, 0xDB, 0xDB, 0xFF, 0xE8, 0xE8, 0xE8, 0xFF, 0xD4, 0xD4, 0xD4, 0xFD, 0xC6, 0xC6, 0xC6, 0xAF, 0x9E, 0x9E, 0x9E, 0x24, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x8D, 0x8D, 0x8D, 0x0A,
0xBF, 0xBF, 0xBF, 0x79, 0xD7, 0xD7, 0xD7, 0xE5, 0xE9, 0xE9, 0xE9, 0xFF, 0xED, 0xED, 0xED, 0xFF, 0xE6, 0xE6, 0xE6, 0xFF, 0xE4, 0xE4, 0xE4, 0xFF, 0xE4, 0xE4, 0xE4, 0xFF, 0xE4, 0xE4, 0xE4, 0xFF, 0xEB, 0xEB, 0xEB, 0xFF, 0xEC, 0xEC, 0xEC, 0xFF,
0xDE, 0xDE, 0xDE, 0xF6, 0xC9, 0xC9, 0xC9, 0xAD, 0xA3, 0xA3, 0xA3, 0x23, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x69, 0x69, 0x69, 0x02, 0xA2, 0xA2, 0xA2, 0x25,
0xC7, 0xC7, 0xC7, 0x8E, 0xD6, 0xD6, 0xD6, 0xC8, 0xE0, 0xE0, 0xE0, 0xEC, 0xE5, 0xE5, 0xE5, 0xF4, 0xE5, 0xE5, 0xE5, 0xF5, 0xE2, 0xE2, 0xE2, 0xF1, 0xD9, 0xD9, 0xD9, 0xD7, 0xCE, 0xCE, 0xCE, 0xAB, 0xB1, 0xB1, 0xB1, 0x44, 0x89, 0x89, 0x89, 0x0A,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x96, 0x96, 0x96, 0x0A,
0xB5, 0xB5, 0xB5, 0x22, 0xBD, 0xBD, 0xBD, 0x47, 0xC3, 0xC3, 0xC3, 0x58, 0xC4, 0xC4, 0xC4, 0x5C, 0xBF, 0xBF, 0xBF, 0x4E, 0xB8, 0xB8, 0xB8, 0x2F, 0xA6, 0xA6, 0xA6, 0x13, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0x00
};
/*************************** End of file ****************************/
|
the_stack_data/92327169.c | #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
#define MSGSZ 128
/*
* Declare the message structure.
*/
typedef struct msgbuf {
long mtype;
char mtext[MSGSZ];
} message_buf;
int main(){
int msqid;
int msgflg = IPC_CREAT | 0666;
key_t key;
message_buf sbuf,rbuf;
size_t buf_length;
key = 1234;
if ((msqid = msgget(key, msgflg )) < 0) {
perror("msgget");
exit(1);
}
while(1){
sbuf.mtype = 1;
printf("\nEnter Message '***' to close connection:");
gets(&sbuf.mtext);
if(strcmp(sbuf.mtext,"***")==0){
strcpy(sbuf.mtext,"\nConnection closed by Other User");
buf_length = strlen(sbuf.mtext) + 1 ;
if (msgsnd(msqid, &sbuf, buf_length, IPC_NOWAIT) < 0) {
printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buf_length);
perror("msgsnd");
exit(1);
}
printf("\nClosing Connection");
break;
}
buf_length = strlen(sbuf.mtext) + 1 ;
if (msgsnd(msqid, &sbuf, buf_length, IPC_NOWAIT) < 0) {
printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buf_length);
perror("msgsnd");
exit(1);
}
else
printf("\nProcess 1:%s", sbuf.mtext);
if (msgrcv(msqid, &rbuf, MSGSZ, 2, 0) < 0) {
perror("msgrcv");
exit(1);
}
else
printf("\nProcess 2:%s", rbuf.mtext);
}
exit(0);
} |
the_stack_data/124283.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main()
{
int num1 , num2, total;
float avg;
printf("Enter first number :");
scanf("%d", &num1);
printf("Enter first number :");
scanf("%d", &num2);
total = num1 + num2;
printf("Total is : %d\n", total);
avg = total / 3;
printf("Aveage is : %.2f",avg);
return 0;
}
|
the_stack_data/816519.c | int cut(int);
int f(int n) {
int i = 0;
while (++i < cut(n) + 1) {
int j = i + 1;
cut(0);
int k = j + cut(j);
cut(k);
}
return 1 + cut(i);
}
|
the_stack_data/126701995.c | #include<stdio.h>
#include<string.h>
#include <stdlib.h>
char table[4][4]={'0','>','>','>',
'<','>','<','>',
'<','>','>','>',
'<','<','<','0'};
char tab_ordr[4]={'i','+','*','$'};
char stack[100];
int stkPtr=-1;
void push(char);
char pop();
char peek();
void error();
int preced(char,char);
int main(){
char str[20],temp,t[10];
int len,inp_ptr=0,prec,countOfI=0;
printf("Enter the expression:- ");
scanf("%s",str);
push('$');
len=strlen(str);
str[len]='$';
str[len+1]='\0';
while(str[inp_ptr]!='$' || peek()!='$')
{
if(str[inp_ptr]>='0'&&str[inp_ptr]<='9'){
while(str[inp_ptr]>='0' && str[inp_ptr]<='9')
inp_ptr++;
str[--inp_ptr]='i';
}
prec=preced(peek(),str[inp_ptr]);
if(prec==0){
if(str[inp_ptr]=='i')
countOfI++;
else
countOfI--;
push(str[inp_ptr++]);
}
else if(prec==1){
do{
temp=pop();
}while(preced(peek(),temp)!=0);
}
else
error();
}
if(countOfI!=1)
error();
printf("Success\n",countOfI);
return 0;
}
void push(char a){
stack[++stkPtr]=a;
}
char pop(){
return stack[stkPtr--];
}
char peek(){
return stack[stkPtr];
}
void error(){
printf("Error\n");
exit(1);
}
int preced(char a,char b)
{
int i,j;
for(i=0;i<4;i++){
if(tab_ordr[i]==a)
break;
}
for(j=0;j<4;j++){
if(tab_ordr[j]==b)
break;
}
if(i==4 || j==4)
error();
else{
if(table[i][j]=='<')
return 0;
else if(table[i][j]=='>')
return 1;
else
return 2;
}
}
|
the_stack_data/187641857.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2017 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation nor the names of its contributors may be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
END_LEGAL */
#include <stdio.h>
#include <stdlib.h>
unsigned int sleep(unsigned int seconds) {
fprintf(stderr, "ERROR: In deepbind_syscalls.c implementation of sleep\n");
exit(3);
}
|
the_stack_data/90762415.c | // BUG: corrupted list in corrupted (2)
// https://syzkaller.appspot.com/bug?id=12e0059f3a711f4312e9b7a8899cda91eab9b6e8
// status:invalid
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/futex.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/usb/ch9.h>
#include <linux/veth.h>
unsigned long long procid;
static __thread int skip_segv;
static __thread jmp_buf segv_env;
static void segv_handler(int sig, siginfo_t* info, void* ctx)
{
uintptr_t addr = (uintptr_t)info->si_addr;
const uintptr_t prog_start = 1 << 20;
const uintptr_t prog_end = 100 << 20;
if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
(addr < prog_start || addr > prog_end)) {
_longjmp(segv_env, 1);
}
exit(sig);
}
static void install_segv_handler(void)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = segv_handler;
sa.sa_flags = SA_NODEFER | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
}
#define NONFAILING(...) \
{ \
__atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \
if (_setjmp(segv_env) == 0) { \
__VA_ARGS__; \
} \
__atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \
}
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static void use_temporary_dir(void)
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
exit(1);
if (chmod(tmpdir, 0777))
exit(1);
if (chdir(tmpdir))
exit(1);
}
static void thread_start(void* (*fn)(void*), void* arg)
{
pthread_t th;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
int i;
for (i = 0; i < 100; i++) {
if (pthread_create(&th, &attr, fn, arg) == 0) {
pthread_attr_destroy(&attr);
return;
}
if (errno == EAGAIN) {
usleep(50);
continue;
}
break;
}
exit(1);
}
typedef struct {
int state;
} event_t;
static void event_init(event_t* ev)
{
ev->state = 0;
}
static void event_reset(event_t* ev)
{
ev->state = 0;
}
static void event_set(event_t* ev)
{
if (ev->state)
exit(1);
__atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG);
}
static void event_wait(event_t* ev)
{
while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}
static int event_isset(event_t* ev)
{
return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}
static int event_timedwait(event_t* ev, uint64_t timeout)
{
uint64_t start = current_time_ms();
uint64_t now = start;
for (;;) {
uint64_t remain = timeout - (now - start);
struct timespec ts;
ts.tv_sec = remain / 1000;
ts.tv_nsec = (remain % 1000) * 1000 * 1000;
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
if (__atomic_load_n(&ev->state, __ATOMIC_RELAXED))
return 1;
now = current_time_ms();
if (now - start > timeout)
return 0;
}
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static struct {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
} nlmsg;
static void netlink_init(int typ, int flags, const void* data, int size)
{
memset(&nlmsg, 0, sizeof(nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg.pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(int typ, const void* data, int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg.pos += NLMSG_ALIGN(attr->nla_len);
}
static void netlink_nest(int typ)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_type = typ;
nlmsg.pos += sizeof(*attr);
nlmsg.nested[nlmsg.nesting++] = attr;
}
static void netlink_done(void)
{
struct nlattr* attr = nlmsg.nested[--nlmsg.nesting];
attr->nla_len = nlmsg.pos - (char*)attr;
}
static int netlink_send(int sock)
{
if (nlmsg.pos > nlmsg.buf + sizeof(nlmsg.buf) || nlmsg.nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_len = nlmsg.pos - nlmsg.buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg.buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg.buf, sizeof(nlmsg.buf), 0);
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static void netlink_add_device_impl(const char* type, const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
if (name)
netlink_attr(IFLA_IFNAME, name, strlen(name));
netlink_nest(IFLA_LINKINFO);
netlink_attr(IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(int sock, const char* type, const char* name)
{
netlink_add_device_impl(type, name);
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_veth(int sock, const char* name, const char* peer)
{
netlink_add_device_impl("veth", name);
netlink_nest(IFLA_INFO_DATA);
netlink_nest(VETH_INFO_PEER);
nlmsg.pos += sizeof(struct ifinfomsg);
netlink_attr(IFLA_IFNAME, peer, strlen(peer));
netlink_done();
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_hsr(int sock, const char* name, const char* slave1,
const char* slave2)
{
netlink_add_device_impl("hsr", name);
netlink_nest(IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_device_change(int sock, const char* name, bool up,
const char* master, const void* mac,
int macsize)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
netlink_init(RTM_NEWLINK, 0, &hdr, sizeof(hdr));
netlink_attr(IFLA_IFNAME, name, strlen(name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(IFLA_ADDRESS, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int netlink_add_addr(int sock, const char* dev, const void* addr,
int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, sizeof(hdr));
netlink_attr(IFA_LOCAL, addr, addrsize);
netlink_attr(IFA_ADDRESS, addr, addrsize);
return netlink_send(sock);
}
static void netlink_add_addr4(int sock, const char* dev, const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(int sock, const char* dev, const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(int sock, const char* name, const void* addr,
int addrsize, const void* mac, int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
netlink_attr(NDA_DST, addr, addrsize);
netlink_attr(NDA_LLADDR, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int tunfd = -1;
static int tun_frags_enabled;
#define SYZ_TUN_MAX_PACKET_SIZE 1000
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
#define IFF_NAPI_FRAGS 0x0020
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_NAPI | IFF_NAPI_FRAGS;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0)
exit(1);
}
if (ioctl(tunfd, TUNGETIFF, (void*)&ifr) < 0)
exit(1);
tun_frags_enabled = (ifr.ifr_flags & IFF_NAPI_FRAGS) != 0;
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(sock, TUN_IFACE, &in_addr, sizeof(in_addr), &macaddr,
ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(sock, TUN_IFACE, &in6_addr, sizeof(in6_addr), &macaddr,
ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN);
close(sock);
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa
static void initialize_netdevices(void)
{
char netdevsim[16];
sprintf(netdevsim, "netdevsim%d", (int)procid);
struct {
const char* type;
const char* dev;
} devtypes[] = {
{"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
{"vcan", "vcan0"}, {"bond", "bond0"},
{"team", "team0"}, {"dummy", "dummy0"},
{"nlmon", "nlmon0"}, {"caif", "caif0"},
{"batadv", "batadv0"}, {"vxcan", "vxcan1"},
{"netdevsim", netdevsim}, {"veth", 0},
};
const char* devmasters[] = {"bridge", "bond", "team"};
struct {
const char* name;
int macsize;
bool noipv6;
} devices[] = {
{"lo", ETH_ALEN},
{"sit0", 0},
{"bridge0", ETH_ALEN},
{"vcan0", 0, true},
{"tunl0", 0},
{"gre0", 0},
{"gretap0", ETH_ALEN},
{"ip_vti0", 0},
{"ip6_vti0", 0},
{"ip6tnl0", 0},
{"ip6gre0", 0},
{"ip6gretap0", ETH_ALEN},
{"erspan0", ETH_ALEN},
{"bond0", ETH_ALEN},
{"veth0", ETH_ALEN},
{"veth1", ETH_ALEN},
{"team0", ETH_ALEN},
{"veth0_to_bridge", ETH_ALEN},
{"veth1_to_bridge", ETH_ALEN},
{"veth0_to_bond", ETH_ALEN},
{"veth1_to_bond", ETH_ALEN},
{"veth0_to_team", ETH_ALEN},
{"veth1_to_team", ETH_ALEN},
{"veth0_to_hsr", ETH_ALEN},
{"veth1_to_hsr", ETH_ALEN},
{"hsr0", 0},
{"dummy0", ETH_ALEN},
{"nlmon0", 0},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
};
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
netlink_add_device(sock, devtypes[i].type, devtypes[i].dev);
for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
sprintf(slave0, "%s_slave_0", devmasters[i]);
sprintf(veth0, "veth0_to_%s", devmasters[i]);
netlink_add_veth(sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(sock, slave0, false, master, 0, 0);
netlink_device_change(sock, slave1, false, master, 0, 0);
}
netlink_device_change(sock, "bridge_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "bridge_slave_1", true, 0, 0, 0);
netlink_add_veth(sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(sock, "hsr_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "hsr_slave_1", true, 0, 0, 0);
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize);
}
close(sock);
}
static void initialize_netdevices_init(void)
{
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
struct {
const char* type;
int macsize;
bool noipv6;
bool noup;
} devtypes[] = {
{"nr", 7, true},
{"rose", 5, true, true},
};
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
char dev[32], addr[32];
sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
netlink_add_addr4(sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
netlink_add_addr6(sock, dev, addr);
}
int macsize = devtypes[i].macsize;
uint64_t macaddr = 0xbbbbbb +
((unsigned long long)i << (8 * (macsize - 2))) +
(procid << (8 * (macsize - 1)));
netlink_device_change(sock, dev, !devtypes[i].noup, 0, &macaddr, macsize);
}
close(sock);
}
static int read_tun(char* data, int size)
{
if (tunfd < 0)
return -1;
int rv = read(tunfd, data, size);
if (rv < 0) {
if (errno == EAGAIN)
return -1;
if (errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[SYZ_TUN_MAX_PACKET_SIZE];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
#define USB_MAX_EP_NUM 32
struct usb_device_index {
struct usb_device_descriptor* dev;
struct usb_config_descriptor* config;
unsigned config_length;
struct usb_interface_descriptor* iface;
struct usb_endpoint_descriptor* eps[USB_MAX_EP_NUM];
unsigned eps_num;
};
static bool parse_usb_descriptor(char* buffer, size_t length,
struct usb_device_index* index)
{
if (length <
sizeof(*index->dev) + sizeof(*index->config) + sizeof(*index->iface))
return false;
index->dev = (struct usb_device_descriptor*)buffer;
index->config = (struct usb_config_descriptor*)(buffer + sizeof(*index->dev));
index->config_length = length - sizeof(*index->dev);
index->iface =
(struct usb_interface_descriptor*)(buffer + sizeof(*index->dev) +
sizeof(*index->config));
index->eps_num = 0;
size_t offset = 0;
while (true) {
if (offset == length)
break;
if (offset + 1 < length)
break;
uint8_t length = buffer[offset];
uint8_t type = buffer[offset + 1];
if (type == USB_DT_ENDPOINT) {
index->eps[index->eps_num] =
(struct usb_endpoint_descriptor*)(buffer + offset);
index->eps_num++;
}
if (index->eps_num == USB_MAX_EP_NUM)
break;
offset += length;
}
return true;
}
enum usb_fuzzer_event_type {
USB_FUZZER_EVENT_INVALID,
USB_FUZZER_EVENT_CONNECT,
USB_FUZZER_EVENT_DISCONNECT,
USB_FUZZER_EVENT_SUSPEND,
USB_FUZZER_EVENT_RESUME,
USB_FUZZER_EVENT_CONTROL,
};
struct usb_fuzzer_event {
uint32_t type;
uint32_t length;
char data[0];
};
struct usb_fuzzer_init {
uint64_t speed;
const char* driver_name;
const char* device_name;
};
struct usb_fuzzer_ep_io {
uint16_t ep;
uint16_t flags;
uint32_t length;
char data[0];
};
#define USB_FUZZER_IOCTL_INIT _IOW('U', 0, struct usb_fuzzer_init)
#define USB_FUZZER_IOCTL_RUN _IO('U', 1)
#define USB_FUZZER_IOCTL_EP0_READ _IOWR('U', 2, struct usb_fuzzer_event)
#define USB_FUZZER_IOCTL_EP0_WRITE _IOW('U', 3, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_EP_ENABLE _IOW('U', 4, struct usb_endpoint_descriptor)
#define USB_FUZZER_IOCTL_EP_WRITE _IOW('U', 6, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_CONFIGURE _IO('U', 8)
#define USB_FUZZER_IOCTL_VBUS_DRAW _IOW('U', 9, uint32_t)
int usb_fuzzer_open()
{
return open("/sys/kernel/debug/usb-fuzzer", O_RDWR);
}
int usb_fuzzer_init(int fd, uint32_t speed, const char* driver,
const char* device)
{
struct usb_fuzzer_init arg;
arg.speed = speed;
arg.driver_name = driver;
arg.device_name = device;
return ioctl(fd, USB_FUZZER_IOCTL_INIT, &arg);
}
int usb_fuzzer_run(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_RUN, 0);
}
int usb_fuzzer_ep0_read(int fd, struct usb_fuzzer_event* event)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_READ, event);
}
int usb_fuzzer_ep0_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_WRITE, io);
}
int usb_fuzzer_ep_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_WRITE, io);
}
int usb_fuzzer_ep_enable(int fd, struct usb_endpoint_descriptor* desc)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_ENABLE, desc);
}
int usb_fuzzer_configure(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_CONFIGURE, 0);
}
int usb_fuzzer_vbus_draw(int fd, uint32_t power)
{
return ioctl(fd, USB_FUZZER_IOCTL_VBUS_DRAW, power);
}
#define USB_MAX_PACKET_SIZE 1024
struct usb_fuzzer_control_event {
struct usb_fuzzer_event inner;
struct usb_ctrlrequest ctrl;
};
struct usb_fuzzer_ep_io_data {
struct usb_fuzzer_ep_io inner;
char data[USB_MAX_PACKET_SIZE];
};
struct vusb_connect_string_descriptor {
uint32_t len;
char* str;
} __attribute__((packed));
struct vusb_connect_descriptors {
uint32_t qual_len;
char* qual;
uint32_t bos_len;
char* bos;
uint32_t strs_len;
struct vusb_connect_string_descriptor strs[0];
} __attribute__((packed));
static volatile long syz_usb_connect(volatile long a0, volatile long a1,
volatile long a2, volatile long a3)
{
int64_t speed = a0;
int64_t dev_len = a1;
char* dev = (char*)a2;
struct vusb_connect_descriptors* conn_descs =
(struct vusb_connect_descriptors*)a3;
if (!dev)
return -1;
struct usb_device_index index;
memset(&index, 0, sizeof(index));
int rv = parse_usb_descriptor(dev, dev_len, &index);
if (!rv)
return -1;
int fd = usb_fuzzer_open();
if (fd < 0)
return -1;
char device[32];
sprintf(&device[0], "dummy_udc.%llu", procid);
rv = usb_fuzzer_init(fd, speed, "dummy_udc", &device[0]);
if (rv < 0)
return -1;
rv = usb_fuzzer_run(fd);
if (rv < 0)
return -1;
bool done = false;
while (!done) {
char* response_data = NULL;
uint32_t response_length = 0;
unsigned ep;
uint8_t str_idx;
struct usb_fuzzer_control_event event;
event.inner.type = 0;
event.inner.length = sizeof(event.ctrl);
rv = usb_fuzzer_ep0_read(fd, (struct usb_fuzzer_event*)&event);
if (rv < 0)
return -1;
if (event.inner.type != USB_FUZZER_EVENT_CONTROL)
continue;
switch (event.ctrl.bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD:
switch (event.ctrl.bRequest) {
case USB_REQ_GET_DESCRIPTOR:
switch (event.ctrl.wValue >> 8) {
case USB_DT_DEVICE:
response_data = (char*)index.dev;
response_length = sizeof(*index.dev);
goto reply;
case USB_DT_CONFIG:
response_data = (char*)index.config;
response_length = index.config_length;
goto reply;
case USB_DT_STRING:
str_idx = (uint8_t)event.ctrl.wValue;
if (str_idx >= conn_descs->strs_len)
goto reply;
response_data = conn_descs->strs[str_idx].str;
response_length = conn_descs->strs[str_idx].len;
goto reply;
case USB_DT_BOS:
response_data = conn_descs->bos;
response_length = conn_descs->bos_len;
goto reply;
case USB_DT_DEVICE_QUALIFIER:
response_data = conn_descs->qual;
response_length = conn_descs->qual_len;
goto reply;
default:
exit(1);
continue;
}
break;
case USB_REQ_SET_CONFIGURATION:
rv = usb_fuzzer_vbus_draw(fd, index.config->bMaxPower);
if (rv < 0)
return -1;
rv = usb_fuzzer_configure(fd);
if (rv < 0)
return -1;
for (ep = 0; ep < index.eps_num; ep++) {
rv = usb_fuzzer_ep_enable(fd, index.eps[ep]);
if (rv < 0)
exit(1);
}
done = true;
goto reply;
default:
exit(1);
continue;
}
break;
default:
exit(1);
continue;
}
struct usb_fuzzer_ep_io_data response;
reply:
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
if (event.ctrl.wLength < response.inner.length)
response.inner.length = event.ctrl.wLength;
usb_fuzzer_ep0_write(fd, (struct usb_fuzzer_ep_io*)&response);
}
sleep_ms(200);
return fd;
}
#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10
struct xt_counters {
uint64_t pcnt, bcnt;
};
struct ipt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_entries;
unsigned int size;
};
struct ipt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct ipt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct ipt_table_desc {
const char* name;
struct ipt_getinfo info;
struct ipt_replace replace;
};
static struct ipt_table_desc ipv4_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
static struct ipt_table_desc ipv6_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)
struct arpt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_entries;
unsigned int size;
};
struct arpt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct arpt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct arpt_table_desc {
const char* name;
struct arpt_getinfo info;
struct arpt_replace replace;
};
static struct arpt_table_desc arpt_tables[] = {
{.name = "filter"},
};
#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)
static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct ipt_get_entries entries;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct ipt_get_entries entries;
struct ipt_getinfo info;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_arptables(void)
{
struct arpt_get_entries entries;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_arptables()
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct arpt_get_entries entries;
struct arpt_getinfo info;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
} else {
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
#define NF_BR_NUMHOOKS 6
#define EBT_TABLE_MAXNAMELEN 32
#define EBT_CHAIN_MAXNAMELEN 32
#define EBT_BASE_CTL 128
#define EBT_SO_SET_ENTRIES (EBT_BASE_CTL)
#define EBT_SO_GET_INFO (EBT_BASE_CTL)
#define EBT_SO_GET_ENTRIES (EBT_SO_GET_INFO + 1)
#define EBT_SO_GET_INIT_INFO (EBT_SO_GET_ENTRIES + 1)
#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO + 1)
struct ebt_replace {
char name[EBT_TABLE_MAXNAMELEN];
unsigned int valid_hooks;
unsigned int nentries;
unsigned int entries_size;
struct ebt_entries* hook_entry[NF_BR_NUMHOOKS];
unsigned int num_counters;
struct ebt_counter* counters;
char* entries;
};
struct ebt_entries {
unsigned int distinguisher;
char name[EBT_CHAIN_MAXNAMELEN];
unsigned int counter_offset;
int policy;
unsigned int nentries;
char data[0] __attribute__((aligned(__alignof__(struct ebt_replace))));
};
struct ebt_table_desc {
const char* name;
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
};
static struct ebt_table_desc ebt_tables[] = {
{.name = "filter"},
{.name = "nat"},
{.name = "broute"},
};
static void checkpoint_ebtables(void)
{
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
strcpy(table->replace.name, table->name);
optlen = sizeof(table->replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_INFO, &table->replace,
&optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->replace.entries_size > sizeof(table->entrytable))
exit(1);
table->replace.num_counters = 0;
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_ENTRIES, &table->replace,
&optlen))
exit(1);
}
close(fd);
}
static void reset_ebtables()
{
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
socklen_t optlen;
unsigned i, j, h;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
if (table->replace.valid_hooks == 0)
continue;
memset(&replace, 0, sizeof(replace));
strcpy(replace.name, table->name);
optlen = sizeof(replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
exit(1);
replace.num_counters = 0;
table->replace.entries = 0;
for (h = 0; h < NF_BR_NUMHOOKS; h++)
table->replace.hook_entry[h] = 0;
if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
memset(&entrytable, 0, sizeof(entrytable));
replace.entries = entrytable;
optlen = sizeof(replace) + replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_ENTRIES, &replace, &optlen))
exit(1);
if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
continue;
}
for (j = 0, h = 0; h < NF_BR_NUMHOOKS; h++) {
if (table->replace.valid_hooks & (1 << h)) {
table->replace.hook_entry[h] =
(struct ebt_entries*)table->entrytable + j;
j++;
}
}
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_net_namespace(void)
{
checkpoint_ebtables();
checkpoint_arptables();
checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void reset_net_namespace(void)
{
reset_ebtables();
reset_arptables();
reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void setup_cgroups()
{
if (mkdir("/syzcgroup", 0777)) {
}
if (mkdir("/syzcgroup/unified", 0777)) {
}
if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
}
if (chmod("/syzcgroup/unified", 0777)) {
}
write_file("/syzcgroup/unified/cgroup.subtree_control",
"+cpu +memory +io +pids +rdma");
if (mkdir("/syzcgroup/cpu", 0777)) {
}
if (mount("none", "/syzcgroup/cpu", "cgroup", 0,
"cpuset,cpuacct,perf_event,hugetlb")) {
}
write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
if (chmod("/syzcgroup/cpu", 0777)) {
}
if (mkdir("/syzcgroup/net", 0777)) {
}
if (mount("none", "/syzcgroup/net", "cgroup", 0,
"net_cls,net_prio,devices,freezer")) {
}
if (chmod("/syzcgroup/net", 0777)) {
}
}
static void setup_cgroups_loop()
{
int pid = getpid();
char file[128];
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/pids.max", cgroupdir);
write_file(file, "32");
snprintf(file, sizeof(file), "%s/memory.low", cgroupdir);
write_file(file, "%d", 298 << 20);
snprintf(file, sizeof(file), "%s/memory.high", cgroupdir);
write_file(file, "%d", 299 << 20);
snprintf(file, sizeof(file), "%s/memory.max", cgroupdir);
write_file(file, "%d", 300 << 20);
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
}
static void setup_cgroups_test()
{
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.cpu")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.net")) {
}
}
static void setup_binfmt_misc()
{
if (mount(0, "/proc/sys/fs/binfmt_misc", "binfmt_misc", 0, 0)) {
}
write_file("/proc/sys/fs/binfmt_misc/register", ":syz0:M:0:\x01::./file0:");
write_file("/proc/sys/fs/binfmt_misc/register",
":syz1:M:1:\x02::./file0:POC");
}
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
setup_cgroups();
setup_binfmt_misc();
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = (200 << 20);
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
initialize_netdevices();
loop();
exit(1);
}
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
DIR* dp;
struct dirent* ep;
int iter = 0;
retry:
while (umount2(dir, MNT_DETACH) == 0) {
}
dp = opendir(dir);
if (dp == NULL) {
if (errno == EMFILE) {
exit(1);
}
exit(1);
}
while ((ep = readdir(dp))) {
if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
continue;
char filename[FILENAME_MAX];
snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
while (umount2(filename, MNT_DETACH) == 0) {
}
struct stat st;
if (lstat(filename, &st))
exit(1);
if (S_ISDIR(st.st_mode)) {
remove_dir(filename);
continue;
}
int i;
for (i = 0;; i++) {
if (unlink(filename) == 0)
break;
if (errno == EPERM) {
int fd = open(filename, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno != EBUSY || i > 100)
exit(1);
if (umount2(filename, MNT_DETACH))
exit(1);
}
}
closedir(dp);
int i;
for (i = 0;; i++) {
if (rmdir(dir) == 0)
break;
if (i < 100) {
if (errno == EPERM) {
int fd = open(dir, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno == EBUSY) {
if (umount2(dir, MNT_DETACH))
exit(1);
continue;
}
if (errno == ENOTEMPTY) {
if (iter < 100) {
iter++;
goto retry;
}
}
}
exit(1);
}
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
#define SYZ_HAVE_SETUP_LOOP 1
static void setup_loop()
{
setup_cgroups_loop();
checkpoint_net_namespace();
}
#define SYZ_HAVE_RESET_LOOP 1
static void reset_loop()
{
reset_net_namespace();
}
#define SYZ_HAVE_SETUP_TEST 1
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setup_cgroups_test();
write_file("/proc/self/oom_score_adj", "1000");
flush_tun();
}
#define SYZ_HAVE_CLOSE_FDS 1
static void close_fds()
{
int fd;
for (fd = 3; fd < 30; fd++)
close(fd);
}
struct thread_t {
int created, call;
event_t ready, done;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
event_wait(&th->ready);
event_reset(&th->ready);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
event_set(&th->done);
}
return 0;
}
static void execute_one(void)
{
int i, call, thread;
int collide = 0;
again:
for (call = 0; call < 1; call++) {
for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
event_init(&th->ready);
event_init(&th->done);
event_set(&th->done);
thread_start(thr, th);
}
if (!event_isset(&th->done))
continue;
event_reset(&th->done);
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
event_set(&th->ready);
if (collide && (call % 2) == 0)
break;
event_timedwait(&th->done, 45);
break;
}
}
for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
sleep_ms(1);
close_fds();
if (!collide) {
collide = 1;
goto again;
}
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
setup_loop();
int iter;
for (iter = 0;; iter++) {
char cwdbuf[32];
sprintf(cwdbuf, "./%d", iter);
if (mkdir(cwdbuf, 0777))
exit(1);
reset_loop();
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
if (chdir(cwdbuf))
exit(1);
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
remove_dir(cwdbuf);
}
}
void execute_call(int call)
{
switch (call) {
case 0:
NONFAILING(*(uint8_t*)0x20000000 = 0x12);
NONFAILING(*(uint8_t*)0x20000001 = 1);
NONFAILING(*(uint16_t*)0x20000002 = 0);
NONFAILING(*(uint8_t*)0x20000004 = 0xb0);
NONFAILING(*(uint8_t*)0x20000005 = 0xf7);
NONFAILING(*(uint8_t*)0x20000006 = 0x87);
NONFAILING(*(uint8_t*)0x20000007 = 8);
NONFAILING(*(uint16_t*)0x20000008 = 0xe41);
NONFAILING(*(uint16_t*)0x2000000a = 0x4151);
NONFAILING(*(uint16_t*)0x2000000c = 0x7a8f);
NONFAILING(*(uint8_t*)0x2000000e = 0);
NONFAILING(*(uint8_t*)0x2000000f = 0);
NONFAILING(*(uint8_t*)0x20000010 = 0);
NONFAILING(*(uint8_t*)0x20000011 = 1);
NONFAILING(*(uint8_t*)0x20000012 = 9);
NONFAILING(*(uint8_t*)0x20000013 = 2);
NONFAILING(*(uint16_t*)0x20000014 = 0x12);
NONFAILING(*(uint8_t*)0x20000016 = 1);
NONFAILING(*(uint8_t*)0x20000017 = 0);
NONFAILING(*(uint8_t*)0x20000018 = 0);
NONFAILING(*(uint8_t*)0x20000019 = 0);
NONFAILING(*(uint8_t*)0x2000001a = 0);
NONFAILING(*(uint8_t*)0x2000001b = 9);
NONFAILING(*(uint8_t*)0x2000001c = 4);
NONFAILING(*(uint8_t*)0x2000001d = 0);
NONFAILING(*(uint8_t*)0x2000001e = 2);
NONFAILING(*(uint8_t*)0x2000001f = 0);
NONFAILING(*(uint8_t*)0x20000020 = 0xd6);
NONFAILING(*(uint8_t*)0x20000021 = 0x36);
NONFAILING(*(uint8_t*)0x20000022 = 0x16);
NONFAILING(*(uint8_t*)0x20000023 = 0);
syz_usb_connect(7, 0x24, 0x20000000, 0);
break;
}
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
install_segv_handler();
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
use_temporary_dir();
do_sandbox_none();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/1213375.c | #include <stdio.h>
int main() {
int i, num;
int j;
printf("Enter the number: ");
scanf("%d", &num);
for(i = 1; i < num; i++) {
j *= i;
}
printf("The factorial of %d is %d\n", num, j);
return 0;
} |
the_stack_data/50137918.c | // Copyright 2011 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be found in the AUTHORS file in the root of the source tree.
// -----------------------------------------------------------------------------
//
// Simple OpenGL-based WebP file viewer.
//
// Author: Skal ([email protected])
#ifdef HAVE_CONFIG_H
#include "webp/config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(WEBP_HAVE_GL)
#if defined(HAVE_GLUT_GLUT_H)
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#ifdef FREEGLUT
#include <GL/freeglut.h>
#endif
#endif
#ifdef WEBP_HAVE_QCMS
#include <qcms.h>
#endif
#include "webp/decode.h"
#include "webp/demux.h"
#include "./example_util.h"
#if defined(_MSC_VER) && _MSC_VER < 1900
#define snprintf _snprintf
#endif
// Unfortunate global variables. Gathered into a struct for comfort.
static struct {
int has_animation;
int has_color_profile;
int done;
int decoding_error;
int print_info;
int use_color_profile;
int canvas_width, canvas_height;
int loop_count;
uint32_t bg_color;
const char* file_name;
WebPData data;
WebPDecoderConfig config;
const WebPDecBuffer* pic;
WebPDemuxer* dmux;
WebPIterator curr_frame;
WebPIterator prev_frame;
WebPChunkIterator iccp;
} kParams;
static void ClearPreviousPic(void) {
WebPFreeDecBuffer((WebPDecBuffer*)kParams.pic);
kParams.pic = NULL;
}
static void ClearParams(void) {
ClearPreviousPic();
WebPDataClear(&kParams.data);
WebPDemuxReleaseIterator(&kParams.curr_frame);
WebPDemuxReleaseIterator(&kParams.prev_frame);
WebPDemuxReleaseChunkIterator(&kParams.iccp);
WebPDemuxDelete(kParams.dmux);
kParams.dmux = NULL;
}
// Sets the previous frame to the dimensions of the canvas and has it dispose
// to background to cause the canvas to be cleared.
static void ClearPreviousFrame(void) {
WebPIterator* const prev = &kParams.prev_frame;
prev->width = kParams.canvas_width;
prev->height = kParams.canvas_height;
prev->x_offset = prev->y_offset = 0;
prev->dispose_method = WEBP_MUX_DISPOSE_BACKGROUND;
}
// -----------------------------------------------------------------------------
// Color profile handling
static int ApplyColorProfile(const WebPData* const profile,
WebPDecBuffer* const rgba) {
#ifdef WEBP_HAVE_QCMS
int i, ok = 0;
uint8_t* line;
uint8_t major_revision;
qcms_profile* input_profile = NULL;
qcms_profile* output_profile = NULL;
qcms_transform* transform = NULL;
const qcms_data_type input_type = QCMS_DATA_RGBA_8;
const qcms_data_type output_type = QCMS_DATA_RGBA_8;
const qcms_intent intent = QCMS_INTENT_DEFAULT;
if (profile == NULL || rgba == NULL) return 0;
if (profile->bytes == NULL || profile->size < 10) return 1;
major_revision = profile->bytes[8];
qcms_enable_iccv4();
input_profile = qcms_profile_from_memory(profile->bytes, profile->size);
// qcms_profile_is_bogus() is broken with ICCv4.
if (input_profile == NULL ||
(major_revision < 4 && qcms_profile_is_bogus(input_profile))) {
fprintf(stderr, "Color profile is bogus!\n");
goto Error;
}
output_profile = qcms_profile_sRGB();
if (output_profile == NULL) {
fprintf(stderr, "Error creating output color profile!\n");
goto Error;
}
qcms_profile_precache_output_transform(output_profile);
transform = qcms_transform_create(input_profile, input_type,
output_profile, output_type,
intent);
if (transform == NULL) {
fprintf(stderr, "Error creating color transform!\n");
goto Error;
}
line = rgba->u.RGBA.rgba;
for (i = 0; i < rgba->height; ++i, line += rgba->u.RGBA.stride) {
qcms_transform_data(transform, line, line, rgba->width);
}
ok = 1;
Error:
if (input_profile != NULL) qcms_profile_release(input_profile);
if (output_profile != NULL) qcms_profile_release(output_profile);
if (transform != NULL) qcms_transform_release(transform);
return ok;
#else
(void)profile;
(void)rgba;
return 1;
#endif // WEBP_HAVE_QCMS
}
//------------------------------------------------------------------------------
// File decoding
static int Decode(void) { // Fills kParams.curr_frame
const WebPIterator* const curr = &kParams.curr_frame;
WebPDecoderConfig* const config = &kParams.config;
WebPDecBuffer* const output_buffer = &config->output;
int ok = 0;
ClearPreviousPic();
output_buffer->colorspace = MODE_RGBA;
ok = (WebPDecode(curr->fragment.bytes, curr->fragment.size,
config) == VP8_STATUS_OK);
if (!ok) {
fprintf(stderr, "Decoding of frame #%d failed!\n", curr->frame_num);
} else {
kParams.pic = output_buffer;
if (kParams.use_color_profile) {
ok = ApplyColorProfile(&kParams.iccp.chunk, output_buffer);
if (!ok) {
fprintf(stderr, "Applying color profile to frame #%d failed!\n",
curr->frame_num);
}
}
}
return ok;
}
static void decode_callback(int what) {
if (what == 0 && !kParams.done) {
int duration = 0;
if (kParams.dmux != NULL) {
WebPIterator* const curr = &kParams.curr_frame;
if (!WebPDemuxNextFrame(curr)) {
WebPDemuxReleaseIterator(curr);
if (WebPDemuxGetFrame(kParams.dmux, 1, curr)) {
--kParams.loop_count;
kParams.done = (kParams.loop_count == 0);
if (kParams.done) return;
ClearPreviousFrame();
} else {
kParams.decoding_error = 1;
kParams.done = 1;
return;
}
}
duration = curr->duration;
}
if (!Decode()) {
kParams.decoding_error = 1;
kParams.done = 1;
} else {
glutPostRedisplay();
glutTimerFunc(duration, decode_callback, what);
}
}
}
//------------------------------------------------------------------------------
// Callbacks
static void HandleKey(unsigned char key, int pos_x, int pos_y) {
(void)pos_x;
(void)pos_y;
if (key == 'q' || key == 'Q' || key == 27 /* Esc */) {
#ifdef FREEGLUT
glutLeaveMainLoop();
#else
ClearParams();
exit(0);
#endif
} else if (key == 'c') {
if (kParams.has_color_profile && !kParams.decoding_error) {
kParams.use_color_profile = 1 - kParams.use_color_profile;
if (kParams.has_animation) {
// Restart the completed animation to pickup the color profile change.
if (kParams.done && kParams.loop_count == 0) {
kParams.loop_count =
(int)WebPDemuxGetI(kParams.dmux, WEBP_FF_LOOP_COUNT) + 1;
kParams.done = 0;
// Start the decode loop immediately.
glutTimerFunc(0, decode_callback, 0);
}
} else {
Decode();
glutPostRedisplay();
}
}
} else if (key == 'i') {
kParams.print_info = 1 - kParams.print_info;
glutPostRedisplay();
}
}
static void HandleReshape(int width, int height) {
// TODO(skal): proper handling of resize, esp. for large pictures.
// + key control of the zoom.
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
static void PrintString(const char* const text) {
void* const font = GLUT_BITMAP_9_BY_15;
int i;
for (i = 0; text[i]; ++i) {
glutBitmapCharacter(font, text[i]);
}
}
static float GetColorf(uint32_t color, int shift) {
return (color >> shift) / 255.f;
}
static void DrawCheckerBoard(void) {
const int square_size = 8; // must be a power of 2
int x, y;
GLint viewport[4]; // x, y, width, height
glPushMatrix();
glGetIntegerv(GL_VIEWPORT, viewport);
// shift to integer coordinates with (0,0) being top-left.
glOrtho(0, viewport[2], viewport[3], 0, -1, 1);
for (y = 0; y < viewport[3]; y += square_size) {
for (x = 0; x < viewport[2]; x += square_size) {
const GLubyte color = 128 + 64 * (!((x + y) & square_size));
glColor3ub(color, color, color);
glRecti(x, y, x + square_size, y + square_size);
}
}
glPopMatrix();
}
static void HandleDisplay(void) {
const WebPDecBuffer* const pic = kParams.pic;
const WebPIterator* const curr = &kParams.curr_frame;
WebPIterator* const prev = &kParams.prev_frame;
GLfloat xoff, yoff;
if (pic == NULL) return;
glPushMatrix();
glPixelZoom(1, -1);
xoff = (GLfloat)(2. * curr->x_offset / kParams.canvas_width);
yoff = (GLfloat)(2. * curr->y_offset / kParams.canvas_height);
glRasterPos2f(-1.f + xoff, 1.f - yoff);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ROW_LENGTH, pic->u.RGBA.stride / 4);
if (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ||
curr->blend_method == WEBP_MUX_NO_BLEND) {
// TODO(later): these offsets and those above should factor in window size.
// they will be incorrect if the window is resized.
// glScissor() takes window coordinates (0,0 at bottom left).
int window_x, window_y;
int frame_w, frame_h;
if (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
// Clear the previous frame rectangle.
window_x = prev->x_offset;
window_y = kParams.canvas_height - prev->y_offset - prev->height;
frame_w = prev->width;
frame_h = prev->height;
} else { // curr->blend_method == WEBP_MUX_NO_BLEND.
// We simulate no-blending behavior by first clearing the current frame
// rectangle (to a checker-board) and then alpha-blending against it.
window_x = curr->x_offset;
window_y = kParams.canvas_height - curr->y_offset - curr->height;
frame_w = curr->width;
frame_h = curr->height;
}
glEnable(GL_SCISSOR_TEST);
// Only update the requested area, not the whole canvas.
glScissor(window_x, window_y, frame_w, frame_h);
glClear(GL_COLOR_BUFFER_BIT); // use clear color
DrawCheckerBoard();
glDisable(GL_SCISSOR_TEST);
}
*prev = *curr;
glDrawPixels(pic->width, pic->height,
GL_RGBA, GL_UNSIGNED_BYTE,
(GLvoid*)pic->u.RGBA.rgba);
if (kParams.print_info) {
char tmp[32];
glColor4f(0.90f, 0.0f, 0.90f, 1.0f);
glRasterPos2f(-0.95f, 0.90f);
PrintString(kParams.file_name);
snprintf(tmp, sizeof(tmp), "Dimension:%d x %d", pic->width, pic->height);
glColor4f(0.90f, 0.0f, 0.90f, 1.0f);
glRasterPos2f(-0.95f, 0.80f);
PrintString(tmp);
if (curr->x_offset != 0 || curr->y_offset != 0) {
snprintf(tmp, sizeof(tmp), " (offset:%d,%d)",
curr->x_offset, curr->y_offset);
glRasterPos2f(-0.95f, 0.70f);
PrintString(tmp);
}
}
glPopMatrix();
glFlush();
}
static void StartDisplay(void) {
const int width = kParams.canvas_width;
const int height = kParams.canvas_height;
glutInitDisplayMode(GLUT_RGBA);
glutInitWindowSize(width, height);
glutCreateWindow("WebP viewer");
glutDisplayFunc(HandleDisplay);
glutIdleFunc(NULL);
glutKeyboardFunc(HandleKey);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glClearColor(GetColorf(kParams.bg_color, 0),
GetColorf(kParams.bg_color, 8),
GetColorf(kParams.bg_color, 16),
GetColorf(kParams.bg_color, 24));
HandleReshape(width, height);
glClear(GL_COLOR_BUFFER_BIT);
DrawCheckerBoard();
}
//------------------------------------------------------------------------------
// Main
static void Help(void) {
printf("Usage: vwebp in_file [options]\n\n"
"Decodes the WebP image file and visualize it using OpenGL\n"
"Options are:\n"
" -version ..... print version number and exit\n"
" -noicc ....... don't use the icc profile if present\n"
" -nofancy ..... don't use the fancy YUV420 upscaler\n"
" -nofilter .... disable in-loop filtering\n"
" -dither <int> dithering strength (0..100), default=50\n"
" -noalphadither disable alpha plane dithering\n"
" -mt .......... use multi-threading\n"
" -info ........ print info\n"
" -h ........... this help message\n"
"\n"
"Keyboard shortcuts:\n"
" 'c' ................ toggle use of color profile\n"
" 'i' ................ overlay file information\n"
" 'q' / 'Q' / ESC .... quit\n"
);
}
int main(int argc, char *argv[]) {
int c;
WebPDecoderConfig* const config = &kParams.config;
WebPIterator* const curr = &kParams.curr_frame;
if (!WebPInitDecoderConfig(config)) {
fprintf(stderr, "Library version mismatch!\n");
return -1;
}
config->options.dithering_strength = 50;
config->options.alpha_dithering_strength = 100;
kParams.use_color_profile = 1;
for (c = 1; c < argc; ++c) {
int parse_error = 0;
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
Help();
return 0;
} else if (!strcmp(argv[c], "-noicc")) {
kParams.use_color_profile = 0;
} else if (!strcmp(argv[c], "-nofancy")) {
config->options.no_fancy_upsampling = 1;
} else if (!strcmp(argv[c], "-nofilter")) {
config->options.bypass_filtering = 1;
} else if (!strcmp(argv[c], "-noalphadither")) {
config->options.alpha_dithering_strength = 0;
} else if (!strcmp(argv[c], "-dither") && c + 1 < argc) {
config->options.dithering_strength =
ExUtilGetInt(argv[++c], 0, &parse_error);
} else if (!strcmp(argv[c], "-info")) {
kParams.print_info = 1;
} else if (!strcmp(argv[c], "-version")) {
const int dec_version = WebPGetDecoderVersion();
const int dmux_version = WebPGetDemuxVersion();
printf("WebP Decoder version: %d.%d.%d\nWebP Demux version: %d.%d.%d\n",
(dec_version >> 16) & 0xff, (dec_version >> 8) & 0xff,
dec_version & 0xff, (dmux_version >> 16) & 0xff,
(dmux_version >> 8) & 0xff, dmux_version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-mt")) {
config->options.use_threads = 1;
} else if (!strcmp(argv[c], "--")) {
if (c < argc - 1) kParams.file_name = argv[++c];
break;
} else if (argv[c][0] == '-') {
printf("Unknown option '%s'\n", argv[c]);
Help();
return -1;
} else {
kParams.file_name = argv[c];
}
if (parse_error) {
Help();
return -1;
}
}
if (kParams.file_name == NULL) {
printf("missing input file!!\n");
Help();
return 0;
}
if (!ExUtilReadFile(kParams.file_name,
&kParams.data.bytes, &kParams.data.size)) {
goto Error;
}
if (!WebPGetInfo(kParams.data.bytes, kParams.data.size, NULL, NULL)) {
fprintf(stderr, "Input file doesn't appear to be WebP format.\n");
goto Error;
}
kParams.dmux = WebPDemux(&kParams.data);
if (kParams.dmux == NULL) {
fprintf(stderr, "Could not create demuxing object!\n");
goto Error;
}
if (WebPDemuxGetI(kParams.dmux, WEBP_FF_FORMAT_FLAGS) & FRAGMENTS_FLAG) {
fprintf(stderr, "Image fragments are not supported for now!\n");
goto Error;
}
kParams.canvas_width = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_WIDTH);
kParams.canvas_height = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_HEIGHT);
if (kParams.print_info) {
printf("Canvas: %d x %d\n", kParams.canvas_width, kParams.canvas_height);
}
ClearPreviousFrame();
memset(&kParams.iccp, 0, sizeof(kParams.iccp));
kParams.has_color_profile =
!!(WebPDemuxGetI(kParams.dmux, WEBP_FF_FORMAT_FLAGS) & ICCP_FLAG);
if (kParams.has_color_profile) {
#ifdef WEBP_HAVE_QCMS
if (!WebPDemuxGetChunk(kParams.dmux, "ICCP", 1, &kParams.iccp)) goto Error;
printf("VP8X: Found color profile\n");
#else
fprintf(stderr, "Warning: color profile present, but qcms is unavailable!\n"
"Build libqcms from Mozilla or Chromium and define WEBP_HAVE_QCMS "
"before building.\n");
#endif
}
if (!WebPDemuxGetFrame(kParams.dmux, 1, curr)) goto Error;
kParams.has_animation = (curr->num_frames > 1);
kParams.loop_count = (int)WebPDemuxGetI(kParams.dmux, WEBP_FF_LOOP_COUNT);
kParams.bg_color = WebPDemuxGetI(kParams.dmux, WEBP_FF_BACKGROUND_COLOR);
printf("VP8X: Found %d images in file (loop count = %d)\n",
curr->num_frames, kParams.loop_count);
// Decode first frame
if (!Decode()) goto Error;
// Position iterator to last frame. Next call to HandleDisplay will wrap over.
// We take this into account by bumping up loop_count.
WebPDemuxGetFrame(kParams.dmux, 0, curr);
if (kParams.loop_count) ++kParams.loop_count;
#if defined(__unix__) || defined(__CYGWIN__)
// Work around GLUT compositor bug.
// https://bugs.launchpad.net/ubuntu/+source/freeglut/+bug/369891
setenv("XLIB_SKIP_ARGB_VISUALS", "1", 1);
#endif
// Start display (and timer)
glutInit(&argc, argv);
#ifdef FREEGLUT
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
#endif
StartDisplay();
if (kParams.has_animation) glutTimerFunc(0, decode_callback, 0);
glutMainLoop();
// Should only be reached when using FREEGLUT:
ClearParams();
return 0;
Error:
ClearParams();
return -1;
}
#else // !WEBP_HAVE_GL
int main(int argc, const char *argv[]) {
fprintf(stderr, "OpenGL support not enabled in %s.\n", argv[0]);
(void)argc;
return 0;
}
#endif
//------------------------------------------------------------------------------
|
the_stack_data/122015221.c | /* dracut-install.c -- install files and executables
Copyright (C) 2012 Harald Hoyer
Copyright (C) 2012 Red Hat, Inc. All rights reserved.
This program is free software: you can redistribute it and/or modify
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#define PROGRAM_VERSION_STRING "1"
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define CPIO_END "TRAILER!!!"
#define CPIO_ENDLEN (sizeof(CPIO_END)-1)
static char buf[CPIO_ENDLEN * 2 + 1];
int main(int argc, char **argv)
{
FILE *f;
size_t s;
if (argc != 2) {
fprintf(stderr, "Usage: %s <file>\n", argv[0]);
exit(1);
}
f = fopen(argv[1], "r");
if (f == NULL) {
fprintf(stderr, "Cannot open file '%s'\n", argv[1]);
exit(1);
}
s = fread(buf, 6, 1, f);
if (s <= 0) {
fprintf(stderr, "Read error from file '%s'\n", argv[1]);
fclose(f);
exit(1);
}
fseek(f, 0, SEEK_SET);
/* check, if this is a cpio archive */
if (buf[0] == '0' && buf[1] == '7' && buf[2] == '0' && buf[3] == '7' && buf[4] == '0' && buf[5] == '1') {
long pos = 0;
/* Search for CPIO_END */
do {
char *h;
fseek(f, pos, SEEK_SET);
buf[sizeof(buf) - 1] = 0;
s = fread(buf, CPIO_ENDLEN, 2, f);
if (s <= 0)
break;
h = strstr(buf, CPIO_END);
if (h) {
pos = (h - buf) + pos + CPIO_ENDLEN;
fseek(f, pos, SEEK_SET);
break;
}
pos += CPIO_ENDLEN;
} while (!feof(f));
if (feof(f)) {
/* CPIO_END not found, just cat the whole file */
fseek(f, 0, SEEK_SET);
} else {
/* skip zeros */
while (!feof(f)) {
size_t i;
buf[sizeof(buf) - 1] = 0;
s = fread(buf, 1, sizeof(buf) - 1, f);
if (s <= 0)
break;
for (i = 0; (i < s) && (buf[i] == 0); i++) ;
if (buf[i] != 0) {
pos += i;
fseek(f, pos, SEEK_SET);
break;
}
pos += s;
}
}
}
/* cat out the rest */
while (!feof(f)) {
s = fread(buf, 1, sizeof(buf), f);
if (s <= 0)
break;
s = fwrite(buf, 1, s, stdout);
if (s <= 0)
break;
}
fclose(f);
return EXIT_SUCCESS;
}
|
the_stack_data/211080575.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#define GRID_ROW 13
#define GRID_COL 4
void printBuffer(unsigned int data[GRID_ROW*GRID_COL] )
{
printf("===========\n");
for (int i=0; i<GRID_ROW*GRID_COL; i++)
{
printf("%d, ", data[i]);
if (i % GRID_COL == 3)
{
printf("\n");
}
}
printf("\n");
}
void spread_fire(unsigned int data[GRID_ROW*GRID_COL])
{
for (int x = 0; x < GRID_ROW; x++)
{
for (int y = 1; y < GRID_COL; y++)
{
unsigned int r_val = (rand() % 3 ) - 3;
unsigned int prev = y * GRID_ROW + x;
unsigned int curr = prev - GRID_ROW;
data[curr] = data[prev] - (r_val & 3);
}
}
printBuffer(data);
}
void init_fire_effect(unsigned int data[GRID_ROW*GRID_COL])
{
// init flame buffer
memset(data, 0, GRID_ROW * GRID_COL * sizeof(unsigned int));
for (int i=0; i<GRID_ROW; i++)
{
data[(GRID_COL-1) * GRID_ROW + i] = 5;
}
}
void run_fire_effect(unsigned int data[GRID_ROW*GRID_COL])
{
init_fire_effect(data);
for (int i=0; i<10; i++)
{
spread_fire(data);
}
}
/*
Matrix style digital rain
- falling pixel stream
- any column in the grid can have a pixel stream
- each pixel stream has a chance randomly appears from the top
- the head of the pixel stream has its own bright color
- each stream has a different length and speed
- each stream is darkest at the top and brightest at the bottom
- each stream must completely traverse the column before a new stream is generated
strategies
1. struct of pixel stream nodes
- initialize pixel stream struct node for each column
- loop through the grid and get the node at each column
- given each column,
- if a stream already exists in the column
- if the node already has a stream
- compute the current position of the stream head
- if the head is negative, continue to the next index of the stream
- else if the head_idx >= 0, set that index as the curr_head_pos
- iterate through the stream col indices; for each positive index,
- update the colors of the stream
- note this assumes you can't run out of colors
- divide the rest of the stream into blocks of size (GRID_COL - length) / 2
- color each block according to the digital rain color key
- else the stream index is negative, so we have the current position of the stream tail
- from the position of the curr_head_pos, keep iterating through the stream indices until we reach a negative number
- the previous index is the curr_tail_pos
- otherwise, a stream has a chance to appear
- if a stream is randomly generated, update the node and initialize the stream
- compute the current position of the stream head
- randomly generate the stream length
- color the head
- initialize thes stream speed
- else the stream was not generated, so continue to the next node
2. An invisible layer of nodes that holds data for digital rain streams
- initialize a 1D grid width array of rain structs for each column in the 2d array display
- each struct contains all properties of the rain stream including position, stream size, speed, col_is_raining
- traverse the 1D array of structs and get the current struct
- for each struct,
- if col_is_raining == true
- update the properties of the struct
- pass the relevant properties to the 2D array display
- else if col_is_raining != false
- randomly determine of a col will be raining
- if col_is_raining becomes true, run the rain_update() function
- else, continue
*/
typedef struct
{
unsigned int row;
unsigned int col;
unsigned int speed;
unsigned int size;
unsigned int col_is_raining;
unsigned int head;
unsigned int tail;
unsigned int block_size;
} rainNode;
/*
Initializes the rainNodes that model the behavior of the rain in each column
Each rainNode is a "cloud" that controls the rain that falls from it
*/
rainNode* init_digital_rain(unsigned int data[GRID_ROW*GRID_COL])
{
unsigned int min_speed_val = 1;
unsigned int max_speed_val = 3;
unsigned int min_size_val = 2;
unsigned int max_size_val = 8;
rainNode rain_cloud[GRID_ROW];
memset(data, 0, GRID_ROW * GRID_COL * sizeof(unsigned int));
for (int i=0; i<GRID_ROW; i++)
{
rain_cloud[i].row = i;
rain_cloud[i].col = -1;
rain_cloud[i].speed = rand() % (max_speed_val + 1 - min_speed_val) + min_speed_val;
rain_cloud[i].size = rand() % (max_size_val + 1 - min_size_val) + min_size_val;
rain_cloud[i].col_is_raining = 0;
rain_cloud[i].head = 0;
rain_cloud[i].tail = rain_cloud[i].head - rain_cloud[i].size;
rain_cloud[i].block_size = rain_cloud[i].size / 4;
}
return rain_cloud;
}
/*
This function computes the current position of each rain stream. The position
data is computed in the rain_cloud.
*/
void update_rain_cloud(rainNode* rain_cloud)
{
}
/*
This reads the rainCloud data and puts in the display buffer. This function
updates each column of the display buf.
The display data is a global just in case I want to have an
accelerometer interrupt system and update the display data.
*/
void display_digital_rain(unsigned int data[GRID_ROW*GRID_COL], rainNode* rain_cloud)
{
}
void run_digital_rain(unsigned int data[GRID_ROW*GRID_COL])
{
rainNode* rain_cloud = init_digital_rain(data);
for (int i=0; i<10; i++)
{
update_rain_cloud(rain_cloud);
display_digital_rain(data, rain_cloud);
}
}
/*
UV Mapping
- map a 2d plane to a parametric figure
- parameterization of a cylinder
- convert x,y to polar
- r = √ ( x2 + y2 )
- θ = tan-1 ( y / x )
- z = z (this would be the row
*/
int main()
{
srand(time(NULL));
unsigned int frame_buf[GRID_ROW*GRID_COL];
run_fire_effect(frame_buf);
run_digital_rain(frame_buf);
return 0;
}
|
the_stack_data/115766603.c | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int v_global = 0; // Variavel global para este exemplo
void Incrementa_Variavel_Global(pid_t id_atual)
{
v_global++;
printf("ID do processo que executou esta funcao = %d\n", id_atual);
printf("v_global = %d\n", v_global);
printf("\n");
}
int main ()
{
pid_t child_pid;
pid_t child_pid1;
pid_t child_pid2;
child_pid = fork();
if (child_pid == 0)
{
printf("********************************************************************\n");
printf("* Este texto foi escrito no terminal pelo processo FILHO (ID=%d) *\n", (int) getpid());
printf("********************************************************************\n");
printf("\n");
Incrementa_Variavel_Global((int) getpid());
child_pid1 = fork();
if (child_pid1 == 0)
{
printf("********************************************************************\n");
printf("* Este texto foi escrito no terminal pelo processo FILHO 1 (ID=%d) *\n", (int) getpid());
printf("********************************************************************\n");
printf("\n");
Incrementa_Variavel_Global((int) getpid());
child_pid2 = fork();
if (child_pid2 == 0)
{
printf("********************************************************************\n");
printf("* Este texto foi escrito no terminal pelo processo FILHO 2 (ID=%d) *\n", (int) getpid());
printf("********************************************************************\n");
printf("\n");
Incrementa_Variavel_Global((int) getpid());
}
}
}
else
{
sleep(1);
printf("******************************************************************\n");
printf("* Este texto foi escrito no terminal pelo processo PAI (ID=%d) *\n", (int) getpid());
printf("******************************************************************\n");
printf("\n");
}
return 0;
}
/* Filho execultam sempre a mesma variavel */
|
the_stack_data/101896.c |
/* hanoi solver for hanoi2 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
static int num_disks[3] =
{0, 0, 0};
static void
move_disk(int from, int to, int fd)
{
char buf[3];
assert(from != to);
num_disks[from]--;
num_disks[to]++;
#ifdef TEST_ENGINE
printf("%d --> %d\n", from, to);
#else
buf[0] = 'M';
buf[1] = (char) from;
buf[2] = (char) to;
if (3 != write(fd, buf, 3)) {
perror("can't write");
exit(1);
}
#endif
}
static void
move_disks(int from, int to, int n, int fd)
{
static int other_table[9] =
{-1, 2, 1, 2, -1, 0, 1, 0, -1};
int other;
assert(from != to);
other = other_table[from * 3 + to];
assert(other != -1);
if (n == 1) {
move_disk(from, to, fd);
} else {
move_disks(from, other, n - 1, fd);
move_disk(from, to, fd);
move_disks(other, to, n - 1, fd);
}
}
void
engine(int *args)
{
num_disks[0] = args[0];
for (;;) {
move_disks(0, 2, args[0], args[1]);
move_disks(2, 0, args[0], args[1]);
}
}
#ifdef TEST_ENGINE
int
main(int argc, char *argv[])
{
int engine_args[2];
if (argc > 1) {
engine_args[0] = atoi(argv[1]);
}
engine_args[1] = 1;
engine(n, engine_args);
return 0; /* ANSI C requires main to return int. */
}
#endif
|
the_stack_data/81223.c | #include "stdio.h"
main()
{
register int i;
for (i = 0; i < 100; i++)
printf("hello ANSI world %d via printf\n", i);
fprintf(stdout, "hello ANSI world via stdout\n");
/* fflush(stdout); */
fprintf(stderr, "hello ANSI world via stderr\n");
}
|
the_stack_data/190768804.c | /*
*******************************************************************************
* Copyright (c) 2020-2021, STMicroelectronics
* All rights reserved.
*
* 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(ARDUINO_GENERIC_MP153AACX) || defined(ARDUINO_GENERIC_MP153CACX) ||\
defined(ARDUINO_GENERIC_MP153DACX) || defined(ARDUINO_GENERIC_MP153FACX) ||\
defined(ARDUINO_GENERIC_MP157AACX) || defined(ARDUINO_GENERIC_MP157CACX) ||\
defined(ARDUINO_GENERIC_MP157DACX) || defined(ARDUINO_GENERIC_MP157FACX)
#include "pins_arduino.h"
/**
* @brief System Clock Configuration
* @param None
* @retval None
*/
WEAK void SystemClock_Config(void)
{
/* SystemClock_Config can be generated by STM32CubeMX */
#warning "SystemClock_Config() is empty. Default clock at reset is used."
}
#endif /* ARDUINO_GENERIC_* */
|
the_stack_data/154831439.c | #include <stdlib.h>
int main(int argc, char * argv[])
{
exit(1);
}
|
the_stack_data/641299.c | #include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int boolean;
typedef struct estrutura {
int chave;
struct estrutura *primFilho;
struct estrutura *proxIrmao;
} NO;
NO* buscaChave(int chave, NO* raiz) {
if (!raiz)
return NULL;
if (raiz->chave == chave)
return raiz;
NO* p = raiz->primFilho;
while (p) {
NO* resp = buscaChave(chave, p);
if (resp)
return resp;
p = p->proxIrmao;
}
return NULL;
}
NO* criarNovoNo(int chave) {
NO* p = (NO*) malloc(sizeof(NO));
p->primFilho = NULL;
p->proxIrmao = NULL;
p->chave = chave;
return p;
}
boolean inserirNo(NO* raiz, int novaChave, int chavePai) {
// verificamos se tem pai
NO* pai = buscaChave(chavePai, raiz);
if (!pai)
return false;
NO* filho = criarNovoNo(novaChave);
// verificamos o primogenito do pai
NO* p = pai->primFilho;
if (!p)
pai->primFilho = filho;
else {
while (p->proxIrmao)
p = p->proxIrmao;
p->proxIrmao = filho;
}
return true;
}
void exibirArvore(NO* raiz) {
if (!raiz)
return;
printf("%d(", raiz->chave);
NO* p = raiz->primFilho;
while (p) {
exibirArvore(p);
p = p->proxIrmao;
}
printf(")");
}
NO* inicializarArvore(int chave) {
return criarNovoNo(chave);
}
int main() {
// A Exclusao depende do contexto
NO* raiz = inicializarArvore(8);
inserirNo(raiz, 15, 8);
inserirNo(raiz, 20, 15);
inserirNo(raiz, 10, 15);
inserirNo(raiz, 28, 15);
inserirNo(raiz, 23, 8);
inserirNo(raiz, 2, 8);
inserirNo(raiz, 36, 2);
inserirNo(raiz, 7, 2);
exibirArvore(raiz);
return 0;
}
|
the_stack_data/61765.c | //Write a menu driven program to read two integers & find their sum, difference & product
#include <stdio.h>
int main()
{
int number_one, number_two, choice;
printf("Press 1 to add and enter the two numbers.\n");
printf("Press 2 to substract and enter two numbers. \n ");
printf("Press 3 to multiply and enter the two numbers \n");
scanf("%d %d %d", &choice, &number_one, &number_two);
switch(choice)
{
case 1:
printf("Result: %d \n", number_one + number_two);
break;
case 2:
printf("Result: %d \n", number_one - number_two);
break;
case 3:
printf("Result: %d \n", number_one * number_two);
break;
default:
printf("Enter the valid options. \n");
}
return 0;
}
|
the_stack_data/46023.c | /*
* mbed Microcontroller Library
* Copyright (c) 2017-2018 Future Electronics
* Copyright (c) 2018-2019 Cypress Semiconductor Corporation
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if DEVICE_SERIAL
#include <string.h>
#include "cmsis.h"
#include "mbed_assert.h"
#include "mbed_error.h"
#include "PeripheralPins.h"
#include "pinmap.h"
#include "serial_api.h"
#include "psoc6_utils.h"
#include "cy_sysclk.h"
#include "cy_gpio.h"
#include "cy_scb_uart.h"
#include "cy_sysint.h"
#define UART_OVERSAMPLE 12
#define UART_DEFAULT_BAUDRATE 115200
#define NUM_SERIAL_PORTS 8
#define SERIAL_DEFAULT_IRQ_PRIORITY 3
#define UART_RX_INTR_MASK (CY_SCB_UART_RX_TRIGGER | CY_SCB_UART_RX_OVERFLOW | \
CY_SCB_UART_RX_ERR_FRAME | CY_SCB_UART_RX_ERR_PARITY)
typedef struct serial_s serial_obj_t;
#if DEVICE_SERIAL_ASYNCH
#define OBJ_P(in) (&(in->serial))
#else
#define OBJ_P(in) (in)
#endif
/*
* NOTE: Cypress PDL high level API implementation of USART doe not
* align well with Mbed interface for interrupt-driven serial I/O.
* For this reason only low level PDL API is used here.
*/
/* Default UART configuration */
static const cy_stc_scb_uart_config_t default_uart_config = {
.uartMode = CY_SCB_UART_STANDARD,
.enableMutliProcessorMode = false,
.smartCardRetryOnNack = false,
.irdaInvertRx = false,
.irdaEnableLowPowerReceiver = false,
.oversample = UART_OVERSAMPLE,
.enableMsbFirst = false,
.dataWidth = 8UL,
.parity = CY_SCB_UART_PARITY_NONE,
.stopBits = CY_SCB_UART_STOP_BITS_1,
.enableInputFilter = false,
.breakWidth = 11UL,
.dropOnFrameError = false,
.dropOnParityError = false,
.receiverAddress = 0x0UL,
.receiverAddressMask = 0x0UL,
.acceptAddrInFifo = false,
.enableCts = false,
.ctsPolarity = CY_SCB_UART_ACTIVE_LOW,
.rtsRxFifoLevel = 20UL,
.rtsPolarity = CY_SCB_UART_ACTIVE_LOW,
.rxFifoTriggerLevel = 0UL, /* Level triggers when at least one element is in FIFO */
.rxFifoIntEnableMask = 0x0UL,
.txFifoTriggerLevel = 63UL, /* Level triggers when half-fifo is half empty */
.txFifoIntEnableMask = 0x0UL
};
/* STDIO serial information */
bool stdio_uart_inited = false;
serial_t stdio_uart;
int bt_uart_inited = false;
serial_t bt_uart;
typedef struct irq_info_s {
serial_obj_t *serial_obj;
uart_irq_handler handler;
uint32_t id_arg;
IRQn_Type irqn;
#if defined (TARGET_MCU_PSOC6_M0)
cy_en_intr_t cm0p_irq_src;
#endif
} irq_info_t;
/* Allocate interrupt information table */
static irq_info_t irq_info[NUM_SERIAL_PORTS] = {
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn},
{NULL, NULL, 0, unconnected_IRQn}
};
/** Routes interrupt to proper SCB block.
*
* @param serial_id The ID of serial object
*/
static void serial_irq_dispatcher(uint32_t serial_id)
{
MBED_ASSERT(serial_id < NUM_SERIAL_PORTS);
irq_info_t *info = &irq_info[serial_id];
serial_obj_t *obj = info->serial_obj;
MBED_ASSERT(obj);
#if DEVICE_SERIAL_ASYNCH
if (obj->async_handler) {
obj->async_handler();
return;
}
#endif
if (Cy_SCB_GetRxInterruptStatusMasked(obj->base) & CY_SCB_RX_INTR_NOT_EMPTY) {
info->handler(info->id_arg, RxIrq);
Cy_SCB_ClearRxInterrupt(obj->base, CY_SCB_RX_INTR_NOT_EMPTY);
}
if (Cy_SCB_GetTxInterruptStatusMasked(obj->base) & CY_SCB_UART_TX_EMPTY) {
info->handler(info->id_arg, TxIrq);
Cy_SCB_ClearTxInterrupt(obj->base, CY_SCB_UART_TX_EMPTY);
}
}
static void serial_irq_dispatcher_uart0(void)
{
serial_irq_dispatcher(0);
}
static void serial_irq_dispatcher_uart1(void)
{
serial_irq_dispatcher(1);
}
static void serial_irq_dispatcher_uart2(void)
{
serial_irq_dispatcher(2);
}
static void serial_irq_dispatcher_uart3(void)
{
serial_irq_dispatcher(3);
}
static void serial_irq_dispatcher_uart4(void)
{
serial_irq_dispatcher(4);
}
static void serial_irq_dispatcher_uart5(void)
{
serial_irq_dispatcher(5);
}
void serial_irq_dispatcher_uart6(void)
{
serial_irq_dispatcher(6);
}
static void serial_irq_dispatcher_uart7(void)
{
serial_irq_dispatcher(7);
}
/* Interrupts table */
static void (*irq_dispatcher_table[])(void) = {
serial_irq_dispatcher_uart0,
serial_irq_dispatcher_uart1,
serial_irq_dispatcher_uart2,
serial_irq_dispatcher_uart3,
serial_irq_dispatcher_uart4,
serial_irq_dispatcher_uart5,
serial_irq_dispatcher_uart6,
serial_irq_dispatcher_uart7
};
static IRQn_Type serial_irq_allocate_channel(serial_obj_t *obj)
{
#if defined (TARGET_MCU_PSOC6_M0)
irq_info[obj->serial_id].cm0p_irq_src = scb_0_interrupt_IRQn + obj->serial_id;
return cy_m0_nvic_allocate_channel(CY_SERIAL_IRQN_ID + obj->serial_id);
#else
return (IRQn_Type)(scb_0_interrupt_IRQn + obj->serial_id);
#endif /* (TARGET_MCU_PSOC6_M0) */
}
static int serial_irq_setup_channel(serial_obj_t *obj)
{
cy_stc_sysint_t irq_config;
irq_info_t *info = &irq_info[obj->serial_id];
if (info->irqn == unconnected_IRQn) {
IRQn_Type irqn = serial_irq_allocate_channel(obj);
if (irqn < 0) {
return (-1);
}
/* Configure NVIC */
irq_config.intrPriority = SERIAL_DEFAULT_IRQ_PRIORITY;
irq_config.intrSrc = irqn;
#if defined (TARGET_MCU_PSOC6_M0)
irq_config.cm0pSrc = info->cm0p_irq_src;
#endif
if (Cy_SysInt_Init(&irq_config, irq_dispatcher_table[obj->serial_id]) != CY_SYSINT_SUCCESS) {
return (-1);
}
info->irqn = irqn;
info->serial_obj = obj;
}
/* Enable interrupt after successful setup */
NVIC_EnableIRQ(info->irqn);
return 0;
}
/** Calculates fractional divider value.
*
* @param frequency The desired frequency of UART clock
* @param frac_bits The number of fractional bits in the divider
* @return The divider value
*/
static uint32_t divider_value(uint32_t frequency, uint32_t frac_bits)
{
/* UARTs use peripheral clock */
return ((cy_PeriClkFreqHz * (1 << frac_bits)) + (frequency / 2)) / frequency;
}
#define FRACT_DIV_INT(divider) (((divider) >> 5U) - 1U)
#define FRACT_DIV_FARCT(divider) ((divider) & 0x1FU)
/** Finds clock divider, configures it and connects to SCB block.
*
* @param obj The serial object
* @param baudrate The desired UART baud rate
* @return CY_SYSCLK_SUCCESS if operation successful and CY_SYSCLK_BAD_PARAM otherwise
*/
static cy_en_sysclk_status_t serial_init_clock(serial_obj_t *obj, uint32_t baudrate)
{
cy_en_sysclk_status_t status = CY_SYSCLK_BAD_PARAM;
if (obj->div_num == CY_INVALID_DIVIDER) {
uint32_t divider_num = cy_clk_allocate_divider(CY_SYSCLK_DIV_16_5_BIT);
if (divider_num < PERI_DIV_16_5_NR) {
/* Assign fractional divider */
status = Cy_SysClk_PeriphAssignDivider(obj->clock, CY_SYSCLK_DIV_16_5_BIT, divider_num);
if (status == CY_SYSCLK_SUCCESS) {
obj->div_type = CY_SYSCLK_DIV_16_5_BIT;
obj->div_num = divider_num;
}
} else {
// Try 16-bit divider.
divider_num = cy_clk_allocate_divider(CY_SYSCLK_DIV_16_BIT);
if (divider_num < PERI_DIV_16_NR) {
/* Assign 16-bit divider */
status = Cy_SysClk_PeriphAssignDivider(obj->clock, CY_SYSCLK_DIV_16_BIT, divider_num);
if (status == CY_SYSCLK_SUCCESS) {
obj->div_type = CY_SYSCLK_DIV_16_BIT;
obj->div_num = divider_num;
}
} else {
error("Serial: cannot assign clock divider.");
}
}
} else {
status = CY_SYSCLK_SUCCESS;
}
if (status == CY_SYSCLK_SUCCESS) {
Cy_SysClk_PeriphDisableDivider(obj->div_type, obj->div_num);
/* Set baud rate */
if (obj->div_type == CY_SYSCLK_DIV_16_5_BIT) {
/* Get fractional divider */
uint32_t divider = divider_value(baudrate * UART_OVERSAMPLE, 5U);
status = Cy_SysClk_PeriphSetFracDivider(CY_SYSCLK_DIV_16_5_BIT,
obj->div_num,
FRACT_DIV_INT(divider),
FRACT_DIV_FARCT(divider));
} else {
/* Get integer divider */
status = Cy_SysClk_PeriphSetDivider(CY_SYSCLK_DIV_16_BIT,
obj->div_num,
divider_value(baudrate * UART_OVERSAMPLE, 0));
}
Cy_SysClk_PeriphEnableDivider(obj->div_type, obj->div_num);
}
return status;
}
/** Initializes i/o pins for UART tx/rx.
*
* @param obj The serial object
*/
static void serial_init_pins(serial_obj_t *obj)
{
if ((cy_reserve_io_pin(obj->pin_tx) || cy_reserve_io_pin(obj->pin_rx))
&& !obj->already_reserved) {
error("Serial TX/RX pin reservation conflict.");
}
pin_function(obj->pin_tx, pinmap_function(obj->pin_tx, PinMap_UART_TX));
pin_function(obj->pin_rx, pinmap_function(obj->pin_rx, PinMap_UART_RX));
}
/** Initializes i/o pins for UART flow control
*
* @param obj The serial object
*/
static void serial_init_flow_pins(serial_obj_t *obj)
{
if (obj->pin_rts != NC) {
if ((0 != cy_reserve_io_pin(obj->pin_rts)) && !obj->already_reserved) {
error("Serial RTS pin reservation conflict.");
}
pin_function(obj->pin_rts, pinmap_function(obj->pin_rts, PinMap_UART_RTS));
}
if (obj->pin_cts != NC) {
if ((0 != cy_reserve_io_pin(obj->pin_cts)) && !obj->already_reserved) {
error("Serial CTS pin reservation conflict.");
}
pin_function(obj->pin_cts, pinmap_function(obj->pin_cts, PinMap_UART_CTS));
}
}
/** Initializes and enables UART/SCB.
*
* @param obj The serial object
*/
static void serial_init_peripheral(serial_obj_t *obj)
{
cy_stc_scb_uart_config_t uart_config = default_uart_config;
uart_config.dataWidth = obj->data_width;
uart_config.parity = obj->parity;
uart_config.stopBits = obj->stop_bits;
uart_config.enableCts = (obj->pin_cts != NC);
Cy_SCB_UART_Init(obj->base, &uart_config, NULL);
Cy_SCB_UART_Enable(obj->base);
}
#if DEVICE_SLEEP && DEVICE_LPTICKER && SERIAL_PM_CALLBACK_ENABLED
static cy_en_syspm_status_t serial_pm_callback(cy_stc_syspm_callback_params_t *params)
{
serial_obj_t *obj = (serial_obj_t *)params->context;
cy_en_syspm_status_t status = CY_SYSPM_FAIL;
switch (params->mode) {
case CY_SYSPM_CHECK_READY:
/* If all data elements are transmitted from the TX FIFO and
* shifter and the RX FIFO is empty: the UART is ready to enter
* Deep Sleep mode.
*/
if (Cy_SCB_UART_IsTxComplete(obj->base)) {
if (0 == Cy_SCB_UART_GetNumInRxFifo(obj->base)) {
/* Disable the UART. The transmitter stops driving the
* lines and the receiver stops receiving data until
* the UART is enabled.
* This happens when the device failed to enter Deep
* Sleep or it is awaken from Deep Sleep mode.
*/
Cy_SCB_UART_Disable(obj->base, NULL);
status = CY_SYSPM_SUCCESS;
}
}
break;
case CY_SYSPM_CHECK_FAIL:
/* Enable the UART to operate */
Cy_SCB_UART_Enable(obj->base);
status = CY_SYSPM_SUCCESS;
break;
case CY_SYSPM_BEFORE_TRANSITION:
status = CY_SYSPM_SUCCESS;
break;
case CY_SYSPM_AFTER_TRANSITION:
/* Enable the UART to operate */
Cy_SCB_UART_Enable(obj->base);
status = CY_SYSPM_SUCCESS;
break;
default:
break;
}
return status;
}
#endif /* (DEVICE_SLEEP && DEVICE_LPTICKER && SERIAL_PM_CALLBACK_ENABLED) */
void serial_init(serial_t *obj_in, PinName tx, PinName rx)
{
serial_obj_t *obj = OBJ_P(obj_in);
bool is_stdio = (tx == CY_STDIO_UART_TX) || (rx == CY_STDIO_UART_RX);
#if !defined(TARGET_CY8CKIT_062_BLE)
bool is_bt = (tx == CY_BT_UART_TX) || (rx == CY_BT_UART_RX);
#else
bool is_bt = false;
#endif
if (is_stdio && stdio_uart_inited) {
memcpy(obj_in, &stdio_uart, sizeof(serial_t));
return;
} else if (is_bt && bt_uart_inited) {
memcpy(obj_in, &bt_uart, sizeof(serial_t));
return;
} else {
uint32_t uart = pinmap_peripheral(tx, PinMap_UART_TX);
uart = pinmap_merge(uart, pinmap_peripheral(rx, PinMap_UART_RX));
if (uart != (uint32_t)NC) {
uint32_t serial_id = ((UARTName)uart - UART_0) / (UART_1 - UART_0);
/* Initialize configuration */
obj->base = (CySCB_Type *)uart;
obj->serial_id = serial_id;
obj->clock = CY_PIN_CLOCK(pinmap_function(tx, PinMap_UART_TX));
obj->div_num = CY_INVALID_DIVIDER;
obj->already_reserved = (0 != cy_reserve_scb(obj->serial_id));
obj->pin_tx = tx;
obj->pin_rx = rx;
obj->pin_rts = NC;
obj->pin_cts = NC;
obj->data_width = 8;
obj->stop_bits = CY_SCB_UART_STOP_BITS_1;
obj->parity = CY_SCB_UART_PARITY_NONE;
/* Check if resource severed */
if (obj->already_reserved) {
uint32_t map;
/* SCB pins and clocks are connected */
/* Disable block and get it into the default state */
Cy_SCB_UART_Disable(obj->base, NULL);
Cy_SCB_UART_DeInit(obj->base);
/* Get connected clock */
map = Cy_SysClk_PeriphGetAssignedDivider(obj->clock);
obj->div_num = _FLD2VAL(CY_PERI_CLOCK_CTL_DIV_SEL, map);
obj->div_type = (cy_en_divider_types_t) _FLD2VAL(CY_PERI_CLOCK_CTL_TYPE_SEL, map);
} else {
#if DEVICE_SLEEP && DEVICE_LPTICKER && SERIAL_PM_CALLBACK_ENABLED
/* Register callback once */
obj->pm_callback_handler.callback = serial_pm_callback;
obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP;
obj->pm_callback_handler.skipMode = 0;
obj->pm_callback_handler.callbackParams = &obj->pm_callback_params;
obj->pm_callback_params.base = obj->base;
obj->pm_callback_params.context = obj;
if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) {
error("PM callback registration failed!");
}
#endif /* (DEVICE_SLEEP && DEVICE_LPTICKER && SERIAL_PM_CALLBACK_ENABLED) */
}
/* Configure hardware resources */
serial_init_clock(obj, UART_DEFAULT_BAUDRATE);
serial_init_pins(obj);
serial_init_peripheral(obj);
if (is_stdio) {
memcpy(&stdio_uart, obj_in, sizeof(serial_t));
stdio_uart_inited = true;
} else if (is_bt) {
memcpy(&bt_uart, obj_in, sizeof(serial_t));
bt_uart_inited = true;
}
} else {
error("Serial pinout mismatch. Requested pins Rx and Tx can't be used for the same Serial communication.");
}
}
}
void serial_free(serial_t *obj)
{
error("This function is not supported.");
}
void serial_baud(serial_t *obj_in, int baudrate)
{
serial_obj_t *obj = OBJ_P(obj_in);
Cy_SCB_UART_Disable(obj->base, NULL);
serial_init_clock(obj, baudrate);
Cy_SCB_UART_Enable(obj->base);
}
void serial_format(serial_t *obj_in, int data_bits, SerialParity parity, int stop_bits)
{
serial_obj_t *obj = OBJ_P(obj_in);
if ((data_bits >= 5) && (data_bits <= 9)) {
obj->data_width = data_bits;
}
switch (parity) {
case ParityNone:
obj->parity = CY_SCB_UART_PARITY_NONE;
break;
case ParityOdd:
obj->parity = CY_SCB_UART_PARITY_ODD;
break;
case ParityEven:
obj->parity = CY_SCB_UART_PARITY_EVEN;
break;
case ParityForced1:
case ParityForced0:
error("Serial parity mode not supported!");
break;
}
switch (stop_bits) {
case 1:
obj->stop_bits = CY_SCB_UART_STOP_BITS_1;
break;
case 2:
obj->stop_bits = CY_SCB_UART_STOP_BITS_2;
break;
case 3:
obj->stop_bits = CY_SCB_UART_STOP_BITS_3;
break;
case 4:
obj->stop_bits = CY_SCB_UART_STOP_BITS_4;
break;
}
Cy_SCB_UART_Disable(obj->base, NULL);
serial_init_peripheral(obj);
/* SCB is enabled at the and of serial_init_peripheral() call */
}
void serial_putc(serial_t *obj_in, int c)
{
serial_obj_t *obj = OBJ_P(obj_in);
while (0 == serial_writable(obj_in)) {
/* There is an entry to be written */
}
Cy_SCB_WriteTxFifo(obj->base, (uint32_t) c);
}
int serial_getc(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
while (0 == serial_readable(obj_in)) {
/* There is an item to be read */
}
return Cy_SCB_UART_Get(obj->base);
}
int serial_readable(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
return Cy_SCB_GetNumInRxFifo(obj->base);
}
int serial_writable(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
return (Cy_SCB_GetFifoSize(obj->base) != Cy_SCB_GetNumInTxFifo(obj->base));
}
void serial_clear(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
/* The hardware FIFOs and statuses are cleared when SCB is disabled */
Cy_SCB_UART_Disable(obj->base, NULL);
serial_init_peripheral(obj);
/* SCB is enabled at the and of serial_init_peripheral() call */
}
void serial_break_set(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
/* Cypress SCB does not support transmitting break directly.
* We emulate functionality by switching TX pin to GPIO mode.
*/
GPIO_PRT_Type *port_tx = Cy_GPIO_PortToAddr(CY_PORT(obj->pin_tx));
Cy_GPIO_Pin_FastInit(port_tx, CY_PIN(obj->pin_tx), CY_GPIO_DM_STRONG_IN_OFF, 0, HSIOM_SEL_GPIO);
Cy_GPIO_Write(port_tx, CY_PIN(obj->pin_tx), 0);
}
void serial_break_clear(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
/* Connect TX pin back to SCB, see a comment in serial_break_set() above */
GPIO_PRT_Type *port_tx = Cy_GPIO_PortToAddr(CY_PORT(obj->pin_tx));
int tx_function = pinmap_function(obj->pin_tx, PinMap_UART_TX);
Cy_GPIO_Pin_FastInit(port_tx, CY_PIN(obj->pin_tx), CY_GPIO_DM_STRONG_IN_OFF, 0, CY_PIN_HSIOM(tx_function));
}
void serial_pinout_tx(PinName tx)
{
error("This function is not supported.");
}
void serial_set_flow_control(serial_t *obj_in, FlowControl type, PinName rxflow, PinName txflow)
{
serial_obj_t *obj = OBJ_P(obj_in);
/* Do not perform pins reservation second time for the same pins */
if ((obj->pin_rts == rxflow) && (obj->pin_cts == txflow))
return;
Cy_SCB_UART_Disable(obj->base, NULL);
switch (type) {
case FlowControlNone:
obj->pin_rts = NC;
obj->pin_cts = NC;
break;
case FlowControlRTS:
obj->pin_rts = rxflow;
obj->pin_cts = NC;
break;
case FlowControlCTS:
obj->pin_rts = NC;
obj->pin_cts = txflow;
break;
case FlowControlRTSCTS:
obj->pin_rts = rxflow;
obj->pin_cts = txflow;
break;
}
serial_init_flow_pins(obj);
serial_init_peripheral(obj);
}
const PinMap *serial_tx_pinmap()
{
return PinMap_UART_TX;
}
const PinMap *serial_rx_pinmap()
{
return PinMap_UART_RX;
}
const PinMap *serial_cts_pinmap()
{
return PinMap_UART_CTS;
}
const PinMap *serial_rts_pinmap()
{
return PinMap_UART_RTS;
}
#if DEVICE_SERIAL_ASYNCH
void serial_irq_handler(serial_t *obj_in, uart_irq_handler handler, uint32_t id)
{
serial_obj_t *obj = OBJ_P(obj_in);
irq_info_t *info = &irq_info[obj->serial_id];
if (info->irqn != unconnected_IRQn) {
/* Seccessful serial_irq_setup_channel enables interrupt in NVIC */
NVIC_DisableIRQ(info->irqn);
}
info->handler = handler;
info->id_arg = id;
if (0 != serial_irq_setup_channel(obj)) {
error("Interrupt setup failed.");
}
}
void serial_irq_set(serial_t *obj_in, SerialIrq irq, uint32_t enable)
{
serial_obj_t *obj = OBJ_P(obj_in);
switch (irq) {
case RxIrq: /* RxIrq for receive (buffer is not empty) */
Cy_SCB_SetRxInterruptMask(obj->base, (0 != enable) ? CY_SCB_RX_INTR_NOT_EMPTY : 0);
break;
case TxIrq: /* TxIrq for transmit (buffer is empty) */
Cy_SCB_SetTxInterruptMask(obj->base, (0 != enable) ? CY_SCB_UART_TX_EMPTY : 0);
break;
}
}
int serial_tx_asynch(serial_t *obj_in, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
{
(void) tx_width; /* Deprecated argument */
(void) hint; /* At the moment we do not support DMA transfers, so this parameter gets ignored. */
serial_obj_t *obj = OBJ_P(obj_in);
const uint8_t *p_buf = tx;
if (obj->tx_pending || (tx_length == 0)) {
return 0;
}
/* Configure interrupt handler */
obj->async_handler = (cy_israddress)handler;
if (serial_irq_setup_channel(obj) < 0) {
return 0;
}
/* Clear TX_DONE interrupt it might remain set from previous call */
Cy_SCB_ClearTxInterrupt(obj->base, CY_SCB_UART_TX_DONE | CY_SCB_TX_INTR_LEVEL);
/* Write as much as possible into the FIFO first */
while ((tx_length > 0) && (0 != Cy_SCB_UART_Put(obj->base, *p_buf))) {
++p_buf;
--tx_length;
}
if (tx_length > 0) {
obj->tx_pending = true;
obj->tx_events = event;
obj_in->tx_buff.pos = 0;
obj_in->tx_buff.buffer = (void *)p_buf;
obj_in->tx_buff.length = tx_length;
/* Enable LEVEL interrupt to complete transmission */
Cy_SCB_SetTxInterruptMask(obj->base, CY_SCB_TX_INTR_LEVEL);
} else {
/* Enable DONE interrupt to signal completing of the transmission */
Cy_SCB_SetTxInterruptMask(obj->base, CY_SCB_UART_TX_DONE);
}
return tx_length;
}
void serial_rx_asynch(serial_t *obj_in, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
{
(void) rx_width; /* Deprecated argument */
(void) hint; /* At the moment we do not support DMA transfers, so this parameter gets ignored. */
serial_obj_t *obj = OBJ_P(obj_in);
if (obj->rx_pending || (rx_length == 0)) {
return;
}
/* Configure interrupt handler */
obj->async_handler = (cy_israddress)handler;
if (serial_irq_setup_channel(obj) < 0) {
return;
}
obj->rx_pending = true;
obj->rx_events = event;
obj_in->char_match = char_match;
obj_in->char_found = false;
obj_in->rx_buff.pos = 0;
obj_in->rx_buff.buffer = rx;
obj_in->rx_buff.length = rx_length;
/* Enable interrupts to start receiving */
Cy_SCB_SetRxInterruptMask(obj->base, UART_RX_INTR_MASK);
}
uint8_t serial_tx_active(serial_t *obj)
{
return obj->serial.tx_pending;
}
uint8_t serial_rx_active(serial_t *obj)
{
return obj->serial.rx_pending;
}
/** Finishes TX asynchronous transfer: disable TX interrupts and clear
* pending state.
*
* @param obj The serial object
*/
static void serial_finish_tx_asynch(serial_obj_t *obj)
{
Cy_SCB_SetTxInterruptMask(obj->base, 0);
obj->tx_pending = false;
}
/** Finishes TX asynchronous transfer: disable TX interrupts and clear
* pending state.
*
* @param obj The serial object
*/
static void serial_finish_rx_asynch(serial_obj_t *obj)
{
Cy_SCB_SetRxInterruptMask(obj->base, 0);
obj->rx_pending = false;
}
int serial_irq_handler_asynch(serial_t *obj_in)
{
uint32_t cur_events = 0;
uint32_t tx_status;
uint32_t rx_status;
serial_obj_t *obj = OBJ_P(obj_in);
/* Interrupt cause is TX */
if (0 != (CY_SCB_TX_INTR & Cy_SCB_GetInterruptCause(obj->base))) {
/* Get interrupt sources and clear them */
tx_status = Cy_SCB_GetTxInterruptStatusMasked(obj->base);
Cy_SCB_ClearTxInterrupt(obj->base, tx_status);
if (0 != (tx_status & CY_SCB_TX_INTR_LEVEL)) {
/* Get current buffer position */
uint8_t *ptr = obj_in->tx_buff.buffer;
ptr += obj_in->tx_buff.pos;
/* FIFO has space available for more TX */
while ((obj_in->tx_buff.pos < obj_in->tx_buff.length) &&
(0 != Cy_SCB_UART_Put(obj->base, *ptr))) {
++ptr;
++(obj_in->tx_buff.pos);
}
if (obj_in->tx_buff.pos == obj_in->tx_buff.length) {
/* No more bytes to follow; check to see if we need to signal completion */
if (0 != (obj->tx_events & SERIAL_EVENT_TX_COMPLETE)) {
/* Disable TX_LEVEL and enable TX_DONE to get completion event */
Cy_SCB_SetTxInterruptMask(obj->base, CY_SCB_UART_TX_DONE);
} else {
/* Nothing more to do, mark end of transmission */
serial_finish_tx_asynch(obj);
}
}
}
if (0 != (tx_status & CY_SCB_TX_INTR_UART_DONE)) {
/* Mark end of the transmission */
serial_finish_tx_asynch(obj);
cur_events |= SERIAL_EVENT_TX_COMPLETE;
}
}
/* Interrupt cause is RX */
if (0 != (CY_SCB_RX_INTR & Cy_SCB_GetInterruptCause(obj->base))) {
/* Get interrupt sources and clear them */
rx_status = Cy_SCB_GetRxInterruptStatusMasked(obj->base);
Cy_SCB_ClearRxInterrupt(obj->base, rx_status);
if (0 != (rx_status & CY_SCB_RX_INTR_OVERFLOW)) {
cur_events |= SERIAL_EVENT_RX_OVERRUN_ERROR;
}
if (0 != (rx_status & CY_SCB_RX_INTR_UART_FRAME_ERROR)) {
cur_events |= SERIAL_EVENT_RX_FRAMING_ERROR;
}
if (0 != (rx_status & CY_SCB_RX_INTR_UART_PARITY_ERROR)) {
cur_events |= SERIAL_EVENT_RX_PARITY_ERROR;
}
if (0 != (rx_status & CY_SCB_RX_INTR_LEVEL)) {
/* Get current buffer position */
uint8_t *ptr = obj_in->rx_buff.buffer;
ptr += obj_in->rx_buff.pos;
/* Get data from the RX FIFO */
while (obj_in->rx_buff.pos < obj_in->rx_buff.length) {
uint32_t c = Cy_SCB_UART_Get(obj->base);
if (c == CY_SCB_UART_RX_NO_DATA) {
break;
}
*ptr++ = (uint8_t) c;
++(obj_in->rx_buff.pos);
/* Check for character match condition */
if (obj_in->char_match != SERIAL_RESERVED_CHAR_MATCH) {
if (c == obj_in->char_match) {
obj_in->char_found = true;
cur_events |= SERIAL_EVENT_RX_CHARACTER_MATCH;
/* Clamp RX buffer */
obj_in->rx_buff.length = obj_in->rx_buff.pos;
break;
}
}
}
}
if (obj_in->rx_buff.pos == obj_in->rx_buff.length) {
serial_finish_rx_asynch(obj);
cur_events |= SERIAL_EVENT_RX_COMPLETE;
}
}
return (cur_events & (obj->tx_events | obj->rx_events));
}
void serial_tx_abort_asynch(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
serial_finish_tx_asynch(obj);
Cy_SCB_UART_ClearTxFifo(obj->base);
}
void serial_rx_abort_asynch(serial_t *obj_in)
{
serial_obj_t *obj = OBJ_P(obj_in);
serial_finish_rx_asynch(obj);
Cy_SCB_UART_ClearRxFifo(obj->base);
Cy_SCB_ClearRxInterrupt(obj->base, CY_SCB_UART_RX_INTR_MASK);
}
#endif /* DEVICE_SERIAL_ASYNCH */
#endif /* DEVICE_SERIAL */
|
the_stack_data/187643504.c | /* Copyright 2013-2020 Free Software Foundation, Inc.
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 <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
unsigned char e_ident[16];
uint16_t e_type;
uint16_t e_machine;
uint32_t e_version;
uint32_t e_entry;
uint32_t e_phoff;
uint32_t e_shoff;
uint32_t e_flags;
uint16_t e_ehsize;
uint16_t e_phentsize;
uint16_t e_phnum;
uint16_t e_shentsize;
uint16_t e_shnum;
uint16_t e_shstrndx;
} Elf32_Ehdr;
typedef struct
{
unsigned char e_ident[16];
uint16_t e_type;
uint16_t e_machine;
uint32_t e_version;
uint64_t e_entry;
uint64_t e_phoff;
uint64_t e_shoff;
uint32_t e_flags;
uint16_t e_ehsize;
uint16_t e_phentsize;
uint16_t e_phnum;
uint16_t e_shentsize;
uint16_t e_shnum;
uint16_t e_shstrndx;
} Elf64_Ehdr;
typedef struct
{
uint32_t p_type;
uint32_t p_offset;
uint32_t p_vaddr;
uint32_t p_paddr;
uint32_t p_filesz;
uint32_t p_memsz;
uint32_t p_flags;
uint32_t p_align;
} Elf32_Phdr;
typedef struct
{
uint32_t p_type;
uint32_t p_flags;
uint64_t p_offset;
uint64_t p_vaddr;
uint64_t p_paddr;
uint64_t p_filesz;
uint64_t p_memsz;
uint64_t p_align;
} Elf64_Phdr;
struct elfbuf
{
const char *path;
unsigned char *buf;
size_t len;
enum { ELFCLASS32 = 1,
ELFCLASS64 = 2 } ei_class;
};
#define ELFBUF_EHDR_LEN(elf) \
((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Ehdr) : \
sizeof (Elf64_Ehdr))
#define ELFBUF_EHDR(elf, memb) \
((elf)->ei_class == ELFCLASS32 ? \
((Elf32_Ehdr *) (elf)->buf)->memb \
: ((Elf64_Ehdr *) (elf)->buf)->memb)
#define ELFBUF_PHDR_LEN(elf) \
((elf)->ei_class == ELFCLASS32 ? sizeof (Elf32_Phdr) : \
sizeof (Elf64_Phdr))
#define ELFBUF_PHDR(elf, idx, memb) \
((elf)->ei_class == ELFCLASS32 ? \
((Elf32_Phdr *) &(elf)->buf[((Elf32_Ehdr *)(elf)->buf) \
->e_phoff])[idx].memb \
: ((Elf64_Phdr *) &(elf)->buf[((Elf64_Ehdr *)(elf)->buf) \
->e_phoff])[idx].memb)
static void
exit_with_msg(const char *fmt, ...)
{
va_list ap;
fflush (stdout);
va_start (ap, fmt);
vfprintf (stderr, fmt, ap);
va_end (ap);
if (errno)
{
fputs (": ", stderr);
perror (NULL);
}
else
fputc ('\n', stderr);
exit (1);
}
static void
read_file (unsigned char **buf_ptr, size_t *len_ptr, FILE *fp)
{
size_t len = 0;
size_t size = 1024;
size_t chunk;
unsigned char *buf = malloc (size);
while ((chunk = fread (buf + len, 1, size - len, fp)) == size - len)
{
len = size;
size *= 2;
buf = realloc (buf, size);
}
len += chunk;
*buf_ptr = buf;
*len_ptr = len;
}
static void
write_file (unsigned char *buf, size_t len, FILE *fp)
{
fwrite (buf, 1, len, fp);
}
static void
elfbuf_init_from_file (struct elfbuf *elf, const char *path)
{
FILE *fp = fopen (path, "rb");
unsigned char *buf;
size_t len;
if (fp == NULL)
exit_with_msg ("%s", path);
read_file (&buf, &len, fp);
fclose (fp);
/* Validate ELF identification. */
if (len < 16
|| buf[0] != 0x7f || buf[1] != 0x45 || buf[2] != 0x4c || buf[3] != 0x46
|| buf[4] < 1 || buf[4] > 2 || buf[5] < 1 || buf[5] > 2)
exit_with_msg ("%s: unsupported or invalid ELF file", path);
elf->path = path;
elf->buf = buf;
elf->len = len;
elf->ei_class = buf[4];
if (ELFBUF_EHDR_LEN (elf) > len
|| ELFBUF_EHDR (elf, e_phoff) > len
|| ELFBUF_EHDR (elf, e_phnum) > ((len - ELFBUF_EHDR (elf, e_phoff))
/ ELFBUF_PHDR_LEN (elf)) )
exit_with_msg ("%s: unexpected end of data", path);
if (ELFBUF_EHDR (elf, e_phentsize) != ELFBUF_PHDR_LEN (elf))
exit_with_msg ("%s: inconsistent ELF header", path);
}
static void
elfbuf_write_to_file (struct elfbuf *elf, const char *path)
{
FILE *fp = fopen (path, "wb");
if (fp == NULL)
exit_with_msg ("%s", path);
write_file (elf->buf, elf->len, fp);
fclose (fp);
}
/* In the auxv note starting at OFFSET with size LEN, mask the hwcap
field using the HWCAP_MASK. */
static void
elfbuf_handle_auxv (struct elfbuf *elf, size_t offset, size_t len,
unsigned long hwcap_mask)
{
size_t i;
uint32_t *auxv32 = (uint32_t *) (elf->buf + offset);
uint64_t *auxv64 = (uint64_t *) auxv32;
size_t entry_size = elf->ei_class == ELFCLASS32 ?
sizeof (auxv32[0]) : sizeof (auxv64[0]);
for (i = 0; i < len / entry_size; i++)
{
uint64_t auxv_type = elf->ei_class == ELFCLASS32 ?
auxv32[2 * i] : auxv64[2 * i];
if (auxv_type == 0)
break;
if (auxv_type != 16)
continue;
if (elf->ei_class == ELFCLASS32)
auxv32[2 * i + 1] &= (uint32_t) hwcap_mask;
else
auxv64[2 * i + 1] &= (uint64_t) hwcap_mask;
}
}
/* In the note segment starting at OFFSET with size LEN, make notes
with type NOTE_TYPE unrecognizable by GDB. Also, mask the hwcap
field of any auxv notes using the HWCAP_MASK. */
static void
elfbuf_handle_note_segment (struct elfbuf *elf, size_t offset, size_t len,
unsigned note_type, unsigned long hwcap_mask)
{
size_t pos = 0;
while (pos + 12 < len)
{
uint32_t *note = (uint32_t *) (elf->buf + offset + pos);
size_t desc_pos = pos + 12 + ((note[0] + 3) & ~3);
size_t next_pos = desc_pos + ((note[1] + 3) & ~3);
if (desc_pos > len || next_pos > len)
exit_with_msg ("%s: corrupt notes data", elf->path);
if (note[2] == note_type)
note[2] |= 0xff000000;
else if (note[2] == 6 && hwcap_mask != 0)
elfbuf_handle_auxv (elf, offset + desc_pos, note[1],
hwcap_mask);
pos = next_pos;
}
}
static void
elfbuf_handle_core_notes (struct elfbuf *elf, unsigned note_type,
unsigned long hwcap_mask)
{
unsigned ph_idx;
if (ELFBUF_EHDR (elf, e_type) != 4)
exit_with_msg ("%s: not a core file", elf->path);
/* Iterate over program headers. */
for (ph_idx = 0; ph_idx != ELFBUF_EHDR (elf, e_phnum); ph_idx++)
{
size_t offset = ELFBUF_PHDR (elf, ph_idx, p_offset);
size_t filesz = ELFBUF_PHDR (elf, ph_idx, p_filesz);
if (offset > elf->len || filesz > elf->len - offset)
exit_with_msg ("%s: unexpected end of data", elf->path);
/* Deal with NOTE segments only. */
if (ELFBUF_PHDR (elf, ph_idx, p_type) != 4)
continue;
elfbuf_handle_note_segment (elf, offset, filesz, note_type,
hwcap_mask);
}
}
int
main (int argc, char *argv[])
{
unsigned note_type;
unsigned long hwcap_mask = 0;
struct elfbuf elf;
if (argc < 4)
{
abort ();
}
if (sscanf (argv[3], "%u", ¬e_type) != 1)
exit_with_msg ("%s: bad command line arguments\n", argv[0]);
if (argc >= 5)
{
if (sscanf (argv[4], "%lu", &hwcap_mask) != 1)
exit_with_msg ("%s: bad command line arguments\n", argv[0]);
}
elfbuf_init_from_file (&elf, argv[1]);
elfbuf_handle_core_notes (&elf, note_type, hwcap_mask);
elfbuf_write_to_file (&elf, argv[2]);
return 0;
}
|
the_stack_data/54826437.c | // https://eoj.i64d.com/problem/2568/
#include <stdio.h>
int main() {
long long a, b, sum=0;
int i, n, cnt;
scanf("%d", &n);
for(i=0; i<n; i++) {
cnt = 0;
scanf("%lld %lld", &a, &b);
sum = a+b;
while(sum){
cnt++;
sum /= 10;
}
printf("%lld\n", cnt);
}
return 0;
} |
the_stack_data/76701453.c | /* attrthread.c */
/* thread attributes example */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void * attr_thread1 (void *arg) {
printf ("Thread 1\n");
sleep (1);
return (void *) 1;
}
void * attr_thread2 (void *arg) {
printf ("Thread 2\n");
sleep (1);
return (void *) 2;
}
int main (void) {
pthread_attr_t attr;
pthread_t tid1, tid2;
int status;
void *result1;
void *result2;
pthread_attr_init (&attr);
status = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_JOINABLE);
if (status != 0) {
fprintf (stderr, "Setdetachstate\n");
exit (1);
}
pthread_create (&tid1, &attr, attr_thread1, NULL);
status = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
if (status != 0) {
fprintf (stderr, "Setdetachstate\n");
exit (1);
}
pthread_create (&tid2, &attr, attr_thread2, NULL);
pthread_attr_destroy (&attr);
pthread_join (tid1, &result1);
pthread_join (tid2, &result2);
printf ("res1 = %p\n", result1);
printf ("res2 = %p\n", result2);
return result1 != (void *) 1 || result2 != (void *) 2;
}
|
the_stack_data/150756.c | int main()
{
int a;
a =(1-(1-(1-(1-1))));
return a;
} |
the_stack_data/438549.c | #include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(){
int fd1;
char * myfifo = "/tmp/myfifo";
mkfifo(myfifo, 0666);
char str1[80];
while(1){
fd1 = open(myfifo, O_RDONLY);
read(fd1, str1, 80);
printf("%s\n",str1);
close(fd1);
// sleep(10);
}
} |
the_stack_data/844402.c | struct mutex;
struct kref;
typedef struct {
int counter;
} atomic_t;
int __VERIFIER_nondet_int(void);
extern void mutex_lock(struct mutex *lock);
extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
extern int mutex_lock_interruptible(struct mutex *lock);
extern int mutex_lock_killable(struct mutex *lock);
extern int mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass);
extern int mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass);
static inline int mutex_is_locked(struct mutex *lock);
extern int mutex_trylock(struct mutex *lock);
extern void mutex_unlock(struct mutex *lock);
extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
static inline int kref_put_mutex(struct kref *kref,
void (*release)(struct kref *kref),
struct mutex *lock);
static void specific_func(struct kref *kref);
void ldv_check_final_state(void);
void main(void)
{
struct mutex *mutex_1, *mutex_2, *mutex_3, *mutex_4, *mutex_5;
struct kref *kref;
atomic_t *counter;
mutex_lock(&mutex_1);
// missing mutex_unlock
ldv_check_final_state();
}
|
the_stack_data/18886620.c | /*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
int main() { fprintf(stdout, "asdf %d\n", 3); }
|
the_stack_data/215768410.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conj(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimag(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static doublecomplex c_b2 = {0.,0.};
static integer c__1 = 1;
/* > \brief \b ZHETRI_ROOK computes the inverse of HE matrix using the factorization obtained with the bounded
Bunch-Kaufman ("rook") diagonal pivoting method. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZHETRI_ROOK + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zhetri_
rook.f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zhetri_
rook.f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri_
rook.f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZHETRI_ROOK( UPLO, N, A, LDA, IPIV, WORK, INFO ) */
/* CHARACTER UPLO */
/* INTEGER INFO, LDA, N */
/* INTEGER IPIV( * ) */
/* COMPLEX*16 A( LDA, * ), WORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix */
/* > A using the factorization A = U*D*U**H or A = L*D*L**H computed by */
/* > ZHETRF_ROOK. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > Specifies whether the details of the factorization are stored */
/* > as an upper or lower triangular matrix. */
/* > = 'U': Upper triangular, form is A = U*D*U**H; */
/* > = 'L': Lower triangular, form is A = L*D*L**H. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is COMPLEX*16 array, dimension (LDA,N) */
/* > On entry, the block diagonal matrix D and the multipliers */
/* > used to obtain the factor U or L as computed by ZHETRF_ROOK. */
/* > */
/* > On exit, if INFO = 0, the (Hermitian) inverse of the original */
/* > matrix. If UPLO = 'U', the upper triangular part of the */
/* > inverse is formed and the part of A below the diagonal is not */
/* > referenced; if UPLO = 'L' the lower triangular part of the */
/* > inverse is formed and the part of A above the diagonal is */
/* > not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] IPIV */
/* > \verbatim */
/* > IPIV is INTEGER array, dimension (N) */
/* > Details of the interchanges and the block structure of D */
/* > as determined by ZHETRF_ROOK. */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is COMPLEX*16 array, dimension (N) */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its */
/* > inverse could not be computed. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date November 2013 */
/* > \ingroup complex16HEcomputational */
/* > \par Contributors: */
/* ================== */
/* > */
/* > \verbatim */
/* > */
/* > November 2013, Igor Kozachenko, */
/* > Computer Science Division, */
/* > University of California, Berkeley */
/* > */
/* > September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas, */
/* > School of Mathematics, */
/* > University of Manchester */
/* > \endverbatim */
/* ===================================================================== */
/* Subroutine */ int zhetri_rook_(char *uplo, integer *n, doublecomplex *a,
integer *lda, integer *ipiv, doublecomplex *work, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
doublereal d__1;
doublecomplex z__1, z__2;
/* Local variables */
doublecomplex temp, akkp1;
doublereal d__;
integer j, k;
doublereal t;
extern logical lsame_(char *, char *);
extern /* Double Complex */ VOID zdotc_(doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *);
integer kstep;
extern /* Subroutine */ int zhemv_(char *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *);
logical upper;
extern /* Subroutine */ int zcopy_(integer *, doublecomplex *, integer *,
doublecomplex *, integer *), zswap_(integer *, doublecomplex *,
integer *, doublecomplex *, integer *);
doublereal ak;
integer kp;
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
doublereal akp1;
/* -- LAPACK computational routine (version 3.5.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* November 2013 */
/* ===================================================================== */
/* Test the input parameters. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--ipiv;
--work;
/* Function Body */
*info = 0;
upper = lsame_(uplo, "U");
if (! upper && ! lsame_(uplo, "L")) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < f2cmax(1,*n)) {
*info = -4;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZHETRI_ROOK", &i__1, (ftnlen)11);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Check that the diagonal matrix D is nonsingular. */
if (upper) {
/* Upper triangular storage: examine D from bottom to top */
for (*info = *n; *info >= 1; --(*info)) {
i__1 = *info + *info * a_dim1;
if (ipiv[*info] > 0 && (a[i__1].r == 0. && a[i__1].i == 0.)) {
return 0;
}
/* L10: */
}
} else {
/* Lower triangular storage: examine D from top to bottom. */
i__1 = *n;
for (*info = 1; *info <= i__1; ++(*info)) {
i__2 = *info + *info * a_dim1;
if (ipiv[*info] > 0 && (a[i__2].r == 0. && a[i__2].i == 0.)) {
return 0;
}
/* L20: */
}
}
*info = 0;
if (upper) {
/* Compute inv(A) from the factorization A = U*D*U**H. */
/* K is the main loop index, increasing from 1 to N in steps of */
/* 1 or 2, depending on the size of the diagonal blocks. */
k = 1;
L30:
/* If K > N, exit from loop. */
if (k > *n) {
goto L70;
}
if (ipiv[k] > 0) {
/* 1 x 1 diagonal block */
/* Invert the diagonal block. */
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
d__1 = 1. / a[i__2].r;
a[i__1].r = d__1, a[i__1].i = 0.;
/* Compute column K of the inverse. */
if (k > 1) {
i__1 = k - 1;
zcopy_(&i__1, &a[k * a_dim1 + 1], &c__1, &work[1], &c__1);
i__1 = k - 1;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[a_offset], lda, &work[1], &c__1,
&c_b2, &a[k * a_dim1 + 1], &c__1);
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
i__3 = k - 1;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[k * a_dim1 + 1], &
c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
kstep = 1;
} else {
/* 2 x 2 diagonal block */
/* Invert the diagonal block. */
t = z_abs(&a[k + (k + 1) * a_dim1]);
i__1 = k + k * a_dim1;
ak = a[i__1].r / t;
i__1 = k + 1 + (k + 1) * a_dim1;
akp1 = a[i__1].r / t;
i__1 = k + (k + 1) * a_dim1;
z__1.r = a[i__1].r / t, z__1.i = a[i__1].i / t;
akkp1.r = z__1.r, akkp1.i = z__1.i;
d__ = t * (ak * akp1 - 1.);
i__1 = k + k * a_dim1;
d__1 = akp1 / d__;
a[i__1].r = d__1, a[i__1].i = 0.;
i__1 = k + 1 + (k + 1) * a_dim1;
d__1 = ak / d__;
a[i__1].r = d__1, a[i__1].i = 0.;
i__1 = k + (k + 1) * a_dim1;
z__2.r = -akkp1.r, z__2.i = -akkp1.i;
z__1.r = z__2.r / d__, z__1.i = z__2.i / d__;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
/* Compute columns K and K+1 of the inverse. */
if (k > 1) {
i__1 = k - 1;
zcopy_(&i__1, &a[k * a_dim1 + 1], &c__1, &work[1], &c__1);
i__1 = k - 1;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[a_offset], lda, &work[1], &c__1,
&c_b2, &a[k * a_dim1 + 1], &c__1);
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
i__3 = k - 1;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[k * a_dim1 + 1], &
c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + (k + 1) * a_dim1;
i__2 = k + (k + 1) * a_dim1;
i__3 = k - 1;
zdotc_(&z__2, &i__3, &a[k * a_dim1 + 1], &c__1, &a[(k + 1) *
a_dim1 + 1], &c__1);
z__1.r = a[i__2].r - z__2.r, z__1.i = a[i__2].i - z__2.i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k - 1;
zcopy_(&i__1, &a[(k + 1) * a_dim1 + 1], &c__1, &work[1], &
c__1);
i__1 = k - 1;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[a_offset], lda, &work[1], &c__1,
&c_b2, &a[(k + 1) * a_dim1 + 1], &c__1);
i__1 = k + 1 + (k + 1) * a_dim1;
i__2 = k + 1 + (k + 1) * a_dim1;
i__3 = k - 1;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[(k + 1) * a_dim1 + 1]
, &c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
kstep = 2;
}
if (kstep == 1) {
/* Interchange rows and columns K and IPIV(K) in the leading */
/* submatrix A(1:k,1:k) */
kp = ipiv[k];
if (kp != k) {
if (kp > 1) {
i__1 = kp - 1;
zswap_(&i__1, &a[k * a_dim1 + 1], &c__1, &a[kp * a_dim1 +
1], &c__1);
}
i__1 = k - 1;
for (j = kp + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L40: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
} else {
/* Interchange rows and columns K and K+1 with -IPIV(K) and */
/* -IPIV(K+1) in the leading submatrix A(k+1:n,k+1:n) */
/* (1) Interchange rows and columns K and -IPIV(K) */
kp = -ipiv[k];
if (kp != k) {
if (kp > 1) {
i__1 = kp - 1;
zswap_(&i__1, &a[k * a_dim1 + 1], &c__1, &a[kp * a_dim1 +
1], &c__1);
}
i__1 = k - 1;
for (j = kp + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L50: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
i__1 = k + (k + 1) * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + (k + 1) * a_dim1;
i__2 = kp + (k + 1) * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + (k + 1) * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
/* (2) Interchange rows and columns K+1 and -IPIV(K+1) */
++k;
kp = -ipiv[k];
if (kp != k) {
if (kp > 1) {
i__1 = kp - 1;
zswap_(&i__1, &a[k * a_dim1 + 1], &c__1, &a[kp * a_dim1 +
1], &c__1);
}
i__1 = k - 1;
for (j = kp + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L60: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
}
++k;
goto L30;
L70:
;
} else {
/* Compute inv(A) from the factorization A = L*D*L**H. */
/* K is the main loop index, decreasing from N to 1 in steps of */
/* 1 or 2, depending on the size of the diagonal blocks. */
k = *n;
L80:
/* If K < 1, exit from loop. */
if (k < 1) {
goto L120;
}
if (ipiv[k] > 0) {
/* 1 x 1 diagonal block */
/* Invert the diagonal block. */
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
d__1 = 1. / a[i__2].r;
a[i__1].r = d__1, a[i__1].i = 0.;
/* Compute column K of the inverse. */
if (k < *n) {
i__1 = *n - k;
zcopy_(&i__1, &a[k + 1 + k * a_dim1], &c__1, &work[1], &c__1);
i__1 = *n - k;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[k + 1 + (k + 1) * a_dim1], lda,
&work[1], &c__1, &c_b2, &a[k + 1 + k * a_dim1], &c__1);
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
i__3 = *n - k;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[k + 1 + k * a_dim1],
&c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
kstep = 1;
} else {
/* 2 x 2 diagonal block */
/* Invert the diagonal block. */
t = z_abs(&a[k + (k - 1) * a_dim1]);
i__1 = k - 1 + (k - 1) * a_dim1;
ak = a[i__1].r / t;
i__1 = k + k * a_dim1;
akp1 = a[i__1].r / t;
i__1 = k + (k - 1) * a_dim1;
z__1.r = a[i__1].r / t, z__1.i = a[i__1].i / t;
akkp1.r = z__1.r, akkp1.i = z__1.i;
d__ = t * (ak * akp1 - 1.);
i__1 = k - 1 + (k - 1) * a_dim1;
d__1 = akp1 / d__;
a[i__1].r = d__1, a[i__1].i = 0.;
i__1 = k + k * a_dim1;
d__1 = ak / d__;
a[i__1].r = d__1, a[i__1].i = 0.;
i__1 = k + (k - 1) * a_dim1;
z__2.r = -akkp1.r, z__2.i = -akkp1.i;
z__1.r = z__2.r / d__, z__1.i = z__2.i / d__;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
/* Compute columns K-1 and K of the inverse. */
if (k < *n) {
i__1 = *n - k;
zcopy_(&i__1, &a[k + 1 + k * a_dim1], &c__1, &work[1], &c__1);
i__1 = *n - k;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[k + 1 + (k + 1) * a_dim1], lda,
&work[1], &c__1, &c_b2, &a[k + 1 + k * a_dim1], &c__1);
i__1 = k + k * a_dim1;
i__2 = k + k * a_dim1;
i__3 = *n - k;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[k + 1 + k * a_dim1],
&c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + (k - 1) * a_dim1;
i__2 = k + (k - 1) * a_dim1;
i__3 = *n - k;
zdotc_(&z__2, &i__3, &a[k + 1 + k * a_dim1], &c__1, &a[k + 1
+ (k - 1) * a_dim1], &c__1);
z__1.r = a[i__2].r - z__2.r, z__1.i = a[i__2].i - z__2.i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = *n - k;
zcopy_(&i__1, &a[k + 1 + (k - 1) * a_dim1], &c__1, &work[1], &
c__1);
i__1 = *n - k;
z__1.r = -1., z__1.i = 0.;
zhemv_(uplo, &i__1, &z__1, &a[k + 1 + (k + 1) * a_dim1], lda,
&work[1], &c__1, &c_b2, &a[k + 1 + (k - 1) * a_dim1],
&c__1);
i__1 = k - 1 + (k - 1) * a_dim1;
i__2 = k - 1 + (k - 1) * a_dim1;
i__3 = *n - k;
zdotc_(&z__2, &i__3, &work[1], &c__1, &a[k + 1 + (k - 1) *
a_dim1], &c__1);
d__1 = z__2.r;
z__1.r = a[i__2].r - d__1, z__1.i = a[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
}
kstep = 2;
}
if (kstep == 1) {
/* Interchange rows and columns K and IPIV(K) in the trailing */
/* submatrix A(k:n,k:n) */
kp = ipiv[k];
if (kp != k) {
if (kp < *n) {
i__1 = *n - kp;
zswap_(&i__1, &a[kp + 1 + k * a_dim1], &c__1, &a[kp + 1 +
kp * a_dim1], &c__1);
}
i__1 = kp - 1;
for (j = k + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L90: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
} else {
/* Interchange rows and columns K and K-1 with -IPIV(K) and */
/* -IPIV(K-1) in the trailing submatrix A(k-1:n,k-1:n) */
/* (1) Interchange rows and columns K and -IPIV(K) */
kp = -ipiv[k];
if (kp != k) {
if (kp < *n) {
i__1 = *n - kp;
zswap_(&i__1, &a[kp + 1 + k * a_dim1], &c__1, &a[kp + 1 +
kp * a_dim1], &c__1);
}
i__1 = kp - 1;
for (j = k + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L100: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
i__1 = k + (k - 1) * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + (k - 1) * a_dim1;
i__2 = kp + (k - 1) * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + (k - 1) * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
/* (2) Interchange rows and columns K-1 and -IPIV(K-1) */
--k;
kp = -ipiv[k];
if (kp != k) {
if (kp < *n) {
i__1 = *n - kp;
zswap_(&i__1, &a[kp + 1 + k * a_dim1], &c__1, &a[kp + 1 +
kp * a_dim1], &c__1);
}
i__1 = kp - 1;
for (j = k + 1; j <= i__1; ++j) {
d_cnjg(&z__1, &a[j + k * a_dim1]);
temp.r = z__1.r, temp.i = z__1.i;
i__2 = j + k * a_dim1;
d_cnjg(&z__1, &a[kp + j * a_dim1]);
a[i__2].r = z__1.r, a[i__2].i = z__1.i;
i__2 = kp + j * a_dim1;
a[i__2].r = temp.r, a[i__2].i = temp.i;
/* L110: */
}
i__1 = kp + k * a_dim1;
d_cnjg(&z__1, &a[kp + k * a_dim1]);
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = k + k * a_dim1;
temp.r = a[i__1].r, temp.i = a[i__1].i;
i__1 = k + k * a_dim1;
i__2 = kp + kp * a_dim1;
a[i__1].r = a[i__2].r, a[i__1].i = a[i__2].i;
i__1 = kp + kp * a_dim1;
a[i__1].r = temp.r, a[i__1].i = temp.i;
}
}
--k;
goto L80;
L120:
;
}
return 0;
/* End of ZHETRI_ROOK */
} /* zhetri_rook__ */
|
the_stack_data/1068.c | #include <stdio.h>
//Array size and array numbers are input. You should output the maximum occurring number.
int main(){
int i;
int n;
int count=0;
int flag=1;
int temp;
int temp_2 = -1;
int number;
scanf("%d", &n);
int num[n];
for (i=0;i<n;i++){
scanf("%d", &num[i]);
}
do{
flag=0;
for (i=0;i<n-1;i++){
if (num[i] > num[i+1]){
flag = 1;
temp = num[i];
num[i]=num[i+1];
num[i+1]=temp;
}
}
}while(flag==1);
for (i=0;i<n;i++){
if(num[i] == num[i+1]){
count++;
}
if (count > 0){
if (count > temp_2){
temp_2 = count;
number = num[i];
}
if (num[i]>num[i+1]){
count=0;
}
}
}
printf("%d", number);
}
|
the_stack_data/29824925.c | #define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define MAX_INPUT_LENGTH 12
#define MAX_LINES 12
int main(int argc, char *argv[]) {
if (argc != 2) {
printf("Missing input file");
return 1;
}
FILE *file = fopen(argv[1], "r");
if (file == NULL) {
printf("Failed to open the input file");
return 1;
}
// Create a counter to store for each line the number of 0 and 1
int counter[MAX_INPUT_LENGTH][2] = {0};
char input[MAX_INPUT_LENGTH];
int input_length = MAX_INPUT_LENGTH;
while(fscanf(file, "%s\n", input) != EOF) {
for (int i = 0; i < input_length; i++) {
switch (input[i]) {
case '0':
counter[i][0]++;
break;
case '1':
counter[i][1]++;
break;
case '\0':
input_length=i;
default:
break;
}
}
}
uint16_t gamma_rate = 0;
uint16_t epsilon_rate = 0;
for (int i=0; i < input_length; i++) {
int shift = (input_length - 1) - i;
if (counter[i][1] > counter[i][0]) {
gamma_rate |= (1 << shift);
} else {
epsilon_rate |= (1 << shift);
}
}
printf("%d\n", gamma_rate * epsilon_rate);
fclose(file);
return 0;
}
|
the_stack_data/635607.c | // RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32i -x c -E -dM %s \
// RUN: -o - | FileCheck %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64i -x c -E -dM %s \
// RUN: -o - | FileCheck %s
// CHECK-NOT: __riscv_div
// CHECK-NOT: __riscv_mul
// CHECK-NOT: __riscv_muldiv
// CHECK-NOT: __riscv_compressed
// CHECK-NOT: __riscv_bitmanip
// CHECK-NOT: __riscv_flen
// CHECK-NOT: __riscv_fdiv
// CHECK-NOT: __riscv_fsqrt
// CHECK-NOT: __riscv_atomic
// CHECK-NOT: __riscv_zba
// CHECK-NOT: __riscv_zbb
// CHECK-NOT: __riscv_zbc
// CHECK-NOT: __riscv_zbe
// CHECK-NOT: __riscv_zbf
// CHECK-NOT: __riscv_zbm
// CHECK-NOT: __riscv_zbp
// CHECK-NOT: __riscv_zbproposedc
// CHECK-NOT: __riscv_zbr
// CHECK-NOT: __riscv_zbs
// CHECK-NOT: __riscv_zbt
// CHECK-NOT: __riscv_zfh
// CHECK-NOT: __riscv_zvamo
// CHECK-NOT: __riscv_zvlsseg
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32im -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-M-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64im -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-M-EXT %s
// CHECK-M-EXT: __riscv_div 1
// CHECK-M-EXT: __riscv_m 2000000
// CHECK-M-EXT: __riscv_mul 1
// CHECK-M-EXT: __riscv_muldiv 1
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ia -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-A-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ia -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-A-EXT %s
// CHECK-A-EXT: __riscv_a 2000000
// CHECK-A-EXT: __riscv_atomic 1
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32if -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-F-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64if -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-F-EXT %s
// CHECK-F-EXT: __riscv_f 2000000
// CHECK-F-EXT: __riscv_fdiv 1
// CHECK-F-EXT: __riscv_flen 32
// CHECK-F-EXT: __riscv_fsqrt 1
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ifd -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-D-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ifd -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-D-EXT %s
// CHECK-D-EXT: __riscv_d 2000000
// CHECK-D-EXT: __riscv_fdiv 1
// CHECK-D-EXT: __riscv_flen 64
// CHECK-D-EXT: __riscv_fsqrt 1
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ic -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-C-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ic -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-C-EXT %s
// CHECK-C-EXT: __riscv_c 2000000
// CHECK-C-EXT: __riscv_compressed 1
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32ib0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-B-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64ib0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-B-EXT %s
// CHECK-B-EXT: __riscv_b 93000
// CHECK-B-EXT: __riscv_bitmanip 1
// CHECK-B-EXT: __riscv_zba 93000
// CHECK-B-EXT: __riscv_zbb 93000
// CHECK-B-EXT: __riscv_zbc 93000
// CHECK-B-EXT: __riscv_zbe 93000
// CHECK-B-EXT: __riscv_zbf 93000
// CHECK-B-EXT: __riscv_zbm 93000
// CHECK-B-EXT: __riscv_zbp 93000
// CHECK-B-EXT: __riscv_zbr 93000
// CHECK-B-EXT: __riscv_zbs 93000
// CHECK-B-EXT: __riscv_zbt 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ifd -mabi=ilp32 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-SOFT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ifd -mabi=lp64 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-SOFT %s
// CHECK-SOFT: __riscv_float_abi_soft 1
// CHECK-SOFT-NOT: __riscv_float_abi_single
// CHECK-SOFT-NOT: __riscv_float_abi_double
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ifd -mabi=ilp32f -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-SINGLE %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ifd -mabi=lp64f -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-SINGLE %s
// CHECK-SINGLE: __riscv_float_abi_single 1
// CHECK-SINGLE-NOT: __riscv_float_abi_soft
// CHECK-SINGLE-NOT: __riscv_float_abi_double
// RUN: %clang -target riscv32-unknown-linux-gnu -march=rv32ifd -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-DOUBLE %s
// RUN: %clang -target riscv64-unknown-linux-gnu -march=rv64ifd -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-DOUBLE %s
// CHECK-DOUBLE: __riscv_float_abi_double 1
// CHECK-DOUBLE-NOT: __riscv_float_abi_soft
// CHECK-DOUBLE-NOT: __riscv_float_abi_single
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
// RUN: -march=rv32iv1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
// RUN: -march=rv64iv1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izvamo1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv32izvamo1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izvlsseg1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv32izvlsseg1p0 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
// CHECK-V-EXT: __riscv_v 1000000
// CHECK-V-EXT: __riscv_vector 1
// CHECK-V-EXT: __riscv_zvamo 1000000
// CHECK-V-EXT: __riscv_zvlsseg 1000000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izba0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBA-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izba0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBA-EXT %s
// CHECK-ZBA-NOT: __riscv_b
// CHECK-ZBA-EXT: __riscv_zba 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbb0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBB-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbb0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBB-EXT %s
// CHECK-ZBB-NOT: __riscv_b
// CHECK-ZBB-EXT: __riscv_zbb 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbc0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBC-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbc0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBC-EXT %s
// CHECK-ZBC-NOT: __riscv_b
// CHECK-ZBC-EXT: __riscv_zbc 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbe0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBE-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbe0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBE-EXT %s
// CHECK-ZBE-NOT: __riscv_b
// CHECK-ZBE-EXT: __riscv_zbe 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbf0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBF-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbf0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBF-EXT %s
// CHECK-ZBF-NOT: __riscv_b
// CHECK-ZBF-EXT: __riscv_zbf 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbm0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBM-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbm0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBM-EXT %s
// CHECK-ZBM-NOT: __riscv_b
// CHECK-ZBM-EXT: __riscv_zbm 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbp0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBP-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbp0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBP-EXT %s
// CHECK-ZBP-NOT: __riscv_b
// CHECK-ZBP-EXT: __riscv_zbp 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbproposedc0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBPROPOSEDC-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbproposedc0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBPROPOSEDC-EXT %s
// CHECK-ZBPROPOSEDC-NOT: __riscv_b
// CHECK-ZBPROPOSEDC-EXT: __riscv_zbproposedc 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbr0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBR-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbr0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBR-EXT %s
// CHECK-ZBR-NOT: __riscv_b
// CHECK-ZBR-EXT: __riscv_zbr 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbs0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBS-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbs0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBS-EXT %s
// CHECK-ZBS-NOT: __riscv_b
// CHECK-ZBS-EXT: __riscv_zbs 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izbt0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBT-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izbt0p93 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZBT-EXT %s
// CHECK-ZBT-NOT: __riscv_b
// CHECK-ZBT-EXT: __riscv_zbt 93000
// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions -march=rv32izfh0p1 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZFH-EXT %s
// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions -march=rv64izfh0p1 -x c -E -dM %s \
// RUN: -o - | FileCheck --check-prefix=CHECK-ZFH-EXT %s
// CHECK-ZFH-EXT: __riscv_zfh 1000
|
the_stack_data/533924.c | int global;
int main()
{
__CPROVER_ASYNC_1: global=2;
__CPROVER_atomic_begin();
global=1;
// no interleaving here
assert(global==1);
__CPROVER_atomic_end();
}
|
the_stack_data/75136734.c | #include <stdbool.h>
#include <stdio.h>
#include <sys/time.h>
void ffiapi_receiveInput(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes) {
return;
}
void ffiapi_sendOutput(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes) {
return;
}
void ffiapi_logInfo(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes){
printf("INFO: %s\n", parameter);
}
void ffiapi_logDebug(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes){
printf("DEBUG: %s\n", parameter);
}
void ffiapi_logError(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes){
printf("ERROR: %s\n", parameter);
}
int difftimeval(struct timeval end, struct timeval start) {
return (end.tv_sec - start.tv_sec)* 1000000
+ (end.tv_usec - start.tv_usec);
}
// Waits until 0.5 seconds after last pacer tick
void ffisb_pacer_notification_wait(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes) {
static bool firstRun = true;
static struct timeval prev;
if (firstRun) {
firstRun = false;
gettimeofday(&prev, NULL);
} else {
struct timeval now;
gettimeofday(&now, NULL);
for(; difftimeval(now, prev) < 500000; gettimeofday(&now, NULL)) {}
prev = now;
}
output[0] = true;
}
void ffisb_pacer_notification_emit(unsigned char *parameter, long parameterSizeBytes, unsigned char *output, long outputSizeBytes) {
output[0] = true;
} |
the_stack_data/14073.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 long input[1] , unsigned long output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
void megaInit(void)
{
{
}
}
void RandomFunc(unsigned long input[1] , unsigned long output[1] )
{
unsigned long state[1] ;
unsigned long local1 ;
unsigned int copy11 ;
unsigned int copy12 ;
{
state[0UL] = (input[0UL] & 914778474UL) << 7UL;
local1 = 0UL;
while (local1 < input[1UL]) {
if (state[0UL] > local1) {
state[local1] = state[0UL] << (((state[local1] >> 1UL) & 7UL) | 1UL);
} else {
copy11 = *((unsigned int *)(& state[0UL]) + 0);
*((unsigned int *)(& state[0UL]) + 0) = *((unsigned int *)(& state[0UL]) + 1);
*((unsigned int *)(& state[0UL]) + 1) = copy11;
}
if (state[0UL] < local1) {
state[local1] = state[0UL] >> (((state[0UL] >> 3UL) & 7UL) | 1UL);
} else {
copy12 = *((unsigned int *)(& state[local1]) + 0);
*((unsigned int *)(& state[local1]) + 0) = *((unsigned int *)(& state[local1]) + 1);
*((unsigned int *)(& state[local1]) + 1) = copy12;
}
local1 ++;
}
output[0UL] = state[0UL] | 538181890UL;
}
}
int main(int argc , char *argv[] )
{
unsigned long input[1] ;
unsigned long output[1] ;
int randomFuns_i5 ;
unsigned long randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == 4242424242UL) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%lu\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
|
the_stack_data/495113.c | /*
* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/** \file
* \brief Set ieee floating point environment.
*/
#include <fenv.h>
int
__fenv_fegetround(void)
{
return fegetround();
}
int
__fenv_fesetround(int rmode)
{
return fesetround(rmode);
}
int
__fenv_fegetexceptflag(fexcept_t *flagp, int exc)
{
return fegetexceptflag(flagp, exc);
}
int
__fenv_fesetexceptflag(fexcept_t *flagp, int exc)
{
return fesetexceptflag(flagp, exc);
}
int
__fenv_fetestexcept(int exc)
{
return fetestexcept(exc);
}
int
__fenv_feclearexcept(int exc)
{
return feclearexcept(exc);
}
int
__fenv_feraiseexcept(int exc)
{
return feraiseexcept(exc);
}
int
__fenv_feenableexcept(int exc)
{
return feenableexcept(exc);
}
int
__fenv_fedisableexcept(int exc)
{
return fedisableexcept(exc);
}
int
__fenv_fegetexcept(void)
{
return fegetexcept();
}
int
__fenv_fegetenv(fenv_t *env)
{
return fegetenv(env);
}
int
__fenv_feholdexcept(fenv_t *env)
{
return feholdexcept(env);
}
int
__fenv_fesetenv(fenv_t *env)
{
return fesetenv(env);
}
int
__fenv_feupdateenv(fenv_t *env)
{
return feupdateenv(env);
}
/** \brief Unimplemented: Set (flush to zero) underflow mode
*
* \param uflow zero to allow denorm numbers,
* non-zero integer to flush to zero
*/
int
__fenv_fesetzerodenorm(int uflow)
{
return 0;
}
/** \brief Unimplemented: Get (flush to zero) underflow mode
*
* \return 1 if flush to zero is set, 0 otherwise
*/
int
__fenv_fegetzerodenorm(void)
{
return 0;
}
|
the_stack_data/33735.c | #include <stdlib.h>
#include <stdio.h>
#define MAX(A, B) (((A) > (B)) ? (A) : (B))
char** readTriangle(FILE *, int *);
void freeTriangle(char **, int);
int solveTriangle(char **, int, int, int);
int main(int argc, char *argv[]) {
FILE *file = fopen("triangle.txt", "r");
if (file == NULL) {
return EXIT_FAILURE;
}
int rows;
char **triangle = readTriangle(file, &rows);
fclose(file);
if (triangle == NULL) {
return EXIT_FAILURE;
}
if (rows > 0) {
printf("Solution: %d.\n", solveTriangle(triangle, 0, 0, rows));
}
freeTriangle(triangle, rows);
return EXIT_SUCCESS;
}
char **readTriangle(FILE *file, int *rows) {
fseek(file, 0, SEEK_END);
int length = ftell(file), fileIndex = 0, limit = 3;
*rows = 0;
if (length >= limit) {
while (fileIndex < length) {
fileIndex += limit;
limit += 3;
(*rows)++;
}
}
char **triangle = malloc(sizeof(*triangle) * (*rows));
if (triangle == NULL) {
return NULL;
}
rewind(file);
char number[3] = { 0 };
int i, j;
for (i = 0; i < *rows; i++) {
triangle[i] = malloc(sizeof(**triangle) * (i + 1));
if (triangle[i] == NULL) {
freeTriangle(triangle, i);
return NULL;
}
for (j = 0; j <= i; j++) {
if (fread(number, 1, 2, file) != 2) {
freeTriangle(triangle, i + 1);
return NULL;
}
fseek(file, 1, SEEK_CUR);
triangle[i][j] = atoi(number);
}
}
return triangle;
}
void freeTriangle(char **triangle, int rows) {
while (--rows >= 0) {
free(triangle[rows]);
}
free(triangle);
}
int solveTriangle(char **triangle, int row, int column, int rows) {
int total = triangle[row][column];
if (rows > 1) {
if (row == rows - 2) {
char left = triangle[row + 1][column];
char right = triangle[row + 1][column + 1];
return total + MAX(left, right);
}
return total + MAX(solveTriangle(triangle, row + 1, column, rows), solveTriangle(triangle, row + 1, column + 1, rows));
}
return total;
}
|
the_stack_data/89201238.c | #include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
int r, c, p, graph[20][20];
char grid[20][20];
while (scanf("%d%d%d", &r, &c, &p) && r) {
memset(grid, 0, sizeof(grid));
memset(graph, -1, sizeof(graph));
for (int i = 0; i < r; i++)
scanf("%s", grid[i]);
int x = 0, y = p - 1, cnt = 0;
while (1) {
graph[x][y] = cnt++;
switch (grid[x][y]) {
case 'N' : x--; break;
case 'S' : x++; break;
case 'E' : y++; break;
case 'W' : y--; break;
}
/*
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++)
printf("%3d", graph[i][j]);
printf("\n");
}
printf("\n%d %d\n", x, y);
//*/
if (x < 0 || x == r || y < 0 || y == c) {
printf("%d step(s) to exit\n", cnt);
break;
}
if (graph[x][y] != -1) {
printf("%d step(s) before a loop of %d step(s)\n", graph[x][y], cnt - graph[x][y]);
break;
}
}
}
return 0;
} |
the_stack_data/50137853.c | /*
* Copyright (c) 2017, [Ribose Inc](https://www.ribose.com).
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <unistd.h>
int main(void)
{
fork();
return 0;
}
|
the_stack_data/115765993.c | // AP to store n employee’s data such as employee name, gender, designation, department, basic pay.
// Calculate the gross pay of each employees as follows:
// Gross pay = basic pay + HR + DA
// HR=25% of basic and DA=75% of basic.
#include<stdio.h>
#include<stdlib.h>
struct Employee
{
int id;
char name[50];
int age;
int basicpay;
};
void getDetails(struct Employee *s)
{
printf("Enter the employee details: \n");
printf("Enter the name: ");
scanf("%s",s->name);
printf("Enter the age: ");
scanf("%d",&s->age);
printf("Enter the ID: ");
scanf("%d",&s->id);
printf("Enter the basic pay: ");
scanf("%d",&s->basicpay);
}
void display(struct Employee s)
{
float grossSal = (float)(s.basicpay)*2;
printf("\t%d\t %s\t%d\t %.2f\n",s.id,s.name,s.age,grossSal);
}
int main()
{
int n;
printf("Enter the number of employees you want: ");
scanf("%d",&n);
struct Employee *a = (struct Employee *)malloc(n*sizeof(struct Employee));
for(int i=0;i<n;i++)
getDetails(&a[i]);
printf("-------------------------------------------------------\n");
printf("| Employee ID | Name | Age | Gross Salary |\n");
for(int i=0;i<n;i++)
display(a[i]);
printf("-------------------------------------------------------\n");
return 0;
} |
the_stack_data/73574160.c |
// To run:
// gcc 4.c -std=c99
//
// Problem:
// A palindromic number reads the same both ways. The largest palindrome
// made from the product of two 2-digit numbers is 9009 = 91 × 99.
//
// Find the largest palindrome made from the product of two 3-digit
// numbers.
#include <stdio.h>
#include <time.h>
int is_palindrome(int number) {
int original = number,
reversed = 0;
for(;number > 0; number /= 10) {
reversed = reversed * 10 + number % 10;
}
return original == reversed;
}
int solve() {
int max = 1000,
largest = 0;
for(int i=100; i < max; i++) {
for(int j=100; j < max; j++) {
if (is_palindrome(i*j) && (i*j > largest)) {
largest = i*j;
}
}
}
return largest;
}
int main() {
clock_t begin = clock();
int result = solve();
clock_t end = clock();
double time = (double)(end - begin) / CLOCKS_PER_SEC;
printf("%d [in %f seconds]", result, time);
}
|
the_stack_data/102706.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
typedef struct RangeEncoder
{
uint32_t range;
uint64_t low;
uint8_t cache;
uint32_t cachesize;
FILE *fh;
} RangeEncoder;
static void InitRangeEncoder(RangeEncoder *self,FILE *fh)
{
self->range=0xffffffff;
self->low=0;
self->cache=0xff; // TODO: Is this right? Original has cache=0 and cachesize=1,
self->cachesize=0; // and output a useless 0 byte at the start.
self->fh=fh;
}
static void ShiftOutputFromRangeEncoder(RangeEncoder *self)
{
if((self->low&0xffffffff)<0xff000000||(self->low>>32)!=0)
{
uint8_t temp=self->cache;
for(int i=0;i<self->cachesize;i++)
{
fputc((temp+(self->low>>32))&0xff,self->fh);
temp=0xff;
}
self->cachesize=0;
self->cache=(self->low>>24)&0xff;
}
self->cachesize++;
self->low=(self->low<<8)&0xffffffff;
}
static void WriteBitAndUpdateWeight(RangeEncoder *self,int bit,uint16_t *weight,int shift)
{
uint32_t threshold=(self->range>>12)*(*weight);
if(bit==0)
{
self->range=threshold;
*weight+=(0x1000-*weight)>>shift;
}
else
{
self->range-=threshold;
self->low+=threshold;
*weight-=*weight>>shift;
}
while(self->range<0x1000000)
{
self->range<<=8;
ShiftOutputFromRangeEncoder(self);
}
}
static void WriteUniversalCode(RangeEncoder *self,uint32_t value,uint16_t *weights1,int shift1,uint16_t *weights2,int shift2)
{
int maxbit=31;
while(maxbit>=0 && (value>>maxbit&1)==0) maxbit--;
for(int i=0;i<=maxbit;i++) WriteBitAndUpdateWeight(self,1,&weights1[i],shift1);
WriteBitAndUpdateWeight(self,0,&weights1[maxbit+1],shift1);
for(int i=maxbit-1;i>=0;i--) WriteBitAndUpdateWeight(self,(value>>i)&1,&weights2[i],shift2);
}
static void FinishRangeEncoder(RangeEncoder *self)
{
for(int i=0;i<5;i++)
{
ShiftOutputFromRangeEncoder(self);
}
}
typedef struct DictionaryEntry
{
uint32_t dataoffset,nextoffset;
} DictionaryEntry;
typedef struct DictionaryLookup
{
uint8_t *buf;
uint32_t size;
DictionaryEntry *entries;
uint32_t offsets[65536];
} DictionaryLookup;
static inline uint16_t GetUInt16LE(uint8_t *ptr)
{
return ptr[0]+(ptr[1]<<8);
}
static void InitDictionaryLookup(DictionaryLookup *self,uint8_t *buf,uint32_t size)
{
self->buf=buf;
self->size=size;
self->entries=malloc((size/2)*sizeof(DictionaryEntry));
memset(self->offsets,0xff,sizeof(self->offsets));
for(int i=size/2-2;i>=0;i--)
{
uint16_t val=GetUInt16LE(&buf[i*2]);
DictionaryEntry *entry=&self->entries[i];
entry->dataoffset=i*2;
entry->nextoffset=self->offsets[val];
self->offsets[val]=i;
}
}
static bool FindDictionaryMatch(DictionaryLookup *self,int start,int *length,int *offs)
{
int maxlength=0,maxpos=-1;
uint16_t first=GetUInt16LE(&self->buf[start]);
uint32_t entryoffset=self->offsets[first];
while(entryoffset!=0xffffffff && self->entries[entryoffset].dataoffset<start)
{
int pos=self->entries[entryoffset].dataoffset;
int matchlen=2;
while(pos+matchlen+2<=self->size && start+matchlen+2<=self->size
&& self->buf[pos+matchlen]==self->buf[start+matchlen]
&& self->buf[pos+matchlen+1]==self->buf[start+matchlen+1]) matchlen+=2;
if(matchlen>=maxlength) // Use >= to capture the *last* hit for multiples.
{
maxlength=matchlen;
maxpos=pos;
}
entryoffset=self->entries[entryoffset].nextoffset;
}
if(maxlength>=4)
{
*length=maxlength;
*offs=maxpos;
return true;
}
else return false;
}
void CompressData(FILE *fh,uint8_t *buf,uint32_t size,
int typeshift,int literalshift,int lengthshift1,int lengthshift2,int offsetshift1,int offsetshift2)
{
RangeEncoder comp;
InitRangeEncoder(&comp,fh);
DictionaryLookup dict;
InitDictionaryLookup(&dict,buf,size);
uint16_t typeweight=0x800;
uint16_t lengthweights1[32],lengthweights2[32];
uint16_t offsetweights1[32],offsetweights2[32];
for(int i=0;i<32;i++)
lengthweights1[i]=lengthweights2[i]=offsetweights1[i]=offsetweights2[i]=0x800;
uint16_t literalbitweights[16][16];
for(int i=0;i<16;i++)
for(int j=0;j<16;j++)
literalbitweights[i][j]=0x800;
int pos=0;
while(pos<size)
{
int length,offs;
if(FindDictionaryMatch(&dict,pos,&length,&offs))
{
WriteBitAndUpdateWeight(&comp,1,&typeweight,typeshift);
WriteUniversalCode(&comp,length/2-2,lengthweights1,lengthshift1,lengthweights2,lengthshift2);
WriteUniversalCode(&comp,(pos-offs)/2-1,offsetweights1,offsetshift1,offsetweights2,offsetshift2);
pos+=length;
}
else
{
WriteBitAndUpdateWeight(&comp,0,&typeweight,typeshift);
uint16_t val=GetUInt16LE(&buf[pos]);
for(int i=15;i>=0;i--)
{
WriteBitAndUpdateWeight(&comp,(val>>i)&1,&literalbitweights[i][(val>>(i+1))&15],literalshift);
}
pos+=2;
}
}
FinishRangeEncoder(&comp);
}
uint8_t *AllocAndReadFile(FILE *fh,uint32_t *size)
{
const int blocksize=4096;
uint8_t *buf=malloc(blocksize);
uint32_t total=0;
for(;;)
{
uint32_t actual=fread(buf+total,1,blocksize,fh);
total+=actual;
if(actual<blocksize) break;
buf=realloc(buf,total+blocksize);
}
*size=total;
return buf;
}
int main(int argc,char **argv)
{
if(argc!=1&&argc!=7)
{
fprintf(stderr,"Usage: %s <inputfile >outputfile [typeshift literalshift lengthshift1 lengthshift2 offsetshift1 offsetshift2]\n",argv[0]);
exit(1);
}
uint32_t size;
uint8_t *file=AllocAndReadFile(stdin,&size);
int typeshift=4,literalshift=2,lengthshift1=4,lengthshift2=4,offsetshift1=4,offsetshift2=4;
if(argc==7)
{
typeshift=atoi(argv[1]);
literalshift=atoi(argv[2]);
lengthshift1=atoi(argv[3]);
lengthshift2=atoi(argv[4]);
offsetshift1=atoi(argv[5]);
offsetshift2=atoi(argv[6]);
}
fputc(size&0xff,stdout);
fputc((size>>8)&0xff,stdout);
fputc((size>>16)&0xff,stdout);
fputc((size>>24)&0xff,stdout);
fputc((offsetshift1<<4)|offsetshift2,stdout);
fputc((lengthshift1<<4)|lengthshift2,stdout);
fputc((typeshift<<4)|literalshift,stdout);
CompressData(stdout,file,size,typeshift,literalshift,lengthshift1,lengthshift2,offsetshift1,offsetshift2);
}
|
the_stack_data/162643040.c | #include <string.h>
char* strtok_r(char* restrict s, const char* restrict sep, char** restrict p) {
if (!s && !(s = *p))
return NULL;
s += strspn(s, sep);
if (!*s)
return *p = 0;
*p = s + strcspn(s, sep);
if (**p)
*(*p)++ = 0;
else
*p = 0;
return s;
}
|
the_stack_data/125040.c | /*
FINDS CLUSTERS/(CLIQUES) IN A GRAPH.
call with :
./cliquedecomp LinkFile OutputFile InitialFile ClusterNumber Zloops Aloops beta Abeta Bbeta Vtoupdate DisplayError BurninSteps BurninBeta
For example:
./cliquedecomp polbooks_links.txt CliqueMatrix.txt random 200 20 10 10 1 20 25 1 5 0.01
LinkFile : a txt file containing on each line an element of the adjacency matrix, e.g. 3 5
OutputFile : the file on which the (transposed) clique matrix Z is stored
InitialFile : File containin initial clique matrix (in transposed order -- ie C rows, V cols). Only the top ClusterNumber rows are used If InitFile=random,
then a random initialisation is used, containing ClusterNumber clusters
ClusterNumber : initial number of clusters to find. The algorithm attempts to find a smaller number.
If 0, the uses the number of clusters in InitialFile.
Zloops : number of internal loops for fixed number of clusters
Aloops : number of exterior loops to try to find smallest number of clusters
beta : steepness of the logistic function (typically 10, but make higher to force low errors, make lower to accept errors)
Abeta : Beta function parameter (typically 1)
Bbeta : Beta function parameter (typically 10 -- make this higher if you want less clusters, but more errors)
Vtoupdate : the number of vertices to updates during the z-loop of the mean-field. Normally one would set this to the number of vertices in the graph, but setting it lower gives a faster approximate implementation. If set to zero, all vertices are updated.
DisplayError: set to 1 to display the errors (expensive to compute), otherwise set to 0
Burn in : Use a burn in of BurninSteps with BurninBeta
The adjacency matrix is approximated by A=ZZ' (under threshold arithmetic)
David Barber : University College London, October 2007
------------------------------------------------------
Compile with
gcc -O3 cliqedecomp.c -o cliquedecomp
---------------------------------
Works under :
Windows XP (Cygwin)
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//#include <math.h>
#define MAXV 250
#define MAXC 3000
#define MAXLINKS 100000
//#define DISP_ERRORS 1 /* set this to 0 to speed up by not displaying errors */
#define DISP_A 0
#define SMALLVALUE 0.1
#define THRESHOLD 0.5
int max_value(int p_array[MAXLINKS], int numlinks)
{
int position, p_max_value;
position = 0;
p_max_value = p_array[position];
for (position = 1; position < numlinks; ++position)
{
if (p_array[position] > p_max_value)
{p_max_value = p_array[position];}
}
return p_max_value;
}
int* randperm(int N)
{
int*ord = malloc(N*sizeof(int));
int i=0;
for (i = 0; i < N; ++i) {
int j = rand() % (i + 1);
ord[i] = ord[j];
ord[j] = i;
}
return ord;
}
float gammaln(float xx)
{
static float x,y,tmp,ser;
static float cof[6]={76.18009172947146,-86.50532032941677,
24.01409824083091,-1.231739572450155,
0.1208650973866179e-2,-0.5395239384953e-5};
int j;
y=x=xx;
tmp=x+5.5;
tmp -= (x+0.5)*log(tmp);
ser=1.000000000190015;
for (j=0;j<=5;j++) ser += cof[j]/++y;
return -tmp+log(2.5066282746310005*ser/x);
}
float betalog(float x, float y)
{return gammaln(x)+gammaln(y)-gammaln(x+y);}
float logsigma(float x, float beta, float Threshold)
{
static float y;
y = beta*(Threshold-x);
if (y<0.0){return -log(1.0+exp(y));}
else {return -y-log(1.0+exp(-y));};
}
float clogsigma(float x, float beta, float Threshold)
{
static float y;
y = beta*(Threshold-x);
if (y<0.0){return y-log(1.0+exp(y));}
else {return -log(1+exp(-y));}
}
int aintprint(bool a[MAXV][MAXV], int l)
{ int i,j;
for (i=0;i<l;i++){
for (j=0;j<l;j++){
printf("%d ",a[i][j]);
}
printf("\n");
}
return;}
int zfloatprint(float z[MAXV][MAXC], int V, int C)
{ static int i,j;
for (i=0;i<C;i++){
for (j=0;j<V;j++){
printf("%3.2f ",z[i][j]);
}
printf("\n");
}
printf("\n");
return;}
int mafloatprint(float ma[MAXC], int C)
{ static int i;
for (i=0;i<C;i++){
printf("%3.2f ",ma[i]);
}
printf("\n");
return;}
float loglik(float z[MAXV][MAXC], bool A[MAXV][MAXV],int V, int C, float beta, float Threshold)
{
static float loglik, field;
static int i,j,c;
loglik=0.0;
for (i=0;i<V;i++){
for (j=0;j<i+1;j++){ // check if can do this -- otherwise use j<V
field=0.0;
for (c=0;c<C;c++){
field+=z[i][c]*z[j][c];
}
if (A[i][j])
{loglik+=logsigma(field,beta,Threshold);}
else
{loglik+=clogsigma(field,beta,Threshold);}
}
}
return loglik;
}
void updateZ(char OutputFile[40], float zm[MAXV][MAXC], float zma[MAXV][MAXC], float ma[MAXC], bool A[MAXV][MAXV], int Zloops, int C, int V, int Vtoupdate, float beta, float Threshold,bool DISP_ERRORS)
{int *permC, *permV, loopz, loopc, cluster, loopvertexj, loopvertexk, vertexi,vertexk, vertexj, cl, i, j,k, errors, tmpi, tmpj;
float meanfield0,meanfield1,logfn1,logfn0,loglik1,loglik0,tmp, copybeta, dellog;
float Mold[MAXV][MAXV], zc[MAXV], Mk[MAXV];
static bool AA[MAXV][MAXV];
FILE *fpLinkFile, *fpOutputFile, *fpInitialFile;
for (loopz=0;loopz<Zloops;loopz++)
{
for (vertexi=0;vertexi<V;vertexi++)
{for (vertexj=0;vertexj<V;vertexj++)
{
Mold[vertexi][vertexj]=0.0;
for (cl=0;cl<C;cl++){
Mold[vertexi][vertexj]+=zma[vertexi][cl]*zma[vertexj][cl];}
}
}
permC=randperm(C);
for (loopc=0;loopc<C;loopc++)
{cluster=permC[loopc];
for (vertexi=0;vertexi<V;vertexi++) {zc[vertexi]=zma[vertexi][cluster];}
permV=randperm(V);
for (loopvertexk=0;loopvertexk<Vtoupdate;loopvertexk++)
{vertexk=permV[loopvertexk];
for (vertexi=0;vertexi<V;vertexi++)
{Mk[vertexi]=Mold[vertexi][vertexk]-zc[vertexi]*zc[vertexk]+zma[vertexi][cluster]*zma[vertexk][cluster];}
logfn1=0.0;logfn0=0.0;
for (vertexj=0;vertexj<V;vertexj++)
{meanfield0=Mk[vertexj]-zma[vertexj][cluster]*zma[vertexk][cluster]-0.5;
meanfield1=zma[vertexj][cluster]+meanfield0;
if (A[vertexj][vertexk]==1)
{logfn1+=logsigma(meanfield1,beta,0.0);
logfn0+= logsigma(meanfield0,beta,0.0);
}
else
{logfn1+= logsigma(-meanfield1,beta,0.0);
logfn0+= logsigma(-meanfield0,beta,0.0);
}
}
dellog=2*(logfn0-logfn1);
zm[vertexk][cluster]=1.0/(1.0+exp(dellog));
zma[vertexk][cluster]=zm[vertexk][cluster]*ma[cluster];
}
for (vertexi=0;vertexi<V;vertexi++)
{for (vertexj=0;vertexj<V;vertexj++)
{Mold[vertexi][vertexj]+=-zc[vertexi]*zc[vertexj]+zma[vertexi][cluster]*zma[vertexj][cluster];
}
}
}
printf("\n C[%d] Zloop[%d] beta[%4.2f]",C,loopz,beta);
/* compute the errors */
if (DISP_ERRORS==1){
errors=0;
for (i=0;i<V;i++)
{
for (j=0;j<i+1;j++)
{tmp=0;
for (k=0;k<C;k++)
{tmp+=zma[i][k]*zma[j][k];}
if (tmp>Threshold){AA[i][j]=1;}
else {AA[i][j]=0;}
AA[j][i]=AA[i][j];
if (AA[i][j]!=A[i][j]){errors+=+1;}
}
}
printf(", errors(threshold<Z><Z'>)=%d",errors);}
/* compute the errors */
if (DISP_ERRORS==1){
errors=0;
for (i=0;i<V;i++)
{
for (j=0;j<i+1;j++)
{tmp=0;
for (k=0;k<C;k++)
{tmp+= (zm[i][k]>Threshold)*(zm[j][k]>Threshold);}
if (tmp>0){AA[i][j]=1;}
else {AA[i][j]=0;}
AA[j][i]=AA[i][j];
if (AA[i][j]!=A[i][j]){errors+=+1;}
}
}
printf(", errors(threshold<Z>threshold<Z'>)=%d",errors);}
/* write out the cluster matrix (in transposed form): only those clusters that are on:*/
fpOutputFile = fopen(OutputFile, "w");
if(fpOutputFile==NULL){
printf("Error: can't open OutputFile %s\n",OutputFile);}
for (cluster=0;cluster<C;cluster++){
if (ma[cluster]>SMALLVALUE){
for (i=0;i<V;i++){
fprintf(fpOutputFile, "%f ", zm[i][cluster]);}}
fprintf(fpOutputFile,"\n");}
fclose(fpOutputFile);
//printf(" written (in transposed form) on %s\n",OutputFile);
}
}
main(int argc, char *argv[])
{int *permC, *permV, *permV2;
int loopz, loopa, loopc, cluster,loopvertexk,loopvertexj,j,i,k,Current,start,outloopc, newcluster;
int V,vertexk,vertexj,cl,errors,numlinks;
float meanfield0,meanfield1,logfn1,logfn0,loglik1,loglik0;
float tmp;
static float zma[MAXV][MAXC],zm[MAXV][MAXC], zmat[MAXV][MAXC];
static float zmatmp[MAXV][MAXC],zmtmp[MAXV][MAXC], matmp[MAXC];
static float ma[MAXC], atmp[MAXC], manew[MAXC], floatval[MAXV*MAXC];
int c,cc;
static bool A[MAXV][MAXV], AA[MAXV][MAXV];
float T1, T0, logprior0, logprior1, logpost0, logpost1;
char LinksInputFile[40], tmps[4];
int C=atoi(argv[4]);
int Zloops=atoi(argv[5]);
int Aloops=atoi(argv[6]);
float beta=atof(argv[7]);
float Abeta=atof(argv[8]);
float Bbeta=atof(argv[9]);
// float Threshold=atof(argv[10]);
float Threshold=THRESHOLD;
int Vtoupdate=atoi(argv[10]);
bool DISP_ERRORS=atoi(argv[11]);
int BurninSteps=atoi(argv[12]);
float BurninBeta=atof(argv[13]);
// char OutputFile=argv[2];
/* get the adjacency matrixc */
FILE *fpLinkFile, *fpOutputFile, *fpInitialFile;
int counter, vertex;
int ii[MAXLINKS],jj[MAXLINKS];
float fl;
srand(time(0));
bool dontstart=0;
bool randominit=1;
bool singleinit=0;
fpLinkFile = fopen(argv[1], "r");
if(fpLinkFile==NULL){
printf("Error: can't open LinkFile %s\n",argv[1]);
dontstart=1;}
if (strcmp(argv[3],"random")==0)
{singleinit=0; randominit=1;printf("\nRandom initialisation.\n");}
if (strcmp(argv[3],"single")==0)
{singleinit=1; randominit=1;printf("\nReplicated single cluster initialisation.\n");}
if (randominit==0)
{fpInitialFile = fopen(argv[3], "r");
if(fpInitialFile==NULL){
printf("Error: can't open InitialFile %s\n",argv[3]);
dontstart=1;
}}
if (dontstart==1){return 1;}
else
/* start the analysis : */
{
counter=0;
while(!feof(fpLinkFile)){
fscanf(fpLinkFile, "%d %d", &ii[counter], &jj[counter]);
counter++;
}
fclose(fpLinkFile);
numlinks=counter;
printf("LinkFile read successfully.\n");
/* find the number of vertices : */
int nums[2];
nums[0]=max_value(ii,numlinks);
nums[1]=max_value(jj,numlinks);
V = max_value(nums,2);
printf("Number of vertices =%d\n",V);
if (Vtoupdate==0){Vtoupdate=V;}
printf("Will update at each iteration %d randomly selected vertices\n",Vtoupdate);
if (randominit==0){
cluster=0;
while(!feof(fpInitialFile)){
for (vertex=0;vertex<V;vertex++){
fscanf(fpInitialFile, "%f ",&zm[vertex][cluster]);
}
++cluster;
}
fclose(fpInitialFile);
printf("InitFile read successfully.\n");
if (C==0){C=cluster;}}
/* setup mean alpha */
for (i=0;i<C;i++){ma[i]=1.0;}
/* initialise Z */
for (i=0;i<C;i++)
{ for (j=0;j<V;j++)
{if (randominit==1){zm[j][i]=1.0*(rand()>0.5*RAND_MAX);} /* initial to 0.05 not important */
zma[j][i]=ma[i]*zm[j][i];
}
}
/* setup adj matrix based on links */
for (i=0;i<V;i++)
{ for (j=0;j<i;j++)
{
A[j][i]=0; A[i][j]=0;
}
A[i][i]=1;
}
for (counter=0;counter<numlinks;counter++)
{A[ii[counter]-1][jj[counter]-1]=1;A[jj[counter]-1][ii[counter]-1]=1;}
if (singleinit==1)
{printf("\nFinding first a single cluster based on random initialisation....\n");
updateZ(argv[2],zm,zma,ma,A,BurninSteps,1,V,V,BurninBeta,Threshold,DISP_ERRORS);
for (i=1;i<C;i++)
{ for (j=0;j<V;j++)
{zm[j][i]=zm[k][0];zma[j][i]=ma[i]*zm[j][i];
}
}
}
printf("\n\nFinding the clique matrix marginals p(z[vertex][cluster]=1|adjacency matrix):\n");
if (BurninSteps>0){updateZ(argv[2],zm,zma,ma,A,BurninSteps,C,V,Vtoupdate,BurninBeta,Threshold,DISP_ERRORS);}
for (loopa=0;loopa<=Aloops;loopa++)
{if (loopa==0) {updateZ(argv[2],zm,zma,ma,A,Zloops,C,V,Vtoupdate,beta,Threshold,DISP_ERRORS);}
else
{updateZ(argv[2],zm,zma,ma,A,Zloops,C,V,Vtoupdate,beta,Threshold,DISP_ERRORS);}
if (loopa<Aloops){
/* update alpha */
printf("\n[%d]Updating number of clusters",loopa);
for (i=0;i<V;i++){
for (cluster=0;cluster<C;cluster++){zmat[i][cluster]=zma[i][cluster];}}
for (c=0;c<C;c++){manew[c]=0.0;}
for (cluster=0;cluster<C;cluster++)
{
for (i=0;i<V;i++){zmat[i][cluster]=zm[i][cluster];}
loglik1=loglik(zmat,A,V,C,beta,Threshold);
for (i=0;i<V;i++){zmat[i][cluster]=0.0;}
loglik0=loglik(zmat,A,V,C,beta,Threshold);
for (i=0;i<V;i++){zmat[i][cluster]=zma[i][cluster];}
for (c=0;c<C;c++){atmp[c]=ma[c];}
atmp[cluster]=1.0;
T1=0.0;
for (c=0;c<C;c++){T1+=atmp[c];}
T0=1.0*C-T1;
logprior1=betalog(Abeta+T1,Bbeta+T0);
atmp[cluster]=0.0;
T1=0.0;
for (c=0;c<C;c++){T1+=atmp[c];}
T0=1.0*C-T1;
logprior0=betalog(Abeta+T1,Bbeta+T0);
logpost1=logprior1+loglik1;
logpost0=logprior0+loglik0;
ma[cluster]=1.0/(1.0+exp(logpost0-logpost1));
}
cluster=0; newcluster=0;
for (cluster=0;cluster<C;cluster++){
matmp[cluster]=ma[cluster];
for (i=0;i<V;i++){
zmatmp[i][cluster]=zma[i][cluster];
zmtmp[i][cluster]=zm[i][cluster];
}
}
for (cluster=0;cluster<C;cluster++){
if (ma[cluster]>SMALLVALUE){
for (i=0;i<V;i++){
zma[i][newcluster]=zmatmp[i][cluster];
zm[i][newcluster]=zmtmp[i][cluster];
}
ma[newcluster]=matmp[cluster];
newcluster++;
}
}
C=newcluster;
}
}
}
}
|
the_stack_data/37638520.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* x11_test.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: sid <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/18 00:18:03 by sid #+# #+# */
/* Updated: 2015/12/18 00:18:28 by sid ### ########.fr */
/* */
/* ************************************************************************** */
/*
* Simple Xlib application drawing a box in a window.
* gcc input.c -o output -lX11
*/
#include <X11/Xlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
Display *display;
Window window;
XEvent event;
char *msg = "Hello, World!";
int s;
/* open connection with the server */
display = XOpenDisplay(NULL);
if (display == NULL)
{
fprintf(stderr, "Cannot open display\n");
exit(1);
}
s = DefaultScreen(display);
/* create window */
window = XCreateSimpleWindow(display, RootWindow(display, s), 10, 10, 200, 200, 1,
BlackPixel(display, s), WhitePixel(display, s));
/* select kind of events we are interested in */
XSelectInput(display, window, ExposureMask | KeyPressMask);
/* map (show) the window */
XMapWindow(display, window);
/* event loop */
for (;;)
{
XNextEvent(display, &event);
/* draw or redraw the window */
if (event.type == Expose)
{
XFillRectangle(display, window, DefaultGC(display, s), 20, 20, 10, 10);
XDrawString(display, window, DefaultGC(display, s), 50, 50, msg, strlen(msg));
}
/* exit on key press */
if (event.type == KeyPress)
break;
}
/* close connection to server */
XCloseDisplay(display);
return 0;
}
|
the_stack_data/92327022.c | #include <stdio.h>
#include <omp.h>
main() {
int n = 9, i, b[n];
for (i=0; i<n; i++)
b[i] = -1;
#pragma omp parallel
{
int a;
//Al single solo entra una de las hebras en paralelo, y copyprivate copia el valor que
//tome esa varaible en el resto de hebras ejecutandose en paralelo
#pragma omp single copyprivate(a)
{
printf("\nIntroduce valor de inicialización a: ");
scanf("%d", &a);
printf("\nSingle ejecutada por el thread %d\n",omp_get_thread_num());
}
#pragma omp for
for (i=0; i<n; i++)
b[i] = a;
}
printf("Depués de la región parallel:\n");
for (i=0; i<n; i++)
printf("b[%d] = %d\t",i,b[i]);
printf("\n");
}
|
the_stack_data/232954426.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#define __MEMORIA_OCUPADA printf("Memoria ocupada: %I64u MB de RAM\n", ((size_t) cuenta)*32);
#define __MEMORIA_LIBERADA printf("Memoria liberada: %I64u MB de RAM\n", ((size_t) elim)*32);
#endif
#ifdef __unix
#define __MEMORIA_OCUPADA printf("Memoria ocupada: %llu MB de RAM\n", (size_t) cuenta*32);
#define __MEMORIA_LIBERADA printf("Memoria liberada: %llu MB de RAM\n", (size_t) elim*32);
#endif
// Bloques a ocupar: 32MB por bloque.
// Se pone un máximo de 1024GB de máximo a ocupar.
#define MILLON 1000000
const size_t TAM_BLOQUE = 32 * MILLON;
const size_t MAX_OCUPAR = 1024000;
void ocupar(size_t mb);
int main(int argc, char const *argv[])
{
unsigned long memSelec = 0;
if (argc < 2)
{
printf("%s: Ocupa la cantidad de RAM en MB asignada\n\n", argv[0]);
printf("Uso del programa:\n");
printf("%s <num de mb a ocupar>\n", argv[0]);
printf("En caso de poner \"0\" en la cantidad de MB a ocupar, ocupara toda");
printf(" la cantidad disponible.\n");
printf("Esto puede causar inestabilidad del sistema.");
printf("\n\n");
exit(0);
}
memSelec = atol(argv[1]);
if (memSelec == 0)
{
memSelec = MAX_OCUPAR;
printf("Cantidad de memoria a ocupar seleccionada: Todo lo posible.");
}
else
{
printf("Cantidad de memoria a ocupar seleccionada: %lu MB\n", memSelec);
}
if (memSelec != 0)
{
ocupar(memSelec);
return 0;
}
return 0;
}
void ocupar(size_t mb)
{ // Se intentan reservar "mb" MB de espacio en bloques de 32MB
if (mb%32 == 0)
{
mb = mb/32;
}
else
{
mb = (mb/32) + 1;
}
size_t cuenta;
unsigned char** memArray;
memArray = (unsigned char**) calloc(mb, sizeof(char*));
if (memArray == NULL)
{
while (memArray == NULL)
{
mb--;
memArray = (unsigned char**) calloc(mb, sizeof(char*));
}
}
cuenta = 0;
for (cuenta = 0; cuenta < mb; ++cuenta)
{
memArray[cuenta] =
(unsigned char*) calloc(TAM_BLOQUE/sizeof(unsigned char),
sizeof(unsigned char));
if (memArray[cuenta] == NULL)
{
break;
}
else
{
size_t i;
for (i=0; i<TAM_BLOQUE; ++i)
{
memArray[cuenta][i] = ~0;
}
}
}
__MEMORIA_OCUPADA
printf("- Pulse Enter para continual\n");
int a = getchar();
size_t elim;
for (elim=0; elim<cuenta; ++elim)
{
free(memArray[elim]);
memArray[elim]=NULL;
}
__MEMORIA_LIBERADA
free(memArray);
}
|
the_stack_data/46168.c | /* ask user for name and greet them with name */
#include <stdio.h>
int main()
{
char name[20]; /* variable is character array */
printf("What is your name?");
fgets(name, 20, stdin); /* gets user input */
printf("Hello %s", name);
return 0;
} |
the_stack_data/340807.c | /*
Instruction
Given an array of integers.
Return an array, where the first element is the count of positives numbers and the second element is sum of negative numbers.
If the input array is empty or null, return an empty array.
Example
For input [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11, -12, -13, -14, -15], you should return [10, -65].
*/
/*
Sample Tests
#include <criterion/criterion.h>
void count_positives_sum_negatives(int *values, size_t count, int *positivesCount, int *negativesSum);
Test(CoreTests, ShouldPassAllTheTestsProvided) {
{
int posCountReceived = 0;
int negSumReceived = 0;
int values[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11, -12, -13, -14, -15 };
count_positives_sum_negatives(
values, sizeof(values)/sizeof(values[0]),
&posCountReceived, &negSumReceived);
int posCountExpected = 10;
int negSumExpected = -65;
cr_assert_eq(
posCountExpected, posCountReceived,
"Positives count expected: %d Positives count received: %d",
posCountExpected, posCountReceived);
cr_assert_eq(
negSumExpected, negSumReceived,
"Negatives sum expected: %d Negatives sum received: %d",
negSumExpected, negSumReceived);
}
{
int posCountReceived = 0;
int negSumReceived = 0;
int values[] = { 0, 2, 3, 0, 5, 6, 7, 8, 9, 10, -11, -12, -13, -14 };
count_positives_sum_negatives(
values, sizeof(values)/sizeof(values[0]),
&posCountReceived, &negSumReceived);
int posCountExpected = 8;
int negSumExpected = -50;
cr_assert_eq(
posCountExpected, posCountReceived,
"Positives count expected: %d Positives count received: %d",
posCountExpected, posCountReceived);
cr_assert_eq(
negSumExpected, negSumReceived,
"Negatives sum expected: %d Negatives sum received: %d",
negSumExpected, negSumReceived);
}
{
int posCountReceived = 0;
int negSumReceived = 0;
int values[] = { 1 };
count_positives_sum_negatives(
values, sizeof(values)/sizeof(values[0]),
&posCountReceived, &negSumReceived);
int posCountExpected = 1;
int negSumExpected = 0;
cr_assert_eq(
posCountExpected, posCountReceived,
"Positives count expected: %d Positives count received: %d",
posCountExpected, posCountReceived);
cr_assert_eq(
negSumExpected, negSumReceived,
"Negatives sum expected: %d Negatives sum received: %d",
negSumExpected, negSumReceived);
}
{
int posCountReceived = 0;
int negSumReceived = 0;
int values[] = { -1 };
count_positives_sum_negatives(
values, sizeof(values)/sizeof(values[0]),
&posCountReceived, &negSumReceived);
int posCountExpected = 0;
int negSumExpected = -1;
cr_assert_eq(
posCountExpected, posCountReceived,
"Positives count expected: %d Positives count received: %d",
posCountExpected, posCountReceived);
cr_assert_eq(
negSumExpected, negSumReceived,
"Negatives sum expected: %d Negatives sum received: %d",
negSumExpected, negSumReceived);
}
{
int posCountReceived = 0;
int negSumReceived = 0;
int values[] = { 0,0,0,0,0,0,0,0,0 };
count_positives_sum_negatives(
values, sizeof(values)/sizeof(values[0]),
&posCountReceived, &negSumReceived);
int posCountExpected = 0;
int negSumExpected = 0;
cr_assert_eq(
posCountExpected, posCountReceived,
"Positives count expected: %d Positives count received: %d",
posCountExpected, posCountReceived);
cr_assert_eq(
negSumExpected, negSumReceived,
"Negatives sum expected: %d Negatives sum received: %d",
negSumExpected, negSumReceived);
}
}
*/
#include <stddef.h>
void count_positives_sum_negatives(
int *values, size_t count, int *positivesCount, int *negativesSum) {
for(int i = 0; i < count; i++) {
// Please store the positives count in the memory, pointed to
// by the positivesCount parameter.
if(values[i] > 0){
*positivesCount += 1;
}
// Please store the negatives sum in the memory, pointed to
// by the negativesSum parameter.
if(values[i] < 0){
*negativesSum += values[i];
}
}
}
|
the_stack_data/93886626.c | #include <stdio.h>
#include <stdlib.h>
#define NC 1.0e+10
void tension(r, res, current, volt)
int r;
float **res, **volt;
float **current;
{
int i, j, ii, jj, iii, jjj, k, end;
/*CALCOLO LE CADUTE DI TENSIONE SU OGNI RESISTENZA*/
/*creo la matrice fall che mi salva le cadute di potenziale in ogni punto e lo inizializzo a zero*/
float fall[r][r];
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
fall[i][j]=0;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(res[i][j]!=0 && current[i][j]!=0) /*occhio se cambi*/
fall[i][j]= current[i][j]*res[i][j];
/*CALCOLO LA TENSIONE IN UNA MAGLIA CHE HA LA BATTERIA*/
/*cerco dov'è la batteria (l'ultimo che trovo)*/
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(volt[i][j]!=0 && current[i][j]!=0){
/*printf("%d\t%d\n", i, j);*/
ii=i;
jj=j;
}
/*printf("ii%d\tjj%d\n", ii, jj);*/
/*creo la matrice per le tensioni iniziali e finali in ogni ramo*/
float tensi[r][r], tensf[r][r];
/*inizializzo tutto a NC (not yet calculated)*/
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++){
tensf[i][j]=NC;
tensi[i][j]=NC;
}
tensf[ii][jj]=volt[ii][jj]-fall[ii][jj]; /*mi calcolo la tensione finale nel ramo con la batteria*/
/*printf("prova\n");*/
iii=ii; /*mi salvo le coordinate del ramo con la batteria*/
jjj=jj;
while(jj!=j){
i=ii; /*mi salvo il ramo precedente*/
j=jj;
for(k=0; k<=r-1; k++) /*cerco il ramo successivo*/
if(current[jj][k]!=0 && tensi[jj][k]==NC){
ii=jj;
jj=k;
/*printf("%d\t%d\n", ii+1, jj+1);*/
break;
}
if((ii!=iii || jj!=jjj) && (ii!=i || jj!=j)){
/*printf("prova\n");*/
tensi[ii][jj]=tensf[i][j]; /*calcolo i voltaggi*/
tensf[ii][jj]=tensi[ii][jj]+volt[ii][jj]-fall[ii][jj];
}
/*printf("tensi%f\ttensf%f\n", tensi[ii][jj], tensf[ii][jj]);*/
}
/*ora mi concentro sulla tensione iniziale del ramo con la batteria*/
for(i=0; i<=r-1; i++)
if(current[i][iii]!=0 && tensf[i][iii]!=NC)
tensi[iii][jjj]=tensf[i][iii];
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(current[i][j]==0){
tensf[i][j]=0;
tensi[i][j]=0;
}
/*printf("prova\n");*/
/*CALCOLO LA TENSIONE NEGLI ALTRI RAMI*/
end=1;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==NC)
end=0;
while(end==0){
/*cerco un ramo in cui sia ancora da calcolare la tensione (l'ultimo che trovo)*/
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==NC && current[i][j]!=0){
ii=i; /*ii è il punto da cui parte la corrente*/
jj=j; /*jj il punto in cui arriva*/
}
/*printf("%d\t%d\n", ii+1, jj+1);*/
/*vedo se questo ramo ha un ramo adiacente in cui sia già stata calcolata la tensione, in caso positivo calcolo la tensione del nuovo ramo*/
k=-1; /*k mi serve ad indicare se ho trovato o meno un ramo vicino con la tensione calcolata*/
for(j=0; j<=r-1; j++)
if(tensi[ii][j]!=NC && tensi[ii][j]!=-NC && current[ii][j]!=0){
tensi[ii][jj]= tensi[ii][j];
tensf[ii][jj]= tensi[ii][jj]-fall[ii][jj]+volt[ii][jj];
k=1;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==-NC)
tensi[i][j]= NC;
/*printf("a\n");*/
break;
}
else if(tensi[j][ii]!=NC && tensi[j][ii]!=-NC && current[j][ii]!=0){
tensi[ii][jj]= tensf[j][ii];
tensf[ii][jj]= tensi[ii][jj]-fall[ii][jj]+volt[ii][jj];
k=1;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==-NC)
tensi[i][j]= NC;
/*printf("b\n");*/
break;
}
else if(tensi[jj][j]!=NC && tensi[jj][j]!=-NC && current[jj][j]!=0){
tensf[ii][jj]= tensi[jj][j];
tensi[ii][jj]= tensf[ii][jj]+fall[ii][jj]-volt[ii][jj];
k=1;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==-NC)
tensi[i][j]= NC;
/*printf("c\n");*/
break;
}
else if(tensi[j][jj]!=NC && tensi[j][jj]!=-NC && current[j][jj]!=0){
tensf[ii][jj]= tensf[j][jj];
tensi[ii][jj]= tensf[ii][jj]+fall[ii][jj]-volt[ii][jj];
k=1;
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==-NC)
tensi[i][j]= NC;
/*printf("d\n");*/
break;
}
else if(k==-1 && j==r-1){ /*questo ciclo considera il caso in cui non si abbia alcun ramo vicino in cui è già stata calcolata la tensione*/
/*quando trovo un ramo che non ha vicini calcolati lo devo segnalare in modo che, finchè non calcola la tensione in un altro ramo*/
/*non lo controlli più, questo per evitare loop infiniti. Per far ciò segno con -NC tali rami quando casco nel caso e, */
/*quando invece casco negli altri casi in cui calcolo un ramo rimetto tutti i -NC a NC */
tensi[ii][jj]=-NC;
/*printf("e\n");*/
}
end=1;
/*stampa totale*/
/*printf("tensi\n");
for(i=0; i<=r-1; i++){
for(j=0; j<r-1; j++)
printf("%f", tensi[i][j]);
printf("%f\n", tensi[i][r-1]);
}
printf("tensf\n");
for(i=0; i<=r-1; i++){
for(j=0; j<r-1; j++)
printf("%f", tensf[i][j]);
printf("%f\n", tensf[i][r-1]);
}*/
for(i=0; i<=r-1; i++)
for(j=0; j<=r-1; j++)
if(tensi[i][j]==NC && current[i][j]!=0){
end=0;
/*printf("end%d\n", end);*/
}
/*fine while*/
}
/*verifica leggi fisiche*/
/*printf("%f\n", tensi[iii][jjj]);*/
if(tensi[iii][jjj]<=0.0001 && tensi[iii][jjj]>=-0.0001)
printf("\nResults pass the final check\n");
/*STAMPA FILE ESTERNO*/
FILE *fp;
fp = fopen ("tension.dat","w");
/*Scrivo su file*/
fprintf(fp,"The initial voltage matrix stores voltages at the start of each branch, where the start of branch is defined by current flow\n");
for(i=0; i<=r-1; i++){
for(j=0; j<r-1; j++)
fprintf(fp, "%f\t", tensi[i][j]);
fprintf(fp, "%f\n", tensi[i][r-1]);
}
fprintf(fp,"The final voltage matrix stores the voltages at the end of each branch.\n");
for(i=0; i<=r-1; i++){
for(j=0; j<r-1; j++)
fprintf(fp, "%f\t", tensf[i][j]);
fprintf(fp, "%f\n", tensf[i][r-1]);
}
fprintf(fp,"The voltage matrix stores voltages across each resistor.\n");
for(i=0; i<=r-1; i++){
for(j=0; j<r-1; j++)
fprintf(fp, "%f\t", fall[i][j]);
fprintf(fp, "%f\n", fall[i][r-1]);
}
if (!fp)
printf ("\nError while writing tension.dat\n");
else
printf("\nFile tension.dat has been written\n");
/*fine function*/
}
|
the_stack_data/154831572.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* test.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: evgenkarlson <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/02/14 12:33:14 by evgenkarlson #+# #+# */
/* Updated: 2020/02/15 10:51:23 by evgenkarlson ### ########.fr */
/* */
/* ************************************************************************** */
/* команда для компиляции и одновременного запуска */
/* */
/* gcc -Wall -Werror -Wextra test.c && chmod +x ./a.out && ./a.out */
/* ************************************************************************** */
#include <unistd.h>
/* ************************************************************************** */
/* ************************************************************************** */
/* ************************************************************************** */
void ft_putchar(char c) /* функция вывода символа */
{
write(1, &c, 1);
}
/* ************************************************************************** */
/* ************************************************************************** */
/* ************************************************************************** */
/* функция печатающая строку */
void ft_putstr(char *str) /* принимаем адрес строки (первого элемента массива) и сохраняем в указателе */
{
int i; /* обьявляем счетчик с помощью которого будем перемещатся по массиву символов вперед*/
i = 0; /* инициализуем счетчик нулем чтобы отталкиваться от нулевой ячейки массива символов и двигаться по массиву вперед */
while (str[i] != '\0') /* Проверяем является ли символ в этой ячейки завершающим нулем '\0'. Если да то завершаем цикл, если нет то запускаем содержимое цикла */
{
ft_putchar(str[i]); /* Печатаем этот символ */
i++; /* увеличивая число на 1 чтоб перейти к проверке к следующего числа и если оно не '\0' то снова печатаем его и т.д и т.п пока str[i] не равен '\0' */
}
}
int main(void)
{
char t[] = {"Hello\n"}; /* Создадим массив символов(Строку) для теста */
ft_putstr(t); /* отправим адресс массива в функцию для печати (адресс масива всегда является адресом нулевого элемента)*/
/* ft_putstr(t); тоже самое что и ft_putstr(&t[0]); */
/* P.S. чтоб отправить адресс массива не нужно использовать оператор взятия адреса */
/* этот оператор(&) нужен с массивом только если ты указываешь конкретную позицию адреса нужного элемента массива */
/* НАПРИМЕР: &t[2] */ /* так мы передаем адресс 3 элемента */
/* Если вызвать функци вот так ft_putstr(&t[2]); передав адрес 3 элемента то строка напечатается начиная с этой позиции */
/* ВЫВОД: "llo" *//* и перевод на новую строку */
return (0);
}
|
the_stack_data/126702605.c | /*
* OpenBOR - http://www.LavaLit.com
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in OpenBOR root for details.
*
* Copyright (c) 2004 - 2011 OpenBOR Team
*/
/*
ADPCM coder/decoder
*/
/* Intel ADPCM step variation table */
static int indexTable[16] = {
-1, -1, -1, -1, 2, 4, 6, 8,
-1, -1, -1, -1, 2, 4, 6, 8,
};
static int stepsizeTable[89] = {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};
struct adpcm_state {
int valprev[2]; /* Previous output value */
int index[2]; /* Index into stepsize table */
};
static struct adpcm_state state;
void adpcm_reset() {
state.valprev[0] = 0;
state.valprev[1] = 0;
state.index[0] = 0;
state.index[1] = 0;
}
short adpcm_valprev(int channel) {
return state.valprev[channel];
}
unsigned char adpcm_index(int channel) {
return state.index[channel];
}
void adpcm_loop_reset(int channel, short valprev, unsigned char index) {
state.valprev[channel] = valprev;
state.index[channel] = index;
}
// len = input buffer size in bytes
// This should always be a multiple of 2 for 16-bit data.
// Return value: number of encoded bytes.
int adpcm_encode_mono(short *indata, unsigned char *outdata, int len) {
int val = 0; /* Current input sample value */
int sign = 0; /* Current adpcm sign bit */
int delta = 0; /* Current adpcm output value */
int diff = 0; /* Difference between val and valprev */
int step = 0; /* Stepsize */
int vpdiff = 0; /* Current change to valpred */
int outputbuffer = 0; /* place to keep previous 4-bit value */
int bufferstep = 0; /* toggle between outputbuffer/output */
int bytescoded = 0;
if(!indata || !outdata || len < 2)
return 0;
len /= 2;
step = stepsizeTable[state.index[0]];
bufferstep = 1;
for(; len > 0; len--) {
val = *indata++;
/* Step 1 - compute difference with previous value */
diff = val - state.valprev[0];
sign = (diff < 0) ? 8 : 0;
if(sign)
diff = (-diff);
/* Step 2 - Divide and clamp */
/* Note:
** This code *approximately* computes:
** delta = diff*4/step;
** vpdiff = (delta+0.5)*step/4;
** but in shift step bits are dropped. The net result of this is
** that even if you have fast mul/div hardware you cannot put it to
** good use since the fixup would be too expensive.
*/
delta = 0;
vpdiff = (step >> 3);
if(diff >= step) {
delta = 4;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 2;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 1;
vpdiff += step;
}
/* Step 3 - Update previous value */
if(sign)
state.valprev[0] -= vpdiff;
else
state.valprev[0] += vpdiff;
/* Step 4 - Clamp previous value to 16 bits */
if(state.valprev[0] > 32767)
state.valprev[0] = 32767;
else if(state.valprev[0] < -32768)
state.valprev[0] = -32768;
/* Step 5 - Assemble value, update index and step values */
delta |= sign;
state.index[0] += indexTable[delta];
if(state.index[0] < 0)
state.index[0] = 0;
if(state.index[0] > 88)
state.index[0] = 88;
step = stepsizeTable[state.index[0]];
/* Step 6 - Output value */
if(bufferstep) {
outputbuffer = (delta << 4) & 0xf0;
} else {
*outdata++ = (delta & 0x0f) | outputbuffer;
bytescoded++;
}
bufferstep = !bufferstep;
}
/* Output last step, if needed */
if(!bufferstep) {
*outdata++ = outputbuffer;
bytescoded++;
}
return bytescoded;
}
// len = input buffer size in bytes
int adpcm_decode_mono(unsigned char *indata, short *outdata, int len) {
int sign = 0; /* Current adpcm sign bit */
int delta = 0; /* Current adpcm output value */
int step = 0; /* Stepsize */
int valpred = 0; /* Predicted value */
int vpdiff = 0; /* Current change to valpred */
int index = 0; /* Current step change index */
int inputbuffer = 0; /* place to keep next 4-bit value */
int bytesdecoded = 0;
if(!indata || !outdata || len < 1)
return 0;
len *= 2;
valpred = state.valprev[0];
index = state.index[0];
step = stepsizeTable[index];
for(bytesdecoded = 0; bytesdecoded < len; bytesdecoded++) {
/* Step 1 - get the delta value */
if(bytesdecoded & 1) {
delta = inputbuffer & 0xf;
} else {
inputbuffer = *indata++;
delta = (inputbuffer >> 4) & 0xf;
}
/* Step 2 - Find new index value (for later) */
index += indexTable[delta];
if(index < 0)
index = 0;
if(index > 88)
index = 88;
/* Step 3 - Separate sign and magnitude */
sign = delta & 8;
delta = delta & 7;
/* Step 4 - Compute difference and new predicted value */
/*
** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
** in adpcm_coder.
*/
vpdiff = step >> 3;
if(delta & 4)
vpdiff += step;
if(delta & 2)
vpdiff += step >> 1;
if(delta & 1)
vpdiff += step >> 2;
if(sign)
valpred -= vpdiff;
else
valpred += vpdiff;
/* Step 5 - clamp output value */
if(valpred > 32767)
valpred = 32767;
else if(valpred < -32768)
valpred = -32768;
/* Step 6 - Update step value */
step = stepsizeTable[index];
/* Step 7 - Output value */
*outdata++ = valpred;
}
state.valprev[0] = valpred;
state.index[0] = index;
return bytesdecoded * 2;
}
// len = input buffer size in bytes
// This should always be a multiple of 4 for 16-bit stereo data.
// Return value: number of encoded bytes.
int adpcm_encode_stereo(short *indata, unsigned char *outdata, int len) {
int val = 0; /* Current input sample value */
int sign = 0; /* Current adpcm sign bit */
int delta = 0; /* Current adpcm output value */
int diff = 0; /* Difference between val and valprev */
int step = 0; /* Stepsize */
int vpdiff = 0; /* Current change to valpred */
int outputbuffer = 0; /* place to keep previous 4-bit value */
int bytescoded = 0;
if(!indata || !outdata || len < 4)
return 0;
len /= 4;
for(bytescoded = 0; bytescoded < len; bytescoded++) {
/* Left Channel */
step = stepsizeTable[state.index[0]];
val = *indata++;
/* Step 1 - compute difference with previous value */
diff = val - state.valprev[0];
sign = (diff < 0) ? 8 : 0;
if(sign)
diff = (-diff);
/* Step 2 - Divide and clamp */
/* Note:
** This code *approximately* computes:
** delta = diff*4/step;
** vpdiff = (delta+0.5)*step/4;
** but in shift step bits are dropped. The net result of this is
** that even if you have fast mul/div hardware you cannot put it to
** good use since the fixup would be too expensive.
*/
delta = 0;
vpdiff = (step >> 3);
if(diff >= step) {
delta = 4;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 2;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 1;
vpdiff += step;
}
/* Step 3 - Update previous value */
if(sign)
state.valprev[0] -= vpdiff;
else
state.valprev[0] += vpdiff;
/* Step 4 - Clamp previous value to 16 bits */
if(state.valprev[0] > 32767)
state.valprev[0] = 32767;
else if(state.valprev[0] < -32768)
state.valprev[0] = -32768;
/* Step 5 - Assemble value, update index and step values */
delta |= sign;
state.index[0] += indexTable[delta];
if(state.index[0] < 0)
state.index[0] = 0;
if(state.index[0] > 88)
state.index[0] = 88;
step = stepsizeTable[state.index[0]];
/* Step 6 - Output value */
outputbuffer = (delta << 4) & 0xf0;
/* Right Channel */
step = stepsizeTable[state.index[1]];
val = *indata++;
/* Step 1 - compute difference with previous value */
diff = val - state.valprev[1];
sign = (diff < 0) ? 8 : 0;
if(sign)
diff = (-diff);
/* Step 2 - Divide and clamp */
/* Note:
** This code *approximately* computes:
** delta = diff*4/step;
** vpdiff = (delta+0.5)*step/4;
** but in shift step bits are dropped. The net result of this is
** that even if you have fast mul/div hardware you cannot put it to
** good use since the fixup would be too expensive.
*/
delta = 0;
vpdiff = (step >> 3);
if(diff >= step) {
delta = 4;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 2;
diff -= step;
vpdiff += step;
}
step >>= 1;
if(diff >= step) {
delta |= 1;
vpdiff += step;
}
/* Step 3 - Update previous value */
if(sign)
state.valprev[1] -= vpdiff;
else
state.valprev[1] += vpdiff;
/* Step 4 - Clamp previous value to 16 bits */
if(state.valprev[1] > 32767)
state.valprev[1] = 32767;
else if(state.valprev[1] < -32768)
state.valprev[1] = -32768;
/* Step 5 - Assemble value, update index and step values */
delta |= sign;
state.index[1] += indexTable[delta];
if(state.index[1] < 0)
state.index[1] = 0;
if(state.index[1] > 88)
state.index[1] = 88;
step = stepsizeTable[state.index[1]];
/* Step 6 - Output value */
*outdata++ = (delta & 0x0f) | outputbuffer;
}
return bytescoded;
}
// len = input buffer size in bytes
int adpcm_decode_stereo(unsigned char *indata, short *outdata, int len) {
int sign = 0; /* Current adpcm sign bit */
int delta = 0; /* Current adpcm output value */
int step[2] = { 0, 0 }; /* Stepsize */
int valpred[2] = { 0, 0 }; /* Predicted value */
int vpdiff = 0; /* Current change to valpred */
int index[2] = { 0, 0 }; /* Current step change index */
int inputbuffer = 0; /* place to keep next 4-bit value */
int bytesdecoded = 0;
if(!indata || !outdata || len < 1)
return 0;
valpred[0] = state.valprev[0];
valpred[1] = state.valprev[1];
index[0] = state.index[0];
index[1] = state.index[1];
step[0] = stepsizeTable[index[0]];
step[1] = stepsizeTable[index[1]];
for(bytesdecoded = 0; bytesdecoded < len; bytesdecoded++) {
inputbuffer = *indata++;
/* Left Channel */
/* Step 1 - get the delta value */
delta = (inputbuffer >> 4) & 0xf;
/* Step 2 - Find new index value (for later) */
index[0] += indexTable[delta];
if(index[0] < 0)
index[0] = 0;
if(index[0] > 88)
index[0] = 88;
/* Step 3 - Separate sign and magnitude */
sign = delta & 8;
delta = delta & 7;
/* Step 4 - Compute difference and new predicted value */
/*
** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
** in adpcm_coder.
*/
vpdiff = step[0] >> 3;
if(delta & 4)
vpdiff += step[0];
if(delta & 2)
vpdiff += step[0] >> 1;
if(delta & 1)
vpdiff += step[0] >> 2;
if(sign)
valpred[0] -= vpdiff;
else
valpred[0] += vpdiff;
/* Step 5 - clamp output value */
if(valpred[0] > 32767)
valpred[0] = 32767;
else if(valpred[0] < -32768)
valpred[0] = -32768;
/* Step 6 - Update step value */
step[0] = stepsizeTable[index[0]];
/* Step 7 - Output value */
*outdata++ = valpred[0];
/* Right Channel */
/* Step 1 - get the delta value */
delta = inputbuffer & 0xf;
/* Step 2 - Find new index value (for later) */
index[1] += indexTable[delta];
if(index[1] < 0)
index[1] = 0;
if(index[1] > 88)
index[1] = 88;
/* Step 3 - Separate sign and magnitude */
sign = delta & 8;
delta = delta & 7;
/* Step 4 - Compute difference and new predicted value */
/*
** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
** in adpcm_coder.
*/
vpdiff = step[1] >> 3;
if(delta & 4)
vpdiff += step[1];
if(delta & 2)
vpdiff += step[1] >> 1;
if(delta & 1)
vpdiff += step[1] >> 2;
if(sign)
valpred[1] -= vpdiff;
else
valpred[1] += vpdiff;
/* Step 5 - clamp output value */
if(valpred[1] > 32767)
valpred[1] = 32767;
else if(valpred[1] < -32768)
valpred[1] = -32768;
/* Step 6 - Update step value */
step[1] = stepsizeTable[index[1]];
/* Step 7 - Output value */
*outdata++ = valpred[1];
}
state.valprev[0] = valpred[0];
state.valprev[1] = valpred[1];
state.index[0] = index[0];
state.index[1] = index[1];
return bytesdecoded * 4;
}
int adpcm_encode(short *indata, unsigned char *outdata, int len, int channels) {
if(channels == 2) {
return adpcm_encode_stereo(indata, outdata, len);
}
return adpcm_encode_mono(indata, outdata, len);
}
int adpcm_decode(unsigned char *indata, short *outdata, int len, int channels) {
if(channels == 2) {
return adpcm_decode_stereo(indata, outdata, len);
}
return adpcm_decode_mono(indata, outdata, len);
}
|
the_stack_data/81368.c | /* mbed Microcontroller Library
* Copyright (c) 2017 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if MBED_CONF_NSAPI_PRESENT
#include "mbed-trace/mbed_trace.h"
#ifndef TRACE_GROUP
#define TRACE_GROUP "RIOT"
#endif // TRACE_GROUP
#include "onboard_modem_api.h"
#include "gpio_api.h"
#include "PinNames.h"
#include "hal/serial_api.h"
#include "platform/mbed_thread.h"
#if MODEM_ON_BOARD
void onboard_modem_init()
{
char promptEnd;
tr_debug("onboard_modem_init");
gpio_t gpio;
gpio_init_out_ex(&gpio, MDMCHEN, 0);
gpio_init_out_ex(&gpio, MDMREMAP, 0);
// Take us out of reset
gpio_init_out_ex(&gpio, MDMRST, 0);
thread_sleep_for(100);
gpio_write(&gpio, 1);
/* Initialize UART1 pins to allow collecting logs from a PC */
gpio_init_in_ex(&gpio, MDM_UART1_TXD, PullNone);
gpio_init_in_ex(&gpio, MDM_UART1_RXD, PullNone);
serial_t bootrom_uart;
serial_init(&bootrom_uart, MDM_UART0_TXD, MDM_UART0_RXD);
serial_baud(&bootrom_uart, 115200);
tr_debug("%s: MODEM RESET", __func__);
serial_getc(&bootrom_uart);
tr_debug("%s: MODEM first activity after reset", __func__);
/* Wait for some dots */
for (int i = 0; i < 3; i++) {
do {
promptEnd = serial_getc(&bootrom_uart);
} while ('.' != promptEnd);
}
serial_putc(&bootrom_uart, ' ');
/* Wait for bootrom prompt */
for (int i = 0; i < 2; i++) {
do {
promptEnd = serial_getc(&bootrom_uart);
} while ('>' != promptEnd);
}
serial_putc(&bootrom_uart, '6');
serial_free(&bootrom_uart);
/* Wait for stack prompt */
tr_debug("%s: Wait for stack prompt", __func__);
thread_sleep_for(100);
serial_t cli_uart;
serial_init(&cli_uart, MDM_UART3_TXD, MDM_UART3_RXD);
serial_baud(&cli_uart, 230400); /* TODO make baud rate configurable */
do {
promptEnd = serial_getc(&cli_uart);
} while ('>' != promptEnd);
serial_free(&cli_uart);
tr_debug("%s: MODEM CLI prompt reached", __func__);
tr_debug("Reset RM1000 completed");
}
void onboard_modem_deinit()
{
tr_debug("onboard_modem_deinit");
gpio_t gpio;
// Back into reset
gpio_init_out_ex(&gpio, MDMRST, 0);
}
#endif //MODEM_ON_BOARD
#endif //MBED_CONF_NSAPI_PRESENT
|
the_stack_data/232956975.c | #include <stdio.h>
/**
* main - entry point
*
* Description: finds largest prime factor of 612852475143
*
* Return: Void
*/
int main(void)
{
long number = 612852475143;
long div = 2, maxFact;
while (number != 0)
{
if (number % div != 0)
div = div + 1;
else
{
maxFact = number;
number = number / div;
if (number == 1)
{
printf("%ld\n", maxFact);
break;
}
}
}
return (0);
}
|
the_stack_data/115766748.c | char *p="abc";
int main()
{
int input;
char ch;
/* should result in bounds violation */
ch=p[input];
}
|
the_stack_data/1123.c | #include<stdio.h>
int main()
{
int i,b,h,j;
printf("Enter the height\n");
scanf("%d",&h);
for(i=1;i<=h;i++)
{
for(b=1;b<=h-i;b++)
{
printf(" ");
}
for(j=1;j<=i;j++)
{
printf("* ");
}
printf("\n");
}
return 0;
}
|
the_stack_data/125140274.c | /*
* pseultra/tools/bootcsum/src/bootcsum.c
* PIFrom ipl2 checksum function decomp
*
* (C) pseudophpt 2018
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#define MAGIC 0x95DACFDC
uint64_t calculate_checksum (uint32_t *bcode);
static inline uint64_t checksum_helper (uint64_t op1, uint64_t op2, uint64_t op3);
int main (int argc, char *argv[]) {
// If arguments not adequate
if (argc < 2) {
printf("Usage: bootcsum <rom file> [<expected checksum>]\n");
return -1;
}
FILE* rom_file;
uint32_t rom_buffer[0x1000 / sizeof(uint32_t)];
rom_file = fopen(argv[1], "rb");
fread(rom_buffer, sizeof(uint32_t), 0x1000 / sizeof(uint32_t), rom_file);
fclose(rom_file);
// LE to BE
for (int i = 0; i < 0x1000 / sizeof(uint32_t); i++) {
uint32_t le = rom_buffer[i];
uint32_t be = ((le & 0xff) << 24) | ((le & 0xff00) << 8) | ((le & 0xff0000) >> 8) | ((le & 0xff000000) >> 24);
rom_buffer[i] = be;
}
// Verification or calculation
if (argc == 2) {
// Calculation
uint64_t checksum = calculate_checksum(&rom_buffer[0x10]);
printf("0x%llx\n", checksum);
return 0;
}
if (argc == 3) {
// Verification
uint64_t expected_checksum = strtoll(argv[2], NULL, 0);
uint64_t checksum = calculate_checksum(&rom_buffer[0x10]);
if (checksum == expected_checksum) {
printf("Correct\n");
return 0;
}
else {
printf("Incorrect:\n");
printf("Expected 0x%llx, got 0x%llx\n", expected_checksum, checksum);
return -1;
}
}
}
/*
* Helper function commonly called during checksum
*/
static inline uint64_t checksum_helper (uint64_t op1, uint64_t op2, uint64_t op3) {
int high_mult;
int low_mult;
if (op2 == 0) {
op2 = op3;
}
low_mult = (op1 * op2) & 0x00000000FFFFFFFF;
high_mult = ((op1 * op2) & 0xFFFFFFFF00000000) >> 32;
if (high_mult - low_mult == 0) {
return low_mult;
}
else return high_mult - low_mult;
}
/*
* Decompiled checksum function
*/
uint64_t calculate_checksum (uint32_t *bcode) {
uint32_t *bcode_inst_ptr = bcode;
uint32_t loop_count = 0;
uint32_t bcode_inst = *bcode_inst_ptr;
uint32_t next_inst;
uint32_t prev_inst;
uint32_t frame [16];
uint32_t sframe [4];
// Calculate magic number
uint32_t magic = MAGIC ^ bcode_inst;
// Generate frame. This is done earlier in IPC2
for (int i = 0; i < 16; i ++) {
frame[i] = magic;
};
// First part of checksum, calculates frame
for (;;) {
/* Loop start, 11E8 - 11FC */
prev_inst = bcode_inst;
bcode_inst = *bcode_inst_ptr;
loop_count ++;
bcode_inst_ptr ++;
next_inst = *(bcode_inst_ptr);
/* Main processing */
frame[0] += checksum_helper(0x3EF - loop_count, bcode_inst, loop_count);
frame[1] = checksum_helper(frame[1], bcode_inst, loop_count);
frame[2] ^= bcode_inst;
frame[3] += checksum_helper(bcode_inst + 5, 0x6c078965, loop_count);
if (prev_inst < bcode_inst) {
frame[9] = checksum_helper(frame[9], bcode_inst, loop_count);
}
else frame[9] += bcode_inst;
frame[4] += ((bcode_inst << (0x20 - (prev_inst & 0x1f))) | (bcode_inst >> (prev_inst & 0x1f)));
frame[7] = checksum_helper(frame[7], ((bcode_inst >> (0x20 - (prev_inst & 0x1f))) | (bcode_inst << (prev_inst & 0x1f))), loop_count);
if (bcode_inst < frame[6]) {
frame[6] = (bcode_inst + loop_count) ^ (frame[3] + frame[6]);
}
else frame[6] = (frame[4] + bcode_inst) ^ frame[6];
frame[5] += (bcode_inst >> (0x20 - (prev_inst >> 27))) | (bcode_inst << (prev_inst >> 27));
frame[8] = checksum_helper(frame[8], (bcode_inst << (0x20 - (prev_inst >> 27))) | (bcode_inst >> (prev_inst >> 27)), loop_count);
if (loop_count == 0x3F0) break;
uint32_t tmp1 = checksum_helper(frame[15], (bcode_inst >> (0x20 - (prev_inst >> 27))) | (bcode_inst << (prev_inst >> 27)), loop_count);
frame[15] = checksum_helper(
tmp1,
(next_inst << (bcode_inst >> 27)) | (next_inst >> (0x20 - (bcode_inst >> 27))),
loop_count
);
uint32_t tmp2 = ((bcode_inst << (0x20 - (prev_inst & 0x1f))) | (bcode_inst >> (prev_inst & 0x1f)));
uint32_t tmp3 = checksum_helper(frame[14], tmp2, loop_count); // v0 at 1384
uint32_t tmp4 = checksum_helper(tmp3, (next_inst >> (bcode_inst & 0x1f)) | (next_inst << (0x20 - (bcode_inst & 0x1f))), loop_count); // v0 at 13a4
frame[14] = tmp4;
frame[13] += ((bcode_inst >> (bcode_inst & 0x1f)) | (bcode_inst << (0x20 - (bcode_inst & 0x1f)))) + ((next_inst >> (next_inst & 0x1f)) | (next_inst << (0x20 - (next_inst & 0x1f))));
frame[10] = checksum_helper(frame[10] + bcode_inst, next_inst, loop_count);
frame[11] = checksum_helper(frame[11] ^ bcode_inst, next_inst, loop_count);
frame[12] += (frame[8] ^ bcode_inst);
}
// Second part, calculates sframe
// Every value in sframe is initialized to frame[0]
for (int i = 0; i < 4; i ++) {
sframe[i] = frame[0];
}
uint32_t *frame_word_ptr = &frame[0];
uint32_t frame_word;
for (uint32_t frame_number = 0; frame_number != 0x10; frame_number ++) {
// Updates
frame_word = *frame_word_ptr;
// Calculations
sframe[0] += ((frame_word << (0x20 - frame_word & 0x1f)) | frame_word >> (frame_word & 0x1f));
if (frame_word < sframe[0]) {
sframe[1] += frame_word;
}
else {
sframe[1] = checksum_helper(sframe[1], frame_word, 0);
}
if (((frame_word & 0x02) >> 1) == (frame_word & 0x01)) {
sframe[2] += frame_word;
}
else {
sframe[2] = checksum_helper(sframe[2], frame_word, frame_number);
}
if (frame_word & 0x01 == 1) {
sframe[3] ^= frame_word;
}
else {
sframe[3] = checksum_helper(sframe[3], frame_word, frame_number);
}
frame_word_ptr ++;
}
// combine sframe into checksum
uint64_t checksum = sframe[2] ^ sframe[3];
checksum |= checksum_helper(sframe[0], sframe[1], 0x10) << 32;
checksum &= 0x0000ffffffffffff;
return checksum;
}
|
the_stack_data/59024.c | #include <stdio.h>
int main()
{
float av1=0, av2=0, media=0;
printf ("Nota da av1");
scanf ("%f", &av1);
printf ("Nota da av2");
scanf ("%f", &av2);
media = (av1+av2)/2;
if (media >=6)
{
printf ("Aprovado");
}
else
printf ("Reprovado");
return 0;
} |
the_stack_data/151595.c | void errorFn() {assert(0);}
int unknown1();
int unknown2();
int unknown3();
int unknown4();
void main()
{
int x=0;
while(unknown1()){
x = x + 3;
}
if(x % 3 != 0)
errorFn();
}
|
the_stack_data/844549.c | /**
* A simple pthread program illustrating RT pthread scheduling.
*
* Figure 6.20
*
* To compile:
*
* gcc posix-rt.c -o posix-rt -lpthread
*
* @author Gagne, Galvin, Silberschatz
* Operating System Concepts - Ninth Edition
* Copyright John Wiley & Sons - 2013.
*/
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5
/* the thread runs in this function */
void *runner(void *param);
main(int argc, char *argv[])
{
int i, policy;
pthread_t tid[NUM_THREADS]; /* the thread identifier */
pthread_attr_t attr; /* set of attributes for the thread */
/* get the default attributes */
pthread_attr_init(&attr);
/* get the current scheduling policy */
if (pthread_attr_getschedpolicy(&attr,&policy) != 0)
fprintf(stderr, "Unable to get policy.\n");
else {
if (policy == SCHED_OTHER)
printf("SCHED_OTHER\n");
else if (policy == SCHED_RR)
printf("SCHED_OTHER\n");
else if (policy == SCHED_FIFO)
printf("SCHED_FIFO\n");
}
/* set the scheduling policy - FIFO, RT, or OTHER */
if (pthread_attr_setschedpolicy(&attr, SCHED_OTHER) != 0)
printf("unable to set scheduling policy to SCHED_OTHER \n");
/* create the threads */
for (i = 0; i < NUM_THREADS; i++)
pthread_create(&tid[i],&attr,runner,NULL);
/**
* Now join on each thread
*/
for (i = 0; i < NUM_THREADS; i++)
pthread_join(tid[i], NULL);
}
/**
* The thread will begin control in this function.
*/
void *runner(void *param)
{
/* do some work ... */
pthread_exit(0);
}
|
the_stack_data/76700690.c | #include <stdio.h>
#include <stdlib.h>
/**
* popen, pclose - pipe stream to or from a process
* #include <stdio.h>
* FILE *popen(const char *command, const char *type);
* int pclose(FILE *stream);
* popen() executes a shell command and passes it to a FILE stream
* pclose() close the FILE stream
**/
int main() {
FILE *fp;
char path[1035];
/* Open the command for reading */
// fp = popen("/bin/ls", "/etc/", "r");
fp = popen(
"python3.6 -c 'from random import choice, randint;from string import ascii_letters, digits; print(*[choice(ascii_letters+digits) for _ in range(randint(10 ,20))], sep=str())'",
"r");
if(fp == NULL) {
printf("Failed to run the command");
exit(1);
}
// /* Read the output a line a time and output it */
// while(fgets(path, sizeof(path)-1, fp) != NULL) {
// printf("%s\n", path);
// }
fgets(path, 1000, fp);
printf("%s\n", path);
pclose(fp);
return 0;
} |
the_stack_data/29826476.c | #include <stdio.h>
int main()
{
int c, i, nc, a;
int ndigit[30];
for(i = 0; i < 30; ++i)
ndigit[i] = 0;
nc = 0;
while((c = getchar()) != EOF) {
++nc;
if(c == '\n' || c == '\t' || c == ' ') {
++ndigit[nc];
nc = 0;
}
}
for(i = 0; i < 30; ++i) {
if(ndigit[i] != 0) {
printf("Slow o dlugosci %d jest: %d ", i-1, ndigit[i]);
for(a = 0; a < ndigit[i]; ++a)
printf("_");
printf("\n");
}
}
}
|
the_stack_data/196795.c | int main(){
int a ,b,c;
a = 10;
b = 14;
c = a > b;
return c;
}
|
the_stack_data/76701518.c | #include <stdio.h>
#include <string.h>
int main()
{
int loop, testCase;
scanf("%d", &testCase);
for (loop = 1; loop <= testCase; loop++)
{
char str[101];
getchar();
scanf("%[^\n]", str);
int i;
for (i = 0; i < strlen(str); i++)
{
printf("%d", str[i] - 64);
}
printf("\n");
}
return 0;
} |
the_stack_data/862187.c | #include <stdio.h>
int reverse(int n)
{
int reverse=0, rem;
while(n!=0)
{
rem=n%10;
reverse=reverse*10+rem;
n/=10;
}
return reverse;
}
int main() {
int a;
int b;
int aReverse, bReverse;
scanf("%d" , &a);
scanf("%d" , &b);
aReverse = reverse(a);
bReverse = reverse(b);
if (aReverse < bReverse) {
printf("%d < %d" , a ,b);
} else if ( bReverse < aReverse ){
printf("%d < %d" , b ,a);
} else {
printf("%d = %d" , a ,b);
}
return 0;
} |
the_stack_data/91232.c | /* Copyright (C) 2005-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <sys/param.h>
#include <sys/socket.h>
ssize_t
__recvfrom_chk (int fd, void *buf, size_t n, size_t buflen, int flags,
__SOCKADDR_ARG addr, socklen_t *addr_len)
{
if (n > buflen)
__chk_fail ();
return __recvfrom (fd, buf, n, flags, addr, addr_len);
}
|
the_stack_data/111887.c | /*
* Crude test driver for processing the VST and MCT testvector files
* generated by the CMVP RNGVS product.
*
* Note the input files are assumed to have a _very_ specific format
* as described in the NIST document "The Random Number Generator
* Validation System (RNGVS)", May 25, 2004.
*
*/
#include <openssl/opensslconf.h>
#ifndef OPENSSL_FIPS
# include <stdio.h>
int main(int argc, char **argv)
{
printf("No FIPS RNG support\n");
return 0;
}
#else
# include <openssl/bn.h>
# include <openssl/dsa.h>
# include <openssl/fips.h>
# include <openssl/err.h>
# include <openssl/rand.h>
# include <openssl/fips_rand.h>
# include <openssl/x509v3.h>
# include <string.h>
# include <ctype.h>
# include "fips_utl.h"
static void vst()
{
unsigned char *key = NULL;
unsigned char *v = NULL;
unsigned char *dt = NULL;
unsigned char ret[16];
char buf[1024];
char lbuf[1024];
char *keyword, *value;
long i, keylen;
keylen = 0;
while (fgets(buf, sizeof buf, stdin) != NULL) {
fputs(buf, stdout);
if (!strncmp(buf, "[AES 128-Key]", 13))
keylen = 16;
else if (!strncmp(buf, "[AES 192-Key]", 13))
keylen = 24;
else if (!strncmp(buf, "[AES 256-Key]", 13))
keylen = 32;
if (!parse_line(&keyword, &value, lbuf, buf))
continue;
if (!strcmp(keyword, "Key")) {
key = hex2bin_m(value, &i);
if (i != keylen) {
fprintf(stderr, "Invalid key length, expecting %ld\n",
keylen);
return;
}
} else if (!strcmp(keyword, "DT")) {
dt = hex2bin_m(value, &i);
if (i != 16) {
fprintf(stderr, "Invalid DT length\n");
return;
}
} else if (!strcmp(keyword, "V")) {
v = hex2bin_m(value, &i);
if (i != 16) {
fprintf(stderr, "Invalid V length\n");
return;
}
if (!key || !dt) {
fprintf(stderr, "Missing key or DT\n");
return;
}
FIPS_rand_set_key(key, keylen);
FIPS_rand_seed(v, 16);
FIPS_rand_set_dt(dt);
if (FIPS_rand_bytes(ret, 16) <= 0) {
fprintf(stderr, "Error getting PRNG value\n");
return;
}
pv("R", ret, 16);
OPENSSL_free(key);
key = NULL;
OPENSSL_free(dt);
dt = NULL;
OPENSSL_free(v);
v = NULL;
}
}
}
static void mct()
{
unsigned char *key = NULL;
unsigned char *v = NULL;
unsigned char *dt = NULL;
unsigned char ret[16];
char buf[1024];
char lbuf[1024];
char *keyword, *value;
long i, keylen;
int j;
keylen = 0;
while (fgets(buf, sizeof buf, stdin) != NULL) {
fputs(buf, stdout);
if (!strncmp(buf, "[AES 128-Key]", 13))
keylen = 16;
else if (!strncmp(buf, "[AES 192-Key]", 13))
keylen = 24;
else if (!strncmp(buf, "[AES 256-Key]", 13))
keylen = 32;
if (!parse_line(&keyword, &value, lbuf, buf))
continue;
if (!strcmp(keyword, "Key")) {
key = hex2bin_m(value, &i);
if (i != keylen) {
fprintf(stderr, "Invalid key length, expecting %ld\n",
keylen);
return;
}
} else if (!strcmp(keyword, "DT")) {
dt = hex2bin_m(value, &i);
if (i != 16) {
fprintf(stderr, "Invalid DT length\n");
return;
}
} else if (!strcmp(keyword, "V")) {
v = hex2bin_m(value, &i);
if (i != 16) {
fprintf(stderr, "Invalid V length\n");
return;
}
if (!key || !dt) {
fprintf(stderr, "Missing key or DT\n");
return;
}
FIPS_rand_set_key(key, keylen);
FIPS_rand_seed(v, 16);
for (i = 0; i < 10000; i++) {
FIPS_rand_set_dt(dt);
if (FIPS_rand_bytes(ret, 16) <= 0) {
fprintf(stderr, "Error getting PRNG value\n");
return;
}
/* Increment DT */
for (j = 15; j >= 0; j--) {
dt[j]++;
if (dt[j])
break;
}
}
pv("R", ret, 16);
OPENSSL_free(key);
key = NULL;
OPENSSL_free(dt);
dt = NULL;
OPENSSL_free(v);
v = NULL;
}
}
}
int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "%s [mct|vst]\n", argv[0]);
exit(1);
}
if (!FIPS_mode_set(1)) {
do_print_errors();
exit(1);
}
FIPS_rand_reset();
if (!FIPS_rand_test_mode()) {
fprintf(stderr, "Error setting PRNG test mode\n");
do_print_errors();
exit(1);
}
if (!strcmp(argv[1], "mct"))
mct();
else if (!strcmp(argv[1], "vst"))
vst();
else {
fprintf(stderr, "Don't know how to %s.\n", argv[1]);
exit(1);
}
return 0;
}
#endif
|
the_stack_data/1120652.c | // RUN: %theta -no-optimize -memory=havoc "%s" | FileCheck "%s"
// RUN: %theta -memory=havoc "%s" | FileCheck "%s"
// CHECK: Verification FAILED
// This test checks that the enabled LLVM optimizations do not
// strip away relevant code under an undefined value.
void __VERIFIER_error(void) __attribute__((noreturn));
int main(void)
{
int x;
if (x == 1) {
__VERIFIER_error();
}
return 0;
} |
the_stack_data/677646.c | /* simple app.
modify test.ld to change address.
Even if the app is position independent, the symbols
need to match to test basic debugging.
To load the app to 0x20000000 in GDB, use:
load a.out
monitor reg sp 0x20004000
monitor reg pc 0x20002000
stepi
arm-elf-gcc -mthumb -mcpu = cortex-m3 -nostdlib -Ttest.ld test.c
*/
int j;
void _start()
{
int i;
for (i = 0; i < 1000; i++)
{
j++;
}
}
|
the_stack_data/206393074.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
unsigned int BKDRHash(char* str, unsigned int len)
{
unsigned int seed = 131; /* 31 131 1313 13131 131313 etc.. */
unsigned int hash = 0;
unsigned int i = 0;
for(i = 0; i < len; str++, i++)
{
hash = (hash * seed) + (*str);
}
return hash;
}
/* End Of BKDR Hash Function */
int main(int argc, char* argv[]) {
unsigned char *str = argv[1];
unsigned int hash = BKDRHash(str, strlen(str));
printf("%x\n", hash);
if (hash == 0xbd9282b2)
printf("You win!\n");
return 0;
}
|
the_stack_data/71774.c | /*
============================================================================
Name : exemplo-7-for.c
Author : taylor klaus cantalice nobrega
Version :
Copyright : Your copyright notice
Description :
============================================================================
*/
#include <stdio.h>
int main(void){
int i, n;
printf("Digite n: ");
scanf("%d", &n);
for(i = 1; i <= 10; i = i + 1){
printf("%2d x %2d = %d\n", i, n, i*n);
}
return 0;
}
|
the_stack_data/56032.c | // C program to illustrate
// recursive approach to ternary search
#include <stdio.h>
// Function to perform Ternary Search
int ternarySearch(int l, int r, int key, int ar[])
{
if (r >= l) {
// Find the mid1 and mid2
int mid1 = l + (r - l) / 3;
int mid2 = r - (r - l) / 3;
// Check if key is present at any mid
if (ar[mid1] == key) {
return mid1;
}
if (ar[mid2] == key) {
return mid2;
}
// Since key is not present at mid,
// check in which region it is present
// then repeat the Search operation
// in that region
if (key < ar[mid1]) {
// The key lies in between l and mid1
return ternarySearch(l, mid1 - 1, key, ar);
}
else if (key > ar[mid2]) {
// The key lies in between mid2 and r
return ternarySearch(mid2 + 1, r, key, ar);
}
else {
// The key lies in between mid1 and mid2
return ternarySearch(mid1 + 1, mid2 - 1, key, ar);
}
}
// Key not found
return -1;
}
// Driver code
int main()
{
int l, r, p, key;
// Get the array
// Sort the array if not sorted
int ar[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Starting index
l = 0;
// length of array
r = 9;
// Checking for 5
// Key to be searched in the array
key = 5;
// Search the key using ternarySearch
p = ternarySearch(l, r, key, ar);
// Print the result
printf("Index of %d is %d\n", key, p);
// Checking for 50
// Key to be searched in the array
key = 50;
// Search the key using ternarySearch
p = ternarySearch(l, r, key, ar);
// Print the result
printf("Index of %d is %d", key, p);
}
|
the_stack_data/20449586.c | #include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char *argv[]) {
printf("%d\n", 5+2); // 7
printf("%d\n", 9-4); // 5
printf("%d\n", 2*3); // 6
printf("%d\n", 10/5); // 2
printf("%d\n", 9%4); // 1
return 0;
}
|
the_stack_data/571965.c | #pragma acc data create (clf, tmp) copyin (Ax, Ry, Ex, Ey, Hz, czm, czp, cxmh, cxph, cymh, cyph) copyout (Bza, Ex, Ey, Hz)
#pragma acc parallel
#pragma acc loop
#pragma acc loop
#pragma acc loop
|
the_stack_data/248579849.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char statFilename[] = "stat_serv_file.dsg";
void main()
{
FILE * staticFp;
char temp[20];
staticFp = fopen (statFilename, "rb");
// fread(p,sizeof(struct staticVar),1,fp);
fseek(staticFp, 0, SEEK_END);
int lengthOfFile = ftell(staticFp);
fseek(staticFp, 0, SEEK_SET);
char *ptr;
ptr = (char*) calloc(1,lengthOfFile*sizeof(char));
fread(ptr,lengthOfFile,1,staticFp);
printf("This is data :\n%s", ptr);
printf("This is pointer address:\n%p", ptr);
scanf("Enter some data :%s", temp);
printf("This is modified data :\n%s", ptr);
fclose(staticFp);
free(ptr);
}
|
the_stack_data/190767959.c | // SKIP PARAM: --set solver td3 --enable ana.int.interval --set ana.base.arrays.domain partitioned --set ana.activated "['base','threadid','threadflag','expRelation','apron','mallocWrapper']" --set ana.base.privatization none
// These examples were cases were we saw issues of not reaching a fixpoint during development of the octagon domain. Since those issues might
// resurface, these tests without asserts are included
int main(int argc, char const *argv[])
{
int l;
int r = 42;
while(1) {
if (l-r <= 0) {
r--;
} else {
break;
}
}
return 0;
}
|
the_stack_data/140747.c | /*
* Complete the function below.
*/
int function(int x) {
return x*x;
}
|
the_stack_data/187547.c | #include <stdio.h>
#include <string.h>
#include <ncurses.h>
#include <stdlib.h>
#include <time.h>
int SCREENWIDTH = 150;
int SCREENHEIGHT = 40;
int ARBLIMIT = 100;
int MAXGENESIZE = 80;
int MAXTRIES = 5;
char BLANKCHAR = '.';
char GRASSCHAR = '|';
char RABBITCHAR = 'r';
char FOXCHAR = 'F';
int MAXGRASSHEALTH = 20;
int MAXRABBITHEALTH = 40;
int MAXFOXHEALTH = 100;
int INITGRASS = 200;
int INITRABBITS = 50;
int INITFOXES = 0;
int Speed = 1;
int Mode = 2;
int TOTALRUNS = 0;
int MAXPLAYERS = 10000;
int GRASSNUTRITION = 10;
int RABBITNUTRITION = 60;
typedef enum {
AllOK = 0,
GeneralError,
NoFreeSpaceError,
OutOfRangeError,
NoFreePointError,
SlotNotFreeError,
ForcedExitError,
OutOfMemError,
MallocError
} ReturnState;
struct ScreenPoint {
int X;
int Y;
};
typedef enum {
False = 0,
True
} Boolean;
typedef enum {
clNone = 0,
clPlant,
clHerb,
clCarn
} EntityClass;
typedef enum {
idNone = 0,
idGrass,
idRabbit,
idFox
} EntityName;
typedef enum {
Stay = 0,
Continue,
MoveRight,
MoveUpRight,
MoveUp,
MoveUpLeft,
MoveLeft,
MoveDownLeft,
MoveDown,
MoveDownRight
} Action;
struct Entity {
EntityClass Class;
EntityName Name;
char Appearance;
int X, Y;
char *GString;
int MaxHealth, Health, GenePointer;
Boolean Visible;
Action (*GetMove) (struct Entity **this);
Action (*HandleObstacle) (struct Entity *this, struct Entity *that);
ReturnState (*HideEntity) (struct Entity *this);
ReturnState (*KillEntity) (struct Entity **this);
ReturnState (*SpawnEntity) (void);
};
struct Entity **EntityArray;
// Trust me, I know how it looks, but this next line is an absolute necessity!
struct Entity ****ScreenArray;
// Grass functions
Action GrowGrass (struct Entity **this);
// HandleObstacle = NULL
ReturnState CrushGrass (struct Entity *this);
ReturnState EatGrass (struct Entity **this);
ReturnState SpawnGrass (void);
// Rabbit functions
Action MoveRabbit (struct Entity **this);
Action BlockedRabbit (struct Entity *this, struct Entity *that);
ReturnState HideRabbit (struct Entity *this);
ReturnState KillRabbit (struct Entity **this);
ReturnState DoWhatRabbitsDoBest (void);
// Fox functions
Action MoveFox (struct Entity **this);
Action BlockedFox (struct Entity *this, struct Entity *that);
//ReturnState HideFox (struct Entity *this); // Shares this function with the rabbit.
//ReturnState KillFox (struct Entity **this); // Shares this function with the rabbit.
ReturnState TheFoxesAreAtItAgain (void);
// Additional Miecos-specific functions
ReturnState GetNewScreenPoint (struct ScreenPoint **NewPoint);
int SetGString (char **NewGString);
// Additional general functions
int Rand (int MaxNum);
//void LogMessage (char *Message);
//void LogStat (char *Message, int Stat);
/*
* This was and will be used for testing/debugging purposes. It is not used
* in the release version but it seems simpler to comment all the lines out
* rather than remove them outright and maintain a separate copy for upgrades
*/
FILE *OutputFile;
int main(int argc, char *argv[])
{
printf("Here we go!");
int i = 0, j = 0, Iterations = 0, StillAlive = 0;
ReturnState ReturnedError = AllOK;
struct timespec DELAY;
// Before we do ANYTHING lets check the command line arguements
for (i=1; i<argc; i++) {
if (!(strcmp ("--help", argv[i]))) {
printf ("Usage: miecos [--help | --version | OPTION]\n");
printf ("Example: miecos --mode=ncurses --speed=fast --runlimit 500 --width 120 --height 40 --grass 200 --rabbits 100 --foxes 300 --maxplayers 3000 --genesize 100\n\n");
printf (" --help show this message\n");
printf (" --version show version number\n");
printf (" --mode=xxx choose display mode, xxx can be 'ncurses' to use the ncurses library for\n");
printf (" screen output, 'basic' for output using simple printf() statements\n");
printf (" or 'noecho' for disabling all screen output (useful for when Miecos is\n");
printf (" invoked from a script file)\n");
printf (" the default is ncurses if no option or an invalid option is selected\n");
printf (" --speed=xxx sets the size of the delay entered in the main loop, valid values for xxx\n");
printf (" are 'instant', 'vfast', 'fast', 'medium', 'slow' or 'vslow'\n");
printf (" the default is 'medium' unless the 'noecho' mode is set which case this\n");
printf (" option is ignored and the speed is set to 'instant'\n");
printf (" --runlimit num normally the program exits when all animals in the program die off however\n");
printf (" this value can be used to limit the number of iterations of the main loop\n");
printf (" the default is zero (not set)\n");
printf (" --width num sets the width of the field\n");
printf (" the default is %i, when the ncurses library is being used the\n", SCREENWIDTH);
printf (" maximum value is set to COLS as defined by ncurses.h, if the 'noecho' or 'basic'\n");
printf (" modes are being used then this value has an arbitrary limit of %i\n", ARBLIMIT);
printf (" --height num sets the height of the field\n");
printf (" the default is %i, when the ncurses library is being used the\n", SCREENHEIGHT);
printf (" maximum value is set to LINES as defined by ncurses.h, if the 'noecho' or 'basic'\n");
printf (" modes are being used then this value has an arbitrary limit of %i\n", ARBLIMIT);
printf (" --grass num this defines the amount of grass that is present at the start of the current run\n");
printf (" the default is %i\n", INITGRASS);
printf (" --rabbits num this defines the number of rabbits that are present at the start of the current run\n");
printf (" the default is %i\n", INITRABBITS);
printf (" --foxes num this defines the number of foxes that are present at the start of the current run\n");
printf (" the default is %i\n", INITRABBITS);
printf (" --maxplayers this defines the maximum number of entities (grass + rabbits + foxes) that can\n");
printf (" exist simultaneously\n");
printf (" the default is (SCREENWIDTH * SCREENHEIGHT)\n");
printf (" --genesize this defines the maximum size of the entitys genestring\n");
printf (" the default is %i\n\n", MAXGENESIZE);
printf ("Miecos is copyright (C) 2005, 2015 Alan Delaney and licensed\n");
printf ("under the GNU General Public License, version 2.\n\n");
printf ("Report bugs or send praise to https://github.com/xarxziux/miecos\n\n");
return 0;
}
}
for (i=1; i<argc; i++) {
if (!(strcmp ("--version", argv[i]))) {
printf ("Miecos 0.0.1 (pre-release)\n");
printf ("Copyright (C) 2005 Alan Delaney.\n");
printf ("Miecos comes with ABSOLUTELY NO WARRANTY.\n");
printf ("You may redistribute copies of Miecos under the\n");
printf ("terms of the GNU General Public License, version 2.\n");
return 0;
}
}
/*
* The "--mode=" arguement determines how the output will be presented. Currently there
* are three modes:
* ncurses - use the ncurses library, this is the default.
* basic - this uses simple printf() statements to provide the output, useful perhaps for debugging purposes
* noecho - does not print anything to the screen, designed to be used as a background program run
* from within a shell script, for example.
*/
i=1;
while (i<argc) {
if (!(strncmp ("--mode=", argv[i], 7))) {
if (!(strcmp ("--mode=ncurses", argv[i]))) {
Mode = 2;
}
else if (!(strcmp ("--mode=basic", argv[i]))) {
Mode = 1;
}
else if (!(strcmp ("--mode=noecho", argv[i]))) {
Mode = 0;
}
i = argc; // If a "--mode" arguement was found then exit this loop, even if the arguement was invalid.
}
i++;
}
/*
* The "-speed" arguement sets the amount of delay between the iterations of the while() loop. There are
* currently six settings: vslow, slow, medium, fast, vfast, instant. The last sets NO time limit and is
* automatically selected if the mode is noecho. On invalid values the default is medium.
*/
if (Mode) {
i=1;
while (i<argc) {
if (!(strncmp ("--speed=", argv[i], 8))) {
if (!(strcmp ("--speed=instant", argv[i]))) {
Speed = 0;
}
else if (!(strcmp ("--speed=vfast", argv[i]))) {
Speed = 1;
}
else if (!(strcmp ("--speed=fast", argv[i]))) {
Speed = 2;
}
else if (!(strcmp ("--speed=medium", argv[i]))) {
Speed = 3;
}
else if (!(strcmp ("--speed=slow", argv[i]))) {
Speed = 4;
}
else if (!(strcmp ("--speed=vslow", argv[i]))) {
Speed = 5;
}
i = argc;
}
i++;
}
}
else {
Speed = 0;
}
switch (Speed) {
case 0:
DELAY.tv_sec = 0;
DELAY.tv_nsec = 0;
break;
case 1:
DELAY.tv_sec = 0;
DELAY.tv_nsec = 25000000;
break;
case 2:
DELAY.tv_sec = 0;
DELAY.tv_nsec = 100000000;
break;
case 3:
DELAY.tv_sec = 0;
DELAY.tv_nsec = 500000000;
break;
case 4:
DELAY.tv_sec = 1;
DELAY.tv_nsec = 0;
break;
case 5:
DELAY.tv_sec = 3;
DELAY.tv_nsec = 0;
break;
default:
break;
} // switch (Speed) {
/*
* The program normally ends when all of the rabbits and foxes have died off. The "--runlimit" arguement
* allows for the program to exit after a set number of iterations are run. The default is zero, i.e. no limit.
*/
i=1;
while (i<argc) {
if (!(strncmp ("--runlimit", argv[i], 10))) {
if ((i + 1) < argc) {
TOTALRUNS = atoi (argv[i+1]);
}
}
i++;
}
/*
* This we need to have here so that the value of LINES and COLS in ncurses.h will be set. Then we can use
* these values to provide error-checking for the command-line arguements of SCREENHEIGHT and SCREENWIDTH.
*/
if (Mode == 2) {
initscr();
}
/*
* We now search the command-line arguements for values for SCREENWIDTH and SCREENHEIGHT. If we are using
* the Ncurses library for output then we will check the values against LINES and COLS as defined by Ncurses,
* otherwise we don't bother and *hope* the user enters sensible values.
*/
i=1;
while (i<argc) {
if (!(strncmp ("--width", argv[i], 7))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if (Temp <= 0) {
if (Mode == 1) {
printf ("Invalid negative argument for SCREENWIDTH.\n");
}
endwin();
return -1;
}
else {
if (Mode == 2) {
if (Temp > COLS) {
endwin();
printf ("Invalid argument for SCREENWIDTH (range = 1 to %i).\n", COLS);
return -1;
}
}
else if (Temp > ARBLIMIT) {
printf ("Invalid argument for SCREENWIDTH (range = 1 to %i).\n", ARBLIMIT);
return -1;
}
SCREENWIDTH = Temp;
i = argc;
}
}
}
i++;
}
i=1;
while (i<argc) {
if (!(strncmp ("--height", argv[i], 8))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if (Temp <= 0) {
if (Mode == 1) {
printf ("Invalid negative argument for SCREENHEIGHT.\n");
}
endwin();
return -1;
}
else {
if (Mode == 2) {
if (Temp > LINES) {
endwin();
printf ("Invalid argument for SCREENHEIGHT (range = 1 to %i).\n", LINES);
return -1;
}
}
else if (Temp > ARBLIMIT) {
printf ("Invalid argument for SCREENHEIGHT (range = 1 to %i).\n", ARBLIMIT);
return -1;
}
SCREENHEIGHT = Temp;
i = argc;
}
}
}
i++;
}
MAXPLAYERS = (SCREENWIDTH * SCREENHEIGHT);
/*
* These three arguements allow the user to alter the basic starting line-up. If no arguements are found then
* the default values are used. If arguements are used but are out-of-range then the program will display an
* error-message and exit.
*/
i=1;
while (i<argc) {
if (!(strncmp ("--grass", argv[i], 7))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if ((Temp < 0) || (Temp >= MAXPLAYERS)) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Invalid argument for INITGRASS (range 0 to %i).\n", MAXPLAYERS);
}
return -1;
}
else {
INITGRASS = Temp;
i = argc;
}
}
}
i++;
}
i=1;
while (i<argc) {
if (!(strncmp ("--rabbits", argv[i], 9))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if ((Temp <= 0) || (Temp >= MAXPLAYERS)) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Invalid argument for INITRABBITS (range 1 to %i).\n", MAXPLAYERS);
}
return -1;
}
else {
INITRABBITS = Temp;
i = argc;
}
}
}
i++;
}
i=1;
while (i<argc) {
if (!(strncmp ("--foxes", argv[i], 7))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if ((Temp <= 0) || (Temp >= MAXPLAYERS)) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Invalid argument for INITFOXES (range 1 to %i).\n", MAXPLAYERS);
}
return -1;
}
else {
INITFOXES = Temp;
i = argc;
}
}
}
i++;
}
/*
* Having now gotten the width and height of the screen we now search for and set the value of MAXPLAYERS
* which is dependent upon those values for error-checking purposes.
*/
i=1;
while (i<argc) {
if (!(strncmp ("--maxplayers", argv[i], 12))) {
if ((i + 1) < argc) {
int Temp = atoi (argv[i+1]);
if ((Temp <= 0) || (Temp >= (SCREENWIDTH * SCREENHEIGHT))) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Invalid argument for MAXPLAYERS (range 1 to %i).\n", (SCREENWIDTH*SCREENHEIGHT));
}
return -1;
}
else {
MAXPLAYERS = Temp;
i = argc;
}
}
}
i++;
}
printf("Still going");
if ((INITGRASS + INITRABBITS + INITFOXES) > MAXPLAYERS) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Initial values are set too high.\n");
printf ("Please ensure the values entered\n");
printf ("total less then %i.\n", MAXPLAYERS);
printf ("Note: if you have only entered values\n");
printf ("for the height and height of the screen\n");
printf ("please ensure you also alter the values\n");
printf ("of the initial grass, rabbits and foxes\n");
printf ("if the default values are too large to\n");
printf ("fit on the screen you have defined.\n");
}
return -1;
}
i=1;
while (i<argc) {
if (!(strncmp ("--genesize", argv[i], 10))) {
if ((i + 1) < argc) {
MAXGENESIZE = atoi (argv[i+1]);
}
if ((MAXGENESIZE <= 0) || (MAXGENESIZE > 1000)) {
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Invalid entry for MAXGENESIZE (range 1 to 1000).\n");
}
return -1;
}
}
i++;
}
srand (time (0));
// Initialise the two arrays
ScreenArray = (struct Entity ****) malloc ((sizeof (struct Entity ***)) * SCREENWIDTH);
EntityArray = (struct Entity **) malloc ((sizeof (struct Entity *)) * MAXPLAYERS);
/*
* You would not believe how many hours it took me to figure out
* that the next few lines of code are an absolute necessity.
* Without NULLing all of the elements of the array, the program
* is prone to random and bugger-to-find Segmentation errors.
* Trust me, I've wasted a large part of my life to discover this!
*/
for (i=0; i<SCREENWIDTH; i++) {
ScreenArray[i] = (struct Entity ***) malloc ((sizeof (struct Entity **)) * SCREENHEIGHT);
for (j=0; j<SCREENHEIGHT; j++) {
ScreenArray[i][j] = NULL;
}
}
for (i=0; i<MAXPLAYERS; i++) {
EntityArray[i] = NULL;
}
/*
// Initialise the output file and put some intro text into it.
if ((OutputFile = fopen (OUTPUTFILENAME, "w")) != NULL) {
fprintf (OutputFile, "output.txt - Miecos run-time error-message and debug data file.\n");
fprintf (OutputFile, "===============================================================\n");
fprintf (OutputFile, "\nFile ready to recieve data.\n\n\n");
}
else {
printf ("Error opening file.");
}
fclose (OutputFile);
*/
//Initialise the grass
for (i=0; i< INITGRASS; i++) {
ReturnedError = SpawnGrass();
if (ReturnedError) {
//LogMessage ("Error in SpawnGrass() call from INITGRASS loop.");
} // if (ReturnedError)
} // for (i=0; i< INITGRASS; i++)
//Initialise the rabbits
for (i=0; i< INITRABBITS; i++)
{
ReturnedError = DoWhatRabbitsDoBest();
if (ReturnedError) {
//LogMessage ("Error in DoWhatRabbitsDoBest() call from INITRABBITS loop.");
} // if (FunctionChecker != AllOK)
} // for (i=0; i< INITRABBITS; i++)
//Initialise the foxes
for (i=0; i< INITFOXES; i++) {
ReturnedError = TheFoxesAreAtItAgain();
if (ReturnedError) {
//LogMessage ("Error in TheFoxesAreAtItAgain() call from INITFOXES loop.");
} // if (FunctionChecker != AllOK)
} // for (i=0; i< INITFOXES; i++)
printf("Drawing screen");
if (Mode == 2) {
// Now we put it all on the screen ...
for (j=0; j<SCREENHEIGHT; j++) {
for (i=0; i<SCREENWIDTH; i++) {
if (ScreenArray[i][j] == NULL) {
mvaddch (j, i, BLANKCHAR);
}
else {
mvaddch (j, i, ScreenArray[i][j][0]->Appearance);
} // if (ScreenArray[NewIndex] == NULL)
} // for (i=0; i<SCREENWIDTH; i++)
} // for (j=0; j<SCREENHEIGHT; j++)
//for (i=0; i<100; i++) {
// mvaddch (43, (i+1), '.');
//}
// ... and draw it.
refresh();
getch();
}
else if (Mode == 1) {
for (j=0; j<SCREENHEIGHT; j++) {
for (i=0; i<SCREENWIDTH; i++) {
if (ScreenArray[i][j]) {
printf ("%c", ScreenArray[i][j][0]->Appearance);
}
else {
printf (".");
}
}
printf ("\n");
}
printf ("\nCompleted iteration 0.\n");
getchar();
}
StillAlive = 1;
//while (Iterations < TOTALRUNS) {
while ((!TOTALRUNS || (Iterations < TOTALRUNS)) && StillAlive) {
for (i=0; i<MAXPLAYERS; i++) {
if (EntityArray[i]) {
Action NextMove = Stay, RevisedMove = Stay;
int dX = 0, dY = 0, OldX = 0, OldY = 0, NewX = 0, NewY = 0;
OldX = EntityArray[i]->X;
OldY = EntityArray[i]->Y;
//ReturnState RecieptValue = AllOK;
/*
* OK, so we have a live entity here (hopefully) so the first thing
* we need to do is ask it what it wants to do.
*/
//LogStat ("Calling EntityArray[]->GetMove for i = ", i);
NextMove = EntityArray[i]->GetMove (&EntityArray[i]);
//LogStat ("NextMove = ", NextMove);
// Now we act upon that request.
switch (NextMove) {
/*
* If the function returns Stay, Die or Hide, the handling for this
* will be taken care of by the function so this loop need not worry
* about it. The same may well be true for Spawn but needs to be
* coded in and tested yet. Eat and Continue only appear when
* HandleObstacle is called but are included anyway for completeness
* and possible debugging purposes. All other possible, legal return
* values are movements which will be handled separately in their own
* nested switch statement.
*/
case Stay:
break;
case Continue:
//LogMessage ("NextMove returned illegal value Continue.");
break;
default:
/*
* In theory, if the switch reaches the default then the return value
* was a movement order. Therefore we now need to work out how to
* handle such an order. The first step is to convert the enum into
* a pair of ints, dX and dY, which can hold only the values of -1, 0
* and 1 which dictate the relative change of the entity. Using that
* we then calculate the absolute value of the entitys' new position.
* Next we see if the space it wants to move to is free and, if so,
* permit it to do so. If not we get the data on the obstacle and pass
* that to the HandleObstacle() method for further instructions.
*/
//LogStat ("GetMove returned ", NextMove);
switch (NextMove) {
case MoveRight:
dX = 1;
dY = 0;
break;
case MoveUpRight:
dX = 1;
dY = -1;
break;
case MoveUp:
dX = 0;
dY = -1;
break;
case MoveUpLeft:
dX = -1;
dY = -1;
break;
case MoveLeft:
dX = -1;
dY = 0;
break;
case MoveDownLeft:
dX = -1;
dY = 1;
break;
case MoveDown:
dX = 0;
dY = 1;
break;
case MoveDownRight:
dX = 1;
dY = 1;
break;
default:
dX = 0;
dY = 0;
break;
} // switch (NextAction) -- movement-specific switch
/*
* Note to self: we have left the nested switch but are still in
* the default clause of the original switch.
*/
//Translate from relative to absolute figures.
NewX = OldX + dX;
NewY = OldY + dY;
/*
* These four lines check if the movement will take it off the
* boundary and wrap it round in a toroidal system to the other
* side of the screen if such is the case.
*/
if (NewX < 0) NewX = (SCREENWIDTH-1);
if (NewY < 0) NewY = (SCREENHEIGHT-1);
if (NewX >= SCREENWIDTH ) NewX = 0;
if (NewY >= SCREENHEIGHT ) NewY = 0;
// if ((OutputFile = fopen ("./output.txt", "a")) != NULL)
// {
// fprintf (OutputFile, "(dX, dY) = (%i,%i).\n\n", dX, dY);
// fprintf (OutputFile, "(NewX, NewY) = (%i,%i).\n\n", NewX, NewY);
// fclose (OutputFile);
// }
// If the point is free then move there.
if (ScreenArray[NewX][NewY] == NULL) {
//LogStat ("Moving EntityArray[i].", i);
EntityArray[i]->X = NewX;
EntityArray[i]->Y = NewY;
ScreenArray[NewX][NewY] = &(EntityArray[i]);
ScreenArray[OldX][OldY] = NULL;
}
else
{
//LogStat ("Calling EntityArray[i]->HandleObstacle() for i = ", i);
//LogStat ("EntityArray[i]->Name = ", EntityArray[i]->Name);
RevisedMove = EntityArray[i]->HandleObstacle (EntityArray[i], ScreenArray[NewX][NewY][0]);
//LogStat ("EntityArray[i]->HandleObstacle() returned ", RevisedMove);
/*
* RevisedMove will be either Continue or Stay, no other possibilities
* exist in the current design. As Stay simply means to do nothing
* we then only need to handle the return value of Continue. All actions
* associated with eating whatever was there before have (fingers
* crossed) already been taken care of. Innit beautiful!
*/
if (RevisedMove == Continue)
{
EntityArray[i]->X = NewX;
EntityArray[i]->Y = NewY;
ScreenArray[NewX][NewY] = &(EntityArray[i]);
ScreenArray[OldX][OldY] = NULL;
}
} // if (ScreenArray[NewX][NewY] == NULL)
} // switch (NextMove) -- from GetMove()
}
}
if (Mode == 2) {
// Now we put it all on the screen ...
for (j=0; j<SCREENHEIGHT; j++) {
for (i=0; i<SCREENWIDTH; i++) {
if (ScreenArray[i][j] == NULL) {
mvaddch (j, i, BLANKCHAR);
}
else {
mvaddch (j, i, ScreenArray[i][j][0]->Appearance);
} // if (ScreenArray[NewIndex] == NULL)
} // for (i=0; i<SCREENWIDTH; i++)
} // for (j=0; j<SCREENHEIGHT; j++)
//for (i=0; i<100; i++) {
// mvaddch (43, (i+1), BLANKCHAR);
//}
// ... and draw it.
refresh();
//getch();
}
else if (Mode == 1) {
for (j=0; j<SCREENHEIGHT; j++) {
for (i=0; i<SCREENWIDTH; i++) {
if (ScreenArray[i][j]) {
printf ("%c", ScreenArray[i][j][0]->Appearance);
}
else {
printf (".");
}
}
printf ("\n");
}
printf ("\nCompleted iteration %i.\n", (Iterations + 1));
//getchar();
}
StillAlive = 0;
for (i=0; i<MAXPLAYERS; i++) {
if (EntityArray[i]) {
if (EntityArray[i]->Class >= 2)
StillAlive = 1;
}
}
if (Speed) {
nanosleep (&DELAY, NULL);
}
Iterations++;
//getch();
} // while ((!TotalRuns || (Iterations < TotalRuns)) && StillAlive) {
/*
* This section may be technically unnecessary as it cleans up all of the arrays of pointers
* that were used in the program and, as the program is about to end soon anyway, it will
* probably be done by the OS automatically but, hey, I'm a perfectionist. Besides, it keeps
* Valgrind happy and if Valgrind's happy them I'm happy!
*/
for (i=0; i<SCREENWIDTH; i++) {
for (j=0; j<SCREENHEIGHT; j++) {
if (ScreenArray[i][j]) {
free (ScreenArray[i][j][0]->GString);
ScreenArray[i][j][0]->GString = NULL;
free (ScreenArray[i][j][0]);
ScreenArray[i][j][0] = NULL;
}
/*
* The program runs fine, no crashes, no memory leaks (per Valgrind) with the following
* line commented out. With it included I get "*** glibc detected ***" errors. Why this
* is I haven't figured out yet therefore I'm leaving the line in until I get my head
* around this problem!
*/
//free (ScreenArray[i][j]);
ScreenArray[i][j] = NULL;
}
free (ScreenArray[i]);
ScreenArray[i] = NULL;
}
free (ScreenArray);
ScreenArray = NULL;
for (i=0; i<MAXPLAYERS; i++) {
free (EntityArray[i]);
EntityArray[i] = NULL;
}
free (EntityArray);
EntityArray = NULL;
if (Mode == 2) {
endwin();
}
if (Mode) {
printf ("Normal end reached!\n");
printf ("%i iterations performed.\n", Iterations);
}
return Iterations;
} // int main()
// Grass functions
Action GrowGrass (struct Entity **this)
{
Action ReturnValue = Stay;
//LogMessage ("Function GrowGrass() answering.");
(*this)->Health++;
if ((*this)->Visible == False)
{
if ((*this)->Health >= ((*this)->MaxHealth)/2)
{
if (ScreenArray[(*this)->X][(*this)->Y] == NULL)
{
(*this)->Visible = True;
ScreenArray[(*this)->X][(*this)->Y] = this;
}
}
}
if ((*this)->Health >= (*this)->MaxHealth)
{
(*this)->Health = ((*this)->Health)/2;
(*this)->SpawnEntity();
}
//LogMessage ("Function GrowGrass() returning.");
return ReturnValue;
} // Action GrowGrass (struct Entity ***this)
ReturnState CrushGrass (struct Entity *this)
{
//LogMessage ("Function CrushGrass() answering.");
ReturnState ReturnValue = AllOK;
this->Health = (this->MaxHealth)/4;
this->Visible = False;
ScreenArray[this->X][this->Y] = NULL;
//LogMessage ("Function CrushGrass() returning.");
return ReturnValue;
} // ReturnState CrushGrass (struct Entity *this)
ReturnState EatGrass (struct Entity **this)
{
//LogMessage ("Function EatGrass() answering.");
ReturnState ReturnValue = AllOK;
int X = (*this)->X, Y = (*this)->Y;
free (ScreenArray[X][Y][0]);
ScreenArray[X][Y][0] = NULL;
ScreenArray[X][Y] = NULL;
return ReturnValue;
} // ReturnState EatGrass (struct Entity **this)
ReturnState SpawnGrass (void)
{
//LogMessage ("Function SpawnGrass() answering.");
/*
* My usual convention is to set ReturnValue to AllOK by default
* but here I take the "guilty until proven innocent" approach
* by making the function find a free space before it is allowed
* to set ReturnValue to AllOK
*/
ReturnState ReturnedError = AllOK; // What the function gets back ...
ReturnState ReturnValue = NoFreeSpaceError; // ... and what it gives back.
int i = 0, FreeSlot = 0;
struct ScreenPoint *NewScreenPoint = NULL;
//LogMessage ("Function SpawnGrass() looking for a free space.");
// First we find somewhere to put it ...
while ((i < MAXPLAYERS) && (ReturnValue == NoFreeSpaceError)) {
if (!(EntityArray[i])) {
// We got one!
//LogStat ("Function SpawnGrass() found one for i = ", i);
EntityArray[i] = (struct Entity *) malloc (sizeof (struct Entity));
//LogMessage ("SpawnGrass() called malloc().");
if (!(EntityArray[i])) {
// Or have we?
ReturnValue = MallocError;
}
else {
FreeSlot = i;
ReturnValue = AllOK;
} // if (EntityArray[i] == NULL) -- from malloc()
} // if (EntityArray[i] == NULL) -- initial test
i++;
} // while ((i<MAXPLAYERS) && (ReturnState == NoFreeSpaceError))
// If we've got one then use it.
if (!(ReturnValue)) {
// ... then we find somewhere to display it.
//LogMessage ("Function SpawnGrass() calling GetNewScreenPoint().");
ReturnedError = GetNewScreenPoint (&NewScreenPoint);
if (ReturnedError) {
// If some thing went wrong null the pointer and return the error code.
//LogStat ("Function SpawnGrass() recieved an error from GetNewScreenPoint(), code = ", RecieptValue);
free (NewScreenPoint);
NewScreenPoint = NULL;
free (EntityArray[FreeSlot]);
EntityArray[FreeSlot] = NULL;
ReturnValue = ReturnedError;
}
else {
// In order to get here all function calls **must** have worked
// so no Segmentation faults :)
// First the basic settings
EntityArray[FreeSlot]->Class = clPlant;
EntityArray[FreeSlot]->Name = idGrass;
EntityArray[FreeSlot]->Appearance = GRASSCHAR;
EntityArray[FreeSlot]->X = NewScreenPoint->X;
EntityArray[FreeSlot]->Y = NewScreenPoint->Y;
EntityArray[FreeSlot]->GString = '\0';
EntityArray[FreeSlot]->MaxHealth = MAXGRASSHEALTH;
EntityArray[FreeSlot]->Health = (MAXGRASSHEALTH)/2;
EntityArray[FreeSlot]->GenePointer = 0;
EntityArray[FreeSlot]->Visible = True;
// Now the function pointers
EntityArray[FreeSlot]->GetMove = GrowGrass;
EntityArray[FreeSlot]->HandleObstacle = NULL;
EntityArray[FreeSlot]->HideEntity = CrushGrass;
EntityArray[FreeSlot]->KillEntity = EatGrass;
EntityArray[FreeSlot]->SpawnEntity = SpawnGrass;
//Now we need to put it on the ScreenArray
//Index = (EntityArray[FreeSlot]->X + (EntityArray[FreeSlot]->Y * SCREENWIDTH));
ScreenArray[EntityArray[FreeSlot]->X][EntityArray[FreeSlot]->Y] = &(EntityArray[FreeSlot]);
// if ((OutputFile = fopen ("./output.txt", "a")) != NULL)
// {
// fprintf (OutputFile, "Index = %i.\n\n", Index);
// fprintf (OutputFile, "FreeSlot = %i.\n\n", FreeSlot);
// fprintf (OutputFile, "EntityArray[%i] (X, Y) = (%i, %i).\n\n", FreeSlot, EntityArray[FreeSlot]->X,
// EntityArray[FreeSlot]->Y);
// fprintf (OutputFile, "ScreenArray[%i] (X, Y) = (%i, %i).\n\n", Index, ScreenArray[Index]->X,
// ScreenArray[Index]->Y);
// fclose (OutputFile);
// }
} // if (RecieptValue != AllOK) -- from GetNewScreenPoint()
} // if (RecieptValue != AllOK) -- from GetNewEntitySpace()
//LogMessage ("Function SpawnGrass() returning.");
free (NewScreenPoint);
NewScreenPoint = NULL;
return ReturnValue;
} // ReturnState SpawnGrass (void)
// Rabbit functions
Action MoveRabbit (struct Entity **this)
{
//LogStat ("Function MoveRabbit() answering, health = ", (*this)->Health);
Action ReturnValue = Stay;
ReturnState ReturnedError = AllOK;
(*this)->Health--;
// If it was hiding then unhide it.
(*this)->Visible = True;
if ((*this)->Health >= (*this)->MaxHealth) {
(*this)->Health = ((*this)->MaxHealth)/2;
//LogMessage ("Function MoveRabbit() calling (*this)->SpawnEntity().");
ReturnedError = (*this)->SpawnEntity();
//LogStat ("Function MoveRabbit() called (*this)->SpawnEntity(), RecieptValue = ", RecieptValue);
ReturnValue = Stay;
}
else if ((*this)->Health <= 0) {
//LogMessage ("Function MoveRabbit() calling (*this)->KillEntity().");
ReturnedError = (*this)->KillEntity (this);
//LogStat ("Function MoveRabbit() called (*this)->KillEntity(), RecieptValue = ", RecieptValue);
ReturnValue = Stay;
}
else if (!((*this)->GString)) {
//LogMessage ("(*this)->GString == NULL.");
ReturnValue = Stay;
}
/*
* If the flow reaches here them everything should be OK
* to move the rabbit. Any conditions that would prevent
* the rabbit from moving should be handled before this
* point.
*/
else {
//fprintf (OutputFile, "\n");
//LogMessage ("Function MoveRabbit() choosing next move.");
// WARNING -- no error-checking of GenePointer value
if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveRight;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUpRight;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O')&&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUp;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUpLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDownLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDown;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDownRight;
}
else {
/*
* If this runs there is problem with the GString so
* some extra coding is needed here to investigate and
* report the problem. For now lets just ignore it and
* carry on gracefully.
*/
ReturnValue = Stay;
}
//LogStat ("Function MoveRabbit() chose next move = ", ReturnValue);
(*this)->GenePointer += 3;
if ((*this)->GenePointer >= strlen ((*this)->GString)) {
(*this)->GenePointer = 0;
}
} // if ((*this)->GString == 0)
//LogMessage ("Function MoveRabbit() returning.");
return ReturnValue;
}
Action BlockedRabbit (struct Entity *this, struct Entity *that)
{
//LogMessage ("Function BlockedRabbit() answering.");
/*
* In this very key function we define what the animal actually eats.
* What happens is that when the controller gets a movement order from
* the animal and tries to move in that direction but finds its way
* blocked, it will then call this function, passing a pointer to
* obstacle, to ask the animal how to handle it. If the animal
* eats that obstacle or performs any other type of action with that
* obstacle then there will be an entry within the switch() statement
* in this function. If there is no entry in the switch() statement
* then the function defaults to Action Stay meaning that the blockage
* is unresolveable.
*/
Action ReturnValue = Stay;
ReturnState ReturnedError = AllOK;
//LogStat ("BlockedRabbit() ready to run switch statement on Name = ", that->Name);
switch (that->Name) {
case idGrass:
//LogMessage ("BlockedRabbit() found some grass, calling that->KillEntity().");
ReturnedError = that->KillEntity (&that);
//LogMessage ("BlockedRabbit() called that->KillEntity().");
if (!ReturnedError) {
// Yum!
this->Health += GRASSNUTRITION;
}
break;
default:
//LogMessage ("BlockedRabbit() hit an unknown obstacle.");
break; // Prevents compiler warning messages!
} // switch (that->EntityName)
//LogMessage ("BlockedRabbit() returning.");
return ReturnValue;
}
ReturnState HideRabbit (struct Entity *this)
{
//LogMessage ("HideRabbit() answering.");
/*
* This function is used for situations where the rabbit is in hiding
* (underground!) and therefore does not appear on the screen. There
* is no implementation of the function at present but it's here
* because it **will** be useful and beacuse it helps to keep the code
* consistent with the GRAND DESIGN (TM).
*/
ReturnState ReturnValue = AllOK;
this->Visible = False;
// Short and sweet.
//LogMessage ("HideRabbit() returning.");
return ReturnValue;
}
ReturnState KillRabbit (struct Entity **this)
{
//LogMessage ("KillRabbit() answering.");
/* This function does exactly what it says on the tin! The parameter
* (struct Entity **this) is necessary because this function needs to
* free() the memory and NULL it. Using (struct Entity *this) does
* not allow for this to be done.
*/
ReturnState ReturnValue = AllOK;
int X = (*this)->X, Y = (*this)->Y;
free (ScreenArray[X][Y][0]->GString);
ScreenArray[X][Y][0]->GString = NULL;
free (ScreenArray[X][Y][0]);
ScreenArray[X][Y][0] = NULL;
ScreenArray[X][Y] = NULL;
//LogMessage ("KillRabbit() returning.\n\n");
return ReturnValue;
}
ReturnState DoWhatRabbitsDoBest (void)
{
//LogMessage ("DoWhatRabbitsDoBest() answering.");
/*
* My usual convention is to set ReturnValue to AllOK by default
* but here I take the "guilty until proven innocent" approach
* by making the function find a free space before it is allowed
* to set ReturnValue to AllOK
*/
/*
* 10-05-05 Re-design notification
* Currently this function has the inefficiency of calling malloc()
* for the struct before we know that all of the functions calls necessary
* to get it running are working first
*/
/*
* The flow of this function goes something like this:
* Check for a free space in EntityArray
* if there is...
* set up the temp values (chromosomes and screen position)
* if not successful...
* report and exit
* else...
* malloc() the struct
* if not successful...
* report and exit
* else...
* init the GString
* if it didn't work
* free() and exit
* else
* set up the attributes and methods
* end if
* end if
* end if
* end if
* return
*/
ReturnState ReturnedError = AllOK; // What the function gets back ...
ReturnState ReturnValue = NoFreeSpaceError; // ... and what it gives back.
int i = 0, Index = 0, FreeSlot = 0, NumChromos = 0;
char *TempGString = NULL;
struct ScreenPoint *NewScreenPoint = NULL;
// First we find somewhere to put it ...
//LogMessage ("DoWhatRabbitsDoBest() looking for a free space.");
while ((i < MAXPLAYERS) && (ReturnValue == NoFreeSpaceError)) {
if (EntityArray[i] == NULL) {
//LogMessage ("DoWhatRabbitsDoBest() found one.");
// We got one!
/*
* 11 May 2005 - Design alteration
* Previously, the entity was malloc()'ed at this point before
* the GString was set. THEN the GString was set and if it failed
* then the GString had to be free()'d. Instead we now create a temporary
* value for the GString, check if it suceeded and only then malloc() the
* entity and copy it across if successful.
*/
// Ditto for the GetNewScreenPoint() call.
//LogMessage ("DoWhatRabbitsDoBest() setting up entity data.");
NumChromos = SetGString (&TempGString);
ReturnedError = GetNewScreenPoint (&NewScreenPoint);
//LogMessage ("DoWhatRabbitsDoBest() has set up entity data.");
// if no chromosomes OR the return value is not equal to AllOK (zero)...
if ((!NumChromos) || (ReturnedError)) {
//LogMessage ("Error setting up entity data in function DoWhatRabbitsDoBest().");
ReturnValue = ReturnedError;
}
else {
EntityArray[i] = (struct Entity *) malloc (sizeof (struct Entity));
if (EntityArray[i] == NULL) {
// Or have we?
//LogMessage ("DoWhatRabbitsDoBest() recieved error from malloc() call.");
ReturnValue = MallocError;
}
else {
EntityArray[i]->GString = (char *) malloc ((NumChromos * 3) + 1);
if (!(EntityArray[i]->GString)) {
free (EntityArray[i]);
ReturnValue = MallocError;
}
else {
// In order to get here all function calls **must** have worked
// so no Segmentation faults :)
FreeSlot = i;
ReturnValue = AllOK;
//LogMessage ("Copying GString.");
strncpy (EntityArray[FreeSlot]->GString, TempGString, ((NumChromos * 3) + 1));
//LogMessage ("DoWhatRabbitsDoBest() setting attributes and methods.");
// First the basic settings
EntityArray[FreeSlot]->Class = clHerb;
EntityArray[FreeSlot]->Name = idRabbit;
EntityArray[FreeSlot]->Appearance = RABBITCHAR;
EntityArray[FreeSlot]->X = NewScreenPoint->X;
EntityArray[FreeSlot]->Y = NewScreenPoint->Y;
EntityArray[FreeSlot]->MaxHealth = MAXRABBITHEALTH;
EntityArray[FreeSlot]->Health = (MAXRABBITHEALTH)/2;
EntityArray[FreeSlot]->GenePointer = 0;
EntityArray[FreeSlot]->Visible = True;
// Now the function pointers
EntityArray[FreeSlot]->GetMove = MoveRabbit;
EntityArray[FreeSlot]->HandleObstacle = BlockedRabbit;
EntityArray[FreeSlot]->HideEntity = HideRabbit;
EntityArray[FreeSlot]->KillEntity = KillRabbit;
EntityArray[FreeSlot]->SpawnEntity = DoWhatRabbitsDoBest;
//Now we need to put it on the ScreenArray
Index = (EntityArray[FreeSlot]->X + (EntityArray[FreeSlot]->Y * SCREENWIDTH));
ScreenArray[NewScreenPoint->X][NewScreenPoint->Y] = &(EntityArray[FreeSlot]);
} // if (!(EntityArray[i]->GString))
} // if (EntityArray[i] == NULL)
} // if ((!NumChromos) || (RecieptValue))
} // if (EntityArray[i] == NULL)
i++;
} // while ((i<MAXPLAYERS) && (ReturnState == NoFreeSpaceError))
//LogMessage (EntityArray[FreeSlot]->GString);
//LogMessage ("DoWhatRabbitsDoBest() returning.");
free (TempGString);
free (NewScreenPoint);
return ReturnValue;
}
// Fox functions.
Action MoveFox (struct Entity **this)
{
//LogStat ("MoveFox() answering, health = ", (*this)->Health);
Action ReturnValue = Stay;
ReturnState ReturnedError = AllOK;
(*this)->Health--;
// If it was hiding then unhide it.
(*this)->Visible = True;
if ((*this)->Health >= (*this)->MaxHealth) {
(*this)->Health = ((*this)->MaxHealth)/2;
//LogMessage ("MoveFox() calling (*this)->SpawnEntity().");
ReturnedError = (*this)->SpawnEntity();
//LogMessage ("MoveFox() called (*this)->SpawnEntity().");
ReturnValue = Stay;
}
else if ((*this)->Health <= 0) {
//LogMessage ("MoveFox() calling (*this)->KillEntity().");
ReturnedError = (*this)->KillEntity (this);
//LogMessage ("MoveFox() called (*this)->KillEntity().");
ReturnValue = Stay;
}
else if (!((*this)->GString)) {
//LogMessage ("(*this)->GString == NULL.");
}
/*
* If the flow reaches here them everything should be OK
* to move the rabbit, ahem, fox. Any conditions that
* would prevent the fox from moving should be handled
* before this point.
*/
else {
//LogMessage ("Function MoveFox() choosing next move.");
if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveRight;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUpRight;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O')&&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUp;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'O')) {
ReturnValue = MoveUpLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'O') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDownLeft;
}
else if (((*this)->GString[(*this)->GenePointer] == 'O') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDown;
}
else if (((*this)->GString[(*this)->GenePointer] == 'I') &&
((*this)->GString[(*this)->GenePointer + 1] == 'I') &&
((*this)->GString[(*this)->GenePointer + 2] == 'I')) {
ReturnValue = MoveDownRight;
}
else {
/*
* If this runs there is problem with the GString so
* some extra coding is needed here to investigate and
* report the problem. For now lets just ignore it and
* carry on gracefully.
*/
ReturnValue = Stay;
}
//LogStat ("Function MoveFox() choose next move = ", ReturnValue);
(*this)->GenePointer += 3;
if ((*this)->GenePointer >= strlen ((*this)->GString)) {
(*this)->GenePointer = 0;
}
} // if ((*this)->GString == 0)
//LogMessage ("MoveFox() returning.");
return ReturnValue;
}
Action BlockedFox (struct Entity *this, struct Entity *that)
{
//LogMessage ("BlockedFox() answering.");
/*
* In this very key function we define what the animal actually eats.
* What happens is that when the controller gets a movement order from
* the animal and tries to move in that direction but finds its way
* blocked, it will then call this function, passing a pointer to
* obstacle, to ask the animal how to handle it. If the animal
* eats that obstacle or performs any other type of action with that
* obstacle then there will be an entry within the switch() statement
* in this function. If there is no entry in the switch() statement
* then the function defaults to Action Stay meaning that the blockage
* is unresolveable.
*/
Action ReturnValue = Stay;
ReturnState ReturnedError = AllOK;
//LogMessage ("BlockedFox() ready to run switch statement.");
switch (that->Name) {
case idRabbit:
//LogMessage ("BlockedFox() caught a rabbit.");
ReturnedError = that->KillEntity (&that);
//LogMessage ("BlockedFox() killed a rabbit.");
if (!ReturnedError) {
// Yum!
this->Health += RABBITNUTRITION;
}
break;
// If it's not a rabbit but it is a plant then walk over it!
default:
switch (that->Class) {
case clPlant:
//LogMessage ("BlockedFox() found some grass.");
ReturnedError = that->HideEntity (that);
if (!ReturnedError) {
// Onwards!
ReturnValue = Continue;
}
break;
default:
break; // Prevents compiler warning messages!
} // switch (that->EntityClass)
} // switch (that->EntityName)
//LogMessage ("BlockedFox() returning.");
return ReturnValue;
} // Action BlockedFox (struct Entity *this, struct Entity *that)
//ReturnState HideFox (struct Entity *this);
//ReturnState KillFox (struct Entity **this);
ReturnState TheFoxesAreAtItAgain (void)
{
//LogMessage ("TheFoxesAreAtItAgain() answering.");
/*
* My usual convention is to set ReturnValue to AllOK by default
* but here I take the "guilty until proven innocent" approach
* by making the function find a free space before it is allowed
* to set ReturnValue to AllOK
*/
/*
* 10-05-05 Re-design notification
* Currently this function has the inefficiency of calling malloc()
* for the struct before we know that all of the functions calls necessary
* to get it running are working first
*/
/*
* The flow of this function goes something like this:
* Check for a free space in EntityArray
* if there is...
* set up the temp values (chromosomes and screen position)
* if not successful...
* report and exit
* else...
* malloc() the struct
* if not successful...
* report and exit
* else...
* init the GString
* if it didn't work
* free() and exit
* else
* set up the attributes and methods
* end if
* end if
* end if
* end if
* return
*/
ReturnState ReturnedError = AllOK; // What the function gets back ...
ReturnState ReturnValue = NoFreeSpaceError; // ... and what it gives back.
int i = 0, Index = 0, FreeSlot = 0, NumChromos = 0;
char *TempGString = NULL;
struct ScreenPoint *NewScreenPoint = NULL;
// First we find somewhere to put it ...
//LogMessage ("TheFoxesAreAtItAgain() looking for a free space.");
while ((i < MAXPLAYERS) && (ReturnValue == NoFreeSpaceError)) {
if (EntityArray[i] == NULL) {
//LogMessage ("TheFoxesAreAtItAgain() found one.");
// We got one!
/*
* 11 May 2005 - Design alteration
* Previously, the entity was malloc()'ed at this point before
* the GString was set. THEN the GString was set and if it failed
* then the GString had to be free()'d. Instead we now create a temporary
* value for the GString, check if it suceeded and only then malloc() the
* entity and copy it across if successful.
*/
// Ditto for the GetNewScreenPoint() call.
//LogMessage ("TheFoxesAreAtItAgain() setting up entity data.");
NumChromos = SetGString (&TempGString);
ReturnedError = GetNewScreenPoint (&NewScreenPoint);
//LogMessage ("TheFoxesAreAtItAgain() has set up entity data.");
// if no chromosomes OR the return value is not equal to AllOK (zero)...
if ((!NumChromos) || (ReturnedError)) {
//LogMessage ("Error setting up entity data in function TheFoxesAreAtItAgain().");
ReturnValue = ReturnedError;
}
else {
EntityArray[i] = malloc (sizeof (struct Entity));
if (EntityArray[i] == NULL) {
// Or have we?
//LogMessage ("TheFoxesAreAtItAgain() recieved error from malloc() call.");
ReturnValue = MallocError;
}
else {
EntityArray[i]->GString = (char *) malloc ((NumChromos * 3) + 1);
if (!(EntityArray[i]->GString)) {
free (EntityArray[i]);
ReturnValue = MallocError;
}
else {
// In order to get here all function calls **must** have worked
// so no Segmentation faults :)
FreeSlot = i;
ReturnValue = AllOK;
//LogMessage ("Copying GString.");
strncpy (EntityArray[FreeSlot]->GString, TempGString, ((NumChromos * 3) + 1));
//LogMessage ("TheFoxesAreAtItAgain() setting attributes and methods.");
// First the basic settings
EntityArray[FreeSlot]->Class = clCarn;
EntityArray[FreeSlot]->Name = idFox;
EntityArray[FreeSlot]->Appearance = FOXCHAR;
//EntityArray[FreeSlot]->Colour = FOXCOLOUR;
EntityArray[FreeSlot]->X = NewScreenPoint->X;
EntityArray[FreeSlot]->Y = NewScreenPoint->Y;
EntityArray[FreeSlot]->MaxHealth = MAXFOXHEALTH;
EntityArray[FreeSlot]->Health = (MAXFOXHEALTH)/4;
EntityArray[FreeSlot]->GenePointer = 0;
EntityArray[FreeSlot]->Visible = True;
// Now the function pointers
EntityArray[FreeSlot]->GetMove = MoveFox;
EntityArray[FreeSlot]->HandleObstacle = BlockedFox;
EntityArray[FreeSlot]->HideEntity = HideRabbit;
EntityArray[FreeSlot]->KillEntity = KillRabbit;
EntityArray[FreeSlot]->SpawnEntity = TheFoxesAreAtItAgain;
//Now we need to put it on the ScreenArray
Index = (EntityArray[FreeSlot]->X + (EntityArray[FreeSlot]->Y * SCREENWIDTH));
ScreenArray[NewScreenPoint->X][NewScreenPoint->Y] = &EntityArray[FreeSlot];
} // if (!(EntityArray[i]->GString))
} // if (EntityArray[i] == NULL)
} // if ((!NumChromos) || (ReturnedError))
} // if (EntityArray[i] == NULL)
i++;
} // while ((i<MAXPLAYERS) && (ReturnState == NoFreeSpaceError))
//LogMessage (EntityArray[FreeSlot]->GString);
//LogMessage ("TheFoxesAreAtItAgain returning.");
free (TempGString);
free (NewScreenPoint);
return ReturnValue;
}
// Additional Miecos-specific functions
ReturnState GetNewScreenPoint (struct ScreenPoint **NewPoint)
{
/* Description:
* This function accepts an pointer a pointer to a struct, finds a space for it in ScreenArray,
* assigns values to its X and Y attributes if it finds a space and returns an error code
* depending on whether on not it was successful.
*
* Libraries:
* stdlib.h - malloc()
* - sizeof()
*
* Dependencies:
* LogMessage (char *)
* int Rand (int)
* enum ReturnState {}
* int MAXTRIES
* int SCREENWIDTH
* int SCREENHEIGHT
* ??? SCREENARRAY[( >= (SCREENHEIGHT * SCREENWIDTH))]
* struct ScreenPoint {... int X, int Y, ...}
*
* Prerequisites:
* This function requires that the parameter has been free()'d first, otherwise the memory
* will be lost resulting in a memory leak.
* It assumes that the array is a one-dimensional one that accesses two dimensions by
* the formula (X, Y) --> (X + (Y * SCREENWIDTH)).
*
* Issues:
* None known.
*
* Contract:
* This program accepts an unused pointer to a pointer to a struct, malloc()'s space to it,
* finds a place for it in the ScreenArray, assigns values for its X and Y arrtubutes and
* returns a value of zero if it was successful or one of the following values if it wasn't:
* NoFreePointError, MallocError.
*/
//LogMessage ("GetNewScreenPoint() answering.");
ReturnState ReturnValue = NoFreePointError;
int i = 0, j = 0, Tries = 0;
(*NewPoint) = NULL;
(*NewPoint) = (struct ScreenPoint *) malloc (sizeof (struct ScreenPoint));
if (NewPoint == NULL) {
ReturnValue = MallocError;
}
else {
while ((Tries < MAXTRIES) && (ReturnValue == NoFreePointError)) {
i = Rand (SCREENWIDTH);
j = Rand (SCREENHEIGHT);
if ((i == -1) || (j == -1)) {
//LogMessage ("Error in Rand function, invalid return value.");
ReturnValue = GeneralError;
}
else {
if (ScreenArray[i][j] == NULL) {
// We got one!
(*NewPoint)->X = i;
(*NewPoint)->Y = j;
ReturnValue = AllOK;
}
else {
Tries++;
}
} // if (ScreenArray[Index] == NULL)
} // while ((Tries < MAXTRIES) && (ReturnValue == NoFreePointError))
} // if (NewPoint == NULL)
//LogMessage ("GetNewScreenPoint() returning.");
//free (NewPoint);
return ReturnValue;
} // ReturnState GetNewScreenPoint (struct ScreenPoint **NewPoint)
int SetGString (char **NewGString)
{
/*
* Description:
* This function accepts a pointer to a string pointer, creates a random, null-terminated
* string of random length consisting of 'I''s and 'O''s and returns the number of
* chromosomes in the string (the length of the string will be ((ReturnValue * 3) + 1)).
*
* Libraries:
* stdlib.h - malloc(), free()
* strings.h - bzero()
*
* Dependencies:
* LogMessage (char *)
* int Rand (int)
* int MANGENESIZE
*
* Prerequisites:
* One of the first things this function does is to NULL the parameter so it needs
* to have been free()'d before being called, if necessary, otherwise anything the
* pointer points to will be lost and a memory leak will be created.
*
* Issues:
* No error-checking of the value of MAXGENESIZE.
*
* Contract:
* This function accepts an unused pointer to a char pointer. It will then NULL the
* pointer, malloc() space for it, create a randomly created genestring of random
* length to a maximum of (MAXGENESIZE * 3) plus the null character in that space and
* return the number of chromosomes in the string. If it encounters any errors it
* will NULL the string and return 0.
*/
/*
* 10 May 2005 - Design Alteration
* Originally this function took a pointer to a pointer to a char
* and used that to create and set the GString. Now however it takes
* no parameters but instead returns a pointer to the newly created
* GString. If there is an error in this function the returned char
* will be NULL
*/
/*
* 11 May 2005 - Design Alteration alteration
* For practical purposes this function will now work directly on the
* string itself and return the number of chromosomes. Otherwise we either
* need to pass the required length as a parameter OR get the length of the
* string with the strlen() function once it has been passed back. Neither
* of these solutions is very elegant.
*/
//LogMessage ("SetGString() answering.");
int i = 0, GeneLength = 0, NextGene = 0, NumChromo = 0;
/*
* Set size for this gene. The genes are a triplet system of the form
* OOI, IOI, etc. and MAXGENESIZE actually denotes the maximum number
* of triplets, NOT the total length of the string. The Rand() function
* return a random number in the range 0 <= ReturnedInt < MAXGENESIZE so this
* statement takes the return value and converts it into the actual length
* of the GString which will be a number divisible by 3. By default if the
* Rand() functions hits an error then it returns the value of -1 meaning
* that the statement below will evaluate to zero.
*/
(*NewGString) = NULL;
NumChromo = (Rand(MAXGENESIZE) + 1);
//LogStat ("GeneLength = ", GeneLength);
if (!(NumChromo)) {
// Houston, we have a problem.
//LogMessage ("Error getting NumChromo from Rand() in SetGString.");
//NumChromo = 0;
/*
* If the flow reaches here then there is an error howeverwe don't need to
* do anything right now except skip the rest of the function and send out an
* error message.
*/
}
else {
// malloc() memory for the GString and set the last value as NULL
GeneLength = (NumChromo * 3);
(*NewGString) = (char *) malloc (GeneLength + 1);
if (!(NewGString)) {
//LogMessage ("Malloc error in function SetGString.");
(*NewGString) = NULL;
NumChromo = 0;
}
else {
/*
* If there has been any problems earlier then ReturnValue will NOT equal
* AllOK. If it does then it should be safe to run this loop
*/
bzero ((*NewGString), (GeneLength + 1));
while (i < GeneLength) {
NextGene = Rand(2);
if (NextGene == 0) {
(*NewGString)[i] = 'O';
}
else if (NextGene == 1) {
(*NewGString)[i] = 'I';
}
else {
//LogMessage ("Error calling Rand() in function SetGString.");
free (*NewGString);
(*NewGString) = NULL;
i = GeneLength;
NumChromo = 0;
} // if (NextGene == 1)
i++;
} // while (i < GeneLength)
} // if (!(NewGString))
} // if (!(NumChromo));
//LogMessage (*NewGString);
//LogMessage ("SetGString() returning.");
//free (NewGString);
return NumChromo;
} // int SetGString (char **NewGString)
// Additional general functions
int Rand (int MaxNum)
{
/*
* Description:
* This function acts as a wrapper for the standard rand() function. It acts as limiter
* allowing for the return of a random number in a specified range.
*
* Libraries:
* stdlib.h - rand().
*
* Dependencies:
* None.
*
* Prerequisites:
* This function does not call the srand() function so this needs to be called
* separately if required.
*
* Issues:
* None known.
*
* Contract:
* This function accepts an integer value (MaxNum) in the range (0 < MaxNum <= 1000).
* It will then return a random value in the range (0 <= ReturnValue < MaxNum).
* If the parameter MaxNum is outside the range specified, the function will return
* the value -1.
*/
unsigned long RandNum;
int ReturnValue = 0;
if ((MaxNum > 0) && (MaxNum <= 1000)) {
RandNum = rand();
/* The next two lines assure that the value of the calculations
* cannot exceed the value of RAND_NUM as defined in stdlib.h
* by first reducing RandNum by 1024 and multiplying it by MaxNum
* which will not be larger than 1000. That should ensure no
* possibility of cut-off errors.
*/
RandNum = (RandNum/1024);
ReturnValue = (int)((RandNum*MaxNum)/(RAND_MAX/1024));
}
else {
ReturnValue = -1;
}
return ReturnValue;
} // int Rand (int MaxNum)
//void LogMessage (char *Message)
//{
/* if ((OutputFile = fopen (OUTPUTFILENAME, "a")) != NULL) {
fprintf (OutputFile, Message);
fprintf (OutputFile, "\n\n");
fclose (OutputFile);
}
//printf (Message);
// } // void LogMessage (char *Message)
//void LogStat (char *Message, int Stat)
//{
// static int LogCalls;
/ *
if ((OutputFile = fopen (OUTPUTFILENAME, "a")) != NULL) {
LogCalls ++;
//fprintf (OutputFile, "%i calls made to LogStat.\n", LogCalls);
fprintf (OutputFile, Message);
fprintf (OutputFile, "%i", Stat);
fprintf (OutputFile, "\n\n");
fclose (OutputFile);
}
} */ // void LogStat (char *Message, int Stat)
// Function header template
/* Description:
*
*
* Libraries:
*
*
* Dependencies:
*
*
* Prerequisites:
*
*
* Issues:
*
*
* Contract:
*
*/
|
the_stack_data/11076373.c | /* GRUPO: Panelinha
Membros:
Henrique Soares Costa (Matricula : 20213010852)
João Vitor Araujo Leão (Matricula : 20213008059)
Lucas Silva Moreira (Matricula : 20213008101)
Roginaldo Reboucas Rocha Junior (Matricula : 20213008157)
Pedro Carneiro Rabetim (Matricula : 20213008139)
Gabriel Henrique Martins (Matricula : 20213009619)
CASO QUEIRA VER MAIS INFORMACOES:
github.com/riquetret/Trabalho-De-Final-de-Prog
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include <ctype.h>
typedef struct //Declara nosso struct de filmes
{
int identificador;
char nome[50];
char genero[30];
unsigned short int anoLancamento;
char nomeDiretor[30];
}Filme;
enum Estados{ //Declara nossos estados do programa (Como se fosse uma FSM, ou maquina de estados)
Saida=0,
Adicionar=1,
Editar=2,
Remover=3,
Exibir=4,
Gravar=5,
Ler_Banco=6,
};
//Declara nossos protótipos
void limpa_tela(); //Limpa a tela da console
void limpa_buffer(); //Limpa o buffer do teclado (lixo do teclado)
int le_numero(void *numero,double ri, double rf, char t); //Le um numero no intervalo ri até rf, ou seja, ri<numero<rf
void inicializa_arquivo(FILE **ptr,char *nome,char *modo); //Inicializa nossos ponteiros de arquivo no modo desejado
int adicionaFilme(Filme *ptr, int tam,FILE *ptr2);
int geraIdentificador(FILE *ptr); //Gera identificador
int editaFilme(Filme *ptr,int posicao,FILE *ptr2);
int removeFilme(Filme *ptr,int posicao);
int imprimeFilmes(Filme *ptr,int posicao);
int escreveFilmes(Filme *ptr,FILE *arq_salvar,int posicao,int *tam);//Escreve do vetor de filmes para o banco de dados
int gravaFilmes(Filme *ptr,FILE *arq_orig,int *tam); //Grava os filmes do vetor para o banco de dados
int leFilmes(Filme *ptr,int acao,FILE *dados); //Ler os filmes do banco de dados e atribuir ao vetor
int buscaFilme(Filme *ptr,FILE *ptr2,char *nome_filme); //Busca o nome do filme desejado
int main(){
Filme filmes_lidos[50]; //Cria Vetor de Structs
removeFilme(&filmes_lidos[0],-1); //Vamos resetar o vetor de filmes do programa
enum Estados opcao; //Declara Enum com estados
char menu[]= //Declara exibição padrão do menu
"0)Sair do Programa\
\n1)Adicionar Filmes\
\n2)Editar Filmes\
\n3)Remover Filmes\
\n4)Exibir Filmes\
\n5)Gravar Filmes\
\n6)Ler Filme do Banco";
char acoes[][9]={"editar?","deletar?"}; //Declara matriz para não repetir o código basicamente
char filme_desejado[50]; //Vetor para receber o nome do filme desejado/a ser buscado
int posicoes,filmes_adicionados=0,retorno; //Declara posicoes (Para alterar uma posição do vetor), declara filmes_adicionados (para contabilizar quantos filmes já foram adicionados) e por fim declara retorno para analisar o retorno de algumas funções
char status_do_banco[]="NAO"; //O banco de dados esta aberto? Neste caso nao
FILE *arquivo; //Declara ponteiro de arquivo
//setlocale(LC_ALL, "Portuguese");
inicializa_arquivo(&arquivo,"filmes.txt","r+"); //Abre o arquivo "filmes.txt" no modo leitura para atualizar
do
{
printf("================================================================\n");
printf("BEM-VINDO ao forum MANIA-FILMES\n"); //Mensagens iniciais
printf("\nSe sua entrada nao for processada, aperte \"enter\" DUAS vezes\n\n"); //Devido ao limpa_buffer que pode tentar ler quando nao ha entradas no buffer do teclado
printf("Voce carregou filmes do banco de dados? %s",status_do_banco); //Exibe se temos um filme carregado do banco de dados
printf("\nQuantos filmes voce ja carregou no sistema? %d Filmes (Max 50 Filmes)\n",filmes_adicionados); //Mostra quantos filmes foram adicionados
printf("\n%s\nDigite qual opcao deseja: ",menu); //Exibe opções ao usuário
le_numero(&opcao,0,6,'i'); //Le opção escolhida do menu (char menu[])
limpa_tela(); //Limpa a tela
if(1<opcao && opcao<4){ //A pessoa deseja editar? ou deletar ou exibir?
imprimeFilmes(&filmes_lidos[0],-1); //Exiba os filmes cadastrados
printf("\nQual posicao deseja %s (0 para cancelar)\n",acoes[opcao-2] ); //Pergunta qual posicao deseja editar ou deletar ou (Sabemos que a pessoa quer uma dessas três opcoes)
le_numero(&posicoes,0,50,'i'); //Le a posição desejada
posicoes--; //Decrementa posicoes para escolher a posicao correta no vetor
if(posicoes<0)continue; //Se deseja cancelar saia e volte para o loop
}
switch(opcao){ //Analisando a escolha da pessoa
case Adicionar:
retorno = adicionaFilme(&filmes_lidos[0],filmes_adicionados,arquivo); //retorno recebe a quantidade filmes adicionados
if(retorno==-1)printf("ERRO: O sistema nao suporta a adicao de mais filmes");//Vetor cheio?
else{
filmes_adicionados+=retorno; //Incrementa os filmes_adicionados
printf("\nFilmes adicionados com sucesso\n\n"); //Mostra mensagem ao usuário
}
break;
case Editar:
limpa_tela(); //Limpa a tela
imprimeFilmes(&filmes_lidos[0],posicoes); //Exibe filme escolhido
editaFilme(&filmes_lidos[0],posicoes,arquivo); //Edita filme escolhido
break;
case Remover:
removeFilme(&filmes_lidos[0],posicoes); //Remove Filme Escolhido
if(filmes_adicionados>0)filmes_adicionados--; //Tiramos um filme logo decremente filmes_adicionados
printf("Filme removido com sucesso\n"); //Mostra Filme Removido com sucesso
break;
case Exibir:
printf("Qual posicao deseja exibir? -1 para todos\n"); //Pergunta qual posicao deseja imprimir/exibir
le_numero(&posicoes,-1,50,'i'); //Exibe a posicao
posicoes--; //Decrementa posicoes, para escolher a posicao correta no vetor
imprimeFilmes(&filmes_lidos[0],posicoes); //Exibe filme escolhido ou todos se posicoes igual a -1
break;
case Gravar:
printf("ALERTA: A gravacao de filmes, retira da memoria os filmes ja carregados\n\n");
gravaFilmes(&filmes_lidos[0],arquivo,&filmes_adicionados); //Grava os filmes adicionados ou alterados
strcpy(status_do_banco,"NAO"); //Tudo foi resetado, logo o banco nao esta mais carregado
inicializa_arquivo(&arquivo,"filmes.txt","r+"); //Abre o arquivo "filmes.txt" novamente, pq o gravaFilme deleta o arquivo "filmes.txt"
break;
case Ler_Banco:
limpa_tela(); //limpa a tela
printf("ALERTA: A leitura do banco de dados, sobrescreve os filmes ja carregados na memoria\n\n");
printf("Voce deseja:\n");
printf("0)Cancelar a operacao\
\n1)Procurar Por Um Filme\
\n2)Abrir os filmes do Banco de dados\
\n3)Deletar/Recriar o Banco de Dados\n");
printf("Sua opcao: ");
le_numero(&posicoes,0,3,'i'); //Le a opcao desejada
switch (posicoes) //Analisa a escolha
{
case 1: //A pessoa deseja procurar um filme
while(1){
printf("\nDigite o filme desejado: "); //Pede o filme
fgets(filme_desejado,50,stdin); //Le o filme para procurar
limpa_buffer(); //Limpa lixo do teclado
filme_desejado[strcspn(filme_desejado, "\n")] = 0; //Remove \n lido pelo fgets
for(posicoes=0;filme_desejado[posicoes]!='\0';posicoes++)filme_desejado[posicoes]=tolower(filme_desejado[posicoes]);//Transforma o nome do filme digitado para minusculo
if(buscaFilme(&filmes_lidos[0],arquivo,filme_desejado)==-1){ //Se o filme nao foi encontrado
printf("\nErro: Filme nao encontrado\n"); //Exiba o erro
printf("Deseja continuar a busca? (Digite S para sim e N para nao)\n"); //Pergunte se deseja continuar a busca
filme_desejado[0]=getchar(); //Leia a opcao digitada
filme_desejado[0]=tolower(filme_desejado[0]); //Transforme a opcao digitada para minusculo
if(filme_desejado[0]=='n')break; //Se pessoa deseja sair, Saia do loop
}
else{
filmes_adicionados++; //Se o filme foi encontrado, logo incremente filmes_adicionados
strcpy(status_do_banco,"SIM"); //Fale que ha filmes carregados do banco
break; //Se o filme foi encontrado, saia do loop
}
}//END while(1)
break;
case 2: //A pessoa deseja ler o banco de dados
retorno=leFilmes(&filmes_lidos[0],2,arquivo); //O leFilmes busca os primeiros 50 filmes do banco e retorna a quantidade adicionada para retorno
filmes_adicionados+=retorno; //Incremene o filmes_adicionados
if(retorno>0)strcpy(status_do_banco,"SIM"); //Se algum filme foi salvo, fale que que ha filmes carregados do banco
break;
case 3:
fclose(arquivo); //Fecha o arquivo do banco de dados por seguranca
remove("filmes.txt"); //Remove o banco de dados
inicializa_arquivo(&arquivo,"filmes.txt","r+"); //Recria o banco de dados "filmes.txt" no modo leitura para atualizar
break;
default:
break;
}
break;//END CASE LER BANCO
} //END SWITCH(OPCAO)
}while(opcao);//END WHILE(1)
fclose(arquivo); //Salva o arquivo para encerrar as operacoes
return 0;
}//END MAIN
/*
Função: limpa_tela
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: Nenhuma
Saídas: Sua tela limpa como cristal
Retorno: Nenhum
Objetivo: Apaga a tela da sua console
usando comandos tipicos do windows e do linux
após isso da 2 quebras de linha
*/
void limpa_tela(){
system("cls"); //Vamos apagar as mensagens iniciais
system("clear"); //Vamos apagar as mensagens iniciais
printf("\n\n"); //Vamos apagar as mensagens iniciais
}
/*
Função: Limpa_Buffer
Autor: Baseado em outras pessoas, modificada por Henrique.
Entradas:Stdin
Saídas: Nenhuma
Retorno: Nenhum
Objetivo: Consumir caracteres
adicionais presentes no stdin.
Se a função encontrar um EOF ela
Reseta o stdin para futuras leituras
*/
void limpa_buffer() {
char caracter=0; //Declara char para a leitura
do {
caracter = fgetc(stdin); //Le caracter por caracter ate "zerar" stdin
} while (caracter != '\n' && caracter!=EOF); //Se foi encontrado uma quebra de linha ou um erro saia
if(caracter==EOF)clearerr(stdin); //Se foi encontrado um EOF, resete stdin
}
/*
Função: le_numero
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: Ponteiro para o número,intervalos ri e rf, tipo t
Saídas: o *numero recebe um valor lido pelo teclado
Retorno: Retorna 0 se tudo ocorreu bem
Objetivo: Lê o teclado e atribui ao *numero,
contudo o valor lido deve estar entre ri e rf (ri<=valor lido<=rf).
É importante especificar o tipo de variavel com o char t
(se t='d', leia um double do teclado,t='f'' lê float, t='i' lê int,
caso nenhum desses seja satisfeito ele irá ler um char do teclado)
*/
int le_numero(void *numero,double ri, double rf, char t){
int erro=-1; //Temos inicialmente um erro pq nenhuma leitura foi realizada
do
{
switch (t) //Analisa o tipo de variavel a ser lido
{
case 'd': //Variavel do tipo double
erro=scanf("%lf",(double *) numero); //Le um double e erro recebe a quantidade de informacoes lidas
if(erro==1){ //Conseguimos ler o numero?
if( (*(double *) numero) >= ri && //Esse numero lido esta dentro o intervalo especificado?
(*(double *) numero) <= rf ) continue; //Se sim pule para o proximo loop e finalize
else erro=0; //Se nao defina um erro
}
break;
case 'f': //Variavel do tipo float
erro=scanf("%f",(float *) numero); //Le um double e erro recebe a quantidade de informacoes lidas
if(erro==1){ //Conseguimos ler o numero?
if( (*(float *) numero) >= (float) ri && //Esse numero lido esta dentro o intervalo especificado?
(*(float *) numero) <= (float) rf ) continue; //Se sim pule para o proximo loop e finalize
else erro=0; //Se nao defina um erro
}
break;
case 'i': //Variavel do tipo inteira
erro=scanf("%d",(int *) numero); //Le um double e erro recebe a quantidade de informacoes lidas
if(erro==1){ //Conseguimos ler o numero?
if( (*(int *) numero) >= (int) ri && //Esse numero lido esta dentro o intervalo especificado?
(*(int *) numero) <= (int) rf ) continue; //Se sim pule para o proximo loop e finalize
else erro=0; //Se nao defina um erro
}
break;
default: //Variavel do tipo char
erro=scanf("%c",(char *) numero); //Le um double e erro recebe a quantidade de informacoes lidas
if(erro==1){ //Conseguimos ler o char?
if( (*(char *) numero) >= (char) ri && //Esse numero lido esta dentro o intervalo especificado?
(*(char *) numero) <= (char) rf ) continue; //Se sim pule para o proximo loop e finalize
else erro=0; //Se nao defina um erro
}
break;
}//END switch(t)
limpa_buffer(); //Limpa lixo do teclado se errar
printf("\nErro Digite Novamente: "); //Mostra mensagem de erro caso erre
} while (erro<=0); //Houve algum erro?
limpa_buffer(); //Limpa lixo do teclado se errar
return 0; //Retorna 0, indicando sucesso
}
/*
Função: inicializa_arquivo
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: Seu ponteiro de arquivo (**arq), nome do seu arquivo(*nome), modo para abrir (*modo)
Saídas: Seu ponteiro de arquivo
Retorno: Nenhum
Objetivo: Abri o arquivo *nome no modo leitura,
caso o arquivo não exista, a função cria o arquivo.
Posteriomente a função reabre o arquivo no modo especificado (*modo)
*/
void inicializa_arquivo(FILE **arq,char *nome,char *modo){
*arq=fopen(nome,"r"); //Tente abrir o arquivo inicialmente no modo leitura
if(*arq==NULL){ //Se ele não existir ou o programa não ter permissão suficiente, crie ele
fclose(*arq); //Feche o arquivo por segurança
*arq=fopen(nome,"w"); //Tente então criar o arquivo
if(*arq==NULL)exit(EXIT_FAILURE); //Se a criação nao foi possível finalize o programa e exiba erro
}
fclose(*arq); //Fecha o arquivo por segurança
*arq=fopen(nome,modo); //Reabre o arquivo no modo selecionado
}
/*
Função: adicionaFilme
Autor: Lucas Silva e Roginaldo
Entradas: Seu vetor de filmes (*ptr), quantos filmes ja foram adicionados ao vetor (tam)
e sua base de dados (*ptr2)
Saídas: Seu vetor cheio de filmes
Retorno: Quantidade de filmes adicionados
Objetivo: Pede quantos filmes deseja adicionar, verifica quantos filmes ja tenho no vetor,
e por fim salva no vetor o filme desejado utilizando como suporte o edita filmes
*/
int adicionaFilme(Filme *ptr, int tam,FILE *ptr2){ //desenvolvimento do prototipo da funcao adiciona filme
if(tam>=50)return -1; //Se o vetor ja estiver cheio retorne erro
int qt_filmes, i; //Declara qt_filmes = quantidade filmes e nosso iterador i
printf("Quantos filmes deseja adicionar? (Digite zero para cancelar a operacao)\n"); //solicita quantidades de filmes a serem adicionados no vetor
le_numero(&qt_filmes,0,50,'i'); //Le a quantidade de filmes que o usuario deseja (De 1 Filme até 50 Filmes)
if (qt_filmes==0)return 0; //Se a pessoa nao quiser adicionar filmes, volte ao programa principal
else if(qt_filmes+tam>50){ //A pessoa deseja adicionar mais do que o vetor suporta?
qt_filmes=50-tam; //Defina então o máximo para ser adicionado, ou seja, quantos espaços vazios eu tenho no vetor para adicionar
printf("\nALERTA O maximo suportado para adicao de filmes eh:%d\n\n",qt_filmes); //Exibe alerta para a pessoa ter ciência
}
tam=0; //O Tam agora tem nova funcionalidade como indicador de quantos filmes ja foram adicionados de fato no vetor
for(i=0;i<50;i++){ //Vamos adicionar os filmes no vetor percorrendo as 50 posicoes
if (ptr[i].identificador!=0) continue; //Caso haja um filme já cadastrado na posicao de memoria pule para a proxima posicao
if((tam==qt_filmes) || (editaFilme(&(*ptr),i,ptr2)==-1) )break; //Adiciona o filme a partir do edita filme e caso a pessoa queira cancelar sai do loop, tambem faz validacao caso a pessoa tenha digitada a quantidade de filmes desejada
tam++; //Se a pessoa introduziu um filme incremente
}
return tam; //Retorna a quantidade filmes adicionada
}
/*
Função: geraIdentificador
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: O ponteiro de arquivo da sua base de dados (*ptr)
Saídas: Nenhum
Retorno: Um identificador unico para seu filme
Objetivo: Gera um numero aleatorio e compara se ha algum identificador igual
a este numero gerado presente na base de dados
*/
int geraIdentificador(FILE *ptr){
srand(time(NULL)); //Gera semente para funcao rand()
int numero_gerado,identificador_lido; //Para receber o numero gerado e para receber o identificador da base de dados
char lido[55]; //Vetor para ler as linhas do arquivo
numero_gerado = rand()+1; //Vamos gerar um numero de 1 até RAND_MAX+1
fseek(ptr,0,SEEK_SET); //Reposiciona ponteiro de arquivo no inicio do meu arquivo "filmes.txt"
while (fgets(lido,0,ptr)!=NULL)
{
if (lido[0]='i') //A linha lido no arquivo é a linha de um identificador?
{
sscanf(lido,"%[i:]%d",identificador_lido); //Vamos ler o identificador em asc2 e atribuir a variavel identificador_lido
if(identificador_lido==numero_gerado)numero_gerado = rand()+1;//Se encontramos um identificador igual na base de dados, gere um novo identificador para o filme
}
}
return numero_gerado; //Retorna o numero_gerado
}
/*
Função: editaFilme
Autor: João Vitor Araujo Leao
Entradas: O ponteiro de arquivo da sua base de dados (*ptr),
a posicao desejada do vetor para editar (posicao), e seu banco de dados (*ptr2)
Saídas: Seu vetor editado com os filmes
Retorno: 0 se sucesso e -1 se erro
Objetivo: Pergunta para o usuario as informacoes do filme
posteriormente gera um identificador para este filme
se ele nao tiver um.
*/
int editaFilme(Filme *ptr,int posicao,FILE *ptr2){
int i;
printf("Caso queira cancelar a operacao como um todo, digite \"0\" em pelo menos um campo a seguir\n\n");
printf("Digite o nome do %d%c filme: ", posicao,248); //atrelando o nome do filme inserido pelo usuario ao filme colocado no vetor
fgets(ptr[posicao].nome,50,stdin); //Le o nome do filme com fgets para nao deixar overflow
ptr[posicao].nome[strcspn(ptr[posicao].nome, "\n")] = 0; //Remove \n lido pelo fgets
limpa_buffer(); //Remove lixo do teclado
if(strcmp(ptr[posicao].nome,"0")==0)return -1; //Se a pessoa digitou 0 sai do programa e cancele
printf("Digite o genero do %d%c filme: ", posicao,248); //atrelando o genero do filme inserido pelo usuario ao filme colocado no vetor
fgets(ptr[posicao].genero,30,stdin); //Le o genero com fgets para nao deixar overflow
ptr[posicao].genero[strcspn(ptr[posicao].genero, "\n")] = 0; //Remove \n lido pelo fgets
limpa_buffer();
if(strcmp(ptr[posicao].genero,"0")==0)return -1; //Se a pessoa digitou 0 sai do programa e cancele
printf("Digite o ano de lancamento do %d%c filme", posicao,248); //atrelando o ano de lancamento do filme inserido pelo usuario
printf("\nDigite um ano entre 1900 e 2021: ");
le_numero(&(ptr[posicao].anoLancamento),1900,2021,'i'); //Le ano do filme com fgets para nao deixar overflow
printf("Digite o nome do diretor do %d%c filme: ", posicao,248); //atrelando o nome do diretor do filme inserido pelo usuario
fgets(ptr[posicao].nomeDiretor,30,stdin); //Le o nome do diretor com fgets para nao deixar overflow
ptr[posicao].nomeDiretor[strcspn(ptr[posicao].nomeDiretor, "\n")] = 0; //Remove \n lido pelo fgets
limpa_buffer();
if(strcmp(ptr[posicao].nomeDiretor,"0")==0)return -1; //Se a pessoa digitou 0 sai do programa e cancele
for(i=0;ptr[posicao].nome[i]!='\0';i++)ptr[posicao].nome[i]=tolower(ptr[posicao].nome[i]); //Transforma as letras para minusculo
for(i=0;ptr[posicao].genero[i]!='\0';i++)ptr[posicao].genero[i]=tolower(ptr[posicao].genero[i]); //Transforma as letras para minusculo
for(i=0;ptr[posicao].nomeDiretor[i]!='\0';i++)ptr[posicao].nomeDiretor[i]=tolower(ptr[posicao].nomeDiretor[i]); //Transforma as letras para minusculo
if(ptr[posicao].identificador==0){ //Se o filme nao tiver identificador
ptr[posicao].identificador=geraIdentificador(ptr2); //Adicione um identificador a ele, analisando obviamente a base de dados
}
return 0;
}
/*
Funcao: removeFilme
Autor: Lucas Silva e Roginaldo Junior
Entradas: O seu vetor de filmes (*ptr) e a posicao que deseja
remover (posicao), obs: se posicao<0, remove todo o vetor de filmes
Saídas: Seu vetor com alguns elementos a menos
Retorno: 0 se sucesso
Objetivo: remover o filme que esta na posicao inserida como
parametro da funcao, 'zerando' o identificador e o ano de lancamento
atribuindo o valor 0 e os demais dados atribuindo o caracter '\0' na
primeira posicao da string.
*/
int removeFilme(Filme *ptr, int posicao){ //desenvolvimento do prototipo da funcao remove filme
int i = 0;
if (posicao<0) posicao = 50; //Se posicao<0, vamos apagar então os 50 elementos do vetor
else{ //Caso contrario, vamos apagar apenas um elemento do vetor
i=posicao; //Vamos posicionar o iterador na posicao escolhida
posicao++; //E vamos fazer o loop for com apenas 1 loop, logo posicao++
}
for(;i<posicao;i++){ //Percorrendo o vetor
ptr[i].identificador = 0; //removendo o identificador atrelado ao filme zerando ele
strcpy(ptr[i].nome,""); //removendo o nome atrelado ao filme zerando ele
strcpy(ptr[i].genero,""); //removendo o genero atrelado ao filme zerando ele
ptr[i].anoLancamento = 0; //removendo o ano de lancamento atrelado ao filme zerando ele
strcpy(ptr[i].nomeDiretor,""); //removendo o nome do diretor atrelado ao filme zerando ele
}
return 0; //retorno da funcao apos sua conclusao
}
/*
Funcao: ImprimeFilme
Autor: Pedro Carneiro Rabetim
Entradas: O seu vetor de filmes (*ptr) e a posicao que deseja
imprimir (posicao), obs: se posicao<0, imprime todo o vetor de filmes
Saídas: Impressao na tela do seu vetor
Retorno: 0 se sucesso
Objetivo: Analisa a posicao introduzida na funcao
e imprime o filme correspondente
*/
int imprimeFilmes(Filme *ptr,int posicao){
int n=0,parada=50; //Define inicialmente iterado no inicio do vetor(0) e parada no fim desse vetor (De 0 ate 49 posicoes)
if(posicao >= 0){ //A pessoa deseja imprimir uma posicao especifica?
n=posicao; //O iterador ficara nesta posicao
parada=posicao+1; //E vamos executar mais um loop, logo posicao++
}
for(;n<parada;n++){ //Vamos percorrer o vetor ate parada
if(ptr[n].identificador!=0){ //O filme tem um identificador valido?
printf("\n=================="); //Imprime caracteristicas do filme
printf("\nNome:");
puts(ptr[n].nome);
printf("Genero:");
puts(ptr[n].genero);
printf("Ano:");
printf("%d\n",ptr[n].anoLancamento);
printf("Diretor:");
puts(ptr[n].nomeDiretor);
printf("Posicao:%d",n+1);
printf("\n==================\n");
}
}
return 0; //Retorna 0
}
/*
Função: escreveFilmes
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: Seu vetor de filmes (*ptr), a sua nova base de dados (*arq_salvar),
a posicao do vetor que deseja salva na base de dados (posicao), a quantidade
de filmes que ja existem no vetor (*tam)
Saídas: Uma base dados cheianha de filmes
Retorno: Zero se tudo ok
Objetivo: Coloca as informacoes do vetor na nova base de dados
escrevendo corretamente. É imporante salientar que apos salvo
o filme na base dados, ele é deletado do vetor e tam tem seu conteudo
decrementado
*/
int escreveFilmes(Filme *ptr,FILE *arq_salvar,int posicao,int *tam){
fprintf(arq_salvar,"i: %d\n",ptr[posicao].identificador); //Coloca o identificador do nosso filme na base de dados
fprintf(arq_salvar,"n: %s\n",ptr[posicao].nome); //Coloca o nome do nosso filme na base de dados
fprintf(arq_salvar,"g: %s\n",ptr[posicao].genero); //Coloca o gernero do nosso filme na base de dados
fprintf(arq_salvar,"l: %d\n",ptr[posicao].anoLancamento); //Coloca o ano de lancamento do nosso filme na base de dados
fprintf(arq_salvar,"d: %s\n",ptr[posicao].nomeDiretor); //Coloca o nome do diretor do nosso filme na base de dados
removeFilme(&(*ptr),posicao); //Vamos agora apagar o filme salvo no vetor
*tam=(*tam)-1; //Ja que tiramos um filme, vamos então decrementar o indicador da quantidade de filmes salvas no vetor
return 0; //Retorna 0
}
/*
Função: gravaFilmes
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: Seu vetor de filmes (*ptr), seu banco de dados original(*arq_orig),
a quantidade de filmes salva no seu vetor(*tam)
Saídas: Um novo arquivo "filmes.txt" atualizado
Retorno: Zero se tudo ok
Objetivo: Cria uma copia de "filmes.txt" atualizando a copia com os valores
do vetor de filmes. Feito isso "filmes.txt" é deletado e a copia torna-se
"filmes.txt".
*/
int gravaFilmes(Filme *ptr,FILE *arq_orig,int *tam){
if(*tam==0)return 0; //O nosso vetor de filmes está vazio? Entao nao precisa gravar nada
FILE *arq_dst=fopen("filmes_copia.txt","w"); //Cria uma copia para escrever os dados
char lido[55]; //Vetor para ler as linhas do "filmes.txt"(*arq_orig)
int j; //Declara iterador j
char *erro; //Ponteiro para receber erro do fgets
int identidade; //Variavel para receber o identificador dos filmes
fseek(arq_orig,0,SEEK_SET); //Posiciona ponteiro para o inicio de "filmes.txt"
do{
erro=fgets(lido,55,arq_orig); //Vamos ler uma linha do meu arquivo
if(erro==NULL){ //Fim do banco de dados encontrado?
for(j=0;j<50 && *tam!=0;j++){ //Vamos entao salvar o nosso vetor no fim "filmes.txt" ate acabar...
if(ptr[j].identificador!=0)escreveFilmes(&(*ptr),arq_dst,j,&(*tam)); //Se o identificador no vetor de filmes nao eh nulo, logo escreva este filme no meu arquivo de destino "filmes_copia.txt"
}
}
else{ //Se meu banco de dados nao acabou...
if(lido[0]=='i'){ //Se a linha lida do banco foi a linha de um identifcador, logo...
sscanf(&(lido[3]),"%d",&identidade); //Vamos transformar o identificador em ASC2 para um inteiro usando sscanf
for(j=0;j<50;j++){ //Agora vamos percorrer o vetor e verificar se este identificador ja existe
if(identidade==ptr[j].identificador){ //Se o identificador lido do arquivo for igual ao do vetor
identidade=-1; //Defina identidade -1 (para analises adiante)
break; //Saia do loop
}
}//END for(j=0;j<50;j++)
if(identidade==-1){ //Se foi encontrado um identificador igual ao presente no vetor, faça a escrita deste filme
escreveFilmes(&(*ptr),arq_dst,j,&(*tam)); //Vamos então escrever o filme do vetor encontrado, no arquivo
for(j=0;j<4;j++)fgets(lido,55,arq_orig); //Vamos ignorar as proximas 4 linhas pois o filme do meu vetor ja foi escrito
continue; //Ja que terminos essa analise vamos para a proxima
}
}//END if(lido[0]=='i')
fputs(lido,arq_dst); //Comentários a seguir
for(j=0;j<4;j++){ //Se o identificador buscado nao tiver correspondencia ou o ponteiro no "filmes.txt" nao tiver lido um identificador
fgets(lido,55,arq_orig); //Leia a linha do "filmes.txt"
fputs(lido,arq_dst); //Copie para "filmes_copia.txt"
}
}//END else
}while(*tam!=0 || erro!=NULL); //Faca a gravacao ate o tamanho ser zero, ou ate acabarmos de ler o banco de dados
fclose(arq_orig); //Feche os ponteiros de arquivo por segurança
fclose(arq_dst);
remove("filmes.txt"); //Remove o antigo "filmes.txt"
rename("filmes_copia.txt","filmes.txt"); //Renomeia a copia para "filmes.txt"
return 0; //Retorna 0
}
/*
Função: leFilmes
Autor: Feita por Gabriel Henrique
*/
int leFilmes(Filme *ptr,int acao,FILE *dados){
char auxiliar[55],*teste_de_fim;
int quantidade_adicionada=0,posicao_identificador,n;
limpa_tela();
if(acao==2){
fseek(dados,0,SEEK_SET);
do
{
teste_de_fim=fgets(auxiliar,55,dados);
if(teste_de_fim!=NULL){
puts(auxiliar);
if(auxiliar[0]=='i'){
quantidade_adicionada++;
if(quantidade_adicionada==1)posicao_identificador=ftell(dados)-strlen(auxiliar); //Vamos salvar a posição desse identificador no arquivo, para que assim no futuro possamos salvar os filmes
}
}
else{
printf("\nFIM DO BANCO DE DADOS");
}
if(quantidade_adicionada==50 || teste_de_fim==NULL){
printf("\nDeseja salvar estes filmes?(Digite S para sim e N para nao)\n");
auxiliar[1]=getchar();
limpa_buffer();
auxiliar[1]=tolower(auxiliar[1]);
if(auxiliar[1]=='n' && teste_de_fim!=NULL)quantidade_adicionada=0;
}
} while (auxiliar[1]!='s');
fseek(dados,posicao_identificador,SEEK_SET);
for(n=0;n<quantidade_adicionada;n++){
fscanf(dados,"%*s%d",&ptr[n].identificador );
fscanf(dados,"%*s %[^\n]",ptr[n].nome); //Leia uma string até encontrar o \n e descarte o \n
fscanf(dados,"%*s %[^\n]",ptr[n].genero); //Leia uma string até encontrar o \n e descarte o \n
fscanf(dados,"%*s %d",&ptr[n].anoLancamento);
fscanf(dados,"%*s %[^\n]",ptr[n].nomeDiretor); //Leia uma string até encontrar o \n e descarte o \n
}
}
else{
imprimeFilmes(&(*ptr),-1);
printf("\n\n\nO FILME BUSCADO FOI ENCONTRADO\n");
printf("\nQual posicao deseja colocar o filme encontrado?\n(Se nenhum filme aparecer acima, digite um numero entre 1 e 50)\n");
le_numero(&n,1,50,'i');
n--;
fscanf(dados,"%*s%d",&ptr[n].identificador );
fscanf(dados,"%*s %[^\n]",ptr[n].nome); //Leia uma string até encontrar o \n e descarte o \n
fscanf(dados,"%*s %[^\n]",ptr[n].genero); //Leia uma string até encontrar o \n e descarte o \n
fscanf(dados,"%*s %d",&ptr[n].anoLancamento);
fscanf(dados,"%*s %[^\n]",ptr[n].nomeDiretor); //Leia uma string até encontrar o \n e descarte o \n
}
return quantidade_adicionada;
}
/*
Função: buscaFilme
Autor: Feita por Henrique Soares Costa, github.com/RIQUETRET
Entradas: O Vetor de filmes(*ptr), O ponteiro de arquivos(*ptr2)
e por fim o nome do filme desejado (*nome_filme)
Saídas: Seu vetor recebe o filme desejado, se este filme
for encontrado na base de dados
Retorno: Zero se tudo ok ou -1 se nao encontrou o filme
Objetivo: Vasculha o arquivo, lendo linha por linha
quando encontra um nome de filme igual ao desejado,
carrega no vetor com leFilmes() e posteriomente retorna 0
*/
int buscaFilme(Filme *ptr,FILE *ptr2,char *nome_filme){
int posicao_identificador; //Variavel para armazenar a posicao do "i" ou identificador, para que assim possamos reposicionar o ponteiro de arquivos (*ptr2)
char lido[55]; //Vamos ler linha por linha do nosso arquivo com esse vetor e portanto podemos ter ao máximo 54 caracteres, sendo que isso pode ocorrer quando formos ler o nome, ou seja, "n: \n" + 50 caracteres do nome
fseek(ptr2,0,SEEK_SET); //Posiciona o cursor no inicio para buscar o filme
while(fgets(lido,55,ptr2)!=NULL) { //Leia uma linha do arquivo e caso encontre EOF, saia do loop e retorne -1
if (lido[0]=='i'){ //A gente leu um identificador?
posicao_identificador=ftell(ptr2)-strlen(lido); //Vamos salvar a posição desse identificador, para que assim no futuro possamos chamar a função le_filmes, que no caso precisa obrigatoriamente iniciar a leitura no identificador
}
else if(lido[0]=='n'){ //A gente leu um filme?
lido[strcspn(lido, "\n")] = 0; //Remove \n introduzido pelo fgets
if(strcmp(&lido[3],nome_filme)==0){ //O filme lido e o desejado eh igual?
fseek(ptr2,posicao_identificador,SEEK_SET); //Reposiciona cursor para o identificador deste filme
leFilmes(&(*ptr),1,ptr2); //Le o filme (salva para o vetor de filmes)
return 0; //Retorna 0 indicando sucesso na busca e salvamento do filme
}
}
}//END while(fgets(lido,55,*ptr2)!=NULL)
return -1; //Retorna -1 indicando falha na busca
}
|
the_stack_data/781239.c | #include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#define DIM 10
int main()
{
float** Matrix = (float**)malloc(sizeof(float*) * DIM);
float** Matrix2 = (float**)malloc(sizeof(float*) * DIM);
for(int i = 0; i < DIM; i++)
{
Matrix[i] = (float*)malloc(sizeof(float) * DIM);
Matrix2[i] = (float*)malloc(sizeof(float) * DIM);
}
for(int i = 0; i < DIM; i++)
{
Matrix[0][i] = 1.0;
Matrix[DIM-1][i] = 1.0;
Matrix[i][0] = 1.0;
Matrix[i][DIM-1] = 1.0;
Matrix2[0][i] = 1.0;
Matrix2[DIM-1][i] = 1.0;
Matrix2[i][0] = 1.0;
Matrix2[i][DIM-1] = 1.0;
}
#pragma omp parallel for
{
for(int i = 1; i < DIM-1; i++)
{
for(int j = 1; j < DIM-1; j++)
{
float star = 4 * Matrix[i][j] - Matrix[i-1][j] - Matrix[i+1][j] - Matrix[i][j-1] - Matrix[i][j+1];
Matrix2[i][j] = star * star;
}
}
}
#pragma omp parallel
{
if(omp_get_thread_num() == 0)
{
for(int i = 0; i < DIM; i++)
{
for(int j = 0; j < DIM; j++)
{
printf("%.4f ", Matrix2[i][j]);
}
printf("\n");
}
}
}
for(int i = 0; i < DIM; i++)
{
free(Matrix[i]);
free(Matrix2[i]);
}
free(Matrix);
free(Matrix2);
return 0;
}
|
the_stack_data/139201694.c | //
#include <stdio.h>
#include <math.h>
int main () {
int integer;
int mod;
printf("\n");
printf("Enter an integer > ");
scanf("%d", &integer);
printf("\n");
while (integer != 0) {
mod = integer % 10;
printf("%d\n", mod);
integer /= 10;
}
printf("That's all, have a nice day!\n");
return(0);
}
|
the_stack_data/181392163.c | // Prg for tree traversals
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
// AClass for a node
struct node
{
int data;
struct node *left;
struct node *right;
};
// Allocation of New Node
struct node *newNode(int data)
{
struct node *node = (struct node *)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return (node);
}
// PREORDER Traversal
void printPreorder(struct node *node)
{
if (node == NULL)
return;
printf("%d ", node->data); // print value
printPreorder(node->left); //recur on left child
printPreorder(node->right); // recur on right child
}
// MAIN
int main()
{
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("\nPreorder traversal of binary tree is: \n");
printPreorder(root);
return 0;
}
|
the_stack_data/92328034.c | #include <stdio.h>
struct s {
int x;
struct {
int y;
int z;
} nest;
};
int
test() {
struct s v;
v.x = 1;
v.nest.y = 2;
v.nest.z = 3;
if (v.x + v.nest.y + v.nest.z != 6)
return 1;
return 0;
}
int main () {
int x;
x = test();
printf("%d\n", x);
return 0;
} |
the_stack_data/244537.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
int test_func2(int n)
{
if (n < 2) return n;
const size_t size = n - 3;
bool* p = calloc(size, sizeof(bool));
printf("%s::%s(%d) outputs: \"", __FILE__, __func__, n);
for (size_t i = 0; i < size; ++i) {
if (!p[i]) {
for (size_t j = i + 1; j < size; ++j) {
if (!((j + 2) % (i + 2))) p[j] = true;
}
printf("%lu ", i + 2);
}
}
puts("\": [OK]");
free(p);
p = NULL;
return 0;
}
|
the_stack_data/198580228.c | #include <unistd.h>
#include <stdio.h>
int main() {
int pid;
pid = fork();
if(pid == 0) {
printf("SOY EL HIJO\n");
execl("/usr/bin/gnome-calculator", "Calculator Cool", (char *)0);
}
else {
printf("SOY EL PADRE\n");
}
return 0;
} |
the_stack_data/182953053.c | /**
* @Author: Tabuyos
* @Created: 2/17/21 7:01 PM
* @Site: www.tabuyos.com
* @Email: [email protected]
* @Description:
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int val;
struct node *next;
} ListNode, *LinkList;
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
ListNode *res = NULL, *tmp = NULL;
res = tmp = malloc(sizeof(ListNode));
int carrier = 0;
while (l1 || l2) {
int add1 = l1 ? l1->val : 0;
int add2 = l2 ? l2->val : 0;
int sum = add1 + add2 + carrier;
tmp->next = malloc(sizeof(ListNode));
tmp->next->val = sum % 10;
tmp = tmp->next;
tmp->next = NULL;
carrier = sum / 10;
if (l1) {
l1 = l1->next;
}
if (l2) {
l2 = l2->next;
}
}
if (carrier > 0) {
tmp->next = malloc(sizeof(ListNode));
tmp->next->val = carrier;
tmp->next->next = NULL;
}
return res->next;
}
int main(void) {
ListNode *s;
ListNode *l1 = malloc(sizeof(ListNode));
ListNode *l2 = malloc(sizeof(ListNode));
l1->next = NULL;
s = malloc(sizeof(ListNode));
s->val = 7, s->next = l1->next, l1->next = s;
s = malloc(sizeof(ListNode));
s->val = 4, s->next = l1->next, l1->next = s;
s = malloc(sizeof(ListNode));
s->val = 2, s->next = l1->next, l1 = s;
l2->next = NULL;
s = malloc(sizeof(ListNode));
s->val = 4, s->next = l2->next, l2->next = s;
s = malloc(sizeof(ListNode));
s->val = 6, s->next = l2->next, l2->next = s;
s = malloc(sizeof(ListNode));
s->val = 5, s->next = l2->next, l2 = s;
s = addTwoNumbers(l1, l2);
while (s) {
printf("%d\n", s->val);
s = s->next;
}
}
|
the_stack_data/50138845.c | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#include <pthread.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#define CHECK(ret) \
if (ret != 0) \
exit(-1);
#define TEST1_EXIT_STATUS 0
#define TEST2_EXIT_STATUS 2
void* thread_exit(void* _args)
{
int* args = (int*)_args;
int code = *args;
fprintf(stderr, "calling exit(%d) from thread_exit\n", code);
exit(code);
}
int test1_child()
{
pthread_t child;
int code = TEST1_EXIT_STATUS;
pthread_create(&child, NULL, thread_exit, &code);
pthread_join(child, NULL);
return -1;
}
int test1()
{
pid_t pid = 0;
int wstatus = 0;
char* const argv[] = {"/bin/exit_status", "test1-child", NULL};
if (posix_spawn(&pid, argv[0], NULL, NULL, argv, NULL) != 0)
return -1;
if (waitpid(pid, &wstatus, 0) != pid)
return -1;
if (!WIFEXITED(wstatus) || (WEXITSTATUS(wstatus) != TEST1_EXIT_STATUS))
{
fprintf(stderr, "didnt return the correct exit status\n");
return -1;
}
return 0;
}
int test2_child()
{
pthread_t child;
int code = TEST2_EXIT_STATUS;
pthread_create(&child, NULL, thread_exit, &code);
pthread_join(child, NULL);
return -1;
}
int test2()
{
pid_t pid = 0;
int wstatus = 0;
char* const argv[] = {"/bin/exit_status", "test2-child", NULL};
if (posix_spawn(&pid, argv[0], NULL, NULL, argv, NULL) != 0)
return -1;
if (waitpid(pid, &wstatus, 0) != pid)
return -1;
if (WEXITSTATUS(wstatus) != TEST2_EXIT_STATUS)
{
fprintf(stderr, "didnt return the correct exit status\n");
return -1;
}
return 0;
}
int tests()
{
CHECK(test1());
CHECK(test2());
return 0;
}
int main(int argc, const char* argv[])
{
if (argc != 2)
exit(-1);
if (strcmp(argv[1], "tests") == 0)
return tests();
else if (strcmp(argv[1], "test1-child") == 0)
return test1_child();
else if (strcmp(argv[1], "test2-child") == 0)
return test2_child();
else
return -1;
}
|
the_stack_data/37637536.c | /*
* aresman.c
*
* Created on: 2017-10-02
* Author: Lorenzo Cipriani <[email protected]>
* Website: https://www.linkedin.com/in/lorenzocipriani
*/
#include <stdio.h>
int main(int argc, char **argv) {
printf("This is AResMan!\n");
}
|
the_stack_data/151706628.c | // Writing and Reading files in C
// Read
#include <stdio.h>
int main(void) {
FILE *file;
char fname[50];
char str;
// Prompt for file to open
printf("Which file to open?: ");
scanf("%s", fname);
// Open file in read mode. Read mode to make it possible to use fgetc()
file = fopen(fname, "r");
if (file == NULL) {
printf("Error while opening file or file does not exist...\n");
return 1;
}
printf("%s content\n\n", fname);
str = fgetc(file);
while (str != EOF) {
printf("%c", str);
str = fgetc(file);
}
printf("\n");
// Close file if it's open
fclose(file);
}
|
the_stack_data/134292.c | /*
9. Faça um programa que receba uma frase (máximo 100 caracteres) e uma letra qualquer, calcule e mostre a quantidade que essa letra aparece na frase digitada.
*/
#include<stdio.h>
#include<stdlib.h>
main()
{
int i;
char str[100];
char c;
int aparicoesLetra = 0;
printf("Informe uma String: ");
fgets(str, 100, stdin);
printf("Informe um caractere: ");
scanf(" %c", &c);
for (i=0; i<100; i++)
{
if (str[i] == c)
{
aparicoesLetra += 1;
}
}
printf("A letra aparece %d vezes na frase digitada", aparicoesLetra);
return 0;
}
|
the_stack_data/134514192.c | #pragma line 1 "imf1.c"
#pragma line 1 "imf1.c" 1
#pragma line 1 "<built-in>" 1
#pragma line 1 "<built-in>" 3
#pragma line 147 "<built-in>" 3
#pragma line 1 "<command line>" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_op.h" 1
/* autopilot_ssdm_op.h*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 280 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
/*#define AP_SPEC_ATTR __attribute__ ((pure))*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
/****** SSDM Intrinsics: OPERATIONS ***/
// Interface operations
//typedef unsigned int __attribute__ ((bitwidth(1))) _uint1_;
void _ssdm_op_IfRead() __attribute__ ((nothrow));
void _ssdm_op_IfWrite() __attribute__ ((nothrow));
//_uint1_ _ssdm_op_IfNbRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfNbWrite() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfCanRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfCanWrite() SSDM_OP_ATTR;
#pragma empty_line
// Stream Intrinsics
void _ssdm_StreamRead() __attribute__ ((nothrow));
void _ssdm_StreamWrite() __attribute__ ((nothrow));
//_uint1_ _ssdm_StreamNbRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamNbWrite() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamCanRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamCanWrite() SSDM_OP_ATTR;
#pragma empty_line
// Misc
void _ssdm_op_MemShiftRead() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Wait() __attribute__ ((nothrow));
void _ssdm_op_Poll() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Return() __attribute__ ((nothrow));
#pragma empty_line
/* SSDM Intrinsics: SPECIFICATIONS */
void _ssdm_op_SpecSynModule() __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef() __attribute__ ((nothrow));
void _ssdm_op_SpecPort() __attribute__ ((nothrow));
void _ssdm_op_SpecConnection() __attribute__ ((nothrow));
void _ssdm_op_SpecChannel() __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive() __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst() __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecReset() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPlatform() __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain() __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain() __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecRegionBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopName() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopTripCount() __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecStateBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecInterface() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPipeline() __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline() __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecLatency() __attribute__ ((nothrow));
void _ssdm_op_SpecParallel() __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol() __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecResource() __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit() __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore() __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore() __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue() __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecExt() __attribute__ ((nothrow));
/*void* _ssdm_op_SpecProcess() SSDM_SPEC_ATTR;
void* _ssdm_op_SpecEdge() SSDM_SPEC_ATTR; */
#pragma empty_line
/* Presynthesis directive functions */
void _ssdm_SpecArrayDimSize() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_RegionBegin() __attribute__ ((nothrow));
void _ssdm_RegionEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_Unroll() __attribute__ ((nothrow));
void _ssdm_UnrollRegion() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_InlineAll() __attribute__ ((nothrow));
void _ssdm_InlineLoop() __attribute__ ((nothrow));
void _ssdm_Inline() __attribute__ ((nothrow));
void _ssdm_InlineSelf() __attribute__ ((nothrow));
void _ssdm_InlineRegion() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecArrayMap() __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition() __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecStream() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecExpr() __attribute__ ((nothrow));
void _ssdm_SpecExprBalance() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecDependence() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecLoopMerge() __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten() __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecFuncInstantiation() __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer() __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract() __attribute__ ((nothrow));
void _ssdm_SpecConstant() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_DataPack() __attribute__ ((nothrow));
void _ssdm_SpecDataPack() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecBitsMap() __attribute__ ((nothrow));
void _ssdm_op_SpecLicense() __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
/*#define _ssdm_op_WaitUntil(X) while (!(X)) _ssdm_op_Wait(1);
#define _ssdm_op_Delayed(X) X */
#pragma line 7 "<command line>" 2
#pragma line 1 "<built-in>" 2
#pragma line 1 "imf1.c" 2
#pragma line 1 "./duc.h" 1
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 1
/* ap_cint.h */
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 62 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 18 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* mingw.org's version macros: these make gcc to define
MINGW32_SUPPORTS_MT_EH and to use the _CRT_MT global
and the __mingwthr_key_dtor() function from the MinGW
CRT in its private gthr-win32.h header. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* MS does not prefix symbols by underscores for 64-bit. */
#pragma empty_line
/* As we have to support older gcc version, which are using underscores
as symbol prefix for x64, we have to check here for the user label
prefix defined by gcc. */
#pragma line 62 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* Use alias for msvcr80 export of get/set_output_format. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set VC specific compiler target macros. */
#pragma line 10 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
/* C/C++ specific language defines. */
#pragma line 32 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Note the extern. This is needed to work around GCC's
limitations in handling dllimport attribute. */
#pragma line 147 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Attribute `nonnull' was valid as of gcc 3.3. We don't use GCC's
variadiac macro facility, because variadic macros cause syntax
errors with --traditional-cpp. */
#pragma line 225 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* High byte is the major version, low byte is the minor. */
#pragma line 247 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/*typedef int __int128 __attribute__ ((__mode__ (TI)));*/
#pragma line 277 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 674 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_directx.h" 1 3
#pragma line 674 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_ddk.h" 1 3
#pragma line 675 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma line 13 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __builtin_va_list __gnuc_va_list;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __gnuc_va_list va_list;
#pragma line 46 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
/* Use GCC builtins */
#pragma line 102 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
#pragma pack(pop)
#pragma line 277 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 316 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* We have to define _DLL for gcc based mingw version. This define is set
by VC, when DLL-based runtime is used. So, gcc based runtime just have
DLL-base runtime, therefore this define has to be set.
As our headers are possibly used by windows compiler having a static
C-runtime, we make this definition gnu compiler specific here. */
#pragma line 370 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long size_t;
#pragma line 380 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ssize_t;
#pragma line 392 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long intptr_t;
#pragma line 405 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long uintptr_t;
#pragma line 418 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ptrdiff_t;
#pragma line 428 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned short wchar_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
#pragma line 456 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int errno_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long __time32_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long __time64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __time64_t time_t;
#pragma line 518 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* _dowildcard is an int that controls the globbing of the command line.
* The MinGW32 (mingw.org) runtime calls it _CRT_glob, so we are adding
* a compatibility definition here: you can use either of _CRT_glob or
* _dowildcard .
* If _dowildcard is non-zero, the command line will be globbed: *.*
* will be expanded to be all files in the startup directory.
* In the mingw-w64 library a _dowildcard variable is defined as being
* 0, therefore command line globbing is DISABLED by default. To turn it
* on and to leave wildcard command line processing MS's globbing code,
* include a line in one of your source modules defining _dowildcard and
* setting it to -1, like so:
* int _dowildcard = -1;
*/
#pragma line 605 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* MSVC-isms: */
#pragma empty_line
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
struct __lc_time_data;
#pragma empty_line
typedef struct localeinfo_struct {
pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct,*_locale_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct tagLC_ID {
unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID,*LPLC_ID;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct threadlocaleinfostruct {
int refcount;
unsigned int lc_codepage;
unsigned int lc_collate_cp;
unsigned long lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
int mb_cur_max;
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
const unsigned short *pctype;
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;
} threadlocinfo;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* mingw-w64 specific functions: */
const char *__mingw_get_crt_info (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 2 3
#pragma line 36 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 3
__attribute__ ((__dllimport__)) void * _memccpy(void *_Dst,const void *_Src,int _Val,size_t _MaxCount);
void * memchr(const void *_Buf ,int _Val,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _memicmp(const void *_Buf1,const void *_Buf2,size_t _Size);
__attribute__ ((__dllimport__)) int _memicmp_l(const void *_Buf1,const void *_Buf2,size_t _Size,_locale_t _Locale);
int memcmp(const void *_Buf1,const void *_Buf2,size_t _Size);
void * memcpy(void * __restrict__ _Dst,const void * __restrict__ _Src,size_t _Size) ;
void * memset(void *_Dst,int _Val,size_t _Size);
#pragma empty_line
void * memccpy(void *_Dst,const void *_Src,int _Val,size_t _Size) ;
int memicmp(const void *_Buf1,const void *_Buf2,size_t _Size) ;
#pragma empty_line
#pragma empty_line
char * _strset(char *_Str,int _Val) ;
char * _strset_l(char *_Str,int _Val,_locale_t _Locale) ;
char * strcpy(char * __restrict__ _Dest,const char * __restrict__ _Source);
char * strcat(char * __restrict__ _Dest,const char * __restrict__ _Source);
int strcmp(const char *_Str1,const char *_Str2);
size_t strlen(const char *_Str);
size_t strnlen(const char *_Str,size_t _MaxCount);
void * memmove(void *_Dst,const void *_Src,size_t _Size) ;
__attribute__ ((__dllimport__)) char * _strdup(const char *_Src);
char * strchr(const char *_Str,int _Val);
__attribute__ ((__dllimport__)) int _stricmp(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _strcmpi(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _stricmp_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
int strcoll(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _strcoll_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _stricoll(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _stricoll_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _strncoll (const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strncoll_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _strnicoll (const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicoll_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
size_t strcspn(const char *_Str,const char *_Control);
__attribute__ ((__dllimport__)) char * _strerror(const char *_ErrMsg) ;
char * strerror(int) ;
__attribute__ ((__dllimport__)) char * _strlwr(char *_String) ;
char *strlwr_l(char *_String,_locale_t _Locale) ;
char * strncat(char * __restrict__ _Dest,const char * __restrict__ _Source,size_t _Count) ;
int strncmp(const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicmp(const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicmp_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
char *strncpy(char * __restrict__ _Dest,const char * __restrict__ _Source,size_t _Count) ;
__attribute__ ((__dllimport__)) char * _strnset(char *_Str,int _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) char * _strnset_l(char *str,int c,size_t count,_locale_t _Locale) ;
char * strpbrk(const char *_Str,const char *_Control);
char * strrchr(const char *_Str,int _Ch);
__attribute__ ((__dllimport__)) char * _strrev(char *_Str);
size_t strspn(const char *_Str,const char *_Control);
char * strstr(const char *_Str,const char *_SubStr);
char * strtok(char * __restrict__ _Str,const char * __restrict__ _Delim) ;
__attribute__ ((__dllimport__)) char * _strupr(char *_String) ;
__attribute__ ((__dllimport__)) char *_strupr_l(char *_String,_locale_t _Locale) ;
size_t strxfrm(char * __restrict__ _Dst,const char * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _strxfrm_l(char * __restrict__ _Dst,const char * __restrict__ _Src,size_t _MaxCount,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
char * strdup(const char *_Src) ;
int strcmpi(const char *_Str1,const char *_Str2) ;
int stricmp(const char *_Str1,const char *_Str2) ;
char * strlwr(char *_Str) ;
int strnicmp(const char *_Str1,const char *_Str,size_t _MaxCount) ;
int strncasecmp (const char *, const char *, size_t);
int strcasecmp (const char *, const char *);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char * strnset(char *_Str,int _Val,size_t _MaxCount) ;
char * strrev(char *_Str) ;
char * strset(char *_Str,int _Val) ;
char * strupr(char *_Str) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wcsdup(const wchar_t *_Str);
wchar_t * wcscat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
wchar_t * wcschr(const wchar_t *_Str,wchar_t _Ch);
int wcscmp(const wchar_t *_Str1,const wchar_t *_Str2);
wchar_t * wcscpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
size_t wcscspn(const wchar_t *_Str,const wchar_t *_Control);
size_t wcslen(const wchar_t *_Str);
size_t wcsnlen(const wchar_t *_Src,size_t _MaxCount);
wchar_t *wcsncat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
int wcsncmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
wchar_t *wcsncpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
wchar_t * _wcsncpy_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count,_locale_t _Locale) ;
wchar_t * wcspbrk(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsrchr(const wchar_t *_Str,wchar_t _Ch);
size_t wcsspn(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsstr(const wchar_t *_Str,const wchar_t *_SubStr);
wchar_t * wcstok(wchar_t * __restrict__ _Str,const wchar_t * __restrict__ _Delim) ;
__attribute__ ((__dllimport__)) wchar_t * _wcserror(int _ErrNum) ;
__attribute__ ((__dllimport__)) wchar_t * __wcserror(const wchar_t *_Str) ;
__attribute__ ((__dllimport__)) int _wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsrev(wchar_t *_Str);
__attribute__ ((__dllimport__)) wchar_t * _wcsset(wchar_t *_Str,wchar_t _Val) ;
__attribute__ ((__dllimport__)) wchar_t * _wcslwr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcslwr_l(wchar_t *_String,_locale_t _Locale) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsupr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcsupr_l(wchar_t *_String,_locale_t _Locale) ;
size_t wcsxfrm(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _wcsxfrm_l(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount,_locale_t _Locale);
int wcscoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcscoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsncoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsncoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
wchar_t * wcsdup(const wchar_t *_Str) ;
#pragma empty_line
int wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2) ;
int wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount) ;
wchar_t * wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
wchar_t * wcsrev(wchar_t *_Str) ;
wchar_t * wcsset(wchar_t *_Str,wchar_t _Val) ;
wchar_t * wcslwr(wchar_t *_Str) ;
wchar_t * wcsupr(wchar_t *_Str) ;
int wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/string_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/string_s.h" 2 3
#pragma line 175 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 2 3
#pragma line 63 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_push.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
/* Undefine __mingw_<printf> macros. */
#pragma line 11 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 26 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
#pragma line 84 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
typedef long _off_t;
#pragma empty_line
typedef long off_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long _off64_t;
#pragma empty_line
__extension__ typedef long long off64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * __iob_func(void);
#pragma line 120 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__extension__ typedef long long fpos_t;
#pragma line 157 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) int _filbuf(FILE *_File);
__attribute__ ((__dllimport__)) int _flsbuf(int _Ch,FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _fsopen(const char *_Filename,const char *_Mode,int _ShFlag);
#pragma empty_line
void clearerr(FILE *_File);
int fclose(FILE *_File);
__attribute__ ((__dllimport__)) int _fcloseall(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _fdopen(int _FileHandle,const char *_Mode);
#pragma empty_line
int feof(FILE *_File);
int ferror(FILE *_File);
int fflush(FILE *_File);
int fgetc(FILE *_File);
__attribute__ ((__dllimport__)) int _fgetchar(void);
int fgetpos(FILE * __restrict__ _File ,fpos_t * __restrict__ _Pos);
char * fgets(char * __restrict__ _Buf,int _MaxCount,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fileno(FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) char * _tempnam(const char *_DirName,const char *_FilePrefix);
__attribute__ ((__dllimport__)) int _flushall(void);
FILE * fopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode) ;
FILE *fopen64(const char * __restrict__ filename,const char * __restrict__ mode);
int fprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,...);
int fputc(int _Ch,FILE *_File);
__attribute__ ((__dllimport__)) int _fputchar(int _Ch);
int fputs(const char * __restrict__ _Str,FILE * __restrict__ _File);
size_t fread(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
FILE * freopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode,FILE * __restrict__ _File) ;
int fscanf(FILE * __restrict__ _File,const char * __restrict__ _Format,...) ;
int _fscanf_l(FILE * __restrict__ _File,const char * __restrict__ _Format,_locale_t locale,...) ;
int fsetpos(FILE *_File,const fpos_t *_Pos);
int fseek(FILE *_File,long _Offset,int _Origin);
int fseeko64(FILE* stream, _off64_t offset, int whence);
long ftell(FILE *_File);
_off64_t ftello64(FILE * stream);
__extension__ int _fseeki64(FILE *_File,long long _Offset,int _Origin);
__extension__ long long _ftelli64(FILE *_File);
size_t fwrite(const void * __restrict__ _Str,size_t _Size,size_t _Count,FILE * __restrict__ _File);
int getc(FILE *_File);
int getchar(void);
__attribute__ ((__dllimport__)) int _getmaxstdio(void);
char * gets(char *_Buffer) ;
int _getw(FILE *_File);
#pragma empty_line
#pragma empty_line
void perror(const char *_ErrMsg);
#pragma empty_line
__attribute__ ((__dllimport__)) int _pclose(FILE *_File);
__attribute__ ((__dllimport__)) FILE * _popen(const char *_Command,const char *_Mode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int printf(const char * __restrict__ _Format,...);
int putc(int _Ch,FILE *_File);
int putchar(int _Ch);
int puts(const char *_Str);
__attribute__ ((__dllimport__)) int _putw(int _Word,FILE *_File);
#pragma empty_line
#pragma empty_line
int remove(const char *_Filename);
int rename(const char *_OldFilename,const char *_NewFilename);
__attribute__ ((__dllimport__)) int _unlink(const char *_Filename);
#pragma empty_line
int unlink(const char *_Filename) ;
#pragma empty_line
#pragma empty_line
void rewind(FILE *_File);
__attribute__ ((__dllimport__)) int _rmtmp(void);
int scanf(const char * __restrict__ _Format,...) ;
int _scanf_l(const char * __restrict__ format,_locale_t locale,... ) ;
void setbuf(FILE * __restrict__ _File,char * __restrict__ _Buffer) ;
__attribute__ ((__dllimport__)) int _setmaxstdio(int _Max);
__attribute__ ((__dllimport__)) unsigned int _set_output_format(unsigned int _Format);
__attribute__ ((__dllimport__)) unsigned int _get_output_format(void);
unsigned int __mingw_set_output_format(unsigned int _Format);
unsigned int __mingw_get_output_format(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int setvbuf(FILE * __restrict__ _File,char * __restrict__ _Buf,int _Mode,size_t _Size);
__attribute__ ((__dllimport__)) int _scprintf(const char * __restrict__ _Format,...);
int sscanf(const char * __restrict__ _Src,const char * __restrict__ _Format,...) ;
int _sscanf_l(const char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _snscanf(const char * __restrict__ _Src,size_t _MaxCount,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snscanf_l(const char * __restrict__ input,size_t length,const char * __restrict__ format,_locale_t locale,...) ;
FILE * tmpfile(void) ;
char * tmpnam(char *_Buffer);
int ungetc(int _Ch,FILE *_File);
int vfprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,va_list _ArgList);
int vprintf(const char * __restrict__ _Format,va_list _ArgList);
#pragma empty_line
/* Make sure macros are not defined. */
extern
__attribute__((__format__ (gnu_printf, 3, 0))) __attribute__ ((__nonnull__ (3)))
int __mingw_vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,
va_list _ArgList);
extern
__attribute__((__format__ (gnu_printf, 3, 4))) __attribute__ ((__nonnull__ (3)))
int __mingw_snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
extern
__attribute__((__format__ (gnu_printf, 1, 2))) __attribute__ ((__nonnull__ (1)))
int __mingw_printf(const char * __restrict__ , ... ) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 1, 0))) __attribute__ ((__nonnull__ (1)))
int __mingw_vprintf (const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_fprintf (FILE * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vfprintf (FILE * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_sprintf (char * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vsprintf (char * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
#pragma empty_line
__attribute__ ((__dllimport__)) int _snprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _vsnprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,va_list _Args) ;
__attribute__ ((__dllimport__)) int _vsnprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,va_list argptr) ;
int sprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,...) ;
int _sprintf_l(char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
int vsprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,va_list _Args) ;
#pragma empty_line
/* this is here to deal with software defining
* vsnprintf as _vsnprintf, eg. libxml2. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,va_list _ArgList) ;
#pragma empty_line
int snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
#pragma line 312 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vscanf(const char * __restrict__ Format, va_list argp);
int vfscanf (FILE * __restrict__ fp, const char * __restrict__ Format,va_list argp);
int vsscanf (const char * __restrict__ _Str,const char * __restrict__ Format,va_list argp);
#pragma empty_line
__attribute__ ((__dllimport__)) int _vscprintf(const char * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _set_printf_count_output(int _Value);
__attribute__ ((__dllimport__)) int _get_printf_count_output(void);
#pragma line 330 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) FILE * _wfsopen(const wchar_t *_Filename,const wchar_t *_Mode,int _ShFlag);
#pragma empty_line
#pragma empty_line
wint_t fgetwc(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fgetwchar(void);
wint_t fputwc(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwchar(wchar_t _Ch);
wint_t getwc(FILE *_File);
wint_t getwchar(void);
wint_t putwc(wchar_t _Ch,FILE *_File);
wint_t putwchar(wchar_t _Ch);
wint_t ungetwc(wint_t _Ch,FILE *_File);
wchar_t * fgetws(wchar_t * __restrict__ _Dst,int _SizeInWords,FILE * __restrict__ _File);
int fputws(const wchar_t * __restrict__ _Str,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) wchar_t * _getws(wchar_t *_String) ;
__attribute__ ((__dllimport__)) int _putws(const wchar_t *_Str);
int fwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
int wprintf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _scwprintf(const wchar_t * __restrict__ _Format,...);
int vfwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
int vwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...) ;
__attribute__ ((__dllimport__)) int _swprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,... ) ;
__attribute__ ((__dllimport__)) int vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ ,va_list) ;
__attribute__ ((__dllimport__)) int _swprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _vsnwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,va_list _Args) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int snwprintf (wchar_t * __restrict__ s, size_t n, const wchar_t * __restrict__ format, ...);
int vsnwprintf (wchar_t * __restrict__ , size_t, const wchar_t * __restrict__ , va_list);
#pragma line 373 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vwscanf (const wchar_t * __restrict__ , va_list);
int vfwscanf (FILE * __restrict__ ,const wchar_t * __restrict__ ,va_list);
int vswscanf (const wchar_t * __restrict__ ,const wchar_t * __restrict__ ,va_list);
#pragma empty_line
__attribute__ ((__dllimport__)) int _fwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _wprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vfwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _wprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _wprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _fwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _fwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vfwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vfwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _swprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vswprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vswprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _scwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vsnwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList) ;
__attribute__ ((__dllimport__)) int _swprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,va_list _Args);
__attribute__ ((__dllimport__)) int __swprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,...) ;
__attribute__ ((__dllimport__)) int _vswprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,va_list argptr) ;
__attribute__ ((__dllimport__)) int __vswprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,va_list _Args) ;
#pragma line 417 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) wchar_t * _wtempnam(const wchar_t *_Directory,const wchar_t *_FilePrefix);
__attribute__ ((__dllimport__)) int _vscwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vscwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
int fwscanf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _fwscanf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
int swscanf(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _swscanf_l(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) int _snwscanf(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _snwscanf_l(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
int wscanf(const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _wscanf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) FILE * _wfdopen(int _FileHandle ,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) FILE * _wfopen(const wchar_t * __restrict__ _Filename,const wchar_t *__restrict__ _Mode) ;
__attribute__ ((__dllimport__)) FILE * _wfreopen(const wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode,FILE * __restrict__ _OldFile) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _wperror(const wchar_t *_ErrMsg);
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _wpopen(const wchar_t *_Command,const wchar_t *_Mode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wremove(const wchar_t *_Filename);
__attribute__ ((__dllimport__)) wchar_t * _wtmpnam(wchar_t *_Buffer);
__attribute__ ((__dllimport__)) wint_t _fgetwc_nolock(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwc_nolock(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _ungetwc_nolock(wint_t _Ch,FILE *_File);
#pragma line 475 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) void _lock_file(FILE *_File);
__attribute__ ((__dllimport__)) void _unlock_file(FILE *_File);
__attribute__ ((__dllimport__)) int _fclose_nolock(FILE *_File);
__attribute__ ((__dllimport__)) int _fflush_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fread_nolock(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fseek_nolock(FILE *_File,long _Offset,int _Origin);
__attribute__ ((__dllimport__)) long _ftell_nolock(FILE *_File);
__extension__ __attribute__ ((__dllimport__)) int _fseeki64_nolock(FILE *_File,long long _Offset,int _Origin);
__extension__ __attribute__ ((__dllimport__)) long long _ftelli64_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fwrite_nolock(const void * __restrict__ _DstBuf,size_t _Size,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _ungetc_nolock(int _Ch,FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char * tempnam(const char *_Directory,const char *_FilePrefix) ;
int fcloseall(void) ;
FILE * fdopen(int _FileHandle,const char *_Format) ;
int fgetchar(void) ;
int fileno(FILE *_File) ;
int flushall(void) ;
int fputchar(int _Ch) ;
int getw(FILE *_File) ;
int putw(int _Ch,FILE *_File) ;
int rmtmp(void) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 2 3
#pragma line 509 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_pop.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
/* Define __mingw_<printf> macros. */
#pragma line 511 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma line 64 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 77 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 1
/* autopilot_apint.h*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 1
/*-*-c++-*-*/
/* autopilot_dt.h: defines all bit-accurate data types.*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 97 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
typedef int __attribute__ ((bitwidth(1))) int1;
typedef int __attribute__ ((bitwidth(2))) int2;
typedef int __attribute__ ((bitwidth(3))) int3;
typedef int __attribute__ ((bitwidth(4))) int4;
typedef int __attribute__ ((bitwidth(5))) int5;
typedef int __attribute__ ((bitwidth(6))) int6;
typedef int __attribute__ ((bitwidth(7))) int7;
typedef int __attribute__ ((bitwidth(8))) int8;
typedef int __attribute__ ((bitwidth(9))) int9;
typedef int __attribute__ ((bitwidth(10))) int10;
typedef int __attribute__ ((bitwidth(11))) int11;
typedef int __attribute__ ((bitwidth(12))) int12;
typedef int __attribute__ ((bitwidth(13))) int13;
typedef int __attribute__ ((bitwidth(14))) int14;
typedef int __attribute__ ((bitwidth(15))) int15;
typedef int __attribute__ ((bitwidth(16))) int16;
typedef int __attribute__ ((bitwidth(17))) int17;
typedef int __attribute__ ((bitwidth(18))) int18;
typedef int __attribute__ ((bitwidth(19))) int19;
typedef int __attribute__ ((bitwidth(20))) int20;
typedef int __attribute__ ((bitwidth(21))) int21;
typedef int __attribute__ ((bitwidth(22))) int22;
typedef int __attribute__ ((bitwidth(23))) int23;
typedef int __attribute__ ((bitwidth(24))) int24;
typedef int __attribute__ ((bitwidth(25))) int25;
typedef int __attribute__ ((bitwidth(26))) int26;
typedef int __attribute__ ((bitwidth(27))) int27;
typedef int __attribute__ ((bitwidth(28))) int28;
typedef int __attribute__ ((bitwidth(29))) int29;
typedef int __attribute__ ((bitwidth(30))) int30;
typedef int __attribute__ ((bitwidth(31))) int31;
typedef int __attribute__ ((bitwidth(32))) int32;
typedef int __attribute__ ((bitwidth(33))) int33;
typedef int __attribute__ ((bitwidth(34))) int34;
typedef int __attribute__ ((bitwidth(35))) int35;
typedef int __attribute__ ((bitwidth(36))) int36;
typedef int __attribute__ ((bitwidth(37))) int37;
typedef int __attribute__ ((bitwidth(38))) int38;
typedef int __attribute__ ((bitwidth(39))) int39;
typedef int __attribute__ ((bitwidth(40))) int40;
typedef int __attribute__ ((bitwidth(41))) int41;
typedef int __attribute__ ((bitwidth(42))) int42;
typedef int __attribute__ ((bitwidth(43))) int43;
typedef int __attribute__ ((bitwidth(44))) int44;
typedef int __attribute__ ((bitwidth(45))) int45;
typedef int __attribute__ ((bitwidth(46))) int46;
typedef int __attribute__ ((bitwidth(47))) int47;
typedef int __attribute__ ((bitwidth(48))) int48;
typedef int __attribute__ ((bitwidth(49))) int49;
typedef int __attribute__ ((bitwidth(50))) int50;
typedef int __attribute__ ((bitwidth(51))) int51;
typedef int __attribute__ ((bitwidth(52))) int52;
typedef int __attribute__ ((bitwidth(53))) int53;
typedef int __attribute__ ((bitwidth(54))) int54;
typedef int __attribute__ ((bitwidth(55))) int55;
typedef int __attribute__ ((bitwidth(56))) int56;
typedef int __attribute__ ((bitwidth(57))) int57;
typedef int __attribute__ ((bitwidth(58))) int58;
typedef int __attribute__ ((bitwidth(59))) int59;
typedef int __attribute__ ((bitwidth(60))) int60;
typedef int __attribute__ ((bitwidth(61))) int61;
typedef int __attribute__ ((bitwidth(62))) int62;
typedef int __attribute__ ((bitwidth(63))) int63;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
typedef int __attribute__ ((bitwidth(65))) int65;
typedef int __attribute__ ((bitwidth(66))) int66;
typedef int __attribute__ ((bitwidth(67))) int67;
typedef int __attribute__ ((bitwidth(68))) int68;
typedef int __attribute__ ((bitwidth(69))) int69;
typedef int __attribute__ ((bitwidth(70))) int70;
typedef int __attribute__ ((bitwidth(71))) int71;
typedef int __attribute__ ((bitwidth(72))) int72;
typedef int __attribute__ ((bitwidth(73))) int73;
typedef int __attribute__ ((bitwidth(74))) int74;
typedef int __attribute__ ((bitwidth(75))) int75;
typedef int __attribute__ ((bitwidth(76))) int76;
typedef int __attribute__ ((bitwidth(77))) int77;
typedef int __attribute__ ((bitwidth(78))) int78;
typedef int __attribute__ ((bitwidth(79))) int79;
typedef int __attribute__ ((bitwidth(80))) int80;
typedef int __attribute__ ((bitwidth(81))) int81;
typedef int __attribute__ ((bitwidth(82))) int82;
typedef int __attribute__ ((bitwidth(83))) int83;
typedef int __attribute__ ((bitwidth(84))) int84;
typedef int __attribute__ ((bitwidth(85))) int85;
typedef int __attribute__ ((bitwidth(86))) int86;
typedef int __attribute__ ((bitwidth(87))) int87;
typedef int __attribute__ ((bitwidth(88))) int88;
typedef int __attribute__ ((bitwidth(89))) int89;
typedef int __attribute__ ((bitwidth(90))) int90;
typedef int __attribute__ ((bitwidth(91))) int91;
typedef int __attribute__ ((bitwidth(92))) int92;
typedef int __attribute__ ((bitwidth(93))) int93;
typedef int __attribute__ ((bitwidth(94))) int94;
typedef int __attribute__ ((bitwidth(95))) int95;
typedef int __attribute__ ((bitwidth(96))) int96;
typedef int __attribute__ ((bitwidth(97))) int97;
typedef int __attribute__ ((bitwidth(98))) int98;
typedef int __attribute__ ((bitwidth(99))) int99;
typedef int __attribute__ ((bitwidth(100))) int100;
typedef int __attribute__ ((bitwidth(101))) int101;
typedef int __attribute__ ((bitwidth(102))) int102;
typedef int __attribute__ ((bitwidth(103))) int103;
typedef int __attribute__ ((bitwidth(104))) int104;
typedef int __attribute__ ((bitwidth(105))) int105;
typedef int __attribute__ ((bitwidth(106))) int106;
typedef int __attribute__ ((bitwidth(107))) int107;
typedef int __attribute__ ((bitwidth(108))) int108;
typedef int __attribute__ ((bitwidth(109))) int109;
typedef int __attribute__ ((bitwidth(110))) int110;
typedef int __attribute__ ((bitwidth(111))) int111;
typedef int __attribute__ ((bitwidth(112))) int112;
typedef int __attribute__ ((bitwidth(113))) int113;
typedef int __attribute__ ((bitwidth(114))) int114;
typedef int __attribute__ ((bitwidth(115))) int115;
typedef int __attribute__ ((bitwidth(116))) int116;
typedef int __attribute__ ((bitwidth(117))) int117;
typedef int __attribute__ ((bitwidth(118))) int118;
typedef int __attribute__ ((bitwidth(119))) int119;
typedef int __attribute__ ((bitwidth(120))) int120;
typedef int __attribute__ ((bitwidth(121))) int121;
typedef int __attribute__ ((bitwidth(122))) int122;
typedef int __attribute__ ((bitwidth(123))) int123;
typedef int __attribute__ ((bitwidth(124))) int124;
typedef int __attribute__ ((bitwidth(125))) int125;
typedef int __attribute__ ((bitwidth(126))) int126;
typedef int __attribute__ ((bitwidth(127))) int127;
typedef int __attribute__ ((bitwidth(128))) int128;
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
typedef int __attribute__ ((bitwidth(129))) int129;
typedef int __attribute__ ((bitwidth(130))) int130;
typedef int __attribute__ ((bitwidth(131))) int131;
typedef int __attribute__ ((bitwidth(132))) int132;
typedef int __attribute__ ((bitwidth(133))) int133;
typedef int __attribute__ ((bitwidth(134))) int134;
typedef int __attribute__ ((bitwidth(135))) int135;
typedef int __attribute__ ((bitwidth(136))) int136;
typedef int __attribute__ ((bitwidth(137))) int137;
typedef int __attribute__ ((bitwidth(138))) int138;
typedef int __attribute__ ((bitwidth(139))) int139;
typedef int __attribute__ ((bitwidth(140))) int140;
typedef int __attribute__ ((bitwidth(141))) int141;
typedef int __attribute__ ((bitwidth(142))) int142;
typedef int __attribute__ ((bitwidth(143))) int143;
typedef int __attribute__ ((bitwidth(144))) int144;
typedef int __attribute__ ((bitwidth(145))) int145;
typedef int __attribute__ ((bitwidth(146))) int146;
typedef int __attribute__ ((bitwidth(147))) int147;
typedef int __attribute__ ((bitwidth(148))) int148;
typedef int __attribute__ ((bitwidth(149))) int149;
typedef int __attribute__ ((bitwidth(150))) int150;
typedef int __attribute__ ((bitwidth(151))) int151;
typedef int __attribute__ ((bitwidth(152))) int152;
typedef int __attribute__ ((bitwidth(153))) int153;
typedef int __attribute__ ((bitwidth(154))) int154;
typedef int __attribute__ ((bitwidth(155))) int155;
typedef int __attribute__ ((bitwidth(156))) int156;
typedef int __attribute__ ((bitwidth(157))) int157;
typedef int __attribute__ ((bitwidth(158))) int158;
typedef int __attribute__ ((bitwidth(159))) int159;
typedef int __attribute__ ((bitwidth(160))) int160;
typedef int __attribute__ ((bitwidth(161))) int161;
typedef int __attribute__ ((bitwidth(162))) int162;
typedef int __attribute__ ((bitwidth(163))) int163;
typedef int __attribute__ ((bitwidth(164))) int164;
typedef int __attribute__ ((bitwidth(165))) int165;
typedef int __attribute__ ((bitwidth(166))) int166;
typedef int __attribute__ ((bitwidth(167))) int167;
typedef int __attribute__ ((bitwidth(168))) int168;
typedef int __attribute__ ((bitwidth(169))) int169;
typedef int __attribute__ ((bitwidth(170))) int170;
typedef int __attribute__ ((bitwidth(171))) int171;
typedef int __attribute__ ((bitwidth(172))) int172;
typedef int __attribute__ ((bitwidth(173))) int173;
typedef int __attribute__ ((bitwidth(174))) int174;
typedef int __attribute__ ((bitwidth(175))) int175;
typedef int __attribute__ ((bitwidth(176))) int176;
typedef int __attribute__ ((bitwidth(177))) int177;
typedef int __attribute__ ((bitwidth(178))) int178;
typedef int __attribute__ ((bitwidth(179))) int179;
typedef int __attribute__ ((bitwidth(180))) int180;
typedef int __attribute__ ((bitwidth(181))) int181;
typedef int __attribute__ ((bitwidth(182))) int182;
typedef int __attribute__ ((bitwidth(183))) int183;
typedef int __attribute__ ((bitwidth(184))) int184;
typedef int __attribute__ ((bitwidth(185))) int185;
typedef int __attribute__ ((bitwidth(186))) int186;
typedef int __attribute__ ((bitwidth(187))) int187;
typedef int __attribute__ ((bitwidth(188))) int188;
typedef int __attribute__ ((bitwidth(189))) int189;
typedef int __attribute__ ((bitwidth(190))) int190;
typedef int __attribute__ ((bitwidth(191))) int191;
typedef int __attribute__ ((bitwidth(192))) int192;
typedef int __attribute__ ((bitwidth(193))) int193;
typedef int __attribute__ ((bitwidth(194))) int194;
typedef int __attribute__ ((bitwidth(195))) int195;
typedef int __attribute__ ((bitwidth(196))) int196;
typedef int __attribute__ ((bitwidth(197))) int197;
typedef int __attribute__ ((bitwidth(198))) int198;
typedef int __attribute__ ((bitwidth(199))) int199;
typedef int __attribute__ ((bitwidth(200))) int200;
typedef int __attribute__ ((bitwidth(201))) int201;
typedef int __attribute__ ((bitwidth(202))) int202;
typedef int __attribute__ ((bitwidth(203))) int203;
typedef int __attribute__ ((bitwidth(204))) int204;
typedef int __attribute__ ((bitwidth(205))) int205;
typedef int __attribute__ ((bitwidth(206))) int206;
typedef int __attribute__ ((bitwidth(207))) int207;
typedef int __attribute__ ((bitwidth(208))) int208;
typedef int __attribute__ ((bitwidth(209))) int209;
typedef int __attribute__ ((bitwidth(210))) int210;
typedef int __attribute__ ((bitwidth(211))) int211;
typedef int __attribute__ ((bitwidth(212))) int212;
typedef int __attribute__ ((bitwidth(213))) int213;
typedef int __attribute__ ((bitwidth(214))) int214;
typedef int __attribute__ ((bitwidth(215))) int215;
typedef int __attribute__ ((bitwidth(216))) int216;
typedef int __attribute__ ((bitwidth(217))) int217;
typedef int __attribute__ ((bitwidth(218))) int218;
typedef int __attribute__ ((bitwidth(219))) int219;
typedef int __attribute__ ((bitwidth(220))) int220;
typedef int __attribute__ ((bitwidth(221))) int221;
typedef int __attribute__ ((bitwidth(222))) int222;
typedef int __attribute__ ((bitwidth(223))) int223;
typedef int __attribute__ ((bitwidth(224))) int224;
typedef int __attribute__ ((bitwidth(225))) int225;
typedef int __attribute__ ((bitwidth(226))) int226;
typedef int __attribute__ ((bitwidth(227))) int227;
typedef int __attribute__ ((bitwidth(228))) int228;
typedef int __attribute__ ((bitwidth(229))) int229;
typedef int __attribute__ ((bitwidth(230))) int230;
typedef int __attribute__ ((bitwidth(231))) int231;
typedef int __attribute__ ((bitwidth(232))) int232;
typedef int __attribute__ ((bitwidth(233))) int233;
typedef int __attribute__ ((bitwidth(234))) int234;
typedef int __attribute__ ((bitwidth(235))) int235;
typedef int __attribute__ ((bitwidth(236))) int236;
typedef int __attribute__ ((bitwidth(237))) int237;
typedef int __attribute__ ((bitwidth(238))) int238;
typedef int __attribute__ ((bitwidth(239))) int239;
typedef int __attribute__ ((bitwidth(240))) int240;
typedef int __attribute__ ((bitwidth(241))) int241;
typedef int __attribute__ ((bitwidth(242))) int242;
typedef int __attribute__ ((bitwidth(243))) int243;
typedef int __attribute__ ((bitwidth(244))) int244;
typedef int __attribute__ ((bitwidth(245))) int245;
typedef int __attribute__ ((bitwidth(246))) int246;
typedef int __attribute__ ((bitwidth(247))) int247;
typedef int __attribute__ ((bitwidth(248))) int248;
typedef int __attribute__ ((bitwidth(249))) int249;
typedef int __attribute__ ((bitwidth(250))) int250;
typedef int __attribute__ ((bitwidth(251))) int251;
typedef int __attribute__ ((bitwidth(252))) int252;
typedef int __attribute__ ((bitwidth(253))) int253;
typedef int __attribute__ ((bitwidth(254))) int254;
typedef int __attribute__ ((bitwidth(255))) int255;
typedef int __attribute__ ((bitwidth(256))) int256;
typedef int __attribute__ ((bitwidth(257))) int257;
typedef int __attribute__ ((bitwidth(258))) int258;
typedef int __attribute__ ((bitwidth(259))) int259;
typedef int __attribute__ ((bitwidth(260))) int260;
typedef int __attribute__ ((bitwidth(261))) int261;
typedef int __attribute__ ((bitwidth(262))) int262;
typedef int __attribute__ ((bitwidth(263))) int263;
typedef int __attribute__ ((bitwidth(264))) int264;
typedef int __attribute__ ((bitwidth(265))) int265;
typedef int __attribute__ ((bitwidth(266))) int266;
typedef int __attribute__ ((bitwidth(267))) int267;
typedef int __attribute__ ((bitwidth(268))) int268;
typedef int __attribute__ ((bitwidth(269))) int269;
typedef int __attribute__ ((bitwidth(270))) int270;
typedef int __attribute__ ((bitwidth(271))) int271;
typedef int __attribute__ ((bitwidth(272))) int272;
typedef int __attribute__ ((bitwidth(273))) int273;
typedef int __attribute__ ((bitwidth(274))) int274;
typedef int __attribute__ ((bitwidth(275))) int275;
typedef int __attribute__ ((bitwidth(276))) int276;
typedef int __attribute__ ((bitwidth(277))) int277;
typedef int __attribute__ ((bitwidth(278))) int278;
typedef int __attribute__ ((bitwidth(279))) int279;
typedef int __attribute__ ((bitwidth(280))) int280;
typedef int __attribute__ ((bitwidth(281))) int281;
typedef int __attribute__ ((bitwidth(282))) int282;
typedef int __attribute__ ((bitwidth(283))) int283;
typedef int __attribute__ ((bitwidth(284))) int284;
typedef int __attribute__ ((bitwidth(285))) int285;
typedef int __attribute__ ((bitwidth(286))) int286;
typedef int __attribute__ ((bitwidth(287))) int287;
typedef int __attribute__ ((bitwidth(288))) int288;
typedef int __attribute__ ((bitwidth(289))) int289;
typedef int __attribute__ ((bitwidth(290))) int290;
typedef int __attribute__ ((bitwidth(291))) int291;
typedef int __attribute__ ((bitwidth(292))) int292;
typedef int __attribute__ ((bitwidth(293))) int293;
typedef int __attribute__ ((bitwidth(294))) int294;
typedef int __attribute__ ((bitwidth(295))) int295;
typedef int __attribute__ ((bitwidth(296))) int296;
typedef int __attribute__ ((bitwidth(297))) int297;
typedef int __attribute__ ((bitwidth(298))) int298;
typedef int __attribute__ ((bitwidth(299))) int299;
typedef int __attribute__ ((bitwidth(300))) int300;
typedef int __attribute__ ((bitwidth(301))) int301;
typedef int __attribute__ ((bitwidth(302))) int302;
typedef int __attribute__ ((bitwidth(303))) int303;
typedef int __attribute__ ((bitwidth(304))) int304;
typedef int __attribute__ ((bitwidth(305))) int305;
typedef int __attribute__ ((bitwidth(306))) int306;
typedef int __attribute__ ((bitwidth(307))) int307;
typedef int __attribute__ ((bitwidth(308))) int308;
typedef int __attribute__ ((bitwidth(309))) int309;
typedef int __attribute__ ((bitwidth(310))) int310;
typedef int __attribute__ ((bitwidth(311))) int311;
typedef int __attribute__ ((bitwidth(312))) int312;
typedef int __attribute__ ((bitwidth(313))) int313;
typedef int __attribute__ ((bitwidth(314))) int314;
typedef int __attribute__ ((bitwidth(315))) int315;
typedef int __attribute__ ((bitwidth(316))) int316;
typedef int __attribute__ ((bitwidth(317))) int317;
typedef int __attribute__ ((bitwidth(318))) int318;
typedef int __attribute__ ((bitwidth(319))) int319;
typedef int __attribute__ ((bitwidth(320))) int320;
typedef int __attribute__ ((bitwidth(321))) int321;
typedef int __attribute__ ((bitwidth(322))) int322;
typedef int __attribute__ ((bitwidth(323))) int323;
typedef int __attribute__ ((bitwidth(324))) int324;
typedef int __attribute__ ((bitwidth(325))) int325;
typedef int __attribute__ ((bitwidth(326))) int326;
typedef int __attribute__ ((bitwidth(327))) int327;
typedef int __attribute__ ((bitwidth(328))) int328;
typedef int __attribute__ ((bitwidth(329))) int329;
typedef int __attribute__ ((bitwidth(330))) int330;
typedef int __attribute__ ((bitwidth(331))) int331;
typedef int __attribute__ ((bitwidth(332))) int332;
typedef int __attribute__ ((bitwidth(333))) int333;
typedef int __attribute__ ((bitwidth(334))) int334;
typedef int __attribute__ ((bitwidth(335))) int335;
typedef int __attribute__ ((bitwidth(336))) int336;
typedef int __attribute__ ((bitwidth(337))) int337;
typedef int __attribute__ ((bitwidth(338))) int338;
typedef int __attribute__ ((bitwidth(339))) int339;
typedef int __attribute__ ((bitwidth(340))) int340;
typedef int __attribute__ ((bitwidth(341))) int341;
typedef int __attribute__ ((bitwidth(342))) int342;
typedef int __attribute__ ((bitwidth(343))) int343;
typedef int __attribute__ ((bitwidth(344))) int344;
typedef int __attribute__ ((bitwidth(345))) int345;
typedef int __attribute__ ((bitwidth(346))) int346;
typedef int __attribute__ ((bitwidth(347))) int347;
typedef int __attribute__ ((bitwidth(348))) int348;
typedef int __attribute__ ((bitwidth(349))) int349;
typedef int __attribute__ ((bitwidth(350))) int350;
typedef int __attribute__ ((bitwidth(351))) int351;
typedef int __attribute__ ((bitwidth(352))) int352;
typedef int __attribute__ ((bitwidth(353))) int353;
typedef int __attribute__ ((bitwidth(354))) int354;
typedef int __attribute__ ((bitwidth(355))) int355;
typedef int __attribute__ ((bitwidth(356))) int356;
typedef int __attribute__ ((bitwidth(357))) int357;
typedef int __attribute__ ((bitwidth(358))) int358;
typedef int __attribute__ ((bitwidth(359))) int359;
typedef int __attribute__ ((bitwidth(360))) int360;
typedef int __attribute__ ((bitwidth(361))) int361;
typedef int __attribute__ ((bitwidth(362))) int362;
typedef int __attribute__ ((bitwidth(363))) int363;
typedef int __attribute__ ((bitwidth(364))) int364;
typedef int __attribute__ ((bitwidth(365))) int365;
typedef int __attribute__ ((bitwidth(366))) int366;
typedef int __attribute__ ((bitwidth(367))) int367;
typedef int __attribute__ ((bitwidth(368))) int368;
typedef int __attribute__ ((bitwidth(369))) int369;
typedef int __attribute__ ((bitwidth(370))) int370;
typedef int __attribute__ ((bitwidth(371))) int371;
typedef int __attribute__ ((bitwidth(372))) int372;
typedef int __attribute__ ((bitwidth(373))) int373;
typedef int __attribute__ ((bitwidth(374))) int374;
typedef int __attribute__ ((bitwidth(375))) int375;
typedef int __attribute__ ((bitwidth(376))) int376;
typedef int __attribute__ ((bitwidth(377))) int377;
typedef int __attribute__ ((bitwidth(378))) int378;
typedef int __attribute__ ((bitwidth(379))) int379;
typedef int __attribute__ ((bitwidth(380))) int380;
typedef int __attribute__ ((bitwidth(381))) int381;
typedef int __attribute__ ((bitwidth(382))) int382;
typedef int __attribute__ ((bitwidth(383))) int383;
typedef int __attribute__ ((bitwidth(384))) int384;
typedef int __attribute__ ((bitwidth(385))) int385;
typedef int __attribute__ ((bitwidth(386))) int386;
typedef int __attribute__ ((bitwidth(387))) int387;
typedef int __attribute__ ((bitwidth(388))) int388;
typedef int __attribute__ ((bitwidth(389))) int389;
typedef int __attribute__ ((bitwidth(390))) int390;
typedef int __attribute__ ((bitwidth(391))) int391;
typedef int __attribute__ ((bitwidth(392))) int392;
typedef int __attribute__ ((bitwidth(393))) int393;
typedef int __attribute__ ((bitwidth(394))) int394;
typedef int __attribute__ ((bitwidth(395))) int395;
typedef int __attribute__ ((bitwidth(396))) int396;
typedef int __attribute__ ((bitwidth(397))) int397;
typedef int __attribute__ ((bitwidth(398))) int398;
typedef int __attribute__ ((bitwidth(399))) int399;
typedef int __attribute__ ((bitwidth(400))) int400;
typedef int __attribute__ ((bitwidth(401))) int401;
typedef int __attribute__ ((bitwidth(402))) int402;
typedef int __attribute__ ((bitwidth(403))) int403;
typedef int __attribute__ ((bitwidth(404))) int404;
typedef int __attribute__ ((bitwidth(405))) int405;
typedef int __attribute__ ((bitwidth(406))) int406;
typedef int __attribute__ ((bitwidth(407))) int407;
typedef int __attribute__ ((bitwidth(408))) int408;
typedef int __attribute__ ((bitwidth(409))) int409;
typedef int __attribute__ ((bitwidth(410))) int410;
typedef int __attribute__ ((bitwidth(411))) int411;
typedef int __attribute__ ((bitwidth(412))) int412;
typedef int __attribute__ ((bitwidth(413))) int413;
typedef int __attribute__ ((bitwidth(414))) int414;
typedef int __attribute__ ((bitwidth(415))) int415;
typedef int __attribute__ ((bitwidth(416))) int416;
typedef int __attribute__ ((bitwidth(417))) int417;
typedef int __attribute__ ((bitwidth(418))) int418;
typedef int __attribute__ ((bitwidth(419))) int419;
typedef int __attribute__ ((bitwidth(420))) int420;
typedef int __attribute__ ((bitwidth(421))) int421;
typedef int __attribute__ ((bitwidth(422))) int422;
typedef int __attribute__ ((bitwidth(423))) int423;
typedef int __attribute__ ((bitwidth(424))) int424;
typedef int __attribute__ ((bitwidth(425))) int425;
typedef int __attribute__ ((bitwidth(426))) int426;
typedef int __attribute__ ((bitwidth(427))) int427;
typedef int __attribute__ ((bitwidth(428))) int428;
typedef int __attribute__ ((bitwidth(429))) int429;
typedef int __attribute__ ((bitwidth(430))) int430;
typedef int __attribute__ ((bitwidth(431))) int431;
typedef int __attribute__ ((bitwidth(432))) int432;
typedef int __attribute__ ((bitwidth(433))) int433;
typedef int __attribute__ ((bitwidth(434))) int434;
typedef int __attribute__ ((bitwidth(435))) int435;
typedef int __attribute__ ((bitwidth(436))) int436;
typedef int __attribute__ ((bitwidth(437))) int437;
typedef int __attribute__ ((bitwidth(438))) int438;
typedef int __attribute__ ((bitwidth(439))) int439;
typedef int __attribute__ ((bitwidth(440))) int440;
typedef int __attribute__ ((bitwidth(441))) int441;
typedef int __attribute__ ((bitwidth(442))) int442;
typedef int __attribute__ ((bitwidth(443))) int443;
typedef int __attribute__ ((bitwidth(444))) int444;
typedef int __attribute__ ((bitwidth(445))) int445;
typedef int __attribute__ ((bitwidth(446))) int446;
typedef int __attribute__ ((bitwidth(447))) int447;
typedef int __attribute__ ((bitwidth(448))) int448;
typedef int __attribute__ ((bitwidth(449))) int449;
typedef int __attribute__ ((bitwidth(450))) int450;
typedef int __attribute__ ((bitwidth(451))) int451;
typedef int __attribute__ ((bitwidth(452))) int452;
typedef int __attribute__ ((bitwidth(453))) int453;
typedef int __attribute__ ((bitwidth(454))) int454;
typedef int __attribute__ ((bitwidth(455))) int455;
typedef int __attribute__ ((bitwidth(456))) int456;
typedef int __attribute__ ((bitwidth(457))) int457;
typedef int __attribute__ ((bitwidth(458))) int458;
typedef int __attribute__ ((bitwidth(459))) int459;
typedef int __attribute__ ((bitwidth(460))) int460;
typedef int __attribute__ ((bitwidth(461))) int461;
typedef int __attribute__ ((bitwidth(462))) int462;
typedef int __attribute__ ((bitwidth(463))) int463;
typedef int __attribute__ ((bitwidth(464))) int464;
typedef int __attribute__ ((bitwidth(465))) int465;
typedef int __attribute__ ((bitwidth(466))) int466;
typedef int __attribute__ ((bitwidth(467))) int467;
typedef int __attribute__ ((bitwidth(468))) int468;
typedef int __attribute__ ((bitwidth(469))) int469;
typedef int __attribute__ ((bitwidth(470))) int470;
typedef int __attribute__ ((bitwidth(471))) int471;
typedef int __attribute__ ((bitwidth(472))) int472;
typedef int __attribute__ ((bitwidth(473))) int473;
typedef int __attribute__ ((bitwidth(474))) int474;
typedef int __attribute__ ((bitwidth(475))) int475;
typedef int __attribute__ ((bitwidth(476))) int476;
typedef int __attribute__ ((bitwidth(477))) int477;
typedef int __attribute__ ((bitwidth(478))) int478;
typedef int __attribute__ ((bitwidth(479))) int479;
typedef int __attribute__ ((bitwidth(480))) int480;
typedef int __attribute__ ((bitwidth(481))) int481;
typedef int __attribute__ ((bitwidth(482))) int482;
typedef int __attribute__ ((bitwidth(483))) int483;
typedef int __attribute__ ((bitwidth(484))) int484;
typedef int __attribute__ ((bitwidth(485))) int485;
typedef int __attribute__ ((bitwidth(486))) int486;
typedef int __attribute__ ((bitwidth(487))) int487;
typedef int __attribute__ ((bitwidth(488))) int488;
typedef int __attribute__ ((bitwidth(489))) int489;
typedef int __attribute__ ((bitwidth(490))) int490;
typedef int __attribute__ ((bitwidth(491))) int491;
typedef int __attribute__ ((bitwidth(492))) int492;
typedef int __attribute__ ((bitwidth(493))) int493;
typedef int __attribute__ ((bitwidth(494))) int494;
typedef int __attribute__ ((bitwidth(495))) int495;
typedef int __attribute__ ((bitwidth(496))) int496;
typedef int __attribute__ ((bitwidth(497))) int497;
typedef int __attribute__ ((bitwidth(498))) int498;
typedef int __attribute__ ((bitwidth(499))) int499;
typedef int __attribute__ ((bitwidth(500))) int500;
typedef int __attribute__ ((bitwidth(501))) int501;
typedef int __attribute__ ((bitwidth(502))) int502;
typedef int __attribute__ ((bitwidth(503))) int503;
typedef int __attribute__ ((bitwidth(504))) int504;
typedef int __attribute__ ((bitwidth(505))) int505;
typedef int __attribute__ ((bitwidth(506))) int506;
typedef int __attribute__ ((bitwidth(507))) int507;
typedef int __attribute__ ((bitwidth(508))) int508;
typedef int __attribute__ ((bitwidth(509))) int509;
typedef int __attribute__ ((bitwidth(510))) int510;
typedef int __attribute__ ((bitwidth(511))) int511;
typedef int __attribute__ ((bitwidth(512))) int512;
typedef int __attribute__ ((bitwidth(513))) int513;
typedef int __attribute__ ((bitwidth(514))) int514;
typedef int __attribute__ ((bitwidth(515))) int515;
typedef int __attribute__ ((bitwidth(516))) int516;
typedef int __attribute__ ((bitwidth(517))) int517;
typedef int __attribute__ ((bitwidth(518))) int518;
typedef int __attribute__ ((bitwidth(519))) int519;
typedef int __attribute__ ((bitwidth(520))) int520;
typedef int __attribute__ ((bitwidth(521))) int521;
typedef int __attribute__ ((bitwidth(522))) int522;
typedef int __attribute__ ((bitwidth(523))) int523;
typedef int __attribute__ ((bitwidth(524))) int524;
typedef int __attribute__ ((bitwidth(525))) int525;
typedef int __attribute__ ((bitwidth(526))) int526;
typedef int __attribute__ ((bitwidth(527))) int527;
typedef int __attribute__ ((bitwidth(528))) int528;
typedef int __attribute__ ((bitwidth(529))) int529;
typedef int __attribute__ ((bitwidth(530))) int530;
typedef int __attribute__ ((bitwidth(531))) int531;
typedef int __attribute__ ((bitwidth(532))) int532;
typedef int __attribute__ ((bitwidth(533))) int533;
typedef int __attribute__ ((bitwidth(534))) int534;
typedef int __attribute__ ((bitwidth(535))) int535;
typedef int __attribute__ ((bitwidth(536))) int536;
typedef int __attribute__ ((bitwidth(537))) int537;
typedef int __attribute__ ((bitwidth(538))) int538;
typedef int __attribute__ ((bitwidth(539))) int539;
typedef int __attribute__ ((bitwidth(540))) int540;
typedef int __attribute__ ((bitwidth(541))) int541;
typedef int __attribute__ ((bitwidth(542))) int542;
typedef int __attribute__ ((bitwidth(543))) int543;
typedef int __attribute__ ((bitwidth(544))) int544;
typedef int __attribute__ ((bitwidth(545))) int545;
typedef int __attribute__ ((bitwidth(546))) int546;
typedef int __attribute__ ((bitwidth(547))) int547;
typedef int __attribute__ ((bitwidth(548))) int548;
typedef int __attribute__ ((bitwidth(549))) int549;
typedef int __attribute__ ((bitwidth(550))) int550;
typedef int __attribute__ ((bitwidth(551))) int551;
typedef int __attribute__ ((bitwidth(552))) int552;
typedef int __attribute__ ((bitwidth(553))) int553;
typedef int __attribute__ ((bitwidth(554))) int554;
typedef int __attribute__ ((bitwidth(555))) int555;
typedef int __attribute__ ((bitwidth(556))) int556;
typedef int __attribute__ ((bitwidth(557))) int557;
typedef int __attribute__ ((bitwidth(558))) int558;
typedef int __attribute__ ((bitwidth(559))) int559;
typedef int __attribute__ ((bitwidth(560))) int560;
typedef int __attribute__ ((bitwidth(561))) int561;
typedef int __attribute__ ((bitwidth(562))) int562;
typedef int __attribute__ ((bitwidth(563))) int563;
typedef int __attribute__ ((bitwidth(564))) int564;
typedef int __attribute__ ((bitwidth(565))) int565;
typedef int __attribute__ ((bitwidth(566))) int566;
typedef int __attribute__ ((bitwidth(567))) int567;
typedef int __attribute__ ((bitwidth(568))) int568;
typedef int __attribute__ ((bitwidth(569))) int569;
typedef int __attribute__ ((bitwidth(570))) int570;
typedef int __attribute__ ((bitwidth(571))) int571;
typedef int __attribute__ ((bitwidth(572))) int572;
typedef int __attribute__ ((bitwidth(573))) int573;
typedef int __attribute__ ((bitwidth(574))) int574;
typedef int __attribute__ ((bitwidth(575))) int575;
typedef int __attribute__ ((bitwidth(576))) int576;
typedef int __attribute__ ((bitwidth(577))) int577;
typedef int __attribute__ ((bitwidth(578))) int578;
typedef int __attribute__ ((bitwidth(579))) int579;
typedef int __attribute__ ((bitwidth(580))) int580;
typedef int __attribute__ ((bitwidth(581))) int581;
typedef int __attribute__ ((bitwidth(582))) int582;
typedef int __attribute__ ((bitwidth(583))) int583;
typedef int __attribute__ ((bitwidth(584))) int584;
typedef int __attribute__ ((bitwidth(585))) int585;
typedef int __attribute__ ((bitwidth(586))) int586;
typedef int __attribute__ ((bitwidth(587))) int587;
typedef int __attribute__ ((bitwidth(588))) int588;
typedef int __attribute__ ((bitwidth(589))) int589;
typedef int __attribute__ ((bitwidth(590))) int590;
typedef int __attribute__ ((bitwidth(591))) int591;
typedef int __attribute__ ((bitwidth(592))) int592;
typedef int __attribute__ ((bitwidth(593))) int593;
typedef int __attribute__ ((bitwidth(594))) int594;
typedef int __attribute__ ((bitwidth(595))) int595;
typedef int __attribute__ ((bitwidth(596))) int596;
typedef int __attribute__ ((bitwidth(597))) int597;
typedef int __attribute__ ((bitwidth(598))) int598;
typedef int __attribute__ ((bitwidth(599))) int599;
typedef int __attribute__ ((bitwidth(600))) int600;
typedef int __attribute__ ((bitwidth(601))) int601;
typedef int __attribute__ ((bitwidth(602))) int602;
typedef int __attribute__ ((bitwidth(603))) int603;
typedef int __attribute__ ((bitwidth(604))) int604;
typedef int __attribute__ ((bitwidth(605))) int605;
typedef int __attribute__ ((bitwidth(606))) int606;
typedef int __attribute__ ((bitwidth(607))) int607;
typedef int __attribute__ ((bitwidth(608))) int608;
typedef int __attribute__ ((bitwidth(609))) int609;
typedef int __attribute__ ((bitwidth(610))) int610;
typedef int __attribute__ ((bitwidth(611))) int611;
typedef int __attribute__ ((bitwidth(612))) int612;
typedef int __attribute__ ((bitwidth(613))) int613;
typedef int __attribute__ ((bitwidth(614))) int614;
typedef int __attribute__ ((bitwidth(615))) int615;
typedef int __attribute__ ((bitwidth(616))) int616;
typedef int __attribute__ ((bitwidth(617))) int617;
typedef int __attribute__ ((bitwidth(618))) int618;
typedef int __attribute__ ((bitwidth(619))) int619;
typedef int __attribute__ ((bitwidth(620))) int620;
typedef int __attribute__ ((bitwidth(621))) int621;
typedef int __attribute__ ((bitwidth(622))) int622;
typedef int __attribute__ ((bitwidth(623))) int623;
typedef int __attribute__ ((bitwidth(624))) int624;
typedef int __attribute__ ((bitwidth(625))) int625;
typedef int __attribute__ ((bitwidth(626))) int626;
typedef int __attribute__ ((bitwidth(627))) int627;
typedef int __attribute__ ((bitwidth(628))) int628;
typedef int __attribute__ ((bitwidth(629))) int629;
typedef int __attribute__ ((bitwidth(630))) int630;
typedef int __attribute__ ((bitwidth(631))) int631;
typedef int __attribute__ ((bitwidth(632))) int632;
typedef int __attribute__ ((bitwidth(633))) int633;
typedef int __attribute__ ((bitwidth(634))) int634;
typedef int __attribute__ ((bitwidth(635))) int635;
typedef int __attribute__ ((bitwidth(636))) int636;
typedef int __attribute__ ((bitwidth(637))) int637;
typedef int __attribute__ ((bitwidth(638))) int638;
typedef int __attribute__ ((bitwidth(639))) int639;
typedef int __attribute__ ((bitwidth(640))) int640;
typedef int __attribute__ ((bitwidth(641))) int641;
typedef int __attribute__ ((bitwidth(642))) int642;
typedef int __attribute__ ((bitwidth(643))) int643;
typedef int __attribute__ ((bitwidth(644))) int644;
typedef int __attribute__ ((bitwidth(645))) int645;
typedef int __attribute__ ((bitwidth(646))) int646;
typedef int __attribute__ ((bitwidth(647))) int647;
typedef int __attribute__ ((bitwidth(648))) int648;
typedef int __attribute__ ((bitwidth(649))) int649;
typedef int __attribute__ ((bitwidth(650))) int650;
typedef int __attribute__ ((bitwidth(651))) int651;
typedef int __attribute__ ((bitwidth(652))) int652;
typedef int __attribute__ ((bitwidth(653))) int653;
typedef int __attribute__ ((bitwidth(654))) int654;
typedef int __attribute__ ((bitwidth(655))) int655;
typedef int __attribute__ ((bitwidth(656))) int656;
typedef int __attribute__ ((bitwidth(657))) int657;
typedef int __attribute__ ((bitwidth(658))) int658;
typedef int __attribute__ ((bitwidth(659))) int659;
typedef int __attribute__ ((bitwidth(660))) int660;
typedef int __attribute__ ((bitwidth(661))) int661;
typedef int __attribute__ ((bitwidth(662))) int662;
typedef int __attribute__ ((bitwidth(663))) int663;
typedef int __attribute__ ((bitwidth(664))) int664;
typedef int __attribute__ ((bitwidth(665))) int665;
typedef int __attribute__ ((bitwidth(666))) int666;
typedef int __attribute__ ((bitwidth(667))) int667;
typedef int __attribute__ ((bitwidth(668))) int668;
typedef int __attribute__ ((bitwidth(669))) int669;
typedef int __attribute__ ((bitwidth(670))) int670;
typedef int __attribute__ ((bitwidth(671))) int671;
typedef int __attribute__ ((bitwidth(672))) int672;
typedef int __attribute__ ((bitwidth(673))) int673;
typedef int __attribute__ ((bitwidth(674))) int674;
typedef int __attribute__ ((bitwidth(675))) int675;
typedef int __attribute__ ((bitwidth(676))) int676;
typedef int __attribute__ ((bitwidth(677))) int677;
typedef int __attribute__ ((bitwidth(678))) int678;
typedef int __attribute__ ((bitwidth(679))) int679;
typedef int __attribute__ ((bitwidth(680))) int680;
typedef int __attribute__ ((bitwidth(681))) int681;
typedef int __attribute__ ((bitwidth(682))) int682;
typedef int __attribute__ ((bitwidth(683))) int683;
typedef int __attribute__ ((bitwidth(684))) int684;
typedef int __attribute__ ((bitwidth(685))) int685;
typedef int __attribute__ ((bitwidth(686))) int686;
typedef int __attribute__ ((bitwidth(687))) int687;
typedef int __attribute__ ((bitwidth(688))) int688;
typedef int __attribute__ ((bitwidth(689))) int689;
typedef int __attribute__ ((bitwidth(690))) int690;
typedef int __attribute__ ((bitwidth(691))) int691;
typedef int __attribute__ ((bitwidth(692))) int692;
typedef int __attribute__ ((bitwidth(693))) int693;
typedef int __attribute__ ((bitwidth(694))) int694;
typedef int __attribute__ ((bitwidth(695))) int695;
typedef int __attribute__ ((bitwidth(696))) int696;
typedef int __attribute__ ((bitwidth(697))) int697;
typedef int __attribute__ ((bitwidth(698))) int698;
typedef int __attribute__ ((bitwidth(699))) int699;
typedef int __attribute__ ((bitwidth(700))) int700;
typedef int __attribute__ ((bitwidth(701))) int701;
typedef int __attribute__ ((bitwidth(702))) int702;
typedef int __attribute__ ((bitwidth(703))) int703;
typedef int __attribute__ ((bitwidth(704))) int704;
typedef int __attribute__ ((bitwidth(705))) int705;
typedef int __attribute__ ((bitwidth(706))) int706;
typedef int __attribute__ ((bitwidth(707))) int707;
typedef int __attribute__ ((bitwidth(708))) int708;
typedef int __attribute__ ((bitwidth(709))) int709;
typedef int __attribute__ ((bitwidth(710))) int710;
typedef int __attribute__ ((bitwidth(711))) int711;
typedef int __attribute__ ((bitwidth(712))) int712;
typedef int __attribute__ ((bitwidth(713))) int713;
typedef int __attribute__ ((bitwidth(714))) int714;
typedef int __attribute__ ((bitwidth(715))) int715;
typedef int __attribute__ ((bitwidth(716))) int716;
typedef int __attribute__ ((bitwidth(717))) int717;
typedef int __attribute__ ((bitwidth(718))) int718;
typedef int __attribute__ ((bitwidth(719))) int719;
typedef int __attribute__ ((bitwidth(720))) int720;
typedef int __attribute__ ((bitwidth(721))) int721;
typedef int __attribute__ ((bitwidth(722))) int722;
typedef int __attribute__ ((bitwidth(723))) int723;
typedef int __attribute__ ((bitwidth(724))) int724;
typedef int __attribute__ ((bitwidth(725))) int725;
typedef int __attribute__ ((bitwidth(726))) int726;
typedef int __attribute__ ((bitwidth(727))) int727;
typedef int __attribute__ ((bitwidth(728))) int728;
typedef int __attribute__ ((bitwidth(729))) int729;
typedef int __attribute__ ((bitwidth(730))) int730;
typedef int __attribute__ ((bitwidth(731))) int731;
typedef int __attribute__ ((bitwidth(732))) int732;
typedef int __attribute__ ((bitwidth(733))) int733;
typedef int __attribute__ ((bitwidth(734))) int734;
typedef int __attribute__ ((bitwidth(735))) int735;
typedef int __attribute__ ((bitwidth(736))) int736;
typedef int __attribute__ ((bitwidth(737))) int737;
typedef int __attribute__ ((bitwidth(738))) int738;
typedef int __attribute__ ((bitwidth(739))) int739;
typedef int __attribute__ ((bitwidth(740))) int740;
typedef int __attribute__ ((bitwidth(741))) int741;
typedef int __attribute__ ((bitwidth(742))) int742;
typedef int __attribute__ ((bitwidth(743))) int743;
typedef int __attribute__ ((bitwidth(744))) int744;
typedef int __attribute__ ((bitwidth(745))) int745;
typedef int __attribute__ ((bitwidth(746))) int746;
typedef int __attribute__ ((bitwidth(747))) int747;
typedef int __attribute__ ((bitwidth(748))) int748;
typedef int __attribute__ ((bitwidth(749))) int749;
typedef int __attribute__ ((bitwidth(750))) int750;
typedef int __attribute__ ((bitwidth(751))) int751;
typedef int __attribute__ ((bitwidth(752))) int752;
typedef int __attribute__ ((bitwidth(753))) int753;
typedef int __attribute__ ((bitwidth(754))) int754;
typedef int __attribute__ ((bitwidth(755))) int755;
typedef int __attribute__ ((bitwidth(756))) int756;
typedef int __attribute__ ((bitwidth(757))) int757;
typedef int __attribute__ ((bitwidth(758))) int758;
typedef int __attribute__ ((bitwidth(759))) int759;
typedef int __attribute__ ((bitwidth(760))) int760;
typedef int __attribute__ ((bitwidth(761))) int761;
typedef int __attribute__ ((bitwidth(762))) int762;
typedef int __attribute__ ((bitwidth(763))) int763;
typedef int __attribute__ ((bitwidth(764))) int764;
typedef int __attribute__ ((bitwidth(765))) int765;
typedef int __attribute__ ((bitwidth(766))) int766;
typedef int __attribute__ ((bitwidth(767))) int767;
typedef int __attribute__ ((bitwidth(768))) int768;
typedef int __attribute__ ((bitwidth(769))) int769;
typedef int __attribute__ ((bitwidth(770))) int770;
typedef int __attribute__ ((bitwidth(771))) int771;
typedef int __attribute__ ((bitwidth(772))) int772;
typedef int __attribute__ ((bitwidth(773))) int773;
typedef int __attribute__ ((bitwidth(774))) int774;
typedef int __attribute__ ((bitwidth(775))) int775;
typedef int __attribute__ ((bitwidth(776))) int776;
typedef int __attribute__ ((bitwidth(777))) int777;
typedef int __attribute__ ((bitwidth(778))) int778;
typedef int __attribute__ ((bitwidth(779))) int779;
typedef int __attribute__ ((bitwidth(780))) int780;
typedef int __attribute__ ((bitwidth(781))) int781;
typedef int __attribute__ ((bitwidth(782))) int782;
typedef int __attribute__ ((bitwidth(783))) int783;
typedef int __attribute__ ((bitwidth(784))) int784;
typedef int __attribute__ ((bitwidth(785))) int785;
typedef int __attribute__ ((bitwidth(786))) int786;
typedef int __attribute__ ((bitwidth(787))) int787;
typedef int __attribute__ ((bitwidth(788))) int788;
typedef int __attribute__ ((bitwidth(789))) int789;
typedef int __attribute__ ((bitwidth(790))) int790;
typedef int __attribute__ ((bitwidth(791))) int791;
typedef int __attribute__ ((bitwidth(792))) int792;
typedef int __attribute__ ((bitwidth(793))) int793;
typedef int __attribute__ ((bitwidth(794))) int794;
typedef int __attribute__ ((bitwidth(795))) int795;
typedef int __attribute__ ((bitwidth(796))) int796;
typedef int __attribute__ ((bitwidth(797))) int797;
typedef int __attribute__ ((bitwidth(798))) int798;
typedef int __attribute__ ((bitwidth(799))) int799;
typedef int __attribute__ ((bitwidth(800))) int800;
typedef int __attribute__ ((bitwidth(801))) int801;
typedef int __attribute__ ((bitwidth(802))) int802;
typedef int __attribute__ ((bitwidth(803))) int803;
typedef int __attribute__ ((bitwidth(804))) int804;
typedef int __attribute__ ((bitwidth(805))) int805;
typedef int __attribute__ ((bitwidth(806))) int806;
typedef int __attribute__ ((bitwidth(807))) int807;
typedef int __attribute__ ((bitwidth(808))) int808;
typedef int __attribute__ ((bitwidth(809))) int809;
typedef int __attribute__ ((bitwidth(810))) int810;
typedef int __attribute__ ((bitwidth(811))) int811;
typedef int __attribute__ ((bitwidth(812))) int812;
typedef int __attribute__ ((bitwidth(813))) int813;
typedef int __attribute__ ((bitwidth(814))) int814;
typedef int __attribute__ ((bitwidth(815))) int815;
typedef int __attribute__ ((bitwidth(816))) int816;
typedef int __attribute__ ((bitwidth(817))) int817;
typedef int __attribute__ ((bitwidth(818))) int818;
typedef int __attribute__ ((bitwidth(819))) int819;
typedef int __attribute__ ((bitwidth(820))) int820;
typedef int __attribute__ ((bitwidth(821))) int821;
typedef int __attribute__ ((bitwidth(822))) int822;
typedef int __attribute__ ((bitwidth(823))) int823;
typedef int __attribute__ ((bitwidth(824))) int824;
typedef int __attribute__ ((bitwidth(825))) int825;
typedef int __attribute__ ((bitwidth(826))) int826;
typedef int __attribute__ ((bitwidth(827))) int827;
typedef int __attribute__ ((bitwidth(828))) int828;
typedef int __attribute__ ((bitwidth(829))) int829;
typedef int __attribute__ ((bitwidth(830))) int830;
typedef int __attribute__ ((bitwidth(831))) int831;
typedef int __attribute__ ((bitwidth(832))) int832;
typedef int __attribute__ ((bitwidth(833))) int833;
typedef int __attribute__ ((bitwidth(834))) int834;
typedef int __attribute__ ((bitwidth(835))) int835;
typedef int __attribute__ ((bitwidth(836))) int836;
typedef int __attribute__ ((bitwidth(837))) int837;
typedef int __attribute__ ((bitwidth(838))) int838;
typedef int __attribute__ ((bitwidth(839))) int839;
typedef int __attribute__ ((bitwidth(840))) int840;
typedef int __attribute__ ((bitwidth(841))) int841;
typedef int __attribute__ ((bitwidth(842))) int842;
typedef int __attribute__ ((bitwidth(843))) int843;
typedef int __attribute__ ((bitwidth(844))) int844;
typedef int __attribute__ ((bitwidth(845))) int845;
typedef int __attribute__ ((bitwidth(846))) int846;
typedef int __attribute__ ((bitwidth(847))) int847;
typedef int __attribute__ ((bitwidth(848))) int848;
typedef int __attribute__ ((bitwidth(849))) int849;
typedef int __attribute__ ((bitwidth(850))) int850;
typedef int __attribute__ ((bitwidth(851))) int851;
typedef int __attribute__ ((bitwidth(852))) int852;
typedef int __attribute__ ((bitwidth(853))) int853;
typedef int __attribute__ ((bitwidth(854))) int854;
typedef int __attribute__ ((bitwidth(855))) int855;
typedef int __attribute__ ((bitwidth(856))) int856;
typedef int __attribute__ ((bitwidth(857))) int857;
typedef int __attribute__ ((bitwidth(858))) int858;
typedef int __attribute__ ((bitwidth(859))) int859;
typedef int __attribute__ ((bitwidth(860))) int860;
typedef int __attribute__ ((bitwidth(861))) int861;
typedef int __attribute__ ((bitwidth(862))) int862;
typedef int __attribute__ ((bitwidth(863))) int863;
typedef int __attribute__ ((bitwidth(864))) int864;
typedef int __attribute__ ((bitwidth(865))) int865;
typedef int __attribute__ ((bitwidth(866))) int866;
typedef int __attribute__ ((bitwidth(867))) int867;
typedef int __attribute__ ((bitwidth(868))) int868;
typedef int __attribute__ ((bitwidth(869))) int869;
typedef int __attribute__ ((bitwidth(870))) int870;
typedef int __attribute__ ((bitwidth(871))) int871;
typedef int __attribute__ ((bitwidth(872))) int872;
typedef int __attribute__ ((bitwidth(873))) int873;
typedef int __attribute__ ((bitwidth(874))) int874;
typedef int __attribute__ ((bitwidth(875))) int875;
typedef int __attribute__ ((bitwidth(876))) int876;
typedef int __attribute__ ((bitwidth(877))) int877;
typedef int __attribute__ ((bitwidth(878))) int878;
typedef int __attribute__ ((bitwidth(879))) int879;
typedef int __attribute__ ((bitwidth(880))) int880;
typedef int __attribute__ ((bitwidth(881))) int881;
typedef int __attribute__ ((bitwidth(882))) int882;
typedef int __attribute__ ((bitwidth(883))) int883;
typedef int __attribute__ ((bitwidth(884))) int884;
typedef int __attribute__ ((bitwidth(885))) int885;
typedef int __attribute__ ((bitwidth(886))) int886;
typedef int __attribute__ ((bitwidth(887))) int887;
typedef int __attribute__ ((bitwidth(888))) int888;
typedef int __attribute__ ((bitwidth(889))) int889;
typedef int __attribute__ ((bitwidth(890))) int890;
typedef int __attribute__ ((bitwidth(891))) int891;
typedef int __attribute__ ((bitwidth(892))) int892;
typedef int __attribute__ ((bitwidth(893))) int893;
typedef int __attribute__ ((bitwidth(894))) int894;
typedef int __attribute__ ((bitwidth(895))) int895;
typedef int __attribute__ ((bitwidth(896))) int896;
typedef int __attribute__ ((bitwidth(897))) int897;
typedef int __attribute__ ((bitwidth(898))) int898;
typedef int __attribute__ ((bitwidth(899))) int899;
typedef int __attribute__ ((bitwidth(900))) int900;
typedef int __attribute__ ((bitwidth(901))) int901;
typedef int __attribute__ ((bitwidth(902))) int902;
typedef int __attribute__ ((bitwidth(903))) int903;
typedef int __attribute__ ((bitwidth(904))) int904;
typedef int __attribute__ ((bitwidth(905))) int905;
typedef int __attribute__ ((bitwidth(906))) int906;
typedef int __attribute__ ((bitwidth(907))) int907;
typedef int __attribute__ ((bitwidth(908))) int908;
typedef int __attribute__ ((bitwidth(909))) int909;
typedef int __attribute__ ((bitwidth(910))) int910;
typedef int __attribute__ ((bitwidth(911))) int911;
typedef int __attribute__ ((bitwidth(912))) int912;
typedef int __attribute__ ((bitwidth(913))) int913;
typedef int __attribute__ ((bitwidth(914))) int914;
typedef int __attribute__ ((bitwidth(915))) int915;
typedef int __attribute__ ((bitwidth(916))) int916;
typedef int __attribute__ ((bitwidth(917))) int917;
typedef int __attribute__ ((bitwidth(918))) int918;
typedef int __attribute__ ((bitwidth(919))) int919;
typedef int __attribute__ ((bitwidth(920))) int920;
typedef int __attribute__ ((bitwidth(921))) int921;
typedef int __attribute__ ((bitwidth(922))) int922;
typedef int __attribute__ ((bitwidth(923))) int923;
typedef int __attribute__ ((bitwidth(924))) int924;
typedef int __attribute__ ((bitwidth(925))) int925;
typedef int __attribute__ ((bitwidth(926))) int926;
typedef int __attribute__ ((bitwidth(927))) int927;
typedef int __attribute__ ((bitwidth(928))) int928;
typedef int __attribute__ ((bitwidth(929))) int929;
typedef int __attribute__ ((bitwidth(930))) int930;
typedef int __attribute__ ((bitwidth(931))) int931;
typedef int __attribute__ ((bitwidth(932))) int932;
typedef int __attribute__ ((bitwidth(933))) int933;
typedef int __attribute__ ((bitwidth(934))) int934;
typedef int __attribute__ ((bitwidth(935))) int935;
typedef int __attribute__ ((bitwidth(936))) int936;
typedef int __attribute__ ((bitwidth(937))) int937;
typedef int __attribute__ ((bitwidth(938))) int938;
typedef int __attribute__ ((bitwidth(939))) int939;
typedef int __attribute__ ((bitwidth(940))) int940;
typedef int __attribute__ ((bitwidth(941))) int941;
typedef int __attribute__ ((bitwidth(942))) int942;
typedef int __attribute__ ((bitwidth(943))) int943;
typedef int __attribute__ ((bitwidth(944))) int944;
typedef int __attribute__ ((bitwidth(945))) int945;
typedef int __attribute__ ((bitwidth(946))) int946;
typedef int __attribute__ ((bitwidth(947))) int947;
typedef int __attribute__ ((bitwidth(948))) int948;
typedef int __attribute__ ((bitwidth(949))) int949;
typedef int __attribute__ ((bitwidth(950))) int950;
typedef int __attribute__ ((bitwidth(951))) int951;
typedef int __attribute__ ((bitwidth(952))) int952;
typedef int __attribute__ ((bitwidth(953))) int953;
typedef int __attribute__ ((bitwidth(954))) int954;
typedef int __attribute__ ((bitwidth(955))) int955;
typedef int __attribute__ ((bitwidth(956))) int956;
typedef int __attribute__ ((bitwidth(957))) int957;
typedef int __attribute__ ((bitwidth(958))) int958;
typedef int __attribute__ ((bitwidth(959))) int959;
typedef int __attribute__ ((bitwidth(960))) int960;
typedef int __attribute__ ((bitwidth(961))) int961;
typedef int __attribute__ ((bitwidth(962))) int962;
typedef int __attribute__ ((bitwidth(963))) int963;
typedef int __attribute__ ((bitwidth(964))) int964;
typedef int __attribute__ ((bitwidth(965))) int965;
typedef int __attribute__ ((bitwidth(966))) int966;
typedef int __attribute__ ((bitwidth(967))) int967;
typedef int __attribute__ ((bitwidth(968))) int968;
typedef int __attribute__ ((bitwidth(969))) int969;
typedef int __attribute__ ((bitwidth(970))) int970;
typedef int __attribute__ ((bitwidth(971))) int971;
typedef int __attribute__ ((bitwidth(972))) int972;
typedef int __attribute__ ((bitwidth(973))) int973;
typedef int __attribute__ ((bitwidth(974))) int974;
typedef int __attribute__ ((bitwidth(975))) int975;
typedef int __attribute__ ((bitwidth(976))) int976;
typedef int __attribute__ ((bitwidth(977))) int977;
typedef int __attribute__ ((bitwidth(978))) int978;
typedef int __attribute__ ((bitwidth(979))) int979;
typedef int __attribute__ ((bitwidth(980))) int980;
typedef int __attribute__ ((bitwidth(981))) int981;
typedef int __attribute__ ((bitwidth(982))) int982;
typedef int __attribute__ ((bitwidth(983))) int983;
typedef int __attribute__ ((bitwidth(984))) int984;
typedef int __attribute__ ((bitwidth(985))) int985;
typedef int __attribute__ ((bitwidth(986))) int986;
typedef int __attribute__ ((bitwidth(987))) int987;
typedef int __attribute__ ((bitwidth(988))) int988;
typedef int __attribute__ ((bitwidth(989))) int989;
typedef int __attribute__ ((bitwidth(990))) int990;
typedef int __attribute__ ((bitwidth(991))) int991;
typedef int __attribute__ ((bitwidth(992))) int992;
typedef int __attribute__ ((bitwidth(993))) int993;
typedef int __attribute__ ((bitwidth(994))) int994;
typedef int __attribute__ ((bitwidth(995))) int995;
typedef int __attribute__ ((bitwidth(996))) int996;
typedef int __attribute__ ((bitwidth(997))) int997;
typedef int __attribute__ ((bitwidth(998))) int998;
typedef int __attribute__ ((bitwidth(999))) int999;
typedef int __attribute__ ((bitwidth(1000))) int1000;
typedef int __attribute__ ((bitwidth(1001))) int1001;
typedef int __attribute__ ((bitwidth(1002))) int1002;
typedef int __attribute__ ((bitwidth(1003))) int1003;
typedef int __attribute__ ((bitwidth(1004))) int1004;
typedef int __attribute__ ((bitwidth(1005))) int1005;
typedef int __attribute__ ((bitwidth(1006))) int1006;
typedef int __attribute__ ((bitwidth(1007))) int1007;
typedef int __attribute__ ((bitwidth(1008))) int1008;
typedef int __attribute__ ((bitwidth(1009))) int1009;
typedef int __attribute__ ((bitwidth(1010))) int1010;
typedef int __attribute__ ((bitwidth(1011))) int1011;
typedef int __attribute__ ((bitwidth(1012))) int1012;
typedef int __attribute__ ((bitwidth(1013))) int1013;
typedef int __attribute__ ((bitwidth(1014))) int1014;
typedef int __attribute__ ((bitwidth(1015))) int1015;
typedef int __attribute__ ((bitwidth(1016))) int1016;
typedef int __attribute__ ((bitwidth(1017))) int1017;
typedef int __attribute__ ((bitwidth(1018))) int1018;
typedef int __attribute__ ((bitwidth(1019))) int1019;
typedef int __attribute__ ((bitwidth(1020))) int1020;
typedef int __attribute__ ((bitwidth(1021))) int1021;
typedef int __attribute__ ((bitwidth(1022))) int1022;
typedef int __attribute__ ((bitwidth(1023))) int1023;
typedef int __attribute__ ((bitwidth(1024))) int1024;
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt_ext.def" 1
#pragma empty_line
#pragma empty_line
typedef int __attribute__ ((bitwidth(1025))) int1025;
typedef int __attribute__ ((bitwidth(1026))) int1026;
typedef int __attribute__ ((bitwidth(1027))) int1027;
typedef int __attribute__ ((bitwidth(1028))) int1028;
typedef int __attribute__ ((bitwidth(1029))) int1029;
typedef int __attribute__ ((bitwidth(1030))) int1030;
typedef int __attribute__ ((bitwidth(1031))) int1031;
typedef int __attribute__ ((bitwidth(1032))) int1032;
typedef int __attribute__ ((bitwidth(1033))) int1033;
typedef int __attribute__ ((bitwidth(1034))) int1034;
typedef int __attribute__ ((bitwidth(1035))) int1035;
typedef int __attribute__ ((bitwidth(1036))) int1036;
typedef int __attribute__ ((bitwidth(1037))) int1037;
typedef int __attribute__ ((bitwidth(1038))) int1038;
typedef int __attribute__ ((bitwidth(1039))) int1039;
typedef int __attribute__ ((bitwidth(1040))) int1040;
typedef int __attribute__ ((bitwidth(1041))) int1041;
typedef int __attribute__ ((bitwidth(1042))) int1042;
typedef int __attribute__ ((bitwidth(1043))) int1043;
typedef int __attribute__ ((bitwidth(1044))) int1044;
typedef int __attribute__ ((bitwidth(1045))) int1045;
typedef int __attribute__ ((bitwidth(1046))) int1046;
typedef int __attribute__ ((bitwidth(1047))) int1047;
typedef int __attribute__ ((bitwidth(1048))) int1048;
typedef int __attribute__ ((bitwidth(1049))) int1049;
typedef int __attribute__ ((bitwidth(1050))) int1050;
typedef int __attribute__ ((bitwidth(1051))) int1051;
typedef int __attribute__ ((bitwidth(1052))) int1052;
typedef int __attribute__ ((bitwidth(1053))) int1053;
typedef int __attribute__ ((bitwidth(1054))) int1054;
typedef int __attribute__ ((bitwidth(1055))) int1055;
typedef int __attribute__ ((bitwidth(1056))) int1056;
typedef int __attribute__ ((bitwidth(1057))) int1057;
typedef int __attribute__ ((bitwidth(1058))) int1058;
typedef int __attribute__ ((bitwidth(1059))) int1059;
typedef int __attribute__ ((bitwidth(1060))) int1060;
typedef int __attribute__ ((bitwidth(1061))) int1061;
typedef int __attribute__ ((bitwidth(1062))) int1062;
typedef int __attribute__ ((bitwidth(1063))) int1063;
typedef int __attribute__ ((bitwidth(1064))) int1064;
typedef int __attribute__ ((bitwidth(1065))) int1065;
typedef int __attribute__ ((bitwidth(1066))) int1066;
typedef int __attribute__ ((bitwidth(1067))) int1067;
typedef int __attribute__ ((bitwidth(1068))) int1068;
typedef int __attribute__ ((bitwidth(1069))) int1069;
typedef int __attribute__ ((bitwidth(1070))) int1070;
typedef int __attribute__ ((bitwidth(1071))) int1071;
typedef int __attribute__ ((bitwidth(1072))) int1072;
typedef int __attribute__ ((bitwidth(1073))) int1073;
typedef int __attribute__ ((bitwidth(1074))) int1074;
typedef int __attribute__ ((bitwidth(1075))) int1075;
typedef int __attribute__ ((bitwidth(1076))) int1076;
typedef int __attribute__ ((bitwidth(1077))) int1077;
typedef int __attribute__ ((bitwidth(1078))) int1078;
typedef int __attribute__ ((bitwidth(1079))) int1079;
typedef int __attribute__ ((bitwidth(1080))) int1080;
typedef int __attribute__ ((bitwidth(1081))) int1081;
typedef int __attribute__ ((bitwidth(1082))) int1082;
typedef int __attribute__ ((bitwidth(1083))) int1083;
typedef int __attribute__ ((bitwidth(1084))) int1084;
typedef int __attribute__ ((bitwidth(1085))) int1085;
typedef int __attribute__ ((bitwidth(1086))) int1086;
typedef int __attribute__ ((bitwidth(1087))) int1087;
typedef int __attribute__ ((bitwidth(1088))) int1088;
typedef int __attribute__ ((bitwidth(1089))) int1089;
typedef int __attribute__ ((bitwidth(1090))) int1090;
typedef int __attribute__ ((bitwidth(1091))) int1091;
typedef int __attribute__ ((bitwidth(1092))) int1092;
typedef int __attribute__ ((bitwidth(1093))) int1093;
typedef int __attribute__ ((bitwidth(1094))) int1094;
typedef int __attribute__ ((bitwidth(1095))) int1095;
typedef int __attribute__ ((bitwidth(1096))) int1096;
typedef int __attribute__ ((bitwidth(1097))) int1097;
typedef int __attribute__ ((bitwidth(1098))) int1098;
typedef int __attribute__ ((bitwidth(1099))) int1099;
typedef int __attribute__ ((bitwidth(1100))) int1100;
typedef int __attribute__ ((bitwidth(1101))) int1101;
typedef int __attribute__ ((bitwidth(1102))) int1102;
typedef int __attribute__ ((bitwidth(1103))) int1103;
typedef int __attribute__ ((bitwidth(1104))) int1104;
typedef int __attribute__ ((bitwidth(1105))) int1105;
typedef int __attribute__ ((bitwidth(1106))) int1106;
typedef int __attribute__ ((bitwidth(1107))) int1107;
typedef int __attribute__ ((bitwidth(1108))) int1108;
typedef int __attribute__ ((bitwidth(1109))) int1109;
typedef int __attribute__ ((bitwidth(1110))) int1110;
typedef int __attribute__ ((bitwidth(1111))) int1111;
typedef int __attribute__ ((bitwidth(1112))) int1112;
typedef int __attribute__ ((bitwidth(1113))) int1113;
typedef int __attribute__ ((bitwidth(1114))) int1114;
typedef int __attribute__ ((bitwidth(1115))) int1115;
typedef int __attribute__ ((bitwidth(1116))) int1116;
typedef int __attribute__ ((bitwidth(1117))) int1117;
typedef int __attribute__ ((bitwidth(1118))) int1118;
typedef int __attribute__ ((bitwidth(1119))) int1119;
typedef int __attribute__ ((bitwidth(1120))) int1120;
typedef int __attribute__ ((bitwidth(1121))) int1121;
typedef int __attribute__ ((bitwidth(1122))) int1122;
typedef int __attribute__ ((bitwidth(1123))) int1123;
typedef int __attribute__ ((bitwidth(1124))) int1124;
typedef int __attribute__ ((bitwidth(1125))) int1125;
typedef int __attribute__ ((bitwidth(1126))) int1126;
typedef int __attribute__ ((bitwidth(1127))) int1127;
typedef int __attribute__ ((bitwidth(1128))) int1128;
typedef int __attribute__ ((bitwidth(1129))) int1129;
typedef int __attribute__ ((bitwidth(1130))) int1130;
typedef int __attribute__ ((bitwidth(1131))) int1131;
typedef int __attribute__ ((bitwidth(1132))) int1132;
typedef int __attribute__ ((bitwidth(1133))) int1133;
typedef int __attribute__ ((bitwidth(1134))) int1134;
typedef int __attribute__ ((bitwidth(1135))) int1135;
typedef int __attribute__ ((bitwidth(1136))) int1136;
typedef int __attribute__ ((bitwidth(1137))) int1137;
typedef int __attribute__ ((bitwidth(1138))) int1138;
typedef int __attribute__ ((bitwidth(1139))) int1139;
typedef int __attribute__ ((bitwidth(1140))) int1140;
typedef int __attribute__ ((bitwidth(1141))) int1141;
typedef int __attribute__ ((bitwidth(1142))) int1142;
typedef int __attribute__ ((bitwidth(1143))) int1143;
typedef int __attribute__ ((bitwidth(1144))) int1144;
typedef int __attribute__ ((bitwidth(1145))) int1145;
typedef int __attribute__ ((bitwidth(1146))) int1146;
typedef int __attribute__ ((bitwidth(1147))) int1147;
typedef int __attribute__ ((bitwidth(1148))) int1148;
typedef int __attribute__ ((bitwidth(1149))) int1149;
typedef int __attribute__ ((bitwidth(1150))) int1150;
typedef int __attribute__ ((bitwidth(1151))) int1151;
typedef int __attribute__ ((bitwidth(1152))) int1152;
typedef int __attribute__ ((bitwidth(1153))) int1153;
typedef int __attribute__ ((bitwidth(1154))) int1154;
typedef int __attribute__ ((bitwidth(1155))) int1155;
typedef int __attribute__ ((bitwidth(1156))) int1156;
typedef int __attribute__ ((bitwidth(1157))) int1157;
typedef int __attribute__ ((bitwidth(1158))) int1158;
typedef int __attribute__ ((bitwidth(1159))) int1159;
typedef int __attribute__ ((bitwidth(1160))) int1160;
typedef int __attribute__ ((bitwidth(1161))) int1161;
typedef int __attribute__ ((bitwidth(1162))) int1162;
typedef int __attribute__ ((bitwidth(1163))) int1163;
typedef int __attribute__ ((bitwidth(1164))) int1164;
typedef int __attribute__ ((bitwidth(1165))) int1165;
typedef int __attribute__ ((bitwidth(1166))) int1166;
typedef int __attribute__ ((bitwidth(1167))) int1167;
typedef int __attribute__ ((bitwidth(1168))) int1168;
typedef int __attribute__ ((bitwidth(1169))) int1169;
typedef int __attribute__ ((bitwidth(1170))) int1170;
typedef int __attribute__ ((bitwidth(1171))) int1171;
typedef int __attribute__ ((bitwidth(1172))) int1172;
typedef int __attribute__ ((bitwidth(1173))) int1173;
typedef int __attribute__ ((bitwidth(1174))) int1174;
typedef int __attribute__ ((bitwidth(1175))) int1175;
typedef int __attribute__ ((bitwidth(1176))) int1176;
typedef int __attribute__ ((bitwidth(1177))) int1177;
typedef int __attribute__ ((bitwidth(1178))) int1178;
typedef int __attribute__ ((bitwidth(1179))) int1179;
typedef int __attribute__ ((bitwidth(1180))) int1180;
typedef int __attribute__ ((bitwidth(1181))) int1181;
typedef int __attribute__ ((bitwidth(1182))) int1182;
typedef int __attribute__ ((bitwidth(1183))) int1183;
typedef int __attribute__ ((bitwidth(1184))) int1184;
typedef int __attribute__ ((bitwidth(1185))) int1185;
typedef int __attribute__ ((bitwidth(1186))) int1186;
typedef int __attribute__ ((bitwidth(1187))) int1187;
typedef int __attribute__ ((bitwidth(1188))) int1188;
typedef int __attribute__ ((bitwidth(1189))) int1189;
typedef int __attribute__ ((bitwidth(1190))) int1190;
typedef int __attribute__ ((bitwidth(1191))) int1191;
typedef int __attribute__ ((bitwidth(1192))) int1192;
typedef int __attribute__ ((bitwidth(1193))) int1193;
typedef int __attribute__ ((bitwidth(1194))) int1194;
typedef int __attribute__ ((bitwidth(1195))) int1195;
typedef int __attribute__ ((bitwidth(1196))) int1196;
typedef int __attribute__ ((bitwidth(1197))) int1197;
typedef int __attribute__ ((bitwidth(1198))) int1198;
typedef int __attribute__ ((bitwidth(1199))) int1199;
typedef int __attribute__ ((bitwidth(1200))) int1200;
typedef int __attribute__ ((bitwidth(1201))) int1201;
typedef int __attribute__ ((bitwidth(1202))) int1202;
typedef int __attribute__ ((bitwidth(1203))) int1203;
typedef int __attribute__ ((bitwidth(1204))) int1204;
typedef int __attribute__ ((bitwidth(1205))) int1205;
typedef int __attribute__ ((bitwidth(1206))) int1206;
typedef int __attribute__ ((bitwidth(1207))) int1207;
typedef int __attribute__ ((bitwidth(1208))) int1208;
typedef int __attribute__ ((bitwidth(1209))) int1209;
typedef int __attribute__ ((bitwidth(1210))) int1210;
typedef int __attribute__ ((bitwidth(1211))) int1211;
typedef int __attribute__ ((bitwidth(1212))) int1212;
typedef int __attribute__ ((bitwidth(1213))) int1213;
typedef int __attribute__ ((bitwidth(1214))) int1214;
typedef int __attribute__ ((bitwidth(1215))) int1215;
typedef int __attribute__ ((bitwidth(1216))) int1216;
typedef int __attribute__ ((bitwidth(1217))) int1217;
typedef int __attribute__ ((bitwidth(1218))) int1218;
typedef int __attribute__ ((bitwidth(1219))) int1219;
typedef int __attribute__ ((bitwidth(1220))) int1220;
typedef int __attribute__ ((bitwidth(1221))) int1221;
typedef int __attribute__ ((bitwidth(1222))) int1222;
typedef int __attribute__ ((bitwidth(1223))) int1223;
typedef int __attribute__ ((bitwidth(1224))) int1224;
typedef int __attribute__ ((bitwidth(1225))) int1225;
typedef int __attribute__ ((bitwidth(1226))) int1226;
typedef int __attribute__ ((bitwidth(1227))) int1227;
typedef int __attribute__ ((bitwidth(1228))) int1228;
typedef int __attribute__ ((bitwidth(1229))) int1229;
typedef int __attribute__ ((bitwidth(1230))) int1230;
typedef int __attribute__ ((bitwidth(1231))) int1231;
typedef int __attribute__ ((bitwidth(1232))) int1232;
typedef int __attribute__ ((bitwidth(1233))) int1233;
typedef int __attribute__ ((bitwidth(1234))) int1234;
typedef int __attribute__ ((bitwidth(1235))) int1235;
typedef int __attribute__ ((bitwidth(1236))) int1236;
typedef int __attribute__ ((bitwidth(1237))) int1237;
typedef int __attribute__ ((bitwidth(1238))) int1238;
typedef int __attribute__ ((bitwidth(1239))) int1239;
typedef int __attribute__ ((bitwidth(1240))) int1240;
typedef int __attribute__ ((bitwidth(1241))) int1241;
typedef int __attribute__ ((bitwidth(1242))) int1242;
typedef int __attribute__ ((bitwidth(1243))) int1243;
typedef int __attribute__ ((bitwidth(1244))) int1244;
typedef int __attribute__ ((bitwidth(1245))) int1245;
typedef int __attribute__ ((bitwidth(1246))) int1246;
typedef int __attribute__ ((bitwidth(1247))) int1247;
typedef int __attribute__ ((bitwidth(1248))) int1248;
typedef int __attribute__ ((bitwidth(1249))) int1249;
typedef int __attribute__ ((bitwidth(1250))) int1250;
typedef int __attribute__ ((bitwidth(1251))) int1251;
typedef int __attribute__ ((bitwidth(1252))) int1252;
typedef int __attribute__ ((bitwidth(1253))) int1253;
typedef int __attribute__ ((bitwidth(1254))) int1254;
typedef int __attribute__ ((bitwidth(1255))) int1255;
typedef int __attribute__ ((bitwidth(1256))) int1256;
typedef int __attribute__ ((bitwidth(1257))) int1257;
typedef int __attribute__ ((bitwidth(1258))) int1258;
typedef int __attribute__ ((bitwidth(1259))) int1259;
typedef int __attribute__ ((bitwidth(1260))) int1260;
typedef int __attribute__ ((bitwidth(1261))) int1261;
typedef int __attribute__ ((bitwidth(1262))) int1262;
typedef int __attribute__ ((bitwidth(1263))) int1263;
typedef int __attribute__ ((bitwidth(1264))) int1264;
typedef int __attribute__ ((bitwidth(1265))) int1265;
typedef int __attribute__ ((bitwidth(1266))) int1266;
typedef int __attribute__ ((bitwidth(1267))) int1267;
typedef int __attribute__ ((bitwidth(1268))) int1268;
typedef int __attribute__ ((bitwidth(1269))) int1269;
typedef int __attribute__ ((bitwidth(1270))) int1270;
typedef int __attribute__ ((bitwidth(1271))) int1271;
typedef int __attribute__ ((bitwidth(1272))) int1272;
typedef int __attribute__ ((bitwidth(1273))) int1273;
typedef int __attribute__ ((bitwidth(1274))) int1274;
typedef int __attribute__ ((bitwidth(1275))) int1275;
typedef int __attribute__ ((bitwidth(1276))) int1276;
typedef int __attribute__ ((bitwidth(1277))) int1277;
typedef int __attribute__ ((bitwidth(1278))) int1278;
typedef int __attribute__ ((bitwidth(1279))) int1279;
typedef int __attribute__ ((bitwidth(1280))) int1280;
typedef int __attribute__ ((bitwidth(1281))) int1281;
typedef int __attribute__ ((bitwidth(1282))) int1282;
typedef int __attribute__ ((bitwidth(1283))) int1283;
typedef int __attribute__ ((bitwidth(1284))) int1284;
typedef int __attribute__ ((bitwidth(1285))) int1285;
typedef int __attribute__ ((bitwidth(1286))) int1286;
typedef int __attribute__ ((bitwidth(1287))) int1287;
typedef int __attribute__ ((bitwidth(1288))) int1288;
typedef int __attribute__ ((bitwidth(1289))) int1289;
typedef int __attribute__ ((bitwidth(1290))) int1290;
typedef int __attribute__ ((bitwidth(1291))) int1291;
typedef int __attribute__ ((bitwidth(1292))) int1292;
typedef int __attribute__ ((bitwidth(1293))) int1293;
typedef int __attribute__ ((bitwidth(1294))) int1294;
typedef int __attribute__ ((bitwidth(1295))) int1295;
typedef int __attribute__ ((bitwidth(1296))) int1296;
typedef int __attribute__ ((bitwidth(1297))) int1297;
typedef int __attribute__ ((bitwidth(1298))) int1298;
typedef int __attribute__ ((bitwidth(1299))) int1299;
typedef int __attribute__ ((bitwidth(1300))) int1300;
typedef int __attribute__ ((bitwidth(1301))) int1301;
typedef int __attribute__ ((bitwidth(1302))) int1302;
typedef int __attribute__ ((bitwidth(1303))) int1303;
typedef int __attribute__ ((bitwidth(1304))) int1304;
typedef int __attribute__ ((bitwidth(1305))) int1305;
typedef int __attribute__ ((bitwidth(1306))) int1306;
typedef int __attribute__ ((bitwidth(1307))) int1307;
typedef int __attribute__ ((bitwidth(1308))) int1308;
typedef int __attribute__ ((bitwidth(1309))) int1309;
typedef int __attribute__ ((bitwidth(1310))) int1310;
typedef int __attribute__ ((bitwidth(1311))) int1311;
typedef int __attribute__ ((bitwidth(1312))) int1312;
typedef int __attribute__ ((bitwidth(1313))) int1313;
typedef int __attribute__ ((bitwidth(1314))) int1314;
typedef int __attribute__ ((bitwidth(1315))) int1315;
typedef int __attribute__ ((bitwidth(1316))) int1316;
typedef int __attribute__ ((bitwidth(1317))) int1317;
typedef int __attribute__ ((bitwidth(1318))) int1318;
typedef int __attribute__ ((bitwidth(1319))) int1319;
typedef int __attribute__ ((bitwidth(1320))) int1320;
typedef int __attribute__ ((bitwidth(1321))) int1321;
typedef int __attribute__ ((bitwidth(1322))) int1322;
typedef int __attribute__ ((bitwidth(1323))) int1323;
typedef int __attribute__ ((bitwidth(1324))) int1324;
typedef int __attribute__ ((bitwidth(1325))) int1325;
typedef int __attribute__ ((bitwidth(1326))) int1326;
typedef int __attribute__ ((bitwidth(1327))) int1327;
typedef int __attribute__ ((bitwidth(1328))) int1328;
typedef int __attribute__ ((bitwidth(1329))) int1329;
typedef int __attribute__ ((bitwidth(1330))) int1330;
typedef int __attribute__ ((bitwidth(1331))) int1331;
typedef int __attribute__ ((bitwidth(1332))) int1332;
typedef int __attribute__ ((bitwidth(1333))) int1333;
typedef int __attribute__ ((bitwidth(1334))) int1334;
typedef int __attribute__ ((bitwidth(1335))) int1335;
typedef int __attribute__ ((bitwidth(1336))) int1336;
typedef int __attribute__ ((bitwidth(1337))) int1337;
typedef int __attribute__ ((bitwidth(1338))) int1338;
typedef int __attribute__ ((bitwidth(1339))) int1339;
typedef int __attribute__ ((bitwidth(1340))) int1340;
typedef int __attribute__ ((bitwidth(1341))) int1341;
typedef int __attribute__ ((bitwidth(1342))) int1342;
typedef int __attribute__ ((bitwidth(1343))) int1343;
typedef int __attribute__ ((bitwidth(1344))) int1344;
typedef int __attribute__ ((bitwidth(1345))) int1345;
typedef int __attribute__ ((bitwidth(1346))) int1346;
typedef int __attribute__ ((bitwidth(1347))) int1347;
typedef int __attribute__ ((bitwidth(1348))) int1348;
typedef int __attribute__ ((bitwidth(1349))) int1349;
typedef int __attribute__ ((bitwidth(1350))) int1350;
typedef int __attribute__ ((bitwidth(1351))) int1351;
typedef int __attribute__ ((bitwidth(1352))) int1352;
typedef int __attribute__ ((bitwidth(1353))) int1353;
typedef int __attribute__ ((bitwidth(1354))) int1354;
typedef int __attribute__ ((bitwidth(1355))) int1355;
typedef int __attribute__ ((bitwidth(1356))) int1356;
typedef int __attribute__ ((bitwidth(1357))) int1357;
typedef int __attribute__ ((bitwidth(1358))) int1358;
typedef int __attribute__ ((bitwidth(1359))) int1359;
typedef int __attribute__ ((bitwidth(1360))) int1360;
typedef int __attribute__ ((bitwidth(1361))) int1361;
typedef int __attribute__ ((bitwidth(1362))) int1362;
typedef int __attribute__ ((bitwidth(1363))) int1363;
typedef int __attribute__ ((bitwidth(1364))) int1364;
typedef int __attribute__ ((bitwidth(1365))) int1365;
typedef int __attribute__ ((bitwidth(1366))) int1366;
typedef int __attribute__ ((bitwidth(1367))) int1367;
typedef int __attribute__ ((bitwidth(1368))) int1368;
typedef int __attribute__ ((bitwidth(1369))) int1369;
typedef int __attribute__ ((bitwidth(1370))) int1370;
typedef int __attribute__ ((bitwidth(1371))) int1371;
typedef int __attribute__ ((bitwidth(1372))) int1372;
typedef int __attribute__ ((bitwidth(1373))) int1373;
typedef int __attribute__ ((bitwidth(1374))) int1374;
typedef int __attribute__ ((bitwidth(1375))) int1375;
typedef int __attribute__ ((bitwidth(1376))) int1376;
typedef int __attribute__ ((bitwidth(1377))) int1377;
typedef int __attribute__ ((bitwidth(1378))) int1378;
typedef int __attribute__ ((bitwidth(1379))) int1379;
typedef int __attribute__ ((bitwidth(1380))) int1380;
typedef int __attribute__ ((bitwidth(1381))) int1381;
typedef int __attribute__ ((bitwidth(1382))) int1382;
typedef int __attribute__ ((bitwidth(1383))) int1383;
typedef int __attribute__ ((bitwidth(1384))) int1384;
typedef int __attribute__ ((bitwidth(1385))) int1385;
typedef int __attribute__ ((bitwidth(1386))) int1386;
typedef int __attribute__ ((bitwidth(1387))) int1387;
typedef int __attribute__ ((bitwidth(1388))) int1388;
typedef int __attribute__ ((bitwidth(1389))) int1389;
typedef int __attribute__ ((bitwidth(1390))) int1390;
typedef int __attribute__ ((bitwidth(1391))) int1391;
typedef int __attribute__ ((bitwidth(1392))) int1392;
typedef int __attribute__ ((bitwidth(1393))) int1393;
typedef int __attribute__ ((bitwidth(1394))) int1394;
typedef int __attribute__ ((bitwidth(1395))) int1395;
typedef int __attribute__ ((bitwidth(1396))) int1396;
typedef int __attribute__ ((bitwidth(1397))) int1397;
typedef int __attribute__ ((bitwidth(1398))) int1398;
typedef int __attribute__ ((bitwidth(1399))) int1399;
typedef int __attribute__ ((bitwidth(1400))) int1400;
typedef int __attribute__ ((bitwidth(1401))) int1401;
typedef int __attribute__ ((bitwidth(1402))) int1402;
typedef int __attribute__ ((bitwidth(1403))) int1403;
typedef int __attribute__ ((bitwidth(1404))) int1404;
typedef int __attribute__ ((bitwidth(1405))) int1405;
typedef int __attribute__ ((bitwidth(1406))) int1406;
typedef int __attribute__ ((bitwidth(1407))) int1407;
typedef int __attribute__ ((bitwidth(1408))) int1408;
typedef int __attribute__ ((bitwidth(1409))) int1409;
typedef int __attribute__ ((bitwidth(1410))) int1410;
typedef int __attribute__ ((bitwidth(1411))) int1411;
typedef int __attribute__ ((bitwidth(1412))) int1412;
typedef int __attribute__ ((bitwidth(1413))) int1413;
typedef int __attribute__ ((bitwidth(1414))) int1414;
typedef int __attribute__ ((bitwidth(1415))) int1415;
typedef int __attribute__ ((bitwidth(1416))) int1416;
typedef int __attribute__ ((bitwidth(1417))) int1417;
typedef int __attribute__ ((bitwidth(1418))) int1418;
typedef int __attribute__ ((bitwidth(1419))) int1419;
typedef int __attribute__ ((bitwidth(1420))) int1420;
typedef int __attribute__ ((bitwidth(1421))) int1421;
typedef int __attribute__ ((bitwidth(1422))) int1422;
typedef int __attribute__ ((bitwidth(1423))) int1423;
typedef int __attribute__ ((bitwidth(1424))) int1424;
typedef int __attribute__ ((bitwidth(1425))) int1425;
typedef int __attribute__ ((bitwidth(1426))) int1426;
typedef int __attribute__ ((bitwidth(1427))) int1427;
typedef int __attribute__ ((bitwidth(1428))) int1428;
typedef int __attribute__ ((bitwidth(1429))) int1429;
typedef int __attribute__ ((bitwidth(1430))) int1430;
typedef int __attribute__ ((bitwidth(1431))) int1431;
typedef int __attribute__ ((bitwidth(1432))) int1432;
typedef int __attribute__ ((bitwidth(1433))) int1433;
typedef int __attribute__ ((bitwidth(1434))) int1434;
typedef int __attribute__ ((bitwidth(1435))) int1435;
typedef int __attribute__ ((bitwidth(1436))) int1436;
typedef int __attribute__ ((bitwidth(1437))) int1437;
typedef int __attribute__ ((bitwidth(1438))) int1438;
typedef int __attribute__ ((bitwidth(1439))) int1439;
typedef int __attribute__ ((bitwidth(1440))) int1440;
typedef int __attribute__ ((bitwidth(1441))) int1441;
typedef int __attribute__ ((bitwidth(1442))) int1442;
typedef int __attribute__ ((bitwidth(1443))) int1443;
typedef int __attribute__ ((bitwidth(1444))) int1444;
typedef int __attribute__ ((bitwidth(1445))) int1445;
typedef int __attribute__ ((bitwidth(1446))) int1446;
typedef int __attribute__ ((bitwidth(1447))) int1447;
typedef int __attribute__ ((bitwidth(1448))) int1448;
typedef int __attribute__ ((bitwidth(1449))) int1449;
typedef int __attribute__ ((bitwidth(1450))) int1450;
typedef int __attribute__ ((bitwidth(1451))) int1451;
typedef int __attribute__ ((bitwidth(1452))) int1452;
typedef int __attribute__ ((bitwidth(1453))) int1453;
typedef int __attribute__ ((bitwidth(1454))) int1454;
typedef int __attribute__ ((bitwidth(1455))) int1455;
typedef int __attribute__ ((bitwidth(1456))) int1456;
typedef int __attribute__ ((bitwidth(1457))) int1457;
typedef int __attribute__ ((bitwidth(1458))) int1458;
typedef int __attribute__ ((bitwidth(1459))) int1459;
typedef int __attribute__ ((bitwidth(1460))) int1460;
typedef int __attribute__ ((bitwidth(1461))) int1461;
typedef int __attribute__ ((bitwidth(1462))) int1462;
typedef int __attribute__ ((bitwidth(1463))) int1463;
typedef int __attribute__ ((bitwidth(1464))) int1464;
typedef int __attribute__ ((bitwidth(1465))) int1465;
typedef int __attribute__ ((bitwidth(1466))) int1466;
typedef int __attribute__ ((bitwidth(1467))) int1467;
typedef int __attribute__ ((bitwidth(1468))) int1468;
typedef int __attribute__ ((bitwidth(1469))) int1469;
typedef int __attribute__ ((bitwidth(1470))) int1470;
typedef int __attribute__ ((bitwidth(1471))) int1471;
typedef int __attribute__ ((bitwidth(1472))) int1472;
typedef int __attribute__ ((bitwidth(1473))) int1473;
typedef int __attribute__ ((bitwidth(1474))) int1474;
typedef int __attribute__ ((bitwidth(1475))) int1475;
typedef int __attribute__ ((bitwidth(1476))) int1476;
typedef int __attribute__ ((bitwidth(1477))) int1477;
typedef int __attribute__ ((bitwidth(1478))) int1478;
typedef int __attribute__ ((bitwidth(1479))) int1479;
typedef int __attribute__ ((bitwidth(1480))) int1480;
typedef int __attribute__ ((bitwidth(1481))) int1481;
typedef int __attribute__ ((bitwidth(1482))) int1482;
typedef int __attribute__ ((bitwidth(1483))) int1483;
typedef int __attribute__ ((bitwidth(1484))) int1484;
typedef int __attribute__ ((bitwidth(1485))) int1485;
typedef int __attribute__ ((bitwidth(1486))) int1486;
typedef int __attribute__ ((bitwidth(1487))) int1487;
typedef int __attribute__ ((bitwidth(1488))) int1488;
typedef int __attribute__ ((bitwidth(1489))) int1489;
typedef int __attribute__ ((bitwidth(1490))) int1490;
typedef int __attribute__ ((bitwidth(1491))) int1491;
typedef int __attribute__ ((bitwidth(1492))) int1492;
typedef int __attribute__ ((bitwidth(1493))) int1493;
typedef int __attribute__ ((bitwidth(1494))) int1494;
typedef int __attribute__ ((bitwidth(1495))) int1495;
typedef int __attribute__ ((bitwidth(1496))) int1496;
typedef int __attribute__ ((bitwidth(1497))) int1497;
typedef int __attribute__ ((bitwidth(1498))) int1498;
typedef int __attribute__ ((bitwidth(1499))) int1499;
typedef int __attribute__ ((bitwidth(1500))) int1500;
typedef int __attribute__ ((bitwidth(1501))) int1501;
typedef int __attribute__ ((bitwidth(1502))) int1502;
typedef int __attribute__ ((bitwidth(1503))) int1503;
typedef int __attribute__ ((bitwidth(1504))) int1504;
typedef int __attribute__ ((bitwidth(1505))) int1505;
typedef int __attribute__ ((bitwidth(1506))) int1506;
typedef int __attribute__ ((bitwidth(1507))) int1507;
typedef int __attribute__ ((bitwidth(1508))) int1508;
typedef int __attribute__ ((bitwidth(1509))) int1509;
typedef int __attribute__ ((bitwidth(1510))) int1510;
typedef int __attribute__ ((bitwidth(1511))) int1511;
typedef int __attribute__ ((bitwidth(1512))) int1512;
typedef int __attribute__ ((bitwidth(1513))) int1513;
typedef int __attribute__ ((bitwidth(1514))) int1514;
typedef int __attribute__ ((bitwidth(1515))) int1515;
typedef int __attribute__ ((bitwidth(1516))) int1516;
typedef int __attribute__ ((bitwidth(1517))) int1517;
typedef int __attribute__ ((bitwidth(1518))) int1518;
typedef int __attribute__ ((bitwidth(1519))) int1519;
typedef int __attribute__ ((bitwidth(1520))) int1520;
typedef int __attribute__ ((bitwidth(1521))) int1521;
typedef int __attribute__ ((bitwidth(1522))) int1522;
typedef int __attribute__ ((bitwidth(1523))) int1523;
typedef int __attribute__ ((bitwidth(1524))) int1524;
typedef int __attribute__ ((bitwidth(1525))) int1525;
typedef int __attribute__ ((bitwidth(1526))) int1526;
typedef int __attribute__ ((bitwidth(1527))) int1527;
typedef int __attribute__ ((bitwidth(1528))) int1528;
typedef int __attribute__ ((bitwidth(1529))) int1529;
typedef int __attribute__ ((bitwidth(1530))) int1530;
typedef int __attribute__ ((bitwidth(1531))) int1531;
typedef int __attribute__ ((bitwidth(1532))) int1532;
typedef int __attribute__ ((bitwidth(1533))) int1533;
typedef int __attribute__ ((bitwidth(1534))) int1534;
typedef int __attribute__ ((bitwidth(1535))) int1535;
typedef int __attribute__ ((bitwidth(1536))) int1536;
typedef int __attribute__ ((bitwidth(1537))) int1537;
typedef int __attribute__ ((bitwidth(1538))) int1538;
typedef int __attribute__ ((bitwidth(1539))) int1539;
typedef int __attribute__ ((bitwidth(1540))) int1540;
typedef int __attribute__ ((bitwidth(1541))) int1541;
typedef int __attribute__ ((bitwidth(1542))) int1542;
typedef int __attribute__ ((bitwidth(1543))) int1543;
typedef int __attribute__ ((bitwidth(1544))) int1544;
typedef int __attribute__ ((bitwidth(1545))) int1545;
typedef int __attribute__ ((bitwidth(1546))) int1546;
typedef int __attribute__ ((bitwidth(1547))) int1547;
typedef int __attribute__ ((bitwidth(1548))) int1548;
typedef int __attribute__ ((bitwidth(1549))) int1549;
typedef int __attribute__ ((bitwidth(1550))) int1550;
typedef int __attribute__ ((bitwidth(1551))) int1551;
typedef int __attribute__ ((bitwidth(1552))) int1552;
typedef int __attribute__ ((bitwidth(1553))) int1553;
typedef int __attribute__ ((bitwidth(1554))) int1554;
typedef int __attribute__ ((bitwidth(1555))) int1555;
typedef int __attribute__ ((bitwidth(1556))) int1556;
typedef int __attribute__ ((bitwidth(1557))) int1557;
typedef int __attribute__ ((bitwidth(1558))) int1558;
typedef int __attribute__ ((bitwidth(1559))) int1559;
typedef int __attribute__ ((bitwidth(1560))) int1560;
typedef int __attribute__ ((bitwidth(1561))) int1561;
typedef int __attribute__ ((bitwidth(1562))) int1562;
typedef int __attribute__ ((bitwidth(1563))) int1563;
typedef int __attribute__ ((bitwidth(1564))) int1564;
typedef int __attribute__ ((bitwidth(1565))) int1565;
typedef int __attribute__ ((bitwidth(1566))) int1566;
typedef int __attribute__ ((bitwidth(1567))) int1567;
typedef int __attribute__ ((bitwidth(1568))) int1568;
typedef int __attribute__ ((bitwidth(1569))) int1569;
typedef int __attribute__ ((bitwidth(1570))) int1570;
typedef int __attribute__ ((bitwidth(1571))) int1571;
typedef int __attribute__ ((bitwidth(1572))) int1572;
typedef int __attribute__ ((bitwidth(1573))) int1573;
typedef int __attribute__ ((bitwidth(1574))) int1574;
typedef int __attribute__ ((bitwidth(1575))) int1575;
typedef int __attribute__ ((bitwidth(1576))) int1576;
typedef int __attribute__ ((bitwidth(1577))) int1577;
typedef int __attribute__ ((bitwidth(1578))) int1578;
typedef int __attribute__ ((bitwidth(1579))) int1579;
typedef int __attribute__ ((bitwidth(1580))) int1580;
typedef int __attribute__ ((bitwidth(1581))) int1581;
typedef int __attribute__ ((bitwidth(1582))) int1582;
typedef int __attribute__ ((bitwidth(1583))) int1583;
typedef int __attribute__ ((bitwidth(1584))) int1584;
typedef int __attribute__ ((bitwidth(1585))) int1585;
typedef int __attribute__ ((bitwidth(1586))) int1586;
typedef int __attribute__ ((bitwidth(1587))) int1587;
typedef int __attribute__ ((bitwidth(1588))) int1588;
typedef int __attribute__ ((bitwidth(1589))) int1589;
typedef int __attribute__ ((bitwidth(1590))) int1590;
typedef int __attribute__ ((bitwidth(1591))) int1591;
typedef int __attribute__ ((bitwidth(1592))) int1592;
typedef int __attribute__ ((bitwidth(1593))) int1593;
typedef int __attribute__ ((bitwidth(1594))) int1594;
typedef int __attribute__ ((bitwidth(1595))) int1595;
typedef int __attribute__ ((bitwidth(1596))) int1596;
typedef int __attribute__ ((bitwidth(1597))) int1597;
typedef int __attribute__ ((bitwidth(1598))) int1598;
typedef int __attribute__ ((bitwidth(1599))) int1599;
typedef int __attribute__ ((bitwidth(1600))) int1600;
typedef int __attribute__ ((bitwidth(1601))) int1601;
typedef int __attribute__ ((bitwidth(1602))) int1602;
typedef int __attribute__ ((bitwidth(1603))) int1603;
typedef int __attribute__ ((bitwidth(1604))) int1604;
typedef int __attribute__ ((bitwidth(1605))) int1605;
typedef int __attribute__ ((bitwidth(1606))) int1606;
typedef int __attribute__ ((bitwidth(1607))) int1607;
typedef int __attribute__ ((bitwidth(1608))) int1608;
typedef int __attribute__ ((bitwidth(1609))) int1609;
typedef int __attribute__ ((bitwidth(1610))) int1610;
typedef int __attribute__ ((bitwidth(1611))) int1611;
typedef int __attribute__ ((bitwidth(1612))) int1612;
typedef int __attribute__ ((bitwidth(1613))) int1613;
typedef int __attribute__ ((bitwidth(1614))) int1614;
typedef int __attribute__ ((bitwidth(1615))) int1615;
typedef int __attribute__ ((bitwidth(1616))) int1616;
typedef int __attribute__ ((bitwidth(1617))) int1617;
typedef int __attribute__ ((bitwidth(1618))) int1618;
typedef int __attribute__ ((bitwidth(1619))) int1619;
typedef int __attribute__ ((bitwidth(1620))) int1620;
typedef int __attribute__ ((bitwidth(1621))) int1621;
typedef int __attribute__ ((bitwidth(1622))) int1622;
typedef int __attribute__ ((bitwidth(1623))) int1623;
typedef int __attribute__ ((bitwidth(1624))) int1624;
typedef int __attribute__ ((bitwidth(1625))) int1625;
typedef int __attribute__ ((bitwidth(1626))) int1626;
typedef int __attribute__ ((bitwidth(1627))) int1627;
typedef int __attribute__ ((bitwidth(1628))) int1628;
typedef int __attribute__ ((bitwidth(1629))) int1629;
typedef int __attribute__ ((bitwidth(1630))) int1630;
typedef int __attribute__ ((bitwidth(1631))) int1631;
typedef int __attribute__ ((bitwidth(1632))) int1632;
typedef int __attribute__ ((bitwidth(1633))) int1633;
typedef int __attribute__ ((bitwidth(1634))) int1634;
typedef int __attribute__ ((bitwidth(1635))) int1635;
typedef int __attribute__ ((bitwidth(1636))) int1636;
typedef int __attribute__ ((bitwidth(1637))) int1637;
typedef int __attribute__ ((bitwidth(1638))) int1638;
typedef int __attribute__ ((bitwidth(1639))) int1639;
typedef int __attribute__ ((bitwidth(1640))) int1640;
typedef int __attribute__ ((bitwidth(1641))) int1641;
typedef int __attribute__ ((bitwidth(1642))) int1642;
typedef int __attribute__ ((bitwidth(1643))) int1643;
typedef int __attribute__ ((bitwidth(1644))) int1644;
typedef int __attribute__ ((bitwidth(1645))) int1645;
typedef int __attribute__ ((bitwidth(1646))) int1646;
typedef int __attribute__ ((bitwidth(1647))) int1647;
typedef int __attribute__ ((bitwidth(1648))) int1648;
typedef int __attribute__ ((bitwidth(1649))) int1649;
typedef int __attribute__ ((bitwidth(1650))) int1650;
typedef int __attribute__ ((bitwidth(1651))) int1651;
typedef int __attribute__ ((bitwidth(1652))) int1652;
typedef int __attribute__ ((bitwidth(1653))) int1653;
typedef int __attribute__ ((bitwidth(1654))) int1654;
typedef int __attribute__ ((bitwidth(1655))) int1655;
typedef int __attribute__ ((bitwidth(1656))) int1656;
typedef int __attribute__ ((bitwidth(1657))) int1657;
typedef int __attribute__ ((bitwidth(1658))) int1658;
typedef int __attribute__ ((bitwidth(1659))) int1659;
typedef int __attribute__ ((bitwidth(1660))) int1660;
typedef int __attribute__ ((bitwidth(1661))) int1661;
typedef int __attribute__ ((bitwidth(1662))) int1662;
typedef int __attribute__ ((bitwidth(1663))) int1663;
typedef int __attribute__ ((bitwidth(1664))) int1664;
typedef int __attribute__ ((bitwidth(1665))) int1665;
typedef int __attribute__ ((bitwidth(1666))) int1666;
typedef int __attribute__ ((bitwidth(1667))) int1667;
typedef int __attribute__ ((bitwidth(1668))) int1668;
typedef int __attribute__ ((bitwidth(1669))) int1669;
typedef int __attribute__ ((bitwidth(1670))) int1670;
typedef int __attribute__ ((bitwidth(1671))) int1671;
typedef int __attribute__ ((bitwidth(1672))) int1672;
typedef int __attribute__ ((bitwidth(1673))) int1673;
typedef int __attribute__ ((bitwidth(1674))) int1674;
typedef int __attribute__ ((bitwidth(1675))) int1675;
typedef int __attribute__ ((bitwidth(1676))) int1676;
typedef int __attribute__ ((bitwidth(1677))) int1677;
typedef int __attribute__ ((bitwidth(1678))) int1678;
typedef int __attribute__ ((bitwidth(1679))) int1679;
typedef int __attribute__ ((bitwidth(1680))) int1680;
typedef int __attribute__ ((bitwidth(1681))) int1681;
typedef int __attribute__ ((bitwidth(1682))) int1682;
typedef int __attribute__ ((bitwidth(1683))) int1683;
typedef int __attribute__ ((bitwidth(1684))) int1684;
typedef int __attribute__ ((bitwidth(1685))) int1685;
typedef int __attribute__ ((bitwidth(1686))) int1686;
typedef int __attribute__ ((bitwidth(1687))) int1687;
typedef int __attribute__ ((bitwidth(1688))) int1688;
typedef int __attribute__ ((bitwidth(1689))) int1689;
typedef int __attribute__ ((bitwidth(1690))) int1690;
typedef int __attribute__ ((bitwidth(1691))) int1691;
typedef int __attribute__ ((bitwidth(1692))) int1692;
typedef int __attribute__ ((bitwidth(1693))) int1693;
typedef int __attribute__ ((bitwidth(1694))) int1694;
typedef int __attribute__ ((bitwidth(1695))) int1695;
typedef int __attribute__ ((bitwidth(1696))) int1696;
typedef int __attribute__ ((bitwidth(1697))) int1697;
typedef int __attribute__ ((bitwidth(1698))) int1698;
typedef int __attribute__ ((bitwidth(1699))) int1699;
typedef int __attribute__ ((bitwidth(1700))) int1700;
typedef int __attribute__ ((bitwidth(1701))) int1701;
typedef int __attribute__ ((bitwidth(1702))) int1702;
typedef int __attribute__ ((bitwidth(1703))) int1703;
typedef int __attribute__ ((bitwidth(1704))) int1704;
typedef int __attribute__ ((bitwidth(1705))) int1705;
typedef int __attribute__ ((bitwidth(1706))) int1706;
typedef int __attribute__ ((bitwidth(1707))) int1707;
typedef int __attribute__ ((bitwidth(1708))) int1708;
typedef int __attribute__ ((bitwidth(1709))) int1709;
typedef int __attribute__ ((bitwidth(1710))) int1710;
typedef int __attribute__ ((bitwidth(1711))) int1711;
typedef int __attribute__ ((bitwidth(1712))) int1712;
typedef int __attribute__ ((bitwidth(1713))) int1713;
typedef int __attribute__ ((bitwidth(1714))) int1714;
typedef int __attribute__ ((bitwidth(1715))) int1715;
typedef int __attribute__ ((bitwidth(1716))) int1716;
typedef int __attribute__ ((bitwidth(1717))) int1717;
typedef int __attribute__ ((bitwidth(1718))) int1718;
typedef int __attribute__ ((bitwidth(1719))) int1719;
typedef int __attribute__ ((bitwidth(1720))) int1720;
typedef int __attribute__ ((bitwidth(1721))) int1721;
typedef int __attribute__ ((bitwidth(1722))) int1722;
typedef int __attribute__ ((bitwidth(1723))) int1723;
typedef int __attribute__ ((bitwidth(1724))) int1724;
typedef int __attribute__ ((bitwidth(1725))) int1725;
typedef int __attribute__ ((bitwidth(1726))) int1726;
typedef int __attribute__ ((bitwidth(1727))) int1727;
typedef int __attribute__ ((bitwidth(1728))) int1728;
typedef int __attribute__ ((bitwidth(1729))) int1729;
typedef int __attribute__ ((bitwidth(1730))) int1730;
typedef int __attribute__ ((bitwidth(1731))) int1731;
typedef int __attribute__ ((bitwidth(1732))) int1732;
typedef int __attribute__ ((bitwidth(1733))) int1733;
typedef int __attribute__ ((bitwidth(1734))) int1734;
typedef int __attribute__ ((bitwidth(1735))) int1735;
typedef int __attribute__ ((bitwidth(1736))) int1736;
typedef int __attribute__ ((bitwidth(1737))) int1737;
typedef int __attribute__ ((bitwidth(1738))) int1738;
typedef int __attribute__ ((bitwidth(1739))) int1739;
typedef int __attribute__ ((bitwidth(1740))) int1740;
typedef int __attribute__ ((bitwidth(1741))) int1741;
typedef int __attribute__ ((bitwidth(1742))) int1742;
typedef int __attribute__ ((bitwidth(1743))) int1743;
typedef int __attribute__ ((bitwidth(1744))) int1744;
typedef int __attribute__ ((bitwidth(1745))) int1745;
typedef int __attribute__ ((bitwidth(1746))) int1746;
typedef int __attribute__ ((bitwidth(1747))) int1747;
typedef int __attribute__ ((bitwidth(1748))) int1748;
typedef int __attribute__ ((bitwidth(1749))) int1749;
typedef int __attribute__ ((bitwidth(1750))) int1750;
typedef int __attribute__ ((bitwidth(1751))) int1751;
typedef int __attribute__ ((bitwidth(1752))) int1752;
typedef int __attribute__ ((bitwidth(1753))) int1753;
typedef int __attribute__ ((bitwidth(1754))) int1754;
typedef int __attribute__ ((bitwidth(1755))) int1755;
typedef int __attribute__ ((bitwidth(1756))) int1756;
typedef int __attribute__ ((bitwidth(1757))) int1757;
typedef int __attribute__ ((bitwidth(1758))) int1758;
typedef int __attribute__ ((bitwidth(1759))) int1759;
typedef int __attribute__ ((bitwidth(1760))) int1760;
typedef int __attribute__ ((bitwidth(1761))) int1761;
typedef int __attribute__ ((bitwidth(1762))) int1762;
typedef int __attribute__ ((bitwidth(1763))) int1763;
typedef int __attribute__ ((bitwidth(1764))) int1764;
typedef int __attribute__ ((bitwidth(1765))) int1765;
typedef int __attribute__ ((bitwidth(1766))) int1766;
typedef int __attribute__ ((bitwidth(1767))) int1767;
typedef int __attribute__ ((bitwidth(1768))) int1768;
typedef int __attribute__ ((bitwidth(1769))) int1769;
typedef int __attribute__ ((bitwidth(1770))) int1770;
typedef int __attribute__ ((bitwidth(1771))) int1771;
typedef int __attribute__ ((bitwidth(1772))) int1772;
typedef int __attribute__ ((bitwidth(1773))) int1773;
typedef int __attribute__ ((bitwidth(1774))) int1774;
typedef int __attribute__ ((bitwidth(1775))) int1775;
typedef int __attribute__ ((bitwidth(1776))) int1776;
typedef int __attribute__ ((bitwidth(1777))) int1777;
typedef int __attribute__ ((bitwidth(1778))) int1778;
typedef int __attribute__ ((bitwidth(1779))) int1779;
typedef int __attribute__ ((bitwidth(1780))) int1780;
typedef int __attribute__ ((bitwidth(1781))) int1781;
typedef int __attribute__ ((bitwidth(1782))) int1782;
typedef int __attribute__ ((bitwidth(1783))) int1783;
typedef int __attribute__ ((bitwidth(1784))) int1784;
typedef int __attribute__ ((bitwidth(1785))) int1785;
typedef int __attribute__ ((bitwidth(1786))) int1786;
typedef int __attribute__ ((bitwidth(1787))) int1787;
typedef int __attribute__ ((bitwidth(1788))) int1788;
typedef int __attribute__ ((bitwidth(1789))) int1789;
typedef int __attribute__ ((bitwidth(1790))) int1790;
typedef int __attribute__ ((bitwidth(1791))) int1791;
typedef int __attribute__ ((bitwidth(1792))) int1792;
typedef int __attribute__ ((bitwidth(1793))) int1793;
typedef int __attribute__ ((bitwidth(1794))) int1794;
typedef int __attribute__ ((bitwidth(1795))) int1795;
typedef int __attribute__ ((bitwidth(1796))) int1796;
typedef int __attribute__ ((bitwidth(1797))) int1797;
typedef int __attribute__ ((bitwidth(1798))) int1798;
typedef int __attribute__ ((bitwidth(1799))) int1799;
typedef int __attribute__ ((bitwidth(1800))) int1800;
typedef int __attribute__ ((bitwidth(1801))) int1801;
typedef int __attribute__ ((bitwidth(1802))) int1802;
typedef int __attribute__ ((bitwidth(1803))) int1803;
typedef int __attribute__ ((bitwidth(1804))) int1804;
typedef int __attribute__ ((bitwidth(1805))) int1805;
typedef int __attribute__ ((bitwidth(1806))) int1806;
typedef int __attribute__ ((bitwidth(1807))) int1807;
typedef int __attribute__ ((bitwidth(1808))) int1808;
typedef int __attribute__ ((bitwidth(1809))) int1809;
typedef int __attribute__ ((bitwidth(1810))) int1810;
typedef int __attribute__ ((bitwidth(1811))) int1811;
typedef int __attribute__ ((bitwidth(1812))) int1812;
typedef int __attribute__ ((bitwidth(1813))) int1813;
typedef int __attribute__ ((bitwidth(1814))) int1814;
typedef int __attribute__ ((bitwidth(1815))) int1815;
typedef int __attribute__ ((bitwidth(1816))) int1816;
typedef int __attribute__ ((bitwidth(1817))) int1817;
typedef int __attribute__ ((bitwidth(1818))) int1818;
typedef int __attribute__ ((bitwidth(1819))) int1819;
typedef int __attribute__ ((bitwidth(1820))) int1820;
typedef int __attribute__ ((bitwidth(1821))) int1821;
typedef int __attribute__ ((bitwidth(1822))) int1822;
typedef int __attribute__ ((bitwidth(1823))) int1823;
typedef int __attribute__ ((bitwidth(1824))) int1824;
typedef int __attribute__ ((bitwidth(1825))) int1825;
typedef int __attribute__ ((bitwidth(1826))) int1826;
typedef int __attribute__ ((bitwidth(1827))) int1827;
typedef int __attribute__ ((bitwidth(1828))) int1828;
typedef int __attribute__ ((bitwidth(1829))) int1829;
typedef int __attribute__ ((bitwidth(1830))) int1830;
typedef int __attribute__ ((bitwidth(1831))) int1831;
typedef int __attribute__ ((bitwidth(1832))) int1832;
typedef int __attribute__ ((bitwidth(1833))) int1833;
typedef int __attribute__ ((bitwidth(1834))) int1834;
typedef int __attribute__ ((bitwidth(1835))) int1835;
typedef int __attribute__ ((bitwidth(1836))) int1836;
typedef int __attribute__ ((bitwidth(1837))) int1837;
typedef int __attribute__ ((bitwidth(1838))) int1838;
typedef int __attribute__ ((bitwidth(1839))) int1839;
typedef int __attribute__ ((bitwidth(1840))) int1840;
typedef int __attribute__ ((bitwidth(1841))) int1841;
typedef int __attribute__ ((bitwidth(1842))) int1842;
typedef int __attribute__ ((bitwidth(1843))) int1843;
typedef int __attribute__ ((bitwidth(1844))) int1844;
typedef int __attribute__ ((bitwidth(1845))) int1845;
typedef int __attribute__ ((bitwidth(1846))) int1846;
typedef int __attribute__ ((bitwidth(1847))) int1847;
typedef int __attribute__ ((bitwidth(1848))) int1848;
typedef int __attribute__ ((bitwidth(1849))) int1849;
typedef int __attribute__ ((bitwidth(1850))) int1850;
typedef int __attribute__ ((bitwidth(1851))) int1851;
typedef int __attribute__ ((bitwidth(1852))) int1852;
typedef int __attribute__ ((bitwidth(1853))) int1853;
typedef int __attribute__ ((bitwidth(1854))) int1854;
typedef int __attribute__ ((bitwidth(1855))) int1855;
typedef int __attribute__ ((bitwidth(1856))) int1856;
typedef int __attribute__ ((bitwidth(1857))) int1857;
typedef int __attribute__ ((bitwidth(1858))) int1858;
typedef int __attribute__ ((bitwidth(1859))) int1859;
typedef int __attribute__ ((bitwidth(1860))) int1860;
typedef int __attribute__ ((bitwidth(1861))) int1861;
typedef int __attribute__ ((bitwidth(1862))) int1862;
typedef int __attribute__ ((bitwidth(1863))) int1863;
typedef int __attribute__ ((bitwidth(1864))) int1864;
typedef int __attribute__ ((bitwidth(1865))) int1865;
typedef int __attribute__ ((bitwidth(1866))) int1866;
typedef int __attribute__ ((bitwidth(1867))) int1867;
typedef int __attribute__ ((bitwidth(1868))) int1868;
typedef int __attribute__ ((bitwidth(1869))) int1869;
typedef int __attribute__ ((bitwidth(1870))) int1870;
typedef int __attribute__ ((bitwidth(1871))) int1871;
typedef int __attribute__ ((bitwidth(1872))) int1872;
typedef int __attribute__ ((bitwidth(1873))) int1873;
typedef int __attribute__ ((bitwidth(1874))) int1874;
typedef int __attribute__ ((bitwidth(1875))) int1875;
typedef int __attribute__ ((bitwidth(1876))) int1876;
typedef int __attribute__ ((bitwidth(1877))) int1877;
typedef int __attribute__ ((bitwidth(1878))) int1878;
typedef int __attribute__ ((bitwidth(1879))) int1879;
typedef int __attribute__ ((bitwidth(1880))) int1880;
typedef int __attribute__ ((bitwidth(1881))) int1881;
typedef int __attribute__ ((bitwidth(1882))) int1882;
typedef int __attribute__ ((bitwidth(1883))) int1883;
typedef int __attribute__ ((bitwidth(1884))) int1884;
typedef int __attribute__ ((bitwidth(1885))) int1885;
typedef int __attribute__ ((bitwidth(1886))) int1886;
typedef int __attribute__ ((bitwidth(1887))) int1887;
typedef int __attribute__ ((bitwidth(1888))) int1888;
typedef int __attribute__ ((bitwidth(1889))) int1889;
typedef int __attribute__ ((bitwidth(1890))) int1890;
typedef int __attribute__ ((bitwidth(1891))) int1891;
typedef int __attribute__ ((bitwidth(1892))) int1892;
typedef int __attribute__ ((bitwidth(1893))) int1893;
typedef int __attribute__ ((bitwidth(1894))) int1894;
typedef int __attribute__ ((bitwidth(1895))) int1895;
typedef int __attribute__ ((bitwidth(1896))) int1896;
typedef int __attribute__ ((bitwidth(1897))) int1897;
typedef int __attribute__ ((bitwidth(1898))) int1898;
typedef int __attribute__ ((bitwidth(1899))) int1899;
typedef int __attribute__ ((bitwidth(1900))) int1900;
typedef int __attribute__ ((bitwidth(1901))) int1901;
typedef int __attribute__ ((bitwidth(1902))) int1902;
typedef int __attribute__ ((bitwidth(1903))) int1903;
typedef int __attribute__ ((bitwidth(1904))) int1904;
typedef int __attribute__ ((bitwidth(1905))) int1905;
typedef int __attribute__ ((bitwidth(1906))) int1906;
typedef int __attribute__ ((bitwidth(1907))) int1907;
typedef int __attribute__ ((bitwidth(1908))) int1908;
typedef int __attribute__ ((bitwidth(1909))) int1909;
typedef int __attribute__ ((bitwidth(1910))) int1910;
typedef int __attribute__ ((bitwidth(1911))) int1911;
typedef int __attribute__ ((bitwidth(1912))) int1912;
typedef int __attribute__ ((bitwidth(1913))) int1913;
typedef int __attribute__ ((bitwidth(1914))) int1914;
typedef int __attribute__ ((bitwidth(1915))) int1915;
typedef int __attribute__ ((bitwidth(1916))) int1916;
typedef int __attribute__ ((bitwidth(1917))) int1917;
typedef int __attribute__ ((bitwidth(1918))) int1918;
typedef int __attribute__ ((bitwidth(1919))) int1919;
typedef int __attribute__ ((bitwidth(1920))) int1920;
typedef int __attribute__ ((bitwidth(1921))) int1921;
typedef int __attribute__ ((bitwidth(1922))) int1922;
typedef int __attribute__ ((bitwidth(1923))) int1923;
typedef int __attribute__ ((bitwidth(1924))) int1924;
typedef int __attribute__ ((bitwidth(1925))) int1925;
typedef int __attribute__ ((bitwidth(1926))) int1926;
typedef int __attribute__ ((bitwidth(1927))) int1927;
typedef int __attribute__ ((bitwidth(1928))) int1928;
typedef int __attribute__ ((bitwidth(1929))) int1929;
typedef int __attribute__ ((bitwidth(1930))) int1930;
typedef int __attribute__ ((bitwidth(1931))) int1931;
typedef int __attribute__ ((bitwidth(1932))) int1932;
typedef int __attribute__ ((bitwidth(1933))) int1933;
typedef int __attribute__ ((bitwidth(1934))) int1934;
typedef int __attribute__ ((bitwidth(1935))) int1935;
typedef int __attribute__ ((bitwidth(1936))) int1936;
typedef int __attribute__ ((bitwidth(1937))) int1937;
typedef int __attribute__ ((bitwidth(1938))) int1938;
typedef int __attribute__ ((bitwidth(1939))) int1939;
typedef int __attribute__ ((bitwidth(1940))) int1940;
typedef int __attribute__ ((bitwidth(1941))) int1941;
typedef int __attribute__ ((bitwidth(1942))) int1942;
typedef int __attribute__ ((bitwidth(1943))) int1943;
typedef int __attribute__ ((bitwidth(1944))) int1944;
typedef int __attribute__ ((bitwidth(1945))) int1945;
typedef int __attribute__ ((bitwidth(1946))) int1946;
typedef int __attribute__ ((bitwidth(1947))) int1947;
typedef int __attribute__ ((bitwidth(1948))) int1948;
typedef int __attribute__ ((bitwidth(1949))) int1949;
typedef int __attribute__ ((bitwidth(1950))) int1950;
typedef int __attribute__ ((bitwidth(1951))) int1951;
typedef int __attribute__ ((bitwidth(1952))) int1952;
typedef int __attribute__ ((bitwidth(1953))) int1953;
typedef int __attribute__ ((bitwidth(1954))) int1954;
typedef int __attribute__ ((bitwidth(1955))) int1955;
typedef int __attribute__ ((bitwidth(1956))) int1956;
typedef int __attribute__ ((bitwidth(1957))) int1957;
typedef int __attribute__ ((bitwidth(1958))) int1958;
typedef int __attribute__ ((bitwidth(1959))) int1959;
typedef int __attribute__ ((bitwidth(1960))) int1960;
typedef int __attribute__ ((bitwidth(1961))) int1961;
typedef int __attribute__ ((bitwidth(1962))) int1962;
typedef int __attribute__ ((bitwidth(1963))) int1963;
typedef int __attribute__ ((bitwidth(1964))) int1964;
typedef int __attribute__ ((bitwidth(1965))) int1965;
typedef int __attribute__ ((bitwidth(1966))) int1966;
typedef int __attribute__ ((bitwidth(1967))) int1967;
typedef int __attribute__ ((bitwidth(1968))) int1968;
typedef int __attribute__ ((bitwidth(1969))) int1969;
typedef int __attribute__ ((bitwidth(1970))) int1970;
typedef int __attribute__ ((bitwidth(1971))) int1971;
typedef int __attribute__ ((bitwidth(1972))) int1972;
typedef int __attribute__ ((bitwidth(1973))) int1973;
typedef int __attribute__ ((bitwidth(1974))) int1974;
typedef int __attribute__ ((bitwidth(1975))) int1975;
typedef int __attribute__ ((bitwidth(1976))) int1976;
typedef int __attribute__ ((bitwidth(1977))) int1977;
typedef int __attribute__ ((bitwidth(1978))) int1978;
typedef int __attribute__ ((bitwidth(1979))) int1979;
typedef int __attribute__ ((bitwidth(1980))) int1980;
typedef int __attribute__ ((bitwidth(1981))) int1981;
typedef int __attribute__ ((bitwidth(1982))) int1982;
typedef int __attribute__ ((bitwidth(1983))) int1983;
typedef int __attribute__ ((bitwidth(1984))) int1984;
typedef int __attribute__ ((bitwidth(1985))) int1985;
typedef int __attribute__ ((bitwidth(1986))) int1986;
typedef int __attribute__ ((bitwidth(1987))) int1987;
typedef int __attribute__ ((bitwidth(1988))) int1988;
typedef int __attribute__ ((bitwidth(1989))) int1989;
typedef int __attribute__ ((bitwidth(1990))) int1990;
typedef int __attribute__ ((bitwidth(1991))) int1991;
typedef int __attribute__ ((bitwidth(1992))) int1992;
typedef int __attribute__ ((bitwidth(1993))) int1993;
typedef int __attribute__ ((bitwidth(1994))) int1994;
typedef int __attribute__ ((bitwidth(1995))) int1995;
typedef int __attribute__ ((bitwidth(1996))) int1996;
typedef int __attribute__ ((bitwidth(1997))) int1997;
typedef int __attribute__ ((bitwidth(1998))) int1998;
typedef int __attribute__ ((bitwidth(1999))) int1999;
typedef int __attribute__ ((bitwidth(2000))) int2000;
typedef int __attribute__ ((bitwidth(2001))) int2001;
typedef int __attribute__ ((bitwidth(2002))) int2002;
typedef int __attribute__ ((bitwidth(2003))) int2003;
typedef int __attribute__ ((bitwidth(2004))) int2004;
typedef int __attribute__ ((bitwidth(2005))) int2005;
typedef int __attribute__ ((bitwidth(2006))) int2006;
typedef int __attribute__ ((bitwidth(2007))) int2007;
typedef int __attribute__ ((bitwidth(2008))) int2008;
typedef int __attribute__ ((bitwidth(2009))) int2009;
typedef int __attribute__ ((bitwidth(2010))) int2010;
typedef int __attribute__ ((bitwidth(2011))) int2011;
typedef int __attribute__ ((bitwidth(2012))) int2012;
typedef int __attribute__ ((bitwidth(2013))) int2013;
typedef int __attribute__ ((bitwidth(2014))) int2014;
typedef int __attribute__ ((bitwidth(2015))) int2015;
typedef int __attribute__ ((bitwidth(2016))) int2016;
typedef int __attribute__ ((bitwidth(2017))) int2017;
typedef int __attribute__ ((bitwidth(2018))) int2018;
typedef int __attribute__ ((bitwidth(2019))) int2019;
typedef int __attribute__ ((bitwidth(2020))) int2020;
typedef int __attribute__ ((bitwidth(2021))) int2021;
typedef int __attribute__ ((bitwidth(2022))) int2022;
typedef int __attribute__ ((bitwidth(2023))) int2023;
typedef int __attribute__ ((bitwidth(2024))) int2024;
typedef int __attribute__ ((bitwidth(2025))) int2025;
typedef int __attribute__ ((bitwidth(2026))) int2026;
typedef int __attribute__ ((bitwidth(2027))) int2027;
typedef int __attribute__ ((bitwidth(2028))) int2028;
typedef int __attribute__ ((bitwidth(2029))) int2029;
typedef int __attribute__ ((bitwidth(2030))) int2030;
typedef int __attribute__ ((bitwidth(2031))) int2031;
typedef int __attribute__ ((bitwidth(2032))) int2032;
typedef int __attribute__ ((bitwidth(2033))) int2033;
typedef int __attribute__ ((bitwidth(2034))) int2034;
typedef int __attribute__ ((bitwidth(2035))) int2035;
typedef int __attribute__ ((bitwidth(2036))) int2036;
typedef int __attribute__ ((bitwidth(2037))) int2037;
typedef int __attribute__ ((bitwidth(2038))) int2038;
typedef int __attribute__ ((bitwidth(2039))) int2039;
typedef int __attribute__ ((bitwidth(2040))) int2040;
typedef int __attribute__ ((bitwidth(2041))) int2041;
typedef int __attribute__ ((bitwidth(2042))) int2042;
typedef int __attribute__ ((bitwidth(2043))) int2043;
typedef int __attribute__ ((bitwidth(2044))) int2044;
typedef int __attribute__ ((bitwidth(2045))) int2045;
typedef int __attribute__ ((bitwidth(2046))) int2046;
typedef int __attribute__ ((bitwidth(2047))) int2047;
typedef int __attribute__ ((bitwidth(2048))) int2048;
#pragma line 99 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 108 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(1))) uint1;
typedef unsigned int __attribute__ ((bitwidth(2))) uint2;
typedef unsigned int __attribute__ ((bitwidth(3))) uint3;
typedef unsigned int __attribute__ ((bitwidth(4))) uint4;
typedef unsigned int __attribute__ ((bitwidth(5))) uint5;
typedef unsigned int __attribute__ ((bitwidth(6))) uint6;
typedef unsigned int __attribute__ ((bitwidth(7))) uint7;
typedef unsigned int __attribute__ ((bitwidth(8))) uint8;
typedef unsigned int __attribute__ ((bitwidth(9))) uint9;
typedef unsigned int __attribute__ ((bitwidth(10))) uint10;
typedef unsigned int __attribute__ ((bitwidth(11))) uint11;
typedef unsigned int __attribute__ ((bitwidth(12))) uint12;
typedef unsigned int __attribute__ ((bitwidth(13))) uint13;
typedef unsigned int __attribute__ ((bitwidth(14))) uint14;
typedef unsigned int __attribute__ ((bitwidth(15))) uint15;
typedef unsigned int __attribute__ ((bitwidth(16))) uint16;
typedef unsigned int __attribute__ ((bitwidth(17))) uint17;
typedef unsigned int __attribute__ ((bitwidth(18))) uint18;
typedef unsigned int __attribute__ ((bitwidth(19))) uint19;
typedef unsigned int __attribute__ ((bitwidth(20))) uint20;
typedef unsigned int __attribute__ ((bitwidth(21))) uint21;
typedef unsigned int __attribute__ ((bitwidth(22))) uint22;
typedef unsigned int __attribute__ ((bitwidth(23))) uint23;
typedef unsigned int __attribute__ ((bitwidth(24))) uint24;
typedef unsigned int __attribute__ ((bitwidth(25))) uint25;
typedef unsigned int __attribute__ ((bitwidth(26))) uint26;
typedef unsigned int __attribute__ ((bitwidth(27))) uint27;
typedef unsigned int __attribute__ ((bitwidth(28))) uint28;
typedef unsigned int __attribute__ ((bitwidth(29))) uint29;
typedef unsigned int __attribute__ ((bitwidth(30))) uint30;
typedef unsigned int __attribute__ ((bitwidth(31))) uint31;
typedef unsigned int __attribute__ ((bitwidth(32))) uint32;
typedef unsigned int __attribute__ ((bitwidth(33))) uint33;
typedef unsigned int __attribute__ ((bitwidth(34))) uint34;
typedef unsigned int __attribute__ ((bitwidth(35))) uint35;
typedef unsigned int __attribute__ ((bitwidth(36))) uint36;
typedef unsigned int __attribute__ ((bitwidth(37))) uint37;
typedef unsigned int __attribute__ ((bitwidth(38))) uint38;
typedef unsigned int __attribute__ ((bitwidth(39))) uint39;
typedef unsigned int __attribute__ ((bitwidth(40))) uint40;
typedef unsigned int __attribute__ ((bitwidth(41))) uint41;
typedef unsigned int __attribute__ ((bitwidth(42))) uint42;
typedef unsigned int __attribute__ ((bitwidth(43))) uint43;
typedef unsigned int __attribute__ ((bitwidth(44))) uint44;
typedef unsigned int __attribute__ ((bitwidth(45))) uint45;
typedef unsigned int __attribute__ ((bitwidth(46))) uint46;
typedef unsigned int __attribute__ ((bitwidth(47))) uint47;
typedef unsigned int __attribute__ ((bitwidth(48))) uint48;
typedef unsigned int __attribute__ ((bitwidth(49))) uint49;
typedef unsigned int __attribute__ ((bitwidth(50))) uint50;
typedef unsigned int __attribute__ ((bitwidth(51))) uint51;
typedef unsigned int __attribute__ ((bitwidth(52))) uint52;
typedef unsigned int __attribute__ ((bitwidth(53))) uint53;
typedef unsigned int __attribute__ ((bitwidth(54))) uint54;
typedef unsigned int __attribute__ ((bitwidth(55))) uint55;
typedef unsigned int __attribute__ ((bitwidth(56))) uint56;
typedef unsigned int __attribute__ ((bitwidth(57))) uint57;
typedef unsigned int __attribute__ ((bitwidth(58))) uint58;
typedef unsigned int __attribute__ ((bitwidth(59))) uint59;
typedef unsigned int __attribute__ ((bitwidth(60))) uint60;
typedef unsigned int __attribute__ ((bitwidth(61))) uint61;
typedef unsigned int __attribute__ ((bitwidth(62))) uint62;
typedef unsigned int __attribute__ ((bitwidth(63))) uint63;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(65))) uint65;
typedef unsigned int __attribute__ ((bitwidth(66))) uint66;
typedef unsigned int __attribute__ ((bitwidth(67))) uint67;
typedef unsigned int __attribute__ ((bitwidth(68))) uint68;
typedef unsigned int __attribute__ ((bitwidth(69))) uint69;
typedef unsigned int __attribute__ ((bitwidth(70))) uint70;
typedef unsigned int __attribute__ ((bitwidth(71))) uint71;
typedef unsigned int __attribute__ ((bitwidth(72))) uint72;
typedef unsigned int __attribute__ ((bitwidth(73))) uint73;
typedef unsigned int __attribute__ ((bitwidth(74))) uint74;
typedef unsigned int __attribute__ ((bitwidth(75))) uint75;
typedef unsigned int __attribute__ ((bitwidth(76))) uint76;
typedef unsigned int __attribute__ ((bitwidth(77))) uint77;
typedef unsigned int __attribute__ ((bitwidth(78))) uint78;
typedef unsigned int __attribute__ ((bitwidth(79))) uint79;
typedef unsigned int __attribute__ ((bitwidth(80))) uint80;
typedef unsigned int __attribute__ ((bitwidth(81))) uint81;
typedef unsigned int __attribute__ ((bitwidth(82))) uint82;
typedef unsigned int __attribute__ ((bitwidth(83))) uint83;
typedef unsigned int __attribute__ ((bitwidth(84))) uint84;
typedef unsigned int __attribute__ ((bitwidth(85))) uint85;
typedef unsigned int __attribute__ ((bitwidth(86))) uint86;
typedef unsigned int __attribute__ ((bitwidth(87))) uint87;
typedef unsigned int __attribute__ ((bitwidth(88))) uint88;
typedef unsigned int __attribute__ ((bitwidth(89))) uint89;
typedef unsigned int __attribute__ ((bitwidth(90))) uint90;
typedef unsigned int __attribute__ ((bitwidth(91))) uint91;
typedef unsigned int __attribute__ ((bitwidth(92))) uint92;
typedef unsigned int __attribute__ ((bitwidth(93))) uint93;
typedef unsigned int __attribute__ ((bitwidth(94))) uint94;
typedef unsigned int __attribute__ ((bitwidth(95))) uint95;
typedef unsigned int __attribute__ ((bitwidth(96))) uint96;
typedef unsigned int __attribute__ ((bitwidth(97))) uint97;
typedef unsigned int __attribute__ ((bitwidth(98))) uint98;
typedef unsigned int __attribute__ ((bitwidth(99))) uint99;
typedef unsigned int __attribute__ ((bitwidth(100))) uint100;
typedef unsigned int __attribute__ ((bitwidth(101))) uint101;
typedef unsigned int __attribute__ ((bitwidth(102))) uint102;
typedef unsigned int __attribute__ ((bitwidth(103))) uint103;
typedef unsigned int __attribute__ ((bitwidth(104))) uint104;
typedef unsigned int __attribute__ ((bitwidth(105))) uint105;
typedef unsigned int __attribute__ ((bitwidth(106))) uint106;
typedef unsigned int __attribute__ ((bitwidth(107))) uint107;
typedef unsigned int __attribute__ ((bitwidth(108))) uint108;
typedef unsigned int __attribute__ ((bitwidth(109))) uint109;
typedef unsigned int __attribute__ ((bitwidth(110))) uint110;
typedef unsigned int __attribute__ ((bitwidth(111))) uint111;
typedef unsigned int __attribute__ ((bitwidth(112))) uint112;
typedef unsigned int __attribute__ ((bitwidth(113))) uint113;
typedef unsigned int __attribute__ ((bitwidth(114))) uint114;
typedef unsigned int __attribute__ ((bitwidth(115))) uint115;
typedef unsigned int __attribute__ ((bitwidth(116))) uint116;
typedef unsigned int __attribute__ ((bitwidth(117))) uint117;
typedef unsigned int __attribute__ ((bitwidth(118))) uint118;
typedef unsigned int __attribute__ ((bitwidth(119))) uint119;
typedef unsigned int __attribute__ ((bitwidth(120))) uint120;
typedef unsigned int __attribute__ ((bitwidth(121))) uint121;
typedef unsigned int __attribute__ ((bitwidth(122))) uint122;
typedef unsigned int __attribute__ ((bitwidth(123))) uint123;
typedef unsigned int __attribute__ ((bitwidth(124))) uint124;
typedef unsigned int __attribute__ ((bitwidth(125))) uint125;
typedef unsigned int __attribute__ ((bitwidth(126))) uint126;
typedef unsigned int __attribute__ ((bitwidth(127))) uint127;
typedef unsigned int __attribute__ ((bitwidth(128))) uint128;
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(129))) uint129;
typedef unsigned int __attribute__ ((bitwidth(130))) uint130;
typedef unsigned int __attribute__ ((bitwidth(131))) uint131;
typedef unsigned int __attribute__ ((bitwidth(132))) uint132;
typedef unsigned int __attribute__ ((bitwidth(133))) uint133;
typedef unsigned int __attribute__ ((bitwidth(134))) uint134;
typedef unsigned int __attribute__ ((bitwidth(135))) uint135;
typedef unsigned int __attribute__ ((bitwidth(136))) uint136;
typedef unsigned int __attribute__ ((bitwidth(137))) uint137;
typedef unsigned int __attribute__ ((bitwidth(138))) uint138;
typedef unsigned int __attribute__ ((bitwidth(139))) uint139;
typedef unsigned int __attribute__ ((bitwidth(140))) uint140;
typedef unsigned int __attribute__ ((bitwidth(141))) uint141;
typedef unsigned int __attribute__ ((bitwidth(142))) uint142;
typedef unsigned int __attribute__ ((bitwidth(143))) uint143;
typedef unsigned int __attribute__ ((bitwidth(144))) uint144;
typedef unsigned int __attribute__ ((bitwidth(145))) uint145;
typedef unsigned int __attribute__ ((bitwidth(146))) uint146;
typedef unsigned int __attribute__ ((bitwidth(147))) uint147;
typedef unsigned int __attribute__ ((bitwidth(148))) uint148;
typedef unsigned int __attribute__ ((bitwidth(149))) uint149;
typedef unsigned int __attribute__ ((bitwidth(150))) uint150;
typedef unsigned int __attribute__ ((bitwidth(151))) uint151;
typedef unsigned int __attribute__ ((bitwidth(152))) uint152;
typedef unsigned int __attribute__ ((bitwidth(153))) uint153;
typedef unsigned int __attribute__ ((bitwidth(154))) uint154;
typedef unsigned int __attribute__ ((bitwidth(155))) uint155;
typedef unsigned int __attribute__ ((bitwidth(156))) uint156;
typedef unsigned int __attribute__ ((bitwidth(157))) uint157;
typedef unsigned int __attribute__ ((bitwidth(158))) uint158;
typedef unsigned int __attribute__ ((bitwidth(159))) uint159;
typedef unsigned int __attribute__ ((bitwidth(160))) uint160;
typedef unsigned int __attribute__ ((bitwidth(161))) uint161;
typedef unsigned int __attribute__ ((bitwidth(162))) uint162;
typedef unsigned int __attribute__ ((bitwidth(163))) uint163;
typedef unsigned int __attribute__ ((bitwidth(164))) uint164;
typedef unsigned int __attribute__ ((bitwidth(165))) uint165;
typedef unsigned int __attribute__ ((bitwidth(166))) uint166;
typedef unsigned int __attribute__ ((bitwidth(167))) uint167;
typedef unsigned int __attribute__ ((bitwidth(168))) uint168;
typedef unsigned int __attribute__ ((bitwidth(169))) uint169;
typedef unsigned int __attribute__ ((bitwidth(170))) uint170;
typedef unsigned int __attribute__ ((bitwidth(171))) uint171;
typedef unsigned int __attribute__ ((bitwidth(172))) uint172;
typedef unsigned int __attribute__ ((bitwidth(173))) uint173;
typedef unsigned int __attribute__ ((bitwidth(174))) uint174;
typedef unsigned int __attribute__ ((bitwidth(175))) uint175;
typedef unsigned int __attribute__ ((bitwidth(176))) uint176;
typedef unsigned int __attribute__ ((bitwidth(177))) uint177;
typedef unsigned int __attribute__ ((bitwidth(178))) uint178;
typedef unsigned int __attribute__ ((bitwidth(179))) uint179;
typedef unsigned int __attribute__ ((bitwidth(180))) uint180;
typedef unsigned int __attribute__ ((bitwidth(181))) uint181;
typedef unsigned int __attribute__ ((bitwidth(182))) uint182;
typedef unsigned int __attribute__ ((bitwidth(183))) uint183;
typedef unsigned int __attribute__ ((bitwidth(184))) uint184;
typedef unsigned int __attribute__ ((bitwidth(185))) uint185;
typedef unsigned int __attribute__ ((bitwidth(186))) uint186;
typedef unsigned int __attribute__ ((bitwidth(187))) uint187;
typedef unsigned int __attribute__ ((bitwidth(188))) uint188;
typedef unsigned int __attribute__ ((bitwidth(189))) uint189;
typedef unsigned int __attribute__ ((bitwidth(190))) uint190;
typedef unsigned int __attribute__ ((bitwidth(191))) uint191;
typedef unsigned int __attribute__ ((bitwidth(192))) uint192;
typedef unsigned int __attribute__ ((bitwidth(193))) uint193;
typedef unsigned int __attribute__ ((bitwidth(194))) uint194;
typedef unsigned int __attribute__ ((bitwidth(195))) uint195;
typedef unsigned int __attribute__ ((bitwidth(196))) uint196;
typedef unsigned int __attribute__ ((bitwidth(197))) uint197;
typedef unsigned int __attribute__ ((bitwidth(198))) uint198;
typedef unsigned int __attribute__ ((bitwidth(199))) uint199;
typedef unsigned int __attribute__ ((bitwidth(200))) uint200;
typedef unsigned int __attribute__ ((bitwidth(201))) uint201;
typedef unsigned int __attribute__ ((bitwidth(202))) uint202;
typedef unsigned int __attribute__ ((bitwidth(203))) uint203;
typedef unsigned int __attribute__ ((bitwidth(204))) uint204;
typedef unsigned int __attribute__ ((bitwidth(205))) uint205;
typedef unsigned int __attribute__ ((bitwidth(206))) uint206;
typedef unsigned int __attribute__ ((bitwidth(207))) uint207;
typedef unsigned int __attribute__ ((bitwidth(208))) uint208;
typedef unsigned int __attribute__ ((bitwidth(209))) uint209;
typedef unsigned int __attribute__ ((bitwidth(210))) uint210;
typedef unsigned int __attribute__ ((bitwidth(211))) uint211;
typedef unsigned int __attribute__ ((bitwidth(212))) uint212;
typedef unsigned int __attribute__ ((bitwidth(213))) uint213;
typedef unsigned int __attribute__ ((bitwidth(214))) uint214;
typedef unsigned int __attribute__ ((bitwidth(215))) uint215;
typedef unsigned int __attribute__ ((bitwidth(216))) uint216;
typedef unsigned int __attribute__ ((bitwidth(217))) uint217;
typedef unsigned int __attribute__ ((bitwidth(218))) uint218;
typedef unsigned int __attribute__ ((bitwidth(219))) uint219;
typedef unsigned int __attribute__ ((bitwidth(220))) uint220;
typedef unsigned int __attribute__ ((bitwidth(221))) uint221;
typedef unsigned int __attribute__ ((bitwidth(222))) uint222;
typedef unsigned int __attribute__ ((bitwidth(223))) uint223;
typedef unsigned int __attribute__ ((bitwidth(224))) uint224;
typedef unsigned int __attribute__ ((bitwidth(225))) uint225;
typedef unsigned int __attribute__ ((bitwidth(226))) uint226;
typedef unsigned int __attribute__ ((bitwidth(227))) uint227;
typedef unsigned int __attribute__ ((bitwidth(228))) uint228;
typedef unsigned int __attribute__ ((bitwidth(229))) uint229;
typedef unsigned int __attribute__ ((bitwidth(230))) uint230;
typedef unsigned int __attribute__ ((bitwidth(231))) uint231;
typedef unsigned int __attribute__ ((bitwidth(232))) uint232;
typedef unsigned int __attribute__ ((bitwidth(233))) uint233;
typedef unsigned int __attribute__ ((bitwidth(234))) uint234;
typedef unsigned int __attribute__ ((bitwidth(235))) uint235;
typedef unsigned int __attribute__ ((bitwidth(236))) uint236;
typedef unsigned int __attribute__ ((bitwidth(237))) uint237;
typedef unsigned int __attribute__ ((bitwidth(238))) uint238;
typedef unsigned int __attribute__ ((bitwidth(239))) uint239;
typedef unsigned int __attribute__ ((bitwidth(240))) uint240;
typedef unsigned int __attribute__ ((bitwidth(241))) uint241;
typedef unsigned int __attribute__ ((bitwidth(242))) uint242;
typedef unsigned int __attribute__ ((bitwidth(243))) uint243;
typedef unsigned int __attribute__ ((bitwidth(244))) uint244;
typedef unsigned int __attribute__ ((bitwidth(245))) uint245;
typedef unsigned int __attribute__ ((bitwidth(246))) uint246;
typedef unsigned int __attribute__ ((bitwidth(247))) uint247;
typedef unsigned int __attribute__ ((bitwidth(248))) uint248;
typedef unsigned int __attribute__ ((bitwidth(249))) uint249;
typedef unsigned int __attribute__ ((bitwidth(250))) uint250;
typedef unsigned int __attribute__ ((bitwidth(251))) uint251;
typedef unsigned int __attribute__ ((bitwidth(252))) uint252;
typedef unsigned int __attribute__ ((bitwidth(253))) uint253;
typedef unsigned int __attribute__ ((bitwidth(254))) uint254;
typedef unsigned int __attribute__ ((bitwidth(255))) uint255;
typedef unsigned int __attribute__ ((bitwidth(256))) uint256;
typedef unsigned int __attribute__ ((bitwidth(257))) uint257;
typedef unsigned int __attribute__ ((bitwidth(258))) uint258;
typedef unsigned int __attribute__ ((bitwidth(259))) uint259;
typedef unsigned int __attribute__ ((bitwidth(260))) uint260;
typedef unsigned int __attribute__ ((bitwidth(261))) uint261;
typedef unsigned int __attribute__ ((bitwidth(262))) uint262;
typedef unsigned int __attribute__ ((bitwidth(263))) uint263;
typedef unsigned int __attribute__ ((bitwidth(264))) uint264;
typedef unsigned int __attribute__ ((bitwidth(265))) uint265;
typedef unsigned int __attribute__ ((bitwidth(266))) uint266;
typedef unsigned int __attribute__ ((bitwidth(267))) uint267;
typedef unsigned int __attribute__ ((bitwidth(268))) uint268;
typedef unsigned int __attribute__ ((bitwidth(269))) uint269;
typedef unsigned int __attribute__ ((bitwidth(270))) uint270;
typedef unsigned int __attribute__ ((bitwidth(271))) uint271;
typedef unsigned int __attribute__ ((bitwidth(272))) uint272;
typedef unsigned int __attribute__ ((bitwidth(273))) uint273;
typedef unsigned int __attribute__ ((bitwidth(274))) uint274;
typedef unsigned int __attribute__ ((bitwidth(275))) uint275;
typedef unsigned int __attribute__ ((bitwidth(276))) uint276;
typedef unsigned int __attribute__ ((bitwidth(277))) uint277;
typedef unsigned int __attribute__ ((bitwidth(278))) uint278;
typedef unsigned int __attribute__ ((bitwidth(279))) uint279;
typedef unsigned int __attribute__ ((bitwidth(280))) uint280;
typedef unsigned int __attribute__ ((bitwidth(281))) uint281;
typedef unsigned int __attribute__ ((bitwidth(282))) uint282;
typedef unsigned int __attribute__ ((bitwidth(283))) uint283;
typedef unsigned int __attribute__ ((bitwidth(284))) uint284;
typedef unsigned int __attribute__ ((bitwidth(285))) uint285;
typedef unsigned int __attribute__ ((bitwidth(286))) uint286;
typedef unsigned int __attribute__ ((bitwidth(287))) uint287;
typedef unsigned int __attribute__ ((bitwidth(288))) uint288;
typedef unsigned int __attribute__ ((bitwidth(289))) uint289;
typedef unsigned int __attribute__ ((bitwidth(290))) uint290;
typedef unsigned int __attribute__ ((bitwidth(291))) uint291;
typedef unsigned int __attribute__ ((bitwidth(292))) uint292;
typedef unsigned int __attribute__ ((bitwidth(293))) uint293;
typedef unsigned int __attribute__ ((bitwidth(294))) uint294;
typedef unsigned int __attribute__ ((bitwidth(295))) uint295;
typedef unsigned int __attribute__ ((bitwidth(296))) uint296;
typedef unsigned int __attribute__ ((bitwidth(297))) uint297;
typedef unsigned int __attribute__ ((bitwidth(298))) uint298;
typedef unsigned int __attribute__ ((bitwidth(299))) uint299;
typedef unsigned int __attribute__ ((bitwidth(300))) uint300;
typedef unsigned int __attribute__ ((bitwidth(301))) uint301;
typedef unsigned int __attribute__ ((bitwidth(302))) uint302;
typedef unsigned int __attribute__ ((bitwidth(303))) uint303;
typedef unsigned int __attribute__ ((bitwidth(304))) uint304;
typedef unsigned int __attribute__ ((bitwidth(305))) uint305;
typedef unsigned int __attribute__ ((bitwidth(306))) uint306;
typedef unsigned int __attribute__ ((bitwidth(307))) uint307;
typedef unsigned int __attribute__ ((bitwidth(308))) uint308;
typedef unsigned int __attribute__ ((bitwidth(309))) uint309;
typedef unsigned int __attribute__ ((bitwidth(310))) uint310;
typedef unsigned int __attribute__ ((bitwidth(311))) uint311;
typedef unsigned int __attribute__ ((bitwidth(312))) uint312;
typedef unsigned int __attribute__ ((bitwidth(313))) uint313;
typedef unsigned int __attribute__ ((bitwidth(314))) uint314;
typedef unsigned int __attribute__ ((bitwidth(315))) uint315;
typedef unsigned int __attribute__ ((bitwidth(316))) uint316;
typedef unsigned int __attribute__ ((bitwidth(317))) uint317;
typedef unsigned int __attribute__ ((bitwidth(318))) uint318;
typedef unsigned int __attribute__ ((bitwidth(319))) uint319;
typedef unsigned int __attribute__ ((bitwidth(320))) uint320;
typedef unsigned int __attribute__ ((bitwidth(321))) uint321;
typedef unsigned int __attribute__ ((bitwidth(322))) uint322;
typedef unsigned int __attribute__ ((bitwidth(323))) uint323;
typedef unsigned int __attribute__ ((bitwidth(324))) uint324;
typedef unsigned int __attribute__ ((bitwidth(325))) uint325;
typedef unsigned int __attribute__ ((bitwidth(326))) uint326;
typedef unsigned int __attribute__ ((bitwidth(327))) uint327;
typedef unsigned int __attribute__ ((bitwidth(328))) uint328;
typedef unsigned int __attribute__ ((bitwidth(329))) uint329;
typedef unsigned int __attribute__ ((bitwidth(330))) uint330;
typedef unsigned int __attribute__ ((bitwidth(331))) uint331;
typedef unsigned int __attribute__ ((bitwidth(332))) uint332;
typedef unsigned int __attribute__ ((bitwidth(333))) uint333;
typedef unsigned int __attribute__ ((bitwidth(334))) uint334;
typedef unsigned int __attribute__ ((bitwidth(335))) uint335;
typedef unsigned int __attribute__ ((bitwidth(336))) uint336;
typedef unsigned int __attribute__ ((bitwidth(337))) uint337;
typedef unsigned int __attribute__ ((bitwidth(338))) uint338;
typedef unsigned int __attribute__ ((bitwidth(339))) uint339;
typedef unsigned int __attribute__ ((bitwidth(340))) uint340;
typedef unsigned int __attribute__ ((bitwidth(341))) uint341;
typedef unsigned int __attribute__ ((bitwidth(342))) uint342;
typedef unsigned int __attribute__ ((bitwidth(343))) uint343;
typedef unsigned int __attribute__ ((bitwidth(344))) uint344;
typedef unsigned int __attribute__ ((bitwidth(345))) uint345;
typedef unsigned int __attribute__ ((bitwidth(346))) uint346;
typedef unsigned int __attribute__ ((bitwidth(347))) uint347;
typedef unsigned int __attribute__ ((bitwidth(348))) uint348;
typedef unsigned int __attribute__ ((bitwidth(349))) uint349;
typedef unsigned int __attribute__ ((bitwidth(350))) uint350;
typedef unsigned int __attribute__ ((bitwidth(351))) uint351;
typedef unsigned int __attribute__ ((bitwidth(352))) uint352;
typedef unsigned int __attribute__ ((bitwidth(353))) uint353;
typedef unsigned int __attribute__ ((bitwidth(354))) uint354;
typedef unsigned int __attribute__ ((bitwidth(355))) uint355;
typedef unsigned int __attribute__ ((bitwidth(356))) uint356;
typedef unsigned int __attribute__ ((bitwidth(357))) uint357;
typedef unsigned int __attribute__ ((bitwidth(358))) uint358;
typedef unsigned int __attribute__ ((bitwidth(359))) uint359;
typedef unsigned int __attribute__ ((bitwidth(360))) uint360;
typedef unsigned int __attribute__ ((bitwidth(361))) uint361;
typedef unsigned int __attribute__ ((bitwidth(362))) uint362;
typedef unsigned int __attribute__ ((bitwidth(363))) uint363;
typedef unsigned int __attribute__ ((bitwidth(364))) uint364;
typedef unsigned int __attribute__ ((bitwidth(365))) uint365;
typedef unsigned int __attribute__ ((bitwidth(366))) uint366;
typedef unsigned int __attribute__ ((bitwidth(367))) uint367;
typedef unsigned int __attribute__ ((bitwidth(368))) uint368;
typedef unsigned int __attribute__ ((bitwidth(369))) uint369;
typedef unsigned int __attribute__ ((bitwidth(370))) uint370;
typedef unsigned int __attribute__ ((bitwidth(371))) uint371;
typedef unsigned int __attribute__ ((bitwidth(372))) uint372;
typedef unsigned int __attribute__ ((bitwidth(373))) uint373;
typedef unsigned int __attribute__ ((bitwidth(374))) uint374;
typedef unsigned int __attribute__ ((bitwidth(375))) uint375;
typedef unsigned int __attribute__ ((bitwidth(376))) uint376;
typedef unsigned int __attribute__ ((bitwidth(377))) uint377;
typedef unsigned int __attribute__ ((bitwidth(378))) uint378;
typedef unsigned int __attribute__ ((bitwidth(379))) uint379;
typedef unsigned int __attribute__ ((bitwidth(380))) uint380;
typedef unsigned int __attribute__ ((bitwidth(381))) uint381;
typedef unsigned int __attribute__ ((bitwidth(382))) uint382;
typedef unsigned int __attribute__ ((bitwidth(383))) uint383;
typedef unsigned int __attribute__ ((bitwidth(384))) uint384;
typedef unsigned int __attribute__ ((bitwidth(385))) uint385;
typedef unsigned int __attribute__ ((bitwidth(386))) uint386;
typedef unsigned int __attribute__ ((bitwidth(387))) uint387;
typedef unsigned int __attribute__ ((bitwidth(388))) uint388;
typedef unsigned int __attribute__ ((bitwidth(389))) uint389;
typedef unsigned int __attribute__ ((bitwidth(390))) uint390;
typedef unsigned int __attribute__ ((bitwidth(391))) uint391;
typedef unsigned int __attribute__ ((bitwidth(392))) uint392;
typedef unsigned int __attribute__ ((bitwidth(393))) uint393;
typedef unsigned int __attribute__ ((bitwidth(394))) uint394;
typedef unsigned int __attribute__ ((bitwidth(395))) uint395;
typedef unsigned int __attribute__ ((bitwidth(396))) uint396;
typedef unsigned int __attribute__ ((bitwidth(397))) uint397;
typedef unsigned int __attribute__ ((bitwidth(398))) uint398;
typedef unsigned int __attribute__ ((bitwidth(399))) uint399;
typedef unsigned int __attribute__ ((bitwidth(400))) uint400;
typedef unsigned int __attribute__ ((bitwidth(401))) uint401;
typedef unsigned int __attribute__ ((bitwidth(402))) uint402;
typedef unsigned int __attribute__ ((bitwidth(403))) uint403;
typedef unsigned int __attribute__ ((bitwidth(404))) uint404;
typedef unsigned int __attribute__ ((bitwidth(405))) uint405;
typedef unsigned int __attribute__ ((bitwidth(406))) uint406;
typedef unsigned int __attribute__ ((bitwidth(407))) uint407;
typedef unsigned int __attribute__ ((bitwidth(408))) uint408;
typedef unsigned int __attribute__ ((bitwidth(409))) uint409;
typedef unsigned int __attribute__ ((bitwidth(410))) uint410;
typedef unsigned int __attribute__ ((bitwidth(411))) uint411;
typedef unsigned int __attribute__ ((bitwidth(412))) uint412;
typedef unsigned int __attribute__ ((bitwidth(413))) uint413;
typedef unsigned int __attribute__ ((bitwidth(414))) uint414;
typedef unsigned int __attribute__ ((bitwidth(415))) uint415;
typedef unsigned int __attribute__ ((bitwidth(416))) uint416;
typedef unsigned int __attribute__ ((bitwidth(417))) uint417;
typedef unsigned int __attribute__ ((bitwidth(418))) uint418;
typedef unsigned int __attribute__ ((bitwidth(419))) uint419;
typedef unsigned int __attribute__ ((bitwidth(420))) uint420;
typedef unsigned int __attribute__ ((bitwidth(421))) uint421;
typedef unsigned int __attribute__ ((bitwidth(422))) uint422;
typedef unsigned int __attribute__ ((bitwidth(423))) uint423;
typedef unsigned int __attribute__ ((bitwidth(424))) uint424;
typedef unsigned int __attribute__ ((bitwidth(425))) uint425;
typedef unsigned int __attribute__ ((bitwidth(426))) uint426;
typedef unsigned int __attribute__ ((bitwidth(427))) uint427;
typedef unsigned int __attribute__ ((bitwidth(428))) uint428;
typedef unsigned int __attribute__ ((bitwidth(429))) uint429;
typedef unsigned int __attribute__ ((bitwidth(430))) uint430;
typedef unsigned int __attribute__ ((bitwidth(431))) uint431;
typedef unsigned int __attribute__ ((bitwidth(432))) uint432;
typedef unsigned int __attribute__ ((bitwidth(433))) uint433;
typedef unsigned int __attribute__ ((bitwidth(434))) uint434;
typedef unsigned int __attribute__ ((bitwidth(435))) uint435;
typedef unsigned int __attribute__ ((bitwidth(436))) uint436;
typedef unsigned int __attribute__ ((bitwidth(437))) uint437;
typedef unsigned int __attribute__ ((bitwidth(438))) uint438;
typedef unsigned int __attribute__ ((bitwidth(439))) uint439;
typedef unsigned int __attribute__ ((bitwidth(440))) uint440;
typedef unsigned int __attribute__ ((bitwidth(441))) uint441;
typedef unsigned int __attribute__ ((bitwidth(442))) uint442;
typedef unsigned int __attribute__ ((bitwidth(443))) uint443;
typedef unsigned int __attribute__ ((bitwidth(444))) uint444;
typedef unsigned int __attribute__ ((bitwidth(445))) uint445;
typedef unsigned int __attribute__ ((bitwidth(446))) uint446;
typedef unsigned int __attribute__ ((bitwidth(447))) uint447;
typedef unsigned int __attribute__ ((bitwidth(448))) uint448;
typedef unsigned int __attribute__ ((bitwidth(449))) uint449;
typedef unsigned int __attribute__ ((bitwidth(450))) uint450;
typedef unsigned int __attribute__ ((bitwidth(451))) uint451;
typedef unsigned int __attribute__ ((bitwidth(452))) uint452;
typedef unsigned int __attribute__ ((bitwidth(453))) uint453;
typedef unsigned int __attribute__ ((bitwidth(454))) uint454;
typedef unsigned int __attribute__ ((bitwidth(455))) uint455;
typedef unsigned int __attribute__ ((bitwidth(456))) uint456;
typedef unsigned int __attribute__ ((bitwidth(457))) uint457;
typedef unsigned int __attribute__ ((bitwidth(458))) uint458;
typedef unsigned int __attribute__ ((bitwidth(459))) uint459;
typedef unsigned int __attribute__ ((bitwidth(460))) uint460;
typedef unsigned int __attribute__ ((bitwidth(461))) uint461;
typedef unsigned int __attribute__ ((bitwidth(462))) uint462;
typedef unsigned int __attribute__ ((bitwidth(463))) uint463;
typedef unsigned int __attribute__ ((bitwidth(464))) uint464;
typedef unsigned int __attribute__ ((bitwidth(465))) uint465;
typedef unsigned int __attribute__ ((bitwidth(466))) uint466;
typedef unsigned int __attribute__ ((bitwidth(467))) uint467;
typedef unsigned int __attribute__ ((bitwidth(468))) uint468;
typedef unsigned int __attribute__ ((bitwidth(469))) uint469;
typedef unsigned int __attribute__ ((bitwidth(470))) uint470;
typedef unsigned int __attribute__ ((bitwidth(471))) uint471;
typedef unsigned int __attribute__ ((bitwidth(472))) uint472;
typedef unsigned int __attribute__ ((bitwidth(473))) uint473;
typedef unsigned int __attribute__ ((bitwidth(474))) uint474;
typedef unsigned int __attribute__ ((bitwidth(475))) uint475;
typedef unsigned int __attribute__ ((bitwidth(476))) uint476;
typedef unsigned int __attribute__ ((bitwidth(477))) uint477;
typedef unsigned int __attribute__ ((bitwidth(478))) uint478;
typedef unsigned int __attribute__ ((bitwidth(479))) uint479;
typedef unsigned int __attribute__ ((bitwidth(480))) uint480;
typedef unsigned int __attribute__ ((bitwidth(481))) uint481;
typedef unsigned int __attribute__ ((bitwidth(482))) uint482;
typedef unsigned int __attribute__ ((bitwidth(483))) uint483;
typedef unsigned int __attribute__ ((bitwidth(484))) uint484;
typedef unsigned int __attribute__ ((bitwidth(485))) uint485;
typedef unsigned int __attribute__ ((bitwidth(486))) uint486;
typedef unsigned int __attribute__ ((bitwidth(487))) uint487;
typedef unsigned int __attribute__ ((bitwidth(488))) uint488;
typedef unsigned int __attribute__ ((bitwidth(489))) uint489;
typedef unsigned int __attribute__ ((bitwidth(490))) uint490;
typedef unsigned int __attribute__ ((bitwidth(491))) uint491;
typedef unsigned int __attribute__ ((bitwidth(492))) uint492;
typedef unsigned int __attribute__ ((bitwidth(493))) uint493;
typedef unsigned int __attribute__ ((bitwidth(494))) uint494;
typedef unsigned int __attribute__ ((bitwidth(495))) uint495;
typedef unsigned int __attribute__ ((bitwidth(496))) uint496;
typedef unsigned int __attribute__ ((bitwidth(497))) uint497;
typedef unsigned int __attribute__ ((bitwidth(498))) uint498;
typedef unsigned int __attribute__ ((bitwidth(499))) uint499;
typedef unsigned int __attribute__ ((bitwidth(500))) uint500;
typedef unsigned int __attribute__ ((bitwidth(501))) uint501;
typedef unsigned int __attribute__ ((bitwidth(502))) uint502;
typedef unsigned int __attribute__ ((bitwidth(503))) uint503;
typedef unsigned int __attribute__ ((bitwidth(504))) uint504;
typedef unsigned int __attribute__ ((bitwidth(505))) uint505;
typedef unsigned int __attribute__ ((bitwidth(506))) uint506;
typedef unsigned int __attribute__ ((bitwidth(507))) uint507;
typedef unsigned int __attribute__ ((bitwidth(508))) uint508;
typedef unsigned int __attribute__ ((bitwidth(509))) uint509;
typedef unsigned int __attribute__ ((bitwidth(510))) uint510;
typedef unsigned int __attribute__ ((bitwidth(511))) uint511;
typedef unsigned int __attribute__ ((bitwidth(512))) uint512;
typedef unsigned int __attribute__ ((bitwidth(513))) uint513;
typedef unsigned int __attribute__ ((bitwidth(514))) uint514;
typedef unsigned int __attribute__ ((bitwidth(515))) uint515;
typedef unsigned int __attribute__ ((bitwidth(516))) uint516;
typedef unsigned int __attribute__ ((bitwidth(517))) uint517;
typedef unsigned int __attribute__ ((bitwidth(518))) uint518;
typedef unsigned int __attribute__ ((bitwidth(519))) uint519;
typedef unsigned int __attribute__ ((bitwidth(520))) uint520;
typedef unsigned int __attribute__ ((bitwidth(521))) uint521;
typedef unsigned int __attribute__ ((bitwidth(522))) uint522;
typedef unsigned int __attribute__ ((bitwidth(523))) uint523;
typedef unsigned int __attribute__ ((bitwidth(524))) uint524;
typedef unsigned int __attribute__ ((bitwidth(525))) uint525;
typedef unsigned int __attribute__ ((bitwidth(526))) uint526;
typedef unsigned int __attribute__ ((bitwidth(527))) uint527;
typedef unsigned int __attribute__ ((bitwidth(528))) uint528;
typedef unsigned int __attribute__ ((bitwidth(529))) uint529;
typedef unsigned int __attribute__ ((bitwidth(530))) uint530;
typedef unsigned int __attribute__ ((bitwidth(531))) uint531;
typedef unsigned int __attribute__ ((bitwidth(532))) uint532;
typedef unsigned int __attribute__ ((bitwidth(533))) uint533;
typedef unsigned int __attribute__ ((bitwidth(534))) uint534;
typedef unsigned int __attribute__ ((bitwidth(535))) uint535;
typedef unsigned int __attribute__ ((bitwidth(536))) uint536;
typedef unsigned int __attribute__ ((bitwidth(537))) uint537;
typedef unsigned int __attribute__ ((bitwidth(538))) uint538;
typedef unsigned int __attribute__ ((bitwidth(539))) uint539;
typedef unsigned int __attribute__ ((bitwidth(540))) uint540;
typedef unsigned int __attribute__ ((bitwidth(541))) uint541;
typedef unsigned int __attribute__ ((bitwidth(542))) uint542;
typedef unsigned int __attribute__ ((bitwidth(543))) uint543;
typedef unsigned int __attribute__ ((bitwidth(544))) uint544;
typedef unsigned int __attribute__ ((bitwidth(545))) uint545;
typedef unsigned int __attribute__ ((bitwidth(546))) uint546;
typedef unsigned int __attribute__ ((bitwidth(547))) uint547;
typedef unsigned int __attribute__ ((bitwidth(548))) uint548;
typedef unsigned int __attribute__ ((bitwidth(549))) uint549;
typedef unsigned int __attribute__ ((bitwidth(550))) uint550;
typedef unsigned int __attribute__ ((bitwidth(551))) uint551;
typedef unsigned int __attribute__ ((bitwidth(552))) uint552;
typedef unsigned int __attribute__ ((bitwidth(553))) uint553;
typedef unsigned int __attribute__ ((bitwidth(554))) uint554;
typedef unsigned int __attribute__ ((bitwidth(555))) uint555;
typedef unsigned int __attribute__ ((bitwidth(556))) uint556;
typedef unsigned int __attribute__ ((bitwidth(557))) uint557;
typedef unsigned int __attribute__ ((bitwidth(558))) uint558;
typedef unsigned int __attribute__ ((bitwidth(559))) uint559;
typedef unsigned int __attribute__ ((bitwidth(560))) uint560;
typedef unsigned int __attribute__ ((bitwidth(561))) uint561;
typedef unsigned int __attribute__ ((bitwidth(562))) uint562;
typedef unsigned int __attribute__ ((bitwidth(563))) uint563;
typedef unsigned int __attribute__ ((bitwidth(564))) uint564;
typedef unsigned int __attribute__ ((bitwidth(565))) uint565;
typedef unsigned int __attribute__ ((bitwidth(566))) uint566;
typedef unsigned int __attribute__ ((bitwidth(567))) uint567;
typedef unsigned int __attribute__ ((bitwidth(568))) uint568;
typedef unsigned int __attribute__ ((bitwidth(569))) uint569;
typedef unsigned int __attribute__ ((bitwidth(570))) uint570;
typedef unsigned int __attribute__ ((bitwidth(571))) uint571;
typedef unsigned int __attribute__ ((bitwidth(572))) uint572;
typedef unsigned int __attribute__ ((bitwidth(573))) uint573;
typedef unsigned int __attribute__ ((bitwidth(574))) uint574;
typedef unsigned int __attribute__ ((bitwidth(575))) uint575;
typedef unsigned int __attribute__ ((bitwidth(576))) uint576;
typedef unsigned int __attribute__ ((bitwidth(577))) uint577;
typedef unsigned int __attribute__ ((bitwidth(578))) uint578;
typedef unsigned int __attribute__ ((bitwidth(579))) uint579;
typedef unsigned int __attribute__ ((bitwidth(580))) uint580;
typedef unsigned int __attribute__ ((bitwidth(581))) uint581;
typedef unsigned int __attribute__ ((bitwidth(582))) uint582;
typedef unsigned int __attribute__ ((bitwidth(583))) uint583;
typedef unsigned int __attribute__ ((bitwidth(584))) uint584;
typedef unsigned int __attribute__ ((bitwidth(585))) uint585;
typedef unsigned int __attribute__ ((bitwidth(586))) uint586;
typedef unsigned int __attribute__ ((bitwidth(587))) uint587;
typedef unsigned int __attribute__ ((bitwidth(588))) uint588;
typedef unsigned int __attribute__ ((bitwidth(589))) uint589;
typedef unsigned int __attribute__ ((bitwidth(590))) uint590;
typedef unsigned int __attribute__ ((bitwidth(591))) uint591;
typedef unsigned int __attribute__ ((bitwidth(592))) uint592;
typedef unsigned int __attribute__ ((bitwidth(593))) uint593;
typedef unsigned int __attribute__ ((bitwidth(594))) uint594;
typedef unsigned int __attribute__ ((bitwidth(595))) uint595;
typedef unsigned int __attribute__ ((bitwidth(596))) uint596;
typedef unsigned int __attribute__ ((bitwidth(597))) uint597;
typedef unsigned int __attribute__ ((bitwidth(598))) uint598;
typedef unsigned int __attribute__ ((bitwidth(599))) uint599;
typedef unsigned int __attribute__ ((bitwidth(600))) uint600;
typedef unsigned int __attribute__ ((bitwidth(601))) uint601;
typedef unsigned int __attribute__ ((bitwidth(602))) uint602;
typedef unsigned int __attribute__ ((bitwidth(603))) uint603;
typedef unsigned int __attribute__ ((bitwidth(604))) uint604;
typedef unsigned int __attribute__ ((bitwidth(605))) uint605;
typedef unsigned int __attribute__ ((bitwidth(606))) uint606;
typedef unsigned int __attribute__ ((bitwidth(607))) uint607;
typedef unsigned int __attribute__ ((bitwidth(608))) uint608;
typedef unsigned int __attribute__ ((bitwidth(609))) uint609;
typedef unsigned int __attribute__ ((bitwidth(610))) uint610;
typedef unsigned int __attribute__ ((bitwidth(611))) uint611;
typedef unsigned int __attribute__ ((bitwidth(612))) uint612;
typedef unsigned int __attribute__ ((bitwidth(613))) uint613;
typedef unsigned int __attribute__ ((bitwidth(614))) uint614;
typedef unsigned int __attribute__ ((bitwidth(615))) uint615;
typedef unsigned int __attribute__ ((bitwidth(616))) uint616;
typedef unsigned int __attribute__ ((bitwidth(617))) uint617;
typedef unsigned int __attribute__ ((bitwidth(618))) uint618;
typedef unsigned int __attribute__ ((bitwidth(619))) uint619;
typedef unsigned int __attribute__ ((bitwidth(620))) uint620;
typedef unsigned int __attribute__ ((bitwidth(621))) uint621;
typedef unsigned int __attribute__ ((bitwidth(622))) uint622;
typedef unsigned int __attribute__ ((bitwidth(623))) uint623;
typedef unsigned int __attribute__ ((bitwidth(624))) uint624;
typedef unsigned int __attribute__ ((bitwidth(625))) uint625;
typedef unsigned int __attribute__ ((bitwidth(626))) uint626;
typedef unsigned int __attribute__ ((bitwidth(627))) uint627;
typedef unsigned int __attribute__ ((bitwidth(628))) uint628;
typedef unsigned int __attribute__ ((bitwidth(629))) uint629;
typedef unsigned int __attribute__ ((bitwidth(630))) uint630;
typedef unsigned int __attribute__ ((bitwidth(631))) uint631;
typedef unsigned int __attribute__ ((bitwidth(632))) uint632;
typedef unsigned int __attribute__ ((bitwidth(633))) uint633;
typedef unsigned int __attribute__ ((bitwidth(634))) uint634;
typedef unsigned int __attribute__ ((bitwidth(635))) uint635;
typedef unsigned int __attribute__ ((bitwidth(636))) uint636;
typedef unsigned int __attribute__ ((bitwidth(637))) uint637;
typedef unsigned int __attribute__ ((bitwidth(638))) uint638;
typedef unsigned int __attribute__ ((bitwidth(639))) uint639;
typedef unsigned int __attribute__ ((bitwidth(640))) uint640;
typedef unsigned int __attribute__ ((bitwidth(641))) uint641;
typedef unsigned int __attribute__ ((bitwidth(642))) uint642;
typedef unsigned int __attribute__ ((bitwidth(643))) uint643;
typedef unsigned int __attribute__ ((bitwidth(644))) uint644;
typedef unsigned int __attribute__ ((bitwidth(645))) uint645;
typedef unsigned int __attribute__ ((bitwidth(646))) uint646;
typedef unsigned int __attribute__ ((bitwidth(647))) uint647;
typedef unsigned int __attribute__ ((bitwidth(648))) uint648;
typedef unsigned int __attribute__ ((bitwidth(649))) uint649;
typedef unsigned int __attribute__ ((bitwidth(650))) uint650;
typedef unsigned int __attribute__ ((bitwidth(651))) uint651;
typedef unsigned int __attribute__ ((bitwidth(652))) uint652;
typedef unsigned int __attribute__ ((bitwidth(653))) uint653;
typedef unsigned int __attribute__ ((bitwidth(654))) uint654;
typedef unsigned int __attribute__ ((bitwidth(655))) uint655;
typedef unsigned int __attribute__ ((bitwidth(656))) uint656;
typedef unsigned int __attribute__ ((bitwidth(657))) uint657;
typedef unsigned int __attribute__ ((bitwidth(658))) uint658;
typedef unsigned int __attribute__ ((bitwidth(659))) uint659;
typedef unsigned int __attribute__ ((bitwidth(660))) uint660;
typedef unsigned int __attribute__ ((bitwidth(661))) uint661;
typedef unsigned int __attribute__ ((bitwidth(662))) uint662;
typedef unsigned int __attribute__ ((bitwidth(663))) uint663;
typedef unsigned int __attribute__ ((bitwidth(664))) uint664;
typedef unsigned int __attribute__ ((bitwidth(665))) uint665;
typedef unsigned int __attribute__ ((bitwidth(666))) uint666;
typedef unsigned int __attribute__ ((bitwidth(667))) uint667;
typedef unsigned int __attribute__ ((bitwidth(668))) uint668;
typedef unsigned int __attribute__ ((bitwidth(669))) uint669;
typedef unsigned int __attribute__ ((bitwidth(670))) uint670;
typedef unsigned int __attribute__ ((bitwidth(671))) uint671;
typedef unsigned int __attribute__ ((bitwidth(672))) uint672;
typedef unsigned int __attribute__ ((bitwidth(673))) uint673;
typedef unsigned int __attribute__ ((bitwidth(674))) uint674;
typedef unsigned int __attribute__ ((bitwidth(675))) uint675;
typedef unsigned int __attribute__ ((bitwidth(676))) uint676;
typedef unsigned int __attribute__ ((bitwidth(677))) uint677;
typedef unsigned int __attribute__ ((bitwidth(678))) uint678;
typedef unsigned int __attribute__ ((bitwidth(679))) uint679;
typedef unsigned int __attribute__ ((bitwidth(680))) uint680;
typedef unsigned int __attribute__ ((bitwidth(681))) uint681;
typedef unsigned int __attribute__ ((bitwidth(682))) uint682;
typedef unsigned int __attribute__ ((bitwidth(683))) uint683;
typedef unsigned int __attribute__ ((bitwidth(684))) uint684;
typedef unsigned int __attribute__ ((bitwidth(685))) uint685;
typedef unsigned int __attribute__ ((bitwidth(686))) uint686;
typedef unsigned int __attribute__ ((bitwidth(687))) uint687;
typedef unsigned int __attribute__ ((bitwidth(688))) uint688;
typedef unsigned int __attribute__ ((bitwidth(689))) uint689;
typedef unsigned int __attribute__ ((bitwidth(690))) uint690;
typedef unsigned int __attribute__ ((bitwidth(691))) uint691;
typedef unsigned int __attribute__ ((bitwidth(692))) uint692;
typedef unsigned int __attribute__ ((bitwidth(693))) uint693;
typedef unsigned int __attribute__ ((bitwidth(694))) uint694;
typedef unsigned int __attribute__ ((bitwidth(695))) uint695;
typedef unsigned int __attribute__ ((bitwidth(696))) uint696;
typedef unsigned int __attribute__ ((bitwidth(697))) uint697;
typedef unsigned int __attribute__ ((bitwidth(698))) uint698;
typedef unsigned int __attribute__ ((bitwidth(699))) uint699;
typedef unsigned int __attribute__ ((bitwidth(700))) uint700;
typedef unsigned int __attribute__ ((bitwidth(701))) uint701;
typedef unsigned int __attribute__ ((bitwidth(702))) uint702;
typedef unsigned int __attribute__ ((bitwidth(703))) uint703;
typedef unsigned int __attribute__ ((bitwidth(704))) uint704;
typedef unsigned int __attribute__ ((bitwidth(705))) uint705;
typedef unsigned int __attribute__ ((bitwidth(706))) uint706;
typedef unsigned int __attribute__ ((bitwidth(707))) uint707;
typedef unsigned int __attribute__ ((bitwidth(708))) uint708;
typedef unsigned int __attribute__ ((bitwidth(709))) uint709;
typedef unsigned int __attribute__ ((bitwidth(710))) uint710;
typedef unsigned int __attribute__ ((bitwidth(711))) uint711;
typedef unsigned int __attribute__ ((bitwidth(712))) uint712;
typedef unsigned int __attribute__ ((bitwidth(713))) uint713;
typedef unsigned int __attribute__ ((bitwidth(714))) uint714;
typedef unsigned int __attribute__ ((bitwidth(715))) uint715;
typedef unsigned int __attribute__ ((bitwidth(716))) uint716;
typedef unsigned int __attribute__ ((bitwidth(717))) uint717;
typedef unsigned int __attribute__ ((bitwidth(718))) uint718;
typedef unsigned int __attribute__ ((bitwidth(719))) uint719;
typedef unsigned int __attribute__ ((bitwidth(720))) uint720;
typedef unsigned int __attribute__ ((bitwidth(721))) uint721;
typedef unsigned int __attribute__ ((bitwidth(722))) uint722;
typedef unsigned int __attribute__ ((bitwidth(723))) uint723;
typedef unsigned int __attribute__ ((bitwidth(724))) uint724;
typedef unsigned int __attribute__ ((bitwidth(725))) uint725;
typedef unsigned int __attribute__ ((bitwidth(726))) uint726;
typedef unsigned int __attribute__ ((bitwidth(727))) uint727;
typedef unsigned int __attribute__ ((bitwidth(728))) uint728;
typedef unsigned int __attribute__ ((bitwidth(729))) uint729;
typedef unsigned int __attribute__ ((bitwidth(730))) uint730;
typedef unsigned int __attribute__ ((bitwidth(731))) uint731;
typedef unsigned int __attribute__ ((bitwidth(732))) uint732;
typedef unsigned int __attribute__ ((bitwidth(733))) uint733;
typedef unsigned int __attribute__ ((bitwidth(734))) uint734;
typedef unsigned int __attribute__ ((bitwidth(735))) uint735;
typedef unsigned int __attribute__ ((bitwidth(736))) uint736;
typedef unsigned int __attribute__ ((bitwidth(737))) uint737;
typedef unsigned int __attribute__ ((bitwidth(738))) uint738;
typedef unsigned int __attribute__ ((bitwidth(739))) uint739;
typedef unsigned int __attribute__ ((bitwidth(740))) uint740;
typedef unsigned int __attribute__ ((bitwidth(741))) uint741;
typedef unsigned int __attribute__ ((bitwidth(742))) uint742;
typedef unsigned int __attribute__ ((bitwidth(743))) uint743;
typedef unsigned int __attribute__ ((bitwidth(744))) uint744;
typedef unsigned int __attribute__ ((bitwidth(745))) uint745;
typedef unsigned int __attribute__ ((bitwidth(746))) uint746;
typedef unsigned int __attribute__ ((bitwidth(747))) uint747;
typedef unsigned int __attribute__ ((bitwidth(748))) uint748;
typedef unsigned int __attribute__ ((bitwidth(749))) uint749;
typedef unsigned int __attribute__ ((bitwidth(750))) uint750;
typedef unsigned int __attribute__ ((bitwidth(751))) uint751;
typedef unsigned int __attribute__ ((bitwidth(752))) uint752;
typedef unsigned int __attribute__ ((bitwidth(753))) uint753;
typedef unsigned int __attribute__ ((bitwidth(754))) uint754;
typedef unsigned int __attribute__ ((bitwidth(755))) uint755;
typedef unsigned int __attribute__ ((bitwidth(756))) uint756;
typedef unsigned int __attribute__ ((bitwidth(757))) uint757;
typedef unsigned int __attribute__ ((bitwidth(758))) uint758;
typedef unsigned int __attribute__ ((bitwidth(759))) uint759;
typedef unsigned int __attribute__ ((bitwidth(760))) uint760;
typedef unsigned int __attribute__ ((bitwidth(761))) uint761;
typedef unsigned int __attribute__ ((bitwidth(762))) uint762;
typedef unsigned int __attribute__ ((bitwidth(763))) uint763;
typedef unsigned int __attribute__ ((bitwidth(764))) uint764;
typedef unsigned int __attribute__ ((bitwidth(765))) uint765;
typedef unsigned int __attribute__ ((bitwidth(766))) uint766;
typedef unsigned int __attribute__ ((bitwidth(767))) uint767;
typedef unsigned int __attribute__ ((bitwidth(768))) uint768;
typedef unsigned int __attribute__ ((bitwidth(769))) uint769;
typedef unsigned int __attribute__ ((bitwidth(770))) uint770;
typedef unsigned int __attribute__ ((bitwidth(771))) uint771;
typedef unsigned int __attribute__ ((bitwidth(772))) uint772;
typedef unsigned int __attribute__ ((bitwidth(773))) uint773;
typedef unsigned int __attribute__ ((bitwidth(774))) uint774;
typedef unsigned int __attribute__ ((bitwidth(775))) uint775;
typedef unsigned int __attribute__ ((bitwidth(776))) uint776;
typedef unsigned int __attribute__ ((bitwidth(777))) uint777;
typedef unsigned int __attribute__ ((bitwidth(778))) uint778;
typedef unsigned int __attribute__ ((bitwidth(779))) uint779;
typedef unsigned int __attribute__ ((bitwidth(780))) uint780;
typedef unsigned int __attribute__ ((bitwidth(781))) uint781;
typedef unsigned int __attribute__ ((bitwidth(782))) uint782;
typedef unsigned int __attribute__ ((bitwidth(783))) uint783;
typedef unsigned int __attribute__ ((bitwidth(784))) uint784;
typedef unsigned int __attribute__ ((bitwidth(785))) uint785;
typedef unsigned int __attribute__ ((bitwidth(786))) uint786;
typedef unsigned int __attribute__ ((bitwidth(787))) uint787;
typedef unsigned int __attribute__ ((bitwidth(788))) uint788;
typedef unsigned int __attribute__ ((bitwidth(789))) uint789;
typedef unsigned int __attribute__ ((bitwidth(790))) uint790;
typedef unsigned int __attribute__ ((bitwidth(791))) uint791;
typedef unsigned int __attribute__ ((bitwidth(792))) uint792;
typedef unsigned int __attribute__ ((bitwidth(793))) uint793;
typedef unsigned int __attribute__ ((bitwidth(794))) uint794;
typedef unsigned int __attribute__ ((bitwidth(795))) uint795;
typedef unsigned int __attribute__ ((bitwidth(796))) uint796;
typedef unsigned int __attribute__ ((bitwidth(797))) uint797;
typedef unsigned int __attribute__ ((bitwidth(798))) uint798;
typedef unsigned int __attribute__ ((bitwidth(799))) uint799;
typedef unsigned int __attribute__ ((bitwidth(800))) uint800;
typedef unsigned int __attribute__ ((bitwidth(801))) uint801;
typedef unsigned int __attribute__ ((bitwidth(802))) uint802;
typedef unsigned int __attribute__ ((bitwidth(803))) uint803;
typedef unsigned int __attribute__ ((bitwidth(804))) uint804;
typedef unsigned int __attribute__ ((bitwidth(805))) uint805;
typedef unsigned int __attribute__ ((bitwidth(806))) uint806;
typedef unsigned int __attribute__ ((bitwidth(807))) uint807;
typedef unsigned int __attribute__ ((bitwidth(808))) uint808;
typedef unsigned int __attribute__ ((bitwidth(809))) uint809;
typedef unsigned int __attribute__ ((bitwidth(810))) uint810;
typedef unsigned int __attribute__ ((bitwidth(811))) uint811;
typedef unsigned int __attribute__ ((bitwidth(812))) uint812;
typedef unsigned int __attribute__ ((bitwidth(813))) uint813;
typedef unsigned int __attribute__ ((bitwidth(814))) uint814;
typedef unsigned int __attribute__ ((bitwidth(815))) uint815;
typedef unsigned int __attribute__ ((bitwidth(816))) uint816;
typedef unsigned int __attribute__ ((bitwidth(817))) uint817;
typedef unsigned int __attribute__ ((bitwidth(818))) uint818;
typedef unsigned int __attribute__ ((bitwidth(819))) uint819;
typedef unsigned int __attribute__ ((bitwidth(820))) uint820;
typedef unsigned int __attribute__ ((bitwidth(821))) uint821;
typedef unsigned int __attribute__ ((bitwidth(822))) uint822;
typedef unsigned int __attribute__ ((bitwidth(823))) uint823;
typedef unsigned int __attribute__ ((bitwidth(824))) uint824;
typedef unsigned int __attribute__ ((bitwidth(825))) uint825;
typedef unsigned int __attribute__ ((bitwidth(826))) uint826;
typedef unsigned int __attribute__ ((bitwidth(827))) uint827;
typedef unsigned int __attribute__ ((bitwidth(828))) uint828;
typedef unsigned int __attribute__ ((bitwidth(829))) uint829;
typedef unsigned int __attribute__ ((bitwidth(830))) uint830;
typedef unsigned int __attribute__ ((bitwidth(831))) uint831;
typedef unsigned int __attribute__ ((bitwidth(832))) uint832;
typedef unsigned int __attribute__ ((bitwidth(833))) uint833;
typedef unsigned int __attribute__ ((bitwidth(834))) uint834;
typedef unsigned int __attribute__ ((bitwidth(835))) uint835;
typedef unsigned int __attribute__ ((bitwidth(836))) uint836;
typedef unsigned int __attribute__ ((bitwidth(837))) uint837;
typedef unsigned int __attribute__ ((bitwidth(838))) uint838;
typedef unsigned int __attribute__ ((bitwidth(839))) uint839;
typedef unsigned int __attribute__ ((bitwidth(840))) uint840;
typedef unsigned int __attribute__ ((bitwidth(841))) uint841;
typedef unsigned int __attribute__ ((bitwidth(842))) uint842;
typedef unsigned int __attribute__ ((bitwidth(843))) uint843;
typedef unsigned int __attribute__ ((bitwidth(844))) uint844;
typedef unsigned int __attribute__ ((bitwidth(845))) uint845;
typedef unsigned int __attribute__ ((bitwidth(846))) uint846;
typedef unsigned int __attribute__ ((bitwidth(847))) uint847;
typedef unsigned int __attribute__ ((bitwidth(848))) uint848;
typedef unsigned int __attribute__ ((bitwidth(849))) uint849;
typedef unsigned int __attribute__ ((bitwidth(850))) uint850;
typedef unsigned int __attribute__ ((bitwidth(851))) uint851;
typedef unsigned int __attribute__ ((bitwidth(852))) uint852;
typedef unsigned int __attribute__ ((bitwidth(853))) uint853;
typedef unsigned int __attribute__ ((bitwidth(854))) uint854;
typedef unsigned int __attribute__ ((bitwidth(855))) uint855;
typedef unsigned int __attribute__ ((bitwidth(856))) uint856;
typedef unsigned int __attribute__ ((bitwidth(857))) uint857;
typedef unsigned int __attribute__ ((bitwidth(858))) uint858;
typedef unsigned int __attribute__ ((bitwidth(859))) uint859;
typedef unsigned int __attribute__ ((bitwidth(860))) uint860;
typedef unsigned int __attribute__ ((bitwidth(861))) uint861;
typedef unsigned int __attribute__ ((bitwidth(862))) uint862;
typedef unsigned int __attribute__ ((bitwidth(863))) uint863;
typedef unsigned int __attribute__ ((bitwidth(864))) uint864;
typedef unsigned int __attribute__ ((bitwidth(865))) uint865;
typedef unsigned int __attribute__ ((bitwidth(866))) uint866;
typedef unsigned int __attribute__ ((bitwidth(867))) uint867;
typedef unsigned int __attribute__ ((bitwidth(868))) uint868;
typedef unsigned int __attribute__ ((bitwidth(869))) uint869;
typedef unsigned int __attribute__ ((bitwidth(870))) uint870;
typedef unsigned int __attribute__ ((bitwidth(871))) uint871;
typedef unsigned int __attribute__ ((bitwidth(872))) uint872;
typedef unsigned int __attribute__ ((bitwidth(873))) uint873;
typedef unsigned int __attribute__ ((bitwidth(874))) uint874;
typedef unsigned int __attribute__ ((bitwidth(875))) uint875;
typedef unsigned int __attribute__ ((bitwidth(876))) uint876;
typedef unsigned int __attribute__ ((bitwidth(877))) uint877;
typedef unsigned int __attribute__ ((bitwidth(878))) uint878;
typedef unsigned int __attribute__ ((bitwidth(879))) uint879;
typedef unsigned int __attribute__ ((bitwidth(880))) uint880;
typedef unsigned int __attribute__ ((bitwidth(881))) uint881;
typedef unsigned int __attribute__ ((bitwidth(882))) uint882;
typedef unsigned int __attribute__ ((bitwidth(883))) uint883;
typedef unsigned int __attribute__ ((bitwidth(884))) uint884;
typedef unsigned int __attribute__ ((bitwidth(885))) uint885;
typedef unsigned int __attribute__ ((bitwidth(886))) uint886;
typedef unsigned int __attribute__ ((bitwidth(887))) uint887;
typedef unsigned int __attribute__ ((bitwidth(888))) uint888;
typedef unsigned int __attribute__ ((bitwidth(889))) uint889;
typedef unsigned int __attribute__ ((bitwidth(890))) uint890;
typedef unsigned int __attribute__ ((bitwidth(891))) uint891;
typedef unsigned int __attribute__ ((bitwidth(892))) uint892;
typedef unsigned int __attribute__ ((bitwidth(893))) uint893;
typedef unsigned int __attribute__ ((bitwidth(894))) uint894;
typedef unsigned int __attribute__ ((bitwidth(895))) uint895;
typedef unsigned int __attribute__ ((bitwidth(896))) uint896;
typedef unsigned int __attribute__ ((bitwidth(897))) uint897;
typedef unsigned int __attribute__ ((bitwidth(898))) uint898;
typedef unsigned int __attribute__ ((bitwidth(899))) uint899;
typedef unsigned int __attribute__ ((bitwidth(900))) uint900;
typedef unsigned int __attribute__ ((bitwidth(901))) uint901;
typedef unsigned int __attribute__ ((bitwidth(902))) uint902;
typedef unsigned int __attribute__ ((bitwidth(903))) uint903;
typedef unsigned int __attribute__ ((bitwidth(904))) uint904;
typedef unsigned int __attribute__ ((bitwidth(905))) uint905;
typedef unsigned int __attribute__ ((bitwidth(906))) uint906;
typedef unsigned int __attribute__ ((bitwidth(907))) uint907;
typedef unsigned int __attribute__ ((bitwidth(908))) uint908;
typedef unsigned int __attribute__ ((bitwidth(909))) uint909;
typedef unsigned int __attribute__ ((bitwidth(910))) uint910;
typedef unsigned int __attribute__ ((bitwidth(911))) uint911;
typedef unsigned int __attribute__ ((bitwidth(912))) uint912;
typedef unsigned int __attribute__ ((bitwidth(913))) uint913;
typedef unsigned int __attribute__ ((bitwidth(914))) uint914;
typedef unsigned int __attribute__ ((bitwidth(915))) uint915;
typedef unsigned int __attribute__ ((bitwidth(916))) uint916;
typedef unsigned int __attribute__ ((bitwidth(917))) uint917;
typedef unsigned int __attribute__ ((bitwidth(918))) uint918;
typedef unsigned int __attribute__ ((bitwidth(919))) uint919;
typedef unsigned int __attribute__ ((bitwidth(920))) uint920;
typedef unsigned int __attribute__ ((bitwidth(921))) uint921;
typedef unsigned int __attribute__ ((bitwidth(922))) uint922;
typedef unsigned int __attribute__ ((bitwidth(923))) uint923;
typedef unsigned int __attribute__ ((bitwidth(924))) uint924;
typedef unsigned int __attribute__ ((bitwidth(925))) uint925;
typedef unsigned int __attribute__ ((bitwidth(926))) uint926;
typedef unsigned int __attribute__ ((bitwidth(927))) uint927;
typedef unsigned int __attribute__ ((bitwidth(928))) uint928;
typedef unsigned int __attribute__ ((bitwidth(929))) uint929;
typedef unsigned int __attribute__ ((bitwidth(930))) uint930;
typedef unsigned int __attribute__ ((bitwidth(931))) uint931;
typedef unsigned int __attribute__ ((bitwidth(932))) uint932;
typedef unsigned int __attribute__ ((bitwidth(933))) uint933;
typedef unsigned int __attribute__ ((bitwidth(934))) uint934;
typedef unsigned int __attribute__ ((bitwidth(935))) uint935;
typedef unsigned int __attribute__ ((bitwidth(936))) uint936;
typedef unsigned int __attribute__ ((bitwidth(937))) uint937;
typedef unsigned int __attribute__ ((bitwidth(938))) uint938;
typedef unsigned int __attribute__ ((bitwidth(939))) uint939;
typedef unsigned int __attribute__ ((bitwidth(940))) uint940;
typedef unsigned int __attribute__ ((bitwidth(941))) uint941;
typedef unsigned int __attribute__ ((bitwidth(942))) uint942;
typedef unsigned int __attribute__ ((bitwidth(943))) uint943;
typedef unsigned int __attribute__ ((bitwidth(944))) uint944;
typedef unsigned int __attribute__ ((bitwidth(945))) uint945;
typedef unsigned int __attribute__ ((bitwidth(946))) uint946;
typedef unsigned int __attribute__ ((bitwidth(947))) uint947;
typedef unsigned int __attribute__ ((bitwidth(948))) uint948;
typedef unsigned int __attribute__ ((bitwidth(949))) uint949;
typedef unsigned int __attribute__ ((bitwidth(950))) uint950;
typedef unsigned int __attribute__ ((bitwidth(951))) uint951;
typedef unsigned int __attribute__ ((bitwidth(952))) uint952;
typedef unsigned int __attribute__ ((bitwidth(953))) uint953;
typedef unsigned int __attribute__ ((bitwidth(954))) uint954;
typedef unsigned int __attribute__ ((bitwidth(955))) uint955;
typedef unsigned int __attribute__ ((bitwidth(956))) uint956;
typedef unsigned int __attribute__ ((bitwidth(957))) uint957;
typedef unsigned int __attribute__ ((bitwidth(958))) uint958;
typedef unsigned int __attribute__ ((bitwidth(959))) uint959;
typedef unsigned int __attribute__ ((bitwidth(960))) uint960;
typedef unsigned int __attribute__ ((bitwidth(961))) uint961;
typedef unsigned int __attribute__ ((bitwidth(962))) uint962;
typedef unsigned int __attribute__ ((bitwidth(963))) uint963;
typedef unsigned int __attribute__ ((bitwidth(964))) uint964;
typedef unsigned int __attribute__ ((bitwidth(965))) uint965;
typedef unsigned int __attribute__ ((bitwidth(966))) uint966;
typedef unsigned int __attribute__ ((bitwidth(967))) uint967;
typedef unsigned int __attribute__ ((bitwidth(968))) uint968;
typedef unsigned int __attribute__ ((bitwidth(969))) uint969;
typedef unsigned int __attribute__ ((bitwidth(970))) uint970;
typedef unsigned int __attribute__ ((bitwidth(971))) uint971;
typedef unsigned int __attribute__ ((bitwidth(972))) uint972;
typedef unsigned int __attribute__ ((bitwidth(973))) uint973;
typedef unsigned int __attribute__ ((bitwidth(974))) uint974;
typedef unsigned int __attribute__ ((bitwidth(975))) uint975;
typedef unsigned int __attribute__ ((bitwidth(976))) uint976;
typedef unsigned int __attribute__ ((bitwidth(977))) uint977;
typedef unsigned int __attribute__ ((bitwidth(978))) uint978;
typedef unsigned int __attribute__ ((bitwidth(979))) uint979;
typedef unsigned int __attribute__ ((bitwidth(980))) uint980;
typedef unsigned int __attribute__ ((bitwidth(981))) uint981;
typedef unsigned int __attribute__ ((bitwidth(982))) uint982;
typedef unsigned int __attribute__ ((bitwidth(983))) uint983;
typedef unsigned int __attribute__ ((bitwidth(984))) uint984;
typedef unsigned int __attribute__ ((bitwidth(985))) uint985;
typedef unsigned int __attribute__ ((bitwidth(986))) uint986;
typedef unsigned int __attribute__ ((bitwidth(987))) uint987;
typedef unsigned int __attribute__ ((bitwidth(988))) uint988;
typedef unsigned int __attribute__ ((bitwidth(989))) uint989;
typedef unsigned int __attribute__ ((bitwidth(990))) uint990;
typedef unsigned int __attribute__ ((bitwidth(991))) uint991;
typedef unsigned int __attribute__ ((bitwidth(992))) uint992;
typedef unsigned int __attribute__ ((bitwidth(993))) uint993;
typedef unsigned int __attribute__ ((bitwidth(994))) uint994;
typedef unsigned int __attribute__ ((bitwidth(995))) uint995;
typedef unsigned int __attribute__ ((bitwidth(996))) uint996;
typedef unsigned int __attribute__ ((bitwidth(997))) uint997;
typedef unsigned int __attribute__ ((bitwidth(998))) uint998;
typedef unsigned int __attribute__ ((bitwidth(999))) uint999;
typedef unsigned int __attribute__ ((bitwidth(1000))) uint1000;
typedef unsigned int __attribute__ ((bitwidth(1001))) uint1001;
typedef unsigned int __attribute__ ((bitwidth(1002))) uint1002;
typedef unsigned int __attribute__ ((bitwidth(1003))) uint1003;
typedef unsigned int __attribute__ ((bitwidth(1004))) uint1004;
typedef unsigned int __attribute__ ((bitwidth(1005))) uint1005;
typedef unsigned int __attribute__ ((bitwidth(1006))) uint1006;
typedef unsigned int __attribute__ ((bitwidth(1007))) uint1007;
typedef unsigned int __attribute__ ((bitwidth(1008))) uint1008;
typedef unsigned int __attribute__ ((bitwidth(1009))) uint1009;
typedef unsigned int __attribute__ ((bitwidth(1010))) uint1010;
typedef unsigned int __attribute__ ((bitwidth(1011))) uint1011;
typedef unsigned int __attribute__ ((bitwidth(1012))) uint1012;
typedef unsigned int __attribute__ ((bitwidth(1013))) uint1013;
typedef unsigned int __attribute__ ((bitwidth(1014))) uint1014;
typedef unsigned int __attribute__ ((bitwidth(1015))) uint1015;
typedef unsigned int __attribute__ ((bitwidth(1016))) uint1016;
typedef unsigned int __attribute__ ((bitwidth(1017))) uint1017;
typedef unsigned int __attribute__ ((bitwidth(1018))) uint1018;
typedef unsigned int __attribute__ ((bitwidth(1019))) uint1019;
typedef unsigned int __attribute__ ((bitwidth(1020))) uint1020;
typedef unsigned int __attribute__ ((bitwidth(1021))) uint1021;
typedef unsigned int __attribute__ ((bitwidth(1022))) uint1022;
typedef unsigned int __attribute__ ((bitwidth(1023))) uint1023;
typedef unsigned int __attribute__ ((bitwidth(1024))) uint1024;
#pragma line 109 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt_ext.def" 1
#pragma empty_line
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(1025))) uint1025;
typedef unsigned int __attribute__ ((bitwidth(1026))) uint1026;
typedef unsigned int __attribute__ ((bitwidth(1027))) uint1027;
typedef unsigned int __attribute__ ((bitwidth(1028))) uint1028;
typedef unsigned int __attribute__ ((bitwidth(1029))) uint1029;
typedef unsigned int __attribute__ ((bitwidth(1030))) uint1030;
typedef unsigned int __attribute__ ((bitwidth(1031))) uint1031;
typedef unsigned int __attribute__ ((bitwidth(1032))) uint1032;
typedef unsigned int __attribute__ ((bitwidth(1033))) uint1033;
typedef unsigned int __attribute__ ((bitwidth(1034))) uint1034;
typedef unsigned int __attribute__ ((bitwidth(1035))) uint1035;
typedef unsigned int __attribute__ ((bitwidth(1036))) uint1036;
typedef unsigned int __attribute__ ((bitwidth(1037))) uint1037;
typedef unsigned int __attribute__ ((bitwidth(1038))) uint1038;
typedef unsigned int __attribute__ ((bitwidth(1039))) uint1039;
typedef unsigned int __attribute__ ((bitwidth(1040))) uint1040;
typedef unsigned int __attribute__ ((bitwidth(1041))) uint1041;
typedef unsigned int __attribute__ ((bitwidth(1042))) uint1042;
typedef unsigned int __attribute__ ((bitwidth(1043))) uint1043;
typedef unsigned int __attribute__ ((bitwidth(1044))) uint1044;
typedef unsigned int __attribute__ ((bitwidth(1045))) uint1045;
typedef unsigned int __attribute__ ((bitwidth(1046))) uint1046;
typedef unsigned int __attribute__ ((bitwidth(1047))) uint1047;
typedef unsigned int __attribute__ ((bitwidth(1048))) uint1048;
typedef unsigned int __attribute__ ((bitwidth(1049))) uint1049;
typedef unsigned int __attribute__ ((bitwidth(1050))) uint1050;
typedef unsigned int __attribute__ ((bitwidth(1051))) uint1051;
typedef unsigned int __attribute__ ((bitwidth(1052))) uint1052;
typedef unsigned int __attribute__ ((bitwidth(1053))) uint1053;
typedef unsigned int __attribute__ ((bitwidth(1054))) uint1054;
typedef unsigned int __attribute__ ((bitwidth(1055))) uint1055;
typedef unsigned int __attribute__ ((bitwidth(1056))) uint1056;
typedef unsigned int __attribute__ ((bitwidth(1057))) uint1057;
typedef unsigned int __attribute__ ((bitwidth(1058))) uint1058;
typedef unsigned int __attribute__ ((bitwidth(1059))) uint1059;
typedef unsigned int __attribute__ ((bitwidth(1060))) uint1060;
typedef unsigned int __attribute__ ((bitwidth(1061))) uint1061;
typedef unsigned int __attribute__ ((bitwidth(1062))) uint1062;
typedef unsigned int __attribute__ ((bitwidth(1063))) uint1063;
typedef unsigned int __attribute__ ((bitwidth(1064))) uint1064;
typedef unsigned int __attribute__ ((bitwidth(1065))) uint1065;
typedef unsigned int __attribute__ ((bitwidth(1066))) uint1066;
typedef unsigned int __attribute__ ((bitwidth(1067))) uint1067;
typedef unsigned int __attribute__ ((bitwidth(1068))) uint1068;
typedef unsigned int __attribute__ ((bitwidth(1069))) uint1069;
typedef unsigned int __attribute__ ((bitwidth(1070))) uint1070;
typedef unsigned int __attribute__ ((bitwidth(1071))) uint1071;
typedef unsigned int __attribute__ ((bitwidth(1072))) uint1072;
typedef unsigned int __attribute__ ((bitwidth(1073))) uint1073;
typedef unsigned int __attribute__ ((bitwidth(1074))) uint1074;
typedef unsigned int __attribute__ ((bitwidth(1075))) uint1075;
typedef unsigned int __attribute__ ((bitwidth(1076))) uint1076;
typedef unsigned int __attribute__ ((bitwidth(1077))) uint1077;
typedef unsigned int __attribute__ ((bitwidth(1078))) uint1078;
typedef unsigned int __attribute__ ((bitwidth(1079))) uint1079;
typedef unsigned int __attribute__ ((bitwidth(1080))) uint1080;
typedef unsigned int __attribute__ ((bitwidth(1081))) uint1081;
typedef unsigned int __attribute__ ((bitwidth(1082))) uint1082;
typedef unsigned int __attribute__ ((bitwidth(1083))) uint1083;
typedef unsigned int __attribute__ ((bitwidth(1084))) uint1084;
typedef unsigned int __attribute__ ((bitwidth(1085))) uint1085;
typedef unsigned int __attribute__ ((bitwidth(1086))) uint1086;
typedef unsigned int __attribute__ ((bitwidth(1087))) uint1087;
typedef unsigned int __attribute__ ((bitwidth(1088))) uint1088;
typedef unsigned int __attribute__ ((bitwidth(1089))) uint1089;
typedef unsigned int __attribute__ ((bitwidth(1090))) uint1090;
typedef unsigned int __attribute__ ((bitwidth(1091))) uint1091;
typedef unsigned int __attribute__ ((bitwidth(1092))) uint1092;
typedef unsigned int __attribute__ ((bitwidth(1093))) uint1093;
typedef unsigned int __attribute__ ((bitwidth(1094))) uint1094;
typedef unsigned int __attribute__ ((bitwidth(1095))) uint1095;
typedef unsigned int __attribute__ ((bitwidth(1096))) uint1096;
typedef unsigned int __attribute__ ((bitwidth(1097))) uint1097;
typedef unsigned int __attribute__ ((bitwidth(1098))) uint1098;
typedef unsigned int __attribute__ ((bitwidth(1099))) uint1099;
typedef unsigned int __attribute__ ((bitwidth(1100))) uint1100;
typedef unsigned int __attribute__ ((bitwidth(1101))) uint1101;
typedef unsigned int __attribute__ ((bitwidth(1102))) uint1102;
typedef unsigned int __attribute__ ((bitwidth(1103))) uint1103;
typedef unsigned int __attribute__ ((bitwidth(1104))) uint1104;
typedef unsigned int __attribute__ ((bitwidth(1105))) uint1105;
typedef unsigned int __attribute__ ((bitwidth(1106))) uint1106;
typedef unsigned int __attribute__ ((bitwidth(1107))) uint1107;
typedef unsigned int __attribute__ ((bitwidth(1108))) uint1108;
typedef unsigned int __attribute__ ((bitwidth(1109))) uint1109;
typedef unsigned int __attribute__ ((bitwidth(1110))) uint1110;
typedef unsigned int __attribute__ ((bitwidth(1111))) uint1111;
typedef unsigned int __attribute__ ((bitwidth(1112))) uint1112;
typedef unsigned int __attribute__ ((bitwidth(1113))) uint1113;
typedef unsigned int __attribute__ ((bitwidth(1114))) uint1114;
typedef unsigned int __attribute__ ((bitwidth(1115))) uint1115;
typedef unsigned int __attribute__ ((bitwidth(1116))) uint1116;
typedef unsigned int __attribute__ ((bitwidth(1117))) uint1117;
typedef unsigned int __attribute__ ((bitwidth(1118))) uint1118;
typedef unsigned int __attribute__ ((bitwidth(1119))) uint1119;
typedef unsigned int __attribute__ ((bitwidth(1120))) uint1120;
typedef unsigned int __attribute__ ((bitwidth(1121))) uint1121;
typedef unsigned int __attribute__ ((bitwidth(1122))) uint1122;
typedef unsigned int __attribute__ ((bitwidth(1123))) uint1123;
typedef unsigned int __attribute__ ((bitwidth(1124))) uint1124;
typedef unsigned int __attribute__ ((bitwidth(1125))) uint1125;
typedef unsigned int __attribute__ ((bitwidth(1126))) uint1126;
typedef unsigned int __attribute__ ((bitwidth(1127))) uint1127;
typedef unsigned int __attribute__ ((bitwidth(1128))) uint1128;
typedef unsigned int __attribute__ ((bitwidth(1129))) uint1129;
typedef unsigned int __attribute__ ((bitwidth(1130))) uint1130;
typedef unsigned int __attribute__ ((bitwidth(1131))) uint1131;
typedef unsigned int __attribute__ ((bitwidth(1132))) uint1132;
typedef unsigned int __attribute__ ((bitwidth(1133))) uint1133;
typedef unsigned int __attribute__ ((bitwidth(1134))) uint1134;
typedef unsigned int __attribute__ ((bitwidth(1135))) uint1135;
typedef unsigned int __attribute__ ((bitwidth(1136))) uint1136;
typedef unsigned int __attribute__ ((bitwidth(1137))) uint1137;
typedef unsigned int __attribute__ ((bitwidth(1138))) uint1138;
typedef unsigned int __attribute__ ((bitwidth(1139))) uint1139;
typedef unsigned int __attribute__ ((bitwidth(1140))) uint1140;
typedef unsigned int __attribute__ ((bitwidth(1141))) uint1141;
typedef unsigned int __attribute__ ((bitwidth(1142))) uint1142;
typedef unsigned int __attribute__ ((bitwidth(1143))) uint1143;
typedef unsigned int __attribute__ ((bitwidth(1144))) uint1144;
typedef unsigned int __attribute__ ((bitwidth(1145))) uint1145;
typedef unsigned int __attribute__ ((bitwidth(1146))) uint1146;
typedef unsigned int __attribute__ ((bitwidth(1147))) uint1147;
typedef unsigned int __attribute__ ((bitwidth(1148))) uint1148;
typedef unsigned int __attribute__ ((bitwidth(1149))) uint1149;
typedef unsigned int __attribute__ ((bitwidth(1150))) uint1150;
typedef unsigned int __attribute__ ((bitwidth(1151))) uint1151;
typedef unsigned int __attribute__ ((bitwidth(1152))) uint1152;
typedef unsigned int __attribute__ ((bitwidth(1153))) uint1153;
typedef unsigned int __attribute__ ((bitwidth(1154))) uint1154;
typedef unsigned int __attribute__ ((bitwidth(1155))) uint1155;
typedef unsigned int __attribute__ ((bitwidth(1156))) uint1156;
typedef unsigned int __attribute__ ((bitwidth(1157))) uint1157;
typedef unsigned int __attribute__ ((bitwidth(1158))) uint1158;
typedef unsigned int __attribute__ ((bitwidth(1159))) uint1159;
typedef unsigned int __attribute__ ((bitwidth(1160))) uint1160;
typedef unsigned int __attribute__ ((bitwidth(1161))) uint1161;
typedef unsigned int __attribute__ ((bitwidth(1162))) uint1162;
typedef unsigned int __attribute__ ((bitwidth(1163))) uint1163;
typedef unsigned int __attribute__ ((bitwidth(1164))) uint1164;
typedef unsigned int __attribute__ ((bitwidth(1165))) uint1165;
typedef unsigned int __attribute__ ((bitwidth(1166))) uint1166;
typedef unsigned int __attribute__ ((bitwidth(1167))) uint1167;
typedef unsigned int __attribute__ ((bitwidth(1168))) uint1168;
typedef unsigned int __attribute__ ((bitwidth(1169))) uint1169;
typedef unsigned int __attribute__ ((bitwidth(1170))) uint1170;
typedef unsigned int __attribute__ ((bitwidth(1171))) uint1171;
typedef unsigned int __attribute__ ((bitwidth(1172))) uint1172;
typedef unsigned int __attribute__ ((bitwidth(1173))) uint1173;
typedef unsigned int __attribute__ ((bitwidth(1174))) uint1174;
typedef unsigned int __attribute__ ((bitwidth(1175))) uint1175;
typedef unsigned int __attribute__ ((bitwidth(1176))) uint1176;
typedef unsigned int __attribute__ ((bitwidth(1177))) uint1177;
typedef unsigned int __attribute__ ((bitwidth(1178))) uint1178;
typedef unsigned int __attribute__ ((bitwidth(1179))) uint1179;
typedef unsigned int __attribute__ ((bitwidth(1180))) uint1180;
typedef unsigned int __attribute__ ((bitwidth(1181))) uint1181;
typedef unsigned int __attribute__ ((bitwidth(1182))) uint1182;
typedef unsigned int __attribute__ ((bitwidth(1183))) uint1183;
typedef unsigned int __attribute__ ((bitwidth(1184))) uint1184;
typedef unsigned int __attribute__ ((bitwidth(1185))) uint1185;
typedef unsigned int __attribute__ ((bitwidth(1186))) uint1186;
typedef unsigned int __attribute__ ((bitwidth(1187))) uint1187;
typedef unsigned int __attribute__ ((bitwidth(1188))) uint1188;
typedef unsigned int __attribute__ ((bitwidth(1189))) uint1189;
typedef unsigned int __attribute__ ((bitwidth(1190))) uint1190;
typedef unsigned int __attribute__ ((bitwidth(1191))) uint1191;
typedef unsigned int __attribute__ ((bitwidth(1192))) uint1192;
typedef unsigned int __attribute__ ((bitwidth(1193))) uint1193;
typedef unsigned int __attribute__ ((bitwidth(1194))) uint1194;
typedef unsigned int __attribute__ ((bitwidth(1195))) uint1195;
typedef unsigned int __attribute__ ((bitwidth(1196))) uint1196;
typedef unsigned int __attribute__ ((bitwidth(1197))) uint1197;
typedef unsigned int __attribute__ ((bitwidth(1198))) uint1198;
typedef unsigned int __attribute__ ((bitwidth(1199))) uint1199;
typedef unsigned int __attribute__ ((bitwidth(1200))) uint1200;
typedef unsigned int __attribute__ ((bitwidth(1201))) uint1201;
typedef unsigned int __attribute__ ((bitwidth(1202))) uint1202;
typedef unsigned int __attribute__ ((bitwidth(1203))) uint1203;
typedef unsigned int __attribute__ ((bitwidth(1204))) uint1204;
typedef unsigned int __attribute__ ((bitwidth(1205))) uint1205;
typedef unsigned int __attribute__ ((bitwidth(1206))) uint1206;
typedef unsigned int __attribute__ ((bitwidth(1207))) uint1207;
typedef unsigned int __attribute__ ((bitwidth(1208))) uint1208;
typedef unsigned int __attribute__ ((bitwidth(1209))) uint1209;
typedef unsigned int __attribute__ ((bitwidth(1210))) uint1210;
typedef unsigned int __attribute__ ((bitwidth(1211))) uint1211;
typedef unsigned int __attribute__ ((bitwidth(1212))) uint1212;
typedef unsigned int __attribute__ ((bitwidth(1213))) uint1213;
typedef unsigned int __attribute__ ((bitwidth(1214))) uint1214;
typedef unsigned int __attribute__ ((bitwidth(1215))) uint1215;
typedef unsigned int __attribute__ ((bitwidth(1216))) uint1216;
typedef unsigned int __attribute__ ((bitwidth(1217))) uint1217;
typedef unsigned int __attribute__ ((bitwidth(1218))) uint1218;
typedef unsigned int __attribute__ ((bitwidth(1219))) uint1219;
typedef unsigned int __attribute__ ((bitwidth(1220))) uint1220;
typedef unsigned int __attribute__ ((bitwidth(1221))) uint1221;
typedef unsigned int __attribute__ ((bitwidth(1222))) uint1222;
typedef unsigned int __attribute__ ((bitwidth(1223))) uint1223;
typedef unsigned int __attribute__ ((bitwidth(1224))) uint1224;
typedef unsigned int __attribute__ ((bitwidth(1225))) uint1225;
typedef unsigned int __attribute__ ((bitwidth(1226))) uint1226;
typedef unsigned int __attribute__ ((bitwidth(1227))) uint1227;
typedef unsigned int __attribute__ ((bitwidth(1228))) uint1228;
typedef unsigned int __attribute__ ((bitwidth(1229))) uint1229;
typedef unsigned int __attribute__ ((bitwidth(1230))) uint1230;
typedef unsigned int __attribute__ ((bitwidth(1231))) uint1231;
typedef unsigned int __attribute__ ((bitwidth(1232))) uint1232;
typedef unsigned int __attribute__ ((bitwidth(1233))) uint1233;
typedef unsigned int __attribute__ ((bitwidth(1234))) uint1234;
typedef unsigned int __attribute__ ((bitwidth(1235))) uint1235;
typedef unsigned int __attribute__ ((bitwidth(1236))) uint1236;
typedef unsigned int __attribute__ ((bitwidth(1237))) uint1237;
typedef unsigned int __attribute__ ((bitwidth(1238))) uint1238;
typedef unsigned int __attribute__ ((bitwidth(1239))) uint1239;
typedef unsigned int __attribute__ ((bitwidth(1240))) uint1240;
typedef unsigned int __attribute__ ((bitwidth(1241))) uint1241;
typedef unsigned int __attribute__ ((bitwidth(1242))) uint1242;
typedef unsigned int __attribute__ ((bitwidth(1243))) uint1243;
typedef unsigned int __attribute__ ((bitwidth(1244))) uint1244;
typedef unsigned int __attribute__ ((bitwidth(1245))) uint1245;
typedef unsigned int __attribute__ ((bitwidth(1246))) uint1246;
typedef unsigned int __attribute__ ((bitwidth(1247))) uint1247;
typedef unsigned int __attribute__ ((bitwidth(1248))) uint1248;
typedef unsigned int __attribute__ ((bitwidth(1249))) uint1249;
typedef unsigned int __attribute__ ((bitwidth(1250))) uint1250;
typedef unsigned int __attribute__ ((bitwidth(1251))) uint1251;
typedef unsigned int __attribute__ ((bitwidth(1252))) uint1252;
typedef unsigned int __attribute__ ((bitwidth(1253))) uint1253;
typedef unsigned int __attribute__ ((bitwidth(1254))) uint1254;
typedef unsigned int __attribute__ ((bitwidth(1255))) uint1255;
typedef unsigned int __attribute__ ((bitwidth(1256))) uint1256;
typedef unsigned int __attribute__ ((bitwidth(1257))) uint1257;
typedef unsigned int __attribute__ ((bitwidth(1258))) uint1258;
typedef unsigned int __attribute__ ((bitwidth(1259))) uint1259;
typedef unsigned int __attribute__ ((bitwidth(1260))) uint1260;
typedef unsigned int __attribute__ ((bitwidth(1261))) uint1261;
typedef unsigned int __attribute__ ((bitwidth(1262))) uint1262;
typedef unsigned int __attribute__ ((bitwidth(1263))) uint1263;
typedef unsigned int __attribute__ ((bitwidth(1264))) uint1264;
typedef unsigned int __attribute__ ((bitwidth(1265))) uint1265;
typedef unsigned int __attribute__ ((bitwidth(1266))) uint1266;
typedef unsigned int __attribute__ ((bitwidth(1267))) uint1267;
typedef unsigned int __attribute__ ((bitwidth(1268))) uint1268;
typedef unsigned int __attribute__ ((bitwidth(1269))) uint1269;
typedef unsigned int __attribute__ ((bitwidth(1270))) uint1270;
typedef unsigned int __attribute__ ((bitwidth(1271))) uint1271;
typedef unsigned int __attribute__ ((bitwidth(1272))) uint1272;
typedef unsigned int __attribute__ ((bitwidth(1273))) uint1273;
typedef unsigned int __attribute__ ((bitwidth(1274))) uint1274;
typedef unsigned int __attribute__ ((bitwidth(1275))) uint1275;
typedef unsigned int __attribute__ ((bitwidth(1276))) uint1276;
typedef unsigned int __attribute__ ((bitwidth(1277))) uint1277;
typedef unsigned int __attribute__ ((bitwidth(1278))) uint1278;
typedef unsigned int __attribute__ ((bitwidth(1279))) uint1279;
typedef unsigned int __attribute__ ((bitwidth(1280))) uint1280;
typedef unsigned int __attribute__ ((bitwidth(1281))) uint1281;
typedef unsigned int __attribute__ ((bitwidth(1282))) uint1282;
typedef unsigned int __attribute__ ((bitwidth(1283))) uint1283;
typedef unsigned int __attribute__ ((bitwidth(1284))) uint1284;
typedef unsigned int __attribute__ ((bitwidth(1285))) uint1285;
typedef unsigned int __attribute__ ((bitwidth(1286))) uint1286;
typedef unsigned int __attribute__ ((bitwidth(1287))) uint1287;
typedef unsigned int __attribute__ ((bitwidth(1288))) uint1288;
typedef unsigned int __attribute__ ((bitwidth(1289))) uint1289;
typedef unsigned int __attribute__ ((bitwidth(1290))) uint1290;
typedef unsigned int __attribute__ ((bitwidth(1291))) uint1291;
typedef unsigned int __attribute__ ((bitwidth(1292))) uint1292;
typedef unsigned int __attribute__ ((bitwidth(1293))) uint1293;
typedef unsigned int __attribute__ ((bitwidth(1294))) uint1294;
typedef unsigned int __attribute__ ((bitwidth(1295))) uint1295;
typedef unsigned int __attribute__ ((bitwidth(1296))) uint1296;
typedef unsigned int __attribute__ ((bitwidth(1297))) uint1297;
typedef unsigned int __attribute__ ((bitwidth(1298))) uint1298;
typedef unsigned int __attribute__ ((bitwidth(1299))) uint1299;
typedef unsigned int __attribute__ ((bitwidth(1300))) uint1300;
typedef unsigned int __attribute__ ((bitwidth(1301))) uint1301;
typedef unsigned int __attribute__ ((bitwidth(1302))) uint1302;
typedef unsigned int __attribute__ ((bitwidth(1303))) uint1303;
typedef unsigned int __attribute__ ((bitwidth(1304))) uint1304;
typedef unsigned int __attribute__ ((bitwidth(1305))) uint1305;
typedef unsigned int __attribute__ ((bitwidth(1306))) uint1306;
typedef unsigned int __attribute__ ((bitwidth(1307))) uint1307;
typedef unsigned int __attribute__ ((bitwidth(1308))) uint1308;
typedef unsigned int __attribute__ ((bitwidth(1309))) uint1309;
typedef unsigned int __attribute__ ((bitwidth(1310))) uint1310;
typedef unsigned int __attribute__ ((bitwidth(1311))) uint1311;
typedef unsigned int __attribute__ ((bitwidth(1312))) uint1312;
typedef unsigned int __attribute__ ((bitwidth(1313))) uint1313;
typedef unsigned int __attribute__ ((bitwidth(1314))) uint1314;
typedef unsigned int __attribute__ ((bitwidth(1315))) uint1315;
typedef unsigned int __attribute__ ((bitwidth(1316))) uint1316;
typedef unsigned int __attribute__ ((bitwidth(1317))) uint1317;
typedef unsigned int __attribute__ ((bitwidth(1318))) uint1318;
typedef unsigned int __attribute__ ((bitwidth(1319))) uint1319;
typedef unsigned int __attribute__ ((bitwidth(1320))) uint1320;
typedef unsigned int __attribute__ ((bitwidth(1321))) uint1321;
typedef unsigned int __attribute__ ((bitwidth(1322))) uint1322;
typedef unsigned int __attribute__ ((bitwidth(1323))) uint1323;
typedef unsigned int __attribute__ ((bitwidth(1324))) uint1324;
typedef unsigned int __attribute__ ((bitwidth(1325))) uint1325;
typedef unsigned int __attribute__ ((bitwidth(1326))) uint1326;
typedef unsigned int __attribute__ ((bitwidth(1327))) uint1327;
typedef unsigned int __attribute__ ((bitwidth(1328))) uint1328;
typedef unsigned int __attribute__ ((bitwidth(1329))) uint1329;
typedef unsigned int __attribute__ ((bitwidth(1330))) uint1330;
typedef unsigned int __attribute__ ((bitwidth(1331))) uint1331;
typedef unsigned int __attribute__ ((bitwidth(1332))) uint1332;
typedef unsigned int __attribute__ ((bitwidth(1333))) uint1333;
typedef unsigned int __attribute__ ((bitwidth(1334))) uint1334;
typedef unsigned int __attribute__ ((bitwidth(1335))) uint1335;
typedef unsigned int __attribute__ ((bitwidth(1336))) uint1336;
typedef unsigned int __attribute__ ((bitwidth(1337))) uint1337;
typedef unsigned int __attribute__ ((bitwidth(1338))) uint1338;
typedef unsigned int __attribute__ ((bitwidth(1339))) uint1339;
typedef unsigned int __attribute__ ((bitwidth(1340))) uint1340;
typedef unsigned int __attribute__ ((bitwidth(1341))) uint1341;
typedef unsigned int __attribute__ ((bitwidth(1342))) uint1342;
typedef unsigned int __attribute__ ((bitwidth(1343))) uint1343;
typedef unsigned int __attribute__ ((bitwidth(1344))) uint1344;
typedef unsigned int __attribute__ ((bitwidth(1345))) uint1345;
typedef unsigned int __attribute__ ((bitwidth(1346))) uint1346;
typedef unsigned int __attribute__ ((bitwidth(1347))) uint1347;
typedef unsigned int __attribute__ ((bitwidth(1348))) uint1348;
typedef unsigned int __attribute__ ((bitwidth(1349))) uint1349;
typedef unsigned int __attribute__ ((bitwidth(1350))) uint1350;
typedef unsigned int __attribute__ ((bitwidth(1351))) uint1351;
typedef unsigned int __attribute__ ((bitwidth(1352))) uint1352;
typedef unsigned int __attribute__ ((bitwidth(1353))) uint1353;
typedef unsigned int __attribute__ ((bitwidth(1354))) uint1354;
typedef unsigned int __attribute__ ((bitwidth(1355))) uint1355;
typedef unsigned int __attribute__ ((bitwidth(1356))) uint1356;
typedef unsigned int __attribute__ ((bitwidth(1357))) uint1357;
typedef unsigned int __attribute__ ((bitwidth(1358))) uint1358;
typedef unsigned int __attribute__ ((bitwidth(1359))) uint1359;
typedef unsigned int __attribute__ ((bitwidth(1360))) uint1360;
typedef unsigned int __attribute__ ((bitwidth(1361))) uint1361;
typedef unsigned int __attribute__ ((bitwidth(1362))) uint1362;
typedef unsigned int __attribute__ ((bitwidth(1363))) uint1363;
typedef unsigned int __attribute__ ((bitwidth(1364))) uint1364;
typedef unsigned int __attribute__ ((bitwidth(1365))) uint1365;
typedef unsigned int __attribute__ ((bitwidth(1366))) uint1366;
typedef unsigned int __attribute__ ((bitwidth(1367))) uint1367;
typedef unsigned int __attribute__ ((bitwidth(1368))) uint1368;
typedef unsigned int __attribute__ ((bitwidth(1369))) uint1369;
typedef unsigned int __attribute__ ((bitwidth(1370))) uint1370;
typedef unsigned int __attribute__ ((bitwidth(1371))) uint1371;
typedef unsigned int __attribute__ ((bitwidth(1372))) uint1372;
typedef unsigned int __attribute__ ((bitwidth(1373))) uint1373;
typedef unsigned int __attribute__ ((bitwidth(1374))) uint1374;
typedef unsigned int __attribute__ ((bitwidth(1375))) uint1375;
typedef unsigned int __attribute__ ((bitwidth(1376))) uint1376;
typedef unsigned int __attribute__ ((bitwidth(1377))) uint1377;
typedef unsigned int __attribute__ ((bitwidth(1378))) uint1378;
typedef unsigned int __attribute__ ((bitwidth(1379))) uint1379;
typedef unsigned int __attribute__ ((bitwidth(1380))) uint1380;
typedef unsigned int __attribute__ ((bitwidth(1381))) uint1381;
typedef unsigned int __attribute__ ((bitwidth(1382))) uint1382;
typedef unsigned int __attribute__ ((bitwidth(1383))) uint1383;
typedef unsigned int __attribute__ ((bitwidth(1384))) uint1384;
typedef unsigned int __attribute__ ((bitwidth(1385))) uint1385;
typedef unsigned int __attribute__ ((bitwidth(1386))) uint1386;
typedef unsigned int __attribute__ ((bitwidth(1387))) uint1387;
typedef unsigned int __attribute__ ((bitwidth(1388))) uint1388;
typedef unsigned int __attribute__ ((bitwidth(1389))) uint1389;
typedef unsigned int __attribute__ ((bitwidth(1390))) uint1390;
typedef unsigned int __attribute__ ((bitwidth(1391))) uint1391;
typedef unsigned int __attribute__ ((bitwidth(1392))) uint1392;
typedef unsigned int __attribute__ ((bitwidth(1393))) uint1393;
typedef unsigned int __attribute__ ((bitwidth(1394))) uint1394;
typedef unsigned int __attribute__ ((bitwidth(1395))) uint1395;
typedef unsigned int __attribute__ ((bitwidth(1396))) uint1396;
typedef unsigned int __attribute__ ((bitwidth(1397))) uint1397;
typedef unsigned int __attribute__ ((bitwidth(1398))) uint1398;
typedef unsigned int __attribute__ ((bitwidth(1399))) uint1399;
typedef unsigned int __attribute__ ((bitwidth(1400))) uint1400;
typedef unsigned int __attribute__ ((bitwidth(1401))) uint1401;
typedef unsigned int __attribute__ ((bitwidth(1402))) uint1402;
typedef unsigned int __attribute__ ((bitwidth(1403))) uint1403;
typedef unsigned int __attribute__ ((bitwidth(1404))) uint1404;
typedef unsigned int __attribute__ ((bitwidth(1405))) uint1405;
typedef unsigned int __attribute__ ((bitwidth(1406))) uint1406;
typedef unsigned int __attribute__ ((bitwidth(1407))) uint1407;
typedef unsigned int __attribute__ ((bitwidth(1408))) uint1408;
typedef unsigned int __attribute__ ((bitwidth(1409))) uint1409;
typedef unsigned int __attribute__ ((bitwidth(1410))) uint1410;
typedef unsigned int __attribute__ ((bitwidth(1411))) uint1411;
typedef unsigned int __attribute__ ((bitwidth(1412))) uint1412;
typedef unsigned int __attribute__ ((bitwidth(1413))) uint1413;
typedef unsigned int __attribute__ ((bitwidth(1414))) uint1414;
typedef unsigned int __attribute__ ((bitwidth(1415))) uint1415;
typedef unsigned int __attribute__ ((bitwidth(1416))) uint1416;
typedef unsigned int __attribute__ ((bitwidth(1417))) uint1417;
typedef unsigned int __attribute__ ((bitwidth(1418))) uint1418;
typedef unsigned int __attribute__ ((bitwidth(1419))) uint1419;
typedef unsigned int __attribute__ ((bitwidth(1420))) uint1420;
typedef unsigned int __attribute__ ((bitwidth(1421))) uint1421;
typedef unsigned int __attribute__ ((bitwidth(1422))) uint1422;
typedef unsigned int __attribute__ ((bitwidth(1423))) uint1423;
typedef unsigned int __attribute__ ((bitwidth(1424))) uint1424;
typedef unsigned int __attribute__ ((bitwidth(1425))) uint1425;
typedef unsigned int __attribute__ ((bitwidth(1426))) uint1426;
typedef unsigned int __attribute__ ((bitwidth(1427))) uint1427;
typedef unsigned int __attribute__ ((bitwidth(1428))) uint1428;
typedef unsigned int __attribute__ ((bitwidth(1429))) uint1429;
typedef unsigned int __attribute__ ((bitwidth(1430))) uint1430;
typedef unsigned int __attribute__ ((bitwidth(1431))) uint1431;
typedef unsigned int __attribute__ ((bitwidth(1432))) uint1432;
typedef unsigned int __attribute__ ((bitwidth(1433))) uint1433;
typedef unsigned int __attribute__ ((bitwidth(1434))) uint1434;
typedef unsigned int __attribute__ ((bitwidth(1435))) uint1435;
typedef unsigned int __attribute__ ((bitwidth(1436))) uint1436;
typedef unsigned int __attribute__ ((bitwidth(1437))) uint1437;
typedef unsigned int __attribute__ ((bitwidth(1438))) uint1438;
typedef unsigned int __attribute__ ((bitwidth(1439))) uint1439;
typedef unsigned int __attribute__ ((bitwidth(1440))) uint1440;
typedef unsigned int __attribute__ ((bitwidth(1441))) uint1441;
typedef unsigned int __attribute__ ((bitwidth(1442))) uint1442;
typedef unsigned int __attribute__ ((bitwidth(1443))) uint1443;
typedef unsigned int __attribute__ ((bitwidth(1444))) uint1444;
typedef unsigned int __attribute__ ((bitwidth(1445))) uint1445;
typedef unsigned int __attribute__ ((bitwidth(1446))) uint1446;
typedef unsigned int __attribute__ ((bitwidth(1447))) uint1447;
typedef unsigned int __attribute__ ((bitwidth(1448))) uint1448;
typedef unsigned int __attribute__ ((bitwidth(1449))) uint1449;
typedef unsigned int __attribute__ ((bitwidth(1450))) uint1450;
typedef unsigned int __attribute__ ((bitwidth(1451))) uint1451;
typedef unsigned int __attribute__ ((bitwidth(1452))) uint1452;
typedef unsigned int __attribute__ ((bitwidth(1453))) uint1453;
typedef unsigned int __attribute__ ((bitwidth(1454))) uint1454;
typedef unsigned int __attribute__ ((bitwidth(1455))) uint1455;
typedef unsigned int __attribute__ ((bitwidth(1456))) uint1456;
typedef unsigned int __attribute__ ((bitwidth(1457))) uint1457;
typedef unsigned int __attribute__ ((bitwidth(1458))) uint1458;
typedef unsigned int __attribute__ ((bitwidth(1459))) uint1459;
typedef unsigned int __attribute__ ((bitwidth(1460))) uint1460;
typedef unsigned int __attribute__ ((bitwidth(1461))) uint1461;
typedef unsigned int __attribute__ ((bitwidth(1462))) uint1462;
typedef unsigned int __attribute__ ((bitwidth(1463))) uint1463;
typedef unsigned int __attribute__ ((bitwidth(1464))) uint1464;
typedef unsigned int __attribute__ ((bitwidth(1465))) uint1465;
typedef unsigned int __attribute__ ((bitwidth(1466))) uint1466;
typedef unsigned int __attribute__ ((bitwidth(1467))) uint1467;
typedef unsigned int __attribute__ ((bitwidth(1468))) uint1468;
typedef unsigned int __attribute__ ((bitwidth(1469))) uint1469;
typedef unsigned int __attribute__ ((bitwidth(1470))) uint1470;
typedef unsigned int __attribute__ ((bitwidth(1471))) uint1471;
typedef unsigned int __attribute__ ((bitwidth(1472))) uint1472;
typedef unsigned int __attribute__ ((bitwidth(1473))) uint1473;
typedef unsigned int __attribute__ ((bitwidth(1474))) uint1474;
typedef unsigned int __attribute__ ((bitwidth(1475))) uint1475;
typedef unsigned int __attribute__ ((bitwidth(1476))) uint1476;
typedef unsigned int __attribute__ ((bitwidth(1477))) uint1477;
typedef unsigned int __attribute__ ((bitwidth(1478))) uint1478;
typedef unsigned int __attribute__ ((bitwidth(1479))) uint1479;
typedef unsigned int __attribute__ ((bitwidth(1480))) uint1480;
typedef unsigned int __attribute__ ((bitwidth(1481))) uint1481;
typedef unsigned int __attribute__ ((bitwidth(1482))) uint1482;
typedef unsigned int __attribute__ ((bitwidth(1483))) uint1483;
typedef unsigned int __attribute__ ((bitwidth(1484))) uint1484;
typedef unsigned int __attribute__ ((bitwidth(1485))) uint1485;
typedef unsigned int __attribute__ ((bitwidth(1486))) uint1486;
typedef unsigned int __attribute__ ((bitwidth(1487))) uint1487;
typedef unsigned int __attribute__ ((bitwidth(1488))) uint1488;
typedef unsigned int __attribute__ ((bitwidth(1489))) uint1489;
typedef unsigned int __attribute__ ((bitwidth(1490))) uint1490;
typedef unsigned int __attribute__ ((bitwidth(1491))) uint1491;
typedef unsigned int __attribute__ ((bitwidth(1492))) uint1492;
typedef unsigned int __attribute__ ((bitwidth(1493))) uint1493;
typedef unsigned int __attribute__ ((bitwidth(1494))) uint1494;
typedef unsigned int __attribute__ ((bitwidth(1495))) uint1495;
typedef unsigned int __attribute__ ((bitwidth(1496))) uint1496;
typedef unsigned int __attribute__ ((bitwidth(1497))) uint1497;
typedef unsigned int __attribute__ ((bitwidth(1498))) uint1498;
typedef unsigned int __attribute__ ((bitwidth(1499))) uint1499;
typedef unsigned int __attribute__ ((bitwidth(1500))) uint1500;
typedef unsigned int __attribute__ ((bitwidth(1501))) uint1501;
typedef unsigned int __attribute__ ((bitwidth(1502))) uint1502;
typedef unsigned int __attribute__ ((bitwidth(1503))) uint1503;
typedef unsigned int __attribute__ ((bitwidth(1504))) uint1504;
typedef unsigned int __attribute__ ((bitwidth(1505))) uint1505;
typedef unsigned int __attribute__ ((bitwidth(1506))) uint1506;
typedef unsigned int __attribute__ ((bitwidth(1507))) uint1507;
typedef unsigned int __attribute__ ((bitwidth(1508))) uint1508;
typedef unsigned int __attribute__ ((bitwidth(1509))) uint1509;
typedef unsigned int __attribute__ ((bitwidth(1510))) uint1510;
typedef unsigned int __attribute__ ((bitwidth(1511))) uint1511;
typedef unsigned int __attribute__ ((bitwidth(1512))) uint1512;
typedef unsigned int __attribute__ ((bitwidth(1513))) uint1513;
typedef unsigned int __attribute__ ((bitwidth(1514))) uint1514;
typedef unsigned int __attribute__ ((bitwidth(1515))) uint1515;
typedef unsigned int __attribute__ ((bitwidth(1516))) uint1516;
typedef unsigned int __attribute__ ((bitwidth(1517))) uint1517;
typedef unsigned int __attribute__ ((bitwidth(1518))) uint1518;
typedef unsigned int __attribute__ ((bitwidth(1519))) uint1519;
typedef unsigned int __attribute__ ((bitwidth(1520))) uint1520;
typedef unsigned int __attribute__ ((bitwidth(1521))) uint1521;
typedef unsigned int __attribute__ ((bitwidth(1522))) uint1522;
typedef unsigned int __attribute__ ((bitwidth(1523))) uint1523;
typedef unsigned int __attribute__ ((bitwidth(1524))) uint1524;
typedef unsigned int __attribute__ ((bitwidth(1525))) uint1525;
typedef unsigned int __attribute__ ((bitwidth(1526))) uint1526;
typedef unsigned int __attribute__ ((bitwidth(1527))) uint1527;
typedef unsigned int __attribute__ ((bitwidth(1528))) uint1528;
typedef unsigned int __attribute__ ((bitwidth(1529))) uint1529;
typedef unsigned int __attribute__ ((bitwidth(1530))) uint1530;
typedef unsigned int __attribute__ ((bitwidth(1531))) uint1531;
typedef unsigned int __attribute__ ((bitwidth(1532))) uint1532;
typedef unsigned int __attribute__ ((bitwidth(1533))) uint1533;
typedef unsigned int __attribute__ ((bitwidth(1534))) uint1534;
typedef unsigned int __attribute__ ((bitwidth(1535))) uint1535;
typedef unsigned int __attribute__ ((bitwidth(1536))) uint1536;
typedef unsigned int __attribute__ ((bitwidth(1537))) uint1537;
typedef unsigned int __attribute__ ((bitwidth(1538))) uint1538;
typedef unsigned int __attribute__ ((bitwidth(1539))) uint1539;
typedef unsigned int __attribute__ ((bitwidth(1540))) uint1540;
typedef unsigned int __attribute__ ((bitwidth(1541))) uint1541;
typedef unsigned int __attribute__ ((bitwidth(1542))) uint1542;
typedef unsigned int __attribute__ ((bitwidth(1543))) uint1543;
typedef unsigned int __attribute__ ((bitwidth(1544))) uint1544;
typedef unsigned int __attribute__ ((bitwidth(1545))) uint1545;
typedef unsigned int __attribute__ ((bitwidth(1546))) uint1546;
typedef unsigned int __attribute__ ((bitwidth(1547))) uint1547;
typedef unsigned int __attribute__ ((bitwidth(1548))) uint1548;
typedef unsigned int __attribute__ ((bitwidth(1549))) uint1549;
typedef unsigned int __attribute__ ((bitwidth(1550))) uint1550;
typedef unsigned int __attribute__ ((bitwidth(1551))) uint1551;
typedef unsigned int __attribute__ ((bitwidth(1552))) uint1552;
typedef unsigned int __attribute__ ((bitwidth(1553))) uint1553;
typedef unsigned int __attribute__ ((bitwidth(1554))) uint1554;
typedef unsigned int __attribute__ ((bitwidth(1555))) uint1555;
typedef unsigned int __attribute__ ((bitwidth(1556))) uint1556;
typedef unsigned int __attribute__ ((bitwidth(1557))) uint1557;
typedef unsigned int __attribute__ ((bitwidth(1558))) uint1558;
typedef unsigned int __attribute__ ((bitwidth(1559))) uint1559;
typedef unsigned int __attribute__ ((bitwidth(1560))) uint1560;
typedef unsigned int __attribute__ ((bitwidth(1561))) uint1561;
typedef unsigned int __attribute__ ((bitwidth(1562))) uint1562;
typedef unsigned int __attribute__ ((bitwidth(1563))) uint1563;
typedef unsigned int __attribute__ ((bitwidth(1564))) uint1564;
typedef unsigned int __attribute__ ((bitwidth(1565))) uint1565;
typedef unsigned int __attribute__ ((bitwidth(1566))) uint1566;
typedef unsigned int __attribute__ ((bitwidth(1567))) uint1567;
typedef unsigned int __attribute__ ((bitwidth(1568))) uint1568;
typedef unsigned int __attribute__ ((bitwidth(1569))) uint1569;
typedef unsigned int __attribute__ ((bitwidth(1570))) uint1570;
typedef unsigned int __attribute__ ((bitwidth(1571))) uint1571;
typedef unsigned int __attribute__ ((bitwidth(1572))) uint1572;
typedef unsigned int __attribute__ ((bitwidth(1573))) uint1573;
typedef unsigned int __attribute__ ((bitwidth(1574))) uint1574;
typedef unsigned int __attribute__ ((bitwidth(1575))) uint1575;
typedef unsigned int __attribute__ ((bitwidth(1576))) uint1576;
typedef unsigned int __attribute__ ((bitwidth(1577))) uint1577;
typedef unsigned int __attribute__ ((bitwidth(1578))) uint1578;
typedef unsigned int __attribute__ ((bitwidth(1579))) uint1579;
typedef unsigned int __attribute__ ((bitwidth(1580))) uint1580;
typedef unsigned int __attribute__ ((bitwidth(1581))) uint1581;
typedef unsigned int __attribute__ ((bitwidth(1582))) uint1582;
typedef unsigned int __attribute__ ((bitwidth(1583))) uint1583;
typedef unsigned int __attribute__ ((bitwidth(1584))) uint1584;
typedef unsigned int __attribute__ ((bitwidth(1585))) uint1585;
typedef unsigned int __attribute__ ((bitwidth(1586))) uint1586;
typedef unsigned int __attribute__ ((bitwidth(1587))) uint1587;
typedef unsigned int __attribute__ ((bitwidth(1588))) uint1588;
typedef unsigned int __attribute__ ((bitwidth(1589))) uint1589;
typedef unsigned int __attribute__ ((bitwidth(1590))) uint1590;
typedef unsigned int __attribute__ ((bitwidth(1591))) uint1591;
typedef unsigned int __attribute__ ((bitwidth(1592))) uint1592;
typedef unsigned int __attribute__ ((bitwidth(1593))) uint1593;
typedef unsigned int __attribute__ ((bitwidth(1594))) uint1594;
typedef unsigned int __attribute__ ((bitwidth(1595))) uint1595;
typedef unsigned int __attribute__ ((bitwidth(1596))) uint1596;
typedef unsigned int __attribute__ ((bitwidth(1597))) uint1597;
typedef unsigned int __attribute__ ((bitwidth(1598))) uint1598;
typedef unsigned int __attribute__ ((bitwidth(1599))) uint1599;
typedef unsigned int __attribute__ ((bitwidth(1600))) uint1600;
typedef unsigned int __attribute__ ((bitwidth(1601))) uint1601;
typedef unsigned int __attribute__ ((bitwidth(1602))) uint1602;
typedef unsigned int __attribute__ ((bitwidth(1603))) uint1603;
typedef unsigned int __attribute__ ((bitwidth(1604))) uint1604;
typedef unsigned int __attribute__ ((bitwidth(1605))) uint1605;
typedef unsigned int __attribute__ ((bitwidth(1606))) uint1606;
typedef unsigned int __attribute__ ((bitwidth(1607))) uint1607;
typedef unsigned int __attribute__ ((bitwidth(1608))) uint1608;
typedef unsigned int __attribute__ ((bitwidth(1609))) uint1609;
typedef unsigned int __attribute__ ((bitwidth(1610))) uint1610;
typedef unsigned int __attribute__ ((bitwidth(1611))) uint1611;
typedef unsigned int __attribute__ ((bitwidth(1612))) uint1612;
typedef unsigned int __attribute__ ((bitwidth(1613))) uint1613;
typedef unsigned int __attribute__ ((bitwidth(1614))) uint1614;
typedef unsigned int __attribute__ ((bitwidth(1615))) uint1615;
typedef unsigned int __attribute__ ((bitwidth(1616))) uint1616;
typedef unsigned int __attribute__ ((bitwidth(1617))) uint1617;
typedef unsigned int __attribute__ ((bitwidth(1618))) uint1618;
typedef unsigned int __attribute__ ((bitwidth(1619))) uint1619;
typedef unsigned int __attribute__ ((bitwidth(1620))) uint1620;
typedef unsigned int __attribute__ ((bitwidth(1621))) uint1621;
typedef unsigned int __attribute__ ((bitwidth(1622))) uint1622;
typedef unsigned int __attribute__ ((bitwidth(1623))) uint1623;
typedef unsigned int __attribute__ ((bitwidth(1624))) uint1624;
typedef unsigned int __attribute__ ((bitwidth(1625))) uint1625;
typedef unsigned int __attribute__ ((bitwidth(1626))) uint1626;
typedef unsigned int __attribute__ ((bitwidth(1627))) uint1627;
typedef unsigned int __attribute__ ((bitwidth(1628))) uint1628;
typedef unsigned int __attribute__ ((bitwidth(1629))) uint1629;
typedef unsigned int __attribute__ ((bitwidth(1630))) uint1630;
typedef unsigned int __attribute__ ((bitwidth(1631))) uint1631;
typedef unsigned int __attribute__ ((bitwidth(1632))) uint1632;
typedef unsigned int __attribute__ ((bitwidth(1633))) uint1633;
typedef unsigned int __attribute__ ((bitwidth(1634))) uint1634;
typedef unsigned int __attribute__ ((bitwidth(1635))) uint1635;
typedef unsigned int __attribute__ ((bitwidth(1636))) uint1636;
typedef unsigned int __attribute__ ((bitwidth(1637))) uint1637;
typedef unsigned int __attribute__ ((bitwidth(1638))) uint1638;
typedef unsigned int __attribute__ ((bitwidth(1639))) uint1639;
typedef unsigned int __attribute__ ((bitwidth(1640))) uint1640;
typedef unsigned int __attribute__ ((bitwidth(1641))) uint1641;
typedef unsigned int __attribute__ ((bitwidth(1642))) uint1642;
typedef unsigned int __attribute__ ((bitwidth(1643))) uint1643;
typedef unsigned int __attribute__ ((bitwidth(1644))) uint1644;
typedef unsigned int __attribute__ ((bitwidth(1645))) uint1645;
typedef unsigned int __attribute__ ((bitwidth(1646))) uint1646;
typedef unsigned int __attribute__ ((bitwidth(1647))) uint1647;
typedef unsigned int __attribute__ ((bitwidth(1648))) uint1648;
typedef unsigned int __attribute__ ((bitwidth(1649))) uint1649;
typedef unsigned int __attribute__ ((bitwidth(1650))) uint1650;
typedef unsigned int __attribute__ ((bitwidth(1651))) uint1651;
typedef unsigned int __attribute__ ((bitwidth(1652))) uint1652;
typedef unsigned int __attribute__ ((bitwidth(1653))) uint1653;
typedef unsigned int __attribute__ ((bitwidth(1654))) uint1654;
typedef unsigned int __attribute__ ((bitwidth(1655))) uint1655;
typedef unsigned int __attribute__ ((bitwidth(1656))) uint1656;
typedef unsigned int __attribute__ ((bitwidth(1657))) uint1657;
typedef unsigned int __attribute__ ((bitwidth(1658))) uint1658;
typedef unsigned int __attribute__ ((bitwidth(1659))) uint1659;
typedef unsigned int __attribute__ ((bitwidth(1660))) uint1660;
typedef unsigned int __attribute__ ((bitwidth(1661))) uint1661;
typedef unsigned int __attribute__ ((bitwidth(1662))) uint1662;
typedef unsigned int __attribute__ ((bitwidth(1663))) uint1663;
typedef unsigned int __attribute__ ((bitwidth(1664))) uint1664;
typedef unsigned int __attribute__ ((bitwidth(1665))) uint1665;
typedef unsigned int __attribute__ ((bitwidth(1666))) uint1666;
typedef unsigned int __attribute__ ((bitwidth(1667))) uint1667;
typedef unsigned int __attribute__ ((bitwidth(1668))) uint1668;
typedef unsigned int __attribute__ ((bitwidth(1669))) uint1669;
typedef unsigned int __attribute__ ((bitwidth(1670))) uint1670;
typedef unsigned int __attribute__ ((bitwidth(1671))) uint1671;
typedef unsigned int __attribute__ ((bitwidth(1672))) uint1672;
typedef unsigned int __attribute__ ((bitwidth(1673))) uint1673;
typedef unsigned int __attribute__ ((bitwidth(1674))) uint1674;
typedef unsigned int __attribute__ ((bitwidth(1675))) uint1675;
typedef unsigned int __attribute__ ((bitwidth(1676))) uint1676;
typedef unsigned int __attribute__ ((bitwidth(1677))) uint1677;
typedef unsigned int __attribute__ ((bitwidth(1678))) uint1678;
typedef unsigned int __attribute__ ((bitwidth(1679))) uint1679;
typedef unsigned int __attribute__ ((bitwidth(1680))) uint1680;
typedef unsigned int __attribute__ ((bitwidth(1681))) uint1681;
typedef unsigned int __attribute__ ((bitwidth(1682))) uint1682;
typedef unsigned int __attribute__ ((bitwidth(1683))) uint1683;
typedef unsigned int __attribute__ ((bitwidth(1684))) uint1684;
typedef unsigned int __attribute__ ((bitwidth(1685))) uint1685;
typedef unsigned int __attribute__ ((bitwidth(1686))) uint1686;
typedef unsigned int __attribute__ ((bitwidth(1687))) uint1687;
typedef unsigned int __attribute__ ((bitwidth(1688))) uint1688;
typedef unsigned int __attribute__ ((bitwidth(1689))) uint1689;
typedef unsigned int __attribute__ ((bitwidth(1690))) uint1690;
typedef unsigned int __attribute__ ((bitwidth(1691))) uint1691;
typedef unsigned int __attribute__ ((bitwidth(1692))) uint1692;
typedef unsigned int __attribute__ ((bitwidth(1693))) uint1693;
typedef unsigned int __attribute__ ((bitwidth(1694))) uint1694;
typedef unsigned int __attribute__ ((bitwidth(1695))) uint1695;
typedef unsigned int __attribute__ ((bitwidth(1696))) uint1696;
typedef unsigned int __attribute__ ((bitwidth(1697))) uint1697;
typedef unsigned int __attribute__ ((bitwidth(1698))) uint1698;
typedef unsigned int __attribute__ ((bitwidth(1699))) uint1699;
typedef unsigned int __attribute__ ((bitwidth(1700))) uint1700;
typedef unsigned int __attribute__ ((bitwidth(1701))) uint1701;
typedef unsigned int __attribute__ ((bitwidth(1702))) uint1702;
typedef unsigned int __attribute__ ((bitwidth(1703))) uint1703;
typedef unsigned int __attribute__ ((bitwidth(1704))) uint1704;
typedef unsigned int __attribute__ ((bitwidth(1705))) uint1705;
typedef unsigned int __attribute__ ((bitwidth(1706))) uint1706;
typedef unsigned int __attribute__ ((bitwidth(1707))) uint1707;
typedef unsigned int __attribute__ ((bitwidth(1708))) uint1708;
typedef unsigned int __attribute__ ((bitwidth(1709))) uint1709;
typedef unsigned int __attribute__ ((bitwidth(1710))) uint1710;
typedef unsigned int __attribute__ ((bitwidth(1711))) uint1711;
typedef unsigned int __attribute__ ((bitwidth(1712))) uint1712;
typedef unsigned int __attribute__ ((bitwidth(1713))) uint1713;
typedef unsigned int __attribute__ ((bitwidth(1714))) uint1714;
typedef unsigned int __attribute__ ((bitwidth(1715))) uint1715;
typedef unsigned int __attribute__ ((bitwidth(1716))) uint1716;
typedef unsigned int __attribute__ ((bitwidth(1717))) uint1717;
typedef unsigned int __attribute__ ((bitwidth(1718))) uint1718;
typedef unsigned int __attribute__ ((bitwidth(1719))) uint1719;
typedef unsigned int __attribute__ ((bitwidth(1720))) uint1720;
typedef unsigned int __attribute__ ((bitwidth(1721))) uint1721;
typedef unsigned int __attribute__ ((bitwidth(1722))) uint1722;
typedef unsigned int __attribute__ ((bitwidth(1723))) uint1723;
typedef unsigned int __attribute__ ((bitwidth(1724))) uint1724;
typedef unsigned int __attribute__ ((bitwidth(1725))) uint1725;
typedef unsigned int __attribute__ ((bitwidth(1726))) uint1726;
typedef unsigned int __attribute__ ((bitwidth(1727))) uint1727;
typedef unsigned int __attribute__ ((bitwidth(1728))) uint1728;
typedef unsigned int __attribute__ ((bitwidth(1729))) uint1729;
typedef unsigned int __attribute__ ((bitwidth(1730))) uint1730;
typedef unsigned int __attribute__ ((bitwidth(1731))) uint1731;
typedef unsigned int __attribute__ ((bitwidth(1732))) uint1732;
typedef unsigned int __attribute__ ((bitwidth(1733))) uint1733;
typedef unsigned int __attribute__ ((bitwidth(1734))) uint1734;
typedef unsigned int __attribute__ ((bitwidth(1735))) uint1735;
typedef unsigned int __attribute__ ((bitwidth(1736))) uint1736;
typedef unsigned int __attribute__ ((bitwidth(1737))) uint1737;
typedef unsigned int __attribute__ ((bitwidth(1738))) uint1738;
typedef unsigned int __attribute__ ((bitwidth(1739))) uint1739;
typedef unsigned int __attribute__ ((bitwidth(1740))) uint1740;
typedef unsigned int __attribute__ ((bitwidth(1741))) uint1741;
typedef unsigned int __attribute__ ((bitwidth(1742))) uint1742;
typedef unsigned int __attribute__ ((bitwidth(1743))) uint1743;
typedef unsigned int __attribute__ ((bitwidth(1744))) uint1744;
typedef unsigned int __attribute__ ((bitwidth(1745))) uint1745;
typedef unsigned int __attribute__ ((bitwidth(1746))) uint1746;
typedef unsigned int __attribute__ ((bitwidth(1747))) uint1747;
typedef unsigned int __attribute__ ((bitwidth(1748))) uint1748;
typedef unsigned int __attribute__ ((bitwidth(1749))) uint1749;
typedef unsigned int __attribute__ ((bitwidth(1750))) uint1750;
typedef unsigned int __attribute__ ((bitwidth(1751))) uint1751;
typedef unsigned int __attribute__ ((bitwidth(1752))) uint1752;
typedef unsigned int __attribute__ ((bitwidth(1753))) uint1753;
typedef unsigned int __attribute__ ((bitwidth(1754))) uint1754;
typedef unsigned int __attribute__ ((bitwidth(1755))) uint1755;
typedef unsigned int __attribute__ ((bitwidth(1756))) uint1756;
typedef unsigned int __attribute__ ((bitwidth(1757))) uint1757;
typedef unsigned int __attribute__ ((bitwidth(1758))) uint1758;
typedef unsigned int __attribute__ ((bitwidth(1759))) uint1759;
typedef unsigned int __attribute__ ((bitwidth(1760))) uint1760;
typedef unsigned int __attribute__ ((bitwidth(1761))) uint1761;
typedef unsigned int __attribute__ ((bitwidth(1762))) uint1762;
typedef unsigned int __attribute__ ((bitwidth(1763))) uint1763;
typedef unsigned int __attribute__ ((bitwidth(1764))) uint1764;
typedef unsigned int __attribute__ ((bitwidth(1765))) uint1765;
typedef unsigned int __attribute__ ((bitwidth(1766))) uint1766;
typedef unsigned int __attribute__ ((bitwidth(1767))) uint1767;
typedef unsigned int __attribute__ ((bitwidth(1768))) uint1768;
typedef unsigned int __attribute__ ((bitwidth(1769))) uint1769;
typedef unsigned int __attribute__ ((bitwidth(1770))) uint1770;
typedef unsigned int __attribute__ ((bitwidth(1771))) uint1771;
typedef unsigned int __attribute__ ((bitwidth(1772))) uint1772;
typedef unsigned int __attribute__ ((bitwidth(1773))) uint1773;
typedef unsigned int __attribute__ ((bitwidth(1774))) uint1774;
typedef unsigned int __attribute__ ((bitwidth(1775))) uint1775;
typedef unsigned int __attribute__ ((bitwidth(1776))) uint1776;
typedef unsigned int __attribute__ ((bitwidth(1777))) uint1777;
typedef unsigned int __attribute__ ((bitwidth(1778))) uint1778;
typedef unsigned int __attribute__ ((bitwidth(1779))) uint1779;
typedef unsigned int __attribute__ ((bitwidth(1780))) uint1780;
typedef unsigned int __attribute__ ((bitwidth(1781))) uint1781;
typedef unsigned int __attribute__ ((bitwidth(1782))) uint1782;
typedef unsigned int __attribute__ ((bitwidth(1783))) uint1783;
typedef unsigned int __attribute__ ((bitwidth(1784))) uint1784;
typedef unsigned int __attribute__ ((bitwidth(1785))) uint1785;
typedef unsigned int __attribute__ ((bitwidth(1786))) uint1786;
typedef unsigned int __attribute__ ((bitwidth(1787))) uint1787;
typedef unsigned int __attribute__ ((bitwidth(1788))) uint1788;
typedef unsigned int __attribute__ ((bitwidth(1789))) uint1789;
typedef unsigned int __attribute__ ((bitwidth(1790))) uint1790;
typedef unsigned int __attribute__ ((bitwidth(1791))) uint1791;
typedef unsigned int __attribute__ ((bitwidth(1792))) uint1792;
typedef unsigned int __attribute__ ((bitwidth(1793))) uint1793;
typedef unsigned int __attribute__ ((bitwidth(1794))) uint1794;
typedef unsigned int __attribute__ ((bitwidth(1795))) uint1795;
typedef unsigned int __attribute__ ((bitwidth(1796))) uint1796;
typedef unsigned int __attribute__ ((bitwidth(1797))) uint1797;
typedef unsigned int __attribute__ ((bitwidth(1798))) uint1798;
typedef unsigned int __attribute__ ((bitwidth(1799))) uint1799;
typedef unsigned int __attribute__ ((bitwidth(1800))) uint1800;
typedef unsigned int __attribute__ ((bitwidth(1801))) uint1801;
typedef unsigned int __attribute__ ((bitwidth(1802))) uint1802;
typedef unsigned int __attribute__ ((bitwidth(1803))) uint1803;
typedef unsigned int __attribute__ ((bitwidth(1804))) uint1804;
typedef unsigned int __attribute__ ((bitwidth(1805))) uint1805;
typedef unsigned int __attribute__ ((bitwidth(1806))) uint1806;
typedef unsigned int __attribute__ ((bitwidth(1807))) uint1807;
typedef unsigned int __attribute__ ((bitwidth(1808))) uint1808;
typedef unsigned int __attribute__ ((bitwidth(1809))) uint1809;
typedef unsigned int __attribute__ ((bitwidth(1810))) uint1810;
typedef unsigned int __attribute__ ((bitwidth(1811))) uint1811;
typedef unsigned int __attribute__ ((bitwidth(1812))) uint1812;
typedef unsigned int __attribute__ ((bitwidth(1813))) uint1813;
typedef unsigned int __attribute__ ((bitwidth(1814))) uint1814;
typedef unsigned int __attribute__ ((bitwidth(1815))) uint1815;
typedef unsigned int __attribute__ ((bitwidth(1816))) uint1816;
typedef unsigned int __attribute__ ((bitwidth(1817))) uint1817;
typedef unsigned int __attribute__ ((bitwidth(1818))) uint1818;
typedef unsigned int __attribute__ ((bitwidth(1819))) uint1819;
typedef unsigned int __attribute__ ((bitwidth(1820))) uint1820;
typedef unsigned int __attribute__ ((bitwidth(1821))) uint1821;
typedef unsigned int __attribute__ ((bitwidth(1822))) uint1822;
typedef unsigned int __attribute__ ((bitwidth(1823))) uint1823;
typedef unsigned int __attribute__ ((bitwidth(1824))) uint1824;
typedef unsigned int __attribute__ ((bitwidth(1825))) uint1825;
typedef unsigned int __attribute__ ((bitwidth(1826))) uint1826;
typedef unsigned int __attribute__ ((bitwidth(1827))) uint1827;
typedef unsigned int __attribute__ ((bitwidth(1828))) uint1828;
typedef unsigned int __attribute__ ((bitwidth(1829))) uint1829;
typedef unsigned int __attribute__ ((bitwidth(1830))) uint1830;
typedef unsigned int __attribute__ ((bitwidth(1831))) uint1831;
typedef unsigned int __attribute__ ((bitwidth(1832))) uint1832;
typedef unsigned int __attribute__ ((bitwidth(1833))) uint1833;
typedef unsigned int __attribute__ ((bitwidth(1834))) uint1834;
typedef unsigned int __attribute__ ((bitwidth(1835))) uint1835;
typedef unsigned int __attribute__ ((bitwidth(1836))) uint1836;
typedef unsigned int __attribute__ ((bitwidth(1837))) uint1837;
typedef unsigned int __attribute__ ((bitwidth(1838))) uint1838;
typedef unsigned int __attribute__ ((bitwidth(1839))) uint1839;
typedef unsigned int __attribute__ ((bitwidth(1840))) uint1840;
typedef unsigned int __attribute__ ((bitwidth(1841))) uint1841;
typedef unsigned int __attribute__ ((bitwidth(1842))) uint1842;
typedef unsigned int __attribute__ ((bitwidth(1843))) uint1843;
typedef unsigned int __attribute__ ((bitwidth(1844))) uint1844;
typedef unsigned int __attribute__ ((bitwidth(1845))) uint1845;
typedef unsigned int __attribute__ ((bitwidth(1846))) uint1846;
typedef unsigned int __attribute__ ((bitwidth(1847))) uint1847;
typedef unsigned int __attribute__ ((bitwidth(1848))) uint1848;
typedef unsigned int __attribute__ ((bitwidth(1849))) uint1849;
typedef unsigned int __attribute__ ((bitwidth(1850))) uint1850;
typedef unsigned int __attribute__ ((bitwidth(1851))) uint1851;
typedef unsigned int __attribute__ ((bitwidth(1852))) uint1852;
typedef unsigned int __attribute__ ((bitwidth(1853))) uint1853;
typedef unsigned int __attribute__ ((bitwidth(1854))) uint1854;
typedef unsigned int __attribute__ ((bitwidth(1855))) uint1855;
typedef unsigned int __attribute__ ((bitwidth(1856))) uint1856;
typedef unsigned int __attribute__ ((bitwidth(1857))) uint1857;
typedef unsigned int __attribute__ ((bitwidth(1858))) uint1858;
typedef unsigned int __attribute__ ((bitwidth(1859))) uint1859;
typedef unsigned int __attribute__ ((bitwidth(1860))) uint1860;
typedef unsigned int __attribute__ ((bitwidth(1861))) uint1861;
typedef unsigned int __attribute__ ((bitwidth(1862))) uint1862;
typedef unsigned int __attribute__ ((bitwidth(1863))) uint1863;
typedef unsigned int __attribute__ ((bitwidth(1864))) uint1864;
typedef unsigned int __attribute__ ((bitwidth(1865))) uint1865;
typedef unsigned int __attribute__ ((bitwidth(1866))) uint1866;
typedef unsigned int __attribute__ ((bitwidth(1867))) uint1867;
typedef unsigned int __attribute__ ((bitwidth(1868))) uint1868;
typedef unsigned int __attribute__ ((bitwidth(1869))) uint1869;
typedef unsigned int __attribute__ ((bitwidth(1870))) uint1870;
typedef unsigned int __attribute__ ((bitwidth(1871))) uint1871;
typedef unsigned int __attribute__ ((bitwidth(1872))) uint1872;
typedef unsigned int __attribute__ ((bitwidth(1873))) uint1873;
typedef unsigned int __attribute__ ((bitwidth(1874))) uint1874;
typedef unsigned int __attribute__ ((bitwidth(1875))) uint1875;
typedef unsigned int __attribute__ ((bitwidth(1876))) uint1876;
typedef unsigned int __attribute__ ((bitwidth(1877))) uint1877;
typedef unsigned int __attribute__ ((bitwidth(1878))) uint1878;
typedef unsigned int __attribute__ ((bitwidth(1879))) uint1879;
typedef unsigned int __attribute__ ((bitwidth(1880))) uint1880;
typedef unsigned int __attribute__ ((bitwidth(1881))) uint1881;
typedef unsigned int __attribute__ ((bitwidth(1882))) uint1882;
typedef unsigned int __attribute__ ((bitwidth(1883))) uint1883;
typedef unsigned int __attribute__ ((bitwidth(1884))) uint1884;
typedef unsigned int __attribute__ ((bitwidth(1885))) uint1885;
typedef unsigned int __attribute__ ((bitwidth(1886))) uint1886;
typedef unsigned int __attribute__ ((bitwidth(1887))) uint1887;
typedef unsigned int __attribute__ ((bitwidth(1888))) uint1888;
typedef unsigned int __attribute__ ((bitwidth(1889))) uint1889;
typedef unsigned int __attribute__ ((bitwidth(1890))) uint1890;
typedef unsigned int __attribute__ ((bitwidth(1891))) uint1891;
typedef unsigned int __attribute__ ((bitwidth(1892))) uint1892;
typedef unsigned int __attribute__ ((bitwidth(1893))) uint1893;
typedef unsigned int __attribute__ ((bitwidth(1894))) uint1894;
typedef unsigned int __attribute__ ((bitwidth(1895))) uint1895;
typedef unsigned int __attribute__ ((bitwidth(1896))) uint1896;
typedef unsigned int __attribute__ ((bitwidth(1897))) uint1897;
typedef unsigned int __attribute__ ((bitwidth(1898))) uint1898;
typedef unsigned int __attribute__ ((bitwidth(1899))) uint1899;
typedef unsigned int __attribute__ ((bitwidth(1900))) uint1900;
typedef unsigned int __attribute__ ((bitwidth(1901))) uint1901;
typedef unsigned int __attribute__ ((bitwidth(1902))) uint1902;
typedef unsigned int __attribute__ ((bitwidth(1903))) uint1903;
typedef unsigned int __attribute__ ((bitwidth(1904))) uint1904;
typedef unsigned int __attribute__ ((bitwidth(1905))) uint1905;
typedef unsigned int __attribute__ ((bitwidth(1906))) uint1906;
typedef unsigned int __attribute__ ((bitwidth(1907))) uint1907;
typedef unsigned int __attribute__ ((bitwidth(1908))) uint1908;
typedef unsigned int __attribute__ ((bitwidth(1909))) uint1909;
typedef unsigned int __attribute__ ((bitwidth(1910))) uint1910;
typedef unsigned int __attribute__ ((bitwidth(1911))) uint1911;
typedef unsigned int __attribute__ ((bitwidth(1912))) uint1912;
typedef unsigned int __attribute__ ((bitwidth(1913))) uint1913;
typedef unsigned int __attribute__ ((bitwidth(1914))) uint1914;
typedef unsigned int __attribute__ ((bitwidth(1915))) uint1915;
typedef unsigned int __attribute__ ((bitwidth(1916))) uint1916;
typedef unsigned int __attribute__ ((bitwidth(1917))) uint1917;
typedef unsigned int __attribute__ ((bitwidth(1918))) uint1918;
typedef unsigned int __attribute__ ((bitwidth(1919))) uint1919;
typedef unsigned int __attribute__ ((bitwidth(1920))) uint1920;
typedef unsigned int __attribute__ ((bitwidth(1921))) uint1921;
typedef unsigned int __attribute__ ((bitwidth(1922))) uint1922;
typedef unsigned int __attribute__ ((bitwidth(1923))) uint1923;
typedef unsigned int __attribute__ ((bitwidth(1924))) uint1924;
typedef unsigned int __attribute__ ((bitwidth(1925))) uint1925;
typedef unsigned int __attribute__ ((bitwidth(1926))) uint1926;
typedef unsigned int __attribute__ ((bitwidth(1927))) uint1927;
typedef unsigned int __attribute__ ((bitwidth(1928))) uint1928;
typedef unsigned int __attribute__ ((bitwidth(1929))) uint1929;
typedef unsigned int __attribute__ ((bitwidth(1930))) uint1930;
typedef unsigned int __attribute__ ((bitwidth(1931))) uint1931;
typedef unsigned int __attribute__ ((bitwidth(1932))) uint1932;
typedef unsigned int __attribute__ ((bitwidth(1933))) uint1933;
typedef unsigned int __attribute__ ((bitwidth(1934))) uint1934;
typedef unsigned int __attribute__ ((bitwidth(1935))) uint1935;
typedef unsigned int __attribute__ ((bitwidth(1936))) uint1936;
typedef unsigned int __attribute__ ((bitwidth(1937))) uint1937;
typedef unsigned int __attribute__ ((bitwidth(1938))) uint1938;
typedef unsigned int __attribute__ ((bitwidth(1939))) uint1939;
typedef unsigned int __attribute__ ((bitwidth(1940))) uint1940;
typedef unsigned int __attribute__ ((bitwidth(1941))) uint1941;
typedef unsigned int __attribute__ ((bitwidth(1942))) uint1942;
typedef unsigned int __attribute__ ((bitwidth(1943))) uint1943;
typedef unsigned int __attribute__ ((bitwidth(1944))) uint1944;
typedef unsigned int __attribute__ ((bitwidth(1945))) uint1945;
typedef unsigned int __attribute__ ((bitwidth(1946))) uint1946;
typedef unsigned int __attribute__ ((bitwidth(1947))) uint1947;
typedef unsigned int __attribute__ ((bitwidth(1948))) uint1948;
typedef unsigned int __attribute__ ((bitwidth(1949))) uint1949;
typedef unsigned int __attribute__ ((bitwidth(1950))) uint1950;
typedef unsigned int __attribute__ ((bitwidth(1951))) uint1951;
typedef unsigned int __attribute__ ((bitwidth(1952))) uint1952;
typedef unsigned int __attribute__ ((bitwidth(1953))) uint1953;
typedef unsigned int __attribute__ ((bitwidth(1954))) uint1954;
typedef unsigned int __attribute__ ((bitwidth(1955))) uint1955;
typedef unsigned int __attribute__ ((bitwidth(1956))) uint1956;
typedef unsigned int __attribute__ ((bitwidth(1957))) uint1957;
typedef unsigned int __attribute__ ((bitwidth(1958))) uint1958;
typedef unsigned int __attribute__ ((bitwidth(1959))) uint1959;
typedef unsigned int __attribute__ ((bitwidth(1960))) uint1960;
typedef unsigned int __attribute__ ((bitwidth(1961))) uint1961;
typedef unsigned int __attribute__ ((bitwidth(1962))) uint1962;
typedef unsigned int __attribute__ ((bitwidth(1963))) uint1963;
typedef unsigned int __attribute__ ((bitwidth(1964))) uint1964;
typedef unsigned int __attribute__ ((bitwidth(1965))) uint1965;
typedef unsigned int __attribute__ ((bitwidth(1966))) uint1966;
typedef unsigned int __attribute__ ((bitwidth(1967))) uint1967;
typedef unsigned int __attribute__ ((bitwidth(1968))) uint1968;
typedef unsigned int __attribute__ ((bitwidth(1969))) uint1969;
typedef unsigned int __attribute__ ((bitwidth(1970))) uint1970;
typedef unsigned int __attribute__ ((bitwidth(1971))) uint1971;
typedef unsigned int __attribute__ ((bitwidth(1972))) uint1972;
typedef unsigned int __attribute__ ((bitwidth(1973))) uint1973;
typedef unsigned int __attribute__ ((bitwidth(1974))) uint1974;
typedef unsigned int __attribute__ ((bitwidth(1975))) uint1975;
typedef unsigned int __attribute__ ((bitwidth(1976))) uint1976;
typedef unsigned int __attribute__ ((bitwidth(1977))) uint1977;
typedef unsigned int __attribute__ ((bitwidth(1978))) uint1978;
typedef unsigned int __attribute__ ((bitwidth(1979))) uint1979;
typedef unsigned int __attribute__ ((bitwidth(1980))) uint1980;
typedef unsigned int __attribute__ ((bitwidth(1981))) uint1981;
typedef unsigned int __attribute__ ((bitwidth(1982))) uint1982;
typedef unsigned int __attribute__ ((bitwidth(1983))) uint1983;
typedef unsigned int __attribute__ ((bitwidth(1984))) uint1984;
typedef unsigned int __attribute__ ((bitwidth(1985))) uint1985;
typedef unsigned int __attribute__ ((bitwidth(1986))) uint1986;
typedef unsigned int __attribute__ ((bitwidth(1987))) uint1987;
typedef unsigned int __attribute__ ((bitwidth(1988))) uint1988;
typedef unsigned int __attribute__ ((bitwidth(1989))) uint1989;
typedef unsigned int __attribute__ ((bitwidth(1990))) uint1990;
typedef unsigned int __attribute__ ((bitwidth(1991))) uint1991;
typedef unsigned int __attribute__ ((bitwidth(1992))) uint1992;
typedef unsigned int __attribute__ ((bitwidth(1993))) uint1993;
typedef unsigned int __attribute__ ((bitwidth(1994))) uint1994;
typedef unsigned int __attribute__ ((bitwidth(1995))) uint1995;
typedef unsigned int __attribute__ ((bitwidth(1996))) uint1996;
typedef unsigned int __attribute__ ((bitwidth(1997))) uint1997;
typedef unsigned int __attribute__ ((bitwidth(1998))) uint1998;
typedef unsigned int __attribute__ ((bitwidth(1999))) uint1999;
typedef unsigned int __attribute__ ((bitwidth(2000))) uint2000;
typedef unsigned int __attribute__ ((bitwidth(2001))) uint2001;
typedef unsigned int __attribute__ ((bitwidth(2002))) uint2002;
typedef unsigned int __attribute__ ((bitwidth(2003))) uint2003;
typedef unsigned int __attribute__ ((bitwidth(2004))) uint2004;
typedef unsigned int __attribute__ ((bitwidth(2005))) uint2005;
typedef unsigned int __attribute__ ((bitwidth(2006))) uint2006;
typedef unsigned int __attribute__ ((bitwidth(2007))) uint2007;
typedef unsigned int __attribute__ ((bitwidth(2008))) uint2008;
typedef unsigned int __attribute__ ((bitwidth(2009))) uint2009;
typedef unsigned int __attribute__ ((bitwidth(2010))) uint2010;
typedef unsigned int __attribute__ ((bitwidth(2011))) uint2011;
typedef unsigned int __attribute__ ((bitwidth(2012))) uint2012;
typedef unsigned int __attribute__ ((bitwidth(2013))) uint2013;
typedef unsigned int __attribute__ ((bitwidth(2014))) uint2014;
typedef unsigned int __attribute__ ((bitwidth(2015))) uint2015;
typedef unsigned int __attribute__ ((bitwidth(2016))) uint2016;
typedef unsigned int __attribute__ ((bitwidth(2017))) uint2017;
typedef unsigned int __attribute__ ((bitwidth(2018))) uint2018;
typedef unsigned int __attribute__ ((bitwidth(2019))) uint2019;
typedef unsigned int __attribute__ ((bitwidth(2020))) uint2020;
typedef unsigned int __attribute__ ((bitwidth(2021))) uint2021;
typedef unsigned int __attribute__ ((bitwidth(2022))) uint2022;
typedef unsigned int __attribute__ ((bitwidth(2023))) uint2023;
typedef unsigned int __attribute__ ((bitwidth(2024))) uint2024;
typedef unsigned int __attribute__ ((bitwidth(2025))) uint2025;
typedef unsigned int __attribute__ ((bitwidth(2026))) uint2026;
typedef unsigned int __attribute__ ((bitwidth(2027))) uint2027;
typedef unsigned int __attribute__ ((bitwidth(2028))) uint2028;
typedef unsigned int __attribute__ ((bitwidth(2029))) uint2029;
typedef unsigned int __attribute__ ((bitwidth(2030))) uint2030;
typedef unsigned int __attribute__ ((bitwidth(2031))) uint2031;
typedef unsigned int __attribute__ ((bitwidth(2032))) uint2032;
typedef unsigned int __attribute__ ((bitwidth(2033))) uint2033;
typedef unsigned int __attribute__ ((bitwidth(2034))) uint2034;
typedef unsigned int __attribute__ ((bitwidth(2035))) uint2035;
typedef unsigned int __attribute__ ((bitwidth(2036))) uint2036;
typedef unsigned int __attribute__ ((bitwidth(2037))) uint2037;
typedef unsigned int __attribute__ ((bitwidth(2038))) uint2038;
typedef unsigned int __attribute__ ((bitwidth(2039))) uint2039;
typedef unsigned int __attribute__ ((bitwidth(2040))) uint2040;
typedef unsigned int __attribute__ ((bitwidth(2041))) uint2041;
typedef unsigned int __attribute__ ((bitwidth(2042))) uint2042;
typedef unsigned int __attribute__ ((bitwidth(2043))) uint2043;
typedef unsigned int __attribute__ ((bitwidth(2044))) uint2044;
typedef unsigned int __attribute__ ((bitwidth(2045))) uint2045;
typedef unsigned int __attribute__ ((bitwidth(2046))) uint2046;
typedef unsigned int __attribute__ ((bitwidth(2047))) uint2047;
typedef unsigned int __attribute__ ((bitwidth(2048))) uint2048;
#pragma line 110 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 131 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
typedef int __attribute__ ((bitwidth(64))) int64;
typedef unsigned int __attribute__ ((bitwidth(64))) uint64;
#pragma line 58 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h" 1
/* autopilot_ssdm_bits.h */
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Concatination ----------------*/
#pragma line 108 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Bit get/set ----------------*/
#pragma line 129 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Part get/set ----------------*/
#pragma empty_line
/* GetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 143 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* SetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 156 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Reduce operations ----------------*/
#pragma line 192 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- String-Integer conversions ----------------*/
#pragma line 59 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 2
#pragma line 85 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h"
/************************************************/
#pragma line 78 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 3 "./duc.h" 2
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 1 3 4
/*===---- limits.h - Standard header for integer sizes --------------------===*\
*
* Copyright (c) 2009 Chris Lattner
*
* 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.
*
\*===----------------------------------------------------------------------===*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
Avert this #include_next madness. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* System headers include a number of constants from POSIX in <limits.h>.
Include it if we're hosted. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 6 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* File system limits
*
* NOTE: Apparently the actual size of PATH_MAX is 260, but a space is
* required for the NUL. TODO: Test?
* NOTE: PATH_MAX is the POSIX equivalent for Microsoft's MAX_PATH; the two
* are semantically identical, with a limit of 259 characters for the
* path name, plus one for a terminating NUL, for a total of 260.
*/
#pragma line 38 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Many system headers try to "help us out" by defining these. No really, we
know how big each datatype is. */
#pragma line 60 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C90/99 5.2.4.2.1 */
#pragma line 90 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C99 5.2.4.2.1: Added long long. */
#pragma line 102 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* LONG_LONG_MIN/LONG_LONG_MAX/ULONG_LONG_MAX are a GNU extension. It's too bad
that we don't have something like #pragma poison that could be used to
deprecate a macro - the code should just use LLONG_MAX and friends.
*/
#pragma line 10 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 36 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef int ( *_onexit_t)(void);
#pragma line 46 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef struct _div_t {
int quot;
int rem;
} div_t;
#pragma empty_line
typedef struct _ldiv_t {
long quot;
long rem;
} ldiv_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(4)
typedef struct {
unsigned char ld[10];
} _LDOUBLE;
#pragma pack()
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
double x;
} _CRT_DOUBLE;
#pragma empty_line
typedef struct {
float f;
} _CRT_FLOAT;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
long double x;
} _LONGDOUBLE;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(4)
typedef struct {
unsigned char ld12[12];
} _LDBL12;
#pragma pack()
#pragma line 100 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern int * __imp___mb_cur_max;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int* __imp___mbcur_max;
#pragma line 132 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef void ( *_purecall_handler)(void);
#pragma empty_line
__attribute__ ((__dllimport__)) _purecall_handler _set_purecall_handler(_purecall_handler _Handler);
__attribute__ ((__dllimport__)) _purecall_handler _get_purecall_handler(void);
#pragma empty_line
typedef void ( *_invalid_parameter_handler)(const wchar_t *,const wchar_t *,const wchar_t *,unsigned int,uintptr_t);
_invalid_parameter_handler _set_invalid_parameter_handler(_invalid_parameter_handler _Handler);
_invalid_parameter_handler _get_invalid_parameter_handler(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) extern int * _errno(void);
#pragma empty_line
errno_t _set_errno(int _Value);
errno_t _get_errno(int *_Value);
#pragma empty_line
__attribute__ ((__dllimport__)) unsigned long * __doserrno(void);
#pragma empty_line
errno_t _set_doserrno(unsigned long _Value);
errno_t _get_doserrno(unsigned long *_Value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __attribute__ ((__dllimport__)) char *_sys_errlist[1];
extern __attribute__ ((__dllimport__)) int _sys_nerr;
#pragma line 172 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern int * __imp___argc;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *** __imp___argv;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *** __imp___wargv;
#pragma line 200 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern char *** __imp__environ;
#pragma line 209 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern wchar_t *** __imp__wenviron;
#pragma line 218 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern char ** __imp__pgmptr;
#pragma line 227 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern wchar_t ** __imp__wpgmptr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
errno_t _get_pgmptr(char **_Value);
errno_t _get_wpgmptr(wchar_t **_Value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int * __imp__fmode;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) errno_t _set_fmode(int _Mode);
__attribute__ ((__dllimport__)) errno_t _get_fmode(int *_PMode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern unsigned int * __imp__osplatform;
#pragma line 257 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__osver;
#pragma line 266 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winver;
#pragma line 275 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winmajor;
#pragma line 284 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winminor;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
errno_t _get_osplatform(unsigned int *_Value);
errno_t _get_osver(unsigned int *_Value);
errno_t _get_winver(unsigned int *_Value);
errno_t _get_winmajor(unsigned int *_Value);
errno_t _get_winminor(unsigned int *_Value);
#pragma line 307 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
void __attribute__ ((__nothrow__)) exit(int _Code) __attribute__ ((__noreturn__));
__attribute__ ((__dllimport__)) void __attribute__ ((__nothrow__)) _exit(int _Code) __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
/* C99 function name */
void _Exit(int) __attribute__ ((__noreturn__));
#pragma line 321 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
void __attribute__((noreturn)) abort(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) unsigned int _set_abort_behavior(unsigned int _Flags,unsigned int _Mask);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int abs(int _X);
long labs(long _X);
#pragma empty_line
#pragma empty_line
__extension__ long long _abs64(long long);
int atexit(void ( *)(void));
#pragma empty_line
#pragma empty_line
double atof(const char *_String);
double _atof_l(const char *_String,_locale_t _Locale);
#pragma empty_line
int atoi(const char *_Str);
__attribute__ ((__dllimport__)) int _atoi_l(const char *_Str,_locale_t _Locale);
long atol(const char *_Str);
__attribute__ ((__dllimport__)) long _atol_l(const char *_Str,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
void * bsearch(const void *_Key,const void *_Base,size_t _NumOfElements,size_t _SizeOfElements,int ( *_PtFuncCompare)(const void *,const void *));
void qsort(void *_Base,size_t _NumOfElements,size_t _SizeOfElements,int ( *_PtFuncCompare)(const void *,const void *));
#pragma empty_line
unsigned short _byteswap_ushort(unsigned short _Short);
/*unsigned long __cdecl _byteswap_ulong (unsigned long _Long); */
__extension__ unsigned long long _byteswap_uint64(unsigned long long _Int64);
div_t div(int _Numerator,int _Denominator);
char * getenv(const char *_VarName) ;
__attribute__ ((__dllimport__)) char * _itoa(int _Value,char *_Dest,int _Radix);
__extension__ __attribute__ ((__dllimport__)) char * _i64toa(long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) char * _ui64toa(unsigned long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) long long _atoi64(const char *_String);
__extension__ __attribute__ ((__dllimport__)) long long _atoi64_l(const char *_String,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long _strtoi64(const char *_String,char **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _strtoi64_l(const char *_String,char **_EndPtr,int _Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _strtoui64(const char *_String,char **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _strtoui64_l(const char *_String,char **_EndPtr,int _Radix,_locale_t _Locale);
ldiv_t ldiv(long _Numerator,long _Denominator);
__attribute__ ((__dllimport__)) char * _ltoa(long _Value,char *_Dest,int _Radix) ;
int mblen(const char *_Ch,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _mblen_l(const char *_Ch,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t _mbstrlen(const char *_Str);
__attribute__ ((__dllimport__)) size_t _mbstrlen_l(const char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t _mbstrnlen(const char *_Str,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _mbstrnlen_l(const char *_Str,size_t _MaxCount,_locale_t _Locale);
int mbtowc(wchar_t * __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t _SrcSizeInBytes);
__attribute__ ((__dllimport__)) int _mbtowc_l(wchar_t * __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t _SrcSizeInBytes,_locale_t _Locale);
size_t mbstowcs(wchar_t * __restrict__ _Dest,const char * __restrict__ _Source,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _mbstowcs_l(wchar_t * __restrict__ _Dest,const char * __restrict__ _Source,size_t _MaxCount,_locale_t _Locale);
int rand(void);
__attribute__ ((__dllimport__)) int _set_error_mode(int _Mode);
void srand(unsigned int _Seed);
#pragma empty_line
#pragma empty_line
#pragma empty_line
double __attribute__ ((__nothrow__)) strtod(const char * __restrict__ _Str,char ** __restrict__ _EndPtr);
float __attribute__ ((__nothrow__)) strtof(const char * __restrict__ nptr, char ** __restrict__ endptr);
long double __attribute__ ((__nothrow__)) strtold(const char * __restrict__ , char ** __restrict__ );
#pragma empty_line
/* libmingwex.a provides a c99-compliant strtod() exported as __strtod() */
extern double __attribute__ ((__nothrow__))
__strtod (const char * __restrict__ , char ** __restrict__);
#pragma line 400 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
float __mingw_strtof (const char * __restrict__, char ** __restrict__);
long double __mingw_strtold(const char * __restrict__, char ** __restrict__);
#pragma empty_line
__attribute__ ((__dllimport__)) double _strtod_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,_locale_t _Locale);
long strtol(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long _strtol_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
unsigned long strtoul(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long _strtoul_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
int system(const char *_Command);
#pragma empty_line
__attribute__ ((__dllimport__)) char * _ultoa(unsigned long _Value,char *_Dest,int _Radix) ;
int wctomb(char *_MbCh,wchar_t _WCh) ;
__attribute__ ((__dllimport__)) int _wctomb_l(char *_MbCh,wchar_t _WCh,_locale_t _Locale) ;
size_t wcstombs(char * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) size_t _wcstombs_l(char * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _MaxCount,_locale_t _Locale) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
void * calloc(size_t _NumOfElements,size_t _SizeOfElements);
void free(void *_Memory);
void * malloc(size_t _Size);
void * realloc(void *_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) void * _recalloc(void *_Memory,size_t _Count,size_t _Size);
/* Make sure that X86intrin.h doesn't produce here collisions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _aligned_free(void *_Memory);
__attribute__ ((__dllimport__)) void * _aligned_malloc(size_t _Size,size_t _Alignment);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void * _aligned_offset_malloc(size_t _Size,size_t _Alignment,size_t _Offset);
__attribute__ ((__dllimport__)) void * _aligned_realloc(void *_Memory,size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void * _aligned_recalloc(void *_Memory,size_t _Count,size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void * _aligned_offset_realloc(void *_Memory,size_t _Size,size_t _Alignment,size_t _Offset);
__attribute__ ((__dllimport__)) void * _aligned_offset_recalloc(void *_Memory,size_t _Count,size_t _Size,size_t _Alignment,size_t _Offset);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _itow(int _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ltow(long _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ultow(unsigned long _Value,wchar_t *_Dest,int _Radix) ;
double wcstod(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr);
float wcstof(const wchar_t * __restrict__ nptr, wchar_t ** __restrict__ endptr);
#pragma empty_line
float wcstof( const wchar_t * __restrict__, wchar_t ** __restrict__);
long double wcstold(const wchar_t * __restrict__, wchar_t ** __restrict__);
#pragma empty_line
__attribute__ ((__dllimport__)) double _wcstod_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,_locale_t _Locale);
long wcstol(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long _wcstol_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
unsigned long wcstoul(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long _wcstoul_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wgetenv(const wchar_t *_VarName) ;
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wsystem(const wchar_t *_Command);
#pragma empty_line
__attribute__ ((__dllimport__)) double _wtof(const wchar_t *_Str);
__attribute__ ((__dllimport__)) double _wtof_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wtoi(const wchar_t *_Str);
__attribute__ ((__dllimport__)) int _wtoi_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) long _wtol(const wchar_t *_Str);
__attribute__ ((__dllimport__)) long _wtol_l(const wchar_t *_Str,_locale_t _Locale);
#pragma empty_line
__extension__ __attribute__ ((__dllimport__)) wchar_t * _i64tow(long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) wchar_t * _ui64tow(unsigned long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64(const wchar_t *_Str);
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64_l(const wchar_t *_Str,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64_l(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64_l(const wchar_t *_Str ,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) char * _fullpath(char *_FullPath,const char *_Path,size_t _SizeInBytes);
__attribute__ ((__dllimport__)) char * _ecvt(double _Val,int _NumOfDigits,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char * _fcvt(double _Val,int _NumOfDec,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char * _gcvt(double _Val,int _NumOfDigits,char *_DstBuf) ;
__attribute__ ((__dllimport__)) int _atodbl(_CRT_DOUBLE *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atoldbl(_LDOUBLE *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atoflt(_CRT_FLOAT *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atodbl_l(_CRT_DOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _atoldbl_l(_LDOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _atoflt_l(_CRT_FLOAT *_Result,char *_Str,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _lrotl(unsigned long long _Val,int _Shift);
__extension__ unsigned long long _lrotr(unsigned long long _Val,int _Shift);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _makepath(char *_Path,const char *_Drive,const char *_Dir,const char *_Filename,const char *_Ext);
_onexit_t _onexit(_onexit_t _Func);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _putenv(const char *_EnvString);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _rotl64(unsigned long long _Val,int _Shift);
__extension__ unsigned long long _rotr64(unsigned long long Value,int Shift);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
unsigned int _rotr(unsigned int _Val,int _Shift);
unsigned int _rotl(unsigned int _Val,int _Shift);
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _rotr64(unsigned long long _Val,int _Shift);
__attribute__ ((__dllimport__)) void _searchenv(const char *_Filename,const char *_EnvVar,char *_ResultPath) ;
__attribute__ ((__dllimport__)) void _splitpath(const char *_FullPath,char *_Drive,char *_Dir,char *_Filename,char *_Ext) ;
__attribute__ ((__dllimport__)) void _swab(char *_Buf1,char *_Buf2,int _SizeInBytes);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wfullpath(wchar_t *_FullPath,const wchar_t *_Path,size_t _SizeInWords);
__attribute__ ((__dllimport__)) void _wmakepath(wchar_t *_ResultPath,const wchar_t *_Drive,const wchar_t *_Dir,const wchar_t *_Filename,const wchar_t *_Ext);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wputenv(const wchar_t *_EnvString);
__attribute__ ((__dllimport__)) void _wsearchenv(const wchar_t *_Filename,const wchar_t *_EnvVar,wchar_t *_ResultPath) ;
__attribute__ ((__dllimport__)) void _wsplitpath(const wchar_t *_FullPath,wchar_t *_Drive,wchar_t *_Dir,wchar_t *_Filename,wchar_t *_Ext) ;
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _beep(unsigned _Frequency,unsigned _Duration) __attribute__ ((__deprecated__));
/* Not to be confused with _set_error_mode (int). */
__attribute__ ((__dllimport__)) void _seterrormode(int _Mode) __attribute__ ((__deprecated__));
__attribute__ ((__dllimport__)) void _sleep(unsigned long _Duration) __attribute__ ((__deprecated__));
#pragma line 574 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
char * ecvt(double _Val,int _NumOfDigits,int *_PtDec,int *_PtSign) ;
char * fcvt(double _Val,int _NumOfDec,int *_PtDec,int *_PtSign) ;
char * gcvt(double _Val,int _NumOfDigits,char *_DstBuf) ;
char * itoa(int _Val,char *_DstBuf,int _Radix) ;
char * ltoa(long _Val,char *_DstBuf,int _Radix) ;
int putenv(const char *_EnvString) ;
void swab(char *_Buf1,char *_Buf2,int _SizeInBytes) ;
char * ultoa(unsigned long _Val,char *_Dstbuf,int _Radix) ;
_onexit_t onexit(_onexit_t _Func);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct { __extension__ long long quot, rem; } lldiv_t;
#pragma empty_line
__extension__ lldiv_t lldiv(long long, long long);
#pragma empty_line
__extension__ long long llabs(long long);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ long long strtoll(const char * __restrict__, char ** __restrict, int);
__extension__ unsigned long long strtoull(const char * __restrict__, char ** __restrict__, int);
#pragma empty_line
/* these are stubs for MS _i64 versions */
__extension__ long long atoll (const char *);
#pragma empty_line
#pragma empty_line
__extension__ long long wtoll (const wchar_t *);
__extension__ char * lltoa (long long, char *, int);
__extension__ char * ulltoa (unsigned long long , char *, int);
__extension__ wchar_t * lltow (long long, wchar_t *, int);
__extension__ wchar_t * ulltow (unsigned long long, wchar_t *, int);
#pragma empty_line
/* __CRT_INLINE using non-ansi functions */
#pragma line 627 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
#pragma pack(pop)
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdlib_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdlib_s.h" 2 3
#pragma line 629 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 31 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
/* Return codes for _heapwalk() */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Values for _heapinfo.useflag */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The structure used to walk through the heap with _heapwalk. */
typedef struct _heapinfo {
int *_pentry;
size_t _size;
int _useflag;
} _HEAPINFO;
#pragma empty_line
#pragma empty_line
extern unsigned int _amblksiz;
#pragma empty_line
/* Make sure that X86intrin.h doesn't produce here collisions. */
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
/* Users should really use MS provided versions */
void * __mingw_aligned_malloc (size_t _Size, size_t _Alignment);
void __mingw_aligned_free (void *_Memory);
void * __mingw_aligned_offset_realloc (void *_Memory, size_t _Size, size_t _Alignment, size_t _Offset);
void * __mingw_aligned_realloc (void *_Memory, size_t _Size, size_t _Offset);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _resetstkoflw (void);
__attribute__ ((__dllimport__)) unsigned long _set_malloc_crt_max_wait(unsigned long _NewValue);
#pragma empty_line
__attribute__ ((__dllimport__)) void * _expand(void *_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) size_t _msize(void *_Memory);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) size_t _get_sbh_threshold(void);
__attribute__ ((__dllimport__)) int _set_sbh_threshold(size_t _NewValue);
__attribute__ ((__dllimport__)) errno_t _set_amblksiz(size_t _Value);
__attribute__ ((__dllimport__)) errno_t _get_amblksiz(size_t *_Value);
__attribute__ ((__dllimport__)) int _heapadd(void *_Memory,size_t _Size);
__attribute__ ((__dllimport__)) int _heapchk(void);
__attribute__ ((__dllimport__)) int _heapmin(void);
__attribute__ ((__dllimport__)) int _heapset(unsigned int _Fill);
__attribute__ ((__dllimport__)) int _heapwalk(_HEAPINFO *_EntryInfo);
__attribute__ ((__dllimport__)) size_t _heapused(size_t *_Used,size_t *_Commit);
__attribute__ ((__dllimport__)) intptr_t _get_heap_handle(void);
#pragma line 140 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
static __inline void *_MarkAllocaS(void *_Ptr,unsigned int _Marker) {
if(_Ptr) {
*((unsigned int*)_Ptr) = _Marker;
_Ptr = (char*)_Ptr + 16;
}
return _Ptr;
}
#pragma line 159 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
static __inline void _freea(void *_Memory) {
unsigned int _Marker;
if(_Memory) {
_Memory = (char*)_Memory - 16;
_Marker = *(unsigned int *)_Memory;
if(_Marker==0xDDDD) {
free(_Memory);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
}
#pragma line 205 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
#pragma pack(pop)
#pragma line 630 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma line 5 "./duc.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//#define FREQ 1657
//#define FREQ 0
/*
N Accumulator
P Phase
M Output
B N-P
Frequency
=========
Fomin = (Fs/(2^N))
Fo = (Fs/(2^N))*Dacc
Fomax = (Fs/2^(N-P))
#pragma empty_line
Phase Quantization
==================
SFDRest = 6.02P - 3.92dB
P = (SFDR+3.92)/6.02
#pragma empty_line
Amplitude Quantization
======================
SNRest = -6.02M -1.76db
Best performance (-SFDR<SNR): P = M+1
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef uint16 acc_t;
typedef uint5 phi_t;
typedef int16 dds_t;
typedef uint11 rnd_t;
#pragma empty_line
#pragma empty_line
// Largest coefficient: 69475 (0x10F63)
typedef int18 srrc_data_t;
typedef int18 srrc_coef_t;
typedef int38 srrc_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf1_data_t;
typedef int18 imf1_coef_t;
typedef int38 imf1_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf2_data_t;
typedef int18 imf2_coef_t;
typedef int38 imf2_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf3_data_t;
typedef int18 imf3_coef_t;
typedef int38 imf3_acc_t;
#pragma empty_line
typedef int18 mix_data_t;
#pragma empty_line
void duc (
srrc_data_t din_i,
acc_t freq,
mix_data_t *dout_i,
mix_data_t *dout_q
);
#pragma empty_line
int37 mult (
int18 c,
int19 d
);
#pragma empty_line
int37 symtap (
int18 a,
int18 b,
int18 c
);
#pragma empty_line
srrc_acc_t srrc_mac (
int18 c,
int18 d,
int40 s
);
#pragma empty_line
imf1_acc_t mac1 (
imf1_coef_t c,
imf1_data_t d,
imf1_acc_t s
);
#pragma empty_line
imf2_acc_t mac2 (
imf2_coef_t c,
imf2_data_t d,
imf2_acc_t s
);
#pragma empty_line
int48 mac (
int18 c,
int18 d,
int48 s
);
#pragma empty_line
void srrc (
srrc_data_t *y,
srrc_data_t x
);
#pragma empty_line
void imf1 (
imf1_data_t *y,
imf1_data_t x
);
#pragma empty_line
void imf2 (
imf2_data_t *y,
imf2_data_t x
);
#pragma empty_line
void imf3 (
imf2_data_t *y,
imf2_data_t x
);
#pragma empty_line
void mixer (
acc_t freq,
mix_data_t Din,
mix_data_t *Dout_I,
mix_data_t *Dout_Q
);
#pragma empty_line
void dds (
acc_t freq,
dds_t *sin,
dds_t *cosine
);
#pragma empty_line
rnd_t rnd();
#pragma line 1 "imf1.c" 2
#pragma empty_line
#pragma empty_line
void imf1 (
imf1_data_t *y,
imf1_data_t x
) {
const imf1_coef_t c[24]={
#pragma empty_line
#pragma line 1 "./imf1_coef.h" 1
-224,
1139,
-3642,
9343,
-22689,
81597,
81597,
-22689,
9343,
-3642,
1139,
-224,
0,
0,
0,
0,
0,
131071,
0,
0,
0,
0,
0,
0
#pragma line 8 "imf1.c" 2
#pragma empty_line
};
_ssdm_SpecConstant(c);
#pragma line 9 "imf1.c"
/*
Transposed form FIR poly branches
*/
static imf1_acc_t shift_reg_p[25][2];
static imf1_data_t in = 0;
static uint1 init = 1;
static uint1 cnt = 0;
static uint1 ch = 0;
static uint5 i = 0;
#pragma empty_line
imf1_acc_t acc;
#pragma empty_line
L1:
//Latch input
if (i==0) {
in = x;
}
uint5 inc = i+1;
#pragma empty_line
//Calculate tap
acc = mac1(c[i], in, (init || i==11 || i==23) ? 0 : shift_reg_p[inc][ch]);
//Shift
shift_reg_p[i][ch] = acc;
if (i==23) {
if (ch) init = 0;
ch = ch ^ cnt;
cnt = !cnt;
}
//Output
if ((i==0) || (i==12))
{
*y = acc >> 17;
}
#pragma empty_line
i = (i == 23) ? 0 : inc;
}
|
the_stack_data/28261757.c | #include <stdio.h>
#include <stdbool.h>
/* COMP 1571
* Lab 3: Elementary Cellular Automata
* by Will Mitchell
*
* Instructor's note: Pass any argument on the command line to have the output
* displayed one row at a time to show the calculations. Hit CTRL+D (EOF) to
* advance. Careful though, too many may close the terminal
*/
int main(int argc, const char** argv) {
const int COLS = 65;
const int ROWS = 32;
bool data[ROWS][COLS];
// Initialize values
for (int row = 0; row < ROWS; ++row) {
for (int col = 0; col < COLS; ++col) {
data[row][col] = false;
}
}
// Setup starting condition
data[0][COLS/2] = true;
// Calculate new results
for (int row = 1; row < ROWS; ++row) {
for (int col = 1; col < COLS - 1; ++col) {
// Rule 90 https://en.wikipedia.org/wiki/Rule_90
// XOR of its two neighbors above
data[row][col] = data[row - 1][col - 1] ^ data[row - 1][col + 1];
}
}
// Print everything
for (int row = 0; row < ROWS; ++row) {
for (int col = 0; col < COLS; ++col) {
if (data[row][col]) {
printf("X");
} else {
printf(".");
}
}
printf("\n");
// Pause stuff - Not expected in student's code
if (argc > 1) {
getchar();
}
// -- End pause stuff
}
printf("\n");
return 0;
}
|
the_stack_data/714122.c | #include <stdio.h>
int main()
{
int c;
while ((c = getchar()) != EOF)
printf('%c ', c);
return 0;
} |
the_stack_data/200142245.c | /* Taxonomy Classification: 0000020000000000000300 */
/*
* WRITE/READ 0 write
* WHICH BOUND 0 upper
* DATA TYPE 0 char
* MEMORY LOCATION 0 stack
* SCOPE 0 same
* CONTAINER 2 struct
* POINTER 0 no
* INDEX COMPLEXITY 0 constant
* ADDRESS COMPLEXITY 0 constant
* LENGTH COMPLEXITY 0 N/A
* ADDRESS ALIAS 0 none
* INDEX ALIAS 0 none
* LOCAL CONTROL FLOW 0 none
* SECONDARY CONTROL FLOW 0 none
* LOOP STRUCTURE 0 no
* LOOP COMPLEXITY 0 N/A
* ASYNCHRONY 0 no
* TAINT 0 no
* RUNTIME ENV. DEPENDENCE 0 no
* MAGNITUDE 3 4096 bytes
* CONTINUOUS/DISCRETE 0 discrete
* SIGNEDNESS 0 no
*/
/*
Copyright 2004 M.I.T.
Permission is hereby granted, without written agreement or royalty fee, to use,
copy, modify, and distribute this software and its documentation for any
purpose, provided that the above copyright notice and the following three
paragraphs appear in all copies of this software.
IN NO EVENT SHALL M.I.T. BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE
AND ITS DOCUMENTATION, EVEN IF M.I.T. HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMANGE.
M.I.T. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
AND NON-INFRINGEMENT.
THE SOFTWARE IS PROVIDED ON AN "AS-IS" BASIS AND M.I.T. HAS NO OBLIGATION TO
PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
typedef struct
{
char buf1[10];
char buf2[10];
} my_struct;
int main(int argc, char *argv[])
{
my_struct s;
/* BAD */
s.buf1[4105] = 'A';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.