file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/770947.c | #include <stdio.h>
#include <math.h>
int main(){
int a, b, c;
for(a = 1; a <= 1000; a++){
for(b = a; b <= 1000; b++){
c = sqrt(a*a + b*b);
if(1000 == a + b + c && a*a + b*b == c*c){
printf("a: %d, b: %d, c: %d, prod: %d\n",a, b, c, a * b * c);
//return 0;
}
}
}
return 0;
}
|
the_stack_data/95450335.c | #include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/resource.h>
int main(int argc, char **argv)
{
struct sigaction sa; /* 시그널 처리를 위한 시그널 액션 */
struct rlimit rl;
int fd0, fd1, fd2, i;
pid_t pid;
if(argc < 2) {
printf("Usage : %s command\n", argv[0]);
return -1;
}
/* 파일 생성을 위한 마스크를 0으로 설정 */
umask(0);
/* 사용할 수 있는 최대의 파일 디스크립터 수 얻기 */
if(getrlimit(RLIMIT_NOFILE, &rl) < 0) {
perror("getlimit()");
}
if((pid = fork()) < 0) {
perror("error()");
} else if(pid != 0) { /* 부모 프로세스는 종료한다. */
return 0;
}
/* 터미널을 제어할 수 없도록 세션의 리더가 된다. */
setsid();
/* 터미널 제어와 관련된 시그널을 무시한다. */
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if(sigaction(SIGHUP, &sa, NULL) < 0) {
perror("sigaction() : Can't ignore SIGHUP");
}
/* 프로세스의 워킹 디렉터리를 ‘/’로 설정한다. */
if(chdir("/") < 0) {
perror("cd()");
}
/* 프로세스의 모든 파일 디스크립터를 닫는다. */
if(rl.rlim_max == RLIM_INFINITY) {
rl.rlim_max = 1024;
}
for(i = 0; i < rl.rlim_max; i++) {
close(i);
}
/* 파일 디스크립터 0, 1과 2를 /dev/null로 연결한다. */
fd0 = open("/dev/null", O_RDWR);
fd1 = dup(0);
fd2 = dup(0);
/* 로그 출력을 위한 파일 로그를 연다. */
openlog(argv[1], LOG_CONS, LOG_DAEMON);
if(fd0 != 0 || fd1 != 1 || fd2 != 2) {
syslog(LOG_ERR, "unexpected file descriptors %d %d %d", fd0, fd1, fd2);
return -1;
}
/* 로그 파일에 정보 수준의 로그를 출력한다. */
syslog(LOG_INFO, "Daemon Process");
while(1) {
/* 데몬 프로세스로 해야 할 일을 반복 수행 */
}
/* 시스템 로그를 닫는다. */
closelog();
return 0;
}
|
the_stack_data/476664.c | #include<stdio.h>
int main()
{
int redius =3;
float pi =3.14;
printf("the area of the circul %f\n",pi*redius*redius);
} |
the_stack_data/1068457.c | #define GPHCON (*((volatile unsigned int *)0x56000070))
#define ULCON0 (*((volatile unsigned int *)0x50000000))
#define UCON0 (*((volatile unsigned int *)0x50000004))
#define UTRSTAT0 (*((volatile unsigned int *)0x50000010))
#define UBRDIV0 (*((volatile unsigned int *)0x50000028))
#define UTXH0 (*((volatile unsigned char *)0x50000020))
#define URXH0 (*((volatile unsigned char *)0x50000024))
void uart_config()
{
/* 配置引脚为TXD和RXD */
GPHCON &= ~((3<<7)|(3<<5)); //清零
GPHCON |= ((1<<7)|(1<<5)); //置一
/* 配置ULCON0
- [6] Infrared Mode 为正常模式：ULCON0[6] = 0
- [5:3] Parity Mode 没有校验位（简单嘛）：ULCON0[5:3] = 0xx
- [2] Number of Stop Bit 每帧一个停止位 ： ULCON0[2] = 0
- [1:0] Word Length 数据位数为8位： ULCON0[1:0] = 0b11
- 也就是 ULCON0 = 0b11 = 0x3
*/
ULCON0 = 3;
/* 配置UCON0
- [15:12] FCLK Divider 不需要用，所以就不设置吧，默认0，不用
- [11:10] Clock Selection 选择PCLK ： UCON0[11:10] = 00 or 10
- [9] Tx Interrupt Type 默认0，不用
- [8] Rx Interrupt Type 默认0，不用
- [7] Rx Time Out Enable 默认0，不用
- [6] Rx Error Status Interrupt Enable 默认0，不用
- [5] Loopback Mode 默认0，不用
- [4] Send Break Signal 默认0，不用
- [3:2] Transmit Mode 设置为中断模式，没其他可以选了：UCON0[3:2] = 0b01
- [1:0] Receive Mode 设置为中断模式，没其他可以选了：UCON0[1:0] = 0b01
**即 UCON0 = 0x5 or 0x805**
*/
UCON0 = 0x5;
/* 配置波特率UBRDIVn
* UBRDIVn = (int)( 50 000 000 / ( 115200 x 16) ) –1 = 26.12 ≈ 26
*/
UBRDIV0 = 26;
}
int putchar(int c)
{
/* UTRSTAT0寄存器
- [2] Transmitter empty 数据发完了就是1
- [1] Transmit buffer empty 数据缓存空的就是1
- [0] Receive buffer data ready 有数据可接收时是1
*/
while(!(UTRSTAT0&(1<<2))); //当寄存器第二位是1时一直循环
UTXH0 = (unsigned char)c; //UTXH0是1个字节的
}
int getchar()
{
/* UTRSTAT0寄存器
- [2] Transmitter empty 数据发完了就是1
- [1] Transmit buffer empty 数据缓存空的就是1
- [0] Receive buffer data ready 有数据可接收时是1
*/
while(!(UTRSTAT0&(1<<0)));
return URXH0;
}
int puts(const char *s)
{
while(*s)
{
putchar(*s++);
}
}
|
the_stack_data/18887809.c | #include <stdio.h>
int main() {
const char* abc = "abc";
printf("%s",abc);
return 0;
}
|
the_stack_data/969100.c | /*
* This program finds the missing number from an array of numbers of size
* 'n' in which all numbers are within the range 0 to 'n'.
*/
#include<stdio.h>
#include<assert.h>
#define ILLEGAL -1
/*
* This function finds the missing number from an array of numbers of
* size 'n' in which all numbers are within the range 0 to 'n'. If the
* array is not valid, then this function will return '-1'. This
* function adds all the numbers in [0, 'n'] and then subtracts the sum
* of all the elements in the array. The time complexity of this function
* is O(n), where 'n' is the number of array elements. The space
* complexity of this function is O(1). This function does two paases
* over all elements in range [0, 'n'].
*/
int find_missing_number_among_0_to_n_v1 (int* array, int len)
{
int sum, i;
/*
* If array is NULL or the length of the array is
* not valid, then return '-1'.
*/
if (!array || (len <= 0)) {
return(ILLEGAL);
}
sum = 0;
/*
* First add all numbers from 0 to 'len'
*/
for (i = 0; i <= len; ++i) {
sum += i;
}
/*
* From the 'sum' subtract the sum of all the
* array elements
*/
for (i = 0; i < len; ++i) {
sum -= array[i];
}
/*
* Return the missing number
*/
return(sum);
}
/*
* This function finds the missing number from an array of numbers of
* size 'n' in which all numbers are within the range 0 to 'n'. If the
* array is not valid, then this function will return '-1'. This
* function adds all the numbers in [0, 'n'] and simultaneously subtracts
* the sum of all the elements in the array. The time complexity of this
* function is O(n), where 'n' is the number of array elements. The space
* complexity of this function is O(1). This function does one paases over
* all elements in range [0, 'n'].
*/
int find_missing_number_among_0_to_n_v2 (int* array, int len)
{
int sum, i;
/*
* If array is NULL or the length of the array is
* not valid, then return '-1'.
*/
if (!array || (len <= 0)) {
return(ILLEGAL);
}
sum = 0;
/*
* Add all numbers from 0 to 'len' and also subtract
* the array elements from this 'sum'.
*/
for (i = 0; i <= len; ++i) {
sum += i;
/*
* If index is less than 'len', then subtract
* from the sum
*/
if (i < len) {
sum -= array[i];
}
}
/*
* Return the missing number
*/
return(sum);
}
/*
* This function finds the missing number from an array of numbers of
* size 'n' in which all numbers are within the range 0 to 'n'. If the
* array is not valid, then this function will return '-1'. This
* function adds all the numbers in [0, 'n'] and simultaneously subtracts
* the sum of all the elements in the array. The time complexity of this
* function is O(n), where 'n' is the number of array elements. The space
* complexity of this function is O(1). This function does one paases over
* all elements in range [0, 'n'].
*/
int find_missing_number_among_0_to_n_v3 (int* array, int len)
{
int sum, i;
/*
* If array is NULL or the length of the array is
* not valid, then return '-1'.
*/
if (!array || (len <= 0)) {
return(ILLEGAL);
}
sum = 0;
/*
* Add all numbers from 0 to 'len - 1' and also subtract
* the array elements from this 'sum'.
*/
for (i = 0; i < len; ++i) {
sum += i;
sum -= array[i];
}
/*
* Add 'len' to the sum
*/
sum += len;
/*
* Return the missing number
*/
return(sum);
}
/*
* This function finds the missing number from an array of numbers of
* size 'n' in which all numbers are within the range 0 to 'n'. If the
* array is not valid, then this function will return '-1'. This function
* xors all the numbers in [0, 'n'] and simultaneously xors the elements
* in the array from the xor of all elements from [0, 'n']. The time
* complexity of this function is O(n), where 'n' is the number of array
* elements. The space complexity of this function is O(1). This function
* does one paases over all elements in range [0, 'n'].
*/
int find_missing_number_among_0_to_n_v4 (int* array, int len)
{
int sum, i;
/*
* If array is NULL or the length of the array is
* not valid, then return '-1'.
*/
if (!array || (len <= 0)) {
return(ILLEGAL);
}
sum = 0;
/*
* bitwise XOR all numbers from 0 to 'len - 1' and also
* xor the array elements from this running xor.
*/
for (i = 0; i < len; ++i) {
sum ^= i;
sum ^= array[i];
}
/*
* Bitwise XOR 'len' to the sum
*/
sum ^= len;
/*
* Return the missing number
*/
return(sum);
}
int main ()
{
/*
* Test 0: Test with NULL array and legal length. The missing
* element returned should be ILLEGAL.
*/
int* array0 = NULL;
int len0 = 10;
assert(ILLEGAL == find_missing_number_among_0_to_n_v1(array0, len0));
assert(ILLEGAL == find_missing_number_among_0_to_n_v2(array0, len0));
assert(ILLEGAL == find_missing_number_among_0_to_n_v3(array0, len0));
assert(ILLEGAL == find_missing_number_among_0_to_n_v4(array0, len0));
/*
* Test 1: Test with valid array but illegal length. The missing
* element returned should be ILLEGAL.
*/
int array1[] = {0, 1, 3};
int len1 = -10;
assert(ILLEGAL == find_missing_number_among_0_to_n_v1(array1, len1));
assert(ILLEGAL == find_missing_number_among_0_to_n_v2(array1, len1));
assert(ILLEGAL == find_missing_number_among_0_to_n_v3(array1, len1));
assert(ILLEGAL == find_missing_number_among_0_to_n_v4(array1, len1));
/*
* Test 2: Find a missing number from the array which is neither
* zero nor the maximum number.
*/
int array2[] = {0,1,3,4,5,6,7,8,9,10,11,12,13,14,15};
int len2 = sizeof(array2)/sizeof(int);
assert(2 == find_missing_number_among_0_to_n_v1(array2, len2));
assert(2 == find_missing_number_among_0_to_n_v2(array2, len2));
assert(2 == find_missing_number_among_0_to_n_v3(array2, len2));
assert(2 == find_missing_number_among_0_to_n_v4(array2, len2));
/*
* Test 3: Find a missing number from the array and the missing
* number should be zero.
*/
int array3[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int len3 = sizeof(array3)/sizeof(int);
assert(0 == find_missing_number_among_0_to_n_v1(array3, len3));
assert(0 == find_missing_number_among_0_to_n_v2(array3, len3));
assert(0 == find_missing_number_among_0_to_n_v3(array3, len3));
assert(0 == find_missing_number_among_0_to_n_v4(array3, len3));
/*
* Test 4: Find a missing number from the array and the missing
* number should be he maximum number.
*/
int array4[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int len4 = sizeof(array4)/sizeof(int);
assert(len4 == find_missing_number_among_0_to_n_v1(array4, len4));
assert(len4 == find_missing_number_among_0_to_n_v2(array4, len4));
assert(len4 == find_missing_number_among_0_to_n_v3(array4, len4));
assert(len4 == find_missing_number_among_0_to_n_v4(array4, len4));
return(0);
}
|
the_stack_data/72014085.c | #include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <signal.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <netdb.h>
#define PORT 2000
#define LENGTH 1024
void error(const char *msg)
{
perror(msg);
exit(1);
}
int main(int argc, char *argv[])
{
/* Variable Definition */
int sockfd;
int nsockfd;
char revbuf[LENGTH];
char response[LENGTH];
struct sockaddr_in remote_addr;
char district[20];
char username[20];
printf("Enter Username: ");
gets(username);
printf("\n");
printf("Enter District: ");
gets(district);
printf("\n");
commands();
while (1)
{
/* Get the Socket file descriptor */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
error("ERROR: Failed to obtain Socket Descriptor!\n");
}
/* Fill the socket address struct */
remote_addr.sin_family = AF_INET;
remote_addr.sin_port = htons(PORT);
inet_pton(AF_INET, "127.0.0.1", &remote_addr.sin_addr);
bzero(&(remote_addr.sin_zero), 8);
/* Try to connect the remote */
if (connect(sockfd, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr)) == -1)
{
error("ERROR: Failed to connect to the host!\n");
}
char cmd[LENGTH];
bzero(cmd, LENGTH);
printf("client: ");
gets(cmd);
printf("\n");
if (strcmp(cmd,"1")==0)
{
bzero(username, 20);
bzero(district, 20);
break;
}else
{
if (strcmp(cmd,"add uft.txt")==0)
{
send_file(sockfd,username,district);
}
else
{
if (strcmp(cmd,"check_status")==0 || strcmp(cmd,"get_statement")==0)
{
strncat(cmd," ",2);
strncat(cmd,username,20);
send(sockfd, cmd, sizeof(cmd), 0);
bzero(cmd, LENGTH);
//recieving from the server
if(recv(sockfd, response, sizeof(response), 0)){
printf("server: %s\n",response);
//break;
};
bzero(response, LENGTH);
}
else{
//sending data to the server
strncat(cmd,",",2);
strncat(cmd,username,20);
strncat(cmd,",",2);
strncat(cmd,district,20);
send(sockfd, cmd, sizeof(cmd), 0);
bzero(cmd, LENGTH);
//recieving from the server
if(recv(sockfd, response, sizeof(response), 0)){
printf("server: %s\n",response);
};
}
bzero(response, LENGTH);
}
}
}
close (sockfd);
printf("[Client] Connection lost.\n");
return (0);
}
void send_file(int sock, char username[20],char district[20]){
char line[256];
char response[256];
// char command[50];
// char query[50];
// sscanf(criteria,"%s %s",command,query);
FILE *fp;
fp = fopen("utf.txt","r");
if (fp==NULL){
// printf("Error file not found;");
//break;
}
while(!feof(fp)){
fgets(line,256,fp);
line [ strcspn(line, "\n\r") ] = 0;
strncat(line,",",2);
strncat(line,username,20);
strncat(line,",",2);
strncat(line,district,20);
send(sock, line, sizeof(line), 0);
bzero(line, 256);
}
fclose(fp);
// printf("Ok File %s from Client was Sent!\n", fp);
recv(sock, response, sizeof(response), 0);
printf("server: %s\n",response);
bzero(response, 256);
}
void commands(){
printf("Please choose from the following commands\n");
printf("-----------------------------------------------------\n");
printf("1. To add member: Addmember member_name,date,gender,recommender,signature\n");
printf("2. To check status: check_status\n");
printf("3. To get a statement: get_statement\n");
printf("4. To add members from file: add uft.txt\n");
printf("5. To search in a file: search criteria\n");
printf("6. To add correct a signature: signature <sign>\n");
printf("7. To exit, press: 1\n");
printf("-----------------------------------------------------\n");
} |
the_stack_data/70450671.c | // autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/capability.h>
#include <linux/futex.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static void thread_start(void* (*fn)(void*), void* arg)
{
pthread_t th;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
int i;
for (i = 0; i < 100; i++) {
if (pthread_create(&th, &attr, fn, arg) == 0) {
pthread_attr_destroy(&attr);
return;
}
if (errno == EAGAIN) {
usleep(50);
continue;
}
break;
}
exit(1);
}
typedef struct {
int state;
} event_t;
static void event_init(event_t* ev)
{
ev->state = 0;
}
static void event_reset(event_t* ev)
{
ev->state = 0;
}
static void event_set(event_t* ev)
{
if (ev->state)
exit(1);
__atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG);
}
static void event_wait(event_t* ev)
{
while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}
static int event_isset(event_t* ev)
{
return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}
static int event_timedwait(event_t* ev, uint64_t timeout)
{
uint64_t start = current_time_ms();
uint64_t now = start;
for (;;) {
uint64_t remain = timeout - (now - start);
struct timespec ts;
ts.tv_sec = remain / 1000;
ts.tv_nsec = (remain % 1000) * 1000 * 1000;
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
if (__atomic_load_n(&ev->state, __ATOMIC_RELAXED))
return 1;
now = current_time_ms();
if (now - start > timeout)
return 0;
}
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
};
static struct nlmsg nlmsg;
static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
const void* data, int size)
{
memset(nlmsg, 0, sizeof(*nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}
static void netlink_nest(struct nlmsg* nlmsg, int typ)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_type = typ;
nlmsg->pos += sizeof(*attr);
nlmsg->nested[nlmsg->nesting++] = attr;
}
static void netlink_done(struct nlmsg* nlmsg)
{
struct nlattr* attr = nlmsg->nested[--nlmsg->nesting];
attr->nla_len = nlmsg->pos - (char*)attr;
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len)
{
if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
if (hdr->nlmsg_type == NLMSG_DONE) {
*reply_len = 0;
return 0;
}
if (n < sizeof(struct nlmsghdr))
exit(1);
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 0;
}
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static int netlink_send(struct nlmsg* nlmsg, int sock)
{
return netlink_send_ext(nlmsg, sock, 0, NULL);
}
static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset,
unsigned int total_len)
{
struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset);
if (offset == total_len || offset + hdr->nlmsg_len > total_len)
return -1;
return hdr->nlmsg_len;
}
static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type,
const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(nlmsg, RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr,
sizeof(hdr));
if (name)
netlink_attr(nlmsg, IFLA_IFNAME, name, strlen(name));
netlink_nest(nlmsg, IFLA_LINKINFO);
netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(struct nlmsg* nlmsg, int sock, const char* type,
const char* name)
{
netlink_add_device_impl(nlmsg, type, name);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_veth(struct nlmsg* nlmsg, int sock, const char* name,
const char* peer)
{
netlink_add_device_impl(nlmsg, "veth", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
netlink_nest(nlmsg, VETH_INFO_PEER);
nlmsg->pos += sizeof(struct ifinfomsg);
netlink_attr(nlmsg, IFLA_IFNAME, peer, strlen(peer));
netlink_done(nlmsg);
netlink_done(nlmsg);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_hsr(struct nlmsg* nlmsg, int sock, const char* name,
const char* slave1, const char* slave2)
{
netlink_add_device_impl(nlmsg, "hsr", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(nlmsg, IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(nlmsg, IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done(nlmsg);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_device_change(struct nlmsg* nlmsg, int sock,
const char* name, bool up, const char* master,
const void* mac, int macsize,
const char* new_name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
hdr.ifi_index = if_nametoindex(name);
netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
if (new_name)
netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int netlink_add_addr(struct nlmsg* nlmsg, int sock, const char* dev,
const void* addr, int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize);
netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize);
return netlink_send(nlmsg, sock);
}
static void netlink_add_addr4(struct nlmsg* nlmsg, int sock, const char* dev,
const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(nlmsg, sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(struct nlmsg* nlmsg, int sock, const char* dev,
const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(struct nlmsg* nlmsg, int sock, const char* name,
const void* addr, int addrsize, const void* mac,
int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(nlmsg, RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, NDA_DST, addr, addrsize);
netlink_attr(nlmsg, NDA_LLADDR, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int tunfd = -1;
static int tun_frags_enabled;
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
#define IFF_NAPI_FRAGS 0x0020
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_NAPI | IFF_NAPI_FRAGS;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0)
exit(1);
}
if (ioctl(tunfd, TUNGETIFF, (void*)&ifr) < 0)
exit(1);
tun_frags_enabled = (ifr.ifr_flags & IFF_NAPI_FRAGS) != 0;
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(&nlmsg, sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(&nlmsg, sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in_addr, sizeof(in_addr),
&macaddr, ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in6_addr, sizeof(in6_addr),
&macaddr, ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(&nlmsg, sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN,
NULL);
close(sock);
}
const int kInitNetNsFd = 239;
#define DEVLINK_FAMILY_NAME "devlink"
#define DEVLINK_CMD_PORT_GET 5
#define DEVLINK_CMD_RELOAD 37
#define DEVLINK_ATTR_BUS_NAME 1
#define DEVLINK_ATTR_DEV_NAME 2
#define DEVLINK_ATTR_NETDEV_NAME 7
#define DEVLINK_ATTR_NETNS_FD 138
static int netlink_devlink_id_get(struct nlmsg* nlmsg, int sock)
{
struct genlmsghdr genlhdr;
struct nlattr* attr;
int err, n;
uint16_t id = 0;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, DEVLINK_FAMILY_NAME,
strlen(DEVLINK_FAMILY_NAME) + 1);
err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
if (err) {
return -1;
}
attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); /* recv ack */
return id;
}
static void netlink_devlink_netns_move(const char* bus_name,
const char* dev_name, int netns_fd)
{
struct genlmsghdr genlhdr;
int sock;
int id, err;
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_RELOAD;
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_NETNS_FD, &netns_fd, sizeof(netns_fd));
err = netlink_send(&nlmsg, sock);
if (err) {
}
error:
close(sock);
}
static struct nlmsg nlmsg2;
static void initialize_devlink_ports(const char* bus_name, const char* dev_name,
const char* netdev_prefix)
{
struct genlmsghdr genlhdr;
int len, total_len, id, err, offset;
uint16_t netdev_index;
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (rtsock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_PORT_GET;
netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
err = netlink_send_ext(&nlmsg, sock, id, &total_len);
if (err) {
goto error;
}
offset = 0;
netdev_index = 0;
while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) {
struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg.buf + offset + len;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) {
char* port_name;
char netdev_name[IFNAMSIZ];
port_name = (char*)(attr + 1);
snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix,
netdev_index);
netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0,
netdev_name);
break;
}
}
offset += len;
netdev_index++;
}
error:
close(rtsock);
close(sock);
}
static void initialize_devlink_pci(void)
{
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
exit(1);
int ret = setns(kInitNetNsFd, 0);
if (ret == -1)
exit(1);
netlink_devlink_netns_move("pci", "0000:00:10.0", netns);
ret = setns(netns, 0);
if (ret == -1)
exit(1);
close(netns);
initialize_devlink_ports("pci", "0000:00:10.0", "netpci");
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa
static void netdevsim_add(unsigned int addr, unsigned int port_count)
{
char buf[16];
sprintf(buf, "%u %u", addr, port_count);
if (write_file("/sys/bus/netdevsim/new_device", buf)) {
snprintf(buf, sizeof(buf), "netdevsim%d", addr);
initialize_devlink_ports("netdevsim", buf, "netdevsim");
}
}
static void initialize_netdevices(void)
{
char netdevsim[16];
sprintf(netdevsim, "netdevsim%d", (int)procid);
struct {
const char* type;
const char* dev;
} devtypes[] = {
{"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
{"vcan", "vcan0"}, {"bond", "bond0"},
{"team", "team0"}, {"dummy", "dummy0"},
{"nlmon", "nlmon0"}, {"caif", "caif0"},
{"batadv", "batadv0"}, {"vxcan", "vxcan1"},
{"netdevsim", netdevsim}, {"veth", 0},
};
const char* devmasters[] = {"bridge", "bond", "team"};
struct {
const char* name;
int macsize;
bool noipv6;
} devices[] = {
{"lo", ETH_ALEN},
{"sit0", 0},
{"bridge0", ETH_ALEN},
{"vcan0", 0, true},
{"tunl0", 0},
{"gre0", 0},
{"gretap0", ETH_ALEN},
{"ip_vti0", 0},
{"ip6_vti0", 0},
{"ip6tnl0", 0},
{"ip6gre0", 0},
{"ip6gretap0", ETH_ALEN},
{"erspan0", ETH_ALEN},
{"bond0", ETH_ALEN},
{"veth0", ETH_ALEN},
{"veth1", ETH_ALEN},
{"team0", ETH_ALEN},
{"veth0_to_bridge", ETH_ALEN},
{"veth1_to_bridge", ETH_ALEN},
{"veth0_to_bond", ETH_ALEN},
{"veth1_to_bond", ETH_ALEN},
{"veth0_to_team", ETH_ALEN},
{"veth1_to_team", ETH_ALEN},
{"veth0_to_hsr", ETH_ALEN},
{"veth1_to_hsr", ETH_ALEN},
{"hsr0", 0},
{"dummy0", ETH_ALEN},
{"nlmon0", 0},
{"vxcan0", 0, true},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
};
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
netlink_add_device(&nlmsg, sock, devtypes[i].type, devtypes[i].dev);
for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
sprintf(slave0, "%s_slave_0", devmasters[i]);
sprintf(veth0, "veth0_to_%s", devmasters[i]);
netlink_add_veth(&nlmsg, sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(&nlmsg, sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(&nlmsg, sock, slave0, false, master, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, slave1, false, master, 0, 0, NULL);
}
netlink_device_change(&nlmsg, sock, "bridge_slave_0", true, 0, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, "bridge_slave_1", true, 0, 0, 0, NULL);
netlink_add_veth(&nlmsg, sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(&nlmsg, sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(&nlmsg, sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(&nlmsg, sock, "hsr_slave_0", true, 0, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, "hsr_slave_1", true, 0, 0, 0, NULL);
netdevsim_add((int)procid, 4);
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(&nlmsg, sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(&nlmsg, sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(&nlmsg, sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize, NULL);
}
close(sock);
}
static void initialize_netdevices_init(void)
{
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
struct {
const char* type;
int macsize;
bool noipv6;
bool noup;
} devtypes[] = {
{"nr", 7, true},
{"rose", 5, true, true},
};
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
char dev[32], addr[32];
sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
netlink_add_addr4(&nlmsg, sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
netlink_add_addr6(&nlmsg, sock, dev, addr);
}
int macsize = devtypes[i].macsize;
uint64_t macaddr = 0xbbbbbb +
((unsigned long long)i << (8 * (macsize - 2))) +
(procid << (8 * (macsize - 1)));
netlink_device_change(&nlmsg, sock, dev, !devtypes[i].noup, 0, &macaddr,
macsize, NULL);
}
close(sock);
}
static int read_tun(char* data, int size)
{
if (tunfd < 0)
return -1;
int rv = read(tunfd, data, size);
if (rv < 0) {
if (errno == EAGAIN)
return -1;
if (errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[1000];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
#define MAX_FDS 30
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
exit(1);
if (dup2(netns, kInitNetNsFd) < 0)
exit(1);
close(netns);
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = (200 << 20);
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static void drop_caps(void)
{
struct __user_cap_header_struct cap_hdr = {};
struct __user_cap_data_struct cap_data[2] = {};
cap_hdr.version = _LINUX_CAPABILITY_VERSION_3;
cap_hdr.pid = getpid();
if (syscall(SYS_capget, &cap_hdr, &cap_data))
exit(1);
const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE);
cap_data[0].effective &= ~drop;
cap_data[0].permitted &= ~drop;
cap_data[0].inheritable &= ~drop;
if (syscall(SYS_capset, &cap_hdr, &cap_data))
exit(1);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
drop_caps();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_devlink_pci();
initialize_tun();
initialize_netdevices();
loop();
exit(1);
}
static int inject_fault(int nth)
{
int fd;
fd = open("/proc/thread-self/fail-nth", O_RDWR);
if (fd == -1)
exit(1);
char buf[16];
sprintf(buf, "%d", nth + 1);
if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf))
exit(1);
return fd;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
flush_tun();
}
static void close_fds()
{
int fd;
for (fd = 3; fd < MAX_FDS; fd++)
close(fd);
}
static void setup_fault()
{
static struct {
const char* file;
const char* val;
bool fatal;
} files[] = {
{"/sys/kernel/debug/failslab/ignore-gfp-wait", "N", true},
{"/sys/kernel/debug/fail_futex/ignore-private", "N", false},
{"/sys/kernel/debug/fail_page_alloc/ignore-gfp-highmem", "N", false},
{"/sys/kernel/debug/fail_page_alloc/ignore-gfp-wait", "N", false},
{"/sys/kernel/debug/fail_page_alloc/min-order", "0", false},
};
unsigned i;
for (i = 0; i < sizeof(files) / sizeof(files[0]); i++) {
if (!write_file(files[i].file, files[i].val)) {
if (files[i].fatal)
exit(1);
}
}
}
struct thread_t {
int created, call;
event_t ready, done;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
event_wait(&th->ready);
event_reset(&th->ready);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
event_set(&th->done);
}
return 0;
}
static void execute_one(void)
{
int i, call, thread;
for (call = 0; call < 9; call++) {
for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
event_init(&th->ready);
event_init(&th->done);
event_set(&th->done);
thread_start(thr, th);
}
if (!event_isset(&th->done))
continue;
event_reset(&th->done);
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
event_set(&th->ready);
event_timedwait(&th->done, 45);
break;
}
}
for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
sleep_ms(1);
close_fds();
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter;
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[4] = {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,
0x0};
void execute_call(int call)
{
intptr_t res;
switch (call) {
case 0:
syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 0ul);
break;
case 1:
syscall(__NR_setsockopt, -1, 0x29ul, 0x3bul, 0ul, 0ul);
break;
case 2:
res = syscall(__NR_socket, 0x10ul, 3ul, 0ul);
if (res != -1)
r[0] = res;
break;
case 3:
res = syscall(__NR_socket, 0x10ul, 3ul, 0ul);
if (res != -1)
r[1] = res;
break;
case 4:
res = syscall(__NR_socket, 0x10ul, 0x803ul, 0);
if (res != -1)
r[2] = res;
break;
case 5:
*(uint64_t*)0x200001c0 = 0;
*(uint32_t*)0x200001c8 = 0;
*(uint64_t*)0x200001d0 = 0x20000180;
*(uint64_t*)0x20000180 = 0;
*(uint64_t*)0x20000188 = 0;
*(uint64_t*)0x200001d8 = 1;
*(uint64_t*)0x200001e0 = 0;
*(uint64_t*)0x200001e8 = 0;
*(uint32_t*)0x200001f0 = 0;
syscall(__NR_sendmsg, r[2], 0x200001c0ul, 0ul);
break;
case 6:
*(uint32_t*)0x20000200 = 0x14;
res = syscall(__NR_getsockname, r[2], 0x20000100ul, 0x20000200ul);
if (res != -1)
r[3] = *(uint32_t*)0x20000104;
break;
case 7:
syscall(__NR_sendmsg, r[1], 0ul, 0ul);
break;
case 8:
*(uint64_t*)0x20000080 = 0;
*(uint32_t*)0x20000088 = 0x325;
*(uint64_t*)0x20000090 = 0x20000040;
*(uint64_t*)0x20000040 = 0x200000c0;
*(uint32_t*)0x200000c0 = 0x28;
*(uint16_t*)0x200000c4 = 0x10;
*(uint16_t*)0x200000c6 = 0x825;
*(uint32_t*)0x200000c8 = 0;
*(uint32_t*)0x200000cc = 0;
*(uint8_t*)0x200000d0 = 0;
*(uint8_t*)0x200000d1 = 0;
*(uint16_t*)0x200000d2 = 0;
*(uint32_t*)0x200000d4 = r[3];
*(uint32_t*)0x200000d8 = 3;
*(uint32_t*)0x200000dc = 0;
*(uint16_t*)0x200000e0 = 8;
*(uint16_t*)0x200000e2 = 0xa;
*(uint8_t*)0x200000e4 = 0x14;
*(uint64_t*)0x20000048 = 0x28;
*(uint64_t*)0x20000098 = 1;
*(uint64_t*)0x200000a0 = 0;
*(uint64_t*)0x200000a8 = 0;
*(uint32_t*)0x200000b0 = 0;
inject_fault(35);
syscall(__NR_sendmsg, r[0], 0x20000080ul, 0ul);
break;
}
}
int main(void)
{
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 3ul, 0x32ul, -1, 0);
setup_fault();
for (procid = 0; procid < 8; procid++) {
if (fork() == 0) {
do_sandbox_none();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/2259.c | // interactor.cpp
#include <assert.h>
#include <stdio.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
int a, b;
int main(int argc, char **argv) {
FILE *inf = fopen(argv[1], "r"), *ouf = fopen(argv[2], "w");
fscanf(inf, "%d%d", &a, &b);
fclose(inf);
fprintf(stderr, "a=%d b=%d\n", a, b);
fflush(stderr);
assert(a <= b);
// sleep(5);
printf("%d\n", b);
fflush(stdout);
FOR(_, 1, 30) {
char x[5];
int y;
scanf("%s%d", x, &y);
fprintf(stderr, "b.cpp: x:[%s], y:[%d]\n", x, y);
if (x[0] == '?') {
printf("%d\n", a >= y);
fflush(stdout);
} else {
assert(x[0] == '!');
if (y == a) {
fprintf(ouf, "AC\n");
} else {
fprintf(ouf, "WA\n");
}
return 0;
}
}
fprintf(ouf, "WA\n");
fclose(ouf);
return 0;
} |
the_stack_data/57950376.c | // RUN: %clang_cc1 -emit-llvm-only -triple x86_64-apple-darwin9 %s
// rdar://8823265
#define ATTR __attribute__((__ms_struct__))
struct
{
char foo;
long : 0;
char bar;
} ATTR t1;
struct
{
char foo;
long : 0;
char : 0;
int : 0;
char bar;
} ATTR t2;
struct
{
char foo;
long : 0;
char : 0;
int : 0;
char bar;
long : 0;
char : 0;
} ATTR t3;
struct
{
long : 0;
char bar;
} ATTR t4;
struct
{
long : 0;
long : 0;
char : 0;
char bar;
} ATTR t5;
struct
{
long : 0;
long : 0;
char : 0;
char bar;
} ATTR t6;
struct
{
char foo;
long : 0;
int : 0;
char bar;
char bar1;
long : 0;
char bar2;
char bar3;
char : 0;
char bar4;
char bar5;
char : 0;
char bar6;
char bar7;
} ATTR t7;
struct
{
long : 0;
long : 0;
char : 0;
} ATTR t8;
struct
{
char foo;
long : 0;
int : 0;
char bar;
char bar1;
long : 0;
char bar2;
char bar3;
char : 0;
char bar4;
char bar5;
char : 0;
char bar6;
char bar7;
int i1;
char : 0;
long : 0;
char :4;
char bar8;
char : 0;
char bar9;
char bar10;
int i2;
char : 0;
long : 0;
char :4;
} ATTR t9;
struct
{
char foo: 8;
long : 0;
char bar;
} ATTR t10;
static int arr1[(sizeof(t1) == 2) -1];
static int arr2[(sizeof(t2) == 2) -1];
static int arr3[(sizeof(t3) == 2) -1];
static int arr4[(sizeof(t4) == 1) -1];
static int arr5[(sizeof(t5) == 1) -1];
static int arr6[(sizeof(t6) == 1) -1];
static int arr7[(sizeof(t7) == 9) -1];
static int arr8[(sizeof(t8) == 0) -1];
static int arr9[(sizeof(t9) == 28) -1];
static int arr10[(sizeof(t10) == 16) -1];
int main() {
return 0;
}
|
the_stack_data/153567.c | #include <stdio.h>
/* copy input to output; 1st version */
main()
{
int c;
c = getchar();
while(c != EOF) {
putchar(c);
c = getchar();
}
}
|
the_stack_data/193892552.c | #include <stdio.h>
#define SIZE 10
void print_vector(int array[]) {
int i;
for (i = 0; i < SIZE; i++) {
printf("%d | ", array[i]);
}
printf("fim\n");
}
void insert_sort(int vet[]) {
int number, counter, position;
for (counter = 1; counter < SIZE; counter++) {
number = vet[counter];
for (position = counter - 1; position >= 0; position--) {
if (number < vet[position]) {
vet[position + 1] = vet[position];
vet[position] = number;
} else {
break;
}
}
print_vector(vet);
}
}
int main() {
int array[] = {23, 4, 67, -8, -5, 54, 21, 87, 2, -7};
print_vector(array);
insert_sort(array);
return 0;
} |
the_stack_data/54825606.c | /*
Copyright (c) 2017, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory
Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
Markus Schordan, and Ian Karlin
(email: [email protected], [email protected], [email protected],
[email protected], [email protected])
LLNL-CODE-732144
All rights reserved.
This file is part of DataRaceBench. For details, see
https://github.com/LLNL/dataracebench. Please also see the LICENSE file
for our additional BSD notice.
Redistribution and use in source and binary forms, with
or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the disclaimer below.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the disclaimer (as noted below)
in the documentation and/or other materials provided with the
distribution.
* Neither the name of the LLNS/LLNL nor the names of its contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL
SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
The outmost loop is parallelized.
But the inner level loop has out of bound access for b[i][j] when j equals to 0.
This will case memory access of a previous row's last element.
For example, an array of 4x4:
j=0 1 2 3
i=0 x x x x
1 x x x x
2 x x x x
3 x x x x
outer loop: i=2,
inner loop: j=0
array element accessed b[i][j-1] becomes b[2][-1], which in turn is b[1][3]
due to linearized row-major storage of the 2-D array.
This causes loop-carried data dependence between i=2 and i=1.
Data race pair: b[i][j]@75 vs. b[i][j-1]@75.
*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
int i,j;
int n=100, m=100;
double b[n][m];
for (i=1;i<n;i++)
#pragma omp parallel for private(j )
for (j=0;j<m;j++)
b[i][j]=b[i-1][j];
printf ("b[50][50]=%f\n",b[50][50]);
return 0;
}
|
the_stack_data/29824484.c | /*-
* Copyright (c) 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)ffs.c 8.1 (Berkeley) 6/4/93
* $FreeBSD: head/lib/libc/string/ffs.c 251069 2013-05-28 20:57:40Z emaste $
*/
#include <strings.h>
/*
* Find First Set bit
*/
int
ffs(int mask)
{
int bit;
if (mask == 0)
return(0);
for (bit = 1; !(mask & 1); bit++)
mask = (unsigned int)mask >> 1;
return (bit);
}
|
the_stack_data/62554.c | /*-
* Copyright (c) 2011-2019 Olivier Cochard-Labbé
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include <stdio.h>
#include <stdlib.h>
static void
usage(void)
{
fprintf(stderr, "quagga-bgp-netgen [nets-number] [local-as] [router-id] [remote-as] [remote-peer-ip]\n");
fprintf(stderr, "example:\n");
fprintf(stderr, "quagga-bgp-netgen 400000 100 0.0.0.100 200 10.0.0.2 > /usr/local/etc/frr/bgpd.conf\n");
exit(-1);
}
/* Generate sample quagga bgp configuration file */
/* With "number" of routes*/
int
main(int argc, char *argv[])
{
unsigned long networks,i;
char *dummy;
/* Network IP: a.b.c.0/24 */
unsigned short a=1,b=0,c=0;
/* check number of argument */
if (argc != 6)
usage();
networks = strtoul(argv[1], &dummy, 10);
if ( networks < 1 || *dummy != '\0' )
usage();
printf("! BGP Quagga/Zebra configuration file\n");
printf("! Autogenerated with %s\n",argv[0]);
printf("! This configuration file injects %li /24 prefixes\n",networks);
printf("router bgp %s\n",argv[2]);
printf(" bgp router-id %s\n",argv[3]);
printf(" neighbor %s remote-as %s\n",argv[5],argv[4]);
printf(" !\n");
printf(" address-family ipv4 unicast\n");
printf(" neighbor %s activate\n",argv[5]);
i=0;
while ( i < networks ) {
/* Avoid loopback network */
if ( a == 127 ) continue;
/* Do not generate invalid networks */
if ( a > 223 ) {
fprintf(stderr, "Maximum number of valid networks reached: %lu\n", i);
exit(-1);
}
b = 0;
while ( b < 255 && i < networks ) {
c = 0;
while ( c < 255 && i < networks ) {
printf(" network %u.%i.%i.0/24\n",a,b,c);
c++;
i++;
}
b++;
}
a++;
}
printf(" exit-address-family\n");
printf(" !\n");
return (0);
}
|
the_stack_data/104827693.c | #include <stdio.h>
int main()
{
int k;
printf("HelloWorld!\n");
nice(15);
while(1);
k=k+1;
return 0;
} |
the_stack_data/45212.c |
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv)
{
int i;
size_t size;
char *str;
if (argc == 3)
{
i = atoi(argv[1]);
if (i == 0)
{
size = atoi(argv[2]);
str = (char *)malloc(size);
bzero(str, size);
while (size > 0)
{
size--;
if (str + size == 0)
printf("0");
}
free(str);
}
}
return (0);
}
|
the_stack_data/232954987.c | #include <stdio.h>
int main ()
{
float x, y;
printf("Digite o valor de x:");
scanf("%f", &x);
printf("Digite o valor de y:");
scanf("%f", &y);
if(x > 0 && y > 0 )
{
if (x > 0 && y > 0)
{
printf("Q1");
}
else
{
printf("Q2");
}
}
else
{
if (x == 0 && y == 0)
{
printf("Origem");
}
else if (x == 0)
{
printf("Eixo y");
}
else if (y == 0)
{
printf("Eixo x");
}
else if (x > 0 && y < 0)
{
printf("Q4");
}
else if ( x < 0 && y > 0)
{
printf("Q2");
}
else
{
printf("Q3");
}
}
return 0;
}
|
the_stack_data/82012.c |
int sum(int x, int y){
int t = x+y;
return t;
}
|
the_stack_data/37638881.c | // Fizzbuzz using switch statement
// Author @NidhxGupta
#include <stdio.h>
int main(void)
{
int i,n;
for(i = 1 ; i < 101; i++)
{
if(i % 3 == 0 && i % 5 == 0)
{
n = 0; // If n is 0, Fizzbuzz
}
else if(i % 3 == 0)
{
n = 1; // If n is 1, Fizz
}
else if(i % 5 == 0)
{
n = 2; // If n is 2, Buzz
}
else
{
n = 3; // Integer
}
switch(n)
{
case 0:
{
printf("Fizzbuzz\n");
break;
}
case 1:
{
printf("Fizz\n");
break;
}
case 2:
{
printf("Buzz\n");
break;
}
case 3:
{
printf("%d\n",i);
break;
}
default:
{
break;
}
}
}
return 0;
} |
the_stack_data/51700955.c | /* Qn :
Write a C function that takes a 2D array and returns the numbers of palindrome
number of that array in the main function.
Sample Input Sample Output
3 121 21
27 43 636 4
15 16 4
*/
/*
Author : Arnob Mahmud
mail : [email protected]
*/
#include <stdio.h>
int palindromeQuery(int A[3][3])
{
int rev, rem, temp, count = 0;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
temp = A[i][j];
rev = 0;
while (A[i][j] != 0)
{
rem = A[i][j] % 10;
rev = rev * 10 + rem;
A[i][j] /= 10;
}
if (rev == temp)
{
//printf("%d ", temp);
count++;
}
}
}
return count;
}
int main(int argc, char const *argv[])
{
int A[3][3];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
printf("A[%d][%d] : ", i, j);
scanf("%d", &A[i][j]);
}
}
printf("%d", palindromeQuery(A));
return 0;
}
|
the_stack_data/950482.c | /***************************************************************************/
/* */
/* psnames.c */
/* */
/* FreeType PSNames module component (body only). */
/* */
/* Copyright 1996-2001 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#define FT_MAKE_OPTION_SINGLE_OBJECT
/* END */
|
the_stack_data/64199814.c | #include <stdint.h>
extern uint32_t _sbss;
extern uint32_t _ebss;
extern uint32_t _sdata;
extern uint32_t _edata;
extern uint32_t _ldata;
extern uint32_t _eram;
extern void platform_main(int);
extern void fault_handler(void);
extern void reset_handler(void);
__attribute__((section(".vectors"))) void (*const vector_table[])(void) = {
(void*)&_eram,
reset_handler,
fault_handler, // nmi_handler
fault_handler, // hard_fault_handler
fault_handler, // mem_manage_handler
fault_handler, // bus_fault_handler
fault_handler, // usage_fault_handler
};
void __attribute__((naked)) bootloader_startup(int arg)
{
volatile uint32_t *p_ram, *p_flash;
// clear .bss section
p_ram = &_sbss;
while (p_ram < &_ebss) {
*p_ram++ = 0;
}
// copy .data section from flash to ram
p_flash = &_ldata;
p_ram = &_sdata;
while (p_ram < &_edata) {
*p_ram++ = *p_flash++;
}
platform_main(arg);
while (1)
;
}
|
the_stack_data/115765432.c | #include <stdio.h>
#include <stdlib.h>
/* Linked List Implementation in C */
// This program aims at "Revering the Link List"
typedef struct node{
int data;
struct node *link;
} node;
node* head; //global variable
void insert_append(int x){
node* temp;
temp = (node*)malloc(sizeof(node));
temp->data = x;
temp->link=NULL;
if(head!=NULL){
node* temp_travel;
temp_travel =head;
while(temp_travel->link != NULL){
temp_travel = temp_travel->link;
}
temp_travel->link = temp;
return;
}
head =temp;
return;
}
void reverse(node *current){
if(current->link == NULL){
head = current;
return;
}
reverse(current->link);
node* temp;
temp = current->link;
temp->link= current;
current->link=NULL;
return;
}
//This is recursive print
void print(node* p){
if (p == NULL) {
return;
}
printf(" %d",p->data);
print(p->link);
return;
}
int main(){
head = NULL; //empty list
insert_append(1); //list is: 1
insert_append(2); //list is: 1 2
insert_append(3); //list is: 1 2 3
insert_append(4); //list is: 1 2 3 4
insert_append(5); //list is: 1 2 3 4 5
printf("list is:");
print(head);
printf("\n");
reverse(head); //list is : 5 4 3 2 1
printf("Reverse list is:");
print(head);
printf("\n");
return 0;
} |
the_stack_data/122016010.c | /* Exercise acc_update_device on unmapped data on nvidia targets. */
/* { dg-do run { target openacc_nvidia_accel_selected } } */
#include <stdio.h>
#include <stdlib.h>
#include <openacc.h>
int
main (int argc, char **argv)
{
const int N = 256;
int i;
unsigned char *h;
h = (unsigned char *) malloc (N);
for (i = 0; i < N; i++)
{
h[i] = i;
}
fprintf (stderr, "CheCKpOInT\n");
acc_update_device (h, N);
acc_copyout (h, N);
for (i = 0; i < N; i++)
{
if (h[i] != 0xab)
abort ();
}
free (h);
return 0;
}
/* { dg-output "CheCKpOInT(\n|\r\n|\r).*" } */
/* { dg-output "\\\[\[0-9a-fA-FxX\]+,256\\\] is not mapped" } */
/* { dg-shouldfail "" } */
|
the_stack_data/90761624.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/sysinfo.h>
int main(int argc, char *argv[]){
//int interval=300; //sec
int interval=atoi(argv[2]); //sec
float input=atof(argv[1]);
int cores=(int)input+1;
float cpuUsage=input/cores;
pid_t *pids = (pid_t*)malloc(sizeof(pid_t)*cores);
int noCpu=get_nprocs_conf();
if(cores>noCpu) {
cores=noCpu;
cpuUsage=1.0;
}
int i=0;
long magicPer01 = 4233779;
int ratioCpu;
int sleepTime;
int elapsedTime=0;
clock_t start;
clock_t end;
double time;
FILE *tax_info = fopen("tax_info.txt", "r");
FILE *tax_report = fopen("tax_report.txt", "w+");
int tax_state;
int tax_fed;
int tax_total;
int *tax_additional = (int*)malloc(sizeof(int)*3);
tax_additional[0]=2;
tax_additional[1]=4;
tax_additional[2]=0;
for(i=0; i<cores; i++){
pids[i]=fork();
if(pids[i]==0){
while(1){
//long myId=(long)getpid();
start=clock();
fscanf(tax_info, "%d %d", &tax_state, &tax_fed);
ratioCpu = (int)(cpuUsage*100);
sleepTime = (100-ratioCpu)*10000;
for(i=0; i<magicPer01*ratioCpu; i++){
tax_total=tax_state+tax_fed;
tax_additional[2]=tax_additional[0] * tax_additional[1];
tax_total=tax_total+tax_additional[2];
}
fprintf(tax_report, "%d\n", tax_total);
end=clock();
time=(double)(end-start)/(CLOCKS_PER_SEC);
//printf("core: %d process ID: %d usage: %.2f calc time: %.2f\n", cores, myId, cpuUsage, time);
usleep(sleepTime);
elapsedTime++;
if(elapsedTime>=interval){
elapsedTime=0;
//break;
return 0;
}
}
fclose(tax_info);
fclose(tax_report);
return 0;
}
}
fclose(tax_info);
fclose(tax_report);
return 0;
}
|
the_stack_data/60807.c | /* PR target/67089 */
/* { dg-do run } */
/* { dg-options "-O2" } */
extern void abort (void);
int cnt, d;
__attribute__((noinline, noclone))
void foo (int x)
{
asm volatile ("" : "+m" (d) : "g" (x) : "memory");
cnt++;
}
#define T(n, type, op, cond) \
__attribute__((noinline, noclone)) \
type \
f##n (type x, type y) \
{ \
type r = op; \
cond; \
return r; \
}
T (1, unsigned int, x + y, if (r > y) foo (0))
T (2, unsigned long, x + y, if (r <= y) foo (0))
T (3, unsigned short, x + y, if (y < r) foo (r))
T (4, unsigned long long, x + y, if (y >= r) foo (0))
T (5, unsigned int, x + y, if (r >= y) foo (0))
T (6, unsigned long, x + y, if (r < y) foo (0))
T (7, unsigned short, x + y, if (y <= r) foo (r))
T (8, unsigned long long, x + y, if (d || y > r) foo (0))
T (9, unsigned int, x + y, if (d || r > y) foo (0))
T (10, unsigned long, x + y, if (d || r <= y) foo (0))
T (11, unsigned char, x + y, if (d || y < r) foo (0))
T (12, unsigned long long, x + y, if (d || y >= r) foo (0))
T (13, unsigned int, x + y, if (d || r >= y) foo (0))
T (14, unsigned long, x + y, if (d || r < y) foo (0))
T (15, unsigned short, x + y, if (d || y <= r) foo (0))
T (16, unsigned long long, x + y, if (d || y > r) foo (0))
int
main ()
{
if (f1 (-7U, 0) != -7U || cnt != 1) abort ();
if (f1 (-7U, 6) != -1U || cnt != 2) abort ();
if (f1 (-7U, 7) != 0U || cnt != 2) abort ();
if (f1 (-7U, 8) != 1U || cnt != 2) abort ();
if (f2 (-9UL, 0) != -9UL || cnt != 2) abort ();
if (f2 (-9UL, 8) != -1UL || cnt != 2) abort ();
if (f2 (-9UL, 9) != 0UL || cnt != 3) abort ();
if (f2 (-9UL, 10) != 1UL || cnt != 4) abort ();
if (f3 (-15, 0) != (unsigned short) -15 || cnt != 5) abort ();
if (f3 (-15, 14) != (unsigned short) -1 || cnt != 6) abort ();
if (f3 (-15, 15) != 0 || cnt != 6) abort ();
if (f3 (-15, 16) != 1 || cnt != 6) abort ();
if (f4 (-9132ULL, 0) != -9132ULL || cnt != 6) abort ();
if (f4 (-9132ULL, 9131) != -1ULL || cnt != 6) abort ();
if (f4 (-9132ULL, 9132) != 0 || cnt != 7) abort ();
if (f4 (-9132ULL, 9133) != 1ULL || cnt != 8) abort ();
if (f5 (-7U, 0) != -7U || cnt != 9) abort ();
if (f5 (-7U, 6) != -1U || cnt != 10) abort ();
if (f5 (-7U, 7) != 0U || cnt != 10) abort ();
if (f5 (-7U, 8) != 1U || cnt != 10) abort ();
if (f6 (-9UL, 0) != -9UL || cnt != 10) abort ();
if (f6 (-9UL, 8) != -1UL || cnt != 10) abort ();
if (f6 (-9UL, 9) != 0UL || cnt != 11) abort ();
if (f6 (-9UL, 10) != 1UL || cnt != 12) abort ();
if (f7 (-15, 0) != (unsigned short) -15 || cnt != 13) abort ();
if (f7 (-15, 14) != (unsigned short) -1 || cnt != 14) abort ();
if (f7 (-15, 15) != 0 || cnt != 14) abort ();
if (f7 (-15, 16) != 1 || cnt != 14) abort ();
if (f8 (-9132ULL, 0) != -9132ULL || cnt != 14) abort ();
if (f8 (-9132ULL, 9131) != -1ULL || cnt != 14) abort ();
if (f8 (-9132ULL, 9132) != 0 || cnt != 15) abort ();
if (f8 (-9132ULL, 9133) != 1ULL || cnt != 16) abort ();
cnt = 0;
if (f9 (-7U, 0) != -7U || cnt != 1) abort ();
if (f9 (-7U, 6) != -1U || cnt != 2) abort ();
if (f9 (-7U, 7) != 0U || cnt != 2) abort ();
if (f9 (-7U, 8) != 1U || cnt != 2) abort ();
if (f10 (-9UL, 0) != -9UL || cnt != 2) abort ();
if (f10 (-9UL, 8) != -1UL || cnt != 2) abort ();
if (f10 (-9UL, 9) != 0UL || cnt != 3) abort ();
if (f10 (-9UL, 10) != 1UL || cnt != 4) abort ();
if (f11 (-15, 0) != (unsigned char) -15 || cnt != 5) abort ();
if (f11 (-15, 14) != (unsigned char) -1 || cnt != 6) abort ();
if (f11 (-15, 15) != 0 || cnt != 6) abort ();
if (f11 (-15, 16) != 1 || cnt != 6) abort ();
if (f12 (-9132ULL, 0) != -9132ULL || cnt != 6) abort ();
if (f12 (-9132ULL, 9131) != -1ULL || cnt != 6) abort ();
if (f12 (-9132ULL, 9132) != 0 || cnt != 7) abort ();
if (f12 (-9132ULL, 9133) != 1ULL || cnt != 8) abort ();
if (f13 (-7U, 0) != -7U || cnt != 9) abort ();
if (f13 (-7U, 6) != -1U || cnt != 10) abort ();
if (f13 (-7U, 7) != 0U || cnt != 10) abort ();
if (f13 (-7U, 8) != 1U || cnt != 10) abort ();
if (f14 (-9UL, 0) != -9UL || cnt != 10) abort ();
if (f14 (-9UL, 8) != -1UL || cnt != 10) abort ();
if (f14 (-9UL, 9) != 0UL || cnt != 11) abort ();
if (f14 (-9UL, 10) != 1UL || cnt != 12) abort ();
if (f15 (-15, 0) != (unsigned short) -15 || cnt != 13) abort ();
if (f15 (-15, 14) != (unsigned short) -1 || cnt != 14) abort ();
if (f15 (-15, 15) != 0 || cnt != 14) abort ();
if (f15 (-15, 16) != 1 || cnt != 14) abort ();
if (f16 (-9132ULL, 0) != -9132ULL || cnt != 14) abort ();
if (f16 (-9132ULL, 9131) != -1ULL || cnt != 14) abort ();
if (f16 (-9132ULL, 9132) != 0 || cnt != 15) abort ();
if (f16 (-9132ULL, 9133) != 1ULL || cnt != 16) abort ();
return 0;
}
|
the_stack_data/145452217.c | #include <stdio.h>
#include <time.h>
int main()
{
time_t current_time = time(NULL);
time_t fixed_time = time(NULL);
char* time_string;
time_string = malloc(100);
char* fixed_time_string;
fixed_time_string = malloc(100);
long int time_int;
struct tm * timeInfo;
time_string = ctime(¤t_time);
time_int = (long int)current_time;
timeInfo = localtime(&fixed_time);
timeInfo->tm_year = 0;
timeInfo->tm_mon = 1;
timeInfo->tm_mday = 1;
//fixed_time = mktime(timeInfo);
//fixed_time_string = asctime(timeInfo);
printf("Hello, World!\n");
printf("time: %s\n", (time_string));
printf("Address of current_time: %p", ¤t_time);
printf("epoch time: %d\n", time_int);
printf("fixed time: %s\n", asctime(timeInfo));
printf("Address of fixed_time_string: %p", &fixed_time);
getch();
return 0;
}
|
the_stack_data/234517365.c | #include <stdio.h>
#include <stdlib.h>
unsigned long long int fatR(unsigned long long n){
if(n<2)
return 1;
else
return n*fatR(n-1);
}
int main(){
unsigned long long int num = 7;
unsigned long long int res = fatR(num);
printf("O logaritmo de %llu eh: %llu", num, res);
return 0;
} |
the_stack_data/666935.c |
/* length.c */
/* Get the length of an array */
/* This code is released to the public domain */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
int main()
{
int myarray[] = {32, 67, 25, 48, 5, 17, 23};
int length = sizeof(myarray) / sizeof(*myarray);
printf("length of myarray is %d \n", length);
return 0;
}
|
the_stack_data/73576192.c | /**
* 1.计算速度
* 2.上溢
* 3.下溢
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
static double m_cache[64];
static int m_top = 0;
double myPow_recur(double x, long n)
{
if (n == 0) {
return 1.0;
}
double res = x;
int m = 1;
int idx = 0;
//while (m < 1073741824 && m * 2 <= n) { // 由于INT_MAX=2147483647, 所以当m = 1073741824时, m*2会发生上溢导致m*2<INT_MAX成立
while (m <= INT_MAX / 2 && m * 2 <= n) {
m = m * 2;
++idx;
}
while (m_top <= idx) {
m_cache[m_top] = m_cache[m_top - 1] * m_cache[m_top - 1];
++m_top;
}
res = m_cache[idx];
if (m < n) {
res = res * myPow_recur(x, n - m);
}
return res;
}
double myPow(double x, int n)
{
m_cache[0] = x;
m_top = 1;
int neg = 0;
int delta = 0;
if (n < 0) {
neg = 1;
if (n == INT_MIN) { // int最小值是-2147483648, 最大值是2147483647, 因此最小值*-1会导致正向溢出
delta = 1;
++n;
}
n *= -1;
}
double res = myPow_recur(x, n);
if (delta) {
res *= x;
}
if (neg) {
res = 1.0 / res;
}
return res;
}
int main()
{
double x;
int n;
#ifdef _TEST
FILE *fp = fopen("1.txt", "rb");
if (fp == NULL) {
fprintf(stderr, "fopen failed\n");
return 1;
}
while (fscanf(fp, "%lf, %d", &x, &n) != EOF) {
#else
while (fscanf(stdin, "%lf, %d", &x, &n) != EOF) {
#endif
//gettimeofday(&t0, NULL);
fprintf(stdout, "%lf\n", myPow(x, n));
//gettimeofday(&t1, NULL);
//timersub(&t1, &t0, &t2);
}
#ifdef _TEST
fclose(fp);
#endif
return 0;
} |
the_stack_data/148579465.c | #include <stdbool.h>
#include <stdio.h>
#include <math.h>
#include <inttypes.h>
void cffi_int32hammingdistance(
const int n,
const int* a,
const int* b,
int* dist
) {
#pragma omp parallel for
for (int elem_idx = 0; elem_idx < n; elem_idx++) {
dist[elem_idx] = 0;
int x = a[elem_idx] ^ b[elem_idx];
while(x != 0) {
x = x & (x-1);
dist[elem_idx]++;
}
}
} |
the_stack_data/92324358.c | /**
* @file strncpy.c
* @provides strncpy
*
* $Id: strncpy.c 221 2007-07-11 18:45:46Z mschul $
*/
/* Embedded XINU, Copyright (C) 2007. All rights reserved. */
/**
* Copy string s2 to s1, truncating or null-padding to always copy n bytes.
* @param s1 first string
* @param s2 second string
* @param n length of s2 to copy
* @return s1
*/
char *strncpy(char *s1, char *s2, int n)
{
register int i;
register char *os1;
os1 = s1;
for (i = 0; i < n; i++)
{
if (((*s1++) = (*s2++)) == '\0')
{
while (++i < n)
{ *s1++ = '\0'; }
return os1;
}
}
return os1;
}
|
the_stack_data/32950785.c | /* This File is Part of LibFalcon.
* Copyright (c) 2018, Syed Nasim
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 LibFalcon 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(__cplusplus)
extern "C" {
#endif
#include <string.h>
char * strcat( char * restrict s1, const char * restrict s2 )
{
char * rc = s1;
if ( *s1 )
{
while ( *++s1 );
}
while ( (*s1++ = *s2++) );
return rc;
}
#if defined(__cplusplus)
}
#endif
|
the_stack_data/18887942.c | // BUG: unable to handle kernel paging request in __schedule
// https://syzkaller.appspot.com/bug?id=e9c98bdf24a3cce55110
// status:0
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static int inject_fault(int nth)
{
int fd;
fd = open("/proc/thread-self/fail-nth", O_RDWR);
if (fd == -1)
exit(1);
char buf[16];
sprintf(buf, "%d", nth + 1);
if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf))
exit(1);
return fd;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
for (int i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void setup_fault()
{
static struct {
const char* file;
const char* val;
bool fatal;
} files[] = {
{"/sys/kernel/debug/failslab/ignore-gfp-wait", "N", true},
{"/sys/kernel/debug/fail_futex/ignore-private", "N", false},
{"/sys/kernel/debug/fail_page_alloc/ignore-gfp-highmem", "N", false},
{"/sys/kernel/debug/fail_page_alloc/ignore-gfp-wait", "N", false},
{"/sys/kernel/debug/fail_page_alloc/min-order", "0", false},
};
unsigned i;
for (i = 0; i < sizeof(files) / sizeof(files[0]); i++) {
if (!write_file(files[i].file, files[i].val)) {
if (files[i].fatal)
exit(1);
}
}
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter = 0;
for (;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
#ifndef __NR_bpf
#define __NR_bpf 321
#endif
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
void execute_one(void)
{
intptr_t res = 0;
*(uint32_t*)0x20000200 = 0x18;
*(uint32_t*)0x20000204 = 3;
*(uint64_t*)0x20000208 = 0x200000c0;
memcpy((void*)0x200000c0,
"\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95",
17);
*(uint64_t*)0x20000210 = 0x20000080;
memcpy((void*)0x20000080, "GPL\000", 4);
*(uint32_t*)0x20000218 = 0;
*(uint32_t*)0x2000021c = 0;
*(uint64_t*)0x20000220 = 0;
*(uint32_t*)0x20000228 = 0;
*(uint32_t*)0x2000022c = 0;
*(uint8_t*)0x20000230 = 0;
*(uint8_t*)0x20000231 = 0;
*(uint8_t*)0x20000232 = 0;
*(uint8_t*)0x20000233 = 0;
*(uint8_t*)0x20000234 = 0;
*(uint8_t*)0x20000235 = 0;
*(uint8_t*)0x20000236 = 0;
*(uint8_t*)0x20000237 = 0;
*(uint8_t*)0x20000238 = 0;
*(uint8_t*)0x20000239 = 0;
*(uint8_t*)0x2000023a = 0;
*(uint8_t*)0x2000023b = 0;
*(uint8_t*)0x2000023c = 0;
*(uint8_t*)0x2000023d = 0;
*(uint8_t*)0x2000023e = 0;
*(uint8_t*)0x2000023f = 0;
*(uint32_t*)0x20000240 = 0;
*(uint32_t*)0x20000244 = 2;
*(uint32_t*)0x20000248 = -1;
*(uint32_t*)0x2000024c = 8;
*(uint64_t*)0x20000250 = 0;
*(uint32_t*)0x20000258 = 0;
*(uint32_t*)0x2000025c = 0x10;
*(uint64_t*)0x20000260 = 0;
*(uint32_t*)0x20000268 = 0;
*(uint32_t*)0x2000026c = 0;
*(uint32_t*)0x20000270 = 0;
res = syscall(__NR_bpf, 5ul, 0x20000200ul, 0x78ul);
if (res != -1)
r[0] = res;
*(uint64_t*)0x200000c0 = 0x20000000;
memcpy((void*)0x20000000, "sched_switch\000", 13);
*(uint32_t*)0x200000c8 = r[0];
res = syscall(__NR_bpf, 0x11ul, 0x200000c0ul, 0x10ul);
if (res != -1)
r[1] = res;
inject_fault(0);
syscall(__NR_dup2, r[0], r[1]);
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
inject_fault(0);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
setup_fault();
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
loop();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/139276.c | typedef long unsigned int size_t;
struct RangeMapRange {
unsigned fromMin;
unsigned fromMax;
unsigned toMin;
};
void reserve1(void);
void f(struct RangeMapRange *q1, size_t t)
{
const struct RangeMapRange *q2 = q1 + t;
size_t n = q2 - q1;
if (n > 0)
reserve1();
}
|
the_stack_data/16081.c | #define _GNU_SOURCE
#include <math.h>
float
significandf(float x)
{
return scalbnf(x, -ilogbf(x));
}
|
the_stack_data/290517.c | int main()
{
'a';
}
|
the_stack_data/1027818.c | #include "stdio.h"
#define ROW 10
#define COL 10
void calculate(int a[][COL], int b[][COL], int c[][COL], int m, int n);
int main()
{
int a[ROW][COL], b[ROW][COL], c[ROW][COL], m, n, i, j;
printf("Enter matrix row count: \n");
scanf("%d", &m);
printf("Enter matrix column count: \n");
scanf("%d", &n);
printf("Enter matrix elements: \n");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", &a[i][j]);
}
}
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", &b[i][j]);
}
}
calculate(a, b, c, m, n);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
printf("%d\t", c[i][j]);
}
printf("\n");
}
}
void calculate(int a[][COL], int b[][COL], int c[][COL], int m, int n)
{
int i, j, k;
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
c[i][j] = 0;
for (k = 0; k < n; k++)
{
c[i][j] = a[i][k] * b[k][j];
}
}
}
}
|
the_stack_data/247019578.c | #include <stdio.h>
#define infinity 999
void dij(int n,int v,int cost[10][10],int dist[])
{
int i,u,count,w,flag[10],min;
for(i=1;i<=n;i++)
flag[i]=0,dist[i]=cost[v][i];
count=2;
while(count<=n)
{
min=99;
for(w=1;w<=n;w++)
if(dist[w]<min && !flag[w])
min=dist[w],u=w;
flag[u]=1;
count++;
for(w=1;w<=n;w++)
if((dist[u]+cost[u][w]<dist[w]) && !flag[w])
dist[w]=dist[u]+cost[u][w];
}
}
void main()
{
int n,v,i,j,cost[10][10],dist[10];
printf("\n Enter the number of nodes:");
scanf("%d",&n);
printf("\n Enter the cost 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]=infinity;
}
printf("\n Enter the source node:");
scanf("%d",&v);
dij(n,v,cost,dist);
printf("\n Shortest path:\n");
for(i=1;i<=n;i++)
if(i!=v)
printf("%d->%d,cost=%d\n",v,i,dist[i]);
}
|
the_stack_data/151834.c | #include<stdio.h>
#include<stdlib.h>
int main(){
system("cls");
int num;
printf("Digite um Número:");
scanf("%i",&num);
if(num%2==0) printf("O Número %i é Par",num);
else printf("O Número %i é Ímpar",num);
return 0;
} |
the_stack_data/17309.c | #include <string.h>
#include <stdlib.h>
#include <ctype.h>
#undef strcpy
#undef strncpy
#undef strcat
#undef strncat
#undef strlen
#undef strcmp
#undef strncmp
#undef strchr
#undef strrchr
#undef strspn
#undef strcspn
#undef strpbrk
#undef strstr
#undef strtok
#undef memchr
#undef memcmp
#undef memset
#undef memcpy
#undef memmove
#undef memchr
char *strcpy(char *dst, const char *src)
{
__ESBMC_HIDE:;
char *cp = dst;
while((*cp++ = *src++))
;
return dst;
}
char *strncpy(char *dst, const char *src, size_t n)
{
__ESBMC_HIDE:;
char *start = dst;
while(n && (*dst++ = *src++))
n--;
if(n)
while(--n)
*dst++ = '\0';
return start;
}
char *strcat(char *dst, const char *src)
{
__ESBMC_HIDE:;
strcpy(dst + strlen(dst), src);
return dst;
}
char *strncat(char *dst, const char *src, size_t n)
{
__ESBMC_HIDE:;
char *start = dst;
while(*dst++)
;
dst--;
while(n--)
if(!(*dst++ = *src++))
return start;
*dst = '\0';
return start;
}
size_t strlen(const char *s)
{
__ESBMC_HIDE:;
size_t len = 0;
while(s[len] != 0)
len++;
return len;
}
int strcmp(const char *p1, const char *p2)
{
__ESBMC_HIDE:;
const unsigned char *s1 = (const unsigned char *)p1;
const unsigned char *s2 = (const unsigned char *)p2;
unsigned char c1, c2;
do
{
c1 = (unsigned char)*s1++;
c2 = (unsigned char)*s2++;
if(c1 == '\0')
return c1 - c2;
} while(c1 == c2);
return c1 - c2;
}
int strncmp(const char *s1, const char *s2, size_t n)
{
__ESBMC_HIDE:;
size_t i = 0;
unsigned char ch1, ch2;
do
{
ch1 = s1[i];
ch2 = s2[i];
if(ch1 == ch2)
{
}
else if(ch1 < ch2)
return -1;
else
return 1;
i++;
} while(ch1 != 0 && ch2 != 0 && i < n);
return 0;
}
char *strchr(const char *s, int ch)
{
__ESBMC_HIDE:;
while(*s && *s != (char)ch)
s++;
if(*s == (char)ch)
return (char *)s;
return NULL;
}
char *strrchr(const char *s, int c)
{
__ESBMC_HIDE:;
const char *found, *p;
c = (unsigned char)c;
/* Since strchr is fast, we use it rather than the obvious loop. */
if(c == '\0')
return strchr(s, '\0');
found = NULL;
while((p = strchr(s, c)) != NULL)
{
found = p;
s = p + 1;
}
return (char *)found;
}
size_t strspn(const char *s, const char *accept)
{
__ESBMC_HIDE:;
const char *p;
const char *a;
size_t count = 0;
for(p = s; *p != '\0'; ++p)
{
for(a = accept; *a != '\0'; ++a)
if(*p == *a)
break;
if(*a == '\0')
return count;
else
++count;
}
return count;
}
size_t strcspn(const char *s, const char *reject)
{
__ESBMC_HIDE:;
size_t count = 0;
while(*s != '\0')
if(strchr(reject, *s++) == NULL)
++count;
else
return count;
return count;
}
char *strpbrk(const char *s, const char *accept)
{
__ESBMC_HIDE:;
while(*s != '\0')
{
const char *a = accept;
while(*a != '\0')
if(*a++ == *s)
return (char *)s;
++s;
}
return NULL;
}
char *strstr(const char *str1, const char *str2)
{
__ESBMC_HIDE:;
char *cp = (char *)str1;
char *s1, *s2;
if(!*str2)
return (char *)str1;
while(*cp)
{
s1 = cp;
s2 = (char *)str2;
while(*s1 && *s2 && !(*s1 - *s2))
s1++, s2++;
if(!*s2)
return cp;
cp++;
}
return NULL;
}
char *strtok(char *str, const char *delim)
{
__ESBMC_HIDE:;
static char *p = 0;
if(str)
p = str;
else if(!p)
return 0;
str = p + strspn(p, delim);
p = str + strcspn(str, delim);
if(p == str)
return p = 0;
p = *p ? *p = 0, p + 1 : 0;
return str;
}
char *strdup(const char *str)
{
__ESBMC_HIDE:;
size_t bufsz;
bufsz = (strlen(str) + 1);
char *cpy = (char *)malloc(bufsz * sizeof(char));
if(cpy == ((void *)0))
return 0;
strcpy(cpy, str);
return cpy;
}
void *memcpy(void *dst, const void *src, size_t n)
{
__ESBMC_HIDE:;
char *cdst = dst;
const char *csrc = src;
for(size_t i = 0; i < n; i++)
cdst[i] = csrc[i];
return dst;
}
void *__memset_impl(void *s, int c, size_t n)
{
__ESBMC_HIDE:;
char *sp = s;
for(size_t i = 0; i < n; i++)
sp[i] = c;
return s;
}
void *memset(void *s, int c, size_t n)
{
__ESBMC_HIDE:;
void *hax = &__memset_impl;
(void)hax;
return __ESBMC_memset(s, c, n);
}
void *memmove(void *dest, const void *src, size_t n)
{
__ESBMC_HIDE:;
char *cdest = dest;
const char *csrc = src;
if(dest - src >= n)
{
for(size_t i = 0; i < n; i++)
cdest[i] = csrc[i];
}
else
{
for(size_t i = n; i > 0; i--)
cdest[i - 1] = csrc[i - 1];
}
return dest;
}
int memcmp(const void *s1, const void *s2, size_t n)
{
__ESBMC_HIDE:;
int res = 0;
const unsigned char *sc1 = s1, *sc2 = s2;
for(; n != 0; n--)
{
res = (*sc1++) - (*sc2++);
if(res != 0)
return res;
}
return res;
}
void *memchr(const void *buf, int ch, size_t n)
{
while(n && (*(unsigned char *)buf != (unsigned char)ch))
{
buf = (unsigned char *)buf + 1;
n--;
}
return (n ? (void *)buf : NULL);
}
|
the_stack_data/903611.c | #include <stdio.h>
int main(){
int age = 15;
printf("Age = %d", age);
return 0;
} |
the_stack_data/14200471.c | static __UINT8_TYPE__ u8;
/*
* check-name: predef-token
*/
|
the_stack_data/20449827.c | /**
* @file dynamicbuffer_test.c
* @brief Tests CNO_DynamicBuffer functions.
* @author Anadian
* @license MIT License:
Copyright 2018 Canosw
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.
*/
|
the_stack_data/805672.c | /* $OpenBSD: s_creal.c,v 1.1 2008/09/07 20:36:09 martynas Exp $ */
/*
* Copyright (c) 2008 Martynas Venckus <[email protected]>
*
* 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 <complex.h>
#include <math.h>
double
creal(double complex z)
{
return __real__ z;
}
|
the_stack_data/98575792.c | /*
* POK header
*
* The following file is a part of the POK project. Any modification should
* made according to the POK licence. You CANNOT use this file or a part of
* this file is this 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-2009 POK team
*
* Created by julien on Tue Dec 8 15:53:28 2009
*/
/* crypto/des/set_key.c */
/* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* 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 copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
/* set_key.c v 1.4 eay 24/9/91
* 1.4 Speed up by 400% :-)
* 1.3 added register declarations.
* 1.2 unrolled make_key_sched a bit more
* 1.1 added norm_expand_bits
* 1.0 First working version
*/
#ifdef POK_NEEDS_PROTOCOLS_DES
#include "des_locl.h"
#ifdef OPENSSL_FIPS
#include <openssl/fips.h>
#endif
OPENSSL_IMPLEMENT_GLOBAL(int,DES_check_key); /* defaults to false */
static const unsigned char odd_parity[256]={
1, 1, 2, 2, 4, 4, 7, 7, 8, 8, 11, 11, 13, 13, 14, 14,
16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254};
void DES_set_odd_parity(DES_cblock *key)
{
unsigned int i;
for (i=0; i<DES_KEY_SZ; i++)
(*key)[i]=odd_parity[(*key)[i]];
}
int DES_check_key_parity(const_DES_cblock *key)
{
unsigned int i;
for (i=0; i<DES_KEY_SZ; i++)
{
if ((*key)[i] != odd_parity[(*key)[i]])
return(0);
}
return(1);
}
/* Weak and semi week keys as take from
* %A D.W. Davies
* %A W.L. Price
* %T Security for Computer Networks
* %I John Wiley & Sons
* %D 1984
* Many thanks to [email protected] (Steven Bellovin) for the reference
* (and actual cblock values).
*/
#define NUM_WEAK_KEY 16
static const DES_cblock weak_keys[NUM_WEAK_KEY]={
/* weak keys */
{0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
{0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE},
{0x1F,0x1F,0x1F,0x1F,0x0E,0x0E,0x0E,0x0E},
{0xE0,0xE0,0xE0,0xE0,0xF1,0xF1,0xF1,0xF1},
/* semi-weak keys */
{0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE},
{0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01},
{0x1F,0xE0,0x1F,0xE0,0x0E,0xF1,0x0E,0xF1},
{0xE0,0x1F,0xE0,0x1F,0xF1,0x0E,0xF1,0x0E},
{0x01,0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1},
{0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1,0x01},
{0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E,0xFE},
{0xFE,0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E},
{0x01,0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E},
{0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E,0x01},
{0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
{0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1}};
int DES_is_weak_key(const_DES_cblock *key)
{
int i;
for (i=0; i<NUM_WEAK_KEY; i++)
/* Added == 0 to comparison, I obviously don't run
* this section very often :-(, thanks to
* [email protected] for the fix
* eay 93/06/29
* Another problem, I was comparing only the first 4
* bytes, 97/03/18 */
if (memcmp(weak_keys[i],key,sizeof(DES_cblock)) == 0) return(1);
return(0);
}
/* NOW DEFINED IN des_local.h
* See ecb_encrypt.c for a pseudo description of these macros.
* #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
* (b)^=(t),\
* (a)=((a)^((t)<<(n))))
*/
#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
(a)=(a)^(t)^(t>>(16-(n))))
static const DES_LONG des_skb[8][64]={
{
/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
0x00000000L,0x00000010L,0x20000000L,0x20000010L,
0x00010000L,0x00010010L,0x20010000L,0x20010010L,
0x00000800L,0x00000810L,0x20000800L,0x20000810L,
0x00010800L,0x00010810L,0x20010800L,0x20010810L,
0x00000020L,0x00000030L,0x20000020L,0x20000030L,
0x00010020L,0x00010030L,0x20010020L,0x20010030L,
0x00000820L,0x00000830L,0x20000820L,0x20000830L,
0x00010820L,0x00010830L,0x20010820L,0x20010830L,
0x00080000L,0x00080010L,0x20080000L,0x20080010L,
0x00090000L,0x00090010L,0x20090000L,0x20090010L,
0x00080800L,0x00080810L,0x20080800L,0x20080810L,
0x00090800L,0x00090810L,0x20090800L,0x20090810L,
0x00080020L,0x00080030L,0x20080020L,0x20080030L,
0x00090020L,0x00090030L,0x20090020L,0x20090030L,
0x00080820L,0x00080830L,0x20080820L,0x20080830L,
0x00090820L,0x00090830L,0x20090820L,0x20090830L,
},{
/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
0x00000000L,0x02000000L,0x00002000L,0x02002000L,
0x00200000L,0x02200000L,0x00202000L,0x02202000L,
0x00000004L,0x02000004L,0x00002004L,0x02002004L,
0x00200004L,0x02200004L,0x00202004L,0x02202004L,
0x00000400L,0x02000400L,0x00002400L,0x02002400L,
0x00200400L,0x02200400L,0x00202400L,0x02202400L,
0x00000404L,0x02000404L,0x00002404L,0x02002404L,
0x00200404L,0x02200404L,0x00202404L,0x02202404L,
0x10000000L,0x12000000L,0x10002000L,0x12002000L,
0x10200000L,0x12200000L,0x10202000L,0x12202000L,
0x10000004L,0x12000004L,0x10002004L,0x12002004L,
0x10200004L,0x12200004L,0x10202004L,0x12202004L,
0x10000400L,0x12000400L,0x10002400L,0x12002400L,
0x10200400L,0x12200400L,0x10202400L,0x12202400L,
0x10000404L,0x12000404L,0x10002404L,0x12002404L,
0x10200404L,0x12200404L,0x10202404L,0x12202404L,
},{
/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
0x00000000L,0x00000001L,0x00040000L,0x00040001L,
0x01000000L,0x01000001L,0x01040000L,0x01040001L,
0x00000002L,0x00000003L,0x00040002L,0x00040003L,
0x01000002L,0x01000003L,0x01040002L,0x01040003L,
0x00000200L,0x00000201L,0x00040200L,0x00040201L,
0x01000200L,0x01000201L,0x01040200L,0x01040201L,
0x00000202L,0x00000203L,0x00040202L,0x00040203L,
0x01000202L,0x01000203L,0x01040202L,0x01040203L,
0x08000000L,0x08000001L,0x08040000L,0x08040001L,
0x09000000L,0x09000001L,0x09040000L,0x09040001L,
0x08000002L,0x08000003L,0x08040002L,0x08040003L,
0x09000002L,0x09000003L,0x09040002L,0x09040003L,
0x08000200L,0x08000201L,0x08040200L,0x08040201L,
0x09000200L,0x09000201L,0x09040200L,0x09040201L,
0x08000202L,0x08000203L,0x08040202L,0x08040203L,
0x09000202L,0x09000203L,0x09040202L,0x09040203L,
},{
/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
0x00000000L,0x00100000L,0x00000100L,0x00100100L,
0x00000008L,0x00100008L,0x00000108L,0x00100108L,
0x00001000L,0x00101000L,0x00001100L,0x00101100L,
0x00001008L,0x00101008L,0x00001108L,0x00101108L,
0x04000000L,0x04100000L,0x04000100L,0x04100100L,
0x04000008L,0x04100008L,0x04000108L,0x04100108L,
0x04001000L,0x04101000L,0x04001100L,0x04101100L,
0x04001008L,0x04101008L,0x04001108L,0x04101108L,
0x00020000L,0x00120000L,0x00020100L,0x00120100L,
0x00020008L,0x00120008L,0x00020108L,0x00120108L,
0x00021000L,0x00121000L,0x00021100L,0x00121100L,
0x00021008L,0x00121008L,0x00021108L,0x00121108L,
0x04020000L,0x04120000L,0x04020100L,0x04120100L,
0x04020008L,0x04120008L,0x04020108L,0x04120108L,
0x04021000L,0x04121000L,0x04021100L,0x04121100L,
0x04021008L,0x04121008L,0x04021108L,0x04121108L,
},{
/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
0x00000000L,0x10000000L,0x00010000L,0x10010000L,
0x00000004L,0x10000004L,0x00010004L,0x10010004L,
0x20000000L,0x30000000L,0x20010000L,0x30010000L,
0x20000004L,0x30000004L,0x20010004L,0x30010004L,
0x00100000L,0x10100000L,0x00110000L,0x10110000L,
0x00100004L,0x10100004L,0x00110004L,0x10110004L,
0x20100000L,0x30100000L,0x20110000L,0x30110000L,
0x20100004L,0x30100004L,0x20110004L,0x30110004L,
0x00001000L,0x10001000L,0x00011000L,0x10011000L,
0x00001004L,0x10001004L,0x00011004L,0x10011004L,
0x20001000L,0x30001000L,0x20011000L,0x30011000L,
0x20001004L,0x30001004L,0x20011004L,0x30011004L,
0x00101000L,0x10101000L,0x00111000L,0x10111000L,
0x00101004L,0x10101004L,0x00111004L,0x10111004L,
0x20101000L,0x30101000L,0x20111000L,0x30111000L,
0x20101004L,0x30101004L,0x20111004L,0x30111004L,
},{
/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
0x00000000L,0x08000000L,0x00000008L,0x08000008L,
0x00000400L,0x08000400L,0x00000408L,0x08000408L,
0x00020000L,0x08020000L,0x00020008L,0x08020008L,
0x00020400L,0x08020400L,0x00020408L,0x08020408L,
0x00000001L,0x08000001L,0x00000009L,0x08000009L,
0x00000401L,0x08000401L,0x00000409L,0x08000409L,
0x00020001L,0x08020001L,0x00020009L,0x08020009L,
0x00020401L,0x08020401L,0x00020409L,0x08020409L,
0x02000000L,0x0A000000L,0x02000008L,0x0A000008L,
0x02000400L,0x0A000400L,0x02000408L,0x0A000408L,
0x02020000L,0x0A020000L,0x02020008L,0x0A020008L,
0x02020400L,0x0A020400L,0x02020408L,0x0A020408L,
0x02000001L,0x0A000001L,0x02000009L,0x0A000009L,
0x02000401L,0x0A000401L,0x02000409L,0x0A000409L,
0x02020001L,0x0A020001L,0x02020009L,0x0A020009L,
0x02020401L,0x0A020401L,0x02020409L,0x0A020409L,
},{
/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
0x00000000L,0x00000100L,0x00080000L,0x00080100L,
0x01000000L,0x01000100L,0x01080000L,0x01080100L,
0x00000010L,0x00000110L,0x00080010L,0x00080110L,
0x01000010L,0x01000110L,0x01080010L,0x01080110L,
0x00200000L,0x00200100L,0x00280000L,0x00280100L,
0x01200000L,0x01200100L,0x01280000L,0x01280100L,
0x00200010L,0x00200110L,0x00280010L,0x00280110L,
0x01200010L,0x01200110L,0x01280010L,0x01280110L,
0x00000200L,0x00000300L,0x00080200L,0x00080300L,
0x01000200L,0x01000300L,0x01080200L,0x01080300L,
0x00000210L,0x00000310L,0x00080210L,0x00080310L,
0x01000210L,0x01000310L,0x01080210L,0x01080310L,
0x00200200L,0x00200300L,0x00280200L,0x00280300L,
0x01200200L,0x01200300L,0x01280200L,0x01280300L,
0x00200210L,0x00200310L,0x00280210L,0x00280310L,
0x01200210L,0x01200310L,0x01280210L,0x01280310L,
},{
/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
0x00000000L,0x04000000L,0x00040000L,0x04040000L,
0x00000002L,0x04000002L,0x00040002L,0x04040002L,
0x00002000L,0x04002000L,0x00042000L,0x04042000L,
0x00002002L,0x04002002L,0x00042002L,0x04042002L,
0x00000020L,0x04000020L,0x00040020L,0x04040020L,
0x00000022L,0x04000022L,0x00040022L,0x04040022L,
0x00002020L,0x04002020L,0x00042020L,0x04042020L,
0x00002022L,0x04002022L,0x00042022L,0x04042022L,
0x00000800L,0x04000800L,0x00040800L,0x04040800L,
0x00000802L,0x04000802L,0x00040802L,0x04040802L,
0x00002800L,0x04002800L,0x00042800L,0x04042800L,
0x00002802L,0x04002802L,0x00042802L,0x04042802L,
0x00000820L,0x04000820L,0x00040820L,0x04040820L,
0x00000822L,0x04000822L,0x00040822L,0x04040822L,
0x00002820L,0x04002820L,0x00042820L,0x04042820L,
0x00002822L,0x04002822L,0x00042822L,0x04042822L,
}};
int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule)
{
if (DES_check_key)
{
return DES_set_key_checked(key, schedule);
}
else
{
DES_set_key_unchecked(key, schedule);
return 0;
}
}
/* return 0 if key parity is odd (correct),
* return -1 if key parity error,
* return -2 if illegal weak key.
*/
int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule)
{
if (!DES_check_key_parity(key))
return(-1);
if (DES_is_weak_key(key))
return(-2);
DES_set_key_unchecked(key, schedule);
return 0;
}
void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
{
static int shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
register DES_LONG c,d,t,s,t2;
register const unsigned char *in;
register DES_LONG *k;
register int i;
#ifdef OPENBSD_DEV_CRYPTO
memcpy(schedule->key,key,sizeof schedule->key);
schedule->session=NULL;
#endif
k = &schedule->ks->deslong[0];
in = &(*key)[0];
#ifdef OPENSSL_FIPS
FIPS_selftest_check();
#endif
c2l(in,c);
c2l(in,d);
/* do PC1 in 47 simple operations :-)
* Thanks to John Fletcher ([email protected])
* for the inspiration. :-) */
PERM_OP (d,c,t,4,0x0f0f0f0fL);
HPERM_OP(c,t,-2,0xcccc0000L);
HPERM_OP(d,t,-2,0xcccc0000L);
PERM_OP (d,c,t,1,0x55555555L);
PERM_OP (c,d,t,8,0x00ff00ffL);
PERM_OP (d,c,t,1,0x55555555L);
d= (((d&0x000000ffL)<<16L)| (d&0x0000ff00L) |
((d&0x00ff0000L)>>16L)|((c&0xf0000000L)>>4L));
c&=0x0fffffffL;
for (i=0; i<ITERATIONS; i++)
{
if (shifts2[i])
{ c=((c>>2L)|(c<<26L)); d=((d>>2L)|(d<<26L)); }
else
{ c=((c>>1L)|(c<<27L)); d=((d>>1L)|(d<<27L)); }
c&=0x0fffffffL;
d&=0x0fffffffL;
/* could be a few less shifts but I am to lazy at this
* point in time to investigate */
s= des_skb[0][ (c )&0x3f ]|
des_skb[1][((c>> 6L)&0x03)|((c>> 7L)&0x3c)]|
des_skb[2][((c>>13L)&0x0f)|((c>>14L)&0x30)]|
des_skb[3][((c>>20L)&0x01)|((c>>21L)&0x06) |
((c>>22L)&0x38)];
t= des_skb[4][ (d )&0x3f ]|
des_skb[5][((d>> 7L)&0x03)|((d>> 8L)&0x3c)]|
des_skb[6][ (d>>15L)&0x3f ]|
des_skb[7][((d>>21L)&0x0f)|((d>>22L)&0x30)];
/* table contained 0213 4657 */
t2=((t<<16L)|(s&0x0000ffffL))&0xffffffffL;
*(k++)=ROTATE(t2,30)&0xffffffffL;
t2=((s>>16L)|(t&0xffff0000L));
*(k++)=ROTATE(t2,26)&0xffffffffL;
}
}
int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule)
{
return(DES_set_key(key,schedule));
}
/*
#undef des_fixup_key_parity
void des_fixup_key_parity(des_cblock *key)
{
des_set_odd_parity(key);
}
*/
#endif /* POK_NEEDS_ ...*/
|
the_stack_data/1201396.c | // license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************
cdrom.c
Generic MAME CD-ROM utilties - build IDE and SCSI CD-ROMs on top of this
****************************************************************************
IMPORTANT:
"physical" block addresses are the actual addresses on the emulated CD.
"chd" block addresses are the block addresses in the CHD file.
Because we pad each track to a 4-frame boundary, these addressing
schemes will differ after track 1!
***************************************************************************/
#ifdef WANT_RAW_DATA_SECTOR
#include <assert.h>
#include <string.h>
#include "cdrom.h"
/***************************************************************************
DEBUGGING
***************************************************************************/
/** @brief The verbose. */
#define VERBOSE (0)
#if VERBOSE
/**
* @def LOG(x) do
*
* @brief A macro that defines log.
*
* @param x The void to process.
*/
#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
/**
* @fn void CLIB_DECL logerror(const char *text, ...) ATTR_PRINTF(1,2);
*
* @brief Logerrors the given text.
*
* @param text The text.
*
* @return A CLIB_DECL.
*/
void CLIB_DECL logerror(const char *text, ...) ATTR_PRINTF(1,2);
#else
/**
* @def LOG(x);
*
* @brief A macro that defines log.
*
* @param x The void to process.
*/
#define LOG(x)
#endif
/***************************************************************************
CONSTANTS
***************************************************************************/
/** @brief offset within sector. */
#define SYNC_OFFSET 0x000
/** @brief 12 bytes. */
#define SYNC_NUM_BYTES 12
/** @brief offset within sector. */
#define MODE_OFFSET 0x00f
/** @brief offset within sector. */
#define ECC_P_OFFSET 0x81c
/** @brief 2 lots of 86. */
#define ECC_P_NUM_BYTES 86
/** @brief 24 bytes each. */
#define ECC_P_COMP 24
/** @brief The ECC q offset. */
#define ECC_Q_OFFSET (ECC_P_OFFSET + 2 * ECC_P_NUM_BYTES)
/** @brief 2 lots of 52. */
#define ECC_Q_NUM_BYTES 52
/** @brief 43 bytes each. */
#define ECC_Q_COMP 43
/**
* @brief -------------------------------------------------
* ECC lookup tables pre-calculated tables for ECC data calcs
* -------------------------------------------------.
*/
static const uint8_t ecclow[256] =
{
0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
0x1d, 0x1f, 0x19, 0x1b, 0x15, 0x17, 0x11, 0x13, 0x0d, 0x0f, 0x09, 0x0b, 0x05, 0x07, 0x01, 0x03,
0x3d, 0x3f, 0x39, 0x3b, 0x35, 0x37, 0x31, 0x33, 0x2d, 0x2f, 0x29, 0x2b, 0x25, 0x27, 0x21, 0x23,
0x5d, 0x5f, 0x59, 0x5b, 0x55, 0x57, 0x51, 0x53, 0x4d, 0x4f, 0x49, 0x4b, 0x45, 0x47, 0x41, 0x43,
0x7d, 0x7f, 0x79, 0x7b, 0x75, 0x77, 0x71, 0x73, 0x6d, 0x6f, 0x69, 0x6b, 0x65, 0x67, 0x61, 0x63,
0x9d, 0x9f, 0x99, 0x9b, 0x95, 0x97, 0x91, 0x93, 0x8d, 0x8f, 0x89, 0x8b, 0x85, 0x87, 0x81, 0x83,
0xbd, 0xbf, 0xb9, 0xbb, 0xb5, 0xb7, 0xb1, 0xb3, 0xad, 0xaf, 0xa9, 0xab, 0xa5, 0xa7, 0xa1, 0xa3,
0xdd, 0xdf, 0xd9, 0xdb, 0xd5, 0xd7, 0xd1, 0xd3, 0xcd, 0xcf, 0xc9, 0xcb, 0xc5, 0xc7, 0xc1, 0xc3,
0xfd, 0xff, 0xf9, 0xfb, 0xf5, 0xf7, 0xf1, 0xf3, 0xed, 0xef, 0xe9, 0xeb, 0xe5, 0xe7, 0xe1, 0xe3
};
/** @brief The ecchigh[ 256]. */
static const uint8_t ecchigh[256] =
{
0x00, 0xf4, 0xf5, 0x01, 0xf7, 0x03, 0x02, 0xf6, 0xf3, 0x07, 0x06, 0xf2, 0x04, 0xf0, 0xf1, 0x05,
0xfb, 0x0f, 0x0e, 0xfa, 0x0c, 0xf8, 0xf9, 0x0d, 0x08, 0xfc, 0xfd, 0x09, 0xff, 0x0b, 0x0a, 0xfe,
0xeb, 0x1f, 0x1e, 0xea, 0x1c, 0xe8, 0xe9, 0x1d, 0x18, 0xec, 0xed, 0x19, 0xef, 0x1b, 0x1a, 0xee,
0x10, 0xe4, 0xe5, 0x11, 0xe7, 0x13, 0x12, 0xe6, 0xe3, 0x17, 0x16, 0xe2, 0x14, 0xe0, 0xe1, 0x15,
0xcb, 0x3f, 0x3e, 0xca, 0x3c, 0xc8, 0xc9, 0x3d, 0x38, 0xcc, 0xcd, 0x39, 0xcf, 0x3b, 0x3a, 0xce,
0x30, 0xc4, 0xc5, 0x31, 0xc7, 0x33, 0x32, 0xc6, 0xc3, 0x37, 0x36, 0xc2, 0x34, 0xc0, 0xc1, 0x35,
0x20, 0xd4, 0xd5, 0x21, 0xd7, 0x23, 0x22, 0xd6, 0xd3, 0x27, 0x26, 0xd2, 0x24, 0xd0, 0xd1, 0x25,
0xdb, 0x2f, 0x2e, 0xda, 0x2c, 0xd8, 0xd9, 0x2d, 0x28, 0xdc, 0xdd, 0x29, 0xdf, 0x2b, 0x2a, 0xde,
0x8b, 0x7f, 0x7e, 0x8a, 0x7c, 0x88, 0x89, 0x7d, 0x78, 0x8c, 0x8d, 0x79, 0x8f, 0x7b, 0x7a, 0x8e,
0x70, 0x84, 0x85, 0x71, 0x87, 0x73, 0x72, 0x86, 0x83, 0x77, 0x76, 0x82, 0x74, 0x80, 0x81, 0x75,
0x60, 0x94, 0x95, 0x61, 0x97, 0x63, 0x62, 0x96, 0x93, 0x67, 0x66, 0x92, 0x64, 0x90, 0x91, 0x65,
0x9b, 0x6f, 0x6e, 0x9a, 0x6c, 0x98, 0x99, 0x6d, 0x68, 0x9c, 0x9d, 0x69, 0x9f, 0x6b, 0x6a, 0x9e,
0x40, 0xb4, 0xb5, 0x41, 0xb7, 0x43, 0x42, 0xb6, 0xb3, 0x47, 0x46, 0xb2, 0x44, 0xb0, 0xb1, 0x45,
0xbb, 0x4f, 0x4e, 0xba, 0x4c, 0xb8, 0xb9, 0x4d, 0x48, 0xbc, 0xbd, 0x49, 0xbf, 0x4b, 0x4a, 0xbe,
0xab, 0x5f, 0x5e, 0xaa, 0x5c, 0xa8, 0xa9, 0x5d, 0x58, 0xac, 0xad, 0x59, 0xaf, 0x5b, 0x5a, 0xae,
0x50, 0xa4, 0xa5, 0x51, 0xa7, 0x53, 0x52, 0xa6, 0xa3, 0x57, 0x56, 0xa2, 0x54, 0xa0, 0xa1, 0x55
};
/**
* @brief -------------------------------------------------
* poffsets - each row represents the addresses used to calculate a byte of the ECC P
* data 86 (*2) ECC P bytes, 24 values represented by each
* -------------------------------------------------.
*/
static const uint16_t poffsets[ECC_P_NUM_BYTES][ECC_P_COMP] =
{
{ 0x000,0x056,0x0ac,0x102,0x158,0x1ae,0x204,0x25a,0x2b0,0x306,0x35c,0x3b2,0x408,0x45e,0x4b4,0x50a,0x560,0x5b6,0x60c,0x662,0x6b8,0x70e,0x764,0x7ba },
{ 0x001,0x057,0x0ad,0x103,0x159,0x1af,0x205,0x25b,0x2b1,0x307,0x35d,0x3b3,0x409,0x45f,0x4b5,0x50b,0x561,0x5b7,0x60d,0x663,0x6b9,0x70f,0x765,0x7bb },
{ 0x002,0x058,0x0ae,0x104,0x15a,0x1b0,0x206,0x25c,0x2b2,0x308,0x35e,0x3b4,0x40a,0x460,0x4b6,0x50c,0x562,0x5b8,0x60e,0x664,0x6ba,0x710,0x766,0x7bc },
{ 0x003,0x059,0x0af,0x105,0x15b,0x1b1,0x207,0x25d,0x2b3,0x309,0x35f,0x3b5,0x40b,0x461,0x4b7,0x50d,0x563,0x5b9,0x60f,0x665,0x6bb,0x711,0x767,0x7bd },
{ 0x004,0x05a,0x0b0,0x106,0x15c,0x1b2,0x208,0x25e,0x2b4,0x30a,0x360,0x3b6,0x40c,0x462,0x4b8,0x50e,0x564,0x5ba,0x610,0x666,0x6bc,0x712,0x768,0x7be },
{ 0x005,0x05b,0x0b1,0x107,0x15d,0x1b3,0x209,0x25f,0x2b5,0x30b,0x361,0x3b7,0x40d,0x463,0x4b9,0x50f,0x565,0x5bb,0x611,0x667,0x6bd,0x713,0x769,0x7bf },
{ 0x006,0x05c,0x0b2,0x108,0x15e,0x1b4,0x20a,0x260,0x2b6,0x30c,0x362,0x3b8,0x40e,0x464,0x4ba,0x510,0x566,0x5bc,0x612,0x668,0x6be,0x714,0x76a,0x7c0 },
{ 0x007,0x05d,0x0b3,0x109,0x15f,0x1b5,0x20b,0x261,0x2b7,0x30d,0x363,0x3b9,0x40f,0x465,0x4bb,0x511,0x567,0x5bd,0x613,0x669,0x6bf,0x715,0x76b,0x7c1 },
{ 0x008,0x05e,0x0b4,0x10a,0x160,0x1b6,0x20c,0x262,0x2b8,0x30e,0x364,0x3ba,0x410,0x466,0x4bc,0x512,0x568,0x5be,0x614,0x66a,0x6c0,0x716,0x76c,0x7c2 },
{ 0x009,0x05f,0x0b5,0x10b,0x161,0x1b7,0x20d,0x263,0x2b9,0x30f,0x365,0x3bb,0x411,0x467,0x4bd,0x513,0x569,0x5bf,0x615,0x66b,0x6c1,0x717,0x76d,0x7c3 },
{ 0x00a,0x060,0x0b6,0x10c,0x162,0x1b8,0x20e,0x264,0x2ba,0x310,0x366,0x3bc,0x412,0x468,0x4be,0x514,0x56a,0x5c0,0x616,0x66c,0x6c2,0x718,0x76e,0x7c4 },
{ 0x00b,0x061,0x0b7,0x10d,0x163,0x1b9,0x20f,0x265,0x2bb,0x311,0x367,0x3bd,0x413,0x469,0x4bf,0x515,0x56b,0x5c1,0x617,0x66d,0x6c3,0x719,0x76f,0x7c5 },
{ 0x00c,0x062,0x0b8,0x10e,0x164,0x1ba,0x210,0x266,0x2bc,0x312,0x368,0x3be,0x414,0x46a,0x4c0,0x516,0x56c,0x5c2,0x618,0x66e,0x6c4,0x71a,0x770,0x7c6 },
{ 0x00d,0x063,0x0b9,0x10f,0x165,0x1bb,0x211,0x267,0x2bd,0x313,0x369,0x3bf,0x415,0x46b,0x4c1,0x517,0x56d,0x5c3,0x619,0x66f,0x6c5,0x71b,0x771,0x7c7 },
{ 0x00e,0x064,0x0ba,0x110,0x166,0x1bc,0x212,0x268,0x2be,0x314,0x36a,0x3c0,0x416,0x46c,0x4c2,0x518,0x56e,0x5c4,0x61a,0x670,0x6c6,0x71c,0x772,0x7c8 },
{ 0x00f,0x065,0x0bb,0x111,0x167,0x1bd,0x213,0x269,0x2bf,0x315,0x36b,0x3c1,0x417,0x46d,0x4c3,0x519,0x56f,0x5c5,0x61b,0x671,0x6c7,0x71d,0x773,0x7c9 },
{ 0x010,0x066,0x0bc,0x112,0x168,0x1be,0x214,0x26a,0x2c0,0x316,0x36c,0x3c2,0x418,0x46e,0x4c4,0x51a,0x570,0x5c6,0x61c,0x672,0x6c8,0x71e,0x774,0x7ca },
{ 0x011,0x067,0x0bd,0x113,0x169,0x1bf,0x215,0x26b,0x2c1,0x317,0x36d,0x3c3,0x419,0x46f,0x4c5,0x51b,0x571,0x5c7,0x61d,0x673,0x6c9,0x71f,0x775,0x7cb },
{ 0x012,0x068,0x0be,0x114,0x16a,0x1c0,0x216,0x26c,0x2c2,0x318,0x36e,0x3c4,0x41a,0x470,0x4c6,0x51c,0x572,0x5c8,0x61e,0x674,0x6ca,0x720,0x776,0x7cc },
{ 0x013,0x069,0x0bf,0x115,0x16b,0x1c1,0x217,0x26d,0x2c3,0x319,0x36f,0x3c5,0x41b,0x471,0x4c7,0x51d,0x573,0x5c9,0x61f,0x675,0x6cb,0x721,0x777,0x7cd },
{ 0x014,0x06a,0x0c0,0x116,0x16c,0x1c2,0x218,0x26e,0x2c4,0x31a,0x370,0x3c6,0x41c,0x472,0x4c8,0x51e,0x574,0x5ca,0x620,0x676,0x6cc,0x722,0x778,0x7ce },
{ 0x015,0x06b,0x0c1,0x117,0x16d,0x1c3,0x219,0x26f,0x2c5,0x31b,0x371,0x3c7,0x41d,0x473,0x4c9,0x51f,0x575,0x5cb,0x621,0x677,0x6cd,0x723,0x779,0x7cf },
{ 0x016,0x06c,0x0c2,0x118,0x16e,0x1c4,0x21a,0x270,0x2c6,0x31c,0x372,0x3c8,0x41e,0x474,0x4ca,0x520,0x576,0x5cc,0x622,0x678,0x6ce,0x724,0x77a,0x7d0 },
{ 0x017,0x06d,0x0c3,0x119,0x16f,0x1c5,0x21b,0x271,0x2c7,0x31d,0x373,0x3c9,0x41f,0x475,0x4cb,0x521,0x577,0x5cd,0x623,0x679,0x6cf,0x725,0x77b,0x7d1 },
{ 0x018,0x06e,0x0c4,0x11a,0x170,0x1c6,0x21c,0x272,0x2c8,0x31e,0x374,0x3ca,0x420,0x476,0x4cc,0x522,0x578,0x5ce,0x624,0x67a,0x6d0,0x726,0x77c,0x7d2 },
{ 0x019,0x06f,0x0c5,0x11b,0x171,0x1c7,0x21d,0x273,0x2c9,0x31f,0x375,0x3cb,0x421,0x477,0x4cd,0x523,0x579,0x5cf,0x625,0x67b,0x6d1,0x727,0x77d,0x7d3 },
{ 0x01a,0x070,0x0c6,0x11c,0x172,0x1c8,0x21e,0x274,0x2ca,0x320,0x376,0x3cc,0x422,0x478,0x4ce,0x524,0x57a,0x5d0,0x626,0x67c,0x6d2,0x728,0x77e,0x7d4 },
{ 0x01b,0x071,0x0c7,0x11d,0x173,0x1c9,0x21f,0x275,0x2cb,0x321,0x377,0x3cd,0x423,0x479,0x4cf,0x525,0x57b,0x5d1,0x627,0x67d,0x6d3,0x729,0x77f,0x7d5 },
{ 0x01c,0x072,0x0c8,0x11e,0x174,0x1ca,0x220,0x276,0x2cc,0x322,0x378,0x3ce,0x424,0x47a,0x4d0,0x526,0x57c,0x5d2,0x628,0x67e,0x6d4,0x72a,0x780,0x7d6 },
{ 0x01d,0x073,0x0c9,0x11f,0x175,0x1cb,0x221,0x277,0x2cd,0x323,0x379,0x3cf,0x425,0x47b,0x4d1,0x527,0x57d,0x5d3,0x629,0x67f,0x6d5,0x72b,0x781,0x7d7 },
{ 0x01e,0x074,0x0ca,0x120,0x176,0x1cc,0x222,0x278,0x2ce,0x324,0x37a,0x3d0,0x426,0x47c,0x4d2,0x528,0x57e,0x5d4,0x62a,0x680,0x6d6,0x72c,0x782,0x7d8 },
{ 0x01f,0x075,0x0cb,0x121,0x177,0x1cd,0x223,0x279,0x2cf,0x325,0x37b,0x3d1,0x427,0x47d,0x4d3,0x529,0x57f,0x5d5,0x62b,0x681,0x6d7,0x72d,0x783,0x7d9 },
{ 0x020,0x076,0x0cc,0x122,0x178,0x1ce,0x224,0x27a,0x2d0,0x326,0x37c,0x3d2,0x428,0x47e,0x4d4,0x52a,0x580,0x5d6,0x62c,0x682,0x6d8,0x72e,0x784,0x7da },
{ 0x021,0x077,0x0cd,0x123,0x179,0x1cf,0x225,0x27b,0x2d1,0x327,0x37d,0x3d3,0x429,0x47f,0x4d5,0x52b,0x581,0x5d7,0x62d,0x683,0x6d9,0x72f,0x785,0x7db },
{ 0x022,0x078,0x0ce,0x124,0x17a,0x1d0,0x226,0x27c,0x2d2,0x328,0x37e,0x3d4,0x42a,0x480,0x4d6,0x52c,0x582,0x5d8,0x62e,0x684,0x6da,0x730,0x786,0x7dc },
{ 0x023,0x079,0x0cf,0x125,0x17b,0x1d1,0x227,0x27d,0x2d3,0x329,0x37f,0x3d5,0x42b,0x481,0x4d7,0x52d,0x583,0x5d9,0x62f,0x685,0x6db,0x731,0x787,0x7dd },
{ 0x024,0x07a,0x0d0,0x126,0x17c,0x1d2,0x228,0x27e,0x2d4,0x32a,0x380,0x3d6,0x42c,0x482,0x4d8,0x52e,0x584,0x5da,0x630,0x686,0x6dc,0x732,0x788,0x7de },
{ 0x025,0x07b,0x0d1,0x127,0x17d,0x1d3,0x229,0x27f,0x2d5,0x32b,0x381,0x3d7,0x42d,0x483,0x4d9,0x52f,0x585,0x5db,0x631,0x687,0x6dd,0x733,0x789,0x7df },
{ 0x026,0x07c,0x0d2,0x128,0x17e,0x1d4,0x22a,0x280,0x2d6,0x32c,0x382,0x3d8,0x42e,0x484,0x4da,0x530,0x586,0x5dc,0x632,0x688,0x6de,0x734,0x78a,0x7e0 },
{ 0x027,0x07d,0x0d3,0x129,0x17f,0x1d5,0x22b,0x281,0x2d7,0x32d,0x383,0x3d9,0x42f,0x485,0x4db,0x531,0x587,0x5dd,0x633,0x689,0x6df,0x735,0x78b,0x7e1 },
{ 0x028,0x07e,0x0d4,0x12a,0x180,0x1d6,0x22c,0x282,0x2d8,0x32e,0x384,0x3da,0x430,0x486,0x4dc,0x532,0x588,0x5de,0x634,0x68a,0x6e0,0x736,0x78c,0x7e2 },
{ 0x029,0x07f,0x0d5,0x12b,0x181,0x1d7,0x22d,0x283,0x2d9,0x32f,0x385,0x3db,0x431,0x487,0x4dd,0x533,0x589,0x5df,0x635,0x68b,0x6e1,0x737,0x78d,0x7e3 },
{ 0x02a,0x080,0x0d6,0x12c,0x182,0x1d8,0x22e,0x284,0x2da,0x330,0x386,0x3dc,0x432,0x488,0x4de,0x534,0x58a,0x5e0,0x636,0x68c,0x6e2,0x738,0x78e,0x7e4 },
{ 0x02b,0x081,0x0d7,0x12d,0x183,0x1d9,0x22f,0x285,0x2db,0x331,0x387,0x3dd,0x433,0x489,0x4df,0x535,0x58b,0x5e1,0x637,0x68d,0x6e3,0x739,0x78f,0x7e5 },
{ 0x02c,0x082,0x0d8,0x12e,0x184,0x1da,0x230,0x286,0x2dc,0x332,0x388,0x3de,0x434,0x48a,0x4e0,0x536,0x58c,0x5e2,0x638,0x68e,0x6e4,0x73a,0x790,0x7e6 },
{ 0x02d,0x083,0x0d9,0x12f,0x185,0x1db,0x231,0x287,0x2dd,0x333,0x389,0x3df,0x435,0x48b,0x4e1,0x537,0x58d,0x5e3,0x639,0x68f,0x6e5,0x73b,0x791,0x7e7 },
{ 0x02e,0x084,0x0da,0x130,0x186,0x1dc,0x232,0x288,0x2de,0x334,0x38a,0x3e0,0x436,0x48c,0x4e2,0x538,0x58e,0x5e4,0x63a,0x690,0x6e6,0x73c,0x792,0x7e8 },
{ 0x02f,0x085,0x0db,0x131,0x187,0x1dd,0x233,0x289,0x2df,0x335,0x38b,0x3e1,0x437,0x48d,0x4e3,0x539,0x58f,0x5e5,0x63b,0x691,0x6e7,0x73d,0x793,0x7e9 },
{ 0x030,0x086,0x0dc,0x132,0x188,0x1de,0x234,0x28a,0x2e0,0x336,0x38c,0x3e2,0x438,0x48e,0x4e4,0x53a,0x590,0x5e6,0x63c,0x692,0x6e8,0x73e,0x794,0x7ea },
{ 0x031,0x087,0x0dd,0x133,0x189,0x1df,0x235,0x28b,0x2e1,0x337,0x38d,0x3e3,0x439,0x48f,0x4e5,0x53b,0x591,0x5e7,0x63d,0x693,0x6e9,0x73f,0x795,0x7eb },
{ 0x032,0x088,0x0de,0x134,0x18a,0x1e0,0x236,0x28c,0x2e2,0x338,0x38e,0x3e4,0x43a,0x490,0x4e6,0x53c,0x592,0x5e8,0x63e,0x694,0x6ea,0x740,0x796,0x7ec },
{ 0x033,0x089,0x0df,0x135,0x18b,0x1e1,0x237,0x28d,0x2e3,0x339,0x38f,0x3e5,0x43b,0x491,0x4e7,0x53d,0x593,0x5e9,0x63f,0x695,0x6eb,0x741,0x797,0x7ed },
{ 0x034,0x08a,0x0e0,0x136,0x18c,0x1e2,0x238,0x28e,0x2e4,0x33a,0x390,0x3e6,0x43c,0x492,0x4e8,0x53e,0x594,0x5ea,0x640,0x696,0x6ec,0x742,0x798,0x7ee },
{ 0x035,0x08b,0x0e1,0x137,0x18d,0x1e3,0x239,0x28f,0x2e5,0x33b,0x391,0x3e7,0x43d,0x493,0x4e9,0x53f,0x595,0x5eb,0x641,0x697,0x6ed,0x743,0x799,0x7ef },
{ 0x036,0x08c,0x0e2,0x138,0x18e,0x1e4,0x23a,0x290,0x2e6,0x33c,0x392,0x3e8,0x43e,0x494,0x4ea,0x540,0x596,0x5ec,0x642,0x698,0x6ee,0x744,0x79a,0x7f0 },
{ 0x037,0x08d,0x0e3,0x139,0x18f,0x1e5,0x23b,0x291,0x2e7,0x33d,0x393,0x3e9,0x43f,0x495,0x4eb,0x541,0x597,0x5ed,0x643,0x699,0x6ef,0x745,0x79b,0x7f1 },
{ 0x038,0x08e,0x0e4,0x13a,0x190,0x1e6,0x23c,0x292,0x2e8,0x33e,0x394,0x3ea,0x440,0x496,0x4ec,0x542,0x598,0x5ee,0x644,0x69a,0x6f0,0x746,0x79c,0x7f2 },
{ 0x039,0x08f,0x0e5,0x13b,0x191,0x1e7,0x23d,0x293,0x2e9,0x33f,0x395,0x3eb,0x441,0x497,0x4ed,0x543,0x599,0x5ef,0x645,0x69b,0x6f1,0x747,0x79d,0x7f3 },
{ 0x03a,0x090,0x0e6,0x13c,0x192,0x1e8,0x23e,0x294,0x2ea,0x340,0x396,0x3ec,0x442,0x498,0x4ee,0x544,0x59a,0x5f0,0x646,0x69c,0x6f2,0x748,0x79e,0x7f4 },
{ 0x03b,0x091,0x0e7,0x13d,0x193,0x1e9,0x23f,0x295,0x2eb,0x341,0x397,0x3ed,0x443,0x499,0x4ef,0x545,0x59b,0x5f1,0x647,0x69d,0x6f3,0x749,0x79f,0x7f5 },
{ 0x03c,0x092,0x0e8,0x13e,0x194,0x1ea,0x240,0x296,0x2ec,0x342,0x398,0x3ee,0x444,0x49a,0x4f0,0x546,0x59c,0x5f2,0x648,0x69e,0x6f4,0x74a,0x7a0,0x7f6 },
{ 0x03d,0x093,0x0e9,0x13f,0x195,0x1eb,0x241,0x297,0x2ed,0x343,0x399,0x3ef,0x445,0x49b,0x4f1,0x547,0x59d,0x5f3,0x649,0x69f,0x6f5,0x74b,0x7a1,0x7f7 },
{ 0x03e,0x094,0x0ea,0x140,0x196,0x1ec,0x242,0x298,0x2ee,0x344,0x39a,0x3f0,0x446,0x49c,0x4f2,0x548,0x59e,0x5f4,0x64a,0x6a0,0x6f6,0x74c,0x7a2,0x7f8 },
{ 0x03f,0x095,0x0eb,0x141,0x197,0x1ed,0x243,0x299,0x2ef,0x345,0x39b,0x3f1,0x447,0x49d,0x4f3,0x549,0x59f,0x5f5,0x64b,0x6a1,0x6f7,0x74d,0x7a3,0x7f9 },
{ 0x040,0x096,0x0ec,0x142,0x198,0x1ee,0x244,0x29a,0x2f0,0x346,0x39c,0x3f2,0x448,0x49e,0x4f4,0x54a,0x5a0,0x5f6,0x64c,0x6a2,0x6f8,0x74e,0x7a4,0x7fa },
{ 0x041,0x097,0x0ed,0x143,0x199,0x1ef,0x245,0x29b,0x2f1,0x347,0x39d,0x3f3,0x449,0x49f,0x4f5,0x54b,0x5a1,0x5f7,0x64d,0x6a3,0x6f9,0x74f,0x7a5,0x7fb },
{ 0x042,0x098,0x0ee,0x144,0x19a,0x1f0,0x246,0x29c,0x2f2,0x348,0x39e,0x3f4,0x44a,0x4a0,0x4f6,0x54c,0x5a2,0x5f8,0x64e,0x6a4,0x6fa,0x750,0x7a6,0x7fc },
{ 0x043,0x099,0x0ef,0x145,0x19b,0x1f1,0x247,0x29d,0x2f3,0x349,0x39f,0x3f5,0x44b,0x4a1,0x4f7,0x54d,0x5a3,0x5f9,0x64f,0x6a5,0x6fb,0x751,0x7a7,0x7fd },
{ 0x044,0x09a,0x0f0,0x146,0x19c,0x1f2,0x248,0x29e,0x2f4,0x34a,0x3a0,0x3f6,0x44c,0x4a2,0x4f8,0x54e,0x5a4,0x5fa,0x650,0x6a6,0x6fc,0x752,0x7a8,0x7fe },
{ 0x045,0x09b,0x0f1,0x147,0x19d,0x1f3,0x249,0x29f,0x2f5,0x34b,0x3a1,0x3f7,0x44d,0x4a3,0x4f9,0x54f,0x5a5,0x5fb,0x651,0x6a7,0x6fd,0x753,0x7a9,0x7ff },
{ 0x046,0x09c,0x0f2,0x148,0x19e,0x1f4,0x24a,0x2a0,0x2f6,0x34c,0x3a2,0x3f8,0x44e,0x4a4,0x4fa,0x550,0x5a6,0x5fc,0x652,0x6a8,0x6fe,0x754,0x7aa,0x800 },
{ 0x047,0x09d,0x0f3,0x149,0x19f,0x1f5,0x24b,0x2a1,0x2f7,0x34d,0x3a3,0x3f9,0x44f,0x4a5,0x4fb,0x551,0x5a7,0x5fd,0x653,0x6a9,0x6ff,0x755,0x7ab,0x801 },
{ 0x048,0x09e,0x0f4,0x14a,0x1a0,0x1f6,0x24c,0x2a2,0x2f8,0x34e,0x3a4,0x3fa,0x450,0x4a6,0x4fc,0x552,0x5a8,0x5fe,0x654,0x6aa,0x700,0x756,0x7ac,0x802 },
{ 0x049,0x09f,0x0f5,0x14b,0x1a1,0x1f7,0x24d,0x2a3,0x2f9,0x34f,0x3a5,0x3fb,0x451,0x4a7,0x4fd,0x553,0x5a9,0x5ff,0x655,0x6ab,0x701,0x757,0x7ad,0x803 },
{ 0x04a,0x0a0,0x0f6,0x14c,0x1a2,0x1f8,0x24e,0x2a4,0x2fa,0x350,0x3a6,0x3fc,0x452,0x4a8,0x4fe,0x554,0x5aa,0x600,0x656,0x6ac,0x702,0x758,0x7ae,0x804 },
{ 0x04b,0x0a1,0x0f7,0x14d,0x1a3,0x1f9,0x24f,0x2a5,0x2fb,0x351,0x3a7,0x3fd,0x453,0x4a9,0x4ff,0x555,0x5ab,0x601,0x657,0x6ad,0x703,0x759,0x7af,0x805 },
{ 0x04c,0x0a2,0x0f8,0x14e,0x1a4,0x1fa,0x250,0x2a6,0x2fc,0x352,0x3a8,0x3fe,0x454,0x4aa,0x500,0x556,0x5ac,0x602,0x658,0x6ae,0x704,0x75a,0x7b0,0x806 },
{ 0x04d,0x0a3,0x0f9,0x14f,0x1a5,0x1fb,0x251,0x2a7,0x2fd,0x353,0x3a9,0x3ff,0x455,0x4ab,0x501,0x557,0x5ad,0x603,0x659,0x6af,0x705,0x75b,0x7b1,0x807 },
{ 0x04e,0x0a4,0x0fa,0x150,0x1a6,0x1fc,0x252,0x2a8,0x2fe,0x354,0x3aa,0x400,0x456,0x4ac,0x502,0x558,0x5ae,0x604,0x65a,0x6b0,0x706,0x75c,0x7b2,0x808 },
{ 0x04f,0x0a5,0x0fb,0x151,0x1a7,0x1fd,0x253,0x2a9,0x2ff,0x355,0x3ab,0x401,0x457,0x4ad,0x503,0x559,0x5af,0x605,0x65b,0x6b1,0x707,0x75d,0x7b3,0x809 },
{ 0x050,0x0a6,0x0fc,0x152,0x1a8,0x1fe,0x254,0x2aa,0x300,0x356,0x3ac,0x402,0x458,0x4ae,0x504,0x55a,0x5b0,0x606,0x65c,0x6b2,0x708,0x75e,0x7b4,0x80a },
{ 0x051,0x0a7,0x0fd,0x153,0x1a9,0x1ff,0x255,0x2ab,0x301,0x357,0x3ad,0x403,0x459,0x4af,0x505,0x55b,0x5b1,0x607,0x65d,0x6b3,0x709,0x75f,0x7b5,0x80b },
{ 0x052,0x0a8,0x0fe,0x154,0x1aa,0x200,0x256,0x2ac,0x302,0x358,0x3ae,0x404,0x45a,0x4b0,0x506,0x55c,0x5b2,0x608,0x65e,0x6b4,0x70a,0x760,0x7b6,0x80c },
{ 0x053,0x0a9,0x0ff,0x155,0x1ab,0x201,0x257,0x2ad,0x303,0x359,0x3af,0x405,0x45b,0x4b1,0x507,0x55d,0x5b3,0x609,0x65f,0x6b5,0x70b,0x761,0x7b7,0x80d },
{ 0x054,0x0aa,0x100,0x156,0x1ac,0x202,0x258,0x2ae,0x304,0x35a,0x3b0,0x406,0x45c,0x4b2,0x508,0x55e,0x5b4,0x60a,0x660,0x6b6,0x70c,0x762,0x7b8,0x80e },
{ 0x055,0x0ab,0x101,0x157,0x1ad,0x203,0x259,0x2af,0x305,0x35b,0x3b1,0x407,0x45d,0x4b3,0x509,0x55f,0x5b5,0x60b,0x661,0x6b7,0x70d,0x763,0x7b9,0x80f }
};
/**
* @brief -------------------------------------------------
* qoffsets - each row represents the addresses used to calculate a byte of the ECC Q
* data 52 (*2) ECC Q bytes, 43 values represented by each
* -------------------------------------------------.
*/
static const uint16_t qoffsets[ECC_Q_NUM_BYTES][ECC_Q_COMP] =
{
{ 0x000,0x058,0x0b0,0x108,0x160,0x1b8,0x210,0x268,0x2c0,0x318,0x370,0x3c8,0x420,0x478,0x4d0,0x528,0x580,0x5d8,0x630,0x688,0x6e0,0x738,0x790,0x7e8,0x840,0x898,0x034,0x08c,0x0e4,0x13c,0x194,0x1ec,0x244,0x29c,0x2f4,0x34c,0x3a4,0x3fc,0x454,0x4ac,0x504,0x55c,0x5b4 },
{ 0x001,0x059,0x0b1,0x109,0x161,0x1b9,0x211,0x269,0x2c1,0x319,0x371,0x3c9,0x421,0x479,0x4d1,0x529,0x581,0x5d9,0x631,0x689,0x6e1,0x739,0x791,0x7e9,0x841,0x899,0x035,0x08d,0x0e5,0x13d,0x195,0x1ed,0x245,0x29d,0x2f5,0x34d,0x3a5,0x3fd,0x455,0x4ad,0x505,0x55d,0x5b5 },
{ 0x056,0x0ae,0x106,0x15e,0x1b6,0x20e,0x266,0x2be,0x316,0x36e,0x3c6,0x41e,0x476,0x4ce,0x526,0x57e,0x5d6,0x62e,0x686,0x6de,0x736,0x78e,0x7e6,0x83e,0x896,0x032,0x08a,0x0e2,0x13a,0x192,0x1ea,0x242,0x29a,0x2f2,0x34a,0x3a2,0x3fa,0x452,0x4aa,0x502,0x55a,0x5b2,0x60a },
{ 0x057,0x0af,0x107,0x15f,0x1b7,0x20f,0x267,0x2bf,0x317,0x36f,0x3c7,0x41f,0x477,0x4cf,0x527,0x57f,0x5d7,0x62f,0x687,0x6df,0x737,0x78f,0x7e7,0x83f,0x897,0x033,0x08b,0x0e3,0x13b,0x193,0x1eb,0x243,0x29b,0x2f3,0x34b,0x3a3,0x3fb,0x453,0x4ab,0x503,0x55b,0x5b3,0x60b },
{ 0x0ac,0x104,0x15c,0x1b4,0x20c,0x264,0x2bc,0x314,0x36c,0x3c4,0x41c,0x474,0x4cc,0x524,0x57c,0x5d4,0x62c,0x684,0x6dc,0x734,0x78c,0x7e4,0x83c,0x894,0x030,0x088,0x0e0,0x138,0x190,0x1e8,0x240,0x298,0x2f0,0x348,0x3a0,0x3f8,0x450,0x4a8,0x500,0x558,0x5b0,0x608,0x660 },
{ 0x0ad,0x105,0x15d,0x1b5,0x20d,0x265,0x2bd,0x315,0x36d,0x3c5,0x41d,0x475,0x4cd,0x525,0x57d,0x5d5,0x62d,0x685,0x6dd,0x735,0x78d,0x7e5,0x83d,0x895,0x031,0x089,0x0e1,0x139,0x191,0x1e9,0x241,0x299,0x2f1,0x349,0x3a1,0x3f9,0x451,0x4a9,0x501,0x559,0x5b1,0x609,0x661 },
{ 0x102,0x15a,0x1b2,0x20a,0x262,0x2ba,0x312,0x36a,0x3c2,0x41a,0x472,0x4ca,0x522,0x57a,0x5d2,0x62a,0x682,0x6da,0x732,0x78a,0x7e2,0x83a,0x892,0x02e,0x086,0x0de,0x136,0x18e,0x1e6,0x23e,0x296,0x2ee,0x346,0x39e,0x3f6,0x44e,0x4a6,0x4fe,0x556,0x5ae,0x606,0x65e,0x6b6 },
{ 0x103,0x15b,0x1b3,0x20b,0x263,0x2bb,0x313,0x36b,0x3c3,0x41b,0x473,0x4cb,0x523,0x57b,0x5d3,0x62b,0x683,0x6db,0x733,0x78b,0x7e3,0x83b,0x893,0x02f,0x087,0x0df,0x137,0x18f,0x1e7,0x23f,0x297,0x2ef,0x347,0x39f,0x3f7,0x44f,0x4a7,0x4ff,0x557,0x5af,0x607,0x65f,0x6b7 },
{ 0x158,0x1b0,0x208,0x260,0x2b8,0x310,0x368,0x3c0,0x418,0x470,0x4c8,0x520,0x578,0x5d0,0x628,0x680,0x6d8,0x730,0x788,0x7e0,0x838,0x890,0x02c,0x084,0x0dc,0x134,0x18c,0x1e4,0x23c,0x294,0x2ec,0x344,0x39c,0x3f4,0x44c,0x4a4,0x4fc,0x554,0x5ac,0x604,0x65c,0x6b4,0x70c },
{ 0x159,0x1b1,0x209,0x261,0x2b9,0x311,0x369,0x3c1,0x419,0x471,0x4c9,0x521,0x579,0x5d1,0x629,0x681,0x6d9,0x731,0x789,0x7e1,0x839,0x891,0x02d,0x085,0x0dd,0x135,0x18d,0x1e5,0x23d,0x295,0x2ed,0x345,0x39d,0x3f5,0x44d,0x4a5,0x4fd,0x555,0x5ad,0x605,0x65d,0x6b5,0x70d },
{ 0x1ae,0x206,0x25e,0x2b6,0x30e,0x366,0x3be,0x416,0x46e,0x4c6,0x51e,0x576,0x5ce,0x626,0x67e,0x6d6,0x72e,0x786,0x7de,0x836,0x88e,0x02a,0x082,0x0da,0x132,0x18a,0x1e2,0x23a,0x292,0x2ea,0x342,0x39a,0x3f2,0x44a,0x4a2,0x4fa,0x552,0x5aa,0x602,0x65a,0x6b2,0x70a,0x762 },
{ 0x1af,0x207,0x25f,0x2b7,0x30f,0x367,0x3bf,0x417,0x46f,0x4c7,0x51f,0x577,0x5cf,0x627,0x67f,0x6d7,0x72f,0x787,0x7df,0x837,0x88f,0x02b,0x083,0x0db,0x133,0x18b,0x1e3,0x23b,0x293,0x2eb,0x343,0x39b,0x3f3,0x44b,0x4a3,0x4fb,0x553,0x5ab,0x603,0x65b,0x6b3,0x70b,0x763 },
{ 0x204,0x25c,0x2b4,0x30c,0x364,0x3bc,0x414,0x46c,0x4c4,0x51c,0x574,0x5cc,0x624,0x67c,0x6d4,0x72c,0x784,0x7dc,0x834,0x88c,0x028,0x080,0x0d8,0x130,0x188,0x1e0,0x238,0x290,0x2e8,0x340,0x398,0x3f0,0x448,0x4a0,0x4f8,0x550,0x5a8,0x600,0x658,0x6b0,0x708,0x760,0x7b8 },
{ 0x205,0x25d,0x2b5,0x30d,0x365,0x3bd,0x415,0x46d,0x4c5,0x51d,0x575,0x5cd,0x625,0x67d,0x6d5,0x72d,0x785,0x7dd,0x835,0x88d,0x029,0x081,0x0d9,0x131,0x189,0x1e1,0x239,0x291,0x2e9,0x341,0x399,0x3f1,0x449,0x4a1,0x4f9,0x551,0x5a9,0x601,0x659,0x6b1,0x709,0x761,0x7b9 },
{ 0x25a,0x2b2,0x30a,0x362,0x3ba,0x412,0x46a,0x4c2,0x51a,0x572,0x5ca,0x622,0x67a,0x6d2,0x72a,0x782,0x7da,0x832,0x88a,0x026,0x07e,0x0d6,0x12e,0x186,0x1de,0x236,0x28e,0x2e6,0x33e,0x396,0x3ee,0x446,0x49e,0x4f6,0x54e,0x5a6,0x5fe,0x656,0x6ae,0x706,0x75e,0x7b6,0x80e },
{ 0x25b,0x2b3,0x30b,0x363,0x3bb,0x413,0x46b,0x4c3,0x51b,0x573,0x5cb,0x623,0x67b,0x6d3,0x72b,0x783,0x7db,0x833,0x88b,0x027,0x07f,0x0d7,0x12f,0x187,0x1df,0x237,0x28f,0x2e7,0x33f,0x397,0x3ef,0x447,0x49f,0x4f7,0x54f,0x5a7,0x5ff,0x657,0x6af,0x707,0x75f,0x7b7,0x80f },
{ 0x2b0,0x308,0x360,0x3b8,0x410,0x468,0x4c0,0x518,0x570,0x5c8,0x620,0x678,0x6d0,0x728,0x780,0x7d8,0x830,0x888,0x024,0x07c,0x0d4,0x12c,0x184,0x1dc,0x234,0x28c,0x2e4,0x33c,0x394,0x3ec,0x444,0x49c,0x4f4,0x54c,0x5a4,0x5fc,0x654,0x6ac,0x704,0x75c,0x7b4,0x80c,0x864 },
{ 0x2b1,0x309,0x361,0x3b9,0x411,0x469,0x4c1,0x519,0x571,0x5c9,0x621,0x679,0x6d1,0x729,0x781,0x7d9,0x831,0x889,0x025,0x07d,0x0d5,0x12d,0x185,0x1dd,0x235,0x28d,0x2e5,0x33d,0x395,0x3ed,0x445,0x49d,0x4f5,0x54d,0x5a5,0x5fd,0x655,0x6ad,0x705,0x75d,0x7b5,0x80d,0x865 },
{ 0x306,0x35e,0x3b6,0x40e,0x466,0x4be,0x516,0x56e,0x5c6,0x61e,0x676,0x6ce,0x726,0x77e,0x7d6,0x82e,0x886,0x022,0x07a,0x0d2,0x12a,0x182,0x1da,0x232,0x28a,0x2e2,0x33a,0x392,0x3ea,0x442,0x49a,0x4f2,0x54a,0x5a2,0x5fa,0x652,0x6aa,0x702,0x75a,0x7b2,0x80a,0x862,0x8ba },
{ 0x307,0x35f,0x3b7,0x40f,0x467,0x4bf,0x517,0x56f,0x5c7,0x61f,0x677,0x6cf,0x727,0x77f,0x7d7,0x82f,0x887,0x023,0x07b,0x0d3,0x12b,0x183,0x1db,0x233,0x28b,0x2e3,0x33b,0x393,0x3eb,0x443,0x49b,0x4f3,0x54b,0x5a3,0x5fb,0x653,0x6ab,0x703,0x75b,0x7b3,0x80b,0x863,0x8bb },
{ 0x35c,0x3b4,0x40c,0x464,0x4bc,0x514,0x56c,0x5c4,0x61c,0x674,0x6cc,0x724,0x77c,0x7d4,0x82c,0x884,0x020,0x078,0x0d0,0x128,0x180,0x1d8,0x230,0x288,0x2e0,0x338,0x390,0x3e8,0x440,0x498,0x4f0,0x548,0x5a0,0x5f8,0x650,0x6a8,0x700,0x758,0x7b0,0x808,0x860,0x8b8,0x054 },
{ 0x35d,0x3b5,0x40d,0x465,0x4bd,0x515,0x56d,0x5c5,0x61d,0x675,0x6cd,0x725,0x77d,0x7d5,0x82d,0x885,0x021,0x079,0x0d1,0x129,0x181,0x1d9,0x231,0x289,0x2e1,0x339,0x391,0x3e9,0x441,0x499,0x4f1,0x549,0x5a1,0x5f9,0x651,0x6a9,0x701,0x759,0x7b1,0x809,0x861,0x8b9,0x055 },
{ 0x3b2,0x40a,0x462,0x4ba,0x512,0x56a,0x5c2,0x61a,0x672,0x6ca,0x722,0x77a,0x7d2,0x82a,0x882,0x01e,0x076,0x0ce,0x126,0x17e,0x1d6,0x22e,0x286,0x2de,0x336,0x38e,0x3e6,0x43e,0x496,0x4ee,0x546,0x59e,0x5f6,0x64e,0x6a6,0x6fe,0x756,0x7ae,0x806,0x85e,0x8b6,0x052,0x0aa },
{ 0x3b3,0x40b,0x463,0x4bb,0x513,0x56b,0x5c3,0x61b,0x673,0x6cb,0x723,0x77b,0x7d3,0x82b,0x883,0x01f,0x077,0x0cf,0x127,0x17f,0x1d7,0x22f,0x287,0x2df,0x337,0x38f,0x3e7,0x43f,0x497,0x4ef,0x547,0x59f,0x5f7,0x64f,0x6a7,0x6ff,0x757,0x7af,0x807,0x85f,0x8b7,0x053,0x0ab },
{ 0x408,0x460,0x4b8,0x510,0x568,0x5c0,0x618,0x670,0x6c8,0x720,0x778,0x7d0,0x828,0x880,0x01c,0x074,0x0cc,0x124,0x17c,0x1d4,0x22c,0x284,0x2dc,0x334,0x38c,0x3e4,0x43c,0x494,0x4ec,0x544,0x59c,0x5f4,0x64c,0x6a4,0x6fc,0x754,0x7ac,0x804,0x85c,0x8b4,0x050,0x0a8,0x100 },
{ 0x409,0x461,0x4b9,0x511,0x569,0x5c1,0x619,0x671,0x6c9,0x721,0x779,0x7d1,0x829,0x881,0x01d,0x075,0x0cd,0x125,0x17d,0x1d5,0x22d,0x285,0x2dd,0x335,0x38d,0x3e5,0x43d,0x495,0x4ed,0x545,0x59d,0x5f5,0x64d,0x6a5,0x6fd,0x755,0x7ad,0x805,0x85d,0x8b5,0x051,0x0a9,0x101 },
{ 0x45e,0x4b6,0x50e,0x566,0x5be,0x616,0x66e,0x6c6,0x71e,0x776,0x7ce,0x826,0x87e,0x01a,0x072,0x0ca,0x122,0x17a,0x1d2,0x22a,0x282,0x2da,0x332,0x38a,0x3e2,0x43a,0x492,0x4ea,0x542,0x59a,0x5f2,0x64a,0x6a2,0x6fa,0x752,0x7aa,0x802,0x85a,0x8b2,0x04e,0x0a6,0x0fe,0x156 },
{ 0x45f,0x4b7,0x50f,0x567,0x5bf,0x617,0x66f,0x6c7,0x71f,0x777,0x7cf,0x827,0x87f,0x01b,0x073,0x0cb,0x123,0x17b,0x1d3,0x22b,0x283,0x2db,0x333,0x38b,0x3e3,0x43b,0x493,0x4eb,0x543,0x59b,0x5f3,0x64b,0x6a3,0x6fb,0x753,0x7ab,0x803,0x85b,0x8b3,0x04f,0x0a7,0x0ff,0x157 },
{ 0x4b4,0x50c,0x564,0x5bc,0x614,0x66c,0x6c4,0x71c,0x774,0x7cc,0x824,0x87c,0x018,0x070,0x0c8,0x120,0x178,0x1d0,0x228,0x280,0x2d8,0x330,0x388,0x3e0,0x438,0x490,0x4e8,0x540,0x598,0x5f0,0x648,0x6a0,0x6f8,0x750,0x7a8,0x800,0x858,0x8b0,0x04c,0x0a4,0x0fc,0x154,0x1ac },
{ 0x4b5,0x50d,0x565,0x5bd,0x615,0x66d,0x6c5,0x71d,0x775,0x7cd,0x825,0x87d,0x019,0x071,0x0c9,0x121,0x179,0x1d1,0x229,0x281,0x2d9,0x331,0x389,0x3e1,0x439,0x491,0x4e9,0x541,0x599,0x5f1,0x649,0x6a1,0x6f9,0x751,0x7a9,0x801,0x859,0x8b1,0x04d,0x0a5,0x0fd,0x155,0x1ad },
{ 0x50a,0x562,0x5ba,0x612,0x66a,0x6c2,0x71a,0x772,0x7ca,0x822,0x87a,0x016,0x06e,0x0c6,0x11e,0x176,0x1ce,0x226,0x27e,0x2d6,0x32e,0x386,0x3de,0x436,0x48e,0x4e6,0x53e,0x596,0x5ee,0x646,0x69e,0x6f6,0x74e,0x7a6,0x7fe,0x856,0x8ae,0x04a,0x0a2,0x0fa,0x152,0x1aa,0x202 },
{ 0x50b,0x563,0x5bb,0x613,0x66b,0x6c3,0x71b,0x773,0x7cb,0x823,0x87b,0x017,0x06f,0x0c7,0x11f,0x177,0x1cf,0x227,0x27f,0x2d7,0x32f,0x387,0x3df,0x437,0x48f,0x4e7,0x53f,0x597,0x5ef,0x647,0x69f,0x6f7,0x74f,0x7a7,0x7ff,0x857,0x8af,0x04b,0x0a3,0x0fb,0x153,0x1ab,0x203 },
{ 0x560,0x5b8,0x610,0x668,0x6c0,0x718,0x770,0x7c8,0x820,0x878,0x014,0x06c,0x0c4,0x11c,0x174,0x1cc,0x224,0x27c,0x2d4,0x32c,0x384,0x3dc,0x434,0x48c,0x4e4,0x53c,0x594,0x5ec,0x644,0x69c,0x6f4,0x74c,0x7a4,0x7fc,0x854,0x8ac,0x048,0x0a0,0x0f8,0x150,0x1a8,0x200,0x258 },
{ 0x561,0x5b9,0x611,0x669,0x6c1,0x719,0x771,0x7c9,0x821,0x879,0x015,0x06d,0x0c5,0x11d,0x175,0x1cd,0x225,0x27d,0x2d5,0x32d,0x385,0x3dd,0x435,0x48d,0x4e5,0x53d,0x595,0x5ed,0x645,0x69d,0x6f5,0x74d,0x7a5,0x7fd,0x855,0x8ad,0x049,0x0a1,0x0f9,0x151,0x1a9,0x201,0x259 },
{ 0x5b6,0x60e,0x666,0x6be,0x716,0x76e,0x7c6,0x81e,0x876,0x012,0x06a,0x0c2,0x11a,0x172,0x1ca,0x222,0x27a,0x2d2,0x32a,0x382,0x3da,0x432,0x48a,0x4e2,0x53a,0x592,0x5ea,0x642,0x69a,0x6f2,0x74a,0x7a2,0x7fa,0x852,0x8aa,0x046,0x09e,0x0f6,0x14e,0x1a6,0x1fe,0x256,0x2ae },
{ 0x5b7,0x60f,0x667,0x6bf,0x717,0x76f,0x7c7,0x81f,0x877,0x013,0x06b,0x0c3,0x11b,0x173,0x1cb,0x223,0x27b,0x2d3,0x32b,0x383,0x3db,0x433,0x48b,0x4e3,0x53b,0x593,0x5eb,0x643,0x69b,0x6f3,0x74b,0x7a3,0x7fb,0x853,0x8ab,0x047,0x09f,0x0f7,0x14f,0x1a7,0x1ff,0x257,0x2af },
{ 0x60c,0x664,0x6bc,0x714,0x76c,0x7c4,0x81c,0x874,0x010,0x068,0x0c0,0x118,0x170,0x1c8,0x220,0x278,0x2d0,0x328,0x380,0x3d8,0x430,0x488,0x4e0,0x538,0x590,0x5e8,0x640,0x698,0x6f0,0x748,0x7a0,0x7f8,0x850,0x8a8,0x044,0x09c,0x0f4,0x14c,0x1a4,0x1fc,0x254,0x2ac,0x304 },
{ 0x60d,0x665,0x6bd,0x715,0x76d,0x7c5,0x81d,0x875,0x011,0x069,0x0c1,0x119,0x171,0x1c9,0x221,0x279,0x2d1,0x329,0x381,0x3d9,0x431,0x489,0x4e1,0x539,0x591,0x5e9,0x641,0x699,0x6f1,0x749,0x7a1,0x7f9,0x851,0x8a9,0x045,0x09d,0x0f5,0x14d,0x1a5,0x1fd,0x255,0x2ad,0x305 },
{ 0x662,0x6ba,0x712,0x76a,0x7c2,0x81a,0x872,0x00e,0x066,0x0be,0x116,0x16e,0x1c6,0x21e,0x276,0x2ce,0x326,0x37e,0x3d6,0x42e,0x486,0x4de,0x536,0x58e,0x5e6,0x63e,0x696,0x6ee,0x746,0x79e,0x7f6,0x84e,0x8a6,0x042,0x09a,0x0f2,0x14a,0x1a2,0x1fa,0x252,0x2aa,0x302,0x35a },
{ 0x663,0x6bb,0x713,0x76b,0x7c3,0x81b,0x873,0x00f,0x067,0x0bf,0x117,0x16f,0x1c7,0x21f,0x277,0x2cf,0x327,0x37f,0x3d7,0x42f,0x487,0x4df,0x537,0x58f,0x5e7,0x63f,0x697,0x6ef,0x747,0x79f,0x7f7,0x84f,0x8a7,0x043,0x09b,0x0f3,0x14b,0x1a3,0x1fb,0x253,0x2ab,0x303,0x35b },
{ 0x6b8,0x710,0x768,0x7c0,0x818,0x870,0x00c,0x064,0x0bc,0x114,0x16c,0x1c4,0x21c,0x274,0x2cc,0x324,0x37c,0x3d4,0x42c,0x484,0x4dc,0x534,0x58c,0x5e4,0x63c,0x694,0x6ec,0x744,0x79c,0x7f4,0x84c,0x8a4,0x040,0x098,0x0f0,0x148,0x1a0,0x1f8,0x250,0x2a8,0x300,0x358,0x3b0 },
{ 0x6b9,0x711,0x769,0x7c1,0x819,0x871,0x00d,0x065,0x0bd,0x115,0x16d,0x1c5,0x21d,0x275,0x2cd,0x325,0x37d,0x3d5,0x42d,0x485,0x4dd,0x535,0x58d,0x5e5,0x63d,0x695,0x6ed,0x745,0x79d,0x7f5,0x84d,0x8a5,0x041,0x099,0x0f1,0x149,0x1a1,0x1f9,0x251,0x2a9,0x301,0x359,0x3b1 },
{ 0x70e,0x766,0x7be,0x816,0x86e,0x00a,0x062,0x0ba,0x112,0x16a,0x1c2,0x21a,0x272,0x2ca,0x322,0x37a,0x3d2,0x42a,0x482,0x4da,0x532,0x58a,0x5e2,0x63a,0x692,0x6ea,0x742,0x79a,0x7f2,0x84a,0x8a2,0x03e,0x096,0x0ee,0x146,0x19e,0x1f6,0x24e,0x2a6,0x2fe,0x356,0x3ae,0x406 },
{ 0x70f,0x767,0x7bf,0x817,0x86f,0x00b,0x063,0x0bb,0x113,0x16b,0x1c3,0x21b,0x273,0x2cb,0x323,0x37b,0x3d3,0x42b,0x483,0x4db,0x533,0x58b,0x5e3,0x63b,0x693,0x6eb,0x743,0x79b,0x7f3,0x84b,0x8a3,0x03f,0x097,0x0ef,0x147,0x19f,0x1f7,0x24f,0x2a7,0x2ff,0x357,0x3af,0x407 },
{ 0x764,0x7bc,0x814,0x86c,0x008,0x060,0x0b8,0x110,0x168,0x1c0,0x218,0x270,0x2c8,0x320,0x378,0x3d0,0x428,0x480,0x4d8,0x530,0x588,0x5e0,0x638,0x690,0x6e8,0x740,0x798,0x7f0,0x848,0x8a0,0x03c,0x094,0x0ec,0x144,0x19c,0x1f4,0x24c,0x2a4,0x2fc,0x354,0x3ac,0x404,0x45c },
{ 0x765,0x7bd,0x815,0x86d,0x009,0x061,0x0b9,0x111,0x169,0x1c1,0x219,0x271,0x2c9,0x321,0x379,0x3d1,0x429,0x481,0x4d9,0x531,0x589,0x5e1,0x639,0x691,0x6e9,0x741,0x799,0x7f1,0x849,0x8a1,0x03d,0x095,0x0ed,0x145,0x19d,0x1f5,0x24d,0x2a5,0x2fd,0x355,0x3ad,0x405,0x45d },
{ 0x7ba,0x812,0x86a,0x006,0x05e,0x0b6,0x10e,0x166,0x1be,0x216,0x26e,0x2c6,0x31e,0x376,0x3ce,0x426,0x47e,0x4d6,0x52e,0x586,0x5de,0x636,0x68e,0x6e6,0x73e,0x796,0x7ee,0x846,0x89e,0x03a,0x092,0x0ea,0x142,0x19a,0x1f2,0x24a,0x2a2,0x2fa,0x352,0x3aa,0x402,0x45a,0x4b2 },
{ 0x7bb,0x813,0x86b,0x007,0x05f,0x0b7,0x10f,0x167,0x1bf,0x217,0x26f,0x2c7,0x31f,0x377,0x3cf,0x427,0x47f,0x4d7,0x52f,0x587,0x5df,0x637,0x68f,0x6e7,0x73f,0x797,0x7ef,0x847,0x89f,0x03b,0x093,0x0eb,0x143,0x19b,0x1f3,0x24b,0x2a3,0x2fb,0x353,0x3ab,0x403,0x45b,0x4b3 },
{ 0x810,0x868,0x004,0x05c,0x0b4,0x10c,0x164,0x1bc,0x214,0x26c,0x2c4,0x31c,0x374,0x3cc,0x424,0x47c,0x4d4,0x52c,0x584,0x5dc,0x634,0x68c,0x6e4,0x73c,0x794,0x7ec,0x844,0x89c,0x038,0x090,0x0e8,0x140,0x198,0x1f0,0x248,0x2a0,0x2f8,0x350,0x3a8,0x400,0x458,0x4b0,0x508 },
{ 0x811,0x869,0x005,0x05d,0x0b5,0x10d,0x165,0x1bd,0x215,0x26d,0x2c5,0x31d,0x375,0x3cd,0x425,0x47d,0x4d5,0x52d,0x585,0x5dd,0x635,0x68d,0x6e5,0x73d,0x795,0x7ed,0x845,0x89d,0x039,0x091,0x0e9,0x141,0x199,0x1f1,0x249,0x2a1,0x2f9,0x351,0x3a9,0x401,0x459,0x4b1,0x509 },
{ 0x866,0x002,0x05a,0x0b2,0x10a,0x162,0x1ba,0x212,0x26a,0x2c2,0x31a,0x372,0x3ca,0x422,0x47a,0x4d2,0x52a,0x582,0x5da,0x632,0x68a,0x6e2,0x73a,0x792,0x7ea,0x842,0x89a,0x036,0x08e,0x0e6,0x13e,0x196,0x1ee,0x246,0x29e,0x2f6,0x34e,0x3a6,0x3fe,0x456,0x4ae,0x506,0x55e },
{ 0x867,0x003,0x05b,0x0b3,0x10b,0x163,0x1bb,0x213,0x26b,0x2c3,0x31b,0x373,0x3cb,0x423,0x47b,0x4d3,0x52b,0x583,0x5db,0x633,0x68b,0x6e3,0x73b,0x793,0x7eb,0x843,0x89b,0x037,0x08f,0x0e7,0x13f,0x197,0x1ef,0x247,0x29f,0x2f7,0x34f,0x3a7,0x3ff,0x457,0x4af,0x507,0x55f }
};
//-------------------------------------------------
// ecc_source_byte - return data from the sector
// at the given offset, masking anything
// particular to a mode
//-------------------------------------------------
static inline uint8_t ecc_source_byte(const uint8_t *sector, uint32_t offset)
{
// in mode 2 always treat these as 0 bytes
return (sector[MODE_OFFSET] == 2 && offset < 4) ? 0x00 : sector[SYNC_OFFSET + SYNC_NUM_BYTES + offset];
}
/**
* @fn void ecc_compute_bytes(const uint8_t *sector, const uint16_t *row, int rowlen, uint8_t &val1, uint8_t &val2)
*
* @brief -------------------------------------------------
* ecc_compute_bytes - calculate an ECC value (P or Q)
* -------------------------------------------------.
*
* @param sector The sector.
* @param row The row.
* @param rowlen The rowlen.
* @param [in,out] val1 The first value.
* @param [in,out] val2 The second value.
*/
void ecc_compute_bytes(const uint8_t *sector, const uint16_t *row, int rowlen, uint8_t *val1, uint8_t *val2)
{
*val1 = *val2 = 0;
for (int component = 0; component < rowlen; component++)
{
*val1 ^= ecc_source_byte(sector, row[component]);
*val2 ^= ecc_source_byte(sector, row[component]);
*val1 = ecclow[*val1];
}
*val1 = ecchigh[ecclow[*val1] ^ *val2];
*val2 ^= *val1;
}
/**
* @fn int ecc_verify(const uint8_t *sector)
*
* @brief -------------------------------------------------
* ecc_verify - verify the P and Q ECC codes in a sector
* -------------------------------------------------.
*
* @param sector The sector.
*
* @return true if it succeeds, false if it fails.
*/
int ecc_verify(const uint8_t *sector)
{
// first verify P bytes
for (int byte = 0; byte < ECC_P_NUM_BYTES; byte++)
{
uint8_t val1, val2;
ecc_compute_bytes(sector, poffsets[byte], ECC_P_COMP, &val1, &val2);
if (sector[ECC_P_OFFSET + byte] != val1 || sector[ECC_P_OFFSET + ECC_P_NUM_BYTES + byte] != val2)
return 0;
}
// then verify Q bytes
for (int byte = 0; byte < ECC_Q_NUM_BYTES; byte++)
{
uint8_t val1, val2;
ecc_compute_bytes(sector, qoffsets[byte], ECC_Q_COMP, &val1, &val2);
if (sector[ECC_Q_OFFSET + byte] != val1 || sector[ECC_Q_OFFSET + ECC_Q_NUM_BYTES + byte] != val2)
return 0;
}
return 1;
}
/**
* @fn void ecc_generate(uint8_t *sector)
*
* @brief -------------------------------------------------
* ecc_generate - generate the P and Q ECC codes for a sector, overwriting any
* existing codes
* -------------------------------------------------.
*
* @param [in,out] sector If non-null, the sector.
*/
void ecc_generate(uint8_t *sector)
{
// first verify P bytes
for (int byte = 0; byte < ECC_P_NUM_BYTES; byte++)
ecc_compute_bytes(sector, poffsets[byte], ECC_P_COMP, §or[ECC_P_OFFSET + byte], §or[ECC_P_OFFSET + ECC_P_NUM_BYTES + byte]);
// then verify Q bytes
for (int byte = 0; byte < ECC_Q_NUM_BYTES; byte++)
ecc_compute_bytes(sector, qoffsets[byte], ECC_Q_COMP, §or[ECC_Q_OFFSET + byte], §or[ECC_Q_OFFSET + ECC_Q_NUM_BYTES + byte]);
}
/**
* @fn void ecc_clear(uint8_t *sector)
*
* @brief -------------------------------------------------
* ecc_clear - erase the ECC P and Q cods to 0 within a sector
* -------------------------------------------------.
*
* @param [in,out] sector If non-null, the sector.
*/
void ecc_clear(uint8_t *sector)
{
memset(§or[ECC_P_OFFSET], 0, 2 * ECC_P_NUM_BYTES);
memset(§or[ECC_Q_OFFSET], 0, 2 * ECC_Q_NUM_BYTES);
}
#endif /* WANT_RAW_DATA_SECTOR */
|
the_stack_data/396574.c | #include <stdlib.h>
#include <stdio.h>
#include <math.h>
int jose (int n)
{
int res = 0;
for( int i=1 ; i<=n ; ++i) res += i;
return res;
}
/* ----- end of function test ----- */
int main(int argc, char** argv)
{
int n = 100;
for (int i= 1; i<=n; i++){
printf("%i\t%i\n" ,i,jose(i));
}
return 0;
}
|
the_stack_data/18888954.c | // zadatak by @who.so ([email protected])
#include <stdio.h>
int main() {
int i,j,n, dobar=0, k=0, l=0;
do{
printf("Unesite broj N: ");
scanf("%d", &n);
if(n<=0)
{
printf("N nije ispravno!\n");
continue;
}
if(n%4!=1)
{
printf("N nije ispravno!\n");
continue;
}
if(n%4==1)
dobar=1;
if(dobar==1)
break;
}while(n>0);
printf("\n");
for(i=0; i<n; i++)
{
k++;
if(i>2)
l++;
for(j=0; j<n; j++)
{
if((j==(n/2)+1) && (i==(n/2)+1) || (i==2 && j==n-2) || (i==1 && j==0))
printf(" ");
else if(i==n-1)
{
printf("*");
}
else if((i<3 && j%2==1 && j==n-1) || (i%2==0 && i<3))
{
printf("*");
}
else if(j<l && i<=(n/2)+1)
{
if(j%2==0)
printf("*");
else
printf(" ");
}
else if(j<=n-k && i>=(n/2)+1)
{
if(j%2==0)
printf("*");
else
printf(" ");
}
else if((j<=n-1 && j>n-k) && i<=(n/2)-1)
{
if(j%2!=0)
printf(" ");
else
printf("*");
}
else if(i>(n/2)-1 && (j<=n-1 && j>=k-1))
{
if(j%2!=0)
printf(" ");
else
printf("*");
}
else if(i%2!=0)
printf(" ");
else
printf("*");
}
printf("\n");
}
}
|
the_stack_data/150144173.c | #include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int bscanner(char *string);
int bbscanner(char *string);
int fxscanner(char *string);
int fscanner(char *string);
void stringxy(char *string, int beginning, int end);
int main (int argc, char *argv[])
{
if (argc <= 1) {
printf( "a demonstration of a spaceless scan\n");
}
else if ((argc == 2))
{
fscanner(argv[1]);
fxscanner(argv[1]);
bscanner(argv[1]);
bbscanner(argv[1]);
}
}
// new scanner
int fxscanner(char *string) {
int i = 0, j = 0, cntr = 0;
int length = 0;
length = strlen(string) - 1;
printf("\nfx scan two %s", string);
while(1)
{
for (j = i; j <= length; j++) {
stringxy(string, i, j);
cntr++;
}
j = 0;
i++;
if (i > length) break;
}
printf("\n");
printf("count = %d\n", cntr);
return (0);
}
// forward scanner
int fscanner(char *string) {
int i = 0, j, k, ctr = 0;
int length = 0;
length = strlen(string) - 1;
printf("\nforward scan %s", string);
// size.length = (strlen(string) - 1);
//
for(i = 0; i <= length; i++)
for(j = i; j <= length; j++)
{
// printf("%d %d\n", i, j);
if (j >= i) stringxy(string, i, j);
ctr++;
}
printf("\n");
printf("count = %d\n", ctr);
return (0);
}
// backward scanner
int bscanner(char *string) {
int i = 0, j, k, ctr = 0;
int length = 0;
length = strlen(string) - 1;
printf("\nbackward scan %s", string);
for(i = length; i >= 0; i--)
for(j = length; j >= 0; j--)
{
if (j >= i) stringxy(string, i, j);
}
printf("\n");
return (0);
}
// backward scanner two
int bbscanner(char *string) {
int i = 0, j, k, ctr = 0;
int length = 0;
length = strlen(string) - 1;
printf("\nbackward scan two %s", string);
for(i = length; i >= 0; i--)
for(j = 0; j <= length; j++)
{
if (j >= i) stringxy(string, i, j);
}
printf("\n");
return (0);
}
// show string from x to y
void stringxy(char *string, int beginning, int end)
{
printf("\nString from (%i, %i) ", beginning, end);
int i = 0;
for (i = beginning; i <= end; i++)
{
printf("%c", (char *) string[i]);
}
}
|
the_stack_data/212644174.c | //C语言中的基本转换
#include <stdio.h>
int main(void)
{
float f1 = 123.125, f2;
int i1, i2 = -150;
char c = 'a';
i1 = f1;
printf("%f assigned to an int produces %i\n", f1, i1);
f1 = i2;
printf("%i assined to a float produces %f\n", i2, f1);
f1 = i2 / 100;
printf("%i divided by 100 produces %f\n", i2, f1);
f2 = i2 / 100.0;
printf("%i divided by 100.0 produces %f\n", i2, f2);
f2 = (float) i2 / 100;
printf("(float) %i divided by 100 prduces %f\n", i2, f2);
return 0;
} |
the_stack_data/103265542.c | #include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <openssl/evp.h>
void hextorb(uint8_t* hex, uint8_t* rb)
{
while(sscanf(hex, "%2x", rb) == 1)
{
hex += 2;
rb += 1;
}
*rb = '\0';
}
int main(int argc, char** argv)
{
uint8_t k_user[2048];
uint8_t salt[2048];
uint8_t key[4096];
uint32_t key_length = atoi(argv[1]);
uint32_t iteration_count = atoi(argv[2]);
hextorb(argv[3], salt);
uint32_t salt_length = strlen(argv[3]) / 2;
fgets(k_user, 2048, stdin);
uint32_t k_user_length = strlen(k_user);
if(k_user[k_user_length - 1] == '\n') {
k_user[k_user_length - 1] = '\0';
}
PKCS5_PBKDF2_HMAC(k_user, k_user_length, salt, salt_length, iteration_count, EVP_sha512(), key_length, key);
fwrite(key, 1, key_length, stdout);
return 0;
} |
the_stack_data/111526.c | /**
*****************************************************************************
**
** File : syscalls.c
**
** Abstract : System Workbench Minimal System calls file
**
** For more information about which c-functions
** need which of these lowlevel functions
** please consult the Newlib libc-manual
**
** Environment : System Workbench for MCU
**
** Distribution: The file is distributed �as is,� without any warranty
** of any kind.
**
** (c)Copyright System Workbench for MCU.
** You may use this file as-is or modify it according to the needs of your
** project. Distribution of this file (unmodified or modified) is not
** permitted. System Workbench for MCU permit registered System Workbench(R) users the
** rights to distribute the assembled, compiled & linked contents of this
** file as part of an application binary file, provided that it is built
** using the System Workbench for MCU toolchain.
**
*****************************************************************************
*/
/* Includes */
#include <sys/stat.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>
#include <sys/times.h>
/*---------------------------------------------------------------------------*/
/** @addtogroup LWM2M_example
* @{
*/
/*---------------------------------------------------------------------------*/
/* Variables */
//#undef errno
extern int errno;
extern int __io_putchar(int ch) __attribute__((weak));
extern int __io_getchar(void) __attribute__((weak));
/*---------------------------------------------------------------------------*/
register char * stack_ptr __asm__("sp");
/*---------------------------------------------------------------------------*/
char *__env[1] = { 0 };
char **environ = __env;
/*---------------------------------------------------------------------------*/
/* Functions */
void initialise_monitor_handles()
{
}
/*---------------------------------------------------------------------------*/
int _getpid(void)
{
return 1;
}
/*---------------------------------------------------------------------------*/
int _kill(int pid, int sig)
{
errno = EINVAL;
return -1;
}
/*---------------------------------------------------------------------------*/
void _exit (int status)
{
_kill(status, -1);
while (1) {} /* Make sure we hang here */
}
/*---------------------------------------------------------------------------*/
int _read (int file, char *ptr, int len)
{
int DataIdx;
for (DataIdx = 0; DataIdx < len; DataIdx++)
{
*ptr++ = __io_getchar();
}
return len;
}
/*---------------------------------------------------------------------------*/
int _write(int file, char *ptr, int len)
{
int DataIdx;
for (DataIdx = 0; DataIdx < len; DataIdx++)
{
__io_putchar(*ptr++);
}
return len;
}
/*---------------------------------------------------------------------------*/
caddr_t _sbrk(int incr)
{
extern char end __asm__("end");
static char *heap_end;
char *prev_heap_end;
if (heap_end == 0)
heap_end = &end;
prev_heap_end = heap_end;
if (heap_end + incr > stack_ptr)
{
// write(1, "Heap and stack collision\n", 25);
// abort();
errno = ENOMEM;
return (caddr_t) -1;
}
heap_end += incr;
return (caddr_t) prev_heap_end;
}
/*---------------------------------------------------------------------------*/
int _close(int file)
{
return -1;
}
/*---------------------------------------------------------------------------*/
int _fstat(int file, struct stat *st)
{
st->st_mode = S_IFCHR;
return 0;
}
/*---------------------------------------------------------------------------*/
int _isatty(int file)
{
return 1;
}
/*---------------------------------------------------------------------------*/
int _lseek(int file, int ptr, int dir)
{
return 0;
}
/*---------------------------------------------------------------------------*/
int _open(char *path, int flags, ...)
{
/* Pretend like we always fail */
return -1;
}
/*---------------------------------------------------------------------------*/
int _wait(int *status)
{
errno = ECHILD;
return -1;
}
/*---------------------------------------------------------------------------*/
int _unlink(char *name)
{
errno = ENOENT;
return -1;
}
/*---------------------------------------------------------------------------*/
int _times(struct tms *buf)
{
return -1;
}
/*---------------------------------------------------------------------------*/
int _stat(char *file, struct stat *st)
{
st->st_mode = S_IFCHR;
return 0;
}
/*---------------------------------------------------------------------------*/
int _link(char *old, char *new)
{
errno = EMLINK;
return -1;
}
/*---------------------------------------------------------------------------*/
int _fork(void)
{
errno = EAGAIN;
return -1;
}
/*---------------------------------------------------------------------------*/
int _execve(char *name, char **argv, char **env)
{
errno = ENOMEM;
return -1;
}
/*---------------------------------------------------------------------------*/
/**
* @}
*/
|
the_stack_data/19097.c | #include<stdio.h>
int main()
{
printf("asdf");
} |
the_stack_data/136260.c | //
// Created by j on 19-1-11.
//
// designate.c -- 使用指定初始化项目
#include <stdio.h>
#define MONTHS 12
int main(void)
{
int days[MONTHS]= {31,28,[4]=31,30,31,[1]=29};
int i;
for(i=0;i<MONTHS;i++)
printf("%2d %d\n",i+1,days[i]);
return 0;
}
|
the_stack_data/234518373.c | #define INVALID -1
#define total_instruction 320 //指令流长
#define total_vp 32 //虚拟页表长度
//#define clear_period 50 //清零周期
typedef struct //页面结构
{
int pn,pfn,counter,time; //页号、页面有效无效、一个周期内访问该页面次数、访问时间
}pl_type;
pl_type pl[total_vp]; //页面结构数组
struct pfc_struct //页面控制结构
{
int pn,pfn;
struct pfc_struct *next;
};
typedef struct pfc_struct pfc_type;
pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;
int diseffect;
int a[total_instruction];
int page[total_instruction],offset[total_instruction];
void initialize(int);
void FIFO(int);
void LRU(int);
//void OPT(int);
#include <stdio.h>
#include <stdlib.h>
//#include "process.h"
int main()
{
int S,i;
srand(_getpid()*10);//每次运行时进程号不同，可以作为初始化随机数队列的种子
S=319*rand()/32767 ; //得到一个0到319之间的一个数
for (i=0;i<total_instruction;i+=4)//产生指令队列
{
a[i]=S;//任选一指令访问点
a[i+1]=a[i]+1;//顺序执行一条指令
if (a[i+1]==320)
a[i+1]=0;
a[i+2]=a[i]*rand()/32767;//执行前地址指令
a[i+3]=319-a[i+2];//执行后地址指令
//S=rand()*(318-a[i+2])/32767+a[i+2]+1;
S=319*rand()/32767 ;
}
for(i=0;i<total_instruction;i++)//将指令序列变换成页地址流：页号+偏移量
{
page[i]=a[i]/10;
offset[i]=a[i]%10;
}
for(i=4;i<=32;i++)
{
printf("%2d page frames",i);
FIFO(i);
LRU(i);
//OPT(i);
//LFU(i);
//NUR(i);
printf("\n");
}
return 1;
}
void FIFO(int total_pf) //total_pf是用户进程页面数目
{
int i;
pfc_type *p;
initialize(total_pf);
busypf_head=busypf_tail=NULL;
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID) { //页面失效
diseffect++; //失效计数
if(freepf_head==NULL) //无空闲页面时置换一页
{
p=busypf_head->next;
pl[busypf_head->pn].pfn=INVALID;
freepf_head=busypf_head;
freepf_head->next=NULL;
busypf_head=p;
}
p=freepf_head->next; //有空闲页面时分配一页
freepf_head->next=NULL;
freepf_head->pn=page[i];
pl[page[i]].pfn=freepf_head->pfn;
if(busypf_tail==NULL)
busypf_head=busypf_tail=freepf_head;
else
{
busypf_tail->next=freepf_head;
busypf_tail=freepf_head;
}
freepf_head=p;
}
}
printf("FIFO():%6.4f ",1-(float)diseffect/320);
}
void LRU(int total_pf) //total_pf是用户进程页面数目,即进程物理内存pageframe数目
{
int min,minj,i,j,present_time;
initialize(total_pf);
present_time=0;
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID) { //页面失效
diseffect++; //失效计数
if(freepf_head==NULL) //无空闲页面时置换一页
{
min=32767;
for(j=0;j<total_vp;j++)
if(min>pl[j].time && (pl[j].pfn !=INVALID))
{min=pl[j].time ;minj=j;}
freepf_head=&pfc[pl[minj].pfn];
pl[minj].pfn=INVALID;
pl[minj].time=-1;
freepf_head->next =NULL;
}
//有空闲页面时分配一页
pl[page[i]].pfn=freepf_head->pfn;
pl[page[i]].time=present_time;
freepf_head=freepf_head->next;
}
else
pl[page[i]].time=present_time;
present_time++;
}
printf("LRU():%6.4f ",1-(float)diseffect/320);
}
void initialize(int total_pf)
{
int i;
diseffect=0;
for(i=0;i<total_vp;i++) //页面控制结构清空
{
pl[i].pn=i;pl[i].pfn =INVALID;
pl[i].counter =0;pl[i].time =-1;
}
for(i=1;i<total_pf;i++) //建立链接
{
pfc[i-1].next=&pfc[i];pfc[i-1].pfn =i-1;
}
pfc[total_pf-1].next =NULL;pfc[total_pf-1].pfn =total_pf-1;
freepf_head=&pfc[0];
}
|
the_stack_data/1037942.c | // 7 - Máxima Coordenada
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define X 0
#define Y 1
#define Z 2
#define N_COORDENADAS 3
float *liga_dois_pontos(const float *a, const float *b)
{
float *r = malloc(sizeof (float) * N_COORDENADAS);
r[X] = b[X] - a[X];
r[Y] = b[Y] - a[Y];
r[Z] = b[Z] - a[Z];
return r;
}
float retorna_maior_mod(const float *a)
{
float maior = LONG_MIN;
int i;
for (i = 0; i < N_COORDENADAS; i++) {
float temp = a[i];
if (temp < 0) temp *= -1;
if (maior < temp) maior = temp;
}
return maior;
}
int main (void)
{
int n, i;
float *lista = NULL;
float coordA[N_COORDENADAS];
float coordB[N_COORDENADAS];
scanf(" %d", &n);
lista = (float *) malloc(sizeof (float) * n + 1);
for (i = 0; i < n; i++) {
scanf(" %f%f%f", &coordA[X], &coordA[Y], &coordA[Z]);
if (i != 0) {
float *ptr = liga_dois_pontos(coordA, coordB);
lista[i] = retorna_maior_mod(ptr);
free(ptr);
}
coordB[X] = coordA[X];
coordB[Y] = coordA[Y];
coordB[Z] = coordA[Z];
}
for (i = 1; i < n; i++) {
printf("%.2f\n", lista[i]);
}
free(lista);
return 0;
}
|
the_stack_data/1098100.c | #include <stdio.h>
#include <stdlib.h>
int main(void){
FILE *filew = fopen("data.csv", "w");
FILE *filer = fopen("data.csv", "r");
int x, y;
fprintf(filew, "%d,%d", 1, 12);
fclose(filew);
while (!feof(filer)){
fscanf(filer, "%d,%d", &x, &y);
printf("%d,%d", x,y);
}
fclose(filer);
return 0;
} |
the_stack_data/486333.c | /*******************************************************************************
* The BYTE UNIX Benchmarks - Release 3
* Module: big.c SID: 3.3 5/15/91 19:30:18
*
*******************************************************************************
* Bug reports, patches, comments, suggestions should be sent to:
*
* Ben Smith, Rick Grehan or Tom Yager
* [email protected] [email protected] [email protected]
*
*******************************************************************************
* Modification Log:
* 10/22/97 - code cleanup to remove ANSI C compiler warnings
* Andy Kahn <[email protected]>
*
******************************************************************************/
/*
* dummy code for execl test [ old version of makework.c ]
*
* makework [ -r rate ] [ -c copyfile ] nusers
*
* job streams are specified on standard input with lines of the form
* full_path_name_for_command [ options ] [ <standard_input_file ]
*
* "standard input" is send to all nuser instances of the commands in the
* job streams at a rate not in excess of "rate" characters per second
* per command
*
*/
/* this code is included in other files and therefore has no SCCSid */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <sys/wait.h>
#define DEF_RATE 5.0
#define GRANULE 5
#define CHUNK 60
#define MAXCHILD 12
#define MAXWORK 10
/* Can't seem to get this declared in the headers... */
extern int kill(pid_t pid, int sig);
void wrapup(char *);
void onalarm(int);
void pipeerr(int sig);
void grunt(int sig);
void getwork(void);
#if debug
void dumpwork(void);
#endif
void fatal(char *s);
float thres;
float est_rate = DEF_RATE;
int nusers; /* number of concurrent users to be simulated by
* this process */
int firstuser; /* ordinal identification of first user for this
* process */
int nwork = 0; /* number of job streams */
int exit_status = 0; /* returned to parent */
int sigpipe; /* pipe write error flag */
struct st_work {
char *cmd; /* name of command to run */
char **av; /* arguments to command */
char *input; /* standard input buffer */
int inpsize; /* size of standard input buffer */
char *outf; /* standard output (filename) */
} work[MAXWORK];
struct {
int xmit; /* # characters sent */
char *bp; /* std input buffer pointer */
int blen; /* std input buffer length */
int fd; /* stdin to command */
int pid; /* child PID */
char *line; /* start of input line */
int firstjob; /* inital piece of work */
int thisjob; /* current piece of work */
} child[MAXCHILD], *cp;
int main(int argc, char *argv[])
{
int i;
int l;
int fcopy = 0; /* fd for copy output */
int master = 1; /* the REAL master, == 0 for clones */
int nchild; /* no. of children for a clone to run */
int done; /* count of children finished */
int output; /* aggregate output char count for all
children */
int c;
int thiswork = 0; /* next job stream to allocate */
int nch; /* # characters to write */
int written; /* # characters actully written */
char logname[15]; /* name of the log file(s) */
int pvec[2]; /* for pipes */
char *p;
char *prog; /* my name */
#if ! debug
freopen("masterlog.00", "a", stderr);
#endif
prog = argv[0];
while (argc > 1 && argv[1][0] == '-') {
p = &argv[1][1];
argc--;
argv++;
while (*p) {
switch (*p) {
case 'r':
est_rate = atoi(argv[1]);
sscanf(argv[1], "%f", &est_rate);
if (est_rate <= 0) {
fprintf(stderr, "%s: bad rate, reset to %.2f chars/sec\n", prog, DEF_RATE);
est_rate = DEF_RATE;
}
argc--;
argv++;
break;
case 'c':
fcopy = open(argv[1], 1);
if (fcopy < 0)
fcopy = creat(argv[1], 0600);
if (fcopy < 0) {
fprintf(stderr, "%s: cannot open copy file '%s'\n",
prog, argv[1]);
exit(2);
}
lseek(fcopy, 0L, 2); /* append at end of file */
argc--;
argv++;
break;
default:
fprintf(stderr, "%s: bad flag '%c'\n", prog, *p);
exit(4);
}
p++;
}
}
if (argc < 2) {
fprintf(stderr, "%s: missing nusers\n", prog);
exit(4);
}
nusers = atoi(argv[1]);
if (nusers < 1) {
fprintf(stderr, "%s: impossible nusers (%d<-%s)\n", prog, nusers, argv[1]);
exit(4);
}
fprintf(stderr, "%d Users\n", nusers);
argc--;
argv++;
/* build job streams */
getwork();
#if debug
dumpwork();
#endif
/* clone copies of myself to run up to MAXCHILD jobs each */
firstuser = MAXCHILD;
fprintf(stderr, "master pid %d\n", getpid());
fflush(stderr);
while (nusers > MAXCHILD) {
fflush(stderr);
if (nusers >= 2*MAXCHILD)
/* the next clone must run MAXCHILD jobs */
nchild = MAXCHILD;
else
/* the next clone must run the leftover jobs */
nchild = nusers - MAXCHILD;
if ((l = fork()) == -1) {
/* fork failed */
fatal("** clone fork failed **\n");
goto bepatient;
} else if (l > 0) {
fprintf(stderr, "master clone pid %d\n", l);
/* I am the master with nchild fewer jobs to run */
nusers -= nchild;
firstuser += MAXCHILD;
continue;
} else {
/* I am a clone, run MAXCHILD jobs */
#if ! debug
sprintf(logname, "masterlog.%02d", firstuser/MAXCHILD);
freopen(logname, "w", stderr);
#endif
master = 0;
nusers = nchild;
break;
}
}
if (master)
firstuser = 0;
close(0);
for (i = 0; i < nusers; i++ ) {
fprintf(stderr, "user %d job %d ", firstuser+i, thiswork);
if (pipe(pvec) == -1) {
/* this is fatal */
fatal("** pipe failed **\n");
goto bepatient;
}
fflush(stderr);
if ((child[i].pid = fork()) == 0) {
int fd;
/* the command */
if (pvec[0] != 0) {
close(0);
dup(pvec[0]);
}
#if ! debug
sprintf(logname, "userlog.%02d", firstuser+i);
freopen(logname, "w", stderr);
#endif
for (fd = 3; fd < 24; fd++)
close(fd);
if (work[thiswork].outf[0] != '\0') {
/* redirect std output */
char *q;
for (q = work[thiswork].outf; *q != '\n'; q++) ;
*q = '\0';
if (freopen(work[thiswork].outf, "w", stdout) == NULL) {
fprintf(stderr, "makework: cannot open %s for std output\n",
work[thiswork].outf);
fflush(stderr);
}
*q = '\n';
}
execv(work[thiswork].cmd, work[thiswork].av);
/* don't expect to get here! */
fatal("** exec failed **\n");
goto bepatient;
}
else if (child[i].pid == -1) {
fatal("** fork failed **\n");
goto bepatient;
}
else {
close(pvec[0]);
child[i].fd = pvec[1];
child[i].line = child[i].bp = work[thiswork].input;
child[i].blen = work[thiswork].inpsize;
child[i].thisjob = thiswork;
child[i].firstjob = thiswork;
fprintf(stderr, "pid %d pipe fd %d", child[i].pid, child[i].fd);
if (work[thiswork].outf[0] != '\0') {
char *q;
fprintf(stderr, " > ");
for (q=work[thiswork].outf; *q != '\n'; q++)
fputc(*q, stderr);
}
fputc('\n', stderr);
thiswork++;
if (thiswork >= nwork)
thiswork = 0;
}
}
fflush(stderr);
srand(time(0));
thres = 0;
done = output = 0;
for (i = 0; i < nusers; i++) {
if (child[i].blen == 0)
done++;
else
thres += est_rate * GRANULE;
}
est_rate = thres;
signal(SIGALRM, onalarm);
signal(SIGPIPE, pipeerr);
alarm(GRANULE);
while (done < nusers) {
for (i = 0; i < nusers; i++) {
cp = &child[i];
if (cp->xmit >= cp->blen) continue;
l = rand() % CHUNK + 1; /* 1-CHUNK chars */
if (l == 0) continue;
if (cp->xmit + l > cp->blen)
l = cp->blen - cp->xmit;
p = cp->bp;
cp->bp += l;
cp->xmit += l;
#if debug
fprintf(stderr, "child %d, %d processed, %d to go\n", i, cp->xmit, cp->blen - cp->xmit);
#endif
while (p < cp->bp) {
if (*p == '\n' || (p == &cp->bp[-1] && cp->xmit >= cp->blen)) {
/* write it out */
nch = p - cp->line + 1;
if ((written = write(cp->fd, cp->line, nch)) != nch) {
/* argh! */
cp->line[nch] = '\0';
fprintf(stderr, "user %d job %d cmd %s ",
firstuser+i, cp->thisjob, cp->line);
fprintf(stderr, "write(,,%d) returns %d\n", nch, written);
if (sigpipe)
fatal("** SIGPIPE error **\n");
else
fatal("** write error **\n");
goto bepatient;
}
if (fcopy)
write(fcopy, cp->line, p - cp->line + 1);
#if debug
fprintf(stderr, "child %d gets \"", i);
{
char *q = cp->line;
while (q <= p) {
if (*q >= ' ' && *q <= '~')
fputc(*q, stderr);
else
fprintf(stderr, "\\%03o", *q);
q++;
}
}
fputc('"', stderr);
#endif
cp->line = &p[1];
}
p++;
}
if (cp->xmit >= cp->blen) {
done++;
close(cp->fd);
#if debug
fprintf(stderr, "child %d, close std input\n", i);
#endif
}
output += l;
}
while (output > thres) {
pause();
#if debug
fprintf(stderr, "after pause: output, thres, done %d %.2f %d\n", output, thres, done);
#endif
}
}
bepatient:
alarm(0);
/****
* If everything is going OK, we should simply be able to keep
* looping unitil 'wait' fails, however some descendent process may
* be in a state from which it can never exit, and so a timeout
* is used.
* 5 minutes should be ample, since the time to run all jobs is of
* the order of 5-10 minutes, however some machines are painfully slow,
* so the timeout has been set at 20 minutes (1200 seconds).
****/
signal(SIGALRM, grunt);
alarm(1200);
while ((c = wait(&l)) != -1) {
for (i = 0; i < nusers; i++) {
if (c == child[i].pid) {
fprintf(stderr, "user %d job %d pid %d done", firstuser+i, child[i].thisjob, c);
if (l != 0) {
if (l & 0x7f)
fprintf(stderr, " status %d", l & 0x7f);
if (l & 0xff00)
fprintf(stderr, " exit code %d", (l>>8) & 0xff);
exit_status = 4;
}
fputc('\n', stderr);
c = child[i].pid = -1;
break;
}
}
if (c != -1) {
fprintf(stderr, "master clone done, pid %d ", c);
if (l != 0) {
if (l & 0x7f)
fprintf(stderr, " status %d", l & 0x7f);
if (l & 0xff00)
fprintf(stderr, " exit code %d", (l>>8) & 0xff);
exit_status = 4;
}
fputc('\n', stderr);
}
}
alarm(0);
wrapup("Finished waiting ...");
exit(0);
}
void onalarm(int foo)
{
thres += est_rate;
signal(SIGALRM, onalarm);
alarm(GRANULE);
}
void grunt(int sig)
{
/* timeout after label "bepatient" in main */
exit_status = 4;
wrapup("Timed out waiting for jobs to finish ...");
}
void pipeerr(int sig)
{
sigpipe++;
}
void wrapup(char *reason)
{
int i;
int killed = 0;
fflush(stderr);
for (i = 0; i < nusers; i++) {
if (child[i].pid > 0 && kill(child[i].pid, SIGKILL) != -1) {
if (!killed) {
killed++;
fprintf(stderr, "%s\n", reason);
fflush(stderr);
}
fprintf(stderr, "user %d job %d pid %d killed off\n", firstuser+i, child[i].thisjob, child[i].pid);
fflush(stderr);
}
}
exit(exit_status);
}
#define MAXLINE 512
void getwork(void)
{
int i;
int f;
int ac=0;
char *lp = (void *)0;
char *q = (void *)0;
struct st_work *w = (void *)0;
char line[MAXLINE];
char c;
while (fgets(line, MAXLINE, stdin) != NULL) {
if (nwork >= MAXWORK) {
fprintf(stderr, "Too many jobs specified, .. increase MAXWORK\n");
exit(4);
}
w = &work[nwork];
lp = line;
i = 1;
while (*lp && *lp != ' ') {
i++;
lp++;
}
w->cmd = (char *)malloc(i);
strncpy(w->cmd, line, i-1);
w->cmd[i-1] = '\0';
w->inpsize = 0;
w->input = "";
/* start to build arg list */
ac = 2;
w->av = (char **)malloc(2*sizeof(char *));
q = w->cmd;
while (*q) q++;
q--;
while (q >= w->cmd) {
if (*q == '/') {
q++;
break;
}
q--;
}
w->av[0] = q;
while (*lp) {
if (*lp == ' ') {
/* space */
lp++;
continue;
}
else if (*lp == '<') {
/* standard input for this job */
q = ++lp;
while (*lp && *lp != ' ') lp++;
c = *lp;
*lp = '\0';
if ((f = open(q, 0)) == -1) {
fprintf(stderr, "cannot open input file (%s) for job %d\n",
q, nwork);
exit(4);
}
/* gobble input */
w->input = (char *)malloc(512);
while ((i = read(f, &w->input[w->inpsize], 512)) > 0) {
w->inpsize += i;
w->input = (char *)realloc(w->input, w->inpsize+512);
}
w->input = (char *)realloc(w->input, w->inpsize);
close(f);
/* extract stdout file name from line beginning "C=" */
w->outf = "";
for (q = w->input; q < &w->input[w->inpsize-10]; q++) {
if (*q == '\n' && strncmp(&q[1], "C=", 2) == 0) {
w->outf = &q[3];
break;
}
}
#if debug
if (*w->outf) {
fprintf(stderr, "stdout->");
for (q=w->outf; *q != '\n'; q++)
fputc(*q, stderr);
fputc('\n', stderr);
}
#endif
}
else {
/* a command option */
ac++;
w->av = (char **)realloc(w->av, ac*sizeof(char *));
q = lp;
i = 1;
while (*lp && *lp != ' ') {
lp++;
i++;
}
w->av[ac-2] = (char *)malloc(i);
strncpy(w->av[ac-2], q, i-1);
w->av[ac-2][i-1] = '\0';
}
}
w->av[ac-1] = (char *)0;
nwork++;
}
}
#if debug
void dumpwork(void)
{
int i;
int j;
for (i = 0; i < nwork; i++) {
fprintf(stderr, "job %d: cmd: %s\n", i, work[i].cmd);
j = 0;
while (work[i].av[j]) {
fprintf(stderr, "argv[%d]: %s\n", j, work[i].av[j]);
j++;
}
fprintf(stderr, "input: %d chars text: ", work[i].inpsize);
if (work[i].input == (char *)0)
fprintf(stderr, "<NULL>\n");
else {
register char *pend;
char *p;
char c;
p = work[i].input;
while (*p) {
pend = p;
while (*pend && *pend != '\n')
pend++;
c = *pend;
*pend = '\0';
fprintf(stderr, "%s\n", p);
*pend = c;
p = &pend[1];
}
}
}
}
#endif
void fatal(char *s)
{
int i;
fprintf(stderr, "%s", s);
fflush(stderr);
perror("Reason?");
fflush(stderr);
for (i = 0; i < nusers; i++) {
if (child[i].pid > 0 && kill(child[i].pid, SIGKILL) != -1) {
fprintf(stderr, "pid %d killed off\n", child[i].pid);
fflush(stderr);
}
}
exit_status = 4;
}
|
the_stack_data/20515.c | #include <stdio.h>
int main(){
int a, b, c;
for(a=1;a<=3;a++){
for(b=1;b<=3;b++){
for(c=1;c<=3;c++){
if(a == b || a == c || b == c){
continue;
}
printf("%d%d%d\n", a, b, c);
}
}
}
return 0;
} |
the_stack_data/125139745.c |
#include <stdio.h>
int main()
{
for(;;);
return 0;
}
|
the_stack_data/93888819.c | #include <asm/unistd.h>
|
the_stack_data/466675.c | #include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <linux/in.h>
#include <unistd.h>
#define LISTENQ 10
#define BUFSIZE 128
pthread_mutex_t lock;
typedef struct
{
int sock;
struct sockaddr address;
int addr_len;
} connection_t;
void process(void *ptr)
{
int fd, n, size;
char fname[50];
struct stat stat_buf;
connection_t *conn;
long addr = 0;
if (!ptr)
pthread_exit(0);
conn = (connection_t *)ptr;
addr = (long)((struct sockaddr_in *)&conn->address)->sin_addr.s_addr;
char *buf = (char *)malloc((BUFSIZE) * sizeof(char));
printf("Handling connection request\n");
recv(conn->sock, fname, 50, 0);
printf("File name is %s : ", fname);
pthread_mutex_lock(&lock);
fd = open(fname, O_WRONLY | O_CREAT, S_IRWXU);
printf("\nopened file\n");
n = read(conn->sock, buf, BUFSIZE);
if (n < 0)
{
printf("error in reading socket data!\n");
pthread_exit(1);
}
int i = 0;
while (buf[i] != '\0' && i < BUFSIZE - 1)
i++;
write(fd, buf, i--);
close(fd);
printf("file modification completed \n");
pthread_mutex_unlock(&lock);
close(conn->sock);
free(conn);
free(buf);
pthread_exit(0);
}
int main(int argc, char **argv)
{
int sockfd = -1;
struct sockaddr_in address;
int port;
connection_t *connection;
pthread_t thread;
if (pthread_mutex_init(&lock, NULL) != 0)
{
printf("\n mutex init has failed\n");
return 1;
}
if (argc != 2)
{
fprintf(stderr, "usage: %s port\n", argv[0]);
return -1;
}
/* obtain port number */
if (sscanf(argv[1], "%d", &port) <= 0)
{
fprintf(stderr, "%s: error: wrong parameter: port\n", argv[0]);
return -2;
}
/* create socket */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd <= 0)
{
fprintf(stderr, "%s: error: cannot create socket\n", argv[0]);
return -3;
}
address.sin_family = AF_INET;
address.sin_port = htons(port);
address.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *)&address, sizeof(address)) < 0)
{
fprintf(stderr, "%s: error: cannot bind socket to port %d\n", argv[0], port);
return -4;
}
if (listen(sockfd, LISTENQ) < 0)
{
fprintf(stderr, "%s: error: cannot listen on port\n", argv[0]);
return -5;
}
printf("%s: ready and listening\n", argv[0]);
while (1)
{
connection = (connection_t *)malloc(sizeof(connection_t));
connection->sock = accept(sockfd, &connection->address, &connection->addr_len);
if (connection->sock <= 0)
{
free(connection);
}
else
{
/* start a new thread but do not wait for it */
pthread_create(&thread, 0, process, (void *)connection);
pthread_detach(thread);
}
}
pthread_mutex_destroy(&lock);
return 0;
} |
the_stack_data/7950260.c | /*
* Copyright (c) 2019, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/mman.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
struct globals_header {
uint64_t size;
__int128 data[0]; // align to 128 bit
};
static uint64_t align_up(uint64_t size) {
long pagesize = sysconf(_SC_PAGESIZE);
uint64_t ret = size;
if (ret % pagesize != 0) {
ret += pagesize - ret % pagesize;
}
return ret;
}
void *__sulong_allocate_globals_block(uint64_t size) {
uint64_t finalSize = align_up(size + sizeof(struct globals_header));
struct globals_header *page = mmap(NULL, finalSize, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
page->size = finalSize;
return &page->data;
}
void __sulong_protect_readonly_globals_block(void *ptr) {
struct globals_header *header = (struct globals_header *)(ptr - sizeof(struct globals_header));
mprotect(header, header->size, PROT_READ);
}
void __sulong_free_globals_block(void *ptr) {
struct globals_header *header = (struct globals_header *)(ptr - sizeof(struct globals_header));
munmap(header, header->size);
}
|
the_stack_data/151705552.c | /* $OpenBSD: res_comp.c,v 1.20 2016/05/01 15:17:29 millert Exp $ */
/*
* ++Copyright++ 1985, 1993
* -
* Copyright (c) 1985, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* -
* Portions Copyright (c) 1993 by Digital Equipment Corporation.
*
* 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, and that
* the name of Digital Equipment Corporation not be used in advertising or
* publicity pertaining to distribution of the document or software without
* specific, written prior permission.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
* CORPORATION 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.
* -
* --Copyright--
*/
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <stdio.h>
#include <resolv.h>
#include <ctype.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
static int dn_find(u_char *, u_char *, u_char **, u_char **);
/*
* Expand compressed domain name 'comp_dn' to full domain name.
* 'msg' is a pointer to the beginning of the message,
* 'eomorig' points to the first location after the message,
* 'exp_dn' is a pointer to a buffer of size 'length' for the result.
* Return size of compressed name or -1 if there was an error.
*/
int
dn_expand(const u_char *msg, const u_char *eomorig, const u_char *comp_dn,
char *exp_dn, int length)
{
const u_char *cp;
char *dn;
int n, c;
char *eom;
int len = -1, checked = 0;
dn = exp_dn;
cp = comp_dn;
if (length > HOST_NAME_MAX)
length = HOST_NAME_MAX;
eom = exp_dn + length;
/*
* fetch next label in domain name
*/
while ((n = *cp++)) {
/*
* Check for indirection
*/
switch (n & INDIR_MASK) {
case 0:
if (dn != exp_dn) {
if (dn >= eom)
return (-1);
*dn++ = '.';
}
if (dn+n >= eom)
return (-1);
checked += n + 1;
while (--n >= 0) {
if (((c = *cp++) == '.') || (c == '\\')) {
if (dn + n + 2 >= eom)
return (-1);
*dn++ = '\\';
}
*dn++ = c;
if (cp >= eomorig) /* out of range */
return (-1);
}
break;
case INDIR_MASK:
if (len < 0)
len = cp - comp_dn + 1;
cp = msg + (((n & 0x3f) << 8) | (*cp & 0xff));
if (cp < msg || cp >= eomorig) /* out of range */
return (-1);
checked += 2;
/*
* Check for loops in the compressed name;
* if we've looked at the whole message,
* there must be a loop.
*/
if (checked >= eomorig - msg)
return (-1);
break;
default:
return (-1); /* flag error */
}
}
*dn = '\0';
if (len < 0)
len = cp - comp_dn;
return (len);
}
DEF_WEAK(dn_expand);
/*
* Compress domain name 'exp_dn' into 'comp_dn'.
* Return the size of the compressed name or -1.
* 'length' is the size of the array pointed to by 'comp_dn'.
* 'dnptrs' is a list of pointers to previous compressed names. dnptrs[0]
* is a pointer to the beginning of the message. The list ends with NULL.
* 'lastdnptr' is a pointer to the end of the arrary pointed to
* by 'dnptrs'. Side effect is to update the list of pointers for
* labels inserted into the message as we compress the name.
* If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
* is NULL, we don't update the list.
*/
int
dn_comp(const char *exp_dn, u_char *comp_dn, int length, u_char **dnptrs,
u_char **lastdnptr)
{
u_char *cp, *dn;
int c, l;
u_char **cpp, **lpp, *sp, *eob;
u_char *msg;
dn = (u_char *)exp_dn;
cp = comp_dn;
eob = cp + length;
lpp = cpp = NULL;
if (dnptrs != NULL) {
if ((msg = *dnptrs++) != NULL) {
for (cpp = dnptrs; *cpp != NULL; cpp++)
;
lpp = cpp; /* end of list to search */
}
} else
msg = NULL;
for (c = *dn++; c != '\0'; ) {
/* look to see if we can use pointers */
if (msg != NULL) {
if ((l = dn_find(dn-1, msg, dnptrs, lpp)) >= 0) {
if (cp+1 >= eob)
return (-1);
*cp++ = (l >> 8) | INDIR_MASK;
*cp++ = l % 256;
return (cp - comp_dn);
}
/* not found, save it */
if (lastdnptr != NULL && cpp < lastdnptr-1) {
*cpp++ = cp;
*cpp = NULL;
}
}
sp = cp++; /* save ptr to length byte */
do {
if (c == '.') {
c = *dn++;
break;
}
if (c == '\\') {
if ((c = *dn++) == '\0')
break;
}
if (cp >= eob) {
if (msg != NULL)
*lpp = NULL;
return (-1);
}
*cp++ = c;
} while ((c = *dn++) != '\0');
/* catch trailing '.'s but not '..' */
if ((l = cp - sp - 1) == 0 && c == '\0') {
cp--;
break;
}
if (l <= 0 || l > MAXLABEL) {
if (msg != NULL)
*lpp = NULL;
return (-1);
}
*sp = l;
}
if (cp >= eob) {
if (msg != NULL)
*lpp = NULL;
return (-1);
}
*cp++ = '\0';
return (cp - comp_dn);
}
/*
* Skip over a compressed domain name. Return the size or -1.
*/
int
__dn_skipname(const u_char *comp_dn, const u_char *eom)
{
const u_char *cp;
int n;
cp = comp_dn;
while (cp < eom && (n = *cp++)) {
/*
* check for indirection
*/
switch (n & INDIR_MASK) {
case 0: /* normal case, n == len */
cp += n;
continue;
case INDIR_MASK: /* indirection */
cp++;
break;
default: /* illegal type */
return (-1);
}
break;
}
if (cp > eom)
return (-1);
return (cp - comp_dn);
}
static int
mklower(int ch)
{
if (isascii(ch) && isupper(ch))
return (tolower(ch));
return (ch);
}
/*
* Search for expanded name from a list of previously compressed names.
* Return the offset from msg if found or -1.
* dnptrs is the pointer to the first name on the list,
* not the pointer to the start of the message.
*/
static int
dn_find(u_char *exp_dn, u_char *msg, u_char **dnptrs, u_char **lastdnptr)
{
u_char *dn, *cp, **cpp;
int n;
u_char *sp;
for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
dn = exp_dn;
sp = cp = *cpp;
while ((n = *cp++)) {
/*
* check for indirection
*/
switch (n & INDIR_MASK) {
case 0: /* normal case, n == len */
while (--n >= 0) {
if (*dn == '.')
goto next;
if (*dn == '\\')
dn++;
if (mklower(*dn++) != mklower(*cp++))
goto next;
}
if ((n = *dn++) == '\0' && *cp == '\0')
return (sp - msg);
if (n == '.')
continue;
goto next;
case INDIR_MASK: /* indirection */
cp = msg + (((n & 0x3f) << 8) | *cp);
break;
default: /* illegal type */
return (-1);
}
}
if (*dn == '\0')
return (sp - msg);
next: ;
}
return (-1);
}
/*
* Verify that a domain name uses an acceptable character set.
*/
/*
* Note the conspicuous absence of ctype macros in these definitions. On
* non-ASCII hosts, we can't depend on string literals or ctype macros to
* tell us anything about network-format data. The rest of the BIND system
* is not careful about this, but for some reason, we're doing it right here.
*/
#define PERIOD 0x2e
#define hyphenchar(c) ((c) == 0x2d)
#define bslashchar(c) ((c) == 0x5c)
#define underscorechar(c) ((c) == 0x5f)
#define periodchar(c) ((c) == PERIOD)
#define asterchar(c) ((c) == 0x2a)
#define alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) \
|| ((c) >= 0x61 && (c) <= 0x7a))
#define digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
#define borderchar(c) (alphachar(c) || digitchar(c))
#define middlechar(c) (borderchar(c) || hyphenchar(c) || underscorechar(c))
#define domainchar(c) ((c) > 0x20 && (c) < 0x7f)
int
__res_hnok(const char *dn)
{
int pch = PERIOD, ch = *dn++;
while (ch != '\0') {
int nch = *dn++;
if (periodchar(ch)) {
;
} else if (periodchar(pch)) {
if (!borderchar(ch))
return (0);
} else if (periodchar(nch) || nch == '\0') {
if (!borderchar(ch))
return (0);
} else {
if (!middlechar(ch))
return (0);
}
pch = ch, ch = nch;
}
return (1);
}
DEF_STRONG(__res_hnok);
/*
* hostname-like (A, MX, WKS) owners can have "*" as their first label
* but must otherwise be as a host name.
*/
int
res_ownok(const char *dn)
{
if (asterchar(dn[0])) {
if (periodchar(dn[1]))
return (res_hnok(dn+2));
if (dn[1] == '\0')
return (1);
}
return (res_hnok(dn));
}
/*
* SOA RNAMEs and RP RNAMEs can have any printable character in their first
* label, but the rest of the name has to look like a host name.
*/
int
res_mailok(const char *dn)
{
int ch, escaped = 0;
/* "." is a valid missing representation */
if (*dn == '\0')
return(1);
/* otherwise <label>.<hostname> */
while ((ch = *dn++) != '\0') {
if (!domainchar(ch))
return (0);
if (!escaped && periodchar(ch))
break;
if (escaped)
escaped = 0;
else if (bslashchar(ch))
escaped = 1;
}
if (periodchar(ch))
return (res_hnok(dn));
return(0);
}
/*
* This function is quite liberal, since RFC 1034's character sets are only
* recommendations.
*/
int
res_dnok(const char *dn)
{
int ch;
while ((ch = *dn++) != '\0')
if (!domainchar(ch))
return (0);
return (1);
}
/*
* Routines to insert/extract short/long's.
*/
u_int16_t
_getshort(const u_char *msgp)
{
u_int16_t u;
GETSHORT(u, msgp);
return (u);
}
DEF_STRONG(_getshort);
u_int32_t
_getlong(const u_char *msgp)
{
u_int32_t u;
GETLONG(u, msgp);
return (u);
}
DEF_STRONG(_getlong);
void
__putshort(u_int16_t s, u_char *msgp)
{
PUTSHORT(s, msgp);
}
void
__putlong(u_int32_t l, u_char *msgp)
{
PUTLONG(l, msgp);
}
|
the_stack_data/11074381.c | #include<stdio.h>
#include<stdlib.h>
#define max 5
int front=-1,rear=-1;
int CQueue[max];
void Enqueue() {
int n;
if((front ==0 && rear == max-1) || front == rear+1)
{
printf("Circular Queue Is Full! Overflow!\n");
return;
}
printf("Enter a number to Insert : ");
scanf("%d",&n);
if(front==-1)
front=front+1;
if(rear==max-1)
rear=0;
else rear=rear+1;
CQueue[rear]=n;
}
void Dequeue() {
int e;
if(front==-1)
{
printf("The Circular Queue is Empty! Underflow!\n");
return;
}
e=CQueue[front];
if(front==max-1)
front=0;
else if(front==rear)
{
front=-1;
rear=-1;
}
else front=front+1;
printf("Deleting the number : %d\n",e);
}
void Peek() {
printf("Front number of the queue is : %d\n", CQueue[front]);
}
void Display() {
int i;
if(front==-1)
{
printf("The Circular Queue is Empty! Nothing To Display!\n");
return;
}
i=front;
if(front<=rear)
{
while(i<=rear)
printf("%d ",CQueue[i++]);
printf("\n");
}
else
{
while(i<=max-1)
printf("%d ",CQueue[i++]) ;
i=0;
while(i<=rear)
printf("%d ",CQueue[i++]);
printf("\n");
}
}
int main() {
int w;
char ch;
loop:
printf("1. Enqueue\n");
printf("2. Dequeue\n");
printf("3. Peek\n");
printf("4. Display\n");
printf("5. EXIT\n");
printf("Choose the option : ");
scanf("%d",&w);
switch(w)
{
case 1:
Enqueue();
break;
case 2:
Dequeue();
break;
case 3:
Peek();
break;
case 4:
Display();
break;
case 5:
exit(1);
default:
printf("Invalid Choice!\n");
}
printf("Want to choose more? (Y/N) : ");
scanf(" %c", &ch);
if (ch=='Y' || ch=='y')
goto loop;
return 0;
} |
the_stack_data/37637897.c | #include <stdio.h>
#include <stdlib.h>
short areDigitsDifferent(unsigned int const num) {
unsigned int tNum = num;
unsigned short usedDigits[8];
for (unsigned int i = 0 ; i < 9; ++i) {
unsigned int const digit = tNum % 10;
for (unsigned int j = 0; j < i; ++j)
if (usedDigits[j] == digit)
return 0;
usedDigits[i] = digit;
tNum /= 10;
}
return 1;
}
int get_nums(unsigned int array[], unsigned int const arraySize) {
if (array == NULL) {
printf("get_nums(): Null pointer input.\n");
return 1;
}
for (unsigned int i = 10000000, counter = 0; i <= 99999999; ++i) {
if (counter >= arraySize) {
printf("get_nums(): Array overflow.\n");
return 2;
}
if (areDigitsDifferent(i)) {
array[counter] = i;
++counter;
}
}
return 0;
}
int print_nums(unsigned int const array[], unsigned int const arraySize) {
if (array == NULL) {
printf("print_nums(): Null pointer input.\n");
return 1;
}
for (unsigned int i = 0; i < arraySize; ++i)
if (array[i] != 0)
printf("%u ", array[i]);
printf("\n");
return 0;
}
int main() {
// 9 * permutations(9, 7); because first digit cannot be null
unsigned int const size = 1632960;
unsigned int *array = malloc(sizeof(unsigned int) * size);
if (get_nums(array, size) != 0)
return 1;
if (print_nums(array, size) != 0)
return 2;
free(array);
return 0;
}
|
the_stack_data/22846.c | #include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
int main() {
int threads = 16;
int msg_size = 2048*64;
size_t size = threads * msg_size;
int fd = open("/tmp/testmmap", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
ftruncate(fd, size + 4096);
volatile char *buf = (char*)mmap(NULL, 4096 + size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
char *src = (char*)malloc(size);
for (size_t i = 0; i < threads; i++) {
buf[i] = 1;
}
for (size_t i = 0; i < size; i++) {
src[i] = i;
}
#pragma omp parallel for
for (size_t i = 0; i < threads; i++) {
size_t off = i * size/threads;
for (int j = 0; j < 1e3; j++) {
memset(src+off, (char)i, size/threads);
while (buf[i] == 0) {
}
memcpy(buf+(off+4096), src+off, size/threads);
buf[i] = 0;
}
}
return 0;
}
|
the_stack_data/1252105.c | #include <stdio.h>
int main(void)
{
float a, b, c;
float result;
b = 1.5;
c = 0.5;
result = 3.0;
__asm
("lf.div.s %0, %1, %2\n\t"
: "=r"(a)
: "r"(b), "r"(c)
);
if (a != result) {
printf("lf.div.s error\n");
return -1;
}
/* double a, b, c, res;
b = 0x80000000;
c = 0x40;
result = 0x2000000;
__asm
("lf.div.d %0, %1, %2\n\t"
: "=r"(a)
: "r"(b), "r"(c)
);
if (a != result) {
printf("lf.div.d error\n");
return -1;
}*/
return 0;
}
|
the_stack_data/745343.c | // The exercise wants you to write a function, that returns the average of grades.
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define LENGTH 40
float compute_GPA(char grades[], int n);
int main(void)
{
char grades[LENGTH] = {0};
int n = LENGTH;
printf("Enter all of the students grades (A to F, letters only, no spaces):");
grades[0] = getchar();
for(int i = 0; i < n; i++)
{
if (isalpha(grades[i]) && toupper(grades[i]) <= 'F')
grades[i + 1] = getchar();
else
continue;
}
printf("This is the average of grades %.2f\n", compute_GPA(grades, n));
return 0;
}
float compute_GPA(char grades[], int n)
{
float sum = 0.0;
int count = 0; //we need the count because n is the max length
for (int i = 0; i < n; i++)
{
switch (toupper(grades[i]))
{
case 'A': sum += 4; count++; break;
case 'B': sum += 3; count++; break;
case 'C': sum += 2; count++; break;
case 'D': sum += 1; count++; break;
case 'F': sum += 0; count++; break;
default: break;
}
}
return sum/count;
} |
the_stack_data/11075009.c | /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
*
* Copyright (c) 2010 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
int foo_real()
{
return 10;
}
// This foo is a "resolver" function that return the actual address of "foo"
void* foo()
{
__asm__(".desc _foo, 0x100");
return &foo_real;
}
|
the_stack_data/104828685.c | #include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
int i=1;
void move(int n,char from,char to){
printf("%2d. Move disk %d from %c to %c\n",i++,n,from,to);
}
void hanoi(int n,char from,char dep,char to){
if(n==1){
move(1,from,to);
}
else{
hanoi(n-1,from,to,dep);
move(n,from,to);
hanoi(n-1,dep,from,to);
}
}
int main(){
int num;
while(scanf("%d",&num)==1){
char a='X',b='Y',c='Z';
hanoi(num,a,b,c);
printf("\n");
i=1;
}
return 0;
}
|
the_stack_data/179829407.c | /*
# Copyright (c) 2012, The Met Office, UK
# 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 copyright holder nor the names of any
# 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.
#
*/
int uascii(int nchar)
/* Convert EBCDIC decimal code to ASCII decimal code */
/* Ansi C version */
/* T.Gowland IT(US) Graphics team */
/*
Usage is thus ;
extern int uascii();
static int icode=38,con;
con = uascii(icode);
printf(" EBCDIC CODE %d ASCII CODE %d ",icode,con);
-1 returned if input is out of range */
{
/* Initialized data */
static int ebcasc[256] = { 0,1,2,3,156,9,134,127,151,141,142,11,12,13,
14,15,16,17,18,19,157,133,8,135,24,25,146,143,28,29,30,31,128,129,
130,131,132,10,23,27,136,137,138,139,140,5,6,7,144,145,22,147,148,
149,150,4,152,153,154,155,20,21,158,26,32,160,161,162,163,164,165,
166,167,168,91,46,60,40,43,33,38,169,170,171,172,173,174,175,176,
177,93,36,42,41,59,94,45,47,178,179,180,181,182,183,184,185,124,
44,37,95,62,63,186,187,188,189,190,191,192,193,194,96,58,35,64,39,
61,34,195,97,98,99,100,101,102,103,104,105,196,197,198,199,200,
201,202,106,107,108,109,110,111,112,113,114,203,204,205,206,207,
208,209,126,115,116,117,118,119,120,121,122,210,211,212,213,214,
215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,
231,123,65,66,67,68,69,70,71,72,73,232,233,234,235,236,237,125,74,
75,76,77,78,79,80,81,82,238,239,240,241,242,243,92,159,83,84,85,
86,87,88,89,90,244,245,246,247,248,249,48,49,50,51,52,53,54,55,56,
57,250,251,252,253,254,255 };
int ret_val;
if(nchar < 0 || nchar > 256)
ret_val = -1;
else
ret_val = ebcasc[nchar];
return ret_val;
}
|
the_stack_data/15762566.c |
//*in - input array
//* postfix - array for psuedo postfix expression
//* valArr - array for stoaring values in expression
char in[200],postfix[200], opSt[50];
float valArr[50],evalSt[20];
int opTop =-1,vTop =-1,eTop=-1;
char pushOp(char c){
if(opTop <199){
opTop++;
opSt[opTop] = c;
return opSt[opTop];
}else{
printf("opStack Overflow Error!!!\n");
return 0;
}
}
float pushVal(float val){
if(vTop <49){
vTop++;
valArr[vTop] =val;
return valArr[vTop];
}else{
printf("valArrack Overflow Error!!!\n");
return 0;
}
}
float pushEval(float val){
if(eTop <19){
eTop++;
evalSt[eTop] =val;
return evalSt[eTop];
}else{
printf("evalArrack Overflow Error!!!\n");
return 0;
}
}
char popOp(){
if(opTop !=-1){
char val = opSt[opTop];
opTop--;
return val;
}else{
printf("opStack Empty Error!!!\n");
return 0;
}
}
float popVal(){
if(vTop !=-1){
float val = valArr[vTop];
vTop--;
return val;
}else{
printf("valArr Empty Error!!!\n");
return 0;
}
}
float popEval(){
if(eTop !=-1){
float val = evalSt[eTop];
eTop--;
return val;
}else{
printf("evalStack Empty Error!!!\n");
return 0;
}
} |
the_stack_data/225143083.c | /*
* Copyright (C) 2009-2011 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>
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv) {
size_t n;
for (n = 1; n < (size_t) argc; n++) {
printf("%s ", argv[n]);
}
printf("\n");
return 0;
}
|
the_stack_data/73786.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#define STR_MAX 256
#define BUF_SIZE 128
#define PORT_MIN 1024
#define PORT_MAX 65535
int main(int argc, char *argv[]) {
// Variabili legate al programma
int i, port, enable = 1, clientSize, pid, fd, result, fileSize, bufSizeReal = BUF_SIZE, nRead, count;
char fileName[STR_MAX];
// Socket descriptors
int sd;
// Socket Addresses
struct sockaddr_in clientAddr, serverAddr;
// Socket entities
struct hostent *clientHost;
// buffer
char buf[BUF_SIZE];
// Controllo numero argomenti
if(argc != 2) {
fprintf(stderr, "Error: incorrect number of arguments!\nProgram usage: %s Port\n", argv[0]);
exit(EXIT_FAILURE);
}
// Controllo che l'argomento "Port" sia composto da soli numeri
for(i=0; i<strlen(argv[1]); i++) {
if (argv[1][i] < '0' || argv[1][i] > '9') {
fprintf(stderr, "Error: port argument '%s' is not an only-digit!\n", argv[1]);
exit(EXIT_FAILURE);
}
}
// Converto la porta in intero e controllo che non super il limite
port = atoi(argv[1]);
if(port < PORT_MIN || port > PORT_MAX) {
fprintf(stderr, "Error: port is exceeding the 65K limit!\n");
}
// Setto a 0 la serverAddr
memset((char*) &serverAddr, 0, sizeof(serverAddr));
// Setto la famiglia di indirizzi (AF_INET perché devo comunicare via internet)
serverAddr.sin_family = AF_INET;
// Setto l'indirizzo su cui ascolto (scelgo ogni interfaccia disponibile perché sono il Server)
serverAddr.sin_addr.s_addr = INADDR_ANY;
// Setto la porta a cui collegarmi (htons perché converto byte host in byte network)
serverAddr.sin_port = htons(port);
// Apertura Socket con relative peroprietà
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd < 0) {
fprintf(stderr, "Error: cannot create Socket!\n");
exit(EXIT_FAILURE);
}
printf("Server: socket created successfuly!\n");
// Setto opzioni della Socket (enable è stata dichiarata come variabile a parte)
if(setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0) {
fprintf(stderr, "Error: cannot set the Socket options! 2\n");
exit(EXIT_FAILURE);
}
// Collego la Socket alla struct "server"
if(bind(sd, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) < 0) {
fprintf(stderr, "Error: 'bind' failed!\n");
exit(EXIT_FAILURE);
}
printf("\n++ Waiting for Client connections ++\n\n");
// Ciclo principale
while(1) {
// Il padre esegue questo codice...
// Ottengo la dimensione dell'indirizzo del Client
clientSize = sizeof(struct sockaddr_in);
// Ricevo il nome del file tramite la primitiva
// ssize_t recvfrom(int sd, void *message, size_t length, int flags, struct sockaddr *src_addr, socklen_t *src_len);
if (recvfrom(sd, &fileName, sizeof(fileName), 0, (struct sockaddr*) &clientAddr, &clientSize) < 0) {
fprintf(stderr, "Error: 'recvfrom' failed!\n");
// Vado al ciclo successivo
continue;
} else {
// Codice generazione figli
if((pid = fork()) == 0) { // Figlio
printf("A new fork has been done!\n");
// Ottengo le informazioni del Client che sta comunicando col Server tramite la primitiva
// struct hostent *gethostbyaddr(const char *addr, int len, int type);
clientHost = gethostbyaddr((char*) &clientAddr.sin_addr, sizeof(clientAddr.sin_addr), AF_INET);
if(clientHost == NULL) {
fprintf(stderr, "Error: client host information not found!\n");
} else {
printf("An operation is required the Client: %s %i\n", clientHost->h_name, ntohs(clientAddr.sin_port));
}
// Inizia la ciccia qui, trovo la parola più lunga contenuta nel file ricevuto dal Client
// Verifico se il fileName ricevuto dal Client esiste nel FileSystem del Server
if((fd = open(fileName, O_RDONLY)) < 0) {
fprintf(stderr, "Error: cannot open file '%s'!\n", fileName);
// Result contiene l'esito dell'operazione:
//
// Result = -1 --> file non esistente nel FileSystem del Server :(
// Result = 0 --> file esistente nel FileSystem del Server :)
//
result = -1;
}else {
printf("File %s opened correctly!\n", fileName);
// Ottengo quanti caratteri sono nel file inviato dal Client
fileSize = lseek(fd, 0, SEEK_END);
// Porto il file pointer all'inizio del file (poiché con lseek me l'ha portato alla fine)
lseek(fd, 0, SEEK_SET);
// Ottengo la bufSizeReal
if (fileSize < bufSizeReal) {
bufSizeReal = fileSize;
}
// Count
count = 0;
result = 0;
// Ciclo lettura file
while((nRead=read(fd, &buf, bufSizeReal * sizeof(char))) > 0) {
for (i=0; i<nRead; i++) {
if (buf[i] == ' ' || buf[i] == '\n' || buf[i] == '\t') {
if (count > result) {
result = count;
}
count = 0;
} else {
count++;
}
}
// Flush array
memset(buf, 0, bufSizeReal * (sizeof buf[0]));
} // fine while
// Chiudo il file
close(fd);
} // fine else
// Stampo a video la lunghezza della parola più lunga
if(result == -1)
fprintf(stderr, "Error: file %s not found!\n", fileName);
else
printf("Length of the longest word: %d \n", result);
// Result diventa uguale
result = htonl(result);
// Invio al client la lunghezza della parola più lunga
if(sendto(sd, &result, sizeof(result), 0, (struct sockaddr*) &clientAddr, clientSize) < 0) {
fprintf(stderr, "Error: 'sendto' failed!\n");
continue;
}
// Chiudo la Socket
close(sd);
exit(EXIT_SUCCESS);
}
else if(pid > 0) { // Padre
continue;
}
else { // Errore fork
// Codice errore
fprintf(stderr, "Error: cannot execute a fork!\n");
continue;
}
} // fine else
} // fine while(1)
return 0;
}
|
the_stack_data/218892592.c | extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
int main()
{
bool _EL_U_128, _x__EL_U_128;
float _diverge_delta, _x__diverge_delta;
float delta, _x_delta;
bool _EL_U_130, _x__EL_U_130;
bool _EL_U_132, _x__EL_U_132;
float v, _x_v;
float h, _x_h;
bool _EL_U_134, _x__EL_U_134;
bool _J174, _x__J174;
bool _J168, _x__J168;
bool _J162, _x__J162;
bool _J156, _x__J156;
int __steps_to_fair = __VERIFIER_nondet_int();
_EL_U_128 = __VERIFIER_nondet_bool();
_diverge_delta = __VERIFIER_nondet_float();
delta = __VERIFIER_nondet_float();
_EL_U_130 = __VERIFIER_nondet_bool();
_EL_U_132 = __VERIFIER_nondet_bool();
v = __VERIFIER_nondet_float();
h = __VERIFIER_nondet_float();
_EL_U_134 = __VERIFIER_nondet_bool();
_J174 = __VERIFIER_nondet_bool();
_J168 = __VERIFIER_nondet_bool();
_J162 = __VERIFIER_nondet_bool();
_J156 = __VERIFIER_nondet_bool();
bool __ok = ((((((h == 0.0) && (v == (981.0/100.0))) && ((delta == 0.0) || ( !((h == 0.0) && ( !(0.0 <= v)))))) && (0.0 <= delta)) && (delta == _diverge_delta)) && ((((( !(( !(_EL_U_134 || ( !(( !((h == 0.0) && (v == 0.0))) || _EL_U_132)))) || (_EL_U_130 || ( !((1.0 <= _diverge_delta) || _EL_U_128))))) && ( !_J156)) && ( !_J162)) && ( !_J168)) && ( !_J174)));
while (__steps_to_fair >= 0 && __ok) {
if ((((_J156 && _J162) && _J168) && _J174)) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x__EL_U_128 = __VERIFIER_nondet_bool();
_x__diverge_delta = __VERIFIER_nondet_float();
_x_delta = __VERIFIER_nondet_float();
_x__EL_U_130 = __VERIFIER_nondet_bool();
_x__EL_U_132 = __VERIFIER_nondet_bool();
_x_v = __VERIFIER_nondet_float();
_x_h = __VERIFIER_nondet_float();
_x__EL_U_134 = __VERIFIER_nondet_bool();
_x__J174 = __VERIFIER_nondet_bool();
_x__J168 = __VERIFIER_nondet_bool();
_x__J162 = __VERIFIER_nondet_bool();
_x__J156 = __VERIFIER_nondet_bool();
__ok = ((((((((_x_delta == 0.0) || ( !((_x_h == 0.0) && ( !(0.0 <= _x_v))))) && (0.0 <= _x_delta)) && (0.0 <= _x_h)) && (((_x_h == 0.0) || ( !((h == 0.0) && (v <= 0.0)))) && (((h == 0.0) && (v <= 0.0)) || (((200.0 * h) + ((-200.0 * _x_h) + ((-981.0 * (delta * delta)) + (200.0 * (v * delta))))) == 0.0)))) && ((((_x_v == 0.0) || ( !((h == 0.0) && ((v <= 0.0) && (-1.0 <= v))))) && (((v + _x_v) == -1.0) || ( !((h == 0.0) && ( !(-1.0 <= v)))))) && ((((100.0 * v) + ((-100.0 * _x_v) + (-981.0 * delta))) == 0.0) || ( !(( !(h <= 0.0)) || ( !(v <= 0.0))))))) && (((delta == _x__diverge_delta) || ( !(1.0 <= _diverge_delta))) && ((1.0 <= _diverge_delta) || ((delta + (_diverge_delta + (-1.0 * _x__diverge_delta))) == 0.0)))) && ((((((_EL_U_130 == (_x__EL_U_130 || ( !(_x__EL_U_128 || (1.0 <= _x__diverge_delta))))) && ((_EL_U_128 == (_x__EL_U_128 || (1.0 <= _x__diverge_delta))) && ((_EL_U_132 == (_x__EL_U_132 || ( !((_x_h == 0.0) && (_x_v == 0.0))))) && (_EL_U_134 == (_x__EL_U_134 || ( !(_x__EL_U_132 || ( !((_x_h == 0.0) && (_x_v == 0.0)))))))))) && (_x__J156 == (( !(((_J156 && _J162) && _J168) && _J174)) && ((((_J156 && _J162) && _J168) && _J174) || ((( !((h == 0.0) && (v == 0.0))) || ( !(( !((h == 0.0) && (v == 0.0))) || _EL_U_132))) || _J156))))) && (_x__J162 == (( !(((_J156 && _J162) && _J168) && _J174)) && ((((_J156 && _J162) && _J168) && _J174) || ((( !(( !((h == 0.0) && (v == 0.0))) || _EL_U_132)) || ( !(_EL_U_134 || ( !(( !((h == 0.0) && (v == 0.0))) || _EL_U_132))))) || _J162))))) && (_x__J168 == (( !(((_J156 && _J162) && _J168) && _J174)) && ((((_J156 && _J162) && _J168) && _J174) || (((1.0 <= _diverge_delta) || ( !((1.0 <= _diverge_delta) || _EL_U_128))) || _J168))))) && (_x__J174 == (( !(((_J156 && _J162) && _J168) && _J174)) && ((((_J156 && _J162) && _J168) && _J174) || ((( !((1.0 <= _diverge_delta) || _EL_U_128)) || ( !(_EL_U_130 || ( !((1.0 <= _diverge_delta) || _EL_U_128))))) || _J174))))));
_EL_U_128 = _x__EL_U_128;
_diverge_delta = _x__diverge_delta;
delta = _x_delta;
_EL_U_130 = _x__EL_U_130;
_EL_U_132 = _x__EL_U_132;
v = _x_v;
h = _x_h;
_EL_U_134 = _x__EL_U_134;
_J174 = _x__J174;
_J168 = _x__J168;
_J162 = _x__J162;
_J156 = _x__J156;
}
}
|
the_stack_data/12637478.c | #include <stdio.h>
int main()
{
printf("File : %s\n", __FILE__);
printf("Date : %s\n", __DATE__);
printf("Time : %s\n", __TIME__);
printf("Line : %d\n", __LINE__);
printf("ANSI : %d\n", __STDC__);
} |
the_stack_data/1123528.c | /**
******************************************************************************
* @file stm32l0xx_ll_i2c.c
* @author MCD Application Team
* @version V1.7.0
* @date 31-May-2016
* @brief I2C LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2016 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 "stm32l0xx_ll_i2c.h"
#include "stm32l0xx_ll_bus.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32L0xx_LL_Driver
* @{
*/
#if defined (I2C1) || defined (I2C2) || defined (I2C3)
/** @defgroup I2C_LL I2C
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup I2C_LL_Private_Macros
* @{
*/
#define IS_LL_I2C_PERIPHERAL_MODE(__VALUE__) (((__VALUE__) == LL_I2C_MODE_I2C) || \
((__VALUE__) == LL_I2C_MODE_SMBUS_HOST) || \
((__VALUE__) == LL_I2C_MODE_SMBUS_DEVICE) || \
((__VALUE__) == LL_I2C_MODE_SMBUS_DEVICE_ARP))
#define IS_LL_I2C_ANALOG_FILTER(__VALUE__) (((__VALUE__) == LL_I2C_ANALOGFILTER_ENABLE) || \
((__VALUE__) == LL_I2C_ANALOGFILTER_DISABLE))
#define IS_LL_I2C_DIGITAL_FILTER(__VALUE__) ((__VALUE__) <= 0x0000000FU)
#define IS_LL_I2C_OWN_ADDRESS1(__VALUE__) ((__VALUE__) <= (uint32_t)0x000003FFU)
#define IS_LL_I2C_TYPE_ACKNOWLEDGE(__VALUE__) (((__VALUE__) == LL_I2C_ACK) || \
((__VALUE__) == LL_I2C_NACK))
#define IS_LL_I2C_OWN_ADDRSIZE(__VALUE__) (((__VALUE__) == LL_I2C_OWNADDRESS1_7BIT) || \
((__VALUE__) == LL_I2C_OWNADDRESS1_10BIT))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup I2C_LL_Exported_Functions
* @{
*/
/** @addtogroup I2C_LL_EF_Init
* @{
*/
/**
* @brief De-initialize the I2C registers to their default reset values.
* @param I2Cx I2C Instance.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: I2C registers are de-initialized
* - ERROR: I2C registers are not de-initialized
*/
uint32_t LL_I2C_DeInit(I2C_TypeDef *I2Cx)
{
ErrorStatus status = SUCCESS;
/* Check the I2C Instance I2Cx */
assert_param(IS_I2C_ALL_INSTANCE(I2Cx));
if (I2Cx == I2C1)
{
/* Force reset of I2C clock */
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
/* Release reset of I2C clock */
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C1);
}
#if defined(I2C2)
else if (I2Cx == I2C2)
{
/* Force reset of I2C clock */
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C2);
/* Release reset of I2C clock */
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C2);
}
#endif
#if defined(I2C3)
else if (I2Cx == I2C3)
{
/* Force reset of I2C clock */
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C3);
/* Release reset of I2C clock */
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C3);
}
#endif
else
{
status = ERROR;
}
return status;
}
/**
* @brief Initialize the I2C registers according to the specified parameters in I2C_InitStruct.
* @param I2Cx I2C Instance.
* @param I2C_InitStruct pointer to a @ref LL_I2C_InitTypeDef structure.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: I2C registers are initialized
* - ERROR: Not applicable
*/
uint32_t LL_I2C_Init(I2C_TypeDef *I2Cx, LL_I2C_InitTypeDef *I2C_InitStruct)
{
/* Check the I2C Instance I2Cx */
assert_param(IS_I2C_ALL_INSTANCE(I2Cx));
/* Check the I2C parameters from I2C_InitStruct */
assert_param(IS_LL_I2C_PERIPHERAL_MODE(I2C_InitStruct->PeripheralMode));
assert_param(IS_LL_I2C_ANALOG_FILTER(I2C_InitStruct->AnalogFilter));
assert_param(IS_LL_I2C_DIGITAL_FILTER(I2C_InitStruct->DigitalFilter));
assert_param(IS_LL_I2C_OWN_ADDRESS1(I2C_InitStruct->OwnAddress1));
assert_param(IS_LL_I2C_TYPE_ACKNOWLEDGE(I2C_InitStruct->TypeAcknowledge));
assert_param(IS_LL_I2C_OWN_ADDRSIZE(I2C_InitStruct->OwnAddrSize));
/* Disable the selected I2Cx Peripheral */
LL_I2C_Disable(I2Cx);
/*---------------------------- I2Cx CR1 Configuration ------------------------
* Configure the analog and digital noise filters with parameters :
* - AnalogFilter: I2C_CR1_ANFOFF bit
* - DigitalFilter: I2C_CR1_DNF[3:0] bits
*/
LL_I2C_ConfigFilters(I2Cx, I2C_InitStruct->AnalogFilter, I2C_InitStruct->DigitalFilter);
/*---------------------------- I2Cx TIMINGR Configuration --------------------
* Configure the SDA setup, hold time and the SCL high, low period with parameter :
* - Timing: I2C_TIMINGR_PRESC[3:0], I2C_TIMINGR_SCLDEL[3:0], I2C_TIMINGR_SDADEL[3:0],
* I2C_TIMINGR_SCLH[7:0] and I2C_TIMINGR_SCLL[7:0] bits
*/
LL_I2C_SetTiming(I2Cx, I2C_InitStruct->Timing);
/* Enable the selected I2Cx Peripheral */
LL_I2C_Enable(I2Cx);
/*---------------------------- I2Cx OAR1 Configuration -----------------------
* Disable, Configure and Enable I2Cx device own address 1 with parameters :
* - OwnAddress1: I2C_OAR1_OA1[9:0] bits
* - OwnAddrSize: I2C_OAR1_OA1MODE bit
*/
LL_I2C_DisableOwnAddress1(I2Cx);
LL_I2C_SetOwnAddress1(I2Cx, I2C_InitStruct->OwnAddress1, I2C_InitStruct->OwnAddrSize);
LL_I2C_EnableOwnAddress1(I2Cx);
/*---------------------------- I2Cx MODE Configuration -----------------------
* Configure I2Cx peripheral mode with parameter :
* - PeripheralMode: I2C_CR1_SMBDEN and I2C_CR1_SMBHEN bits
*/
LL_I2C_SetMode(I2Cx, I2C_InitStruct->PeripheralMode);
/*---------------------------- I2Cx CR2 Configuration ------------------------
* Configure the ACKnowledge or Non ACKnowledge condition
* after the address receive match code or next received byte with parameter :
* - TypeAcknowledge: I2C_CR2_NACK bit
*/
LL_I2C_AcknowledgeNextData(I2Cx, I2C_InitStruct->TypeAcknowledge);
return SUCCESS;
}
/**
* @brief Set each @ref LL_I2C_InitTypeDef field to default value.
* @param I2C_InitStruct Pointer to a @ref LL_I2C_InitTypeDef structure.
* @retval None
*/
void LL_I2C_StructInit(LL_I2C_InitTypeDef *I2C_InitStruct)
{
/* Set I2C_InitStruct fields to default values */
I2C_InitStruct->PeripheralMode = LL_I2C_MODE_I2C;
I2C_InitStruct->Timing = 0U;
I2C_InitStruct->AnalogFilter = LL_I2C_ANALOGFILTER_ENABLE;
I2C_InitStruct->DigitalFilter = 0U;
I2C_InitStruct->OwnAddress1 = 0U;
I2C_InitStruct->TypeAcknowledge = LL_I2C_NACK;
I2C_InitStruct->OwnAddrSize = LL_I2C_OWNADDRESS1_7BIT;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* I2C1 || I2C2 || I2C3 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/92148.c | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int data;
struct Node* leftChild;
struct Node* rightChild;
}Node;
Node* initNode(int data, Node* leftChild, Node* rightChild) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->leftChild = leftChild;
node->rightChild = rightChild;
return node;
}
void preorder(Node* root) {
if (root) {
printf("%d ", root->data);
preorder(root->leftChild);
preorder(root->rightChild);
}
}
void inorder(Node* root) {
if (root) {
preorder(root->leftChild);
printf("%d ", root->data);
preorder(root->rightChild);
}
}
void postorder(Node* root) {
if (root) {
preorder(root->leftChild);
preorder(root->rightChild);
printf("%d ", root->data);
}
} |
the_stack_data/113875.c | /*
04.2016
openssl genrsa -out private.pem 2048 && openssl rsa -in private.pem -outform PEM -pubout -out public.pem
*/
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int padding = RSA_NO_PADDING;
void printLastError(char *msg){
char *err = malloc(130);;
ERR_load_crypto_strings();
ERR_error_string(ERR_get_error(), err);
printf("%s ERROR: %s\n",msg, err);
free(err);
exit(1);
}
RSA *createRSA(unsigned char * key,int public){
RSA *rsa = NULL;
BIO *keybio;
keybio = BIO_new_mem_buf(key, -1);
if(keybio == NULL){
puts("Failed to create key BIO");
return 0;
}
if(public)
rsa = PEM_read_bio_RSA_PUBKEY(keybio, &rsa, NULL, NULL);
else
rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);
if(rsa == NULL)
puts("Failed to create RSA");
return rsa;
}
RSA *createRSAWithFilename(char *filename, int public){
FILE *fp = fopen(filename,"rb");
if(fp == NULL){
printf("Unable to open file %s \n",filename);
return NULL;
}
RSA *rsa = RSA_new();
if(public)
rsa = PEM_read_RSA_PUBKEY(fp, &rsa, NULL, NULL);
else
rsa = PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL);
return rsa;
}
int private_encrypt(unsigned char *data, int data_len, unsigned char *filename, unsigned char *encrypted){
RSA *rsa = createRSAWithFilename(filename, 0);
int result = RSA_private_encrypt(data_len, data, encrypted, rsa, padding);
return result;
}
int private_decrypt(unsigned char *enc_data, int data_len, unsigned char *filename, unsigned char *decrypted){
RSA *rsa = createRSAWithFilename(filename, 0);
int result = RSA_private_decrypt(data_len, enc_data, decrypted, rsa, padding);
return result;
}
int public_encrypt(unsigned char *data, int data_len, unsigned char *filename, unsigned char *encrypted){
RSA *rsa = createRSAWithFilename(filename, 1);
int result = RSA_public_encrypt(data_len, data, encrypted, rsa, padding);
return result;
}
int public_decrypt(unsigned char *enc_data, int data_len, unsigned char *filename, unsigned char *decrypted){
RSA *rsa = createRSAWithFilename(filename, 1);
int result = RSA_public_decrypt(data_len, enc_data, decrypted, rsa, padding);
return result;
}
int main(int argc, char *argv[]){
if(argc != 4){
fprintf(stderr, "Usage: %s [e|d] KEY_FILENAME INPUT\n", argv[0]);
return -1;
}
char *key = argv[2];
char plaintext[2048/8] = {0};
char encrypted[4096];
if(argv[1][0] == 'e'){
puts("Public enc.");
FILE *IN_FILE = fopen(argv[3], "r");
int OUT_FILE = open("test.enc", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
int x = 0;
while((x=fread(plaintext, 1, 256, IN_FILE))){
// Put this in a loop for files > plaintext size. append to output with write()
if(x != 256)
padding = RSA_PKCS1_PADDING;
int encrypted_length = public_encrypt(plaintext, x, key, encrypted);
if(encrypted_length == -1)
printLastError("Error encrypting.");
write(OUT_FILE, encrypted, encrypted_length);
}
if(x != 256)
write(OUT_FILE, "\xFF", 1);
fclose(IN_FILE);
close(OUT_FILE);
}
else if(argv[1][0] == 'd'){
int OUT_FILE = open("test.dec", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
// See if padding was used.
struct stat fileStat;
stat("test.enc", &fileStat);
puts("Private decrypt.");
FILE *IN_FILE = fopen("test.enc", "r");
int x = 0;
int ttl_read = 0;
while((x=fread(plaintext, 1, 256, IN_FILE))){
if(x == 1)
break; // Extra byte at the end to signify padding.
ttl_read += x;
if(ttl_read == fileStat.st_size-1)
padding = RSA_PKCS1_PADDING;
int dec = private_decrypt(plaintext, x, key, encrypted);
if(dec == -1)
printLastError("Error decrypting.");
if(dec > 0)
write(OUT_FILE, encrypted, dec);
}
fclose(IN_FILE);
close(OUT_FILE);
}
puts("Success.");
return 0;
}
|
the_stack_data/55348.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
char a;
printf("Enter Grade: ");
scanf(" %c",&a);
if( a=='A' || a=='a' )
printf("Excellent");
else if( (a=='B' || a=='b') )
printf("Good");
else if( (a=='C' || a=='c') )
printf("Satisfactory");
else if( (a=='D' || a=='d') )
printf("Needs Improvement");
return 0;
}
|
the_stack_data/233398.c | void main()
{
int x = 0;
int y;
__CPROVER_assume(10<=y && y<=20);
while(x!=15)
{
if(x>0) x=y;
if(x==0) x=5;
}
assert(x>=5);
assert(x<=20);
}
|
the_stack_data/176705736.c | /*
* libc/stdio/fread.c
*/
#include <stdio.h>
size_t fread(void *buf, size_t size, size_t count, FILE *f)
{
size_t bytes_requested = size * count;
size_t bytes_read;
if (bytes_requested == 0)
return 0;
bytes_read = __stdio_read(f, buf, bytes_requested);
return bytes_read == bytes_requested ? count : bytes_read / size;
}
|
the_stack_data/6387926.c | /* $OpenBSD: wcscoll.c,v 1.2 2012/12/05 23:20:00 deraadt Exp $ */
/* $NetBSD: wcscoll.c,v 1.1 2003/03/02 22:18:16 tshiozak Exp $ */
/*-
* Copyright (c)2003 Citrus Project,
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR 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 <assert.h>
#include <wchar.h>
/*
* Compare strings with using collating information.
*/
int
wcscoll(const wchar_t *s1, const wchar_t *s2)
{
/* XXX: LC_COLLATE should be implemented. */
return (wcscmp(s1, s2));
}
|
the_stack_data/43888258.c | //@ ltl invariant negative: ( ([] ( (! ( AP((s0_l1 != 0)) && (! AP((s0_l0 != 0))))) || (<> ( (! AP((s0_l0 != 0))) && (! AP((s0_l1 != 0))))))) || (! ([] (<> AP((1.0 <= _diverge_delta))))));
extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
char __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
float _diverge_delta, _x__diverge_delta;
char s8_evt0, _x_s8_evt0;
char s7_l1, _x_s7_l1;
char s7_l0, _x_s7_l0;
char s0_l0, _x_s0_l0;
char s7_evt2, _x_s7_evt2;
char s0_evt2, _x_s0_evt2;
float s19_x, _x_s19_x;
char s7_evt1, _x_s7_evt1;
char s0_evt1, _x_s0_evt1;
char s7_evt0, _x_s7_evt0;
char s0_evt0, _x_s0_evt0;
char s6_l1, _x_s6_l1;
char s6_l0, _x_s6_l0;
char s5_l1, _x_s5_l1;
char s5_l0, _x_s5_l0;
char s19_l1, _x_s19_l1;
char s5_evt2, _x_s5_evt2;
char bus_l0, _x_bus_l0;
float s17_x, _x_s17_x;
float s5_x, _x_s5_x;
char s4_l1, _x_s4_l1;
char s4_l0, _x_s4_l0;
char s18_l1, _x_s18_l1;
char s4_evt2, _x_s4_evt2;
float s16_x, _x_s16_x;
char s18_evt2, _x_s18_evt2;
char s4_evt0, _x_s4_evt0;
char s18_evt1, _x_s18_evt1;
float s4_x, _x_s4_x;
float bus_x, _x_bus_x;
float s15_x, _x_s15_x;
char s17_evt2, _x_s17_evt2;
float s0_x, _x_s0_x;
char s0_l1, _x_s0_l1;
float s7_x, _x_s7_x;
char s19_l0, _x_s19_l0;
char s5_evt1, _x_s5_evt1;
char s19_evt2, _x_s19_evt2;
char s6_evt0, _x_s6_evt0;
char bus_l1, _x_bus_l1;
float s3_x, _x_s3_x;
char s3_l1, _x_s3_l1;
char bus_evt2, _x_bus_evt2;
char s18_evt0, _x_s18_evt0;
char s5_evt0, _x_s5_evt0;
char s3_l0, _x_s3_l0;
char s3_evt2, _x_s3_evt2;
char s17_l1, _x_s17_l1;
char bus_evt1, _x_bus_evt1;
char s6_evt2, _x_s6_evt2;
int bus_j, _x_bus_j;
float s18_x, _x_s18_x;
char bus_evt0, _x_bus_evt0;
char s2_l1, _x_s2_l1;
char s1_l0, _x_s1_l0;
char s2_l0, _x_s2_l0;
float delta, _x_delta;
int bus_cd_id, _x_bus_cd_id;
char s6_evt1, _x_s6_evt1;
char s1_l1, _x_s1_l1;
char s19_evt1, _x_s19_evt1;
float s1_x, _x_s1_x;
float s2_x, _x_s2_x;
float s6_x, _x_s6_x;
char s1_evt0, _x_s1_evt0;
char s15_evt1, _x_s15_evt1;
char s2_evt0, _x_s2_evt0;
char s16_evt1, _x_s16_evt1;
float s8_x, _x_s8_x;
char s3_evt0, _x_s3_evt0;
char s17_evt1, _x_s17_evt1;
char s15_evt2, _x_s15_evt2;
char s16_evt2, _x_s16_evt2;
char s15_l1, _x_s15_l1;
char s1_evt2, _x_s1_evt2;
float s13_x, _x_s13_x;
char s16_l1, _x_s16_l1;
char s2_evt2, _x_s2_evt2;
float s14_x, _x_s14_x;
char s8_evt1, _x_s8_evt1;
char s8_evt2, _x_s8_evt2;
char s8_l0, _x_s8_l0;
char s8_l1, _x_s8_l1;
float s9_x, _x_s9_x;
char s9_evt0, _x_s9_evt0;
char s9_evt1, _x_s9_evt1;
char s9_evt2, _x_s9_evt2;
char s9_l0, _x_s9_l0;
char s9_l1, _x_s9_l1;
float s10_x, _x_s10_x;
char s10_evt0, _x_s10_evt0;
char s10_evt1, _x_s10_evt1;
char s10_evt2, _x_s10_evt2;
char s10_l0, _x_s10_l0;
char s10_l1, _x_s10_l1;
float s11_x, _x_s11_x;
char s11_evt0, _x_s11_evt0;
char s11_evt1, _x_s11_evt1;
char s11_evt2, _x_s11_evt2;
char s11_l0, _x_s11_l0;
char s11_l1, _x_s11_l1;
float s12_x, _x_s12_x;
char s12_evt0, _x_s12_evt0;
char s12_evt1, _x_s12_evt1;
char s12_evt2, _x_s12_evt2;
char s12_l0, _x_s12_l0;
char s12_l1, _x_s12_l1;
char s13_evt0, _x_s13_evt0;
char s13_evt1, _x_s13_evt1;
char s13_evt2, _x_s13_evt2;
char s13_l0, _x_s13_l0;
char s13_l1, _x_s13_l1;
char s14_evt0, _x_s14_evt0;
char s14_evt1, _x_s14_evt1;
char s14_evt2, _x_s14_evt2;
char s14_l0, _x_s14_l0;
char s14_l1, _x_s14_l1;
char s15_evt0, _x_s15_evt0;
char s1_evt1, _x_s1_evt1;
char s15_l0, _x_s15_l0;
char s16_evt0, _x_s16_evt0;
char s2_evt1, _x_s2_evt1;
char s16_l0, _x_s16_l0;
char s17_evt0, _x_s17_evt0;
char s3_evt1, _x_s3_evt1;
char s17_l0, _x_s17_l0;
char s4_evt1, _x_s4_evt1;
char s18_l0, _x_s18_l0;
char s19_evt0, _x_s19_evt0;
int main()
{
_diverge_delta = __VERIFIER_nondet_float();
s8_evt0 = __VERIFIER_nondet_bool();
s7_l1 = __VERIFIER_nondet_bool();
s7_l0 = __VERIFIER_nondet_bool();
s0_l0 = __VERIFIER_nondet_bool();
s7_evt2 = __VERIFIER_nondet_bool();
s0_evt2 = __VERIFIER_nondet_bool();
s19_x = __VERIFIER_nondet_float();
s7_evt1 = __VERIFIER_nondet_bool();
s0_evt1 = __VERIFIER_nondet_bool();
s7_evt0 = __VERIFIER_nondet_bool();
s0_evt0 = __VERIFIER_nondet_bool();
s6_l1 = __VERIFIER_nondet_bool();
s6_l0 = __VERIFIER_nondet_bool();
s5_l1 = __VERIFIER_nondet_bool();
s5_l0 = __VERIFIER_nondet_bool();
s19_l1 = __VERIFIER_nondet_bool();
s5_evt2 = __VERIFIER_nondet_bool();
bus_l0 = __VERIFIER_nondet_bool();
s17_x = __VERIFIER_nondet_float();
s5_x = __VERIFIER_nondet_float();
s4_l1 = __VERIFIER_nondet_bool();
s4_l0 = __VERIFIER_nondet_bool();
s18_l1 = __VERIFIER_nondet_bool();
s4_evt2 = __VERIFIER_nondet_bool();
s16_x = __VERIFIER_nondet_float();
s18_evt2 = __VERIFIER_nondet_bool();
s4_evt0 = __VERIFIER_nondet_bool();
s18_evt1 = __VERIFIER_nondet_bool();
s4_x = __VERIFIER_nondet_float();
bus_x = __VERIFIER_nondet_float();
s15_x = __VERIFIER_nondet_float();
s17_evt2 = __VERIFIER_nondet_bool();
s0_x = __VERIFIER_nondet_float();
s0_l1 = __VERIFIER_nondet_bool();
s7_x = __VERIFIER_nondet_float();
s19_l0 = __VERIFIER_nondet_bool();
s5_evt1 = __VERIFIER_nondet_bool();
s19_evt2 = __VERIFIER_nondet_bool();
s6_evt0 = __VERIFIER_nondet_bool();
bus_l1 = __VERIFIER_nondet_bool();
s3_x = __VERIFIER_nondet_float();
s3_l1 = __VERIFIER_nondet_bool();
bus_evt2 = __VERIFIER_nondet_bool();
s18_evt0 = __VERIFIER_nondet_bool();
s5_evt0 = __VERIFIER_nondet_bool();
s3_l0 = __VERIFIER_nondet_bool();
s3_evt2 = __VERIFIER_nondet_bool();
s17_l1 = __VERIFIER_nondet_bool();
bus_evt1 = __VERIFIER_nondet_bool();
s6_evt2 = __VERIFIER_nondet_bool();
bus_j = __VERIFIER_nondet_int();
s18_x = __VERIFIER_nondet_float();
bus_evt0 = __VERIFIER_nondet_bool();
s2_l1 = __VERIFIER_nondet_bool();
s1_l0 = __VERIFIER_nondet_bool();
s2_l0 = __VERIFIER_nondet_bool();
delta = __VERIFIER_nondet_float();
bus_cd_id = __VERIFIER_nondet_int();
s6_evt1 = __VERIFIER_nondet_bool();
s1_l1 = __VERIFIER_nondet_bool();
s19_evt1 = __VERIFIER_nondet_bool();
s1_x = __VERIFIER_nondet_float();
s2_x = __VERIFIER_nondet_float();
s6_x = __VERIFIER_nondet_float();
s1_evt0 = __VERIFIER_nondet_bool();
s15_evt1 = __VERIFIER_nondet_bool();
s2_evt0 = __VERIFIER_nondet_bool();
s16_evt1 = __VERIFIER_nondet_bool();
s8_x = __VERIFIER_nondet_float();
s3_evt0 = __VERIFIER_nondet_bool();
s17_evt1 = __VERIFIER_nondet_bool();
s15_evt2 = __VERIFIER_nondet_bool();
s16_evt2 = __VERIFIER_nondet_bool();
s15_l1 = __VERIFIER_nondet_bool();
s1_evt2 = __VERIFIER_nondet_bool();
s13_x = __VERIFIER_nondet_float();
s16_l1 = __VERIFIER_nondet_bool();
s2_evt2 = __VERIFIER_nondet_bool();
s14_x = __VERIFIER_nondet_float();
s8_evt1 = __VERIFIER_nondet_bool();
s8_evt2 = __VERIFIER_nondet_bool();
s8_l0 = __VERIFIER_nondet_bool();
s8_l1 = __VERIFIER_nondet_bool();
s9_x = __VERIFIER_nondet_float();
s9_evt0 = __VERIFIER_nondet_bool();
s9_evt1 = __VERIFIER_nondet_bool();
s9_evt2 = __VERIFIER_nondet_bool();
s9_l0 = __VERIFIER_nondet_bool();
s9_l1 = __VERIFIER_nondet_bool();
s10_x = __VERIFIER_nondet_float();
s10_evt0 = __VERIFIER_nondet_bool();
s10_evt1 = __VERIFIER_nondet_bool();
s10_evt2 = __VERIFIER_nondet_bool();
s10_l0 = __VERIFIER_nondet_bool();
s10_l1 = __VERIFIER_nondet_bool();
s11_x = __VERIFIER_nondet_float();
s11_evt0 = __VERIFIER_nondet_bool();
s11_evt1 = __VERIFIER_nondet_bool();
s11_evt2 = __VERIFIER_nondet_bool();
s11_l0 = __VERIFIER_nondet_bool();
s11_l1 = __VERIFIER_nondet_bool();
s12_x = __VERIFIER_nondet_float();
s12_evt0 = __VERIFIER_nondet_bool();
s12_evt1 = __VERIFIER_nondet_bool();
s12_evt2 = __VERIFIER_nondet_bool();
s12_l0 = __VERIFIER_nondet_bool();
s12_l1 = __VERIFIER_nondet_bool();
s13_evt0 = __VERIFIER_nondet_bool();
s13_evt1 = __VERIFIER_nondet_bool();
s13_evt2 = __VERIFIER_nondet_bool();
s13_l0 = __VERIFIER_nondet_bool();
s13_l1 = __VERIFIER_nondet_bool();
s14_evt0 = __VERIFIER_nondet_bool();
s14_evt1 = __VERIFIER_nondet_bool();
s14_evt2 = __VERIFIER_nondet_bool();
s14_l0 = __VERIFIER_nondet_bool();
s14_l1 = __VERIFIER_nondet_bool();
s15_evt0 = __VERIFIER_nondet_bool();
s1_evt1 = __VERIFIER_nondet_bool();
s15_l0 = __VERIFIER_nondet_bool();
s16_evt0 = __VERIFIER_nondet_bool();
s2_evt1 = __VERIFIER_nondet_bool();
s16_l0 = __VERIFIER_nondet_bool();
s17_evt0 = __VERIFIER_nondet_bool();
s3_evt1 = __VERIFIER_nondet_bool();
s17_l0 = __VERIFIER_nondet_bool();
s4_evt1 = __VERIFIER_nondet_bool();
s18_l0 = __VERIFIER_nondet_bool();
s19_evt0 = __VERIFIER_nondet_bool();
int __ok = ((((((((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) && (s19_x == 0.0)) && ((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) || (((( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))) || ((s19_evt2 != 0) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))) || ((( !(s19_evt2 != 0)) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))) || ((s19_evt2 != 0) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))))))) && ((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) || (((s19_l1 != 0) && ( !(s19_l0 != 0))) || ((s19_l0 != 0) && ( !(s19_l1 != 0)))))) && ((s19_x <= 404.0) || ( !((s19_l1 != 0) && ( !(s19_l0 != 0)))))) && ((s19_x <= 26.0) || ( !((s19_l0 != 0) && ( !(s19_l1 != 0)))))) && (((((((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) && (s18_x == 0.0)) && ((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) || (((( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))) || ((s18_evt2 != 0) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))) || ((( !(s18_evt2 != 0)) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))) || ((s18_evt2 != 0) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))))))) && ((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) || (((s18_l1 != 0) && ( !(s18_l0 != 0))) || ((s18_l0 != 0) && ( !(s18_l1 != 0)))))) && ((s18_x <= 404.0) || ( !((s18_l1 != 0) && ( !(s18_l0 != 0)))))) && ((s18_x <= 26.0) || ( !((s18_l0 != 0) && ( !(s18_l1 != 0)))))) && (((((((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) && (s17_x == 0.0)) && ((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) || (((( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) || ((s17_evt2 != 0) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))) || ((( !(s17_evt2 != 0)) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))) || ((s17_evt2 != 0) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))))))) && ((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) || (((s17_l1 != 0) && ( !(s17_l0 != 0))) || ((s17_l0 != 0) && ( !(s17_l1 != 0)))))) && ((s17_x <= 404.0) || ( !((s17_l1 != 0) && ( !(s17_l0 != 0)))))) && ((s17_x <= 26.0) || ( !((s17_l0 != 0) && ( !(s17_l1 != 0)))))) && (((((((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) && (s16_x == 0.0)) && ((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) || (((( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) || ((s16_evt2 != 0) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))) || ((( !(s16_evt2 != 0)) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))) || ((s16_evt2 != 0) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))))))) && ((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) || (((s16_l1 != 0) && ( !(s16_l0 != 0))) || ((s16_l0 != 0) && ( !(s16_l1 != 0)))))) && ((s16_x <= 404.0) || ( !((s16_l1 != 0) && ( !(s16_l0 != 0)))))) && ((s16_x <= 26.0) || ( !((s16_l0 != 0) && ( !(s16_l1 != 0)))))) && (((((((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) && (s15_x == 0.0)) && ((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) || (((( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || ((s15_evt2 != 0) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))) || ((( !(s15_evt2 != 0)) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))) || ((s15_evt2 != 0) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))))))) && ((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) || (((s15_l1 != 0) && ( !(s15_l0 != 0))) || ((s15_l0 != 0) && ( !(s15_l1 != 0)))))) && ((s15_x <= 404.0) || ( !((s15_l1 != 0) && ( !(s15_l0 != 0)))))) && ((s15_x <= 26.0) || ( !((s15_l0 != 0) && ( !(s15_l1 != 0)))))) && (((((((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) && (s14_x == 0.0)) && ((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) || (((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || ((s14_evt2 != 0) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))) || ((( !(s14_evt2 != 0)) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))) || ((s14_evt2 != 0) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))))))) && ((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) || (((s14_l1 != 0) && ( !(s14_l0 != 0))) || ((s14_l0 != 0) && ( !(s14_l1 != 0)))))) && ((s14_x <= 404.0) || ( !((s14_l1 != 0) && ( !(s14_l0 != 0)))))) && ((s14_x <= 26.0) || ( !((s14_l0 != 0) && ( !(s14_l1 != 0)))))) && (((((((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) && (s13_x == 0.0)) && ((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) || (((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || ((s13_evt2 != 0) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))) || ((( !(s13_evt2 != 0)) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))) || ((s13_evt2 != 0) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))))))) && ((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) || (((s13_l1 != 0) && ( !(s13_l0 != 0))) || ((s13_l0 != 0) && ( !(s13_l1 != 0)))))) && ((s13_x <= 404.0) || ( !((s13_l1 != 0) && ( !(s13_l0 != 0)))))) && ((s13_x <= 26.0) || ( !((s13_l0 != 0) && ( !(s13_l1 != 0)))))) && (((((((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) && (s12_x == 0.0)) && ((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) || (((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || ((s12_evt2 != 0) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))) || ((( !(s12_evt2 != 0)) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))) || ((s12_evt2 != 0) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))))))) && ((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) || (((s12_l1 != 0) && ( !(s12_l0 != 0))) || ((s12_l0 != 0) && ( !(s12_l1 != 0)))))) && ((s12_x <= 404.0) || ( !((s12_l1 != 0) && ( !(s12_l0 != 0)))))) && ((s12_x <= 26.0) || ( !((s12_l0 != 0) && ( !(s12_l1 != 0)))))) && (((((((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && (s11_x == 0.0)) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) || (((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || ((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))) || ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || ((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))))))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) || (((s11_l1 != 0) && ( !(s11_l0 != 0))) || ((s11_l0 != 0) && ( !(s11_l1 != 0)))))) && ((s11_x <= 404.0) || ( !((s11_l1 != 0) && ( !(s11_l0 != 0)))))) && ((s11_x <= 26.0) || ( !((s11_l0 != 0) && ( !(s11_l1 != 0)))))) && (((((((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && (s10_x == 0.0)) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) || (((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || ((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))) || ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || ((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))))))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) || (((s10_l1 != 0) && ( !(s10_l0 != 0))) || ((s10_l0 != 0) && ( !(s10_l1 != 0)))))) && ((s10_x <= 404.0) || ( !((s10_l1 != 0) && ( !(s10_l0 != 0)))))) && ((s10_x <= 26.0) || ( !((s10_l0 != 0) && ( !(s10_l1 != 0)))))) && (((((((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && (s9_x == 0.0)) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) || (((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || ((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))) || ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || ((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))))))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) || (((s9_l1 != 0) && ( !(s9_l0 != 0))) || ((s9_l0 != 0) && ( !(s9_l1 != 0)))))) && ((s9_x <= 404.0) || ( !((s9_l1 != 0) && ( !(s9_l0 != 0)))))) && ((s9_x <= 26.0) || ( !((s9_l0 != 0) && ( !(s9_l1 != 0)))))) && (((((((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && (s8_x == 0.0)) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) || (((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || ((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))) || ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || ((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))))))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) || (((s8_l1 != 0) && ( !(s8_l0 != 0))) || ((s8_l0 != 0) && ( !(s8_l1 != 0)))))) && ((s8_x <= 404.0) || ( !((s8_l1 != 0) && ( !(s8_l0 != 0)))))) && ((s8_x <= 26.0) || ( !((s8_l0 != 0) && ( !(s8_l1 != 0)))))) && (((((((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && (s7_x == 0.0)) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) || (((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || ((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))) || ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || ((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))))))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) || (((s7_l1 != 0) && ( !(s7_l0 != 0))) || ((s7_l0 != 0) && ( !(s7_l1 != 0)))))) && ((s7_x <= 404.0) || ( !((s7_l1 != 0) && ( !(s7_l0 != 0)))))) && ((s7_x <= 26.0) || ( !((s7_l0 != 0) && ( !(s7_l1 != 0)))))) && (((((((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && (s6_x == 0.0)) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) || (((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || ((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))) || ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || ((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))))))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) || (((s6_l1 != 0) && ( !(s6_l0 != 0))) || ((s6_l0 != 0) && ( !(s6_l1 != 0)))))) && ((s6_x <= 404.0) || ( !((s6_l1 != 0) && ( !(s6_l0 != 0)))))) && ((s6_x <= 26.0) || ( !((s6_l0 != 0) && ( !(s6_l1 != 0)))))) && (((((((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && (s5_x == 0.0)) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) || (((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || ((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))) || ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || ((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))))))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) || (((s5_l1 != 0) && ( !(s5_l0 != 0))) || ((s5_l0 != 0) && ( !(s5_l1 != 0)))))) && ((s5_x <= 404.0) || ( !((s5_l1 != 0) && ( !(s5_l0 != 0)))))) && ((s5_x <= 26.0) || ( !((s5_l0 != 0) && ( !(s5_l1 != 0)))))) && (((((((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && (s4_x == 0.0)) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) || (((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || ((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))) || ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || ((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))))))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) || (((s4_l1 != 0) && ( !(s4_l0 != 0))) || ((s4_l0 != 0) && ( !(s4_l1 != 0)))))) && ((s4_x <= 404.0) || ( !((s4_l1 != 0) && ( !(s4_l0 != 0)))))) && ((s4_x <= 26.0) || ( !((s4_l0 != 0) && ( !(s4_l1 != 0)))))) && (((((((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && (s3_x == 0.0)) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) || (((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || ((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))) || ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || ((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))))))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) || (((s3_l1 != 0) && ( !(s3_l0 != 0))) || ((s3_l0 != 0) && ( !(s3_l1 != 0)))))) && ((s3_x <= 404.0) || ( !((s3_l1 != 0) && ( !(s3_l0 != 0)))))) && ((s3_x <= 26.0) || ( !((s3_l0 != 0) && ( !(s3_l1 != 0)))))) && (((((((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && (s2_x == 0.0)) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) || (((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || ((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))) || ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || ((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))))))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) || (((s2_l1 != 0) && ( !(s2_l0 != 0))) || ((s2_l0 != 0) && ( !(s2_l1 != 0)))))) && ((s2_x <= 404.0) || ( !((s2_l1 != 0) && ( !(s2_l0 != 0)))))) && ((s2_x <= 26.0) || ( !((s2_l0 != 0) && ( !(s2_l1 != 0)))))) && (((((((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && (s1_x == 0.0)) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) || (((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || ((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || ((( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) || ((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) || (((s1_l1 != 0) && ( !(s1_l0 != 0))) || ((s1_l0 != 0) && ( !(s1_l1 != 0)))))) && ((s1_x <= 404.0) || ( !((s1_l1 != 0) && ( !(s1_l0 != 0)))))) && ((s1_x <= 26.0) || ( !((s1_l0 != 0) && ( !(s1_l1 != 0)))))) && (((((((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && (s0_x == 0.0)) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) || (((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || ((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))) || ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || ((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))))))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) || (((s0_l1 != 0) && ( !(s0_l0 != 0))) || ((s0_l0 != 0) && ( !(s0_l1 != 0)))))) && ((s0_x <= 404.0) || ( !((s0_l1 != 0) && ( !(s0_l0 != 0)))))) && ((s0_x <= 26.0) || ( !((s0_l0 != 0) && ( !(s0_l1 != 0)))))) && (((((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) && (((( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) || ((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) || (( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0))))) || (((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) || (( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0))))))) && (((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) || ((bus_l1 != 0) && ( !(bus_l0 != 0)))) || (((bus_l0 != 0) && ( !(bus_l1 != 0))) || ((bus_l0 != 0) && (bus_l1 != 0)))))) && ((bus_j == 0) && (bus_x == 0.0))) && ((( !(13.0 <= bus_x)) || ( !((bus_l0 != 0) && ( !(bus_l1 != 0))))) && ((delta == 0.0) || ( !((bus_l0 != 0) && (bus_l1 != 0)))))) && (0.0 <= delta)))))))))))))))))))))) && (delta == _diverge_delta));
while (__ok) {
_x__diverge_delta = __VERIFIER_nondet_float();
_x_s8_evt0 = __VERIFIER_nondet_bool();
_x_s7_l1 = __VERIFIER_nondet_bool();
_x_s7_l0 = __VERIFIER_nondet_bool();
_x_s0_l0 = __VERIFIER_nondet_bool();
_x_s7_evt2 = __VERIFIER_nondet_bool();
_x_s0_evt2 = __VERIFIER_nondet_bool();
_x_s19_x = __VERIFIER_nondet_float();
_x_s7_evt1 = __VERIFIER_nondet_bool();
_x_s0_evt1 = __VERIFIER_nondet_bool();
_x_s7_evt0 = __VERIFIER_nondet_bool();
_x_s0_evt0 = __VERIFIER_nondet_bool();
_x_s6_l1 = __VERIFIER_nondet_bool();
_x_s6_l0 = __VERIFIER_nondet_bool();
_x_s5_l1 = __VERIFIER_nondet_bool();
_x_s5_l0 = __VERIFIER_nondet_bool();
_x_s19_l1 = __VERIFIER_nondet_bool();
_x_s5_evt2 = __VERIFIER_nondet_bool();
_x_bus_l0 = __VERIFIER_nondet_bool();
_x_s17_x = __VERIFIER_nondet_float();
_x_s5_x = __VERIFIER_nondet_float();
_x_s4_l1 = __VERIFIER_nondet_bool();
_x_s4_l0 = __VERIFIER_nondet_bool();
_x_s18_l1 = __VERIFIER_nondet_bool();
_x_s4_evt2 = __VERIFIER_nondet_bool();
_x_s16_x = __VERIFIER_nondet_float();
_x_s18_evt2 = __VERIFIER_nondet_bool();
_x_s4_evt0 = __VERIFIER_nondet_bool();
_x_s18_evt1 = __VERIFIER_nondet_bool();
_x_s4_x = __VERIFIER_nondet_float();
_x_bus_x = __VERIFIER_nondet_float();
_x_s15_x = __VERIFIER_nondet_float();
_x_s17_evt2 = __VERIFIER_nondet_bool();
_x_s0_x = __VERIFIER_nondet_float();
_x_s0_l1 = __VERIFIER_nondet_bool();
_x_s7_x = __VERIFIER_nondet_float();
_x_s19_l0 = __VERIFIER_nondet_bool();
_x_s5_evt1 = __VERIFIER_nondet_bool();
_x_s19_evt2 = __VERIFIER_nondet_bool();
_x_s6_evt0 = __VERIFIER_nondet_bool();
_x_bus_l1 = __VERIFIER_nondet_bool();
_x_s3_x = __VERIFIER_nondet_float();
_x_s3_l1 = __VERIFIER_nondet_bool();
_x_bus_evt2 = __VERIFIER_nondet_bool();
_x_s18_evt0 = __VERIFIER_nondet_bool();
_x_s5_evt0 = __VERIFIER_nondet_bool();
_x_s3_l0 = __VERIFIER_nondet_bool();
_x_s3_evt2 = __VERIFIER_nondet_bool();
_x_s17_l1 = __VERIFIER_nondet_bool();
_x_bus_evt1 = __VERIFIER_nondet_bool();
_x_s6_evt2 = __VERIFIER_nondet_bool();
_x_bus_j = __VERIFIER_nondet_int();
_x_s18_x = __VERIFIER_nondet_float();
_x_bus_evt0 = __VERIFIER_nondet_bool();
_x_s2_l1 = __VERIFIER_nondet_bool();
_x_s1_l0 = __VERIFIER_nondet_bool();
_x_s2_l0 = __VERIFIER_nondet_bool();
_x_delta = __VERIFIER_nondet_float();
_x_bus_cd_id = __VERIFIER_nondet_int();
_x_s6_evt1 = __VERIFIER_nondet_bool();
_x_s1_l1 = __VERIFIER_nondet_bool();
_x_s19_evt1 = __VERIFIER_nondet_bool();
_x_s1_x = __VERIFIER_nondet_float();
_x_s2_x = __VERIFIER_nondet_float();
_x_s6_x = __VERIFIER_nondet_float();
_x_s1_evt0 = __VERIFIER_nondet_bool();
_x_s15_evt1 = __VERIFIER_nondet_bool();
_x_s2_evt0 = __VERIFIER_nondet_bool();
_x_s16_evt1 = __VERIFIER_nondet_bool();
_x_s8_x = __VERIFIER_nondet_float();
_x_s3_evt0 = __VERIFIER_nondet_bool();
_x_s17_evt1 = __VERIFIER_nondet_bool();
_x_s15_evt2 = __VERIFIER_nondet_bool();
_x_s16_evt2 = __VERIFIER_nondet_bool();
_x_s15_l1 = __VERIFIER_nondet_bool();
_x_s1_evt2 = __VERIFIER_nondet_bool();
_x_s13_x = __VERIFIER_nondet_float();
_x_s16_l1 = __VERIFIER_nondet_bool();
_x_s2_evt2 = __VERIFIER_nondet_bool();
_x_s14_x = __VERIFIER_nondet_float();
_x_s8_evt1 = __VERIFIER_nondet_bool();
_x_s8_evt2 = __VERIFIER_nondet_bool();
_x_s8_l0 = __VERIFIER_nondet_bool();
_x_s8_l1 = __VERIFIER_nondet_bool();
_x_s9_x = __VERIFIER_nondet_float();
_x_s9_evt0 = __VERIFIER_nondet_bool();
_x_s9_evt1 = __VERIFIER_nondet_bool();
_x_s9_evt2 = __VERIFIER_nondet_bool();
_x_s9_l0 = __VERIFIER_nondet_bool();
_x_s9_l1 = __VERIFIER_nondet_bool();
_x_s10_x = __VERIFIER_nondet_float();
_x_s10_evt0 = __VERIFIER_nondet_bool();
_x_s10_evt1 = __VERIFIER_nondet_bool();
_x_s10_evt2 = __VERIFIER_nondet_bool();
_x_s10_l0 = __VERIFIER_nondet_bool();
_x_s10_l1 = __VERIFIER_nondet_bool();
_x_s11_x = __VERIFIER_nondet_float();
_x_s11_evt0 = __VERIFIER_nondet_bool();
_x_s11_evt1 = __VERIFIER_nondet_bool();
_x_s11_evt2 = __VERIFIER_nondet_bool();
_x_s11_l0 = __VERIFIER_nondet_bool();
_x_s11_l1 = __VERIFIER_nondet_bool();
_x_s12_x = __VERIFIER_nondet_float();
_x_s12_evt0 = __VERIFIER_nondet_bool();
_x_s12_evt1 = __VERIFIER_nondet_bool();
_x_s12_evt2 = __VERIFIER_nondet_bool();
_x_s12_l0 = __VERIFIER_nondet_bool();
_x_s12_l1 = __VERIFIER_nondet_bool();
_x_s13_evt0 = __VERIFIER_nondet_bool();
_x_s13_evt1 = __VERIFIER_nondet_bool();
_x_s13_evt2 = __VERIFIER_nondet_bool();
_x_s13_l0 = __VERIFIER_nondet_bool();
_x_s13_l1 = __VERIFIER_nondet_bool();
_x_s14_evt0 = __VERIFIER_nondet_bool();
_x_s14_evt1 = __VERIFIER_nondet_bool();
_x_s14_evt2 = __VERIFIER_nondet_bool();
_x_s14_l0 = __VERIFIER_nondet_bool();
_x_s14_l1 = __VERIFIER_nondet_bool();
_x_s15_evt0 = __VERIFIER_nondet_bool();
_x_s1_evt1 = __VERIFIER_nondet_bool();
_x_s15_l0 = __VERIFIER_nondet_bool();
_x_s16_evt0 = __VERIFIER_nondet_bool();
_x_s2_evt1 = __VERIFIER_nondet_bool();
_x_s16_l0 = __VERIFIER_nondet_bool();
_x_s17_evt0 = __VERIFIER_nondet_bool();
_x_s3_evt1 = __VERIFIER_nondet_bool();
_x_s17_l0 = __VERIFIER_nondet_bool();
_x_s4_evt1 = __VERIFIER_nondet_bool();
_x_s18_l0 = __VERIFIER_nondet_bool();
_x_s19_evt0 = __VERIFIER_nondet_bool();
__ok = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( !(_x_s19_evt2 != 0)) && ((_x_s19_evt0 != 0) && ( !(_x_s19_evt1 != 0)))) || (((( !(_x_s19_evt2 != 0)) && (( !(_x_s19_evt0 != 0)) && ( !(_x_s19_evt1 != 0)))) || ((_x_s19_evt2 != 0) && (( !(_x_s19_evt0 != 0)) && ( !(_x_s19_evt1 != 0))))) || ((( !(_x_s19_evt2 != 0)) && ((_x_s19_evt1 != 0) && ( !(_x_s19_evt0 != 0)))) || ((_x_s19_evt2 != 0) && ((_x_s19_evt1 != 0) && ( !(_x_s19_evt0 != 0))))))) && ((( !(_x_s19_l0 != 0)) && ( !(_x_s19_l1 != 0))) || (((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0))) || ((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0)))))) && ((_x_s19_x <= 404.0) || ( !((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0)))))) && ((_x_s19_x <= 26.0) || ( !((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0)))))) && ((delta <= 0.0) || ((((s19_l0 != 0) == (_x_s19_l0 != 0)) && ((s19_l1 != 0) == (_x_s19_l1 != 0))) && ((delta + (s19_x + (-1.0 * _x_s19_x))) == 0.0)))) && (((((s19_l0 != 0) == (_x_s19_l0 != 0)) && ((s19_l1 != 0) == (_x_s19_l1 != 0))) && ((delta + (s19_x + (-1.0 * _x_s19_x))) == 0.0)) || ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && ((((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0))) || ((( !(_x_s19_l0 != 0)) && ( !(_x_s19_l1 != 0))) || ((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0))))) || ( !((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))))))))) && (((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) && (_x_s19_x == 0.0)) || ( !((( !(_x_s19_l0 != 0)) && ( !(_x_s19_l1 != 0))) && ((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && ((((s19_evt2 != 0) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))) && (_x_s19_x == 0.0)) || ( !(((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0))) && ((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && (((_x_s19_x == 0.0) && (((s19_evt2 != 0) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))) || (( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))))) || ( !(((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0))) && ((( !(s19_l0 != 0)) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && (((( !(_x_s19_l0 != 0)) && ( !(_x_s19_l1 != 0))) || ((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0)))) || ( !(((s19_l1 != 0) && ( !(s19_l0 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))))))))) && (((404.0 <= s19_x) && ((( !(s19_evt2 != 0)) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))) && (_x_s19_x == 0.0))) || ( !((( !(_x_s19_l0 != 0)) && ( !(_x_s19_l1 != 0))) && (((s19_l1 != 0) && ( !(s19_l0 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && (((s19_x <= 26.0) && ((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) && (_x_s19_x == 0.0))) || ( !(((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0))) && (((s19_l1 != 0) && ( !(s19_l0 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && ((((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0))) || ((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0)))) || ( !(((s19_l0 != 0) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))))))))) && (((s19_x <= 26.0) && ((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) && (_x_s19_x == 0.0))) || ( !(((_x_s19_l0 != 0) && ( !(_x_s19_l1 != 0))) && (((s19_l0 != 0) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && (((s19_x <= 26.0) && (((s19_evt2 != 0) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))) && (_x_s19_x == 0.0))) || ( !(((_x_s19_l1 != 0) && ( !(_x_s19_l0 != 0))) && (((s19_l0 != 0) && ( !(s19_l1 != 0))) && ((delta == 0.0) && ( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s18_evt2 != 0)) && ((_x_s18_evt0 != 0) && ( !(_x_s18_evt1 != 0)))) || (((( !(_x_s18_evt2 != 0)) && (( !(_x_s18_evt0 != 0)) && ( !(_x_s18_evt1 != 0)))) || ((_x_s18_evt2 != 0) && (( !(_x_s18_evt0 != 0)) && ( !(_x_s18_evt1 != 0))))) || ((( !(_x_s18_evt2 != 0)) && ((_x_s18_evt1 != 0) && ( !(_x_s18_evt0 != 0)))) || ((_x_s18_evt2 != 0) && ((_x_s18_evt1 != 0) && ( !(_x_s18_evt0 != 0))))))) && ((( !(_x_s18_l0 != 0)) && ( !(_x_s18_l1 != 0))) || (((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0))) || ((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0)))))) && ((_x_s18_x <= 404.0) || ( !((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0)))))) && ((_x_s18_x <= 26.0) || ( !((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0)))))) && ((delta <= 0.0) || ((((s18_l0 != 0) == (_x_s18_l0 != 0)) && ((s18_l1 != 0) == (_x_s18_l1 != 0))) && ((delta + (s18_x + (-1.0 * _x_s18_x))) == 0.0)))) && (((((s18_l0 != 0) == (_x_s18_l0 != 0)) && ((s18_l1 != 0) == (_x_s18_l1 != 0))) && ((delta + (s18_x + (-1.0 * _x_s18_x))) == 0.0)) || ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && ((((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0))) || ((( !(_x_s18_l0 != 0)) && ( !(_x_s18_l1 != 0))) || ((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0))))) || ( !((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))))))))) && (((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) && (_x_s18_x == 0.0)) || ( !((( !(_x_s18_l0 != 0)) && ( !(_x_s18_l1 != 0))) && ((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && ((((s18_evt2 != 0) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))) && (_x_s18_x == 0.0)) || ( !(((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0))) && ((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && (((_x_s18_x == 0.0) && (((s18_evt2 != 0) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))) || (( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))))) || ( !(((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0))) && ((( !(s18_l0 != 0)) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && (((( !(_x_s18_l0 != 0)) && ( !(_x_s18_l1 != 0))) || ((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0)))) || ( !(((s18_l1 != 0) && ( !(s18_l0 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))))))))) && (((404.0 <= s18_x) && ((( !(s18_evt2 != 0)) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))) && (_x_s18_x == 0.0))) || ( !((( !(_x_s18_l0 != 0)) && ( !(_x_s18_l1 != 0))) && (((s18_l1 != 0) && ( !(s18_l0 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && (((s18_x <= 26.0) && ((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) && (_x_s18_x == 0.0))) || ( !(((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0))) && (((s18_l1 != 0) && ( !(s18_l0 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && ((((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0))) || ((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0)))) || ( !(((s18_l0 != 0) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))))))))) && (((s18_x <= 26.0) && ((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) && (_x_s18_x == 0.0))) || ( !(((_x_s18_l0 != 0) && ( !(_x_s18_l1 != 0))) && (((s18_l0 != 0) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && (((s18_x <= 26.0) && (((s18_evt2 != 0) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))) && (_x_s18_x == 0.0))) || ( !(((_x_s18_l1 != 0) && ( !(_x_s18_l0 != 0))) && (((s18_l0 != 0) && ( !(s18_l1 != 0))) && ((delta == 0.0) && ( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s17_evt2 != 0)) && ((_x_s17_evt0 != 0) && ( !(_x_s17_evt1 != 0)))) || (((( !(_x_s17_evt2 != 0)) && (( !(_x_s17_evt0 != 0)) && ( !(_x_s17_evt1 != 0)))) || ((_x_s17_evt2 != 0) && (( !(_x_s17_evt0 != 0)) && ( !(_x_s17_evt1 != 0))))) || ((( !(_x_s17_evt2 != 0)) && ((_x_s17_evt1 != 0) && ( !(_x_s17_evt0 != 0)))) || ((_x_s17_evt2 != 0) && ((_x_s17_evt1 != 0) && ( !(_x_s17_evt0 != 0))))))) && ((( !(_x_s17_l0 != 0)) && ( !(_x_s17_l1 != 0))) || (((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0))) || ((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0)))))) && ((_x_s17_x <= 404.0) || ( !((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0)))))) && ((_x_s17_x <= 26.0) || ( !((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0)))))) && ((delta <= 0.0) || ((((s17_l0 != 0) == (_x_s17_l0 != 0)) && ((s17_l1 != 0) == (_x_s17_l1 != 0))) && ((delta + (s17_x + (-1.0 * _x_s17_x))) == 0.0)))) && (((((s17_l0 != 0) == (_x_s17_l0 != 0)) && ((s17_l1 != 0) == (_x_s17_l1 != 0))) && ((delta + (s17_x + (-1.0 * _x_s17_x))) == 0.0)) || ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && ((((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0))) || ((( !(_x_s17_l0 != 0)) && ( !(_x_s17_l1 != 0))) || ((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0))))) || ( !((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))))))))) && (((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) && (_x_s17_x == 0.0)) || ( !((( !(_x_s17_l0 != 0)) && ( !(_x_s17_l1 != 0))) && ((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && ((((s17_evt2 != 0) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) && (_x_s17_x == 0.0)) || ( !(((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0))) && ((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && (((_x_s17_x == 0.0) && (((s17_evt2 != 0) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))) || (( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))))) || ( !(((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0))) && ((( !(s17_l0 != 0)) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && (((( !(_x_s17_l0 != 0)) && ( !(_x_s17_l1 != 0))) || ((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0)))) || ( !(((s17_l1 != 0) && ( !(s17_l0 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))))))))) && (((404.0 <= s17_x) && ((( !(s17_evt2 != 0)) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))) && (_x_s17_x == 0.0))) || ( !((( !(_x_s17_l0 != 0)) && ( !(_x_s17_l1 != 0))) && (((s17_l1 != 0) && ( !(s17_l0 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && (((s17_x <= 26.0) && ((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) && (_x_s17_x == 0.0))) || ( !(((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0))) && (((s17_l1 != 0) && ( !(s17_l0 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && ((((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0))) || ((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0)))) || ( !(((s17_l0 != 0) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))))))))) && (((s17_x <= 26.0) && ((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) && (_x_s17_x == 0.0))) || ( !(((_x_s17_l0 != 0) && ( !(_x_s17_l1 != 0))) && (((s17_l0 != 0) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && (((s17_x <= 26.0) && (((s17_evt2 != 0) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) && (_x_s17_x == 0.0))) || ( !(((_x_s17_l1 != 0) && ( !(_x_s17_l0 != 0))) && (((s17_l0 != 0) && ( !(s17_l1 != 0))) && ((delta == 0.0) && ( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s16_evt2 != 0)) && ((_x_s16_evt0 != 0) && ( !(_x_s16_evt1 != 0)))) || (((( !(_x_s16_evt2 != 0)) && (( !(_x_s16_evt0 != 0)) && ( !(_x_s16_evt1 != 0)))) || ((_x_s16_evt2 != 0) && (( !(_x_s16_evt0 != 0)) && ( !(_x_s16_evt1 != 0))))) || ((( !(_x_s16_evt2 != 0)) && ((_x_s16_evt1 != 0) && ( !(_x_s16_evt0 != 0)))) || ((_x_s16_evt2 != 0) && ((_x_s16_evt1 != 0) && ( !(_x_s16_evt0 != 0))))))) && ((( !(_x_s16_l0 != 0)) && ( !(_x_s16_l1 != 0))) || (((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0))) || ((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0)))))) && ((_x_s16_x <= 404.0) || ( !((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0)))))) && ((_x_s16_x <= 26.0) || ( !((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0)))))) && ((delta <= 0.0) || ((((s16_l0 != 0) == (_x_s16_l0 != 0)) && ((s16_l1 != 0) == (_x_s16_l1 != 0))) && ((delta + (s16_x + (-1.0 * _x_s16_x))) == 0.0)))) && (((((s16_l0 != 0) == (_x_s16_l0 != 0)) && ((s16_l1 != 0) == (_x_s16_l1 != 0))) && ((delta + (s16_x + (-1.0 * _x_s16_x))) == 0.0)) || ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && ((((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0))) || ((( !(_x_s16_l0 != 0)) && ( !(_x_s16_l1 != 0))) || ((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0))))) || ( !((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))))))))) && (((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) && (_x_s16_x == 0.0)) || ( !((( !(_x_s16_l0 != 0)) && ( !(_x_s16_l1 != 0))) && ((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && ((((s16_evt2 != 0) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) && (_x_s16_x == 0.0)) || ( !(((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0))) && ((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && (((_x_s16_x == 0.0) && (((s16_evt2 != 0) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))) || (( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))))) || ( !(((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0))) && ((( !(s16_l0 != 0)) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && (((( !(_x_s16_l0 != 0)) && ( !(_x_s16_l1 != 0))) || ((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0)))) || ( !(((s16_l1 != 0) && ( !(s16_l0 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))))))))) && (((404.0 <= s16_x) && ((( !(s16_evt2 != 0)) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))) && (_x_s16_x == 0.0))) || ( !((( !(_x_s16_l0 != 0)) && ( !(_x_s16_l1 != 0))) && (((s16_l1 != 0) && ( !(s16_l0 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && (((s16_x <= 26.0) && ((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) && (_x_s16_x == 0.0))) || ( !(((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0))) && (((s16_l1 != 0) && ( !(s16_l0 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && ((((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0))) || ((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0)))) || ( !(((s16_l0 != 0) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))))))))) && (((s16_x <= 26.0) && ((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) && (_x_s16_x == 0.0))) || ( !(((_x_s16_l0 != 0) && ( !(_x_s16_l1 != 0))) && (((s16_l0 != 0) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && (((s16_x <= 26.0) && (((s16_evt2 != 0) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) && (_x_s16_x == 0.0))) || ( !(((_x_s16_l1 != 0) && ( !(_x_s16_l0 != 0))) && (((s16_l0 != 0) && ( !(s16_l1 != 0))) && ((delta == 0.0) && ( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s15_evt2 != 0)) && ((_x_s15_evt0 != 0) && ( !(_x_s15_evt1 != 0)))) || (((( !(_x_s15_evt2 != 0)) && (( !(_x_s15_evt0 != 0)) && ( !(_x_s15_evt1 != 0)))) || ((_x_s15_evt2 != 0) && (( !(_x_s15_evt0 != 0)) && ( !(_x_s15_evt1 != 0))))) || ((( !(_x_s15_evt2 != 0)) && ((_x_s15_evt1 != 0) && ( !(_x_s15_evt0 != 0)))) || ((_x_s15_evt2 != 0) && ((_x_s15_evt1 != 0) && ( !(_x_s15_evt0 != 0))))))) && ((( !(_x_s15_l0 != 0)) && ( !(_x_s15_l1 != 0))) || (((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0))) || ((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0)))))) && ((_x_s15_x <= 404.0) || ( !((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0)))))) && ((_x_s15_x <= 26.0) || ( !((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0)))))) && ((delta <= 0.0) || ((((s15_l0 != 0) == (_x_s15_l0 != 0)) && ((s15_l1 != 0) == (_x_s15_l1 != 0))) && ((delta + (s15_x + (-1.0 * _x_s15_x))) == 0.0)))) && (((((s15_l0 != 0) == (_x_s15_l0 != 0)) && ((s15_l1 != 0) == (_x_s15_l1 != 0))) && ((delta + (s15_x + (-1.0 * _x_s15_x))) == 0.0)) || ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && ((((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0))) || ((( !(_x_s15_l0 != 0)) && ( !(_x_s15_l1 != 0))) || ((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0))))) || ( !((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))))))))) && (((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) && (_x_s15_x == 0.0)) || ( !((( !(_x_s15_l0 != 0)) && ( !(_x_s15_l1 != 0))) && ((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && ((((s15_evt2 != 0) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) && (_x_s15_x == 0.0)) || ( !(((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0))) && ((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && (((_x_s15_x == 0.0) && (((s15_evt2 != 0) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))) || (( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))))) || ( !(((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0))) && ((( !(s15_l0 != 0)) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && (((( !(_x_s15_l0 != 0)) && ( !(_x_s15_l1 != 0))) || ((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0)))) || ( !(((s15_l1 != 0) && ( !(s15_l0 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))))))))) && (((404.0 <= s15_x) && ((( !(s15_evt2 != 0)) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))) && (_x_s15_x == 0.0))) || ( !((( !(_x_s15_l0 != 0)) && ( !(_x_s15_l1 != 0))) && (((s15_l1 != 0) && ( !(s15_l0 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && (((s15_x <= 26.0) && ((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) && (_x_s15_x == 0.0))) || ( !(((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0))) && (((s15_l1 != 0) && ( !(s15_l0 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && ((((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0))) || ((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0)))) || ( !(((s15_l0 != 0) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))))))))) && (((s15_x <= 26.0) && ((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) && (_x_s15_x == 0.0))) || ( !(((_x_s15_l0 != 0) && ( !(_x_s15_l1 != 0))) && (((s15_l0 != 0) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && (((s15_x <= 26.0) && (((s15_evt2 != 0) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) && (_x_s15_x == 0.0))) || ( !(((_x_s15_l1 != 0) && ( !(_x_s15_l0 != 0))) && (((s15_l0 != 0) && ( !(s15_l1 != 0))) && ((delta == 0.0) && ( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s14_evt2 != 0)) && ((_x_s14_evt0 != 0) && ( !(_x_s14_evt1 != 0)))) || (((( !(_x_s14_evt2 != 0)) && (( !(_x_s14_evt0 != 0)) && ( !(_x_s14_evt1 != 0)))) || ((_x_s14_evt2 != 0) && (( !(_x_s14_evt0 != 0)) && ( !(_x_s14_evt1 != 0))))) || ((( !(_x_s14_evt2 != 0)) && ((_x_s14_evt1 != 0) && ( !(_x_s14_evt0 != 0)))) || ((_x_s14_evt2 != 0) && ((_x_s14_evt1 != 0) && ( !(_x_s14_evt0 != 0))))))) && ((( !(_x_s14_l0 != 0)) && ( !(_x_s14_l1 != 0))) || (((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0))) || ((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0)))))) && ((_x_s14_x <= 404.0) || ( !((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0)))))) && ((_x_s14_x <= 26.0) || ( !((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0)))))) && ((delta <= 0.0) || ((((s14_l0 != 0) == (_x_s14_l0 != 0)) && ((s14_l1 != 0) == (_x_s14_l1 != 0))) && ((delta + (s14_x + (-1.0 * _x_s14_x))) == 0.0)))) && (((((s14_l0 != 0) == (_x_s14_l0 != 0)) && ((s14_l1 != 0) == (_x_s14_l1 != 0))) && ((delta + (s14_x + (-1.0 * _x_s14_x))) == 0.0)) || ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && ((((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0))) || ((( !(_x_s14_l0 != 0)) && ( !(_x_s14_l1 != 0))) || ((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0))))) || ( !((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))))))))) && (((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) && (_x_s14_x == 0.0)) || ( !((( !(_x_s14_l0 != 0)) && ( !(_x_s14_l1 != 0))) && ((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && ((((s14_evt2 != 0) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) && (_x_s14_x == 0.0)) || ( !(((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0))) && ((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && (((_x_s14_x == 0.0) && (((s14_evt2 != 0) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))) || (( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))))) || ( !(((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0))) && ((( !(s14_l0 != 0)) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && (((( !(_x_s14_l0 != 0)) && ( !(_x_s14_l1 != 0))) || ((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0)))) || ( !(((s14_l1 != 0) && ( !(s14_l0 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))))))))) && (((404.0 <= s14_x) && ((( !(s14_evt2 != 0)) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))) && (_x_s14_x == 0.0))) || ( !((( !(_x_s14_l0 != 0)) && ( !(_x_s14_l1 != 0))) && (((s14_l1 != 0) && ( !(s14_l0 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && (((s14_x <= 26.0) && ((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) && (_x_s14_x == 0.0))) || ( !(((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0))) && (((s14_l1 != 0) && ( !(s14_l0 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && ((((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0))) || ((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0)))) || ( !(((s14_l0 != 0) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))))))))) && (((s14_x <= 26.0) && ((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) && (_x_s14_x == 0.0))) || ( !(((_x_s14_l0 != 0) && ( !(_x_s14_l1 != 0))) && (((s14_l0 != 0) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && (((s14_x <= 26.0) && (((s14_evt2 != 0) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) && (_x_s14_x == 0.0))) || ( !(((_x_s14_l1 != 0) && ( !(_x_s14_l0 != 0))) && (((s14_l0 != 0) && ( !(s14_l1 != 0))) && ((delta == 0.0) && ( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s13_evt2 != 0)) && ((_x_s13_evt0 != 0) && ( !(_x_s13_evt1 != 0)))) || (((( !(_x_s13_evt2 != 0)) && (( !(_x_s13_evt0 != 0)) && ( !(_x_s13_evt1 != 0)))) || ((_x_s13_evt2 != 0) && (( !(_x_s13_evt0 != 0)) && ( !(_x_s13_evt1 != 0))))) || ((( !(_x_s13_evt2 != 0)) && ((_x_s13_evt1 != 0) && ( !(_x_s13_evt0 != 0)))) || ((_x_s13_evt2 != 0) && ((_x_s13_evt1 != 0) && ( !(_x_s13_evt0 != 0))))))) && ((( !(_x_s13_l0 != 0)) && ( !(_x_s13_l1 != 0))) || (((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0))) || ((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0)))))) && ((_x_s13_x <= 404.0) || ( !((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0)))))) && ((_x_s13_x <= 26.0) || ( !((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0)))))) && ((delta <= 0.0) || ((((s13_l0 != 0) == (_x_s13_l0 != 0)) && ((s13_l1 != 0) == (_x_s13_l1 != 0))) && ((delta + (s13_x + (-1.0 * _x_s13_x))) == 0.0)))) && (((((s13_l0 != 0) == (_x_s13_l0 != 0)) && ((s13_l1 != 0) == (_x_s13_l1 != 0))) && ((delta + (s13_x + (-1.0 * _x_s13_x))) == 0.0)) || ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && ((((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0))) || ((( !(_x_s13_l0 != 0)) && ( !(_x_s13_l1 != 0))) || ((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0))))) || ( !((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))))))))) && (((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) && (_x_s13_x == 0.0)) || ( !((( !(_x_s13_l0 != 0)) && ( !(_x_s13_l1 != 0))) && ((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && ((((s13_evt2 != 0) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) && (_x_s13_x == 0.0)) || ( !(((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0))) && ((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && (((_x_s13_x == 0.0) && (((s13_evt2 != 0) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))) || (( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))))) || ( !(((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0))) && ((( !(s13_l0 != 0)) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && (((( !(_x_s13_l0 != 0)) && ( !(_x_s13_l1 != 0))) || ((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0)))) || ( !(((s13_l1 != 0) && ( !(s13_l0 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))))))))) && (((404.0 <= s13_x) && ((( !(s13_evt2 != 0)) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))) && (_x_s13_x == 0.0))) || ( !((( !(_x_s13_l0 != 0)) && ( !(_x_s13_l1 != 0))) && (((s13_l1 != 0) && ( !(s13_l0 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && (((s13_x <= 26.0) && ((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) && (_x_s13_x == 0.0))) || ( !(((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0))) && (((s13_l1 != 0) && ( !(s13_l0 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && ((((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0))) || ((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0)))) || ( !(((s13_l0 != 0) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))))))))) && (((s13_x <= 26.0) && ((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) && (_x_s13_x == 0.0))) || ( !(((_x_s13_l0 != 0) && ( !(_x_s13_l1 != 0))) && (((s13_l0 != 0) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && (((s13_x <= 26.0) && (((s13_evt2 != 0) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) && (_x_s13_x == 0.0))) || ( !(((_x_s13_l1 != 0) && ( !(_x_s13_l0 != 0))) && (((s13_l0 != 0) && ( !(s13_l1 != 0))) && ((delta == 0.0) && ( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s12_evt2 != 0)) && ((_x_s12_evt0 != 0) && ( !(_x_s12_evt1 != 0)))) || (((( !(_x_s12_evt2 != 0)) && (( !(_x_s12_evt0 != 0)) && ( !(_x_s12_evt1 != 0)))) || ((_x_s12_evt2 != 0) && (( !(_x_s12_evt0 != 0)) && ( !(_x_s12_evt1 != 0))))) || ((( !(_x_s12_evt2 != 0)) && ((_x_s12_evt1 != 0) && ( !(_x_s12_evt0 != 0)))) || ((_x_s12_evt2 != 0) && ((_x_s12_evt1 != 0) && ( !(_x_s12_evt0 != 0))))))) && ((( !(_x_s12_l0 != 0)) && ( !(_x_s12_l1 != 0))) || (((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0))) || ((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0)))))) && ((_x_s12_x <= 404.0) || ( !((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0)))))) && ((_x_s12_x <= 26.0) || ( !((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0)))))) && ((delta <= 0.0) || ((((s12_l0 != 0) == (_x_s12_l0 != 0)) && ((s12_l1 != 0) == (_x_s12_l1 != 0))) && ((delta + (s12_x + (-1.0 * _x_s12_x))) == 0.0)))) && (((((s12_l0 != 0) == (_x_s12_l0 != 0)) && ((s12_l1 != 0) == (_x_s12_l1 != 0))) && ((delta + (s12_x + (-1.0 * _x_s12_x))) == 0.0)) || ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && ((((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0))) || ((( !(_x_s12_l0 != 0)) && ( !(_x_s12_l1 != 0))) || ((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0))))) || ( !((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))))))))) && (((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) && (_x_s12_x == 0.0)) || ( !((( !(_x_s12_l0 != 0)) && ( !(_x_s12_l1 != 0))) && ((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && ((((s12_evt2 != 0) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) && (_x_s12_x == 0.0)) || ( !(((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0))) && ((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && (((_x_s12_x == 0.0) && (((s12_evt2 != 0) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))) || (( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))))) || ( !(((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0))) && ((( !(s12_l0 != 0)) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && (((( !(_x_s12_l0 != 0)) && ( !(_x_s12_l1 != 0))) || ((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0)))) || ( !(((s12_l1 != 0) && ( !(s12_l0 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))))))))) && (((404.0 <= s12_x) && ((( !(s12_evt2 != 0)) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))) && (_x_s12_x == 0.0))) || ( !((( !(_x_s12_l0 != 0)) && ( !(_x_s12_l1 != 0))) && (((s12_l1 != 0) && ( !(s12_l0 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && (((s12_x <= 26.0) && ((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) && (_x_s12_x == 0.0))) || ( !(((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0))) && (((s12_l1 != 0) && ( !(s12_l0 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && ((((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0))) || ((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0)))) || ( !(((s12_l0 != 0) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))))))))) && (((s12_x <= 26.0) && ((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) && (_x_s12_x == 0.0))) || ( !(((_x_s12_l0 != 0) && ( !(_x_s12_l1 != 0))) && (((s12_l0 != 0) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && (((s12_x <= 26.0) && (((s12_evt2 != 0) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) && (_x_s12_x == 0.0))) || ( !(((_x_s12_l1 != 0) && ( !(_x_s12_l0 != 0))) && (((s12_l0 != 0) && ( !(s12_l1 != 0))) && ((delta == 0.0) && ( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s11_evt2 != 0)) && ((_x_s11_evt0 != 0) && ( !(_x_s11_evt1 != 0)))) || (((( !(_x_s11_evt2 != 0)) && (( !(_x_s11_evt0 != 0)) && ( !(_x_s11_evt1 != 0)))) || ((_x_s11_evt2 != 0) && (( !(_x_s11_evt0 != 0)) && ( !(_x_s11_evt1 != 0))))) || ((( !(_x_s11_evt2 != 0)) && ((_x_s11_evt1 != 0) && ( !(_x_s11_evt0 != 0)))) || ((_x_s11_evt2 != 0) && ((_x_s11_evt1 != 0) && ( !(_x_s11_evt0 != 0))))))) && ((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || (((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))))) && ((_x_s11_x <= 404.0) || ( !((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0)))))) && ((_x_s11_x <= 26.0) || ( !((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))))) && ((delta <= 0.0) || ((((s11_l0 != 0) == (_x_s11_l0 != 0)) && ((s11_l1 != 0) == (_x_s11_l1 != 0))) && ((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0)))) && (((((s11_l0 != 0) == (_x_s11_l0 != 0)) && ((s11_l1 != 0) == (_x_s11_l1 != 0))) && ((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0)) || ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && ((((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) || ((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || ((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))))) || ( !((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0)) || ( !((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0)) || ( !(((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((_x_s11_x == 0.0) && (((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || (( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))) || ( !(((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((404.0 <= s11_x) && ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) && (_x_s11_x == 0.0))) || ( !((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) && (((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((s11_x <= 26.0) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && (((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))) || ( !(((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((s11_x <= 26.0) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && (((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((s11_x <= 26.0) && (((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) && (((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s10_evt2 != 0)) && ((_x_s10_evt0 != 0) && ( !(_x_s10_evt1 != 0)))) || (((( !(_x_s10_evt2 != 0)) && (( !(_x_s10_evt0 != 0)) && ( !(_x_s10_evt1 != 0)))) || ((_x_s10_evt2 != 0) && (( !(_x_s10_evt0 != 0)) && ( !(_x_s10_evt1 != 0))))) || ((( !(_x_s10_evt2 != 0)) && ((_x_s10_evt1 != 0) && ( !(_x_s10_evt0 != 0)))) || ((_x_s10_evt2 != 0) && ((_x_s10_evt1 != 0) && ( !(_x_s10_evt0 != 0))))))) && ((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || (((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))))) && ((_x_s10_x <= 404.0) || ( !((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0)))))) && ((_x_s10_x <= 26.0) || ( !((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))))) && ((delta <= 0.0) || ((((s10_l0 != 0) == (_x_s10_l0 != 0)) && ((s10_l1 != 0) == (_x_s10_l1 != 0))) && ((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0)))) && (((((s10_l0 != 0) == (_x_s10_l0 != 0)) && ((s10_l1 != 0) == (_x_s10_l1 != 0))) && ((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0)) || ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && ((((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) || ((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || ((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))))) || ( !((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0)) || ( !((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0)) || ( !(((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((_x_s10_x == 0.0) && (((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || (( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))) || ( !(((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((404.0 <= s10_x) && ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) && (_x_s10_x == 0.0))) || ( !((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) && (((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((s10_x <= 26.0) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && (((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))) || ( !(((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((s10_x <= 26.0) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && (((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((s10_x <= 26.0) && (((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) && (((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s9_evt2 != 0)) && ((_x_s9_evt0 != 0) && ( !(_x_s9_evt1 != 0)))) || (((( !(_x_s9_evt2 != 0)) && (( !(_x_s9_evt0 != 0)) && ( !(_x_s9_evt1 != 0)))) || ((_x_s9_evt2 != 0) && (( !(_x_s9_evt0 != 0)) && ( !(_x_s9_evt1 != 0))))) || ((( !(_x_s9_evt2 != 0)) && ((_x_s9_evt1 != 0) && ( !(_x_s9_evt0 != 0)))) || ((_x_s9_evt2 != 0) && ((_x_s9_evt1 != 0) && ( !(_x_s9_evt0 != 0))))))) && ((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || (((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))))) && ((_x_s9_x <= 404.0) || ( !((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0)))))) && ((_x_s9_x <= 26.0) || ( !((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))))) && ((delta <= 0.0) || ((((s9_l0 != 0) == (_x_s9_l0 != 0)) && ((s9_l1 != 0) == (_x_s9_l1 != 0))) && ((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0)))) && (((((s9_l0 != 0) == (_x_s9_l0 != 0)) && ((s9_l1 != 0) == (_x_s9_l1 != 0))) && ((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0)) || ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && ((((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) || ((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || ((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))))) || ( !((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0)) || ( !((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0)) || ( !(((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((_x_s9_x == 0.0) && (((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || (( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))) || ( !(((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((404.0 <= s9_x) && ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) && (_x_s9_x == 0.0))) || ( !((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) && (((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((s9_x <= 26.0) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && (((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))) || ( !(((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((s9_x <= 26.0) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && (((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((s9_x <= 26.0) && (((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) && (((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s8_evt2 != 0)) && ((_x_s8_evt0 != 0) && ( !(_x_s8_evt1 != 0)))) || (((( !(_x_s8_evt2 != 0)) && (( !(_x_s8_evt0 != 0)) && ( !(_x_s8_evt1 != 0)))) || ((_x_s8_evt2 != 0) && (( !(_x_s8_evt0 != 0)) && ( !(_x_s8_evt1 != 0))))) || ((( !(_x_s8_evt2 != 0)) && ((_x_s8_evt1 != 0) && ( !(_x_s8_evt0 != 0)))) || ((_x_s8_evt2 != 0) && ((_x_s8_evt1 != 0) && ( !(_x_s8_evt0 != 0))))))) && ((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || (((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))))) && ((_x_s8_x <= 404.0) || ( !((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0)))))) && ((_x_s8_x <= 26.0) || ( !((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))))) && ((delta <= 0.0) || ((((s8_l0 != 0) == (_x_s8_l0 != 0)) && ((s8_l1 != 0) == (_x_s8_l1 != 0))) && ((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0)))) && (((((s8_l0 != 0) == (_x_s8_l0 != 0)) && ((s8_l1 != 0) == (_x_s8_l1 != 0))) && ((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0)) || ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && ((((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) || ((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || ((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))))) || ( !((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0)) || ( !((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0)) || ( !(((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((_x_s8_x == 0.0) && (((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || (( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))) || ( !(((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((404.0 <= s8_x) && ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) && (_x_s8_x == 0.0))) || ( !((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) && (((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((s8_x <= 26.0) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && (((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))) || ( !(((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((s8_x <= 26.0) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && (((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((s8_x <= 26.0) && (((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) && (((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s7_evt2 != 0)) && ((_x_s7_evt0 != 0) && ( !(_x_s7_evt1 != 0)))) || (((( !(_x_s7_evt2 != 0)) && (( !(_x_s7_evt0 != 0)) && ( !(_x_s7_evt1 != 0)))) || ((_x_s7_evt2 != 0) && (( !(_x_s7_evt0 != 0)) && ( !(_x_s7_evt1 != 0))))) || ((( !(_x_s7_evt2 != 0)) && ((_x_s7_evt1 != 0) && ( !(_x_s7_evt0 != 0)))) || ((_x_s7_evt2 != 0) && ((_x_s7_evt1 != 0) && ( !(_x_s7_evt0 != 0))))))) && ((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || (((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))))) && ((_x_s7_x <= 404.0) || ( !((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0)))))) && ((_x_s7_x <= 26.0) || ( !((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))))) && ((delta <= 0.0) || ((((s7_l0 != 0) == (_x_s7_l0 != 0)) && ((s7_l1 != 0) == (_x_s7_l1 != 0))) && ((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0)))) && (((((s7_l0 != 0) == (_x_s7_l0 != 0)) && ((s7_l1 != 0) == (_x_s7_l1 != 0))) && ((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0)) || ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && ((((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) || ((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || ((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))))) || ( !((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0)) || ( !((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0)) || ( !(((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((_x_s7_x == 0.0) && (((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || (( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))) || ( !(((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((404.0 <= s7_x) && ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) && (_x_s7_x == 0.0))) || ( !((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) && (((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((s7_x <= 26.0) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && (((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))) || ( !(((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((s7_x <= 26.0) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && (((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((s7_x <= 26.0) && (((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) && (((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s6_evt2 != 0)) && ((_x_s6_evt0 != 0) && ( !(_x_s6_evt1 != 0)))) || (((( !(_x_s6_evt2 != 0)) && (( !(_x_s6_evt0 != 0)) && ( !(_x_s6_evt1 != 0)))) || ((_x_s6_evt2 != 0) && (( !(_x_s6_evt0 != 0)) && ( !(_x_s6_evt1 != 0))))) || ((( !(_x_s6_evt2 != 0)) && ((_x_s6_evt1 != 0) && ( !(_x_s6_evt0 != 0)))) || ((_x_s6_evt2 != 0) && ((_x_s6_evt1 != 0) && ( !(_x_s6_evt0 != 0))))))) && ((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || (((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))))) && ((_x_s6_x <= 404.0) || ( !((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0)))))) && ((_x_s6_x <= 26.0) || ( !((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))))) && ((delta <= 0.0) || ((((s6_l0 != 0) == (_x_s6_l0 != 0)) && ((s6_l1 != 0) == (_x_s6_l1 != 0))) && ((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0)))) && (((((s6_l0 != 0) == (_x_s6_l0 != 0)) && ((s6_l1 != 0) == (_x_s6_l1 != 0))) && ((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0)) || ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && ((((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) || ((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || ((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))))) || ( !((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0)) || ( !((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0)) || ( !(((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((_x_s6_x == 0.0) && (((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || (( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))) || ( !(((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((404.0 <= s6_x) && ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) && (_x_s6_x == 0.0))) || ( !((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) && (((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((s6_x <= 26.0) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && (((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))) || ( !(((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((s6_x <= 26.0) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && (((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((s6_x <= 26.0) && (((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) && (((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s5_evt2 != 0)) && ((_x_s5_evt0 != 0) && ( !(_x_s5_evt1 != 0)))) || (((( !(_x_s5_evt2 != 0)) && (( !(_x_s5_evt0 != 0)) && ( !(_x_s5_evt1 != 0)))) || ((_x_s5_evt2 != 0) && (( !(_x_s5_evt0 != 0)) && ( !(_x_s5_evt1 != 0))))) || ((( !(_x_s5_evt2 != 0)) && ((_x_s5_evt1 != 0) && ( !(_x_s5_evt0 != 0)))) || ((_x_s5_evt2 != 0) && ((_x_s5_evt1 != 0) && ( !(_x_s5_evt0 != 0))))))) && ((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || (((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))))) && ((_x_s5_x <= 404.0) || ( !((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0)))))) && ((_x_s5_x <= 26.0) || ( !((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))))) && ((delta <= 0.0) || ((((s5_l0 != 0) == (_x_s5_l0 != 0)) && ((s5_l1 != 0) == (_x_s5_l1 != 0))) && ((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0)))) && (((((s5_l0 != 0) == (_x_s5_l0 != 0)) && ((s5_l1 != 0) == (_x_s5_l1 != 0))) && ((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0)) || ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && ((((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) || ((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || ((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))))) || ( !((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0)) || ( !((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0)) || ( !(((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((_x_s5_x == 0.0) && (((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || (( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))) || ( !(((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((404.0 <= s5_x) && ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) && (_x_s5_x == 0.0))) || ( !((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) && (((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((s5_x <= 26.0) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && (((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))) || ( !(((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((s5_x <= 26.0) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && (((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((s5_x <= 26.0) && (((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) && (((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s4_evt2 != 0)) && ((_x_s4_evt0 != 0) && ( !(_x_s4_evt1 != 0)))) || (((( !(_x_s4_evt2 != 0)) && (( !(_x_s4_evt0 != 0)) && ( !(_x_s4_evt1 != 0)))) || ((_x_s4_evt2 != 0) && (( !(_x_s4_evt0 != 0)) && ( !(_x_s4_evt1 != 0))))) || ((( !(_x_s4_evt2 != 0)) && ((_x_s4_evt1 != 0) && ( !(_x_s4_evt0 != 0)))) || ((_x_s4_evt2 != 0) && ((_x_s4_evt1 != 0) && ( !(_x_s4_evt0 != 0))))))) && ((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || (((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))))) && ((_x_s4_x <= 404.0) || ( !((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0)))))) && ((_x_s4_x <= 26.0) || ( !((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))))) && ((delta <= 0.0) || ((((s4_l0 != 0) == (_x_s4_l0 != 0)) && ((s4_l1 != 0) == (_x_s4_l1 != 0))) && ((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0)))) && (((((s4_l0 != 0) == (_x_s4_l0 != 0)) && ((s4_l1 != 0) == (_x_s4_l1 != 0))) && ((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0)) || ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && ((((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) || ((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || ((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))))) || ( !((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0)) || ( !((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0)) || ( !(((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((_x_s4_x == 0.0) && (((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || (( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))) || ( !(((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((404.0 <= s4_x) && ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) && (_x_s4_x == 0.0))) || ( !((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) && (((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((s4_x <= 26.0) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && (((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))) || ( !(((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((s4_x <= 26.0) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && (((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((s4_x <= 26.0) && (((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) && (((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s3_evt2 != 0)) && ((_x_s3_evt0 != 0) && ( !(_x_s3_evt1 != 0)))) || (((( !(_x_s3_evt2 != 0)) && (( !(_x_s3_evt0 != 0)) && ( !(_x_s3_evt1 != 0)))) || ((_x_s3_evt2 != 0) && (( !(_x_s3_evt0 != 0)) && ( !(_x_s3_evt1 != 0))))) || ((( !(_x_s3_evt2 != 0)) && ((_x_s3_evt1 != 0) && ( !(_x_s3_evt0 != 0)))) || ((_x_s3_evt2 != 0) && ((_x_s3_evt1 != 0) && ( !(_x_s3_evt0 != 0))))))) && ((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || (((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))))) && ((_x_s3_x <= 404.0) || ( !((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0)))))) && ((_x_s3_x <= 26.0) || ( !((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))))) && ((delta <= 0.0) || ((((s3_l0 != 0) == (_x_s3_l0 != 0)) && ((s3_l1 != 0) == (_x_s3_l1 != 0))) && ((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0)))) && (((((s3_l0 != 0) == (_x_s3_l0 != 0)) && ((s3_l1 != 0) == (_x_s3_l1 != 0))) && ((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0)) || ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && ((((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) || ((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || ((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))))) || ( !((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0)) || ( !((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0)) || ( !(((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((_x_s3_x == 0.0) && (((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || (( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))) || ( !(((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((404.0 <= s3_x) && ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) && (_x_s3_x == 0.0))) || ( !((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) && (((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((s3_x <= 26.0) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && (((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))) || ( !(((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((s3_x <= 26.0) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && (((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((s3_x <= 26.0) && (((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) && (((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s2_evt2 != 0)) && ((_x_s2_evt0 != 0) && ( !(_x_s2_evt1 != 0)))) || (((( !(_x_s2_evt2 != 0)) && (( !(_x_s2_evt0 != 0)) && ( !(_x_s2_evt1 != 0)))) || ((_x_s2_evt2 != 0) && (( !(_x_s2_evt0 != 0)) && ( !(_x_s2_evt1 != 0))))) || ((( !(_x_s2_evt2 != 0)) && ((_x_s2_evt1 != 0) && ( !(_x_s2_evt0 != 0)))) || ((_x_s2_evt2 != 0) && ((_x_s2_evt1 != 0) && ( !(_x_s2_evt0 != 0))))))) && ((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || (((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))))) && ((_x_s2_x <= 404.0) || ( !((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0)))))) && ((_x_s2_x <= 26.0) || ( !((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))))) && ((delta <= 0.0) || ((((s2_l0 != 0) == (_x_s2_l0 != 0)) && ((s2_l1 != 0) == (_x_s2_l1 != 0))) && ((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0)))) && (((((s2_l0 != 0) == (_x_s2_l0 != 0)) && ((s2_l1 != 0) == (_x_s2_l1 != 0))) && ((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0)) || ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && ((((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) || ((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || ((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))))) || ( !((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0)) || ( !((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0)) || ( !(((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((_x_s2_x == 0.0) && (((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || (( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))) || ( !(((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((404.0 <= s2_x) && ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) && (_x_s2_x == 0.0))) || ( !((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) && (((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((s2_x <= 26.0) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && (((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))) || ( !(((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((s2_x <= 26.0) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && (((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((s2_x <= 26.0) && (((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) && (((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s1_evt2 != 0)) && ((_x_s1_evt0 != 0) && ( !(_x_s1_evt1 != 0)))) || (((( !(_x_s1_evt2 != 0)) && (( !(_x_s1_evt0 != 0)) && ( !(_x_s1_evt1 != 0)))) || ((_x_s1_evt2 != 0) && (( !(_x_s1_evt0 != 0)) && ( !(_x_s1_evt1 != 0))))) || ((( !(_x_s1_evt2 != 0)) && ((_x_s1_evt1 != 0) && ( !(_x_s1_evt0 != 0)))) || ((_x_s1_evt2 != 0) && ((_x_s1_evt1 != 0) && ( !(_x_s1_evt0 != 0))))))) && ((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || (((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))))) && ((_x_s1_x <= 404.0) || ( !((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0)))))) && ((_x_s1_x <= 26.0) || ( !((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))))) && ((delta <= 0.0) || ((((s1_l0 != 0) == (_x_s1_l0 != 0)) && ((s1_l1 != 0) == (_x_s1_l1 != 0))) && ((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0)))) && (((((s1_l0 != 0) == (_x_s1_l0 != 0)) && ((s1_l1 != 0) == (_x_s1_l1 != 0))) && ((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0)) || ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))) && ((((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) || ((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || ((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))))) || ( !((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0)) || ( !((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0)) || ( !(((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((_x_s1_x == 0.0) && (((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))) || ( !(((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((404.0 <= s1_x) && ((( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) && (_x_s1_x == 0.0))) || ( !((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) && (((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((s1_x <= 26.0) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && (((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))) || ( !(((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((s1_x <= 26.0) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && (((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((s1_x <= 26.0) && (((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) && (((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s0_evt2 != 0)) && ((_x_s0_evt0 != 0) && ( !(_x_s0_evt1 != 0)))) || (((( !(_x_s0_evt2 != 0)) && (( !(_x_s0_evt0 != 0)) && ( !(_x_s0_evt1 != 0)))) || ((_x_s0_evt2 != 0) && (( !(_x_s0_evt0 != 0)) && ( !(_x_s0_evt1 != 0))))) || ((( !(_x_s0_evt2 != 0)) && ((_x_s0_evt1 != 0) && ( !(_x_s0_evt0 != 0)))) || ((_x_s0_evt2 != 0) && ((_x_s0_evt1 != 0) && ( !(_x_s0_evt0 != 0))))))) && ((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || (((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))))) && ((_x_s0_x <= 404.0) || ( !((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0)))))) && ((_x_s0_x <= 26.0) || ( !((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))))) && ((delta <= 0.0) || ((((s0_l0 != 0) == (_x_s0_l0 != 0)) && ((s0_l1 != 0) == (_x_s0_l1 != 0))) && ((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0)))) && (((((s0_l0 != 0) == (_x_s0_l0 != 0)) && ((s0_l1 != 0) == (_x_s0_l1 != 0))) && ((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0)) || ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))) && ((((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) || ((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || ((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))))) || ( !((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0)) || ( !((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && ((((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0)) || ( !(((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((_x_s0_x == 0.0) && (((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || (( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))) || ( !(((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((404.0 <= s0_x) && ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) && (_x_s0_x == 0.0))) || ( !((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) && (((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((s0_x <= 26.0) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && (((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && ((((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))) || ( !(((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((s0_x <= 26.0) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && (((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((s0_x <= 26.0) && (((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) && (((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((((((((((((((( !(_x_bus_evt2 != 0)) && (( !(_x_bus_evt0 != 0)) && ( !(_x_bus_evt1 != 0)))) || ((((_x_bus_evt2 != 0) && (( !(_x_bus_evt0 != 0)) && ( !(_x_bus_evt1 != 0)))) || (( !(_x_bus_evt2 != 0)) && ((_x_bus_evt1 != 0) && ( !(_x_bus_evt0 != 0))))) || (((_x_bus_evt2 != 0) && ((_x_bus_evt1 != 0) && ( !(_x_bus_evt0 != 0)))) || (( !(_x_bus_evt2 != 0)) && ((_x_bus_evt0 != 0) && ( !(_x_bus_evt1 != 0))))))) && (((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))) || (((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l0 != 0) && (_x_bus_l1 != 0))))) && ((( !(13.0 <= _x_bus_x)) || ( !((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))))) && ((_x_delta == 0.0) || ( !((_x_bus_l0 != 0) && (_x_bus_l1 != 0)))))) && ((delta <= 0.0) || (((delta + (bus_x + (-1.0 * _x_bus_x))) == 0.0) && ((((bus_l0 != 0) == (_x_bus_l0 != 0)) && ((bus_l1 != 0) == (_x_bus_l1 != 0))) && (bus_j == _x_bus_j))))) && ((((delta + (bus_x + (-1.0 * _x_bus_x))) == 0.0) && ((((bus_l0 != 0) == (_x_bus_l0 != 0)) && ((bus_l1 != 0) == (_x_bus_l1 != 0))) && (bus_j == _x_bus_j))) || ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0))))))) && (((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) && ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))) && ((bus_j == _x_bus_j) && (_x_bus_x == 0.0))) || ( !((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && (((bus_j == _x_bus_j) && (((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))) || ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))))) || ( !(((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && (((( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) && (_x_bus_x == 0.0)) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) && ((bus_l1 != 0) && ( !(bus_l0 != 0)))))))) && ((((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) && ((13.0 <= bus_x) && (bus_x == _x_bus_x))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))))))) && ((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) && (( !(13.0 <= bus_x)) && (_x_bus_x == 0.0))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0)))))))) && ((((((_x_bus_l0 != 0) && (_x_bus_l1 != 0)) && ( !(13.0 <= bus_x))) && ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == bus_j))) && ((_x_bus_x == 0.0) && ((bus_j + (-1 * _x_bus_j)) == -1))) || ( !(((bus_l0 != 0) && ( !(bus_l1 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && ((((bus_j + (-1 * _x_bus_j)) == -1) && (((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == bus_j)) && ((_x_bus_x == 0.0) && ( !(19 <= bus_j))))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l0 != 0) && (bus_l1 != 0)) && ((_x_bus_l0 != 0) && (_x_bus_l1 != 0))))))) && (((((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_j == 19)) && ((_x_bus_x == 0.0) && (bus_cd_id == bus_j))) && (_x_bus_j == 0)) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) && ((bus_l0 != 0) && (bus_l1 != 0))))))) && (0.0 <= _x_delta)))))))))))))))))))))) && (((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || ( !(delta == 0.0)))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || (( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) || (( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) || (( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))) || (( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))))) && (( !(delta == 0.0)) || (( !(( !(s19_evt2 != 0)) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0))))) || (( !(( !(s18_evt2 != 0)) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0))))) || (( !(( !(s17_evt2 != 0)) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0))))) || (( !(( !(s16_evt2 != 0)) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0))))) || (( !(( !(s15_evt2 != 0)) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0))))) || (( !(( !(s14_evt2 != 0)) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0))))) || (( !(( !(s13_evt2 != 0)) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0))))) || (( !(( !(s12_evt2 != 0)) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0))))) || (( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))) || (( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))) || (( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))) || (( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))) || (( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))) || (( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))) || (( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))) || (( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))) || (( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))) || (( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))) || (( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || (( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0))))) || ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))))))))))))))))))) && (( !(delta == 0.0)) || (((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) == (((s19_evt2 != 0) && (( !(s19_evt0 != 0)) && ( !(s19_evt1 != 0)))) || (((s18_evt2 != 0) && (( !(s18_evt0 != 0)) && ( !(s18_evt1 != 0)))) || (((s17_evt2 != 0) && (( !(s17_evt0 != 0)) && ( !(s17_evt1 != 0)))) || (((s16_evt2 != 0) && (( !(s16_evt0 != 0)) && ( !(s16_evt1 != 0)))) || (((s15_evt2 != 0) && (( !(s15_evt0 != 0)) && ( !(s15_evt1 != 0)))) || (((s14_evt2 != 0) && (( !(s14_evt0 != 0)) && ( !(s14_evt1 != 0)))) || (((s13_evt2 != 0) && (( !(s13_evt0 != 0)) && ( !(s13_evt1 != 0)))) || (((s12_evt2 != 0) && (( !(s12_evt0 != 0)) && ( !(s12_evt1 != 0)))) || (((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || ((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))))))))))))))))))) && (( !(delta == 0.0)) || ((( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) == ((( !(s19_evt2 != 0)) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))) || ((( !(s18_evt2 != 0)) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))) || ((( !(s17_evt2 != 0)) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))) || ((( !(s16_evt2 != 0)) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))) || ((( !(s15_evt2 != 0)) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))) || ((( !(s14_evt2 != 0)) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))) || ((( !(s13_evt2 != 0)) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))) || ((( !(s12_evt2 != 0)) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))) || ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))))))))))))))))))))) && (( !(delta == 0.0)) || (((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) == (((s19_evt2 != 0) && ((s19_evt1 != 0) && ( !(s19_evt0 != 0)))) || (((s18_evt2 != 0) && ((s18_evt1 != 0) && ( !(s18_evt0 != 0)))) || (((s17_evt2 != 0) && ((s17_evt1 != 0) && ( !(s17_evt0 != 0)))) || (((s16_evt2 != 0) && ((s16_evt1 != 0) && ( !(s16_evt0 != 0)))) || (((s15_evt2 != 0) && ((s15_evt1 != 0) && ( !(s15_evt0 != 0)))) || (((s14_evt2 != 0) && ((s14_evt1 != 0) && ( !(s14_evt0 != 0)))) || (((s13_evt2 != 0) && ((s13_evt1 != 0) && ( !(s13_evt0 != 0)))) || (((s12_evt2 != 0) && ((s12_evt1 != 0) && ( !(s12_evt0 != 0)))) || (((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || (((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || (((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || (((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || (((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || (((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || (((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || (((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || (((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || (((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || (((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || ((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))))))))))))))))))))) && (( !(delta == 0.0)) || ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) == ((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) || ((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) || ((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) || ((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) || ((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) || ((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) || ((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) || ((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) || ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) || ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) || ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) || ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) || ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) || ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) || ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) || ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) || ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) || ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) || ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))))))))))))))))))))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 0))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 1))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 2))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 3))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 4))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 5))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 6))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 7))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 8))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 9))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 10))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 11))))) && (( !(delta == 0.0)) || ((( !(s12_evt2 != 0)) && ((s12_evt0 != 0) && ( !(s12_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 12))))) && (( !(delta == 0.0)) || ((( !(s13_evt2 != 0)) && ((s13_evt0 != 0) && ( !(s13_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 13))))) && (( !(delta == 0.0)) || ((( !(s14_evt2 != 0)) && ((s14_evt0 != 0) && ( !(s14_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 14))))) && (( !(delta == 0.0)) || ((( !(s15_evt2 != 0)) && ((s15_evt0 != 0) && ( !(s15_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 15))))) && (( !(delta == 0.0)) || ((( !(s16_evt2 != 0)) && ((s16_evt0 != 0) && ( !(s16_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 16))))) && (( !(delta == 0.0)) || ((( !(s17_evt2 != 0)) && ((s17_evt0 != 0) && ( !(s17_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 17))))) && (( !(delta == 0.0)) || ((( !(s18_evt2 != 0)) && ((s18_evt0 != 0) && ( !(s18_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 18))))) && (( !(delta == 0.0)) || ((( !(s19_evt2 != 0)) && ((s19_evt0 != 0) && ( !(s19_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 19))))) && (((delta == _x__diverge_delta) || ( !(1.0 <= _diverge_delta))) && ((1.0 <= _diverge_delta) || ((delta + (_diverge_delta + (-1.0 * _x__diverge_delta))) == 0.0))));
_diverge_delta = _x__diverge_delta;
s8_evt0 = _x_s8_evt0;
s7_l1 = _x_s7_l1;
s7_l0 = _x_s7_l0;
s0_l0 = _x_s0_l0;
s7_evt2 = _x_s7_evt2;
s0_evt2 = _x_s0_evt2;
s19_x = _x_s19_x;
s7_evt1 = _x_s7_evt1;
s0_evt1 = _x_s0_evt1;
s7_evt0 = _x_s7_evt0;
s0_evt0 = _x_s0_evt0;
s6_l1 = _x_s6_l1;
s6_l0 = _x_s6_l0;
s5_l1 = _x_s5_l1;
s5_l0 = _x_s5_l0;
s19_l1 = _x_s19_l1;
s5_evt2 = _x_s5_evt2;
bus_l0 = _x_bus_l0;
s17_x = _x_s17_x;
s5_x = _x_s5_x;
s4_l1 = _x_s4_l1;
s4_l0 = _x_s4_l0;
s18_l1 = _x_s18_l1;
s4_evt2 = _x_s4_evt2;
s16_x = _x_s16_x;
s18_evt2 = _x_s18_evt2;
s4_evt0 = _x_s4_evt0;
s18_evt1 = _x_s18_evt1;
s4_x = _x_s4_x;
bus_x = _x_bus_x;
s15_x = _x_s15_x;
s17_evt2 = _x_s17_evt2;
s0_x = _x_s0_x;
s0_l1 = _x_s0_l1;
s7_x = _x_s7_x;
s19_l0 = _x_s19_l0;
s5_evt1 = _x_s5_evt1;
s19_evt2 = _x_s19_evt2;
s6_evt0 = _x_s6_evt0;
bus_l1 = _x_bus_l1;
s3_x = _x_s3_x;
s3_l1 = _x_s3_l1;
bus_evt2 = _x_bus_evt2;
s18_evt0 = _x_s18_evt0;
s5_evt0 = _x_s5_evt0;
s3_l0 = _x_s3_l0;
s3_evt2 = _x_s3_evt2;
s17_l1 = _x_s17_l1;
bus_evt1 = _x_bus_evt1;
s6_evt2 = _x_s6_evt2;
bus_j = _x_bus_j;
s18_x = _x_s18_x;
bus_evt0 = _x_bus_evt0;
s2_l1 = _x_s2_l1;
s1_l0 = _x_s1_l0;
s2_l0 = _x_s2_l0;
delta = _x_delta;
bus_cd_id = _x_bus_cd_id;
s6_evt1 = _x_s6_evt1;
s1_l1 = _x_s1_l1;
s19_evt1 = _x_s19_evt1;
s1_x = _x_s1_x;
s2_x = _x_s2_x;
s6_x = _x_s6_x;
s1_evt0 = _x_s1_evt0;
s15_evt1 = _x_s15_evt1;
s2_evt0 = _x_s2_evt0;
s16_evt1 = _x_s16_evt1;
s8_x = _x_s8_x;
s3_evt0 = _x_s3_evt0;
s17_evt1 = _x_s17_evt1;
s15_evt2 = _x_s15_evt2;
s16_evt2 = _x_s16_evt2;
s15_l1 = _x_s15_l1;
s1_evt2 = _x_s1_evt2;
s13_x = _x_s13_x;
s16_l1 = _x_s16_l1;
s2_evt2 = _x_s2_evt2;
s14_x = _x_s14_x;
s8_evt1 = _x_s8_evt1;
s8_evt2 = _x_s8_evt2;
s8_l0 = _x_s8_l0;
s8_l1 = _x_s8_l1;
s9_x = _x_s9_x;
s9_evt0 = _x_s9_evt0;
s9_evt1 = _x_s9_evt1;
s9_evt2 = _x_s9_evt2;
s9_l0 = _x_s9_l0;
s9_l1 = _x_s9_l1;
s10_x = _x_s10_x;
s10_evt0 = _x_s10_evt0;
s10_evt1 = _x_s10_evt1;
s10_evt2 = _x_s10_evt2;
s10_l0 = _x_s10_l0;
s10_l1 = _x_s10_l1;
s11_x = _x_s11_x;
s11_evt0 = _x_s11_evt0;
s11_evt1 = _x_s11_evt1;
s11_evt2 = _x_s11_evt2;
s11_l0 = _x_s11_l0;
s11_l1 = _x_s11_l1;
s12_x = _x_s12_x;
s12_evt0 = _x_s12_evt0;
s12_evt1 = _x_s12_evt1;
s12_evt2 = _x_s12_evt2;
s12_l0 = _x_s12_l0;
s12_l1 = _x_s12_l1;
s13_evt0 = _x_s13_evt0;
s13_evt1 = _x_s13_evt1;
s13_evt2 = _x_s13_evt2;
s13_l0 = _x_s13_l0;
s13_l1 = _x_s13_l1;
s14_evt0 = _x_s14_evt0;
s14_evt1 = _x_s14_evt1;
s14_evt2 = _x_s14_evt2;
s14_l0 = _x_s14_l0;
s14_l1 = _x_s14_l1;
s15_evt0 = _x_s15_evt0;
s1_evt1 = _x_s1_evt1;
s15_l0 = _x_s15_l0;
s16_evt0 = _x_s16_evt0;
s2_evt1 = _x_s2_evt1;
s16_l0 = _x_s16_l0;
s17_evt0 = _x_s17_evt0;
s3_evt1 = _x_s3_evt1;
s17_l0 = _x_s17_l0;
s4_evt1 = _x_s4_evt1;
s18_l0 = _x_s18_l0;
s19_evt0 = _x_s19_evt0;
}
}
|
the_stack_data/5476.c | #include <stdio.h>
int main(void){
printf("zadaj dlzku pola(viac ako 0):\n");
int n;
scanf("%d", &n);
if(n <= 0){
printf("ZADAJ KLADNE CISLO!!!");
return 0;
}
int numbers[n], i = 2;
numbers[0] = 1;
numbers[1] = 1;
while(i < n){
numbers[i] = numbers[i-1] + numbers[i-2];
i++;
}
i = 0;
while(i < n){
printf("%d ", numbers[i]);
i++;
}
return 0;
} |
the_stack_data/12875.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
int N, i, j;
printf ("Enter N to have all the simple numbers less than N\nN = ");
scanf("%d", &N);
printf ("\nSimple numbers:\n");
for (i = 2; i < N; i++)
{
int b = 1;
for (j = 1; j < i; j++)
{
float a = (float)i/(float)j - i/j;
if ((a == 0.0) && (i!=j) && (i!=1) && (j!=1))
{
b = 0;
break;
}
}
if(b==1)
{
printf("%d\n", i);
}
}
printf("\n");
system("pause");
return 0;
} |
the_stack_data/72012522.c | #include <stdlib.h>
#include <stdio.h>
#define DEBUG 0
/*************************************************************
* Title : pyrFilt.c
*
* PURPOSE : Initializes down- and up-sampling filter arrays for
* least squares splines of degree 0 to 3. (little l_2 norm)
* g : reduce filter
* h : expand filter
*
* NOTE : filter arrays should be defined as
* float g[20],h[20];
*
* Michael Unser / BEIP MAY-92
*
*************************************************************/
void pyr_filters(float g[],short *ng,float h[],short *nh,short idegree);
void pyr_filters(float g[],short *ng,float h[],short *nh,short idegree)
/* float g[],h[]; filter arrays
short *ng,*nh; number of taps
short idegree; degree of the spline */
{
switch (idegree) {
case 0 :
*ng=1; *nh=1;
break;
case 1 :
g[0]=0.707107; g[1]=0.292893; g[2]=-0.12132; g[3]=-0.0502525;
g[4]=0.0208153; g[5]=0.00862197; g[6]=-0.00357134;
g[7]=-0.0014793; g[8]=0.000612745;
*ng=9;
h[0]=1.; h[1]=0.5;
*nh=2;
break;
case 2 :
g[0]=0.617317; g[1]=0.310754; g[2]=-0.0949641; g[3]=-0.0858654;
g[4]=0.0529153; g[5]=0.0362437; g[6]=-0.0240408;
g[7]=-0.0160987; g[8]=0.0107498; g[9]=0.00718418;
g[10]=-0.00480004; g[11]=-0.00320734; g[12]=0.00214306;
g[13]=0.00143195; g[14]=-0.0009568; g[15]=-0.000639312;
*ng=16;
h[0]=1.; h[1]=0.585786; h[2]=0; h[3]=-0.100505; h[4]=0;
h[5]=0.0172439; h[6]=0; h[7]=-0.00295859; h[8]=0;
h[9]=0.000507614;
*nh=10;
break;
case 3 :
g[0]=0.596797; g[1]=0.313287; g[2]=-0.0827691; g[3]=-0.0921993;
g[4]=0.0540288; g[5]=0.0436996; g[6]=-0.0302508;
g[7]=-0.0225552; g[8]=0.0162251; g[9]=0.0118738;
g[10]=-0.00861788; g[11]=-0.00627964; g[12]=0.00456713;
g[13]=0.00332464; g[14]=-0.00241916; g[15]=-0.00176059;
g[16]=0.00128128; g[17]=0.000932349; g[18]=-0.000678643;
g[19]=-0.000493682;
*ng=20;
h[0]=1.; h[1]=0.600481; h[2]=0; h[3]=-0.127405; h[4]=0;
h[5]=0.034138; h[6]=0; h[7]=-0.00914725; h[8]=0;
h[9]=0.002451; h[10]=0; h[11]=-0.000656743;
*nh=12;
break;
default :
*ng=1; *nh=1;
break;
}
}
|
the_stack_data/154348.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, Z. Vasicek and R. Hrbacek, "Role of circuit representation in evolutionary design of energy-efficient approximate circuits" in IET Computers & Digital Techniques, vol. 12, no. 4, pp. 139-149, 7 2018. doi: 10.1049/iet-cdt.2017.0188
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mre parameters
***/
// MAE% = 0.0061 %
// MAE = 0.5
// WCE% = 0.012 %
// WCE = 1.0
// WCRE% = 50.00 %
// EP% = 50.00 %
// MRE% = 0.017 %
// MSE = 0.5
// PDK45_PWR = 0.047 mW
// PDK45_AREA = 97.1 um2
// PDK45_DELAY = 0.88 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t add12u_20A(uint64_t a, uint64_t b) {
uint64_t o = 0;
int n_415=0, n_410=0, n_255=0, n_312=0, n_259=0, n_419=0, n_317=0, n_46=0, n_41=0, n_384=0;
int n_148=0, n_388=0, n_406=0, n_68=0, n_401=0, n_246=0, n_241=0, n_32=0, n_37=0, n_397=0;
int n_392=0, n_299=0, n_152=0, n_157=0, n_237=0, n_23=0, n_22=0, n_21=0, n_20=0, n_24=0;
int n_28=0, n_126=0, n_121=0, n_344=0, n_228=0, n_184=0, n_188=0, n_348=0, n_224=0, n_2=0;
int n_18=0, n_19=0, n_16=0, n_17=0, n_14=0, n_15=0, n_12=0, n_13=0, n_10=0, n_11=0;
int n_95=0, n_90=0, n_99=0, n_330=0, n_335=0, n_139=0, n_339=0, n_135=0, n_357=0, n_352=0;
int n_197=0, n_81=0, n_86=0, n_108=0, n_104=0, n_361=0, n_366=0, n_117=0, n_112=0, n_295=0;
int n_77=0, n_72=0, n_290=0, n_215=0, n_219=0, n_277=0, n_379=0, n_272=0, n_375=0, n_370=0;
int n_161=0, n_166=0, n_281=0, n_64=0, n_201=0, n_206=0, n_264=0, n_8=0, n_9=0, n_4=0;
int n_5=0, n_6=0, n_7=0, n_0=0, n_1=0, n_268=0, n_3=0, n_59=0, n_175=0, n_52=0;
int n_50=0, n_179=0, n_55=0;
n_0 = (a >> 0) & 0x1;
n_1 = (a >> 1) & 0x1;
n_2 = (a >> 2) & 0x1;
n_3 = (a >> 3) & 0x1;
n_4 = (a >> 4) & 0x1;
n_5 = (a >> 5) & 0x1;
n_6 = (a >> 6) & 0x1;
n_7 = (a >> 7) & 0x1;
n_8 = (a >> 8) & 0x1;
n_9 = (a >> 9) & 0x1;
n_10 = (a >> 10) & 0x1;
n_11 = (a >> 11) & 0x1;
n_12 = (b >> 0) & 0x1;
n_13 = (b >> 1) & 0x1;
n_14 = (b >> 2) & 0x1;
n_15 = (b >> 3) & 0x1;
n_16 = (b >> 4) & 0x1;
n_17 = (b >> 5) & 0x1;
n_18 = (b >> 6) & 0x1;
n_19 = (b >> 7) & 0x1;
n_20 = (b >> 8) & 0x1;
n_21 = (b >> 9) & 0x1;
n_22 = (b >> 10) & 0x1;
n_23 = (b >> 11) & 0x1;
n_24 = ~(n_11 | n_21);
n_28 = n_24 & n_21;
n_32 = n_1 ^ n_13;
n_37 = n_1 & n_13;
n_41 = n_2 ^ n_14;
n_46 = n_2 & n_14;
n_50 = n_3 ^ n_15;
n_52 = ~(n_6 & n_28);
n_55 = n_3 & n_15;
n_59 = n_4 ^ n_16;
n_64 = n_4 & n_16;
n_68 = n_5 ^ n_17;
n_72 = n_5 & n_17;
n_77 = n_6 ^ n_18;
n_81 = n_6 & n_18;
n_86 = n_7 ^ n_19;
n_90 = n_7 & n_19;
n_95 = n_8 ^ n_20;
n_99 = n_8 & n_20;
n_104 = n_9 ^ n_21;
n_108 = n_9 & n_21;
n_112 = n_10 ^ n_22;
n_117 = n_10 & n_22;
n_121 = n_11 ^ n_23;
n_126 = n_11 & n_23;
n_135 = n_28 | n_37;
n_139 = n_2 & n_50;
n_148 = n_13 & n_50;
n_152 = n_14 & n_139;
n_157 = n_152 | n_55;
n_161 = n_157 & n_59;
n_166 = n_161 | n_64;
n_175 = n_13 & n_59;
n_179 = n_72 & n_77;
n_184 = n_179 | n_81;
n_188 = n_68 & n_77;
n_197 = n_179 | n_81;
n_201 = n_197 & n_86;
n_206 = n_201 | n_90;
n_215 = n_188 & n_86;
n_219 = n_99 & n_104;
n_224 = n_219 | n_108;
n_228 = n_95 & n_104;
n_237 = n_224;
n_241 = n_237 & n_112;
n_246 = n_241 | n_117;
n_255 = n_52 & n_112;
n_259 = n_37 & n_41;
n_264 = n_259 | n_46;
n_268 = n_259 & n_148;
n_272 = n_268 | n_157;
n_277 = n_268 & n_175;
n_281 = n_277 | n_166;
n_290 = n_277 | n_166;
n_295 = n_290 & n_68;
n_299 = n_295 | n_72;
n_312 = n_295 & n_188;
n_317 = n_312 | n_184;
n_330 = n_312 & n_215;
n_335 = n_330 | n_206;
n_339 = n_335 & n_95;
n_344 = n_339 | n_99;
n_348 = n_335 & n_228;
n_352 = n_348 | n_224;
n_357 = n_348 & n_255;
n_361 = n_357 | n_246;
n_366 = n_32;
n_370 = n_41 ^ n_135;
n_375 = n_50 ^ n_264;
n_379 = n_59 ^ n_272;
n_384 = n_68 ^ n_281;
n_388 = n_77 ^ n_299;
n_392 = n_86 ^ n_317;
n_397 = n_95 ^ n_335;
n_401 = n_104 ^ n_344;
n_406 = n_112 ^ n_352;
n_410 = n_121 ^ n_361;
n_415 = n_121 & n_361;
n_419 = n_126 | n_415;
o |= (n_52 & 0x01) << 0;
o |= (n_366 & 0x01) << 1;
o |= (n_370 & 0x01) << 2;
o |= (n_375 & 0x01) << 3;
o |= (n_379 & 0x01) << 4;
o |= (n_384 & 0x01) << 5;
o |= (n_388 & 0x01) << 6;
o |= (n_392 & 0x01) << 7;
o |= (n_397 & 0x01) << 8;
o |= (n_401 & 0x01) << 9;
o |= (n_406 & 0x01) << 10;
o |= (n_410 & 0x01) << 11;
o |= (n_419 & 0x01) << 12;
return o;
}
|
the_stack_data/51699147.c | #include <time.h>
#include <assert.h>
time_t mktime(struct tm* tm)
{
assert(!"mktime() not implemented!\n");
return 0;
} |
the_stack_data/68887275.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define IM1 2147483563
#define IM2 2147483399
#define AM (1.0/IM1)
#define IMM1 (IM1-1)
#define IA1 40014
#define IA2 40692
#define IQ1 53668
#define IQ2 52774
#define IR1 12211
#define IR2 3791
#define NTAB 32
#define NDIV (1+IMM1/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
/*C (C) Copr. 1986-92 Numerical Recipes Software #.3. */
float my_rand(idum)
int *idum;
{
int j;
long k;
static long idum2=123456789;
static long iy=0;
static long iv[NTAB];
float temp;
if (*idum <= 0) {
if (-(*idum) < 1) *idum=1;
else *idum = -(*idum);
idum2=(*idum);
for (j=NTAB+7;j>=0;j--) {
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
if (j < NTAB) iv[j] = *idum;
}
iy=iv[0];
}
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
k=idum2/IQ2;
idum2=IA2*(idum2-k*IQ2)-k*IR2;
if (idum2 < 0) idum2 += IM2;
j=iy/NDIV;
iy=iv[j]-idum2;
iv[j] = *idum;
if (iy < 1) iy += IMM1;
if ((temp=AM*iy) > RNMX) return RNMX;
else return temp;
}
#undef IM1
#undef IM2
#undef AM
#undef IMM1
#undef IA1
#undef IA2
#undef IQ1
#undef IQ2
#undef IR1
#undef IR2
#undef NTAB
#undef NDIV
#undef EPS
#undef RNMX |
the_stack_data/123846.c | //main() function file taking a number as an input.
#include<stdio.h>
main()
{
int num;
printf("Enter the number :");
scanf("%d",&num);
if(is_even(num))printf("%d is even",num);
else printf("%d is odd",num);
}
/*OUTPUT
Enter the number :2345
2345 is odd*/
|
the_stack_data/192329966.c | /* A Bison parser, made by GNU Bison 3.5.1. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
variables, as they might otherwise be expanded by user macros.
There are some unavoidable exceptions within include files to
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
/* Undocumented macros, especially those whose name start with YY_,
are private implementation details. Do not rely on them. */
/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "3.5.1"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 0
/* Push parsers. */
#define YYPUSH 0
/* Pull parsers. */
#define YYPULL 1
/* First part of user prologue. */
#line 1 "pronombre.y"
#include <stdio.h>
int yylex();
int yyerror (char *s);
#line 76 "pronombre.tab.c"
# ifndef YY_CAST
# ifdef __cplusplus
# define YY_CAST(Type, Val) static_cast<Type> (Val)
# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
# else
# define YY_CAST(Type, Val) ((Type) (Val))
# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
# endif
# endif
# ifndef YY_NULLPTR
# if defined __cplusplus
# if 201103L <= __cplusplus
# define YY_NULLPTR nullptr
# else
# define YY_NULLPTR 0
# endif
# else
# define YY_NULLPTR ((void*)0)
# endif
# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif
/* Use api.header.include to #include this header
instead of duplicating it here. */
#ifndef YY_YY_PRONOMBRE_TAB_H_INCLUDED
# define YY_YY_PRONOMBRE_TAB_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Token type. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
PRON = 258,
NL = 259
};
#endif
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
extern YYSTYPE yylval;
int yyparse (void);
#endif /* !YY_YY_PRONOMBRE_TAB_H_INCLUDED */
#ifdef short
# undef short
#endif
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
<limits.h> and (if available) <stdint.h> are included
so that the code can choose integer types of a good width. */
#ifndef __PTRDIFF_MAX__
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
# define YY_STDINT_H
# endif
#endif
/* Narrow types that promote to a signed type and that can represent a
signed or unsigned integer of at least N bits. In tables they can
save space and decrease cache pressure. Promoting to a signed type
helps avoid bugs in integer arithmetic. */
#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif
#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
&& UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
&& UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif
#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
# define YYPTRDIFF_T __PTRDIFF_TYPE__
# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
# ifndef ptrdiff_t
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# endif
# define YYPTRDIFF_T ptrdiff_t
# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
# define YYPTRDIFF_T long
# define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# define YYSIZE_T unsigned
# endif
#endif
#define YYSIZE_MAXIMUM \
YY_CAST (YYPTRDIFF_T, \
(YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
? YYPTRDIFF_MAXIMUM \
: YY_CAST (YYSIZE_T, -1)))
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
/* Stored state numbers (used for stacks). */
typedef yytype_int8 yy_state_t;
/* State numbers in computations. */
typedef int yy_state_fast_t;
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
# define YY_ATTRIBUTE_PURE
# endif
#endif
#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
# define YY_ATTRIBUTE_UNUSED
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif
#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END \
_Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif
#define YY_ASSERT(E) ((void) (0 && (E)))
#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
yy_state_t yyss_alloc;
YYSTYPE yyvs_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYPTRDIFF_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / YYSIZEOF (*yyptr); \
} \
while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
YYPTRDIFF_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 2
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 3
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 5
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 2
/* YYNRULES -- Number of rules. */
#define YYNRULES 3
/* YYNSTATES -- Number of states. */
#define YYNSTATES 5
#define YYUNDEFTOK 2
#define YYMAXUTOK 259
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, with out-of-bounds checking. */
#define YYTRANSLATE(YYX) \
(0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex. */
static const yytype_int8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4
};
#if YYDEBUG
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_int8 yyrline[] =
{
0, 10, 10, 11
};
#endif
#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "PRON", "NL", "$accept", "cadena", YY_NULLPTR
};
#endif
# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
(internal) symbol number NUM (which must be that of a token). */
static const yytype_int16 yytoknum[] =
{
0, 256, 257, 258, 259
};
# endif
#define YYPACT_NINF (-4)
#define yypact_value_is_default(Yyn) \
((Yyn) == YYPACT_NINF)
#define YYTABLE_NINF (-1)
#define yytable_value_is_error(Yyn) \
0
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
static const yytype_int8 yypact[] =
{
-4, 0, -4, -3, -4
};
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do. Zero
means the default is an error. */
static const yytype_int8 yydefact[] =
{
2, 0, 1, 0, 3
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int8 yypgoto[] =
{
-4, -4
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto[] =
{
-1, 1
};
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule whose
number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int8 yytable[] =
{
2, 4, 0, 3
};
static const yytype_int8 yycheck[] =
{
0, 4, -1, 3
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_int8 yystos[] =
{
0, 6, 0, 3, 4
};
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_int8 yyr1[] =
{
0, 5, 6, 6
};
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
static const yytype_int8 yyr2[] =
{
0, 2, 0, 3
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
/* Error token number */
#define YYTERROR 1
#define YYERRCODE 256
/* Enable debugging if requested. */
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
/* This macro is provided for backward compatibility. */
#ifndef YY_LOCATION_PRINT
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
/*-----------------------------------.
| Print this symbol's value on YYO. |
`-----------------------------------*/
static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
{
FILE *yyoutput = yyo;
YYUSE (yyoutput);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YYUSE (yytype);
YY_IGNORE_MAYBE_UNINITIALIZED_END
}
/*---------------------------.
| Print this symbol on YYO. |
`---------------------------*/
static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
{
YYFPRINTF (yyo, "%s %s (",
yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
yy_symbol_value_print (yyo, yytype, yyvaluep);
YYFPRINTF (yyo, ")");
}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
{
int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr,
yystos[+yyssp[yyi + 1 - yynrhs]],
&yyvsp[(yyi + 1) - (yynrhs)]
);
YYFPRINTF (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyssp, yyvsp, Rule); \
} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
#if YYERROR_VERBOSE
# ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
# else
/* Return the length of YYSTR. */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
YYPTRDIFF_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
# endif
# ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
# endif
# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result
would have been. */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
YYPTRDIFF_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
else
goto append;
append:
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
if (yyres)
return yystpcpy (yyres, yystr) - yyres;
else
return yystrlen (yystr);
}
# endif
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return 2 if the
required number of bytes is too large to store. */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
yy_state_t *yyssp, int yytoken)
{
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat: reported tokens (one for the "unexpected",
one per "expected"). */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Actual size of YYARG. */
int yycount = 0;
/* Cumulated lengths of YYARG. */
YYPTRDIFF_T yysize = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
if (yytoken != YYEMPTY)
{
int yyn = yypact[+*yyssp];
YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
yysize = yysize0;
yyarg[yycount++] = yytname[yytoken];
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
yysize = yysize0;
break;
}
yyarg[yycount++] = yytname[yyx];
{
YYPTRDIFF_T yysize1
= yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
yysize = yysize1;
else
return 2;
}
}
}
}
switch (yycount)
{
# define YYCASE_(N, S) \
case N: \
yyformat = S; \
break
default: /* Avoid compiler warnings. */
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
}
{
/* Don't count the "%s"s in the final size, but reserve room for
the terminator. */
YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
yysize = yysize1;
else
return 2;
}
if (*yymsg_alloc < yysize)
{
*yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
return 1;
}
/* Avoid sprintf, as that infringes on the user's name space.
Don't have undefined behavior even if the translation
produced a string with the wrong number of "%s"s. */
{
char *yyp = *yymsg;
int yyi = 0;
while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
yyp += yytnamerr (yyp, yyarg[yyi++]);
yyformat += 2;
}
else
{
++yyp;
++yyformat;
}
}
return 0;
}
#endif /* YYERROR_VERBOSE */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
{
YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YYUSE (yytype);
YY_IGNORE_MAYBE_UNINITIALIZED_END
}
/* The lookahead symbol. */
int yychar;
/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
/* Number of syntax errors so far. */
int yynerrs;
/*----------.
| yyparse. |
`----------*/
int
yyparse (void)
{
yy_state_fast_t yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
'yyss': related to states.
'yyvs': related to semantic values.
Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
yy_state_t yyssa[YYINITDEPTH];
yy_state_t *yyss;
yy_state_t *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
YYPTRDIFF_T yystacksize;
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
yyssp = yyss = yyssa;
yyvsp = yyvs = yyvsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
goto yysetstate;
/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate. |
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate. |
`--------------------------------------------------------------------*/
yysetstate:
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
YY_IGNORE_USELESS_CAST_BEGIN
*yyssp = YY_CAST (yy_state_t, yystate);
YY_IGNORE_USELESS_CAST_END
if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
goto yyexhaustedlab;
#else
{
/* Get the current used size of the three stacks, in elements. */
YYPTRDIFF_T yysize = yyssp - yyss + 1;
# if defined yyoverflow
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
yy_state_t *yyss1 = yyss;
YYSTYPE *yyvs1 = yyvs;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * YYSIZEOF (*yyssp),
&yyvs1, yysize * YYSIZEOF (*yyvsp),
&yystacksize);
yyss = yyss1;
yyvs = yyvs1;
}
# else /* defined YYSTACK_RELOCATE */
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yy_state_t *yyss1 = yyss;
union yyalloc *yyptr =
YY_CAST (union yyalloc *,
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
YY_IGNORE_USELESS_CAST_BEGIN
YYDPRINTF ((stderr, "Stack size increased to %ld\n",
YY_CAST (long, yystacksize)));
YY_IGNORE_USELESS_CAST_END
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
if (yystate == YYFINAL)
YYACCEPT;
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yypact_value_is_default (yyn))
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = yylex ();
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yytable_value_is_error (yyn))
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Discard the shifted token. */
yychar = YYEMPTY;
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
'$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
case 3:
#line 11 "pronombre.y"
{printf("Se imprime un texto \n");}
#line 1289 "pronombre.tab.c"
break;
#line 1293 "pronombre.tab.c"
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
incorrect destructor might then be invoked immediately. In the
case of YYERROR or YYBACKUP, subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated. */
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
/* Now 'shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
{
const int yylhs = yyr1[yyn] - YYNTOKENS;
const int yyi = yypgoto[yylhs] + *yyssp;
yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
? yytable[yyi]
: yydefgoto[yylhs]);
}
goto yynewstate;
/*--------------------------------------.
| yyerrlab -- here on detecting error. |
`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)
{
char const *yymsgp = YY_("syntax error");
int yysyntax_error_status;
yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0)
yymsgp = yymsg;
else if (yysyntax_error_status == 1)
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
if (!yymsg)
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = 2;
}
else
{
yysyntax_error_status = YYSYNTAX_ERROR;
yymsgp = yymsg;
}
}
yyerror (yymsgp);
if (yysyntax_error_status == 2)
goto yyexhaustedlab;
}
# undef YYSYNTAX_ERROR
#endif
}
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
}
}
/* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
/* Pacify compilers when the user code never invokes YYERROR and the
label yyerrorlab therefore never appears in user code. */
if (0)
YYERROR;
/* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
goto yyreturn;
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
goto yyreturn;
#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result. |
`-----------------------------------------------------*/
yyreturn:
if (yychar != YYEMPTY)
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
}
/* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[+*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
return yyresult;
}
#line 12 "pronombre.y"
int yyerror (char *s){
printf("Cadena invalida %s\n", s);
return 1;
}
int main(int argc, char **argv){
printf("Ingrese la cadena\n");
yyparse();
return 0;
}
|
the_stack_data/878616.c | #include <stdio.h>
int main()
{
int n, k;
float m;
scanf("%d", &n);
scanf("%f", &m);
scanf("%d", &k);
float sum = 0;
float discount = 0.0;
for(int i = 0; i < n; i += k)
{
sum += k * m * (1 - discount);
discount += 0.02;
}
printf("%.f", sum);
return 0;
}
|
the_stack_data/165767256.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
int main()
{
pid_t pid = 0;
int fds[2];
char buf[128];
int nwr = 0;
pipe(fds);
//在 fork()前执行
pid = fork();
if(pid < 0)
{
printf("Fork error!\n");
return -1;
}
else if(pid == 0)
{
printf("This is child process, pid = %d\n", getpid());
printf("Child:waiting for message...\n");
close(fds[1]);
//关闭写端 fds[1]
nwr = read(fds[0], buf, sizeof(buf));
//从读端 fds[0]读入数据
printf("Child:received\"%s\"\n", buf);
}
else
{
printf("This is parent process, pid = %d\n", getpid());
printf("Parent:sending message...\n");
close(fds[0]);
//关闭写端 fds[0]
strcpy(buf, "Message from parent!");
nwr = write(fds[1], buf, sizeof(buf));
//往写端 fds[1]写出数据
printf("Parent:send %d bytes to child.\n", nwr);
}
return 0;
} |
the_stack_data/117327761.c | #include <assert.h>
void test_int() {
volatile int a = 7;
volatile int result = __sync_fetch_and_xor(&a, 31);
assert(a == 24);
assert(result == 7);
}
void test_long() {
volatile long a = 7;
volatile long result = __sync_fetch_and_xor(&a, 31);
assert(a == 24);
assert(result == 7);
}
void test_longlong() {
volatile long long a = 7;
volatile long long result = __sync_fetch_and_xor(&a, 31);
assert(a == 24);
assert(result == 7);
}
int main() {
test_int();
test_long();
test_longlong();
return 0;
}
|
the_stack_data/991325.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2012-2017 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#define BUFSIZE 0x1000
static jmp_buf jmp;
void
infcall (void)
{
longjmp (jmp, 1); /* test-next */
}
static void
run1 (void)
{
char buf[BUFSIZE / 2];
int dummy = 0;
dummy++; /* break-run1 */
}
static char buf_zero[BUFSIZE];
static void
run2 (void)
{
char buf[BUFSIZE];
memset (buf, 0, sizeof (buf));
if (memcmp (buf, buf_zero, sizeof (buf)) != 0) /* break-run2 */
abort (); /* break-fail */
}
int
main ()
{
if (setjmp (jmp) == 0) /* test-pass */
infcall ();
if (setjmp (jmp) == 0) /* test-fail */
run1 ();
else
run2 ();
return 0; /* break-exit */
}
|
the_stack_data/898350.c | #include<stdio.h>
int main()
{
int a,i,b,temp,j;
scanf("%d%d", &a,&b);
int A[a],sum=0;
for(i=0;i<a;i++)
scanf("%d", &A[i]);
for(i=0;i<a;i++)
{
for(j=i;j<a;j++)
{
if(A[j]<A[i])
{
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}
}
for(i=0;i<a;i++)
{
printf("%d", A[i]);
sum+=A[i];
}
printf("\n%d", -sum);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.