file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/31386882.c | /*
Write a function that given a list of non negative integers, arranges them
such that they form the largest possible number. For example, given
[50, 2, 1, 9], the largest formed number is 95021.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define USAGE "usage: %s <number> [<number>]\n"
#define BUFFER_SIZE 256
void to_str(char* buf, int a, int b)
{
char tmp[BUFFER_SIZE];
sprintf(buf, "%d", a);
sprintf(tmp, "%d", b);
strcat(buf, tmp);
}
int comparator(const void* lhs, const void* rhs)
{
int l = *(int*)lhs;
int r = *(int*)rhs;
if (l == r)
return 0;
char lbuf[BUFFER_SIZE];
char rbuf[BUFFER_SIZE];
to_str((char*)lbuf, l, r);
to_str((char*)rbuf, r, l);
return strcmp(rbuf, lbuf);
}
/* Returns the length of the buffer. On error return -1. */
int readargs(int argc, char* argv[], int* buffer)
{
int len = argc-1;
for (int i = 0; i < len; ++i)
{
int val = atoi(argv[i+1]);
if (val < 0)
return -1;
buffer[i] = val;
}
return len;
}
int main(int argc, char* argv[])
{
int buffer[BUFFER_SIZE];
if (argc - 1 > BUFFER_SIZE)
{
fprintf(stderr, USAGE, argv[0]);
fprintf(stderr, "\tToo many arguments. Max args: %d\n", BUFFER_SIZE);
return 1;
}
if (readargs(argc, argv, buffer) <= 0)
{
fprintf(stderr, USAGE, argv[0]);
fprintf(stderr, "\tInvalid input. Non-negative integers only\n");
return 1;
}
qsort(buffer, argc-1, sizeof(int), comparator);
for(int i = 0; i < argc-1; ++i)
printf("%d", buffer[i]);
printf("\n");
return 0;
}
|
the_stack_data/146603.c | //I bet you didn't read these notes, did you? Delete this line to compile
/* READ THIS BEFORE COMPILING AND RUNNING THIS PROGRAM.
- This program was developed using the Borland C++ Rel. 2.0 compiler
- Read the note on how to convert to workstation-ready code if you want
to run this on a Sun or mainframe. It's right at the top of the code
- This is an M/M/1 simulator. Conversion to M/M/1/K is pretty easy, if
messages are just rejected when the population count reaches a certain
level. Conversion to M/M/m is a little trickier, and requires the use
of an array for the servers to keep an account of the status of each.
As a suggestion, the status would include the termination time of the
element in service at that particular server. When the server is
empty, perhaps the time to completion of service could be made negative,
to reflect empty status. Note that there is no such time as a negative
time.
- This simulator incarnation seems to work, but I make no claim as to the
perfection of it. Nor do I make any claim as to preference of design
approach. In fact, already this is a collection of the work of a couple of
people. Copy this to a safe file that won't be corrupted. As I said, it
seems to work as is. But then, don't hesitate to hack it up and make it
your own. It's fun to express yourself with creative designs.
*/
/*******************************************************************/
/* */
/* PC USERS: This program contains frequent usage of the */
/* "long int" data type. This is because while the involved values*/
/* are discrete, they are too large to fit into a 16-bit value. */
/* EVERYONE ELSE: (Take note, workstation users) To get rid of the */
/* "long int" declaration, simply grep for "long", then do the */
/* substitution of "int" for "long int". I don't think that the */
/* Sun compliler, in particular, recognizes the "long int" data */
/* type */
/*******************************************************************/
/*******************************************************************/
/* */
/* Queueing Network Simulation Program */
/* */
/*******************************************************************/
/* */
/* For Class EE381K Project Assignment */
/*******************************************************************/
/* Author : Hong-Dah Sheng */
/*command format: */
/* mm1c [arrival rate][service rate][run length][initial queue size]*/
/* */
/*******************************************************************/
/* Appended and changed for EE381K by Peter J. Zievers */
/* November-December 1992 */
/*******************************************************************/
#include <stdio.h>
#include <math.h>
/******************************************************************/
/* */
/* Define System Parameter */
/* */
/******************************************************************/
#define maxcenter 20 /*maximum number of service center */
#define modulus 1000000000 /*modulus of random number generator */
#define maximum 1.0e9 /*maximun of the random integer */
/*******************************************************************/
/* */
/* RANDOM NUMBER GENERATOR SEED RIGHT HERE */
/* */
/*******************************************************************/
#define seed 3 /*seed of the random number generator */
/* Note that if one wanted, one could input this value at the command
line. If that is a desired mode, then one would have to establish a
global data element of type double or type int called "seed" in the
global variable section below. Then, one would have to use the atof()
or atoi() function in the math.h library to convert, because the input
held in the argv[] array is held as a character string. Note that if
the seed is input from the command line, the #define would have to be
removed or commented out. pjz 12/10/92
*/
#define population_limit 500 /*maximum number of customer allowed */
/*check for unbounded parameter */
#define TRUE 1
/*******************************************************************/
/* */
/* Define Data Structure */
/* */
/*******************************************************************/
typedef double TIME_TYPE; /* basic time unit */
typedef int CENTER_IDX; /* type for center I.D. */
struct event_list { /* element of the event list */
TIME_TYPE time; /* time at which event will transpire*/
CENTER_IDX queue; /* specific index of involved queue */
struct event_list* next; /* pointer for linkage to next event */
};
typedef struct event_list ELEMENT; /* Compiler directives for convenience */
typedef ELEMENT* LINK; /* pointer to event element */
/*****************************************************************/
/* */
/* Global Variable */
/* */
/*****************************************************************/
int center_no = 0; /*actual number of service center to be run */
CENTER_IDX current_center = 0; /* center whose event is being processed */
TIME_TYPE clock = 0; /*the present simulation time */
TIME_TYPE sim_end = 0; /*the amount of time to simulate */
LINK event_head; /*pointer to header of the event list */
double arrive_rate; /*arrival rate of customer */
double service_rate; /*service rate at server */
/*************************** My code *****************************/
int num_servers = 10;
int idle_servers = 10;
int queue_size = 15;
int population = 20;
int service_customer_number = 0;
TIME_TYPE p0_t = 0, p1_t = 0, p2_t = 0, p3_t = 0, p4_t = 0, p5_t = 0, p6_t = 0;
int iter = 0;
/*****************************************************************/
/* system statistics*/
long int total_customer; /*customer present in system */
long int total_event; /*total event had been processed */
long int total_completion; /*number of completion */
TIME_TYPE total_wait_time; /*total wait time */
TIME_TYPE total_busy_time; /*total busy time */
TIME_TYPE sys_last_changed; /*time of last change of system state */
/** Trace switch - for debugging purposes **/
int rswitch; /* report statistics every 500 completion*/
int dswitch; /*dump event and center state at every step */
/*******************************************************************/
/* */
/* Main Program */
/* */
/*******************************************************************/
main(argc, argv)
int argc; /* number of optional argument */
char* argv[]; /* argument list */
{
/*** Function ********************/
int init_rand();
void report();
int init_query(), check_option();
int init_buffer();
int remove_first_event(), insert_event();
double uniform01(), mexpntl();
long int srand(), subtract();
int in_system(), out_system();
CENTER_IDX dummy;
long int start_level;
FILE* fp_mean_customer;
fp_mean_customer = fopen("C:\\Users\\NESL\\source\\repos\\Jungmin\\Jungmin\\customer.txt", "a");
/***** Execution Begin *******/
/* First, we have to initialize everything. In this section, we check for
the following things:
(1) Do we want to activate the debugging features, so we can see
can see incremental progress of the system?
(2) If we haven't input from the command line, we need to
parameterize the model in some way.
(3) All buffer structures need to be initialized. Recall that
this is a model of a queueing system, and queues entail buffers.
Also, the system uses an event queue apart from the system
under simulation, and this control structure must also be
initialized.
(4) The random number generator must be initialized, and the
transients from cold start must be purged.
(5) The first event must be provided, since events are produced
in a stream, where one event leads to the creation of the
next event. Without the first event, the stream would never
get started
*/
/* check_option(argc,argv);*/ /*check option 'r' and 'd' */
if (argc == 5)
{
arrive_rate = atof(argv[1]);
service_rate = atof(argv[2]);
sim_end = atof(argv[3]);
start_level = atol(argv[4]);
}
else
init_query(&start_level); /*query model to be simulate */
init_buffer(); /*initialize buffer */
init_rand(); /*initialize random number gen. */
dummy = 0;
insert_event(mexpntl(1.0 / arrive_rate), dummy);
/*generate first arrival */
/* If the starting queue level is greater than 0, then have to issue a service
event to get the service distribution launched. Otherwise, the first arrival
will trigger the start of the service distribution
*/
if (start_level != 0)
{
insert_event((clock + mexpntl(1.0 / service_rate)), 1);
total_customer = start_level;
}
/* The next section of code simulates the target system. The conditionals in
the while statement are interesting because they signal termination of the
simulation run. Note the visual structure of these conditionals. Each
conditional is stacked up so each condition is readable and obvious. To add
to this list of conditionals, add a "&&" to the end of the last conditional
and insert a line below with your own conditional.
*/
while (
(clock < sim_end) && /*End of simulated run time? */
(total_customer < population_limit)/* Queue overflow? */
)
{
remove_first_event(&clock, ¤t_center); /*get next event and
update the clock in
the simulated system */
/* This switch/case structure branches control of the simulator to the
appropriate place to deal with the event just removed from the event queue.
Adding treatments to this is as easy as assigning a code number to the type of
treatment and putting in a new case() statement similar to those shown below.
If you aren't sure how the switch statement works, check a C programming text
for lots of detail on how to handle switch structures. Kelley and Pohl is a
pretty good text, or Lippman if you like to code in C++.
*/
switch (current_center) {
case(0): /* an arrival into system*/
in_system(); /*do system statistics for newcomer */
break;
case(1): /* A completion of service */
out_system(); /* leave the system */
break;
default:
printf("There's a screwy element in the event queue\n");
exit(1);
}
/* This stuff below is for debugging purposes. If you activated the debugging
information from the command line, this piece will be activated and stuff will
print out when you run the simulator. If not, this piece will not be executed
*/
if (dswitch)
dump_event_list();
iter++;
};
/**************************** My code ****************************/
printf("Iteration : %d \n\n", iter);
printf("\n");
printf("p0 : %lf\n", p0_t / clock);
printf("p1 : %lf\n", p1_t / clock);
printf("p2 : %lf\n", p2_t / clock);
printf("p3 : %lf\n", p3_t / clock);
printf("p4 : %lf\n", p4_t / clock);
printf("p5 : %lf\n", p5_t / clock);
printf("p6 : %lf\n", p6_t / clock);
printf("\n");
/*****************************************************************/
if (total_customer > population_limit) /* Did the simulator stop because
the max. queue level was
exceeded? */
{
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
printf("! BLOWUP !\n");
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}
/* end of simulation*/
report(); /*generate final report */
fprintf(fp_mean_customer, "%lf ", total_wait_time / clock);
fclose(fp_mean_customer);
system("pause");
}
/********************************************************************/
/* Function : check_option() */
/********************************************************************/
check_option(argc, argv)
int argc;
char* argv[];
{
int i;
char c;
for (i = 1; i < argc; ++i) {
c = *argv[i];
switch (c) {
case 'd': dswitch = TRUE; /*enable dump at each step */
break;
default: printf("\nOnly: 'd' and 'r' allowed\n");
break;
}
}
}
/***************************************************************/
/* Function : init_query */
/***************************************************************/
/* ask for configuration and parameter to simulate */
init_query(begin)
long int* begin; /* starting queue level */
{
int i, j;
double pb_sum;
center_no = 1;
/*ask arrival rate and mean service time */
printf("\nPlease enter the arrival rate of customer? ");
scanf("%lf", &arrive_rate);
printf("\nPlease enter the mean service time of queue? ");
scanf("%lf", &service_rate);
/*ask for amount of time to simulate */
printf("\nPlease enter the amount of time to be simulated?");
scanf("%lf", &sim_end);
printf("\nPlease enter the starting queue length ");
scanf("%ld", begin);
}
/**********************************************/
/* Function:init_buffer */
/**********************************************/
init_buffer()
{
int i; /* the center index */
/* initialize system state and statistics */
event_head = NULL;
total_customer = 0;
total_event = 0;
current_center = 0;
clock = 0.0;
total_completion = 0;
total_wait_time = 0.0;
total_busy_time = 0.0;
sys_last_changed = 0.0;
/*****************************Change******************************/
num_servers = 10;
idle_servers = 10;
service_customer_number = 0;
/*****************************************************************/
}
/********************************************/
/* Function: remove_first_event */
/********************************************/
remove_first_event(t, x)
TIME_TYPE* t;
CENTER_IDX* x;
{
if (event_head == NULL) /* warning for error */
printf("empty event_list");
else { /* get the first event in the list */
LINK t1 = event_head;
*t = t1->time; /* Extract time from event */
*x = t1->queue; /* Extract indicator from event */
event_head = event_head->next; /* Link in new head of list */
free(t1); /* deallocate memory to OS */
++total_event; /* increment count for processed event*/
}
}
/*******************************************/
/* Function: insert_event */
/*******************************************/
insert_event(t, x)
TIME_TYPE t;
CENTER_IDX x;
{
CENTER_IDX holder;
LINK t2;
LINK t1 = (LINK)malloc(sizeof(ELEMENT));
/*obtain buffer from OS */
/* fill data in this buffer */
holder = x;
t1->next = NULL;
t1->queue = holder;
t1->time = t;
if (event_head == NULL) /* the list is free,put on head*/
event_head = t1;
else {
if (t < event_head->time) {
/*timer smaller than other event*/
/*put in head of list*/
t1->next = event_head;
event_head = t1;
}
else {
/* put this element in the list */
/* in order of time sequence */
t2 = event_head;
while ((t2->next != NULL) && (t > t2->next->time))
t2 = t2->next;
t1->next = t2->next;
t2->next = t1;
};
};
}
/***********************************************************/
/*Function: in_system */
/**********************************************************/
/* A new customer arrives at the system. Update system statistics */
/*Schedule next arrival */
in_system()
{
double mexpntl();
int i, suc;
LINK dum;
TIME_TYPE temp;
suc = 0;
total_busy_time += (clock - sys_last_changed) * service_customer_number;
total_wait_time += (clock - sys_last_changed) * total_customer;
if (total_customer == 1)
p1_t += (clock - sys_last_changed);
else if (total_customer == 2)
p2_t += (clock - sys_last_changed);
else if (total_customer == 3)
p3_t += (clock - sys_last_changed);
else if (total_customer == 4)
p4_t += (clock - sys_last_changed);
else if (total_customer == 5)
p5_t += (clock - sys_last_changed);
else if (total_customer == 6)
p6_t += (clock - sys_last_changed);
else
p0_t += (clock - sys_last_changed);
if (idle_servers > 0)
{
insert_event(clock + mexpntl(1.0 / service_rate), 1); // Create Departure event
service_customer_number++;
idle_servers--; // idle_servers = num_servers - customer_in_service;
}
// Increment total customer count
total_customer++;
// Update the time marker
sys_last_changed = clock;
//seed = rand() % 1000;
// Create next Arrive event
if (total_customer == queue_size)
{
temp = clock;
while (suc == 0)
{
temp = temp + mexpntl(1.0 / (arrive_rate * (population - total_customer)));
dum = event_head;
if (temp > dum->time)
suc = 1;
}
insert_event(temp, 0); // Create Arrival event
}
else
insert_event(clock + mexpntl(1.0 / (arrive_rate * (population - total_customer))), 0); // Create Arrival event
}
/*****************************************************************/
/*Function: out_system */
/****************************************************************/
/* A customer leaves the system. Do system statistics */
/* If interim report needed (at every 500 completion), */
/* call report function */
out_system()
{
void report();
double mexpntl(TIME_TYPE);
int i;
total_completion++;
total_busy_time += (clock - sys_last_changed) * service_customer_number;
total_wait_time += (clock - sys_last_changed) * total_customer; //(total_customer - service_customer_number);
if (total_customer == 1)
p1_t += (clock - sys_last_changed);
else if (total_customer == 2)
p2_t += (clock - sys_last_changed);
else if (total_customer == 3)
p3_t += (clock - sys_last_changed);
else if (total_customer == 4)
p4_t += (clock - sys_last_changed);
else if (total_customer == 5)
p5_t += (clock - sys_last_changed);
else if (total_customer == 6)
p6_t += (clock - sys_last_changed);
else
p0_t += (clock - sys_last_changed);
//seed = rand() % 1000;
if (total_customer - service_customer_number > 0)
insert_event(clock + mexpntl(1.0 / service_rate), 1);
else
{
idle_servers++;
service_customer_number--;
}
// Decrement total customer count
total_customer--;
// Update the time marker
sys_last_changed = clock;
/* If the debugging info. is asked for, the next statement activates */
if (rswitch && ((total_completion % 500) == 0))
report();
}
/*****************************************************************/
/* Function: report */
/******************************************************************/
/* generate report of (1) total completion (2)total event */
/* (3) present clock (4) average system performance parameters */
void report()
{
int i;
printf("\n\n\nTotal Completion:%7ld", total_completion);
printf("\nNumber of Events Processed:%7ld", total_event);
printf("\nSimulated time : %8.1f seconds", clock);
printf("\n\n\nPerformance of the System\n");
/*overall system performance */
printf(" Average Average Average Average\n");
printf(" Service Arrival Waiting Utilization System \n");
printf(" Rate Rate Rate Factor Population\n");
printf("\n------------------------------------------------------------------------");
printf("\n %7.3f %6.3f %5.3f %3.4f %5.3f\n",
total_busy_time / (double)total_completion,
(double)total_completion / clock,
total_wait_time / (double)total_completion,
arrive_rate / service_rate,
total_wait_time / clock);
}
/***************************************************************/
/* Function: Dump_event_list */
/****************************************************************/
/* dump all event */
dump_event_list()
{
LINK t1;
printf("\nEvent_list=");
t1 = event_head;
while (t1 != NULL) {
printf("!%10f>%2d ", t1->time, t1->queue);
t1 = t1->next;
}
}
/***************************************************************/
/* Data structure for random number generator */
/***************************************************************/
long int y[55];
/***************************************************************/
/* Function: init_rand() */
/***************************************************************/
init_rand()
{
long int subtract();
long int x1, x2, x3, i, temp, srand();
/*generate initial data for the array */
x1 = y[34 * 21 % 55] = seed;
x2 = y[(1 + 34) * 21 % 55] = 1;
for (i = 2; i <= 54; ++i)
{
x3 = y[(i + 34) * 21 % 55] = subtract(x1, x2);
x1 = x2;
x2 = x3;
};
/* skip first 165 data */
for (i = 1; i <= 165; srand(), ++i);
}
/**********************************************************************/
/* Function: mexpntl(mean) */
/**********************************************************************/
/* a negative exponential random variable generator */
TIME_TYPE mexpntl(mean)
TIME_TYPE mean;
{
double uniform01();
return((-mean) * log(uniform01())); }
/**********************************************************************/
/* Function: uniform01() */
/**********************************************************************/
/* a uniform randon number generator in [0,1] */
double uniform01()
{
long int srand();
return((double)srand() / maximum);
}
/********************************************************************/
/* Function: srand() */
/********************************************************************/
/* generate a random integer number from 0 to 1000000000 */
/* The range of the number depends on the modulus that is operated */
/* on in subtract(). This modulus is set in a #define at the top */
/* of the code */
long int srand()
{
static long int n_minus_55;
long int t1, subtract();
t1 = subtract(y[n_minus_55], y[(n_minus_55 + 31) % 55]);
y[n_minus_55] = t1;
n_minus_55 = (n_minus_55 + 1) % 55;
return (t1);
}
/********************************************************************/
/* Function: subtract(a,b) */
/********************************************************************/
long int subtract(a, b)
long int a, b;
{
if (a >= b)
return ((a - b));
else
return ((modulus - (b - a)));
}
|
the_stack_data/175142179.c | extern const unsigned char Pods_DDJiOSVersionString[];
extern const double Pods_DDJiOSVersionNumber;
const unsigned char Pods_DDJiOSVersionString[] __attribute__ ((used)) = "@(#)PROGRAM:Pods_DDJiOS PROJECT:Pods-1" "\n";
const double Pods_DDJiOSVersionNumber __attribute__ ((used)) = (double)1.;
|
the_stack_data/527469.c | #include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<errno.h>
#define m 2
#define n 3
typedef struct node{
int (*ptr1)[m][n];
int (*ptr2)[m][n];
int (*ptr3)[m][n];
int row;
}th_data;
void *run_add(void * th_d)
{
th_data *dptr = th_d;
int p,q,r;
r = dptr->row;
for(p = 0 ; p < n ; p+=2)
(*dptr->ptr3)[r][p] = (*dptr->ptr1)[r][p] - (*dptr->ptr2)[r][p];
pthread_exit(NULL);
}
void *run_add_2(void * th_d)
{
th_data *dptr = th_d;
int p,q,r;
r = dptr->row;
for(p = 1 ; p < n ; p+=2)
(*dptr->ptr3)[r][p] = (*dptr->ptr1)[r][p] - (*dptr->ptr2)[r][p];
pthread_exit(NULL);
}
int main(void)
{
int A[m][n],B[m][n],C[m][n],i,j,k,l,x;
pthread_t pt1,pt2;
printf("\nEnter the values of 1st matrix :\n");
for ( i=0 ; i<m ; i++ )
for ( j=0 ; j<n ; j++ )
scanf("%d",&A[i][j]);
printf("\nEnter the values of 2nd matrix :\n");
for ( i=0 ; i<m ; i++ )
for ( j=0 ; j<n ; j++ )
scanf("%d",&B[i][j]);
th_data d,e;
d.ptr1 = &A;
d.ptr2 = &B;
d.ptr3 = &C;
for ( k=0;k<m;k++)
{
d.row = k;
if((d.row % 2)==0)
x = pthread_create(&pt1,NULL,run_add,&d);
else
x = pthread_create(&pt2,NULL,run_add_2,&d);
if(x)
{
printf("\nThread creation failed with error code : %d\n",x);
exit(0);
}
pthread_join(pt1,NULL); //Waiting for child thread
pthread_join(pt2,NULL);
}
printf("\nThe solution matrix : \n");
for ( i=0;i<m;i++)
{
for(j=0;j<n;j++)
printf("%d\t",C[i][j]);
printf("\n");
}
pthread_exit(NULL);
}
|
the_stack_data/20451606.c | #include <stdio.h>
#include <stdlib.h>
#ifdef COMPILE_ERROR
void const_int_ptr_fail(const int *n) {
*n = 27;
}
#endif
void const_int_ptr(const int *n) {
n = (int *) malloc(sizeof(int));
printf("in const_int_ptr: %d\n", *n);
}
#ifdef COMPILE_ERROR
void const_int_ptr_fail2(const int *n) {
n = (int *) malloc(sizeof(int));
*n = 48;
}
#endif
#ifdef COMPILE_ERROR
void int_ptr_const_fail(int* const n) {
n = (int *) malloc(sizeof(int));
printf("in const_int_ptr: %d\n", *n);
}
#endif
void int_ptr_const(int* const n) {
*n = 23;
}
int main() {
int n = 5;
printf("before: %d\n", n);
int_ptr_const(&n);
printf("after int_ptr_const: %d\n", n);
const_int_ptr(&n);
printf("after const_int_ptr: %d\n", n);
return 0;
}
|
the_stack_data/26700985.c | // Check that we pass -fcomment-block-commands to frontend.
//
// RUN: %clang -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-ARG
// RUN: %clang -c %s -fcomment-block-commands=Foo -### 2>&1 | FileCheck %s --check-prefix=CHECK-ARG
//
// CHECK-ARG: -fcomment-block-commands=Foo
//
// CHECK-NO-ARG-NOT: -fcomment-block-commands=
|
the_stack_data/25660.c | /*
* Copyright (c) 2003 Stephen Williams ([email protected])
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
/*
* Things that should be statically linked by VPI modules go here.
*/
void __libvpi_c_dummy_function()
{
}
|
the_stack_data/1153000.c | // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1}, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
// RUN: ]}' -- -Wno-strict-prototypes -x c
int myprint();
int add(int X, int Y);
void notRelated(int A, int B) {}
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters of 'notRelated' of similar type ('int')
// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in the range is 'A'
// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in the range is 'B'
int addedTogether(int A, int B) { return add(A, B); } // NO-WARN: Passed to same function.
void passedToSameKNRFunction(int A, int B) {
myprint("foo", A);
myprint("bar", B);
}
// CHECK-MESSAGES: :[[@LINE-4]]:30: warning: 2 adjacent parameters of 'passedToSameKNRFunction' of similar type ('int')
// CHECK-MESSAGES: :[[@LINE-5]]:34: note: the first parameter in the range is 'A'
// CHECK-MESSAGES: :[[@LINE-6]]:41: note: the last parameter in the range is 'B'
// This is actually a false positive: the "passed to same function" heuristic
// can't map the parameter index 1 to A and B because myprint() has no
// parameters.
|
the_stack_data/178264445.c |
//{{BLOCK(Stage7Both)
//======================================================================
//
// Stage7Both, 256x256@4,
// + palette 256 entries, not compressed
// + 2 tiles (t|f|p reduced) not compressed
// + regular map (in SBBs), not compressed, 32x32
// Total size: 512 + 64 + 2048 = 2624
//
// Time-stamp: 2018-05-03, 14:54:40
// Exported by Cearn's GBA Image Transmogrifier, v0.8.3
// ( http://www.coranac.com/projects/#grit )
//
//======================================================================
const unsigned short Stage7BothTiles[32] __attribute__((aligned(4)))=
{
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x4655,0x4466,0x5465,0x6644,0x5465,0x5465,0x5546,0x6455,
0x5564,0x4665,0x6564,0x6446,0x4646,0x5664,0x6454,0x5556,
};
const unsigned short Stage7BothMap[1024] __attribute__((aligned(4)))=
{
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,
0x0000,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,
0x0000,0x0000,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,
0x0000,0x0000,0x0001,0x0000,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,0x0000,0x0001,
0x0000,0x0001,0x0000,0x0001,0x0000,0x0000,0x0001,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,0x0000,0x0001,
0x0000,0x0001,0x0000,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,
0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
};
const unsigned short Stage7BothPal[256] __attribute__((aligned(4)))=
{
0x0000,0x001F,0x318C,0x4A52,0x14EC,0x0CAA,0x150E,0x6318,
0x4210,0x001F,0x03E0,0x03FF,0x7C00,0x7C1F,0x7FE0,0x7FFF,
0x0004,0x0007,0x000B,0x000F,0x0013,0x0017,0x001B,0x001F,
0x0080,0x00E0,0x0160,0x01E0,0x0260,0x02E0,0x0360,0x03E0,
0x0084,0x00E7,0x016B,0x01EF,0x0273,0x02F7,0x037B,0x03FF,
0x1000,0x1C00,0x2C00,0x3C00,0x4C00,0x5C00,0x6C00,0x7C00,
0x1004,0x1C07,0x2C0B,0x3C0F,0x4C13,0x5C17,0x6C1B,0x7C1F,
0x1080,0x1CE0,0x2D60,0x3DE0,0x4E60,0x5EE0,0x6F60,0x7FE0,
0x0842,0x0C63,0x14A5,0x1CE7,0x2529,0x2D6B,0x35AD,0x3DEF,
0x4631,0x4E73,0x56B5,0x5EF7,0x6739,0x6F7B,0x77BD,0x7FFF,
0x001F,0x007F,0x00FF,0x017F,0x01FF,0x027F,0x02FF,0x037F,
0x03FF,0x03FC,0x03F8,0x03F4,0x03F0,0x03EC,0x03E8,0x03E4,
0x03E0,0x0FE0,0x1FE0,0x2FE0,0x3FE0,0x4FE0,0x5FE0,0x6FE0,
0x7FE0,0x7F80,0x7F00,0x7E80,0x7E00,0x7D80,0x7D00,0x7C80,
0x7C00,0x7C03,0x7C07,0x7C0B,0x7C0F,0x7C13,0x7C17,0x7C1B,
0x7C1F,0x701F,0x601F,0x501F,0x401F,0x301F,0x201F,0x101F,
0x0000,0x2108,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x2108,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0421,0x0842,0x0C63,0x1084,0x14A5,0x18C6,0x1CE7,
0x2108,0x2529,0x294A,0x2D6B,0x318C,0x35AD,0x39CE,0x3DEF,
0x4210,0x4631,0x4A52,0x4E73,0x5294,0x56B5,0x5AD6,0x5EF7,
0x6318,0x6739,0x6B5A,0x6F7B,0x739C,0x77BD,0x7BDE,0x7FFF,
};
//}}BLOCK(Stage7Both)
|
the_stack_data/145993.c | //Caso definamos apenas a como int; b e c como float; obtemos o valor de c equivalente a 4.1
#include <stdio.h>
int main() {
int a;
float b, c;
a = 3;
b = a/2;
c = b + 3.1;
printf("%g", c);
}
|
the_stack_data/45450036.c | #include <stdio.h>
int main()
{
// 'a' 'b' 'A'
// "jack" == 'j' + 'a' + 'c' + 'k' + '\0
char name[10] = "jack888\n";
// printf(name);
printf("jack888\n");
char it[8] = "it";
char it2[8] = {'i', 't', '\0'};
char it3[8] = {'i', 't', '0'};
// not normal string
// char it4[8] = {'i', 't', '0', '0', '0', '0', '0', '0'...};
char it4[8] = {'i', 't'};
// none a string
char it5[] = {'i', 't'};
char ary[] = "array";
int size = sizeof(ary);
printf("%d\n",size);
for (int i = 0; i < sizeof(ary); i++) {
printf("%u-%s\n",ary[i],name);
}
printf("--------\n");
char i[] = "it";
char i2[] = {'o', 'k', '\0'};
printf("%s\n", i2);
printf("%d\n", i);
printf("%d\n", i2);
return 0;
} |
the_stack_data/23576326.c | /*
Nama : Zidan Rafindra Utomo
NIM : 24060121130051
tgl pengerjaan: 9 Mei 2022
*/
#include <stdio.h>
#include <stdlib.h>
void insertionSort(int arr[], int n){
int i, temp, j;
for (i = 1; i < n; i++) {
printf("%d ", i+1);
for (j = 0; j < n; j++){
printf("%d", arr[j]);
if (j != n-1) printf(", ");
}
temp = arr[i];
j = i - 1;
printf(" on process: %d ", arr[i]);
// geser ke kiri selama temp ini lebih kecil dari kirinya
while (0 <= j && temp < arr[j]) {
arr[j + 1] = arr[j];
j = j - 1;
}
printf(" swapped: %d \n ", arr[j+1]);
// selipin
arr[j + 1] = temp;
for (j = 0; j < n; j++){
printf("%d", arr[j]);
if (j != n-1) printf(", ");
}
printf("\n");
}
}
int main(){
int arr[] = {32,15,20,55,13,17,85,10,18,75};
int n = 10;
insertionSort(arr, n);
printf("hasil sorting:\n");
for(int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
} |
the_stack_data/114653.c | /**
* Userspace PCI Endpoint Test Module
*
* Copyright (C) 2017 Texas Instruments
* Author: Kishon Vijay Abraham I <[email protected]>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 of
* the License as published by the Free Software Foundation.
*
* 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 <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <time.h>
#include <unistd.h>
#include <linux/pcitest.h>
#define BILLION 1E9
static char *result[] = { "NOT OKAY", "OKAY" };
struct pci_test {
char *device;
char barnum;
bool legacyirq;
unsigned int msinum;
bool read;
bool write;
bool copy;
unsigned long size;
};
static int run_test(struct pci_test *test)
{
long ret;
int fd;
struct timespec start, end;
double time;
fd = open(test->device, O_RDWR);
if (fd < 0) {
perror("can't open PCI Endpoint Test device");
return fd;
}
if (test->barnum >= 0 && test->barnum <= 5) {
ret = ioctl(fd, PCITEST_BAR, test->barnum);
fprintf(stdout, "BAR%d:\t\t", test->barnum);
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
if (test->legacyirq) {
ret = ioctl(fd, PCITEST_LEGACY_IRQ, 0);
fprintf(stdout, "LEGACY IRQ:\t");
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
if (test->msinum > 0 && test->msinum <= 32) {
ret = ioctl(fd, PCITEST_MSI, test->msinum);
fprintf(stdout, "MSI%d:\t\t", test->msinum);
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
if (test->write) {
ret = ioctl(fd, PCITEST_WRITE, test->size);
fprintf(stdout, "WRITE (%7ld bytes):\t\t", test->size);
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
if (test->read) {
ret = ioctl(fd, PCITEST_READ, test->size);
fprintf(stdout, "READ (%7ld bytes):\t\t", test->size);
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
if (test->copy) {
ret = ioctl(fd, PCITEST_COPY, test->size);
fprintf(stdout, "COPY (%7ld bytes):\t\t", test->size);
if (ret < 0)
fprintf(stdout, "TEST FAILED\n");
else
fprintf(stdout, "%s\n", result[ret]);
}
fflush(stdout);
}
int main(int argc, char **argv)
{
int c;
struct pci_test *test;
test = calloc(1, sizeof(*test));
if (!test) {
perror("Fail to allocate memory for pci_test\n");
return -ENOMEM;
}
/* since '0' is a valid BAR number, initialize it to -1 */
test->barnum = -1;
/* set default size as 100KB */
test->size = 0x19000;
/* set default endpoint device */
test->device = "/dev/pci-endpoint-test.0";
while ((c = getopt(argc, argv, "D:b:m:lrwcs:")) != EOF)
switch (c) {
case 'D':
test->device = optarg;
continue;
case 'b':
test->barnum = atoi(optarg);
if (test->barnum < 0 || test->barnum > 5)
goto usage;
continue;
case 'l':
test->legacyirq = true;
continue;
case 'm':
test->msinum = atoi(optarg);
if (test->msinum < 1 || test->msinum > 32)
goto usage;
continue;
case 'r':
test->read = true;
continue;
case 'w':
test->write = true;
continue;
case 'c':
test->copy = true;
continue;
case 's':
test->size = strtoul(optarg, NULL, 0);
continue;
case '?':
case 'h':
default:
usage:
fprintf(stderr,
"usage: %s [options]\n"
"Options:\n"
"\t-D <dev> PCI endpoint test device {default: /dev/pci-endpoint-test.0}\n"
"\t-b <bar num> BAR test (bar number between 0..5)\n"
"\t-m <msi num> MSI test (msi number between 1..32)\n"
"\t-l Legacy IRQ test\n"
"\t-r Read buffer test\n"
"\t-w Write buffer test\n"
"\t-c Copy buffer test\n"
"\t-s <size> Size of buffer {default: 100KB}\n",
argv[0]);
return -EINVAL;
}
run_test(test);
return 0;
}
|
the_stack_data/87637349.c | /* The value returned from main() is used as the exit status of the
process. */
int
main(void)
{
return 34;
}
|
the_stack_data/133115.c |
/*********************************************************/
/*NAME: MATRIX MULTIPLICATION USING MULTITHREAD */
/*DATE: 10TH MAY 2019 */
/*SUBJECT: OPERATING SYSTEM */
/*DESCRIPTION: IMPLEMENTED MATRIX MULT. USING 2 THREADS */
/*NOTING DOWN THE TIME FOR DIFFERENT NUMBER OF ELEMENTS */
/*********************************************************/
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <time.h>
#define max 10
int matA[max][max];
int matB[max][max];
int matC[max][max];
int dividing_variable=0;
void* multi(void* arg)
{
int core = dividing_variable++;
for (int i = core * max / 4; i < (core + 1) * max / 4; i++)
for (int j = 0; j < max; j++)
for (int k = 0; k < max; k++)
matC[i][j] += matA[i][k] * matB[k][j];
}
int main(){
/*start:
printf("Enter Size of Metrix X:X");
scanf("%d",max);
if(max<2){
printf("\n\nError Enter again");
goto start;
}
*/
pthread_t threads[max];
clock_t start, end;
double cpu_time_used;
for (int i = 0; i < max; i++) {
for (int j = 0; j < max; j++) {
matA[i][j] = rand() % 10;
matB[i][j] = rand() % 10;
}
}
printf("\n");
printf("Matrix A\n");
for (int i = 0; i < max; i++) {
for (int j = 0; j < max; j++)
printf("%d ", matA[i][j]);;
printf("\n");
}
printf("\n");
printf("Matrix B\n");
for (int i = 0; i < max; i++) {
for (int j = 0; j < max; j++)
printf("%d ", matB[i][j]);
printf("\n");
}
start=clock();
for (int i = 0; i < max; i++) {
int* p;
pthread_create(&threads[i], NULL, multi, (void*)(p));
}
for (int i = 0; i < max; i++)
pthread_join(threads[i], NULL);
end=clock();
printf("\n");
printf("mul of Matrix A and B\n");
for (int i = 0; i < max; i++) {
for (int j = 0; j < max; j++)
printf("%d ", matC[i][j]);
printf("\n");
}
cpu_time_used = (double)( (end - start))/ CLOCKS_PER_SEC;
printf("\ncpu time => %f",cpu_time_used);
return 0;
}
|
the_stack_data/6388139.c | /* Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <sys/stat.h>
int
__mknod (path, mode, device)
const char *path;
mode_t mode;
dev_t device;
{
return mknod (path, mode, device);
}
|
the_stack_data/150141206.c | /*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdlib.h>
/****************************************************************************
* ldiv
*
* Returns an ldiv_t corresponding to the division of <num> by <denom>.
*/
ldiv_t ldiv(long int num, long int denom) {
ldiv_t result;
result.quot = num / denom;
result.rem = num % denom;
return result;
}
|
the_stack_data/690087.c | int main() {
int test = 5;
int var = 6;
int bazing = (test = 7 + (var = 9));
bazing = bazing - 5;
return bazing;
}
|
the_stack_data/117888.c | /****************************************************************
*
* The author of this software is David M. Gay.
*
* Copyright (c) 1991, 1996 by Lucent Technologies.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software and in all copies of the supporting
* documentation for such software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
***************************************************************/
/* g_fmt(buf,x) stores the closest decimal approximation to x in buf;
* it suffices to declare buf
* char buf[32];
*/
#ifdef __cplusplus
extern "C" {
#endif
extern char *dtoa(double, int, int, int *, int *, char **);
extern char *g_fmt(char *, double);
extern void freedtoa(char*);
#ifdef __cplusplus
}
#endif
char *
g_fmt(register char *b, double x)
{
register int i, k;
register char *s;
int decpt, j, sign;
char *b0, *s0, *se;
b0 = b;
#ifdef IGNORE_ZERO_SIGN
if (!x) {
*b++ = '0';
*b = 0;
goto done;
}
#endif
s = s0 = dtoa(x, 0, 0, &decpt, &sign, &se);
if (sign)
*b++ = '-';
if (decpt == 9999) /* Infinity or Nan */ {
while(*b++ = *s++);
goto done0;
}
if (decpt <= -4 || decpt > se - s + 5) {
*b++ = *s++;
if (*s) {
*b++ = '.';
while(*b = *s++)
b++;
}
*b++ = 'e';
/* sprintf(b, "%+.2d", decpt - 1); */
if (--decpt < 0) {
*b++ = '-';
decpt = -decpt;
}
else
*b++ = '+';
for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10);
for(;;) {
i = decpt / k;
*b++ = i + '0';
if (--j <= 0)
break;
decpt -= i*k;
decpt *= 10;
}
*b = 0;
}
else if (decpt <= 0) {
*b++ = '.';
for(; decpt < 0; decpt++)
*b++ = '0';
while(*b++ = *s++);
}
else {
while(*b = *s++) {
b++;
if (--decpt == 0 && *s)
*b++ = '.';
}
for(; decpt > 0; decpt--)
*b++ = '0';
*b = 0;
}
done0:
freedtoa(s0);
#ifdef IGNORE_ZERO_SIGN
done:
#endif
return b0;
}
|
the_stack_data/170452450.c | #include <stdio.h>
# include <string.h>
int main(){
//char path[100];
char ch;
int x=0;
int characters, whitespaces,lines;
characters = 0;
whitespaces = 0;
lines = 0;
FILE *filepointer;
int alpha[30]={0};
filepointer = fopen("lab9task5.c","r");
if (filepointer == NULL){
printf("ERROR opening file");
}
else{
while ((ch = fgetc(filepointer)) != EOF)
{
characters++;
if (ch == '\n'){
lines++;
}
if (ch == ' '){
whitespaces++;
}
if (ch>='a' && ch <='z')
{ x=ch-'a';
alpha[x] +=1;
}
}
}
//printf("\n");
printf("Lines = %d \n", lines);
printf("WhiteSpaces = %d \n", whitespaces);
printf("Characters = %d \n", characters);
for (int az =0; az<=26;az++){
printf("Small letter %c : %d \n", az+'a' , alpha[az]);
}
fclose(filepointer);
return 0;
}
|
the_stack_data/154827427.c | int main() {
return 94 & (1 << 3);
}
|
the_stack_data/220456794.c | #include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <langinfo.h>
#include <locale.h>
void clear(void) {
int c;
while( (c = getchar() != '\n' && c != EOF ));
}
int main()
{
int mon, fexit=1, f;
char ans;
const nl_item nl_months[12] = { MON_1, MON_2, MON_3, MON_4, MON_5, MON_6,
MON_7, MON_8, MON_9, MON_10, MON_11, MON_12};
setlocale(LC_ALL, "");
do
{
mon = 0;
printf("Enter a month number: ");
f = scanf("%d", &mon);
clear();
if (mon>0 && mon<=12) {
printf("%s\n", nl_langinfo(nl_months[mon-1]));
} else {
printf("There is no such date!");
}
printf("Would you like to try it again? ");
scanf("%c", &ans);
clear();
if (ans == 'N' || ans == 'n')
fexit = 0;
} while(fexit);
printf("Goodbye!\n");
} |
the_stack_data/62637746.c | /*
Copyright (c) Centre National de la Recherche Scientifique (CNRS,
France). 2010.
Copyright (c) Members of the EGEE Collaboration. 2008-2010. See
http://www.eu-egee.org/partners/ for details on the copyright
holders.
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.
---------------------------------------------------------------------
Developed by Etienne DUBLE - CNRS LIG (http://www.liglab.fr)
etienne __dot__ duble __at__ imag __dot__ fr
---------------------------------------------------------------------
*/
#include <stdio.h>
// global variables
FILE *tty_fd;
// per-thread variables
__thread int function_depth=0;
|
the_stack_data/175142032.c | // RUN: %clang_cc1 -fsyntax-only -verify %s
void f1(void) {
int x = 0;
/* expected-error@+1 {{'#pragma fp_contract' can only appear at file scope or at the start of a compound statement}} */
#pragma STDC FP_CONTRACT ON
}
void f2(void) {
#pragma STDC FP_CONTRACT OFF
#pragma STDC FP_CONTRACT ON
}
struct S1 {
// expected-error@+1 {{this pragma cannot appear in struct declaration}}
#pragma STDC FP_CONTRACT ON
float f1;
};
union U1 {
float f1;
float f2;
// expected-error@+1 {{this pragma cannot appear in union declaration}}
#pragma STDC FP_CONTRACT ON
};
|
the_stack_data/500264.c | #include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);
int parse_int(char*);
/*
* Complete the 'solve' function below.
*
* The function is expected to return a STRING.
* The function accepts following parameters:
* 1. INTEGER x1
* 2. INTEGER y1
* 3. INTEGER x2
* 4. INTEGER y2
* 5. INTEGER xm
* 6. INTEGER ym
*/
/*
* To return the string from the function, you should either do static allocation or dynamic allocation
*
* For example,
* char* return_string_using_static_allocation() {
* static char s[] = "static allocation of string";
*
* return s;
* }
*
* char* return_string_using_dynamic_allocation() {
* char* s = malloc(100 * sizeof(char));
*
* s = "dynamic allocation of string";
*
* return s;
* }
*
*/
struct Point
{
int x;
int y;
};
bool onSegment(struct Point p,struct Point q,struct Point r)
{
if (q.x <= ((p.x > r.x) ?p.x : r.x) && q.x >= ((p.x < r.x) ?p.x : r.x) &&
q.y <= ((p.y > r.y) ?p.y : r.y) && q.y >= ((p.y < r.y) ?p.y : r.y))
{
return true;
}
else
{
return false;
}
}
int orientation(struct Point p,struct Point q,struct Point r)
{
long long int first = (long long int)((long long int)(q.y - p.y) * (long long int)(r.x - q.x));
long long int second = (long long int)((long long int)(q.x - p.x) * (long long int)(r.y - q.y));
long long int val = (long long int)(first - second);
return (val == 0)? 0: ((val > 0)? 1: 2);
}
bool doIntersect(struct Point p1,struct Point q1,struct Point p2,struct Point q2)
{
int o1 = orientation(p1, q1, p2);
int o2 = orientation(p1, q1, q2);
int o3 = orientation(p2, q2, p1);
int o4 = orientation(p2, q2, q1);
if (o1 != o2 && o3 != o4)
{
return true;
}
if ((o1 == 0 && onSegment(p1, p2, q1)) ||
(o2 == 0 && onSegment(p1, q2, q1)) ||
(o3 == 0 && onSegment(p2, p1, q2)) ||
(o4 == 0 && onSegment(p2, q1, q2)))
{
return true;
}
else
{
return false;
}
}
char* solve(int x1, int y1, int x2, int y2, int xm, int ym) {
struct Point p1 = {x1, y1};
struct Point q1 = {x2, y2};
struct Point pm = {xm, ym};
struct Point Zero = {0, 0};
return((doIntersect(Zero, pm, p1, q1)) ? "NO" : "YES");
}
int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");
int t = parse_int(ltrim(rtrim(readline())));
for (int t_itr = 0; t_itr < t; t_itr++) {
char** first_multiple_input = split_string(rtrim(readline()));
int x1 = parse_int(*(first_multiple_input + 0));
int y1 = parse_int(*(first_multiple_input + 1));
int x2 = parse_int(*(first_multiple_input + 2));
int y2 = parse_int(*(first_multiple_input + 3));
int xm = parse_int(*(first_multiple_input + 4));
int ym = parse_int(*(first_multiple_input + 5));
char* result = solve(x1, y1, x2, y2, xm, ym);
fprintf(fptr, "%s\n", result);
}
fclose(fptr);
return 0;
}
char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);
while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);
if (!line) {
break;
}
data_length += strlen(cursor);
if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
break;
}
alloc_length <<= 1;
data = realloc(data, alloc_length);
if (!data) {
data = '\0';
break;
}
}
if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
data = realloc(data, data_length);
if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);
if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}
return data;
}
char* ltrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
while (*str != '\0' && isspace(*str)) {
str++;
}
return str;
}
char* rtrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
char* end = str + strlen(str) - 1;
while (end >= str && isspace(*end)) {
end--;
}
*(end + 1) = '\0';
return str;
}
char** split_string(char* str) {
char** splits = NULL;
char* token = strtok(str, " ");
int spaces = 0;
while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);
if (!splits) {
return splits;
}
splits[spaces - 1] = token;
token = strtok(NULL, " ");
}
return splits;
}
int parse_int(char* str) {
char* endptr;
int value = strtol(str, &endptr, 10);
if (endptr == str || *endptr != '\0') {
exit(EXIT_FAILURE);
}
return value;
}
|
the_stack_data/237642035.c | /**
Questão 3
*/
#include <stdio.h>
int main(){
int i, j, k;
int couldFindRepeteadValue;
int vectorValues[2][50];
int vectorSizes[2] = {0, 0};
int vectorNames[2] = {'M', 'N'};
int uniqueValues[100];
int uniqueValuesSize = 0;
/* reading values and storing the unique ones */
for (i = 0; i < 2; i++){
printf("Entre com o valor de %c: ", vectorNames[i]);
scanf("%d", &vectorSizes[i]);
printf("Valores da sequência %c: ", vectorNames[i]);
for (j = 0; j < vectorSizes[i]; j++) {
scanf("%d", &vectorValues[i][j]);
couldFindRepeteadValue = 0;
for(k = 0; k < uniqueValuesSize; k++){
if (uniqueValues[k] == vectorValues[i][j]){
couldFindRepeteadValue = 1;
break;
}
}
if (!couldFindRepeteadValue){
uniqueValues[uniqueValuesSize++] = vectorValues[i][j];
}
}
}
/* sorting the unique values using bubble algorithm */
int leftIndex, rightIndex, swapped, aux;
do{
swapped = 0;
for (i = 1; i < uniqueValuesSize; i++){
leftIndex = i-1;
rightIndex = i;
if (uniqueValues[leftIndex] > uniqueValues[rightIndex]){
aux = uniqueValues[leftIndex];
uniqueValues[leftIndex] = uniqueValues[rightIndex];
uniqueValues[rightIndex] = aux;
swapped = 1;
}
}
} while (swapped);
/* printing the sorted unique values */
for(i = 0; i < uniqueValuesSize; i++){
printf("%d ", uniqueValues[i]);
}
printf("\n");
return 0;
} |
the_stack_data/61075337.c | // PARAM: --enable ana.int.interval
#include<stdio.h>
void main()
{
char data;
fscanf(stdin, "%c", &data);
if(-data < 0) // avoid potential overflow
{
char result = -data * 2; // WARN: potential underflow
printf("%hhd\n", result);
}
}
|
the_stack_data/88371.c | /*
* POK header
*
* The following file is a part of the POK project. Any modification should
* be made according to the POK licence. You CANNOT use this file or a part
* of a file for your own project.
*
* For more information on the POK licence, please see our LICENCE FILE
*
* Please follow the coding guidelines described in doc/CODING_GUIDELINES
*
* Copyright (c) 2007-2022 POK team
*/
/* s_erff.c -- float version of s_erf.c.
* Conversion to float by Ian Lance Taylor, Cygnus Support, [email protected].
*/
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
#ifdef POK_NEEDS_LIBMATH
#include "math_private.h"
#include <libm.h>
static const float tiny = 1e-30, half = 5.0000000000e-01, /* 0x3F000000 */
one = 1.0000000000e+00, /* 0x3F800000 */
two = 2.0000000000e+00, /* 0x40000000 */
/* c = (subfloat)0.84506291151 */
erx = 8.4506291151e-01, /* 0x3f58560b */
/*
* Coefficients for approximation to erf on [0,0.84375]
*/
efx = 1.2837916613e-01, /* 0x3e0375d4 */
efx8 = 1.0270333290e+00, /* 0x3f8375d4 */
pp0 = 1.2837916613e-01, /* 0x3e0375d4 */
pp1 = -3.2504209876e-01, /* 0xbea66beb */
pp2 = -2.8481749818e-02, /* 0xbce9528f */
pp3 = -5.7702702470e-03, /* 0xbbbd1489 */
pp4 = -2.3763017452e-05, /* 0xb7c756b1 */
qq1 = 3.9791721106e-01, /* 0x3ecbbbce */
qq2 = 6.5022252500e-02, /* 0x3d852a63 */
qq3 = 5.0813062117e-03, /* 0x3ba68116 */
qq4 = 1.3249473704e-04, /* 0x390aee49 */
qq5 = -3.9602282413e-06, /* 0xb684e21a */
/*
* Coefficients for approximation to erf in [0.84375,1.25]
*/
pa0 = -2.3621185683e-03, /* 0xbb1acdc6 */
pa1 = 4.1485610604e-01, /* 0x3ed46805 */
pa2 = -3.7220788002e-01, /* 0xbebe9208 */
pa3 = 3.1834661961e-01, /* 0x3ea2fe54 */
pa4 = -1.1089469492e-01, /* 0xbde31cc2 */
pa5 = 3.5478305072e-02, /* 0x3d1151b3 */
pa6 = -2.1663755178e-03, /* 0xbb0df9c0 */
qa1 = 1.0642088205e-01, /* 0x3dd9f331 */
qa2 = 5.4039794207e-01, /* 0x3f0a5785 */
qa3 = 7.1828655899e-02, /* 0x3d931ae7 */
qa4 = 1.2617121637e-01, /* 0x3e013307 */
qa5 = 1.3637083583e-02, /* 0x3c5f6e13 */
qa6 = 1.1984500103e-02, /* 0x3c445aa3 */
/*
* Coefficients for approximation to erfc in [1.25,1/0.35]
*/
ra0 = -9.8649440333e-03, /* 0xbc21a093 */
ra1 = -6.9385856390e-01, /* 0xbf31a0b7 */
ra2 = -1.0558626175e+01, /* 0xc128f022 */
ra3 = -6.2375331879e+01, /* 0xc2798057 */
ra4 = -1.6239666748e+02, /* 0xc322658c */
ra5 = -1.8460508728e+02, /* 0xc3389ae7 */
ra6 = -8.1287437439e+01, /* 0xc2a2932b */
ra7 = -9.8143291473e+00, /* 0xc11d077e */
sa1 = 1.9651271820e+01, /* 0x419d35ce */
sa2 = 1.3765776062e+02, /* 0x4309a863 */
sa3 = 4.3456588745e+02, /* 0x43d9486f */
sa4 = 6.4538726807e+02, /* 0x442158c9 */
sa5 = 4.2900814819e+02, /* 0x43d6810b */
sa6 = 1.0863500214e+02, /* 0x42d9451f */
sa7 = 6.5702495575e+00, /* 0x40d23f7c */
sa8 = -6.0424413532e-02, /* 0xbd777f97 */
/*
* Coefficients for approximation to erfc in [1/.35,28]
*/
rb0 = -9.8649431020e-03, /* 0xbc21a092 */
rb1 = -7.9928326607e-01, /* 0xbf4c9dd4 */
rb2 = -1.7757955551e+01, /* 0xc18e104b */
rb3 = -1.6063638306e+02, /* 0xc320a2ea */
rb4 = -6.3756646729e+02, /* 0xc41f6441 */
rb5 = -1.0250950928e+03, /* 0xc480230b */
rb6 = -4.8351919556e+02, /* 0xc3f1c275 */
sb1 = 3.0338060379e+01, /* 0x41f2b459 */
sb2 = 3.2579251099e+02, /* 0x43a2e571 */
sb3 = 1.5367296143e+03, /* 0x44c01759 */
sb4 = 3.1998581543e+03, /* 0x4547fdbb */
sb5 = 2.5530502930e+03, /* 0x451f90ce */
sb6 = 4.7452853394e+02, /* 0x43ed43a7 */
sb7 = -2.2440952301e+01; /* 0xc1b38712 */
float erff(float x) {
int32_t hx, ix, i;
float R, S, P, Q, s, y, z, r;
GET_FLOAT_WORD(hx, x);
ix = hx & 0x7fffffff;
if (ix >= 0x7f800000) { /* erf(nan)=nan */
i = ((uint32_t)hx >> 31) << 1;
return (float)(1 - i) + one / x; /* erf(+-inf)=+-1 */
}
if (ix < 0x3f580000) { /* |x|<0.84375 */
if (ix < 0x31800000) { /* |x|<2**-28 */
if (ix < 0x04000000)
/*avoid underflow */
return (float)0.125 * ((float)8.0 * x + efx8 * x);
return x + efx * x;
}
z = x * x;
r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
s = one + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
y = r / s;
return x + x * y;
}
if (ix < 0x3fa00000) { /* 0.84375 <= |x| < 1.25 */
s = fabsf(x) - one;
P = pa0 +
s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6)))));
Q = one +
s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6)))));
if (hx >= 0)
return erx + P / Q;
else
return -erx - P / Q;
}
if (ix >= 0x40c00000) { /* inf>|x|>=6 */
if (hx >= 0)
return one - tiny;
else
return tiny - one;
}
x = fabsf(x);
s = one / (x * x);
if (ix < 0x4036DB6E) { /* |x| < 1/0.35 */
R = ra0 +
s * (ra1 +
s * (ra2 +
s * (ra3 + s * (ra4 + s * (ra5 + s * (ra6 + s * ra7))))));
S = one +
s * (sa1 +
s * (sa2 +
s * (sa3 +
s * (sa4 +
s * (sa5 + s * (sa6 + s * (sa7 + s * sa8)))))));
} else { /* |x| >= 1/0.35 */
R = rb0 +
s * (rb1 + s * (rb2 + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6)))));
S = one +
s * (sb1 +
s * (sb2 +
s * (sb3 + s * (sb4 + s * (sb5 + s * (sb6 + s * sb7))))));
}
GET_FLOAT_WORD(ix, x);
SET_FLOAT_WORD(z, ix & 0xfffff000);
r = __ieee754_expf(-z * z - (float)0.5625) *
__ieee754_expf((z - x) * (z + x) + R / S);
if (hx >= 0)
return one - r / x;
else
return r / x - one;
}
float erfcf(float x) {
int32_t hx, ix;
float R, S, P, Q, s, y, z, r;
GET_FLOAT_WORD(hx, x);
ix = hx & 0x7fffffff;
if (ix >= 0x7f800000) { /* erfc(nan)=nan */
/* erfc(+-inf)=0,2 */
return (float)(((uint32_t)hx >> 31) << 1) + one / x;
}
if (ix < 0x3f580000) { /* |x|<0.84375 */
if (ix < 0x23800000) /* |x|<2**-56 */
return one - x;
z = x * x;
r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
s = one + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
y = r / s;
if (hx < 0x3e800000) { /* x<1/4 */
return one - (x + x * y);
} else {
r = x * y;
r += (x - half);
return half - r;
}
}
if (ix < 0x3fa00000) { /* 0.84375 <= |x| < 1.25 */
s = fabsf(x) - one;
P = pa0 +
s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6)))));
Q = one +
s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6)))));
if (hx >= 0) {
z = one - erx;
return z - P / Q;
} else {
z = erx + P / Q;
return one + z;
}
}
if (ix < 0x41e00000) { /* |x|<28 */
x = fabsf(x);
s = one / (x * x);
if (ix < 0x4036DB6D) { /* |x| < 1/.35 ~ 2.857143*/
R = ra0 +
s * (ra1 +
s * (ra2 +
s * (ra3 + s * (ra4 + s * (ra5 + s * (ra6 + s * ra7))))));
S = one +
s * (sa1 +
s * (sa2 +
s * (sa3 +
s * (sa4 +
s * (sa5 + s * (sa6 + s * (sa7 + s * sa8)))))));
} else { /* |x| >= 1/.35 ~ 2.857143 */
if (hx < 0 && ix >= 0x40c00000)
return two - tiny; /* x < -6 */
R = rb0 +
s * (rb1 + s * (rb2 + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6)))));
S = one +
s * (sb1 +
s * (sb2 +
s * (sb3 + s * (sb4 + s * (sb5 + s * (sb6 + s * sb7))))));
}
GET_FLOAT_WORD(ix, x);
SET_FLOAT_WORD(z, ix & 0xfffff000);
r = __ieee754_expf(-z * z - (float)0.5625) *
__ieee754_expf((z - x) * (z + x) + R / S);
if (hx > 0)
return r / x;
else
return two - r / x;
} else {
if (hx > 0)
return tiny * tiny;
else
return two - tiny;
}
}
#endif
|
the_stack_data/146748.c | /*
--------------------------------------------
Up to 20% marks will be allotted for good programming practice. These include
- Comments: for non-trivial code
- Indentation: align your code properly
- Function use and modular programming
- Do not include anything in the header other than what is already given in the template.
- You are required to allocate memory Dynamically instead of static memory allocation otherwise you might get 0
- TAs: Please ensure that the submission is doing Insertion Sort and not any other sorting routine.
---------------------------------------------
Insertion sort (in ascending order) iterates, consuming one input element in each iteration, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.
Sorting is typically done in-place, by iterating up the array, growing the sorted list behind it. At each array-position, it checks the value there against the largest value in the sorted list (which happens to be next to it, in the previous array-position checked). If larger, it leaves the element in place and moves to the next. If smaller, it finds the correct position within the sorted list, shifts all the larger values up to make a space, and inserts into that correct position.
The algorithm is described using the pseudocode given below:
1. For all elements arr[i] (0 < i < n), if arr[i] less than arr[i-1] go to step 2, otherwise continue step 1 for the next i.
2. Find the element arr[j] such that j is the lowest index which satisfies arr[j] > arr[i]. (Such an index is bound to exist, since arr[i-1] > arr[i] after Step 1.) Put arr[i] at the j-th position in the list and shift every element, from the indices j+1 to i-1, by one place to the right.
Input: A positive integer n followed by a line containing n positive integers separated by space.
Output: Space separated sorted list of integers.
*/
#include<stdio.h>
#include<stdlib.h>
void InsertionSort(int* arr, int n){
int i;
for(i=1;i<n;i++){
if(arr[i]>=arr[i-1])
continue;
int j;
for(j=0;j<i;j++){
if(arr[j]>arr[i]){
int k=j;
int prev=arr[k];
arr[k]=arr[i];
for(k=j+1;k<=i;k++){
int curr=arr[k];
arr[k]=prev;
prev=curr;
}
break;
}
}
}
}
int main(){
int n;
scanf("%d",&n);
int* arr;
arr = (int*) malloc(n*sizeof(int));
int i;
for(i=0;i<n;i++){
scanf("%d",&arr[i]);
}
InsertionSort(arr,n);
for(i=0;i<n;i++){
printf("%d ",arr[i]);
}
printf("\n");
return 0;
} |
the_stack_data/568826.c | /*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
/*
* Copyright (c) 2014, Joyent, Inc. All rights reserved.
* Copyright 2020 Oxide Computer Company
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <locale.h>
#include <string.h>
#include <ctype.h>
#include <err.h>
#define DEF_LINE_COUNT 10
static void copyout(off_t, int);
static void Usage();
static FILE *input;
/*
* head - give the first few lines of a stream or of each of a set of files.
* Optionally shows a specific number of bytes instead.
*/
int
main(int argc, char **argv)
{
int fileCount;
int around = 0;
int i;
int opt;
off_t linecnt = DEF_LINE_COUNT;
int isline = 1;
int error = 0;
int quiet = 0;
int verbose = 0;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
/* check for non-standard "-line-count" option */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "--") == 0)
break;
if ((argv[i][0] == '-') && isdigit(argv[i][1])) {
if (strlen(&argv[i][1]) !=
strspn(&argv[i][1], "0123456789")) {
(void) fprintf(stderr, gettext(
"%s: Badly formed number\n"), argv[0]);
Usage();
}
linecnt = (off_t)strtoll(&argv[i][1], (char **)NULL,
10);
while (i < argc) {
argv[i] = argv[i + 1];
i++;
}
argc--;
}
}
/* get options */
while ((opt = getopt(argc, argv, "qvn:c:")) != EOF) {
switch (opt) {
case 'n':
case 'c':
if ((strcmp(optarg, "--") == 0) || (optind > argc)) {
(void) fprintf(stderr, gettext(
"%s: Missing -%c argument\n"), argv[0],
optopt);
Usage();
}
linecnt = (off_t)strtoll(optarg, (char **)NULL, 10);
if (linecnt <= 0) {
(void) fprintf(stderr, gettext(
"%s: Invalid \"-%c %s\" option\n"),
argv[0], optopt, optarg);
Usage();
}
isline = optopt != 'c';
break;
case 'q':
quiet = 1;
verbose = 0;
break;
case 'v':
quiet = 0;
verbose = 1;
break;
default:
Usage();
}
}
fileCount = argc - optind;
do {
if ((argv[optind] == NULL) && around)
break;
if (argv[optind] != NULL) {
if (input != NULL)
(void) fclose(input);
if ((input = fopen(argv[optind], "r")) == NULL) {
perror(argv[optind]);
error = 1;
optind++;
continue;
}
} else {
input = stdin;
}
if (quiet == 0) {
if (around)
(void) putchar('\n');
if (fileCount > 1 || verbose != 0) {
const char *file = argv[optind];
if (file == NULL) {
file = "standard input";
}
(void) printf("==> %s <==\n", file);
}
}
if (argv[optind] != NULL)
optind++;
copyout(linecnt, isline);
(void) fflush(stdout);
around++;
} while (argv[optind] != NULL);
return (error);
}
static void
copyout(off_t cnt, int isline)
{
char lbuf[BUFSIZ];
size_t len;
while (cnt > 0) {
len = fread(lbuf, sizeof (char), sizeof (lbuf) / sizeof (char),
input);
if (len == 0) {
return;
}
if (isline) {
size_t i;
for (i = 0; i < len; i++) {
if (lbuf[i] == '\n') {
cnt--;
if (cnt == 0) {
i++;
break;
}
}
}
len = i;
} else {
if (len > cnt) {
len = cnt;
}
cnt -= len;
}
if (fwrite(lbuf, sizeof (char), len, stdout) != len) {
err(EXIT_FAILURE, "failed to write to stdout");
}
}
}
static void
Usage()
{
(void) printf(gettext("usage: head [-q] [-v] [-n #] [-c #] [-#] "
"[filename...]\n"));
exit(1);
}
|
the_stack_data/25136821.c | #include<stdio.h>
#include<stdlib.h>
int i,j,k,a,b,u,v,n,ne=1;
int min,mincost=0,cost[9][9],parent[9];
int find(int);
int uni(int,int);
void main()
{
printf("\n\tImplementation of Kruskal's algorithm\n");
printf("\nEnter the no. of vertices:");
scanf("%d",&n);
printf("\nEnter the cost adjacency matrix:\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=999;
}
}
printf("The edges of Minimum Cost Spanning Tree are\n");
while(ne < n)
{
for(i=1,min=999;i<=n;i++)
{
for(j=1;j <= n;j++)
{
if(cost[i][j] < min)
{
min=cost[i][j];
a=u=i;
b=v=j;
}
}
}
u=find(u);
v=find(v);
if(uni(u,v))
{
printf("%d edge (%d,%d) =%d\n",ne++,a,b,min);
mincost +=min;
}
cost[a][b]=cost[b][a]=999;
}
printf("\n\tMinimum cost = %d\n",mincost);
}
int find(int i)
{
while(parent[i])
i=parent[i];
return i;
}
int uni(int i,int j)
{
if(i!=j)
{
parent[j]=i;
return 1;
}
return 0;
}
|
the_stack_data/160386.c | #include <stdio.h>
int main()
{
int c;
c = getchar( );
while ((c = getchar( )) != EOF)
{
if(c==' ')
{
putchar(' ');
while((c = getchar()) == ' ');
}
putchar(c);
}
return 0;
}
|
the_stack_data/68637.c | #include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
/* code */
fork();
fork();
printf("OSLab962\n");
return 0;
}
|
the_stack_data/184517936.c | // RUN: %clang_msan -std=c99 -O0 -g %s -o %t && %run %t
// strerror_r under a weird set of circumstances can be redirected to
// __xpg_strerror_r. Test that MSan handles this correctly.
#define _POSIX_C_SOURCE 200112
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main() {
char buf[1000];
int res = strerror_r(EINVAL, buf, sizeof(buf));
assert(!res);
volatile int z = strlen(buf);
return 0;
}
|
the_stack_data/567830.c | #include <sys/socket.h>
#include <sys/un.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>
#include <syscall.h>
#include <linux/random.h>
#include <sys/stat.h>
#include <openssl/pem.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/engine.h>
#define _LOCKY_SYM_KEY_SIZE 32
#define _LOCKY_PKG_MSG_LENGTH_MAX 256
#define _LUKSD_BUFFER_SIZE 1024
#define SOCKET_QUEUE 128
typedef struct locky_peer_t locky_peer_t;
struct locky_peer_t {
char addr[NI_MAXHOST];
char port[NI_MAXSERV];
char cipher[_LOCKY_SYM_KEY_SIZE];
locky_peer_t *next;
};
typedef struct {
int socket;
locky_peer_t *peers;
EVP_PKEY *pubKey;
} locky_connection_t;
typedef struct {
unsigned char *data;
size_t size;
} locky_message_t;
enum {
_LOCKY_REQ_METHOD_AUTH = 0x31,
_LOCKY_REQ_METHOD_UNLOCK
};
void deregisterPeers(locky_connection_t *locky);
void methodAuth(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *data);
bool methodUnlock(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *data);
locky_peer_t *registerPeer(locky_connection_t *locky, locky_peer_t peer);
void sendData(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *msg);
bool unlockLuks(locky_message_t *luksKey);
bool authPeer(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *plaintext, locky_message_t *signature) {
EVP_MD_CTX *ctx;
const EVP_MD *md;
unsigned char d[EVP_MAX_MD_SIZE];
unsigned l;
ctx = EVP_MD_CTX_create();
md = EVP_get_digestbyname("sha256");
EVP_DigestInit_ex(ctx, md, NULL);
EVP_DigestUpdate(ctx, plaintext->data, plaintext->size);
if(EVP_VerifyFinal(ctx, signature->data, signature->size, locky->pubKey) == 1) {
syscall(SYS_getrandom, &peer->cipher, _LOCKY_SYM_KEY_SIZE, GRND_NONBLOCK);
printf("authenticated peer %s:%s\n", peer->addr, peer->port);
return true;
}
printf("failed to verify message signature from %s:%s\n", peer->addr, peer->port);
return false;
}
void connLoop(locky_connection_t *locky) {
struct sockaddr_storage client;
socklen_t addrlen = sizeof(client);
char buffer[1024];
locky_message_t payload;
locky_peer_t peer;
locky_peer_t *p;
int method = 0;
bool running = true;
while(running) {
payload.size = recvfrom(
locky->socket,
buffer, sizeof(buffer),
0,
(struct sockaddr *) &client,
&addrlen);
if(payload.size < 2)
continue;
method = (int) buffer[0];
payload.size -= 1 * sizeof(char);
payload.data = &buffer[1];
memset(peer.addr, 0, sizeof(peer.addr));
memset(peer.port, 0, sizeof(peer.port));
getnameinfo(
(struct sockaddr *) &client,
addrlen,
peer.addr, sizeof(peer.addr),
peer.port, sizeof(peer.port),
NI_NUMERICHOST);
printf("received request (0x%02x) from %s:%s (%d bytes)\n", method, peer.addr, peer.port, payload.size);
p = registerPeer(locky, peer);
switch(method) {
case _LOCKY_REQ_METHOD_AUTH: methodAuth(locky, p, &payload); break;
case _LOCKY_REQ_METHOD_UNLOCK: running = !methodUnlock(locky, p, &payload); break;
default: printf("request (0x%02x) not impemented...\n", method);
}
}
deregisterPeers(locky);
}
bool decryptSym(unsigned char *iv, char *secret, locky_message_t *plaintext, locky_message_t *cipher) {
EVP_CIPHER_CTX *ctx;
int l = plaintext->size;
ctx = EVP_CIPHER_CTX_new();
if(ctx)
if(EVP_CipherInit_ex(ctx, EVP_aes_256_cbc(),
NULL, secret, iv, 0))
if(EVP_CipherUpdate(ctx, plaintext->data, &l,
cipher->data, cipher->size)) {
EVP_CipherFinal(ctx, plaintext->data, &l);
plaintext->size = l;
return true;
}
return false;
}
void deregisterPeers(locky_connection_t *locky) {
locky_peer_t *ptr;
while(locky->peers->next) {
ptr = locky->peers;
locky->peers = locky->peers->next;
free(ptr);
}
}
void encryptAsym(EVP_PKEY *pubKey, locky_message_t *crypt, char *data) {
EVP_PKEY_CTX *ctx;
ENGINE *eng;
size_t o;
eng = ENGINE_get_default_RSA();
ctx = EVP_PKEY_CTX_new(pubKey, eng);
if(ctx)
if(EVP_PKEY_encrypt_init(ctx) > 0)
if(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) > 0)
if(EVP_PKEY_encrypt(ctx, NULL, &o, data, _LOCKY_SYM_KEY_SIZE) > 0) {
crypt->size = o;
crypt->data = OPENSSL_malloc(crypt->size);
if(crypt->data) {
EVP_PKEY_encrypt(ctx, crypt->data, &crypt->size, data, _LOCKY_SYM_KEY_SIZE);
}
}
}
void methodAuth(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *data) {
locky_message_t plaintext, signature, crypt;
int s = 0;
s |= (data->data[0] << (sizeof(char) * 8));
s |= (data->data[1]);
plaintext.size = s;
signature.size = data->size - plaintext.size - (sizeof(char) *2);
printf("deserialize auth message (size: %d/%d/%d)\n", plaintext.size, signature.size, data->size);
if(plaintext.size <= ((data->size - 2) / 2)) {
char pt[plaintext.size];
char sig[signature.size];
memcpy(pt, &data->data[2], plaintext.size);
memcpy(sig, &data->data[2 + plaintext.size], signature.size);
plaintext.data = pt;
signature.data = sig;
if(authPeer(locky, peer, &plaintext, &signature)) {
encryptAsym(locky->pubKey, &crypt, peer->cipher);
if(crypt.size > 0) {
sendData(locky, peer, &crypt);
OPENSSL_free(crypt.data);
}
}
}
}
bool methodUnlock(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *data) {
locky_message_t cipher, plaintext, response;
unsigned char iv[16], plain[data->size - 16];
memcpy(iv, &data->data[0], 16);
cipher.size = data->size - 16;
cipher.data = &data->data[16];
plaintext.size = cipher.size;
plaintext.data = plain;
if(decryptSym(iv, peer->cipher, &plaintext, &cipher)) {
printf("received luks key (%d) from %s:%s\n", plaintext.size, peer->addr, peer->port);
if(unlockLuks(&plaintext)) {
encryptAsym(locky->pubKey, &response, "success");
sendData(locky, peer, &response);
OPENSSL_free(response.data);
return true;
}
}
return false;
}
bool readPubKey(locky_connection_t *locky, char *pubKeyFile) {
FILE *fd;
EVP_PKEY *pubKey;
fd = fopen(pubKeyFile, "rb");
if(!fd)
return false;
pubKey = PEM_read_PUBKEY(fd, NULL, NULL, NULL);
if(!pubKey)
return false;
locky->pubKey = pubKey;
return true;
}
locky_peer_t *registerPeer(locky_connection_t *locky, locky_peer_t peer) {
locky_peer_t *ptr = locky->peers;
locky_peer_t *new;
while(ptr) {
if(strcmp(ptr->addr, peer.addr) == 0 &&
strcmp(ptr->port, peer.port) == 0) {
return ptr;
}
ptr = ptr->next;
}
new = malloc(sizeof(locky_peer_t));
strcpy(new->addr, peer.addr);
strcpy(new->port, peer.port);
new->next = locky->peers;
locky->peers = new;
printf("registered new peer %s:%s\n", locky->peers->addr, locky->peers->port);
return new;
}
void sendData(locky_connection_t *locky, locky_peer_t *peer, locky_message_t *msg) {
struct addrinfo hints, *res;
int n;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
n = getaddrinfo(peer->addr, peer->port, &hints, &res);
if(n >= 0) {
if(sendto(locky->socket, msg->data, msg->size, 0,
res->ai_addr, res->ai_addrlen) > 0) {
printf("sent message to %s:%s (%d bytes)\n", peer->addr, peer->port, msg->size);
}
}
freeaddrinfo(res);
}
bool unlockLuks(locky_message_t *luksKey) {
int fd, rc;
struct sockaddr_un addr;
char buffer[_LUKSD_BUFFER_SIZE];
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, "/run/luksd.sock");
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if(fd > 0) {
rc = connect(fd,
(struct sockaddr *) &addr,
sizeof(addr));
if(rc == 0) {
printf("send secret to luksd\n");
send(fd, luksKey->data, luksKey->size, 0);
rc = recv(fd, buffer, _LUKSD_BUFFER_SIZE, 0);
}
close(fd);
}
if(rc > 0 && strcmp("ack", buffer) == 0) {
printf("received acknowledgement from luksd\n");
return true;
}
return false;
}
int main(int argc, char *argv[]) {
struct addrinfo hints, *res, *resSave;
int n;
locky_connection_t locky;
locky.peers = NULL;
struct stat pubKeyFile;
if(argc != 2) {
printf("USAGE: %s <publicKey>\n",
argv[0]);
return 1;
}
if(stat(argv[1], &pubKeyFile) != 0) {
fprintf(stderr, "cannot stat public key file %s\n",
argv[1]);
return 1;
}
if(!readPubKey(&locky, argv[1])) {
fprintf(stderr, "cannot read public key %s\n",
argv[1]);
return 1;
}
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
n = getaddrinfo("*", "23420", &hints, &res);
if(n >= 0) {
resSave = res;
locky.socket = -1;
while(res) {
locky.socket = socket(
res->ai_family,
res->ai_socktype,
res->ai_protocol);
if(locky.socket >= 0) {
if(bind(locky.socket, res->ai_addr, res->ai_addrlen) == 0)
break;
close(locky.socket);
locky.socket = -1;
}
res = res->ai_next;
}
if(locky.socket >= 0) {
listen(locky.socket, SOCKET_QUEUE);
connLoop(&locky);
}
freeaddrinfo(resSave);
close(locky.socket);
}
return 0;
}
|
the_stack_data/168892721.c | /**
* @file csvtable.c
* SQLite extension module for mapping a CSV file as
* a read-only SQLite virtual table plus extension
* function to import a CSV file as a real table.
*
* 2012 July 27
*
* The author disclaims copyright to this source code. In place of
* a legal notice, here is a blessing:
*
* May you do good and not evil.
* May you find forgiveness for yourself and forgive others.
* May you share freely, never taking more than you give.
*
********************************************************************
*/
#ifdef STANDALONE
#include <sqlite3.h>
#else
#include <sqlite3ext.h>
static SQLITE_EXTENSION_INIT1
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#ifdef _WIN32
#include <windows.h>
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#endif
/**
* @typedef csv_file
* @struct csv_file
* Structure to implement CSV file handle.
*/
typedef struct csv_file {
FILE *f; /**< CSV file */
char *sep; /**< column separator characters */
char *quot; /**< text quoting characters */
int isdos; /**< true, when DOS format detected */
int maxl; /**< max. capacity of line buffer */
char *line; /**< line buffer */
long pos0; /**< file position for rewind */
int maxc; /**< max. capacity of column buffer */
int ncols; /**< number of columns */
char **cols; /**< column buffer */
} csv_file;
/**
* @typedef csv_guess_fmt
* @struct csv_guess_fmt
* Info to guess CSV layout.
*/
typedef struct csv_guess_fmt {
int nlines;
int hist[256];
} csv_guess_fmt;
/**
* @typedef csv_vtab
* @struct csv_vtab
* Structure to describe a CSV virtual table.
*/
typedef struct csv_vtab {
sqlite3_vtab vtab; /**< SQLite virtual table */
csv_file *csv; /**< CSV file handle */
int convert; /**< convert flags */
char coltypes[1]; /**< column types */
} csv_vtab;
/**
* @typedef csv_cursor
* @struct csv_cursor
* Structure to describe CSV virtual table cursor.
*/
typedef struct {
sqlite3_vtab_cursor cursor; /**< SQLite virtual table cursor */
long pos; /**< CSV file position */
} csv_cursor;
/**
* Free dynamically allocated string buffer
* @param in input string pointer
*/
static void
append_free(char **in)
{
long *p = (long *) *in;
if (p) {
p -= 2;
sqlite3_free(p);
*in = 0;
}
}
/**
* Append a string to dynamically allocated string buffer
* with optional quoting
* @param in input string pointer
* @param append string to append
* @param quote quote character or NUL
* @result new string to be free'd with append_free()
*/
static char *
append(char **in, char const *append, char quote)
{
long *p = (long *) *in;
long len, maxlen, actlen;
int i;
char *pp;
int nappend = append ? strlen(append) : 0;
if (p) {
p -= 2;
maxlen = p[0];
actlen = p[1];
} else {
maxlen = actlen = 0;
}
len = nappend + actlen;
if (quote) {
len += 2;
for (i = 0; i < nappend; i++) {
if (append[i] == quote) {
len++;
}
}
} else if (!nappend) {
return *in;
}
if (len >= maxlen - 1) {
long *q;
maxlen = (len + 0x03ff) & (~0x3ff);
q = (long *) sqlite3_realloc(p, maxlen + 1 + 2 * sizeof (long));
if (!q) {
return 0;
}
if (!p) {
q[1] = 0;
}
p = q;
p[0] = maxlen;
*in = (char *) (p + 2);
}
pp = *in + actlen;
if (quote) {
*pp++ = quote;
for (i = 0; i < nappend; i++) {
*pp++ = append[i];
if (append[i] == quote) {
*pp++ = quote;
}
}
*pp++ = quote;
*pp = '\0';
} else {
if (nappend) {
memcpy(pp, append, nappend);
pp += nappend;
*pp = '\0';
}
}
p[1] = pp - *in;
return *in;
}
/**
* Strip off quotes given string.
* @param in string to be processed
* @result new string to be free'd with sqlite3_free()
*/
static char *
unquote(char const *in)
{
char c, *ret;
int i;
ret = sqlite3_malloc(strlen(in) + 1);
if (ret) {
c = in[0];
if ((c == '"') || (c == '\'')) {
i = strlen(in + 1);
if ((i > 0) && (in[i] == c)) {
strcpy(ret, in + 1);
ret[i - 1] = '\0';
return ret;
}
}
strcpy(ret, in);
}
return ret;
}
/**
* Map string to SQLite data type.
* @param type string to be mapped
* @result SQLITE_TEXT et.al.
*/
static int
maptype(char const *type)
{
int typelen = type ? strlen(type) : 0;
if ((typelen >= 3) &&
(strncasecmp(type, "integer", 7) == 0)) {
return SQLITE_INTEGER;
}
if ((typelen >= 6) &&
(strncasecmp(type, "double", 6) == 0)) {
return SQLITE_FLOAT;
}
if ((typelen >= 5) &&
(strncasecmp(type, "float", 5) == 0)) {
return SQLITE_FLOAT;
}
if ((typelen >= 4) &&
(strncasecmp(type, "real", 4) == 0)) {
return SQLITE_FLOAT;
}
return SQLITE_TEXT;
}
/**
* Convert and collapse white space in column names to underscore
* @param names string vector of column names
* @param ncols number of columns
*/
static void
conv_names(char **names, int ncols)
{
int i;
char *p, *q;
static const char ws[] = "\n\t\r\b\v ";
if (!names || ncols <= 0) {
return;
}
for (i = 0; i < ncols; i++) {
p = names[i];
while (*p) {
if (strchr(ws, *p)) {
*p++ = '_';
q = p;
while (*q && strchr(ws, *q)) {
++q;
}
if (*q && q > p) {
strcpy(p, q);
}
continue;
}
++p;
}
}
}
/**
* Make result data or parameter binding accoring to type
* @param ctx SQLite function context or NULL
* @param stmt SQLite statement or NULL
* @param idx parameter number, 1-based
* @param data string data
* @param len string length
* @param type SQLite type
*/
static void
result_or_bind(sqlite3_context *ctx, sqlite3_stmt *stmt, int idx,
char *data, int len, int type)
{
char *endp;
if (!data) {
if (ctx) {
sqlite3_result_null(ctx);
} else {
sqlite3_bind_null(stmt, idx);
}
return;
}
if (type == SQLITE_INTEGER) {
sqlite_int64 val;
#if defined(_WIN32) || defined(_WIN64)
char endc;
if (sscanf(data, "%I64d%c", &val, &endc) == 1) {
if (ctx) {
sqlite3_result_int64(ctx, val);
} else {
sqlite3_bind_int64(stmt, idx, val);
}
return;
}
#else
endp = 0;
#ifdef __osf__
val = strtol(data, &endp, 0);
#else
val = strtoll(data, &endp, 0);
#endif
if (endp && (endp != data) && !*endp) {
if (ctx) {
sqlite3_result_int64(ctx, val);
} else {
sqlite3_bind_int64(stmt, idx, val);
}
return;
}
#endif
} else if (type == SQLITE_FLOAT) {
double val;
endp = 0;
val = strtod(data, &endp);
if (endp && (endp != data) && !*endp) {
if (ctx) {
sqlite3_result_double(ctx, val);
} else {
sqlite3_bind_double(stmt, idx, val);
}
return;
}
}
if (ctx) {
sqlite3_result_text(ctx, data, len, SQLITE_TRANSIENT);
} else {
sqlite3_bind_text(stmt, idx, data, len, SQLITE_TRANSIENT);
}
}
/**
* Process one column of the current row
* @param ctx SQLite function context or NULL
* @param stmt SQLite statement or NULL
* @param idx parameter index, 1-based
* @param data string data
* @param type SQLite type
* @param conv conversion flags
*/
static int
process_col(sqlite3_context *ctx, sqlite3_stmt *stmt, int idx,
char *data, int type, int conv)
{
char c, *p;
const char flchars[] = "Ee+-.,0123456789";
if (!data) {
goto putdata;
}
/*
* Floating point number test,
* converts single comma to dot.
*/
c = data[0];
if ((c != '\0') && strchr(flchars + 2, c)) {
p = data + 1;
while (*p && strchr(flchars, *p)) {
++p;
}
if (*p == '\0') {
char *first = 0;
int n = 0;
p = data;
while (p) {
p = strchr(p, ',');
if (!p) {
break;
}
if (++n == 1) {
first = p;
}
++p;
}
if (first) {
*first = '.';
goto putdata;
}
}
}
if (conv) {
char *utf = sqlite3_malloc(strlen(data) * 2 + 2);
if (utf) {
p = utf;
while ((c = *data) != '\0') {
if (((conv & 10) == 10) && (c == '\\')) {
if (data[1] == 'q') {
*p++ = '\'';
data += 2;
continue;
}
}
if ((conv & 2) && (c == '\\')) {
char c2 = data[1];
switch (c2) {
case '\0':
goto convdone;
case 'n':
*p = '\n';
break;
case 't':
*p = '\t';
break;
case 'r':
*p = '\r';
break;
case 'f':
*p = '\f';
break;
case 'v':
*p = '\v';
break;
case 'b':
*p = '\b';
break;
case 'a':
*p = '\a';
break;
case '?':
*p = '\?';
break;
case '\'':
*p = '\'';
break;
case '"':
*p = '\"';
break;
case '\\':
*p = '\\';
break;
default:
*p++ = c;
*p = c2;
break;
}
p++;
data += 2;
continue;
}
if ((conv & 1) && (c & 0x80)) {
*p++ = 0xc0 | ((c >> 6) & 0x1f);
*p++ = 0x80 | (c & 0x3f);
} else {
*p++ = c;
}
data++;
}
convdone:
*p = '\0';
result_or_bind(ctx, stmt, idx, utf, p - utf, type);
sqlite3_free(utf);
return SQLITE_OK;
} else {
if (ctx) {
sqlite3_result_error(ctx, "out of memory", -1);
}
return SQLITE_NOMEM;
}
}
putdata:
result_or_bind(ctx, stmt, idx, data, -1, type);
return SQLITE_OK;
}
/**
* Open CSV file for reading and return handle to it.
* @param filename name of CSV file
* @param sep column separator characters or NULL
* @param quot string quote characters or NULL
* @result CSV file handle
*/
static csv_file *
csv_open(const char *filename, const char *sep, const char *quot)
{
FILE *f;
csv_file *csv;
#ifdef _WIN32
f = fopen(filename, "rb");
#else
f = fopen(filename, "r");
#endif
if (!f) {
return 0;
}
csv = sqlite3_malloc(sizeof (csv_file));
if (!csv) {
error0:
fclose(f);
return 0;
}
csv->f = f;
if (sep && sep[0]) {
csv->sep = sqlite3_malloc(strlen(sep) + 1);
if (!csv->sep) {
error1:
sqlite3_free(csv);
goto error0;
}
strcpy(csv->sep, sep);
} else {
csv->sep = 0;
}
if (quot && quot[0]) {
csv->quot = sqlite3_malloc(strlen(quot) + 1);
if (!csv->quot) {
if (csv->sep) {
sqlite3_free(csv->sep);
}
goto error1;
}
strcpy(csv->quot, quot);
} else {
csv->quot = 0;
}
csv->isdos = 0;
csv->maxl = 0;
csv->line = 0;
csv->pos0 = 0;
csv->maxc = 0;
csv->ncols = 0;
csv->cols = 0;
return csv;
}
/**
* Close CSV file handle.
* @param csv CSV file handle
*/
static void
csv_close(csv_file *csv)
{
if (csv) {
if (csv->sep) {
sqlite3_free(csv->sep);
}
if (csv->quot) {
sqlite3_free(csv->quot);
}
if (csv->line) {
sqlite3_free(csv->line);
}
if (csv->cols) {
sqlite3_free(csv->cols);
}
if (csv->f) {
fclose(csv->f);
}
sqlite3_free(csv);
}
}
/**
* Test EOF on CSV file handle.
* @param csv CSV file handle
* @result true when file position is at EOF
*/
static int
csv_eof(csv_file *csv)
{
if (csv && csv->f) {
return feof(csv->f);
}
return 1;
}
/**
* Position CSV file handle.
* @param csv CSV file handle
* @param pos position to seek
* @result 0 on success, EOF on error
*/
static long
csv_seek(csv_file *csv, long pos)
{
if (csv && csv->f) {
return fseek(csv->f, pos, SEEK_SET);
}
return EOF;
}
/**
* Rewind CSV file handle.
* @param csv CSV file handle
*/
static void
csv_rewind(csv_file *csv)
{
if (csv && csv->f) {
csv_seek(csv, csv->pos0);
}
}
/**
* Return current position of CSV file handle.
* @param csv CSV file handle
* @result current file position
*/
static long
csv_tell(csv_file *csv)
{
if (csv && csv->f) {
return ftell(csv->f);
}
return EOF;
}
/**
* Read and process one line of CSV file handle.
* @param csv CSV file handle
* @param guess NULL or buffer for guessing file format
* @result number of columns on success, EOF on error
*/
static int
csv_getline(csv_file *csv, csv_guess_fmt *guess)
{
int i, index = 0, inq = 0, c, col;
char *p, *sep;
if (!csv || !csv->f) {
return EOF;
}
while (1) {
c = fgetc(csv->f);
if (c == EOF) {
if (index > 0) {
break;
}
return EOF;
}
if (c == '\0') {
continue;
}
if (c == '\r') {
int c2 = fgetc(csv->f);
c = '\n';
if (c2 == '\n') {
csv->isdos = 1;
} else if (c2 != EOF) {
ungetc(c2, csv->f);
}
}
/* check for DOS EOF (Ctrl-Z) */
if (csv->isdos && (c == '\032')) {
int c2 = fgetc(csv->f);
if (c2 == EOF) {
if (index > 0) {
break;
}
return EOF;
}
ungetc(c2, csv->f);
}
if (index >= csv->maxl - 1) {
int n = csv->maxl * 2;
char *line;
if (n <= 0) {
n = 4096;
}
line = sqlite3_malloc(n);
if (!line) {
return EOF;
}
if (csv->line) {
memcpy(line, csv->line, index);
sqlite3_free(csv->line);
}
csv->maxl = n;
csv->line = line;
}
csv->line[index++] = c;
if (csv->quot && (p = strchr(csv->quot, c))) {
if (inq) {
if (*p == inq) {
inq = 0;
}
} else {
inq = *p;
}
}
if (!inq && (c == '\n')) {
break;
}
}
if (guess) {
for (i = 0; i < index; i++) {
guess->hist[csv->line[i] & 0xFF] += 1;
}
guess->nlines += 1;
csv->ncols = 0;
return 0;
}
for (i = index - 1; i >= 0; i--) {
if (csv->line[i] != '\n') {
break;
}
}
index = i + 1;
csv->line[index] = '\0';
i = inq = col = 0;
sep = csv->sep ? csv->sep : ";";
if (!csv->cols) {
int n = 128;
csv->cols = sqlite3_malloc(sizeof (char *) * n);
if (!csv->cols) {
return EOF;
}
csv->maxc = n;
}
csv->cols[col++] = csv->line;
while (i < index) {
if (csv->quot && (p = strchr(csv->quot, csv->line[i]))) {
if (inq) {
if (*p == inq) {
inq = 0;
}
} else {
inq = *p;
}
}
if (!inq && (p = strchr(sep, csv->line[i]))) {
p = csv->line + i;
*p = '\0';
if (col >= csv->maxc) {
int n = csv->maxc * 2;
char **cols;
cols = sqlite3_realloc(csv->cols, sizeof (char *) * n);
if (!cols) {
return EOF;
}
csv->cols = cols;
csv->maxc = n;
}
csv->cols[col++] = p + 1;
}
++i;
}
csv->ncols = col;
/* strip off quotes */
if (csv->quot) {
for (i = 0; i < col; i++) {
if (*csv->cols[i]) {
p = strchr(csv->quot, *csv->cols[i]);
if (p) {
char *src, *dst;
c = *p;
csv->cols[i] += 1;
sep = csv->cols[i] + strlen(csv->cols[i]) - 1;
if ((sep >= csv->cols[i]) && (*sep == c)) {
*sep = '\0';
}
/* collapse quote escape sequences */
src = csv->cols[i];
dst = 0;
while (*src) {
if ((*src == c) && (src[1] == c)) {
if (!dst) {
dst = src;
}
src++;
while (*src) {
*dst++ = *src++;
if (*src == c) {
--src;
break;
}
}
}
++src;
}
if (dst) {
*dst++ = '\0';
}
}
}
}
}
return col;
}
/**
* Return number of columns of current row in CSV file.
* @param csv CSV file handle
* @result number of columns of current row
*/
static int
csv_ncols(csv_file *csv)
{
if (csv && csv->cols) {
return csv->ncols;
}
return 0;
}
/**
* Return nth column of current row in CSV file.
* @param csv CSV file handle
* @param n column number
* @result string pointer or NULL
*/
static char *
csv_coldata(csv_file *csv, int n)
{
if (csv && csv->cols && (n >= 0) && (n < csv->ncols)) {
return csv->cols[n];
}
return 0;
}
/**
* Guess CSV layout of CSV file handle.
* @param csv CSV file handle
* @result 0 on succes, EOF on error
*/
static int
csv_guess(csv_file *csv)
{
csv_guess_fmt guess;
int i, n;
char *p, sep[32], quot[4];
const struct {
int c;
int min;
} sep_test[] = {
{ ',', 2 },
{ ';', 2 },
{ '\t', 2 },
{ ' ', 4 },
{ '|', 2 }
};
if (!csv) {
return EOF;
}
memset(&guess, 0, sizeof (guess));
csv->pos0 = 0;
csv_rewind(csv);
for (i = n = 0; i < 10; i++) {
n = csv_getline(csv, &guess);
if (n == EOF) {
break;
}
}
csv_rewind(csv);
if (n && !i) {
return EOF;
}
p = quot;
n = '"';
if (guess.hist[n] > 1) {
*p++ = n;
}
n = '\'';
if (guess.hist[n] > 1) {
*p++ = n;
}
*p = '\0';
p = sep;
for (i = 0; i < sizeof (sep_test) / sizeof (sep_test[0]); i++) {
if (guess.hist[sep_test[i].c] > sep_test[i].min * guess.nlines) {
*p++ = sep_test[i].c;
}
}
*p = '\0';
if (quot[0]) {
p = sqlite3_malloc(strlen(quot) + 1);
if (p) {
strcpy(p, quot);
if (csv->quot) {
sqlite3_free(csv->quot);
}
csv->quot = p;
} else {
return EOF;
}
}
if (sep[0]) {
p = sqlite3_malloc(strlen(sep) + 1);
if (p) {
strcpy(p, sep);
if (csv->sep) {
sqlite3_free(csv->sep);
}
csv->sep = p;
} else {
return EOF;
}
}
return 0;
}
/**
* Connect to virtual table
* @param db SQLite database pointer
* @param aux user specific pointer (unused)
* @param argc argument count
* @param argv argument vector
* @param vtabp pointer receiving virtual table pointer
* @param errp pointer receiving error messag
* @result SQLite error code
*
* Argument vector contains:
*
* argv[0] - module name<br>
* argv[1] - database name<br>
* argv[2] - table name (virtual table)<br>
* argv[3] - filename (required)<br>
* argv[4] - number, when non-zero use first line as column names,
* when negative use given type names (optional)<br>
* argv[5] - number, when non-zero, translate data (optional, see below)<br>
* argv[6] - column separator characters (optional)<br>
* argv[7] - string quoting characters (optional)<br>
* argv[8] - column/type name for first column (optional)<br>
* ..<br>
* argv[X] - column/type name for last column (optional)<br><br>
*
* Translation flags:
*
* 1 - convert ISO-8859-1 to UTF-8<br>
* 2 - perform backslash substitution<br>
* 4 - convert and collapse white-space in column names to underscore<br>
* 10 - convert \q to single quote, in addition to backslash substitution<br>
*/
static int
csv_vtab_connect(sqlite3* db, void *aux, int argc, const char * const *argv,
sqlite3_vtab **vtabp, char **errp)
{
csv_file *csv;
int rc = SQLITE_ERROR, i, ncnames, row1;
char **cnames, *schema = 0, **nargv;
csv_vtab *vtab;
if (argc < 4) {
*errp = sqlite3_mprintf("input file name missing");
return SQLITE_ERROR;
}
nargv = sqlite3_malloc(sizeof (char *) * argc);
memset(nargv, 0, sizeof (char *) * argc);
for (i = 3; i < argc; i++) {
nargv[i] = unquote(argv[i]);
}
csv = csv_open(nargv[3], (argc > 6) ? nargv[6] : 0,
(argc > 7) ? nargv[7] : 0);
if (!csv) {
*errp = sqlite3_mprintf("unable to open input file");
cleanup:
append_free(&schema);
for (i = 3; i < argc; i++) {
if (nargv[i]) {
sqlite3_free(nargv[i]);
}
}
return rc;
}
if (!csv->sep && !csv->quot) {
csv_guess(csv);
}
csv->pos0 = 0;
row1 = 0;
if (argc > 4) {
row1 = strtol(nargv[4], 0, 10);
}
if (row1) {
/* use column names from 1st row */
csv_getline(csv, 0);
if (csv->ncols < 1) {
csv_close(csv);
*errp = sqlite3_mprintf("unable to get column names");
goto cleanup;
}
csv->pos0 = csv_tell(csv);
csv_rewind(csv);
ncnames = csv_ncols(csv);
cnames = csv->cols;
} else if (argc > 8) {
ncnames = argc - 8;
cnames = (char **) nargv + 8;
} else {
/* use number of columns from 1st row */
csv_getline(csv, 0);
if (csv->ncols < 1) {
csv_close(csv);
*errp = sqlite3_mprintf("unable to get column names");
goto cleanup;
}
csv_rewind(csv);
ncnames = csv_ncols(csv);
cnames = 0;
}
vtab = sqlite3_malloc(sizeof(csv_vtab) + ncnames);
if (!vtab) {
csv_close(csv);
*errp = sqlite3_mprintf("out of memory");
goto cleanup;
}
memset(vtab, 0, sizeof (*vtab));
vtab->convert = 0;
if (argc > 5) {
vtab->convert = strtol(nargv[5], 0, 10);
if (row1 && (vtab->convert & 4)) {
conv_names(cnames, ncnames);
}
}
vtab->csv = csv;
append(&schema, "CREATE TABLE x(", 0);
for (i = 0; i < ncnames; i++) {
vtab->coltypes[i] = SQLITE_TEXT;
if (!cnames || !cnames[i]) {
char colname[64];
sprintf(colname, "column_%d", i + 1);
append(&schema, colname, '"');
} else if (row1 > 0) {
append(&schema, cnames[i], '"');
} else if (row1 < 0) {
append(&schema, cnames[i], '"');
if (i + 8 < argc) {
char *type = nargv[i + 8];
append(&schema, " ", 0);
append(&schema, type, 0);
vtab->coltypes[i] = maptype(type);
}
} else {
char *type = cnames[i];
append(&schema, cnames[i], 0);
while (*type && !strchr(" \t", *type)) {
type++;
}
while (*type && strchr(" \t", *type)) {
type++;
}
vtab->coltypes[i] = maptype(type);
}
if (i < ncnames - 1) {
append(&schema, ",", 0);
}
}
append(&schema, ")", 0);
rc = sqlite3_declare_vtab(db, schema);
if (rc != SQLITE_OK) {
csv_close(csv);
sqlite3_free(vtab);
*errp = sqlite3_mprintf("table definition failed, error %d, "
"schema '%s'", rc, schema);
goto cleanup;
}
*vtabp = &vtab->vtab;
*errp = 0;
goto cleanup;
}
/**
* Create virtual table
* @param db SQLite database pointer
* @param aux user specific pointer (unused)
* @param argc argument count
* @param argv argument vector
* @param vtabp pointer receiving virtual table pointer
* @param errp pointer receiving error messag
* @result SQLite error code
*/
static int
csv_vtab_create(sqlite3* db, void *aux, int argc,
const char *const *argv,
sqlite3_vtab **vtabp, char **errp)
{
return csv_vtab_connect(db, aux, argc, argv, vtabp, errp);
}
/**
* Disconnect virtual table.
* @param vtab virtual table pointer
* @result always SQLITE_OK
*/
static int
csv_vtab_disconnect(sqlite3_vtab *vtab)
{
csv_vtab *tab = (csv_vtab *) vtab;
csv_close(tab->csv);
sqlite3_free(tab);
return SQLITE_OK;
}
/**
* Destroy virtual table.
* @param vtab virtual table pointer
* @result always SQLITE_OK
*/
static int
csv_vtab_destroy(sqlite3_vtab *vtab)
{
return csv_vtab_disconnect(vtab);
}
/**
* Determines information for filter function according to constraints.
* @param vtab virtual table
* @param info index/constraint iinformation
* @result SQLite error code
*/
static int
csv_vtab_bestindex(sqlite3_vtab *vtab, sqlite3_index_info *info)
{
return SQLITE_OK;
}
/**
* Open virtual table and return cursor.
* @param vtab virtual table pointer
* @param cursorp pointer receiving cursor pointer
* @result SQLite error code
*/
static int
csv_vtab_open(sqlite3_vtab *vtab, sqlite3_vtab_cursor **cursorp)
{
csv_cursor *cur = sqlite3_malloc(sizeof(*cur));
csv_vtab *tab = (csv_vtab *) vtab;
if (!cur) {
return SQLITE_ERROR;
}
cur->cursor.pVtab = vtab;
csv_rewind(tab->csv);
cur->pos = csv_tell(tab->csv);
*cursorp = &cur->cursor;
return SQLITE_OK;
}
/**
* Close virtual table cursor.
* @param cursor cursor pointer
* @result SQLite error code
*/
static int
csv_vtab_close(sqlite3_vtab_cursor *cursor)
{
sqlite3_free(cursor);
return SQLITE_OK;
}
/**
* Retrieve next row from virtual table cursor
* @param cursor virtual table cursor
* @result SQLite error code
*/
static int
csv_vtab_next(sqlite3_vtab_cursor *cursor)
{
csv_cursor *cur = (csv_cursor *) cursor;
csv_vtab *tab = (csv_vtab *) cur->cursor.pVtab;
cur->pos = csv_tell(tab->csv);
csv_getline(tab->csv, 0);
return SQLITE_OK;
}
/**
* Filter function for virtual table.
* @param cursor virtual table cursor
* @param idxNum unused (always 0)
* @param idxStr unused
* @param argc number arguments (unused, 0)
* @param argv argument (nothing)
* @result SQLite error code
*/
static int
csv_vtab_filter(sqlite3_vtab_cursor *cursor, int idxNum,
const char *idxStr, int argc, sqlite3_value **argv)
{
csv_cursor *cur = (csv_cursor *) cursor;
csv_vtab *tab = (csv_vtab *) cur->cursor.pVtab;
csv_rewind(tab->csv);
return csv_vtab_next(cursor);
}
/**
* Return end of table state of virtual table cursor
* @param cursor virtual table cursor
* @result true/false
*/
static int
csv_vtab_eof(sqlite3_vtab_cursor *cursor)
{
csv_cursor *cur = (csv_cursor *) cursor;
csv_vtab *tab = (csv_vtab *) cur->cursor.pVtab;
return csv_eof(tab->csv);
}
/**
* Return column data of virtual table.
* @param cursor virtual table cursor
* @param ctx SQLite function context
* @param n column index
* @result SQLite error code
*/
static int
csv_vtab_column(sqlite3_vtab_cursor *cursor, sqlite3_context *ctx, int n)
{
csv_cursor *cur = (csv_cursor *) cursor;
csv_vtab *tab = (csv_vtab *) cur->cursor.pVtab;
char *data = csv_coldata(tab->csv, n);
return process_col(ctx, 0, 0, data, tab->coltypes[n], tab->convert);
}
/**
* Return current rowid of virtual table cursor
* @param cursor virtual table cursor
* @param rowidp value buffer to receive current rowid
* @result SQLite error code
*/
static int
csv_vtab_rowid(sqlite3_vtab_cursor *cursor, sqlite_int64 *rowidp)
{
csv_cursor *cur = (csv_cursor *) cursor;
*rowidp = cur->pos;
return SQLITE_OK;
}
#if (SQLITE_VERSION_NUMBER > 3004000)
/**
* Rename virtual table.
* @param newname new name for table
* @result SQLite error code
*/
static int
csv_vtab_rename(sqlite3_vtab *vtab, const char *newname)
{
return SQLITE_OK;
}
#endif
/**
* SQLite module descriptor.
*/
static const sqlite3_module csv_vtab_mod = {
1, /* iVersion */
csv_vtab_create, /* xCreate */
csv_vtab_connect, /* xConnect */
csv_vtab_bestindex, /* xBestIndex */
csv_vtab_disconnect, /* xDisconnect */
csv_vtab_destroy, /* xDestroy */
csv_vtab_open, /* xOpen */
csv_vtab_close, /* xClose */
csv_vtab_filter, /* xFilter */
csv_vtab_next, /* xNext */
csv_vtab_eof, /* xEof */
csv_vtab_column, /* xColumn */
csv_vtab_rowid, /* xRowid */
0, /* xUpdate */
0, /* xBegin */
0, /* xSync */
0, /* xCommit */
0, /* xRollback */
0, /* xFindFunction */
#if (SQLITE_VERSION_NUMBER > 3004000)
csv_vtab_rename, /* xRename */
#endif
};
/**
* Import CSV file as table into database
* @param ctx SQLite function context
* @param argc number of arguments
* @param argv argument vector
*
* Argument vector contains:
*
* argv[0] - name of table to create (required)<br>
* argv[1] - filename (required)<br>
* argv[2] - number, when non-zero use first line as column names,
* when negative use given type names (optional)<br>
* argv[3] - number, when non-zero, translate data (optional, see below)<br>
* argv[4] - column separator characters (optional)<br>
* argv[5] - string quoting characters (optional)<br>
* argv[6] - column/type name for first column (optional)<br>
* ..<br>
* argv[X] - column/type name for last column (optional)<br><br>
*
* Translation flags:
*
* 1 - convert ISO-8859-1 to UTF-8<br>
* 2 - perform backslash substitution<br>
* 4 - convert and collapse white-space in column names to underscore<br>
* 10 - convert \q to single quote, in addition to backslash substitution<br>
*/
static void
csv_import_func(sqlite3_context *ctx, int argc, sqlite3_value **argv)
{
csv_file *csv;
int rc, i, ncnames, row1, convert = 0, useargs = 0;
char *tname, *fname, *sql = 0, **cnames, *coltypes = 0;
sqlite3 *db = (sqlite3 *) sqlite3_user_data(ctx);
sqlite3_stmt *stmt = 0;
if (argc < 2) {
sqlite3_result_error(ctx, "need at least 2 arguments", -1);
return;
}
tname = (char *) sqlite3_value_text(argv[0]);
if (!tname) {
sqlite3_result_error(ctx, "table name is NULL", -1);
return;
}
fname = (char *) sqlite3_value_text(argv[1]);
if (!fname) {
sqlite3_result_error(ctx, "file name is NULL", -1);
return;
}
csv = csv_open(fname,
(argc > 4) ? (char *) sqlite3_value_text(argv[4]) : 0,
(argc > 5) ? (char *) sqlite3_value_text(argv[5]) : 0);
if (!csv) {
sqlite3_result_error(ctx, "unable to open input file", -1);
cleanup:
if (stmt) {
sqlite3_finalize(stmt);
}
append_free(&sql);
if (coltypes) {
sqlite3_free(coltypes);
}
if (csv) {
csv_close(csv);
}
return;
}
if (!csv->sep && !csv->quot) {
csv_guess(csv);
}
csv->pos0 = 0;
row1 = 0;
if (argc > 2) {
row1 = sqlite3_value_int(argv[2]);
}
if (row1) {
/* use column names from 1st row */
csv_getline(csv, 0);
if (csv->ncols < 1) {
sqlite3_result_error(ctx, "unable to get column names", -1);
goto cleanup;
}
csv->pos0 = csv_tell(csv);
csv_rewind(csv);
ncnames = csv_ncols(csv);
cnames = csv->cols;
} else if (argc > 6) {
ncnames = argc - 6;
cnames = 0;
useargs = 1;
} else {
/* use number of columns from 1st row */
csv_getline(csv, 0);
if (csv->ncols < 1) {
sqlite3_result_error(ctx, "unable to get column names", -1);
goto cleanup;
}
csv_rewind(csv);
ncnames = csv_ncols(csv);
cnames = 0;
}
convert = 0;
if (argc > 3) {
convert = sqlite3_value_int(argv[3]);
if (row1 && (convert & 4)) {
conv_names(cnames, ncnames);
}
}
/* test if table exists */
append(&sql, "PRAGMA table_info(", 0);
append(&sql, tname, '"');
append(&sql, ")", 0);
if (!sql) {
oom:
sqlite3_result_error(ctx, "out of memory", -1);
goto cleanup;
}
rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
append_free(&sql);
if (rc != SQLITE_OK) {
prepfail:
sqlite3_result_error(ctx, "prepare failed", -1);
goto cleanup;
}
/* find number of colums */
i = 0;
rc = sqlite3_step(stmt);
while (rc == SQLITE_ROW) {
i++;
rc = sqlite3_step(stmt);
}
if (rc != SQLITE_DONE) {
selfail:
sqlite3_result_error(ctx, "select failed", -1);
goto cleanup;
}
if (i > 0) {
/* get column types */
sqlite3_reset(stmt);
ncnames = i;
coltypes = sqlite3_malloc(ncnames);
if (!coltypes) {
goto oom;
}
rc = sqlite3_step(stmt);
i = 0;
while (rc == SQLITE_ROW) {
coltypes[i++] = maptype((char *) sqlite3_column_text(stmt, 2));
rc = sqlite3_step(stmt);
}
if (rc != SQLITE_DONE) {
goto selfail;
}
} else {
/* create new table */
sqlite3_finalize(stmt);
stmt = 0;
coltypes = sqlite3_malloc(ncnames);
if (!coltypes) {
goto oom;
}
append(&sql, "CREATE TABLE ", 0);
append(&sql, tname, '"');
append(&sql, "(", 0);
for (i = 0; i < ncnames; i++) {
char colname[64];
coltypes[i] = SQLITE_TEXT;
if (useargs) {
char *type = (char *) sqlite3_value_text(argv[i + 6]);
if (!type) {
goto defcol;
}
append(&sql, type, 0);
while (*type && !strchr(" \t", *type)) {
type++;
}
while (*type && strchr(" \t", *type)) {
type++;
}
coltypes[i] = maptype(type);
} else if (!cnames || !cnames[i]) {
defcol:
sprintf(colname, "column_%d", i + 1);
append(&sql, colname, '"');
} else if (row1 > 0) {
append(&sql, cnames[i], '"');
} else if (row1 < 0) {
append(&sql, cnames[i], '"');
if (i + 6 < argc) {
char *type = (char *) sqlite3_value_text(argv[i + 6]);
if (type) {
append(&sql, " ", 0);
append(&sql, type, 0);
coltypes[i] = maptype(type);
}
}
}
if (i < ncnames - 1) {
append(&sql, ",", 0);
}
}
append(&sql, ")", 0);
rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
if (rc != SQLITE_OK) {
goto prepfail;
}
rc = sqlite3_step(stmt);
if ((rc != SQLITE_DONE) && (rc != SQLITE_OK)) {
sqlite3_result_error(ctx, "create table failed", -1);
goto cleanup;
}
append_free(&sql);
}
sqlite3_finalize(stmt);
stmt = 0;
/* make INSERT statement */
append(&sql, "INSERT INTO ", 0);
append(&sql, tname, '"');
append(&sql, " VALUES(", 0);
for (i = 0; i < ncnames; i++) {
append(&sql, (i < ncnames - 1) ? "?," : "?)", 0);
}
rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
if (rc != SQLITE_OK) {
goto prepfail;
}
append_free(&sql);
/* import the CSV file */
row1 = 0;
while (csv_getline(csv, 0) != EOF) {
for (i = 0; i < ncnames; i++) {
char *data = csv_coldata(csv, i);
rc = process_col(0, stmt, i + 1, data, coltypes[i], convert);
if (rc != SQLITE_OK) {
goto inserr;
}
}
rc = sqlite3_step(stmt);
if ((rc != SQLITE_DONE) && (rc != SQLITE_OK)) {
if ((rc != SQLITE_MISMATCH) && (rc != SQLITE_CONSTRAINT)) {
inserr:
sqlite3_result_error(ctx, "insert failed", -1);
goto cleanup;
}
} else {
row1++;
}
sqlite3_reset(stmt);
}
sqlite3_result_int(ctx, row1);
goto cleanup;
}
/**
* Module initializer creating SQLite functions and modules
* @param db database pointer
* @result SQLite error code
*/
#ifndef STANDALONE
static
#endif
int
csv_vtab_init(sqlite3 *db)
{
sqlite3_create_function(db, "import_csv", -1, SQLITE_UTF8,
(void *) db, csv_import_func, 0, 0);
return sqlite3_create_module(db, "csvtable", &csv_vtab_mod, 0);
}
#ifndef STANDALONE
/**
* Initializer for SQLite extension load mechanism.
* @param db SQLite database pointer
* @param errmsg pointer receiving error message
* @param api SQLite API routines
* @result SQLite error code
*/
int
sqlite3_extension_init(sqlite3 *db, char **errmsg,
const sqlite3_api_routines *api)
{
SQLITE_EXTENSION_INIT2(api);
return csv_vtab_init(db);
}
#endif
|
the_stack_data/681255.c | #include <stdio.h>
void transitionTable(char *query, int M, int TF[][256]){
int i, lps=0, x;
for(x=0; x<256; x++) TF[0][x]=0;
TF[0][query[0]]=1;
for(i=1; i<=M; i++){
for(x=0; x<256; x++) TF[i][x]=TF[lps][x];
TF[i][query[i]]=i+1;
if(i<M) lps = TF[lps][query[i]];
}
}
void patternMatching2(char *query, char *mainString){
int M = 0, N = 0;
while(mainString[N]!='\0') N++;
while(query[M]!='\0') M++;
int TF[M+1][256];
transitionTable(query, M, TF);
int i, j=0;
for(i=0; i<N; i++){
j=TF[j][mainString[i]];
if(j==M) printf("%d\t", i-M+1);
}
}
int main(){
char str[100]="Tomay Amar Shonar Bangla, Ami Tomay Valobashi! Tomay!", query[100]="Tomay";
patternMatching2(query, str);
return 0;
}
|
the_stack_data/184518920.c | # 1 "benchmarks/ds-08-impl2.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "benchmarks/ds-08-impl2.c"
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h"
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h" 1
# 132 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h"
int X_SIZE_VALUE = 0;
int overflow_mode = 1;
int rounding_mode = 0;
# 155 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h"
typedef struct {
double a[100];
int a_size;
double b[100];
int b_size;
double sample_time;
double a_uncertainty[100];
double b_uncertainty[100];
} digital_system;
typedef struct {
double A[4][4];
double B[4][4];
double C[4][4];
double D[4][4];
double states[4][4];
double outputs[4][4];
double inputs[4][4];
double K[4][4];
unsigned int nStates;
unsigned int nInputs;
unsigned int nOutputs;
} digital_system_state_space;
typedef struct {
int int_bits;
int frac_bits;
double max;
double min;
int default_realization;
double delta;
int scale;
double max_error;
} implementation;
typedef struct {
int push;
int in;
int sbiw;
int cli;
int out;
int std;
int ldd;
int subi;
int sbci;
int lsl;
int rol;
int add;
int adc;
int adiw;
int rjmp;
int mov;
int sbc;
int ld;
int rcall;
int cp;
int cpc;
int ldi;
int brge;
int pop;
int ret;
int st;
int brlt;
int cpi;
} instructions;
typedef struct {
long clock;
int device;
double cycle;
instructions assembly;
} hardware;
typedef struct{
float Ap, Ar, Ac;
float wp, wc, wr;
int type;
}filter_parameters;
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 461 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 462 "/usr/include/features.h" 2 3 4
# 485 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 486 "/usr/include/features.h" 2 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
# 26 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 209 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
# 209 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 321 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
typedef int wchar_t;
# 32 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 40 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
# 56 "/usr/include/stdlib.h" 2 3 4
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) ;
extern double atof (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) ;
extern long int a64l (const char *__s)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
typedef int __sig_atomic_t;
# 30 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
# 59 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
# 97 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __pid_t pid_t;
typedef __id_t id_t;
typedef __ssize_t ssize_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
typedef __clock_t clock_t;
# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
typedef __clockid_t clockid_t;
# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
typedef __time_t time_t;
# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
typedef __timer_t timer_t;
# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 144 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 24 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
# 25 "/usr/include/endian.h" 2 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{
return __builtin_bswap16 (__bsx);
}
static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{
return __builtin_bswap32 (__bsx);
}
# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
typedef __sigset_t sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
typedef __suseconds_t suseconds_t;
typedef long int __fd_mask;
# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
__fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
# 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
# 227 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
# 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
# 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
int __cur_writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
# 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
typedef unsigned long int pthread_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 395 "/usr/include/stdlib.h" 2 3 4
extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern long int nrand48 (unsigned short int __xsubi[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern long int jrand48 (unsigned short int __xsubi[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern void *calloc (size_t __nmemb, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
extern void *realloc (void *__ptr, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__))
__attribute__ ((__alloc_size__ (2, 3)));
extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
# 569 "/usr/include/stdlib.h" 2 3 4
extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 647 "/usr/include/stdlib.h" 3 4
extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
# 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 688 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 710 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
# 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) ;
typedef int (*__compar_fn_t) (const void *, const void *);
# 820 "/usr/include/stdlib.h" 3 4
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
# 840 "/usr/include/stdlib.h" 3 4
extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
# 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
__attribute__ ((__nothrow__ , __leaf__));
extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 957 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
# 1003 "/usr/include/stdlib.h" 3 4
extern int getloadavg (double __loadavg[], int __nelem)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 1013 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 1014 "/usr/include/stdlib.h" 2 3 4
# 1023 "/usr/include/stdlib.h" 3 4
# 18 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 66 "/usr/include/assert.h" 3 4
extern void __assert_fail (const char *__assertion, const char *__file,
unsigned int __line, const char *__function)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void __assert_perror_fail (int __errnum, const char *__file,
unsigned int __line, const char *__function)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void __assert (const char *__assertion, const char *__file, int __line)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 37 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
typedef struct _G_fpos_t
{
__off_t __pos;
__mbstate_t __state;
} __fpos_t;
# 40 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
__off64_t __pos;
__mbstate_t __state;
} __fpos64_t;
# 41 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE __FILE;
# 42 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
# 43 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;
typedef void _IO_lock_t;
struct _IO_FILE
{
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
# 44 "/usr/include/stdio.h" 2 3 4
# 52 "/usr/include/stdio.h" 3 4
typedef __gnuc_va_list va_list;
# 84 "/usr/include/stdio.h" 3 4
typedef __fpos_t fpos_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 134 "/usr/include/stdio.h" 2 3 4
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) __attribute__ ((__nothrow__ , __leaf__));
# 173 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) ;
# 187 "/usr/include/stdio.h" 3 4
extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
# 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 246 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
# 279 "/usr/include/stdio.h" 3 4
extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;
# 292 "/usr/include/stdio.h" 3 4
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
__attribute__ ((__nothrow__ , __leaf__)) ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) __attribute__ ((__nothrow__ , __leaf__));
extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) __attribute__ ((__nothrow__));
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) __attribute__ ((__nothrow__));
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
# 379 "/usr/include/stdio.h" 3 4
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
;
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
;
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))
;
# 432 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
__attribute__ ((__format__ (__scanf__, 2, 0)));
# 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
# 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 603 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
# 673 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
# 707 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
# 731 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 757 "/usr/include/stdio.h" 3 4
extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void perror (const char *__s);
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
# 782 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
# 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
# 840 "/usr/include/stdio.h" 3 4
extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
# 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 873 "/usr/include/stdio.h" 3 4
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
void __DSVERIFIER_assume(_Bool expression){
__CPROVER_assume(expression);
}
void __DSVERIFIER_assert(_Bool expression){
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
((void) sizeof ((
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ; else __assert_fail (
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
"expression"
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h", 36, __extension__ __PRETTY_FUNCTION__); }))
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
;
}
void __DSVERIFIER_assert_msg(_Bool expression, char * msg){
printf("%s", msg);
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
((void) sizeof ((
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ; else __assert_fail (
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
"expression"
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h", 41, __extension__ __PRETTY_FUNCTION__); }))
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
;
}
# 22 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 1
# 27 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;
typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 87 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;
typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 10 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 2 3 4
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 34 "/usr/include/inttypes.h" 3 4
typedef int __gwchar_t;
# 266 "/usr/include/inttypes.h" 3 4
typedef struct
{
long int quot;
long int rem;
} imaxdiv_t;
# 290 "/usr/include/inttypes.h" 3 4
extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern intmax_t strtoimax (const char *__restrict __nptr,
char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
extern uintmax_t strtoumax (const char *__restrict __nptr,
char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
__gwchar_t **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__));
extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
__gwchar_t ** __restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__));
# 432 "/usr/include/inttypes.h" 3 4
# 29 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 2
# 30 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
extern implementation impl;
typedef int64_t fxp_t;
fxp_t _fxp_one;
fxp_t _fxp_half;
fxp_t _fxp_minus_one;
fxp_t _fxp_min;
fxp_t _fxp_max;
double _dbl_max;
double _dbl_min;
fxp_t _fxp_fmask;
fxp_t _fxp_imask;
static const double scale_factor[31] = { 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0,
128.0, 256.0, 512.0, 1024.0, 2048.0, 4096.0, 8192.0, 16384.0, 32768.0,
65536.0, 131072.0, 262144.0, 524288.0, 1048576.0, 2097152.0, 4194304.0,
8388608.0, 16777216.0, 33554432.0, 67108864.0, 134217728.0,
268435456.0, 536870912.0, 1073741824.0 };
static const double scale_factor_inv[31] = { 1.0, 0.5, 0.25, 0.125, 0.0625,
0.03125, 0.015625, 0.0078125, 0.00390625, 0.001953125, 0.0009765625,
0.00048828125, 0.000244140625, 0.0001220703125, 0.00006103515625,
0.000030517578125, 0.000015258789063, 0.000007629394531,
0.000003814697266, 0.000001907348633, 0.000000953674316,
0.000000476837158, 0.000000238418579, 0.000000119209290,
0.000000059604645, 0.000000029802322, 0.000000014901161,
0.000000007450581, 0.000000003725290, 0.000000001862645,
0.000000000931323 };
static const float rand_uni[10000] = { -0.486240329978498f, -0.0886462298529236f, -0.140307596103306f, 0.301096597450952f, 0.0993171079928659f, 0.971751769763271f, 0.985173975730828f, 0.555993645184930f, 0.582088652691427f, -0.153377496651175f, 0.383610009058905f, -0.335724126391271f, 0.978768141636516f, -0.276250018648572f, 0.390075705739569f, -0.179022404038782f, 0.690083827115783f, -0.872530132490992f, -0.970585763293203f, -0.581476053441704f, -0.532614615674888f, -0.239699306693312f, -0.678183014035494f, 0.349502640932782f, -0.210469890686263f, 0.841262085391842f, -0.473585465151401f, 0.659383565443701f, -0.651160036945754f, -0.961043527561335f, -0.0814927639199137f, 0.621303110569702f, -0.784529166943541f, 0.0238464770757800f, 0.392694728594110f, 0.776848735202001f, 0.0870059709310509f, 0.880563655271790f, 0.883457036977564f, -0.249235082877382f, -0.691040749216870f, 0.578731120064320f, -0.973932858000832f, -0.117699105431720f, -0.723831748151088f, -0.483149657477524f, -0.821277691383664f, -0.459725618100875f, 0.148175952221864f, 0.444306875534854f, -0.325610376336498f, 0.544142311404910f, -0.165319440455435f, 0.136706800705517f, 0.543312481350682f, 0.467210959764607f, -0.349266618228534f, -0.660110730565862f, 0.910332331495431f, 0.961049802789367f, -0.786168905164629f, 0.305648402726554f, 0.510815258508885f, 0.0950733260984060f, 0.173750645487898f, 0.144488668408672f, 0.0190031984466126f, -0.299194577636724f, 0.302411647442273f, -0.730462524226212f, 0.688646006554796f, 0.134948379722118f, 0.533716723458894f, -0.00226300779660438f, -0.561340777806718f, 0.450396313744017f, -0.569445876566955f, 0.954155246557698f, -0.255403882430676f, -0.759820984120828f, -0.855279790307514f, -0.147352581758156f, -0.302269055643746f, -0.642038024364086f, -0.367405981107491f, 0.491844011712164f, -0.542191710121194f, -0.938294043323732f, 0.683979894338020f, 0.294728290855287f, 0.00662691839443919f, -0.931040350582855f, 0.152356209974418f, 0.678620860551457f, -0.534989269238408f, 0.932096367913226f, -0.0361062818028513f, -0.847189697149530f, -0.975903030160255f, 0.623293205784014f, -0.661289688031659f, 0.724486055119603f, 0.307504095172835f, 0.00739266163731767f, -0.393681596442097f, 0.0313739422974388f, 0.0768157689673350f, -0.652063346886817f, 0.864188030044388f, -0.588932092781034f, 0.496015896758580f, -0.872858269231211f, 0.978780599551039f, -0.504887732991147f, -0.462378791937628f, 0.0141726829338038f, 0.769610007653591f, 0.945233033188923f, -0.782235375325016f, -0.832206533738799f, 0.745634368088673f, -0.696969510157151f, -0.0674631869948374f, -0.123186450806584f, -0.359158959141949f, -0.393882649464391f, 0.441371446689899f, -0.829394270569736f, -0.301502651277431f, -0.996215501187289f, 0.934634037393066f, -0.282431114746289f, -0.927550795619590f, -0.437037530043415f, -0.360426812995980f, 0.949549724575862f, 0.502784616197919f, 0.800771681422909f, -0.511398929004089f, 0.309288504642554f, -0.207261227890933f, 0.930587995125773f, -0.777029876696670f, -0.489329175755640f, -0.134595132329858f, 0.285771358983518f, 0.182331373854387f, -0.544110494560697f, 0.278439882883985f, -0.556325158102182f, 0.579043806545889f, 0.134648133801916f, 0.602850725479294f, -0.151663563868883f, 0.180694361855878f, -0.651591295315595f, 0.281129147768056f, -0.580047306475484f, 0.687883075491433f, 0.279398670804288f, -0.853428128249503f, -0.532609367372680f, -0.821156786377917f, -0.181273229058573f, -0.983898569846882f, -0.0964374318311501f, 0.880923372124250f, 0.102643371392389f, 0.893615387135596f, -0.259276649383649f, 0.699287743639363f, 0.402940604635828f, -0.110721596226581f, 0.0846246472582877f, 0.820733021865405f, 0.795578903285308f, -0.495144122011537f, 0.273150029257472f, -0.268249949701437f, 0.231982193341980f, 0.694211299124074f, 0.859950868718233f, 0.959483382623794f, -0.422972626833543f, -0.109621798738360f, 0.433094703426531f, 0.694025903378851f, 0.374478987547435f, -0.293668545105608f, -0.396213864190828f, -0.0632095887099047f, -0.0285139536748673f, 0.831794132192390f, -0.548543088139238f, 0.791869201724680f, 0.325211484201845f, 0.155274810721772f, -0.112383643064821f, -0.674403070297721f, 0.642801068229810f, -0.615712048835242f, -0.322576771285566f, -0.409336818836595f, 0.548069973193770f, -0.386353709407947f, -0.0741664985357784f, 0.619639599324983f, -0.815703814931314f, 0.965550307223862f, 0.623407852683828f, -0.789634372832984f, 0.736750050047572f, -0.0269443926793700f, 0.00545706093721488f, -0.315712479832091f, -0.890110021644720f, -0.869390443173846f, -0.381538869981866f, -0.109498998005949f, 0.131433952330613f, -0.233452413139316f, 0.660289822785465f, 0.543381186340023f, -0.384712418750451f, -0.913477554164890f, 0.767102957655267f, -0.115129944521936f, -0.741161985822647f, -0.0604180020782450f, -0.819131535144059f, -0.409539679760029f, 0.574419252943637f, -0.0440704617157433f, 0.933173744590532f, 0.261360623390448f, -0.880290575543046f, 0.329806293425492f, 0.548915621667952f, 0.635187167795234f, -0.611034070318967f, 0.458196727901944f, 0.397377226781023f, 0.711941361933987f, 0.782147744383368f, -0.00300685339552631f, 0.384687233450957f, 0.810102466029521f, 0.452919847968424f, -0.183164257016897f, -0.755603185485427f, -0.604334477365858f, -0.786222413488860f, -0.434887500763099f, -0.678845635625581f, -0.381200370488331f, -0.582350534916068f, -0.0444427346996734f, 0.116237247526397f, -0.364680921206275f, -0.829395404347498f, -0.258574590032613f, -0.910082114298859f, 0.501356900925997f, 0.0295361922006900f, -0.471786618165219f, 0.536352925101547f, -0.316120662284464f, -0.168902841718737f, 0.970850119987976f, -0.813818666854395f, -0.0861183123848732f, 0.866784827877161f, 0.535966478165739f, -0.806958669103425f, -0.627307415616045f, -0.686618354673079f, 0.0239165685193152f, 0.525427699287402f, 0.834079334357391f, -0.527333932295852f, 0.130970034225907f, -0.790218350377199f, 0.399338640441987f, 0.133591886379939f, -0.181354311053254f, 0.420121912637914f, -0.625002202728601f, -0.293296669160307f, 0.0113819513424340f, -0.882382002895096f, -0.883750159690028f, 0.441583656876336f, -0.439054135454480f, 0.873049498123622f, 0.660844523562817f, 0.0104240153103699f, 0.611420248331623f, -0.235926309432748f, 0.207317724918460f, 0.884691834560657f, 0.128302402592277f, -0.283754448219060f, 0.237649901255856f, 0.610200763264703f, -0.625035441247926f, -0.964609592118695f, -0.323146562743113f, 0.961529402270719f, -0.793576233735450f, -0.843916713821003f, 0.314105102728384f, -0.204535560653294f, 0.753318789613803f, 0.160678386635821f, -0.647065919861379f, -0.202789866826280f, 0.648108234268198f, -0.261292621025902f, 0.156681828732770f, 0.405377351820066f, 0.228465381497500f, 0.972348516671163f, 0.288346037401522f, -0.0799068604307178f, 0.916939290109587f, -0.279220972402209f, -0.203447523864279f, -0.533640046855273f, 0.543561961674653f, 0.880711097286889f, -0.549683064687774f, 0.0130107219236368f, -0.554838164576024f, -0.379442406201385f, -0.00500104610043062f, 0.409530122826868f, -0.580423080726061f, 0.824555731914455f, -0.254134502966922f, 0.655609706875230f, 0.629093866184236f, -0.690033250889974f, -0.652346551677826f, 0.169820593515952f, 0.922459552232043f, 0.351812083539940f, 0.876342426613034f, -0.513486005850680f, -0.626382302780497f, -0.734690688861027f, 0.245594886018314f, -0.875740935105191f, -0.388580462918006f, 0.0127041754106421f, -0.0330962560066819f, -0.425003146474193f, 0.0281641353527495f, 0.261441358666622f, 0.949781327102773f, 0.919646340564270f, 0.504503377003781f, 0.0817071051871894f, 0.319968570729658f, 0.229065413577318f, -0.0512608414259468f, -0.0740848540944785f, -0.0974457038582892f, 0.532775710298005f, -0.492913317622840f, 0.492871078783642f, -0.289562388384881f, 0.229149968879593f, 0.697586903105899f, 0.900855243684925f, 0.969700445892771f, -0.618162745501349f, -0.533241431614228f, -0.937955908995453f, 0.886669636523452f, 0.498748076602594f, 0.974106016180519f, -0.199411214757595f, 0.725270392729083f, -0.0279932700005097f, -0.889385821767448f, -0.452211028905500f, -0.487216271217731f, -0.577105004471439f, 0.777405674160298f, 0.390121144627092f, -0.595062864225581f, -0.844712795815575f, -0.894819796738658f, 0.0556635002662202f, 0.200767245646242f, 0.481227096067452f, -0.0854169009474664f, 0.524532943920022f, -0.880292014538901f, -0.127923833629789f, -0.929275628802356f, 0.233276357260949f, -0.776272194935070f, 0.953325886548014f, -0.884399921036004f, -0.504227548828417f, -0.546526107689276f, 0.852622421886067f, 0.947722695551154f, -0.668635552599119f, 0.768739709906834f, 0.830755876586102f, -0.720579994994166f, 0.761613532216491f, 0.340510345777526f, 0.335046764810816f, 0.490102926886310f, -0.568989013749608f, -0.296018470377601f, 0.979838924243657f, 0.624231653632879f, 0.553904401851075f, -0.355359451941014f, 0.267623165480721f, 0.985914275634075f, -0.741887849211797f, 0.560479100333108f, -0.602590162007993f, -0.874870765077352f, -0.0306218773384892f, 0.963145768131215f, 0.544824028787036f, -0.133990816021791f, 0.0679964588712787f, -0.156401335214901f, -0.0802554171832672f, 0.856386218492912f, 0.143013580527942f, 0.403921859374840f, -0.179029058044097f, 0.770723540077919f, -0.183650969350452f, -0.340718434629824f, 0.217166124261387f, -0.171159949445977f, 0.127493767348173f, -0.649649349141405f, -0.0986978180993434f, 0.301786606637125f, 0.942172200207855f, 0.0323236270151113f, -0.579853744301016f, -0.964413060851558f, 0.917535782777861f, 0.442144649483292f, -0.684960854610878f, -0.418908715566712f, 0.617844265088789f, 0.897145578082386f, 0.235463167636481f, 0.0166312355859484f, 0.948331447443040f, -0.961085640409103f, -0.0386086809179784f, -0.949138997977665f, 0.738211385880427f, 0.613757309091864f, -0.606937832993426f, 0.825253298062192f, 0.932609757667859f, -0.169023247637751f, -0.411237965787391f, 0.550590803600950f, -0.0561729280137304f, -0.559663108323671f, -0.718592671237337f, 0.885889621415361f, -0.364207826334344f, -0.839614660327507f, 0.265502694339344f, 0.394329270534417f, -0.270184577808578f, -0.865353487778069f, -0.528848754655393f, -0.179961524561963f, 0.571721065613544f, -0.774363220756696f, 0.251123315200792f, -0.217722762975159f, 0.0901359910328954f, -0.329445470667965f, 0.366410356722994f, -0.777512662632715f, 0.654844363477267f, -0.882409911562713f, -0.613612530795153f, -0.926517759636550f, 0.111572665207194f, 0.0729846382226607f, 0.789912813274098,
0.784452109264882f, -0.949766989295825f, 0.318378232675431f, 0.732077593075111f, 0.786829143208386f, -0.134682559823644f, 0.733164743374965f, 0.978410877665941f, 0.992008491438409f, -0.319064303035495f, 0.958430683602029f, 0.514518212363212f, 0.101876224417090f, 0.642655735778237f, -0.170746516901312f, 0.252352078365623f, -0.761327278132210f, 0.724119717129199f, 0.889374997869224f, -0.785987369200692f, -0.594670344572584f, 0.805192297495935f, -0.990523259595814f, 0.483998949026664f, 0.747350619254878f, -0.824845161088780f, 0.543009506581798f, -0.208778528683094f, -0.314149951901368f, 0.943576771177672f, -0.102633559170861f, -0.947663019606703f, -0.557033071578968f, 0.419150797499848f, 0.251214274356296f, 0.565717763755325f, 0.126676667925064f, -0.0213369479214840f, 0.342212953426240f, -0.288015274572288f, 0.121313363277304f, 0.452832374494206f, 0.545420403121955f, -0.616024063400938f, -0.0320352392995826f, -0.400581850938279f, 0.0642433474653812f, -0.673966224453150f, 0.951962939602010f, -0.241906012952983f, 0.0322060960995099f, -0.449185553826233f, -0.709575766146540f, 0.0283340814242898f, 0.234237103593580f, -0.285526615094797f, -0.793192668153991f, -0.437130485497140f, -0.956132143306919f, 0.601158367473616f, 0.238689691528783f, 0.173709925321432f, 0.437983847738997f, 0.397380645202102f, 0.432093344086237f, -0.0338869881121104f, -0.966303269542493f, 0.875351570183604f, -0.0584554089652962f, 0.294207497692552f, 0.200323088145182f, 0.826642387259759f, 0.284806025494260f, -0.00660991970522007f, 0.682493772727303f, -0.151980775670668f, 0.0470705546940635f, -0.236378427235531f, -0.844780853112247f, 0.134166207564174f, -0.586842667384924f, 0.0711866699414370f, 0.311698821368897f, -0.361229767252053f, 0.750924311039976f, 0.0764323989785694f, 0.898463708247144f, 0.398232179543916f, -0.515644913011399f, -0.189067061520362f, -0.567430593060929f, -0.641924269747436f, -0.0960378699625619f, -0.792054031692334f, 0.803891878854351f, -0.233518627249889f, -0.892523453249154f, 0.707550017996875f, -0.782288435525895f, -0.156166443894764f, -0.543737876329167f, 0.565637809380957f, -0.757689989749326f, -0.612543942167974f, -0.766327195073259f, 0.587626843767440f, -0.280769385897397f, -0.457487372245825f, 0.0862799426622438f, -0.616867284053547f, 0.121778903484808f, -0.451988651573766f, -0.618146087265495f, -0.285868777534354f, 0.108999472244014f, -0.620755183347358f, -0.268563184810196f, -0.721678169615489f, -0.146060198874409f, -0.661506858070617f, 0.901707853998409f, 0.222488776533930f, 0.679599685031679f, 0.974760448601209f, 0.535485953830496f, -0.562345697123585f, 0.369219363331071f, -0.0282801684694869f, -0.0734880727832297f, 0.733216287314358f, -0.514352095765627f, -0.850813063545195f, 0.642458447327163f, 0.118661521915783f, -0.907015526838341f, 0.789277766886329f, -0.719864125961721f, 0.274329068829509f, 0.830124687647056f, 0.719352367261587f, -0.821767317737384f, -0.840153496829227f, 0.650796781936517f, 0.381065387870166f, 0.341870564586224f, -0.00174423702285131f, -0.216348832349188f, 0.678010477635713f, -0.748695103596683f, -0.819659325555269f, 0.620922373008647f, 0.471659250504894f, 0.417848292160984f, -0.990577315445198f, -0.509842007818877f, 0.705761459091187f, 0.723072116074702f, -0.606476484252158f, -0.871593699865195f, -0.662059658667501f, -0.207267692377271f, -0.274706370444270f, 0.317047325063391f, 0.329780707114887f, -0.966325651181920f, -0.666131009799803f, 0.118609206658210f, 0.232960448350140f, -0.139134616436389f, -0.936412642687343f, -0.554985387484625f, -0.609914445911143f, -0.371023087262482f, -0.461044793696911f, 0.0277553171809701f, -0.241589304772568f, -0.990769995548029f, 0.114245771600061f, -0.924483328431436f, 0.237901450206836f, -0.615461633242452f, 0.201497106528945f, -0.599898812620374f, 0.982389910778332f, 0.125701388874024f, -0.892749115498369f, 0.513592673006880f, 0.229316745749793f, 0.422997355912517f, 0.150920221978738f, 0.447743452078441f, 0.366767059168664f, -0.605741985891581f, 0.274905013892524f, -0.861378867171578f, -0.731508622159258f, 0.171187057183023f, 0.250833501952177f, -0.609814068526718f, -0.639397597618127f, -0.712497631420166f, -0.539831932321101f, -0.962361328901384f, 0.799060001548069f, 0.618582550608426f, -0.603865594092701f, -0.750840334759883f, -0.432368099184739f, -0.581021252111797f, 0.134711953024238f, 0.331863889421602f, -0.172907726656169f, -0.435358718118896f, -0.689326993725649f, 0.415840315809038f, -0.333576262820904f, 0.279343777676723f, -0.0393098862927832f, 0.00852090010085194f, -0.853705195692250f, 0.526006696633762f, -0.478653377052437f, -0.584840261391485f, 0.679261003071696f, 0.0367484618219474f, -0.616340335633997f, -0.912843423145420f, -0.221248732289686f, -0.477921890680232f, -0.127369625511666f, 0.865190146410824f, 0.817916456258544f, 0.445973590438029f, -0.621435280140991f, -0.584264056171687f, 0.718712277931876f, -0.337835985469843f, 0.00569064504159345f, -0.546546294846311f, 0.101653624648361f, -0.795498735829364f, -0.249043531299132f, -0.112839395737321f, -0.350305425122331f, -0.910866368205041f, 0.345503177966105f, -0.549306515692918f, 0.711774722622726f, 0.283368922297518f, 0.0401988801224620f, 0.269228967910704f, 0.408165826013612f, -0.306571373865680f, 0.937429053394878f, 0.992154362395068f, 0.679431847774404f, 0.660561953302554f, 0.903254489326130f, -0.939312119455540f, -0.211194531611303f, 0.401554296146757f, -0.0373187111351370f, -0.209143098987164f, -0.483955198209448f, -0.860858509666882f, 0.847006442151417f, 0.287950263267018f, 0.408253171937961f, -0.720812569529331f, 0.623305171273525f, 0.543495760078790f, -0.364025150023839f, -0.893335585394842f, -0.757545415624741f, -0.525417020183382f, -0.985814550271000f, -0.571551008375522f, 0.930716377819686f, -0.272863385293023f, 0.982334910750391f, 0.297868844366342f, 0.922428080219044f, 0.917194773824871f, 0.846964493212884f, 0.0641834146212110f, 0.279768184306094f, 0.591959126556958f, 0.355630573995206f, 0.839818707895839f, 0.219674727597944f, -0.174518904670883f, 0.708669864813752f, -0.224562931791369f, 0.677232454840133f, -0.904826802486527f, -0.627559033402838f, 0.263680517444611f, 0.121902314059156f, -0.704881790282995f, 0.242825089229032f, -0.309373554231866f, -0.479824461459095f, -0.720536286348018f, -0.460418173937526f, 0.774174710513849f, 0.452001499049874f, -0.316992092650694f, 0.153064869645527f, -0.209558599627989f, 0.685508351648252f, -0.508615450383790f, 0.598109567185095f, 0.391177475074196f, 0.964444988755186f, 0.336277292954506f, -0.0367817159101076f, -0.668752640081528f, 0.169621732437504f, -0.440925495294537f, 0.352359477392856f, 0.300517139597811f, 0.464188724292127f, 0.342732840629593f, -0.772028689116952f, 0.523987886508557f, 0.920723209445309f, 0.325634245623597f, 0.999728757965472f, -0.108202444213629f, -0.703463061246440f, -0.764321104361266f, 0.153478091277821f, 0.400776808520781f, 0.0362608595686520f, 0.602660289034871f, -0.00396673312072204f, 0.296881393918662f, 0.563978362789779f, 0.849699999703012f, 0.699481370949461f, -0.517318771826836f, 0.488696839410786f, -0.863267084031406f, 0.0353144039838211f, 0.346060763700543f, 0.964270355001567f, 0.354899825242107f, 0.806313705199543f, 0.675286452110240f, 0.0873918818789949f, -0.595319879813140f, 0.768247284622921f, 0.424433552458434f, -0.308023836359512f, 0.802163480612923f, -0.348151008192881f, -0.889061130591849f, -0.593277042719599f, -0.669426232128590f, 0.758542808803890f, 0.515943031751579f, -0.359688459650311f, 0.568175936707751f, 0.741304023515212f, 0.260283681057109f, 0.957668849401749f, -0.665096753421305f, 0.769229664798946f, -0.0871019488695104f, -0.362662093346394f, -0.411439775739547f, 0.700347493632751f, 0.593221225653487f, 0.712841887456470f, 0.413663813878195f, -0.868002281057698f, -0.704419248587642f, 0.497097875881516f, -0.00234623694758684f, 0.690202361192435f, -0.850266199595343f, 0.315244026446767f, 0.709124123964306f, 0.438047076925768f, 0.798239617424585f, 0.330853072912708f, 0.581059745965701f, 0.449755612947191f, -0.462738032798907f, 0.607731925865227f, 0.0898348455002427f, -0.762827831849901f, 0.895598896497952f, -0.752254194382105f, -0.0916186048978613f, -0.906243795607547f, 0.229263971313788f, 0.401148319671400f, -0.699999035942240f, 0.949897297168705f, 0.442965954562621f, -0.836602533575693f, 0.960460356865877f, -0.588638958628591f, -0.826876652501322f, 0.358883606332526f, 0.963216314331105f, -0.932992215875777f, -0.790078242370583f, 0.402080896170037f, -0.0768348888017805f, 0.728030138891631f, -0.259252300581205f, -0.239039520569651f, -0.0343187629251645f, -0.500656851699075f, 0.213230170834557f, -0.806162554023268f, -0.346741158269134f, 0.593197383681288f, -0.874207905790597f, 0.396896283395687f, -0.899758892162590f, 0.645625478431829f, 0.724064646901595f, 0.505831437483414f, -0.592809028527107f, 0.191058921738261f, 0.329699861086760f, 0.637747614705911f, 0.228492417185859f, 0.350565075483143f, 0.495645634191973f, 0.0378873636406241f, -0.558682871042752f, -0.0463515226573312f, -0.699882077624744f, -0.727701564368345f, -0.185876979038391f, 0.969357227041006f, -0.0396554302826258f, 0.994123321254905f, -0.103700411263859f, -0.122414150286554f, -0.952967253268750f, -0.310113557790019f, 0.389885130024049f, 0.698109781822753f, -0.566884614177461f, -0.807731715569885f, 0.295459359747620f, 0.353911434620388f, -0.0365360121873806f, -0.433710246410727f, -0.112374658849445f, -0.710362620548396f, -0.750188568899340f, -0.421921409270312f, -0.0946825033112555f, -0.207114343395422f, -0.712346704375406f, -0.762905208265238f, 0.668705185793373f, 0.874811836887758f, 0.734155331047614f, 0.0717699959166771f, -0.649642655211151f, 0.710177200600726f, -0.790892796708330f, -0.609051316139055f, 0.158155751049403f, 0.273837117392194f, 0.101461674737037f, -0.341978434311156f, 0.358741707078855f, 0.415990974906378f, 0.760270133083538f, 0.164383469371383f, 0.559847879549422f, 0.209104118141764f, -0.265721227148806f, 0.165407943936551f, 0.611035396421350f, -0.626230501208063f, -0.116714293310250f, -0.696697517286888f, 0.0545261414014888f, 0.440139257477096f, 0.202311640602444f, -0.369311356303593f, 0.901884565342531f, 0.256026357399272f, -0.673699547202088f, 0.108550667621349f, -0.961092940829968f, -0.254802826645023f, 0.553897912330318f, 0.110751075533042f, -0.587445414043347f, 0.786722059164009,
0.182042556749386f, 0.398835909383655f, 0.431324012457533f, 0.587021142157922f, -0.644072183989352f, 0.187430090296218f, 0.516741122998546f, -0.275250933267487f, -0.933673413249875f, -0.767709448823879f, 0.00345814033609182f, -0.585884382069128f, 0.463549040471035f, 0.666537178805293f, -0.393605927315148f, -0.260156573858491f, -0.298799291489529f, -0.246398415746503f, 0.970774181159203f, -0.485708631308223f, -0.456571313115555f, -0.264210030877189f, -0.442583504871362f, 0.0585567697312368f, 0.955769232723545f, 0.651822742221258f, 0.667605490119116f, -0.178564750516287f, 0.744464599638885f, -0.0962758978504710f, -0.538627454923738f, -0.844634654117462f, 0.109151162611125f, -0.862255427201396f, -0.478955305843323f, 0.645965860697344f, 0.345569271369828f, 0.930605011671297f, -0.195523686135506f, 0.927940875293964f, 0.0529927450986318f, -0.537243314646225f, 0.0815400161801159f, -0.528889663721737f, -0.0803965087898244f, 0.722188412643543f, -0.115173100460772f, 0.391581967064874f, 0.609102624309301f, -0.726409099849031f, -0.924071529212721f, -0.424370859730340f, -0.932399086010354f, -0.679903916227243f, 0.398593637781810f, -0.395942610474455f, 0.911017267923838f, 0.830660098751580f, 0.485689056693942f, -0.634874052918746f, 0.558342102044082f, 0.153345477027740f, -0.418797532948752f, -0.962412446404476f, 0.499334884055701f, 0.772755578982235f, 0.486905718186221f, -0.680415982465391f, -0.983589696155766f, 0.0802707365440833f, -0.108186099494932f, 0.272227706025405f, 0.651170828846750f, -0.804713753056757f, 0.778076504684911f, 0.869094633196957f, -0.213764089899489f, -0.289485853647921f, -0.248376169846176f, -0.273907386272412f, -0.272735585352615f, -0.851779302143109f, 0.777935500545070f, 0.610526499062369f, -0.825926925832998f, -0.00122853287679647f, -0.250920102747366f, -0.0333860483260329f, 0.562878228390427f, 0.685359102189134f, 0.909722844787783f, -0.686791591637469f, 0.700018932525581f, -0.975597558640926f, 0.111273045778084f, 0.0313167229308478f, -0.185767397251192f, -0.587922465203314f, -0.569364866257444f, -0.433710470415537f, 0.744709870476354f, 0.812284989338678f, -0.835936210940005f, 0.409175739115410f, 0.364745324015946f, -0.526496413512530f, -0.0949041293633228f, -0.710914623019602f, -0.199035360261516f, 0.249903358254580f, 0.799197892184193f, -0.974131439735146f, -0.962913228246770f, -0.0584067290846062f, 0.0678080882131218f, 0.619989552612058f, 0.600692636138022f, -0.325324145536173f, 0.00758797937831957f, -0.133193608214778f, -0.312408219890363f, -0.0752971209304969f, 0.764751638735404f, 0.207290375565515f, -0.965680055629168f, 0.526346325957267f, 0.365879948128040f, -0.899713698342006f, 0.300806506284083f, 0.282047017067903f, -0.464418831301796f, -0.793644005532544f, -0.338781149582286f, 0.627059412508279f, -0.624056896643864f, -0.503708045945915f, 0.339203903916317f, -0.920899287490514f, -0.753331218450680f, -0.561190137775443f, 0.216431106588929f, -0.191601189620092f, 0.613179188721972f, 0.121381145781083f, -0.477139741951367f, 0.606347924649253f, 0.972409497819530f, 0.00419185232258634f, 0.786976564006247f, 0.716984027373809f, -0.577296880358192f, 0.336508364109364f, -0.837637061538727f, -0.706860533591818f, 0.655351330285695f, -0.799458036429467f, 0.804951754011505f, 0.405471126911303f, 0.485125485165526f, 0.0354103156047567f, 0.774748847269929f, 0.396581375869036f, 0.420464745452802f, -0.544531741676535f, -0.779088258182329f, -0.129534599431145f, 0.228882319223921f, 0.669504936432777f, -0.158954596495398f, -0.171927546721685f, 0.675107968066445f, -0.201470217862098f, -0.185894687796509f, 0.244174688826684f, 0.310288210346694f, -0.0674603586289346f, 0.138103839181198f, 0.269292861340219f, 0.121469813317732f, 0.168629748875041f, 0.581112629873687f, 0.499508530746584f, -0.741772433024897f, -0.311060071316150f, -0.263697352439521f, 0.180487383518774f, -0.800786488742242f, -0.949903966987338f, 0.134975524166410f, 0.213364683193138f, -0.684441197699222f, -0.254697287796379f, -0.260521050814253f, -0.757605554637199f, -0.134324873215927f, -0.699675596579060f, 0.136000646890289f, 0.355272520354523f, -0.712620797948690f, -0.729995036352282f, 0.323100037780915f, -0.718364487938777f, 0.807709622188084f, 0.289336059472722f, -0.558738026311145f, -0.591811756545896f, -0.894952978489225f, -0.354996929975694f, -0.142213103464027f, -0.651950180085633f, 0.182694586161578f, -0.193492058009904f, -0.540079537334588f, -0.300927433533712f, 0.119585035086049f, 0.895807833710939f, -0.413843745301811f, -0.209041322713332f, 0.808094803654324f, 0.0792829008489782f, 0.314806980452270f, 0.502591873175427f, -0.0474189387090473f, -0.407131047818007f, 0.797117088440354f, 0.902395237588928f, -0.783327055804990f, -0.591709085168646f, 0.628191184754911f, -0.454649879692076f, -0.588819444306752f, 0.250889716959370f, -0.582306627010669f, -0.145495766591841f, -0.634137346823528f, 0.667934845545285f, 0.873756470938530f, 0.425969845715827f, -0.779543910541245f, -0.265210219994391f, 0.781530681845886f, 0.304461599274577f, 0.211087853085430f, 0.281022407596766f, 0.0701313665097776f, 0.342337400087349f, -0.0618264046031387f, 0.177147380816613f, 0.751693209867024f, -0.279073264607508f, 0.740459307255654f, -0.352163564204507f, -0.726238685136937f, -0.565819729501492f, -0.779416133306559f, -0.783925450697670f, 0.542612245021260f, -0.810510148278478f, -0.693707081804938f, 0.918862988543900f, -0.368717045271828f, 0.0654919784331340f, -0.438514219239944f, -0.923935138084824f, 0.913316783811291f, -0.961646539574340f, 0.734888382653474f, -0.464102713631586f, -0.896154678819649f, 0.349856565392685f, 0.646610836502422f, -0.104378701809970f, 0.347319102015858f, -0.263947819351090f, 0.343722186197186f, 0.825747554146473f, 0.0661865525544676f, 0.918864908112419f, -0.999160312662909f, -0.904953244747070f, 0.246613032125664f, 0.123426960800262f, -0.294364203503845f, -0.150056966431615f, 0.904179479721301f, 0.517721252782648f, 0.661473373608678f, -0.784276966825964f, -0.984631287069650f, 0.239695484607744f, -0.499150590123099f, 0.00153518224500027f, -0.817955534401114f, 0.221240310713583f, 0.114442325207070f, -0.717650856748245f, -0.722902799253535f, -0.962998380704103f, 0.214092155997873f, -0.226370691123970f, 0.536806140446569f, 0.111745807092858f, 0.657580594136395f, -0.239950592200226f, 0.0981270621736083f, -0.173398466414235f, 0.414811672195735f, 0.147604904291238f, -0.649219724907210f, 0.907797399703411f, -0.496097071857490f, -0.0958082520749422f, -0.700618145301611f, 0.238049932994406f, 0.946616020659334f, 0.143538494511824f, 0.0641076718667677f, 0.377873848622552f, -0.413854028741624f, -0.838831021130186f, 0.0208044297354626f, 0.476712667979210f, 0.850908020233298f, 0.0692454021020814f, 0.841788714865238f, -0.251777041865926f, 0.512215668857165f, 0.827988589806208f, -0.399200428030715f, 0.999219950547600f, -0.00465542086542259f, 0.279790771964531f, -0.683125623289052f, 0.988128867315143f, 0.00697090775456410f, -0.409501680375786f, -0.190812202162744f, -0.154565639467601f, 0.305734586628079f, -0.922825484202279f, -0.0622811516391562f, -0.502492855870975f, 0.358550513844403f, 0.678271216185703f, -0.940222215291861f, 0.568581934651071f, 0.953835466578938f, -0.476569789986603f, 0.0141049472573418f, 0.722262461730185f, -0.128913572076972f, -0.583948340870808f, -0.254358587904773f, -0.390569309413304f, -0.0495119137883056f, -0.486356443935695f, -0.112768011009410f, -0.608763417511343f, -0.145843822867367f, 0.767829603838659f, 0.791239479733126f, 0.0208376062066382f, -0.524291005204912f, -0.200159553848628f, -0.835647719235620f, -0.222774380961612f, 0.0617292533934060f, 0.233433696650208f, -0.543969878951657f, -0.628168009147650f, -0.725602523060817f, -0.273904472034828f, 0.320527317085229f, -0.556961185821848f, 0.261533413201255f, 0.696617398495973f, 0.200506775746016f, -0.395581923906907f, 0.0196423782530712f, -0.0552577396777472f, -0.594078139517501f, -0.816132673139052f, -0.898431571909616f, 0.879105843430143f, 0.949666380003024f, -0.245578843355682f, 0.528960018663897f, 0.201586039072583f, -0.651684706542954f, 0.596063456431086f, -0.659712784781056f, -0.213702651629353f, -0.629790163054887f, -0.0572029778771013f, 0.645291034768991f, -0.453266855343461f, -0.581253959024410f, 0.632682730071992f, 0.991406037765467f, 0.701390336150136f, -0.879037255220971f, -0.304180069776406f, 0.0969095808767941f, -0.465682778651712f, 0.815108046274786f, -0.532850846043973f, 0.950550134670033f, 0.296008118726089f, -0.198390447541329f, 0.159049143352201f, 0.105169964332594f, -0.482506131358523f, 0.493753482281684f, 0.292058685647414f, 0.283730532860951f, 0.00323819209092657f, 0.765838273699203f, -0.0753176377562099f, -0.679824808630431f, 0.548180003463159f, -0.996048798712591f, 0.782768288046545f, 0.396509190560532f, 0.848686742379558f, 0.750049741585178f, 0.730186188655936f, -0.0220701180542726f, -0.487618042364281f, -0.403562199756249f, -0.0693129490117646f, 0.947019452953246f, -0.731947366410442f, 0.198175872470120f, -0.329413252854837f, -0.641319161749268f, 0.186271826190842f, -0.0739989831663739f, -0.334046268448298f, -0.191676071751509f, -0.632573515889708f, -0.999115061914042f, -0.677989795015932f, 0.289828136337821f, 0.696081747094487f, 0.965765319961706f, -0.203649463803737f, -0.195384468978610f, 0.746979659338745f, 0.701651229142588f, -0.498361303522421f, 0.289120104962302f, 0.270493509228559f, -0.132329670835432f, 0.385545665843914f, -0.265371843427444f, 0.306155119003788f, -0.859790373316264f, -0.0198057838521546f, 0.233572324299025f, 0.426354273793125f, -0.510901479579029f, -0.600001464460011f, -0.972316846268671f, 0.531678082677910f, -0.0543913028234813f, -0.860333915321655f, 0.0717414549918496f, -0.992726205437930f, 0.587189647572868f, -0.710120198811545f, -0.712433353767817f, 0.000905613890617163f, 0.323638959833707f, -0.148002344942812f, 0.422217478090035f, -0.512122539396176f, -0.652032513920892f, -0.0749826795945674f, 0.689725543651565f, 0.00708142459169103f, 0.612282380092436f, -0.182868915402510f, -0.478704046524703f, 0.630078231167476f, -0.201694106935605f, 0.471080354222778f, 0.705764111397718f, 0.504296612895499f, -0.245442802115836f, -0.0255433216413170f, 0.244606720514349f, -0.620852691611321f, 0.130333792055452f, -0.0404066268217753f, 0.533698497858480f, 0.569324696850915f, -0.0208385747745345f, -0.344454279574176f, 0.697793551353488f, 0.223740789443046,
0.0819835387259940f, -0.378565059057637f, 0.265230570199009f, -0.654654047270763f, -0.959845479426107f, -0.524706200047066f, -0.320773238900823f, 0.133125806793072f, 0.204919719422386f, 0.781296208272529f, 0.357447172843949f, -0.295741363322007f, -0.531151992759176f, -0.928760461863525f, -0.492737999698919f, 0.185299312597934f, 0.0308933157463984f, 0.0940868629278078f, -0.223134180713975f, -0.728994909644464f, 0.748645378716214f, 0.602424843862873f, 0.939628558971957f, -0.601577015562304f, -0.178714119359324f, 0.812720866753088f, -0.864296642561293f, 0.448439532249340f, 0.423570043689909f, 0.883922405988390f, -0.121889129001415f, -0.0435604321758833f, -0.823641147317994f, -0.775345608718704f, -0.621149628042832f, 0.532395431283659f, -0.803045105215129f, 0.897460124955135f, 0.432615281777583f, -0.0245386640589920f, -0.822321626075771f, -0.992080038736755f, -0.829220327319793f, 0.125841786813822f, 0.277412627470833f, 0.623989234604340f, -0.207977347981346f, -0.666564975567417f, 0.419758053880881f, -0.146809205344117f, 0.702495819380827f, 0.802212477505035f, 0.161529115911938f, 0.987832568197053f, -0.885776673164970f, -0.608518024629661f, -0.126430573784758f, 0.168260422890915f, -0.517060428948049f, -0.766296586196077f, -0.827624510690858f, -0.149091785188351f, -0.643782325842734f, 0.768634567718711f, 0.815278279059715f, -0.648037361329720f, -0.480742843535214f, 0.983809287193308f, -0.701958358623791f, 0.0797427982273327f, 0.903943825454071f, 0.980486658260621f, 0.207436790541324f, -0.536781321571165f, -0.885473392956838f, -0.626744905152131f, 0.279917970592554f, -0.489532633799085f, 0.402084958261836f, -0.566738134593205f, -0.0990017532286025f, 0.458891753618823f, 0.893734110503312f, 0.541822126435773f, -0.856210577956263f, -0.0354679151809227f, -0.868531503535520f, 0.150589222911699f, 0.611651396802303f, 0.524911319413221f, 0.555472734209632f, -0.723626819813614f, -0.162106613127807f, 0.602405197560299f, 0.903198408993777f, 0.329150411562290f, -0.806468536757339f, -0.671787125844359f, -0.707262852044556f, 0.474934689940169f, -0.379636706541612f, 0.404933387269815f, 0.332303761521238f, 0.394233678536033f, -0.0366067593524413f, 0.904405677123363f, -0.356597686978725f, -0.623034135107067f, 0.572040316921149f, 0.799160684670195f, -0.507817199545094f, -0.533380730448667f, -0.884507921224020f, -0.00424735629746076f, 0.647537115339283f, 0.456309536956504f, -0.766102127867730f, -0.625121831714406f, 0.341487890703535f, -0.360549668352997f, -0.229900108098778f, -0.666760418812903f, 0.813282715359911f, 0.115522674116703f, -0.221360306077384f, 0.0297293679340875f, 0.00682810040637105f, 0.0115235719886584f, 0.887989949086462f, 0.792212187398941f, 0.415172771519484f, -0.600202208047434f, 0.949356119962045f, -0.526700730890731f, 0.946712583567682f, -0.392771116330410f, 0.0144823046999243f, -0.649518061223406f, 0.724776068810104f, 0.00920735790862981f, -0.461670796134611f, 0.217703889787716f, 0.846151165623083f, -0.202702970245097f, 0.314177560430781f, -0.761102867343919f, 0.0528399640076420f, -0.986438508940994f, -0.595548022863232f, -0.430067198426456f, 0.150038004203120f, 0.738795383589380f, -0.605707072657181f, -0.597976219376529f, 0.375792542283657f, -0.321042914446039f, 0.902243988712398f, 0.463286578609220f, -0.739643422607773f, 0.210980536147575f, -0.539210294582617f, 0.405318056313257f, -0.876865698043818f, -0.0883135270940518f, 0.0300580586347285f, -0.657955040210154f, 0.159261648552234f, 0.288659459148804f, 0.274488527537659f, 0.646615145281349f, 0.431532024055095f, -0.982045186676854f, -0.777285361097106f, -0.124875006659614f, 0.503004910525253f, 0.824987340852061f, -0.859357943951028f, -0.894837450578304f, 0.744772864540654f, 0.415263521487854f, 0.337833126081168f, -0.612498979721313f, 0.391475686177086f, 0.573982630935632f, -0.391044576636065f, 0.669493459114130f, -0.763807443372196f, -0.898924075896803f, -0.969897663976237f, -0.266947396046322f, 0.198506503481333f, -0.355803387868922f, 0.787375525807664f, 0.655019979695179f, -0.266247398074148f, -0.665577607941915f, 0.0617617780742654f, -0.303207459096743f, 0.807119242186051f, -0.864431193732911f, 0.711808914065391f, 0.267969697417500f, -0.643939259651104f, -0.723685356192067f, 0.887757759160107f, -0.318420101532538f, -0.984559057628900f, -0.123118506428834f, 0.264872379685241f, 0.258477870902406f, -0.727462993670953f, -0.223845786938221f, 0.683462211502638f, -0.989811504909606f, 0.292644294487220f, -0.926087081411227f, -0.801377664261936f, -0.337757621052903f, 0.356167431525877f, 0.974619379699180f, 0.456124311183874f, 0.664192098344107f, -0.910993234571633f, -0.484097468631090f, -0.128534589958108f, -0.770879324529314f, 0.320053414246682f, 0.249818479771296f, 0.0153345543766990f, 0.696352481669035f, -0.397719804512483f, 0.670333638147646f, -0.678192291329959f, 0.190143924397131f, 0.342035884244954f, -0.350791038317704f, 0.0218450632953668f, 0.437133719806156f, 0.659960895652910f, 0.903378806323159f, 0.855089775229062f, 0.946706092624795f, 0.335540975081955f, 0.838337968455111f, -0.102693592034237f, -0.702102376052106f, 0.409624309223486f, -0.654483499569910f, 0.886576641430416f, -0.200573725141884f, -0.461284656727627f, 0.262661770963709f, 0.867505406245483f, -0.0688648080253220f, -0.707487995489326f, -0.248871627068848f, -0.197869870234198f, -0.243745607075197f, -0.244106806741608f, 0.489848112299788f, -0.0909708869175492f, -0.377678949786167f, 0.0385783576998284f, -0.470361956031595f, 0.802403491439449f, -0.408319987166305f, 0.345170991986463f, -0.433455880962420f, 0.00950587287655291f, -0.441888155900165f, -0.817874450719479f, 0.818308133775667f, 0.931915253798354f, 0.818494801634479f, 0.787941704188320f, 0.882012210451449f, 0.0749985961399193f, 0.259772455233352f, -0.655786948552735f, 0.0824323575519799f, 0.980211564632039f, -0.798619050684746f, 0.496019643929772f, -0.727312997781404f, -0.999839600489443f, 0.625938920414345f, -0.561059012154101f, 0.215650518505246f, 0.121571798563274f, 0.161863493108371f, -0.340322748036792f, 0.521792371708641f, 0.655248389359818f, -0.180967013066484f, 0.936797969156762f, 0.523749660366580f, 0.764744126333943f, 0.384701560810431f, -0.744092118301334f, 0.719721922905938f, 0.365931545158250f, -0.720202871171563f, 0.121662048491076f, -0.355501954289222f, 0.379420491208481f, -0.593818415223405f, -0.433690576121147f, -0.766763563509045f, -0.377445104709670f, -0.955638620720410f, 0.309622585052195f, -0.613767678153186f, 0.0177719922394908f, 0.362917537485277f, -0.297613292472489f, 0.0275561832152067f, -0.962345352767599f, 0.452866577068408f, -0.307485159523065f, 0.931778412136845f, 0.639592220588070f, 0.00782144244951311f, -0.0466407334447796f, -0.134392603781566f, 0.895314655361308f, -0.537785271016286f, 0.663926391064792f, -0.886126633268266f, -0.0975129470189278f, -0.429791706025144f, -0.440337831994928f, -0.00156267573188829f, 0.933113069253665f, -0.560704402651437f, -0.201658150324907f, 0.465819560354530f, 0.0701448781871696f, 0.859597672251104f, -0.525851890358272f, -0.992674038068357f, -0.0846761339576128f, -0.401686794568758f, -0.886069686075370f, -0.480254412625133f, 0.432758053902000f, 0.168651590377605f, -0.453397134906684f, 0.340250287733381f, -0.972972507965963f, 0.0560333167197302f, -0.180812774382952f, -0.689848943619717f, -0.427945332505659f, 0.771841237806370f, 0.329334772795521f, 0.573083591606505f, 0.280711890938316f, -0.265074342340277f, -0.166538165045598f, -0.0612128221482104f, 0.458392746490372f, 0.199475931235870f, 0.681819191997175f, 0.356837960840067f, 0.756968760265553f, 0.763288512531608f, -0.890082643508294f, -0.322752448111365f, 0.799445915816577f, -0.956403501496524f, 0.723055987751969f, 0.943900989848643f, -0.217092255585658f, -0.426893469064855f, 0.834596828462842f, 0.723793256883097f, 0.781491391875921f, 0.928040296363564f, -0.468095417622644f, 0.758584798435784f, 0.589732897992602f, 0.929077658343636f, 0.829643041135239f, 0.0947252609994522f, 0.554884923338572f, -0.513740258764285f, -0.221798194292427f, 0.499855133319165f, -0.0237986912033636f, 0.559618648100625f, -0.509812142428963f, -0.444047241791607f, 0.678274420898738f, -0.983706185790147f, -0.295400077545522f, -0.688769625375228f, 0.729259863393412f, 0.889478872450658f, 0.928277502215167f, -0.429388564745762f, -0.790568684428380f, 0.930220908227667f, -0.796970618648576f, -0.980240003047008f, 0.0372716153521411f, -0.290828043433527f, -0.303854123029680f, 0.160774056645456f, -0.712081432630280f, 0.390787025293754f, 0.981202442873064f, -0.679439021090013f, 0.183053153027806f, 0.665002789261745f, -0.708708782620398f, 0.254574948166343f, 0.0575397183305137f, -0.723713533137924f, -0.732816726186887f, 0.501983534740534f, 0.879998734527489f, 0.825871571001792f, 0.920880943816000f, 0.311565022703289f, -0.788226302840017f, -0.223197800016568f, 0.850662847422425f, -0.365181128095578f, 0.958907951854379f, -0.0421327708909884f, -0.153860389403659f, -0.219620959578892f, -0.469076971423126f, -0.523348925540362f, -0.287762354299832f, -0.913332930679763f, 0.403264134926789f, 0.725849051303960f, 0.743650157693605f, -0.382580349065687f, -0.297138545454038f, -0.480092092629432f, 0.0412697614821378f, -0.396203822475830f, -0.0721078217568973f, 0.979038611510460f, -0.766187876085830f, -0.344262922592081f, 0.943351952071948f, -0.219460259008486f, 0.115393587800227f, -0.342675526066015f, 0.926460460401492f, -0.486133445041596f, 0.0722019534490863f, -0.571069005453629f, -0.0854568609959852f, 0.370182934471805f, -0.554007448618166f, 0.899885956615126f, -0.188476209845590f, -0.548132066932086f, 0.0559544259937872f, -0.161750926638529f, -0.532342080900202f, 0.585205009957713f, -0.374876171959848f, -0.169253952741901f, -0.473665572804341f, 0.942267543457416f, -0.515867520277168f, -0.706362509002908f, -0.320672724679343f, -0.398410016134417f, 0.733774712982205f, 0.449599271169282f, 0.109119420842892f, -0.285090495549516f, 0.0854116107702212f, 0.0603189331827261f, -0.943780826189008f, 0.0679186452322331f, 0.0975973769951632f, -0.870728474197789f, -0.153122881744074f, -0.519939625069588f, -0.633620207951748f, -0.767551214057718f, -0.905802311420298f, -0.841350087901049f, -0.271805404203346f, 0.282221543099561f, -0.0874121080198842f, 0.0634591013505281f, 0.318965595714934f, -0.865047622711268f, -0.401960840475322f, 0.637557181177199f, -0.664578054110050f, -0.871253510227744,
-0.893972634695541f, 0.442396058421524f, -0.427901040556135f, -0.740186385510743f, 0.788155411447006f, -0.541278113339818f, 0.509586521956676f, -0.461159620800394f, 0.664671981848839f, 0.880365181842209f, -0.0831685214800200f, 0.952827020902887f, 0.183226454466898f, -0.176729350626920f, 0.851946105206441f, -0.361976142339276f, 0.357209010683668f, 0.982462882042961f, -0.690757734204635f, 0.178681657923363f, -0.0804395784672956f, 0.971787623805611f, 0.875217157810758f, 0.160844021450331f, -0.359951755747351f, 0.0178495935461525f, 0.0203610854761294f, 0.413933338290502f, -0.676038601090005f, -0.111093077131977f, -0.381792206260952f, -0.459903351782575f, 0.308522841938619f, 0.324961267942541f, 0.365201262605939f, 0.732543185546895f, -0.559558093250200f, 0.848266528378337f, -0.185546299813159f, 0.997052205707190f, -0.932554828383249f, -0.106322273904826f, -0.0690562674587807f, 0.919489002936141f, 0.137210930163322f, -0.664517238270193f, -0.985856844408119f, -0.0719443995256963f, -0.602400574547167f, -0.398979518518077f, -0.581117055144305f, -0.0626081333075188f, -0.0372763806643306f, -0.688808592854889f, 0.703980953746103f, -0.480647539644480f, 0.615510592326288f, -0.940226159289884f, -0.953483236094818f, -0.300312284206625f, -0.819419230573751f, 0.657560634657022f, -0.0500336389233971f, 0.628589817614501f, 0.717012803783103f, -0.0315450822394920f, -0.445526173532186f, 0.521475917548504f, -0.479539088650145f, 0.695075897089419f, -0.0365115706205694f, 0.0256264409967832f, -0.0121306374106025f, -0.817618774100623f, 0.375407640753000f, 0.944299492219378f, -0.717119961760812f, -0.120740746804286f, 0.995225399986245f, -0.460846026818625f, 0.904552069467540f, 0.807270804870602f, -0.842962924665094f, -0.923108139392625f, -0.130295037856512f, 0.760624035683226f, 0.986419847047289f, -0.959218334866074f, -0.203345611185410f, -0.474420035241129f, -0.872329912560413f, 0.485994152094788f, -0.515456811755484f, -0.948541161235413f, 0.509659433909651f, 0.783030335970347f, -4.41004028146619e-05f, -0.664795573083349f, 0.917509788523214f, -0.824045573084530f, -0.461857767121051f, -0.667434409929092f, -0.00822974230444418f, 0.825606347148302f, -0.396378080991589f, 0.0161379983198293f, -0.940751675506308f, -0.520997013834332f, -0.239727035024153f, -0.354546027474561f, 0.430652211989940f, -0.557416557692462f, -0.357117274957257f, -0.891975448321656f, -0.0775302131779423f, 0.716775563686830f, -0.903453980341467f, 0.946455001410598f, -0.615060907661003f, 0.964288374469340f, 0.0506144897273089f, 0.720601612869967f, -0.991323837622476f, 0.647403093538608f, -0.400304988135589f, -0.883732066109751f, -0.792060477777513f, 0.710867542231890f, -0.840766000234525f, 0.460362174479788f, -0.834771343071341f, -0.329399142231491f, -0.139853203297018f, -0.760035442359396f, -0.546795911275364f, -0.598172518777125f, 0.244198671304740f, 0.0816980976432087f, -0.978470883754859f, -0.425173722072458f, -0.469868865988971f, 0.847396146045236f, 0.0513388454446360f, -0.545662072513986f, -0.130534232821355f, -0.654100097045099f, 0.0409163969999120f, 0.573001152600502f, 0.706046270983569f, 0.587208280138624f, 0.237670099964068f, 0.848355476872244f, -0.318971649676775f, -0.659343733364940f, 0.321817022392701f, -0.595779268050966f, -0.114109784140171f, 0.998897482902424f, -0.615792624357560f, -0.384232465470235f, 0.156963634764123f, 0.499645454164798f, -0.627603624482829f, 0.169440948996654f, 0.109888994819522f, -0.492231461622548f, -0.463014567947703f, 0.825436145613203f, -0.0271223123229367f, 0.497887971992266f, 0.811868354230459f, -0.192668816770168f, 0.287930938097264f, 0.0283112173817568f, 0.791359470942568f, 0.365100854153897f, -0.566922537281877f, 0.915510517906894f, 0.674211624006981f, 0.505848146007678f, 0.509348889158374f, -0.0477364348461706f, 0.409703628204478f, -0.820970358007873f, -0.565377675052345f, 0.810052924776160f, -0.448904038826591f, -0.830251135876445f, -0.660589978662428f, -0.890196028167542f, 0.130526506200048f, 0.924600157422957f, 0.587215078998604f, 0.727552064386916f, -0.224172021948978f, -0.182984019951690f, 0.308546229024235f, 0.971188035736775f, 0.0229902398155457f, 0.0608728749867729f, -0.0712317776940203f, 0.549832674352445f, -0.600015690750697f, -0.0495103483291919f, -0.564669458296125f, 0.726873201108802f, -0.197851942682556f, -0.983422510445155f, -0.905314463127421f, 0.453289030588920f, 0.792504915504518f, -0.840826310621539f, 0.0979339624518987f, -0.506416975007688f, -0.143310751135128f, -0.451251909709310f, -0.356156486602212f, -0.430777119656356f, -0.593002001098269f, -0.212505135257792f, -0.378005313269430f, 0.516460778234704f, -0.574171750919822f, -0.702870049350445f, 0.190454765104412f, 0.694962035659523f, 0.177498499962424f, -0.00126954773922439f, -0.766110586126502f, -0.769862303237397f, -0.208905136673906f, 0.0728026097773338f, -0.467480087700933f, -0.368839893652514f, -0.608806955889496f, -0.531329879815774f, 0.411920547737697f, -0.407318902586407f, 0.922406353838750f, -0.0272310683929855f, 0.781051179942937f, 0.860271807949640f, -0.703736733439623f, -0.285650334863399f, -0.466904334435873f, -0.716816768536707f, 0.0869377378786880f, -0.280331892461309f, 0.773946156883160f, -0.139856444064730f, 0.575680110908147f, -0.887887626173303f, 0.314286545048942f, 0.673119170729964f, 0.520399233930039f, 0.581347801663144f, 0.731708017815653f, 0.672583525027818f, -0.0534590776637494f, -0.880572908687369f, 0.171150522778545f, -0.377041265530122f, -0.478003213002057f, 0.458602883802583f, 0.836824527658741f, -0.0686622680764437f, -0.301000630566919f, -0.652562984155554f, 0.604631263268903f, 0.791770979838877f, 0.0790491584346489f, 0.812646960034949f, 0.138794042671596f, 0.709411730079774f, 0.226484869016811f, 0.797388098554019f, -0.162225991160828f, -0.0295749256270541f, 0.218242165083417f, 0.442845427695148f, -0.480622209857766f, 0.873464432574125f, -0.868017543466245f, -0.435489784247438f, 0.0589001507244313f, 0.829134536020168f, 0.614063504046069f, -0.0498036542372153f, -0.803122689381969f, -0.495207870035615f, -0.126836582496751f, -0.0715271574335641f, -0.600815700055194f, 0.434993547671690f, -0.891665893518364f, 0.515259516482513f, 0.475325173737397f, -0.716548558025405f, -0.881097306400870f, 0.738462585443836f, -0.244486212870867f, -0.750368936394211f, 0.303496411011494f, -0.602701428305057f, -0.400346153635480f, -0.300002744969481f, -0.518552440201900f, 0.437964598712580f, -0.816689813412280f, -0.814392666138757f, -0.888568091915377f, 0.449416911306476f, -0.231889259488176f, 0.589775175288682f, 0.817224890217553f, 0.518646001325967f, -0.406046689874425f, -0.822100925750380f, 0.0528571826460145f, 0.502410576690672f, -0.795964394123106f, 0.0587614583641718f, -0.960750994569408f, 0.0366871534513058f, 0.723018804498087f, 0.0607565140068052f, 0.337380735516841f, 0.810682513202583f, -0.636743814403438f, 0.287171363373943f, -0.651998050401509f, -0.913606366413836f, 0.642186273694795f, -0.197674788034638f, -0.261253290776174f, 0.696450222503413f, -0.178859131737947f, -0.388167582041093f, -0.0593965887764258f, -0.638517356081890f, 0.804955770174156f, 0.220726627737384f, 0.263712659676167f, -0.214285245576410f, -0.267640297291737f, -0.268009369634837f, -0.957726158424482f, 0.708674977585603f, 0.336764494287156f, -0.985742981232916f, -0.883053422617300f, 0.560301189759340f, -0.692967747323003f, 0.977419052658484f, 0.0749830817523358f, 0.916618822945019f, 0.941660769630849f, 0.454145712080114f, 0.176036352526593f, 0.103229925297037f, 0.936507745325933f, -0.870159095287666f, -0.106465234217744f, 0.684178938709319f, 0.669775326656340f, -0.620857222834950f, 0.939074959093680f, -0.592224920792423f, 0.620706594809134f, 0.0456831422421473f, 0.738727999152789f, -0.751090911501446f, 0.683669216540363f, 0.153825621938168f, -0.255671723273688f, -0.773772764499189f, -0.667753952059522f, 0.887641972124558f, -0.664358118222428f, 0.512196622998674f, -0.0234362604874272f, 0.942878420215240f, -0.406617487191566f, -0.140379594627198f, -0.0587253931185765f, 0.419570878799757f, 0.533674656399007f, 0.108777047479414f, -0.695880604462579f, 0.481525582104998f, 0.511165135231064f, 0.136105196996658f, -0.481918536916982f, 0.757546893769363f, 0.957648176032083f, -0.908743619686586f, -0.395640537583668f, 0.0493439519763970f, 0.293569612893396f, 0.387420368421925f, 0.0928482742403196f, 0.407302666835821f, -0.787979245337637f, -0.968269218296593f, -0.409517247978962f, 0.775076200793689f, -0.217738166217447f, -0.370002483875998f, -0.570975789421316f, 0.844070553036478f, 0.668620483679341f, 0.00139813137293987f, -0.0912495442122028f, -0.0375370940595317f, 0.723007849224616f, 0.369999774115317f, 0.862240371150479f, 0.749525689790910f, 0.742992309993137f, -0.495813719545874f, -0.101947508108870f, -0.152536889610560f, 0.0598123624723883f, -0.436496899502871f, 0.520026918467263f, 0.241005798945400f, 0.970456690492966f, -0.376417224463442f, 0.614223236672359f, 0.336733945081746f, 0.376602027190701f, 0.00373987228923456f, -0.415425448787442f, 0.330560415319813f, -0.277250467297048f, 0.861008806111330f, -0.00655914035278493f, 0.810375656135324f, -0.0113631690466840f, -0.191699616402287f, -0.808952204107388f, 0.813180054552450f, 0.472985418265257f, 0.180147510998781f, -0.262580568975063f, 0.211152909221457f, -0.882514639604489f, -0.575589191561861f, 0.106927561961233f, 0.964591320892138f, 0.738192954342001f, 0.687649298588472f, -0.229142519883570f, -0.354434619656716f, -0.420522788056562f, 0.684638470896597f, -0.608080686160634f, 0.172668231197353f, 0.571295073068563f, -0.202258974457565f, 0.183035733721930f, -0.425589835248751f, -0.181955831301366f, 0.798193178080558f, -0.719799491928433f, -0.376418218727565f, 0.100370714244854f, -0.674685331738723f, -0.528950922374114f, 0.480443520097694f, 0.432497368954013f, 0.887439714903326f, 0.598241701759478f, -0.250064970303242f, -0.743111010477448f, 0.936189907099845f, -0.867383557331633f, 0.852536175309851f, -0.426378707286007f, 0.793838638663137f, 0.856262917294594f, 0.734157059815547f, 0.00452009494051664f, -0.884258713402709f, -0.0835595438259760f, -0.735457210599502f, -0.710727075357488f, 0.858050351034768f, -0.626070522205317f, -0.848201957131499f, 0.0180933910837406f, -0.0350884878366737f, -0.893836321618480f, -0.0682788306189803f, -0.539993219329871f, -0.557660404374917f, 0.268969847256868f, 0.505363999910409f, -0.0464757944714727f, -0.529689906951922,
-0.138445378586710f, 0.992531054118938f, 0.974585450054910f, 0.940349645687053f, 0.648085319100986f, -0.410736404028701f, 0.804131759246012f, -0.774897101314247f, 0.178246382655493f, -0.361699623232501f, -0.836093509684016f, 0.806309487627613f, -0.758182371322663f, 0.718410035716663f, -0.213136487421868f, -0.0563465521625497f, 0.0411192849612654f, -0.532497330327019f, -0.0419839515250475f, 0.769432068229678f, 0.253556234192255f, -0.745131216530268f, -0.890639235422577f, -0.140643637034330f, 0.318127074868768f, -0.497415632768561f, -0.383508820416842f, -0.468783454456628f, -0.289531078129000f, -0.0831555730758713f, 0.0107128404847427f, -0.567754537918270f, 0.926366772604370f, -0.600154724486768f, -0.0920759547805206f, 0.889582307602381f, -0.0710437157605615f, -0.182724716112986f, 0.228135065644420f, 0.851015495602628f, 0.653035806598961f, -0.986676404958677f, -0.871714951288816f, -0.824734086356281f, -0.490239304888267f, 0.244318295619814f, -0.923794688606381f, 0.670566388343457f, 0.849438492633058f, -0.225318912425116f, 0.461075616917687f, 0.656436404012820f, -0.416403369651597f, 0.205630417444150f, -0.163509095777762f, -0.0670299490212758f, -0.315561491397908f, -0.0952855008191476f, -0.377993693497066f, 0.860172853824826f, -0.669622978211317f, 0.595058880455053f, -0.425661849490015f, -0.0405359106780283f, 0.129968697438974f, -0.156244199842099f, 0.996996665434629f, -0.888570357356090f, -0.925646614993414f, -0.753998082238076f, 0.714491335460749f, -0.307849905639463f, 0.536274323586448f, -0.462944722411129f, 0.622202376598447f, -0.215582012734053f, -0.115115003363232f, 0.128168110175570f, -0.556263623663708f, 0.921813264386344f, -0.288173574121268f, -0.175054002159610f, 0.0621862747516269f, -0.468862899314091f, 0.976184545317535f, 0.468469061953779f, 0.679394669665911f, -0.0651943232114096f, 0.872740953203360f, -0.917720162541254f, 0.271535917769933f, 0.265441861283112f, 0.542190484993772f, -0.0208550501604048f, 0.983272473294640f, -0.522164666401537f, 0.833823680455458f, 0.414337644113416f, 0.588576354535126f, 0.318369292694380f, 0.870442561030567f, -0.422722224743553f, -0.200185003922166f, -0.770185495487048f, -0.878134057034045f, -0.712873198675798f, 0.647706512601268f, 0.593648188899773f, 0.126171748161942f, -0.189622212946038f, 0.707877641788638f, 0.790070498218410f, 0.698576567863428f, 0.594748885238005f, 0.567439045931572f, -0.591839707769224f, -0.632709967090349f, 0.415471238430617f, 0.115403276784208f, -0.375797954748234f, 0.123611001678020f, -0.864109581464288f, 0.115346512920739f, -0.515581940111704f, 0.880606114362175f, 0.356011740142007f, -0.318112820131587f, 0.765766689783476f, -0.226772670084743f, 0.442067390135885f, 0.348547568069751f, 0.862154389627291f, -0.894863284060244f, 0.475714942110286f, 0.552377629980789f, -0.0838875341374268f, -0.227654706745770f, 0.0998522598030438f, 0.870812229993830f, -0.518250234958224f, -0.0635791579471283f, -0.284101882205902f, -0.454751668241269f, 0.720773434493943f, 0.0756117818245317f, -0.0572317848090118f, -0.692584830354208f, 0.776250173796276f, 0.514052484701885f, 0.00770839936587864f, 0.775668871262837f, 0.933055956393907f, 0.0501713700022097f, -0.922194089981246f, 0.266653852930886f, -0.408584553416038f, 0.797066793752635f, -0.785570848747099f, 0.931403610887599f, 0.660859952465710f, -0.630963871875185f, -0.673000673345695f, 0.518897255252506f, -0.342041914345720f, 0.405613809903414f, -0.373516504843492f, -0.208292396009356f, 0.0510871025610438f, 0.396765368381847f, 0.00537609874241829f, 0.935717099427788f, -0.564801066383885f, -0.907523685862547f, 0.670551481631625f, -0.457309616171932f, 0.364001526470449f, 0.140805524345232f, -0.349945327329409f, -0.0361532758624807f, -0.304268551311720f, 0.618482952755668f, -0.0120110524971313f, 0.106364353621731f, -0.427587198043230f, 0.464249033810121f, -0.808297048471569f, 0.675277128303038f, -0.0663762607268352f, -0.431951364170808f, 0.953951718476660f, -0.725934553905574f, -0.685163723789561f, 0.164132617720945f, 0.934798872032034f, -0.695343627424553f, -0.420317401094920f, -0.689247558220342f, -0.605894279765940f, -0.693832779320227f, 0.455037128281788f, 0.968645000038447f, -0.0839147410947130f, 0.603463489419899f, 0.776913738299999f, -0.491560292499776f, 0.692235227850848f, 0.0824017593921889f, 0.459024952691847f, -0.918050509352710f, -0.777463066447746f, -0.161045596440278f, 0.982603547894360f, 0.700884888820475f, 0.998304481713913f, -0.362488733430088f, 0.171493948866881f, 0.565871153533442f, -0.965620428705067f, -0.835532968802398f, 0.885598629033760f, 0.609604257914327f, 0.725300244775050f, 0.153524048564152f, -0.662541112390878f, 0.912145212201290f, 0.135610445338421f, -0.0813934125800109f, 0.242209063597546f, -0.264886126609115f, -0.335070345839122f, 0.823958964903978f, -0.313110855907701f, -0.354068037633970f, -0.0381190024996405f, 0.117794735211134f, -0.604442743379238f, 0.524930955656444f, -0.754959642694882f, -0.359151666678207f, -0.247910739722172f, 0.573570999369016f, 0.543167570010806f, -0.718553346110069f, 0.202415372555816f, -0.860091438569300f, -0.0125446132328610f, 0.509348782140749f, 0.349261188228469f, 0.424395913611831f, 0.0557092265870811f, 0.740276822496471f, 0.479158001215769f, -0.221873518706244f, -0.744883456979009f, 0.393114117430743f, -0.733203119089531f, -0.506531269498885f, -0.505532097672033f, -0.509440981371663f, 0.666118722468113f, 0.0164067375520756f, -0.530276655546078f, 0.786338654343788f, -0.985008085364936f, 0.479988836226036f, -0.233652481382475f, 0.838641098910395f, -0.407379719374768f, -0.314266358910263f, -0.938033692224531f, -0.627320971378707f, -0.229174127295511f, 0.642505983671691f, -0.387855473250297f, 0.360324209821339f, -0.900766206699468f, 0.176676285751262f, 0.833894117554548f, -0.0207873177403817f, -0.202625183820044f, 0.706644325019314f, -0.817922707040537f, -0.242742059004419f, 0.282109349674866f, 0.0164603911954744f, -0.504625902855950f, 0.0415496120997125f, -0.787777778295785f, 0.362588721999523f, -0.371357162843751f, -0.818375262182416f, 0.727779997467707f, -0.836502839702384f, 0.0423869176265037f, -0.283934686546853f, 0.665864224978728f, -0.0428162304637920f, 0.243534621880753f, -0.803789304599586f, 0.570866852088607f, 0.340615579467880f, -0.323456502239327f, 0.403242371952148f, -0.0679158901587793f, -0.866985651416456f, -0.439873628406335f, -0.246357367033863f, 0.436234859832243f, 0.560714706225535f, -0.632564381913014f, -0.316451076258298f, -0.977122780282003f, 0.0741405862954117f, -0.217862250253606f, 0.887093089232476f, -0.418281865182365f, -0.638553415535034f, -0.262631979211197f, -0.567499176465252f, 0.676178859605923f, 0.933551699581608f, -0.0139735129263516f, -0.610719575803582f, 0.565123751720690f, 0.230672823422021f, 0.323935439339366f, 0.635142215896104f, 0.981184609133698f, 0.883668802319366f, -0.281281673616891f, 0.583204242495555f, 0.150854689098149f, -0.775890223139644f, 0.419951701513177f, -0.565767744791652f, -0.855232478054420f, 0.472188579901153f, -0.501463211798228f, 0.727960518524943f, 0.977187851385321f, 0.908113737694915f, -0.570200931535418f, 0.716036980035073f, 0.147838037485588f, 0.218820342222622f, -0.0673193461152677f, 0.433612519652386f, 0.449601736390411f, 0.556458722303960f, 0.417345590820787f, -0.783345413347895f, 0.858903187230710f, 0.178354025272247f, -0.130619018471658f, 0.858282827806003f, 0.508916167873459f, 0.139535936201634f, 0.240400109521332f, -0.102942705407161f, 0.841682417072375f, -0.696350979494975f, -0.793644449061670f, -0.698273636720141f, -0.228676865074326f, -0.195917865828574f, -0.306483109792438f, -0.865320326812636f, 0.659185969805107f, -0.368847387975239f, 0.337343722359231f, 0.0723822170210744f, 0.907475280998826f, 0.515168301614856f, 0.0790167120323961f, -0.756697420780699f, 0.966477562469936f, -0.663190129982788f, 0.145761851826854f, 0.376079225193173f, 0.631883071958707f, -0.956568110802436f, -0.735990864315730f, -0.795999578321461f, 0.958459465243432f, 0.319180429028702f, -0.907664654881857f, 0.992381284978014f, -0.511208110440365f, -0.714797966909523f, -0.717021870210999f, 0.545775837604423f, -0.0443828768329362f, 0.333311879948434f, 0.617237628406207f, -0.0895192882305207f, 0.506491005527430f, -0.354205929841282f, 0.777993157224477f, -0.667532693120319f, -0.105006112097613f, -0.337191911902220f, -0.337964429160738f, 0.609014812897482f, -0.368922911475613f, 0.889184378947484f, -0.676392242654630f, 0.429716870038086f, 0.916751115281822f, -0.655611878274175f, 0.538928395264007f, 0.382674384886170f, 0.0580742902089004f, -0.0124611362991478f, -0.0240388340005702f, -0.726296501832402f, -0.805701334732693f, 0.945344279474230f, -0.668066000378724f, 0.761436128738929f, -0.314275650172792f, -0.394331510439346f, 0.262887592668013f, 0.155064800148016f, -0.561829218656134f, -0.491542446753775f, 0.922248338472926f, 0.574575887413700f, 0.631722295929094f, -0.368854197209698f, 0.984780657580794f, 0.845286034922662f, -0.965631634115590f, -0.435710392440405f, -0.616488688868478f, 0.885865616625930f, 0.425733070487506f, 0.776721663555227f, -0.0652930284860209f, -0.734431875923792f, 0.725517937762654f, -0.474146253075108f, 0.895357779508529f, -0.0725048758018345f, -0.360185856190223f, 0.559350280666427f, 0.363695103660096f, 0.152231254765544f, 0.698196273442671f, 0.0518001104801953f, -0.139037096279713f, 0.340637636595997f, 0.584243998596814f, -0.442304329829130f, -0.501574294329747f, 0.250155103662225f, 0.320493999001502f, -0.150217982700108f, -0.0381390799255577f, 0.734760815545772f, -0.574574233376749f, 0.593440338163725f, 0.408049858247104f, -0.0845023181203484f, -0.855507806920297f, -0.473198309372409f, 0.331033392104072f, 0.196445364460658f, -0.799745050834061f, -0.973517526224363f, 0.333748727500822f, -0.772356831553232f, -0.430793038424357f, 0.649852557262489f, 0.504357958431509f, 0.779588082810134f, 0.0111847677569461f, -0.995526851285634f, -0.676007517368195f, 0.216774012875664f, -0.618928775636485f, -0.418043155155598f, -0.532063904545563f, -0.566979013994587f, 0.246319907266774f, 0.868651379198082f, -0.0433430896891542f, 0.463004686009427f, -0.162112430964754f, 0.285379745117090f, 0.901512987149549f, -0.706916206313139f, 0.685678130935725f, -0.673017501666538f, 0.0616272859909088f, 0.147532779463338f, -0.0108539826652629f, 0.960841184863269f, -0.950190006701182f, 0.992171414792924f, 0.715577145884581,
0.975908103138584f, -0.769014520827696f, -0.463212420186382f, -0.0761813427220397f, -0.704830850508594f, -0.220579724380686f, 0.840893269946637f, -0.432181989863148f, -0.956790418498701f, 0.122344784859397f, -0.242133592220528f, 0.908514497715246f, 0.303653521236872f, 0.756500828196849f, -0.752207807361831f, 0.367894642791072f, -0.702474131286247f, 0.189226989057138f, 0.401804209353236f, 0.608493473010907f, -0.437378101171900f, -0.158801297891213f, -0.381027984311046f, -0.949403985394057f, 0.370189685252539f, -0.872655295458655f, -0.337934909993878f, -0.0619622888328213f, 0.352094440420005f, 0.128759637109350f, 0.432413186229881f, -0.497474226759161f, 0.552933107875735f, 0.332665936587804f, -0.559261497212156f, -0.886188834336549f, 0.0170548801295034f, 0.192729852728271f, -0.674432365770129f, -0.526014722983374f, 0.425009223123802f, -0.186164676538888f, 0.190362042383007f, -0.0930204201587825f, 0.794188212052413f, -0.243549629178106f, 0.118970185744958f, -0.216230226310237f, 0.412570247218594f, 0.659556685538155f, -0.150540425515543f, -0.850858266540316f, -0.843827815842486f, 0.629298164439457f, 0.944304062363374f, -0.117764731240517f, 0.558568737697335f, 0.731745392387362f, -0.00413812760139165f, -0.251933493011685f, -0.473346352965658f, 0.178783613032362f, 0.547769344759580f, -0.414330113592064f, -0.550251453379012f, -0.925253680779905f, 0.623832825809309f, -0.494251081521428f, 0.0643361026845244f, 0.727107898350051f, 0.814864886916156f, 0.0177325632172460f, 0.749324691554934f, -0.266301024849295f, 0.675202550635588f, -0.0748462128620644f, -0.747853513216831f, -0.222563643557406f, -0.608884446788701f, -0.0374135649675464f, 0.852579123003940f, -0.585927920129879f, 0.604065857569210f, 0.573072924781108f, 0.816831955879520f, 0.723975232584095f, 0.367887024581694f, 0.765292601085641f, 0.836490699448589f, 0.623434131440044f, 0.743568762340577f, 0.140474444458222f, -0.746327891490507f, 0.700496422194197f, 0.549693846244016f, 0.729372970291116f, 0.728185563682229f, -0.614909046853182f, -0.756209631211223f, -0.530222413502955f, -0.312453162783936f, -0.752364704008701f, -0.634475515424180f, -0.133239439768175f, 0.252790153178337f, 0.760626105409900f, -0.838262213452153f, -0.266093046689486f, 0.549339088324875f, -0.278178592347115f, 0.190458706141960f, 0.906814275056971f, -0.579827980376046f, -0.134191470195968f, 0.244720998349483f, 0.795502128014338f, 0.287019836683889f, -0.906277889518234f, -0.817071933038363f, 0.613378274793081f, 0.518208081766432f, -0.388902790616382f, -0.785778461147273f, 0.574976429920521f, -0.283168065839246f, -0.857322381041868f, 0.424932015236353f, 0.919756642423073f, 0.412896759578072f, -0.976511020897041f, 0.157825653359643f, -0.0606591903280758f, 0.508438714729350f, -0.513115001652116f, 0.881391940997543f, -0.129708782033534f, 0.382462819411800f, -0.538751535594113f, 0.816770663497783f, 0.869013288394013f, -0.728381721932439f, -0.956736333819522f, -0.839107107637575f, 0.394821058517234f, 0.721983518815999f, -0.0847231453556103f, 0.0206545030491683f, 0.414707730497861f, 0.246591855656934f, -0.546187573590839f, -0.578957978692654f, 0.162844799084821f, 0.493731081270802f, -0.765815587549615f, 0.151613093585910f, -0.112883397239635f, 0.879319928900002f, 0.295375250614654f, -0.505370201033860f, -0.635319167339584f, -0.309818465920078f, 0.768627024018538f, -0.544374452091825f, 0.758974060573473f, -0.106050973670013f, 0.508616501970226f, -0.207224226211215f, 0.616842248601645f, 0.688381226662374f, 0.643728558619948f, -0.906982649598668f, 0.526262112978799f, -0.666644270400075f, 0.314806313630502f, -0.292000096972562f, -0.358353880616007f, 0.156344541906829f, 0.637606941586786f, -0.199572501073669f, -0.669369278061572f, 0.237513395315133f, -0.576741807179552f, 0.0750117203638310f, -0.633877533594996f, 0.829285089669934f, 0.622345234313277f, -0.892617583855908f, -0.280449892200797f, 0.241147361581176f, -0.0784016295955696f, 0.414945819313502f, 0.287238318044040f, -0.691458270387106f, 0.597656137422422f, 0.549022082569726f, -0.590776624040652f, 0.666740423918019f, -0.743115212424850f, 0.164036350785269f, -0.229427480781113f, 0.283602991107853f, -0.533993445778340f, 0.185806116700093f, -0.317953364055307f, 0.140412503708198f, 0.280706883979940f, 0.0439806827213221f, 0.176471515460512f, -0.614144204292693f, 0.314194083857125f, 0.519572839644130f, -0.850547081260782f, -0.515460990713008f, 0.353087995032390f, -0.0241014119925820f, 0.269453276643829f, -0.608515317887958f, -0.777818225534647f, -0.834277444316067f, -0.842707175235771f, -0.929547602540323f, -0.884691870945475f, 0.710591809809692f, 0.143423776629673f, 0.797136471728128f, 0.233311155245426f, -0.923169961754164f, 0.627911916101674f, -0.338187201367212f, 0.211044396110784f, -0.443699655795038f, 0.256593551969761f, -0.406688684034041f, 0.364900889856600f, 0.900530571350288f, -0.160476177153537f, 0.0634217008071056f, 0.709241599309354f, -0.789562037599596f, 0.00891621061029158f, 0.801674768895422f, -0.704378031949125f, 0.430576706378041f, 0.796937507044124f, -0.193348850174576f, -0.493924902919358f, -0.935781577118986f, 0.468142331108629f, 0.00965840085728753f, 0.0834398764999438f, 0.599712941235232f, -0.735675950275295f, 0.200152501800787f, -0.751603779675650f, 0.0697488403240092f, 0.300634243862625f, -0.901969784333300f, -0.958816237033024f, -0.754976119377363f, 0.719702182489622f, -0.338038642556184f, -0.703280944186943f, -0.579148694005994f, 0.556115731092296f, -0.920710928208685f, -0.278178108839470f, -0.793795308512285f, 0.916547680808212f, 0.419467216101691f, 0.177932177026735f, 0.682833725334600f, -0.926849803428705f, 0.179045225389745f, -0.209414969718359f, -0.889551871881532f, 0.961659420127890f, -0.250341627298645f, 0.105606170554974f, -0.547860346689080f, 0.845704098204057f, 0.886892635683680f, 0.768134466622042f, -0.954777823503721f, -0.718106389777233f, -0.580779231998609f, -0.0241800476518665f, 0.815063484178525f, -0.351971452344303f, 0.770369263680192f, 0.520886146470712f, -0.236456125482696f, 0.0900173391919312f, -0.00610611501589697f, 0.0986788038317752f, 0.277083194173223f, 0.0877085076786761f, 0.695814138412262f, 0.281021332783082f, -0.701468161850407f, -0.785496560046616f, -0.805623403379156f, -0.0524204125046179f, 0.0836418099696601f, 0.467252832788807f, 0.148967572323544f, 0.314141193557124f, -0.722297309069329f, 0.147068590429361f, -0.868307069306109f, 0.118712645744921f, 0.737896544941878f, 0.897526485681248f, 0.842207508585120f, 0.817408479766998f, 0.522315328909182f, -0.409136979179218f, 0.580654760034574f, -0.384701243761730f, -0.769398544059918f, -0.791317178699730f, 0.357020281620118f, -0.235410423267782f, -0.326332500533018f, -0.416891876268284f, -0.863029987000052f, 0.505171215727166f, -0.728709553380428f, 0.554546891580919f, 0.737429989077498f, -0.355088598334119f, 0.911987317939763f, 0.525846127625130f, 0.851549830104189f, -0.772303673276796f, 0.0421942169353806f, -0.521836640530782f, 0.995279650924240f, -0.186831960875832f, 0.421233670121556f, -0.0891583750230474f, 0.661100169663965f, 0.393809652414978f, 0.346165179707090f, 0.384203760628548f, -0.329281932973211f, 0.446133401546675f, -0.748200766224366f, -0.0275154142375615f, 0.771701580845288f, -0.0177829993094090f, 0.406813206251131f, 0.606021648140155f, 0.218435152341115f, 0.236571855064013f, -0.513495776515847f, 0.729086381137554f, -0.137775825035815f, 0.0320966747364262f, -0.313487802206023f, 0.105472520924239f, 0.423606700821375f, -0.231301628369264f, 0.465218832919270f, 0.379671652150568f, -0.00497780485272159f, 0.509290230688327f, 0.467240127182068f, 0.353587964503845f, 0.390455232684039f, 0.721536288927627f, -0.838922323815237f, 0.827628029266859f, 0.768844149796201f, -0.813963144642386f, -0.797054297232628f, -0.933039367361175f, -0.0723957249866136f, -0.664824147893300f, 0.695914840901794f, -0.206071660300270f, 0.879389414398409f, 0.181872681691416f, -0.582831210733033f, 0.624249199449935f, 0.204959730900228f, 0.354831594370532f, 0.337152636438178f, 0.596132114241829f, -0.295619496794481f, -0.443402055665686f, 0.743995051028396f, 0.543706744165365f, 0.825846155044062f, -0.764982315603181f, -0.0355223730700034f, -0.682467026736627f, -0.914037445162109f, -0.222823484413727f, 0.825323277024566f, 0.0769459194171547f, 0.696453968928934f, 0.760786120466962f, -0.525470048583831f, 0.764981036001869f, 0.458525204937000f, -0.612703584870878f, 0.626016142683351f, 0.284799326870320f, -0.130410894642153f, -0.730659587111424f, 0.0251896513929686f, 0.744421417725379f, 0.481278905427271f, -0.718686189713675f, -0.972110566787501f, -0.178005803066219f, -0.761536801353512f, 0.675177569459847f, -0.613068600254845f, -0.854757540148688f, 0.641823580903407f, 0.112536000301536f, 0.201235170163357f, -0.332623522893231f, 0.602028236317460f, 0.487529253813741f, -0.936537443253385f, 0.932862477850079f, -0.0977461167435834f, -0.485449569929182f, -0.575807340541437f, -0.920527242558033f, -0.938208754460503f, 0.890054000488493f, -0.154888511872567f, -0.106629818916523f, 0.323343252623500f, 0.105328135407289f, -0.837197492121459f, 0.497769113944639f, -0.234127101891878f, 0.840922493788059f, -0.994297350473539f, 0.241966031396186f, -0.241143860453769f, -0.598953146106117f, 0.839112451637864f, -0.639567866338402f, -0.219908091959649f, -0.778137266578287f, -0.201424793310289f, -0.486105622640452f, 0.874947034932591f, -0.131437343585340f, -0.674427373037920f, -0.161007203320351f, 0.215285933912207f, -0.963047650748652f, -0.841020847986178f, 0.259702280444602f, -0.165325097679823f, 0.572379756389254f, -0.435802768396928f, -0.0776125194906274f, -0.0293182206559168f, -0.847945015803839f, -0.576891917046364f, 0.728544652294888f, 0.110676857648527f, 0.760459056611184f, 0.486936926897001f, 0.680603035572503f, 0.330358411271561f, 0.901153157113818f, -0.893323547516767f, 0.268679990552354f, 0.794615743189695f, 0.221637368947158f, -0.0207579360252996f, -0.585634995914835f, 0.587646126395593f, -0.317780705107399f, 0.790321547328449f, 0.251610679655279f, -0.0386445267248654f, 0.881542790650722f, -0.469258891944944f, -0.900544881246558f, -0.344978220866601f, -0.271404539202745f, 0.863631450621357f, 0.805892242474368f, -0.325004362330199f, -0.649692260224921f, 0.535815472185538f, 0.427767946389023f, 0.924517987543855f, 0.571059970962007f, 0.549923246060706f, -0.639468249016352,
0.307213071097954f, -0.885892976847170f, -0.526002656640427f, 0.733743042788359f, 0.186919211020217f, 0.322167483598106f, -0.933484010727969f, 0.307181642341518f, -0.391959805653480f, -0.892298105797306f, 0.100065710151584f, -0.932962740784651f, -0.643536993204857f, 0.200747180046148f, 0.310831344540979f, -0.923416823619512f, 0.440768799148345f, -0.666930667413366f, -0.485487251971431f, -0.0627811951952384f, -0.331082293469460f, 0.0335811939608148f, -0.653610782697787f, -0.320586426505716f, 0.559163070852115f, -0.497363452770543f, -0.329886484503569f, -0.146612217140156f, -0.0265272745798242f, -0.288663397675155f, -0.996138396801714f, 0.705746028666908f, 0.634215549629091f, 0.165248482682243f, -0.110791752682943f, -0.0583711657160508f, 0.704663932851230f, 0.105987046073574f, -0.674234600022039f, -0.852792911043127f, 0.779458558047699f, -0.506163961277651f, 0.661431789813829f, 0.362986600662932f, 0.677673397902417f, 0.909704544299484f, -0.678129611146149f, -0.700854916363125f, -0.954905799366644f, 0.819329178422143f, -0.278866438326573f, 0.240572863896085f, -0.597973444252616f, 0.520707363092687f, -0.891796539359942f, -0.0707113684027092f, 0.730270237241197f, -0.202809887987925f, 0.712903235793333f, 0.815918058519912f, -0.619284883130692f, 0.620432327799984f, 0.215462902206797f, 0.913706499476201f, -0.284266999538807f, 0.137669223817851f, -0.320599930994154f, -0.279885143029947f, 0.0759863610502050f, 0.362519848337183f, 0.0897184432777523f, 0.730407126330006f, -0.715664883515070f, -0.964294244830797f, 0.337668374417089f, 0.563780948124681f, 0.534272089774928f, 0.670003495251274f, 0.976582736706313f, -0.576021162432801f, 0.318863740329612f, 0.374838616807691f, 0.437628782275460f, 0.629331465907672f, 0.800673318445353f, -0.964950925853698f, -0.115288102568929f, 0.581179798077059f, 0.892103220665649f, -0.224009831257430f, -0.486848659265476f, 0.768601825625188f, -0.478996958061453f, 0.987216084861456f, -0.00828256241998737f, 0.443388113322642f, -0.209225960405120f, 0.784392408672073f, -0.821157008960409f, 0.169088259578466f, 0.188648958653604f, 0.796321723736402f, 0.804915614204973f, -0.947435972579018f, -0.320368366702004f, -0.0857043727442930f, -0.229914128505395f, -0.802013870592427f, 0.497444368231634f, 0.791040716463223f, 0.586369970276563f, 0.871236424247704f, 0.770091868124107f, -0.458396647683594f, 0.871149873224889f, 0.753895449519495f, 0.295832468734546f, 0.574616471536691f, 0.384408809311353f, -0.978021020306570f, 0.0397482936794495f, 0.628095200786834f, -0.968059492217325f, -0.404306711220928f, 0.659301030460980f, -0.345766174675525f, -0.0517956907600681f, -0.640289082986305f, 0.965202733073502f, 0.909703156044274f, -0.744545066259015f, -0.676836498528477f, 0.0507393165493961f, 0.394673166210436f, 0.250366706754377f, -0.287411651947684f, -0.521760552601739f, 0.214487178617345f, -0.922260536787078f, -0.970217444063294f, -0.632705652784150f, -0.720016326822300f, -0.506393579710801f, 0.774172771450182f, 0.891546338793249f, 0.559706491124446f, -0.513481979527671f, 0.735727350850420f, -0.207760672132971f, 0.956672164225499f, -0.516696999265124f, -0.846015525317730f, -0.199370940530009f, 0.927580907007946f, 0.669786891276299f, -0.208316500739886f, -0.349932032863852f, 0.382722440637189f, -0.455635180187178f, -0.573852668753046f, 0.237990995216907f, -0.00210628303929439f, 0.846035951941252f, 0.921932267818374f, 0.141873820779935f, 0.871317167610738f, -0.632607355185838f, -0.565801401210940f, -0.959881482283947f, -0.732559764685905f, -0.655277252471118f, 0.136770193226314f, 0.206392768880907f, 0.0946932052352707f, -0.147722827344946f, 0.142504821799194f, -0.891443939735724f, -0.660161817562772f, -0.918683225740157f, 0.524851053279394f, -0.841532325411647f, -0.662931925252737f, 0.450018807591706f, 0.157794014139767f, -0.562525486647545f, 0.604051451992330f, 0.859220943805127f, 0.943321402026900f, 0.511188518123118f, -0.332990520726740f, 0.904709059147998f, -0.336911302156504f, -0.0329301811082998f, 0.307263624236174f, -0.640655394434152f, 0.791676792853669f, 0.450137270831791f, 0.746000232170803f, -0.915436267533878f, 0.976514418439799f, 0.828073391112522f, 0.990695018409237f, 0.419713963781614f, -0.286897378037841f, 0.111527193084439f, -0.956913449095442f, 0.263769440437253f, 0.534739246489713f, -0.918314908283506f, 0.680501951418845f, -0.0258330390798596f, -0.696521999550769f, 0.274590593565720f, -0.821334538131451f, 0.104139627465949f, -0.790104923997319f, 0.399265830301725f, 0.118854169469537f, 0.309552488812324f, -0.961100729890863f, -0.665645274594184f, -0.125767140532335f, 0.377154316156289f, -0.971986633153292f, -0.148225730575294f, -0.801072242848910f, 0.735673216754228f, 0.247753694178141f, 0.759093842520115f, -0.529946694334253f, 0.594235069164038f, -0.801015868726278f, 0.141962211231124f, 0.135473683510959f, -0.0431660672944612f, -0.437176231417910f, 0.467008031415084f, 0.324675317141816f, 0.122578305547357f, -0.0351479470228342f, -0.437236315511244f, -0.822621846670407f, 0.989461679354308f, -0.242059902390237f, 0.800837521050356f, -0.387832478851607f, 0.316362161826139f, 0.602440060427024f, 0.890992007298149f, 0.319686042477150f, 0.930326885903916f, -0.170779817104763f, -0.437602177375177f, 0.835764105962134f, 0.522922752459604f, 0.295156847627349f, -0.857646277751538f, -0.451421990712551f, 0.752856133268497f, -0.826193868550830f, -0.906961130052697f, 0.118621494342013f, -0.627099634988204f, 0.163256363060383f, -0.719362770410877f, -0.576563943780491f, -0.369939711177846f, -0.294180430088591f, 0.868430622614485f, 0.945955651201780f, -0.879259966782947f, 0.376142233233261f, -0.549019623646418f, -0.366403875933169f, -0.631308623984507f, -0.398270064613022f, 0.631780765950599f, -0.497821177556814f, -0.0754938097555216f, 0.358298259390762f, -0.438971283619577f, -0.835962846436280f, 0.771544885338102f, 0.132031497593111f, 0.0964144932127649f, -0.171144812197942f, 0.734241841669664f, 0.773828279651661f, 0.591442573315395f, 0.449840299498767f, -0.249196666141921f, 0.910274822633449f, -0.623687862912847f, -0.954398427932048f, 0.700975370671540f, -0.128268698036002f, 0.723971772247224f, -0.239872317271662f, 0.599101633280873f, 0.323504979356466f, 0.726076237951951f, 0.775013638477775f, -0.736157118505210f, 0.681129332563739f, -0.989456914597076f, -0.860559243921100f, -0.652547050354339f, 0.227533741410917f, 0.263244425371628f, -0.412800042549063f, -0.774547399227093f, 0.959749220773555f, 0.0285018454625012f, 0.0260964660594436f, -0.817249773797516f, -0.275510098931589f, -0.957071090655421f, 0.755874233806472f, 0.0601247360044190f, 0.155148678178749f, 0.744458452388040f, 0.206143083045583f, 0.405575258734775f, 0.591273066531951f, -0.286358679634110f, 0.168522523380964f, -0.0740663582251186f, 0.991796969736415f, 0.00304472789286958f, 0.0955103281360055f, 0.595292305224677f, -0.633460800851610f, 0.969720344590438f, -0.788939516987962f, -0.690852963213444f, -0.751849610482179f, -0.454105756229298f, 0.527652178438853f, -0.249156091787771f, -0.395486634371019f, -0.586329259469701f, 0.774216673365643f, 0.000796185912973479f, 0.753872935709907f, 0.691883261316931f, -0.599798140130743f, 0.140718954973018f, 0.400016581571111f, -0.412934563119652f, 0.782683275869451f, -0.837415681080234f, 0.503344297140354f, 0.443222186121185f, -0.869067764953740f, 0.891507832007671f, -0.258782538717313f, -0.592111951047753f, 0.542828422857983f, -0.959476625230936f, -0.373353196174649f, 0.558975637763876f, 0.848608638566440f, -0.861701716955403f, -0.937645215971517f, 0.0456695238513540f, -0.643462752057364f, -0.194887894642735f, 0.576940690214110f, -0.889414400002951f, -0.120401270393403f, 0.581976128201341f, -0.914549817300516f, 0.619675229253819f, -0.446355411157033f, -0.686510097388917f, 0.199022704414501f, 0.0679083509214176f, 0.939286059873160f, 0.919854436895475f, -0.921420499961796f, -0.933865152326639f, -0.173428453947994f, 0.0481843697148709f, 0.282408667923603f, 0.411093542307595f, 0.332739798472214f, -0.539048264159821f, -0.704491312083244f, -0.502163632960363f, 0.955228344617550f, 0.620064399129425f, -0.470222569036376f, 0.754614931250763f, -0.616308595262807f, -0.914574682979899f, 0.624066330640082f, 0.836911269770582f, 0.913639510454430f, 0.653228461676548f, -0.269928008555249f, 0.313006679186127f, 0.984676487220296f, -0.492012769698267f, 0.956868299674771f, 0.291679581317590f, 0.0391808383867289f, 0.572884371819903f, 0.0424011452585180f, 0.955486550514640f, -0.402317209279260f, -0.606465037288902f, 0.547296561663929f, -0.262634118959448f, -0.555413611714328f, -0.328781770154915f, 0.145794994289916f, 0.141260540582646f, -0.451655981927315f, 0.305553535897825f, 0.828724940454557f, 0.263943455052409f, -0.609183422737396f, 0.691170220321907f, -0.372701931956834f, 0.750237424665146f, -0.249353280856890f, 0.379870697565802f, 0.385751069018950f, -0.515117494253264f, 0.716937491491901f, 0.343749563024118f, -0.462962268225808f, -0.542579750084113f, 0.865163879545508f, 0.348358741505572f, -0.309602240547849f, -0.0504864877295679f, -0.822856269672862f, 0.199343960697129f, -0.790668167630170f, -0.0910655952543342f, -0.0243531696455832f, 0.832501734319368f, 0.604933598167068f, 0.899053047900036f, 0.270668041381131f, 0.523691409964688f, -0.0841567002292820f, -0.844392287920523f, -0.910987838261586f, -0.470654231510287f, -0.103828495683496f, 0.253788695977573f, -0.103172947809401f, -0.339896741661867f, -0.447251997825083f, 0.217200476817515f, -0.474840886373359f, 0.227876267254650f, -0.851351819181938f, -0.902078585170911f, 0.445464427415683f, -0.842484493463611f, -0.141606736723087f, 0.104224619207891f, -0.554900879859470f, 0.818556374444811f, -0.832710463532413f, -0.284760316465868f, 0.697962734672817f, 0.235137001970259f, 0.538298155374871f, -0.598477541924834f, -0.833959821954974f, -0.164556670763502f, -0.443902305525605f, 0.484290717235912f, 0.319356252041167f, 0.0834544406255109f, -0.839174383593280f, -0.514784811627172f, 0.466424623987191f, 0.597641402168886f, -0.344706573843316f, 0.346954604803744f, 0.150560726232471f, -0.963838773301094f, -0.210406119881130f, 0.740751216241446f, -0.519896828058978f, 0.882277568799242f, 0.982734995306564f, -0.691486807580351f, -0.120653164608028f, 0.263039860106709f, -0.472131671311566f, -0.469155525952548f, -0.562705921604020f, -0.737502946123759f, 0.151863404645485,
-0.367233093688652f, 0.149585386378220f, -0.152980596399920f, 0.572826412281344f, -0.498718037086228f, -0.0794332639424211f, 0.659760386972575f, -0.574814983564964f, 0.451329484188896f, 0.473066930128670f, -0.135151886005125f, 0.379571405476121f, -0.308712078323501f, -0.136843563834117f, 0.395667583713552f, 0.196238140324408f, 0.588147058383512f, 0.770505301611929f, -0.865188840370228f, 0.266437694165002f, -0.428134513764013f, 0.661967260527446f, -0.752421375452379f, -0.556389852423621f, 0.424944298468302f, -0.480554454112605f, 0.916159659428765f, -0.112147362457396f, 0.363475545209813f, 0.698805683596358f, -0.862382341730295f, -0.489415523853276f, 0.453056404353730f, -0.606183761884457f, -0.00869682692408680f, -0.288739722701460f, 0.487988005841341f, 0.566870040344668f, 0.0894575138005909f, 0.887832293799319f, -0.0981274237649674f, -0.279935090781560f, 0.506891141525948f, 0.952901245338457f, 0.458002767525373f, -0.569410776125351f, 0.849518291873527f, -0.585020953514368f, 0.676037258640625f, 0.299076264841081f, 0.911385441491479f, -0.954959555659035f, -0.681285607891366f, 0.631368118385947f, 0.522268523899537f, 0.900701101674748f, -0.647701850365577f, 0.567960815808216f, -0.138958982219446f, 0.267024801687456f, -0.975771109955874f, 0.314682157086949f, -0.378801381286130f, 0.665990927256163f, -0.573674360032848f, -0.860450785684384f, 0.516581474078532f, -0.190844183471714f, -0.451971355445856f, -0.808113003973650f, 0.860446168028895f, 0.377778958059242f, 0.126949039950121f, -0.892203650250330f, 0.572503460980517f, 0.975224974978800f, -0.202312370945465f, 0.500665599343084f, -0.0510413720986291f, 0.353231752436633f, -0.805555931906752f, -0.199761377956955f, -0.829487282239605f, 0.0282459088867508f, 0.814545057118991f, 0.557652277921578f, 0.613951716518862f, -0.678811366342345f, 0.896500288318877f, -0.627622562398925f, 0.802545092571611f, 0.211382709497062f, -0.979380222642662f, 0.826784411456488f, -0.670689878657734f, 0.788878029765924f, 0.137070906151783f, 0.901907287859132f, -0.526217367070263f, -0.545043827128876f, 0.494756249972086f, 0.236657948774128f, 0.156603327087660f, 0.516397244064118f, -0.325837179590292f, 0.460683385171580f, -0.196022953760504f, -0.441996357332195f, -0.808932369852494f, 0.291980108741838f, -0.833583979826152f, 0.365574438479475f, -0.797139524158001f, -0.0649288183732912f, -0.000696491493834994f, 0.100125393693922f, 0.598035350719377f, -0.312548404453564f, 0.0414605409182345f, -0.675913083156432f, 0.236245026389435f, 0.550464243484224f, 0.193366907856750f, -0.903654015709839f, -0.00993172527377806f, 0.0180900754210873f, 0.880678290110106f, 0.166539520562349f, -0.984509466189118f, 0.810283124477894f, -0.925371921448173f, 0.193528916069728f, -0.748644561903135f, 0.534508666819454f, 0.364436869280188f, -0.386979667637943f, 0.427958998441480f, 0.362750270039032f, 0.420886957715891f, 0.0300301961707390f, -0.655220626875711f, 0.0504522662127427f, 0.472640818703213f, -0.417745816013639f, 0.0689992794158720f, 0.461232479061866f, -0.483517586427718f, -0.411463769964024f, 0.622740736364726f, 0.659687134578680f, 0.243900134982579f, -0.684356227282321f, -0.688699031115733f, -0.316032121634021f, -0.644296362948831f, -0.236133265458216f, 0.880259454885881f, -0.956880609581177f, 0.737775899964131f, -0.529059297472703f, 0.794119601436042f, -0.375698158660466f, 0.493447663117292f, -0.752511119115434f, -0.941143365329844f, 0.610101048864035f, 0.253791011658991f, -0.369994602049336f, -0.697364270085742f, -0.681360550250048f, -0.571943442128960f, -0.749697324128684f, 0.611997629275096f, 0.892727938106141f, -0.440225399106758f, 0.00196047981855352f, 0.951252158369648f, 0.0351885308766962f, -0.471806546113710f, -0.657231535594911f, -0.0873481442406481f, -0.0341288006282565f, 0.579184398564974f, -0.224334624306026f, -0.298557652719061f, -0.509401519638379f, 0.188853505083675f, -0.321619146497229f, -0.613159956450671f, 0.570042044631281f, 0.699213203307007f, 0.537439231469861f, 0.529440733283839f, -0.744527226912905f, 0.362949055807175f, 0.529758698714545f, -0.114804719889245f, 0.991089489396930f, -0.186716454683287f, -0.218189173574106f, -0.0493780858124198f, -0.928812411399224f, -0.101855573638590f, 0.454268528366586f, 0.617591620012079f, -0.197519518988231f, 0.0973277590468935f, -0.185672509894105f, 0.649922648337967f, -0.896862900376972f, 0.594999589349510f, -0.746978997769556f, 0.590642952628647f, 0.935109901616311f, -0.293310684054096f, 0.783281817912060f, -0.189898897214222f, 0.414859016240278f, -0.0858574647662298f, 0.0810260863380805f, -0.633024441577653f, 0.248442861097829f, 0.984586601784679f, 0.982811638387854f, 0.547456083836220f, 0.476239638753291f, -0.897709902882279f, -0.208045489357872f, -0.860637131636973f, -0.496740558564284f, -0.944185351410090f, 0.157610983944341f, 0.975214099838643f, 0.550265718083095f, -0.630360326400067f, 0.672420341653334f, -0.897139264107564f, -0.670556423663785f, 0.298764071000339f, -0.310465384759529f, -0.978153640586955f, 0.189785151994709f, 0.929291975296760f, 0.758271912876084f, 0.806829662560108f, -0.472787451147715f, -0.802032434276146f, 0.455809631085663f, 0.985520713417984f, 0.739637167649794f, 0.311705106454777f, -0.120539152808323f, 0.977785717545631f, -0.848554870988208f, -0.281179241544089f, 0.931102239520177f, -0.255243432382956f, -0.284952242030900f, -0.189341152192864f, 0.647573166562597f, -0.474203015584843f, -0.545915610099538f, 0.672696420688916f, -0.239274489717776f, 0.956544960216021f, -0.0858024073600807f, -0.758223415922611f, -0.00817763648068581f, -0.500893489164054f, -0.669386983409311f, -0.344450617815217f, -0.728051392792875f, 0.804121117816188f, 0.00718436691280910f, 0.195237363230272f, -0.472485206728796f, 0.642070241911164f, -0.272384993247314f, -0.731715323915071f, -0.791266589031733f, 0.0339783427570857f, 0.0696513783219659f, -0.894169486972683f, 0.00234016305501483f, -0.0403382685361653f, -0.943600572111266f, -0.788181603936192f, 0.851406365407377f, -0.100015982664501f, 0.145502229793638f, -0.528736628076536f, -0.0313760382570432f, -0.662221611141088f, -0.885722031379862f, -0.744257140212482f, 0.524976313116033f, 0.186092035304635f, 0.181669793648209f, -0.606482674165339f, 0.849303544554227f, 0.226118051135263f, -0.690025550727719f, -0.256543384397548f, -0.207714017766381f, -0.447913202664626f, 0.375270273897879f, -0.884312586292038f, -0.0838720085819762f, 0.969898436757285f, -0.736808033249456f, 0.668875150485586f, -0.599937439969920f, 0.470077288925414f, 0.903135367105719f, -0.895619185450694f, -0.637694108244489f, 0.572669535020987f, -0.696211470281632f, -0.820577518545193f, 0.937364674938455f, 0.422458818039761f, -0.593964370461091f, -0.586264791612426f, 0.0282373486927521f, 0.298051147134121f, 0.592825359583763f, 0.716195674857467f, -0.684008410968338f, -0.167523841045924f, -0.370794208549223f, 0.768054740581884f, 0.997835641681024f, -0.366262133888883f, -0.523114034556271f, -0.457946740456489f, -0.530941146838744f, 0.298744841822404f, 0.390761228562591f, 0.0871171594445448f, 0.764002674223649f, 0.233966808661423f, -0.116573523634048f, 0.426118986433559f, -0.255934695328716f, 0.302314199650152f, -0.254971729124577f, -0.330865677738578f, -0.0840307537517577f, -0.711910586170446f, 0.622585361690409f, 0.367595248366733f, 0.422102667722561f, 0.269580206097961f, 0.707083822001774f, 0.625367208198523f, -0.729594790471199f, 0.708679674727951f, 0.00355767003560614f, 0.379158300246371f, -0.688791438249760f, 0.261637457245975f, 0.704008781391790f, -0.917586017594177f, 0.886443038824615f, -0.923559496787343f, 0.360365726214756f, 0.547058288460181f, -0.279853192856989f, -0.996331953899586f, -0.323735921605962f, -0.618788277975037f, 0.314597206161166f, 0.106380963133907f, -0.235044228453968f, 0.0406899091091886f, 0.687339428801573f, 0.344837805924860f, 0.123214914005620f, -0.735264225932133f, 0.0396243248944774f, 0.270602083588730f, -0.316104623194235f, 0.201800731173529f, -0.348987679395254f, 0.994312100135549f, -0.986073454140000f, -0.787571177818193f, 0.508460947811657f, -0.443663972776222f, 0.800303477136838f, 0.712158443474503f, 0.958364684407633f, -0.0512343510942759f, -0.391095518504938f, -0.291911155637644f, 0.721770656984705f, -0.163541232110535f, 0.0366644501980513f, 0.700853097239887f, -0.508089885354834f, -0.375072588159867f, 0.161585369564288f, 0.686325557438797f, -0.113188612544717f, 0.859354598908873f, -0.723198679696606f, 0.398879124170303f, 0.139357627051752f, 0.484780500073663f, -0.0437501438537016f, -0.868783676783105f, -0.147865612288567f, -0.116480069295514f, -0.986846049950927f, -0.859405305954576f, -0.631359938031082f, -0.0310065270390489f, -0.288382201791710f, -0.500960878568203f, -0.805633068309090f, -0.837604329816134f, 0.0325253228618525f, -0.538953832190091f, 0.913844038280417f, 0.681967460199437f, -0.656775429658090f, 0.922492558885196f, -0.689527254640680f, 0.688263898240070f, -0.225450858342925f, 0.0287239965989763f, -0.407744573364816f, -0.477326718671529f, -0.780374037627418f, 0.500400378743065f, -0.532646941279704f, 0.999679272201893f, 0.136003002234441f, -0.811267727922649f, -0.585019862511894f, 0.125465493193590f, 0.203160759437510f, -0.101322607820275f, 0.543784310894398f, 0.630139383695983f, 0.775322422120693f, 0.229262447827729f, -0.656821799421711f, 0.795940998463793f, 0.263281283116320f, -0.377237794697631f, -0.714267543277316f, -0.161924029976839f, 0.804294011825499f, -0.500488029613262f, 0.716655543045374f, -0.709565530287520f, -0.260746944768714f, -0.496886497176178f, -0.896154699339640f, -0.891352204187934f, 0.0589172685048254f, -0.952496908556348f, -0.543314015084183f, 0.0724005345282401f, -0.132089156895576f, 0.694937364018361f, -0.884509342587775f, -0.944587795707932f, 0.346949362800262f, -0.587900264454839f, 0.531217960795664f, 0.404240620498887f, 0.182769547944683f, 0.804826966991636f, 0.601398794220406f, -0.767933817870427f, -0.329693990599177f, -0.880648189418561f, 0.0370834298504716f, -0.405270662847564f, -0.551993194163015f, 0.357335885219159f, -0.442910616174561f, -0.978355051725551f, -0.638907517841606f, 0.266841057307734f, 0.778698832906031f, -0.967180516636130f, -0.772940622039654f, -0.268706136695081f, -0.326082261974967f, 0.0386785617389067f, 0.576293286973562f, 0.446884000380730f, 0.396703264915684f, -0.718633572608705f, 0.586041202195072f, -0.791039546767268f, 0.556638124682382,
0.728711593864679f, -0.576551104247230f, 0.690227524206044f, 0.0451432373341216f, -0.0569690667958747f, 0.877674150343795f, -0.268602876493051f, -0.770720641807978f, 0.630269600593677f, 0.801702094819180f, 0.177071915997341f, -0.0764831522886398f, -0.476930347674815f, 0.0196833210809626f, -0.566188434097295f, 0.309890567123613f, -0.642682312350471f, -0.645839718540077f, -0.985031719881713f, 0.153028235575708f, -0.446724738384881f, -0.616280949001367f, -0.306418078463084f, 0.313048512921978f, 0.944732667717825f, -0.292311689238647f, 0.263616032352334f, 0.776777395064071f, -0.529182830991988f, -0.418996105801001f, 0.286960890623362f, 0.588336822287104f, 0.268219370126612f, -0.696727535489037f, 0.806089151192541f, 0.0396168299208206f, -0.613570658239778f, 0.358002315998429f, -0.0576147175733950f, -0.859664908314368f, 0.930793190364908f, -0.108955403960031f, 0.640347446939098f, 0.0301817512477458f, 0.508435547839785f, -0.774928250619894f, 0.254548271045827f, -0.192551571812315f, -0.401867317012389f, -0.136220787532581f, -0.480363308055205f, 0.146599399729624f, 0.225767301672040f, -0.207158678688912f, 0.763491487133281f, 0.161192803873192f, -0.574968151683314f, -0.454043408746924f, 0.427131132989065f, 0.170648543751820f, 0.0690597676805780f, 0.0360172652133248f, -0.244429817416531f, -0.973014074152018f, -0.172642279134011f, -0.798684796670922f, -0.622626145444778f, -0.743408670602069f, -0.316057396003030f, 0.908608689971065f, 0.948356574904685f, 0.573858539226522f, 0.457065605245418f, -0.246203048690671f, -0.750525340546383f, 0.612971646035183f, 0.951528788403619f, -0.529776510809815f, 0.0886901849846271f, -0.0254136796699882f, 0.978897595553096f, 0.293893753097695f, 0.620217642132267f, 0.862352989549627f, -0.379040515436326f, 0.790157871471479f, 0.147151952442201f, 0.688271487774812f, -0.897847532497188f, -0.0355337105008888f, -0.850253422176695f, -0.0354384862653523f, -0.625796807949394f, 0.851730076897135f, 0.294773618291289f, 0.834287219330433f, 0.0758749738551283f, 0.912613321307355f, -0.326698079590551f, -0.844748577890143f, -0.685263599922107f, -0.197029963909655f, 0.591416614029013f, -0.130921826828109f, -0.524292687689084f, 0.356220524225632f, -0.150091552835503f, -0.935232109847821f, -0.302103008478127f, -0.998557516519010f, -0.477012685701094f, -0.882343341754284f, 0.210797034143964f, -0.963566378978947f, -0.855600913755685f, -0.790231379847513f, -0.625235937382084f, 0.106405105589857f, -0.760544427202586f, 0.0103124858505332f, -0.610157345750845f, 0.968354521575116f, 0.602472069136318f, -0.216458111191680f, 0.935180184275450f, -0.369261245032360f, -0.289325139062185f, -0.772389696964545f, -0.345513639348744f, 0.135539262008296f, -0.747409495863324f, -0.849724942811800f, -0.739393030129744f, -0.0301380087411172f, 0.373808817820448f, 0.760444548005323f, -0.365739960428504f, 0.121859476627292f, -0.719257541809299f, -0.136914676340304f, -0.178479405732130f, -0.336676444507223f, -0.795056125367297f, -0.0872862684496700f, -0.950510559362909f, -0.395266512078238f, 0.636773305385949f, -0.150667208767723f, 0.534401287220298f, -0.349371424663528f, -0.784729313810243f, -0.0510904599006878f, -0.938702345462904f, 0.616929636007953f, -0.228578318449040f, 0.239101663221907f, 0.0390879233281141f, -0.294705782740043f, -0.847928516841798f, -0.0480433695823821f, 0.487351505367245f, -0.820736333448301f, 0.128692585024021f, -0.305133215914817f, 0.344900079505924f, -0.764316168982242f, 0.717529584295197f, 0.655848670831377f, 0.479849611138232f, -0.107624564628078f, -0.345816374073252f, 0.0822414215758816f, -0.0120870567528208f, 0.475870901669481f, -0.00594923432583361f, 0.869227669945672f, -0.262862047504512f, 0.272430399676396f, -0.734262318791166f, 0.980593493214018f, 0.110413869658192f, -0.732486564250777f, 0.470756873196238f, 0.897133387901917f, -0.151953973158384f, -0.591296220619271f, -0.113167158942796f, -0.103020520738423f, 0.220384226627647f, -0.0570027879342681f, 0.0923157145066511f, -0.523010309215342f, 0.385053964060568f, -0.223938668105458f, -0.0566497019068211f, 0.636390081595965f, -0.753651530578004f, -0.765450358896516f, 0.790370075460245f, 0.622949415286967f, -0.0947634056426396f, 0.122381201893998f, -0.138573523511105f, -0.544298107235542f, 0.535416341314523f, -0.341107295330707f, 0.266262786345860f, 0.620108481133049f, 0.190424987800150f, 0.978559599202704f, -0.925772919482004f, -0.300038300695816f, 0.963372836978511f, -0.501235224357981f, 0.828375446308031f, -0.595716120481773f, -0.889271354193173f, -0.389843123593065f, 0.659433696092409f, -0.633476165557619f, -0.708607689555741f, -0.737738480460783f, 0.985245299432648f, 0.976853985813928f, -0.863072444190232f, -0.785830171723126f, 0.309433061520758f, 0.166813366328975f, -0.552916412621405f, 0.0385101740167735f, 0.445866961855263f, 0.222557362424800f, 0.0710515871571971f, -0.368563489700928f, 0.317406114361191f, 0.326902000037272f, 0.868261309598320f, -0.897838476369198f, 0.664364291232529f, -0.373333343843574f, -0.599809263387549f, -0.411236387818613f, -0.118186587264933f, 0.544960929851182f, 0.395925813072269f, 0.337332244255533f, -0.0195528742963547f, -0.580383437020279f, 0.0779554182143842f, -0.902635825594202f, -0.821554429188969f, 0.869996816042779f, 0.646142135585380f, -0.0824693320525758f, 0.643317857725100f, -0.903892480205129f, -0.457595546004975f, 0.540461917564665f, -0.467530238695992f, 0.107497588388074f, -0.122360487746121f, -0.276968072230331f, -0.436413500733568f, 0.0719555518906898f, -0.794937479672675f, -0.641344733876686f, -0.934734152781945f, -0.0610463967348016f, -0.302623058375597f, 0.281116298309257f, 0.557459622053789f, -0.350054779110337f, 0.681853624031498f, -0.0454067482892435f, -0.897204174835461f, 0.0289327275291300f, 0.664312739864751f, -0.368814604980581f, -0.576946854776660f, -0.187886132141311f, 0.424385580259236f, 0.257994303715228f, -0.567650112011742f, -0.0453371545575014f, -0.362909825264387f, 0.450095578912812f, -0.713870209574945f, -0.956583539581944f, -0.969891699048729f, -0.417755773448598f, -0.230738535348142f, -0.153353095644968f, 0.539368458440622f, 0.591116036659417f, 0.779095541288385f, -0.578525766017613f, -0.587777137316663f, -0.301051260910212f, -0.319655538885669f, -0.343495369437935f, 0.908167583226333f, 0.764220052027033f, 0.0536418758245909f, -0.0529753241803754f, 0.249066042857931f, -0.840152142252005f, -0.529971459254312f, -0.449462194610696f, 0.467144819001113f, -0.500103828192601f, -0.758390449663076f, 0.369740436821770f, 0.189153926151852f, -0.188283227959439f, -0.427563759945909f, -0.186773725840825f, -0.00989853573399446f, -0.783648829817413f, -0.626450875837851f, -0.328015817185970f, 0.760383401930071f, -0.00804531008117837f, -0.982799468341000f, 0.392730506677802f, 0.117799138097530f, 0.351088974844522f, -0.259750164530173f, 0.776495358243216f, -0.703059519879109f, -0.362866233240751f, -0.421345310205860f, -0.818968876330675f, 0.936887497269786f, 0.713300632813635f, 0.916608801523944f, -0.147818975792564f, 0.317064988534009f, 0.885779227314381f, -0.897706599297367f, 0.685423132064732f, 0.907830438936990f, 0.0636614655685575f, -0.423018627861747f, 0.411565657893159f, 0.911060408474647f, -0.617833142759668f, -0.709543522964145f, -0.817633731247023f, -0.252433983274424f, 0.160456393103956f, -0.160765428576997f, -0.622001061437904f, -0.470257555319641f, 0.790643274059634f, -0.648181378655916f, -0.828694900506363f, -0.0234091767546987f, -0.562865077760768f, 0.369299949506391f, -0.423850142805423f, 0.520699811923658f, -0.877662359466779f, -0.739844704434180f, 0.300520939787139f, 0.0655718600121620f, 0.970843358712180f, -0.634231195336845f, 0.324880041395596f, -0.479089635857354f, -0.196422753715449f, 0.568762754402869f, 0.699215376070842f, 0.445741923102597f, 0.679868900756090f, 0.107609859752086f, -0.980983474461865f, -0.788419140653730f, 0.0696289436185713f, 0.00330944186568516f, 0.392265626672398f, 0.803469542460994f, 0.131029913648810f, -0.845408454497170f, -0.754797811352229f, -0.824208086798235f, 0.510072775586974f, -0.809491727769575f, -0.0228491196350333f, 0.920014947791232f, 0.441066319826495f, 0.969846842038360f, -0.199024726691046f, 0.886564290041856f, 0.203997575245743f, 0.481547443573126f, -0.637742489331117f, 0.0664642070998316f, 0.109187062068770f, -0.952676759642045f, 0.309247049771982f, 0.880534651306060f, -0.269363005485603f, 0.280012695899358f, 0.853031642671923f, -0.216236966392235f, 0.903180305900435f, 0.837949615815047f, 0.748563816043584f, 0.266735542018788f, -0.685176037557414f, 0.505893787666761f, 0.977721983069541f, -0.667151469253569f, -0.451774081267849f, -0.385755850727233f, 0.681037251596535f, 0.550130384863457f, 0.704080312734731f, 0.519624533199220f, 0.789651392050294f, 0.176325856625025f, 0.684011432098839f, -0.469125761119035f, -0.841814129063957f, -0.901473334652527f, -0.117747872709914f, -0.608533033968273f, 0.199709646080986f, -0.349430401438670f, -0.435162733168206f, -0.368150014673779f, 0.699084004342174f, -0.446068942643995f, 0.197420740774886f, 0.524893584115327f, 0.706475758890142f, 0.912020785879679f, -0.820472223153770f, -0.334742316079635f, -0.851724976994477f, -0.702164662784812f, -0.649654462810552f, 0.411435475616403f, -0.0438368033650360f, 0.799231452421757f, 0.713371883779316f, 0.252437083518609f, -0.685658163265283f, 0.0734649179831324f, -0.400549431226783f, -0.415602545578540f, 0.233864615718965f, 0.828846528739923f, 0.606577491175688f, -0.266016048272811f, -0.619106744484090f, -0.690853262778644f, -0.503499724631377f, -0.409761822901473f, 0.0576293548519007f, 0.551582021066584f, 0.132631452787255f, -0.838228405334512f, -0.107475742619267f, -0.875306852866273f, -0.184700469068763f, -0.317074087896838f, -0.580912620700556f, 0.453916157844897f, 0.690470988649940f, 0.712835197480083f, 0.314786689622726f, 0.759835688452120f, -0.671090442836235f, -0.408277610289776f, -0.815988422173708f, 0.227854929660384f, -0.0482646895577266f, 0.968141192561708f, 0.373896367655818f, 0.820435826598941f, 0.817746838197885f, -0.0970819110331989f, 0.679170154451559f, -0.577986561676471f, -0.0523570914231941f, -0.776930151133931f, -0.560456597170701f, 0.927747720961181f, 0.0350177837302503f, 0.844938034137843f, 0.00849044473190053f, 0.325089161670337f, -0.851825175889265f, 0.835251667623832f, -0.266397917890485f, 0.108463887056499f, -0.817868888235156f, 0.590399913800720f, 0.699274619715208,
0.200782223352391f, -0.936155874445214f, 0.218471971175575f, -0.890402779861849f, 0.268496441855317f, 0.881231954583528f, 0.279360358017994f, -0.492400368838405f, -0.894376670076375f, 0.585129064098519f, 0.340135248071744f, 0.455880107692993f, -0.861081993524584f, -0.303321115935151f, -0.562781799622214f, -0.526041750296426f, 0.999581943964160f, 0.249814139040315f, -0.0537475603822974f, -0.845239239849439f, -0.874024176808607f, 0.997751771128387f, -0.861617607547820f, 0.671357923629889f, -0.687974310115279f, -0.969462039056016f, -0.448304961870341f, 0.713064428261850f, -0.00718668165564318f, -0.450608596544700f, -0.106059234376561f, -0.591961308554238f, 0.588633089685867f, -0.755341317752403f, -0.542715401462936f, 0.759199260356047f, 0.0297710796506234f, -0.997343196630657f, 0.574076752994254f, -0.696719940193256f, -0.852227517176613f, 0.906332566627663f, -0.171801252847090f, -0.925131151948528f, -0.0212194634560026f, -0.940316444070044f, 0.262965279952363f, 0.902198615594563f, -0.265057066430189f, 0.161983092277652f, 0.0181345459457500f, 0.467973650469608f, 0.857351800575040f, -0.889882538061811f, 0.728868283859490f, 0.671187732362764f, -0.296882575397444f, -0.793099233276668f, 0.335561922676737f, 0.0671874495572633f, -0.0857142329385701f, -0.352870876674233f, -0.119927139078065f, 0.814127111105761f, -0.323910302649634f, -0.313495077982818f, 0.0690526899468447f, 0.877155536890319f, 0.768040884649443f, 0.158910636324140f, -0.824414709871474f, 0.00718921022841235f, -0.868917281154898f, -0.564967532196669f, 0.206261416621150f, -0.0699574404456100f, -0.0547095858591442f, 0.811674902353136f, -0.562993920383635f, 0.441212008804309f, 0.917951119557396f, 0.915571961092301f, 0.0901952529553498f, 0.614118141118295f, 0.760473529905706f, -0.566505475760865f, 0.00880029006400429f, 0.975626259597421f, 0.370738159620831f, -0.0242162976348563f, 0.828887690189252f, -0.665240810020082f, 0.00123256686221063f, 0.184020074202841f, 0.829917510366750f, -0.447854906466885f, 0.529356328938248f, -0.995192699858126f, -0.843748622724646f, -0.422765372440245f, -0.386179414096638f, 0.206325400140261f, -0.369817591904938f, 0.266933785902425f, 0.892617584642659f, 0.740018647415220f, -0.481907279471296f, 0.248268418729551f, -0.382770749117505f, 0.974424303757207f, -0.879320252286332f, -0.0294961755317245f, 0.638693329623790f, -0.765127178629299f, -0.160881380476610f, -0.725001019123526f, 0.00294709357263234f, -0.701949969294570f, -0.708933381768328f, -0.463893635537772f, 0.476650147791524f, -0.206043208566879f, 0.223011684523516f, -0.258637160422673f, 0.206325908651728f, -0.432336904344548f, 0.921979975841259f, -0.944396630315761f, -0.00680582426415510f, 0.319263487872783f, -0.836389324192867f, 0.111532890274445f, -0.938142383682239f, -0.637288670131655f, -0.834211558255576f, 0.251969378874330f, -0.970874587083192f, 0.831662411079802f, -0.446568187924869f, -0.659109068071113f, -0.877869176622375f, -0.890670252448197f, 0.477602927742628f, 0.324737705007923f, -0.147513413112549f, -0.186594638422632f, -0.282864808082840f, 0.745093922271927f, 0.915500859154332f, 0.0421588655873384f, -0.483320910754088f, 0.00503734690385604f, 0.555792895688253f, 0.129412601050279f, -0.229347983583150f, -0.680101211823600f, -0.866063899229274f, 0.437769924839021f, 0.133958234316391f, 0.589233411145099f, -0.498053917701437f, 0.180863681584405f, 0.525955777469479f, -0.581250985307273f, -0.327934857804250f, 0.482381204171926f, -0.867703472610278f, 0.833733008515087f, -0.607761820334944f, -0.758512235503178f, 0.0380785706067470f, 0.719862150842292f, 0.651283470517919f, -0.614218162858801f, -0.239754124815405f, -0.733992057859951f, -0.422541764223845f, 0.951215428883086f, 0.882569470276544f, 0.937054481646402f, 0.184532408731968f, -0.104097666585483f, 0.693277433170057f, 0.800241936558839f, -0.998230532922071f, 0.259835639125661f, 0.562745639592536f, 0.220441127510705f, 0.313735993201991f, 0.330940415696351f, -0.602872424656300f, 0.841677792852844f, 0.749701489563795f, 0.266727039860087f, 0.696379094133993f, -0.430719144952456f, -0.276768289732264f, -0.0872580230244173f, -0.722033206227688f, -0.837309584159114f, -0.629739366225350f, -0.185692585028452f, -0.110619837317415f, 0.515881116042359f, -0.105875685978079f, -0.513700186568578f, 0.961245417898430f, 0.655513716233953f, -0.0921704793645632f, -0.694925472850399f, -0.872174817305748f, 0.0307133806779607f, 0.531120672076921f, 0.965271277398122f, -0.00974420246777163f, -0.497322783064087f, 0.693565685926388f, 0.546918707342947f, -0.230039497490898f, -0.316024461029338f, 0.684231559582941f, -0.306362794944468f, 0.861366189035942f, 0.378922635334764f, 0.259443877770437f, -0.838617128408830f, -0.205350631644011f, -0.139772960377519f, -0.192918167939180f, 0.602404904043886f, -0.537407583974730f, -0.877007125624351f, 0.361539942609439f, -0.732030207831016f, -0.488792995226420f, 0.612591017966442f, 0.567185560938756f, 0.195543595335781f, -0.428955670554558f, -0.666590144318038f, -0.702467396810860f, -0.894350832807439f, -0.0620405855731709f, -0.583114546325259f, -0.482155957064968f, 0.212152442925647f, 0.112603107288251f, 0.0683986906619714f, 0.639176340917929f, 0.642610005510521f, -0.708605273163374f, 0.739594669131005f, -0.492786220480274f, -0.308196102291547f, 0.918748221553053f, 0.186736140989674f, 0.438437026242591f, 0.638769573344929f, 0.928896220524135f, 0.579945520523175f, 0.218608554904045f, -0.526070140579576f, -0.140303420071590f, 0.304347769360423f, 0.488123173638490f, 0.987207018313181f, -0.536397951752998f, -0.553296120219359f, 0.184294880372153f, -0.101502970339396f, 0.287041514309517f, 0.658172721877726f, -0.270141883431914f, -0.0196021946303913f, 0.000779126872975988f, -0.0500294515684538f, -0.588505226599557f, 0.550916571982769f, 0.703271386531766f, 0.982335628009701f, 0.942133544852489f, 0.690741953320684f, 0.0466423349204477f, -0.941178278727504f, 0.121655023640973f, 0.777925151322362f, 0.132430336075323f, -0.114812120408198f, -0.694094073965245f, -0.441397675924967f, -0.187253074701348f, -0.672248118097589f, -0.688869123609503f, -0.0723581859661586f, 0.553779536791160f, 0.380610143087564f, -0.392032089052147f, -0.709403552653908f, -0.607184251637473f, 0.698227587629545f, -0.272885954851784f, 0.0736609147840435f, 0.687106303730018f, -0.230362931709251f, 0.393640839382244f, -0.846905732907407f, 0.0727598538725249f, -0.0119849190815611f, 0.470122652313157f, -0.171681529301612f, -0.329268850654460f, -0.433013841687086f, -0.943499527192280f, -0.123404693276305f, -0.0861435714812342f, -0.228816973160929f, 0.0531549757963279f, 0.901446101051298f, 0.470738280922993f, 0.238383552115632f, 0.292841887198914f, -0.617423653544601f, -0.865786115828523f, 0.586332203179351f, 0.267618252846898f, 0.888575002575769f, -0.0220649407038027f, -0.946385428026066f, 0.317436113017866f, -0.277195072909682f, -0.207326502081016f, 0.735387675940421f, 0.961386190882120f, -0.564038045970629f, 0.840007249305217f, -0.262593952346269f, -0.556378761937190f, -0.346529850864238f, 0.00895460576800877f, -0.695431082536551f, -0.105261635693881f, -0.658342101938401f, -0.631093613961188f, 0.601639903111316f, 0.886830692209879f, -0.600591324826329f, -0.350296019796741f, 0.294348102011741f, 0.555826495708193f, 0.216370653207427f, -0.672654026881445f, -0.572202359802723f, 0.202776438466314f, -0.490708964058038f, 0.0148723360197853f, -0.799031226692943f, -0.221164759306209f, 0.0323674121757880f, -0.130290693568615f, 0.613592603765503f, 0.372755498065474f, -0.540502917956863f, -0.740021877141017f, 0.652888612951242f, -0.666157898478327f, 0.476156241264794f, -0.632081251666311f, -0.538341981270842f, -0.275717185193560f, 0.332983363477103f, -0.989659450166330f, 0.212868816589688f, -0.238985653168422f, -0.453005976359810f, -0.805975530848911f, -0.948192632970312f, -0.291329963979224f, 0.549811667826684f, 0.291147979443248f, 0.909805561757383f, 0.0728533843443158f, 0.737767652888933f, 0.605331616290165f, 0.274826946403577f, 0.710517586349601f, 0.666670055891909f, 0.522059053677516f, -0.553398792071804f, -0.406610321679562f, -0.893232547853708f, 0.549587730399741f, 0.714498083720551f, 0.281833380830291f, 0.652788061587949f, 0.825163748516741f, 0.381299333971584f, -0.485549061474930f, -0.881961689917888f, 0.308937809723222f, -0.524542880617761f, 0.329114405956449f, 0.434631551667457f, -0.894732322264538f, -0.831528385961058f, 0.669760583803638f, -0.674650675537928f, -0.373119878846435f, 0.456602566684508f, 0.387804792569985f, -0.556983911869482f, 0.000826745899317194f, 0.687973801099889f, 0.0471935422816141f, 0.0768302380434509f, 0.317557055919800f, -0.823316513699125f, 0.394699119350099f, 0.609556161256400f, -0.0413041171293194f, -0.244100882405517f, -0.939678976894569f, 0.403390183804743f, -0.933567523933859f, -0.331149894636631f, -0.0265881324103010f, 0.224249195386459f, 0.888271870759308f, -0.119845268644579f, -0.357275416804345f, -0.597001288429956f, -0.486847206619720f, -0.181232488650601f, 0.115441291842326f, -0.599055795186955f, 0.213179364205327f, -0.205238322081458f, -0.373942142629613f, -0.610680997090469f, -0.495737765362772f, -0.257634306994249f, 0.583708320566486f, -0.372047136603982f, 0.953878668619925f, -0.632595987923462f, 0.452049761997455f, 0.166602807787896f, 0.773555002555059f, -0.277154387560832f, -0.557129156714301f, -0.985242402457283f, -0.441173064787937f, 0.561221765682284f, -0.352004972295446f, 0.970292440826449f, 0.855523836321424f, -0.528113079339624f, 0.685454746939680f, 0.322200261898966f, 0.953249967336372f, 0.825673980624808f, 0.177229970128320f, -0.728281956776614f, -0.479030792350269f, -0.00697019557862144f, 0.851652517094715f, 0.853865750362844f, 0.514736989335681f, -0.943509205199198f, -0.0524009027225623f, -0.0798997671509367f, -0.355414349557791f, -0.366273957594958f, -0.565729285138989f, -0.931573923976439f, 0.345119269147864f, 0.638375370217726f, 0.711524360229150f, 0.331664704859388f, -0.986788646426241f, 0.521200596781614f, 0.656290865944842f, -0.436907564088290f, 0.305075696150381f, -0.848337345127939f, 0.354044695448027f, 0.690691708552038f, 0.900352213238582f, 0.475181192463882f, 0.219103309687964f, 0.885437995493547f, 0.421455288320496f, -0.879874221804522f, 0.893371290952196f, -0.545214090169942f, 0.800731783168682f, 0.249421864783476f, 0.0766192343033301f, -0.745747520609971f, -0.613575150364454f, -0.700199720327423,
0.0694373671332735f, 0.759953164582251f, -0.0973030480378387f, -0.298615297250225f, 0.0176506580013247f, -0.269562553201540f, -0.405489169051539f, -0.00491991297033256f, -0.0327449030548885f, -0.688168836745951f, 0.703014457338754f, -0.0909491575673764f, 0.738417882180070f, 0.202377973915515f, 0.338436193625848f, -0.408790267504483f, 0.611776208408261f, -0.711043784659083f, 0.841495665411188f, -0.0445715899008592f, -0.127281559164749f, -0.778797832908623f, 0.210344625249896f, 0.287086540530447f, -0.703702357088620f, -0.151146112491418f, -0.785180444786487f, 0.427963227387140f, 0.873814130606035f, -0.344356753075357f, -0.755726746591465f, 0.846013365191461f, 0.126678120904524f, 0.166687962199295f, -0.148273386834835f, -0.770559345875477f, -0.999129219024862f, -0.223692721084046f, -0.652712854614213f, 0.468054498362978f, -0.911782175948953f, 0.555084850374905f, 0.103972972463380f, -0.414021910330282f, 0.938793897617340f, 0.515461292224815f, -0.127677414947037f, 0.510661477088580f, 0.898409443447962f, 0.528096097102698f, -0.444620870908750f, -0.275909952832928f, -0.516074838791812f, 0.110104492330694f, -0.293114842926621f, -0.596621371059734f, 0.152807456749103f, -0.592864305196648f, 0.948295231208874f, -0.575278847840010f, -0.312463646261757f, 0.664597237604897f, -0.177619554099550f, -0.932259652303036f, -0.295074750863924f, 0.731539128777660f, 0.860409131570119f, -0.0947206503071862f, 0.106073387018718f, -0.235389180430490f, -0.494787189603633f, -0.536357147973158f, -0.680862001049455f, 0.618979489665256f, 0.613893487415732f, -0.308605775713246f, 0.694789556987429f, -0.440049894326668f, 0.908690328690240f, 0.233612239829512f, -0.190662564463532f, -0.344799878911344f, -0.185877286582818f, -0.553543917790750f, -0.859543533414720f, -0.996044831818542f, 0.0388505104043095f, 0.650508591477642f, -0.425233346101631f, -0.576839967180874f, 0.378730359294024f, 0.531713629917424f, 0.506096660522796f, 0.854779196325727f, 0.725302682547051f, -0.414685510902716f, 0.654208477287561f, 0.580368151427426f, -0.000356066597174687f, -0.897393734991154f, -0.845565244312410f, 0.615044057364182f, 0.0434592638759266f, 0.342119048500289f, -0.696414680186901f, -0.713269554140146f, -0.580866925323696f, -0.290886355957456f, -0.473082507703548f, 0.517942229000179f, -0.846159512055215f, -0.715410253368047f, -0.526272663742330f, 0.114004124940380f, -0.207397773975621f, -0.920379649009572f, -0.277970833475531f, -0.636533427057722f, -0.972531734576472f, -0.687000156900366f, 0.872752357637196f, 0.617872391924648f, -0.835274231587444f, -0.383282792481497f, 0.399233665040770f, -0.191230601890140f, 0.620222785371960f, 0.106379326744619f, 0.987222511696630f, 0.219022023664391f, 0.179689082166371f, -0.961619514581522f, 0.570178582343486f, -0.811091514477978f, 0.924484469376845f, 0.744507591138529f, 0.272936430096096f, 0.0646316580619510f, 0.314005111302676f, 0.558833629327024f, -0.329744916784918f, -0.544045568909541f, 0.895769679770795f, 0.798125821580789f, 0.877473384028199f, 0.616163339432501f, 0.441057381106904f, -0.642498173762053f, 0.989059595616979f, -0.374771110304453f, 0.480877593471524f, 0.904941689893360f, 0.428742160807762f, -0.430483645585549f, 0.0830560957640680f, 0.694220841170708f, -0.602964792788891f, -0.522672782287498f, 0.717494777479591f, -0.918002255923909f, -0.454075191574169f, -0.378662039464110f, 0.221482629450150f, 0.750918040362614f, -0.636211037178780f, -0.254529141198887f, -0.944623201010144f, -0.720775773991847f, -0.674641067104323f, -0.208243950413264f, -0.959488786545901f, -0.619966503980330f, 0.599486634018692f, -0.0955439064236721f, -0.458181000169795f, 0.736914498713083f, -0.176789993854223f, 0.676652697410790f, -0.967275583857650f, 0.319377813603719f, -0.427030468653864f, 0.0670640089595258f, 0.769945699222976f, 0.767923203047440f, 0.985790354694142f, -0.207111795449682f, 0.219134401666738f, 0.548513609112215f, 0.977227384558063f, -0.198131173309759f, 0.914163808432723f, 0.178214485462450f, -0.240590252223318f, 0.356128697574950f, 0.453093488702627f, -0.0401152114159198f, 0.818060948361957f, -0.880551400213416f, 0.631519794065582f, 0.658832307703964f, -0.179752451562622f, -0.237844011105596f, 0.739834592198990f, 0.711355594921083f, 0.774856912009109f, 0.321864249971600f, 0.470574585274056f, 0.261964793641569f, -0.634481134262705f, 0.461363065389595f, 0.0879014163867016f, 0.698353456328335f, 0.0611830044908546f, 0.918599000791453f, -0.147822590771951f, -0.208296009525534f, 0.775436805889909f, 0.0380914463017457f, -0.954468558268744f, -0.620451283908529f, -0.770251739379244f, 0.772246778681563f, 0.326462458587915f, 0.417738473564738f, 0.0942643452092895f, 0.486153909005530f, -0.720202618855819f, 0.0172425211828453f, -0.460430186764708f, -0.582933725313246f, -0.439721219285309f, -0.694337374508112f, 0.493516461453915f, -0.993527345413430f, -0.562763570629586f, -0.0644937992008268f, 0.741476357523546f, -0.668588797988340f, 0.594184164979780f, -0.605220767543645f, 0.110074204567278f, -0.599398769115359f, 0.723882026196765f, 0.678747828159456f, -0.608589528492249f, -0.881419419882399f, -0.139357674240927f, 0.873828011683502f, 0.314798068434754f, -0.457017849147976f, -0.526003289738433f, -0.411404919696823f, -0.792254466556923f, -0.299635866135236f, 0.0102316480137963f, 0.161921266554201f, 0.981427028530907f, -0.647351555346480f, -0.183312260273700f, -0.348651484808239f, -0.198142718294920f, 0.589869434168343f, -0.201926511662287f, 0.0337896878721506f, -0.0276515055864679f, 0.236943449722327f, -0.473103622922213f, 0.954358213176107f, -0.536519478008862f, -0.603363977756898f, 0.776267386457251f, 0.780662223932714f, 0.289187291033147f, -0.439954328280331f, 0.0429585232791456f, 0.457321950803212f, 0.236810565417317f, 0.167393310927116f, 0.634521586990289f, 0.154409349572581f, -0.750588956901316f, 0.862647670558265f, 0.800182258889404f, -0.342011510602950f, -0.102697321575297f, -0.797254530582515f, -0.718599505627591f, -0.729105921762328f, -0.152424255231618f, -0.702781451563249f, -0.0212710413372206f, 0.961258625954530f, -0.598484979483616f, 0.188043416567111f, -0.511990501189325f, -0.437449883017104f, -0.352443017251219f, 0.0991554004559394f, -0.663282401319921f, -0.835139403797870f, 0.587602722898819f, -0.939771062270554f, 0.613878515061637f, -0.523857415147229f, 0.444842501987166f, -0.297001528475358f, -0.914581150341453f, 0.554844832376064f, -0.816400014706997f, 0.823726509832068f, 0.704425080572720f, -0.819397910034912f, 0.999003444973468f, -0.968751535943602f, 0.0311500939174130f, 0.247867291448898f, 0.835560943875924f, 0.169794916341582f, -0.302041142019408f, 0.289549413666482f, 0.672141268085176f, 0.947060095876251f, 0.324754171403184f, 0.800014020753458f, -0.785428883146460f, -0.463092135879982f, 0.659192831110219f, 0.118301326248760f, -0.542297334341874f, -0.335957421787428f, 0.794808066256455f, 0.625133567458879f, 0.227917183877260f, 0.533557157748932f, -0.948877884679630f, 0.186417887458649f, 0.859592912781013f, -0.0183320237921572f, 0.967066787435574f, -0.141349529637213f, 0.958107445094614f, 0.264359167622140f, -0.631325355674829f, 0.684598042547604f, -0.527467468151933f, 0.294659298854560f, -0.439220168509424f, 0.391038218778621f, 0.0155669207052447f, -0.681384294454809f, 0.146739459198561f, -0.756404876084652f, 0.381192113543008f, 0.442850940158445f, 0.964002016096921f, -0.0507253848694798f, 0.563462880019551f, 0.190980650425415f, 0.482598778123453f, -0.273426091300166f, 0.980640722167518f, 0.198298590133615f, 0.678100193958147f, 0.530416610025615f, 0.196483886579908f, -0.00515783872303177f, 0.0273438459465027f, -0.257248394117661f, -0.576964504105195f, -0.331030677719652f, 0.389178134459083f, 0.0714066784585938f, 0.915179137858455f, 0.529738860096996f, -0.0851681338619263f, -0.692212896293625f, 0.0786352959300358f, -0.122712774017974f, -0.154641019547052f, -0.487537192251297f, 0.0435645872670241f, 0.856938631597551f, 0.351874085305670f, 0.708100804109985f, -0.701200509799317f, 0.0804479422214388f, -0.0794375302823220f, 0.543751723132725f, 0.346144383452864f, -0.680373368944156f, -0.572281173045994f, 0.237981706511708f, 0.0671482960376590f, 0.852393956008547f, -0.301262907769845f, 0.523762878044853f, 0.0885512158718469f, 0.885168455552951f, -0.333351382431635f, -0.914187358461713f, 0.657220242471575f, 0.202238670865175f, -0.660684692864216f, 0.641271628674064f, 0.795923699912913f, -0.332641448887164f, -0.297595219329770f, 0.427283618553541f, 0.601893958036382f, 0.355248259075043f, -0.420766820174961f, 0.355159952778514f, -0.806733697216087f, -0.694403711049608f, -0.719250654428532f, 0.580487742419744f, 0.959156165420351f, -0.941898541689400f, 0.960568821753178f, 0.119007749103819f, -0.973468502734443f, -0.627534816021182f, 0.331394418445345f, -0.415230278112412f, 0.225355270950915f, -0.216818510922154f, 0.716553646689289f, 0.149097723527982f, -0.212491921692561f, 0.681645638056938f, 0.675358683729395f, 0.0591550775861416f, -0.221626142364110f, -0.235878877821190f, 0.168188057112471f, -0.709738432254387f, 0.842890391064944f, -0.331175752377862f, 0.231375360302226f, -0.714989093452242f, -0.492645353426504f, 0.552424848261518f, -0.436987392663331f, -0.336155191719795f, 0.137666231065822f, 0.739347397348610f, 0.493222787180627f, 0.283646543313800f, -0.603522923409923f, -0.474181275984451f, 0.249315354427624f, 0.323736714335287f, 0.933612934150728f, -0.651555022796413f, -0.743229221575077f, -0.648309364385349f, 0.115117716036212f, -0.0689988553878600f, 0.0394979772968704f, 0.732729774997258f, 0.487584669162102f, 0.808754952095239f, 0.827617962775983f, 0.550826738558347f, 0.890858298785235f, 0.152998196795770f, 0.401198245071198f, 0.187173931669199f, 0.576387011979054f, -0.464903903379260f, 0.735172244343599f, -0.0393734341215035f, -0.501927105416023f, -0.852926247859480f, 0.384774001880198f, 0.723957370923565f, 0.869614310250896f, 0.698124990202440f, -0.0618370378422302f, -0.273879540781302f, -0.0745005910544518f, -0.754408143155094f, -0.859084370639359f, -0.709011936778905f, -0.883595552533659f, 0.326386065122049f, 0.756686513420982f, -0.639817612043620f, -0.536531544653662f, -0.596858657734988f, -0.187117983404806f, 0.760208405412209f, 0.191383034225783f, -0.771443976174702f, -0.371171018178012f, 0.723338724416329f, -0.325113980261468f, -0.652823731845602f, -0.902765567501679f, -0.109945188610355,
0.863727536109734f, 0.762531987550249f, 0.484671237555863f, -0.376731181566557f, -0.961176245257487f, 0.374503763045540f, -0.275274129954644f, 0.947951135663002f, 0.891610575724484f, 0.233179187366345f, 0.868694446846928f, -0.201812205484274f, -0.676342903796604f, 0.962133604967067f, 0.0941637112283598f, -0.0856261317646829f, 0.375061189807232f, -0.275342940020193f, 0.0614298144531287f, -0.183234253182376f, 0.146964792162229f, -0.307180215012337f, -0.139123531176191f, 0.130840221889238f, -0.0654726742084248f, 0.988722897887987f, -0.805684911622576f, 0.763299463922693f, 0.148136188784880f, -0.432183160161832f, -0.592185939638987f, -0.593835208842770f, -0.366135084813261f, 0.840566739882685f, 0.572052978307971f, -0.825682529425410f, -0.970222226210689f, -0.554421263584439f, 0.324648156825255f, 0.0472246837302466f, 0.168098848238140f, 0.00634984653176796f, 0.850237261066903f, 0.286624344510407f, 0.196043215794080f, 0.289161416244007f, 0.334801090322515f, 0.871286740072183f, -0.754609531300255f, 0.623871003889383f, 0.0843430009639772f, -0.736369938040848f, 0.400507674511444f, 0.816325383600297f, -0.500667496861800f, 0.453092855162135f, 0.281798170796444f, 0.631969623501011f, 0.472467114651372f, 0.525988741184527f, -0.124862967293674f, -0.882904489381606f, -0.501090007558747f, 0.631622297793485f, -0.0234210285578584f, -0.521093811962915f, -0.0402368492672573f, -0.762999364505356f, 0.948716268452360f, -0.572740830308272f, -0.261042904339051f, -0.506108365537530f, 0.585933508412429f, -0.362463094458446f, -0.885375028242576f, -0.835757117571791f, 0.337250829139564f, 0.298618238243588f, -0.744903291826588f, -0.979848674056393f, -0.488518944548476f, -0.000297116577397283f, -0.137863396173336f, -0.627207234158244f, -0.970417810284170f, -0.601487862773028f, -0.999527775716382f, 0.116672274325216f, -0.786330829714504f, 0.740118245374718f, 0.856485463622646f, -0.555144930193560f, -0.0168912375666686f, -0.774544329159697f, -0.782767315598991f, -0.600844843420598f, 0.885816107471180f, 0.577075799078571f, 0.663829997048111f, -0.359000184287277f, -0.390009578642891f, 0.202240602818017f, -0.0191477232064394f, -0.566459499064884f, 0.288883557382261f, 0.962583478738218f, 0.782123756762393f, -0.312311582870785f, -0.749354208187204f, 0.205679267602357f, 0.804004517387718f, -0.733078779233144f, -0.426195645938973f, 0.686872484317089f, -0.398704803137823f, -0.267786412313359f, -0.374306263341615f, 0.632992513422251f, -0.972217744254910f, -0.167080739523409f, 0.608176739669718f, -0.935550125875275f, -0.422451600932096f, 0.499643952974426f, -0.491034978653149f, -0.0256130378373849f, -0.158669355267388f, 0.360503946885584f, 0.227714934784132f, -0.138648043280479f, -0.0707461296301128f, 0.0638330442765616f, -0.168811643868974f, -0.575670642767690f, -0.162143785491822f, 0.528621079903453f, 0.581283330394272f, 0.444430744183000f, 0.859288341846780f, -0.170487584890459f, -0.440175706710406f, -0.184806402672108f, 0.676010805169568f, -0.0117535553470483f, -0.231606756742133f, -0.210042044569361f, -0.517950708003565f, -0.805772781723687f, 0.156938933772370f, 0.892075905739393f, 0.403874478002384f, 0.572031508558373f, -0.604145909072008f, -0.330076696654475f, 0.0314560087228033f, 0.683787496948704f, -0.788582181996934f, 0.835276281386949f, -0.0644658492206380f, 0.938270191882745f, -0.344927907293928f, -0.976720519493346f, 0.906264084343827f, -0.648152742145255f, -0.776984965421811f, -0.299470572593974f, -0.423690646950321f, 0.749911693814570f, -0.701929894551648f, -0.665191316321370f, -0.568359320650352f, -0.957309362369509f, 0.914088966355983f, 0.770952996203681f, 0.0924190787439159f, 0.844599990803978f, -0.613336716591875f, -0.683270165308367f, 0.358563204319583f, 0.934597169812267f, 0.236596595813630f, -0.895964332479994f, -0.673302324943916f, 0.454883302340070f, -0.473926010524343f, -0.576000657136217f, -0.644850950007290f, -0.980218836434995f, 0.321620362364719f, -0.799924718666919f, 0.0619872524925393f, -0.609255645268410f, 0.159243124858648f, -0.339764623434603f, 0.379865023026277f, -0.923132229333074f, -0.0300494021321296f, -0.183835365297645f, 0.122648511393234f, 0.887652015676064f, -0.616448517838488f, -0.920600866006207f, 0.352861591267815f, -0.930578364778234f, -0.378819076263050f, 0.775423778544869f, 0.836977798656885f, 0.0472244767469148f, 0.484934339557912f, -0.939155187409193f, 0.261555270800537f, 0.143595058480400f, -0.323517719771947f, 0.483466454684928f, -0.423163689969697f, 0.356966814701025f, -0.843907304366205f, 0.945903563730962f, -0.495952298317153f, 0.972277051575873f, 0.153052037173145f, -0.715894882755676f, -0.617028915483254f, -0.332307224095366f, -0.171207102890728f, 0.841771328272651f, -0.0308707743261867f, -0.626480028747696f, -0.729235538916864f, -0.743517330301179f, -0.733868915239511f, -0.449192858200231f, 0.362286468575150f, 0.327436676142902f, 0.609768663831898f, -0.147499187968100f, -0.470195300907973f, -0.232167856443943f, 0.225074905574485f, -0.0818541072414634f, 0.793403933843056f, 0.267628199755028f, -0.391701371806294f, -0.846991992740029f, -0.776221590294324f, 0.121351482320532f, -0.189789365942677f, -0.894392208695015f, -0.632864319945356f, 0.927817761109627f, -0.732454610273421f, 0.260011686544283f, -0.713973491605344f, 0.469764032416604f, -0.608895265807545f, -0.684992974060601f, -0.745556289276139f, -0.536308213076133f, 0.586581187207818f, 0.149804345860779f, 0.401576742698496f, -0.719670291046630f, 0.618659855530024f, -0.256639783379370f, -0.862966031725668f, 0.893866512913152f, 0.861800793529066f, -0.704895723095590f, 0.154163397540805f, -0.0775797186536984f, -0.252297335448882f, 0.869851864160888f, 0.428747373815147f, -0.818372805928921f, -0.739117647833389f, -0.697378012429133f, 0.182997863108567f, 0.689563104159966f, -0.0506114067037338f, -0.705077813920782f, 0.452892458862023f, -0.365069844049503f, -0.889224821648518f, 0.0194889225677406f, 0.847743515500726f, -0.0650338075825718f, -0.108889937983496f, -0.168485037502421f, 0.912533003086865f, 0.428132366084106f, 0.692652998111620f, 0.130599999674344f, 0.411245435867244f, -0.194909473459497f, 0.562152151569866f, 0.503795293326445f, 0.801805532943245f, 0.795718119772331f, -0.327975015537058f, 0.771389506217327f, 0.237139782375987f, -0.793798852884360f, 0.537824655594807f, -0.0767253125021830f, 0.444538451472890f, 0.623473048970629f, -0.500663871860675f, -0.890399840538612f, 0.389528755348857f, -0.915832255765501f, 0.000652855725217894f, -0.121310443088642f, 0.206662014558968f, -0.409513641801496f, -0.0496262665388731f, -0.313314447256644f, -0.994839397423865f, 0.344513198428247f, 0.250828855150578f, 0.845438302422055f, -0.728803841305459f, 0.249670562418639f, 0.543601559270672f, 0.0138774767713057f, -0.0667600054234216f, -0.803421294778238f, -0.222729734665659f, 0.461896933387103f, -0.378537171475208f, -0.464200027877777f, -0.363170335357481f, 0.616070694104851f, -0.316407896795124f, 0.131719997218670f, 0.0622146037260092f, -0.881713850066484f, 0.400811652868418f, 0.163777537634682f, -0.528768052383715f, 0.553072310703894f, 0.931393033749660f, 0.410062835546529f, -0.190904471223264f, 0.0533617852685424f, -0.911780226731855f, 0.823696403963215f, 0.756735978125573f, -0.849701310148249f, 0.106070214350541f, 0.747890454578944f, -0.559823302095172f, 0.976181619002882f, 0.506524051225122f, -0.0735228576098872f, 0.635610640336510f, 0.607728217052133f, -0.383443012662118f, -0.640835123345673f, 0.0897243696426577f, 0.722421963278953f, -0.368833835044170f, 0.684790387373836f, -0.0336846755494535f, 0.199819176553169f, 0.351822803019512f, -0.433387005248570f, 0.709401898386598f, -0.0149217994364210f, -0.549115733466769f, -0.774049259429836f, 0.440376751789406f, 0.740171176715015f, -0.322301969056869f, -0.148261856544327f, 0.724527166150266f, -0.744178178219827f, -0.743031462890542f, -0.00997727490160383f, 0.550074849063942f, 0.147825200269716f, 0.777182602759074f, -0.625412073440604f, -0.0614214671235789f, -0.400121310797195f, 0.864511820640236f, 0.327656445569618f, 0.765838911283705f, -0.906185069285438f, 0.543656228031101f, -0.527337383463707f, 0.544932532036177f, 0.453966596910417f, -0.422906847383216f, 0.803455668330395f, 0.496651297123425f, -0.254890927444284f, -0.940902660088963f, -0.0691448074129200f, 0.0165534278793877f, 0.510199004798987f, -0.0286331020627788f, -0.141471298460923f, 0.872000980716430f, -0.752995088893842f, 0.167696515625982f, -0.181673581299286f, 0.496236252387172f, 0.854022562040503f, 0.388320660177419f, 0.499320363074588f, 0.173522726183149f, 0.0334192536945390f, 0.631347719906229f, -0.832803059709609f, -0.523826088751894f, 0.322557683663180f, 0.0263621365506006f, 0.948982322858062f, -0.253991680115490f, -0.165970359640120f, 0.331700483099733f, 0.808731855823033f, 0.159862831431822f, -0.438178259673022f, -0.943749594272300f, -0.967819867274861f, 0.263403865531262f, 0.710981741513574f, -0.274597382335371f, 0.929606564147885f, 0.125943272920181f, 0.691306164809532f, -0.607946869004681f, 0.284352421048012f, -0.421663515398071f, -0.409479725854699f, -0.152265311389352f, 0.630868673855242f, 0.123144840061153f, -0.645105689918733f, 0.360153393247973f, 0.683885744053582f, 0.752598814717991f, -0.581494857182821f, -0.469116962448560f, -0.0691726199196117f, 0.174679188611332f, 0.351269328558955f, 0.394815335607621f, 0.710281940645013f, -0.618593505217632f, -0.721546422551907f, -0.974088703589852f, 0.939556772536401f, 0.599407011070674f, -0.342213391542906f, -0.387135346574836f, -0.572027944718123f, -0.622717582512866f, -0.676949872287677f, 0.993953153886700f, -0.784539234625462f, 0.788778188174951f, -0.0652679971583152f, -0.988740647590182f, 0.748989697777310f, 0.412949190397683f, 0.206661198525718f, 0.573116044772809f, 0.938498079842984f, 0.743167714677278f, 0.755679122637903f, -0.295095987460132f, 0.217166189740252f, 0.230160404687938f, -0.504654557405015f, 0.472402206737240f, -0.867751757044285f, 0.869050101160567f, -0.905285205825199f, -0.0698843699947245f, 0.762379282963140f, 0.634191197174691f, -0.498487028811837f, -0.284257632541078f, 0.224245853978976f, 0.412950901773606f, -0.831984679101472f, -0.375663639002356f, 0.153699995838016f, -0.953997055484851f, -0.545360745186449f, 0.637687001020610f, 0.465459355638311f, 0.0769011654935299f, 0.267123343048604f, 0.545842501706277f, 0.778890986545214f, -0.363432183057524f, 0.479786652022207,
-0.600912698239979f, -0.738845504293020f, -0.775987143750184f, -0.705559714187038f, -0.310523750352236f, -0.576081829930414f, -0.0341897834633795f, -0.388414434291246f, -0.790681299048144f, -0.169440674711419f, 0.219815472280053f, -0.323451599202462f, 0.835623141427806f, -0.932446301638351f, -0.831480966559550f, -0.185050128422203f, 0.946045240208487f, 0.864740749402213f, 0.916918979039328f, -0.204049261822351f, -0.807183358636872f, -0.484543897885746f, 0.974235382435000f, -0.208019257024664f, 0.647411336652954f, 0.0961385231960816f, -0.800258527388060f, 0.352982142334643f, 0.917274278881503f, -0.733934252997685f, -0.229420044045673f, -0.358499183112933f, 0.469156578609832f, -0.859359096702447f, -0.937762141277625f, 0.389776419837803f, 0.458425599271073f, 0.542973137971009f, 0.675023236195573f, 0.944029213696263f, -0.774027667733194f, 0.262984845114612f, 0.842689106929982f, 0.349251854560315f, 0.815938991679117f, -0.226283690374971f, 0.144356327986477f, -0.610588223452142f, 0.539695204296007f, 0.655759463021729f, -0.725805170479948f, -0.194977831685847f, -0.306105075607822f, 0.725461617920836f, 0.678283785172857f, 0.250577882812283f, -0.571672652704059f, 0.112132856850530f, -0.236412229648694f, 0.768173015701816f, -0.799251028098975f, 0.100723381526471f, 0.113856811781171f, -0.0281630563735495f, -0.0727902548617043f, -0.515248547261805f, 0.795765010992038f, 0.505540143557856f, -0.496124371632015f, -0.363010091302494f, -0.302067159683438f, 0.941309812688142f, 0.0564765277142674f, 0.733027295879568f, 0.582734217224559f, -0.159007222603058f, 0.827637470837748f, -0.163060519537145f, 0.352357500273427f, 0.920405360379926f, -0.280691553157313f, -0.401974149240862f, -0.131353114797667f, 0.0719728276882135f, 0.795795661384902f, -0.348203323368113f, 0.946184663961743f, -0.188400643814906f, 0.979319203447783f, -0.132195434304746f, 0.585832597473452f, -0.894730397941282f, -0.998045985412111f, -0.717844040997160f, -0.706372640246558f, 0.237517748136224f, 0.767232946579208f, -0.246080656591091f, -0.767887803661775f, 0.139501344992184f, -0.545658806327887f, 0.480755550666584f, -0.355750609145607f, -0.493518864013929f, 0.832011102158605f, 0.122542855024589f, 0.179356501845966f, 0.630805165349165f, -0.888557403477561f, 0.861375782261841f, 0.963467658712489f, -0.00498707715217361f, 0.341894517453263f, 0.654808049991043f, -0.826909952854692f, 0.101446328788119f, 0.401514152845232f, -0.830556985096328f, 0.832187560444347f, -0.657254039822149f, 0.0304197382717133f, -0.718462386339415f, -0.592343549551534f, -0.356333235896531f, 0.674135547073730f, 0.606490641440102f, -0.707328770155748f, 0.0251846271186025f, 0.763024927861424f, -0.258224600040528f, 0.456384203436896f, 0.626482995304888f, 0.162353458245830f, 0.964280614412026f, 0.869262296229816f, -0.0659501568862260f, -0.712869755397848f, -0.946968242335746f, -0.852822740386429f, 0.791522782900379f, 0.824530390150335f, -0.369383609091590f, 0.118366422602132f, -0.713278848975255f, 0.549165545117801f, -0.00201102645336770f, 0.748955154405439f, -0.173689412898754f, 0.175162399203493f, 0.0819730422177463f, -0.804833155982895f, 0.972966530563786f, -0.0614871820303859f, -0.293463394754661f, 0.885919261783643f, 0.498531250561504f, -0.808874001349436f, 0.364344357769432f, -0.945616638616975f, -0.285864129675031f, -0.0438177789332626f, 0.303981486324719f, 0.362653007142366f, -0.543157427730716f, 0.174551703296805f, 0.140105048664068f, -0.704163993684247f, -0.647461975308389f, 0.831243960763754f, -0.364954329841192f, -0.730289885595360f, 0.0119708019435723f, 0.796338505809816f, -0.227851954967331f, -0.927330125804492f, 0.0602265250934577f, -0.485204061877453f, 0.198319346525046f, -0.529723177394882f, -0.321493822700232f, -0.839566193416413f, -0.187812484529161f, -0.396142329367383f, 0.367600156667632f, -0.922657847865138f, 0.893508892950972f, -0.504434314314017f, 0.663184814192863f, 0.887813887366393f, 0.267103483259066f, 0.984313142773772f, -0.667515321448428f, 0.0718416862496054f, -0.733363156570869f, 0.00186343206374962f, -0.316531364321301f, -0.467549697367438f, 0.569865535259013f, -0.556502178434536f, -0.650896672234238f, 0.564462797319346f, 0.585276582729153f, -0.433005641153548f, 0.847012427243871f, -0.462088105064984f, -0.379468633087939f, -0.0104892833799723f, 0.654191676584918f, -0.893278846859767f, -0.689350274835588f, -0.333220721049179f, -0.0461703436190983f, -0.463411501818667f, -0.995085073808794f, 0.526075522777196f, -0.0686703698159610f, -0.855908120278260f, -0.239774384006192f, -0.524142243888286f, 0.119526621106050f, -0.838266471869898f, -0.459366707886497f, -0.974921205300089f, -0.680517660007036f, 0.507695286553230f, 0.0920009889477380f, -0.674459855090400f, 0.554585280302756f, 0.357871391273056f, 0.453052004120624f, -0.991707675828263f, 0.144725488641274f, 0.0886535789688503f, 0.708257184179799f, 0.579351194763774f, 0.902098539548710f, 0.0104715251706708f, 0.112677648152527f, 0.0513772996762050f, -0.647561525299580f, 0.321958856072156f, -0.433510239079594f, -0.481493822802105f, 0.651663699618654f, 0.922649363108760f, -0.751799312011289f, -0.0336105332513619f, 0.236872038257485f, -0.0434863841224971f, 0.150810692021768f, -0.217629544451037f, 0.345890414626050f, -0.471941673338326f, 0.675001035054686f, -0.986585320322202f, -0.784679789758475f, 0.270727429189404f, 0.595792127677512f, -0.485969146811564f, 0.222507692419212f, -0.850070310429306f, -0.575184466843042f, -0.220860571657717f, -0.749449040845746f, 0.743039624335149f, 0.463892797640518f, 0.224829531690830f, 0.935410439714992f, 0.00609595972560872f, 0.830877831388658f, 0.0270299847557276f, -0.648763861115704f, 0.471982277585509f, -0.145722971031426f, 0.650947186397952f, -0.266164907037466f, -0.962378355156458f, 0.354855353373398f, -0.184127215272909f, -0.825621979621661f, 0.595495186093792f, 0.448679578752395f, -0.839671989567806f, 0.302158874138200f, -0.735484620769119f, -0.891040803749876f, 0.880298595525880f, -0.281199581528421f, 0.0195033020490396f, -0.511515485794419f, 0.447303195702203f, 0.375317547074287f, 0.964442757731427f, 0.167643569291013f, 0.0118587246816413f, 0.958187068873858f, 0.315395458761821f, 0.188852872643367f, 0.417450657662866f, -0.540566147670448f, -0.422709015019828f, 0.101425586029329f, -0.235465301656357f, -0.806044548641562f, -0.617153815671298f, 0.350658348898447f, -0.738540593521098f, 0.291893065415692f, 0.335435501842245f, 0.832048727909480f, -0.609539777284250f, -0.436992256701542f, -0.685315947977391f, -0.502107715051164f, -0.893460699283628f, -0.262263680492396f, 0.454417031133778f, 0.223227655510993f, 0.605288383003966f, -0.698800586984034f, 0.864843125666124f, 0.363752223710394f, -0.354571459375900f, -0.575008718239530f, 0.423061550052490f, -0.272459660313524f, -0.116932919064239f, 0.547073367599225f, -0.890822451422250f, -0.884262586749836f, -0.889803003239001f, 0.217660629852574f, 0.154863581361214f, -0.333284425759330f, -0.826087281020982f, -0.958198419703014f, 0.850114828540176f, -0.391190814837661f, 0.956578087128909f, 0.0541599967910713f, 0.0988550815990206f, 0.851903747125444f, 0.361959550717838f, -0.901818125706440f, -0.0561477675277424f, 0.522090821863134f, 0.263383912024089f, -0.161061362097086f, -0.983707460720128f, -0.333128836619106f, -0.546535222349413f, 0.627261888412583f, 0.408731616102241f, 0.754700916401496f, 0.869772826180715f, 0.362242883540519f, 0.853587698951791f, -0.698910717068557f, -0.671945256263701f, 0.802655941071284f, 0.338701009518668f, -0.0297818698247327f, -0.881311052338108f, -0.296717226328950f, -0.965699941652671f, -0.737164428831818f, 0.00804554422537485f, 0.989716933531351f, -0.832438692682457f, 0.454553001515962f, -0.933801685729775f, -0.644562445615081f, 0.104508389084640f, -0.535426180524709f, -0.937041822784313f, 0.599911275476691f, -0.789109397888652f, 0.821293320968620f, 0.818032308067912f, -0.838306491947354f, -0.172883985566904f, -0.185775969502745f, -0.672256019841514f, -0.412525056012874f, 0.142272136963196f, 0.792136721788200f, -0.726314486042219f, -0.445981475954073f, -0.857821372905156f, -0.783006950965519f, 0.438776336055643f, 0.400193156140386f, 0.177525578340235f, -0.435380642286229f, 0.547815754835977f, 0.0496394855194708f, -0.442174406426496f, -0.0856142956982360f, -0.0247840885457120f, -0.779016166389253f, -0.511802368745331f, 0.319887353303028f, 0.721806644023428f, 0.770423389111803f, 0.809969588377187f, -0.196191981856391f, -0.105718971622809f, -0.301674515042257f, 0.613622254387482f, -0.969517273103490f, 0.0144576310630131f, -0.668829420461301f, 0.750377960820232f, 0.696858494013122f, -0.563485511352760f, 0.726226115587466f, -0.227540741583116f, 0.665488592033944f, -0.124611809537824f, 0.489550286613580f, -0.579185308695604f, 0.628687311174276f, -0.295770837727116f, 0.240358361854250f, -0.155642183802961f, -0.885945841456110f, 0.388592282428421f, -0.663862196774143f, 0.363779469451472f, -0.371285870971327f, 0.563159689631810f, 0.102725415308920f, -0.320909176496511f, 0.334328794247963f, -0.401664407219370f, 0.726728495517480f, -0.192310060924823f, -0.107973316004269f, 0.898177814643418f, 0.456682306673978f, 0.890742303266606f, -0.742770990765425f, 0.0337493848747046f, 0.786190819119190f, 0.911503487800545f, 0.288384155888888f, -0.249479393879906f, -0.431949793185094f, -0.0847659302921913f, -0.475416985100444f, -0.362720571751962f, 0.676910741300893f, 0.00488530543559529f, -0.227678010632002f, -0.0632947771540859f, -0.990261099329279f, -0.708485805011827f, -0.304846597458441f, -0.480289782580152f, -0.593254971635338f, -0.656335976085053f, 0.584373334310954f, -0.493268395245234f, -0.00212668034894836f, -0.480221591678953f, 0.622365041709782f, -0.258845071515928f, 0.943825418665593f, -0.716642329101759f, -0.765317239111819f, 0.324487844009035f, 0.108158868464706f, -0.790583201992229f, -0.649218622127061f, 0.751409704126257f, 0.301455204388007f, 0.620482350165047f, 0.411016780608874f, -0.878843779367281f, -0.779673415191805f, 0.616508572699874f, 0.0750844738292273f, 0.341011338533919f, -0.553376665552953f, 0.277561087965059f, 0.527499935800293f, -0.489644680144407f, 0.514353996113782f, 0.229842524701725f, 0.139172928186734f, 0.793753206591897f, 0.835555341130211f, 0.794120687009671f, -0.0994745468343306f, 0.109098970584400f, 0.383123470993648f, 0.272549010931094f, 0.683070582699418f, 0.522823199313615f, 0.235903759158310,
-0.269490013000195f, -0.103775744391749f, -0.994083979953753f, 0.754983594207459f, 0.806308398378106f, -0.997543362839150f, -0.00396367603607373f, -0.873768378178592f, -0.755907732827809f, 0.703713206520365f, -0.0716773056166142f, 0.0792968663717508f, -0.113760825029016f, 0.828188140127672f, -0.103062543982628f, 0.0455017026983378f, 0.330658414568756f, -0.615810862221588f, 0.827890015477212f, -0.507551960954374f, -0.371044788092612f, 0.723489294741891f, 0.169072478802524f, 0.885612989356318f, -0.496475905980558f, 0.114400438991609f, 0.427961880327008f, -0.0456714004002505f, 0.0246660859589438f, 0.175616122301987f, -0.349777838484285f, -0.939474935533562f, -0.215061649130134f, 0.907049169335834f, -0.0553600192559760f, -0.982464152311714f, 0.405919915647442f, 0.755952405091542f, -0.695422520039876f, 0.373280568864688f, 0.483909023765611f, 0.784896384994620f, 0.978722132488262f, -0.113866140463085f, -0.630016943176703f, 0.512742627309861f, -0.829104067044703f, -0.240982431155520f, 0.0107361024967163f, -0.438682584788413f, 0.935730031472303f, -0.953447901200043f, -0.984218956474073f, -0.745077052885218f, -0.466232938128846f, 0.0326267564209573f, 0.303877586274065f, -0.199843777507458f, 0.674317529952029f, 0.448678903834397f, -0.681863209154081f, 0.273397524216090f, 0.193101955704959f, -0.342858479278718f, -0.485179713360910f, -0.586067050491890f, 0.393099777352274f, -0.982324485510343f, -0.852553426343700f, 0.773613825101220f, -0.590256032959421f, 0.837952413540589f, -0.643137731235821f, -0.311955662956384f, -0.888588599835619f, 0.304629859477166f, -0.810098957400030f, -0.534291626181040f, 0.878601703692302f, 0.362706441157764f, -0.254447668911795f, 0.604309282304246f, -0.977266419340276f, 0.250927873824064f, 0.549600558999971f, -0.796155833245480f, 0.226373301058549f, 0.0137578302483823f, 0.819708534464965f, 0.185662636424304f, -0.450456459548662f, 0.0953849597308440f, 0.736872088617975f, -0.582024306116842f, -0.0522261513001507f, 0.394348349710790f, -0.461023913227183f, 0.139996201153565f, -0.790168851966909f, 0.692544084408690f, -0.580603732841955f, -0.584540773580447f, -0.967062276813525f, -0.00886260208554912f, -0.0520831218167985f, -0.999614949922684f, -0.965820736077636f, 0.366390034326646f, 0.0323069925013668f, 0.164651515113853f, 0.300260003499445f, -0.340634856317630f, -0.238157231550037f, -0.291645957143165f, -0.773881882387456f, -0.144494053860223f, 0.660329619628580f, -0.626727996257997f, -0.994965090982706f, 0.161018019917379f, -0.327211572176153f, 0.0410991278573425f, 0.0123663905917732f, 0.747176159655312f, -0.485981637435718f, 0.00667961234248971f, 0.631625759154389f, -0.831294487064668f, 0.449606477050286f, 0.768845094514142f, 0.928354534843426f, 0.812647997969340f, 0.353418126917875f, -0.872184763557736f, -0.579130598386915f, -0.912928075675835f, -0.779484407508668f, 0.534916834944041f, 0.326353225230543f, 0.395431557674662f, -0.842103899863317f, 0.196590107332985f, -0.261317824893025f, 0.750190543523333f, -0.103409967857074f, -0.201452426430379f, -0.213633615009587f, 0.578822104214576f, -0.130809161238349f, -0.774608769872343f, -0.0222201705228122f, 0.126990738965544f, 0.785780586747108f, 0.0379484317527632f, 0.837140835706189f, -0.191007948387153f, 0.106781679021568f, 0.990298140861558f, 0.618337701073777f, 0.460255491901774f, 0.716379796730692f, -0.159421014009881f, -0.560212468621569f, -0.147263014783522f, -0.962301694075771f, -0.327702010262213f, -0.773959532468388f, 0.351239668535113f, -0.682281479449518f, 0.342188824054257f, -0.743039216419066f, 0.700710268270439f, 0.919651386092770f, 0.626343233048871f, -0.157189576636596f, 0.781882574006976f, 0.349953565654219f, 0.361235312853466f, 0.313242228422046f, 0.582185182102266f, 0.554504358491139f, 0.711217954194576f, 0.332473377627418f, 0.165078226255772f, -0.228349029389292f, 0.899730713958153f, 0.653894503448836f, -0.0452904440925501f, 0.0328806142413372f, 0.793701315832839f, -0.703826261467540f, -0.901648894320192f, -0.195631966969018f, -0.0470590812056508f, 0.487185699934959f, 0.175961644103331f, 0.818028721319245f, -0.224389104974946f, 0.901974203693823f, -0.153212477843726f, -0.472747796173897f, -0.587471692952684f, 0.452340198339707f, 0.996443894349412f, -0.849126217374502f, -0.403800337277983f, 0.923427876645159f, -0.0516037992113898f, -0.380335341989182f, -0.299914673109747f, 0.764492139190834f, 0.773463290027243f, 0.0175454601261817f, -0.400742340353541f, 0.912354892189422f, 0.999766609328281f, -0.521321752061712f, -0.365769506846305f, 0.477612405338644f, -0.0522578739905535f, -0.479259238587280f, 0.645161410912429f, -0.702546085166056f, 0.359736398041538f, 0.638130894056863f, 0.115633419893101f, -0.674410360620500f, -0.150824943737990f, -0.824854463897591f, -0.504410162129685f, 0.560317574021813f, -0.159611666752889f, 0.997647540626334f, 0.702777895178414f, -0.946494281691535f, -0.0109619562916898f, -0.383756482005404f, 0.872670066971334f, -0.453527506439184f, -0.635719199113957f, 0.932852122005178f, -0.800755479140234f, -0.225213334363716f, 0.251163542389519f, -0.598147625383133f, -0.155241293946661f, 0.967736510890644f, -0.0157250628103103f, 0.250570924071858f, 0.209749651169078f, -0.381016062687537f, -0.679300447230592f, 0.160197663113971f, -0.749803147200800f, 0.596917045783617f, -0.0878737681749431f, 0.642402180339789f, 0.261614973684270f, -0.111833224093973f, 0.300170844971678f, 0.317966800167647f, 0.0585375534708252f, -0.842709435910728f, 0.760207701069839f, -0.979366191145221f, 0.940703569377911f, 0.866488078693979f, 0.553497107695259f, 0.127260247084497f, 0.530106152060111f, 0.725171359852920f, 0.356742729430045f, -0.209841680046178f, -0.164239817187855f, -0.888858150931758f, 0.0367561852378047f, 0.803496113779956f, -0.594927045375575f, -0.00347281985657166f, 0.114118941713783f, -0.427864462568672f, 0.719021423892768f, 0.335845790828654f, 0.0207216235296064f, -0.523146933862102f, -0.145001077781793f, 0.490566784879983f, 0.461904660734682f, -0.897010089735077f, -0.895737903861849f, 0.343397505472310f, -0.684377591381862f, -0.0154016881290400f, -0.462987614871549f, 0.884045010701589f, 0.192617174725234f, 0.226497290324550f, -0.788151335932529f, -0.190538526746651f, -0.556614046330326f, -0.139480186854974f, 0.196785300148418f, 0.978844132512627f, -0.290726060479808f, -0.591813978495167f, -0.0769033757443105f, -0.467044929381376f, 0.171585053083057f, 0.408215527269010f, -0.818706013465989f, -0.328144984930982f, 0.790275356337217f, -0.977491163139178f, -0.979679268318504f, -0.524875121608236f, -0.263859024168277f, 0.0180787743488171f, -0.984390626106750f, 0.952274619010224f, -0.851400664579601f, 0.692959439369046f, -0.150312001943653f, 0.712066554169562f, -0.492336226254660f, -0.453559897031351f, -0.159679763180474f, 0.745834647687870f, -0.725963425297178f, -0.720341794596050f, 0.370674334928492f, -0.845974926208293f, -0.00448769398027360f, -0.595973105115042f, 0.967372249596385f, 0.512949503724102f, 0.889619262804735f, 0.990718232652913f, -0.662246751886904f, 0.333846293708563f, -0.423114421367372f, 0.549637439543149f, -0.987876053136374f, -0.782714958794276f, 0.294868983681807f, 0.931284560597614f, 0.445522387300861f, -0.388400162488578f, -0.182673246109423f, -0.773488958971573f, 0.438788569593725f, 0.578106509978236f, -0.373449127435319f, -0.301996528814967f, -0.227124771031239f, 0.700176189695036f, -0.910948938567526f, 0.733412403327578f, 0.486154072292544f, -0.974058632864456f, 0.216693355653246f, 0.147564301397678f, -0.715192277853558f, -0.366996833259925f, 0.568909126406069f, -0.0810069456450131f, -0.371253841044151f, 0.254736918036059f, -0.868966383080701f, 0.190312518076662f, 0.457253801337437f, 0.941043431633233f, -0.297470749600241f, 0.244270515950156f, -0.240122562119888f, -0.766384662307300f, 0.765045432900429f, -0.608250739173787f, -0.733052557932594f, -0.268433000443065f, 0.733598123424154f, -0.0550005774741753f, 0.273893221740822f, -0.659641650983149f, 0.967032725204337f, 0.390126626361090f, 0.518740746381756f, -0.859387560527806f, 0.554117289841284f, 0.648904904654236f, -0.755880975555381f, 0.834231592524942f, -0.137512395743275f, 0.0477027353535724f, -0.880364563062979f, 0.458763614093086f, 0.650036413308116f, 0.496385905878033f, -0.418537115548864f, -0.565561960782851f, -0.227941684691245f, -0.165031891659812f, 0.204464989908300f, -0.688093624763916f, -0.678874848552394f, 0.813764873880514f, -0.561723359541237f, -0.575805702297063f, -0.288097000970518f, 0.950119107184838f, 0.709879842972902f, 0.730067219897393f, 0.710813066057284f, -0.192333836978130f, -0.190446300563246f, 0.872679304648751f, 0.134143163657763f, -0.979443835407234f, -0.103872104041761f, -0.0568328979324004f, -0.863020133862081f, -0.0257801722427251f, -0.577962771617033f, -0.0500056799801032f, 0.191817418291914f, -0.799853775410853f, -0.110019424741421f, 0.840753817223395f, 0.355588322976119f, 0.274501278628024f, 0.757538306972136f, 0.771547320156202f, 0.0394143752709530f, 0.120744072764658f, 0.324337882930581f, -0.380086709776951f, -0.772025774284869f, 0.473986846199588f, 0.703247561676381f, 0.734667480205300f, -0.594290184210087f, 0.760158653782445f, 0.624553744314883f, -0.941053266957965f, -0.165913770936962f, -0.0497972870738055f, -0.0435608680908517f, -0.663165366083943f, -0.570972482385751f, 0.427845034528880f, 0.0897903148165149f, -0.481825010950428f, -0.0901127105939594f, 0.887770435656611f, 0.770985476674623f, 0.00966158758316293f, -0.331059327378268f, -0.286033645163736f, -0.0698945910210471f, 0.834392309773299f, 0.875537383319608f, -0.657919190548359f, 0.583890957562885f, -0.418481077359384f, -0.282242397022386f, 0.864577023994874f, -0.898367126143440f, 0.815804441243808f, 0.616061408588373f, 0.132365642864798f, -0.221099752471970f, -0.852722283680675f, -0.269499596712950f, 0.360828136129415f, -0.120022743070141f, -0.0354652134632905f, -0.718389836602256f, 0.973490047219112f, -0.201775047168341f, 0.348769511760972f, -0.338750368577880f, -0.269769414088757f, 0.498910931428472f, -0.787648791515347f, 0.508408064858444f, -0.904215976374529f, -0.778575029821227f, -0.662889546847757f, -0.787503064261069f, -0.915166838630178f, -0.415784802770356f, 0.731806835017609f, -0.903922155472207f, 0.0872811033112211f, -0.452516774501827f, 0.577942533813694f, -0.200909337658770f, 0.866167939661793f, 0.982552542055944f, -0.332277333696961f, 0.201673960342839,
0.881239812364993f, -0.0293753746942893f, 0.0967170348490725f, -0.765573023404242f, -0.179225339525953f, -0.931530757069740f, -0.702596334762137f, 0.439106079307245f, -0.469364154277323f, 0.211063395888038f, -0.245858633045693f, 0.936376071219385f, 0.0334087380010875f, 0.0765265939183459f, 0.417091701258078f, 0.962467059286170f, -0.180698008768999f, -0.129816441691123f, -0.833694435146788f, -0.800582099046532f, 0.736376297618233f, 0.0164704176688124f, 0.207462305741760f, 0.300555292898496f, 0.777154212278295f, -0.0804533056660695f, -0.279940128908185f, 0.203101811030871f, 0.447496959357837f, 0.508353359025257f, 0.644333822521829f, 0.897259297488483f, -0.675785952117501f, 0.149337263319588f, 0.350953290584184f, 0.600296681944338f, -0.606098182955297f, -0.418312129297725f, 0.792551232171214f, -0.944025948110651f, -0.923106441737020f, 0.508989820072736f, 0.101554011154237f, -0.799369609980037f, -0.229001813644938f, 0.196367996268564f, -0.634078446275840f, 0.267446716753553f, 0.943765754688567f, 0.329924442019441f, -0.898235312442524f, 0.563592978494850f, -0.976934293161001f, -0.609744819901837f, 0.498989633313589f, -0.105680058480959f, -0.400730747241191f, 0.264919109340783f, -0.313066735594123f, -0.465399967597728f, -0.425123918113080f, -0.609514085808810f, 0.916560800692384f, 0.0173757138934230f, 0.147814399202503f, 0.594152503614559f, -0.145681097751433f, -0.427232299718493f, 0.233460382614713f, 0.337361272635241f, 0.376106438004541f, 0.900277274651600f, 0.424547631957395f, -0.710790444715071f, 0.0846761090154495f, -0.0122707338404220f, 0.119989812955904f, -0.239774389963524f, -0.692300891031819f, -0.735109129583214f, 0.802276300301071f, 0.348982047806247f, 0.916302084278941f, -0.0838164783829127f, -0.989134997097880f, 0.832909602224562f, -0.701363449605445f, -0.150487976031971f, -0.728594035984111f, -0.144393031996783f, -0.458856761770637f, 0.733295441303064f, -0.405608670768629f, 0.522871610912813f, 0.468223399458939f, -0.575139530810903f, -0.241684287862418f, -0.499140599234906f, -0.395586476697394f, 0.692745485195348f, -0.125142235859546f, -0.342212246193052f, 0.133841188490164f, -0.539478395228865f, -0.887973984329817f, -0.474033882236453f, -0.837114132429830f, 0.773392302912611f, 0.117697651876253f, -0.461595011213406f, -0.528669601602068f, -0.957799577987062f, -0.468654423525192f, -0.0602288998398475f, 0.154553704272891f, -0.422854231304259f, -0.496136532114270f, -0.348154983723668f, 0.0576478341707483f, 0.542088962901856f, -0.0465812136931592f, -0.280128217727361f, -0.900695482510248f, 0.525110685457899f, -0.957266165874283f, 0.136490670826643f, -0.213221811269364f, 0.690040133288898f, 0.269408771473479f, -0.0488994830172422f, -0.837526616586426f, -0.289127052660601f, 0.149325279006459f, -0.694169700971401f, -0.0230547571616897f, -0.368313297034846f, 0.344434270521740f, 0.859135365902404f, 0.839336654691204f, -0.511783987355355f, -0.0349625753049687f, 0.935857929664427f, 0.820032045433520f, -0.0394079346656324f, -0.656352913407746f, -0.874383371678169f, -0.425836335156061f, 0.208600154889275f, -0.135596548598733f, 0.566430757256762f, 0.820840891306264f, 0.735746624790780f, -0.765482927015804f, -0.0195537720748045f, 0.606216172027628f, 0.436027839798869f, -0.609233580289002f, -0.963547951222316f, -0.575271468261977f, 0.692873344771925f, 0.143031668657597f, 0.890157114774225f, 0.762299295692265f, 0.653618249618643f, -0.957258626549595f, 0.521895225378123f, -0.607922211531407f, -0.956795748110572f, 0.477633684273092f, 0.794301967670603f, 0.139753218894595f, 0.371726372555490f, -0.804791987531745f, 0.837080126047059f, -0.440992020192054f, 0.584986017638085f, 0.950442046050057f, 0.613109120495913f, 0.633948971396891f, -0.581246845000116f, 0.730290176291093f, 0.599119212595240f, 0.120096101936515f, -0.144169383323758f, 0.930776406826440f, -0.0209712926465206f, 0.572995665695966f, 0.924623298379120f, -0.751832867985678f, 0.630196806059302f, 0.506634179395662f, 0.0388997263873157f, -0.311041196366299f, -0.729049093325017f, -0.918815504666740f, -0.103935429478766f, -0.000623544124330300f, 0.102880227280474f, -0.563637096166535f, -0.332148269587814f, 0.472114131256244f, 0.295717126494164f, 0.246944592105312f, -0.713191555660498f, 0.160410320426559f, 0.110992936470077f, 0.213877527744528f, 0.541660996543375f, -0.872405734998843f, 0.388515073094269f, -0.840811647524440f, -0.968008592072007f, 0.669947948420772f, -0.122943215855172f, 0.565929115911552f, -0.695408966310186f, 0.361296950635219f, 0.574282481983669f, 0.0877180513263536f, -0.694316083550519f, 0.327696487191071f, 0.289746985823208f, -0.241476327174879f, 0.605084742574250f, 0.0929272338220821f, -0.391399761658219f, -0.612928183827531f, 0.0471987261466311f, 0.157388702609590f, 0.575695018001234f, 0.450453491026024f, 0.876623108212541f, -0.456500163180038f, 0.436901006801809f, 0.796734433864345f, 0.771008396172517f, -0.784740610155705f, 0.405172719255834f, 0.958393667559228f, 0.787380105147761f, -0.262826016234054f, 0.773327117333271f, 0.482142068916266f, -0.461607549022954f, -0.153993688218026f, -0.129280134980317f, 0.901812622560630f, -0.111520793491644f, -0.0973214524989203f, -0.293695817178366f, -0.190045093887485f, -0.204792515844396f, 0.501086384719391f, 0.755953359112033f, -0.425886872154604f, -0.0883029298084141f, 0.763071371252921f, -0.556289447935984f, 0.577370462369201f, 0.0480599614417476f, -0.794423686623353f, 0.756645959967545f, 0.570538730848462f, 0.872575422156333f, -0.443572567528656f, -0.0487937634747691f, 0.283986553648095f, -0.170910821134099f, -0.329867000423004f, -0.982322841409943f, 0.555344201026651f, -0.351964643393940f, 0.776172688776518f, -0.148102477734717f, 0.889532618676503f, -0.310979434517253f, 0.711839903052208f, -0.646385596147085f, 0.145592596381502f, 0.233949589173221f, -0.825471565980294f, -0.370248763132654f, -0.777194557275684f, -0.224658064754195f, 0.263281286751478f, 0.849661910468068f, 0.271261490445121f, -0.915885420717958f, -0.947144520818678f, 0.227960459606299f, 0.784463828083640f, 0.995882406349565f, -0.987273766396493f, 0.0792453274840108f, -0.788403526960056f, -0.619975942121645f, 0.801181796307713f, 0.967884377026145f, -0.781223064263388f, -0.300716486479280f, 0.994748932974184f, -0.200152360574411f, -0.101898131541608f, 0.542914585925881f, 0.407729967031792f, -0.105215843903154f, 0.638066037611924f, -0.563777780161298f, 0.134189395993685f, -0.503320561486155f, -0.0379170306314711f, 0.723638115686875f, 0.747948383928228f, 0.928239905995551f, -0.736883772878758f, 0.892242913709735f, 0.468998243295705f, -0.224406388545097f, 0.758754382878863f, 0.994739001052496f, -0.749837906573089f, -0.938777322178786f, -0.619168635741936f, 0.827875717654585f, 0.294033159230782f, -0.372766318349126f, -0.292752124932124f, 0.396629951868878f, -0.986760927173237f, -0.0841834195975009f, 0.999760803826313f, 0.0142305924173638f, -0.820393900206961f, 0.409972278573230f, 0.227315924377402f, -0.641500351639361f, -0.470788010535406f, -0.486171076557593f, -0.758140688442947f, -0.971539708794928f, -0.949039718833189f, -0.146844988902767f, -0.0183627478820223f, 0.402918762093981f, 0.0620266698060286f, -0.182527786403967f, -0.374395326540229f, 0.566584207940253f, 0.879546558847970f, 0.853360173786566f, -0.515321950652696f, 0.511692631053674f, 0.342152084355850f, 0.374686420595610f, -0.794372980760555f, -0.648670375991101f, 0.761192158420166f, 0.223791993225057f, -0.342720055148453f, 0.965612513218950f, -0.796193009647904f, 0.215057114709867f, -0.0459498239576994f, 0.871047701509015f, 0.664672380241520f, -0.546301701630944f, -0.939910946986200f, -0.213195706858966f, 0.559543622118596f, -0.255844807516886f, 0.509576048776352f, -0.699005089750431f, -0.520317652140772f, -0.924306703712950f, -0.923814193467638f, 0.868401299001930f, -0.571229497763863f, 0.984740691690212f, -0.911782692220985f, -0.265295471266664f, 0.0479848731515942f, -0.195328058836883f, 0.758281465939343f, -0.418177229854869f, -0.263323557662932f, 0.0230762644115943f, 0.382605016442608f, -0.576209059863238f, -0.739785100410209f, 0.0956412509899256f, 0.0369702493097637f, 0.0738922616872486f, 0.589371657036664f, 0.548586250623500f, 0.996096574632666f, -0.574178408335425f, -0.827059309028347f, 0.600283403682961f, -0.0651062813338117f, 0.985857002071398f, 0.982700721670305f, 0.777628710286989f, -0.139415722014730f, 0.951156387462424f, 0.806391217144736f, 0.135433009714206f, 0.252388414319270f, 0.485541324740928f, 0.270688932431637f, 0.892850103229909f, 0.440168171407923f, 0.515384398158669f, 0.600884162546465f, 0.947986221531091f, 0.339440884303404f, 0.403857490690436f, -0.937015609644647f, 0.729529495316627f, -0.389601866986821f, -0.420712615666380f, -0.763003723744745f, -0.0619534667970105f, 0.486654476027536f, -0.943536854881494f, 0.471171699317719f, 0.996886209046820f, -0.945316270673373f, 0.230772742042993f, -0.621222111022648f, 0.838934157721328f, 0.124035987915113f, 0.737576768711407f, -0.217898078842006f, 0.0429859145211120f, 0.223685413947773f, 0.820073956039170f, -0.378381145423743f, -0.335672684173821f, 0.649791267584388f, -0.457253860252872f, -0.664776842833046f, 0.150429615666837f, 0.974812973893170f, 0.00119972362050369f, 0.140744912838368f, -0.252632269055503f, -0.124205752907507f, -0.383194456927254f, -0.356455432479067f, 0.0694989880525767f, 0.188230048541949f, -0.854592697407303f, -0.902559387772971f, 0.454054169179423f, 0.534684767654295f, 0.806837289706952f, 0.274203715752641f, -0.765433763984323f, 0.459365005291520f, -0.896797218412250f, 0.382900474341852f, 0.169400421233177f, -0.184111368111075f, 0.0323514487432812f, 0.621015577938758f, 0.139872518806323f, 0.480965263781330f, 0.0649386999855643f, 0.815365754221614f, 0.761990264098834f, -0.0927412249348933f, -0.580853742457387f, 0.211615321410605f, 0.165159968106305f, 0.305515629345863f, 0.725748395743965f, -0.667649812347274f, -0.621843189978885f, -0.939317191264789f, -0.197108718554958f, 0.902152006895939f, -0.889744652803018f, 0.667113256888905f, 0.929471703711725f, 0.660025836042506f, -0.0712223078913006f, 0.416152292126436f, -0.602223852277700f, -0.828462878627106f, -0.956915163338265f, 0.298196541541469f, -0.933863927954050f, -0.198745190221695f, 0.749101206471011f, -0.922366396086261f, 0.769953026855636f, 0.971459582749177f, -0.226637139032289f, -0.593509265485619f, -0.635649447577657,
-0.443127775644156f, 0.350464269654307f, 0.379979516655134f, 0.896282784801247f, 0.00871209446887344f, 0.401818712823609f, 0.815422566258939f, 0.215868289995843f, 0.682217845700443f, 0.508819667108007f, -0.988484263336122f, 0.216656890144568f, -0.185777888700071f, 0.522106353117928f, 0.894211314619113f, -0.779300881699217f, 0.137801937535128f, -0.818740955579722f, 0.637214461095055f, 0.187867696634722f, 0.184985729971243f, 0.315323389557324f, -0.0312525033775366f, 0.498559120407008f, 0.855778208118391f, 0.936851170962385f, -0.0524308158818188f, 0.257087262622978f, 0.816141818246927f, -0.147192803443011f, 0.194545158383538f, -0.655428449892669f, -0.650441844539509f, 0.536015423540886f, 0.0250060573607953f, -0.863380305825989f, 0.0605420782823460f, -0.963662464088496f, 0.689136717877590f, -0.929664162821947f, -0.327349437742288f, 0.713122240487331f, 0.765587094162777f, -0.314350325341316f, 0.409992519686522f, 0.753377832105546f, -0.756848529995586f, 0.760787899507869f, 0.512213162407276f, -0.674820237484644f, 0.560776719592082f, -0.874905891603855f, 0.925202682923872f, -0.907405002733482f, -0.575836335118172f, -0.248173888600965f, -0.187923239740639f, 0.230951002247789f, -0.540190666146588f, 0.390890663320481f, -0.705511708249712f, 0.0980457138183717f, 0.879979753648798f, -0.378326046226794f, -0.645363625221967f, 0.883365508962968f, 0.728720763588748f, -0.191571576393619f, -0.941989254130187f, 0.944312154950866f, -0.367184985473008f, -0.974124559264444f, -0.579946765132286f, 0.509825236656578f, 0.952047194261820f, -0.0955445631918663f, -0.00500764501201401f, -0.00111382665477655f, -0.0404281661495578f, -0.265706359102834f, 0.865881843285797f, -0.947915521623861f, -0.820337973623839f, 0.0843747524022067f, -0.948599514028391f, -0.464018526769358f, 0.600790429663803f, -0.0779017384430381f, 0.756949801920938f, -0.955436496929340f, -0.553346424499498f, -0.401256107066610f, 0.569624108543687f, 0.179455179577041f, -0.189386842296675f, -0.467166492259358f, 0.367644583467601f, -0.722338735126514f, 0.863903729827081f, 0.0631027352569811f, -0.982269235503679f, -0.837788470642698f, 0.421730643738386f, -0.671745211565315f, 0.858467932275763f, -0.745298219348761f, -0.659594977600028f, 0.403238381269873f, 0.951987904652099f, 0.228887404582426f, -0.331665752024408f, 0.794789885033899f, 0.669978127515269f, 0.977583870328654f, -0.346398989178462f, 0.692053246433782f, -0.159407706019695f, 0.710808563527500f, -0.555701359319642f, 0.625665798239905f, -0.711048329414687f, -0.672431532474912f, -0.474897384314332f, -0.196250611816064f, 0.902140605659856f, -0.459732035217428f, 0.651412290305649f, -0.686137550630920f, -0.803228611526547f, 0.371120664039117f, 0.289869860968561f, -0.720979161638185f, -0.0940498575417996f, 0.185025844935128f, 0.401524077274769f, 0.811721346556136f, 0.224659861626089f, 0.106438807548742f, -0.117458956991326f, -0.407361487623449f, 0.683891165426988f, -0.216582410631386f, 0.710644530504861f, 0.867797453793643f, 0.626683550176870f, 0.115061097783331f, 0.976742668387085f, 0.250700864990527f, 0.272723539841862f, 0.159923684669346f, 0.167713264013185f, -0.445764377935606f, -0.489538472614810f, 0.227880894824940f, 0.670702116476237f, 0.610361511284318f, 0.503801949624464f, -0.687816091694902f, -0.0413765153535617f, 0.155769004545734f, 0.921910233366689f, -0.467299226678025f, -0.991984541712805f, -0.527009262324220f, 0.248157897392517f, 0.661145853979517f, -0.975947426744844f, -0.242453990684693f, -0.277956284573619f, 0.162010437415540f, 0.889456199489152f, -0.171259539670729f, -0.0636124576727060f, 0.311318764402696f, -0.227771282875219f, -0.567702050585727f, -0.132881625149059f, 0.870846950418812f, 0.440078398779761f, -0.0908818839265000f, 0.410077545060762f, 0.917678125288724f, 0.975295290129489f, 0.736514272579886f, 0.653896379317074f, -0.166512942888681f, -0.218665383726096f, -0.0688642360506688f, -0.596589868100824f, -0.180873413844075f, 0.229002598511067f, -0.647630976455599f, 0.722615884501717f, 0.760194030884127f, 0.253262836539679f, 0.0734191803957118f, -0.941427952376035f, 0.224118866807764f, 0.634990976599086f, 0.538622500570355f, -0.591487367587299f, 0.829253069890529f, 0.426659996899884f, -0.562435396124737f, 0.924178169394878f, -0.693964899988321f, -0.520472617448914f, 0.845157115508053f, 0.162984246343684f, -0.212032053476592f, 0.0482566706558292f, 0.820584028875367f, 0.676120066619505f, 0.590174358812695f, -0.457289938956925f, -0.351282540371674f, 0.322162683499620f, -0.683726196205246f, -0.279636659553935f, -0.186133028676429f, 0.965481755833750f, -0.0550172560314044f, -0.437844829991532f, -0.448670532146325f, -0.438916826946834f, 0.830205353164842f, -0.0125988502002286f, 0.733716462327519f, 0.870000673588185f, -0.189915082276716f, -0.676269331249200f, -0.336432931956768f, -0.288892891213265f, -0.912569275291884f, 0.509853767908707f, -0.658452317958678f, -0.562848133961047f, -0.102082581799095f, 0.904062026055565f, 0.473339990381854f, 0.210234896873676f, -0.0884007008398613f, 0.720872020499257f, 0.538315255331760f, -0.884485227439286f, 0.160844002639634f, 0.625863524205804f, -0.947487159926400f, 0.362643826956149f, -0.189913270725334f, -0.110428721523612f, -0.666510263156819f, -0.214827103263521f, 0.912669747474334f, -0.973896103049543f, 0.665373714127588f, 0.148135031012834f, 0.126524689644449f, 0.00283763548841764f, 0.312700495893193f, 0.579520771033243f, 0.677583023476560f, -0.779567427807191f, 0.0694994546110597f, -0.298762697062437f, 0.655210050716681f, 0.435909078048151f, 0.322095567178671f, 0.764827170021089f, -0.713736794113842f, 0.992844460358584f, -0.735915506109616f, 0.280204875392391f, 0.584446532772711f, 0.796955505835788f, 0.742508124239176f, 0.0785523490091065f, -0.562359397016753f, 0.874448473576734f, -0.794251927759664f, -0.658767152705445f, 0.120015806343044f, 0.662372174700575f, -0.719334975225296f, -0.663474261357014f, -0.637663874969148f, 0.706137632813821f, 0.734790814693796f, -0.449118755654663f, -0.758125670003823f, 0.719059339327447f, -0.228679956701166f, -0.0782671261690160f, 0.637830522744746f, -0.178696376536345f, -0.848273935253246f, 0.840882430630200f, 0.977813953976437f, 0.565474986185913f, -0.807314895274907f, -0.100534840844589f, -0.436186956483089f, 0.854663592026441f, -0.547576146320248f, -0.621784076386717f, 0.688687549426321f, -0.688962085987764f, -0.998914668418794f, 0.751493418398842f, -0.203018738091861f, -0.881317097659280f, -0.422480898609404f, -0.321074554557095f, -0.759379357125740f, -0.806503084491033f, -0.496837315822352f, 0.217087355208111f, -0.776801484423500f, -0.445747498145286f, 0.710204776554782f, 0.274276964033182f, 0.650397224484409f, -0.709395921248168f, 0.862663541330686f, -0.946166202558813f, 0.826638502366159f, -0.450587332736099f, -0.808257632193740f, -0.414360554482101f, -0.471118187583276f, 0.981592919290155f, 0.192794908371370f, -0.314979855997427f, 0.722518962804398f, -0.795914669179603f, 0.121447532644509f, 0.0446893237592363f, 0.651720955387594f, 0.897128141094619f, 0.283834144643742f, 0.369570391543943f, -0.163784005163726f, -0.799144231493300f, 0.338136741961422f, 0.795991730702685f, 0.601735561139351f, -0.556654767533027f, 0.907044495725416f, -0.374604065784494f, 0.814308532452677f, -0.254295412850351f, 0.443103437041340f, -0.0218296619602199f, 0.826728672505738f, 0.773205771668962f, 0.171909022893217f, 0.497670481959597f, 0.954178712898056f, 0.0840098577761919f, -0.705861127301893f, 0.145663865959608f, -0.436204975766037f, 0.479359595998989f, -0.719493824988072f, -0.523146212355768f, -0.917822711649927f, -0.610003715217602f, -0.192266667446473f, -0.377507163265653f, -0.250419291332051f, 0.873627391381727f, 0.922899703740095f, -0.902411671519496f, 0.285830821349708f, -0.577368595723736f, -0.598296174995687f, -0.0152478418690674f, 0.503725955636280f, 0.946501779740920f, 0.261108140547963f, 0.206258978593364f, -0.887022338332430f, 0.989187042741485f, 0.461764104690670f, 0.305280284664753f, 0.243972878436235f, -0.573704516784209f, 0.111805651228880f, -0.373590027525854f, 0.574564836347642f, -0.712884790778729f, -0.0570130063179222f, 0.244209425500712f, -0.717492787619277f, -0.476920207759357f, -0.444169983027413f, -0.254851417015366f, -0.505678630542571f, -0.953549022234155f, -0.0316841901798541f, 0.198256779602804f, 0.151938229162240f, -0.0259028503944394f, -0.799645893003010f, -0.889308912372168f, 0.339221517072804f, 0.904784479404768f, -0.367330903112591f, 0.866281762131661f, 0.112765232993802f, -0.0852946527317187f, -0.283538359072154f, -0.734951426632046f, 0.502970854898684f, -0.541434927857400f, 0.881496286285600f, -0.227404039639917f, -0.636983936776183f, -0.0799774217214970f, -0.833780310813424f, -0.222787370954425f, 0.433143783060434f, 0.0953330524947187f, 0.965400264971588f, 0.308927931247299f, 0.344316393259575f, 0.122880788538352f, -0.898509922382301f, -0.187062523329053f, 0.705352247460646f, -0.817811000761718f, 0.303714513401701f, 0.714863075518907f, -0.00862372607283035f, -0.842715848975590f, 0.816504077307885f, 0.924594085591125f, 0.334618732730041f, -0.212414743241377f, -0.758289625449925f, 0.586405661412351f, 0.909247363444287f, -0.800422609846793f, 0.397430897916299f, -0.408827454151232f, -0.411913213123543f, -0.602703152770135f, -0.893591462026327f, 0.417648762458765f, -0.766362696266534f, -0.166060103951854f, 0.883234167729589f, -0.0741908774062401f, 0.113912882075078f, -0.268248292164738f, -0.825585719915457f, 0.885446166477969f, -0.996523379251940f, -0.000841720632677401f, 0.940286529247477f, -0.528330498750176f, 0.0938880690147421f, -0.966296878893937f, 0.891956527154360f, -0.483384605653306f, 0.257210342748458f, -0.820220338820906f, 0.363913841603935f, 0.0364865250689275f, 0.0619156958713947f, -0.645447937080250f, 0.548279343062761f, -0.289526240449473f, -0.506780094171335f, -0.901771170107367f, -0.437874075223813f, 0.748512212111141f, -0.529884246718074f, 0.924062132675193f, -0.365432219122282f, -0.263296006595835f, -0.927083881647913f, -0.192737974697553f, -0.450051159199964f, -0.543528645806642f, 0.834976909049276f, -0.426975046433596f, -0.361056079272416f, 0.883880063360531f, 0.680380429911630f, -0.553642515320953f, 0.548847108935282f, -0.357430246936948f, 0.210445016993628f, 0.949511601115471f, -0.611278947360487f, 0.344744934459962f, 0.0684247970496175f, -0.877154656281116f, -0.521992702610556,
-0.0303764312006813f, -0.647220068176984f, 0.693175336224119f, -0.0955602614554496f, -0.765579758912278f, -0.821318118938906f, -0.220936603794347f, 0.159013709512021f, 0.0222743973539492f, 0.569438412513281f, 0.896083437551563f, 0.973699071868637f, -0.403438951991928f, -0.976931032127622f, -0.0720613180573018f, 0.0788813367661694f, -0.430781354548607f, 0.580378296309349f, -0.175446689199481f, -0.256743557012462f, -0.696667845393283f, 0.870473046831235f, 0.146660713923108f, 0.277741407197705f, 0.502075064404417f, 0.396530064046844f, -0.000209092342246420f, -0.977003947244262f, 0.451457326960000f, 0.420509664462095f, -0.0826395067671402f, 0.461120688156973f, 0.786867285802415f, 0.429254905841222f, 0.894426863739026f, -0.670297281923597f, -0.833650409296060f, -0.908588009702110f, 0.516311115539149f, 0.975234001829324f, -0.532953533466378f, 0.775291582519158f, -0.0136022600428900f, 0.654817093112596f, 0.363512141498233f, 0.624779024037534f, 0.0237004661473674f, -0.172570506046968f, 0.401807838319043f, 0.997391258152958f, -0.553969395939123f, -0.415425175833161f, -0.758032843655304f, -0.482766088920005f, 0.637574309072414f, -0.729000055114342f, 0.699851428676091f, -0.827508053421131f, 0.900655803848482f, -0.431149800814228f, 0.0369409101983413f, -0.378608101457895f, 0.237564147838841f, 0.533020461112441f, -0.280269627508005f, -0.864065787343603f, -0.0381481642453043f, -0.566886547530062f, 0.539727700361167f, 0.166859339425035f, 0.850080295054718f, 0.384690146030125f, -0.384995288415294f, 0.303656036600558f, -0.580297619022502f, 0.0649069482840878f, -0.162922327392773f, -0.235019427063355f, -0.265468718118809f, -0.121827312187455f, 0.0416628805824146f, 0.343481543012411f, -0.251429566892972f, -0.868100204320718f, -0.802636407512128f, -0.549547579028752f, -0.570017983863503f, -0.853634311513627f, -0.564570567173235f, 0.955944215494794f, -0.0930750790375956f, -0.160319122401953f, -0.640886790354213f, 0.798634607857513f, 0.503051518023559f, 0.765247226736789f, 0.909476811674882f, 0.677590253114963f, -0.110641683440517f, -0.336445241915220f, -0.684064840782028f, 0.962285048920031f, 0.883303701653897f, 0.981819291389659f, -0.597290928759656f, 0.215792997443025f, -0.847656608719347f, 0.679887992445640f, 0.299901700372808f, -0.677306526467426f, -0.348340058872692f, 0.651490451411335f, -0.133387041637395f, 0.718311240322040f, 0.0869279817052975f, 0.155413706090559f, -0.869119988858735f, -0.566773040844476f, -0.0513826414151206f, -0.368087669232071f, -0.978175512831125f, -0.229213501073727f, 0.344608572405871f, -0.663307667219997f, 0.437238632879575f, 0.00205230197288353f, -0.0897076092856746f, 0.834529513214144f, 0.131872357342232f, 0.113081940417244f, -0.418620232731326f, -0.317993033651213f, -0.740303025960662f, 0.423423655701288f, -0.300833032468860f, -0.458960388256530f, 0.692670405117589f, -0.559944357561921f, 0.0168623577148430f, 0.568661331088367f, -0.385055363002398f, -0.356055436463140f, -0.794446573681063f, 0.908870080953069f, -0.295500656666577f, 0.800625150733729f, 0.206307902542489f, 0.729591183391974f, -0.0655746333947396f, -0.261707022686154f, -0.802380330579914f, 0.0812359238243023f, -0.00528231140765212f, -0.725740453383981f, 0.919076065030463f, -0.896497189839174f, 0.861919731820265f, -0.804273875755869f, 0.230339021648310f, 0.296779613186519f, -0.349872572510143f, -0.270230381483447f, 0.0368924200249658f, 0.581340248642417f, 0.943620537648739f, 0.715012058065301f, 0.528414993233909f, 0.695917111744314f, -0.634354198968852f, -0.483786223099716f, 0.565405035681248f, -0.530076864213017f, 0.363019522302994f, -0.825556544716473f, 0.891096876998683f, -0.990692760548295f, -0.450641405862313f, -0.597008073985341f, -0.464377765418678f, -0.942926913464693f, -0.871399725569805f, 0.232335933943403f, 0.858786794807406f, -0.528589179815518f, -0.324757177062634f, 0.595880088750788f, -0.976574570427974f, -0.423824220654658f, -0.832990206908489f, 0.198704682807118f, -0.168244652325292f, 0.843066822744011f, 0.0912498543932607f, 0.485570815146582f, -0.104653316420662f, -0.623461298489716f, -0.807713596811018f, 0.737782734425857f, 0.456364368166532f, -0.430703367862900f, -0.188953991637209f, -0.827984282695373f, 0.0246267653665548f, 0.891225605267640f, 0.910600867999638f, 0.345236086687552f, -0.600682365520065f, 0.833182106437698f, 0.213749250288017f, -0.0866339102562885f, -0.618385082289017f, 0.859527120927500f, 0.749978780964161f, -0.334770513867011f, 0.242140166670949f, -0.196268320459958f, 0.611789869603675f, 0.655057159657307f, -0.603759576722096f, 0.614654509385217f, 0.144145218488192f, 0.959930150756613f, 0.485009777784726f, -0.564230295010912f, -0.404716165405314f, 0.0442672151313601f, 0.929486639423805f, 0.409386317338224f, 0.527053707674182f, 0.899087569745327f, -0.933259779365388f, 0.265159475034860f, -0.858300862890810f, -0.870994388031662f, 0.354868177430506f, 0.00956840260511749f, 0.429740959889133f, 0.649668163567379f, -0.744532888765288f, -0.967499901569196f, 0.556703631745254f, 0.535130550118618f, -0.639502350153040f, -0.604586469532735f, 0.0799683564329623f, -0.156074786599444f, -0.348308700325411f, 0.217829052228100f, 0.545642400171123f, -0.303317700019152f, -0.473220675222451f, -0.239688108834945f, 0.0998500862725149f, -0.962734081833842f, 0.870743993144299f, 0.464578557934316f, 0.184511089576136f, 0.559729843314504f, 0.0702052363354577f, 0.632714874625648f, 0.212930743289312f, -0.454606863365109f, -0.592679055778218f, 0.287649993384466f, -0.457293694071368f, -0.423493046785686f, -0.0674763327876298f, 0.242131064298176f, 0.488581911885965f, -0.464567743213882f, -0.387515661812354f, -0.914585596974616f, -0.255803162310627f, 0.941267268311980f, 0.690278917089395f, 0.302397314111962f, -0.178461434689705f, -0.949279941481428f, 0.160440202901122f, -0.970582196769486f, -0.0119478205074164f, -0.206440255898676f, 0.221640403444713f, -0.819801447827624f, 0.263614394802488f, 0.616376195532700f, -0.596859494305351f, -0.118659509995453f, 0.458168997595326f, -0.0400474705134108f, 0.934465050133603f, -0.852936731989621f, 0.0191637795580570f, 0.298534793677081f, -0.857491630206749f, -0.0141198383157879f, -0.365027350962024f, 0.450964838023674f, 0.351383095290905f, -0.387039947149600f, -0.983994933095116f, 0.610531582220017f, -0.0446025524732094f, 0.216718014780746f, -0.676819246943449f, 0.0385619292249610f, 0.192482456707739f, -0.288809653393521f, 0.241774557042318f, -0.444638770943313f, 0.535319194413803f, 0.374773141606987f, 0.186364279454450f, 0.0701814972821988f, -0.452753172654203f, -0.350918291268194f, -0.332963791049667f, 0.179301863965318f, 0.954101654404080f, -0.687960044344130f, 0.611454049205213f, -0.696789567124132f, -0.551566492897529f, 0.656434797122885f, -0.601779335396959f, -0.265656331560395f, -0.528821434638507f, 0.153601151147409f, 0.514739334540489f, -0.0517769842323894f, -0.659246830986894f, -0.453055366696259f, -0.0515886000780059f, 0.958478845408115f, 0.0221452906045994f, -0.159960643390796f, 0.816263632871352f, 0.245244170325114f, -0.0919839688704780f, 0.947170598807362f, 0.846772793441790f, 0.247105133025056f, -0.801972939368103f, -0.224977420586025f, 0.130099925027197f, 0.497816036746753f, 0.308139730113712f, -0.0536876417759813f, -0.492022090866895f, 0.188938438822753f, -0.400894058284033f, 0.314370104391157f, 0.618580768947071f, 0.830051263404639f, -0.228700130023340f, 0.811855169643177f, 0.0924092179787017f, 0.273652523319809f, -0.0624274843235475f, -0.503696982048589f, 0.510545161203341f, 0.341823133345436f, -0.437486933663093f, 0.0134072800031224f, 0.613837993234983f, 0.740945655313894f, 0.135311460882606f, 0.464832228842466f, -0.973962843371452f, -0.519388256678232f, 0.631469277357519f, -0.936937468616713f, 0.208677911871604f, -0.0946010975796272f, 0.560587233611855f, 0.230925763372331f, -0.637408482848184f, -0.679175194353885f, -0.408696637706987f, -0.0837464598184048f, -0.911070817707239f, 0.985815432104941f, -0.208807972878988f, 0.741966810464688f, 0.162772839973564f, 0.717702638881939f, 0.490767958961575f, -0.835565390813677f, -0.878516167634055f, -0.956727838876563f, -0.00772081382858891f, 0.355227897612178f, 0.202889185809854f, -0.431078767653467f, 0.106936101717808f, 0.354494042302258f, -0.619623833602791f, 0.193065593078352f, -0.105803087758606f, 0.151828327005194f, -0.141094922099930f, 0.847569902283069f, -0.656683924792181f, -0.880754505470701f, -0.421714047610595f, 0.681762288858050f, 0.633712681698887f, 0.947060360650644f, -0.959122611588459f, -0.0690574969687099f, -0.805062392278087f, 0.226501754467861f, -0.414732397455275f, 0.242398867364043f, -0.831838824773804f, 0.00787391802290793f, -0.860692119913991f, -0.391321299589110f, -0.0548681430681355f, -0.992920640472037f, 0.0975642331777702f, 0.894630836703243f, 0.767919825689366f, -0.260878774442215f, 0.407457430171103f, 0.140688657702825f, 0.737494845272763f, -0.650969054257040f, 0.230613259000797f, -0.0986876345046772f, 0.0996951163848971f, -0.679173062298700f, -0.760174222364469f, -0.613840714529317f, -0.692138390397415f, -0.0919103790884603f, 0.0259548517830916f, 0.463763807478796f, -0.859327137970617f, 0.298600182982665f, -0.591236092977368f, -0.994984881037264f, -0.0533840054951049f, 0.544979189292485f, 0.652482875230260f, 0.897548627394727f, -0.340241293753474f, 0.508237349558163f, -0.611986702936889f, -0.399952468536369f, -0.758494484998191f, -0.148960755782999f, 0.895231513826071f, -0.870487943961511f, -0.172763884748068f, -0.652702954266129f, 0.784450103085903f, -0.428504279168614f, -0.347266234450861f, -0.0897193897382391f, 0.760686883857503f, -0.0863659842493281f, -0.453544362916610f, 0.713112885874267f, -0.529914378597266f, -0.134507787695203f, -0.590955798880753f, -0.372583442870916f, 0.646730663631020f, -0.809515553972267f, 0.0226873348847205f, -0.209338539804651f, -0.737170063193136f, 0.365916689978321f, 0.658019395382111f, 0.733982378695990f, -0.579926149814113f, 0.973814182111372f, 0.933875763922095f, -0.985234946636757f, -0.103124599698243f, -0.798304574918884f, -0.119705341414667f, 0.205941898284561f, 0.111088288053652f, 0.418598493379981f, 0.309112287901667f, 0.0865232803642195f, -0.281174085998345f, -0.158426951248790f, 0.156672456990889f, 0.608691108739118f, -0.124654784531448f, -0.372060827503666f, 0.555750853569654f, -0.481715370485256f, 0.411012047999522f, 0.265636511301544f, 0.164466400718006f, 0.427292785417094,
-0.407665783814271f, 0.0463239131527564f, 0.0109249300633605f, 0.0949704798708169f, 0.223291931618591f, 0.708651599857453f, 0.810927407452143f, -0.298811874805995f, 0.347215272448441f, 0.778225160999446f, -0.981258755328673f, -0.629231280170021f, -0.948786159268210f, -0.0530522786747270f, -0.665046033882002f, 0.776993795678436f, -0.604492154463805f, -0.906360689482177f, 0.543616910115371f, -0.501547360013149f, 0.571784796850774f, 0.868511495621889f, 0.783008382563488f, 0.571870376568081f, 0.0471150346240308f, 0.402433510592678f, 0.661353159662286f, 0.0253381317208246f, 0.720141243708461f, -0.478805385943742f, 0.989639021624774f, 0.538614599364854f, -0.282810721919526f, 0.888399971333007f, 0.118572990347886f, 0.564528382703688f, 0.988296121763412f, 0.509638594649021f, -0.797738059997026f, 0.0363326380089621f, 0.978315833815278f, -0.483368013204689f, 0.879051054425480f, 0.632539830439323f, 0.722677742708361f, 0.578919286433726f, -0.250721628167261f, 0.534435049744896f, -0.0404568429105234f, 0.00805525426120179f, 0.841210870775473f, -0.731771544679396f, 0.713758914490801f, 0.830250762535296f, 0.436563669872217f, 0.567024378980237f, 0.983941121609744f, -0.253548560865555f, 0.647105012325159f, 0.434994339049196f, 0.130837710207442f, -0.775136733344706f, 0.234917279141211f, -0.498429841761386f, -0.273571256415041f, 0.247467425899991f, -0.970396693506149f, 0.975835855884816f, -0.347896516486866f, -0.552856369180847f, -0.887336234316568f, -0.573271015958957f, 0.910862901097874f, -0.807236601077904f, -0.523971593712952f, -0.263589563369279f, 0.591056276091253f, -0.320168527954128f, 0.726795865615521f, -0.731502115921006f, -0.942225519371229f, 0.268573107637337f, 0.380348127119473f, -0.284539943611895f, 0.117478291379931f, -0.817442486350524f, 0.0734705767013011f, -0.626880755668906f, -0.873066996524459f, -0.528675805715351f, 0.490255491577847f, 0.398142666604162f, -0.911320079669940f, -0.870350237514323f, 0.854587452657144f, 0.736349579728106f, 0.948232845958681f, -0.00126774478569258f, 0.905641169934000f, -0.965500575551565f, 0.0831330388550517f, -0.892713267782484f, -0.277958019172831f, 0.312987842344813f, 0.484268977417485f, -0.365960524226328f, 0.177956605738091f, 0.913776767689874f, -0.897537691614058f, 0.473075982698961f, 0.913190042662185f, -0.00843862630950820f, 0.972679442298938f, -0.856058592202917f, 0.264007224067230f, -0.138444823656136f, -0.386195416368251f, -0.286657907928107f, -0.231200657384828f, 0.917365701941188f, -0.271317547281263f, -0.252691685075831f, 0.893742787021399f, 0.512463051119608f, 0.979155111008605f, -0.472272776864686f, 0.238767541974988f, -0.672234403865928f, -0.846783135777377f, 0.0877594573148737f, 0.493055606176910f, -0.289012308379085f, 0.416463895880697f, -0.0795051375851281f, -0.476692131327163f, -0.430471976159529f, -0.701875030095239f, 0.724684336417516f, 0.984802039066595f, 0.798285421773762f, 0.000509924988974175f, -0.0852199551444761f, -0.709724122158260f, -0.332735158942919f, -0.741119907407496f, 0.729608513555970f, 0.500578022862182f, 0.520862987462710f, 0.565678561009731f, -0.393741545311224f, -0.568866018100912f, 0.571654318026290f, -0.817900961532165f, -0.793268461448962f, 0.614914392385859f, 0.763415306986536f, 0.450074180772758f, -0.737435729799608f, 0.841185794339245f, 0.894276069286366f, -0.276262284222369f, -0.798623475612628f, -0.280994234105732f, 0.821175230597885f, -0.474251640366966f, -0.190039801864015f, 0.0663032720971493f, 0.884162053156770f, -0.162023139878049f, -0.963135153785511f, -0.582213329804047f, -0.328536493809765f, -0.938405687658462f, -0.0171569611327957f, -0.727260847907578f, 0.419920927745257f, -0.361592243835530f, 0.476989471873569f, -0.146161675185107f, 0.431817832405826f, -0.371528849369885f, -0.940567978751516f, 0.165203770962029f, 0.781321525273307f, 0.0585592625092357f, 0.573299596753579f, -0.378869924017182f, 0.523139576520889f, 0.385605607116478f, -0.235893429970747f, 0.285814921067909f, -0.121941292771133f, 0.621558611608942f, -0.0860979132283732f, -0.627097832687809f, -0.312083243705910f, -0.494490796681559f, -0.987187334387934f, -0.0804474888246625f, 0.496400656176795f, -0.851811189314651f, -0.791398271297849f, -0.868174317799275f, -0.226794668997878f, -0.335339474552766f, -0.276765924750817f, -0.395876032147377f, -0.740529136126816f, -0.167799472110453f, 0.593129248263724f, 0.336783120133436f, 0.248892158925787f, 0.950120283075237f, -0.795216613504226f, -0.574731116508357f, -0.822689608026685f, 0.973698546284335f, 0.125166556654624f, 0.588150318080073f, 0.128654744345192f, -0.219207714307262f, -0.271053050307713f, 0.124071241265810f, -0.618209718015327f, -0.766619799595349f, -0.478340220431165f, -0.446873929629545f, 0.978019432749647f, -0.627041040766022f, 0.169323691066764f, -0.714079827532216f, 0.386101296128268f, -0.360225804976135f, -0.236797717782837f, -0.311635747131794f, 0.0482888201705840f, -0.477302740867809f, -0.427349080854399f, 0.390352470816329f, 0.611790541936623f, -0.648292156214605f, -0.345871618789073f, 0.509300603302844f, -0.0142202703124219f, -0.570248077753979f, -0.0629178211029751f, -0.737806048037047f, 0.497750084049821f, -0.761650107803135f, -0.788756591098617f, -0.994497286039420f, -0.987344273533962f, 0.657151987467984f, -0.763708299084062f, -0.0729359162118841f, 0.0455275633022023f, -0.101919187896584f, 0.457804242981095f, 0.0117715388281796f, -0.274125197027132f, -0.949738804931191f, 0.762108173886486f, 0.405150754308562f, -0.733330375873553f, -0.712774896799572f, -0.791947616412901f, 0.444023894424500f, 0.00507562975249609f, -0.900698136223538f, -0.576055334977054f, -0.948895529956106f, -0.832665060374124f, -0.992753953473078f, -0.0674086978315183f, 0.569494111501383f, -0.962269067721443f, -0.489700810475570f, 0.972626508328545f, -0.777400448149780f, 0.115588644128954f, 0.0730469703310024f, 0.523584488072518f, 0.659055312807301f, 0.134198234373838f, -0.797833055125151f, -0.167842823235145f, -0.662347837139732f, -0.537544370279756f, -0.622353549740796f, -0.789789664448618f, 0.985300123665319f, 0.862449845163424f, 0.973193986256980f, 0.148883268671144f, 0.283619537155083f, 0.508503183151258f, -0.246167305966866f, -0.259543094514413f, -0.778029136807597f, 0.128978622849116f, -0.920978818238085f, -0.116324837544276f, -0.261472397833253f, 0.772449038068069f, -0.696754008784325f, 0.980778877985902f, -0.227636956328402f, -0.472493776528032f, -0.568519858000960f, -0.151689463117960f, -0.102997587484899f, 0.464752146042376f, -0.839114793935065f, -0.0325074343587592f, -0.180618880765978f, 0.0132253638432844f, -0.646173464496730f, 0.821983901071593f, 0.657453744559881f, 0.786315172070382f, -0.438718096604728f, 0.702691078885442f, 0.859957412428682f, -0.505281395658564f, -0.236722160990303f, -0.698465568366759f, -0.746418979540090f, -0.218205126412646f, -0.808715244840435f, -0.949813739800491f, 0.176975348790769f, 0.723960974918154f, -0.139253733704369f, -0.387224393658603f, -0.869945438924443f, -0.396979039594941f, 0.0256060022407458f, -0.566074790002811f, -0.161564565183606f, -0.736189868188370f, -0.205593811665825f, -0.628996407588712f, -0.0266462623004120f, -0.344127255771429f, -0.229003801178142f, -0.469786561635510f, 0.258249378153965f, 0.160442939158622f, 0.0528817242116550f, 0.261960766261548f, -0.571069557415276f, 0.411333771884545f, -0.145205354714326f, 0.249324532476397f, 0.163889600722793f, 0.649915677347011f, 0.147077371087195f, -0.227104208942068f, 0.867390199578604f, -0.0734153565896754f, 0.0491208061060167f, 0.0360590744216485f, 0.181620126101180f, 0.0567549454976457f, -0.856976992549465f, -0.242511192726339f, -0.624770508991394f, -0.793161214564285f, -0.251208532727981f, -0.833192309869275f, 0.368166434661069f, 0.939730260791580f, 0.305796202211942f, -0.598830491282818f, -0.0575368190467946f, 0.371329658849021f, -0.227872714677810f, 0.707539568196379f, 0.795186297468385f, 0.475847791658551f, 0.829361555893632f, 0.405386540930889f, 0.213282954068900f, 0.767339023510319f, 0.525055513018554f, 0.259437496637378f, -0.524342591286100f, -0.731515526086696f, -0.233118783725590f, 0.237972339628935f, -0.933985285078109f, 0.537013420173496f, 0.498819465200784f, -0.407713459607516f, 0.382821417923595f, -0.416894700661466f, 0.0787266904103943f, -0.0627973593192392f, -0.320105342653426f, -0.844066834407447f, 0.138221622417319f, -0.676665423871596f, -0.961043785105959f, 0.832268610130385f, -0.905530890441773f, -0.114191325652611f, -0.376697124207843f, 0.390323137798417f, 0.953143142925101f, 0.983427991280007f, -0.0895687386326503f, -0.681543125061097f, 0.677131540142176f, -0.867715848764628f, -0.812718786220309f, -0.212509939486840f, -0.990002327123638f, -0.0682855560011961f, 0.129310729289606f, -0.623746296335073f, -0.285580241032587f, 0.235626081900812f, -0.611973228709249f, 0.539189737955466f, 0.970058678533189f, 0.901944358898624f, 0.168094826408153f, -0.666711281252260f, 0.965612752173968f, 0.651034558458719f, 0.687501917067508f, 0.758614314567106f, -0.839396045781239f, -0.552775028233564f, -0.528941743867256f, 0.174761156721889f, 0.243585712774679f, 0.588913151268911f, -0.306898192880627f, 0.921540023069231f, -0.0223654942298541f, -0.102408576957649f, 0.612577852207921f, 0.835809058447089f, -0.437118459197839f, 0.455316033239981f, 0.311435507416257f, -0.648992336007256f, 0.346823844785409f, -0.632080213667648f, -0.599678627679202f, -0.653822991854328f, 0.484305292443427f, 0.782046295685087f, 0.960987598814982f, 0.627169162605570f, 0.948092598306120f, -0.185268381817018f, 0.602489977060513f, -0.885827813790617f, -0.00179203147433582f, -0.175476447614991f, 0.0461282236560925f, -0.898013889602944f, 0.256310837914276f, -0.733422110056865f, -0.740091677658095f, 0.966724540497493f, 0.328056986822768f, -0.267854591449557f, 0.670545831663244f, -0.356204313297688f, 0.0729865206358908f, -0.594530723723669f, 0.519965324048968f, 0.0632129606097647f, -0.878434885663544f, -0.497945943395010f, 0.0151854050905818f, -0.218036856012343f, 0.547721213710874f, -0.0915514918588898f, -0.279344098401951f, -0.228654882218650f, 0.100432155997130f, 0.802024600677294f, 0.175832345686877f, 0.0551231013299744f, 0.938247319394824f, 0.639298571360036f, -0.291461603371678f, -0.853503115314794f, -0.604829242631156f, 0.0291571486740745f, -0.932575328418390f, -0.621235088415116f, 0.403040314052094f, -0.809695618266849f, 0.966605888732736f, -0.199254401023053,
-0.540808222970056f, -0.0141840769249790f, 0.114579158224093f, 0.466889318471371f, -0.145415211797766f, -0.846707387707480f, -0.881237200733915f, -0.410798723199712f, -0.637697860299854f, -0.196366036081372f, 0.193267531425712f, -0.258591200841940f, -0.173003722066551f, 0.478121376006132f, 0.953819951501542f, 0.969916001975448f, 0.131515861287576f, -0.499829658784781f, 0.320952777516193f, -0.226980682212371f, 0.766886115655233f, 0.647310434110803f, -0.772594685974992f, 0.772645949480187f, -0.936357605801364f, -0.671842916281206f, -0.595127074295355f, 0.335132581825520f, 0.648964430112689f, -0.793376819398441f, -0.963663232647360f, 0.914308824314478f, -0.397663128784982f, 0.803240040231588f, -0.291039120047626f, -0.339918835846510f, -0.208620988780609f, 0.278177231697424f, -0.833157746552451f, 0.260554706029473f, -0.580537744139231f, 0.918561093477862f, 0.641368468308093f, 0.827379039283645f, -0.412231303854834f, -0.518315486749742f, 0.423356687848085f, 0.0777277584993787f, 0.394127392657178f, 0.609705410002715f, 0.264669032561337f, -0.460555696512027f, -0.0858908123066196f, -0.281781559603429f, -0.179777723960362f, -0.00449990348855067f, 0.803703377739133f, -0.155074032314596f, -0.00206139428833696f, 0.0661730930565525f, -0.737509215752079f, 0.620182143819587f, 0.114750705414661f, 0.545663051433958f, 0.661601724477194f, -0.592280382351976f, 0.609240020031149f, -0.968781019917808f, -0.668068368389875f, 0.206915551463500f, 0.0951453192552747f, 0.268580107578401f, -0.0450052302342363f, -0.933589842483940f, 0.236570492858402f, 0.0688734168318912f, 0.930163232697303f, 0.435953476823146f, 0.533759385687075f, 0.368282038662015f, -0.602312961473778f, 0.709516631712345f, -0.168303926671961f, 0.130670870119294f, -0.657736111745007f, 0.115028598388756f, 0.173728026281032f, -0.681671363429886f, -0.538786035950873f, 0.481457671665448f, 0.0136795278434168f, -0.570065342244344f, 0.188187050857249f, -0.352869308173680f, -0.979175308628854f, 0.223702879460018f, 0.994220466087713f, -0.147795166105729f, 0.218427535879435f, -0.120050826084179f, -0.0124939247430063f, -0.645134875027126f, -0.503122688484778f, 0.534123007328982f, 0.619710972635444f, -0.234248243706177f, 0.987144458053815f, 0.261284702576427f, 0.851827092094236f, 0.750019654249059f, -0.926154630610335f, 0.449356103243440f, 0.783011320523296f, -0.459228158107270f, -0.228877816937867f, 0.271108937592868f, -0.676085611673506f, 0.783114428240160f, 0.636093784021493f, -0.754110314308629f, -0.546386104880684f, 0.0385811136139234f, -0.768951137117397f, -0.644624743947807f, 0.00890157035391148f, -0.0792572116273387f, -0.989980668770044f, 0.603057533157075f, 0.280835727469123f, -0.634716709420524f, -0.712669415138995f, -0.424129916157595f, -0.436923748487354f, 0.467366013559791f, 0.907740481011987f, 0.788617065944311f, -0.152237692069130f, -0.963044404518533f, 0.907393322909416f, 0.806867676446313f, 0.699270310021791f, 0.107867603776547f, 0.127360747415417f, -0.502645789696788f, -0.511744166872327f, -0.121672719343072f, -0.596527146770249f, 0.410180172377510f, -0.852889849908704f, 0.278972213674154f, 0.0260156356783650f, 0.997558501949683f, -0.499245840292893f, -0.451169267624132f, -0.881643497362337f, 0.986957209874262f, -0.129608292321380f, 0.935829016346258f, -0.649021465281634f, 0.550436689069794f, 0.278888743082679f, 0.0137769346664500f, -0.660666060213522f, -0.416709136728042f, -0.302903068397225f, 0.180657445835459f, -0.908195955986293f, 0.280056533234627f, -0.660025789034158f, -0.798207438952561f, 0.901575224780405f, -0.608702932295102f, 0.318860199910414f, 0.874005722023406f, -0.0816057579181704f, 0.981671341873017f, -0.339234700161323f, 0.559717959858931f, 0.390363525109105f, -0.309384476087470f, 0.956563156784297f, -0.623734354817613f, -0.196627375289105f, -0.702076014509088f, 0.293098766889643f, -0.617152224560368f, 0.859117491438645f, 0.661015739867647f, 0.0747554166353739f, -0.282417009682732f, -0.667461537762524f, -0.451029960388404f, -0.464518668674360f, 0.591389440503293f, 0.552648871601186f, -0.242406315814918f, 0.147876771864331f, -0.00605730052917419f, -0.850648363553678f, -0.659957159486993f, -0.165475362851332f, 0.204150315434812f, -0.665767311591476f, -0.716154682563576f, 0.417487456932076f, 0.448184990956287f, 0.733843802413198f, -0.170228277851921f, -0.346809954182150f, 0.956058632188011f, 0.0315623945930987f, 0.509027121691627f, -0.147826185909834f, 0.717423768198044f, -0.153258078639530f, -0.586190749016474f, 0.122228033051868f, -0.884999045468193f, -0.364729711773548f, 0.0869976154696972f, -0.793532199218799f, 0.533748273468951f, -0.852754376244435f, 0.294752047699830f, 0.136764278163013f, 0.838074791168389f, 0.795224598541123f, -0.778005568697498f, -0.260924769562304f, -0.303759147861313f, 0.273726011325558f, 0.530476779331216f, 0.0866801234357086f, 0.0677702376031544f, 0.724353404182035f, -0.974710312543683f, 0.791838170482991f, 0.247768259921660f, 0.979431048271259f, -0.386992541899814f, 0.0640038231299192f, -0.00457726816166693f, 0.371455553726539f, 0.647649995487707f, 0.268304945808406f, -0.320428608173924f, 0.0927511620029309f, 0.256010036486838f, 0.740396212690346f, -0.656873241472848f, 0.823534292439413f, -0.820380362458844f, -0.453300307443023f, 0.784238355222248f, 0.912791840124321f, 0.0999478035440859f, -0.212620916988855f, 0.0170290625008669f, -0.589062380565879f, -0.171833624145497f, -0.524918122866141f, 0.961528292650892f, 0.101262818636430f, 0.941455114569308f, -0.967226220138929f, 0.616781547648562f, -0.913823148383971f, 0.274508821885917f, 0.924653374107756f, -0.866302908989783f, 0.227541907715857f, 0.0907574361370582f, -0.127499097943315f, -0.942071371521895f, -0.119419163649152f, 0.674284088819523f, 0.881328505929745f, 0.246290207551702f, 0.0547607254148590f, -0.462882918359077f, 0.888969728230585f, 0.666583509571921f, 0.238417203582380f, -0.279842248122727f, 0.855260336845903f, 0.314306869401155f, -0.188654877893078f, -0.609304918228150f, 0.169453885325888f, 0.265617874907016f, -0.943423537926184f, 0.493118676869450f, -0.386147750024858f, 0.0103920154342951f, 0.753677832518483f, 0.363353012331066f, -0.286620106520429f, -0.623332994906295f, 0.183966714365642f, -0.124278942882867f, -0.687889346448110f, -0.509002319646341f, -0.705769785650865f, 0.600586126467172f, 0.814989294939922f, 0.198959025256652f, 0.477897007911356f, 0.757957814363899f, 0.617755921094230f, -0.353589871947529f, 0.419688673189503f, -0.860584865805600f, -0.0232779635193843f, -0.789951030889387f, -0.893196700185750f, 0.610996462535201f, 0.847373590985131f, -0.989553358501822f, -0.367651771428081f, 0.741563712056747f, -0.923595352848971f, -0.580174215739367f, 0.577092000574232f, -0.910872910110270f, -0.907499077314190f, 0.692372247654077f, 0.810694134592084f, -0.608596332548047f, 0.761254615051625f, 0.0546240611947364f, -0.393956427117691f, -0.116127831535139f, -0.0352014590913388f, 0.374742194768889f, -0.927344099730091f, 0.939301337232488f, -0.969831716293845f, -0.0489333404770240f, -0.586719398908953f, 0.0235541378462407f, 0.388882981728285f, -0.0728483242295113f, 0.418280445244943f, -0.574289337805456f, -0.779962057565259f, -0.835190719754123f, 0.918717316922657f, -0.765889988109173f, -0.935310664146932f, -0.0750906135370848f, -0.256246546197534f, 0.693865929543926f, 0.592800255527084f, 0.836743344551035f, -0.801953470827580f, 0.0595524153568945f, 0.158376549012192f, -0.429364776412726f, -0.450531184162532f, -0.169317185285268f, 0.420344570579195f, -0.902838087574441f, -0.654676904337469f, 0.941802178622893f, -0.411034608875500f, -0.455381371659872f, 0.582371240315256f, -0.276150504466756f, 0.164276403376185f, -0.960238817086774f, 0.590055303394028f, -0.995185688656226f, -0.285809748360467f, -0.792066171752882f, -0.456123303649101f, -0.864169187700384f, 0.798745251308383f, -0.517673464079948f, 0.523086536900369f, 0.398784615211052f, 0.908677185333852f, -0.434846969584770f, -0.277024535706464f, 0.575800013122065f, -0.0423952171673019f, -0.327530749916683f, -0.401220909875065f, -0.232577533032385f, 0.577630268254944f, -0.733290201484409f, -0.297499739456838f, 0.166541885572822f, -0.646828619904039f, 0.0312662656272755f, 0.754145050600965f, -0.908499825108811f, 0.315379190361296f, 0.366242661082351f, 0.867903806940678f, -0.613391940567782f, 0.00760147209048068f, 0.953424134034927f, -0.812551125910811f, 0.734998935207065f, 0.781720854678504f, -0.653974423413561f, 0.612587888218526f, -0.297359914095386f, -0.409559158758694f, -0.143962230212734f, -0.814888102841114f, 0.359131810502055f, 0.356924557741016f, -0.872415989401612f, 0.716849887848809f, -0.374916928585818f, -0.0702264435280595f, 0.329843438660215f, 0.0956097573088677f, -0.937528128860310f, -0.322293489817529f, 0.781444964993177f, -0.810141738751828f, -0.150295079242497f, 0.846909181293597f, -0.128124277517711f, -0.752611695817661f, 0.839996835828451f, -0.0705685941510277f, 0.000366462394740585f, 0.0788016995849923f, -0.246053200655556f, -0.156645099915028f, -0.460752333796863f, 0.622021359864204f, 0.722871957583123f, -0.257873353238499f, -0.309810184480446f, 0.765248644407833f, -0.553316047243663f, -0.612742789838491f, 0.354017349601509f, 0.923293368553697f, 0.630695912377860f, -0.148750121613537f, -0.821801680234240f, 0.368247966228196f, 0.405416044101496f, -0.803232509711354f, -0.429778551911399f, -0.723837414527446f, -0.963925147452133f, 0.190882872226757f, 0.477008077263598f, -0.661282403679070f, 0.271643442525556f, -0.915994079618801f, 0.196564556546175f, 0.378359035245796f, 0.584016730657668f, -0.0377864332655202f, -0.327376192853106f, 0.850744189707984f, 0.799571679043808f, -0.111126908452029f, 0.525587242291601f, -0.404486180733535f, -0.134496922397279f, 0.0890128096708100f, -0.815560643303157f, -0.920166023598312f, -0.360079578314899f, -0.556238898466371f, -0.220978103133838f, -0.571530268052405f, 0.573332217175226f, -0.133862258696460f, -0.982130330352248f, -0.352538465285082f, 0.318683937697894f, -0.790927430842686f, 0.691168535237102f, 0.806014327242002f, -0.981639450008060f, 0.407200095027265f, 0.918249921845949f, 0.776880149695420f, -0.437773083955269f, -0.385117533333437f, 0.0115152415796460f, 0.687224538003991f, 0.992524870612626f, 0.471003324792228f, -0.873541777412034f, -0.560923118634380f, -0.726151823613842f, -0.538941951730010f, 0.772057551475325f, 0.858490725829641f, -0.168849338472479f };
# 102 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t wrap(fxp_t kX, fxp_t kLowerBound, fxp_t kUpperBound)
{
int32_t range_size = kUpperBound - kLowerBound + 1;
if (kX < kLowerBound){
kX += range_size * ((kLowerBound - kX) / range_size + 1);
}
return kLowerBound + (kX - kLowerBound) % range_size;
}
fxp_t fxp_get_int_part(fxp_t in) {
return ((in < 0) ? -((-in) & _fxp_imask) : in & _fxp_imask);
}
fxp_t fxp_get_frac_part(fxp_t in) {
return ((in < 0) ? -((-in) & _fxp_fmask) : in & _fxp_fmask);
}
float fxp_to_float(fxp_t fxp);
fxp_t fxp_quantize(fxp_t aquant) {
if (overflow_mode == 2) {
if(aquant < _fxp_min) {
return _fxp_min;
}
else if(aquant > _fxp_max) {
return _fxp_max;
}
}
else if (overflow_mode == 3) {
if(aquant < _fxp_min || aquant > _fxp_max) {
return wrap(aquant, _fxp_min, _fxp_max);
}
}
return (fxp_t) aquant;
}
void fxp_verify_overflow(fxp_t value){
fxp_quantize(value);
printf("An Overflow Occurred in system's output");
__DSVERIFIER_assert(value <= _fxp_max && value >= _fxp_min);
}
void fxp_verify_overflow_node(fxp_t value, char* msg){
if (1 == 2)
{
printf("%s",msg);
__DSVERIFIER_assert(value <= _fxp_max && value >= _fxp_min);
}
}
void fxp_verify_overflow_array(fxp_t array[], int n){
int i=0;
for(i=0; i<n;i++){
fxp_verify_overflow(array[i]);
}
}
fxp_t fxp_int_to_fxp(int in) {
fxp_t lin;
lin = (fxp_t) in*_fxp_one;
return lin;
}
int fxp_to_int(fxp_t fxp) {
if(fxp >= 0){
fxp += _fxp_half;
} else {
fxp -= _fxp_half;
}
fxp >>= impl.frac_bits;
return (int) fxp;
}
fxp_t fxp_float_to_fxp(float f) {
fxp_t tmp;
double ftemp;
ftemp = f * scale_factor[impl.frac_bits];
if(f >= 0) {
tmp = (fxp_t)(ftemp + 0.5);
}
else {
tmp = (fxp_t)(ftemp - 0.5);
}
return tmp;
}
fxp_t fxp_double_to_fxp(double value) {
fxp_t tmp;
double ftemp = value * scale_factor[impl.frac_bits];
if (rounding_mode == 0){
if(value >= 0) {
tmp = (fxp_t)(ftemp + 0.5);
}
else {
tmp = (fxp_t)(ftemp - 0.5);
}
} else if(rounding_mode == 1){
tmp = (fxp_t) ftemp;
double residue = ftemp - tmp;
if ((value < 0) && (residue != 0)){
ftemp = ftemp - 1;
tmp = (fxp_t) ftemp;
}
} else if (rounding_mode == 0){
tmp = (fxp_t) ftemp;
}
return tmp;
}
void fxp_float_to_fxp_array(float f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
r[i] = fxp_float_to_fxp(f[i]);
}
}
void fxp_double_to_fxp_array(double f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
r[i] = fxp_double_to_fxp(f[i]);
}
}
# 275 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
float fxp_to_float(fxp_t fxp) {
float f;
int f_int = (int) fxp;
f = f_int * scale_factor_inv[impl.frac_bits];
return f;
}
double fxp_to_double(fxp_t fxp) {
double f;
int f_int = (int) fxp;
f = f_int * scale_factor_inv[impl.frac_bits];
return f;
}
void fxp_to_float_array(float f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
f[i] = fxp_to_float(r[i]);
}
}
void fxp_to_double_array(double f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
f[i] = fxp_to_double(r[i]);
}
}
fxp_t fxp_abs(fxp_t a) {
fxp_t tmp;
tmp = ((a < 0) ? -(fxp_t)(a) : a);
tmp = fxp_quantize(tmp);
return tmp;
}
fxp_t fxp_add(fxp_t aadd, fxp_t badd) {
fxp_t tmpadd;
tmpadd = ((fxp_t)(aadd) + (fxp_t)(badd));
tmpadd = fxp_quantize(tmpadd);
return tmpadd;
}
fxp_t fxp_sub(fxp_t asub, fxp_t bsub) {
fxp_t tmpsub;
tmpsub = (fxp_t)((fxp_t)(asub) - (fxp_t)(bsub));
tmpsub = fxp_quantize(tmpsub);
return tmpsub;
}
fxp_t fxp_mult(fxp_t amult, fxp_t bmult) {
fxp_t tmpmult, tmpmultprec;
tmpmult = (fxp_t)((fxp_t)(amult)*(fxp_t)(bmult));
if (tmpmult >= 0) {
tmpmultprec = (tmpmult + ((tmpmult & 1 << (impl.frac_bits - 1)) << 1)) >> impl.frac_bits;
} else {
tmpmultprec = -(((-tmpmult) + (((-tmpmult) & 1 << (impl.frac_bits - 1)) << 1)) >> impl.frac_bits);
}
tmpmultprec = fxp_quantize(tmpmultprec);
return tmpmultprec;
}
# 372 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t fxp_div(fxp_t a, fxp_t b){
__DSVERIFIER_assume( b!=0 );
fxp_t tmpdiv = ((a << impl.frac_bits) / b);
tmpdiv = fxp_quantize(tmpdiv);
return tmpdiv;
}
fxp_t fxp_neg(fxp_t aneg) {
fxp_t tmpneg;
tmpneg = -(fxp_t)(aneg);
tmpneg = fxp_quantize(tmpneg);
return tmpneg;
}
# 398 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t fxp_sign(fxp_t a) {
return ((a == 0) ? 0 : ((a < 0) ? _fxp_minus_one : _fxp_one) );
}
fxp_t fxp_shrl(fxp_t in, int shift) {
return (fxp_t) (((unsigned int) in) >> shift);
}
fxp_t fxp_square(fxp_t a) {
return fxp_mult(a, a);
}
void fxp_print_int(fxp_t a) {
printf("\n%i", (int32_t)a);
}
void fxp_print_float(fxp_t a) {
printf("\n%f", fxp_to_float(a));
}
void fxp_print_float_array(fxp_t a[], int N) {
int i;
for(i = 0; i < N; ++i) {
printf("\n%f", fxp_to_float(a[i]));
}
}
void print_fxp_array_elements(char * name, fxp_t * v, int n){
printf("%s = {", name);
int i;
for(i=0; i < n; i++){
printf(" %jd ", v[i]);
}
printf("}\n");
}
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 1
# 24 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
void initialize_array(double v[], int n){
int i;
for(i=0; i<n; i++){
v[i] = 0;
}
}
void revert_array(double v[], double out[], int n){
initialize_array(out,n);
int i;
for(i=0; i<n; i++){
out[i] = v[n-i-1];
}
}
double internal_pow(double a, double b){
int i;
double acc = 1;
for (i=0; i < b; i++){
acc = acc*a;
}
return acc;
}
double internal_abs(double a){
return a < 0 ? -a : a;
}
int fatorial(int n){
return n == 0 ? 1 : n * fatorial(n-1);
}
int check_stability(double a[], int n){
int lines = 2 * n - 1;
int columns = n;
double m[lines][n];
int i,j;
double current_stability[n];
for (i=0; i < n; i++){
current_stability[i] = a[i];
}
double sum = 0;
for (i=0; i < n; i++){
sum += a[i];
}
if (sum <= 0){
printf("[DEBUG] the first constraint of Jury criteria failed: (F(1) > 0)");
return 0;
}
sum = 0;
for (i=0; i < n; i++){
sum += a[i] * internal_pow(-1, n-1-i);
}
sum = sum * internal_pow(-1, n-1);
if (sum <= 0){
printf("[DEBUG] the second constraint of Jury criteria failed: (F(-1)*(-1)^n > 0)");
return 0;
}
if (internal_abs(a[n-1]) > a[0]){
printf("[DEBUG] the third constraint of Jury criteria failed: (abs(a0) < a_{n}*z^{n})");
return 0;
}
for (i=0; i < lines; i++){
for (j=0; j < columns; j++){
m[i][j] = 0;
}
}
for (i=0; i < lines; i++){
for (j=0; j < columns; j++){
if (i == 0){
m[i][j] = a[j];
continue;
}
if (i % 2 != 0 ){
int x;
for(x=0; x<columns;x++){
m[i][x] = m[i-1][columns-x-1];
}
columns = columns - 1;
j = columns;
}else{
m[i][j] = m[i-2][j] - (m[i-2][columns] / m[i-2][0]) * m[i-1][j];
}
}
}
int first_is_positive = m[0][0] >= 0 ? 1 : 0;
for (i=0; i < lines; i++){
if (i % 2 == 0){
int line_is_positive = m[i][0] >= 0 ? 1 : 0;
if (first_is_positive != line_is_positive){
return 0;
}
continue;
}
}
return 1;
}
void poly_sum(double a[], int Na, double b[], int Nb, double ans[], int Nans){
int i;
Nans = Na>Nb? Na:Nb;
for (i=0; i<Nans; i++){
if (Na>Nb){
ans[i]=a[i];
if (i > Na-Nb-1){
ans[i]=ans[i]+b[i-Na+Nb];
}
}else {
ans[i]=b[i];
if (i> Nb - Na -1){
ans[i]=ans[i]+a[i-Nb+Na];
}
}
}
}
void poly_mult(double a[], int Na, double b[], int Nb, double ans[], int Nans){
int i;
int j;
int k;
Nans = Na+Nb-1;
for (i=0; i<Na; i++){
for (j=0; j<Nb; j++){
k= Na + Nb - i - j - 2;
ans[k]=0;
}
}
for (i=0; i<Na; i++){
for (j=0; j<Nb; j++){
k= Na + Nb - i - j - 2;
ans[k]=ans[k]+a[Na - i - 1]*b[Nb - j - 1];
}
}
}
void double_check_oscillations(double * y, int y_size){
__DSVERIFIER_assume(y[0] != y[y_size - 1]);
int window_timer = 0;
int window_count = 0;
int i, j;
for (i = 2; i < y_size; i++){
int window_size = i;
for(j=0; j<y_size; j++){
if (window_timer > window_size){
window_timer = 0;
window_count = 0;
}
int window_index = j + window_size;
if (window_index < y_size){
if (y[j] == y[window_index]){
window_count++;
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
((void) sizeof ((
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
!(window_count == window_size)
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
!(window_count == window_size)
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
) ; else __assert_fail (
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
"!(window_count == window_size)"
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h", 209, __extension__ __PRETTY_FUNCTION__); }))
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
;
}
}else{
break;
}
window_timer++;
}
}
}
void double_check_limit_cycle(double * y, int y_size){
double reference = y[y_size - 1];
int idx = 0;
int window_size = 1;
for(idx = (y_size-2); idx >= 0; idx--){
if (y[idx] != reference){
window_size++;
}else{
break;
}
}
__DSVERIFIER_assume(window_size != y_size && window_size != 1);
printf("window_size %d\n", window_size);
int desired_elements = 2 * window_size;
int found_elements = 0;
for(idx = (y_size-1); idx >= 0; idx--){
if (idx > (y_size-window_size-1)){
printf("%.0f == %.0f\n", y[idx], y[idx-window_size]);
int cmp_idx = idx - window_size;
if ((cmp_idx > 0) && (y[idx] == y[idx-window_size])){
found_elements = found_elements + 2;
}else{
break;
}
}
}
printf("desired_elements %d\n", desired_elements);
printf("found_elements %d\n", found_elements);
__DSVERIFIER_assert(desired_elements != found_elements);
}
void double_check_persistent_limit_cycle(double * y, int y_size){
int idy = 0;
int count_same = 0;
int window_size = 0;
double reference = y[0];
for(idy = 0; idy < y_size; idy++){
if (y[idy] != reference){
window_size++;
} else if (window_size != 0){
break;
} else {
count_same++;
}
}
window_size += count_same;
__DSVERIFIER_assume(window_size > 1 && window_size <= y_size/2);
double lco_elements[window_size];
for(idy = 0; idy < y_size; idy++){
if (idy < window_size){
lco_elements[idy] = y[idy];
}
}
idy = 0;
int lco_idy = 0;
_Bool is_persistent = 0;
while (idy < y_size){
if(y[idy++] == lco_elements[lco_idy++]){
is_persistent = 1;
}else{
is_persistent = 0;
break;
}
if (lco_idy == window_size){
lco_idy = 0;
}
}
__DSVERIFIER_assert(is_persistent == 0);
}
void print_array_elements(char * name, double * v, int n){
printf("%s = {", name);
int i;
for(i=0; i < n; i++){
printf(" %.32f ", v[i]);
}
printf("}\n");
}
void double_add_matrix( unsigned int lines, unsigned int columns, double m1[4][4], double m2[4][4], double result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
result[i][j] = m1[i][j] + m2[i][j];
}
}
}
void double_sub_matrix( unsigned int lines, unsigned int columns, double m1[4][4], double m2[4][4], double result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
result[i][j] = m1[i][j] - m2[i][j];
}
}
}
void double_matrix_multiplication( unsigned int i1, unsigned int j1, unsigned int i2, unsigned int j2, double m1[4][4], double m2[4][4], double m3[4][4]){
unsigned int i, j, k;
if (j1 == i2) {
for (i=0; i<i1; i++) {
for (j=0; j<j2; j++) {
m3[i][j] = 0;
}
}
for (i=0;i<i1; i++) {
for (j=0; j<j2; j++) {
for (k=0; k<j1; k++) {
double mult = (m1[i][k] * m2[k][j]);
m3[i][j] = m3[i][j] + (m1[i][k] * m2[k][j]);
}
}
}
} else {
printf("\nError! Operation invalid, please enter with valid matrices.\n");
}
}
void fxp_matrix_multiplication( unsigned int i1, unsigned int j1, unsigned int i2, unsigned int j2, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t m3[4][4]){
unsigned int i, j, k;
if (j1 == i2) {
for (i=0; i<i1; i++) {
for (j=0; j<j2; j++) {
m3[i][j] = 0;
}
}
for (i=0;i<i1; i++) {
for (j=0; j<j2; j++) {
for (k=0; k<j1; k++) {
m3[i][j] = fxp_add( m3[i][j], fxp_mult(m1[i][k] , m2[k][j]));
}
}
}
} else {
printf("\nError! Operation invalid, please enter with valid matrices.\n");
}
}
void fxp_exp_matrix(unsigned int lines, unsigned int columns, fxp_t m1[4][4], unsigned int expNumber, fxp_t result[4][4]){
unsigned int i, j, l, k;
fxp_t m2[4][4];
if(expNumber == 0){
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
if(i == j){
result[i][j] = fxp_double_to_fxp(1.0);
} else {
result[i][j] = 0.0;
}
}
}
return;
}
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = m1[i][j];
if(expNumber == 1){
return;
}
for(l = 1; l < expNumber; l++){
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) m2[i][j] = result[i][j];
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = 0;
for (i=0;i<lines; i++) {
for (j=0; j<columns; j++) {
for (k=0; k<columns; k++) {
result[i][j] = fxp_add( result[i][j], fxp_mult(m2[i][k] , m1[k][j]));
}
}
}
}
}
void double_exp_matrix(unsigned int lines, unsigned int columns, double m1[4][4], unsigned int expNumber, double result[4][4]){
unsigned int i, j, k, l;
double m2[4][4];
if(expNumber == 0){
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
if(i == j){
result[i][j] = 1.0;
} else {
result[i][j] = 0.0;
}
}
}
return;
}
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = m1[i][j];
if(expNumber == 1){
return;
}
for(l = 1; l < expNumber; l++){
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) m2[i][j] = result[i][j];
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = 0;
for (i=0;i<lines; i++) {
for (j=0; j<columns; j++) {
for (k=0; k<columns; k++) {
result[i][j] = result[i][j] + (m2[i][k] * m1[k][j]);
}
}
}
}
}
void fxp_add_matrix( unsigned int lines, unsigned int columns, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) {
result[i][j] = fxp_add(m1[i][j] , m2[i][j]);
}
}
void fxp_sub_matrix( unsigned int lines, unsigned int columns, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = fxp_sub(m1[i][j] , m2[i][j]);
}
void print_matrix(double matrix[4][4], unsigned int lines, unsigned int columns){
printf("\nMatrix\n=====================\n\n");
unsigned int i, j;
for (i=0; i<lines; i++) {
for (j=0; j<columns; j++) {
printf("#matrix[%d][%d]: %2.2f ", i,j,matrix[i][j]);
}
printf("\n");
}
printf("\n");
}
double determinant(double a[4][4],int n)
{
int i,j,j1,j2;
double det = 0;
double m[4][4];
if (n < 1) {
} else if (n == 1) {
det = a[0][0];
} else if (n == 2) {
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
} else {
det = 0;
for (j1=0;j1<n;j1++) {
for (i=0;i<n-1;i++)
for (i=1;i<n;i++) {
j2 = 0;
for (j=0;j<n;j++) {
if (j == j1)
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += internal_pow(-1.0,1.0+j1+1.0) * a[0][j1] * determinant(m,n-1);
}
}
return(det);
}
double fxp_determinant(fxp_t a_fxp[4][4],int n)
{
int i,j,j1,j2;
double a[4][4];
for(i=0; i<n;i++){
for(j=0; j<n;j++){
a[i][j]= fxp_to_double(a_fxp[i][j]);
}
}
double det = 0;
double m[4][4];
if (n < 1) {
} else if (n == 1) {
det = a[0][0];
} else if (n == 2) {
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
} else {
det = 0;
for (j1=0;j1<n;j1++) {
for (i=0;i<n-1;i++)
for (i=1;i<n;i++) {
j2 = 0;
for (j=0;j<n;j++) {
if (j == j1)
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += internal_pow(-1.0,1.0+j1+1.0) * a[0][j1] * determinant(m,n-1);
}
}
return(det);
}
void transpose(double a[4][4], double b[4][4],int n, int m)
{
int i,j;
for (i=0;i<n;i++) {
for (j=0;j<m;j++) {
b[j][i] = a[i][j];
}
}
}
void fxp_transpose(fxp_t a[4][4], fxp_t b[4][4],int n, int m)
{
int i,j;
for (i=0;i<n;i++) {
for (j=0;j<m;j++) {
b[j][i] = a[i][j];
}
}
}
# 24 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
extern int generic_timer;
extern hardware hw;
double generic_timing_shift_l_double(double zIn, double z[], int N) {
generic_timer += ((2 * hw.assembly.push) + (3 * hw.assembly.in) + (3 * hw.assembly.out) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (8 * hw.assembly.std));
int i;
double zOut;
zOut = z[0];
generic_timer += ((5 * hw.assembly.ldd) + (2 * hw.assembly.mov) + (4 * hw.assembly.std) + (1 * hw.assembly.ld));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (i = 0; i < N - 1; i++) {
generic_timer += ((17 * hw.assembly.ldd) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (6 * hw.assembly.mov) + (2 * hw.assembly.adiw) + (5 * hw.assembly.std) + (1 * hw.assembly.ld) + (1 * hw.assembly.st) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbc)+ (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
z[i] = z[i + 1];
}
z[N - 1] = zIn;
generic_timer += ((12 * hw.assembly.ldd) + (6 * hw.assembly.mov) + (3 * hw.assembly.std) + (2 * hw.assembly.lsl) + (2 * hw.assembly.rol) + (1 * hw.assembly.adc) + (1 * hw.assembly.add) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in)+ (1 * hw.assembly.cli));
generic_timer += ((3 * hw.assembly.out) + (2 * hw.assembly.pop) + (1 * hw.assembly.ret));
return (zOut);
}
double generic_timing_shift_r_double(double zIn, double z[], int N) {
generic_timer += ((2 * hw.assembly.push) + (3 * hw.assembly.in) + (3 * hw.assembly.out) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (8 * hw.assembly.std));
int i;
double zOut;
zOut = z[N - 1];
generic_timer += ((7 * hw.assembly.ldd) + (2 * hw.assembly.rol) + (2 * hw.assembly.lsl) + (2 * hw.assembly.mov) + (4 * hw.assembly.std) + (1 * hw.assembly.add) + (1 * hw.assembly.adc) + (1 * hw.assembly.ld) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci));
generic_timer += ((2 * hw.assembly.ldd) + (2 * hw.assembly.std) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.rjmp));
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
generic_timer += ((15 * hw.assembly.ldd) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (4 * hw.assembly.mov) + (5 * hw.assembly.std) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.ld) + (1 * hw.assembly.st) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
}
z[0] = zIn;
generic_timer += ((10 * hw.assembly.ldd) + (5 * hw.assembly.mov) + (3 * hw.assembly.std) + (3 * hw.assembly.out) + (2 * hw.assembly.pop) + (1 * hw.assembly.ret) + (1 * hw.assembly.ret) + (1 * hw.assembly.cli) + (1 * hw.assembly.in) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw));
return zOut;
}
fxp_t shiftL(fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
fxp_t shiftR(fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
float shiftLfloat(float zIn, float z[], int N) {
int i;
float zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
float shiftRfloat(float zIn, float z[], int N) {
int i;
float zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
double shiftRDdouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
double shiftRdouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
double shiftLDouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
void shiftLboth(float zfIn, float zf[], fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
float zfOut;
zOut = z[0];
zfOut = zf[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
zf[i] = zf[i + 1];
}
z[N - 1] = zIn;
zf[N - 1] = zfIn;
}
void shiftRboth(float zfIn, float zf[], fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
float zfOut;
zOut = z[N - 1];
zfOut = zf[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
zf[i] = zf[i - 1];
}
z[0] = zIn;
zf[0] = zfIn;
}
int order(int Na, int Nb) {
return Na > Nb ? Na - 1 : Nb - 1;
}
void fxp_check_limit_cycle(fxp_t y[], int y_size){
fxp_t reference = y[y_size - 1];
int idx = 0;
int window_size = 1;
for(idx = (y_size-2); idx >= 0; idx--){
if (y[idx] != reference){
window_size++;
}else{
break;
}
}
__DSVERIFIER_assume(window_size != y_size && window_size != 1);
printf("window_size %d\n", window_size);
int desired_elements = 2 * window_size;
int found_elements = 0;
for(idx = (y_size-1); idx >= 0; idx--){
if (idx > (y_size-window_size-1)){
printf("%.0f == %.0f\n", y[idx], y[idx-window_size]);
int cmp_idx = idx - window_size;
if ((cmp_idx > 0) && (y[idx] == y[idx-window_size])){
found_elements = found_elements + 2;
}else{
break;
}
}
}
__DSVERIFIER_assume(found_elements > 0);
printf("desired_elements %d\n", desired_elements);
printf("found_elements %d\n", found_elements);
__DSVERIFIER_assume(found_elements == desired_elements);
__DSVERIFIER_assert(0);
}
void fxp_check_persistent_limit_cycle(fxp_t * y, int y_size){
int idy = 0;
int count_same = 0;
int window_size = 0;
fxp_t reference = y[0];
for(idy = 0; idy < y_size; idy++){
if (y[idy] != reference){
window_size++;
} else if (window_size != 0){
break;
} else {
count_same++;
}
}
window_size += count_same;
__DSVERIFIER_assume(window_size > 1 && window_size <= y_size/2);
fxp_t lco_elements[window_size];
for(idy = 0; idy < y_size; idy++){
if (idy < window_size){
lco_elements[idy] = y[idy];
}
}
idy = 0;
int lco_idy = 0;
_Bool is_persistent = 0;
while (idy < y_size){
if(y[idy++] == lco_elements[lco_idy++]){
is_persistent = 1;
}else{
is_persistent = 0;
break;
}
if (lco_idy == window_size){
lco_idy = 0;
}
}
__DSVERIFIER_assert(is_persistent == 0);
}
void fxp_check_oscillations(fxp_t y[] , int y_size){
__DSVERIFIER_assume((y[0] != y[y_size - 1]) && (y[y_size - 1] != y[y_size - 2]));
int window_timer = 0;
int window_count = 0;
int i, j;
for (i = 2; i < y_size; i++){
int window_size = i;
for(j=0; j<y_size; j++){
if (window_timer > window_size){
window_timer = 0;
window_count = 0;
}
int window_index = j + window_size;
if (window_index < y_size){
if (y[j] == y[window_index]){
window_count++;
__DSVERIFIER_assert(!(window_count == window_size));
}
}else{
break;
}
window_timer++;
}
}
}
int fxp_ln(int x) {
int t, y;
y = 0xa65af;
if (x < 0x00008000)
x <<= 16, y -= 0xb1721;
if (x < 0x00800000)
x <<= 8, y -= 0x58b91;
if (x < 0x08000000)
x <<= 4, y -= 0x2c5c8;
if (x < 0x20000000)
x <<= 2, y -= 0x162e4;
if (x < 0x40000000)
x <<= 1, y -= 0x0b172;
t = x + (x >> 1);
if ((t & 0x80000000) == 0)
x = t, y -= 0x067cd;
t = x + (x >> 2);
if ((t & 0x80000000) == 0)
x = t, y -= 0x03920;
t = x + (x >> 3);
if ((t & 0x80000000) == 0)
x = t, y -= 0x01e27;
t = x + (x >> 4);
if ((t & 0x80000000) == 0)
x = t, y -= 0x00f85;
t = x + (x >> 5);
if ((t & 0x80000000) == 0)
x = t, y -= 0x007e1;
t = x + (x >> 6);
if ((t & 0x80000000) == 0)
x = t, y -= 0x003f8;
t = x + (x >> 7);
if ((t & 0x80000000) == 0)
x = t, y -= 0x001fe;
x = 0x80000000 - x;
y -= x >> 15;
return y;
}
double fxp_log10_low(double x) {
int xint = (int) (x * 65536.0 + 0.5);
int lnum = fxp_ln(xint);
int lden = fxp_ln(655360);
return ((double) lnum / (double) lden);
}
double fxp_log10(double x) {
if (x > 32767.0) {
if (x > 1073676289.0) {
x = x / 1073676289.0;
return fxp_log10_low(x) + 9.030873362;
}
x = x / 32767.0;
return fxp_log10_low(x) + 4.515436681;
}
return fxp_log10_low(x);
}
float snrVariance(float s[], float n[], int blksz) {
int i;
double sm = 0, nm = 0, sv = 0, nv = 0, snr;
for (i = 0; i < blksz; i++) {
sm += s[i];
nm += n[i];
}
sm /= blksz;
nm /= blksz;
for (i = 0; i < blksz; i++) {
sv += (s[i] - sm) * (s[i] - sm);
nv += (n[i] - nm) * (n[i] - nm);
}
if (nv != 0.0f) {
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"sv >= nv"
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 373, __extension__ __PRETTY_FUNCTION__); }))
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
snr = sv / nv;
return snr;
} else {
return 9999.9f;
}
}
float snrPower(float s[], float n[], int blksz) {
int i;
double sv = 0, nv = 0, snr;
for (i = 0; i < blksz; i++) {
sv += s[i] * s[i];
nv += n[i] * n[i];
}
if (nv != 0.0f) {
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"sv >= nv"
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 394, __extension__ __PRETTY_FUNCTION__); }))
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
snr = sv / nv;
return snr;
} else {
return 9999.9f;
}
}
float snrPoint(float s[], float n[], int blksz) {
int i;
double ratio = 0, power = 0;
for (i = 0; i < blksz; i++) {
if(n[i] == 0) continue;
ratio = s[i] / n[i];
if(ratio > 150.0f || ratio < -150.0f) continue;
power = ratio * ratio;
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
power >= 1.0f
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
power >= 1.0f
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"power >= 1.0f"
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 412, __extension__ __PRETTY_FUNCTION__); }))
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
}
return 9999.9f;
}
unsigned long next = 1;
int rand(void)
{
next = next*1103515245 + 12345;
return (unsigned int)(next/65536) % 32768;
}
void srand(unsigned int seed)
{
next = seed;
}
float iirIIOutTime(float w[], float x, float a[], float b[], int Na, int Nb) {
int timer1 = 0;
float *a_ptr, *b_ptr, *w_ptr;
float sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
timer1 += 71;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
timer1 += 54;
}
w[0] += x;
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
timer1 += 46;
}
timer1 += 38;
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 450, __extension__ __PRETTY_FUNCTION__); }))
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return sum;
}
float iirIItOutTime(float w[], float x, float a[], float b[], int Na, int Nb) {
int timer1 = 0;
float *a_ptr, *b_ptr;
float yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 477, __extension__ __PRETTY_FUNCTION__); }))
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return yout;
}
double iirIItOutTime_double(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 504, __extension__ __PRETTY_FUNCTION__); }))
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return yout;
}
void iirOutBoth(float yf[], float xf[], float af[], float bf[], float *sumf_ref,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t *sum_ref, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
fxp_t sum = 0;
float sumf = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
af_ptr = &af[1];
yf_ptr = &yf[Na - 1];
bf_ptr = &bf[0];
xf_ptr = &xf[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *x_ptr--));
sumf += *bf_ptr++ * *xf_ptr--;
}
for (j = 1; j < Na; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr++, *y_ptr--));
sumf -= *af_ptr++ * *yf_ptr--;
}
*sum_ref = sum;
*sumf_ref = sumf;
}
fxp_t iirOutFixedL(fxp_t y[], fxp_t x[], fxp_t xin, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[j] = y[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[Na - 1] = sum;
return sum;
}
float iirOutFloatL(float y[], float x[], float xin, float a[], float b[], int Na, int Nb) {
float *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum += *b_ptr-- * *x_ptr++;
}
x[Nb - 1] = xin;
sum += *b_ptr-- * *x_ptr++;
for (j = 1; j < Na - 1; j++) {
sum -= *a_ptr-- * *y_ptr++;
y[j] = y[j+1];
}
if(Na>1) sum -= *a_ptr-- * *y_ptr++;
y[Na - 1] = sum;
return sum;
}
float iirOutBothL(float yf[], float xf[], float af[], float bf[], float xfin,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t xin, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
float sumf = 0;
af_ptr = &af[Na - 1];
yf_ptr = &yf[1];
bf_ptr = &bf[Nb - 1];
xf_ptr = &xf[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
xf[i] = xf[i+1];
sumf += *bf_ptr-- * *xf_ptr++;
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
xf[Nb - 1] = xfin;
sumf += *bf_ptr-- * *xf_ptr++;
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[j] = y[j+1];
sumf -= *af_ptr-- * *yf_ptr++;
yf[j] = yf[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[Na - 1] = sum;
if(Na>1) sumf -= *af_ptr-- * *yf_ptr++;
yf[Na - 1] = sumf;
return fxp_to_float(sum) - sumf;
}
float iirOutBothL2(float yf[], float xf[], float af[], float bf[], float xfin,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t xin, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
float sumf = 0;
af_ptr = &af[Na - 1];
yf_ptr = &yf[1];
bf_ptr = &bf[Nb - 1];
xf_ptr = &xf[0];
int i=0, j=1;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(b[Nb - 1 - i], x[i]));
xf[i] = xf[i+1];
sumf += bf[Nb - 1 - i] * xf[i];
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(b[Nb - 1 - i], x[i]));
xf[Nb - 1] = xfin;
sumf += bf[Nb - 1 - i] * xf[i];
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(a[Na - j], y[j]));
y[j] = y[j+1];
sumf -= af[Na - j] * yf[j];
yf[j] = yf[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(a[Na - j], y[j]));
y[Na - 1] = sum;
if(Na>1) sumf -= af[Na - j] * yf[j];
yf[Na - 1] = sumf;
return fxp_to_float(sum) - sumf;
}
# 25 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
extern digital_system ds;
extern hardware hw;
extern int generic_timer;
fxp_t fxp_direct_form_1(fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *x_ptr--));
}
for (j = 1; j < Na; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr++, *y_ptr--));
}
fxp_verify_overflow_node(sum, "An Overflow Occurred in the node a0");
sum = fxp_div(sum,a[0]);
return fxp_quantize(sum);
}
fxp_t fxp_direct_form_2(fxp_t w[], fxp_t x, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *b_ptr, *w_ptr;
fxp_t sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] = fxp_sub(w[0], fxp_mult(*a_ptr++, *w_ptr++));
}
w[0] = fxp_add(w[0], x);
w[0] = fxp_div(w[0], a[0]);
fxp_verify_overflow_node(w[0], "An Overflow Occurred in the node b0");
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *w_ptr++));
}
return fxp_quantize(sum);
}
fxp_t fxp_transposed_direct_form_2(fxp_t w[], fxp_t x, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *b_ptr;
fxp_t yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = fxp_add(fxp_mult(*b_ptr++, x), w[0]);
yout = fxp_div(yout, a[0]);
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] = fxp_sub(w[j], fxp_mult(*a_ptr++, yout));
}
if (j < Nb - 1) {
w[j] = fxp_add(w[j], fxp_mult(*b_ptr++, x));
}
}
fxp_verify_overflow_node(w[j], "An Overflow Occurred in the node a0");
return fxp_quantize(yout);
}
double double_direct_form_1(double y[], double x[], double a[], double b[], int Na, int Nb) {
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum += *b_ptr++ * *x_ptr--;
}
for (j = 1; j < Na; j++) {
sum -= *a_ptr++ * *y_ptr--;
}
sum = (sum / a[0]);
return sum;
}
double double_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
}
return sum;
}
double double_transposed_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
yout = yout / a[0];
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
}
return yout;
}
float float_direct_form_1(float y[], float x[], float a[], float b[], int Na, int Nb) {
float *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum += *b_ptr++ * *x_ptr--;
}
for (j = 1; j < Na; j++) {
sum -= *a_ptr++ * *y_ptr--;
}
sum = (sum / a[0]);
return sum;
}
float float_direct_form_2(float w[], float x, float a[], float b[], int Na, int Nb) {
float *a_ptr, *b_ptr, *w_ptr;
float sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
}
return sum;
}
float float_transposed_direct_form_2(float w[], float x, float a[], float b[], int Na, int Nb) {
float *a_ptr, *b_ptr;
float yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
yout = yout / a[0];
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
}
return yout;
}
double double_direct_form_1_MSP430(double y[], double x[], double a[], double b[], int Na, int Nb){
int timer1 = 0;
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na-1];
b_ptr = &b[0];
x_ptr = &x[Nb-1];
int i, j;
timer1 += 91;
for (i = 0; i < Nb; i++){
sum += *b_ptr++ * *x_ptr--;
timer1 += 47;
}
for (j = 1; j < Na; j++){
sum -= *a_ptr++ * *y_ptr--;
timer1 += 57;
}
timer1 += 3;
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 235, __extension__ __PRETTY_FUNCTION__); }))
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return sum;
}
double double_direct_form_2_MSP430(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
timer1 += 71;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
timer1 += 54;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
timer1 += 46;
}
timer1 += 38;
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 262, __extension__ __PRETTY_FUNCTION__); }))
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return sum;
}
double double_transposed_direct_form_2_MSP430(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 291, __extension__ __PRETTY_FUNCTION__); }))
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return yout;
}
double generic_timing_double_direct_form_1(double y[], double x[], double a[], double b[], int Na, int Nb){
generic_timer += ((6 * hw.assembly.push) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (12 * hw.assembly.std));
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na-1];
b_ptr = &b[0];
x_ptr = &x[Nb-1];
generic_timer += ((12 * hw.assembly.std) + (12 * hw.assembly.ldd) + (2 * hw.assembly.subi) + (2 * hw.assembly.sbci) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (1 * hw.assembly.adiw));
int i, j;
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (i = 0; i < Nb; i++){
generic_timer += ((20 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.sbc) + (10 * hw.assembly.std) + (2 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
sum += *b_ptr++ * *x_ptr--;
}
generic_timer += ((2 * hw.assembly.ldi) + (2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 1; j < Na; j++){
generic_timer += ((22 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.subi) + (8 * hw.assembly.std) + (1 * hw.assembly.sbci) + (2 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (1 * hw.assembly.sbc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
sum -= *a_ptr++ * *y_ptr--;
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (6 * hw.assembly.pop) + (1 * hw.assembly.ret));
return sum;
}
double generic_timing_double_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
generic_timer += ((8 * hw.assembly.push) + (14 * hw.assembly.std) + (3 * hw.assembly.out) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli));
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
generic_timer += ((10 * hw.assembly.std) + (6 * hw.assembly.ldd) + (2 * hw.assembly.adiw));
generic_timer += ((2 * hw.assembly.ldi) + (2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
generic_timer += ((23 * hw.assembly.ldd) + (32 * hw.assembly.mov) + (9 * hw.assembly.std) + (2 * hw.assembly.subi) + (3 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (2 * hw.assembly.sbci) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brge));
}
w[0] += x;
w_ptr = &w[0];
generic_timer += ((13 * hw.assembly.ldd) + (12 * hw.assembly.mov) + (5 * hw.assembly.std) + (1 * hw.assembly.st) + (1 * hw.assembly.ld) + (1 * hw.assembly.rcall));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
generic_timer += ((20 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (10 * hw.assembly.std) + (2 * hw.assembly.rcall) + (2 * hw.assembly.ld) + (2 * hw.assembly.subi) + (2 * hw.assembly.sbci) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (8 * hw.assembly.pop) + (1 * hw.assembly.ret));
return sum;
}
double generic_timing_double_transposed_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
generic_timer += ((8 * hw.assembly.push) + (14 * hw.assembly.std) + (3 * hw.assembly.out) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli));
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
generic_timer += ((15 * hw.assembly.std) + (22 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.rcall) + (2 * hw.assembly.ld) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.brge) + (1 * hw.assembly.adiw));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
generic_timer += ((70 * hw.assembly.mov) + (65 * hw.assembly.ldd) + (12 * hw.assembly.lsl) + (12 * hw.assembly.rol) + (15 * hw.assembly.std) + (6 * hw.assembly.add) + (6 * hw.assembly.adc) + (2 * hw.assembly.adiw) + (3 * hw.assembly.cpc) + (3 * hw.assembly.cp) + (5 * hw.assembly.ld) + (4 * hw.assembly.rcall) + (5 * hw.assembly.subi) + (3 * hw.assembly.rjmp) + (2 * hw.assembly.brlt) + (3 * hw.assembly.st) + (2 * hw.assembly.sbci) + (3 * hw.assembly.sbc) + (1 * hw.assembly.brge));
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (8 * hw.assembly.pop) + (3 * hw.assembly.out) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (1 * hw.assembly.adiw) + (1 * hw.assembly.ret));
return yout;
}
void double_direct_form_1_impl2(double x[], int x_size, double b[], int b_size, double a[], int a_size, double y[]){
int i = 0; int j = 0;
double v[x_size];
for(i = 0; i < x_size; i++){
v[i] = 0;
for(j = 0; j < b_size; j++){
if (j > i) break;
v[i] = v[i] + x[i-j] * b[j];
}
}
y[0] = v[0];
for(i = 1; i < x_size; i++){
y[i] = 0;
y[i] = y[i] + v[i];
for(j = 1; j < a_size; j++){
if (j > i) break;
y[i] = y[i] + y[i-j] * ((-1) * a[j]);
}
}
}
void fxp_direct_form_1_impl2(fxp_t x[], int x_size, fxp_t b[], int b_size, fxp_t a[], int a_size, fxp_t y[]){
int i = 0; int j = 0;
fxp_t v[x_size];
for(i = 0; i < x_size; i++){
v[i] = 0;
for(j = 0; j < b_size; j++){
if (j > i) break;
v[i] = fxp_add(v[i], fxp_mult(x[i-j], b[j]));
}
}
y[0] = v[0];
for(i = 1; i < x_size; i++){
y[i] = 0;
y[i] = fxp_add(y[i], v[i]);
for(j = 1; j < a_size; j++){
if (j > i) break;
y[i] = fxp_add(y[i], fxp_mult(y[i-j] , -a[j]));
}
}
}
# 26 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h"
# 1 "/usr/include/assert.h" 1 3 4
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 2
int nchoosek(int n, int k){
if (k == 0)
return 1;
return (n * nchoosek(n - 1, k - 1)) / k;
}
void generate_delta_coefficients(double vetor[], double out[], int n, double delta){
int i,j;
int N = n - 1;
double sum_delta_operator;
for(i=0; i<=N; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + vetor[j]*nchoosek(N-j,i-j);
}
out[i] = internal_pow(delta,N-i)*sum_delta_operator;
}
}
void get_delta_transfer_function(double b[], double b_out[], int b_size, double a[], double a_out[], int a_size, double delta){
generate_delta_coefficients(b, b_out, b_size, delta);
generate_delta_coefficients(a, a_out, a_size, delta);
}
void get_delta_transfer_function_with_base(double b[], double b_out[], int b_size, double a[], double a_out[], int a_size, double delta){
int i,j;
int N = a_size - 1;
int M = b_size - 1;
double sum_delta_operator;
for(i=0; i<=N; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + a[j]*nchoosek(N-j,i-j);
}
a_out[i] = internal_pow(delta,N-i)*sum_delta_operator;
}
for(i=0; i<=M; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + b[j]*nchoosek(M-j,i-j);
}
b_out[i] = internal_pow(delta,M-i)*sum_delta_operator;
}
}
# 27 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/closed-loop.h" 1
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/closed-loop.h"
void ft_closedloop_series(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
Nans_num = Nc_num + Nmodel_num - 1;
Nans_den = Nc_den + Nmodel_den - 1 ;
double den_mult [Nans_den];
poly_mult(c_num, Nc_num, model_num, Nmodel_num, ans_num, Nans_num);
poly_mult(c_den, Nc_den, model_den, Nmodel_den, den_mult, Nans_den );
poly_sum(ans_num, Nans_num , den_mult, Nans_den , ans_den, Nans_den);
}
void ft_closedloop_sensitivity(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
int Nans_num_p = Nc_num + Nmodel_num-1;
Nans_den = Nc_den + Nmodel_den-1;
Nans_num = Nc_den + Nmodel_den-1;
double num_mult [Nans_num_p];
poly_mult(c_den, Nc_den, model_den, Nmodel_den, ans_num, Nans_num);
poly_mult(c_num, Nc_num, model_num, Nmodel_num, num_mult, Nans_num_p);
poly_sum(ans_num, Nans_num, num_mult, Nans_num_p, ans_den, Nans_den);
}
void ft_closedloop_feedback(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
Nans_num = Nc_den + Nmodel_num - 1;
Nans_den = Nc_den + Nmodel_den - 1;
int Nnum_mult = Nc_num + Nmodel_num - 1;
double den_mult [Nans_den];
double num_mult [Nnum_mult];
poly_mult(c_num, Nc_num, model_num, Nmodel_num, num_mult, Nnum_mult);
poly_mult(c_den, Nc_den, model_den, Nmodel_den, den_mult, Nans_den);
poly_sum(num_mult, Nnum_mult, den_mult, Nans_den, ans_den, Nans_den);
poly_mult(c_den, Nc_den, model_num, Nmodel_num, ans_num, Nans_num);
}
int check_stability_closedloop(double a[], int n, double plant_num[], int p_num_size, double plant_den[], int p_den_size){
int columns = n;
double m[2 * n - 1][n];
int i,j;
int first_is_positive = 0;
double * p_num = plant_num;
double * p_den = plant_den;
double sum = 0;
for (i=0; i < n; i++){
sum += a[i];
}
__DSVERIFIER_assert(sum > 0);
sum = 0;
for (i=0; i < n; i++){
sum += a[i] * internal_pow(-1, n-1-i);
}
sum = sum * internal_pow(-1, n-1);
__DSVERIFIER_assert(sum > 0);
__DSVERIFIER_assert(internal_abs(a[n-1]) < a[0]);
for (i=0; i < 2 * n - 1; i++){
for (j=0; j < columns; j++){
m[i][j] = 0;
if (i == 0){
m[i][j] = a[j];
continue;
}
if (i % 2 != 0 ){
int x;
for(x=0; x<columns;x++){
m[i][x] = m[i-1][columns-x-1];
}
columns = columns - 1;
j = columns;
}else{
__DSVERIFIER_assert(m[i-2][0] > 0);
m[i][j] = m[i-2][j] - (m[i-2][columns] / m[i-2][0]) * m[i-1][j];
__DSVERIFIER_assert((m[0][0] >= 0) && (m[i][0] >= 0));
}
}
}
return 1;
}
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
extern digital_system ds;
extern digital_system plant;
extern digital_system control;
extern implementation impl;
extern filter_parameters filter;
extern hardware hw;
void initialization(){
if (impl.frac_bits >= 32){
printf("impl.frac_bits must be less than word width!\n");
}
if (impl.int_bits >= 32 - impl.frac_bits){
printf("impl.int_bits must be less than word width subtracted by precision!\n");
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
((void) sizeof ((
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
0
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
0
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
) ; else __assert_fail (
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
"0"
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h", 33, __extension__ __PRETTY_FUNCTION__); }))
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
;
}
if(impl.frac_bits >= 31){
_fxp_one = 0x7fffffff;
}else{
_fxp_one = (0x00000001 << impl.frac_bits);
}
_fxp_half = (0x00000001 << (impl.frac_bits - 1));
_fxp_minus_one = -(0x00000001 << impl.frac_bits);
_fxp_min = -(0x00000001 << (impl.frac_bits + impl.int_bits - 1));
_fxp_max = (0x00000001 << (impl.frac_bits + impl.int_bits - 1)) - 1;
_fxp_fmask = ((((int32_t) 1) << impl.frac_bits) - 1);
_fxp_imask = ((0x80000000) >> (32 - impl.frac_bits - 1));
_dbl_min = _fxp_min;
_dbl_min /= (1 << impl.frac_bits);
_dbl_max = _fxp_max;
_dbl_max /= (1 << impl.frac_bits);
if ((impl.scale == 0) || (impl.scale == 1)){
impl.scale = 1;
return;
}
if (impl.min != 0){
impl.min = impl.min / impl.scale;
}
if (impl.max != 0){
impl.max = impl.max / impl.scale;
}
# 80 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
}
# 29 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/state-space.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/state-space.h"
extern digital_system_state_space _controller;
extern int nStates;
extern int nInputs;
extern int nOutputs;
double double_state_space_representation(void){
double result1[4][4];
double result2[4][4];
int i, j;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
return _controller.outputs[0][0];
}
double fxp_state_space_representation(void){
fxp_t result1[4][4];
fxp_t result2[4][4];
int i, j;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
fxp_t A_fpx[4][4];
fxp_t B_fpx[4][4];
fxp_t C_fpx[4][4];
fxp_t D_fpx[4][4];
fxp_t states_fpx[4][4];
fxp_t inputs_fpx[4][4];
fxp_t outputs_fpx[4][4];
for(i=0; i<4;i++){
for(j=0; j<4;j++){
A_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
B_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
C_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
D_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
states_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
inputs_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
outputs_fpx[i][j]=0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
B_fpx[i][j]= fxp_double_to_fxp(_controller.B[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
C_fpx[i][j]= fxp_double_to_fxp(_controller.C[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
D_fpx[i][j]= fxp_double_to_fxp(_controller.D[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
states_fpx[i][j]= fxp_double_to_fxp(_controller.states[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
inputs_fpx[i][j]= fxp_double_to_fxp(_controller.inputs[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
outputs_fpx[i][j]= fxp_double_to_fxp(_controller.outputs[i][j]);
}
}
fxp_matrix_multiplication(nOutputs,nStates,nStates,1,C_fpx,states_fpx,result1);
fxp_matrix_multiplication(nOutputs,nInputs,nInputs,1,D_fpx,inputs_fpx,result2);
fxp_add_matrix(nOutputs,
1,
result1,
result2,
outputs_fpx);
fxp_matrix_multiplication(nStates,nStates,nStates,1,A_fpx,states_fpx,result1);
fxp_matrix_multiplication(nStates,nInputs,nInputs,1,B_fpx,inputs_fpx,result2);
fxp_add_matrix(nStates,
1,
result1,
result2,
states_fpx);
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= fxp_to_double(states_fpx[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
_controller.outputs[i][j]= fxp_to_double(outputs_fpx[i][j]);
}
}
return _controller.outputs[0][0];
}
# 30 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/filter_functions.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/filter_functions.h"
double sinTyl(double x, int precision){
double sine;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
sine = aux;
if (precision >= 1)
{
aux = x;
sine += aux;
if (precision >= 2)
{
aux = aux*xsquared;
sine -= aux/6;
if (precision >= 3)
{
aux = aux*xsquared;
sine +=aux/120;
if(precision >=4)
{
aux = aux*xsquared;
sine -=aux/5040;
if(precision >= 5)
{
aux = aux*xsquared;
sine +=aux/362880;
if(precision >= 6)
{
aux = aux*xsquared;
sine -=aux/39916800;
if (precision >= 7)
printf("Warning: Function sinTyl "
"from bmc/core/filter_functions.h: Precision "
"representation exceeded. Assuming maximum precision of 6\n");
}
}
}
}
}
}
}
return sine;
}
double cosTyl(double x, int precision){
double cosine;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function cosTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
cosine = aux;
if (precision >= 1)
{
aux = 1;
cosine = 1;
if (precision >= 2)
{
aux = xsquared;
cosine -= aux/2;
if (precision >= 3)
{
aux = aux*xsquared;
cosine += aux/24;
if(precision >=4)
{
aux = aux*xsquared;
cosine -=aux/720;
if(precision >= 5)
{
aux = aux*xsquared;
cosine +=aux/40320;
if(precision >= 6)
{
aux = aux*xsquared;
cosine -=aux/3628800;
if (precision >= 7) printf("Warning: Function sinTyl "
"from bmc/core/filter_functions.h: Precision "
"representation exceeded. Assuming maximum precision of 6\n");
}
}
}
}
}
}
}
return cosine;
}
double atanTyl(double x, int precision){
double atangent;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
atangent = aux;
if (precision >= 1)
{
aux = x;
atangent = aux;
if (precision >= 2)
{
aux = xsquared;
atangent -= aux/3;
if (precision >= 3)
{
aux = aux*xsquared;
atangent += aux/5;
if(precision >=4)
{
aux = aux*xsquared;
atangent -=aux/7;
if (precision >= 7)
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision representation exceeded. Assuming maximum precision of 4\n");
}
}
}
}
}
return atangent;
}
float sqrt1(const float x)
{
const float xhalf = 0.5f*x;
union
{
float x;
int i;
} u;
u.x = x;
u.i = 0x5f3759df - (u.i >> 1);
return x*u.x*(1.5f - xhalf*u.x*u.x);
}
float sqrt2(const float x)
{
union
{
int i;
float x;
} u;
u.x = x;
u.i = (1<<29) + (u.i >> 1) - (1<<22);
return u.x;
}
float fabsolut(float x)
{
if (x < 0)
x = -x;
return x;
}
static float sqrt3(float val)
{
float x = val/10;
float dx;
double diff;
double min_tol = 0.00001;
int i, flag;
flag = 0;
if (val == 0 ) x = 0;
else
{
for (i=1;i<20;i++)
{
if (!flag)
{
dx = (val - (x*x)) / (2.0 * x);
x = x + dx;
diff = val - (x*x);
if (fabsolut(diff) <= min_tol) flag = 1;
}
else x =x;
}
}
return (x);
}
# 31 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
int verify_overflow(void) {
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 73 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_int();
__DSVERIFIER_assume(x[i] >= min_fxp && x[i] <= max_fxp);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for (i = 0; i < X_SIZE_VALUE; ++i) {
# 123 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
shiftR(0, waux, Nw);
y[i] = fxp_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 174 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
}
overflow_mode = 1;
fxp_verify_overflow_array(y, X_SIZE_VALUE);
return 0;
}
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 1
# 15 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
extern digital_system_state_space _controller;
extern int nStates;
extern int nInputs;
extern int nOutputs;
int verify_limit_cycle_state_space(void){
double stateMatrix[4][4];
double outputMatrix[4][4];
double arrayLimitCycle[4];
double result1[4][4];
double result2[4][4];
int i, j, k;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
stateMatrix[i][j]=0;
outputMatrix[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
k = 0;
for (i = 1; i < 0; i++) {
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
int l;
for(l = 0; l < nStates; l++){
stateMatrix[l][k] = _controller.states[l][0];
}
for(l = 0; l < nOutputs; l++){
stateMatrix[l][k] = _controller.outputs[l][0];
}
k++;
}
printf("#matrix STATES -------------------------------");
print_matrix(stateMatrix,nStates,0);
printf("#matrix OUTPUTS -------------------------------");
print_matrix(outputMatrix,nOutputs,0);
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 93, __extension__ __PRETTY_FUNCTION__); }))
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
for(i=0; i<nStates;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = stateMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
for(i=0; i<nOutputs;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = outputMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 110, __extension__ __PRETTY_FUNCTION__); }))
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
}
int verify_limit_cycle(void){
overflow_mode = 3;
int i;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
__DSVERIFIER_assert(X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na);
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 168 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t xaux[ds.b_size];
int nondet_constant_input = nondet_int();
__DSVERIFIER_assume(nondet_constant_input >= min_fxp && nondet_constant_input <= max_fxp);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = nondet_constant_input;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t y0[ds.a_size];
fxp_t waux[Nw];
fxp_t w0[Nw];
# 206 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= min_fxp && waux[i] <= max_fxp);
w0[i] = waux[i];
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
# 228 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
shiftR(0, waux, Nw);
y[i] = fxp_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 278 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 34 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
extern digital_system ds;
extern implementation impl;
int verify_error(void){
overflow_mode = 2;
double a_cascade[100];
int a_cascade_size;
double b_cascade[100];
int b_cascade_size;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 69 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
double yf[X_SIZE_VALUE];
double xf[X_SIZE_VALUE];
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
double yfaux[ds.a_size];
double xfaux[ds.b_size];
double wfaux[Nw];
int i;
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
yfaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
xfaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
wfaux[i] = 0;
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_int();
__DSVERIFIER_assume(x[i] >= min_fxp && x[i] <= max_fxp);
yf[i] = 0.0f;
xf[i] = fxp_to_double(x[i]);
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
# 139 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
shiftRboth(0.0f, wfaux, 0, waux, Nw);
y[i] = fxp_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
yf[i] = double_direct_form_2(wfaux, xf[i], ds.a, ds.b, ds.a_size, ds.b_size);
# 169 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
double absolute_error = yf[i] - fxp_to_double(y[i]);
__DSVERIFIER_assert(absolute_error < (impl.max_error) && absolute_error > (-impl.max_error));
}
return 0;
}
# 35 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 1
# 13 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
int verify_zero_input_limit_cycle(void){
overflow_mode = 3;
int i,j;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
((void) sizeof ((
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ; else __assert_fail (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
"X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na"
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h", 23, __extension__ __PRETTY_FUNCTION__); }))
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 71 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = 0;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
fxp_t y0[ds.a_size];
fxp_t w0[Nw];
# 104 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= min_fxp && waux[i] <= max_fxp);
w0[i] = waux[i];
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
for(i=0; i<X_SIZE_VALUE; ++i){
# 132 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
shiftR(0, waux, Nw);
y[i] = fxp_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 188 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
extern hardware hw;
int generic_timer = 0;
int verify_generic_timing(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
double initial_timer = generic_timer;
for (i = 0; i < X_SIZE_VALUE; ++i) {
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.adiw) + (2 * hw.assembly.std));
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.cpi) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
# 79 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
generic_timing_shift_r_double(0, waux, Nw);
y[i] = generic_timing_double_direct_form_2(waux, x[i], ds.a, ds.b, ds.a_size, ds.b_size);
double spent_time = (((double) generic_timer) * hw.cycle);
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
((void) sizeof ((
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ; else __assert_fail (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
"spent_time <= ds.sample_time"
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h", 89, __extension__ __PRETTY_FUNCTION__); }))
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
;
generic_timer = initial_timer;
}
return 0;
}
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
int verify_timing_msp_430(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for (i = 0; i < X_SIZE_VALUE; ++i) {
# 69 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
shiftR(0, waux, Nw);
y[i] = double_direct_form_2_MSP430(waux, x[i], ds.a, ds.b, ds.a_size, ds.b_size);
# 121 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
}
return 0;
}
# 38 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
extern digital_system ds;
extern implementation impl;
int verify_stability(void){
overflow_mode = 0;
fxp_t a_fxp[ds.a_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
double _a[ds.a_size];
fxp_to_double_array(_a, a_fxp, ds.a_size);
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
((void) sizeof ((
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ; else __assert_fail (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
"check_stability(_a, ds.a_size)"
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h", 37, __extension__ __PRETTY_FUNCTION__); }))
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
;
# 83 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
return 0;
}
# 39 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
extern digital_system ds;
extern implementation impl;
int verify_minimum_phase(void){
overflow_mode = 0;
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
double _b[ds.b_size];
fxp_to_double_array(_b, b_fxp, ds.b_size);
__DSVERIFIER_assert(check_stability(_b, ds.b_size));
# 85 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
return 0;
}
# 40 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_stability_closedloop_using_dslib(void){
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 48 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 68 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
printf("Verifying stability for closedloop function\n");
__DSVERIFIER_assert(check_stability_closedloop(ans_den, ans_den_size, p_num, p_num_size, p_den, p_den_size));
return 0;
}
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
double nondet_double();
int verify_limit_cycle_closed_loop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 58 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
int i;
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux[i] = nondet_constant_input;
}
double yaux[ans_den_size];
double y0[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux[Nw];
double w0[Nw];
# 105 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= impl.min && waux[i] <= impl.max);
w0[i] = waux[i];
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
# 128 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
shiftRDdouble(0, waux, Nw);
y[i] = double_direct_form_2(waux, x[i], ans_den, ans_num, ans_den_size, ans_num_size);
}
double_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 42 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_error_closedloop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 56 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num_double[100];
double ans_num_qtz[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den_qtz[100];
double ans_den_double[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 77 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
int i;
double y_qtz[X_SIZE_VALUE];
double y_double[X_SIZE_VALUE];
double x_qtz[X_SIZE_VALUE];
double x_double[X_SIZE_VALUE];
double xaux_qtz[ans_num_size];
double xaux_double[ans_num_size];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x_qtz[i] = nondet_constant_input;
x_double[i] = nondet_constant_input;
y_qtz[i] = 0;
y_double[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux_qtz[i] = nondet_constant_input;
xaux_double[i] = nondet_constant_input;
}
double yaux_qtz[ans_den_size];
double yaux_double[ans_den_size];
double y0_qtz[ans_den_size];
double y0_double[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux_qtz[Nw];
double waux_double[Nw];
double w0_qtz[Nw];
double w0_double[Nw];
for (i = 0; i < Nw; ++i) {
waux_qtz[i] = 0;
waux_double[i] = 0;
}
for(i=0; i<X_SIZE_VALUE; ++i){
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
shiftRDdouble(0, waux_qtz, Nw);
y_qtz[i] = double_direct_form_2(waux_qtz, x_qtz[i], ans_den_qtz, ans_num_qtz, ans_den_size, ans_num_size);
shiftRDdouble(0, waux_double, Nw);
y_double[i] = double_direct_form_2(waux_double, x_double[i], ans_den_double, ans_num_double, ans_den_size, ans_num_size);
# 156 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
double absolute_error = y_double[i] - fxp_to_double(y_qtz[i]);
__DSVERIFIER_assert(absolute_error < (impl.max_error) && absolute_error > (-impl.max_error));
}
return 0;
}
# 43 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
extern digital_system_state_space _controller;
extern double error_limit;
extern int closed_loop;
double new_state[4][4];
double new_stateFWL[4][4];
digital_system_state_space _controller_fxp;
digital_system_state_space _controller_double;
double ss_system_quantization_error(fxp_t inputs){
digital_system_state_space __backupController;
int i;
int j;
_controller.inputs[0][0] = inputs;
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
__backupController.A[i][j]= (_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
__backupController.B[i][j]= (_controller.B[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
__backupController.C[i][j]= (_controller.C[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
__backupController.D[i][j]= (_controller.D[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
__backupController.states[i][j]= (_controller.states[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
__backupController.inputs[i][j]= (_controller.inputs[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
__backupController.outputs[i][j]= (_controller.outputs[i][j]);
}
}
double __quant_error = 0.0;
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= (new_state[i][j]);
}
}
double output_double = double_state_space_representation();
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_state[i][j]= (_controller.states[i][j]);
}
}
__backupController.inputs[0][0] = inputs;
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
_controller.A[i][j] = __backupController.A[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
_controller.B[i][j] = __backupController.B[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
_controller.C[i][j] = __backupController.C[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
_controller.D[i][j] = __backupController.D[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j] = __backupController.states[i][j];
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
_controller.inputs[i][j] = __backupController.inputs[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
_controller.outputs[i][j] = __backupController.outputs[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= (new_stateFWL[i][j]);
}
}
double output_fxp = fxp_state_space_representation();
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_stateFWL[i][j]= (_controller.states[i][j]);
}
}
__quant_error = output_double - output_fxp;
return __quant_error;
}
double fxp_ss_closed_loop_quantization_error(double reference){
double reference_aux[4][4];
double result1[4][4];
double temp_result1[4][4];
double result2[4][4];
double temp_states[4][4];
fxp_t K_fxp[4][4];
fxp_t states_fxp[4][4];
fxp_t result_fxp[4][4];
unsigned int i;
unsigned int j;
unsigned int k;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller_fxp.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
reference_aux[i][j]=0;
K_fxp[i][j] = 0;
}
}
for(i=0; i<nInputs;i++){
reference_aux[i][0]= reference;
}
for(i=0; i<4;i++){
states_fxp[i][0]=0;
}
for(i=0; i<nStates;i++){
K_fxp[0][i]= fxp_double_to_fxp(_controller_fxp.K[0][i]);
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
for(k=0; k<nStates;k++)
{
states_fxp[k][0]= fxp_double_to_fxp(_controller_fxp.states[k][0]);
}
fxp_matrix_multiplication(nOutputs,nStates,nStates,1,K_fxp,states_fxp,result_fxp);
fxp_t reference_fxp[4][4];
fxp_t result_fxp2[4][4];
for(k=0;k<nInputs;k++)
{
reference_fxp[k][0] =fxp_double_to_fxp(fxp_quantize(reference_aux[k][0]));
}
fxp_sub_matrix(nInputs,1, reference_fxp, result_fxp, result_fxp2);
for(k=0; k<nInputs;k++)
{
_controller_fxp.inputs[k][0] = fxp_to_double(fxp_quantize(result_fxp2[k][0]));
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_fxp.C,_controller_fxp.states,result1);
if(flag == 1)
{
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller_fxp.D,_controller_fxp.inputs,result2);
}
double_add_matrix(nOutputs,1,result1,result2,_controller_fxp.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller_fxp.A,_controller_fxp.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller_fxp.B,_controller_fxp.inputs,result2);
double_add_matrix(nStates,1,result1,result2,_controller_fxp.states);
return _controller_fxp.outputs[0][0];
}
double ss_closed_loop_quantization_error(double reference){
double reference_aux[4][4];
double result1[4][4];
double result2[4][4];
unsigned int i;
unsigned int j;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller_double.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
reference_aux[i][j]= reference;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_double.K,_controller_double.states,result1);
double_sub_matrix(nInputs,1,reference_aux,result1, _controller_double.inputs);
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_double.C,_controller_double.states,result1);
if(flag == 1)
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller_double.D,_controller_double.inputs,result2);
double_add_matrix(nOutputs,1,result1,result2,_controller_double.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller_double.A,_controller_double.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller_double.B,_controller_double.inputs,result2);
double_add_matrix(nStates,1,result1,result2,_controller_double.states);
return _controller_double.outputs[0][0];
}
int verify_error_state_space(void){
int i,j;
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_state[i][j]= (_controller.states[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_stateFWL[i][j]= (_controller.states[i][j]);
}
}
_controller_fxp = _controller;
_controller_double = _controller;
overflow_mode = 0;
fxp_t x[0];
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= min_fxp && nondet_constant_input <= max_fxp);
for (i = 0; i < 0; ++i) {
x[i] = nondet_constant_input;
}
double __quant_error;
if(closed_loop){
for (i = 0; i < 0; ++i) {
__quant_error = ss_closed_loop_quantization_error(x[i]) - fxp_ss_closed_loop_quantization_error(x[i]);
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
((void) sizeof ((
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ; else __assert_fail (
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
"__quant_error < error_limit && __quant_error > ((-1)*error_limit)"
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h", 354, __extension__ __PRETTY_FUNCTION__); }))
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
;
}
}
else {
for (i=0; i < 0; i++)
{
__quant_error = ss_system_quantization_error(x[i]);
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
((void) sizeof ((
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ; else __assert_fail (
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
"__quant_error < error_limit && __quant_error > ((-1)*error_limit)"
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h", 361, __extension__ __PRETTY_FUNCTION__); }))
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
;
}
}
return 0;
}
# 44 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
extern digital_system_state_space _controller;
extern double error_limit;
extern int closed_loop;
double fxp_ss_closed_loop_safety(){
double reference[4][4];
double result1[4][4];
double result2[4][4];
fxp_t K_fpx[4][4];
fxp_t outputs_fpx[4][4];
fxp_t result_fxp[4][4];
unsigned int i;
unsigned int j;
unsigned int k;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
reference[i][j]= (_controller.inputs[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<nOutputs;j++){
K_fpx[i][j]=0;
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
outputs_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result_fxp[i][j]=0;
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<nOutputs;j++){
K_fpx[i][j]= fxp_double_to_fxp(_controller.K[i][j]);
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
for (i = 1; i < 0; i++) {
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
if(flag == 1){
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
}
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
for(k=0; k<nOutputs;k++){
for(j=0; j<1;j++){
outputs_fpx[k][j]= fxp_double_to_fxp(_controller.outputs[k][j]);
}
}
fxp_matrix_multiplication(nInputs,nOutputs,nOutputs,1,K_fpx,outputs_fpx,result_fxp);
for(k=0; k<nInputs;k++){
for(j=0; j<1;j++){
result1[k][j]= fxp_to_double(result_fxp[k][j]);
}
}
printf("### fxp: U (before) = %.9f", _controller.inputs[0][0]);
printf("### fxp: reference = %.9f", reference[0][0]);
printf("### fxp: result1 = %.9f", result1[0][0]);
printf("### fxp: reference - result1 = %.9f", (reference[0][0] - result1[0][0]));
double_sub_matrix(nInputs,
1,
reference,
result1,
_controller.inputs);
printf("### fxp: Y = %.9f", _controller.outputs[0][0]);
printf("### fxp: U (after) = %.9f \n### \n### ", _controller.inputs[0][0]);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
}
return _controller.outputs[0][0];
}
int verify_safety_state_space(void){
fxp_t output_fxp = fxp_ss_closed_loop_safety();
double output_double = fxp_to_double(output_fxp);
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
((void) sizeof ((
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
output_double <= error_limit
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
output_double <= error_limit
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
) ; else __assert_fail (
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
"output_double <= error_limit"
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h", 140, __extension__ __PRETTY_FUNCTION__); }))
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
;
return 0;
}
# 45 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 1
# 14 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
extern digital_system_state_space _controller;
int verify_controllability(void){
int i;
int j;
fxp_t A_fpx[4][4];
fxp_t B_fpx[4][4];
fxp_t controllabilityMatrix[4][4];
fxp_t backup[4][4];
fxp_t backupSecond[4][4];
double controllabilityMatrix_double[4][4];
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
A_fpx[i][j] = 0.0;
B_fpx[i][j] = 0.0;
controllabilityMatrix[i][j] = 0.0;
backup[i][j] = 0.0;
backupSecond[i][j] = 0.0;
controllabilityMatrix_double[i][j] = 0.0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
B_fpx[i][j]= fxp_double_to_fxp(_controller.B[i][j]);
}
}
if(nInputs > 1){
int l = 0;
for(j=0; j<(nStates*nInputs);){
fxp_exp_matrix(nStates,nStates,A_fpx,l,backup);
l++;
fxp_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,B_fpx,backupSecond);
for(int k = 0; k < nInputs; k++){
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][k];
}
j++;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
backup[i][j]= 0.0;
}
}
fxp_transpose(controllabilityMatrix,backup,nStates,(nStates*nInputs));
fxp_t mimo_controllabilityMatrix_fxp[4][4];
fxp_matrix_multiplication(nStates,(nStates*nInputs),(nStates*nInputs),nStates,controllabilityMatrix,backup,mimo_controllabilityMatrix_fxp);
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
controllabilityMatrix_double[i][j]= fxp_to_double(mimo_controllabilityMatrix_fxp[i][j]);
}
}
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix_double,nStates) != 0"
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 91, __extension__ __PRETTY_FUNCTION__); }))
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
} else {
for(j=0; j<nStates;j++){
fxp_exp_matrix(nStates,nStates,A_fpx,j,backup);
fxp_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,B_fpx,backupSecond);
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][0];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
controllabilityMatrix_double[i][j]= fxp_to_double(controllabilityMatrix[i][j]);
}
}
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix_double,nStates) != 0"
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 113, __extension__ __PRETTY_FUNCTION__); }))
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
}
return 0;
}
int verify_controllability_double(void){
int i;
int j;
double controllabilityMatrix[4][4];
double backup[4][4];
double backupSecond[4][4];
double controllabilityMatrix_double[4][4];
if(nInputs > 1){
int l = 0;
for(j=0; j<(nStates*nInputs);){
double_exp_matrix(nStates,nStates,_controller.A,l,backup);
l++;
double_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,_controller.B,backupSecond);
for(int k = 0; k < nInputs; k++){
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][k];
}
j++;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
backup[i][j]= 0.0;
}
}
transpose(controllabilityMatrix,backup,nStates,(nStates*nInputs));
double mimo_controllabilityMatrix_double[4][4];
double_matrix_multiplication(nStates,(nStates*nInputs),(nStates*nInputs),nStates,controllabilityMatrix,backup,mimo_controllabilityMatrix_double);
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(mimo_controllabilityMatrix_double,nStates) != 0
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(mimo_controllabilityMatrix_double,nStates) != 0
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(mimo_controllabilityMatrix_double,nStates) != 0"
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 154, __extension__ __PRETTY_FUNCTION__); }))
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
} else {
for(j=0; j<nStates;j++){
double_exp_matrix(nStates,nStates,_controller.A,j,backup);
double_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,_controller.B,backupSecond);
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][0];
}
}
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix,nStates) != 0
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix,nStates) != 0
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix,nStates) != 0"
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 163, __extension__ __PRETTY_FUNCTION__); }))
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
}
return 0;
}
# 46 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
extern digital_system_state_space _controller;
int verify_observability(void){
int i;
int j;
fxp_t A_fpx[4][4];
fxp_t C_fpx[4][4];
fxp_t observabilityMatrix[4][4];
fxp_t backup[4][4];
fxp_t backupSecond[4][4];
double observabilityMatrix_double[4][4];
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix[i][j]= 0;
A_fpx[i][j]=0;
C_fpx[i][j]= 0;
backup[i][j]= 0;
backupSecond[i][j]= 0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
C_fpx[i][j]= fxp_double_to_fxp(_controller.C[i][j]);
}
}
if(nOutputs > 1){
int l;
j = 0;
for(l=0; l<nStates;){
fxp_exp_matrix(nStates,nStates,A_fpx,l,backup);
l++;
fxp_matrix_multiplication(nOutputs,nStates,nStates,nStates,C_fpx,backup,backupSecond);
for(int k = 0; k < nOutputs; k++){
for(i = 0; i<nStates;i++){
observabilityMatrix[j][i]= backupSecond[k][i];
}
j++;
}
}
# 80 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nOutputs);j++){
backup[i][j]= 0.0;
}
}
fxp_transpose(observabilityMatrix,backup,(nStates*nOutputs),nStates);
# 99 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
fxp_t mimo_observabilityMatrix_fxp[4][4];
fxp_matrix_multiplication(nStates,(nStates*nOutputs),(nStates*nOutputs),nStates,backup,observabilityMatrix,mimo_observabilityMatrix_fxp);
# 112 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix_double[i][j]= fxp_to_double(mimo_observabilityMatrix_fxp[i][j]);
}
}
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
((void) sizeof ((
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ; else __assert_fail (
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
"determinant(observabilityMatrix_double,nStates) != 0"
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h", 119, __extension__ __PRETTY_FUNCTION__); }))
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
;
}else{
for(i=0; i<nStates;i++){
fxp_exp_matrix(nStates,nStates,A_fpx,i,backup);
fxp_matrix_multiplication(nOutputs,nStates,nStates,nStates,C_fpx,backup,backupSecond);
for(j = 0; j<nStates;j++){
observabilityMatrix[i][j]= backupSecond[0][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix_double[i][j]= fxp_to_double(observabilityMatrix[i][j]);
}
}
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
((void) sizeof ((
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ; else __assert_fail (
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
"determinant(observabilityMatrix_double,nStates) != 0"
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h", 134, __extension__ __PRETTY_FUNCTION__); }))
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
;
}
return 0;
}
# 47 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h"
extern filter_parameters filter;
extern implementation impl;
extern digital_system ds;
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h"
void resp_mag(double* num, int lnum, double* den, int lden, double* res, int N) {
double w;
int m, i;
double out_numRe[N + 1];
double out_numIm[N + 1];
double out_denRe[N + 1];
double out_denIm[N + 1];
double old_out_Re;
double zero_test;
for (w = 0, i = 0; w <= 3.14159265358979323846; w += 3.14159265358979323846 / N, ++i) {
out_numRe[i] = num[0];
out_numIm[i] = 0;
for (m = 1; m < lnum; ++m) {
old_out_Re = out_numRe[i];
out_numRe[i] = cosTyl(w, 6) * out_numRe[i] - sinTyl(w, 6) * out_numIm[i] + num[m];
out_numIm[i] = sinTyl(w, 6) * old_out_Re + cosTyl(w, 6) * out_numIm[i];
}
out_denRe[i] = den[0];
out_denIm[i] = 0;
for (m = 1; m < lden; ++m) {
old_out_Re = out_denRe[i];
out_denRe[i] = cosTyl(w, 6) * out_denRe[i] - sinTyl(w, 6) * out_denIm[i] + den[m];
out_denIm[i] = sinTyl(w, 6) * old_out_Re + cosTyl(w, 6) * out_denIm[i];
}
res[i] = sqrt3(out_numRe[i] * out_numRe[i] + out_numIm[i] * out_numIm[i]);
zero_test = sqrt3(out_denRe[i] * out_denRe[i] + out_denIm[i] * out_denIm[i]);
__DSVERIFIER_assume(zero_test != 0);
res[i] = res[i] / zero_test;
}
}
int verify_magnitude(void) {
int freq_response_samples = 100;
double w;
double w_incr = 1.0 / freq_response_samples;
double res[freq_response_samples+1];
int i,j;
fxp_t a_fxp[ds.a_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
double _a[ds.a_size];
fxp_to_double_array(_a, a_fxp, ds.a_size);
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
double _b[ds.b_size];
fxp_to_double_array(_b, b_fxp, ds.b_size);
resp_mag(ds.b, ds.b_size, ds.a, ds.a_size, res, freq_response_samples);
if (filter.type == 1) {
for (i = 0, w = 0; (w <= 1.0); ++i, w += w_incr) {
if (w <= filter.wp) {
__DSVERIFIER_assert_msg(res[i] >= filter.Ap, "|----------------Passband Failure-------------|");
} else if (w == filter.wc) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ac, "|-------------Cutoff Frequency Failure--------|");
} else if ((w >= filter.wr) && (w <= 1)) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ar, "|----------------Stopband Failure-------------|");
}
}
} else if (filter.type == 2) {
for (i = 0, w = 0; (w <= 1.0); ++i, w += w_incr) {
if (w <= filter.wr) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ar, "|----------------Stopband Failure-------------|");
} else if (w == filter.wc) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ac, "|-------------Cutoff Frequency Failure--------|");
} else if ((w > filter.wp) && (w <= 1)) {
__DSVERIFIER_assert_msg(res[i] >= filter.Ap, "|----------------Passband Failure-------------|");
}
}
} else {
__DSVERIFIER_assert(0);
}
return 0;
}
# 48 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
extern digital_system ds;
extern digital_system plant;
digital_system plant_cbmc;
extern digital_system controller;
extern implementation impl;
extern hardware hw;
extern digital_system_state_space _controller;
extern filter_parameters filter;
unsigned int nondet_uint();
extern void initials();
void validation();
void call_verification_task(void * verification_task);
void call_closedloop_verification_task(void * closedloop_verification_task);
float nondet_float();
double nondet_double();
int main(){
initialization();
validation();
if (1 == 0)
rounding_mode = 0;
else if (1 == 1)
rounding_mode = 1;
else if (1 == 2)
rounding_mode = 2;
if (2 == 3)
{
call_verification_task(&verify_overflow);
}
else if (2 == 2)
{
call_verification_task(&verify_limit_cycle);
}
else if (2 == 6)
{
call_verification_task(&verify_error);
}
else if (2 == 1)
{
call_verification_task(&verify_zero_input_limit_cycle);
}
else if (2 == 4)
{
call_verification_task(&verify_timing_msp_430);
}
else if (2 == 5)
{
call_verification_task(&verify_generic_timing);
}
else if (2 == 7)
{
call_verification_task(&verify_stability);
}
else if (2 == 8)
{
call_verification_task(&verify_minimum_phase);
}
else if (2 == 9)
{
call_closedloop_verification_task(&verify_stability_closedloop_using_dslib);
}
else if (2 == 10)
{
call_closedloop_verification_task(&verify_limit_cycle_closed_loop);
}
else if (2 == 11)
{
call_closedloop_verification_task(&verify_error_closedloop);
}
else if (2 == 12)
{
verify_error_state_space();
}
else if (2 == 16)
{
verify_safety_state_space();
}
else if (2 == 13)
{
verify_controllability();
}
else if (2 == 14)
{
verify_observability();
}
else if (2 == 15)
{
verify_limit_cycle_state_space();
}
else if (2 == 18)
{
call_verification_task(&verify_magnitude);
}
return 0;
}
void validation()
{
if (2 == 12 || 2 == 16 ||
2 == 15 || 2 == 13 ||
2 == 14)
{
if (0 == 0)
{
printf("\n\n********************************************************************************************\n");
printf("* set a K_SIZE to use this property in DSVerifier (use: -DK_SIZE=VALUE) *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
exit(1);
}
initials();
return;
}
if (((2 != 9) && (2 != 10) &&
(2 != 11)) && (ds.a_size == 0 || ds.b_size == 0))
{
printf("\n\n****************************************************************************\n");
printf("* set (ds and impl) parameters to check with DSVerifier *\n");
printf("****************************************************************************\n");
__DSVERIFIER_assert(0);
}
if ((2 == 9) || (2 == 10) ||
(2 == 11))
{
if (controller.a_size == 0 || plant.b_size == 0 || impl.int_bits == 0 )
{
printf("\n\n*****************************************************************************************************\n");
printf("* set (controller, plant, and impl) parameters to check CLOSED LOOP with DSVerifier *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else
{
printf("\n\n*****************************************************************************************************\n");
printf("* set (controller and impl) parameters so that they do not overflow *\n");
printf("*****************************************************************************************************\n");
unsigned j;
for (j = 0; j < controller.a_size; ++j)
{
const double value=controller.a[j];
__DSVERIFIER_assert(value <= _dbl_max);
__DSVERIFIER_assert(value >= _dbl_min);
}
for (j = 0; j < controller.b_size; ++j)
{
const double value=controller.b[j];
__DSVERIFIER_assert(value <= _dbl_max);
__DSVERIFIER_assert(value >= _dbl_min);
}
}
if (controller.b_size > 0)
{
unsigned j, zeros=0;
for (j = 0; j < controller.b_size; ++j)
{
if (controller.b[j]==0)
++zeros;
}
if (zeros == controller.b_size)
{
printf("\n\n*****************************************************************************************************\n");
printf("* The controller numerator must not be zero *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (controller.a_size > 0)
{
unsigned j, zeros=0;
for (j = 0; j < controller.a_size; ++j)
{
if (controller.a[j]==0)
++zeros;
}
if (zeros == controller.a_size)
{
printf("\n\n*****************************************************************************************************\n");
printf("* The controller denominator must not be zero *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (0 == 0)
{
printf("\n\n***************************************************************************************************************\n");
printf("* set a connection mode to check CLOSED LOOP with DSVerifier (use: --connection-mode TYPE) *\n");
printf("***************************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (2 == 0)
{
printf("\n\n***************************************************************************************\n");
printf("* set the property to check with DSVerifier (use: --property NAME) *\n");
printf("***************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if ((2 == 3) || (2 == 2) || (2 == 1) ||
(2 == 10) || (2 == 11) ||
(2 == 4 || 2 == 5) || 2 == 6)
{
if ((5 == 0) && !(0 == 1))
{
printf("\n\n********************************************************************************************\n");
printf("* set a X_SIZE to use this property in DSVerifier (use: --x-size VALUE) *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else if (0 == 1)
{
X_SIZE_VALUE = nondet_uint();
__DSVERIFIER_assume( X_SIZE_VALUE > (2 * ds.a_size));
}
else if (5 < 0)
{
printf("\n\n********************************************************************************************\n");
printf("* set a X_SIZE > 0 *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else
{
X_SIZE_VALUE = 5;
}
}
if ((2 == 0) && (2 != 9) && (2 != 18))
{
printf("\n\n*********************************************************************************************\n");
printf("* set the realization to check with DSVerifier (use: --realization NAME) *\n");
printf("*********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if (2 == 6 || 2 == 11)
{
if (impl.max_error == 0)
{
printf("\n\n***********************************************************************\n");
printf("* provide the maximum expected error (use: impl.max_error) *\n");
printf("***********************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (2 == 4 || 2 == 5)
{
if (2 == 5 || 2 == 4)
{
if (hw.clock == 0l)
{
printf("\n\n***************************\n");
printf("* Clock could not be zero *\n");
printf("***************************\n");
__DSVERIFIER_assert(0);
}
hw.cycle = ((double) 1.0 / hw.clock);
if (hw.cycle < 0)
{
printf("\n\n*********************************************\n");
printf("* The cycle time could not be representable *\n");
printf("*********************************************\n");
__DSVERIFIER_assert(0);
}
if (ds.sample_time == 0)
{
printf("\n\n*****************************************************************************\n");
printf("* provide the sample time of the digital system (ds.sample_time) *\n");
printf("*****************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
}
if (2 == 18)
{
if (!((filter.Ap > 0) && (filter.Ac >0) && (filter.Ar >0)))
{
printf("\n\n*****************************************************************************\n");
printf("* set values bigger than 0 for Ap, Ac and Ar* \n");
printf("*****************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if ((2 == 7) || (2 == 8) || (2 == 9) ||
(2 == 10) || (2 == 11) || (2 == 12))
{
printf("\n\n******************************************\n");
printf("* Temporarily the cascade modes are disabled *\n");
printf("**********************************************\n");
__DSVERIFIER_assert(0);
}
}
void call_verification_task(void * verification_task)
{
int i = 0;
_Bool base_case_executed = 0;
if (0 == 2)
{
for(i=0; i<ds.b_size; i++)
{
if (ds.b_uncertainty[i] > 0)
{
double factor = ds.b_uncertainty[i];
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.b[i] - factor;
double max = ds.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.b[i] = nondet_double();
__DSVERIFIER_assume((ds.b[i] >= min) && (ds.b[i] <= max));
}
}
for(i=0; i<ds.a_size; i++)
{
if (ds.a_uncertainty[i] > 0)
{
double factor = ds.a_uncertainty[i];
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.a[i] - factor;
double max = ds.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.a[i] = nondet_double();
__DSVERIFIER_assume((ds.a[i] >= min) && (ds.a[i] <= max));
}
}
}
else
{
int i=0;
for(i=0; i<ds.b_size; i++)
{
if (ds.b_uncertainty[i] > 0)
{
double factor = ((ds.b[i] * ds.b_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.b[i] - factor;
double max = ds.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.b[i] = nondet_double();
__DSVERIFIER_assume((ds.b[i] >= min) && (ds.b[i] <= max));
}
}
for(i=0; i<ds.a_size; i++)
{
if (ds.a_uncertainty[i] > 0)
{
double factor = ((ds.a[i] * ds.a_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.a[i] - factor;
double max = ds.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.a[i] = nondet_double();
__DSVERIFIER_assume((ds.a[i] >= min) && (ds.a[i] <= max));
}
}
}
((void(*)())verification_task)();
}
void call_closedloop_verification_task(void * closedloop_verification_task)
{
_Bool base_case_executed = 0;
int i=0;
for(i=0; i<plant.b_size; i++)
{
if (plant.b_uncertainty[i] > 0)
{
double factor = ((plant.b[i] * plant.b_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = plant.b[i] - factor;
double max = plant.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
plant_cbmc.b[i] = nondet_double();
__DSVERIFIER_assume((plant_cbmc.b[i] >= min) && (plant_cbmc.b[i] <= max));
}else{
plant_cbmc.b[i] = plant.b[i];
}
}
for(i=0; i<plant.a_size; i++)
{
if (plant.a_uncertainty[i] > 0)
{
double factor = ((plant.a[i] * plant.a_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = plant.a[i] - factor;
double max = plant.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
plant_cbmc.a[i] = nondet_double();
__DSVERIFIER_assume((plant_cbmc.a[i] >= min) && (plant_cbmc.a[i] <= max));
}
else
{
plant_cbmc.a[i] = plant.a[i];
}
}
((void(*)())closedloop_verification_task)();
}
# 2 "benchmarks/ds-08-impl2.c" 2
digital_system ds = {
.b = { 0.0096, -0.009 },
.b_size = 2,
.a = { 0.02, 0.0 },
.a_size = 2,
.sample_time = 0.02
};
implementation impl = {
.int_bits = 4,
.frac_bits = 12,
.max = 1.0,
.min = -1.0
};
|
the_stack_data/90766802.c | //
//
#include <stdio.h>
int main()
{
int a, b, c, median;
printf("Please enter 3 numbers separated by spaces > ");
scanf("%d%d%d", &a, &b, &c);
if((a >= b && a <= c) || (a >= c && a <= b))
median = a;
if((b >= a && b <= c) || (b >= c && b <= a))
median = b;
else
median = c;
printf("%d is the median\n", median);
return 0;
}
|
the_stack_data/67621.c | #include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define SEMA_NAME "/semname"
static sem_t* create_sem() {
sem_t* semaphoreAddr;
if((semaphoreAddr = sem_open(SEMA_NAME, O_CREAT | O_RDWR)) == SEM_FAILED) {
perror("Error in sem_open create.");
exit(EXIT_FAILURE);
}
return semaphoreAddr;
}
static void post_sem(sem_t* semaphore) {
if(sem_post(semaphore) == -1) {
perror("Error in sem_post.");
exit(EXIT_FAILURE);
}
}
static void wait_sem(sem_t* semaphore) {
if(sem_wait(semaphore) == -1) {
perror("Error in sem_wait.");
exit(EXIT_FAILURE);
}
}
// binary semaphore is a mutex
int main() {
sem_t* semaphore = create_sem();
if(fork()) {
// parent
if(fork()) {
// parent
sleep(2);
post_sem(semaphore);
sleep(2);
post_sem(semaphore);
exit(0);
} else {
// child 2
sem_wait(semaphore);
printf("Child2 recvd. exiting.\n");
exit(0);
}
} else {
// child1
sem_wait(semaphore);
printf("Child1 recvd. exiting.\n");
exit(0);
}
} |
the_stack_data/40167.c | #define _GNU_SOURCE
#include <sys/wait.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define LOG(...) fprintf(stderr, __VA_ARGS__)
#define DIE(MSG) \
do { \
perror(MSG); \
exit(EXIT_FAILURE); \
} while (0)
static int *g_magic;
static int childproc(void *arg) {
LOG("Hello I'm child proc!\n");
LOG("Arg is: %s\n", (char *)arg);
LOG("Magic is: %d\n", *g_magic);
return 0;
}
enum {
CHILD_STACK_SIZE = 4 * 1024
};
int main(int argc, char *argv[]) {
if (argc == 1) {
LOG("Need an argument to be passed to childproc!\n");
return 1;
}
g_magic = malloc(sizeof(int));
if (!g_magic)
DIE("malloc magic");
*g_magic = 0x1337;
LOG("magic at %p is set to: %d\n", g_magic, *g_magic);
char *childStack = malloc(CHILD_STACK_SIZE);
if (!childStack)
DIE("malloc child stack");
pid_t childPid = clone(childproc, childStack + CHILD_STACK_SIZE, SIGCHLD, argv[1]);
if (childPid == -1)
DIE("clone");
LOG("clone() returned %ld\n", (long)childPid);
int childStatus;
if (waitpid(childPid, &childStatus, 0) == -1)
DIE("waitpid");
LOG("child has terminated with status %d\n", childStatus);
return EXIT_SUCCESS;
}
|
the_stack_data/1018034.c | // succeeds
int main() {
int i = 1;
while (i) --i;
} |
the_stack_data/200579.c | #include <stdio.h>
#include <stddef.h>
typedef struct { float f; int i; } st;
int main() {
st s = {.f=1.0, .i=1};
st *ps = &s;
unsigned char *pcs = ((unsigned char*)ps);
unsigned char *pci = (pcs + offsetof(st,i));
unsigned char *pcf = (pci - offsetof(st,i))
+ offsetof(st,f);
float *pf = (float *)pcf;
*pf = 2.0; // is this free of undefined behaviour?
printf("s.f=%f *pf=%f s.i=%i\n",s.f,*pf,s.i);
}
|
the_stack_data/165764484.c | #include <stdio.h>
#include <string.h>
void write_natural(unsigned n) {
printf("%u\n", n);
}
unsigned read_natural() {
unsigned ret = 0;
scanf("%u", &ret);
return ret;
}
void write_boolean(char b) {
printf(b ? "true\n" : "false\n");
}
char read_boolean() {
char buf[6] = {0};
scanf("%5s", buf);
return strcmp(buf, "true") == 0 ? 1 : 0;
}
|
the_stack_data/661713.c | /* volatile */ int P1_is_marked/* = 3 */;
/* volatile */ long P1_marking_member_0[3];
/* volatile */ int P2_is_marked/* = 5 */;
/* volatile */ long P2_marking_member_0[5];
/* volatile */ int P3_is_marked/* = 0 */;
/* volatile */ long P3_marking_member_0[6];
// Added by Jorge
void init_global_variables(){
P1_is_marked = 3;
P2_is_marked = 5;
P3_is_marked = 0;
}
int main()
{
int dummy_i;
long a,b,c,x,y,z;
init_global_variables();
dummy_i = 2;
while (dummy_i > 0) {
dummy_i--;
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[1] == P1_marking_member_0[2]) ) {
/*long x; */
/*long y; */
/*long z; */
x = P1_marking_member_0[0];
y = P1_marking_member_0[1];
if (x < y) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[2] == P1_marking_member_0[1]) ) {
/* long x; */
/* long y; */
/* long z; */
x = P1_marking_member_0[0];
y = P1_marking_member_0[2];
if ((x < y)) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[0] == P1_marking_member_0[2]) ) {
/* long x; */
/* long y; */
/* long z; */
x = P1_marking_member_0[1];
y = P1_marking_member_0[0];
if (x < y) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[2] == P1_marking_member_0[0])) {
/* long x; */
/* long y; */
/* long z; */
x = P1_marking_member_0[1];
y = P1_marking_member_0[2];
if ((x < y)) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[0] == P1_marking_member_0[1]) ) {
/* long x; */
/* long y; */
/* long z; */
x = P1_marking_member_0[2];
y = P1_marking_member_0[0];
if ((x < y)) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P1_is_marked >= 3) &&
(P3_is_marked + 3 <= 6) &&
(P1_marking_member_0[1] == P1_marking_member_0[0]) ) {
/* long x; */
/* long y; */
/* long z; */
x = P1_marking_member_0[2];
y = P1_marking_member_0[1];
if ((x < y)) {
P1_is_marked = P1_is_marked - 3;
z = x - y;
P3_marking_member_0[P3_is_marked+0] = x;
P3_marking_member_0[P3_is_marked+1] = y;
P3_marking_member_0[P3_is_marked+2] = z;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
(((P3_is_marked + 3) <= 6)) &&
( ((P2_marking_member_0[1] == P2_marking_member_0[2])) &&
((P2_marking_member_0[1] == P2_marking_member_0[3])) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
(((P3_is_marked + 3) <= 6)) &&
( (P2_marking_member_0[1] == P2_marking_member_0[3]) &&
(P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[2] == P2_marking_member_0[1]) &&
(P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/*block 10*/
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[2] == P2_marking_member_0[3]) &&
(P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[1]) &&
(P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[2]) &&
(P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[0] == P2_marking_member_0[2]) &&
(P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[0] == P2_marking_member_0[3]) &&
(P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/*block 15*/
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[2] == P2_marking_member_0[0]) &&
(P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[2] == P2_marking_member_0[3]) &&
(P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[0]) &&
(P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
// HERE is the limit with 32Mb of Heap AND partition
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[2]) &&
(P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 19 */
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[0] == P2_marking_member_0[1]) &&
(P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 20 */
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[0] == P2_marking_member_0[3]) &&
(P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[1] == P2_marking_member_0[0]) &&
(P2_marking_member_0[1] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[1] == P2_marking_member_0[3]) &&
(P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[0]) &&
(P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[3] == P2_marking_member_0[1]) &&
(P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
((P3_is_marked + 3) <= 6) &&
( (P2_marking_member_0[0] == P2_marking_member_0[1]) &&
(P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[0] == P2_marking_member_0[2]) &&
( P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[0]) &&
( P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[2]) &&
( P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 4) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[0]) &&
( P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 30 */
if ( (P2_is_marked >= 4) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[1]) &&
( P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[2]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 32 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[3]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[1]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[3]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[3] == P2_marking_member_0[1]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 40 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[3] == P2_marking_member_0[2]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 45 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
( ( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[0];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[2]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 50 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[3]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[0]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[3]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[0]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[2]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 60 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[1];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[1]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[3]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 70 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[0]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[3]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[0]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[1]) &&
( P2_marking_member_0[3] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[4]) &&
( P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 80 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[3]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[2];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 85 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[1]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[2]) &&
( P2_marking_member_0[0] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[4]) &&
( P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[0]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 90 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[2]) &&
( P2_marking_member_0[1] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[4]) &&
( P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[0]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[1]) &&
( P2_marking_member_0[2] == P2_marking_member_0[4]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[4]) &&
( P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[0]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 100 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[1]) &&
( P2_marking_member_0[4] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[4] == P2_marking_member_0[2]) &&
( P2_marking_member_0[4] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[3];
b = P2_marking_member_0[4];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[1]) &&
( P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[1]) &&
( P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[2]) &&
( P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[2]) &&
( P2_marking_member_0[0] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[3]) &&
( P2_marking_member_0[0] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[0] == P2_marking_member_0[3]) &&
( P2_marking_member_0[0] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[0];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[0]) &&
( P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 110 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[0]) &&
( P2_marking_member_0[1] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[2]) &&
( P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[2]) &&
( P2_marking_member_0[1] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[3]) &&
( P2_marking_member_0[1] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[1] == P2_marking_member_0[3]) &&
( P2_marking_member_0[1] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[1];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[0]) &&
( P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[0]) &&
( P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[1]) &&
( P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[3];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[1]) &&
( P2_marking_member_0[2] == P2_marking_member_0[3]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[3]) &&
( P2_marking_member_0[2] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 120 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[2] == P2_marking_member_0[3]) &&
( P2_marking_member_0[2] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[2];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[0]) &&
( P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[0]) &&
( P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[1]) &&
( P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[2];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[1]) &&
( P2_marking_member_0[3] == P2_marking_member_0[2]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[2]) &&
( P2_marking_member_0[3] == P2_marking_member_0[0]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_marking_member_0[0] = P2_marking_member_0[1];
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
/* block 126 */
if ( (P2_is_marked >= 5) &&
( (P3_is_marked + 3) <= 6) &&
(( P2_marking_member_0[3] == P2_marking_member_0[2]) &&
( P2_marking_member_0[3] == P2_marking_member_0[1]) ) ) {
/* long a; */
/* long b; */
/* long c; */
a = P2_marking_member_0[4];
b = P2_marking_member_0[3];
if ((b > a)) {
P2_is_marked = P2_is_marked - 4;
c = a + b;
P3_marking_member_0[P3_is_marked+0] = a;
P3_marking_member_0[P3_is_marked+1] = b;
P3_marking_member_0[P3_is_marked+2] = c;
P3_is_marked = P3_is_marked + 3;
}
}
} // while
dummy_i = 77;
return dummy_i;
}
|
the_stack_data/646055.c | #include <stdio.h>
int main()
{
int A;
int B;
int coin;
int i;
scanf("%d %d", &A, &B);
coin = 0;
for(i = 0; i < 2; i++) {
if(A >= B) {
coin += A;
A -= 1;
} else {
coin += B;
B -=1;
}
}
printf("%d\n", coin);
return 0;
}
|
the_stack_data/87367.c | #include <stdio.h>
int
main()
{
int i;
for (i=0;i<5;++i) {
putchar('x');
fflush(stdout);
sleep(1);
}
putchar('\n');
return 0;
}
|
the_stack_data/111077228.c | /**
******************************************************************************
* @file stm32f4xx_ll_exti.c
* @author MCD Application Team
* @version V1.7.0
* @date 17-February-2017
* @brief EXTI LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_ll_exti.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32F4xx_LL_Driver
* @{
*/
#if defined (EXTI)
/** @defgroup EXTI_LL EXTI
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup EXTI_LL_Private_Macros
* @{
*/
#define IS_LL_EXTI_LINE_0_31(__VALUE__) (((__VALUE__) & ~LL_EXTI_LINE_ALL_0_31) == 0x00000000U)
#define IS_LL_EXTI_MODE(__VALUE__) (((__VALUE__) == LL_EXTI_MODE_IT) \
|| ((__VALUE__) == LL_EXTI_MODE_EVENT) \
|| ((__VALUE__) == LL_EXTI_MODE_IT_EVENT))
#define IS_LL_EXTI_TRIGGER(__VALUE__) (((__VALUE__) == LL_EXTI_TRIGGER_NONE) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_FALLING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING_FALLING))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup EXTI_LL_Exported_Functions
* @{
*/
/** @addtogroup EXTI_LL_EF_Init
* @{
*/
/**
* @brief De-initialize the EXTI registers to their default reset values.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are de-initialized
* - ERROR: not applicable
*/
uint32_t LL_EXTI_DeInit(void)
{
/* Interrupt mask register set to default reset values */
LL_EXTI_WriteReg(IMR, 0x00000000U);
/* Event mask register set to default reset values */
LL_EXTI_WriteReg(EMR, 0x00000000U);
/* Rising Trigger selection register set to default reset values */
LL_EXTI_WriteReg(RTSR, 0x00000000U);
/* Falling Trigger selection register set to default reset values */
LL_EXTI_WriteReg(FTSR, 0x00000000U);
/* Software interrupt event register set to default reset values */
LL_EXTI_WriteReg(SWIER, 0x00000000U);
/* Pending register set to default reset values */
LL_EXTI_WriteReg(PR, 0x00FFFFFFU);
return SUCCESS;
}
/**
* @brief Initialize the EXTI registers according to the specified parameters in EXTI_InitStruct.
* @param EXTI_InitStruct pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are initialized
* - ERROR: not applicable
*/
uint32_t LL_EXTI_Init(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_LL_EXTI_LINE_0_31(EXTI_InitStruct->Line_0_31));
assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->LineCommand));
assert_param(IS_LL_EXTI_MODE(EXTI_InitStruct->Mode));
/* ENABLE LineCommand */
if (EXTI_InitStruct->LineCommand != DISABLE)
{
assert_param(IS_LL_EXTI_TRIGGER(EXTI_InitStruct->Trigger));
/* Configure EXTI Lines in range from 0 to 31 */
if (EXTI_InitStruct->Line_0_31 != LL_EXTI_LINE_NONE)
{
switch (EXTI_InitStruct->Mode)
{
case LL_EXTI_MODE_IT:
/* First Disable Event on provided Lines */
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable IT on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_EVENT:
/* First Disable IT on provided Lines */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Event on provided Lines */
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_IT_EVENT:
/* Directly Enable IT & Event on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
if (EXTI_InitStruct->Trigger != LL_EXTI_TRIGGER_NONE)
{
switch (EXTI_InitStruct->Trigger)
{
case LL_EXTI_TRIGGER_RISING:
/* First Disable Falling Trigger on provided Lines */
LL_EXTI_DisableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Rising Trigger on provided Lines */
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_FALLING:
/* First Disable Rising Trigger on provided Lines */
LL_EXTI_DisableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Falling Trigger on provided Lines */
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_RISING_FALLING:
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
}
}
}
/* DISABLE LineCommand */
else
{
/* De-configure EXTI Lines in range from 0 to 31 */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
}
return status;
}
/**
* @brief Set each @ref LL_EXTI_InitTypeDef field to default value.
* @param EXTI_InitStruct Pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval None
*/
void LL_EXTI_StructInit(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
EXTI_InitStruct->Line_0_31 = LL_EXTI_LINE_NONE;
EXTI_InitStruct->LineCommand = DISABLE;
EXTI_InitStruct->Mode = LL_EXTI_MODE_IT;
EXTI_InitStruct->Trigger = LL_EXTI_TRIGGER_FALLING;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* defined (EXTI) */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/154828431.c | #include <stdio.h>
int main()
{
int i;
do{
printf("entre com um valor entre 0 e 9: ");
scanf("%d", &i);
}
while (i>9 || i<0);
return 0;
} |
the_stack_data/62638750.c | /* PR 30437: Test negative of -Wall
Don't change this without changing Wall.c as well. */
/* { dg-do compile } */
/* { dg-options "-Wall -Wno-all" } */
void foo()
{
int a;
5 * (a == 1) | (a == 2); /* { dg-bogus "no effect" "no effect" } */
}
|
the_stack_data/243892697.c | #include <stdio.h> // i/o
#define END '\0'
int strindex(char s[], char t[]) {
int i, j, k;
for (i = 0; s[i] != END; i++) {
for (j = i, k = 0; t[k] != END && s[j] == t[k]; j++, k++);
if (k > 0 && t[k] == END) {
return i + (k - 1);
}
}
return -1;
}
int main() {
char s[] = "Hola, esto es una prueba";
char t[] = "prueba";
int res;
res = strindex(s, t);
printf("%d\n", res);
}
|
the_stack_data/864188.c | //编写一个函数使一个字符串转换为浮点数（包括负数）
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
float result;
char str[] = "987.255*12.3";
float strToFloat(char string[]);
printf("Before string transformed to int: \"%s\".\n", str);
result = strToFloat(str);
printf("After string transformed to int: %g\n", result);
return 0;
}
float strToFloat(char string[])
{
int i, j = 0, index, temp, length;
float result, division = 1.0;
int stringLength(char string[]);
int findString(char str1[], char str2[]);
void removeString(char str[], int start, int count);
index = findString(string, ".");
while(string[j] != '\0'){
if(!((string[j] >= '0' && string[j] <= '9') || string[j] == '-'
|| string[j] == '.' || string[j] == ',')){
length = j;
break;
}
++j;
}
removeString(string, index, 1);
for(i = 0; i < (length - index - 1) &&
(string[i] >= '1' && string[i] <= '9'); ++i)
division *= 10;
temp = strToInt(string);
return temp / division;
}
int strToInt(char string[])
{
int i, intValue, result = 0;
if(string[0] == '-'){
for(i = 1; string[i] >= '0' && string[i] <= '9'; ++i){
intValue = string[i] - '0';
result = result * 10 + intValue;
}
return -result;
}
else{
for(i = 0; string[i] >= '0' && string[i] <= '9'; ++i){
intValue = string[i] - '0';
result = result * 10 + intValue;
}
return result;
}
}
void removeString(char str[], int start, int count)
{
int i = start, length;
int stringLength(char string[]);
length = stringLength(str);
if(start + count <= length)
while(str[i + count] != '\0'){
str[i] = str[i + count];
++i;
}
str[i] = '\0';
}
int findString(char str1[], char str2[])
{
int i, length1, length2;
int stringLength(char string[]);
char subStr1[81];
bool equalStrings(char s1[], char s2[]);
void substring(char source[], int start, int count, char result[]);
length1 = stringLength(str1);
length2 = stringLength(str2);
for(i = 0; str1[i] != '\0'; ++i){
if(str2[0] == str1[i]){
if(i + length2 > length1)
return -1;
else{
substring(str1, i, length2, subStr1);
if(equalStrings(subStr1, str2))
return i;
}
}
}
return -1;
}
void substring(char source[], int start, int count, char result[])
{
int i, length;
int stringLength(char string[]);
length = stringLength(source);
if(count <= length){
for(i = start; i < start + count; ++i)
result[i - start] = source[i];
result[count] = '\0';
}
else{
for(i = start; i < length; ++i)
result[i - start] = source[i];
result[length - start] = '\0';
}
}
int stringLength(char string[])
{
int count = 0;
while(string[count] != '\0')
++count;
return count;
}
bool equalStrings(char s1[], char s2[])
{
int i = 0;
bool areEqual;
while(s1[i] == s2[i] &&
s1[i] != '\0' && s2[i] != '\0')
++i;
if(s1[i] == '\0' && s2[i] == '\0')
areEqual = true;
else
areEqual = false;
return areEqual;
} |
the_stack_data/904837.c | /* $Id: wingettimeofday.c,v 1.5 2012/03/05 19:38:37 nanard Exp $ */
/* libnatpmp
Copyright (c) 2007-2011, Thomas BERNARD
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.
* The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef WIN32
#if defined(_MSC_VER)
struct timeval {
long tv_sec;
long tv_usec;
};
#else
#include <sys/time.h>
#endif
typedef struct _FILETIME {
unsigned long dwLowDateTime;
unsigned long dwHighDateTime;
} FILETIME;
void __stdcall GetSystemTimeAsFileTime(FILETIME*);
int gettimeofday(struct timeval* p, void* tz /* IGNORED */) {
union {
long long ns100; /*time since 1 Jan 1601 in 100ns units */
FILETIME ft;
} _now;
if(!p)
return -1;
GetSystemTimeAsFileTime( &(_now.ft) );
p->tv_usec =(long)((_now.ns100 / 10LL) % 1000000LL );
p->tv_sec = (long)((_now.ns100-(116444736000000000LL))/10000000LL);
return 0;
}
#endif
|
the_stack_data/97012924.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 */
// This little application is used to test calling application functions.
//
#include <stdio.h>
#if defined (TARGET_WINDOWS)
#define EXPORT_SYM __declspec( dllexport )
#else
#define EXPORT_SYM extern
#endif
EXPORT_SYM void * Bar4( long one, long two );
int main()
{
void * res;
res = Bar4(6, 8);
printf("main: res = %lx\n", (long)res);
res = Bar4(10, 12);
printf("main: res = %lx\n", (long)res);
res = Bar4(14, 16);
printf("main: res = %lx\n", (long)res);
return 0;
}
|
the_stack_data/949860.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
int age = 40;
double gpa = 3.6;
char grade = 'A';
char phrase[] = "Byrontech";
return 0;
} |
the_stack_data/193941.c | // Ensure that --redundant is indeed implied by --leaf-changes-only mode and
// that all the changed functions get complete reports.
struct stn1 {
int x;
};
struct stn2 {
long x;
double y;
};
void fn1(struct stn1 s) { // was sto1
}
void fn2(struct stn2 s) { // was sto2
}
void fn3(struct stn1* s) { // was sto1
}
void fn4(struct stn2* s) { // was sto2
}
|
the_stack_data/159515419.c | # include <ctype.h>
# include <stdio.h>
int wordCount(const char *s) {
int cnt = 0;
while (*s != '\0') {
while (isspace(*s))
s++;
if (*s != '\0') {
cnt++;
while (!isspace(*s) && *s != '\0')
s++;
}
}
return cnt;
}
int main() {
printf("%d", wordCount("I like them."));
} |
the_stack_data/906564.c | /*
*
* 1. Take a filename as a command line argument
* 2. Read stdin
* 3. Read file contents
* 4. Use user input to deobfuscate file contents
* 5. Print the deobfuscated file contents
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BINARY_NAME "source04_bad.bin"
#define PASSWORD "fuzzy"
#define BUF_LEN 65
int authenticate(char *secret);
char *get_filename(int argc, char *argv[]);
char *get_password(void);
char *parse_args(int argc, char *argv[]);
void print_usage(void);
char *validate_arg(char *argOne);
int verify_filename(char *filename);
void truncate_newlines(char *string);
int main(int argc, char *argv[])
{
// LOCAL VARIABLES
char *filename = NULL; // Flow control
// int file_exists = 0; // Return value from verify_filename(): 1 exists, 0 missing, -1 error
int success = 0; // 0 Success, -1 Bad input, -2 Error
// DO IT
// 1. PARSE ARGUMENTS
// filename = get_filename(argc, argv);
filename = argv[1];
// 2. VERIFY ENVIRONMENT
// if (filename)
// {
// file_exists = verify_filename(filename);
// if (0 == file_exists)
// {
// fprintf(stderr, "Unable to find %s\n", filename);
// print_usage();
// filename = NULL; // Used to control flow
// success = -1;
// }
// else if (-1 == file_exists)
// {
// fprintf(stderr, "Error verifying %s\n", filename);
// filename = NULL; // Used to control flow
// success = -2;
// }
// }
// 3. READ FILE
if (filename)
{
if(!authenticate(PASSWORD))
{
// 4. Read file
// 5. Print the file contents
fprintf(stderr, "%s\n", filename); // DEBUGGING
}
else
{
success = -1; // Bad password
}
}
// DONE
return success;
}
/*
* Read a password from stdin and authenticate. 0 for success, 1 for failure.
*/
int authenticate(char *secret)
{
// LOCAL VARIABLES
char *user_input = NULL; // Heap-allocated buffer with the user's input
int success = 1; // Default the return value to failure
// INPUT VALIDATION
if (secret && *secret)
{
user_input = get_password();
if (user_input && !strcmp(user_input, secret))
{
success = 0;
}
}
// DONE
free(user_input);
user_input = NULL;
return success;
}
/*
* Return the filename argument
*/
char *get_filename(int argc, char *argv[])
{
// LOCAL VARIABLES
char *argOne = NULL; // Argument 1 from argv
char *filename = NULL; // Filename, if it exists
// PARSE ARGS
argOne = parse_args(argc, argv);
// CHECK ARGS
filename = validate_arg(argOne);
// DONE
return filename;
}
/*
* Reads user input from stdin into a heap-allocated buffer
*/
char *get_password(void)
{
// LOCAL VARIABLES
char *input_ptr = malloc(BUF_LEN * sizeof(char));
// INPUT VALIDATION
if (input_ptr)
{
printf("Enter your password:\n");
if (!fgets(input_ptr, BUF_LEN, stdin))
{
free(input_ptr);
input_ptr = NULL;
}
else
{
truncate_newlines(input_ptr);
}
}
// DONE
return input_ptr;
}
/*
* Validate arguments. Return argument 1 (as appropriate).
*/
char *parse_args(int argc, char *argv[])
{
// LOCAL VARIABLES
char *argOne = NULL;
// VALIDATE ARGUMENTS
// Verify argc
if (argc != 2)
{
fprintf(stderr, "Invalid number of arguments!\n");
}
else if (argv[0] && argv[1])
{
// Verify arg 0
if (strstr(argv[0], BINARY_NAME) != (strlen(argv[0]) - strlen(BINARY_NAME) + argv[0]))
{
fprintf(stderr, "Invalid binary name!\n");
}
else
{
argOne = argv[1];
}
}
// ERROR
if (!argOne)
{
print_usage();
}
// DONE
return argOne;
}
void print_usage(void)
{
fprintf(stderr, "usage: app_name [options] obfuscated_file\n");
fprintf(stderr, "\toptions:\n");
fprintf(stderr, "\t\t-h, --help\t\tprint usage\n");
fprintf(stderr, "\n");
}
void truncate_newlines(char *string)
{
// LOCAL VARIABLES
char *tmp_ptr = string;
// INPUT VALIDATION
if (tmp_ptr && *tmp_ptr)
{
while(*tmp_ptr)
{
if ('\n' == *tmp_ptr)
{
*tmp_ptr = '\0';
break;
}
else
{
tmp_ptr++;
}
}
}
}
/*
* Prints usage instructions on option match or returns argOne
*/
char *validate_arg(char *argOne)
{
// LOCAL VARIABLES
char *filename = argOne;
char *options[] = { "-h", "--help", NULL };
char **tmp_option = options;
// CHECK IT
while(tmp_option && *tmp_option)
{
if (strstr(argOne, *tmp_option) == argOne)
{
filename = NULL; // It was an option, not the filename
print_usage();
break;
}
else
{
tmp_option++;
}
}
// DONE
return filename;
}
/*
* Verify filename exists: 1 exists, 0 missing, -1 error
*/
int verify_filename(char *filename)
{
// LOCAL VARIABLES
struct stat response; // Used by stat()
int exists = 0; // Return value
// INPUT VALIDATION
if (!filename || !(*filename))
{
exists = -1;
}
else
{
if (0 == stat(filename, &response))
{
exists = 1;
}
}
// DONE
return exists;
}
|
the_stack_data/828257.c | /*
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if PRJCONF_NET_EN
#include "cmd_util.h"
#include "net/nopoll/nopoll.h"
static const char websockets_ca_cert[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIC6zCCAdMCFELncsTSBAsyNRBc/4V2/QXlLdQ8MA0GCSqGSIb3DQEBBQUAMDIx\r\n"
"MDAuBgNVBAoMJ1RMUyBQcm9qZWN0IERvZGd5IENlcnRpZmljYXRlIEF1dGhvcml0\r\n"
"eTAeFw0xOTA3MTUwNjMzMzhaFw0zMzAzMjMwNjMzMzhaMDIxMDAuBgNVBAoMJ1RM\r\n"
"UyBQcm9qZWN0IERvZGd5IENlcnRpZmljYXRlIEF1dGhvcml0eTCCASIwDQYJKoZI\r\n"
"hvcNAQEBBQADggEPADCCAQoCggEBAKXfNjrZaQgbQgHnf+8fnkVou9g6iRofZcjy\r\n"
"HT97qUQrInSUo062+2nqFyfhsrDJU5oGHRUPaCXS9SyEregqa+6XqbMRLvL9Qf/8\r\n"
"NO0rsroqz+fQIIW8i6kxE/9s9/4csJDk7WPxV/ncG2bcHoYf9wiN6AR6hA+h4bZj\r\n"
"Cjt4qGQ23BhwIOLWrIBHq9yTfgQ2Nys01m35FvIjzSwzjQXaEcMJNy20fcmhvAr9\r\n"
"CXhPCm8np7zhbgs6SS7jUpg+9tmLypJ6JUB4GeSIAk62VlixJe+9ku4SxP9beO1/\r\n"
"YpxbcKE9Ubl01z1A6KDOzox7XReqv9iAgu03x+nDv5j9p+0SEi8CAwEAATANBgkq\r\n"
"hkiG9w0BAQUFAAOCAQEAoBYa7wGU5buBQbXRW7HYsu47mOAd2gd/ezMunV+L/ENQ\r\n"
"9IAfFJy9p816fpHShoQuQsf7RV6R/UTu/2c272/clfqanyEDFL1MupvQ7SDY+lyK\r\n"
"ofwz1H7ajWVeGBtPKtFc5btsgW6xtQIwOlHKRNI8BPP5qOrsvcwfipJ4jYlEBSGS\r\n"
"l+tIr0xpuBO0hEcG97jdoe3KpFZ0APW2C4xh8ctW1CArRVnezdCULnWFdKpdhQAY\r\n"
"ssuB2CL76qRa8l6ZZj5gUEa3IgRCj3UisBvNCMV63EhfJd/0mLv1OWqx9GPwQgMa\r\n"
"A3VSOLvHqch6Da88e6wE5irwZoCZLrUMCuS5mrOQTQ==\r\n"
"-----END CERTIFICATE-----\r\n";
/* use for two-phase verification */
static const char websockets_client_cert[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIC/DCCAeQCFFk4HVa42niSzTZbbPwh49UZW3rHMA0GCSqGSIb3DQEBBQUAMDIx\r\n"
"MDAuBgNVBAoMJ1RMUyBQcm9qZWN0IERvZGd5IENlcnRpZmljYXRlIEF1dGhvcml0\r\n"
"eTAeFw0xOTA3MTUwNjMzMzhaFw0zMzAzMjMwNjMzMzhaMEMxJzAlBgNVBAoMHlRM\r\n"
"UyBQcm9qZWN0IERldmljZSBDZXJ0aWZpY2F0ZTEYMBYGA1UEAwwPMTkyLjE2OC4x\r\n"
"MTEuMTAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxY05JdapYr6B\r\n"
"ohID4gFxh5ANvqGtTqTdfmeZSQIPzA3b6kTHF+HbMw0FGaKCd2Minah4IlWHq5mE\r\n"
"9jpggj3UxqEcdmCDzBV2bbj+ZA8XdtB7oqeb+6Bt+Gqxi83RDEQpDI/nwwWrGahu\r\n"
"6YXF+PXlJQC3YasW/JrQDJY9VMf1nyGf3FN5TJQ4HJ6eHWsXhwNUCSwE6e4ol+V6\r\n"
"GO2coFukOmQDQ2KgK7MYMKF9YTbusvaSIx1AbmJCfszoudUolbnlVIYIh98g2z7X\r\n"
"p1ki0Vtr0UnrK3qBYVlPXWq+d4hbtgL9rNoR4mSrp9k4QvdChwkZ4szblwkMZ7Xf\r\n"
"wB2qBYO2LwIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQAl0ui4I0cCtZ9q1el7ACS4\r\n"
"y9ph8aD0WsosQlHl6sjIQOMIU0dH9xSyELaST7UzGauOXx4sWnxWb6NhtB1huC0l\r\n"
"eRZgHqnHMqioxDTb2LPB1rA/B4ntzVkOBzoi44xuL3LFhQap8UMm+1oYJi+WSGsF\r\n"
"3qwIkju1VmL6b85P6xKBoC8N9jLKGVVUFBZ0gCUT+vCsb8fcoiQWqAGXkrz1RWEp\r\n"
"9CEFH1AQYHiRlZOb0lIPizI5Zo29GsPWbj0yai4/vI+q7uYs67Q3Yjd6V8tSu8AC\r\n"
"npskXlMqLl76F1SkD4SEBj57eB40Llm7WSfXPx182naZdHzsKpFzDkjod6MlCWCS\r\n"
"-----END CERTIFICATE-----\r\n";
/* use for two-phase verification */
static const char websockets_client_key[] =
"-----BEGIN RSA PRIVATE KEY-----\r\n"
"MIIEpAIBAAKCAQEAxY05JdapYr6BohID4gFxh5ANvqGtTqTdfmeZSQIPzA3b6kTH\r\n"
"F+HbMw0FGaKCd2Minah4IlWHq5mE9jpggj3UxqEcdmCDzBV2bbj+ZA8XdtB7oqeb\r\n"
"+6Bt+Gqxi83RDEQpDI/nwwWrGahu6YXF+PXlJQC3YasW/JrQDJY9VMf1nyGf3FN5\r\n"
"TJQ4HJ6eHWsXhwNUCSwE6e4ol+V6GO2coFukOmQDQ2KgK7MYMKF9YTbusvaSIx1A\r\n"
"bmJCfszoudUolbnlVIYIh98g2z7Xp1ki0Vtr0UnrK3qBYVlPXWq+d4hbtgL9rNoR\r\n"
"4mSrp9k4QvdChwkZ4szblwkMZ7XfwB2qBYO2LwIDAQABAoIBAQCtbkjwdh7oqHTo\r\n"
"EsbD4B6KM6ZNaGTcuRIWyd6hYKT7sGMTrOPYjJjCnbiPg8LkCu012dP12H6t4K4A\r\n"
"+MkHLj8hTgnNxveN8H2y4Ai9UR55WZhg+KKQ6owA3bIXGU5gZWpgM+n0pYJLmTod\r\n"
"2yotYbqUnKdhoDEi/MqPckpPpuh0lSVXOGBf88Cl1A3WGqhPn/fvMAGAMEuayCU9\r\n"
"NxsK9K05OBox9+CuJX9Gfhx0vcC4cB0HQfLzpAOe5j6W/FhYb39sZCalNSx/9sKt\r\n"
"uxTGiiQrmPJ9mGtY6x0ksPvmZGIKmh6YdNIZ+MQlE5iDf1mYr4SuzuLBpuU6rDEI\r\n"
"1zKV6Ih5AoGBAPL5cNV9QZNSGg/bS5hBzKnyOdubSg0nkFXPA2lqfz2uwQ9c0DYl\r\n"
"5TF2JExGy7YpUWiJCuXjmcNO6ck5QTo8K3M17zikcthOxEtM0cZDHnSWcWLz+EiO\r\n"
"XiK9VMyJZqb2ZivEHPyzjxffE6rvPVN/vYMaKt5Mdw6Jzh8cGPzZjIqFAoGBANAk\r\n"
"Z6rXzrEwbNv9YGiXFj9gnbLTcfVLDlropL9Hf/dxWP8PQxBeyvZ3XfvFxpWI/MU5\r\n"
"hdj3c+AvkB//5AUcHU0K5vE8Sv+M2e7bsFxyMYuVybXlpvqwt9zOpzw5x7xlreRE\r\n"
"/xVpKbUO3YKCjrqeOsJtVOeEhYwK4hAcygD/y44jAoGAAKYX3goSlcEfXrF4NzTd\r\n"
"xgpmiyaUAQr9AK2n1a06H8EKtO7Lg4mAXixxll6OBrN/iybqh4ifDX11dFsZyH0G\r\n"
"pK0dMWqG//rd3VGcMcpWF3ubW+dI33C54Z/dzRoE0ydPSIiihy43kJnA5LD02fc6\r\n"
"W1JDkQplOv21NjIOAwbVsD0CgYBeG0efz8kNBecCI/I197HAX++NDdrlW9UWtz7d\r\n"
"mPc7qkzhrUXWHfXIL7oXfplFvNUEWviwW1lR0E9qmGjBArAgyEAYa/lAx681NrDr\r\n"
"a1oJUWUMz9OKXuISfIDSUxGClbpkjemDBbQsv5bZTiw4JhhNFd+geaNj6PvC6zFN\r\n"
"+FlRXwKBgQDBWxw6FPL/q+AP+B+RNde9pueVHQFx0hZM57K7jjddoVOTo1f98TM/\r\n"
"51b2QXR65Rl08c4tkvDqtf3jT3LeRsvgazfXNyDTp0C2BQ+ocXhyvQ2Har8z+ujs\r\n"
"0h9L+vHw1lUzfFrda7igD2XZDvJEgOlTQ4FQRcTxRSu7A5QSi8WQOg==\r\n"
"-----END RSA PRIVATE KEY-----\r\n";
static const char websockets_server_cert[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIC6DCCAdACFFk4HVa42niSzTZbbPwh49UZW3rGMA0GCSqGSIb3DQEBBQUAMDIx\r\n"
"MDAuBgNVBAoMJ1RMUyBQcm9qZWN0IERvZGd5IENlcnRpZmljYXRlIEF1dGhvcml0\r\n"
"eTAeFw0xOTA3MTUwNjMzMzhaFw0zMzAzMjMwNjMzMzhaMC8xFDASBgNVBAoMC1RM\r\n"
"UyBQcm9qZWN0MRcwFQYDVQQDDA4xOTIuMTY4LjUxLjEwMDCCASIwDQYJKoZIhvcN\r\n"
"AQEBBQADggEPADCCAQoCggEBANdysGO5RWrQnzmBQbA7GfopxWXrdtNGMqOp4410\r\n"
"jGVyAd8r5Md8JVK2uUBAZrOEiiFj8LcSaR1T5oPnE5pOEWCxD3wziGNJCjEAeeQx\r\n"
"MASL5Ua2YUk5164qiUqOJcNIJHMXfQ+5BDCIfDCRAqAdJBHFcw6r0c+HKd9FTWMU\r\n"
"JyFHrAemcfCJFbZqPSFej/oYesqV06bP1ox30X31qM1hLn0olUnIEkFAU2p4jL7u\r\n"
"rJfWT3GgEpwjp0FXq8ByMg7ib/zzh8A/JruboHk4wj5uFhbsdDluCXD25AjCtJDI\r\n"
"N/DnnmHMFcvM/KVP0t98iNkOPy50vrErMEKTefA/WqGYpecCAwEAATANBgkqhkiG\r\n"
"9w0BAQUFAAOCAQEAJiGCUmrBTc0GnxIM3VmZEKK64uUHyhndLE1lSDO/gAi6S7Di\r\n"
"5Sh2Q7OQ9d8h/vV8B31BeYZKA0tLSRYWznbYtvGVszVnCJpQ1rBnq+Wk670F/4iM\r\n"
"Nihae7FHHAZ3tHUhL5NPMjK/m+0fp19KvNYIEBecm/E7Am06nCzKV7rDgLPMmWNC\r\n"
"CW07/ViXCQSYUOQoSijaxcjxzD+mCCf38vD0qQ3XR2un/+Ny9tZwzqj6VcaDSvy+\r\n"
"JVaFJFwMIe0P+hHbOTSrpaJ8C0H+Tem72UNRImwe5KX6SP+VFlOQV31HFj3G5rKb\r\n"
"zT81oxV8CdSZSxbsWWXDtiaCEGr6ioq78t7Kqw==\r\n"
"-----END CERTIFICATE-----\r\n";
static const char websockets_server_key[] =
"-----BEGIN RSA PRIVATE KEY-----\r\n"
"MIIEpAIBAAKCAQEA13KwY7lFatCfOYFBsDsZ+inFZet200Yyo6njjXSMZXIB3yvk\r\n"
"x3wlUra5QEBms4SKIWPwtxJpHVPmg+cTmk4RYLEPfDOIY0kKMQB55DEwBIvlRrZh\r\n"
"STnXriqJSo4lw0gkcxd9D7kEMIh8MJECoB0kEcVzDqvRz4cp30VNYxQnIUesB6Zx\r\n"
"8IkVtmo9IV6P+hh6ypXTps/WjHfRffWozWEufSiVScgSQUBTaniMvu6sl9ZPcaAS\r\n"
"nCOnQVerwHIyDuJv/POHwD8mu5ugeTjCPm4WFux0OW4JcPbkCMK0kMg38OeeYcwV\r\n"
"y8z8pU/S33yI2Q4/LnS+sSswQpN58D9aoZil5wIDAQABAoIBAFOr6u0PyvHMy8md\r\n"
"dVFn4pLRHiSS6bbrkEcXd5Q8KzpKqIdvmI4QnL4e0JsvZ7NYSfzlv1qZ/9CwANpB\r\n"
"J8/Jed4/ZXAq41EL0LVvJeeFYsyhOA3aTrYNjMHLKz6VLf1FS0KXYK52gDYJC5Ig\r\n"
"/xAHwTZVpHWSLQ2XxJ89XuyXqwq1AKJ3dLK8RdDAeIbaZ50cR4OfLUU04uuBJ6zC\r\n"
"QKpfiDjf0BM4VGLJZP1uMTvfHFZhUU8b/FQjaHZ7My1EBSffpCnVy0edJnkxKn3E\r\n"
"xs++0nb7xjDhUrp9CkTTfMxrvRmUWSni09P1SCD26TUnBXqjQ9QX3DewAGKLOJaT\r\n"
"JbeMDOECgYEA7MPT6d6f2iBOr3qdx9VREQsbljXtGSCxlwWnfCS5nrC93csXZ95e\r\n"
"5NDd4S9hf328FTYszT7Z+HjJvL8az1owT8IFhLDwa62N1c0rlcwuLNGkzX5WsxgF\r\n"
"5Hzn38u3nUzOVV7ltFeVeMrVobrXf8p5IegAiARjzi/JWnyHlSRWxlsCgYEA6POE\r\n"
"aIFtEcY+OJD1LhkShWOE2jk46rgN+KufbhIaKIRwvftoNev5sczeZSII7fZHXx8I\r\n"
"dYWF56c+x4hKH+u52aW6Qvmod/aur11ncyE0bDWlqb3fQcpcAmJRLdh95pY+g1N8\r\n"
"ZAqDwUQY99nuMSb0uPELFSpsS7f9EOj1UwpqbGUCgYAFsnyh7wp3rDlYfaHYUii+\r\n"
"OT8zsR6AcUn0sV0jXprc17Hp6V4p0K8F4ITGS2aUM8lX1VLkqXODSBzKnuqdPLVW\r\n"
"5ftOAxf171ovX92BoEUoLO9DRpv9eUGDCwJlXziO329DnKH4YfclzfOwDZfr6kpZ\r\n"
"54RDwZ9JMdstgzub+iDgawKBgQCusWfbYyvjB3LDwtlK75x3EZGggQcQ5mP71uBh\r\n"
"kAuz1NYjcrTMsyD2WDdzShm+MlGFoOUcFLy9YytuQOOtmn4uHN1Yupa/F+waMIaS\r\n"
"zRTeDUEl0PDrCpEDbK2KHu8TjBpnK6V99HCn76R1wiWhEKC3THRONBkwk1KhasIG\r\n"
"uyniDQKBgQDFL9bjpQFUoJLn07Cs5gkdDSupScohz1RNjTGKq+6cT7ARL3yh+kyU\r\n"
"lE6MWCw9iONopE6I+hShP2+s+t6DqyTgnrVK1l7EWyE59Ei4g9QLYMLcOaKayyum\r\n"
"3zcjhbjyyfgmnsDSi9hFpjIaNw9pZKmyLrSHnsQzd1HEqeGuaRJ8KQ==\r\n"
"-----END RSA PRIVATE KEY-----\r\n";
#define CMD_NOPOLL_MSG_EXIT (0)
#define CMD_NOPOLL_MSG_OPEN (1)
#define CMD_NOPOLL_MSG_SEND (2)
#define CMD_NOPOLL_MSG_RECV (3)
#define CMD_NOPOLL_MSG_CLOSE (4)
struct cmd_nopoll_open_data {
uint32_t tls;
uint32_t verify;
uint32_t cer;
};
struct cmd_nopoll_send_data {
uint8_t *buf;
uint32_t size;
};
struct cmd_nopoll_msg {
uint32_t type;
void *data;
};
#define CMD_NOPOLL_QUEUE_WAIT_TIME (5000)
#define CMD_NOPOLL_THREAD_STACK_SIZE (4 * 1024)
static OS_Thread_t g_nopoll_server_thread;
static OS_Thread_t g_nopoll_client_thread;
static char g_server_host[32] = {0};
static char g_server_port[8] = {0};
static noPollCtx *g_server_ctx = NULL;
static noPollConn *g_listener = NULL;
static noPollConnOpts *g_listener_opts = NULL;
static OS_Queue_t g_client_queue;
static char g_client_host[32] = {0};
static char g_client_port[8] = {0};
static noPollCtx *g_client_ctx = NULL;
static noPollConn *g_conn = NULL;
static noPollConnOpts *g_conn_opts = NULL;
static int ag_nopoll_complete_pending_write(noPollConn *conn)
{
int tries = 0;
while (tries < 5 && errno == NOPOLL_EWOULDBLOCK && nopoll_conn_pending_write_bytes (conn) > 0) {
nopoll_sleep(50000);
if (nopoll_conn_complete_pending_write (conn) == 0)
return 0;
tries++;
}
return 1;
}
static void cmd_nopoll_server_task(void *arg)
{
nopoll_loop_wait(g_server_ctx, 0);
CMD_DBG("%s() end\n", __func__);
OS_ThreadDelete(&g_nopoll_server_thread);
}
static void cmd_nopoll_server_on_close(noPollCtx *ctx, noPollConn *conn, noPollPtr user_data)
{
CMD_LOG(1, "called connection close\n");
}
static nopoll_bool cmd_nopoll_server_on_open(noPollCtx *ctx, noPollConn *conn, noPollPtr user_data)
{
CMD_LOG(1, "called connection open\n");
nopoll_conn_set_on_close(conn, cmd_nopoll_server_on_close, NULL);
if (!nopoll_conn_set_sock_block(nopoll_conn_socket(conn), nopoll_false)) {
CMD_ERR("ERROR: failed to configure non-blocking state to connection..\n");
return nopoll_false;
}
return nopoll_true;
}
static void cmd_nopoll_server_on_message(noPollCtx *ctx, noPollConn *conn, noPollMsg *msg, noPollPtr user_data)
{
int ret;
int size = nopoll_msg_get_payload_size(msg);
const char *content = (const char *)nopoll_msg_get_payload(msg);
CMD_LOG(1, "server receive message:\n");
CMD_LOG(1, "%s\n", content);
ret = nopoll_conn_send_text(conn, content, size);
if (ret != size) {
if (ag_nopoll_complete_pending_write(conn))
CMD_ERR("size = %u, but nopoll_conn_send_text ret = %d\n", size, ret);
}
if (nopoll_cmp(content, "nopoll test stop running")) {
nopoll_loop_stop(g_server_ctx);
}
}
static enum cmd_status cmd_nopoll_server_init_exec(char *cmd)
{
int cnt;
uint32_t dbg;
cnt = cmd_sscanf(cmd, "d=%u", &dbg);
if (cnt != 1) {
CMD_ERR("cmd_sscanf return: cnt = %d\n", cnt);
return CMD_STATUS_INVALID_ARG;
}
if (g_server_ctx != NULL) {
CMD_ERR("already init\n");
return CMD_STATUS_FAIL;
}
g_server_ctx = nopoll_ctx_new();
if (g_server_ctx == NULL) {
CMD_ERR("nopoll_ctx_new failed\n");
return CMD_STATUS_FAIL;
}
if (dbg == 0)
nopoll_log_enable(g_server_ctx, nopoll_false);
else
nopoll_log_enable(g_server_ctx, nopoll_true);
/* set on open */
nopoll_ctx_set_on_open(g_server_ctx, cmd_nopoll_server_on_open, NULL);
/* set on message received */
nopoll_ctx_set_on_msg(g_server_ctx, cmd_nopoll_server_on_message, NULL);
OS_ThreadSetInvalid(&g_nopoll_server_thread);
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_server_open_exec(char *cmd)
{
int cnt;
uint32_t tls;
uint32_t verify;
cnt = cmd_sscanf(cmd, "h=%s p=%s t=%u v=%u", g_server_host, g_server_port, &tls, &verify);
if (cnt != 4) {
CMD_ERR("cmd_sscanf return: cnt = %d\n", cnt);
return CMD_STATUS_INVALID_ARG;
}
if (g_server_ctx == NULL) {
CMD_ERR("without init\n");
return CMD_STATUS_FAIL;
}
if ((g_listener != NULL) || (g_listener_opts != NULL)) {
CMD_ERR("already open\n");
return CMD_STATUS_FAIL;
}
g_listener_opts = nopoll_conn_opts_new();
if (g_listener_opts == NULL) {
CMD_ERR("nopoll_conn_opts_new failed\n");
return CMD_STATUS_FAIL;
}
if (tls == 0)
g_listener = nopoll_listener_new_opts(g_server_ctx, g_listener_opts, g_server_host, g_server_port);
else {
if (!nopoll_conn_opts_set_ssl_certs(g_listener_opts,
websockets_server_cert, sizeof(websockets_server_cert),
websockets_server_key, sizeof(websockets_server_key),
websockets_ca_cert, sizeof(websockets_ca_cert),
websockets_ca_cert, sizeof(websockets_ca_cert))) {
CMD_ERR("nopoll_conn_opts_set_ssl_certs failed\n");
nopoll_conn_opts_free(g_listener_opts);
g_listener_opts = NULL;
return CMD_STATUS_FAIL;
}
if (verify == 0)
nopoll_conn_opts_ssl_peer_verify (g_listener_opts, nopoll_false);
else
nopoll_conn_opts_ssl_peer_verify (g_listener_opts, nopoll_true);
g_listener = nopoll_listener_tls_new_opts(g_server_ctx, g_listener_opts, g_server_host, g_server_port);
}
if (g_listener == NULL) {
CMD_ERR("nopoll_listener(_tls)_new_opts failed\n");
nopoll_conn_opts_free(g_listener_opts);
g_listener_opts = NULL;
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_server_start_exec(char *cmd)
{
if ((g_listener == NULL) || (g_listener_opts == NULL)) {
CMD_ERR("without open\n");
return CMD_STATUS_FAIL;
}
if (OS_ThreadIsValid(&g_nopoll_server_thread)) {
CMD_ERR("already start\n");
return CMD_STATUS_FAIL;
}
if (OS_ThreadCreate(&g_nopoll_server_thread,
"cmd_nopoll_serv",
cmd_nopoll_server_task,
NULL,
OS_THREAD_PRIO_CONSOLE,
CMD_NOPOLL_THREAD_STACK_SIZE) != OS_OK) {
CMD_ERR("thread create failed\n");
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_server_stop_exec(char *cmd)
{
if (!OS_ThreadIsValid(&g_nopoll_server_thread)) {
CMD_ERR("without start\n");
return CMD_STATUS_FAIL;
}
nopoll_loop_stop(g_server_ctx);
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_server_close_exec(char *cmd)
{
if ((g_listener == NULL) || (g_listener_opts == NULL)) {
CMD_ERR("without open\n");
return CMD_STATUS_FAIL;
}
if (OS_ThreadIsValid(&g_nopoll_server_thread)) {
CMD_ERR("without stop\n");
return CMD_STATUS_FAIL;
}
nopoll_conn_close(g_listener);
g_listener = NULL;
g_listener_opts = NULL;
cmd_memset(g_server_host, 0, sizeof(g_server_host));
cmd_memset(g_server_port, 0, sizeof(g_server_port));
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_server_deinit_exec(char *cmd)
{
if (g_server_ctx == NULL) {
CMD_ERR("without init\n");
return CMD_STATUS_FAIL;
}
nopoll_ctx_unref(g_server_ctx);
nopoll_cleanup_library();
g_server_ctx = NULL;
return CMD_STATUS_OK;
}
static void cmd_nopoll_client_open_task(struct cmd_nopoll_open_data *data)
{
g_conn_opts = nopoll_conn_opts_new();
if (g_conn_opts == NULL) {
CMD_ERR("nopoll_conn_opts_new failed\n");
goto open_task_exit;
}
if (data->tls == 0)
g_conn = nopoll_conn_new_opts(g_client_ctx, g_conn_opts, g_client_host, g_client_port, NULL, NULL, NULL, NULL);
else {
if (data->cer != 0) {
if (!nopoll_conn_opts_set_ssl_certs(g_conn_opts,
websockets_client_cert, sizeof(websockets_client_cert),
websockets_client_key, sizeof(websockets_client_key),
NULL, 0,
websockets_ca_cert, sizeof(websockets_ca_cert))) {
CMD_ERR("nopoll_conn_opts_set_ssl_certs failed\n");
nopoll_conn_opts_free(g_conn_opts);
g_conn_opts = NULL;
goto open_task_exit;
}
}
if (data->verify == 0)
nopoll_conn_opts_ssl_peer_verify (g_conn_opts, nopoll_false);
else
nopoll_conn_opts_ssl_peer_verify (g_conn_opts, nopoll_true);
g_conn = nopoll_conn_tls_new(g_client_ctx, g_conn_opts, g_client_host, g_client_port, NULL, NULL, NULL, NULL);
}
if (g_conn == NULL) {
CMD_ERR("nopoll_conn(_tls)_new(_opts) failed\n");
goto open_task_exit;
}
if (nopoll_conn_wait_until_connection_ready(g_conn, 10))
CMD_LOG(1, "the connection is ready\n");
else
CMD_ERR("connection timeout\n");
open_task_exit:
cmd_free(data);
data = NULL;
return;
}
static void cmd_nopoll_client_send_task(struct cmd_nopoll_send_data *data)
{
int ret = nopoll_conn_send_text(g_conn, (char *)data->buf, data->size);
if (ret != (int)data->size) {
if (ag_nopoll_complete_pending_write(g_conn))
CMD_ERR("size = %u, but nopoll_conn_send_text ret = %d\n", data->size, ret);
}
cmd_free(data->buf);
data->buf = NULL;
cmd_free(data);
data = NULL;
return;
}
static void cmd_nopoll_client_recv_task(void *data)
{
uint32_t msec = 10 * 1000;
noPollMsg *msg;
const char *content;
while (1) {
if (!nopoll_conn_is_ok(g_conn)) {
CMD_DBG("received websocket connection close\n");
break;
}
msg = nopoll_conn_get_msg(g_conn);
if (msg) {
content = (const char *)nopoll_msg_get_payload(msg);
CMD_LOG(1, "receive message:\n");
CMD_LOG(1, "%s\n", content);
nopoll_msg_unref (msg);
} else {
if (msec == 0) {
CMD_ERR("get message timeout\n");
break;
}
nopoll_sleep(100000);
msec -= 100;
}
}
}
static void cmd_nopoll_client_close_task(void *data)
{
nopoll_conn_close(g_conn);
g_conn = NULL;
g_conn_opts = NULL;
cmd_memset(g_client_host, 0, sizeof(g_client_host));
cmd_memset(g_client_port, 0, sizeof(g_client_port));
return;
}
static void cmd_nopoll_client_task(void *arg)
{
uint8_t task_exit = 0;
struct cmd_nopoll_msg *msg;
while (task_exit == 0) {
if (OS_MsgQueueReceive(&g_client_queue, (void **)&msg, OS_WAIT_FOREVER) != OS_OK) {
CMD_ERR("msg queue receive failed\n");
break;
}
// CMD_DBG("recv msg type %u\n", msg->type);
switch (msg->type) {
case CMD_NOPOLL_MSG_EXIT:
task_exit = 1;
break;
case CMD_NOPOLL_MSG_OPEN:
cmd_nopoll_client_open_task(msg->data);
break;
case CMD_NOPOLL_MSG_SEND:
cmd_nopoll_client_send_task(msg->data);
break;
case CMD_NOPOLL_MSG_RECV:
cmd_nopoll_client_recv_task(msg->data);
break;
case CMD_NOPOLL_MSG_CLOSE:
cmd_nopoll_client_close_task(msg->data);
break;
default:
CMD_WRN("unknown msg\n");
break;
}
cmd_free(msg);
msg = NULL;
}
CMD_DBG("%s() end\n", __func__);
OS_ThreadDelete(&g_nopoll_client_thread);
}
static enum cmd_status cmd_nopoll_client_init_exec(char *cmd)
{
int cnt;
uint32_t dbg;
cnt = cmd_sscanf(cmd, "d=%u", &dbg);
if (cnt != 1) {
CMD_ERR("cmd_sscanf return: cnt = %d\n", cnt);
return CMD_STATUS_INVALID_ARG;
}
if (g_client_ctx != NULL) {
CMD_ERR("already init\n");
return CMD_STATUS_FAIL;
}
g_client_ctx = nopoll_ctx_new();
if (g_client_ctx == NULL) {
CMD_ERR("nopoll_ctx_new failed\n");
return CMD_STATUS_FAIL;
}
if (dbg == 0)
nopoll_log_enable(g_client_ctx, nopoll_false);
else
nopoll_log_enable(g_client_ctx, nopoll_true);
OS_ThreadSetInvalid(&g_nopoll_client_thread);
if (OS_MsgQueueCreate(&g_client_queue, 1) != OS_OK) {
CMD_ERR("msg queue create failed\n");
return CMD_STATUS_FAIL;
}
if (OS_ThreadCreate(&g_nopoll_client_thread,
"cmd_nopoll_cli",
cmd_nopoll_client_task,
NULL,
OS_THREAD_PRIO_CONSOLE,
CMD_NOPOLL_THREAD_STACK_SIZE) != OS_OK) {
CMD_ERR("thread create failed\n");
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_client_open_exec(char *cmd)
{
int cnt;
uint32_t tls;
uint32_t verify;
uint32_t cer;
struct cmd_nopoll_open_data *data;
struct cmd_nopoll_msg *msg;
cnt = cmd_sscanf(cmd, "h=%s p=%s t=%u v=%u c=%u", g_client_host, g_client_port, &tls, &verify, &cer);
if (cnt != 5) {
CMD_ERR("cmd_sscanf return: cnt = %d\n", cnt);
return CMD_STATUS_INVALID_ARG;
}
if (g_client_ctx == NULL) {
CMD_ERR("without init\n");
return CMD_STATUS_FAIL;
}
if ((g_conn != NULL) || (g_conn_opts != NULL)) {
CMD_ERR("already open\n");
return CMD_STATUS_FAIL;
}
msg = cmd_malloc(sizeof(struct cmd_nopoll_msg));
data = cmd_malloc(sizeof(struct cmd_nopoll_open_data));
if ((msg == NULL) || (data == NULL)) {
CMD_ERR("malloc failed\n");
if (msg)
cmd_free(msg);
if (data)
cmd_free(data);
return CMD_STATUS_FAIL;
}
data->tls = tls;
data->verify = verify;
data->cer = cer;
msg->type = CMD_NOPOLL_MSG_OPEN;
msg->data = data;
if (OS_MsgQueueSend(&g_client_queue, msg, CMD_NOPOLL_QUEUE_WAIT_TIME) != OS_OK) {
CMD_ERR("msg queue send failed\n");
if (msg)
cmd_free(msg);
if (data)
cmd_free(data);
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_client_send_exec(char *cmd)
{
int cnt;
int ret;
uint32_t size;
uint8_t *buf;
struct cmd_nopoll_send_data *data;
struct cmd_nopoll_msg *msg;
cnt = cmd_sscanf(cmd, "s=%u", &size);
if (cnt != 1) {
CMD_ERR("cmd_sscanf return: cnt = %d\n", cnt);
return CMD_STATUS_INVALID_ARG;
}
if (size == 0) {
CMD_ERR("size = 0\n");
return CMD_STATUS_INVALID_ARG;
}
if ((g_conn == NULL) || (g_conn_opts == NULL)) {
CMD_ERR("without open\n");
return CMD_STATUS_FAIL;
}
msg = cmd_malloc(sizeof(struct cmd_nopoll_msg));
data = cmd_malloc(sizeof(struct cmd_nopoll_send_data));
buf = cmd_malloc(size);
if ((msg == NULL) || (data == NULL) || (buf == NULL)) {
CMD_ERR("malloc failed\n");
if (msg)
cmd_free(msg);
if (data)
cmd_free(data);
if (buf)
cmd_free(buf);
return CMD_STATUS_FAIL;
}
cmd_write_respond(CMD_STATUS_OK, "OK");
cmd_raw_mode_enable();
ret = cmd_raw_mode_read(buf, size, 10000);
if (ret != (int)size) {
CMD_ERR("size = %u, but cmd_raw_mode_read ret = %d\n", size, ret);
cmd_free(msg);
cmd_free(data);
cmd_free(buf);
cmd_raw_mode_write((uint8_t *)"FAIL\n", 5);
cmd_raw_mode_disable();
return CMD_STATUS_ACKED;
}
cmd_raw_mode_disable();
data->buf = buf;
data->size = size;
msg->type = CMD_NOPOLL_MSG_SEND;
msg->data = data;
if (OS_MsgQueueSend(&g_client_queue, msg, CMD_NOPOLL_QUEUE_WAIT_TIME) != OS_OK) {
CMD_ERR("msg queue send failed\n");
if (msg)
cmd_free(msg);
if (data)
cmd_free(data);
if (buf)
cmd_free(buf);
return CMD_STATUS_ACKED;
}
return CMD_STATUS_ACKED;
}
static enum cmd_status cmd_nopoll_client_recv_exec(char *cmd)
{
struct cmd_nopoll_msg *msg;
if ((g_conn == NULL) || (g_conn_opts == NULL)) {
CMD_ERR("without open\n");
return CMD_STATUS_FAIL;
}
msg = cmd_malloc(sizeof(struct cmd_nopoll_msg));
if (msg == NULL) {
CMD_ERR("msg queue send failed\n");
return CMD_STATUS_FAIL;
}
msg->type = CMD_NOPOLL_MSG_RECV;
msg->data = NULL;
if (OS_MsgQueueSend(&g_client_queue, msg, CMD_NOPOLL_QUEUE_WAIT_TIME) != OS_OK) {
CMD_ERR("msg queue send failed\n");
if (msg)
cmd_free(msg);
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_client_close_exec(char *cmd)
{
struct cmd_nopoll_msg *msg;
if ((g_conn == NULL) || (g_conn_opts == NULL)) {
CMD_ERR("without open\n");
return CMD_STATUS_FAIL;
}
msg = cmd_malloc(sizeof(struct cmd_nopoll_msg));
if (msg == NULL) {
CMD_ERR("msg queue send failed\n");
return CMD_STATUS_FAIL;
}
msg->type = CMD_NOPOLL_MSG_CLOSE;
msg->data = NULL;
if (OS_MsgQueueSend(&g_client_queue, msg, CMD_NOPOLL_QUEUE_WAIT_TIME) != OS_OK) {
CMD_ERR("msg queue send failed\n");
if (msg)
cmd_free(msg);
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static enum cmd_status cmd_nopoll_client_deinit_exec(char *cmd)
{
struct cmd_nopoll_msg *msg;
if (g_client_ctx == NULL) {
CMD_ERR("without init\n");
return CMD_STATUS_FAIL;
}
nopoll_ctx_unref(g_client_ctx);
g_client_ctx = NULL;
msg = cmd_malloc(sizeof(struct cmd_nopoll_msg));
if (msg == NULL) {
CMD_ERR("msg queue send failed\n");
return CMD_STATUS_FAIL;
}
msg->type = CMD_NOPOLL_MSG_EXIT;
msg->data = NULL;
if (OS_MsgQueueSend(&g_client_queue, msg, CMD_NOPOLL_QUEUE_WAIT_TIME) != OS_OK) {
CMD_ERR("msg queue send failed\n");
if (msg)
cmd_free(msg);
return CMD_STATUS_FAIL;
}
OS_MSleep(100);
if (OS_MsgQueueDelete(&g_client_queue) != OS_OK) {
CMD_ERR("msg queue delete failed\n");
return CMD_STATUS_FAIL;
}
return CMD_STATUS_OK;
}
static const struct cmd_data g_nopoll_server_cmds[] = {
{ "init", cmd_nopoll_server_init_exec },
{ "open", cmd_nopoll_server_open_exec },
{ "start", cmd_nopoll_server_start_exec },
{ "stop", cmd_nopoll_server_stop_exec },
{ "close", cmd_nopoll_server_close_exec },
{ "deinit", cmd_nopoll_server_deinit_exec },
};
static const struct cmd_data g_nopoll_client_cmds[] = {
{ "init", cmd_nopoll_client_init_exec },
{ "open", cmd_nopoll_client_open_exec },
{ "send", cmd_nopoll_client_send_exec },
{ "recv", cmd_nopoll_client_recv_exec },
{ "close", cmd_nopoll_client_close_exec },
{ "deinit", cmd_nopoll_client_deinit_exec },
};
static enum cmd_status cmd_nopoll_server_exec(char *cmd)
{
return cmd_exec(cmd, g_nopoll_server_cmds, cmd_nitems(g_nopoll_server_cmds));
}
static enum cmd_status cmd_nopoll_client_exec(char *cmd)
{
return cmd_exec(cmd, g_nopoll_client_cmds, cmd_nitems(g_nopoll_client_cmds));
}
static const struct cmd_data g_nopoll_cmds[] = {
{ "srv", cmd_nopoll_server_exec },
{ "cli", cmd_nopoll_client_exec },
};
enum cmd_status cmd_nopoll_exec(char *cmd)
{
return cmd_exec(cmd, g_nopoll_cmds, cmd_nitems(g_nopoll_cmds));
}
#endif /* PRJCONF_NET_EN */
|
the_stack_data/140766538.c | typedef __builtin_va_list va_list;
typedef struct {
va_list ap;
} ScanfState;
void
GetInt(ScanfState *state, long llval)
{
*__builtin_va_arg(state->ap,long *) = llval;
__builtin_va_end(state->ap);
}
|
the_stack_data/159514791.c | /*
@@@@ PROGRAM NAME: knkcch16e18.c
@@@@ FLAGS: -std=c99
@@@@ PROGRAM STATEMENT:
(a) Each square of a chessboard can hold one piece—a pawn, knight, bishop, rook, queen,
or king—or it may be empty. Each piece is either black or white. Define two enumerated
types: Piece, which has seven possible values (one of which is “empty’), and Color,
which has two.
(b) Using the types from part (a), define a structure type named Square that can store both
the type of a piece and its color.
(c) Using the Square type from part (b), declare an 8 x 8 array named board that can
store the entire contents of a chessboard.
(d) Add an initializer to the declaration in part (c) so that board's initial value
corresponds to the usual arrangement of pieces at the start of a chess game. A square
that’s not occupied by a piece should have an “empty” piece value and the color black.
*/
#include<stdio.h>
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
enum piece {empty, pawn, knight, bishop, rook, queen, king};
enum color {black, white};
//---------------------------------------------------------------------------
struct square
{
enum piece p;
enum color c;
};
//---------------------------------------------------------------------------
struct square board[8][8] =
{
{{rook, black},{knight, black},{bishop, black},{queen, black},{king, black},{bishop, black},{knight, black},{rook, black}},
{{pawn, black},{pawn, black},{pawn, black},{pawn, black},{pawn, black},{pawn, black},{pawn, black},{pawn, black}},
{{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black}},
{{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black}},
{{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black}},
{{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black},{empty, black}},
{{pawn, white},{pawn, white},{pawn, white},{pawn, white},{pawn, white},{pawn, white},{pawn, white},{pawn, white}},
{{rook, white},{knight, white},{bishop, white},{king, white},{queen, white},{bishop, white},{knight, white},{rook, white}}
};
//------------------------START OF MAIN()--------------------------------------
int main(void)
{
printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
printf("File: %s (Date: %s, Time: %s)\n", __FILE__, __DATE__, __TIME__);
printf("\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
return 0;
}
//-------------------------END OF MAIN()---------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
/*
OUTPUT:
@@@@ Trial1:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
File: knkcch16e18.c (Date: Mar 13 2021, Time: 16:02:27)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@@@ Trial2:
@@@@ Trial3:
@@@@ Trial4:
@@@@ Trial5:
@@@@ Trial6:
@@@@ Trial7:
@@@@ Trial8:
@@@@ Trial9:
*/
//--------------------------------------------------------------------------- |
the_stack_data/48574652.c | /*
Ben Ziemann
Hw 2.5
Implementation of Bigint
Example code for Exercises in C.
This program shows a way to represent a BigInt type (arbitrary length integers)
using C strings, with numbers represented as a string of decimal digits in reverse order.
Follow these steps to get this program working:
1) Read through the whole program so you understand the design.
2) Compile and run the program. It should run three tests, and they should fail.
3) Fill in the body of reverse_string(). When you get it working, the first test should pass.
4) Fill in the body of itoc(). When you get it working, the second test should pass.
5) Fill in the body of add_digits(). When you get it working, the third test should pass.
6) Uncomment the last test in main. If your three previous tests pass, this one should, too.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
/* reverse_string: Returns a new string with the characters reversed.
It is the caller's responsibility to free the result.
s: string
returns: string
*/
char *reverse_string(char *s) {
int len;
len = strlen(s);
int i;
int j;
i = 0;
char *rev =(char *)malloc(sizeof(char)*len);
//Use moving indexes to reverse string
for(j=len-1; j>=0; j--){
rev[j] = s[i];
i++;
}
return rev;
}
/* ctoi: Converts a character to integer.
c: one of the characters '0' to '9'
returns: integer 0 to 9
*/
int ctoi(char c) {
assert(isdigit(c));
return c - '0';
}
/* itoc: Converts an integer to character.
i: integer 0 to 9
returns: character '0' to '9'
*/
char itoc(int i) {
//Zero acts as the offeset value from the straight ASCII value of i (1=some header) to the ASCII value
//corresponding to the decimal interger (1+0(ASCII value of 48) = 49 (the ASCII value of 1))
char myIntStr = i+'0';
return myIntStr;
}
/* add_digits: Adds two decimal digits, returns the total and carry.
For example, if a='5', b='6', and c='1', the sum is 12, so
the output value of total should be '2' and carry should be '1'
a: character '0' to '9'
b: character '0' to '9'
c: character '0' to '9'
total: pointer to char
carry: pointer to char
*/
void add_digits(char a, char b, char c, char *total, char *carry) {
//Convert char to int for each to be summed
int i1 = ctoi(a);
int i2 = ctoi(b);
int i3 = ctoi(c);
int sum = i1+i2+i3;
//Carry over needed
if(sum>=10){
sum -= 10;
*total = itoc(sum);
*carry = '1';
return;
}
//Carry over not needed
*total = itoc(sum);
*carry = '0';
}
/* Define a type to represent a BigInt.
Internally, a BigInt is a string of digits, with the digits in
reverse order.
*/
typedef char * BigInt;
/* add_bigint: Adds two BigInts
Stores the result in z.
x: BigInt
y: BigInt
carry_in: char
z: empty buffer
*/
void add_bigint(BigInt x, BigInt y, char carry_in, BigInt z) {
char total, carry_out;
int dx=1, dy=1, dz=1;
char a, b;
/* OPTIONAL TODO: Modify this function to allocate and return z
* rather than taking an empty buffer as a parameter.
* Hint: you might need a helper function.
*/
if (*x == '\0') {
a = '0';
dx = 0;
}else{
a = *x;
}
if (*y == '\0') {
b = '0';
dy = 0;
}else{
b = *y;
}
// printf("%c %c %c\n", a, b, carry_in);
add_digits(a, b, carry_in, &total, &carry_out);
// printf("%c %c\n", carry_out, total);
// if total and carry are 0, we're done
if (total == '0' && carry_out == '0') {
*z = '\0';
return;
}
// otherwise store the digit we just computed
*z = total;
// and make a recursive call to fill in the rest.
add_bigint(x+dx, y+dy, carry_out, z+dz);
}
/* print_bigint: Prints the digits of BigInt in the normal order.
big: BigInt
*/
void print_bigint(BigInt big) {
char c = *big;
if (c == '\0') return;
print_bigint(big+1);
printf("%c", c);
}
/* make_bigint: Creates and returns a BigInt.
Caller is responsible for freeing.
s: string of digits in the usual order
returns: BigInt
*/
BigInt make_bigint(char *s) {
char *r = reverse_string(s);
return (BigInt) r;
}
void test_reverse_string() {
char *s = "123";
char *t = reverse_string(s);
if (strcmp(t, "321") == 0) {
printf("reverse_string passed\n");
} else {
printf("reverse_string failed\n");
}
}
void test_itoc() {
char c = itoc(3);
if (c == '3') {
printf("itoc passed\n");
} else {
printf("itoc failed\n");
}
}
void test_add_digits() {
char total, carry;
add_digits('7', '4', '1', &total, &carry);
if (total == '2' && carry == '1') {
printf("add_digits passed\n");
} else {
printf("add_digits failed\n");
}
}
void test_add_bigint() {
char *s = "1";
char *t = "99999999999999999999999999999999999999999999";
char *res = "000000000000000000000000000000000000000000001";
BigInt big1 = make_bigint(s);
BigInt big2 = make_bigint(t);
BigInt big3 = malloc(100);
add_bigint(big1, big2, '0', big3);
if (strcmp(big3, res) == 0) {
printf("add_bigint passed\n");
} else {
printf("add_bigint failed\n");
}
}
int main (int argc, char *argv[])
{
test_reverse_string();
test_itoc();
test_add_digits();
//TODO: When you have the first three functions working,
// uncomment the following, and it should work.
test_add_bigint();
return 0;
}
|
the_stack_data/90764551.c | /*binary search*/
#include<stdio.h>
int main()
{
int j,i,n,min,key,flag=0;
printf("enter the value of n");
scanf("%d",&n);
int ar[n];
printf("enter elements of the array");
for(i=0;i<=n-1;i++)
scanf("%d",&ar[i]);
for(j=0;j<n;j++)
{
min=ar[j];
for(i=j+1;i<=n-1;i++)
if(min>ar[i])
{ min=ar[i];
ar[i]=ar[j];
ar[j]=min;
}
}
printf("enter the key");
scanf("%d",&key);
if(key>ar[n-1])
goto a;
else if(key<ar[n/2])
for(i=0;i<=n/2;i++)
{
if(key==ar[i])
flag=1;
}
else for(i=n/2;i<n;i++)
if (key==ar[i])
flag=1;
if(flag==1)
printf("found");
else a: printf("not found");
}
|
the_stack_data/104709.c | /*
https://www.musl-libc.org/
http://git.musl-libc.org/cgit/musl/tree/src/math/exp10.c
musl as a whole is licensed under the following standard MIT license:
----------------------------------------------------------------------
Copyright © 2005-2014 Rich Felker, et al.
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.
----------------------------------------------------------------------
Authors/contributors include:
Alex Dowad
Alexander Monakov
Anthony G. Basile
Arvid Picciani
Bobby Bingham
Boris Brezillon
Brent Cook
Chris Spiegel
Clément Vasseur
Daniel Micay
Denys Vlasenko
Emil Renner Berthing
Felix Fietkau
Felix Janda
Gianluca Anzolin
Hauke Mehrtens
Hiltjo Posthuma
Isaac Dunham
Jaydeep Patil
Jens Gustedt
Jeremy Huntwork
Jo-Philipp Wich
Joakim Sindholt
John Spencer
Josiah Worcester
Justin Cormack
Khem Raj
Kylie McClain
Luca Barbato
Luka Perkov
M Farkas-Dyck (Strake)
Mahesh Bodapati
Michael Forney
Natanael Copa
Nicholas J. Kain
orc
Pascal Cuoq
Petr Hosek
Pierre Carrier
Rich Felker
Richard Pennington
Shiz
sin
Solar Designer
Stefan Kristiansson
Szabolcs Nagy
Timo Teräs
Trutz Behn
Valentin Ochs
William Haddon
Portions of this software are derived from third-party works licensed
under terms compatible with the above MIT license:
The TRE regular expression implementation (src/regex/reg* and
src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
under a 2-clause BSD license (license text in the source files). The
included version has been heavily modified by Rich Felker in 2012, in
the interests of size, simplicity, and namespace cleanliness.
Much of the math library code (src/math/ * and src/complex/ *) is
Copyright © 1993,2004 Sun Microsystems or
Copyright © 2003-2011 David Schultz or
Copyright © 2003-2009 Steven G. Kargl or
Copyright © 2003-2009 Bruce D. Evans or
Copyright © 2008 Stephen L. Moshier
and labelled as such in comments in the individual source files. All
have been licensed under extremely permissive terms.
The ARM memcpy code (src/string/arm/memcpy_el.S) is Copyright © 2008
The Android Open Source Project and is licensed under a two-clause BSD
license. It was taken from Bionic libc, used on Android.
The implementation of DES for crypt (src/crypt/crypt_des.c) is
Copyright © 1994 David Burren. It is licensed under a BSD license.
The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
originally written by Solar Designer and placed into the public
domain. The code also comes with a fallback permissive license for use
in jurisdictions that may not recognize the public domain.
The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
Valentin Ochs and is licensed under an MIT-style license.
The BSD PRNG implementation (src/prng/random.c) and XSI search API
(src/search/ *.c) functions are Copyright © 2011 Szabolcs Nagy and
licensed under following terms: "Permission to use, copy, modify,
and/or distribute this code for any purpose with or without fee is
hereby granted. There is no warranty."
The x86_64 port was written by Nicholas J. Kain and is licensed under
the standard MIT terms.
The mips and microblaze ports were originally written by Richard
Pennington for use in the ellcc project. The original code was adapted
by Rich Felker for build system and code conventions during upstream
integration. It is licensed under the standard MIT terms.
The mips64 port was contributed by Imagination Technologies and is
licensed under the standard MIT terms.
The powerpc port was also originally written by Richard Pennington,
and later supplemented and integrated by John Spencer. It is licensed
under the standard MIT terms.
All other files which have no copyright comments are original works
produced specifically for use as part of this library, written either
by Rich Felker, the main author of the library, or by one or more
contibutors listed above. Details on authorship of individual files
can be found in the git version control history of the project. The
omission of copyright and license comments in each file is in the
interest of source tree size.
In addition, permission is hereby granted for all public header files
(include/ * and arch/ * /bits/ *) and crt files intended to be linked into
applications (crt/ *, ldso/dlstart.c, and arch/ * /crt_arch.h) to omit
the copyright notice and permission notice otherwise required by the
license, and to use these files without any requirement of
attribution. These files include substantial contributions from:
Bobby Bingham
John Spencer
Nicholas J. Kain
Rich Felker
Richard Pennington
Stefan Kristiansson
Szabolcs Nagy
all of whom have explicitly granted such permission.
This file previously contained text expressing a belief that most of
the files covered by the above exception were sufficiently trivial not
to be subject to copyright, resulting in confusion over whether it
negated the permissions granted in the license. In the spirit of
permissive licensing, and of not having licensing issues being an
obstacle to adoption, that text has been removed.
*/
#include <math.h>
#include <stdint.h>
double exp10(double x)
{
static const double p10[] = {
1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10,
1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1,
1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1e10, 1e11, 1e12, 1e13, 1e14, 1e15
};
double n, y = modf(x, &n);
union {double f; uint64_t i;} u = {n};
/* fabs(n) < 16 without raising invalid on nan */
if ((u.i>>52 & 0x7ff) < 0x3ff+4) {
if (!y) return p10[(int)n+15];
y = exp2(3.32192809488736234787031942948939 * y);
return y * p10[(int)n+15];
}
return pow(10.0, x);
}
float exp10f(float x)
{
static const float p10[] = {
1e-7f, 1e-6f, 1e-5f, 1e-4f, 1e-3f, 1e-2f, 1e-1f,
1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7
};
float n, y = modff(x, &n);
union {float f; uint32_t i;} u = {n};
/* fabsf(n) < 8 without raising invalid on nan */
if ((u.i>>23 & 0xff) < 0x7f+3) {
if (!y) return p10[(int)n+7];
y = exp2f(3.32192809488736234787031942948939f * y);
return y * p10[(int)n+7];
}
return exp2(3.32192809488736234787031942948939 * x);
}
double pow10(double x)
{
return exp10(x);
}
float pow10f(float x)
{
return exp10f(x);
}
|
the_stack_data/231393519.c |
extern int foo();
extern int baz;
int bar() {
return foo() + baz;
} |
the_stack_data/105481.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
char* cCipher(int, char*, char);
int main () {
char text[] = "Hello World! ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char *encryptedText;
char *decryptedText;
encryptedText = cCipher(1, text, 'e');
decryptedText = cCipher(1, encryptedText, 'd');
printf("Plain text: %s\n", text);
printf("Encrypted text with key 1: %s\n", encryptedText);
printf("Decrypted text: %s\n", decryptedText);
free(encryptedText);
return 0;
}
char* cCipher(int key, char *text, char opt) {
char alphabet[26];
int offset = 65;
int textSize = strlen(text);
int i = 0;
char *outputText = malloc(textSize+1);
char oldCharacter;
char newCharacter;
char upperChar;
if (!outputText)
exit(1);
// if decrypting text
if (opt == 'd')
key = -key;
// create alphabet
for (i = 0; i < 26; i++) {
alphabet[i] = offset + i;
}
// caesar cipher
for (i = 0; i < textSize; i++) {
if (isalpha(text[i])) {
// convert text to uppercase
upperChar = toupper(text[i]);
// gets index of the old character in alphabet array
oldCharacter = upperChar - offset;
// finds shifted index
newCharacter = (oldCharacter + key) % 26;
if (newCharacter < 0)
newCharacter += 26;
// add character to output text
outputText[i] = alphabet[newCharacter];
} else {
// if character isn't in the alphabet, add it
outputText[i] = text[i];
}
}
outputText[textSize] = '\0';
return outputText;
}
|
the_stack_data/231392691.c | /* savestring.c */
/* Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of the GNU Readline Library, a library for
reading lines of text with interactive input and history editing.
The GNU Readline Library 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 1, or
(at your option) any later version.
The GNU Readline 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 General Public License for more details.
The GNU General Public License is often shipped with GNU software, and
is generally kept in a file called COPYING or LICENSE. If you do not
have a copy of the license, write to the Free Software Foundation,
675 Mass Ave, Cambridge, MA 02139, USA. */
extern char *strcpy ();
extern char *xmalloc ();
/* Backwards compatibility, now that savestring has been removed from
all `public' readline header files. */
char *
savestring (s)
char *s;
{
return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s)));
}
|
the_stack_data/176706507.c | /*
-- CXB30060.C
--
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--
-- FUNCTION NAME: CXB30060 ("wchar_gen")
--
-- FUNCTION DESCRIPTION:
-- This C function returns the value of type wchar_t corresponding to the
-- value of its parameter, where
-- Val 0 .. 9 ==> '0' .. '9'
-- Val 10 .. 19 ==> 'A' .. 'J'
-- Val 20 .. 29 ==> 'k' .. 't'
-- Val 30 ==> ' '
-- Val 31 ==> '.'
-- Val 32 ==> ','
--
-- INPUT:
-- This function requires that one int parameter be passed to it.
--
-- OUTPUT:
-- The function will return the appropriate value of type wchar_t.
--
-- CHANGE HISTORY:
-- 13 Sep 99 RLB Created function to replace incorrect
-- Unchecked_Conversion.
--
--!
*/
#include <stddef.h>
wchar_t CXB30060 (int val)
/* NOTE: The above function definition should be accepted by an ANSI-C */
/* compiler. Older C compilers may reject it; they may, however */
/* accept the following two lines. An implementation may comment */
/* out the above function definition and uncomment the following */
/* one. Otherwise, an implementation must provide the necessary */
/* modifications to this C code to satisfy the function */
/* requirements (see Function Description). */
/* */
/* wchar_t CXB30060 (val) */
/* int val; */
/* */
{ wchar_t return_value = ';';
switch (val)
{
case 0:
return_value = '0';
break;
case 1:
return_value = '1';
break;
case 2:
return_value = '2';
break;
case 3:
return_value = '3';
break;
case 4:
return_value = '4';
break;
case 5:
return_value = '5';
break;
case 6:
return_value = '6';
break;
case 7:
return_value = '7';
break;
case 8:
return_value = '8';
break;
case 9:
return_value = '9';
break;
case 10:
return_value = 'A';
break;
case 11:
return_value = 'B';
break;
case 12:
return_value = 'C';
break;
case 13:
return_value = 'D';
break;
case 14:
return_value = 'E';
break;
case 15:
return_value = 'F';
break;
case 16:
return_value = 'G';
break;
case 17:
return_value = 'H';
break;
case 18:
return_value = 'I';
break;
case 19:
return_value = 'J';
break;
case 20:
return_value = 'k';
break;
case 21:
return_value = 'l';
break;
case 22:
return_value = 'm';
break;
case 23:
return_value = 'n';
break;
case 24:
return_value = 'o';
break;
case 25:
return_value = 'p';
break;
case 26:
return_value = 'q';
break;
case 27:
return_value = 'r';
break;
case 28:
return_value = 's';
break;
case 29:
return_value = 't';
break;
case 30:
return_value = ' ';
break;
case 31:
return_value = '.';
break;
case 32:
return_value = ',';
break;
}
return (return_value); /* Return character value */
}
|
the_stack_data/248579902.c | #define thisprog "xe-matrixmod1"
#define TITLE_STRING thisprog" v 21.October.2017 [JRH]"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
<TAGS>signal_processing dt.matrix transform </TAGS>
v 21.October.2017 [JRH]
- update variable naming conventions for ii,jj,kk
v 14.October.2017 [JRH]
- added -pn option to preserve NAN's in plot after smoothing
v 19: 30.September.2016 [JRH]
- major overhaul to reduce memory overhead associated with resampling
- now uses two separate functions to bin and expand matrixes
- binning has no memory overhead
- expansion temporarily increases memory requirements but this is offset by reducing memory first if binning is performed in one dimension
v 19: 08.December.2015 [JRH]
- add ability to flip matrixes in the x- or y-axis
v 18: 10.March.2014 [JRH]
- new output method eliminates extra tab on end of lines
v 17: 11.February.2014 [JRH]
- bugfix: reports memory allocation errors for resampling (resampling function is particularly memory intense)
v 16: 23.September.2013 [JRH]
- bugfix: normalization (1 or 2) now takes into account that the function doing the normalizing expects zero or 1
v 15: 7.May.2013 [JRH]
- add transpose capability (-t)
v 14: 15.April.2013 [JRH]
- Fisher's transform is now a separate step
- option to apply Fisher's transform scaled to correlation values limited to a range of 0-1
- limit of +-3.8 applied to Fisher's transform - this is done in the xf_fisherstransform1_d function
v 13: 6.April.2013 [JRH]
- bugfix in xf_resample2_d
- now allocates sufficient memory for new matrix based on maximum dimension in input or ourput
v 12: 18.March.2013 [JRH]
- bugfix - rotation was not working properly
- use new function xf_resample2_d for resampling the matrix
v 11: 12.March.2013 [JRH]
- add ability to applyFishers-transform to data (to normalize Pearson's correlation coefficients)
v 10: 10.March.2013 [JRH]
- use xf_matrixread1_d to read matrix and assign values to nrows, ncols etc
v 9: 4.March.2013 [JRH]
- use newer smoothing function xf_smoothgauss2_d
- assumes NAN or INF are invalid
- no longer smooths NANs into adjacent bins!
v 7: 15.February.2013 [JRH]
- use new matrixrotate function
- now assumes input files are rectangular matrices (ie. no uneven rows) - an error arises otherwise
- added width and height resampling option
v 6: 19.January.2013 [JRH]
- allow resampling of each line to generate a fixed-width matrix from a variable-width matrix
v 5: 16.December.2012 [JRH]
- now uses function _lineread1 to read lines of unknown length
- also handles initialization and memory allocation for line
- MAXLINELEN definition is unnecessary
v 4: 10.December.2012 [JRH]
- remove unused "invalid value" setting
- initialize maxlinelen to MAXLINELEN at start of program and pre-allocate memory
v 3: 19.November.2012 [JRH]
- change print format of output from %f to %g, to better preserve precision
*/
/* external functions start */
double *xf_matrixread1_d(long *nmatrices, long *ncols, long *nrows, char *message, FILE *fpin);
void xf_norm2_d(double *data,long N,int normtype);
int xf_smoothgauss2_d(double *data,int xbintot,int ybintot,int xsmooth,int ysmooth);
double *xf_matrixrotate1_d(double *data1, long *nx1, long *ny1, int r);
int xf_matrixbin1_d(double *matrix1, long nx1, long ny1, long nx2, long ny2, char *message);
double *xf_matrixexpand1_d(double *matrix1, long nx1, long ny1, long nx2, long ny2, char *nessage);
void xf_fishertransform2_d(double *data, long n, int type);
double *xf_matrixtrans1_d(double *data1, long *width, long *height);
double *xf_matrixflipy_d(double *data1, long nx, long ny);
double *xf_matrixflipx_d(double *data1, long nx, long ny);
/* external functions end */
int main (int argc, char *argv[]) {
/* general variables */
char infile[256],outfile[256],*line=NULL,*templine=NULL,*pline,*pcol,message[256];
long int ii,jj,kk;
int v,w,x,y,z,n=0,col,colmatch,result_i[32];
int sizeofchar=sizeof(char),sizeoflong=sizeof(long),sizeofdouble=sizeof(double);
float a,b,c,d;
double aa,bb,cc,dd;
FILE *fpin,*fpout;
/* program-specific variables */
int bintot=0,count=0;
long N=0,N1=0,nmatrices;
long width1,width2,height1,height2;
double *matrix1=NULL,*matrix2=NULL;
/* arguments */
int setnorm=0,setfishers=0,setxsmooth=0,setysmooth=0,setkeepnans=0,setrotate=0,settrans=0,setflip=0;
long setwidth=0,setheight=0;
/* PRINT INSTRUCTIONS IF THERE IS NO FILENAME SPECIFIED */
if(argc<2) {
fprintf(stderr,"\n");
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"%s\n",TITLE_STRING);
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"Modify a matrix:\n");
fprintf(stderr," flip/rotate/transpose,resample,smooth,Fisher-transform,normalize - in that order\n");
fprintf(stderr,"USAGE:\n");
fprintf(stderr," %s [input] [options]\n",thisprog);
fprintf(stderr," [input]: file or \"stdin\" in matrix format\n");
fprintf(stderr,"VALID OPTIONS (defaults in []):\n");
fprintf(stderr," -flip : flip matrix (0=NO, 1= x-flip, 2= y-flip) [%d]\n",setflip);
fprintf(stderr," -t : transpose (0=NO, 1=YES - cannot be combined with rotation) [%d]\n",settrans);
fprintf(stderr," -r : rotation, in degrees (choose 0,+-90,+-180,+-270) [%d]\n",setrotate);
fprintf(stderr," -w : width, set (resample) number of columns [%d]\n",setwidth);
fprintf(stderr," -h : height, set (resample) number of rows [%d]\n",setheight);
fprintf(stderr," NOTE: expands or averages data in each row/column as needed\n");
fprintf(stderr," NOTE: set to zero to leave as-is\n");
fprintf(stderr," -sx : 2D gaussian smoothing factor to apply to matrix [%d]\n",setxsmooth);
fprintf(stderr," -sy : 2D gaussian smoothing factor to apply to matrix [%d]\n",setysmooth);
fprintf(stderr," -pn : preserve NANs when smoothing (0=NO 1=YES) [%d]\n",setkeepnans);
fprintf(stderr," -n : normalization, 0=no, 1=0-1 range, 2=z-scores [%d]\n",setnorm);
fprintf(stderr," -f : Fisher z' transformation : 0=no, 1 or 2 = yes [%d]\n",setfishers);
fprintf(stderr," transform for r-values\n");
fprintf(stderr," set to 1 of numbers range from -1 to 1\n");
fprintf(stderr," set to 2 of numbers range from 0 to 1\n");
fprintf(stderr,"EXAMPLES:\n");
fprintf(stderr," %s matrix.txt -n 0 -sx 1 -sy 2 \n",thisprog);
fprintf(stderr,"OUTPUT:\n");
fprintf(stderr," An [width]x[height] modified matrix\n");
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"\n");
exit(0);
}
/* READ THE FILENAME AND OPTIONAL ARGUMENTS */
sprintf(infile,"%s",argv[1]);
for(ii=2;ii<argc;ii++) {
if( *(argv[ii]+0) == '-') {
if((ii+1)>=argc) {fprintf(stderr,"\n--- Error [%s]: missing value for argument \"%s\"\n\n",thisprog,argv[ii]); exit(1);}
else if(strcmp(argv[ii],"-flip")==0) setflip=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-t")==0) settrans=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-r")==0) setrotate=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-n")==0) setnorm=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-f")==0) setfishers=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-w")==0) setwidth=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-h")==0) setheight=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-sx")==0) setxsmooth=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-sy")==0) setysmooth=atoi(argv[++ii]);
else if(strcmp(argv[ii],"-pn")==0) setkeepnans=atoi(argv[++ii]);
else {fprintf(stderr,"\n--- Error [%s]: invalid command line argument \"%s\"\n\n",thisprog,argv[ii]); exit(1);}
}}
x=abs(setrotate);
if(x!=0&&x!=90&&x!=180&&x!=270) {fprintf(stderr,"\n--- Error [%s]: invalid rotation setting (-r %d) \n\n",thisprog,setrotate);exit(1);}
if(setnorm!=0&&setnorm!=1&&setnorm!=2) {fprintf(stderr,"\n--- Error [%s]: invalid normalization setting (-n %d) \n\n",thisprog,setnorm);exit(1);}
if(setfishers!=0&&setfishers!=1&&setfishers!=2) {fprintf(stderr,"\n--- Error [%s]: invalid Fisher transform setting (-f %d) \n\n",thisprog,setfishers);exit(1);}
if(settrans!=0&&settrans!=1) {fprintf(stderr,"\n--- Error [%s]: invalid transpose setting (-t %d) \n\n",thisprog,settrans);exit(1);}
if(setkeepnans!=0&&setkeepnans!=1) {fprintf(stderr,"\n--- Error [%s]: invalid setting (-pn %d) \n\n",thisprog,setkeepnans);exit(1);}
if(settrans==1 && x>0) {fprintf(stderr,"\n--- Error [%s]: cannot both rotate and transpose the input\n\n",thisprog);exit(1);}
if(setflip<0 || setflip>2) {fprintf(stderr,"\n--- Error [%s]: invalid -flip (%d) must be 0-2\n\n",thisprog,setflip);exit(1);}
/* STORE THE MATRIX - THIS METHOD IS ROBUST AGAINST LINES OF UNKNOWN LENGTH */
if(strcmp(infile,"stdin")==0) fpin=stdin;
else if((fpin=fopen(infile,"r"))==0) {fprintf(stderr,"\n\a--- Error [%s]: file \"%s\" not found\n\n",thisprog,infile);exit(1);}
matrix1= xf_matrixread1_d(&nmatrices,&width1,&height1,message,fpin);
if(strcmp(infile,"stdin")!=0) fclose(fpin);
if(matrix1==NULL) {fprintf(stderr,"\n--- Error [%s]: %s\n\n",thisprog,message);exit(1);}
N1= width1*height1;
if(nmatrices>1) {fprintf(stderr,"\n--- Error [%s]: file %s contains more than one matrix - average before passing to this program\n\n",thisprog,infile);exit(1);}
/* FLIP THE MATRIX */
if(setflip==1) matrix1= xf_matrixflipx_d(matrix1,width1,height1);
if(setflip==2) matrix1= xf_matrixflipy_d(matrix1,width1,height1);
/* TRANSPOSE THE MATRIX - this will also update the variables width1 and height1 */
if(settrans==1) matrix1= xf_matrixtrans1_d(matrix1,&width1,&height1);
if(matrix1==NULL) {fprintf(stderr,"\n--- Error [%s]: transpose function encountered insufficient memory\n\n",thisprog);exit(1);}
/* ROTATE THE MATRIX - this will also update the variables width1 and height1 */
if(setrotate!=0) matrix1= xf_matrixrotate1_d(matrix1,&width1,&height1,setrotate);
if(matrix1==NULL) {fprintf(stderr,"\n--- Error [%s]: rotation function encountered insufficient memory\n\n",thisprog);exit(1);}
/*
RESAMPLE THE MATRIX
- note that the bin and expand functions will complain if passed arguments indicating the wrong type of modification
- hence we call the bin function first, and separately for width and height
- then, the expansion function only sees the matrix which has already been binned in one dimension, if required
*/
if(setwidth>0 || setheight>0) {
/* for auto settings, assign existing matrix size to setwidth and/or setheight */
if(setwidth<=0) setwidth=width1;
if(setheight<=0) setheight=height1;
/* if matrix is to be downsampled (binned)... */
if(setwidth<width1) {
z= xf_matrixbin1_d(matrix1,width1,height1,setwidth,height1,message);
if(z!=0) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); }
width1=setwidth;
matrix1=(double *)realloc(matrix1,((width1*height1)*sizeof(double)));
}
if(setheight<height1) {
z= xf_matrixbin1_d(matrix1,width1,height1,width1,setheight,message);
if(z!=0) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); }
height1=setheight;
matrix1=(double *)realloc(matrix1,((width1*height1)*sizeof(double)));
}
/* if matrix is to be expanded... */
if(setwidth>width1 || setheight>height1) {
matrix1= xf_matrixexpand1_d(matrix1,width1,height1,setwidth,setheight,message);
if(matrix1==NULL) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); }
if(setwidth>width1) width1=setwidth;
if(setheight>height1) height1=setheight;
}
//else {fprintf(stderr,"\n--- Error [%s]: a single call to this program cannot mix matrix downsampling in one dimension with expansion in another: call this program twice instead\n\n",thisprog);exit(1);}
N1=width1*height1;
}
/* SMOOTH THE MATRIX */
if(setxsmooth>0 || setysmooth>0) {
if(setkeepnans==1) {
/* make a copy to store NAN's if present */
matrix2= realloc(matrix2,((width1*height1)*sizeof(*matrix2)));
for(ii=0;ii<N1;ii++) matrix2[ii]= matrix1[ii];
/* apply smoothing */
z=xf_smoothgauss2_d(matrix1,width1,height1,setxsmooth,setysmooth);
if(z!=0) {fprintf(stderr,"\n--- Error [%s]: smoothing function encountered insufficient memory\n\n",thisprog);exit(1);}
/* reinstate NAN's where required */
for(ii=0;ii<N1;ii++) if(!isfinite(matrix2[ii])) matrix1[ii]=NAN;
}
else {
z=xf_smoothgauss2_d(matrix1,width1,height1,setxsmooth,setysmooth);
if(z!=0) {fprintf(stderr,"\n--- Error [%s]: smoothing function encountered insufficient memory\n\n",thisprog);exit(1);}
}
}
/* APPLY A FISHER'S TRANSFORM FOR CORRELATION VALUES */
if(setfishers==1 || setfishers==2)
xf_fishertransform2_d(matrix1,N1,setfishers);
/* NORMALISE THE MATRIX */
if(setnorm==1 || setnorm==2)
xf_norm2_d(matrix1,N1,(setnorm-1));
/* OUTPUT THE MATRIX */
for(ii=0;ii<height1;ii++) {
jj=ii*width1;
kk=jj+width1;
printf("%g",matrix1[jj++]);
for(jj=jj;jj<kk;jj++) printf(" %g",matrix1[jj]); // only print a tab separator for columns after the first column
printf("\n");
}
/* FREE MEMORY */
if(matrix1!=NULL) free(matrix1);
if(matrix2!=NULL) free(matrix2);
exit(0);
}
|
the_stack_data/56179.c | #include <stdio.h>
#include <math.h>
#define DIVIDER 2
boxcount_(pixels,xsize,ysize,tresh)
float *pixels;
int *xsize, *ysize;
float *tresh;
{
FILE *outf, *outf1;
int L,SIZE;
int i,j;
int *count;
if ( (outf = fopen("result.data", "w")) == NULL) {
printf("Unable to open file result.data\n");
exit(1);
};
if ( (outf1 = fopen("res.data", "w")) == NULL) {
printf("Unable to open file res.data\n");
exit(1);
};
SIZE = (*xsize > *ysize) ? *ysize : *xsize;
printf("Using %dx%d raster\n",*xsize,*ysize);
printf("Using %d as SIZE\n",SIZE);
printf("Treshold %8.3f\n",*tresh);
count = (int *) malloc(sizeof(int)*SIZE/DIVIDER+1);
printf(" === Init counters\n");
for (i=0; i<=SIZE/DIVIDER; i++)
count[i] = 0;
printf(" === Counting boxes\n");
i = 0;
for (L=1; L<=SIZE/DIVIDER; L++)
if ((SIZE%L) == 0) Sum(pixels,count,L,*xsize,*ysize,*tresh);
printf(" === Printing results\n");
for (i=1; i<=SIZE/DIVIDER; i++)
if (count[i]>0) {
fprintf(outf,"%10.5f %10.5f %5d, %5d\n", log((float)i), log((float)count[i]),
i,count[i]);
}
free(count);
fclose(outf);
fclose(outf1);
}
Sum(pixels,count,L,xsize,ysize,tr)
float *pixels;
int *count;
int L;
int xsize,ysize;
float tr;
{
int i, j;
int res = 0;
printf("L is %d\n", L);
for (i=0; i<=(xsize-L); i += L)
for (j=0; j<=(ysize-L); j += L)
if ( (res = add(pixels,xsize,tr,i,i+L,j,j+L)) > 0) {
count[L] += 1;
}
}
int add(pixels,xsize,tr,x1,x2,y1,y2)
float *pixels;
int xsize;
float tr;
int x1,x2,y1,y2;
{
int i, j;
int res = 0;
for (j=y1; j<y2; j++)
for (i=x1; i<x2; i++)
if (pixels[i*xsize+j]> tr)
return(1);
return(0);
}
|
the_stack_data/247016984.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <CL/cl.h>
unsigned char *read_buffer(char *file_name, size_t *size_ptr)
{
FILE *f;
unsigned char *buf;
size_t size;
/* Open file */
f = fopen(file_name, "rb");
if (!f)
return NULL;
/* Obtain file size */
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
/* Allocate and read buffer */
buf = malloc(size + 1);
fread(buf, 1, size, f);
buf[size] = '\0';
/* Return size of buffer */
if (size_ptr)
*size_ptr = size;
/* Return buffer */
return buf;
}
void write_buffer(char *file_name, const char *buffer, size_t buffer_size)
{
FILE *f;
/* Open file */
f = fopen(file_name, "w+");
/* Write buffer */
if(buffer)
fwrite(buffer, 1, buffer_size, f);
/* Close file */
fclose(f);
}
int main(int argc, char const *argv[])
{
/* Get platform */
cl_platform_id platform;
cl_uint num_platforms;
cl_int ret = clGetPlatformIDs(1, &platform, &num_platforms);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformIDs' failed\n");
exit(1);
}
printf("Number of platforms: %d\n", num_platforms);
printf("platform=%p\n", platform);
/* Get platform name */
char platform_name[100];
ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformInfo' failed\n");
exit(1);
}
printf("platform.name='%s'\n\n", platform_name);
/* Get device */
cl_device_id device;
cl_uint num_devices;
ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &num_devices);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceIDs' failed\n");
exit(1);
}
printf("Number of devices: %d\n", num_devices);
printf("device=%p\n", device);
/* Get device name */
char device_name[100];
ret = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name),
device_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceInfo' failed\n");
exit(1);
}
printf("device.name='%s'\n", device_name);
printf("\n");
/* Create a Context Object */
cl_context context;
context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateContext' failed\n");
exit(1);
}
printf("context=%p\n", context);
/* Create a Command Queue Object*/
cl_command_queue command_queue;
command_queue = clCreateCommandQueue(context, device, 0, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateCommandQueue' failed\n");
exit(1);
}
printf("command_queue=%p\n", command_queue);
printf("\n");
/* Program source */
unsigned char *source_code;
size_t source_length;
/* Read program from 'pre_increment_char8.cl' */
source_code = read_buffer("pre_increment_char8.cl", &source_length);
/* Create a program */
cl_program program;
program = clCreateProgramWithSource(context, 1, (const char **)&source_code, &source_length, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateProgramWithSource' failed\n");
exit(1);
}
printf("program=%p\n", program);
/* Build program */
ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
if (ret != CL_SUCCESS )
{
size_t size;
char *log;
/* Get log size */
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,0, NULL, &size);
/* Allocate log and print */
log = malloc(size);
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,size, log, NULL);
printf("error: call to 'clBuildProgram' failed:\n%s\n", log);
/* Free log and exit */
free(log);
exit(1);
}
printf("program built\n");
printf("\n");
/* Create a Kernel Object */
cl_kernel kernel;
kernel = clCreateKernel(program, "pre_increment_char8", &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateKernel' failed\n");
exit(1);
}
/* Create and allocate host buffers */
size_t num_elem = 10;
/* Create and init host side src buffer 0 */
cl_char8 *src_0_host_buffer;
src_0_host_buffer = malloc(num_elem * sizeof(cl_char8));
for (int i = 0; i < num_elem; i++)
src_0_host_buffer[i] = (cl_char8){{2, 2, 2, 2, 2, 2, 2, 2}};
/* Create and init device side src buffer 0 */
cl_mem src_0_device_buffer;
src_0_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_char8), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create source buffer\n");
exit(1);
}
ret = clEnqueueWriteBuffer(command_queue, src_0_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_char8), src_0_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueWriteBuffer' failed\n");
exit(1);
}
/* Create host dst buffer */
cl_char8 *dst_host_buffer;
dst_host_buffer = malloc(num_elem * sizeof(cl_char8));
memset((void *)dst_host_buffer, 1, num_elem * sizeof(cl_char8));
/* Create device dst buffer */
cl_mem dst_device_buffer;
dst_device_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, num_elem *sizeof(cl_char8), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create dst buffer\n");
exit(1);
}
/* Set kernel arguments */
ret = CL_SUCCESS;
ret |= clSetKernelArg(kernel, 0, sizeof(cl_mem), &src_0_device_buffer);
ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clSetKernelArg' failed\n");
exit(1);
}
/* Launch the kernel */
size_t global_work_size = num_elem;
size_t local_work_size = num_elem;
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueNDRangeKernel' failed\n");
exit(1);
}
/* Wait for it to finish */
clFinish(command_queue);
/* Read results from GPU */
ret = clEnqueueReadBuffer(command_queue, dst_device_buffer, CL_TRUE,0, num_elem * sizeof(cl_char8), dst_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueReadBuffer' failed\n");
exit(1);
}
/* Dump dst buffer to file */
char dump_file[100];
sprintf((char *)&dump_file, "%s.result", argv[0]);
write_buffer(dump_file, (const char *)dst_host_buffer, num_elem * sizeof(cl_char8));
printf("Result dumped to %s\n", dump_file);
/* Free host dst buffer */
free(dst_host_buffer);
/* Free device dst buffer */
ret = clReleaseMemObject(dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Free host side src buffer 0 */
free(src_0_host_buffer);
/* Free device side src buffer 0 */
ret = clReleaseMemObject(src_0_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Release kernel */
ret = clReleaseKernel(kernel);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseKernel' failed\n");
exit(1);
}
/* Release program */
ret = clReleaseProgram(program);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseProgram' failed\n");
exit(1);
}
/* Release command queue */
ret = clReleaseCommandQueue(command_queue);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseCommandQueue' failed\n");
exit(1);
}
/* Release context */
ret = clReleaseContext(context);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseContext' failed\n");
exit(1);
}
return 0;
} |
the_stack_data/100139740.c | /*
Database "cre_Doc_Control_Systems" contains tables:
addresses
circulation_history
document_drafts
documents
documents_mailed
draft_copies
employees
reference_document_status
reference_document_types
reference_shipping_agents
roles
*/
#ifndef CRE_DOC_CONTROL_SYSTEMS
#define CRE_DOC_CONTROL_SYSTEMS
struct T_addresses {
double address_id;
char address_details[3];
};
struct T_circulation_history {
double document_id; // --> draft_copies.document_id
double draft_number; // --> draft_copies.draft_number
double copy_number; // --> draft_copies.copy_number
double employee_id; // --> employees.employee_id
};
struct T_document_drafts {
double document_id; // --> documents.document_id
double draft_number;
char draft_details[2];
};
struct T_documents {
double document_id;
char document_status_code[8]; // --> reference_document_status.document_status_code
char document_type_code[11]; // --> reference_document_types.document_type_code
char shipping_agent_code[3]; // --> reference_shipping_agents.shipping_agent_code
char receipt_date[20];
char receipt_number[4];
char other_details[2];
};
struct T_documents_mailed {
double document_id; // --> documents.document_id
double mailed_to_address_id; // --> addresses.address_id
char mailing_date[20];
};
struct T_draft_copies {
double document_id; // --> document_drafts.document_id
double draft_number; // --> document_drafts.draft_number
double copy_number;
};
struct T_employees {
double employee_id;
char role_code[3]; // --> roles.role_code
char employee_name[8];
char other_details[2];
};
struct T_reference_document_status {
char document_status_code[8];
char document_status_description[21];
};
struct T_reference_document_types {
char document_type_code[11];
char document_type_description[2];
};
struct T_reference_shipping_agents {
char shipping_agent_code[3];
char shipping_agent_name[8];
char shipping_agent_description[2];
};
struct T_roles {
char role_code[3];
char role_description[14];
};
struct T_addresses
addresses[] = {
{ 0, "IT" },
{ 1, "MX" },
{ 2, "DE" },
{ 3, "ES" },
{ 4, "ES" },
{ 5, "IE" },
{ 6, "US" },
{ 7, "PT" },
{ 8, "IE" },
{ 9, "MX" }
};
struct T_circulation_history
circulation_history[] = {
{ 20, 17, 15, 8 },
{ 1, 2, 5, 1 },
{ 2, 1, 4, 2 },
{ 10, 20, 10, 2 }
};
struct T_document_drafts
document_drafts[] = {
{ 1, 0, "e" },
{ 1, 2, "k" },
{ 2, 1, "v" },
{ 2, 8, "v" },
{ 4, 9, "r" },
{ 7, 10, "m" },
{ 10, 20, "k" },
{ 12, 11, "b" },
{ 12, 12, "r" },
{ 13, 4, "w" },
{ 13, 16, "p" },
{ 14, 14, "x" },
{ 17, 19, "a" },
{ 20, 17, "l" },
{ 23, 9, "r" }
};
struct T_documents
documents[] = {
{ 1, "working", "CD", "UP", "2008-04-21 20:42:25", "19", "z" },
{ 2, "done", "Paper", "US", "1974-05-08 00:00:46", "34", "h" },
{ 3, "done", "Paper", "UP", "2014-12-25 17:22:44", "93", "h" },
{ 4, "done", "Paper", "US", "1973-11-05 21:48:53", "80", "q" },
{ 7, "working", "CD", "SH", "1982-09-27 14:52:15", "61", "w" },
{ 10, "overdue", "Paper", "UP", "1976-09-15 19:24:17", "8", "m" },
{ 12, "overdue", "Hard Drive", "US", "1996-05-31 06:51:58", "69", "n" },
{ 13, "working", "CD", "UP", "2015-04-03 09:36:19", "79", "y" },
{ 14, "working", "CD", "FE", "2017-07-02 17:39:09", "117", "u" },
{ 15, "overdue", "CD", "UP", "1986-12-14 14:18:59", "37", "r" },
{ 17, "done", "Paper", "FE", "1983-09-26 09:32:56", "55", "p" },
{ 20, "working", "Paper", "UP", "1996-07-27 03:30:40", "189", "x" },
{ 23, "working", "Hard Drive", "FE", "1999-04-17 14:19:32", "124", "b" },
{ 24, "working", "Hard Drive", "FE", "2005-09-30 00:10:02", "114", "j" },
{ 25, "overdue", "Hard Drive", "AL", "1985-11-05 17:59:34", "83", "u" }
};
struct T_documents_mailed
documents_mailed[] = {
{ 2, 8, "1977-04-01 17:03:50" },
{ 4, 3, "1992-11-07 15:03:41" },
{ 4, 9, "1973-02-21 10:17:01" },
{ 7, 5, "1979-09-21 10:30:52" },
{ 10, 3, "1993-05-24 22:13:48" },
{ 12, 0, "1999-05-22 23:21:07" },
{ 12, 7, "2007-01-01 22:32:11" },
{ 12, 8, "2007-03-20 05:22:01" },
{ 13, 4, "1991-05-27 14:17:37" },
{ 14, 5, "1986-05-16 06:25:33" },
{ 20, 2, "2010-11-04 04:00:16" },
{ 20, 7, "1982-01-14 05:50:54" },
{ 23, 8, "1971-11-03 12:32:14" },
{ 24, 0, "2013-01-27 03:29:31" }
};
struct T_draft_copies
draft_copies[] = {
{ 2, 8, 5 },
{ 4, 9, 6 },
{ 23, 9, 15 },
{ 10, 20, 10 },
{ 2, 1, 4 },
{ 1, 2, 5 },
{ 20, 17, 15 },
{ 12, 12, 10 }
};
struct T_employees
employees[] = {
{ 1, "ED", "Koby", "h" },
{ 2, "ED", "Kenyon", "f" },
{ 3, "PR", "Haley", "b" },
{ 5, "PT", "Clemens", "b" },
{ 7, "PT", "Jordyn", "v" },
{ 8, "MG", "Erling", "u" }
};
struct T_reference_document_status
reference_document_status[] = {
{ "working", "currently working on" },
{ "done", "mailed" },
{ "overdue", "mailed late" }
};
struct T_reference_document_types
reference_document_types[] = {
{ "CD", "b" },
{ "Paper", "u" },
{ "Hard Drive", "f" }
};
struct T_reference_shipping_agents
reference_shipping_agents[] = {
{ "UP", "UPS", "g" },
{ "US", "USPS", "q" },
{ "AL", "Airline", "w" },
{ "FE", "Fedex", "k" },
{ "SH", "Ship", "t" }
};
struct T_roles
roles[] = {
{ "ED", "Editor" },
{ "PT", "Photo" },
{ "MG", "Manager" },
{ "PR", "Proof Manager" }
};
#endif |
the_stack_data/215767406.c | /*
BSD 2-Clause License
Copyright (c) 2016, Rafael Kitover
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <wctype.h>
#include <wchar.h>
#include <locale.h>
#ifndef _MSC_VER
#include <unistd.h>
#endif
#define BUF_SIZE 4096
#define WBUF_SIZE BUF_SIZE * sizeof(wchar_t)
#define MSG_SIZE 256
const char* version = "0.3";
const char* msg_prefix = "bin2c: ";
void format_perror(const char* fmt, va_list args) {
static char error_str[MSG_SIZE];
static char fmt_str[MSG_SIZE];
strcpy(fmt_str, msg_prefix);
strncat(fmt_str, fmt, MSG_SIZE - sizeof(msg_prefix));
vsnprintf(error_str, sizeof(error_str), fmt_str, args);
perror(error_str);
}
void die(const char* fmt, ...) {
va_list args;
va_start(args, fmt);
format_perror(fmt, args);
va_end(args);
exit(1);
}
void* safe_malloc(size_t size) {
void* allocated;
if (!(allocated = malloc(size)))
die("out of memory");
return allocated;
}
char* file_name_to_identifier(const char* file_name_cstr) {
wchar_t* file_name = safe_malloc(WBUF_SIZE);
wchar_t* identifier = safe_malloc(WBUF_SIZE);
char* identifier_cstr = safe_malloc(WBUF_SIZE);
wchar_t* file_name_ptr = file_name;
wchar_t* identifier_ptr = identifier;
wchar_t* file_name_end = NULL;
size_t file_name_len = 0;
int between_tokens = 0;
if ((file_name_len = mbstowcs(file_name, file_name_cstr, BUF_SIZE - 1)) == -1)
die("cannot convert '%s' to locale representation", file_name_cstr);
*identifier = 0;
file_name_end = file_name + file_name_len + 1;
while (file_name_ptr < file_name_end) {
if (iswalnum(*file_name_ptr)) {
*identifier_ptr = *file_name_ptr;
identifier_ptr++;
between_tokens = 0;
}
else if (!between_tokens) {
mbstowcs(identifier_ptr, "_", 1);
identifier_ptr++;
between_tokens = 1;
}
file_name_ptr++;
}
/* terminate identifier, on _ or on next position */
if (between_tokens) identifier_ptr--;
*identifier_ptr = 0;
if (wcstombs(identifier_cstr, identifier, WBUF_SIZE - 1) == -1)
die("failed to convert wide character string to bytes");
free(file_name);
free(identifier);
return identifier_cstr;
}
void usage(int err) {
FILE* stream = err ? stderr : stdout;
fputs(
"Usage: [32mbin2c [1;34m[[1;35mIN_FILE [1;34m[[1;35mOUT_FILE [1;34m[[1;35mVAR_NAME[1;34m][1;34m][1;34m][0m\n"
"Write [1;35mIN_FILE[0m as a C array of bytes named [1;35mVAR_NAME[0m into [1;35mOUT_FILE[0m.\n"
"\n"
"By default, [1mSTDIN[0m is the input and [1mSTDOUT[0m is the output, either can be explicitly specified with [1;35m-[0m.\n"
"\n"
"The default [1;35mVAR_NAME[0m is the [1;35mIN_FILE[0m name converted to an identifier, or [1m\"resource_data\"[0m\n"
"if it's [1mSTDIN[0m.\n"
"\n"
" [1m-h, --help[0m Show this help screen and exit.\n"
" [1m-v, --version[0m Print version and exit.\n"
"\n"
"Examples:\n"
" # write data from file [1;35m./compiled-resources.xrs[0m into header file [1;35m./resources.h[0m using variable name [1;35mresource_data[0m\n"
" [32mbin2c [1;35m./compiled-resources.xrs[0m [1;35m./resources.h[0m [1;35mresource_data[0m\n"
" # write data from [1mSTDIN[0m to [1mSTDOUT[0m with [1m\"resource_data\"[0m as the [1;35mVAR_NAME[0m\n"
" [32mbin2c[0m\n"
" # write data from [1;35m./compiled-resources.xrs[0m to [1mSTDOUT[0m with [1m\"compiled_resources_xrs\"[0m as the [1;35mVAR_NAME[0m\n"
" [32mbin2c [1;35m./compiled-resources.xrs[0m\n"
" # write data from [1;35m./compiled-resources.xrs[0m to [1;35m./resources.h[0m with [1m\"compiled_resources_xrs\"[0m as the [1;35mVAR_NAME[0m\n"
" [32mbin2c [1;35m./compiled-resources.xrs [1;35m./resources.h[0m\n"
"\n"
"Project homepage and documentation: <[1;34mhttp://github.com/rkitover/bin2c[0m>\n"
, stream);
}
void die_usage(const char* fmt, ...) {
static char fmt_str[MSG_SIZE];
va_list args;
va_start(args, fmt);
strcpy(fmt_str, msg_prefix);
strncat(fmt_str, fmt, MSG_SIZE - sizeof(msg_prefix) - 1);
strcat(fmt_str, "\n");
vfprintf(stderr, fmt_str, args);
va_end(args);
usage(1);
exit(1);
}
void exit_usage(int exit_code) {
usage(exit_code);
exit(exit_code);
}
int main(int argc, const char** argv) {
const char* usage_opts[] = {"-h", "--help"};
const char* version_opts[] = {"-v", "--version"};
const char* in_file_name = argc >= 2 ? argv[1] : NULL;
const char* out_file_name = argc >= 3 ? argv[2] : NULL;
const char* var_name = argc >= 4 ? argv[3] : NULL;
char* computed_identifier = NULL;
int i = 0, file_pos = 0, in_fd = -1;
size_t bytes_read = 0;
unsigned char* buf = safe_malloc(BUF_SIZE);
FILE *in_file, *out_file;
setlocale(LC_ALL, "");
if (argc > 4)
die_usage("invalid number of arguments");
if (argc >= 2) {
for (i = 0; i < (sizeof(usage_opts)/sizeof(char*)); i++) {
if (!strcmp(argv[1], usage_opts[i])) exit_usage(0);
}
for (i = 0; i < (sizeof(version_opts)/sizeof(char*)); i++) {
if (!strcmp(argv[1], version_opts[i])) {
printf("bin2c %s\n", version);
return 0;
}
}
}
if (!(in_file = !in_file_name || !strcmp(in_file_name, "-") ? stdin : fopen(in_file_name, "rb")))
die("can't open input file '%s'", in_file_name);
if (!(out_file = !out_file_name || !strcmp(out_file_name, "-") ? stdout : fopen(out_file_name, "w")))
die("can't open '%s' for writing", out_file_name);
if (in_file_name && !var_name)
var_name = computed_identifier = file_name_to_identifier(in_file_name);
fprintf(out_file, "/* generated from %s: do not edit */\n"
"const unsigned char %s[] = {\n",
in_file_name ? in_file_name : "resource data",
var_name ? var_name : "resource_data"
);
in_fd = fileno(in_file);
while ((bytes_read = read(in_fd, buf, BUF_SIZE))) {
for (i = 0; i < bytes_read; i++) {
char* comma = bytes_read < BUF_SIZE && i == bytes_read - 1 ? "" : ",";
fprintf(out_file, "0x%02x%s", buf[i], comma);
if (++file_pos % 16 == 0) fputc('\n', out_file);
}
}
fputs("};\n", out_file);
free(buf);
free(computed_identifier);
fclose(in_file);
fclose(out_file);
return 0;
}
|
the_stack_data/91379.c | // нужна прога с двумерным динамическим массивом,
// которая исполняет вот это вот:
// вводишь строку и слово, а прога выводит эту же строку,
// но после каждого слова, содержащего то слово,
// которое ты ввёл, прога выводила бы "---"
// пример:
// hello world gell, ell
// hellо--- world gell---
#include <stdio.h>
#include <stdlib.h>
int len = 0;
int strlen(char *str) { // определяем длину строки
int count = 0;
for (int i = 0; str[i] != 0; i++) count++;
return count;
}
void strcopy(char* to, const char* from, size_t n) {
while(n--) // копируем n символов
*(to++) = *(from++); // из одной строки в другую
}
int strcmp(char *s1, char *s2) {
for (int i = 0; i < strlen(s2); i++) // пока не дойдем до конца второго слова
if (s1[i] != s2[i]) // сравниваем каждую букву
return 0; // не совпадают
return 1; // совпадают
}
char *readstr() { // оптимальный ввод слова в динамическую память
len = 0;
int capacity = 1;
char *s = (char *)malloc(sizeof(char));
char c = getchar(); // получаем введенный символ
while (c != '\n') { // пока не найдем конец ввода
s[(len)++] = c;
if (len >= capacity) { // если памяти не хватает
capacity *= 2; // выделяем в 2 раза больше памяти
s = (char *)realloc(s, capacity * sizeof(char));
}
c = getchar();
}
s[len] = 0; // в конце введенной строки всегда \0
len += 1;
return s; // возвращаем указатель на строку
}
int main (int argc, char *argv[]) {
printf("Enter string:\n");
char *str = readstr(); // считываем строку в динамическую память
int str_len = len;
printf("\nEnter word:\n");
char* word = readstr(); // считываем слово в динамическую память
int word_len = len;
printf("\n");
int words_count = 0;
for (int i = 0; i < str_len; i++)
if (str[i] == ' ' || str[i] == 0)
words_count++; // определяем количество слов
char** words = malloc(words_count * sizeof(char*)); // выделяем массив указателей на слова
int curr_word = 0, pos = 0;
for (int i = 0; i < str_len; i++) { // проходим по всей строке
if (str[i] == ' ' || str[i] == 0) { // если нашли новое слово
words[curr_word] = malloc(i - pos + 1); // выделяем память на одно слово
strcopy(words[curr_word], &str[pos], i - pos); // записываем его в двумерный массив
words[curr_word][i - pos] = 0; // последний символ в слове - \0
pos = i + 1;
for (int i = 0; i <= strlen(words[curr_word]) - strlen(word); i++) // проходим по срезам слова (abcd, bcd, cd, d)
if (strcmp(words[curr_word]+i, word)) { // проверяем на соответствие нужной подстроке
curr_word++;
words_count++;
words = realloc(words, (words_count) * sizeof(char*));
words[curr_word] = malloc(sizeof(char) * 4);
strcopy(words[curr_word], "---", 4);
break; // выходим из цикла проверки срезов
}
curr_word++;
}
}
for (int w = 0; w < words_count; w++) printf("%s ", words[w]);
} |
the_stack_data/22012375.c | // Client side C/C++ program to demonstrate Socket programming
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#define PORT 8890
int main(int argc, char const *argv[])
{
int sock = 0, valread;
struct sockaddr_in serv_addr;
char *hello = "Hello from client";
char buffer[1024] = {0};
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// Convert IPv4 and IPv6 addresses from text to binary form
if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\nConnection Failed \n");
return -1;
}
char input[1024];
char output[1024];
printf("Enter sentence: ");
scanf("%[^\n]", input);
send(sock, &input, sizeof(input), 0);
printf("Input sent: %s\n", input);
valread = read(sock, &output, sizeof(output));
printf("Output recieved: %s \n", output);
return 0;
}
|
the_stack_data/15761757.c | /*
* Copyright (C) 2020 ETH Zurich and University of Bologna
*
* 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.
*/
#include <stdio.h>
int main()
{
printf("Left bootrom and arrived in main!\n");
return 0;
}
|
the_stack_data/49035.c | #include <math.h>
long long llrintf (float x)
{
long long retval;
__asm__ __volatile__ \
("fistpll %0" : "=m" (retval) : "t" (x) : "st"); \
return retval;
}
|
the_stack_data/141584.c | #include <stdio.h>
int main (void){
int a, b, c, ab, maior;
scanf ("%d %d %d", &a, &b, &c);
ab=(a+b+abs(a-b))/2;
maior=(ab+c+abs(ab-c))/2;
printf("%d eh o maior\n", maior);
}
|
the_stack_data/148576899.c | # 1 "CMakeCUDACompilerId.cu"
# 40 "CMakeCUDACompilerId.cu"
extern const char *info_compiler;
# 272 "CMakeCUDACompilerId.cu"
static const char info_version[50];
# 319 "CMakeCUDACompilerId.cu"
extern const char *info_platform;
extern const char *info_arch;
extern const char *info_language_dialect_default;
# 40 "CMakeCUDACompilerId.cu"
const char *info_compiler = ((const char *)"INFO:compiler[NVIDIA]");
# 272 "CMakeCUDACompilerId.cu"
static const char info_version[50] = {((char)73),((char)78),((char)70),((char)79),((char)58),((char)99),((char)111),((char)109),((char)112),((char)105),((char)108),((char)101),((char)114),((char)95),((char)118),((char)101),((char)114),((char)115),((char)105),((char)111),((char)110),((char)91),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)48),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)48),((char)53),((char)93),((char)0)};
# 319 "CMakeCUDACompilerId.cu"
const char *info_platform = ((const char *)"INFO:platform[Linux]");
const char *info_arch = ((const char *)"INFO:arch[]");
const char *info_language_dialect_default = ((const char *)"INFO:dialect_default[14]");
|
the_stack_data/11076238.c | /*
AUTHOR: Fábio Pereira da Silva
YEAR: 2019
LICENSE: MIT
EMAIL: [email protected] or [email protected]
*/
// Tester of implementation of equation 7.12 (7.3 A Statistical Definition of Entropy)
// https://web.mit.edu/16.unified/www/FALL/thermodynamics/notes/node56.html
// Many thanks to Professor Z. S. Spakovszky
//Sáb 21 Set 2019 23:53:26 -03
#include <stdio.h>
#include <string.h>
#define F_LOG_MAX 8*256
#define F_ENTROPY_TYPE_PARANOIC (unsigned int)1477500000//1476682819
#define F_ENTROPY_TYPE_EXCELENT (unsigned int)1475885281
#define F_ENTROPY_TYPE_GOOD (unsigned int)1471531015
#define F_ENTROPY_TYPE_NOT_ENOUGH (unsigned int)1470001808
#define F_ENTROPY_TYPE_NOT_RECOMENDED (unsigned int)1469703345
unsigned long int f_test_entropy(unsigned char *rand_data, size_t rand_data_sz/*, unsigned int type*/)
{
extern const int F_LOG_ARRAY[F_LOG_MAX+1] asm("_binary_f_log_dat_start");
unsigned int f_entropy_val[256];
unsigned long int final;
size_t i;
//f_test_entropy_RET:
final=0;
memset(f_entropy_val,0,sizeof(f_entropy_val));
for (i=0;i<rand_data_sz;i++)
f_entropy_val[rand_data[i]]+=1;
for (i=0;i<256;i++)
final+=f_entropy_val[i]*F_LOG_ARRAY[f_entropy_val[i]];
// if ((unsigned long int)type>final)
// goto f_test_entropy_RET;
return final;
}
int main(int argc, char **argv)
{
FILE *f;
unsigned char msg[F_LOG_MAX];
unsigned long int parm=(unsigned long int)F_ENTROPY_TYPE_PARANOIC;
unsigned long int final;
printf("\nReading \"stdin\" ... and calculating entropy data ...\n");
main_RET:
if (fread(msg, 1, sizeof(msg), stdin)^sizeof(msg)) {
printf("\nCould no read data\n");
printf("\nStream of data must be at least %d bytes\n", F_LOG_MAX);
return 1;
}
if (parm>(final=f_test_entropy(msg, sizeof(msg))))
goto main_RET;
printf("\nEntropy result: %lu\n", final);
fclose(stdin);
return 0;
}
|
the_stack_data/872196.c | #include <stdio.h>
enum {
SIZE = 9
};
/* qsort: sort v[left]...v[right] into increasing order */
void qsort(int v[], int left, int right);
/* swap: interchange v[i] and v[j] */
void swap(int v[], int i, int j);
int main(void)
{
int arr[SIZE] = { 16, 4, 12, 9, 13, 15, 1, 8, 11 };
int i;
printf("Before: ");
for (i = 0; i < SIZE; ++i)
printf("%2d ", arr[i]);
putchar('\n');
qsort(arr, 0, SIZE - 1);
printf("After : ");
for (i = 0; i < SIZE; ++i)
printf("%2d ", arr[i]);
putchar('\n');
return 0;
}
void qsort(int v[], int left, int right)
{
int i, last;
void swap(int v[], int i, int j);
if (left >= right) /* do nothing if array contains */
return; /* fewer than two elements */
swap(v, left, (left + right) / 2); /* move partition elem */
last = left; /* to v[0] */
for (i = left + 1; i <= right; ++i) { /* partition */
if (v[i] < v[left])
swap(v, ++last, i);
}
swap(v, left, last); /* restore partition elem */
qsort(v, left, last - 1);
qsort(v, last + 1, right);
}
/* swap: interchange v[i] and v[j] */
void swap(int v[], int i, int j)
{
int temp;
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
|
the_stack_data/175144176.c | // Not guarented to work
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<unistd.h>
#include<strings.h>
#define MAX(a,b) a>b?a:b
int main()
{
struct sockaddr_in TCP_address,UDP_address;
int TCP_Socket,UDP_Socket,i;
fd_set rset;
TCP_Socket = socket(AF_INET,SOCK_STREAM,0);
UDP_Socket = socket(AF_INET,SOCK_DGRAM,0);
char data[50];
TCP_address.sin_family = AF_INET;
TCP_address.sin_port = htons(8080);
UDP_address.sin_family = AF_INET;
UDP_address.sin_port = htons(8070);
bzero(&TCP_address.sin_addr,sizeof(TCP_address.sin_addr));
bzero(&UDP_address.sin_addr,sizeof(UDP_address.sin_addr));
inet_pton(AF_INET,"127.0.0.1",&TCP_address.sin_addr);
inet_pton(AF_INET,"127.0.0.1",&UDP_address.sin_addr);
bind(TCP_Socket,(struct sockaddr *)&TCP_address,sizeof(TCP_address));
listen(TCP_Socket,10);
bind(UDP_Socket,(struct sockaddr *)&TCP_address,sizeof(TCP_address));
FD_ZERO(&rset);
int maxval = MAX(TCP_Socket,UDP_Socket) + 1;
for(;;)
{
FD_SET(TCP_Socket,&rset);
FD_SET(UDP_Socket,&rset);
int number = select(maxval,&rset,NULL,NULL,NULL);
printf("Hello\n");
if(FD_ISSET(TCP_Socket,&rset))
{
printf("Got Connection from TCP\n");
int socklen = sizeof(TCP_address);
int newsock = accept(TCP_Socket,(struct sockaddr *)&TCP_address,(socklen_t *)&socklen);
if(fork()==0)
{
int dataReceived = recv(newsock,data,50,0);
for(i=0;i<dataReceived;i++)
{
printf("%c",data[i]);
data[i] = data[i] - 32;
}
send(newsock,data,dataReceived,0);
}
close(newsock);
}
if(FD_ISSET(UDP_Socket,&rset))
{
printf("Got Connection from UDP");
int socklen = sizeof(TCP_address);
int dataReceived = recvfrom(UDP_Socket,data,1024,0,(struct sockaddr *)&TCP_address,(socklen_t *)&socklen);
for(i=0;i<dataReceived;i++)
data[i] = data[i] - 32;
int sizeUDPAddr = sizeof(UDP_address);
sendto(UDP_Socket,data,dataReceived,0,(struct sockaddr *)&UDP_address,sizeUDPAddr);
}
}
}
|
the_stack_data/237644171.c | /**
* Copyright © 2016, University of Washington
* 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 University of Washington 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 UNIVERSITY OF
* WASHINGTON 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 <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
/**
* Testing the mmap system call for memory mapping a file/device into
* the address space of the calling program.
*/
int main( int argc, char* argv[] ) {
int ps = sysconf( _SC_PAGE_SIZE );
printf( "PageSize: %d\n", ps );
int fd = open( "1GB", O_RDWR );
if( fd < 0 ) {
perror( "open" );
exit(1);
}
struct stat st;
int sc = fstat( fd, &st );
if( sc ) {
perror( "fstat" );
exit(1);
}
void* addr = mmap( NULL, st.st_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE, fd, 0 );
if( addr == MAP_FAILED ) {
perror( "mmap" );
exit(1);
}
close( fd );
}
|
the_stack_data/190767812.c | /*
ID:lindong6
PROG:pprime
LANG:C
*/
#include <stdio.h>
#include <math.h>
int isprim(int x){
int max=sqrt(x)+10;
if(x<=1)return 0;
if(x==2)return 1;
int i;
if(x%2==0)return 0;
for(i=3;i<x&&i<max;i+=2)if(x%i==0)return 0;
return 1;
}
int iscycle(int x){
int y=x,num=0;
while (y!=0){
num=num*10+y%10;
y/=10;
}
if (num==x) return 1;
else return 0;
}
int main(void){
int i,a,b;
freopen("pprime.in", "r", stdin);
freopen("pprime.out", "w", stdout);
scanf("%d%d",&a,&b);
#ifdef DEBUG
printf("a=%d,b=%d,i=%d\n",a,b,i);
#endif
if(a>b){
i=a;a=b;b=i;
}
#ifdef DEBUG
printf("a=%d,b=%d,i=%d\n",a,b,i);
#endif
for(i=a;i<=b;i++){
if(1000<=i && i <=9999)continue;
if(100000<=i && i<=999999)continue;
if(i>=10000000)break;
if(iscycle(i))
if(isprim(i))
printf("%d\n",i);
}
return 0;
}
|
the_stack_data/151706763.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
struct Object {
char *s;
char **dict;
int len;
};
void print_words(char **words, int size)
{
int i;
char *s = "";
printf("[");
for (i = 0; i < size; i++) {
printf("%s\"%s\"", s, words[i]);
s = ", ";
}
printf("]");
}
#define container_of(ptr, type, member) \
((type *)((char *)(ptr)) - (size_t)&(((type *)0)->member))
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
#define list_for_each(p, head) \
for (p = (head)->next; p != (head); p = p->next)
#define list_for_each_safe(p, n, head) \
for (p = (head)->next, n = p->next; p != (head); p = n, n = p->next)
struct list_head {
struct list_head *next, *prev;
};
void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list->prev = list;
}
int list_empty(const struct list_head *head)
{
return (head->next == head);
}
void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
void list_add(struct list_head *_new, struct list_head *head)
{
__list_add(_new, head, head->next);
}
void list_add_tail(struct list_head *_new, struct list_head *head)
{
__list_add(_new, head->prev, head);
}
void __list_del(struct list_head *entry)
{
entry->next->prev = entry->prev;
entry->prev->next = entry->next;
}
void list_del(struct list_head *entry)
{
__list_del(entry);
entry->next = entry->prev = NULL;
}
struct word_node {
char *word;
struct list_head link;
};
struct dfs_cache {
int num;
int capacity;
struct list_head **heads;
};
struct dfs_cache *resize(struct dfs_cache **caches, int index)
{
int i;
struct dfs_cache *cache = caches[index];
if (cache->num + 1 > cache->capacity) {
cache->capacity *= 2;
struct list_head **heads = malloc(cache->capacity * sizeof(*heads));
for (i = 0; i < cache->capacity; i++) {
if (i < cache->num) {
heads[i] = cache->heads[i];
} else {
heads[i] = malloc(sizeof(struct list_head));
INIT_LIST_HEAD(heads[i]);
}
}
}
free(cache->heads);
return cache;
}
struct dfs_cache *dfs(char *s, char **words, int *sizes, int num,
struct dfs_cache **caches, int index)
{
if (*s == '\0') {
return NULL;
} else if (caches[index] != NULL) {
return caches[index];
} else {
int i, j;
struct dfs_cache *result = malloc(sizeof(*result));
result->num = 0;
result->capacity = 1;
result->heads = malloc(sizeof(struct list_head *));
result->heads[0] = malloc(sizeof(struct list_head));
INIT_LIST_HEAD(result->heads[0]);
caches[index] = result;
for (i = 0; i < num; i++) {
if (strlen(s) >= sizes[i] && !memcmp(s, words[i], sizes[i])) {
struct dfs_cache *next = dfs(s + sizes[i], words, sizes, num, caches, index + sizes[i]);
if (next != NULL) {
int k = result->num;
for (j = k; j < k + next->num; j++) {
result = resize(caches, index);
struct word_node *wn = malloc(sizeof(*wn));
wn->word = words[i];
list_add(&wn->link, result->heads[j]);
struct list_head *p;
list_for_each(p, next->heads[j - k]) {
struct word_node *wnn = list_entry(p, struct word_node, link);
wn = malloc(sizeof(*wn));
wn->word = wnn->word;
list_add_tail(&wn->link, result->heads[j]);
}
result->num++;
}
} else {
return NULL;
}
}
}
return result;
}
}
bool word_break(char *s, char **word_dict, int word_dict_size)
{
if (word_dict_size < 1) {
return false;
}
int i, total = 0;
int len = strlen(s);
int *sizes = malloc(word_dict_size * sizeof(int));
for (i = 0; i < word_dict_size; i++) {
sizes[i] = strlen(word_dict[i]);
total += sizes[i];
}
struct dfs_cache **caches = malloc(len * sizeof(*caches));
memset(caches, 0, len * sizeof(*caches));
bool ret = (dfs(s, word_dict, sizes, word_dict_size, caches, 0) == NULL);
free(sizes);
free(caches);
return ret;
}
int main(int argc, char **argv)
{
char *dict1[] = { "leet", "code" }, *s1 = "leetcode";
int len1 = sizeof(dict1) / sizeof(char *);
char *dict2[] = { "apple", "pen" }, *s2 = "applepenapple";
int len2 = sizeof(dict2) / sizeof(char *);
char *dict3[] = { "cats", "dog", "sand", "and", "cat" }, *s3 = "catsandog";
int len3 = sizeof(dict3) / sizeof(char *);
struct Object inputs[] = {
//{ .s = s1, .dict = dict1, .len = len1 },
//{ .s = s2, .dict = dict2, .len = len2 },
{ .s = s3, .dict = dict3, .len = len3 },
};
int i, len = sizeof(inputs) / sizeof(struct Object);
for (i = 0; i < len; i++) {
char *s = inputs[i].s;
char **dict = inputs[i].dict;
int size = inputs[i].len;
printf("\n Input: s = \"%s\", wordDict = ", s);
print_words(dict, size);
printf("\n");
bool can = word_break(s, dict, size);
printf("\n Output: %s\n", can ? "true" : "false");
}
return EXIT_SUCCESS;
}
|
the_stack_data/182953118.c | #include <stdio.h>
#include <stdlib.h>
long int func(long n,long * arr);
int main()
{
long n,m=0;
long x[10];
int c=0;
while(scanf("%ld",&n)>0)
{
x[c]=n;
c++;
if(m<n)
m=n;
}
long arr[m];
for(long i=0;i<m;i++)
arr[i]=-1;
arr[0]=0;
int i=0;
while (i<c)
{
long int ans=func(x[i],arr);
printf("%ld\n",arr[x[i]]);
i++;
}
return 0;
}
long int func(long n,long * arr){
//printf("x=%d s=%d\n",x,s);
if(arr[n]){
}
else if(n<12){
arr[n]=n;
}
else{
arr[n]=func(n/2,arr)+func(n/3,arr)+func(n/4,arr);
}
return arr[n];
} |
the_stack_data/198580363.c | // version 1.0 2018-07-19
#include <stdio.h>
typedef unsigned char *byte_pointer;
void show_bytes(byte_pointer start, size_t len)
{
size_t i;
for (i = 0; i < len; i++) {
printf(" %.2x", start[i]);
}
printf("\n");
}
int main()
{
unsigned r = 1U - 2U;
show_bytes((byte_pointer) &r, sizeof(unsigned));
return 0;
}
|
the_stack_data/181392028.c | #include <stdio.h>
#include <math.h>
int simple(long long n)
{
for (long long i = 2; i * i <= n; i++)
if ((n % i) == 0)
return 0;
return 1;
}
int main()
{
double c = 2;
for (int j = 2; j <= 31; j++)
{
if (simple(j))
{
long long a = pow(c, j) - 1;
if (simple(a))
printf("%lld\n", a);
}
}
return 0;
} |
the_stack_data/23724.c | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <stdlib.h>
int dereference_bad() {
int* p;
return *p;
}
void self_assign_bad() {
int x;
x = x;
}
void use_and_mayinit(int, int*);
void call_to_use_and_mayinit_bad() {
int x;
use_and_mayinit(x, &x);
}
void malloc_good() {
int* p = (int*)malloc(sizeof(int));
if (p) {
*p = 5;
int x = *p;
}
free(p);
}
void malloc_bad() {
int* p = (int*)malloc(sizeof(int));
if (p) {
int x = *p;
}
free(p);
}
void init_int_ref(int* p) { *p = 5; }
void interprocedural_init_in_callee_good() {
int x;
init_int_ref(&x);
int y = x;
}
void nop(int* p) {}
void interprocedural_nop_in_callee_bad() {
int x;
nop(&x);
int y = x;
}
void read_int_ref(int* p) { int x = *p; }
void interprocedural_read_in_callee_bad() {
int x;
read_int_ref(&x);
}
int* uninit() { return (int*)malloc(sizeof(int)); }
void interprocedural_uninit_in_callee_bad() {
int* p = uninit();
if (p) {
int x = *p;
}
free(p);
}
struct uninit_s {
int f1;
int f2;
};
void get_field_address_good() {
struct uninit_s* s = (struct uninit_s*)malloc(2 * sizeof(int));
if (s) {
int* p = &s->f1;
}
free(s);
}
void init_f1(struct uninit_s* p) { p->f1 = 5; }
void interprocedural_struct_good() {
struct uninit_s s;
init_f1(&s);
int y = s.f1;
}
void interprocedural_struct_bad() {
struct uninit_s s;
init_f1(&s);
int y = s.f2;
}
void malloc_array_good(int len) {
char* o = (char*)malloc(len);
if (o) {
o[0] = 'a';
char c = o[0];
}
free(o);
}
struct uninit_s unknown_struct();
struct uninit_s unknown_wrapper() {
return unknown_struct();
}
void havoc_calling_unknown_struct_good() {
struct uninit_s x = unknown_wrapper();
int y = x.f1;
}
void malloc_array_bad_FN(int len) {
char* o = (char*)malloc(len);
if (o) {
o[0] = 'a';
char c = o[1];
}
free(o);
}
void local_array_good() {
char o[10];
o[0] = 'a';
char c = o[0];
free(o);
}
void local_array_bad_FN() {
char o[10];
o[0] = 'a';
char c = o[1];
free(o);
}
struct uninit_nested {
struct uninit_s g1;
int g2;
};
void read_g1_f1(struct uninit_nested* x) { int y = x->g1.f1; }
void nested_struct_good() {
struct uninit_nested x;
x.g1.f1 = 42;
read_g1_f1(&x);
}
void nested_struct_bad() {
struct uninit_nested x;
x.g1.f2 = 42;
read_g1_f1(&x);
}
void init_ptr_zero(int* ptr, int i) {
if (i != 0) {
*ptr = 42;
} else {
*(ptr + i) = 42;
}
}
void call_init_ptr_zero_good() {
int x;
init_ptr_zero(&x, 0);
int y = x;
}
int uninit_if_zero_latent(int a) {
int x;
if (a == 0) {
int y = x + 1;
int z = 4;
return z;
}
return 10;
}
void uninit_interproc_manifest_bad() {
int x = uninit_if_zero_latent(0);
if (x == 4) {
int* p = NULL;
*p = 42; // NPE to test that uninit didn't terminate the symbolic execution
}
}
|
the_stack_data/523935.c | // This test verifies that the correct macros are predefined.
//
// RUN: %clang_cc1 %s -E -dM -triple i686-pc-win32 -fms-extensions -fms-compatibility \
// RUN: -fms-compatibility-version=13.00 -o - | FileCheck %s --check-prefix=CHECK-MS
// CHECK-MS: #define _INTEGRAL_MAX_BITS 64
// CHECK-MS: #define _MSC_EXTENSIONS 1
// CHECK-MS: #define _MSC_VER 1300
// CHECK-MS: #define _M_IX86 600
// CHECK-MS: #define _M_IX86_FP
// CHECK-MS: #define _WIN32 1
// CHECK-MS-NOT: #define __STRICT_ANSI__
// CHECK-MS-NOT: GCC
// CHECK-MS-NOT: GNU
// CHECK-MS-NOT: GXX
//
// RUN: %clang_cc1 %s -E -dM -triple x86_64-pc-win32 -fms-extensions -fms-compatibility \
// RUN: -fms-compatibility-version=13.00 -o - | FileCheck %s --check-prefix=CHECK-MS64
// CHECK-MS64: #define _INTEGRAL_MAX_BITS 64
// CHECK-MS64: #define _MSC_EXTENSIONS 1
// CHECK-MS64: #define _MSC_VER 1300
// CHECK-MS64: #define _M_AMD64 1
// CHECK-MS64: #define _M_X64 1
// CHECK-MS64: #define _WIN64 1
// CHECK-MS64-NOT: #define __STRICT_ANSI__
// CHECK-MS64-NOT: GCC
// CHECK-MS64-NOT: GNU
// CHECK-MS64-NOT: GXX
//
// RUN: %clang_cc1 %s -E -dM -triple i686-pc-win32 -fms-compatibility \
// RUN: -o - | FileCheck %s --check-prefix=CHECK-MS-STDINT
// CHECK-MS-STDINT-NOT:#define __INT16_MAX__ 32767
// CHECK-MS-STDINT-NOT:#define __INT32_MAX__ 2147483647
// CHECK-MS-STDINT-NOT:#define __INT64_MAX__ 9223372036854775807LL
// CHECK-MS-STDINT-NOT:#define __INT8_MAX__ 127
// CHECK-MS-STDINT-NOT:#define __INTPTR_MAX__ 2147483647
// CHECK-MS-STDINT-NOT:#define __INT_FAST16_MAX__ 32767
// CHECK-MS-STDINT-NOT:#define __INT_FAST16_TYPE__ short
// CHECK-MS-STDINT-NOT:#define __INT_FAST32_MAX__ 2147483647
// CHECK-MS-STDINT-NOT:#define __INT_FAST32_TYPE__ int
// CHECK-MS-STDINT-NOT:#define __INT_FAST64_MAX__ 9223372036854775807LL
// CHECK-MS-STDINT-NOT:#define __INT_FAST64_TYPE__ long long int
// CHECK-MS-STDINT-NOT:#define __INT_FAST8_MAX__ 127
// CHECK-MS-STDINT-NOT:#define __INT_FAST8_TYPE__ char
// CHECK-MS-STDINT-NOT:#define __INT_LEAST16_MAX__ 32767
// CHECK-MS-STDINT-NOT:#define __INT_LEAST16_TYPE__ short
// CHECK-MS-STDINT-NOT:#define __INT_LEAST32_MAX__ 2147483647
// CHECK-MS-STDINT-NOT:#define __INT_LEAST32_TYPE__ int
// CHECK-MS-STDINT-NOT:#define __INT_LEAST64_MAX__ 9223372036854775807LL
// CHECK-MS-STDINT-NOT:#define __INT_LEAST64_TYPE__ long long int
// CHECK-MS-STDINT-NOT:#define __INT_LEAST8_MAX__ 127
// CHECK-MS-STDINT-NOT:#define __INT_LEAST8_TYPE__ char
// CHECK-MS-STDINT-NOT:#define __UINT16_C_SUFFIX__ U
// CHECK-MS-STDINT-NOT:#define __UINT16_MAX__ 65535U
// CHECK-MS-STDINT-NOT:#define __UINT16_TYPE__ unsigned short
// CHECK-MS-STDINT-NOT:#define __UINT32_C_SUFFIX__ U
// CHECK-MS-STDINT-NOT:#define __UINT32_MAX__ 4294967295U
// CHECK-MS-STDINT-NOT:#define __UINT32_TYPE__ unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT64_C_SUFFIX__ ULL
// CHECK-MS-STDINT-NOT:#define __UINT64_MAX__ 18446744073709551615ULL
// CHECK-MS-STDINT-NOT:#define __UINT64_TYPE__ long long unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT8_C_SUFFIX__ U
// CHECK-MS-STDINT-NOT:#define __UINT8_MAX__ 255U
// CHECK-MS-STDINT-NOT:#define __UINT8_TYPE__ unsigned char
// CHECK-MS-STDINT-NOT:#define __UINTMAX_MAX__ 18446744073709551615ULL
// CHECK-MS-STDINT-NOT:#define __UINTPTR_MAX__ 4294967295U
// CHECK-MS-STDINT-NOT:#define __UINTPTR_TYPE__ unsigned int
// CHECK-MS-STDINT-NOT:#define __UINTPTR_WIDTH__ 32
// CHECK-MS-STDINT-NOT:#define __UINT_FAST16_MAX__ 65535U
// CHECK-MS-STDINT-NOT:#define __UINT_FAST16_TYPE__ unsigned short
// CHECK-MS-STDINT-NOT:#define __UINT_FAST32_MAX__ 4294967295U
// CHECK-MS-STDINT-NOT:#define __UINT_FAST32_TYPE__ unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT_FAST64_MAX__ 18446744073709551615ULL
// CHECK-MS-STDINT-NOT:#define __UINT_FAST64_TYPE__ long long unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT_FAST8_MAX__ 255U
// CHECK-MS-STDINT-NOT:#define __UINT_FAST8_TYPE__ unsigned char
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST16_MAX__ 65535U
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST16_TYPE__ unsigned short
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST32_MAX__ 4294967295U
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST32_TYPE__ unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST64_MAX__ 18446744073709551615ULL
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST64_TYPE__ long long unsigned int
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST8_MAX__ 255U
// CHECK-MS-STDINT-NOT:#define __UINT_LEAST8_TYPE__ unsigned char
//
// RUN: %clang_cc1 %s -E -dM -ffast-math -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-FAST-MATH
// CHECK-FAST-MATH: #define __FAST_MATH__
// CHECK-FAST-MATH: #define __FINITE_MATH_ONLY__ 1
//
// RUN: %clang_cc1 %s -E -dM -ffinite-math-only -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-FINITE-MATH-ONLY
// CHECK-FINITE-MATH-ONLY: #define __FINITE_MATH_ONLY__ 1
//
// RUN: %clang %s -E -dM -fno-finite-math-only -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-NO-FINITE-MATH-ONLY
// CHECK-NO-FINITE-MATH-ONLY: #define __FINITE_MATH_ONLY__ 0
//
// RUN: %clang_cc1 %s -E -dM -o - \
// RUN: | FileCheck %s --check-prefix=CHECK-FINITE-MATH-FLAG-UNDEFINED
// CHECK-FINITE-MATH-FLAG-UNDEFINED: #define __FINITE_MATH_ONLY__ 0
//
// RUN: %clang_cc1 %s -E -dM -o - -triple i686 -target-cpu i386 \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_I386
// CHECK-SYNC_CAS_I386-NOT: __GCC_HAVE_SYNC_COMPARE_AND_SWAP
//
// RUN: %clang_cc1 %s -E -dM -o - -triple i686 -target-cpu i486 \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_I486
// CHECK-SYNC_CAS_I486: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
// CHECK-SYNC_CAS_I486: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
// CHECK-SYNC_CAS_I486: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
// CHECK-SYNC_CAS_I486-NOT: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
//
// RUN: %clang_cc1 %s -E -dM -o - -triple i686 -target-cpu i586 \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_I586
// CHECK-SYNC_CAS_I586: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
// CHECK-SYNC_CAS_I586: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
// CHECK-SYNC_CAS_I586: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
// CHECK-SYNC_CAS_I586: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
//
// RUN: %clang_cc1 %s -E -dM -o - -triple armv6 -target-cpu arm1136j-s \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_ARM
// CHECK-SYNC_CAS_ARM: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
// CHECK-SYNC_CAS_ARM: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
// CHECK-SYNC_CAS_ARM: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
// CHECK-SYNC_CAS_ARM: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
//
// RUN: %clang_cc1 %s -E -dM -o - -triple armv7 -target-cpu cortex-a8 \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_ARMv7
// CHECK-SYNC_CAS_ARMv7: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
// CHECK-SYNC_CAS_ARMv7: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
// CHECK-SYNC_CAS_ARMv7: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
// CHECK-SYNC_CAS_ARMv7: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
//
// RUN: %clang_cc1 %s -E -dM -o - -triple armv6 -target-cpu cortex-m0 \
// RUN: | FileCheck %s --check-prefix=CHECK-SYNC_CAS_ARMv6
// CHECK-SYNC_CAS_ARMv6-NOT: __GCC_HAVE_SYNC_COMPARE_AND_SWAP
|
the_stack_data/182952290.c | //*****************************************************************************
//
// startup_codered.c - Startup code for use with code_red tools.
//
// Copyright (c) 2009-2012 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 8555 of the EK-LM3S9B90 Firmware Package.
//
//*****************************************************************************
//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
//*****************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//*****************************************************************************
extern void USBUARTIntHandler(void);
extern void USB0DeviceIntHandler(void);
//*****************************************************************************
//
// The entry point for the application.
//
//*****************************************************************************
#if defined(__REDLIB__)
#define __MAIN__ __main
#else
#define __MAIN__ main
#endif
extern int __MAIN__(void);
//*****************************************************************************
//
// Reserve space for the system stack.
//
//*****************************************************************************
extern unsigned long _vStackTop;
//*****************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000.
//
//*****************************************************************************
__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) =
{
(void (*)(void))((unsigned long)&_vStackTop),
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // The MPU fault handler
IntDefaultHandler, // The bus fault handler
IntDefaultHandler, // The usage fault handler
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // SVCall handler
IntDefaultHandler, // Debug monitor handler
0, // Reserved
IntDefaultHandler, // The PendSV handler
IntDefaultHandler, // The SysTick handler
IntDefaultHandler, // GPIO Port A
IntDefaultHandler, // GPIO Port B
IntDefaultHandler, // GPIO Port C
IntDefaultHandler, // GPIO Port D
IntDefaultHandler, // GPIO Port E
USBUARTIntHandler, // UART0 Rx and Tx
IntDefaultHandler, // UART1 Rx and Tx
IntDefaultHandler, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0
IntDefaultHandler, // PWM Generator 1
IntDefaultHandler, // PWM Generator 2
IntDefaultHandler, // Quadrature Encoder 0
IntDefaultHandler, // ADC Sequence 0
IntDefaultHandler, // ADC Sequence 1
IntDefaultHandler, // ADC Sequence 2
IntDefaultHandler, // ADC Sequence 3
IntDefaultHandler, // Watchdog timer
IntDefaultHandler, // Timer 0 subtimer A
IntDefaultHandler, // Timer 0 subtimer B
IntDefaultHandler, // Timer 1 subtimer A
IntDefaultHandler, // Timer 1 subtimer B
IntDefaultHandler, // Timer 2 subtimer A
IntDefaultHandler, // Timer 2 subtimer B
IntDefaultHandler, // Analog Comparator 0
IntDefaultHandler, // Analog Comparator 1
IntDefaultHandler, // Analog Comparator 2
IntDefaultHandler, // System Control (PLL, OSC, BO)
IntDefaultHandler, // FLASH Control
IntDefaultHandler, // GPIO Port F
IntDefaultHandler, // GPIO Port G
IntDefaultHandler, // GPIO Port H
IntDefaultHandler, // UART2 Rx and Tx
IntDefaultHandler, // SSI1 Rx and Tx
IntDefaultHandler, // Timer 3 subtimer A
IntDefaultHandler, // Timer 3 subtimer B
IntDefaultHandler, // I2C1 Master and Slave
IntDefaultHandler, // Quadrature Encoder 1
IntDefaultHandler, // CAN0
IntDefaultHandler, // CAN1
IntDefaultHandler, // CAN2
IntDefaultHandler, // Ethernet
IntDefaultHandler, // Hibernate
USB0DeviceIntHandler, // USB0
IntDefaultHandler, // PWM Generator 3
IntDefaultHandler, // uDMA Software Transfer
IntDefaultHandler, // uDMA Error
IntDefaultHandler, // ADC1 Sequence 0
IntDefaultHandler, // ADC1 Sequence 1
IntDefaultHandler, // ADC1 Sequence 2
IntDefaultHandler, // ADC1 Sequence 3
IntDefaultHandler, // I2S0
IntDefaultHandler, // External Bus Interface 0
IntDefaultHandler // GPIO Port J
};
//*****************************************************************************
//
// The following are constructs created by the linker, indicating where the
// the "data" and "bss" segments reside in memory. The initializers for the
// for the "data" segment resides immediately following the "text" segment.
//
//*****************************************************************************
extern unsigned long _etext;
extern unsigned long _data;
extern unsigned long _edata;
extern unsigned long _bss;
extern unsigned long _ebss;
//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
unsigned long *pulSrc, *pulDest;
//
// Copy the data segment initializers from flash to SRAM.
//
pulSrc = &_etext;
for(pulDest = &_data; pulDest < &_edata; )
{
*pulDest++ = *pulSrc++;
}
//
// Zero fill the bss segment.
//
__asm(" ldr r0, =_bss\n"
" ldr r1, =_ebss\n"
" mov r2, #0\n"
" .thumb_func\n"
"zero_loop:\n"
" cmp r0, r1\n"
" it lt\n"
" strlt r2, [r0], #4\n"
" blt zero_loop");
//
// Call the application's entry point.
//
__MAIN__();
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
|
the_stack_data/112717.c | /* ********************************************************************** */
/**
* @brief Command line tool to escape characters greater than 0x7F.
* @author eel3
* @date 2020/06/21
*
* @par Compilers
* - TDM-GCC 4.8.1 (Windows 7 64bit SP1)
* - Visual Studio 2005 SP1 (Windows 7 64bit SP1)
* - Visual Studio 2010 SP1 (Windows 7 64bit SP1)
*/
/* ********************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
# if !defined(__MINGW32__) && !defined(__MINGW64__)
# ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
# endif /* ndef _CRT_SECURE_NO_WARNINGS */
# endif /* !defined(__MINGW32__) && !defined(__MINGW64__) */
#endif /* defined(_WIN32) || defined(_WIN64) */
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ---------------------------------------------------------------------- */
/* Constant */
/* ---------------------------------------------------------------------- */
/** File separator */
#if defined(_WIN32) || defined(_WIN64)
# define PATH_SEP '\\'
#else /* defined(_WIN32) || defined(_WIN64) */
# define PATH_SEP '/'
#endif /* defined(_WIN32) || defined(_WIN64) */
/* ---------------------------------------------------------------------- */
/* Variable */
/* ---------------------------------------------------------------------- */
/** The program name. */
static const char *program_name;
/* ---------------------------------------------------------------------- */
/* Function-like macro */
/* ---------------------------------------------------------------------- */
/* ====================================================================== */
/**
* @brief Return true if string s1 equal to s2.
*
* @param[in] s1 string 1.
* @param[in] s2 string 2.
*
* @retval !=0 Equal.
* @retval 0 Not equal.
*/
/* ====================================================================== */
#define STREQ(s1, s2) (((s1)[0] == (s2)[0]) && (strcmp((s1), (s2)) == 0))
/* ---------------------------------------------------------------------- */
/* Function */
/* ---------------------------------------------------------------------- */
/* ====================================================================== */
/**
* @brief Tiny copy of basename(3).
*
* @param[in] *name (See man 3 basename).
*
* @return (See man 3 basename).
*/
/* ====================================================================== */
static const char *my_basename(const char * const name)
{
const char *bn;
assert(name != NULL);
bn = strrchr(name, PATH_SEP);
return (bn == NULL) ? name : bn+1;
}
/* ====================================================================== */
/**
* @brief Show usage,
*
* @param[in,out] *out Output stream.
*/
/* ====================================================================== */
static void usage(FILE * const out)
{
assert(out != NULL);
(void) fprintf(out, "usage: %s [-hv] [-o output] [file ...]\n", program_name);
}
/* ====================================================================== */
/**
* @brief Show version number,
*/
/* ====================================================================== */
static void version(void)
{
(void) fprintf(stdout, "%s 2020-06-21\n", program_name);
}
/* ====================================================================== */
/**
* @brief Escape characters greater than 0x7F.
*
* @param[in,out] *in input stream
* @param[in,out] *out output stream
*/
/* ====================================================================== */
static void do_escape(FILE *in, FILE *out)
{
int c;
assert((in != NULL) && (out != NULL));
while ((c = fgetc(in)) != EOF) {
if (c >= 0x80) {
(void) fprintf(out, "\\x%02X", (unsigned) c);
} else {
(void) fputc(c, out);
}
}
}
/* ********************************************************************** */
/**
* @brief Main routine.
*
* @retval EXIT_SUCCESS OK (success).
* @retval EXIT_FAILURE NG (failure).
*/
/* ********************************************************************** */
int main(int argc, char *argv[])
{
const char *output;
FILE *out;
int retval;
program_name = my_basename(argv[0]);
output = "-";
for (; (argc > 1) && (argv[1][0] == '-') && (argv[1][1] != '\0'); argc--, argv++) {
const char *p = &argv[1][1];
if (argv[1][1] == '-') {
p = &argv[1][2];
if (*p == '\0') {
argc--, argv++;
break;
} else if (STREQ(p, "help")) {
usage(stdout);
return EXIT_SUCCESS;
} else if (STREQ(p, "output")) {
if (argc < 3) {
usage(stderr);
return EXIT_FAILURE;
} else {
argc--, argv++;
output = argv[1];
}
} else if (STREQ(p, "version")) {
version();
return EXIT_SUCCESS;
} else {
usage(stderr);
return EXIT_FAILURE;
}
continue;
}
do switch (*p) {
case 'h':
usage(stdout);
return EXIT_SUCCESS;
case 'o':
if (p[1] != '\0') {
output = &p[1];
p += strlen(output);
} else if (argc < 3) {
usage(stderr);
return EXIT_FAILURE;
} else {
argc--, argv++;
output = argv[1];
}
break;
case 'v':
version();
return EXIT_SUCCESS;
default:
usage(stderr);
return EXIT_FAILURE;
} while (*++p != '\0');
}
if (STREQ(output, "-")) {
out = stdout;
} else if (errno = 0, (out = fopen(output, "w")) == NULL) {
perror(output);
return EXIT_FAILURE;
} else {
/*EMPTY*/
}
retval = EXIT_SUCCESS;
if (argc <= 1) {
do_escape(stdin, out);
} else {
int i;
FILE *in;
for (i = 1; i < argc; ++i) {
if (STREQ(argv[i], "-")) {
in = stdin;
} else if (errno = 0, (in = fopen(argv[i], "r")) == NULL) {
perror(argv[i]);
retval = EXIT_FAILURE;
continue;
} else {
/*EMPTY*/
}
do_escape(in, out);
if (in != stdin) {
(void) fclose(in);
}
}
}
if (out != stdout) {
(void) fclose(out);
}
return retval;
}
|
the_stack_data/135051.c | // RUN: %clang -target aarch64 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57 %s
// RUN: %clang -target aarch64 -mlittle-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57 %s
// RUN: %clang -target aarch64_be -mlittle-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57 %s
// RUN: %clang -target aarch64 -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-TUNE %s
// RUN: %clang -target aarch64 -mlittle-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-TUNE %s
// RUN: %clang -target aarch64_be -mlittle-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-TUNE %s
// CA57: "-cc1"{{.*}} "-triple" "aarch64{{(--)?}}"{{.*}} "-target-cpu" "cortex-a57"
// CA57-TUNE: "-cc1"{{.*}} "-triple" "aarch64{{(--)?}}"{{.*}} "-target-cpu" "generic"
// RUN: %clang -target arm64 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s
// RUN: %clang -target arm64 -mlittle-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s
// RUN: %clang -target arm64 -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-TUNE %s
// RUN: %clang -target arm64 -mlittle-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-TUNE %s
// ARM64-CA57: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "cortex-a57"
// ARM64-CA57-TUNE: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "generic"
// RUN: %clang -target aarch64_be -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s
// RUN: %clang -target aarch64 -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s
// RUN: %clang -target aarch64_be -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s
// RUN: %clang -target aarch64_be -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE-TUNE %s
// RUN: %clang -target aarch64 -mbig-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE-TUNE %s
// RUN: %clang -target aarch64_be -mbig-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE-TUNE %s
// CA57-BE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "cortex-a57"
// CA57-BE-TUNE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "generic"
// RUN: %clang -target aarch64 -mcpu=cortex-a57 -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=MCPU-MTUNE-A57 %s
// RUN: %clang -target aarch64 -mtune=cortex-a53 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=MCPU-MTUNE-A57 %s
// MCPU-MTUNE-A57: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-cpu" "cortex-a57"
|
the_stack_data/12637892.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
void ordenacaoBinaria(char *vet);
int main(){
char texto[] = "heflain";
ordenacaoBinaria(texto);
printf("%s\n",texto);
return 0;
}
void ordenacaoBinaria(char *vet){
int i, j, tam = strlen(vet);
int meio,dir, esq;
char aux;
for (i = 1; i < tam ; i++){
aux = vet[i];
esq = 0;
dir = i;
//busca binaria
while (esq < dir){
meio = (esq + dir) / 2;
if (vet[meio] <= aux){
esq = meio + 1;
}else{
dir = meio;
}
}
for (j = i; j > esq; j--)
{
vet[j] = vet[j -1];
}
vet[dir] = aux;//só é ´posivel por que na busca dir só para quando esq < dir
//printf("direito %d e esquerdo %d\n", dir, esq);
}
} |
the_stack_data/218892978.c | /* remove( const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
/* This is an example implementation of remove() fit for use with POSIX kernels.
*/
#include <stdio.h>
#ifndef REGTEST
#include <string.h>
#include <errno.h>
extern struct _PDCLIB_file_t* _PDCLIB_filelist;
int remove(const char* pathname)
{
errno = ENOTSUP;
return 1;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main(void)
{
/* Testing covered by ftell.c (and several others) */
return TEST_RESULTS;
}
#endif
|
the_stack_data/103266773.c | #include <stdio.h>
int main()
{
int n, triangular, fator = 0;
printf("\nInforme um número 'n' para ver os 'n' primeiros números triangulares: ");
scanf("%i", &n);
printf("\n");
for (int i = 0; i < n; i++)
{
triangular = (fator * (fator + 1) * (fator + 2));
fator++;
if (i == (n - 1))
{
printf("%i.", triangular);
}
else
{
printf("%i,", triangular);
}
}
printf("\n\n");
return 0;
} |
the_stack_data/26699574.c | /* Copyright (C) 2004-2015 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <stdlib.h>
/* Return 1 if the whole area PTR .. PTR+SIZE is not writable.
Return -1 if it is writable. */
int
__readonly_area (const void *ptr, size_t size)
{
/* We cannot determine in general whether memory is writable or not.
This must be handled in a system-dependent manner. to not
unconditionally break code we need to return here a positive
answer. This disables this security measure but that is the
price people have to pay for using systems without a real
implementation of this interface. */
return 1;
}
|
the_stack_data/176704854.c | /*
* Author: Manuel
* Email: [email protected]
* Created: 2016-09-01 11:06:31
* @Last Modified by: Manuel
* @Last Modified time: 2016-09-01 11:32:33
*
* Description: Implements the atob function that translates an string into an int
*/
#include <ctype.h>
#include <stddef.h>
int atob(size_t* value_store, char* string, int base)
{
size_t value = 0;
int digit = 0, sign = 1;
//Check the base
if(base == 0)
{
if(string[0] == '0')
{
switch (string[1])
{
case 'x':
case 'X':
base = 16;
break;
case 't':
case 'n':
base = 10;
case 'o':
base = 8;
default:
base = 10;
goto skip;
}
string += 2;
}
else
return 0;
}
skip:
*value_store = value;
if(*string == '-')
{
sign = -1;
string++;
}
else if(*string == '+')
string++;
for(; *string; string++)
{
if(*string >= '0' && *string <= '9')
digit = digit_to_int(*string);
else if(*string >= 'a' && *string <= 'f')
digit = *string - 'a' + 10;
else if(*string >= 'A' && *string <= 'F')
digit = *string - 'A' + 10;
else
return 0;
//The specified base is invalid
if(digit > base)
return 0;
value *= base;
value += digit;
}
*value_store = sign*value;
//Success convering the number
return 1;
} |
the_stack_data/200143086.c | /// ## About
/// - _stddoc.c_ is a tiny documentation generator for 60 programming languages.
/// - This page sample was auto-generated from the code comments found in `stddoc.c` file.
///
/// ## How does it work?
/// - Markdeep code comments are extracted from stdin and printed into stdout as a HTML file.
///
/// ## Supported languages
/// - `/// Three slashes comment` [ActionScript, AngelScript, C (C99), C#, C++, ChaiScript, D,
/// GameMonkey, GML, Go, Java, JavaScript, JetScript, jtc, Jx9, Kotlin, Neko, Object Pascal (Delphi),
/// Objective-C, Pawn, PHP, QuakeC, Rust, SASS, Scala, Squirrel, Swift, Vala, Wren, Xojo].
/// - `--- Three dashes comment` [Ada, AppleScript, Eiffel, Euphoria, Haskell, Lua, Occam,
/// PL/SQL, PSL, SGML, SPARK, SQL, Terra, TSQL, VHDL].
/// - `### Three hashes comment` [AWK, Bash, Bourne shell, C shell, Cobra, Maple, Maple,
/// Perl, Perl6, PowerShell, Python, R, Ruby, Seed7, Tcl].
///
/// ## Usage
/// - `stddoc < source.code > documentation.html`
///
/// ## Changelog
/// 2018/01/07
/// : Initial version (_v1.0.0_)
///
/// ## License
/// - rlyeh, unlicensed (~public domain).
#include <stdio.h>
int main() {
printf("%s\n", "<meta charset='utf-8' emacsmode='-*- markdown -*-'>");
printf("%s\n", "<link rel='stylesheet' href='https://casual-effects.com/markdeep/latest/apidoc.css?'>");
for( int fsm_S = 0, fsm_D = 0, fsm_H = 0; !feof(stdin); ) {
int chr = getc(stdin);
if( fsm_S > 3 || fsm_D > 3 || fsm_H > 3 ) {
putc(chr, stdout);
if( chr != '\r' && chr != '\n' ) continue;
}
/**/ if( fsm_S <= 2 && chr == '/' && !fsm_D && !fsm_H ) fsm_S++;
else if( fsm_S == 3 && chr == ' ' && !fsm_D && !fsm_H ) fsm_S++;
else if( fsm_D <= 2 && chr == '-' && !fsm_S && !fsm_H ) fsm_D++;
else if( fsm_D == 3 && chr == ' ' && !fsm_S && !fsm_H ) fsm_D++;
else if( fsm_H <= 2 && chr == '#' && !fsm_S && !fsm_D ) fsm_H++;
else if( fsm_H == 3 && chr == ' ' && !fsm_S && !fsm_D ) fsm_H++;
else fsm_S = fsm_D = fsm_H = 0;
}
printf("%s\n", "<script>markdeepOptions={tocStyle:'medium'};</script>");
printf("%s\n", "<!-- Markdeep: --><script src='https://casual-effects.com/markdeep/latest/markdeep.min.js?'></script>");
}
///
/// ## **Example page!**
///
/// Imaginary documentation page. Here would be some introduction text.
///
/// The table of contents that Markdeep produces is stuffed on the right side,
/// if the browser window is wide enough. Otherwise it is hidden.
///
/// ### Basic Markdeep
///
/// Regular styling like **bold**, _italics_, ~~strikethrough~~, `inline code`, etc. Lists as:
///
/// * A
/// * Bullet
/// * List
///
/// And:
///
/// 1. A
/// 1. Numbered
/// 1. List!
///
/// Symbol substitutions: a 45-degree turn; som x -> y arrows; some whoa ==> fancy <==> arrows.
///
/// Is this a definition list?
/// : Looks like one to me
/// Is that right?
/// : Possibly!
///
/// And a code listing:
///
/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/// int main()
/// {
/// return 1;
/// }
/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
///
///
/// ### Tables
///
/// Thing Name | Description |Notes
/// ------------------------|--------------------|-----
/// Yes | Yup! |
/// No | Nope :( |
/// FileNotFound | Doesn't find files | Pass `-sFIND_FILE=maybe` to maybe find them
///
///
/// ### Diagrams
///
/// ******************************************* Here's a text to the right of the diagram,
/// * +-----------------+ .-. * ain't that fancy. Pretty fancy indeed, I
/// * |\ | .-+ | * must say! Markdeep diagrams are generally
/// * | \ A-B *---+--> .--+ '--. * enclosed into a rectangle full made of `*`
/// * | \ | | Cloud! | * symbols; and are "drawn" using ASCII-art
/// * +---+-------------+ '-------------' * style, with `- | + / \ * o` etc.
/// ******************************************* Suh-weet!
///
/// Another random diagram, just because:
///
/// ********************
/// * +-+-+-+-*-o *
/// * / / ^ / *
/// * / v / / *
/// * +-+-+-+ *
/// ********************
///
/// ### Special notes
///
/// !!! Note
/// Hey I'm a note. Don't mind me, I'm just sitting here.
///
/// !!! WARNING
/// I'm a warning, perhaps. *Something might happen!*
///
/// !!! Error: Never Pass `nullptr` to a Shader
/// Invoking a shader with a null argument can seg fault.
/// This is a multi-line admonition.
///
/// Seriously, don't call shaders like that.
///
/// ### Embedding HTML
///
/// <pre>
/// This is an embedded html node by the way!
/// </pre>
///
/// ## Credits
/// - API doc style created by [Aras Pranckevičius](https://github.com/aras-p)
/// - Markdeep by [Morgan McGuire](https://casual-effects.com/markdeep/).
|
the_stack_data/821305.c |
#include <stdio.h>
void scilab_rt_contour_d2i2i2d2d0d0_(int in00, int in01, double matrixin0[in00][in01],
int in10, int in11, int matrixin1[in10][in11],
int in20, int in21, int matrixin2[in20][in21],
int in30, int in31, double matrixin3[in30][in31],
double scalarin0,
double scalarin1)
{
int i;
int j;
double val0 = 0;
int val1 = 0;
int val2 = 0;
double val3 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%f", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%d", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%d", val2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
printf("%f", scalarin0);
printf("%f", scalarin1);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.