file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/52658.c
|
#include <stdio.h>
int main(void)
{
int age;
float assets;
char pet[30];
printf("Enter your age, assets, and favorite pet.\n");
scanf("%d %f", &age, &assets);
scanf("%s", pet);
printf("age: %d, assets: %.2f, pet: %s\n", age, assets, pet);
return 0;
}
|
the_stack_data/868473.c
|
// C program to calculate the power using recursion
// Source code to calculate power of a number using recursion in C programming....
#include <stdio.h>
int power(int n1, int n2);
int main()
{
int base, powerRaised, result;
printf("Enter base number: ");
scanf("%d",&base);
printf("Enter power number(positive integer): ");
scanf("%d",&powerRaised);
result = power(base, powerRaised);
printf("%d^%d = %d", base, powerRaised, result);
return 0;
}
int power(int base, int powerRaised)
{
if (powerRaised != 0)
return (base*power(base, powerRaised-1));
else
return 1;
}
// https://www.programiz.com/c-programming/examples/power-recursion
|
the_stack_data/212641937.c
|
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <unistd.h>
/* I mostly wrote this to remind myself how to program in C, because I haven't
* done that in around a year. But also, because nobody else had an up-to-date
* and working factorio->JSON converter, and I needed one for my own project.
*/
//Note: cannot be 512k or smaller, has to accommodate the largest top-level-object.
#define CHUNK_SIZE 1024*1024*10
#define TMP_FILE_NAME "/tmp/fix_json_tmpfile"
//[a-zA-Z]
inline int isAlphabetical(char c)
{
if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '[') { return 1; }
return 0;
}//end isAlphabetical
//[0-9\-.]
inline int isNumber(char c)
{
if((c >= '0' && c <= '9') || c == '-' || c == '.') { return 1; }
return 0;
}//end isNumber
int findMatchingBrace(int open_brace, char *buf, int charsRead, int *is_double_brace)
{
int found_alphanum = 0;
int deeper_dbl_brace = 0;
int bracketed_field = 0;
int ret = 0;
//We have to find the close } first, and determine if there are any { in between
// which are also on the left-side of an =. We have to do this before anything
// else because there are some text fields intermixed within double-brace regions
//As for what happens to text in a double-brace? It's deleted. JSON doesn't support
// key-value pairs inside of object lists.
int depth = 0;
int am_right_of_equals = 0;
for(int i = open_brace+1; i < charsRead; ++i)
{
if(buf[i] == '{' && depth == 0 && !am_right_of_equals)
{
++depth;
*is_double_brace = 1;
break;
} else if(buf[i] == '{') { ++depth; }
else if(buf[i] == '}') {
--depth;
if(depth == 0) { am_right_of_equals = 0; }
}
else if(buf[i] == '=') { am_right_of_equals = 1; }
if(depth == -1) { break; }
}
for(int i = open_brace+1; i < charsRead; ++i)
{
if(buf[i] == '{')
{
ret = findMatchingBrace(i, buf, charsRead, &deeper_dbl_brace);
//need more data to find match
if(ret < 0) { return ret; }
//otherwise, ignore or replace
if(deeper_dbl_brace)
{
buf[i] = '[';
buf[ret] = ']';
deeper_dbl_brace = 0;
}
i = ret;
}
else if(buf[i] == '}') {
if(bracketed_field)
{
buf[open_brace] = '[';
buf[i] = ']';
}
//clean up any dangling ,
if(*is_double_brace)
{
for(int z = i-1; z >= 0; --z)
{
if(buf[z] == ',') { buf[z] = ' '; }
else if(buf[z] != ' ' && buf[z] != '\n') { break; }
}
}
return i;
}
else if(*is_double_brace && buf[i] != ' ' && buf[i] != ',' && buf[i] != '\n')
{
buf[i] = ' ';
if(buf[i+1] == ',') { buf[i+1] = ' '; }
}
else if(!found_alphanum) {
if(isAlphabetical(buf[i]))
{
found_alphanum = 1;
}
else if(isNumber(buf[i]) || buf[i] == '"')
{
found_alphanum = 1;
//fields containing just numbers get treated the same as double braces.
bracketed_field = 1;
}
}
}
return -1;
}//end findMatchingBrace
int handleBracketsAndBraces(char *buf, int charsRead)
{
int ret = 0;
int is_double_brace = 0;
int i = 0;
for(; i < charsRead; ++i)
{
if(buf[i] == '{')
{
ret = findMatchingBrace(i, buf, charsRead, &is_double_brace);
//<0 means we couldn't find matching }, need to read more from file.
if(ret < 0) { return i; }
else {
//otherwise ret is the position of the close brace, any intermediate
// braces were fixed along the way.
if(is_double_brace)
{
buf[i] = '[';
buf[ret] = '[';
is_double_brace = 0;
}
i = ret;
}
}
}
return i;
}//end handleBracketsAndBraces
void sumTimeDiff(struct timeval *start, struct timeval *end, int *seconds, int *millis)
{
int seconds_end = end->tv_sec*1000000 + end->tv_usec;
int seconds_start = start->tv_sec*1000000 + start->tv_usec;
int tmp_seconds = (seconds_end - seconds_start)/1000000;
int tmp_micros = (seconds_end - seconds_start) - tmp_seconds*1000000;
int full_value_time = ((*seconds + tmp_seconds)*1000000) + tmp_micros + *millis*1000;
*seconds = full_value_time / 1000000;
*millis = (full_value_time - (*seconds*1000000))/1000;
}//end sumTimeDiff
int main(int argc, char **argv)
{
if(argc < 2)
{
printf("%s <input file>\n",argv[0]);
exit(1);
}
struct timeval start, end;
int sed_seconds = 0, sed_millis = 0;
int prog_seconds = 0, prog_millis = 0;
int ret = 0;
gettimeofday(&start, NULL);
//Read buffer
char *buffer = (char*)malloc(CHUNK_SIZE);
if(buffer == NULL)
{
exit(7);
}
//open input file
int infile = open(argv[1],O_RDONLY);
if(infile < 0){
exit(6);
}
//copy input file to tmp location
int charsRead = read(infile,buffer,CHUNK_SIZE);
int charsWritten = 0;
int outfile = open(TMP_FILE_NAME,O_CREAT|O_WRONLY|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
while(charsRead > 0)
{
ret = write(outfile,buffer+charsWritten,charsRead);
if(ret != charsRead && charsRead > 0)
{
charsWritten = ret;
charsRead = charsRead - ret;
} else {
charsRead = read(infile,buffer,CHUNK_SIZE);
charsWritten = 0;
}
}
close(infile);
close(outfile);
gettimeofday(&end, NULL);
sumTimeDiff(&start,&end,&prog_seconds,&prog_millis);
gettimeofday(&start, NULL);
//Nils are cancer. We must squash them first.
int status = 0;
pid_t pid = fork();
if(pid == -1) { exit(17); }
else if(pid > 0) {
int status;
waitpid(pid, &status, 0);
} else {
execl("/bin/sed","sed","-i","-E","-e","s/\\bnil\\b/\"nil\"/g", TMP_FILE_NAME, NULL);
return 0;
}
gettimeofday(&end, NULL);
sumTimeDiff(&start,&end,&sed_seconds,&sed_millis);
gettimeofday(&start, NULL);
//close original input file, re-open modified input file
infile = open(TMP_FILE_NAME,O_RDONLY);
if(infile < 0){
exit(6);
}
int outflen = snprintf(NULL,0,"%s.json",argv[1]);
++outflen;
char *tmp = (char*)malloc(outflen);
snprintf(tmp,outflen,"%s.json",argv[1]);
outfile = open(tmp,O_CREAT|O_WRONLY|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if(outfile < 0){
exit(6);
}
charsRead = read(infile, buffer, CHUNK_SIZE);
//skip over any data before the first {
for(int i = 0; i < charsRead; ++i)
{
if(buffer[i] == '{')
{
//Write out the first { to make the rest of the program logic cleaner.
ret = write(outfile,"{",1);
if(ret != 1) { exit(12); }
//overwrite bogus data at start.
memcpy(buffer,buffer+i+1, charsRead - i - 1);
charsRead = charsRead - i - 1;
break;
}
}
int carryover_chars = 0;
while(charsRead > 0)
{
carryover_chars = charsRead - handleBracketsAndBraces(buffer, charsRead);
//Flush corrected data
ret = write(outfile,buffer,charsRead - carryover_chars);
if(ret != charsRead - carryover_chars)
{
exit(11);
}
//Move data that still needs to be processed to the start of the buffer.
memcpy(buffer,buffer+charsRead - carryover_chars, carryover_chars);
//Fill in remaining buffer slots with new data
charsRead = read(infile,buffer+carryover_chars,CHUNK_SIZE - carryover_chars);
charsRead += carryover_chars - 1;
}
free(buffer);
close(infile);
close(outfile);
gettimeofday(&end, NULL);
sumTimeDiff(&start,&end,&prog_seconds,&prog_millis);
gettimeofday(&start, NULL);
printf("Bracket replacement completed in %d seconds and %d milliseconds. Starting sed.\n",prog_seconds,prog_millis);
//We use regex to fix a few of the more annoying problems
//1. Replacing nil with "nil"
//2. Replacing '<something> =' with '"<something>":'
//3. Replacing ["hyphen-word"] with "hyphen-word": (note: this one actually takes two passes,
// and there's an interaction between rules 2 and 3 to get this desired outcome.
//Most of the runtime of this program is this command. Sed's fast, but we've asked it to do a lot!
status = 0;
pid = fork();
if(pid == -1) { exit(17); }
else if(pid > 0) {
int status;
waitpid(pid, &status, 0);
} else {
execl("/bin/sed","sed","-i","-E","-e","/math.huge/d","-e","s/\\[\"(.+?)\"\\]/\\1/g","-e","s/([^ \t]*) =/\"\\1\":/g", tmp, NULL);
return 0;
}
gettimeofday(&end, NULL);
sumTimeDiff(&start,&end,&sed_seconds,&sed_millis);
printf("Sed took %d seconds and %d milliseconds.\n",sed_seconds,sed_millis);
free(tmp);
ret = remove(TMP_FILE_NAME);
return 0;
}
|
the_stack_data/150141930.c
|
/* { dg-do compile { target int128 } } */
/* { dg-options "-O2 -msse2 -mtune=core2 -dp" } */
extern __int128 a;
struct foo
{
__int128 i;
}__attribute__ ((packed));
extern struct foo x;
void
foo (void)
{
a = x.i;
}
/* { dg-final { scan-assembler-not "movv1ti_internal" } } */
|
the_stack_data/150143528.c
|
// WARNING: locking bug in look_up_lock_class
// https://syzkaller.appspot.com/bug?id=6f1ba503a51f62863065403077e0c081b556b0b6
// status:invalid
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/futex.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>
unsigned long long procid;
static __thread int skip_segv;
static __thread jmp_buf segv_env;
static void segv_handler(int sig, siginfo_t* info, void* ctx)
{
uintptr_t addr = (uintptr_t)info->si_addr;
const uintptr_t prog_start = 1 << 20;
const uintptr_t prog_end = 100 << 20;
if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
(addr < prog_start || addr > prog_end)) {
_longjmp(segv_env, 1);
}
exit(sig);
}
static void install_segv_handler(void)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = segv_handler;
sa.sa_flags = SA_NODEFER | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
}
#define NONFAILING(...) \
{ \
__atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \
if (_setjmp(segv_env) == 0) { \
__VA_ARGS__; \
} \
__atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \
}
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static void use_temporary_dir(void)
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
exit(1);
if (chmod(tmpdir, 0777))
exit(1);
if (chdir(tmpdir))
exit(1);
}
static void thread_start(void* (*fn)(void*), void* arg)
{
pthread_t th;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
int i;
for (i = 0; i < 100; i++) {
if (pthread_create(&th, &attr, fn, arg) == 0) {
pthread_attr_destroy(&attr);
return;
}
if (errno == EAGAIN) {
usleep(50);
continue;
}
break;
}
exit(1);
}
typedef struct {
int state;
} event_t;
static void event_init(event_t* ev)
{
ev->state = 0;
}
static void event_reset(event_t* ev)
{
ev->state = 0;
}
static void event_set(event_t* ev)
{
if (ev->state)
exit(1);
__atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG);
}
static void event_wait(event_t* ev)
{
while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}
static int event_isset(event_t* ev)
{
return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}
static int event_timedwait(event_t* ev, uint64_t timeout)
{
uint64_t start = current_time_ms();
uint64_t now = start;
for (;;) {
uint64_t remain = timeout - (now - start);
struct timespec ts;
ts.tv_sec = remain / 1000;
ts.tv_nsec = (remain % 1000) * 1000 * 1000;
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
if (__atomic_load_n(&ev->state, __ATOMIC_RELAXED))
return 1;
now = current_time_ms();
if (now - start > timeout)
return 0;
}
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static struct {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
} nlmsg;
static void netlink_init(int typ, int flags, const void* data, int size)
{
memset(&nlmsg, 0, sizeof(nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg.pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(int typ, const void* data, int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg.pos += NLMSG_ALIGN(attr->nla_len);
}
static void netlink_nest(int typ)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_type = typ;
nlmsg.pos += sizeof(*attr);
nlmsg.nested[nlmsg.nesting++] = attr;
}
static void netlink_done(void)
{
struct nlattr* attr = nlmsg.nested[--nlmsg.nesting];
attr->nla_len = nlmsg.pos - (char*)attr;
}
static int netlink_send(int sock)
{
if (nlmsg.pos > nlmsg.buf + sizeof(nlmsg.buf) || nlmsg.nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_len = nlmsg.pos - nlmsg.buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg.buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg.buf, sizeof(nlmsg.buf), 0);
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static void netlink_add_device_impl(const char* type, const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
if (name)
netlink_attr(IFLA_IFNAME, name, strlen(name));
netlink_nest(IFLA_LINKINFO);
netlink_attr(IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(int sock, const char* type, const char* name)
{
netlink_add_device_impl(type, name);
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_veth(int sock, const char* name, const char* peer)
{
netlink_add_device_impl("veth", name);
netlink_nest(IFLA_INFO_DATA);
netlink_nest(VETH_INFO_PEER);
nlmsg.pos += sizeof(struct ifinfomsg);
netlink_attr(IFLA_IFNAME, peer, strlen(peer));
netlink_done();
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_hsr(int sock, const char* name, const char* slave1,
const char* slave2)
{
netlink_add_device_impl("hsr", name);
netlink_nest(IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_device_change(int sock, const char* name, bool up,
const char* master, const void* mac,
int macsize)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
netlink_init(RTM_NEWLINK, 0, &hdr, sizeof(hdr));
netlink_attr(IFLA_IFNAME, name, strlen(name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(IFLA_ADDRESS, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int netlink_add_addr(int sock, const char* dev, const void* addr,
int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, sizeof(hdr));
netlink_attr(IFA_LOCAL, addr, addrsize);
netlink_attr(IFA_ADDRESS, addr, addrsize);
return netlink_send(sock);
}
static void netlink_add_addr4(int sock, const char* dev, const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(int sock, const char* dev, const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(int sock, const char* name, const void* addr,
int addrsize, const void* mac, int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
netlink_attr(NDA_DST, addr, addrsize);
netlink_attr(NDA_LLADDR, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int tunfd = -1;
static int tun_frags_enabled;
#define SYZ_TUN_MAX_PACKET_SIZE 1000
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
#define IFF_NAPI_FRAGS 0x0020
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_NAPI | IFF_NAPI_FRAGS;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0)
exit(1);
}
if (ioctl(tunfd, TUNGETIFF, (void*)&ifr) < 0)
exit(1);
tun_frags_enabled = (ifr.ifr_flags & IFF_NAPI_FRAGS) != 0;
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(sock, TUN_IFACE, &in_addr, sizeof(in_addr), &macaddr,
ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(sock, TUN_IFACE, &in6_addr, sizeof(in6_addr), &macaddr,
ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN);
close(sock);
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa
static void initialize_netdevices(void)
{
char netdevsim[16];
sprintf(netdevsim, "netdevsim%d", (int)procid);
struct {
const char* type;
const char* dev;
} devtypes[] = {
{"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
{"vcan", "vcan0"}, {"bond", "bond0"},
{"team", "team0"}, {"dummy", "dummy0"},
{"nlmon", "nlmon0"}, {"caif", "caif0"},
{"batadv", "batadv0"}, {"vxcan", "vxcan1"},
{"netdevsim", netdevsim}, {"veth", 0},
};
const char* devmasters[] = {"bridge", "bond", "team"};
struct {
const char* name;
int macsize;
bool noipv6;
} devices[] = {
{"lo", ETH_ALEN},
{"sit0", 0},
{"bridge0", ETH_ALEN},
{"vcan0", 0, true},
{"tunl0", 0},
{"gre0", 0},
{"gretap0", ETH_ALEN},
{"ip_vti0", 0},
{"ip6_vti0", 0},
{"ip6tnl0", 0},
{"ip6gre0", 0},
{"ip6gretap0", ETH_ALEN},
{"erspan0", ETH_ALEN},
{"bond0", ETH_ALEN},
{"veth0", ETH_ALEN},
{"veth1", ETH_ALEN},
{"team0", ETH_ALEN},
{"veth0_to_bridge", ETH_ALEN},
{"veth1_to_bridge", ETH_ALEN},
{"veth0_to_bond", ETH_ALEN},
{"veth1_to_bond", ETH_ALEN},
{"veth0_to_team", ETH_ALEN},
{"veth1_to_team", ETH_ALEN},
{"veth0_to_hsr", ETH_ALEN},
{"veth1_to_hsr", ETH_ALEN},
{"hsr0", 0},
{"dummy0", ETH_ALEN},
{"nlmon0", 0},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
};
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
netlink_add_device(sock, devtypes[i].type, devtypes[i].dev);
for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
sprintf(slave0, "%s_slave_0", devmasters[i]);
sprintf(veth0, "veth0_to_%s", devmasters[i]);
netlink_add_veth(sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(sock, slave0, false, master, 0, 0);
netlink_device_change(sock, slave1, false, master, 0, 0);
}
netlink_device_change(sock, "bridge_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "bridge_slave_1", true, 0, 0, 0);
netlink_add_veth(sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(sock, "hsr_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "hsr_slave_1", true, 0, 0, 0);
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize);
}
close(sock);
}
static void initialize_netdevices_init(void)
{
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
struct {
const char* type;
int macsize;
bool noipv6;
bool noup;
} devtypes[] = {
{"nr", 7, true},
{"rose", 5, true, true},
};
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
char dev[32], addr[32];
sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
netlink_add_addr4(sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
netlink_add_addr6(sock, dev, addr);
}
int macsize = devtypes[i].macsize;
uint64_t macaddr = 0xbbbbbb +
((unsigned long long)i << (8 * (macsize - 2))) +
(procid << (8 * (macsize - 1)));
netlink_device_change(sock, dev, !devtypes[i].noup, 0, &macaddr, macsize);
}
close(sock);
}
static int read_tun(char* data, int size)
{
if (tunfd < 0)
return -1;
int rv = read(tunfd, data, size);
if (rv < 0) {
if (errno == EAGAIN)
return -1;
if (errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[SYZ_TUN_MAX_PACKET_SIZE];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10
struct xt_counters {
uint64_t pcnt, bcnt;
};
struct ipt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_entries;
unsigned int size;
};
struct ipt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct ipt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct ipt_table_desc {
const char* name;
struct ipt_getinfo info;
struct ipt_replace replace;
};
static struct ipt_table_desc ipv4_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
static struct ipt_table_desc ipv6_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)
struct arpt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_entries;
unsigned int size;
};
struct arpt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct arpt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct arpt_table_desc {
const char* name;
struct arpt_getinfo info;
struct arpt_replace replace;
};
static struct arpt_table_desc arpt_tables[] = {
{.name = "filter"},
};
#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)
static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct ipt_get_entries entries;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct ipt_get_entries entries;
struct ipt_getinfo info;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_arptables(void)
{
struct arpt_get_entries entries;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_arptables()
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct arpt_get_entries entries;
struct arpt_getinfo info;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
} else {
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
#define NF_BR_NUMHOOKS 6
#define EBT_TABLE_MAXNAMELEN 32
#define EBT_CHAIN_MAXNAMELEN 32
#define EBT_BASE_CTL 128
#define EBT_SO_SET_ENTRIES (EBT_BASE_CTL)
#define EBT_SO_GET_INFO (EBT_BASE_CTL)
#define EBT_SO_GET_ENTRIES (EBT_SO_GET_INFO + 1)
#define EBT_SO_GET_INIT_INFO (EBT_SO_GET_ENTRIES + 1)
#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO + 1)
struct ebt_replace {
char name[EBT_TABLE_MAXNAMELEN];
unsigned int valid_hooks;
unsigned int nentries;
unsigned int entries_size;
struct ebt_entries* hook_entry[NF_BR_NUMHOOKS];
unsigned int num_counters;
struct ebt_counter* counters;
char* entries;
};
struct ebt_entries {
unsigned int distinguisher;
char name[EBT_CHAIN_MAXNAMELEN];
unsigned int counter_offset;
int policy;
unsigned int nentries;
char data[0] __attribute__((aligned(__alignof__(struct ebt_replace))));
};
struct ebt_table_desc {
const char* name;
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
};
static struct ebt_table_desc ebt_tables[] = {
{.name = "filter"},
{.name = "nat"},
{.name = "broute"},
};
static void checkpoint_ebtables(void)
{
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
strcpy(table->replace.name, table->name);
optlen = sizeof(table->replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_INFO, &table->replace,
&optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->replace.entries_size > sizeof(table->entrytable))
exit(1);
table->replace.num_counters = 0;
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_ENTRIES, &table->replace,
&optlen))
exit(1);
}
close(fd);
}
static void reset_ebtables()
{
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
socklen_t optlen;
unsigned i, j, h;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
if (table->replace.valid_hooks == 0)
continue;
memset(&replace, 0, sizeof(replace));
strcpy(replace.name, table->name);
optlen = sizeof(replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
exit(1);
replace.num_counters = 0;
table->replace.entries = 0;
for (h = 0; h < NF_BR_NUMHOOKS; h++)
table->replace.hook_entry[h] = 0;
if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
memset(&entrytable, 0, sizeof(entrytable));
replace.entries = entrytable;
optlen = sizeof(replace) + replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_ENTRIES, &replace, &optlen))
exit(1);
if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
continue;
}
for (j = 0, h = 0; h < NF_BR_NUMHOOKS; h++) {
if (table->replace.valid_hooks & (1 << h)) {
table->replace.hook_entry[h] =
(struct ebt_entries*)table->entrytable + j;
j++;
}
}
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_net_namespace(void)
{
checkpoint_ebtables();
checkpoint_arptables();
checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void reset_net_namespace(void)
{
reset_ebtables();
reset_arptables();
reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void setup_cgroups()
{
if (mkdir("/syzcgroup", 0777)) {
}
if (mkdir("/syzcgroup/unified", 0777)) {
}
if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
}
if (chmod("/syzcgroup/unified", 0777)) {
}
write_file("/syzcgroup/unified/cgroup.subtree_control",
"+cpu +memory +io +pids +rdma");
if (mkdir("/syzcgroup/cpu", 0777)) {
}
if (mount("none", "/syzcgroup/cpu", "cgroup", 0,
"cpuset,cpuacct,perf_event,hugetlb")) {
}
write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
if (chmod("/syzcgroup/cpu", 0777)) {
}
if (mkdir("/syzcgroup/net", 0777)) {
}
if (mount("none", "/syzcgroup/net", "cgroup", 0,
"net_cls,net_prio,devices,freezer")) {
}
if (chmod("/syzcgroup/net", 0777)) {
}
}
static void setup_cgroups_loop()
{
int pid = getpid();
char file[128];
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/pids.max", cgroupdir);
write_file(file, "32");
snprintf(file, sizeof(file), "%s/memory.low", cgroupdir);
write_file(file, "%d", 298 << 20);
snprintf(file, sizeof(file), "%s/memory.high", cgroupdir);
write_file(file, "%d", 299 << 20);
snprintf(file, sizeof(file), "%s/memory.max", cgroupdir);
write_file(file, "%d", 300 << 20);
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
}
static void setup_cgroups_test()
{
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.cpu")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.net")) {
}
}
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
setup_cgroups();
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = (200 << 20);
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
initialize_netdevices();
loop();
exit(1);
}
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
DIR* dp;
struct dirent* ep;
int iter = 0;
retry:
while (umount2(dir, MNT_DETACH) == 0) {
}
dp = opendir(dir);
if (dp == NULL) {
if (errno == EMFILE) {
exit(1);
}
exit(1);
}
while ((ep = readdir(dp))) {
if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
continue;
char filename[FILENAME_MAX];
snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
while (umount2(filename, MNT_DETACH) == 0) {
}
struct stat st;
if (lstat(filename, &st))
exit(1);
if (S_ISDIR(st.st_mode)) {
remove_dir(filename);
continue;
}
int i;
for (i = 0;; i++) {
if (unlink(filename) == 0)
break;
if (errno == EPERM) {
int fd = open(filename, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno != EBUSY || i > 100)
exit(1);
if (umount2(filename, MNT_DETACH))
exit(1);
}
}
closedir(dp);
int i;
for (i = 0;; i++) {
if (rmdir(dir) == 0)
break;
if (i < 100) {
if (errno == EPERM) {
int fd = open(dir, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno == EBUSY) {
if (umount2(dir, MNT_DETACH))
exit(1);
continue;
}
if (errno == ENOTEMPTY) {
if (iter < 100) {
iter++;
goto retry;
}
}
}
exit(1);
}
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_loop()
{
setup_cgroups_loop();
checkpoint_net_namespace();
}
static void reset_loop()
{
reset_net_namespace();
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setup_cgroups_test();
write_file("/proc/self/oom_score_adj", "1000");
flush_tun();
}
static void close_fds()
{
int fd;
for (fd = 3; fd < 30; fd++)
close(fd);
}
static void setup_binfmt_misc()
{
if (mount(0, "/proc/sys/fs/binfmt_misc", "binfmt_misc", 0, 0)) {
}
write_file("/proc/sys/fs/binfmt_misc/register", ":syz0:M:0:\x01::./file0:");
write_file("/proc/sys/fs/binfmt_misc/register",
":syz1:M:1:\x02::./file0:POC");
}
struct thread_t {
int created, call;
event_t ready, done;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
event_wait(&th->ready);
event_reset(&th->ready);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
event_set(&th->done);
}
return 0;
}
static void execute_one(void)
{
int i, call, thread;
int collide = 0;
again:
for (call = 0; call < 7; call++) {
for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
event_init(&th->ready);
event_init(&th->done);
event_set(&th->done);
thread_start(thr, th);
}
if (!event_isset(&th->done))
continue;
event_reset(&th->done);
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
event_set(&th->ready);
if (collide && (call % 2) == 0)
break;
event_timedwait(&th->done, 45);
break;
}
}
for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
sleep_ms(1);
close_fds();
if (!collide) {
collide = 1;
goto again;
}
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
setup_loop();
int iter;
for (iter = 0;; iter++) {
char cwdbuf[32];
sprintf(cwdbuf, "./%d", iter);
if (mkdir(cwdbuf, 0777))
exit(1);
reset_loop();
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
if (chdir(cwdbuf))
exit(1);
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
remove_dir(cwdbuf);
}
}
uint64_t r[3] = {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff};
void execute_call(int call)
{
intptr_t res;
switch (call) {
case 0:
res = syscall(__NR_socket, 0x10, 3, 6);
if (res != -1)
r[0] = res;
break;
case 1:
res = syscall(__NR_socket, 0xa, 2, 0);
if (res != -1)
r[1] = res;
break;
case 2:
syscall(__NR_setsockopt, r[0], 0x10e, 1, 0, 0);
break;
case 3:
syscall(__NR_connect, r[1], 0, 0);
break;
case 4:
res = syscall(__NR_socket, 0x18, 1, 1);
if (res != -1)
r[2] = res;
break;
case 5:
NONFAILING(*(uint16_t*)0x20000040 = 0x18);
NONFAILING(*(uint32_t*)0x20000042 = 1);
NONFAILING(*(uint32_t*)0x20000046 = 0);
NONFAILING(*(uint32_t*)0x2000004a = r[1]);
NONFAILING(*(uint16_t*)0x2000004e = 2);
NONFAILING(*(uint16_t*)0x20000050 = htobe16(0));
NONFAILING(*(uint32_t*)0x20000052 = htobe32(0xe0000002));
NONFAILING(*(uint32_t*)0x2000005e = 4);
NONFAILING(*(uint32_t*)0x20000062 = 0);
NONFAILING(*(uint32_t*)0x20000066 = 0);
NONFAILING(*(uint32_t*)0x2000006a = 0);
syscall(__NR_connect, r[2], 0x20000040, 0x2e);
break;
case 6:
syscall(__NR_setsockopt, r[1], 0x29, 0x23, 0, 0);
break;
}
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
setup_binfmt_misc();
install_segv_handler();
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
use_temporary_dir();
do_sandbox_none();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/40763342.c
|
/*
* Copyright (C) 2015-2018 Alibaba Group Holding Limited
*/
#if defined(AWSS_SUPPORT_ADHA) || defined(AWSS_SUPPORT_AHA)
#include <stdio.h>
#include <stdint.h>
#include "os.h"
#include "awss.h"
#include "awss_log.h"
#include "awss_timer.h"
#include "awss_adha.h"
#include "awss_statis.h"
#include "awss_aplist.h"
#include "zconfig_lib.h"
#include "zconfig_protocol.h"
#include "zconfig_ieee80211.h"
#if defined(__cplusplus) /* If this is a C++ compiler, use C linkage */
extern "C" {
#endif
struct adha_info *adha_aplist = NULL;
const char *zc_adha_ssid = "adha";
const char *zc_adha_passwd = "08d9f22c60157fd01f57645d791a0b610fe0a558c104d6a1f9d9c0a9913c";
#ifdef AWSS_SUPPORT_ADHA
#define ADHA_WORK_CYCLE (5 * 1000)
#define ADHA_PROBE_PKT_LEN (50)
#define ADHA_SA_OFFSET (10)
static const uint8_t adha_probe_req_frame[ADHA_PROBE_PKT_LEN] = {
0x40, 0x00, /* mgnt type, frame control */
0x00, 0x00, /* duration */
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* DA */
0x28, 0xC2, 0xDD, 0x61, 0x68, 0x83, /* SA, to be replaced with wifi mac */
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* BSSID */
0xC0, 0x79, /* seq */
0x00, 0x04, 0x61, 0x64, 0x68, 0x61, /* ssid, adha */
0x01, 0x08, 0x82, 0x84, 0x8B, 0x96, 0x8C, 0x92, 0x98, 0xA4, /* supported rates */
0x32, 0x04, 0xB0, 0x48, 0x60, 0x6C, /* extended supported rates */
0x3F, 0x84, 0x10, 0x9E /* FCS */
};
static void *adha_timer = NULL;
static volatile char adha_switch = 0;
static void adha_monitor(void);
static void adha_monitor(void)
{
adha_switch = 1;
}
int awss_is_ready_switch_next_adha(void)
{
return adha_switch > 0;
}
int awss_open_adha_monitor(void)
{
adha_switch = 0;
if (adha_timer == NULL) {
adha_timer = (void *)HAL_Timer_Create("adha", (void (*)(void *))adha_monitor, NULL);
}
if (adha_timer == NULL) {
return -1;
}
HAL_Timer_Stop(adha_timer);
HAL_Timer_Start(adha_timer, ADHA_WORK_CYCLE);
return 0;
}
int awss_close_adha_monitor(void)
{
awss_stop_timer(adha_timer);
adha_timer = NULL;
adha_switch = 0;
return 0;
}
int awss_recv_callback_adha_ssid(struct parser_res *res)
{
uint8_t tods = res->tods;
uint8_t channel = res->channel;
AWSS_UPDATE_STATIS(AWSS_STATIS_ROUTE_IDX, AWSS_STATIS_TYPE_TIME_START);
awss_debug("found adha ssid: %s\r\n", zc_adha_ssid);
strncpy((char *)zc_ssid, zc_adha_ssid, ZC_MAX_SSID_LEN - 1);
strncpy((char *)zc_passwd, zc_adha_passwd, ZC_MAX_PASSWD_LEN - 1);
zconfig_set_state(STATE_RCV_DONE, tods, channel);
return PKG_END;
}
int aws_send_adha_probe_req(void)
{
uint8_t probe[ADHA_PROBE_PKT_LEN];
memcpy(probe, adha_probe_req_frame, sizeof(probe));
os_wifi_get_mac(&probe[ADHA_SA_OFFSET]);
os_wifi_send_80211_raw_frame(FRAME_PROBE_REQ, probe, sizeof(probe));
return 0;
}
int awss_ieee80211_adha_process(uint8_t *mgmt_header, int len, int link_type, struct parser_res *res, signed char rssi)
{
uint8_t ssid[ZC_MAX_SSID_LEN] = {0}, bssid[ETH_ALEN] = {0};
uint8_t auth, pairwise_cipher, group_cipher;
struct ieee80211_hdr *hdr;
int fc, ret, channel;
/*
* when device try to connect current router (include adha and aha)
* skip the new aha and process the new aha in the next scope.
*/
if (mgmt_header == NULL || zconfig_finished) {
return ALINK_INVALID;
}
/*
* if user press configure button, drop all adha
*/
if (awss_get_config_press()) {
return ALINK_INVALID;
}
hdr = (struct ieee80211_hdr *)mgmt_header;
fc = hdr->frame_control;
if (!ieee80211_is_beacon(fc) && !ieee80211_is_probe_resp(fc)) {
return ALINK_INVALID;
}
ret = ieee80211_get_bssid(mgmt_header, bssid);
if (ret < 0) {
return ALINK_INVALID;
}
ret = ieee80211_get_ssid(mgmt_header, len, ssid);
if (ret < 0) {
return ALINK_INVALID;
}
/*
* skip ap which is not adha
*/
if (strcmp((const char *)ssid, zc_adha_ssid)) {
return ALINK_INVALID;
}
channel = cfg80211_get_bss_channel(mgmt_header, len);
rssi = rssi > 0 ? rssi - 256 : rssi;
cfg80211_get_cipher_info(mgmt_header, len, &auth,
&pairwise_cipher, &group_cipher);
#ifdef AWSS_SUPPORT_APLIST
awss_save_apinfo(ssid, bssid, channel, auth,
pairwise_cipher, group_cipher, rssi);
#endif
/*
* If user press the configure button,
* skip all the adha.
*/
if (adha_aplist->cnt > adha_aplist->try_idx) {
uint8_t ap_idx = adha_aplist->aplist[adha_aplist->try_idx ++];
#ifdef AWSS_SUPPORT_APLIST
memcpy(zc_bssid, zconfig_aplist[ap_idx].mac, ETH_ALEN);
#endif
return ALINK_ADHA_SSID;
}
return ALINK_INVALID;
}
#endif
int awss_init_adha_aplist(void)
{
if (adha_aplist) {
return 0;
}
adha_aplist = (struct adha_info *)awss_zalloc(sizeof(struct adha_info));
if (adha_aplist == NULL) {
return -1;
}
return 0;
}
int awss_deinit_adha_aplist(void)
{
if (adha_aplist == NULL) {
return 0;
}
awss_free(adha_aplist);
adha_aplist = NULL;
return 0;
}
#if defined(__cplusplus) /* If this is a C++ compiler, use C linkage */
}
#endif
#endif
|
the_stack_data/23575780.c
|
/* This testcase is part of GDB, the GNU debugger.
Copyright 2005-2021 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 <stdio.h>
volatile int cond_hit;
int
cond (void)
{
cond_hit++;
return 1;
}
int
func (void)
{
return 0; /* in-func */
}
int
main (void)
{
/* Variable is used so that there is always at least one instruction on the
same line after FUNC returns. */
int i = func (); /* call-func */
/* Dummy calls. */
cond ();
func ();
return 0;
}
|
the_stack_data/1047617.c
|
#include <stdio.h>
int tamanio(char *s){
int cont = 0;
while(*s != '\0'){
cont++;
s++;
}
return cont;
}
void intercambia(char n[], char m[]){
int aux;
aux = *n;
*n = *m;
*m = aux;
}
void voltea(char a[100]){
int i, n = tamanio(a);
for(i=0, n= n-1; i<n; i++, n--){
intercambia(&a[i],&a[n]);
}
}
int buscar(char a[100], char b[100][100],int n,int m){
int i,j,k, t=tamanio(a), contador;
for(k=0;k<n;k++){
for(i=0;i<m-t+1;i++){
for(j=0, contador=0;j<t;j++){
if(a[j]==b[k][j+i])
contador++;
}
if(contador==t)
return 1;
}
}
for(k=0;k<m;k++){
for(i=0;i<n-t+1;i++){
for(j=0, contador=0;j<t;j++){
if(a[j]==b[j+i][k])
contador++;
}
if(contador==t)
return 1;
}
}
return 0;
}
int main (){
char p[100][100], s[100];
int i,n,m,q,r[1000];
scanf("%d%d", &n,&m);
for(i = 0; i < n; i++){
scanf("%s", &p[i]);
}
scanf("%d",&q);
for(i=0;i<q;i++){
scanf("%s",s);
r[i]=buscar(s,p,n,m);
if(r[i]==0){
voltea(s);
r[i]=buscar(s,p,n,m);
}
}
for(i=0;i<q;i++){
if(r[i]==0){
printf("no\n");
}else{
printf("si\n");
}
}
return 0;
}
|
the_stack_data/38002.c
|
#include <stdio.h>
#include <stdlib.h>
static void toto(void)
{
(void)printf("%s\n", "Je suis dans toto()");
}
static void tutu(void)
{
(void)printf("%s\n", "Je suis dans tutu()");
}
int main(void)
{
toto();
tutu();
exit(EXIT_SUCCESS);
}
|
the_stack_data/97840.c
|
/*
********************************************************************************
* Copyright (C) 2005-2006, International Business Machines
* Corporation and others. All Rights Reserved.
********************************************************************************
*/
#include "unicode/utypes.h"
#include "unicode/ucsdet.h"
#include <string.h>
#include <stdio.h>
#define BUFFER_SIZE 8192
int main(int argc, char *argv[])
{
static char buffer[BUFFER_SIZE];
int32_t arg;
if( argc <= 1 ) {
printf("Usage: %s [filename]...\n", argv[0]);
return -1;
}
for(arg = 1; arg < argc; arg += 1) {
FILE *file;
char *filename = argv[arg];
int32_t inputLength, match, matchCount = 0;
UCharsetDetector* csd;
const UCharsetMatch **csm;
UErrorCode status = U_ZERO_ERROR;
if (arg > 1) {
printf("\n");
}
file = fopen(filename, "rb");
if (file == NULL) {
printf("Cannot open file \"%s\"\n\n", filename);
continue;
}
printf("%s:\n", filename);
inputLength = (int32_t) fread(buffer, 1, BUFFER_SIZE, file);
fclose(file);
csd = ucsdet_open(&status);
ucsdet_setText(csd, buffer, inputLength, &status);
csm = ucsdet_detectAll(csd, &matchCount, &status);
for(match = 0; match < matchCount; match += 1) {
const char *name = ucsdet_getName(csm[match], &status);
const char *lang = ucsdet_getLanguage(csm[match], &status);
int32_t confidence = ucsdet_getConfidence(csm[match], &status);
if (lang == NULL || strlen(lang) == 0) {
lang = "**";
}
printf("%s (%s) %d\n", name, lang, confidence);
}
ucsdet_close(csd);
}
return 0;
}
|
the_stack_data/167330957.c
|
extern double __ieee754_atan2();
/*
* --INFO--
* Address: 800CF98C
* Size: 000020
*/
double atan2(double __x, double __y) { return (double)__ieee754_atan2(); }
/*
.loc_0x0:
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
bl -0x33B0
lwz r0, 0x14(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
|
the_stack_data/23574408.c
|
// This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2017 Rodrigo Castano
// SPDX-FileCopyrightText: 2017-2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
int __VERIFIER_nondet_int();
int main() {
int i = __VERIFIER_nondet_int();
if (i) {
if (i > 5) {
i = i + 5;
} else {
i = i + 1;
}
} else {
i = i - 2;
}
return 0;
}
|
the_stack_data/109031.c
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int selnum = 0;
char strcontent[128] = {0,};
printf("숫자를 입력하세요\n");
scanf("%d", &selnum);
printf("입력한 숫자는 [%d]\n", selnum);
printf("문자를 입력하세요\n");
scanf("%s", strcontent);
printf("입력한 문자는 [%s]\n", strcontent);
return 0;
}
|
the_stack_data/86074046.c
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int fahr, celsius;
int lower, upper, step;
lower = 0;
upper = 300;
step = 20;
fahr = lower;
while (fahr <= upper)
{
celsius = 5 * (fahr-32)/9;
printf("%d F\t%d C\n", fahr, celsius);
fahr = fahr + step;
}
return 0;
}
|
the_stack_data/240216.c
|
/* работа с памятью, T13.816-T13.889 $DVS:time$ */
#include <stdlib.h>
#include <stdint.h>
#include "memory.h"
#if defined(_WIN32) || defined(_WIN64)
int xdag_mem_init(size_t size)
{
return 0;
}
void *xdag_malloc(size_t size)
{
return malloc(size);
}
void xdag_free(void *mem)
{
return free(mem);
}
void xdag_mem_finish(void)
{
}
int xdag_free_all(void)
{
return -1;
}
#else
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/mman.h>
#define MEM_PORTION ((size_t)1 << 24)
static int g_fd = -1;
static size_t g_pos = 0, g_fsize = 0, g_size = 0;
static void *g_mem;
static pthread_mutex_t g_mem_mutex = PTHREAD_MUTEX_INITIALIZER;
static char g_tmpname[64] = "xdag-tmp-XXXXXX";
int xdag_mem_init(size_t size)
{
if (!size) {
return 0;
}
size--;
size |= MEM_PORTION - 1;
size++;
g_fd = mkstemp(g_tmpname);
if (g_fd < 0) {
return -1;
}
g_mem = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, g_fd, 0);
if (g_mem == MAP_FAILED) {
close(g_fd); return -1;
}
g_size = size;
return 0;
}
void *xdag_malloc(size_t size)
{
uint8_t *res;
if (g_fd < 0) {
return malloc(size);
}
if (!size) {
return 0;
}
pthread_mutex_lock(&g_mem_mutex);
size--;
size |= 0xf;
size++;
while (g_pos + size > g_fsize) {
if (g_fsize + MEM_PORTION > g_size) {
pthread_mutex_unlock(&g_mem_mutex);
return 0;
}
g_fsize += MEM_PORTION;
ftruncate(g_fd, g_fsize);
}
res = (uint8_t*)g_mem + g_pos;
g_pos += size;
pthread_mutex_unlock(&g_mem_mutex);
return res;
}
void xdag_free(void *mem)
{
}
void xdag_mem_finish(void)
{
if (g_fd < 0) return;
pthread_mutex_lock(&g_mem_mutex);
munmap(g_mem, g_size);
ftruncate(g_fd, 0);
close(g_fd);
remove(g_tmpname);
}
int xdag_free_all(void)
{
g_pos = 0;
return 0;
}
#endif
char** xdagCreateStringArray(int count, int stringLen)
{
char** stringArray = malloc(count * sizeof(char*));
for (int i = 0; i < count; ++i) {
stringArray[i] = malloc(stringLen);
}
return stringArray;
}
void xdagFreeStringArray(char** stringArray, int count)
{
for (int i = 0; i < count; ++i) {
free(stringArray[i]);
}
free(stringArray);
}
|
the_stack_data/111078843.c
|
int Mkfifo(const char *path,int mode){
return -1;
}
|
the_stack_data/173577715.c
|
/*
Modified l1.c on Joxan's request.
Run statistics:
Model checker stats:
Nb iterations of outer while loop: 0
Nb iterations of reachability: 12716
Nb created nodes: 0
Nb refinment processes: 43
Nb refined nodes: 0
Nb proof tree nodes: 906
Nb proof tree covered nodes: 303Nb deleted nodes: 0
Abstractor stats:
Total number of non-post queries = 1
Total number of cached queries = 143678
Total number of queries = 172259
Worst-case number of post queries = 175096
Actual number of post queries = 175096
NonDC number of post queries = 4995
Assume post queries = 36658
Total posts = 4641
Total assume posts = 1115
Total foci queries = 256
Foci Theory Clauses:
Num theory clauses: 0
List of predicates:
Number of predicates =69
Maximum number of predicates active together (discounting scope) = 0
Timings:
real 0m32.110s
user 0m17.108s
sys 0m12.173s
*/
/*
BLAST
w/o -predH 7
12 predicates
1.11s
w/ -predH 7
11 predicates
0.88s
TRACER
44 states and 2 subsumed
0.05s
*/
int BLAST_NONDET;
void main()
{
int s;
s=0;
if (BLAST_NONDET) { s = s+1; }
if (BLAST_NONDET) { s = s+2; }
if (BLAST_NONDET) { s = s+4; }
if (BLAST_NONDET) { s = s+8; }
if (BLAST_NONDET) { s = s+16; }
if (BLAST_NONDET) { s = s+32; }
if (BLAST_NONDET) { s = s+64; }
if (BLAST_NONDET) { s = s+128; }
if (s>600) {
s=0;
if (BLAST_NONDET) { s = s+1; }
if (BLAST_NONDET) { s = s+2; }
if (BLAST_NONDET) { s = s+4; }
if (BLAST_NONDET) { s = s+8; }
if (BLAST_NONDET) { s = s+16; }
if (BLAST_NONDET) { s = s+32; }
if (BLAST_NONDET) { s = s+64; }
if (BLAST_NONDET) { s = s+128; }
// BLAST
if (s>600) ERROR: goto ERROR;
// TRACER _ABORT(s>600);
}
return;
}
|
the_stack_data/153269346.c
|
#include <stdio.h>
#include <string.h>
#include <math.h>
void troca(int *a, int *b) {
int aux = *a;
*a = *b;
*b = aux;
}
int particiona(int v[], int a, int b) {
int i, k = a;
for (i=a+1;i<=b;i++) {
if (v[i] < v[a]) {
k++;
troca(&v[i], &v[k]);
}
}
troca(&v[a], &v[k]);
return k;
}
void quick_sort(int v[], int a, int b) {
if (a < b) {
int p = particiona(v, a, b);
quick_sort(v, a, p-1);
quick_sort(v, p+1, b);
}
}
int main() {
int i, j, pacote, tcp[100000];
char string[15];
while(scanf("%s", string) != EOF) {
i=0;
if(strcmp(string, "1")==0) {
while(strcmp(string, "0")!=0) {
scanf(" %[^\n^\r]s", string);
if(strcmp(string, "0") == 0)
break;
sscanf(&string[8], "%d%*c", &pacote);
tcp[i] = pacote;
i++;
}
tcp[i] = 0;
quick_sort(tcp, 0, i);
for(j=1;j<=i;j++) {
printf("Package %03d\n", tcp[j]);
}
printf("\n");
}
}
return 0;
}
|
the_stack_data/248580631.c
|
//+inc
//+depends tolower
//+needs ctype.h
//+def
int _strcasecmp(const char*c1,const char*c2,int len){
int a = 0;
while ( (c1[a] != 0) && (c2[a]!=0 ) && a != len ){
if ( c1[a] != c2[a] ){
if ( tolower( c1[a] ) > tolower( c2[a] ) )
return(1);
if ( tolower( c1[a] ) < tolower( c2[a] ) )
return(-1);
}
a++;
}
if ( (c1[a] == 0 ) && ( c2[a] == 0 ) )
return(0);
return (1);
}
//+inc
//+depends _strcasecmp
//+needs ctype.h
//+def
int strcasecmp(const char*c1,const char*c2){
return( _strcasecmp(c1,c2,-1) );
}
//+depends _strcasecmp
//+inc
//+def
int strncasecmp(const char*c1,const char*c2,int len){
if ( len <=0 )
return(-1);
return(_strcasecmp(c1,c2,len) );
}
|
the_stack_data/265803.c
|
#include<stdio.h>
#include<stdlib.h>
void copy(int *from,int *to,int size)
{
int temp;
for(int i=0;i<size;i++)
{
temp=from[i];
to[i]=temp;
}
printf("the copied array:");
for(int j=0;j<size;j++)
{
printf("%d ",to[j]);
}
}
int main()
{
int size;
printf("enter size of FROM array");
scanf("%d",&size);
int from[size],to[size];
printf("enter elements:");
for(int i=0;i<size;i++)
{
scanf("%d",&from[i]);
}
copy(from,to,size);
}
|
the_stack_data/165768034.c
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
static size_t my_tablen(char **tab)
{
size_t i = 0;
if (tab != NULL)
for (; tab[i] != NULL; i++);
return i;
}
char **my_tabdup(char **tab)
{
size_t i = 0;
size_t len = my_tablen(tab);
char **new = malloc(sizeof(char *) * (len + 1));
assert(new != NULL);
for (; i < len; i++) {
new[i] = strdup(tab[i]);
assert(new[i] != NULL);
}
new[i] = NULL;
return new;
}
|
the_stack_data/117328503.c
|
#include <stdio.h>
void main() {
char data[6] = {'h', 'a', 'p', 'p', 'y', 0};
char ment[ ] = "C programming~";
printf("%s \n", data);
printf("%s \n", ment);
}
|
the_stack_data/89199937.c
|
char *my_revstr(char *str)
{
int i;
int j;
char swap;
i = 0;
j = my_strlen(str) - 1;
while (i < j)
{
swap = str[i];
str[i] = str[j];
str[j] = swap;
i++;
j++;
}
return (str);
}
|
the_stack_data/26701070.c
|
/*
* Copyright (c) 2020 roleo.
*
* 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, version 3.
*
* 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/>.
*/
/*
* Scans the buffer, finds the last h264 i-frame and saves the relative
* position to /tmp/iframe.idx
*/
#define _GNU_SOURCE
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#define BUF_OFFSET 300
#define BUF_SIZE 1786156
#define FRAME_HEADER_SIZE 22
#define USLEEP 100000
#define BUFFER_FILE "/dev/shm/fshare_frame_buf"
#define I_FILE "/tmp/iframe.idx"
#define STATE_NONE 0 /* Starting state*/
#define STATE_SPS_HIGH 1 /* Last nalu is SPS high res */
#define STATE_SPS_LOW 2 /* Last nalu is SPS low res */
#define STATE_PPS_HIGH 3 /* Last nalu is PPS high res */
#define STATE_PPS_LOW 4 /* Last nalu is PPS low res */
#define STATE_IDR_HIGH 5 /* Last nalu is IDR high res */
#define STATE_IDR_LOW 6 /* Last nalu is IDR low res */
typedef struct {
int sps_addr;
int sps_len;
int pps_addr;
int pps_len;
int idr_addr;
int idr_len;
} frame;
unsigned char IDR[] = {0x65, 0xB8};
unsigned char NAL_START[] = {0x00, 0x00, 0x00, 0x01};
unsigned char IDR_START[] = {0x00, 0x00, 0x00, 0x01, 0x65, 0x88};
unsigned char PFR_START[] = {0x00, 0x00, 0x00, 0x01, 0x41};
unsigned char SPS_START[] = {0x00, 0x00, 0x00, 0x01, 0x67};
unsigned char PPS_START[] = {0x00, 0x00, 0x00, 0x01, 0x68};
unsigned char SPS_640X360[] = {0x00, 0x00, 0x00, 0x01, 0x67, 0x4D, 0x00, 0x14,
0x96, 0x54, 0x05, 0x01, 0x7B, 0xCB, 0x37, 0x01};
unsigned char SPS_1920X1080[] = {0x00, 0x00, 0x00, 0x01, 0x67, 0x4D, 0x00, 0x20,
0x96, 0x54, 0x03, 0xC0, 0x11, 0x2F, 0x2C, 0xDC};
unsigned char *addr; /* Pointer to shared memory region (header) */
int debug = 0; /* Set to 1 to debug this .cpp */
int state = STATE_NONE; /* State of the state machine */
/* Locate a string in the circular buffer */
unsigned char * cb_memmem(unsigned char *src,
int src_len, unsigned char *what, int what_len, unsigned char *buf, int buf_size)
{
unsigned char *p;
if (src_len >= 0) {
p = (unsigned char*) memmem(src, src_len, what, what_len);
} else {
// From src to the end of the buffer
p = (unsigned char*) memmem(src, buf + buf_size - src, what, what_len);
if (p == NULL) {
// And from the start of the buffer size src_len
p = (unsigned char*) memmem(buf, src + src_len - buf, what, what_len);
}
}
return p;
}
unsigned char * cb_move(unsigned char *buf, int offset)
{
buf += offset;
if ((offset > 0) && (buf > addr + BUF_SIZE))
buf -= (BUF_SIZE - BUF_OFFSET);
if ((offset < 0) && (buf < addr + BUF_OFFSET))
buf += (BUF_SIZE - BUF_OFFSET);
return buf;
}
void writeFile(char *name, char *data, int len) {
FILE *fp;
fp = fopen(name, "w") ;
if (fp == NULL) {
if (debug) fprintf(stderr, "could not open file %s\n", name) ;
return;
}
if (fwrite(data, sizeof(char), len, fp) != len) {
if (debug) fprintf(stderr, "error writing to file %s\n", name) ;
}
fclose(fp) ;
}
unsigned int getFrameLen(unsigned char *buf, int offset)
{
unsigned char *tmpbuf = buf;
int ret = 0;
tmpbuf = cb_move(tmpbuf, -(offset + FRAME_HEADER_SIZE));
memcpy(&ret, tmpbuf, 4);
tmpbuf = cb_move(tmpbuf, offset + FRAME_HEADER_SIZE);
return ret;
}
int main(int argc, char **argv) {
unsigned char *addrh; /* Pointer to h264 data */
int sizeh; /* Size of h264 data */
unsigned char *buf_idx_1, *buf_idx_2;
unsigned char *buf_idx_w, *buf_idx_tmp;
unsigned char *buf_idx_start, *buf_idx_end;
FILE *fFid;
uint32_t utmp[4];
uint32_t utmp_old[4];
int i;
int sequence_size;
frame hl_frame[2], hl_frame_old[2];
// Opening an existing file
fFid = fopen(BUFFER_FILE, "r") ;
if ( fFid == NULL ) {
if (debug) fprintf(stderr, "could not open file %s\n", BUFFER_FILE) ;
return -1;
}
// Map file to memory
addr = (unsigned char*) mmap(NULL, BUF_SIZE, PROT_READ, MAP_SHARED, fileno(fFid), 0);
if (addr == MAP_FAILED) {
if (debug) fprintf(stderr, "error mapping file %s\n", BUFFER_FILE);
return -2;
}
if (debug) fprintf(stderr, "mapping file %s, size %d, to %08x\n", BUFFER_FILE, BUF_SIZE, (unsigned int) addr);
// Closing the file
if (debug) fprintf(stderr, "closing the file %s\n", BUFFER_FILE) ;
fclose(fFid) ;
// Define default vaules
addrh = addr + BUF_OFFSET;
sizeh = BUF_SIZE - BUF_OFFSET;
buf_idx_1 = addrh;
buf_idx_w = 0;
state = STATE_NONE;
// Infinite loop
while (1) {
memcpy(&i, addr + 16, sizeof(i));
buf_idx_w = addrh + i;
if (debug) fprintf(stderr, "buf_idx_w: %08x\n", (unsigned int) buf_idx_w);
buf_idx_tmp = cb_memmem(buf_idx_1, buf_idx_w - buf_idx_1, NAL_START, sizeof(NAL_START), addrh, sizeh);
if (buf_idx_tmp == NULL) {
usleep(USLEEP);
continue;
} else {
buf_idx_1 = buf_idx_tmp;
}
if (debug) fprintf(stderr, "found buf_idx_1: %08x\n", (unsigned int) buf_idx_1);
buf_idx_tmp = cb_memmem(buf_idx_1 + 1, buf_idx_w - (buf_idx_1 + 1), NAL_START, sizeof(NAL_START), addrh, sizeh);
if (buf_idx_tmp == NULL) {
usleep(USLEEP);
continue;
} else {
buf_idx_2 = buf_idx_tmp;
}
if (debug) fprintf(stderr, "found buf_idx_2: %08x\n", (unsigned int) buf_idx_2);
switch (state) {
case STATE_SPS_HIGH:
if (memcmp(buf_idx_1, PPS_START, sizeof(PPS_START)) == 0) {
state = STATE_PPS_HIGH;
if (debug) fprintf(stderr, "state = STATE_PPS_HIGH\n");
hl_frame[0].pps_addr = buf_idx_1 - addr;
hl_frame[0].pps_len = getFrameLen(buf_idx_1, 0);
}
break;
case STATE_PPS_HIGH:
if (memcmp(buf_idx_1, IDR_START, sizeof(IDR_START)) == 0) {
state = STATE_NONE;
if (debug) fprintf(stderr, "state = STATE_IDR_HIGH\n");
hl_frame[0].idr_addr = buf_idx_1 - addr;
hl_frame[0].idr_len = getFrameLen(buf_idx_1, 0);
if (memcmp(hl_frame, hl_frame_old, 2 * sizeof(frame)) != 0) {
writeFile(I_FILE, (unsigned char *) hl_frame, 2 * sizeof(frame));
memcpy(hl_frame_old, hl_frame, 2 * sizeof(frame));
}
}
break;
// case STATE_IDR_HIGH:
// state = STATE_NONE;
// if (debug) fprintf(stderr, "state = STATE_NONE\n");
// buf_idx_end = buf_idx_1;
// sequence_size = buf_idx_end - buf_idx_start;
// if (sequence_size < 0)
// sequence_size = (addrh + sizeh) - buf_idx_start + buf_idx_end - addrh;
// // Write IDR address and size to the file
// utmp[0] = (uint32_t) (buf_idx_start - addr);
// utmp[1] = (uint32_t) sequence_size;
// if (memcmp(utmp, utmp_old, sizeof(utmp)) != 0) {
// writeFile(I_FILE, (char *) utmp, sizeof(utmp));
// memcpy(utmp_old, utmp, sizeof(utmp));
// }
// break;
case STATE_SPS_LOW:
if (memcmp(buf_idx_1, PPS_START, sizeof(PPS_START)) == 0) {
state = STATE_PPS_LOW;
if (debug) fprintf(stderr, "state = STATE_PPS_LOW\n");
hl_frame[1].pps_addr = buf_idx_1 - addr;
hl_frame[1].pps_len = getFrameLen(buf_idx_1, 0);
}
break;
case STATE_PPS_LOW:
if (memcmp(buf_idx_1, IDR_START, sizeof(IDR_START)) == 0) {
state = STATE_NONE;
if (debug) fprintf(stderr, "state = STATE_IDR_LOW\n");
hl_frame[1].idr_addr = buf_idx_1 - addr;
hl_frame[1].idr_len = getFrameLen(buf_idx_1, 0);
if (memcmp(hl_frame, hl_frame_old, 2 * sizeof(frame)) != 0) {
writeFile(I_FILE, (unsigned char *) hl_frame, 2 * sizeof(frame));
memcpy(hl_frame_old, hl_frame, 2 * sizeof(frame));
}
}
break;
// case STATE_IDR_LOW:
// state = STATE_NONE;
// if (debug) fprintf(stderr, "state = STATE_NONE\n");
// buf_idx_end = buf_idx_1;
// sequence_size = buf_idx_end - buf_idx_start;
// if (sequence_size < 0)
// sequence_size = (addrh + sizeh) - buf_idx_start + buf_idx_end - addrh;
// // Write IDR address and size to the file
// utmp[2] = (uint32_t) (buf_idx_start - addr);
// utmp[3] = (uint32_t) sequence_size;
// if (memcmp(utmp, utmp_old, sizeof(utmp)) != 0) {
// writeFile(I_FILE, (char *) utmp, sizeof(utmp));
// memcpy(utmp_old, utmp, sizeof(utmp));
// }
// break;
case STATE_NONE:
if (memcmp(buf_idx_1, SPS_1920X1080, sizeof(SPS_1920X1080)) == 0) {
state = STATE_SPS_HIGH;
if (debug) fprintf(stderr, "state = STATE_SPS_HIGH\n");
hl_frame[0].sps_addr = buf_idx_1 - addr;
hl_frame[0].sps_len = getFrameLen(buf_idx_1, 6);
} else if (memcmp(buf_idx_1, SPS_640X360, sizeof(SPS_640X360)) == 0) {
state = STATE_SPS_LOW;
if (debug) fprintf(stderr, "state = STATE_SPS_LOW\n");
hl_frame[1].sps_addr = buf_idx_1 - addr;
hl_frame[1].sps_len = getFrameLen(buf_idx_1, 6);
}
break;
default:
break;
}
buf_idx_1 = buf_idx_2;
}
// Unreacheable path
// Unmap file from memory
if (munmap(addr, BUF_SIZE) == -1) {
if (debug) fprintf(stderr, "error munmapping file");
} else {
if (debug) fprintf(stderr, "unmapping file %s, size %d, from %08x\n", BUFFER_FILE, BUF_SIZE, addr);
}
return 0;
}
|
the_stack_data/67324782.c
|
// Código-fonte disponível em https://github.com/mpeschke/locadoradefilmes.git
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
void calc_preco_final(char* tipo, float* preco, char* dia);
int main()
{
// ----------|--------|
// 12345678901234567890
// LANÇAMENTO
// COMUM
char tipo[10+1] = {'\0'};
// ----------|--------|
// 12345678901234567890
// SEGUNDA
// TERCA
// QUARTA
// QUINTA
// SEXTA
// SABADO
// DOMINGO
char dia[7+1] = {'\0'};
float preco = 0.0f;
char* sair = "SAIR";
int continuar = 1;
do
{
printf("Digite o tipo de locação: ");
scanf("%s", tipo);
if(strcmp(sair, tipo) == 0)
return 0;
printf("Digite o preço sem desconto: ");
scanf("%f", &preco);
if(strcmp(sair, dia) == 0)
return 0;
printf("Digite o dia da locação: ");
scanf("%s", dia);
calc_preco_final((char*)tipo, &preco, dia);
printf("\nPreço final de locação: %f\n", preco);
while ((getchar()) != '\n');
} while (continuar);
return 0;
}
void calc_preco_final(char* tipo, float* preco, char* dia)
{
float descontotipo = 1.0f;
if(strcmp(tipo, "LANÇAMENTO") == 0)
descontotipo = 1.15f;
float descontodia = 1.0f;
if(strcmp(dia, "SEGUNDA") == 0)
descontodia = 0.64f;
else if(strcmp(dia, "TERCA") == 0)
descontodia = 0.64f;
else if(strcmp(dia, "QUARTA") == 0)
descontodia = 0.77f;
else if(strcmp(dia, "QUINTA") == 0)
descontodia = 0.64f;
else if(strcmp(dia, "SEXTA") == 0)
descontodia = 0.77f;
*preco = (*preco * descontotipo) * descontodia;
}
|
the_stack_data/742718.c
|
// Mon programme hello world!
#include <stdio.h>
int main() {
printf ("Hello Ynov Campus! Votre recette est fonctionelle\n");
return 0;
}
|
the_stack_data/144066.c
|
a, b;
c() {
int *d;
int e = d = b;
for (; a;) {
for (; e;)
;
for (;;)
f(d[1]);
}
}
|
the_stack_data/323572.c
|
/*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
int main() {
int a = 0;
switch (0) {
case 0:
case 1:
case 2:
default:
a = 5;
}
return a;
}
|
the_stack_data/156393491.c
|
/*
* Copyright (c) 1988, 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.
*
* @(#)atol.c 8.1 (Berkeley) 6/4/93
* $FreeBSD: src/lib/libc/stdlib/atol.c,v 1.5 2007/01/09 00:28:09 imp Exp $
* $DragonFly: src/lib/libc/stdlib/atol.c,v 1.3 2005/11/20 12:37:48 swildner Exp $
*/
#include <stdlib.h>
long
atol(const char *str)
{
return(strtol(str, NULL, 10));
}
|
the_stack_data/87637934.c
|
#include <stdio.h>
int main() {
unsigned short int T, N, R;
scanf("%hu", &T);
for(unsigned short int i = 0; i < T; i++) {
scanf("%hu %hu", &N, &R);
N--;
R--;
unsigned int n = 1;
unsigned int d = 1;
for(unsigned short int j = 1; j <= N - R; j++) {
n *= j + R;
d *= j;
}
printf("%u\n", n/d);
}
return 0;
}
|
the_stack_data/218894241.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()
{
float s16_x, _x_s16_x;
bool s16_l1, _x_s16_l1;
float _diverge_delta, _x__diverge_delta;
float delta, _x_delta;
float r_x, _x_r_x;
bool s7_l1, _x_s7_l1;
bool r_l, _x_r_l;
bool s7_l0, _x_s7_l0;
float s16_z, _x_s16_z;
bool s7_l2, _x_s7_l2;
float s16_y, _x_s16_y;
int r_counter, _x_r_counter;
float s7_x, _x_s7_x;
float s7_z, _x_s7_z;
bool s16_evt1, _x_s16_evt1;
bool s16_evt0, _x_s16_evt0;
float s7_y, _x_s7_y;
bool s17_l1, _x_s17_l1;
bool s7_evt1, _x_s7_evt1;
bool s17_l0, _x_s17_l0;
bool s7_evt0, _x_s7_evt0;
bool s17_l2, _x_s17_l2;
float s17_x, _x_s17_x;
bool s8_l1, _x_s8_l1;
bool s8_l0, _x_s8_l0;
float s17_z, _x_s17_z;
bool s8_l2, _x_s8_l2;
float s17_y, _x_s17_y;
float s8_x, _x_s8_x;
int r_evt_id, _x_r_evt_id;
float s8_z, _x_s8_z;
bool s17_evt1, _x_s17_evt1;
bool s17_evt0, _x_s17_evt0;
float s8_y, _x_s8_y;
bool s18_l1, _x_s18_l1;
bool s8_evt1, _x_s8_evt1;
bool s18_l0, _x_s18_l0;
bool s8_evt0, _x_s8_evt0;
bool s18_l2, _x_s18_l2;
float s18_x, _x_s18_x;
bool r_event0, _x_r_event0;
bool r_event1, _x_r_event1;
bool s9_l1, _x_s9_l1;
bool s9_l0, _x_s9_l0;
float s18_z, _x_s18_z;
bool s9_l2, _x_s9_l2;
float s18_y, _x_s18_y;
float s9_x, _x_s9_x;
bool s0_l1, _x_s0_l1;
bool s0_l0, _x_s0_l0;
bool s0_l2, _x_s0_l2;
float s9_z, _x_s9_z;
bool s18_evt1, _x_s18_evt1;
bool s18_evt0, _x_s18_evt0;
float s9_y, _x_s9_y;
float s0_x, _x_s0_x;
float s0_z, _x_s0_z;
bool s19_l1, _x_s19_l1;
bool s9_evt1, _x_s9_evt1;
bool s19_l0, _x_s19_l0;
bool s9_evt0, _x_s9_evt0;
bool s19_l2, _x_s19_l2;
float s0_y, _x_s0_y;
float s19_x, _x_s19_x;
bool s10_l1, _x_s10_l1;
bool s0_evt1, _x_s0_evt1;
bool s10_l0, _x_s10_l0;
float s19_z, _x_s19_z;
bool s0_evt0, _x_s0_evt0;
float s19_y, _x_s19_y;
bool s10_l2, _x_s10_l2;
float s10_x, _x_s10_x;
bool s1_l1, _x_s1_l1;
bool s1_l0, _x_s1_l0;
float s10_z, _x_s10_z;
bool s19_evt1, _x_s19_evt1;
bool s19_evt0, _x_s19_evt0;
bool s1_l2, _x_s1_l2;
float s10_y, _x_s10_y;
float s1_x, _x_s1_x;
float s1_z, _x_s1_z;
bool s20_l1, _x_s20_l1;
bool s10_evt1, _x_s10_evt1;
bool s20_l0, _x_s20_l0;
bool s10_evt0, _x_s10_evt0;
bool s20_l2, _x_s20_l2;
float s1_y, _x_s1_y;
float s20_x, _x_s20_x;
bool s11_l1, _x_s11_l1;
bool s1_evt1, _x_s1_evt1;
bool s11_l0, _x_s11_l0;
float s20_z, _x_s20_z;
bool s1_evt0, _x_s1_evt0;
float s20_y, _x_s20_y;
bool s11_l2, _x_s11_l2;
float s11_x, _x_s11_x;
bool s2_l1, _x_s2_l1;
bool s2_l0, _x_s2_l0;
float s11_z, _x_s11_z;
bool s20_evt1, _x_s20_evt1;
bool s20_evt0, _x_s20_evt0;
bool s2_l2, _x_s2_l2;
float s11_y, _x_s11_y;
float s2_x, _x_s2_x;
float s2_z, _x_s2_z;
bool s11_evt1, _x_s11_evt1;
bool s11_evt0, _x_s11_evt0;
float s2_y, _x_s2_y;
bool _J5155, _x__J5155;
bool _J5149, _x__J5149;
bool _J5143, _x__J5143;
bool _J5137, _x__J5137;
bool _EL_U_5111, _x__EL_U_5111;
bool _EL_U_5113, _x__EL_U_5113;
bool _EL_U_5115, _x__EL_U_5115;
bool s12_l1, _x_s12_l1;
bool s2_evt1, _x_s2_evt1;
bool s12_l0, _x_s12_l0;
bool s2_evt0, _x_s2_evt0;
bool s12_l2, _x_s12_l2;
bool _EL_U_5117, _x__EL_U_5117;
float s12_x, _x_s12_x;
bool s3_l1, _x_s3_l1;
bool s3_l0, _x_s3_l0;
float s12_z, _x_s12_z;
bool s3_l2, _x_s3_l2;
float s12_y, _x_s12_y;
float s3_x, _x_s3_x;
float s3_z, _x_s3_z;
bool s12_evt1, _x_s12_evt1;
bool s12_evt0, _x_s12_evt0;
float s3_y, _x_s3_y;
bool s13_l1, _x_s13_l1;
bool s3_evt1, _x_s3_evt1;
bool s13_l0, _x_s13_l0;
bool s3_evt0, _x_s3_evt0;
bool s13_l2, _x_s13_l2;
float s13_x, _x_s13_x;
bool s4_l1, _x_s4_l1;
bool s4_l0, _x_s4_l0;
float s13_z, _x_s13_z;
bool s4_l2, _x_s4_l2;
float s13_y, _x_s13_y;
float s4_x, _x_s4_x;
float s4_z, _x_s4_z;
bool s13_evt1, _x_s13_evt1;
bool s13_evt0, _x_s13_evt0;
float s4_y, _x_s4_y;
bool s14_l1, _x_s14_l1;
bool s4_evt1, _x_s4_evt1;
bool s14_l0, _x_s14_l0;
bool s4_evt0, _x_s4_evt0;
bool s14_l2, _x_s14_l2;
float s14_x, _x_s14_x;
bool s5_l1, _x_s5_l1;
bool s5_l0, _x_s5_l0;
float s14_z, _x_s14_z;
bool s5_l2, _x_s5_l2;
float s14_y, _x_s14_y;
float s5_x, _x_s5_x;
float s5_z, _x_s5_z;
bool s14_evt1, _x_s14_evt1;
bool s14_evt0, _x_s14_evt0;
float s5_y, _x_s5_y;
bool s15_l1, _x_s15_l1;
bool s5_evt1, _x_s5_evt1;
bool s15_l0, _x_s15_l0;
bool s5_evt0, _x_s5_evt0;
bool s15_l2, _x_s15_l2;
float s15_x, _x_s15_x;
bool s6_l1, _x_s6_l1;
bool s6_l0, _x_s6_l0;
float s15_z, _x_s15_z;
bool s6_l2, _x_s6_l2;
float s15_y, _x_s15_y;
float s6_x, _x_s6_x;
float s6_z, _x_s6_z;
bool s15_evt1, _x_s15_evt1;
bool s15_evt0, _x_s15_evt0;
float s6_y, _x_s6_y;
bool s6_evt1, _x_s6_evt1;
bool s6_evt0, _x_s6_evt0;
bool s16_l0, _x_s16_l0;
bool s16_l2, _x_s16_l2;
int __steps_to_fair = __VERIFIER_nondet_int();
s16_x = __VERIFIER_nondet_float();
s16_l1 = __VERIFIER_nondet_bool();
_diverge_delta = __VERIFIER_nondet_float();
delta = __VERIFIER_nondet_float();
r_x = __VERIFIER_nondet_float();
s7_l1 = __VERIFIER_nondet_bool();
r_l = __VERIFIER_nondet_bool();
s7_l0 = __VERIFIER_nondet_bool();
s16_z = __VERIFIER_nondet_float();
s7_l2 = __VERIFIER_nondet_bool();
s16_y = __VERIFIER_nondet_float();
r_counter = __VERIFIER_nondet_int();
s7_x = __VERIFIER_nondet_float();
s7_z = __VERIFIER_nondet_float();
s16_evt1 = __VERIFIER_nondet_bool();
s16_evt0 = __VERIFIER_nondet_bool();
s7_y = __VERIFIER_nondet_float();
s17_l1 = __VERIFIER_nondet_bool();
s7_evt1 = __VERIFIER_nondet_bool();
s17_l0 = __VERIFIER_nondet_bool();
s7_evt0 = __VERIFIER_nondet_bool();
s17_l2 = __VERIFIER_nondet_bool();
s17_x = __VERIFIER_nondet_float();
s8_l1 = __VERIFIER_nondet_bool();
s8_l0 = __VERIFIER_nondet_bool();
s17_z = __VERIFIER_nondet_float();
s8_l2 = __VERIFIER_nondet_bool();
s17_y = __VERIFIER_nondet_float();
s8_x = __VERIFIER_nondet_float();
r_evt_id = __VERIFIER_nondet_int();
s8_z = __VERIFIER_nondet_float();
s17_evt1 = __VERIFIER_nondet_bool();
s17_evt0 = __VERIFIER_nondet_bool();
s8_y = __VERIFIER_nondet_float();
s18_l1 = __VERIFIER_nondet_bool();
s8_evt1 = __VERIFIER_nondet_bool();
s18_l0 = __VERIFIER_nondet_bool();
s8_evt0 = __VERIFIER_nondet_bool();
s18_l2 = __VERIFIER_nondet_bool();
s18_x = __VERIFIER_nondet_float();
r_event0 = __VERIFIER_nondet_bool();
r_event1 = __VERIFIER_nondet_bool();
s9_l1 = __VERIFIER_nondet_bool();
s9_l0 = __VERIFIER_nondet_bool();
s18_z = __VERIFIER_nondet_float();
s9_l2 = __VERIFIER_nondet_bool();
s18_y = __VERIFIER_nondet_float();
s9_x = __VERIFIER_nondet_float();
s0_l1 = __VERIFIER_nondet_bool();
s0_l0 = __VERIFIER_nondet_bool();
s0_l2 = __VERIFIER_nondet_bool();
s9_z = __VERIFIER_nondet_float();
s18_evt1 = __VERIFIER_nondet_bool();
s18_evt0 = __VERIFIER_nondet_bool();
s9_y = __VERIFIER_nondet_float();
s0_x = __VERIFIER_nondet_float();
s0_z = __VERIFIER_nondet_float();
s19_l1 = __VERIFIER_nondet_bool();
s9_evt1 = __VERIFIER_nondet_bool();
s19_l0 = __VERIFIER_nondet_bool();
s9_evt0 = __VERIFIER_nondet_bool();
s19_l2 = __VERIFIER_nondet_bool();
s0_y = __VERIFIER_nondet_float();
s19_x = __VERIFIER_nondet_float();
s10_l1 = __VERIFIER_nondet_bool();
s0_evt1 = __VERIFIER_nondet_bool();
s10_l0 = __VERIFIER_nondet_bool();
s19_z = __VERIFIER_nondet_float();
s0_evt0 = __VERIFIER_nondet_bool();
s19_y = __VERIFIER_nondet_float();
s10_l2 = __VERIFIER_nondet_bool();
s10_x = __VERIFIER_nondet_float();
s1_l1 = __VERIFIER_nondet_bool();
s1_l0 = __VERIFIER_nondet_bool();
s10_z = __VERIFIER_nondet_float();
s19_evt1 = __VERIFIER_nondet_bool();
s19_evt0 = __VERIFIER_nondet_bool();
s1_l2 = __VERIFIER_nondet_bool();
s10_y = __VERIFIER_nondet_float();
s1_x = __VERIFIER_nondet_float();
s1_z = __VERIFIER_nondet_float();
s20_l1 = __VERIFIER_nondet_bool();
s10_evt1 = __VERIFIER_nondet_bool();
s20_l0 = __VERIFIER_nondet_bool();
s10_evt0 = __VERIFIER_nondet_bool();
s20_l2 = __VERIFIER_nondet_bool();
s1_y = __VERIFIER_nondet_float();
s20_x = __VERIFIER_nondet_float();
s11_l1 = __VERIFIER_nondet_bool();
s1_evt1 = __VERIFIER_nondet_bool();
s11_l0 = __VERIFIER_nondet_bool();
s20_z = __VERIFIER_nondet_float();
s1_evt0 = __VERIFIER_nondet_bool();
s20_y = __VERIFIER_nondet_float();
s11_l2 = __VERIFIER_nondet_bool();
s11_x = __VERIFIER_nondet_float();
s2_l1 = __VERIFIER_nondet_bool();
s2_l0 = __VERIFIER_nondet_bool();
s11_z = __VERIFIER_nondet_float();
s20_evt1 = __VERIFIER_nondet_bool();
s20_evt0 = __VERIFIER_nondet_bool();
s2_l2 = __VERIFIER_nondet_bool();
s11_y = __VERIFIER_nondet_float();
s2_x = __VERIFIER_nondet_float();
s2_z = __VERIFIER_nondet_float();
s11_evt1 = __VERIFIER_nondet_bool();
s11_evt0 = __VERIFIER_nondet_bool();
s2_y = __VERIFIER_nondet_float();
_J5155 = __VERIFIER_nondet_bool();
_J5149 = __VERIFIER_nondet_bool();
_J5143 = __VERIFIER_nondet_bool();
_J5137 = __VERIFIER_nondet_bool();
_EL_U_5111 = __VERIFIER_nondet_bool();
_EL_U_5113 = __VERIFIER_nondet_bool();
_EL_U_5115 = __VERIFIER_nondet_bool();
s12_l1 = __VERIFIER_nondet_bool();
s2_evt1 = __VERIFIER_nondet_bool();
s12_l0 = __VERIFIER_nondet_bool();
s2_evt0 = __VERIFIER_nondet_bool();
s12_l2 = __VERIFIER_nondet_bool();
_EL_U_5117 = __VERIFIER_nondet_bool();
s12_x = __VERIFIER_nondet_float();
s3_l1 = __VERIFIER_nondet_bool();
s3_l0 = __VERIFIER_nondet_bool();
s12_z = __VERIFIER_nondet_float();
s3_l2 = __VERIFIER_nondet_bool();
s12_y = __VERIFIER_nondet_float();
s3_x = __VERIFIER_nondet_float();
s3_z = __VERIFIER_nondet_float();
s12_evt1 = __VERIFIER_nondet_bool();
s12_evt0 = __VERIFIER_nondet_bool();
s3_y = __VERIFIER_nondet_float();
s13_l1 = __VERIFIER_nondet_bool();
s3_evt1 = __VERIFIER_nondet_bool();
s13_l0 = __VERIFIER_nondet_bool();
s3_evt0 = __VERIFIER_nondet_bool();
s13_l2 = __VERIFIER_nondet_bool();
s13_x = __VERIFIER_nondet_float();
s4_l1 = __VERIFIER_nondet_bool();
s4_l0 = __VERIFIER_nondet_bool();
s13_z = __VERIFIER_nondet_float();
s4_l2 = __VERIFIER_nondet_bool();
s13_y = __VERIFIER_nondet_float();
s4_x = __VERIFIER_nondet_float();
s4_z = __VERIFIER_nondet_float();
s13_evt1 = __VERIFIER_nondet_bool();
s13_evt0 = __VERIFIER_nondet_bool();
s4_y = __VERIFIER_nondet_float();
s14_l1 = __VERIFIER_nondet_bool();
s4_evt1 = __VERIFIER_nondet_bool();
s14_l0 = __VERIFIER_nondet_bool();
s4_evt0 = __VERIFIER_nondet_bool();
s14_l2 = __VERIFIER_nondet_bool();
s14_x = __VERIFIER_nondet_float();
s5_l1 = __VERIFIER_nondet_bool();
s5_l0 = __VERIFIER_nondet_bool();
s14_z = __VERIFIER_nondet_float();
s5_l2 = __VERIFIER_nondet_bool();
s14_y = __VERIFIER_nondet_float();
s5_x = __VERIFIER_nondet_float();
s5_z = __VERIFIER_nondet_float();
s14_evt1 = __VERIFIER_nondet_bool();
s14_evt0 = __VERIFIER_nondet_bool();
s5_y = __VERIFIER_nondet_float();
s15_l1 = __VERIFIER_nondet_bool();
s5_evt1 = __VERIFIER_nondet_bool();
s15_l0 = __VERIFIER_nondet_bool();
s5_evt0 = __VERIFIER_nondet_bool();
s15_l2 = __VERIFIER_nondet_bool();
s15_x = __VERIFIER_nondet_float();
s6_l1 = __VERIFIER_nondet_bool();
s6_l0 = __VERIFIER_nondet_bool();
s15_z = __VERIFIER_nondet_float();
s6_l2 = __VERIFIER_nondet_bool();
s15_y = __VERIFIER_nondet_float();
s6_x = __VERIFIER_nondet_float();
s6_z = __VERIFIER_nondet_float();
s15_evt1 = __VERIFIER_nondet_bool();
s15_evt0 = __VERIFIER_nondet_bool();
s6_y = __VERIFIER_nondet_float();
s6_evt1 = __VERIFIER_nondet_bool();
s6_evt0 = __VERIFIER_nondet_bool();
s16_l0 = __VERIFIER_nondet_bool();
s16_l2 = __VERIFIER_nondet_bool();
bool __ok = (((((((((((( !s20_evt0) && ( !s20_evt1)) || (s20_evt0 && ( !s20_evt1))) || ((s20_evt1 && ( !s20_evt0)) || (s20_evt0 && s20_evt1))) && ((((( !s20_l2) && (( !s20_l0) && ( !s20_l1))) || (( !s20_l2) && (s20_l0 && ( !s20_l1)))) || ((( !s20_l2) && (s20_l1 && ( !s20_l0))) || (( !s20_l2) && (s20_l0 && s20_l1)))) || ((s20_l2 && (( !s20_l0) && ( !s20_l1))) || (s20_l2 && (s20_l0 && ( !s20_l1)))))) && (((( !s20_l2) && (( !s20_l0) && ( !s20_l1))) && (s20_x == 0.0)) && ((s20_y == 0.0) && (s20_z == 0.0)))) && ((s20_x <= 20.0) || ( !(( !s20_l2) && (s20_l0 && ( !s20_l1)))))) && ((s20_x <= 120.0) || ( !(( !s20_l2) && (s20_l1 && ( !s20_l0)))))) && ((s20_x <= 120.0) || ( !(s20_l2 && (s20_l0 && ( !s20_l1)))))) && (((((((((( !s19_evt0) && ( !s19_evt1)) || (s19_evt0 && ( !s19_evt1))) || ((s19_evt1 && ( !s19_evt0)) || (s19_evt0 && s19_evt1))) && ((((( !s19_l2) && (( !s19_l0) && ( !s19_l1))) || (( !s19_l2) && (s19_l0 && ( !s19_l1)))) || ((( !s19_l2) && (s19_l1 && ( !s19_l0))) || (( !s19_l2) && (s19_l0 && s19_l1)))) || ((s19_l2 && (( !s19_l0) && ( !s19_l1))) || (s19_l2 && (s19_l0 && ( !s19_l1)))))) && (((( !s19_l2) && (( !s19_l0) && ( !s19_l1))) && (s19_x == 0.0)) && ((s19_y == 0.0) && (s19_z == 0.0)))) && ((s19_x <= 20.0) || ( !(( !s19_l2) && (s19_l0 && ( !s19_l1)))))) && ((s19_x <= 120.0) || ( !(( !s19_l2) && (s19_l1 && ( !s19_l0)))))) && ((s19_x <= 120.0) || ( !(s19_l2 && (s19_l0 && ( !s19_l1)))))) && (((((((((( !s18_evt0) && ( !s18_evt1)) || (s18_evt0 && ( !s18_evt1))) || ((s18_evt1 && ( !s18_evt0)) || (s18_evt0 && s18_evt1))) && ((((( !s18_l2) && (( !s18_l0) && ( !s18_l1))) || (( !s18_l2) && (s18_l0 && ( !s18_l1)))) || ((( !s18_l2) && (s18_l1 && ( !s18_l0))) || (( !s18_l2) && (s18_l0 && s18_l1)))) || ((s18_l2 && (( !s18_l0) && ( !s18_l1))) || (s18_l2 && (s18_l0 && ( !s18_l1)))))) && (((( !s18_l2) && (( !s18_l0) && ( !s18_l1))) && (s18_x == 0.0)) && ((s18_y == 0.0) && (s18_z == 0.0)))) && ((s18_x <= 20.0) || ( !(( !s18_l2) && (s18_l0 && ( !s18_l1)))))) && ((s18_x <= 120.0) || ( !(( !s18_l2) && (s18_l1 && ( !s18_l0)))))) && ((s18_x <= 120.0) || ( !(s18_l2 && (s18_l0 && ( !s18_l1)))))) && (((((((((( !s17_evt0) && ( !s17_evt1)) || (s17_evt0 && ( !s17_evt1))) || ((s17_evt1 && ( !s17_evt0)) || (s17_evt0 && s17_evt1))) && ((((( !s17_l2) && (( !s17_l0) && ( !s17_l1))) || (( !s17_l2) && (s17_l0 && ( !s17_l1)))) || ((( !s17_l2) && (s17_l1 && ( !s17_l0))) || (( !s17_l2) && (s17_l0 && s17_l1)))) || ((s17_l2 && (( !s17_l0) && ( !s17_l1))) || (s17_l2 && (s17_l0 && ( !s17_l1)))))) && (((( !s17_l2) && (( !s17_l0) && ( !s17_l1))) && (s17_x == 0.0)) && ((s17_y == 0.0) && (s17_z == 0.0)))) && ((s17_x <= 20.0) || ( !(( !s17_l2) && (s17_l0 && ( !s17_l1)))))) && ((s17_x <= 120.0) || ( !(( !s17_l2) && (s17_l1 && ( !s17_l0)))))) && ((s17_x <= 120.0) || ( !(s17_l2 && (s17_l0 && ( !s17_l1)))))) && (((((((((( !s16_evt0) && ( !s16_evt1)) || (s16_evt0 && ( !s16_evt1))) || ((s16_evt1 && ( !s16_evt0)) || (s16_evt0 && s16_evt1))) && ((((( !s16_l2) && (( !s16_l0) && ( !s16_l1))) || (( !s16_l2) && (s16_l0 && ( !s16_l1)))) || ((( !s16_l2) && (s16_l1 && ( !s16_l0))) || (( !s16_l2) && (s16_l0 && s16_l1)))) || ((s16_l2 && (( !s16_l0) && ( !s16_l1))) || (s16_l2 && (s16_l0 && ( !s16_l1)))))) && (((( !s16_l2) && (( !s16_l0) && ( !s16_l1))) && (s16_x == 0.0)) && ((s16_y == 0.0) && (s16_z == 0.0)))) && ((s16_x <= 20.0) || ( !(( !s16_l2) && (s16_l0 && ( !s16_l1)))))) && ((s16_x <= 120.0) || ( !(( !s16_l2) && (s16_l1 && ( !s16_l0)))))) && ((s16_x <= 120.0) || ( !(s16_l2 && (s16_l0 && ( !s16_l1)))))) && (((((((((( !s15_evt0) && ( !s15_evt1)) || (s15_evt0 && ( !s15_evt1))) || ((s15_evt1 && ( !s15_evt0)) || (s15_evt0 && s15_evt1))) && ((((( !s15_l2) && (( !s15_l0) && ( !s15_l1))) || (( !s15_l2) && (s15_l0 && ( !s15_l1)))) || ((( !s15_l2) && (s15_l1 && ( !s15_l0))) || (( !s15_l2) && (s15_l0 && s15_l1)))) || ((s15_l2 && (( !s15_l0) && ( !s15_l1))) || (s15_l2 && (s15_l0 && ( !s15_l1)))))) && (((( !s15_l2) && (( !s15_l0) && ( !s15_l1))) && (s15_x == 0.0)) && ((s15_y == 0.0) && (s15_z == 0.0)))) && ((s15_x <= 20.0) || ( !(( !s15_l2) && (s15_l0 && ( !s15_l1)))))) && ((s15_x <= 120.0) || ( !(( !s15_l2) && (s15_l1 && ( !s15_l0)))))) && ((s15_x <= 120.0) || ( !(s15_l2 && (s15_l0 && ( !s15_l1)))))) && (((((((((( !s14_evt0) && ( !s14_evt1)) || (s14_evt0 && ( !s14_evt1))) || ((s14_evt1 && ( !s14_evt0)) || (s14_evt0 && s14_evt1))) && ((((( !s14_l2) && (( !s14_l0) && ( !s14_l1))) || (( !s14_l2) && (s14_l0 && ( !s14_l1)))) || ((( !s14_l2) && (s14_l1 && ( !s14_l0))) || (( !s14_l2) && (s14_l0 && s14_l1)))) || ((s14_l2 && (( !s14_l0) && ( !s14_l1))) || (s14_l2 && (s14_l0 && ( !s14_l1)))))) && (((( !s14_l2) && (( !s14_l0) && ( !s14_l1))) && (s14_x == 0.0)) && ((s14_y == 0.0) && (s14_z == 0.0)))) && ((s14_x <= 20.0) || ( !(( !s14_l2) && (s14_l0 && ( !s14_l1)))))) && ((s14_x <= 120.0) || ( !(( !s14_l2) && (s14_l1 && ( !s14_l0)))))) && ((s14_x <= 120.0) || ( !(s14_l2 && (s14_l0 && ( !s14_l1)))))) && (((((((((( !s13_evt0) && ( !s13_evt1)) || (s13_evt0 && ( !s13_evt1))) || ((s13_evt1 && ( !s13_evt0)) || (s13_evt0 && s13_evt1))) && ((((( !s13_l2) && (( !s13_l0) && ( !s13_l1))) || (( !s13_l2) && (s13_l0 && ( !s13_l1)))) || ((( !s13_l2) && (s13_l1 && ( !s13_l0))) || (( !s13_l2) && (s13_l0 && s13_l1)))) || ((s13_l2 && (( !s13_l0) && ( !s13_l1))) || (s13_l2 && (s13_l0 && ( !s13_l1)))))) && (((( !s13_l2) && (( !s13_l0) && ( !s13_l1))) && (s13_x == 0.0)) && ((s13_y == 0.0) && (s13_z == 0.0)))) && ((s13_x <= 20.0) || ( !(( !s13_l2) && (s13_l0 && ( !s13_l1)))))) && ((s13_x <= 120.0) || ( !(( !s13_l2) && (s13_l1 && ( !s13_l0)))))) && ((s13_x <= 120.0) || ( !(s13_l2 && (s13_l0 && ( !s13_l1)))))) && (((((((((( !s12_evt0) && ( !s12_evt1)) || (s12_evt0 && ( !s12_evt1))) || ((s12_evt1 && ( !s12_evt0)) || (s12_evt0 && s12_evt1))) && ((((( !s12_l2) && (( !s12_l0) && ( !s12_l1))) || (( !s12_l2) && (s12_l0 && ( !s12_l1)))) || ((( !s12_l2) && (s12_l1 && ( !s12_l0))) || (( !s12_l2) && (s12_l0 && s12_l1)))) || ((s12_l2 && (( !s12_l0) && ( !s12_l1))) || (s12_l2 && (s12_l0 && ( !s12_l1)))))) && (((( !s12_l2) && (( !s12_l0) && ( !s12_l1))) && (s12_x == 0.0)) && ((s12_y == 0.0) && (s12_z == 0.0)))) && ((s12_x <= 20.0) || ( !(( !s12_l2) && (s12_l0 && ( !s12_l1)))))) && ((s12_x <= 120.0) || ( !(( !s12_l2) && (s12_l1 && ( !s12_l0)))))) && ((s12_x <= 120.0) || ( !(s12_l2 && (s12_l0 && ( !s12_l1)))))) && (((((((((( !s11_evt0) && ( !s11_evt1)) || (s11_evt0 && ( !s11_evt1))) || ((s11_evt1 && ( !s11_evt0)) || (s11_evt0 && s11_evt1))) && ((((( !s11_l2) && (( !s11_l0) && ( !s11_l1))) || (( !s11_l2) && (s11_l0 && ( !s11_l1)))) || ((( !s11_l2) && (s11_l1 && ( !s11_l0))) || (( !s11_l2) && (s11_l0 && s11_l1)))) || ((s11_l2 && (( !s11_l0) && ( !s11_l1))) || (s11_l2 && (s11_l0 && ( !s11_l1)))))) && (((( !s11_l2) && (( !s11_l0) && ( !s11_l1))) && (s11_x == 0.0)) && ((s11_y == 0.0) && (s11_z == 0.0)))) && ((s11_x <= 20.0) || ( !(( !s11_l2) && (s11_l0 && ( !s11_l1)))))) && ((s11_x <= 120.0) || ( !(( !s11_l2) && (s11_l1 && ( !s11_l0)))))) && ((s11_x <= 120.0) || ( !(s11_l2 && (s11_l0 && ( !s11_l1)))))) && (((((((((( !s10_evt0) && ( !s10_evt1)) || (s10_evt0 && ( !s10_evt1))) || ((s10_evt1 && ( !s10_evt0)) || (s10_evt0 && s10_evt1))) && ((((( !s10_l2) && (( !s10_l0) && ( !s10_l1))) || (( !s10_l2) && (s10_l0 && ( !s10_l1)))) || ((( !s10_l2) && (s10_l1 && ( !s10_l0))) || (( !s10_l2) && (s10_l0 && s10_l1)))) || ((s10_l2 && (( !s10_l0) && ( !s10_l1))) || (s10_l2 && (s10_l0 && ( !s10_l1)))))) && (((( !s10_l2) && (( !s10_l0) && ( !s10_l1))) && (s10_x == 0.0)) && ((s10_y == 0.0) && (s10_z == 0.0)))) && ((s10_x <= 20.0) || ( !(( !s10_l2) && (s10_l0 && ( !s10_l1)))))) && ((s10_x <= 120.0) || ( !(( !s10_l2) && (s10_l1 && ( !s10_l0)))))) && ((s10_x <= 120.0) || ( !(s10_l2 && (s10_l0 && ( !s10_l1)))))) && (((((((((( !s9_evt0) && ( !s9_evt1)) || (s9_evt0 && ( !s9_evt1))) || ((s9_evt1 && ( !s9_evt0)) || (s9_evt0 && s9_evt1))) && ((((( !s9_l2) && (( !s9_l0) && ( !s9_l1))) || (( !s9_l2) && (s9_l0 && ( !s9_l1)))) || ((( !s9_l2) && (s9_l1 && ( !s9_l0))) || (( !s9_l2) && (s9_l0 && s9_l1)))) || ((s9_l2 && (( !s9_l0) && ( !s9_l1))) || (s9_l2 && (s9_l0 && ( !s9_l1)))))) && (((( !s9_l2) && (( !s9_l0) && ( !s9_l1))) && (s9_x == 0.0)) && ((s9_y == 0.0) && (s9_z == 0.0)))) && ((s9_x <= 20.0) || ( !(( !s9_l2) && (s9_l0 && ( !s9_l1)))))) && ((s9_x <= 120.0) || ( !(( !s9_l2) && (s9_l1 && ( !s9_l0)))))) && ((s9_x <= 120.0) || ( !(s9_l2 && (s9_l0 && ( !s9_l1)))))) && (((((((((( !s8_evt0) && ( !s8_evt1)) || (s8_evt0 && ( !s8_evt1))) || ((s8_evt1 && ( !s8_evt0)) || (s8_evt0 && s8_evt1))) && ((((( !s8_l2) && (( !s8_l0) && ( !s8_l1))) || (( !s8_l2) && (s8_l0 && ( !s8_l1)))) || ((( !s8_l2) && (s8_l1 && ( !s8_l0))) || (( !s8_l2) && (s8_l0 && s8_l1)))) || ((s8_l2 && (( !s8_l0) && ( !s8_l1))) || (s8_l2 && (s8_l0 && ( !s8_l1)))))) && (((( !s8_l2) && (( !s8_l0) && ( !s8_l1))) && (s8_x == 0.0)) && ((s8_y == 0.0) && (s8_z == 0.0)))) && ((s8_x <= 20.0) || ( !(( !s8_l2) && (s8_l0 && ( !s8_l1)))))) && ((s8_x <= 120.0) || ( !(( !s8_l2) && (s8_l1 && ( !s8_l0)))))) && ((s8_x <= 120.0) || ( !(s8_l2 && (s8_l0 && ( !s8_l1)))))) && (((((((((( !s7_evt0) && ( !s7_evt1)) || (s7_evt0 && ( !s7_evt1))) || ((s7_evt1 && ( !s7_evt0)) || (s7_evt0 && s7_evt1))) && ((((( !s7_l2) && (( !s7_l0) && ( !s7_l1))) || (( !s7_l2) && (s7_l0 && ( !s7_l1)))) || ((( !s7_l2) && (s7_l1 && ( !s7_l0))) || (( !s7_l2) && (s7_l0 && s7_l1)))) || ((s7_l2 && (( !s7_l0) && ( !s7_l1))) || (s7_l2 && (s7_l0 && ( !s7_l1)))))) && (((( !s7_l2) && (( !s7_l0) && ( !s7_l1))) && (s7_x == 0.0)) && ((s7_y == 0.0) && (s7_z == 0.0)))) && ((s7_x <= 20.0) || ( !(( !s7_l2) && (s7_l0 && ( !s7_l1)))))) && ((s7_x <= 120.0) || ( !(( !s7_l2) && (s7_l1 && ( !s7_l0)))))) && ((s7_x <= 120.0) || ( !(s7_l2 && (s7_l0 && ( !s7_l1)))))) && (((((((((( !s6_evt0) && ( !s6_evt1)) || (s6_evt0 && ( !s6_evt1))) || ((s6_evt1 && ( !s6_evt0)) || (s6_evt0 && s6_evt1))) && ((((( !s6_l2) && (( !s6_l0) && ( !s6_l1))) || (( !s6_l2) && (s6_l0 && ( !s6_l1)))) || ((( !s6_l2) && (s6_l1 && ( !s6_l0))) || (( !s6_l2) && (s6_l0 && s6_l1)))) || ((s6_l2 && (( !s6_l0) && ( !s6_l1))) || (s6_l2 && (s6_l0 && ( !s6_l1)))))) && (((( !s6_l2) && (( !s6_l0) && ( !s6_l1))) && (s6_x == 0.0)) && ((s6_y == 0.0) && (s6_z == 0.0)))) && ((s6_x <= 20.0) || ( !(( !s6_l2) && (s6_l0 && ( !s6_l1)))))) && ((s6_x <= 120.0) || ( !(( !s6_l2) && (s6_l1 && ( !s6_l0)))))) && ((s6_x <= 120.0) || ( !(s6_l2 && (s6_l0 && ( !s6_l1)))))) && (((((((((( !s5_evt0) && ( !s5_evt1)) || (s5_evt0 && ( !s5_evt1))) || ((s5_evt1 && ( !s5_evt0)) || (s5_evt0 && s5_evt1))) && ((((( !s5_l2) && (( !s5_l0) && ( !s5_l1))) || (( !s5_l2) && (s5_l0 && ( !s5_l1)))) || ((( !s5_l2) && (s5_l1 && ( !s5_l0))) || (( !s5_l2) && (s5_l0 && s5_l1)))) || ((s5_l2 && (( !s5_l0) && ( !s5_l1))) || (s5_l2 && (s5_l0 && ( !s5_l1)))))) && (((( !s5_l2) && (( !s5_l0) && ( !s5_l1))) && (s5_x == 0.0)) && ((s5_y == 0.0) && (s5_z == 0.0)))) && ((s5_x <= 20.0) || ( !(( !s5_l2) && (s5_l0 && ( !s5_l1)))))) && ((s5_x <= 120.0) || ( !(( !s5_l2) && (s5_l1 && ( !s5_l0)))))) && ((s5_x <= 120.0) || ( !(s5_l2 && (s5_l0 && ( !s5_l1)))))) && (((((((((( !s4_evt0) && ( !s4_evt1)) || (s4_evt0 && ( !s4_evt1))) || ((s4_evt1 && ( !s4_evt0)) || (s4_evt0 && s4_evt1))) && ((((( !s4_l2) && (( !s4_l0) && ( !s4_l1))) || (( !s4_l2) && (s4_l0 && ( !s4_l1)))) || ((( !s4_l2) && (s4_l1 && ( !s4_l0))) || (( !s4_l2) && (s4_l0 && s4_l1)))) || ((s4_l2 && (( !s4_l0) && ( !s4_l1))) || (s4_l2 && (s4_l0 && ( !s4_l1)))))) && (((( !s4_l2) && (( !s4_l0) && ( !s4_l1))) && (s4_x == 0.0)) && ((s4_y == 0.0) && (s4_z == 0.0)))) && ((s4_x <= 20.0) || ( !(( !s4_l2) && (s4_l0 && ( !s4_l1)))))) && ((s4_x <= 120.0) || ( !(( !s4_l2) && (s4_l1 && ( !s4_l0)))))) && ((s4_x <= 120.0) || ( !(s4_l2 && (s4_l0 && ( !s4_l1)))))) && (((((((((( !s3_evt0) && ( !s3_evt1)) || (s3_evt0 && ( !s3_evt1))) || ((s3_evt1 && ( !s3_evt0)) || (s3_evt0 && s3_evt1))) && ((((( !s3_l2) && (( !s3_l0) && ( !s3_l1))) || (( !s3_l2) && (s3_l0 && ( !s3_l1)))) || ((( !s3_l2) && (s3_l1 && ( !s3_l0))) || (( !s3_l2) && (s3_l0 && s3_l1)))) || ((s3_l2 && (( !s3_l0) && ( !s3_l1))) || (s3_l2 && (s3_l0 && ( !s3_l1)))))) && (((( !s3_l2) && (( !s3_l0) && ( !s3_l1))) && (s3_x == 0.0)) && ((s3_y == 0.0) && (s3_z == 0.0)))) && ((s3_x <= 20.0) || ( !(( !s3_l2) && (s3_l0 && ( !s3_l1)))))) && ((s3_x <= 120.0) || ( !(( !s3_l2) && (s3_l1 && ( !s3_l0)))))) && ((s3_x <= 120.0) || ( !(s3_l2 && (s3_l0 && ( !s3_l1)))))) && (((((((((( !s2_evt0) && ( !s2_evt1)) || (s2_evt0 && ( !s2_evt1))) || ((s2_evt1 && ( !s2_evt0)) || (s2_evt0 && s2_evt1))) && ((((( !s2_l2) && (( !s2_l0) && ( !s2_l1))) || (( !s2_l2) && (s2_l0 && ( !s2_l1)))) || ((( !s2_l2) && (s2_l1 && ( !s2_l0))) || (( !s2_l2) && (s2_l0 && s2_l1)))) || ((s2_l2 && (( !s2_l0) && ( !s2_l1))) || (s2_l2 && (s2_l0 && ( !s2_l1)))))) && (((( !s2_l2) && (( !s2_l0) && ( !s2_l1))) && (s2_x == 0.0)) && ((s2_y == 0.0) && (s2_z == 0.0)))) && ((s2_x <= 20.0) || ( !(( !s2_l2) && (s2_l0 && ( !s2_l1)))))) && ((s2_x <= 120.0) || ( !(( !s2_l2) && (s2_l1 && ( !s2_l0)))))) && ((s2_x <= 120.0) || ( !(s2_l2 && (s2_l0 && ( !s2_l1)))))) && (((((((((( !s1_evt0) && ( !s1_evt1)) || (s1_evt0 && ( !s1_evt1))) || ((s1_evt1 && ( !s1_evt0)) || (s1_evt0 && s1_evt1))) && ((((( !s1_l2) && (( !s1_l0) && ( !s1_l1))) || (( !s1_l2) && (s1_l0 && ( !s1_l1)))) || ((( !s1_l2) && (s1_l1 && ( !s1_l0))) || (( !s1_l2) && (s1_l0 && s1_l1)))) || ((s1_l2 && (( !s1_l0) && ( !s1_l1))) || (s1_l2 && (s1_l0 && ( !s1_l1)))))) && (((( !s1_l2) && (( !s1_l0) && ( !s1_l1))) && (s1_x == 0.0)) && ((s1_y == 0.0) && (s1_z == 0.0)))) && ((s1_x <= 20.0) || ( !(( !s1_l2) && (s1_l0 && ( !s1_l1)))))) && ((s1_x <= 120.0) || ( !(( !s1_l2) && (s1_l1 && ( !s1_l0)))))) && ((s1_x <= 120.0) || ( !(s1_l2 && (s1_l0 && ( !s1_l1)))))) && (((((((((( !s0_evt0) && ( !s0_evt1)) || (s0_evt0 && ( !s0_evt1))) || ((s0_evt1 && ( !s0_evt0)) || (s0_evt0 && s0_evt1))) && ((((( !s0_l2) && (( !s0_l0) && ( !s0_l1))) || (( !s0_l2) && (s0_l0 && ( !s0_l1)))) || ((( !s0_l2) && (s0_l1 && ( !s0_l0))) || (( !s0_l2) && (s0_l0 && s0_l1)))) || ((s0_l2 && (( !s0_l0) && ( !s0_l1))) || (s0_l2 && (s0_l0 && ( !s0_l1)))))) && (((( !s0_l2) && (( !s0_l0) && ( !s0_l1))) && (s0_x == 0.0)) && ((s0_y == 0.0) && (s0_z == 0.0)))) && ((s0_x <= 20.0) || ( !(( !s0_l2) && (s0_l0 && ( !s0_l1)))))) && ((s0_x <= 120.0) || ( !(( !s0_l2) && (s0_l1 && ( !s0_l0)))))) && ((s0_x <= 120.0) || ( !(s0_l2 && (s0_l0 && ( !s0_l1)))))) && ((((((r_l && ((r_counter == 0) && (r_x == 0.0))) && ((( !r_event0) && ( !r_event1)) || ((r_event0 && ( !r_event1)) || (r_event1 && ( !r_event0))))) && (((((((((((((((((((((r_evt_id == 0) || (r_evt_id == 1)) || (r_evt_id == 2)) || (r_evt_id == 3)) || (r_evt_id == 4)) || (r_evt_id == 5)) || (r_evt_id == 6)) || (r_evt_id == 7)) || (r_evt_id == 8)) || (r_evt_id == 9)) || (r_evt_id == 10)) || (r_evt_id == 11)) || (r_evt_id == 12)) || (r_evt_id == 13)) || (r_evt_id == 14)) || (r_evt_id == 15)) || (r_evt_id == 16)) || (r_evt_id == 17)) || (r_evt_id == 18)) || (r_evt_id == 19)) || (r_evt_id == 20))) && (((((((((((((((((((((r_counter == 0) || (r_counter == 1)) || (r_counter == 2)) || (r_counter == 3)) || (r_counter == 4)) || (r_counter == 5)) || (r_counter == 6)) || (r_counter == 7)) || (r_counter == 8)) || (r_counter == 9)) || (r_counter == 10)) || (r_counter == 11)) || (r_counter == 12)) || (r_counter == 13)) || (r_counter == 14)) || (r_counter == 15)) || (r_counter == 16)) || (r_counter == 17)) || (r_counter == 18)) || (r_counter == 19)) || (r_counter == 20))) && (( !r_l) || (r_x <= 0.0))) && (0.0 <= delta))))))))))))))))))))))) && (delta == _diverge_delta)) && ((((( !(( !(_EL_U_5117 || ( !((s0_l2 && (s0_l0 && ( !s0_l1))) || _EL_U_5115)))) || (_EL_U_5113 || ( !((1.0 <= _diverge_delta) || _EL_U_5111))))) && ( !_J5137)) && ( !_J5143)) && ( !_J5149)) && ( !_J5155)));
while (__steps_to_fair >= 0 && __ok) {
if ((((_J5137 && _J5143) && _J5149) && _J5155)) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x_s16_x = __VERIFIER_nondet_float();
_x_s16_l1 = __VERIFIER_nondet_bool();
_x__diverge_delta = __VERIFIER_nondet_float();
_x_delta = __VERIFIER_nondet_float();
_x_r_x = __VERIFIER_nondet_float();
_x_s7_l1 = __VERIFIER_nondet_bool();
_x_r_l = __VERIFIER_nondet_bool();
_x_s7_l0 = __VERIFIER_nondet_bool();
_x_s16_z = __VERIFIER_nondet_float();
_x_s7_l2 = __VERIFIER_nondet_bool();
_x_s16_y = __VERIFIER_nondet_float();
_x_r_counter = __VERIFIER_nondet_int();
_x_s7_x = __VERIFIER_nondet_float();
_x_s7_z = __VERIFIER_nondet_float();
_x_s16_evt1 = __VERIFIER_nondet_bool();
_x_s16_evt0 = __VERIFIER_nondet_bool();
_x_s7_y = __VERIFIER_nondet_float();
_x_s17_l1 = __VERIFIER_nondet_bool();
_x_s7_evt1 = __VERIFIER_nondet_bool();
_x_s17_l0 = __VERIFIER_nondet_bool();
_x_s7_evt0 = __VERIFIER_nondet_bool();
_x_s17_l2 = __VERIFIER_nondet_bool();
_x_s17_x = __VERIFIER_nondet_float();
_x_s8_l1 = __VERIFIER_nondet_bool();
_x_s8_l0 = __VERIFIER_nondet_bool();
_x_s17_z = __VERIFIER_nondet_float();
_x_s8_l2 = __VERIFIER_nondet_bool();
_x_s17_y = __VERIFIER_nondet_float();
_x_s8_x = __VERIFIER_nondet_float();
_x_r_evt_id = __VERIFIER_nondet_int();
_x_s8_z = __VERIFIER_nondet_float();
_x_s17_evt1 = __VERIFIER_nondet_bool();
_x_s17_evt0 = __VERIFIER_nondet_bool();
_x_s8_y = __VERIFIER_nondet_float();
_x_s18_l1 = __VERIFIER_nondet_bool();
_x_s8_evt1 = __VERIFIER_nondet_bool();
_x_s18_l0 = __VERIFIER_nondet_bool();
_x_s8_evt0 = __VERIFIER_nondet_bool();
_x_s18_l2 = __VERIFIER_nondet_bool();
_x_s18_x = __VERIFIER_nondet_float();
_x_r_event0 = __VERIFIER_nondet_bool();
_x_r_event1 = __VERIFIER_nondet_bool();
_x_s9_l1 = __VERIFIER_nondet_bool();
_x_s9_l0 = __VERIFIER_nondet_bool();
_x_s18_z = __VERIFIER_nondet_float();
_x_s9_l2 = __VERIFIER_nondet_bool();
_x_s18_y = __VERIFIER_nondet_float();
_x_s9_x = __VERIFIER_nondet_float();
_x_s0_l1 = __VERIFIER_nondet_bool();
_x_s0_l0 = __VERIFIER_nondet_bool();
_x_s0_l2 = __VERIFIER_nondet_bool();
_x_s9_z = __VERIFIER_nondet_float();
_x_s18_evt1 = __VERIFIER_nondet_bool();
_x_s18_evt0 = __VERIFIER_nondet_bool();
_x_s9_y = __VERIFIER_nondet_float();
_x_s0_x = __VERIFIER_nondet_float();
_x_s0_z = __VERIFIER_nondet_float();
_x_s19_l1 = __VERIFIER_nondet_bool();
_x_s9_evt1 = __VERIFIER_nondet_bool();
_x_s19_l0 = __VERIFIER_nondet_bool();
_x_s9_evt0 = __VERIFIER_nondet_bool();
_x_s19_l2 = __VERIFIER_nondet_bool();
_x_s0_y = __VERIFIER_nondet_float();
_x_s19_x = __VERIFIER_nondet_float();
_x_s10_l1 = __VERIFIER_nondet_bool();
_x_s0_evt1 = __VERIFIER_nondet_bool();
_x_s10_l0 = __VERIFIER_nondet_bool();
_x_s19_z = __VERIFIER_nondet_float();
_x_s0_evt0 = __VERIFIER_nondet_bool();
_x_s19_y = __VERIFIER_nondet_float();
_x_s10_l2 = __VERIFIER_nondet_bool();
_x_s10_x = __VERIFIER_nondet_float();
_x_s1_l1 = __VERIFIER_nondet_bool();
_x_s1_l0 = __VERIFIER_nondet_bool();
_x_s10_z = __VERIFIER_nondet_float();
_x_s19_evt1 = __VERIFIER_nondet_bool();
_x_s19_evt0 = __VERIFIER_nondet_bool();
_x_s1_l2 = __VERIFIER_nondet_bool();
_x_s10_y = __VERIFIER_nondet_float();
_x_s1_x = __VERIFIER_nondet_float();
_x_s1_z = __VERIFIER_nondet_float();
_x_s20_l1 = __VERIFIER_nondet_bool();
_x_s10_evt1 = __VERIFIER_nondet_bool();
_x_s20_l0 = __VERIFIER_nondet_bool();
_x_s10_evt0 = __VERIFIER_nondet_bool();
_x_s20_l2 = __VERIFIER_nondet_bool();
_x_s1_y = __VERIFIER_nondet_float();
_x_s20_x = __VERIFIER_nondet_float();
_x_s11_l1 = __VERIFIER_nondet_bool();
_x_s1_evt1 = __VERIFIER_nondet_bool();
_x_s11_l0 = __VERIFIER_nondet_bool();
_x_s20_z = __VERIFIER_nondet_float();
_x_s1_evt0 = __VERIFIER_nondet_bool();
_x_s20_y = __VERIFIER_nondet_float();
_x_s11_l2 = __VERIFIER_nondet_bool();
_x_s11_x = __VERIFIER_nondet_float();
_x_s2_l1 = __VERIFIER_nondet_bool();
_x_s2_l0 = __VERIFIER_nondet_bool();
_x_s11_z = __VERIFIER_nondet_float();
_x_s20_evt1 = __VERIFIER_nondet_bool();
_x_s20_evt0 = __VERIFIER_nondet_bool();
_x_s2_l2 = __VERIFIER_nondet_bool();
_x_s11_y = __VERIFIER_nondet_float();
_x_s2_x = __VERIFIER_nondet_float();
_x_s2_z = __VERIFIER_nondet_float();
_x_s11_evt1 = __VERIFIER_nondet_bool();
_x_s11_evt0 = __VERIFIER_nondet_bool();
_x_s2_y = __VERIFIER_nondet_float();
_x__J5155 = __VERIFIER_nondet_bool();
_x__J5149 = __VERIFIER_nondet_bool();
_x__J5143 = __VERIFIER_nondet_bool();
_x__J5137 = __VERIFIER_nondet_bool();
_x__EL_U_5111 = __VERIFIER_nondet_bool();
_x__EL_U_5113 = __VERIFIER_nondet_bool();
_x__EL_U_5115 = __VERIFIER_nondet_bool();
_x_s12_l1 = __VERIFIER_nondet_bool();
_x_s2_evt1 = __VERIFIER_nondet_bool();
_x_s12_l0 = __VERIFIER_nondet_bool();
_x_s2_evt0 = __VERIFIER_nondet_bool();
_x_s12_l2 = __VERIFIER_nondet_bool();
_x__EL_U_5117 = __VERIFIER_nondet_bool();
_x_s12_x = __VERIFIER_nondet_float();
_x_s3_l1 = __VERIFIER_nondet_bool();
_x_s3_l0 = __VERIFIER_nondet_bool();
_x_s12_z = __VERIFIER_nondet_float();
_x_s3_l2 = __VERIFIER_nondet_bool();
_x_s12_y = __VERIFIER_nondet_float();
_x_s3_x = __VERIFIER_nondet_float();
_x_s3_z = __VERIFIER_nondet_float();
_x_s12_evt1 = __VERIFIER_nondet_bool();
_x_s12_evt0 = __VERIFIER_nondet_bool();
_x_s3_y = __VERIFIER_nondet_float();
_x_s13_l1 = __VERIFIER_nondet_bool();
_x_s3_evt1 = __VERIFIER_nondet_bool();
_x_s13_l0 = __VERIFIER_nondet_bool();
_x_s3_evt0 = __VERIFIER_nondet_bool();
_x_s13_l2 = __VERIFIER_nondet_bool();
_x_s13_x = __VERIFIER_nondet_float();
_x_s4_l1 = __VERIFIER_nondet_bool();
_x_s4_l0 = __VERIFIER_nondet_bool();
_x_s13_z = __VERIFIER_nondet_float();
_x_s4_l2 = __VERIFIER_nondet_bool();
_x_s13_y = __VERIFIER_nondet_float();
_x_s4_x = __VERIFIER_nondet_float();
_x_s4_z = __VERIFIER_nondet_float();
_x_s13_evt1 = __VERIFIER_nondet_bool();
_x_s13_evt0 = __VERIFIER_nondet_bool();
_x_s4_y = __VERIFIER_nondet_float();
_x_s14_l1 = __VERIFIER_nondet_bool();
_x_s4_evt1 = __VERIFIER_nondet_bool();
_x_s14_l0 = __VERIFIER_nondet_bool();
_x_s4_evt0 = __VERIFIER_nondet_bool();
_x_s14_l2 = __VERIFIER_nondet_bool();
_x_s14_x = __VERIFIER_nondet_float();
_x_s5_l1 = __VERIFIER_nondet_bool();
_x_s5_l0 = __VERIFIER_nondet_bool();
_x_s14_z = __VERIFIER_nondet_float();
_x_s5_l2 = __VERIFIER_nondet_bool();
_x_s14_y = __VERIFIER_nondet_float();
_x_s5_x = __VERIFIER_nondet_float();
_x_s5_z = __VERIFIER_nondet_float();
_x_s14_evt1 = __VERIFIER_nondet_bool();
_x_s14_evt0 = __VERIFIER_nondet_bool();
_x_s5_y = __VERIFIER_nondet_float();
_x_s15_l1 = __VERIFIER_nondet_bool();
_x_s5_evt1 = __VERIFIER_nondet_bool();
_x_s15_l0 = __VERIFIER_nondet_bool();
_x_s5_evt0 = __VERIFIER_nondet_bool();
_x_s15_l2 = __VERIFIER_nondet_bool();
_x_s15_x = __VERIFIER_nondet_float();
_x_s6_l1 = __VERIFIER_nondet_bool();
_x_s6_l0 = __VERIFIER_nondet_bool();
_x_s15_z = __VERIFIER_nondet_float();
_x_s6_l2 = __VERIFIER_nondet_bool();
_x_s15_y = __VERIFIER_nondet_float();
_x_s6_x = __VERIFIER_nondet_float();
_x_s6_z = __VERIFIER_nondet_float();
_x_s15_evt1 = __VERIFIER_nondet_bool();
_x_s15_evt0 = __VERIFIER_nondet_bool();
_x_s6_y = __VERIFIER_nondet_float();
_x_s6_evt1 = __VERIFIER_nondet_bool();
_x_s6_evt0 = __VERIFIER_nondet_bool();
_x_s16_l0 = __VERIFIER_nondet_bool();
_x_s16_l2 = __VERIFIER_nondet_bool();
__ok = (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( !_x_s20_evt0) && ( !_x_s20_evt1)) || (_x_s20_evt0 && ( !_x_s20_evt1))) || ((_x_s20_evt1 && ( !_x_s20_evt0)) || (_x_s20_evt0 && _x_s20_evt1))) && ((((( !_x_s20_l2) && (( !_x_s20_l0) && ( !_x_s20_l1))) || (( !_x_s20_l2) && (_x_s20_l0 && ( !_x_s20_l1)))) || ((( !_x_s20_l2) && (_x_s20_l1 && ( !_x_s20_l0))) || (( !_x_s20_l2) && (_x_s20_l0 && _x_s20_l1)))) || ((_x_s20_l2 && (( !_x_s20_l0) && ( !_x_s20_l1))) || (_x_s20_l2 && (_x_s20_l0 && ( !_x_s20_l1)))))) && ((_x_s20_x <= 20.0) || ( !(( !_x_s20_l2) && (_x_s20_l0 && ( !_x_s20_l1)))))) && ((_x_s20_x <= 120.0) || ( !(( !_x_s20_l2) && (_x_s20_l1 && ( !_x_s20_l0)))))) && ((_x_s20_x <= 120.0) || ( !(_x_s20_l2 && (_x_s20_l0 && ( !_x_s20_l1)))))) && ((delta <= 0.0) || ((((delta + (s20_x + (-1.0 * _x_s20_x))) == 0.0) && ((delta + (s20_y + (-1.0 * _x_s20_y))) == 0.0)) && ((((s20_l0 == _x_s20_l0) && (s20_l1 == _x_s20_l1)) && (s20_l2 == _x_s20_l2)) && ((delta + (s20_z + (-1.0 * _x_s20_z))) == 0.0))))) && ((((((s20_l0 == _x_s20_l0) && (s20_l1 == _x_s20_l1)) && (s20_l2 == _x_s20_l2)) && ((delta + (s20_x + (-1.0 * _x_s20_x))) == 0.0)) && (((delta + (s20_y + (-1.0 * _x_s20_y))) == 0.0) && ((delta + (s20_z + (-1.0 * _x_s20_z))) == 0.0))) || ( !(( !s20_evt0) && ( !s20_evt1))))) && (((((s20_evt0 && s20_evt1) && (( !_x_s20_l2) && (_x_s20_l0 && ( !_x_s20_l1)))) && ((_x_s20_x == 0.0) && (_x_s20_y == 0.0))) && (s20_z == _x_s20_z)) || ( !((( !s20_l2) && (( !s20_l0) && ( !s20_l1))) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && (((((( !_x_s20_l2) && (_x_s20_l1 && ( !_x_s20_l0))) || (( !_x_s20_l2) && (_x_s20_l0 && _x_s20_l1))) && (s20_x == _x_s20_x)) && ((s20_z == _x_s20_z) && (s20_y == _x_s20_y))) || ( !((( !s20_l2) && (s20_l0 && ( !s20_l1))) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && (((s20_evt0 && ( !s20_evt1)) && ((20.0 <= s20_x) && ( !(120.0 <= s20_z)))) || ( !(((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))) && ((( !s20_l2) && (s20_l0 && ( !s20_l1))) && (( !_x_s20_l2) && (_x_s20_l1 && ( !_x_s20_l0)))))))) && (((s20_evt1 && ( !s20_evt0)) && ((20.0 <= s20_x) && (120.0 <= s20_z))) || ( !(((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))) && ((( !s20_l2) && (s20_l0 && ( !s20_l1))) && (( !_x_s20_l2) && (_x_s20_l0 && _x_s20_l1))))))) && (((s20_z == _x_s20_z) && (((s20_evt1 && ( !s20_evt0)) && (( !_x_s20_l2) && (_x_s20_l0 && _x_s20_l1))) && ((s20_x == _x_s20_x) && (s20_y == _x_s20_y)))) || ( !((( !s20_l2) && (s20_l1 && ( !s20_l0))) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && (((((s20_evt0 && s20_evt1) && (_x_s20_l2 && (( !_x_s20_l0) && ( !_x_s20_l1)))) && ((_x_s20_x == 0.0) && (s20_y == _x_s20_y))) && (_x_s20_z == 0.0)) || ( !((( !s20_l2) && (s20_l0 && s20_l1)) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && ((((s20_x == _x_s20_x) && (s20_y == _x_s20_y)) && ((s20_z == _x_s20_z) && ((( !_x_s20_l2) && (( !_x_s20_l0) && ( !_x_s20_l1))) || (_x_s20_l2 && (_x_s20_l0 && ( !_x_s20_l1)))))) || ( !((s20_l2 && (( !s20_l0) && ( !s20_l1))) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && (((s20_evt0 && ( !s20_evt1)) && ((20.0 <= s20_x) && ( !(120.0 <= s20_y)))) || ( !(((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))) && ((s20_l2 && (( !s20_l0) && ( !s20_l1))) && (_x_s20_l2 && (_x_s20_l0 && ( !_x_s20_l1)))))))) && (((s20_evt1 && ( !s20_evt0)) && ((20.0 <= s20_x) && (120.0 <= s20_y))) || ( !(((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))) && ((( !_x_s20_l2) && (( !_x_s20_l0) && ( !_x_s20_l1))) && (s20_l2 && (( !s20_l0) && ( !s20_l1)))))))) && (((s20_z == _x_s20_z) && (((s20_x == _x_s20_x) && (s20_y == _x_s20_y)) && ((s20_evt1 && ( !s20_evt0)) && (( !_x_s20_l2) && (( !_x_s20_l0) && ( !_x_s20_l1)))))) || ( !((s20_l2 && (s20_l0 && ( !s20_l1))) && ((delta == 0.0) && ( !(( !s20_evt0) && ( !s20_evt1)))))))) && ((((((((((((((((((((( !_x_s19_evt0) && ( !_x_s19_evt1)) || (_x_s19_evt0 && ( !_x_s19_evt1))) || ((_x_s19_evt1 && ( !_x_s19_evt0)) || (_x_s19_evt0 && _x_s19_evt1))) && ((((( !_x_s19_l2) && (( !_x_s19_l0) && ( !_x_s19_l1))) || (( !_x_s19_l2) && (_x_s19_l0 && ( !_x_s19_l1)))) || ((( !_x_s19_l2) && (_x_s19_l1 && ( !_x_s19_l0))) || (( !_x_s19_l2) && (_x_s19_l0 && _x_s19_l1)))) || ((_x_s19_l2 && (( !_x_s19_l0) && ( !_x_s19_l1))) || (_x_s19_l2 && (_x_s19_l0 && ( !_x_s19_l1)))))) && ((_x_s19_x <= 20.0) || ( !(( !_x_s19_l2) && (_x_s19_l0 && ( !_x_s19_l1)))))) && ((_x_s19_x <= 120.0) || ( !(( !_x_s19_l2) && (_x_s19_l1 && ( !_x_s19_l0)))))) && ((_x_s19_x <= 120.0) || ( !(_x_s19_l2 && (_x_s19_l0 && ( !_x_s19_l1)))))) && ((delta <= 0.0) || ((((delta + (s19_x + (-1.0 * _x_s19_x))) == 0.0) && ((delta + (s19_y + (-1.0 * _x_s19_y))) == 0.0)) && ((((s19_l0 == _x_s19_l0) && (s19_l1 == _x_s19_l1)) && (s19_l2 == _x_s19_l2)) && ((delta + (s19_z + (-1.0 * _x_s19_z))) == 0.0))))) && ((((((s19_l0 == _x_s19_l0) && (s19_l1 == _x_s19_l1)) && (s19_l2 == _x_s19_l2)) && ((delta + (s19_x + (-1.0 * _x_s19_x))) == 0.0)) && (((delta + (s19_y + (-1.0 * _x_s19_y))) == 0.0) && ((delta + (s19_z + (-1.0 * _x_s19_z))) == 0.0))) || ( !(( !s19_evt0) && ( !s19_evt1))))) && (((((s19_evt0 && s19_evt1) && (( !_x_s19_l2) && (_x_s19_l0 && ( !_x_s19_l1)))) && ((_x_s19_x == 0.0) && (_x_s19_y == 0.0))) && (s19_z == _x_s19_z)) || ( !((( !s19_l2) && (( !s19_l0) && ( !s19_l1))) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && (((((( !_x_s19_l2) && (_x_s19_l1 && ( !_x_s19_l0))) || (( !_x_s19_l2) && (_x_s19_l0 && _x_s19_l1))) && (s19_x == _x_s19_x)) && ((s19_z == _x_s19_z) && (s19_y == _x_s19_y))) || ( !((( !s19_l2) && (s19_l0 && ( !s19_l1))) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && (((s19_evt0 && ( !s19_evt1)) && ((20.0 <= s19_x) && ( !(120.0 <= s19_z)))) || ( !(((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))) && ((( !s19_l2) && (s19_l0 && ( !s19_l1))) && (( !_x_s19_l2) && (_x_s19_l1 && ( !_x_s19_l0)))))))) && (((s19_evt1 && ( !s19_evt0)) && ((20.0 <= s19_x) && (120.0 <= s19_z))) || ( !(((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))) && ((( !s19_l2) && (s19_l0 && ( !s19_l1))) && (( !_x_s19_l2) && (_x_s19_l0 && _x_s19_l1))))))) && (((s19_z == _x_s19_z) && (((s19_evt1 && ( !s19_evt0)) && (( !_x_s19_l2) && (_x_s19_l0 && _x_s19_l1))) && ((s19_x == _x_s19_x) && (s19_y == _x_s19_y)))) || ( !((( !s19_l2) && (s19_l1 && ( !s19_l0))) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && (((((s19_evt0 && s19_evt1) && (_x_s19_l2 && (( !_x_s19_l0) && ( !_x_s19_l1)))) && ((_x_s19_x == 0.0) && (s19_y == _x_s19_y))) && (_x_s19_z == 0.0)) || ( !((( !s19_l2) && (s19_l0 && s19_l1)) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && ((((s19_x == _x_s19_x) && (s19_y == _x_s19_y)) && ((s19_z == _x_s19_z) && ((( !_x_s19_l2) && (( !_x_s19_l0) && ( !_x_s19_l1))) || (_x_s19_l2 && (_x_s19_l0 && ( !_x_s19_l1)))))) || ( !((s19_l2 && (( !s19_l0) && ( !s19_l1))) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && (((s19_evt0 && ( !s19_evt1)) && ((20.0 <= s19_x) && ( !(120.0 <= s19_y)))) || ( !(((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))) && ((s19_l2 && (( !s19_l0) && ( !s19_l1))) && (_x_s19_l2 && (_x_s19_l0 && ( !_x_s19_l1)))))))) && (((s19_evt1 && ( !s19_evt0)) && ((20.0 <= s19_x) && (120.0 <= s19_y))) || ( !(((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))) && ((( !_x_s19_l2) && (( !_x_s19_l0) && ( !_x_s19_l1))) && (s19_l2 && (( !s19_l0) && ( !s19_l1)))))))) && (((s19_z == _x_s19_z) && (((s19_x == _x_s19_x) && (s19_y == _x_s19_y)) && ((s19_evt1 && ( !s19_evt0)) && (( !_x_s19_l2) && (( !_x_s19_l0) && ( !_x_s19_l1)))))) || ( !((s19_l2 && (s19_l0 && ( !s19_l1))) && ((delta == 0.0) && ( !(( !s19_evt0) && ( !s19_evt1)))))))) && ((((((((((((((((((((( !_x_s18_evt0) && ( !_x_s18_evt1)) || (_x_s18_evt0 && ( !_x_s18_evt1))) || ((_x_s18_evt1 && ( !_x_s18_evt0)) || (_x_s18_evt0 && _x_s18_evt1))) && ((((( !_x_s18_l2) && (( !_x_s18_l0) && ( !_x_s18_l1))) || (( !_x_s18_l2) && (_x_s18_l0 && ( !_x_s18_l1)))) || ((( !_x_s18_l2) && (_x_s18_l1 && ( !_x_s18_l0))) || (( !_x_s18_l2) && (_x_s18_l0 && _x_s18_l1)))) || ((_x_s18_l2 && (( !_x_s18_l0) && ( !_x_s18_l1))) || (_x_s18_l2 && (_x_s18_l0 && ( !_x_s18_l1)))))) && ((_x_s18_x <= 20.0) || ( !(( !_x_s18_l2) && (_x_s18_l0 && ( !_x_s18_l1)))))) && ((_x_s18_x <= 120.0) || ( !(( !_x_s18_l2) && (_x_s18_l1 && ( !_x_s18_l0)))))) && ((_x_s18_x <= 120.0) || ( !(_x_s18_l2 && (_x_s18_l0 && ( !_x_s18_l1)))))) && ((delta <= 0.0) || ((((delta + (s18_x + (-1.0 * _x_s18_x))) == 0.0) && ((delta + (s18_y + (-1.0 * _x_s18_y))) == 0.0)) && ((((s18_l0 == _x_s18_l0) && (s18_l1 == _x_s18_l1)) && (s18_l2 == _x_s18_l2)) && ((delta + (s18_z + (-1.0 * _x_s18_z))) == 0.0))))) && ((((((s18_l0 == _x_s18_l0) && (s18_l1 == _x_s18_l1)) && (s18_l2 == _x_s18_l2)) && ((delta + (s18_x + (-1.0 * _x_s18_x))) == 0.0)) && (((delta + (s18_y + (-1.0 * _x_s18_y))) == 0.0) && ((delta + (s18_z + (-1.0 * _x_s18_z))) == 0.0))) || ( !(( !s18_evt0) && ( !s18_evt1))))) && (((((s18_evt0 && s18_evt1) && (( !_x_s18_l2) && (_x_s18_l0 && ( !_x_s18_l1)))) && ((_x_s18_x == 0.0) && (_x_s18_y == 0.0))) && (s18_z == _x_s18_z)) || ( !((( !s18_l2) && (( !s18_l0) && ( !s18_l1))) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && (((((( !_x_s18_l2) && (_x_s18_l1 && ( !_x_s18_l0))) || (( !_x_s18_l2) && (_x_s18_l0 && _x_s18_l1))) && (s18_x == _x_s18_x)) && ((s18_z == _x_s18_z) && (s18_y == _x_s18_y))) || ( !((( !s18_l2) && (s18_l0 && ( !s18_l1))) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && (((s18_evt0 && ( !s18_evt1)) && ((20.0 <= s18_x) && ( !(120.0 <= s18_z)))) || ( !(((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))) && ((( !s18_l2) && (s18_l0 && ( !s18_l1))) && (( !_x_s18_l2) && (_x_s18_l1 && ( !_x_s18_l0)))))))) && (((s18_evt1 && ( !s18_evt0)) && ((20.0 <= s18_x) && (120.0 <= s18_z))) || ( !(((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))) && ((( !s18_l2) && (s18_l0 && ( !s18_l1))) && (( !_x_s18_l2) && (_x_s18_l0 && _x_s18_l1))))))) && (((s18_z == _x_s18_z) && (((s18_evt1 && ( !s18_evt0)) && (( !_x_s18_l2) && (_x_s18_l0 && _x_s18_l1))) && ((s18_x == _x_s18_x) && (s18_y == _x_s18_y)))) || ( !((( !s18_l2) && (s18_l1 && ( !s18_l0))) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && (((((s18_evt0 && s18_evt1) && (_x_s18_l2 && (( !_x_s18_l0) && ( !_x_s18_l1)))) && ((_x_s18_x == 0.0) && (s18_y == _x_s18_y))) && (_x_s18_z == 0.0)) || ( !((( !s18_l2) && (s18_l0 && s18_l1)) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && ((((s18_x == _x_s18_x) && (s18_y == _x_s18_y)) && ((s18_z == _x_s18_z) && ((( !_x_s18_l2) && (( !_x_s18_l0) && ( !_x_s18_l1))) || (_x_s18_l2 && (_x_s18_l0 && ( !_x_s18_l1)))))) || ( !((s18_l2 && (( !s18_l0) && ( !s18_l1))) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && (((s18_evt0 && ( !s18_evt1)) && ((20.0 <= s18_x) && ( !(120.0 <= s18_y)))) || ( !(((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))) && ((s18_l2 && (( !s18_l0) && ( !s18_l1))) && (_x_s18_l2 && (_x_s18_l0 && ( !_x_s18_l1)))))))) && (((s18_evt1 && ( !s18_evt0)) && ((20.0 <= s18_x) && (120.0 <= s18_y))) || ( !(((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))) && ((( !_x_s18_l2) && (( !_x_s18_l0) && ( !_x_s18_l1))) && (s18_l2 && (( !s18_l0) && ( !s18_l1)))))))) && (((s18_z == _x_s18_z) && (((s18_x == _x_s18_x) && (s18_y == _x_s18_y)) && ((s18_evt1 && ( !s18_evt0)) && (( !_x_s18_l2) && (( !_x_s18_l0) && ( !_x_s18_l1)))))) || ( !((s18_l2 && (s18_l0 && ( !s18_l1))) && ((delta == 0.0) && ( !(( !s18_evt0) && ( !s18_evt1)))))))) && ((((((((((((((((((((( !_x_s17_evt0) && ( !_x_s17_evt1)) || (_x_s17_evt0 && ( !_x_s17_evt1))) || ((_x_s17_evt1 && ( !_x_s17_evt0)) || (_x_s17_evt0 && _x_s17_evt1))) && ((((( !_x_s17_l2) && (( !_x_s17_l0) && ( !_x_s17_l1))) || (( !_x_s17_l2) && (_x_s17_l0 && ( !_x_s17_l1)))) || ((( !_x_s17_l2) && (_x_s17_l1 && ( !_x_s17_l0))) || (( !_x_s17_l2) && (_x_s17_l0 && _x_s17_l1)))) || ((_x_s17_l2 && (( !_x_s17_l0) && ( !_x_s17_l1))) || (_x_s17_l2 && (_x_s17_l0 && ( !_x_s17_l1)))))) && ((_x_s17_x <= 20.0) || ( !(( !_x_s17_l2) && (_x_s17_l0 && ( !_x_s17_l1)))))) && ((_x_s17_x <= 120.0) || ( !(( !_x_s17_l2) && (_x_s17_l1 && ( !_x_s17_l0)))))) && ((_x_s17_x <= 120.0) || ( !(_x_s17_l2 && (_x_s17_l0 && ( !_x_s17_l1)))))) && ((delta <= 0.0) || ((((delta + (s17_x + (-1.0 * _x_s17_x))) == 0.0) && ((delta + (s17_y + (-1.0 * _x_s17_y))) == 0.0)) && ((((s17_l0 == _x_s17_l0) && (s17_l1 == _x_s17_l1)) && (s17_l2 == _x_s17_l2)) && ((delta + (s17_z + (-1.0 * _x_s17_z))) == 0.0))))) && ((((((s17_l0 == _x_s17_l0) && (s17_l1 == _x_s17_l1)) && (s17_l2 == _x_s17_l2)) && ((delta + (s17_x + (-1.0 * _x_s17_x))) == 0.0)) && (((delta + (s17_y + (-1.0 * _x_s17_y))) == 0.0) && ((delta + (s17_z + (-1.0 * _x_s17_z))) == 0.0))) || ( !(( !s17_evt0) && ( !s17_evt1))))) && (((((s17_evt0 && s17_evt1) && (( !_x_s17_l2) && (_x_s17_l0 && ( !_x_s17_l1)))) && ((_x_s17_x == 0.0) && (_x_s17_y == 0.0))) && (s17_z == _x_s17_z)) || ( !((( !s17_l2) && (( !s17_l0) && ( !s17_l1))) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && (((((( !_x_s17_l2) && (_x_s17_l1 && ( !_x_s17_l0))) || (( !_x_s17_l2) && (_x_s17_l0 && _x_s17_l1))) && (s17_x == _x_s17_x)) && ((s17_z == _x_s17_z) && (s17_y == _x_s17_y))) || ( !((( !s17_l2) && (s17_l0 && ( !s17_l1))) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && (((s17_evt0 && ( !s17_evt1)) && ((20.0 <= s17_x) && ( !(120.0 <= s17_z)))) || ( !(((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))) && ((( !s17_l2) && (s17_l0 && ( !s17_l1))) && (( !_x_s17_l2) && (_x_s17_l1 && ( !_x_s17_l0)))))))) && (((s17_evt1 && ( !s17_evt0)) && ((20.0 <= s17_x) && (120.0 <= s17_z))) || ( !(((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))) && ((( !s17_l2) && (s17_l0 && ( !s17_l1))) && (( !_x_s17_l2) && (_x_s17_l0 && _x_s17_l1))))))) && (((s17_z == _x_s17_z) && (((s17_evt1 && ( !s17_evt0)) && (( !_x_s17_l2) && (_x_s17_l0 && _x_s17_l1))) && ((s17_x == _x_s17_x) && (s17_y == _x_s17_y)))) || ( !((( !s17_l2) && (s17_l1 && ( !s17_l0))) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && (((((s17_evt0 && s17_evt1) && (_x_s17_l2 && (( !_x_s17_l0) && ( !_x_s17_l1)))) && ((_x_s17_x == 0.0) && (s17_y == _x_s17_y))) && (_x_s17_z == 0.0)) || ( !((( !s17_l2) && (s17_l0 && s17_l1)) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && ((((s17_x == _x_s17_x) && (s17_y == _x_s17_y)) && ((s17_z == _x_s17_z) && ((( !_x_s17_l2) && (( !_x_s17_l0) && ( !_x_s17_l1))) || (_x_s17_l2 && (_x_s17_l0 && ( !_x_s17_l1)))))) || ( !((s17_l2 && (( !s17_l0) && ( !s17_l1))) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && (((s17_evt0 && ( !s17_evt1)) && ((20.0 <= s17_x) && ( !(120.0 <= s17_y)))) || ( !(((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))) && ((s17_l2 && (( !s17_l0) && ( !s17_l1))) && (_x_s17_l2 && (_x_s17_l0 && ( !_x_s17_l1)))))))) && (((s17_evt1 && ( !s17_evt0)) && ((20.0 <= s17_x) && (120.0 <= s17_y))) || ( !(((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))) && ((( !_x_s17_l2) && (( !_x_s17_l0) && ( !_x_s17_l1))) && (s17_l2 && (( !s17_l0) && ( !s17_l1)))))))) && (((s17_z == _x_s17_z) && (((s17_x == _x_s17_x) && (s17_y == _x_s17_y)) && ((s17_evt1 && ( !s17_evt0)) && (( !_x_s17_l2) && (( !_x_s17_l0) && ( !_x_s17_l1)))))) || ( !((s17_l2 && (s17_l0 && ( !s17_l1))) && ((delta == 0.0) && ( !(( !s17_evt0) && ( !s17_evt1)))))))) && ((((((((((((((((((((( !_x_s16_evt0) && ( !_x_s16_evt1)) || (_x_s16_evt0 && ( !_x_s16_evt1))) || ((_x_s16_evt1 && ( !_x_s16_evt0)) || (_x_s16_evt0 && _x_s16_evt1))) && ((((( !_x_s16_l2) && (( !_x_s16_l0) && ( !_x_s16_l1))) || (( !_x_s16_l2) && (_x_s16_l0 && ( !_x_s16_l1)))) || ((( !_x_s16_l2) && (_x_s16_l1 && ( !_x_s16_l0))) || (( !_x_s16_l2) && (_x_s16_l0 && _x_s16_l1)))) || ((_x_s16_l2 && (( !_x_s16_l0) && ( !_x_s16_l1))) || (_x_s16_l2 && (_x_s16_l0 && ( !_x_s16_l1)))))) && ((_x_s16_x <= 20.0) || ( !(( !_x_s16_l2) && (_x_s16_l0 && ( !_x_s16_l1)))))) && ((_x_s16_x <= 120.0) || ( !(( !_x_s16_l2) && (_x_s16_l1 && ( !_x_s16_l0)))))) && ((_x_s16_x <= 120.0) || ( !(_x_s16_l2 && (_x_s16_l0 && ( !_x_s16_l1)))))) && ((delta <= 0.0) || ((((delta + (s16_x + (-1.0 * _x_s16_x))) == 0.0) && ((delta + (s16_y + (-1.0 * _x_s16_y))) == 0.0)) && ((((s16_l0 == _x_s16_l0) && (s16_l1 == _x_s16_l1)) && (s16_l2 == _x_s16_l2)) && ((delta + (s16_z + (-1.0 * _x_s16_z))) == 0.0))))) && ((((((s16_l0 == _x_s16_l0) && (s16_l1 == _x_s16_l1)) && (s16_l2 == _x_s16_l2)) && ((delta + (s16_x + (-1.0 * _x_s16_x))) == 0.0)) && (((delta + (s16_y + (-1.0 * _x_s16_y))) == 0.0) && ((delta + (s16_z + (-1.0 * _x_s16_z))) == 0.0))) || ( !(( !s16_evt0) && ( !s16_evt1))))) && (((((s16_evt0 && s16_evt1) && (( !_x_s16_l2) && (_x_s16_l0 && ( !_x_s16_l1)))) && ((_x_s16_x == 0.0) && (_x_s16_y == 0.0))) && (s16_z == _x_s16_z)) || ( !((( !s16_l2) && (( !s16_l0) && ( !s16_l1))) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && (((((( !_x_s16_l2) && (_x_s16_l1 && ( !_x_s16_l0))) || (( !_x_s16_l2) && (_x_s16_l0 && _x_s16_l1))) && (s16_x == _x_s16_x)) && ((s16_z == _x_s16_z) && (s16_y == _x_s16_y))) || ( !((( !s16_l2) && (s16_l0 && ( !s16_l1))) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && (((s16_evt0 && ( !s16_evt1)) && ((20.0 <= s16_x) && ( !(120.0 <= s16_z)))) || ( !(((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))) && ((( !s16_l2) && (s16_l0 && ( !s16_l1))) && (( !_x_s16_l2) && (_x_s16_l1 && ( !_x_s16_l0)))))))) && (((s16_evt1 && ( !s16_evt0)) && ((20.0 <= s16_x) && (120.0 <= s16_z))) || ( !(((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))) && ((( !s16_l2) && (s16_l0 && ( !s16_l1))) && (( !_x_s16_l2) && (_x_s16_l0 && _x_s16_l1))))))) && (((s16_z == _x_s16_z) && (((s16_evt1 && ( !s16_evt0)) && (( !_x_s16_l2) && (_x_s16_l0 && _x_s16_l1))) && ((s16_x == _x_s16_x) && (s16_y == _x_s16_y)))) || ( !((( !s16_l2) && (s16_l1 && ( !s16_l0))) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && (((((s16_evt0 && s16_evt1) && (_x_s16_l2 && (( !_x_s16_l0) && ( !_x_s16_l1)))) && ((_x_s16_x == 0.0) && (s16_y == _x_s16_y))) && (_x_s16_z == 0.0)) || ( !((( !s16_l2) && (s16_l0 && s16_l1)) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && ((((s16_x == _x_s16_x) && (s16_y == _x_s16_y)) && ((s16_z == _x_s16_z) && ((( !_x_s16_l2) && (( !_x_s16_l0) && ( !_x_s16_l1))) || (_x_s16_l2 && (_x_s16_l0 && ( !_x_s16_l1)))))) || ( !((s16_l2 && (( !s16_l0) && ( !s16_l1))) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && (((s16_evt0 && ( !s16_evt1)) && ((20.0 <= s16_x) && ( !(120.0 <= s16_y)))) || ( !(((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))) && ((s16_l2 && (( !s16_l0) && ( !s16_l1))) && (_x_s16_l2 && (_x_s16_l0 && ( !_x_s16_l1)))))))) && (((s16_evt1 && ( !s16_evt0)) && ((20.0 <= s16_x) && (120.0 <= s16_y))) || ( !(((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))) && ((( !_x_s16_l2) && (( !_x_s16_l0) && ( !_x_s16_l1))) && (s16_l2 && (( !s16_l0) && ( !s16_l1)))))))) && (((s16_z == _x_s16_z) && (((s16_x == _x_s16_x) && (s16_y == _x_s16_y)) && ((s16_evt1 && ( !s16_evt0)) && (( !_x_s16_l2) && (( !_x_s16_l0) && ( !_x_s16_l1)))))) || ( !((s16_l2 && (s16_l0 && ( !s16_l1))) && ((delta == 0.0) && ( !(( !s16_evt0) && ( !s16_evt1)))))))) && ((((((((((((((((((((( !_x_s15_evt0) && ( !_x_s15_evt1)) || (_x_s15_evt0 && ( !_x_s15_evt1))) || ((_x_s15_evt1 && ( !_x_s15_evt0)) || (_x_s15_evt0 && _x_s15_evt1))) && ((((( !_x_s15_l2) && (( !_x_s15_l0) && ( !_x_s15_l1))) || (( !_x_s15_l2) && (_x_s15_l0 && ( !_x_s15_l1)))) || ((( !_x_s15_l2) && (_x_s15_l1 && ( !_x_s15_l0))) || (( !_x_s15_l2) && (_x_s15_l0 && _x_s15_l1)))) || ((_x_s15_l2 && (( !_x_s15_l0) && ( !_x_s15_l1))) || (_x_s15_l2 && (_x_s15_l0 && ( !_x_s15_l1)))))) && ((_x_s15_x <= 20.0) || ( !(( !_x_s15_l2) && (_x_s15_l0 && ( !_x_s15_l1)))))) && ((_x_s15_x <= 120.0) || ( !(( !_x_s15_l2) && (_x_s15_l1 && ( !_x_s15_l0)))))) && ((_x_s15_x <= 120.0) || ( !(_x_s15_l2 && (_x_s15_l0 && ( !_x_s15_l1)))))) && ((delta <= 0.0) || ((((delta + (s15_x + (-1.0 * _x_s15_x))) == 0.0) && ((delta + (s15_y + (-1.0 * _x_s15_y))) == 0.0)) && ((((s15_l0 == _x_s15_l0) && (s15_l1 == _x_s15_l1)) && (s15_l2 == _x_s15_l2)) && ((delta + (s15_z + (-1.0 * _x_s15_z))) == 0.0))))) && ((((((s15_l0 == _x_s15_l0) && (s15_l1 == _x_s15_l1)) && (s15_l2 == _x_s15_l2)) && ((delta + (s15_x + (-1.0 * _x_s15_x))) == 0.0)) && (((delta + (s15_y + (-1.0 * _x_s15_y))) == 0.0) && ((delta + (s15_z + (-1.0 * _x_s15_z))) == 0.0))) || ( !(( !s15_evt0) && ( !s15_evt1))))) && (((((s15_evt0 && s15_evt1) && (( !_x_s15_l2) && (_x_s15_l0 && ( !_x_s15_l1)))) && ((_x_s15_x == 0.0) && (_x_s15_y == 0.0))) && (s15_z == _x_s15_z)) || ( !((( !s15_l2) && (( !s15_l0) && ( !s15_l1))) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && (((((( !_x_s15_l2) && (_x_s15_l1 && ( !_x_s15_l0))) || (( !_x_s15_l2) && (_x_s15_l0 && _x_s15_l1))) && (s15_x == _x_s15_x)) && ((s15_z == _x_s15_z) && (s15_y == _x_s15_y))) || ( !((( !s15_l2) && (s15_l0 && ( !s15_l1))) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && (((s15_evt0 && ( !s15_evt1)) && ((20.0 <= s15_x) && ( !(120.0 <= s15_z)))) || ( !(((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))) && ((( !s15_l2) && (s15_l0 && ( !s15_l1))) && (( !_x_s15_l2) && (_x_s15_l1 && ( !_x_s15_l0)))))))) && (((s15_evt1 && ( !s15_evt0)) && ((20.0 <= s15_x) && (120.0 <= s15_z))) || ( !(((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))) && ((( !s15_l2) && (s15_l0 && ( !s15_l1))) && (( !_x_s15_l2) && (_x_s15_l0 && _x_s15_l1))))))) && (((s15_z == _x_s15_z) && (((s15_evt1 && ( !s15_evt0)) && (( !_x_s15_l2) && (_x_s15_l0 && _x_s15_l1))) && ((s15_x == _x_s15_x) && (s15_y == _x_s15_y)))) || ( !((( !s15_l2) && (s15_l1 && ( !s15_l0))) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && (((((s15_evt0 && s15_evt1) && (_x_s15_l2 && (( !_x_s15_l0) && ( !_x_s15_l1)))) && ((_x_s15_x == 0.0) && (s15_y == _x_s15_y))) && (_x_s15_z == 0.0)) || ( !((( !s15_l2) && (s15_l0 && s15_l1)) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && ((((s15_x == _x_s15_x) && (s15_y == _x_s15_y)) && ((s15_z == _x_s15_z) && ((( !_x_s15_l2) && (( !_x_s15_l0) && ( !_x_s15_l1))) || (_x_s15_l2 && (_x_s15_l0 && ( !_x_s15_l1)))))) || ( !((s15_l2 && (( !s15_l0) && ( !s15_l1))) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && (((s15_evt0 && ( !s15_evt1)) && ((20.0 <= s15_x) && ( !(120.0 <= s15_y)))) || ( !(((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))) && ((s15_l2 && (( !s15_l0) && ( !s15_l1))) && (_x_s15_l2 && (_x_s15_l0 && ( !_x_s15_l1)))))))) && (((s15_evt1 && ( !s15_evt0)) && ((20.0 <= s15_x) && (120.0 <= s15_y))) || ( !(((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))) && ((( !_x_s15_l2) && (( !_x_s15_l0) && ( !_x_s15_l1))) && (s15_l2 && (( !s15_l0) && ( !s15_l1)))))))) && (((s15_z == _x_s15_z) && (((s15_x == _x_s15_x) && (s15_y == _x_s15_y)) && ((s15_evt1 && ( !s15_evt0)) && (( !_x_s15_l2) && (( !_x_s15_l0) && ( !_x_s15_l1)))))) || ( !((s15_l2 && (s15_l0 && ( !s15_l1))) && ((delta == 0.0) && ( !(( !s15_evt0) && ( !s15_evt1)))))))) && ((((((((((((((((((((( !_x_s14_evt0) && ( !_x_s14_evt1)) || (_x_s14_evt0 && ( !_x_s14_evt1))) || ((_x_s14_evt1 && ( !_x_s14_evt0)) || (_x_s14_evt0 && _x_s14_evt1))) && ((((( !_x_s14_l2) && (( !_x_s14_l0) && ( !_x_s14_l1))) || (( !_x_s14_l2) && (_x_s14_l0 && ( !_x_s14_l1)))) || ((( !_x_s14_l2) && (_x_s14_l1 && ( !_x_s14_l0))) || (( !_x_s14_l2) && (_x_s14_l0 && _x_s14_l1)))) || ((_x_s14_l2 && (( !_x_s14_l0) && ( !_x_s14_l1))) || (_x_s14_l2 && (_x_s14_l0 && ( !_x_s14_l1)))))) && ((_x_s14_x <= 20.0) || ( !(( !_x_s14_l2) && (_x_s14_l0 && ( !_x_s14_l1)))))) && ((_x_s14_x <= 120.0) || ( !(( !_x_s14_l2) && (_x_s14_l1 && ( !_x_s14_l0)))))) && ((_x_s14_x <= 120.0) || ( !(_x_s14_l2 && (_x_s14_l0 && ( !_x_s14_l1)))))) && ((delta <= 0.0) || ((((delta + (s14_x + (-1.0 * _x_s14_x))) == 0.0) && ((delta + (s14_y + (-1.0 * _x_s14_y))) == 0.0)) && ((((s14_l0 == _x_s14_l0) && (s14_l1 == _x_s14_l1)) && (s14_l2 == _x_s14_l2)) && ((delta + (s14_z + (-1.0 * _x_s14_z))) == 0.0))))) && ((((((s14_l0 == _x_s14_l0) && (s14_l1 == _x_s14_l1)) && (s14_l2 == _x_s14_l2)) && ((delta + (s14_x + (-1.0 * _x_s14_x))) == 0.0)) && (((delta + (s14_y + (-1.0 * _x_s14_y))) == 0.0) && ((delta + (s14_z + (-1.0 * _x_s14_z))) == 0.0))) || ( !(( !s14_evt0) && ( !s14_evt1))))) && (((((s14_evt0 && s14_evt1) && (( !_x_s14_l2) && (_x_s14_l0 && ( !_x_s14_l1)))) && ((_x_s14_x == 0.0) && (_x_s14_y == 0.0))) && (s14_z == _x_s14_z)) || ( !((( !s14_l2) && (( !s14_l0) && ( !s14_l1))) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && (((((( !_x_s14_l2) && (_x_s14_l1 && ( !_x_s14_l0))) || (( !_x_s14_l2) && (_x_s14_l0 && _x_s14_l1))) && (s14_x == _x_s14_x)) && ((s14_z == _x_s14_z) && (s14_y == _x_s14_y))) || ( !((( !s14_l2) && (s14_l0 && ( !s14_l1))) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && (((s14_evt0 && ( !s14_evt1)) && ((20.0 <= s14_x) && ( !(120.0 <= s14_z)))) || ( !(((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))) && ((( !s14_l2) && (s14_l0 && ( !s14_l1))) && (( !_x_s14_l2) && (_x_s14_l1 && ( !_x_s14_l0)))))))) && (((s14_evt1 && ( !s14_evt0)) && ((20.0 <= s14_x) && (120.0 <= s14_z))) || ( !(((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))) && ((( !s14_l2) && (s14_l0 && ( !s14_l1))) && (( !_x_s14_l2) && (_x_s14_l0 && _x_s14_l1))))))) && (((s14_z == _x_s14_z) && (((s14_evt1 && ( !s14_evt0)) && (( !_x_s14_l2) && (_x_s14_l0 && _x_s14_l1))) && ((s14_x == _x_s14_x) && (s14_y == _x_s14_y)))) || ( !((( !s14_l2) && (s14_l1 && ( !s14_l0))) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && (((((s14_evt0 && s14_evt1) && (_x_s14_l2 && (( !_x_s14_l0) && ( !_x_s14_l1)))) && ((_x_s14_x == 0.0) && (s14_y == _x_s14_y))) && (_x_s14_z == 0.0)) || ( !((( !s14_l2) && (s14_l0 && s14_l1)) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && ((((s14_x == _x_s14_x) && (s14_y == _x_s14_y)) && ((s14_z == _x_s14_z) && ((( !_x_s14_l2) && (( !_x_s14_l0) && ( !_x_s14_l1))) || (_x_s14_l2 && (_x_s14_l0 && ( !_x_s14_l1)))))) || ( !((s14_l2 && (( !s14_l0) && ( !s14_l1))) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && (((s14_evt0 && ( !s14_evt1)) && ((20.0 <= s14_x) && ( !(120.0 <= s14_y)))) || ( !(((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))) && ((s14_l2 && (( !s14_l0) && ( !s14_l1))) && (_x_s14_l2 && (_x_s14_l0 && ( !_x_s14_l1)))))))) && (((s14_evt1 && ( !s14_evt0)) && ((20.0 <= s14_x) && (120.0 <= s14_y))) || ( !(((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))) && ((( !_x_s14_l2) && (( !_x_s14_l0) && ( !_x_s14_l1))) && (s14_l2 && (( !s14_l0) && ( !s14_l1)))))))) && (((s14_z == _x_s14_z) && (((s14_x == _x_s14_x) && (s14_y == _x_s14_y)) && ((s14_evt1 && ( !s14_evt0)) && (( !_x_s14_l2) && (( !_x_s14_l0) && ( !_x_s14_l1)))))) || ( !((s14_l2 && (s14_l0 && ( !s14_l1))) && ((delta == 0.0) && ( !(( !s14_evt0) && ( !s14_evt1)))))))) && ((((((((((((((((((((( !_x_s13_evt0) && ( !_x_s13_evt1)) || (_x_s13_evt0 && ( !_x_s13_evt1))) || ((_x_s13_evt1 && ( !_x_s13_evt0)) || (_x_s13_evt0 && _x_s13_evt1))) && ((((( !_x_s13_l2) && (( !_x_s13_l0) && ( !_x_s13_l1))) || (( !_x_s13_l2) && (_x_s13_l0 && ( !_x_s13_l1)))) || ((( !_x_s13_l2) && (_x_s13_l1 && ( !_x_s13_l0))) || (( !_x_s13_l2) && (_x_s13_l0 && _x_s13_l1)))) || ((_x_s13_l2 && (( !_x_s13_l0) && ( !_x_s13_l1))) || (_x_s13_l2 && (_x_s13_l0 && ( !_x_s13_l1)))))) && ((_x_s13_x <= 20.0) || ( !(( !_x_s13_l2) && (_x_s13_l0 && ( !_x_s13_l1)))))) && ((_x_s13_x <= 120.0) || ( !(( !_x_s13_l2) && (_x_s13_l1 && ( !_x_s13_l0)))))) && ((_x_s13_x <= 120.0) || ( !(_x_s13_l2 && (_x_s13_l0 && ( !_x_s13_l1)))))) && ((delta <= 0.0) || ((((delta + (s13_x + (-1.0 * _x_s13_x))) == 0.0) && ((delta + (s13_y + (-1.0 * _x_s13_y))) == 0.0)) && ((((s13_l0 == _x_s13_l0) && (s13_l1 == _x_s13_l1)) && (s13_l2 == _x_s13_l2)) && ((delta + (s13_z + (-1.0 * _x_s13_z))) == 0.0))))) && ((((((s13_l0 == _x_s13_l0) && (s13_l1 == _x_s13_l1)) && (s13_l2 == _x_s13_l2)) && ((delta + (s13_x + (-1.0 * _x_s13_x))) == 0.0)) && (((delta + (s13_y + (-1.0 * _x_s13_y))) == 0.0) && ((delta + (s13_z + (-1.0 * _x_s13_z))) == 0.0))) || ( !(( !s13_evt0) && ( !s13_evt1))))) && (((((s13_evt0 && s13_evt1) && (( !_x_s13_l2) && (_x_s13_l0 && ( !_x_s13_l1)))) && ((_x_s13_x == 0.0) && (_x_s13_y == 0.0))) && (s13_z == _x_s13_z)) || ( !((( !s13_l2) && (( !s13_l0) && ( !s13_l1))) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && (((((( !_x_s13_l2) && (_x_s13_l1 && ( !_x_s13_l0))) || (( !_x_s13_l2) && (_x_s13_l0 && _x_s13_l1))) && (s13_x == _x_s13_x)) && ((s13_z == _x_s13_z) && (s13_y == _x_s13_y))) || ( !((( !s13_l2) && (s13_l0 && ( !s13_l1))) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && (((s13_evt0 && ( !s13_evt1)) && ((20.0 <= s13_x) && ( !(120.0 <= s13_z)))) || ( !(((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))) && ((( !s13_l2) && (s13_l0 && ( !s13_l1))) && (( !_x_s13_l2) && (_x_s13_l1 && ( !_x_s13_l0)))))))) && (((s13_evt1 && ( !s13_evt0)) && ((20.0 <= s13_x) && (120.0 <= s13_z))) || ( !(((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))) && ((( !s13_l2) && (s13_l0 && ( !s13_l1))) && (( !_x_s13_l2) && (_x_s13_l0 && _x_s13_l1))))))) && (((s13_z == _x_s13_z) && (((s13_evt1 && ( !s13_evt0)) && (( !_x_s13_l2) && (_x_s13_l0 && _x_s13_l1))) && ((s13_x == _x_s13_x) && (s13_y == _x_s13_y)))) || ( !((( !s13_l2) && (s13_l1 && ( !s13_l0))) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && (((((s13_evt0 && s13_evt1) && (_x_s13_l2 && (( !_x_s13_l0) && ( !_x_s13_l1)))) && ((_x_s13_x == 0.0) && (s13_y == _x_s13_y))) && (_x_s13_z == 0.0)) || ( !((( !s13_l2) && (s13_l0 && s13_l1)) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && ((((s13_x == _x_s13_x) && (s13_y == _x_s13_y)) && ((s13_z == _x_s13_z) && ((( !_x_s13_l2) && (( !_x_s13_l0) && ( !_x_s13_l1))) || (_x_s13_l2 && (_x_s13_l0 && ( !_x_s13_l1)))))) || ( !((s13_l2 && (( !s13_l0) && ( !s13_l1))) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && (((s13_evt0 && ( !s13_evt1)) && ((20.0 <= s13_x) && ( !(120.0 <= s13_y)))) || ( !(((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))) && ((s13_l2 && (( !s13_l0) && ( !s13_l1))) && (_x_s13_l2 && (_x_s13_l0 && ( !_x_s13_l1)))))))) && (((s13_evt1 && ( !s13_evt0)) && ((20.0 <= s13_x) && (120.0 <= s13_y))) || ( !(((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))) && ((( !_x_s13_l2) && (( !_x_s13_l0) && ( !_x_s13_l1))) && (s13_l2 && (( !s13_l0) && ( !s13_l1)))))))) && (((s13_z == _x_s13_z) && (((s13_x == _x_s13_x) && (s13_y == _x_s13_y)) && ((s13_evt1 && ( !s13_evt0)) && (( !_x_s13_l2) && (( !_x_s13_l0) && ( !_x_s13_l1)))))) || ( !((s13_l2 && (s13_l0 && ( !s13_l1))) && ((delta == 0.0) && ( !(( !s13_evt0) && ( !s13_evt1)))))))) && ((((((((((((((((((((( !_x_s12_evt0) && ( !_x_s12_evt1)) || (_x_s12_evt0 && ( !_x_s12_evt1))) || ((_x_s12_evt1 && ( !_x_s12_evt0)) || (_x_s12_evt0 && _x_s12_evt1))) && ((((( !_x_s12_l2) && (( !_x_s12_l0) && ( !_x_s12_l1))) || (( !_x_s12_l2) && (_x_s12_l0 && ( !_x_s12_l1)))) || ((( !_x_s12_l2) && (_x_s12_l1 && ( !_x_s12_l0))) || (( !_x_s12_l2) && (_x_s12_l0 && _x_s12_l1)))) || ((_x_s12_l2 && (( !_x_s12_l0) && ( !_x_s12_l1))) || (_x_s12_l2 && (_x_s12_l0 && ( !_x_s12_l1)))))) && ((_x_s12_x <= 20.0) || ( !(( !_x_s12_l2) && (_x_s12_l0 && ( !_x_s12_l1)))))) && ((_x_s12_x <= 120.0) || ( !(( !_x_s12_l2) && (_x_s12_l1 && ( !_x_s12_l0)))))) && ((_x_s12_x <= 120.0) || ( !(_x_s12_l2 && (_x_s12_l0 && ( !_x_s12_l1)))))) && ((delta <= 0.0) || ((((delta + (s12_x + (-1.0 * _x_s12_x))) == 0.0) && ((delta + (s12_y + (-1.0 * _x_s12_y))) == 0.0)) && ((((s12_l0 == _x_s12_l0) && (s12_l1 == _x_s12_l1)) && (s12_l2 == _x_s12_l2)) && ((delta + (s12_z + (-1.0 * _x_s12_z))) == 0.0))))) && ((((((s12_l0 == _x_s12_l0) && (s12_l1 == _x_s12_l1)) && (s12_l2 == _x_s12_l2)) && ((delta + (s12_x + (-1.0 * _x_s12_x))) == 0.0)) && (((delta + (s12_y + (-1.0 * _x_s12_y))) == 0.0) && ((delta + (s12_z + (-1.0 * _x_s12_z))) == 0.0))) || ( !(( !s12_evt0) && ( !s12_evt1))))) && (((((s12_evt0 && s12_evt1) && (( !_x_s12_l2) && (_x_s12_l0 && ( !_x_s12_l1)))) && ((_x_s12_x == 0.0) && (_x_s12_y == 0.0))) && (s12_z == _x_s12_z)) || ( !((( !s12_l2) && (( !s12_l0) && ( !s12_l1))) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && (((((( !_x_s12_l2) && (_x_s12_l1 && ( !_x_s12_l0))) || (( !_x_s12_l2) && (_x_s12_l0 && _x_s12_l1))) && (s12_x == _x_s12_x)) && ((s12_z == _x_s12_z) && (s12_y == _x_s12_y))) || ( !((( !s12_l2) && (s12_l0 && ( !s12_l1))) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && (((s12_evt0 && ( !s12_evt1)) && ((20.0 <= s12_x) && ( !(120.0 <= s12_z)))) || ( !(((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))) && ((( !s12_l2) && (s12_l0 && ( !s12_l1))) && (( !_x_s12_l2) && (_x_s12_l1 && ( !_x_s12_l0)))))))) && (((s12_evt1 && ( !s12_evt0)) && ((20.0 <= s12_x) && (120.0 <= s12_z))) || ( !(((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))) && ((( !s12_l2) && (s12_l0 && ( !s12_l1))) && (( !_x_s12_l2) && (_x_s12_l0 && _x_s12_l1))))))) && (((s12_z == _x_s12_z) && (((s12_evt1 && ( !s12_evt0)) && (( !_x_s12_l2) && (_x_s12_l0 && _x_s12_l1))) && ((s12_x == _x_s12_x) && (s12_y == _x_s12_y)))) || ( !((( !s12_l2) && (s12_l1 && ( !s12_l0))) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && (((((s12_evt0 && s12_evt1) && (_x_s12_l2 && (( !_x_s12_l0) && ( !_x_s12_l1)))) && ((_x_s12_x == 0.0) && (s12_y == _x_s12_y))) && (_x_s12_z == 0.0)) || ( !((( !s12_l2) && (s12_l0 && s12_l1)) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && ((((s12_x == _x_s12_x) && (s12_y == _x_s12_y)) && ((s12_z == _x_s12_z) && ((( !_x_s12_l2) && (( !_x_s12_l0) && ( !_x_s12_l1))) || (_x_s12_l2 && (_x_s12_l0 && ( !_x_s12_l1)))))) || ( !((s12_l2 && (( !s12_l0) && ( !s12_l1))) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && (((s12_evt0 && ( !s12_evt1)) && ((20.0 <= s12_x) && ( !(120.0 <= s12_y)))) || ( !(((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))) && ((s12_l2 && (( !s12_l0) && ( !s12_l1))) && (_x_s12_l2 && (_x_s12_l0 && ( !_x_s12_l1)))))))) && (((s12_evt1 && ( !s12_evt0)) && ((20.0 <= s12_x) && (120.0 <= s12_y))) || ( !(((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))) && ((( !_x_s12_l2) && (( !_x_s12_l0) && ( !_x_s12_l1))) && (s12_l2 && (( !s12_l0) && ( !s12_l1)))))))) && (((s12_z == _x_s12_z) && (((s12_x == _x_s12_x) && (s12_y == _x_s12_y)) && ((s12_evt1 && ( !s12_evt0)) && (( !_x_s12_l2) && (( !_x_s12_l0) && ( !_x_s12_l1)))))) || ( !((s12_l2 && (s12_l0 && ( !s12_l1))) && ((delta == 0.0) && ( !(( !s12_evt0) && ( !s12_evt1)))))))) && ((((((((((((((((((((( !_x_s11_evt0) && ( !_x_s11_evt1)) || (_x_s11_evt0 && ( !_x_s11_evt1))) || ((_x_s11_evt1 && ( !_x_s11_evt0)) || (_x_s11_evt0 && _x_s11_evt1))) && ((((( !_x_s11_l2) && (( !_x_s11_l0) && ( !_x_s11_l1))) || (( !_x_s11_l2) && (_x_s11_l0 && ( !_x_s11_l1)))) || ((( !_x_s11_l2) && (_x_s11_l1 && ( !_x_s11_l0))) || (( !_x_s11_l2) && (_x_s11_l0 && _x_s11_l1)))) || ((_x_s11_l2 && (( !_x_s11_l0) && ( !_x_s11_l1))) || (_x_s11_l2 && (_x_s11_l0 && ( !_x_s11_l1)))))) && ((_x_s11_x <= 20.0) || ( !(( !_x_s11_l2) && (_x_s11_l0 && ( !_x_s11_l1)))))) && ((_x_s11_x <= 120.0) || ( !(( !_x_s11_l2) && (_x_s11_l1 && ( !_x_s11_l0)))))) && ((_x_s11_x <= 120.0) || ( !(_x_s11_l2 && (_x_s11_l0 && ( !_x_s11_l1)))))) && ((delta <= 0.0) || ((((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0) && ((delta + (s11_y + (-1.0 * _x_s11_y))) == 0.0)) && ((((s11_l0 == _x_s11_l0) && (s11_l1 == _x_s11_l1)) && (s11_l2 == _x_s11_l2)) && ((delta + (s11_z + (-1.0 * _x_s11_z))) == 0.0))))) && ((((((s11_l0 == _x_s11_l0) && (s11_l1 == _x_s11_l1)) && (s11_l2 == _x_s11_l2)) && ((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0)) && (((delta + (s11_y + (-1.0 * _x_s11_y))) == 0.0) && ((delta + (s11_z + (-1.0 * _x_s11_z))) == 0.0))) || ( !(( !s11_evt0) && ( !s11_evt1))))) && (((((s11_evt0 && s11_evt1) && (( !_x_s11_l2) && (_x_s11_l0 && ( !_x_s11_l1)))) && ((_x_s11_x == 0.0) && (_x_s11_y == 0.0))) && (s11_z == _x_s11_z)) || ( !((( !s11_l2) && (( !s11_l0) && ( !s11_l1))) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && (((((( !_x_s11_l2) && (_x_s11_l1 && ( !_x_s11_l0))) || (( !_x_s11_l2) && (_x_s11_l0 && _x_s11_l1))) && (s11_x == _x_s11_x)) && ((s11_z == _x_s11_z) && (s11_y == _x_s11_y))) || ( !((( !s11_l2) && (s11_l0 && ( !s11_l1))) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && (((s11_evt0 && ( !s11_evt1)) && ((20.0 <= s11_x) && ( !(120.0 <= s11_z)))) || ( !(((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))) && ((( !s11_l2) && (s11_l0 && ( !s11_l1))) && (( !_x_s11_l2) && (_x_s11_l1 && ( !_x_s11_l0)))))))) && (((s11_evt1 && ( !s11_evt0)) && ((20.0 <= s11_x) && (120.0 <= s11_z))) || ( !(((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))) && ((( !s11_l2) && (s11_l0 && ( !s11_l1))) && (( !_x_s11_l2) && (_x_s11_l0 && _x_s11_l1))))))) && (((s11_z == _x_s11_z) && (((s11_evt1 && ( !s11_evt0)) && (( !_x_s11_l2) && (_x_s11_l0 && _x_s11_l1))) && ((s11_x == _x_s11_x) && (s11_y == _x_s11_y)))) || ( !((( !s11_l2) && (s11_l1 && ( !s11_l0))) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && (((((s11_evt0 && s11_evt1) && (_x_s11_l2 && (( !_x_s11_l0) && ( !_x_s11_l1)))) && ((_x_s11_x == 0.0) && (s11_y == _x_s11_y))) && (_x_s11_z == 0.0)) || ( !((( !s11_l2) && (s11_l0 && s11_l1)) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && ((((s11_x == _x_s11_x) && (s11_y == _x_s11_y)) && ((s11_z == _x_s11_z) && ((( !_x_s11_l2) && (( !_x_s11_l0) && ( !_x_s11_l1))) || (_x_s11_l2 && (_x_s11_l0 && ( !_x_s11_l1)))))) || ( !((s11_l2 && (( !s11_l0) && ( !s11_l1))) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && (((s11_evt0 && ( !s11_evt1)) && ((20.0 <= s11_x) && ( !(120.0 <= s11_y)))) || ( !(((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))) && ((s11_l2 && (( !s11_l0) && ( !s11_l1))) && (_x_s11_l2 && (_x_s11_l0 && ( !_x_s11_l1)))))))) && (((s11_evt1 && ( !s11_evt0)) && ((20.0 <= s11_x) && (120.0 <= s11_y))) || ( !(((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))) && ((( !_x_s11_l2) && (( !_x_s11_l0) && ( !_x_s11_l1))) && (s11_l2 && (( !s11_l0) && ( !s11_l1)))))))) && (((s11_z == _x_s11_z) && (((s11_x == _x_s11_x) && (s11_y == _x_s11_y)) && ((s11_evt1 && ( !s11_evt0)) && (( !_x_s11_l2) && (( !_x_s11_l0) && ( !_x_s11_l1)))))) || ( !((s11_l2 && (s11_l0 && ( !s11_l1))) && ((delta == 0.0) && ( !(( !s11_evt0) && ( !s11_evt1)))))))) && ((((((((((((((((((((( !_x_s10_evt0) && ( !_x_s10_evt1)) || (_x_s10_evt0 && ( !_x_s10_evt1))) || ((_x_s10_evt1 && ( !_x_s10_evt0)) || (_x_s10_evt0 && _x_s10_evt1))) && ((((( !_x_s10_l2) && (( !_x_s10_l0) && ( !_x_s10_l1))) || (( !_x_s10_l2) && (_x_s10_l0 && ( !_x_s10_l1)))) || ((( !_x_s10_l2) && (_x_s10_l1 && ( !_x_s10_l0))) || (( !_x_s10_l2) && (_x_s10_l0 && _x_s10_l1)))) || ((_x_s10_l2 && (( !_x_s10_l0) && ( !_x_s10_l1))) || (_x_s10_l2 && (_x_s10_l0 && ( !_x_s10_l1)))))) && ((_x_s10_x <= 20.0) || ( !(( !_x_s10_l2) && (_x_s10_l0 && ( !_x_s10_l1)))))) && ((_x_s10_x <= 120.0) || ( !(( !_x_s10_l2) && (_x_s10_l1 && ( !_x_s10_l0)))))) && ((_x_s10_x <= 120.0) || ( !(_x_s10_l2 && (_x_s10_l0 && ( !_x_s10_l1)))))) && ((delta <= 0.0) || ((((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0) && ((delta + (s10_y + (-1.0 * _x_s10_y))) == 0.0)) && ((((s10_l0 == _x_s10_l0) && (s10_l1 == _x_s10_l1)) && (s10_l2 == _x_s10_l2)) && ((delta + (s10_z + (-1.0 * _x_s10_z))) == 0.0))))) && ((((((s10_l0 == _x_s10_l0) && (s10_l1 == _x_s10_l1)) && (s10_l2 == _x_s10_l2)) && ((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0)) && (((delta + (s10_y + (-1.0 * _x_s10_y))) == 0.0) && ((delta + (s10_z + (-1.0 * _x_s10_z))) == 0.0))) || ( !(( !s10_evt0) && ( !s10_evt1))))) && (((((s10_evt0 && s10_evt1) && (( !_x_s10_l2) && (_x_s10_l0 && ( !_x_s10_l1)))) && ((_x_s10_x == 0.0) && (_x_s10_y == 0.0))) && (s10_z == _x_s10_z)) || ( !((( !s10_l2) && (( !s10_l0) && ( !s10_l1))) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && (((((( !_x_s10_l2) && (_x_s10_l1 && ( !_x_s10_l0))) || (( !_x_s10_l2) && (_x_s10_l0 && _x_s10_l1))) && (s10_x == _x_s10_x)) && ((s10_z == _x_s10_z) && (s10_y == _x_s10_y))) || ( !((( !s10_l2) && (s10_l0 && ( !s10_l1))) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && (((s10_evt0 && ( !s10_evt1)) && ((20.0 <= s10_x) && ( !(120.0 <= s10_z)))) || ( !(((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))) && ((( !s10_l2) && (s10_l0 && ( !s10_l1))) && (( !_x_s10_l2) && (_x_s10_l1 && ( !_x_s10_l0)))))))) && (((s10_evt1 && ( !s10_evt0)) && ((20.0 <= s10_x) && (120.0 <= s10_z))) || ( !(((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))) && ((( !s10_l2) && (s10_l0 && ( !s10_l1))) && (( !_x_s10_l2) && (_x_s10_l0 && _x_s10_l1))))))) && (((s10_z == _x_s10_z) && (((s10_evt1 && ( !s10_evt0)) && (( !_x_s10_l2) && (_x_s10_l0 && _x_s10_l1))) && ((s10_x == _x_s10_x) && (s10_y == _x_s10_y)))) || ( !((( !s10_l2) && (s10_l1 && ( !s10_l0))) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && (((((s10_evt0 && s10_evt1) && (_x_s10_l2 && (( !_x_s10_l0) && ( !_x_s10_l1)))) && ((_x_s10_x == 0.0) && (s10_y == _x_s10_y))) && (_x_s10_z == 0.0)) || ( !((( !s10_l2) && (s10_l0 && s10_l1)) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && ((((s10_x == _x_s10_x) && (s10_y == _x_s10_y)) && ((s10_z == _x_s10_z) && ((( !_x_s10_l2) && (( !_x_s10_l0) && ( !_x_s10_l1))) || (_x_s10_l2 && (_x_s10_l0 && ( !_x_s10_l1)))))) || ( !((s10_l2 && (( !s10_l0) && ( !s10_l1))) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && (((s10_evt0 && ( !s10_evt1)) && ((20.0 <= s10_x) && ( !(120.0 <= s10_y)))) || ( !(((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))) && ((s10_l2 && (( !s10_l0) && ( !s10_l1))) && (_x_s10_l2 && (_x_s10_l0 && ( !_x_s10_l1)))))))) && (((s10_evt1 && ( !s10_evt0)) && ((20.0 <= s10_x) && (120.0 <= s10_y))) || ( !(((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))) && ((( !_x_s10_l2) && (( !_x_s10_l0) && ( !_x_s10_l1))) && (s10_l2 && (( !s10_l0) && ( !s10_l1)))))))) && (((s10_z == _x_s10_z) && (((s10_x == _x_s10_x) && (s10_y == _x_s10_y)) && ((s10_evt1 && ( !s10_evt0)) && (( !_x_s10_l2) && (( !_x_s10_l0) && ( !_x_s10_l1)))))) || ( !((s10_l2 && (s10_l0 && ( !s10_l1))) && ((delta == 0.0) && ( !(( !s10_evt0) && ( !s10_evt1)))))))) && ((((((((((((((((((((( !_x_s9_evt0) && ( !_x_s9_evt1)) || (_x_s9_evt0 && ( !_x_s9_evt1))) || ((_x_s9_evt1 && ( !_x_s9_evt0)) || (_x_s9_evt0 && _x_s9_evt1))) && ((((( !_x_s9_l2) && (( !_x_s9_l0) && ( !_x_s9_l1))) || (( !_x_s9_l2) && (_x_s9_l0 && ( !_x_s9_l1)))) || ((( !_x_s9_l2) && (_x_s9_l1 && ( !_x_s9_l0))) || (( !_x_s9_l2) && (_x_s9_l0 && _x_s9_l1)))) || ((_x_s9_l2 && (( !_x_s9_l0) && ( !_x_s9_l1))) || (_x_s9_l2 && (_x_s9_l0 && ( !_x_s9_l1)))))) && ((_x_s9_x <= 20.0) || ( !(( !_x_s9_l2) && (_x_s9_l0 && ( !_x_s9_l1)))))) && ((_x_s9_x <= 120.0) || ( !(( !_x_s9_l2) && (_x_s9_l1 && ( !_x_s9_l0)))))) && ((_x_s9_x <= 120.0) || ( !(_x_s9_l2 && (_x_s9_l0 && ( !_x_s9_l1)))))) && ((delta <= 0.0) || ((((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0) && ((delta + (s9_y + (-1.0 * _x_s9_y))) == 0.0)) && ((((s9_l0 == _x_s9_l0) && (s9_l1 == _x_s9_l1)) && (s9_l2 == _x_s9_l2)) && ((delta + (s9_z + (-1.0 * _x_s9_z))) == 0.0))))) && ((((((s9_l0 == _x_s9_l0) && (s9_l1 == _x_s9_l1)) && (s9_l2 == _x_s9_l2)) && ((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0)) && (((delta + (s9_y + (-1.0 * _x_s9_y))) == 0.0) && ((delta + (s9_z + (-1.0 * _x_s9_z))) == 0.0))) || ( !(( !s9_evt0) && ( !s9_evt1))))) && (((((s9_evt0 && s9_evt1) && (( !_x_s9_l2) && (_x_s9_l0 && ( !_x_s9_l1)))) && ((_x_s9_x == 0.0) && (_x_s9_y == 0.0))) && (s9_z == _x_s9_z)) || ( !((( !s9_l2) && (( !s9_l0) && ( !s9_l1))) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && (((((( !_x_s9_l2) && (_x_s9_l1 && ( !_x_s9_l0))) || (( !_x_s9_l2) && (_x_s9_l0 && _x_s9_l1))) && (s9_x == _x_s9_x)) && ((s9_z == _x_s9_z) && (s9_y == _x_s9_y))) || ( !((( !s9_l2) && (s9_l0 && ( !s9_l1))) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && (((s9_evt0 && ( !s9_evt1)) && ((20.0 <= s9_x) && ( !(120.0 <= s9_z)))) || ( !(((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))) && ((( !s9_l2) && (s9_l0 && ( !s9_l1))) && (( !_x_s9_l2) && (_x_s9_l1 && ( !_x_s9_l0)))))))) && (((s9_evt1 && ( !s9_evt0)) && ((20.0 <= s9_x) && (120.0 <= s9_z))) || ( !(((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))) && ((( !s9_l2) && (s9_l0 && ( !s9_l1))) && (( !_x_s9_l2) && (_x_s9_l0 && _x_s9_l1))))))) && (((s9_z == _x_s9_z) && (((s9_evt1 && ( !s9_evt0)) && (( !_x_s9_l2) && (_x_s9_l0 && _x_s9_l1))) && ((s9_x == _x_s9_x) && (s9_y == _x_s9_y)))) || ( !((( !s9_l2) && (s9_l1 && ( !s9_l0))) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && (((((s9_evt0 && s9_evt1) && (_x_s9_l2 && (( !_x_s9_l0) && ( !_x_s9_l1)))) && ((_x_s9_x == 0.0) && (s9_y == _x_s9_y))) && (_x_s9_z == 0.0)) || ( !((( !s9_l2) && (s9_l0 && s9_l1)) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && ((((s9_x == _x_s9_x) && (s9_y == _x_s9_y)) && ((s9_z == _x_s9_z) && ((( !_x_s9_l2) && (( !_x_s9_l0) && ( !_x_s9_l1))) || (_x_s9_l2 && (_x_s9_l0 && ( !_x_s9_l1)))))) || ( !((s9_l2 && (( !s9_l0) && ( !s9_l1))) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && (((s9_evt0 && ( !s9_evt1)) && ((20.0 <= s9_x) && ( !(120.0 <= s9_y)))) || ( !(((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))) && ((s9_l2 && (( !s9_l0) && ( !s9_l1))) && (_x_s9_l2 && (_x_s9_l0 && ( !_x_s9_l1)))))))) && (((s9_evt1 && ( !s9_evt0)) && ((20.0 <= s9_x) && (120.0 <= s9_y))) || ( !(((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))) && ((( !_x_s9_l2) && (( !_x_s9_l0) && ( !_x_s9_l1))) && (s9_l2 && (( !s9_l0) && ( !s9_l1)))))))) && (((s9_z == _x_s9_z) && (((s9_x == _x_s9_x) && (s9_y == _x_s9_y)) && ((s9_evt1 && ( !s9_evt0)) && (( !_x_s9_l2) && (( !_x_s9_l0) && ( !_x_s9_l1)))))) || ( !((s9_l2 && (s9_l0 && ( !s9_l1))) && ((delta == 0.0) && ( !(( !s9_evt0) && ( !s9_evt1)))))))) && ((((((((((((((((((((( !_x_s8_evt0) && ( !_x_s8_evt1)) || (_x_s8_evt0 && ( !_x_s8_evt1))) || ((_x_s8_evt1 && ( !_x_s8_evt0)) || (_x_s8_evt0 && _x_s8_evt1))) && ((((( !_x_s8_l2) && (( !_x_s8_l0) && ( !_x_s8_l1))) || (( !_x_s8_l2) && (_x_s8_l0 && ( !_x_s8_l1)))) || ((( !_x_s8_l2) && (_x_s8_l1 && ( !_x_s8_l0))) || (( !_x_s8_l2) && (_x_s8_l0 && _x_s8_l1)))) || ((_x_s8_l2 && (( !_x_s8_l0) && ( !_x_s8_l1))) || (_x_s8_l2 && (_x_s8_l0 && ( !_x_s8_l1)))))) && ((_x_s8_x <= 20.0) || ( !(( !_x_s8_l2) && (_x_s8_l0 && ( !_x_s8_l1)))))) && ((_x_s8_x <= 120.0) || ( !(( !_x_s8_l2) && (_x_s8_l1 && ( !_x_s8_l0)))))) && ((_x_s8_x <= 120.0) || ( !(_x_s8_l2 && (_x_s8_l0 && ( !_x_s8_l1)))))) && ((delta <= 0.0) || ((((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0) && ((delta + (s8_y + (-1.0 * _x_s8_y))) == 0.0)) && ((((s8_l0 == _x_s8_l0) && (s8_l1 == _x_s8_l1)) && (s8_l2 == _x_s8_l2)) && ((delta + (s8_z + (-1.0 * _x_s8_z))) == 0.0))))) && ((((((s8_l0 == _x_s8_l0) && (s8_l1 == _x_s8_l1)) && (s8_l2 == _x_s8_l2)) && ((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0)) && (((delta + (s8_y + (-1.0 * _x_s8_y))) == 0.0) && ((delta + (s8_z + (-1.0 * _x_s8_z))) == 0.0))) || ( !(( !s8_evt0) && ( !s8_evt1))))) && (((((s8_evt0 && s8_evt1) && (( !_x_s8_l2) && (_x_s8_l0 && ( !_x_s8_l1)))) && ((_x_s8_x == 0.0) && (_x_s8_y == 0.0))) && (s8_z == _x_s8_z)) || ( !((( !s8_l2) && (( !s8_l0) && ( !s8_l1))) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && (((((( !_x_s8_l2) && (_x_s8_l1 && ( !_x_s8_l0))) || (( !_x_s8_l2) && (_x_s8_l0 && _x_s8_l1))) && (s8_x == _x_s8_x)) && ((s8_z == _x_s8_z) && (s8_y == _x_s8_y))) || ( !((( !s8_l2) && (s8_l0 && ( !s8_l1))) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && (((s8_evt0 && ( !s8_evt1)) && ((20.0 <= s8_x) && ( !(120.0 <= s8_z)))) || ( !(((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))) && ((( !s8_l2) && (s8_l0 && ( !s8_l1))) && (( !_x_s8_l2) && (_x_s8_l1 && ( !_x_s8_l0)))))))) && (((s8_evt1 && ( !s8_evt0)) && ((20.0 <= s8_x) && (120.0 <= s8_z))) || ( !(((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))) && ((( !s8_l2) && (s8_l0 && ( !s8_l1))) && (( !_x_s8_l2) && (_x_s8_l0 && _x_s8_l1))))))) && (((s8_z == _x_s8_z) && (((s8_evt1 && ( !s8_evt0)) && (( !_x_s8_l2) && (_x_s8_l0 && _x_s8_l1))) && ((s8_x == _x_s8_x) && (s8_y == _x_s8_y)))) || ( !((( !s8_l2) && (s8_l1 && ( !s8_l0))) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && (((((s8_evt0 && s8_evt1) && (_x_s8_l2 && (( !_x_s8_l0) && ( !_x_s8_l1)))) && ((_x_s8_x == 0.0) && (s8_y == _x_s8_y))) && (_x_s8_z == 0.0)) || ( !((( !s8_l2) && (s8_l0 && s8_l1)) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && ((((s8_x == _x_s8_x) && (s8_y == _x_s8_y)) && ((s8_z == _x_s8_z) && ((( !_x_s8_l2) && (( !_x_s8_l0) && ( !_x_s8_l1))) || (_x_s8_l2 && (_x_s8_l0 && ( !_x_s8_l1)))))) || ( !((s8_l2 && (( !s8_l0) && ( !s8_l1))) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && (((s8_evt0 && ( !s8_evt1)) && ((20.0 <= s8_x) && ( !(120.0 <= s8_y)))) || ( !(((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))) && ((s8_l2 && (( !s8_l0) && ( !s8_l1))) && (_x_s8_l2 && (_x_s8_l0 && ( !_x_s8_l1)))))))) && (((s8_evt1 && ( !s8_evt0)) && ((20.0 <= s8_x) && (120.0 <= s8_y))) || ( !(((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))) && ((( !_x_s8_l2) && (( !_x_s8_l0) && ( !_x_s8_l1))) && (s8_l2 && (( !s8_l0) && ( !s8_l1)))))))) && (((s8_z == _x_s8_z) && (((s8_x == _x_s8_x) && (s8_y == _x_s8_y)) && ((s8_evt1 && ( !s8_evt0)) && (( !_x_s8_l2) && (( !_x_s8_l0) && ( !_x_s8_l1)))))) || ( !((s8_l2 && (s8_l0 && ( !s8_l1))) && ((delta == 0.0) && ( !(( !s8_evt0) && ( !s8_evt1)))))))) && ((((((((((((((((((((( !_x_s7_evt0) && ( !_x_s7_evt1)) || (_x_s7_evt0 && ( !_x_s7_evt1))) || ((_x_s7_evt1 && ( !_x_s7_evt0)) || (_x_s7_evt0 && _x_s7_evt1))) && ((((( !_x_s7_l2) && (( !_x_s7_l0) && ( !_x_s7_l1))) || (( !_x_s7_l2) && (_x_s7_l0 && ( !_x_s7_l1)))) || ((( !_x_s7_l2) && (_x_s7_l1 && ( !_x_s7_l0))) || (( !_x_s7_l2) && (_x_s7_l0 && _x_s7_l1)))) || ((_x_s7_l2 && (( !_x_s7_l0) && ( !_x_s7_l1))) || (_x_s7_l2 && (_x_s7_l0 && ( !_x_s7_l1)))))) && ((_x_s7_x <= 20.0) || ( !(( !_x_s7_l2) && (_x_s7_l0 && ( !_x_s7_l1)))))) && ((_x_s7_x <= 120.0) || ( !(( !_x_s7_l2) && (_x_s7_l1 && ( !_x_s7_l0)))))) && ((_x_s7_x <= 120.0) || ( !(_x_s7_l2 && (_x_s7_l0 && ( !_x_s7_l1)))))) && ((delta <= 0.0) || ((((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0) && ((delta + (s7_y + (-1.0 * _x_s7_y))) == 0.0)) && ((((s7_l0 == _x_s7_l0) && (s7_l1 == _x_s7_l1)) && (s7_l2 == _x_s7_l2)) && ((delta + (s7_z + (-1.0 * _x_s7_z))) == 0.0))))) && ((((((s7_l0 == _x_s7_l0) && (s7_l1 == _x_s7_l1)) && (s7_l2 == _x_s7_l2)) && ((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0)) && (((delta + (s7_y + (-1.0 * _x_s7_y))) == 0.0) && ((delta + (s7_z + (-1.0 * _x_s7_z))) == 0.0))) || ( !(( !s7_evt0) && ( !s7_evt1))))) && (((((s7_evt0 && s7_evt1) && (( !_x_s7_l2) && (_x_s7_l0 && ( !_x_s7_l1)))) && ((_x_s7_x == 0.0) && (_x_s7_y == 0.0))) && (s7_z == _x_s7_z)) || ( !((( !s7_l2) && (( !s7_l0) && ( !s7_l1))) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && (((((( !_x_s7_l2) && (_x_s7_l1 && ( !_x_s7_l0))) || (( !_x_s7_l2) && (_x_s7_l0 && _x_s7_l1))) && (s7_x == _x_s7_x)) && ((s7_z == _x_s7_z) && (s7_y == _x_s7_y))) || ( !((( !s7_l2) && (s7_l0 && ( !s7_l1))) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && (((s7_evt0 && ( !s7_evt1)) && ((20.0 <= s7_x) && ( !(120.0 <= s7_z)))) || ( !(((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))) && ((( !s7_l2) && (s7_l0 && ( !s7_l1))) && (( !_x_s7_l2) && (_x_s7_l1 && ( !_x_s7_l0)))))))) && (((s7_evt1 && ( !s7_evt0)) && ((20.0 <= s7_x) && (120.0 <= s7_z))) || ( !(((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))) && ((( !s7_l2) && (s7_l0 && ( !s7_l1))) && (( !_x_s7_l2) && (_x_s7_l0 && _x_s7_l1))))))) && (((s7_z == _x_s7_z) && (((s7_evt1 && ( !s7_evt0)) && (( !_x_s7_l2) && (_x_s7_l0 && _x_s7_l1))) && ((s7_x == _x_s7_x) && (s7_y == _x_s7_y)))) || ( !((( !s7_l2) && (s7_l1 && ( !s7_l0))) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && (((((s7_evt0 && s7_evt1) && (_x_s7_l2 && (( !_x_s7_l0) && ( !_x_s7_l1)))) && ((_x_s7_x == 0.0) && (s7_y == _x_s7_y))) && (_x_s7_z == 0.0)) || ( !((( !s7_l2) && (s7_l0 && s7_l1)) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && ((((s7_x == _x_s7_x) && (s7_y == _x_s7_y)) && ((s7_z == _x_s7_z) && ((( !_x_s7_l2) && (( !_x_s7_l0) && ( !_x_s7_l1))) || (_x_s7_l2 && (_x_s7_l0 && ( !_x_s7_l1)))))) || ( !((s7_l2 && (( !s7_l0) && ( !s7_l1))) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && (((s7_evt0 && ( !s7_evt1)) && ((20.0 <= s7_x) && ( !(120.0 <= s7_y)))) || ( !(((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))) && ((s7_l2 && (( !s7_l0) && ( !s7_l1))) && (_x_s7_l2 && (_x_s7_l0 && ( !_x_s7_l1)))))))) && (((s7_evt1 && ( !s7_evt0)) && ((20.0 <= s7_x) && (120.0 <= s7_y))) || ( !(((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))) && ((( !_x_s7_l2) && (( !_x_s7_l0) && ( !_x_s7_l1))) && (s7_l2 && (( !s7_l0) && ( !s7_l1)))))))) && (((s7_z == _x_s7_z) && (((s7_x == _x_s7_x) && (s7_y == _x_s7_y)) && ((s7_evt1 && ( !s7_evt0)) && (( !_x_s7_l2) && (( !_x_s7_l0) && ( !_x_s7_l1)))))) || ( !((s7_l2 && (s7_l0 && ( !s7_l1))) && ((delta == 0.0) && ( !(( !s7_evt0) && ( !s7_evt1)))))))) && ((((((((((((((((((((( !_x_s6_evt0) && ( !_x_s6_evt1)) || (_x_s6_evt0 && ( !_x_s6_evt1))) || ((_x_s6_evt1 && ( !_x_s6_evt0)) || (_x_s6_evt0 && _x_s6_evt1))) && ((((( !_x_s6_l2) && (( !_x_s6_l0) && ( !_x_s6_l1))) || (( !_x_s6_l2) && (_x_s6_l0 && ( !_x_s6_l1)))) || ((( !_x_s6_l2) && (_x_s6_l1 && ( !_x_s6_l0))) || (( !_x_s6_l2) && (_x_s6_l0 && _x_s6_l1)))) || ((_x_s6_l2 && (( !_x_s6_l0) && ( !_x_s6_l1))) || (_x_s6_l2 && (_x_s6_l0 && ( !_x_s6_l1)))))) && ((_x_s6_x <= 20.0) || ( !(( !_x_s6_l2) && (_x_s6_l0 && ( !_x_s6_l1)))))) && ((_x_s6_x <= 120.0) || ( !(( !_x_s6_l2) && (_x_s6_l1 && ( !_x_s6_l0)))))) && ((_x_s6_x <= 120.0) || ( !(_x_s6_l2 && (_x_s6_l0 && ( !_x_s6_l1)))))) && ((delta <= 0.0) || ((((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0) && ((delta + (s6_y + (-1.0 * _x_s6_y))) == 0.0)) && ((((s6_l0 == _x_s6_l0) && (s6_l1 == _x_s6_l1)) && (s6_l2 == _x_s6_l2)) && ((delta + (s6_z + (-1.0 * _x_s6_z))) == 0.0))))) && ((((((s6_l0 == _x_s6_l0) && (s6_l1 == _x_s6_l1)) && (s6_l2 == _x_s6_l2)) && ((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0)) && (((delta + (s6_y + (-1.0 * _x_s6_y))) == 0.0) && ((delta + (s6_z + (-1.0 * _x_s6_z))) == 0.0))) || ( !(( !s6_evt0) && ( !s6_evt1))))) && (((((s6_evt0 && s6_evt1) && (( !_x_s6_l2) && (_x_s6_l0 && ( !_x_s6_l1)))) && ((_x_s6_x == 0.0) && (_x_s6_y == 0.0))) && (s6_z == _x_s6_z)) || ( !((( !s6_l2) && (( !s6_l0) && ( !s6_l1))) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && (((((( !_x_s6_l2) && (_x_s6_l1 && ( !_x_s6_l0))) || (( !_x_s6_l2) && (_x_s6_l0 && _x_s6_l1))) && (s6_x == _x_s6_x)) && ((s6_z == _x_s6_z) && (s6_y == _x_s6_y))) || ( !((( !s6_l2) && (s6_l0 && ( !s6_l1))) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && (((s6_evt0 && ( !s6_evt1)) && ((20.0 <= s6_x) && ( !(120.0 <= s6_z)))) || ( !(((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))) && ((( !s6_l2) && (s6_l0 && ( !s6_l1))) && (( !_x_s6_l2) && (_x_s6_l1 && ( !_x_s6_l0)))))))) && (((s6_evt1 && ( !s6_evt0)) && ((20.0 <= s6_x) && (120.0 <= s6_z))) || ( !(((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))) && ((( !s6_l2) && (s6_l0 && ( !s6_l1))) && (( !_x_s6_l2) && (_x_s6_l0 && _x_s6_l1))))))) && (((s6_z == _x_s6_z) && (((s6_evt1 && ( !s6_evt0)) && (( !_x_s6_l2) && (_x_s6_l0 && _x_s6_l1))) && ((s6_x == _x_s6_x) && (s6_y == _x_s6_y)))) || ( !((( !s6_l2) && (s6_l1 && ( !s6_l0))) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && (((((s6_evt0 && s6_evt1) && (_x_s6_l2 && (( !_x_s6_l0) && ( !_x_s6_l1)))) && ((_x_s6_x == 0.0) && (s6_y == _x_s6_y))) && (_x_s6_z == 0.0)) || ( !((( !s6_l2) && (s6_l0 && s6_l1)) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && ((((s6_x == _x_s6_x) && (s6_y == _x_s6_y)) && ((s6_z == _x_s6_z) && ((( !_x_s6_l2) && (( !_x_s6_l0) && ( !_x_s6_l1))) || (_x_s6_l2 && (_x_s6_l0 && ( !_x_s6_l1)))))) || ( !((s6_l2 && (( !s6_l0) && ( !s6_l1))) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && (((s6_evt0 && ( !s6_evt1)) && ((20.0 <= s6_x) && ( !(120.0 <= s6_y)))) || ( !(((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))) && ((s6_l2 && (( !s6_l0) && ( !s6_l1))) && (_x_s6_l2 && (_x_s6_l0 && ( !_x_s6_l1)))))))) && (((s6_evt1 && ( !s6_evt0)) && ((20.0 <= s6_x) && (120.0 <= s6_y))) || ( !(((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))) && ((( !_x_s6_l2) && (( !_x_s6_l0) && ( !_x_s6_l1))) && (s6_l2 && (( !s6_l0) && ( !s6_l1)))))))) && (((s6_z == _x_s6_z) && (((s6_x == _x_s6_x) && (s6_y == _x_s6_y)) && ((s6_evt1 && ( !s6_evt0)) && (( !_x_s6_l2) && (( !_x_s6_l0) && ( !_x_s6_l1)))))) || ( !((s6_l2 && (s6_l0 && ( !s6_l1))) && ((delta == 0.0) && ( !(( !s6_evt0) && ( !s6_evt1)))))))) && ((((((((((((((((((((( !_x_s5_evt0) && ( !_x_s5_evt1)) || (_x_s5_evt0 && ( !_x_s5_evt1))) || ((_x_s5_evt1 && ( !_x_s5_evt0)) || (_x_s5_evt0 && _x_s5_evt1))) && ((((( !_x_s5_l2) && (( !_x_s5_l0) && ( !_x_s5_l1))) || (( !_x_s5_l2) && (_x_s5_l0 && ( !_x_s5_l1)))) || ((( !_x_s5_l2) && (_x_s5_l1 && ( !_x_s5_l0))) || (( !_x_s5_l2) && (_x_s5_l0 && _x_s5_l1)))) || ((_x_s5_l2 && (( !_x_s5_l0) && ( !_x_s5_l1))) || (_x_s5_l2 && (_x_s5_l0 && ( !_x_s5_l1)))))) && ((_x_s5_x <= 20.0) || ( !(( !_x_s5_l2) && (_x_s5_l0 && ( !_x_s5_l1)))))) && ((_x_s5_x <= 120.0) || ( !(( !_x_s5_l2) && (_x_s5_l1 && ( !_x_s5_l0)))))) && ((_x_s5_x <= 120.0) || ( !(_x_s5_l2 && (_x_s5_l0 && ( !_x_s5_l1)))))) && ((delta <= 0.0) || ((((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0) && ((delta + (s5_y + (-1.0 * _x_s5_y))) == 0.0)) && ((((s5_l0 == _x_s5_l0) && (s5_l1 == _x_s5_l1)) && (s5_l2 == _x_s5_l2)) && ((delta + (s5_z + (-1.0 * _x_s5_z))) == 0.0))))) && ((((((s5_l0 == _x_s5_l0) && (s5_l1 == _x_s5_l1)) && (s5_l2 == _x_s5_l2)) && ((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0)) && (((delta + (s5_y + (-1.0 * _x_s5_y))) == 0.0) && ((delta + (s5_z + (-1.0 * _x_s5_z))) == 0.0))) || ( !(( !s5_evt0) && ( !s5_evt1))))) && (((((s5_evt0 && s5_evt1) && (( !_x_s5_l2) && (_x_s5_l0 && ( !_x_s5_l1)))) && ((_x_s5_x == 0.0) && (_x_s5_y == 0.0))) && (s5_z == _x_s5_z)) || ( !((( !s5_l2) && (( !s5_l0) && ( !s5_l1))) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && (((((( !_x_s5_l2) && (_x_s5_l1 && ( !_x_s5_l0))) || (( !_x_s5_l2) && (_x_s5_l0 && _x_s5_l1))) && (s5_x == _x_s5_x)) && ((s5_z == _x_s5_z) && (s5_y == _x_s5_y))) || ( !((( !s5_l2) && (s5_l0 && ( !s5_l1))) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && (((s5_evt0 && ( !s5_evt1)) && ((20.0 <= s5_x) && ( !(120.0 <= s5_z)))) || ( !(((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))) && ((( !s5_l2) && (s5_l0 && ( !s5_l1))) && (( !_x_s5_l2) && (_x_s5_l1 && ( !_x_s5_l0)))))))) && (((s5_evt1 && ( !s5_evt0)) && ((20.0 <= s5_x) && (120.0 <= s5_z))) || ( !(((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))) && ((( !s5_l2) && (s5_l0 && ( !s5_l1))) && (( !_x_s5_l2) && (_x_s5_l0 && _x_s5_l1))))))) && (((s5_z == _x_s5_z) && (((s5_evt1 && ( !s5_evt0)) && (( !_x_s5_l2) && (_x_s5_l0 && _x_s5_l1))) && ((s5_x == _x_s5_x) && (s5_y == _x_s5_y)))) || ( !((( !s5_l2) && (s5_l1 && ( !s5_l0))) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && (((((s5_evt0 && s5_evt1) && (_x_s5_l2 && (( !_x_s5_l0) && ( !_x_s5_l1)))) && ((_x_s5_x == 0.0) && (s5_y == _x_s5_y))) && (_x_s5_z == 0.0)) || ( !((( !s5_l2) && (s5_l0 && s5_l1)) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && ((((s5_x == _x_s5_x) && (s5_y == _x_s5_y)) && ((s5_z == _x_s5_z) && ((( !_x_s5_l2) && (( !_x_s5_l0) && ( !_x_s5_l1))) || (_x_s5_l2 && (_x_s5_l0 && ( !_x_s5_l1)))))) || ( !((s5_l2 && (( !s5_l0) && ( !s5_l1))) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && (((s5_evt0 && ( !s5_evt1)) && ((20.0 <= s5_x) && ( !(120.0 <= s5_y)))) || ( !(((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))) && ((s5_l2 && (( !s5_l0) && ( !s5_l1))) && (_x_s5_l2 && (_x_s5_l0 && ( !_x_s5_l1)))))))) && (((s5_evt1 && ( !s5_evt0)) && ((20.0 <= s5_x) && (120.0 <= s5_y))) || ( !(((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))) && ((( !_x_s5_l2) && (( !_x_s5_l0) && ( !_x_s5_l1))) && (s5_l2 && (( !s5_l0) && ( !s5_l1)))))))) && (((s5_z == _x_s5_z) && (((s5_x == _x_s5_x) && (s5_y == _x_s5_y)) && ((s5_evt1 && ( !s5_evt0)) && (( !_x_s5_l2) && (( !_x_s5_l0) && ( !_x_s5_l1)))))) || ( !((s5_l2 && (s5_l0 && ( !s5_l1))) && ((delta == 0.0) && ( !(( !s5_evt0) && ( !s5_evt1)))))))) && ((((((((((((((((((((( !_x_s4_evt0) && ( !_x_s4_evt1)) || (_x_s4_evt0 && ( !_x_s4_evt1))) || ((_x_s4_evt1 && ( !_x_s4_evt0)) || (_x_s4_evt0 && _x_s4_evt1))) && ((((( !_x_s4_l2) && (( !_x_s4_l0) && ( !_x_s4_l1))) || (( !_x_s4_l2) && (_x_s4_l0 && ( !_x_s4_l1)))) || ((( !_x_s4_l2) && (_x_s4_l1 && ( !_x_s4_l0))) || (( !_x_s4_l2) && (_x_s4_l0 && _x_s4_l1)))) || ((_x_s4_l2 && (( !_x_s4_l0) && ( !_x_s4_l1))) || (_x_s4_l2 && (_x_s4_l0 && ( !_x_s4_l1)))))) && ((_x_s4_x <= 20.0) || ( !(( !_x_s4_l2) && (_x_s4_l0 && ( !_x_s4_l1)))))) && ((_x_s4_x <= 120.0) || ( !(( !_x_s4_l2) && (_x_s4_l1 && ( !_x_s4_l0)))))) && ((_x_s4_x <= 120.0) || ( !(_x_s4_l2 && (_x_s4_l0 && ( !_x_s4_l1)))))) && ((delta <= 0.0) || ((((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0) && ((delta + (s4_y + (-1.0 * _x_s4_y))) == 0.0)) && ((((s4_l0 == _x_s4_l0) && (s4_l1 == _x_s4_l1)) && (s4_l2 == _x_s4_l2)) && ((delta + (s4_z + (-1.0 * _x_s4_z))) == 0.0))))) && ((((((s4_l0 == _x_s4_l0) && (s4_l1 == _x_s4_l1)) && (s4_l2 == _x_s4_l2)) && ((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0)) && (((delta + (s4_y + (-1.0 * _x_s4_y))) == 0.0) && ((delta + (s4_z + (-1.0 * _x_s4_z))) == 0.0))) || ( !(( !s4_evt0) && ( !s4_evt1))))) && (((((s4_evt0 && s4_evt1) && (( !_x_s4_l2) && (_x_s4_l0 && ( !_x_s4_l1)))) && ((_x_s4_x == 0.0) && (_x_s4_y == 0.0))) && (s4_z == _x_s4_z)) || ( !((( !s4_l2) && (( !s4_l0) && ( !s4_l1))) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && (((((( !_x_s4_l2) && (_x_s4_l1 && ( !_x_s4_l0))) || (( !_x_s4_l2) && (_x_s4_l0 && _x_s4_l1))) && (s4_x == _x_s4_x)) && ((s4_z == _x_s4_z) && (s4_y == _x_s4_y))) || ( !((( !s4_l2) && (s4_l0 && ( !s4_l1))) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && (((s4_evt0 && ( !s4_evt1)) && ((20.0 <= s4_x) && ( !(120.0 <= s4_z)))) || ( !(((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))) && ((( !s4_l2) && (s4_l0 && ( !s4_l1))) && (( !_x_s4_l2) && (_x_s4_l1 && ( !_x_s4_l0)))))))) && (((s4_evt1 && ( !s4_evt0)) && ((20.0 <= s4_x) && (120.0 <= s4_z))) || ( !(((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))) && ((( !s4_l2) && (s4_l0 && ( !s4_l1))) && (( !_x_s4_l2) && (_x_s4_l0 && _x_s4_l1))))))) && (((s4_z == _x_s4_z) && (((s4_evt1 && ( !s4_evt0)) && (( !_x_s4_l2) && (_x_s4_l0 && _x_s4_l1))) && ((s4_x == _x_s4_x) && (s4_y == _x_s4_y)))) || ( !((( !s4_l2) && (s4_l1 && ( !s4_l0))) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && (((((s4_evt0 && s4_evt1) && (_x_s4_l2 && (( !_x_s4_l0) && ( !_x_s4_l1)))) && ((_x_s4_x == 0.0) && (s4_y == _x_s4_y))) && (_x_s4_z == 0.0)) || ( !((( !s4_l2) && (s4_l0 && s4_l1)) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && ((((s4_x == _x_s4_x) && (s4_y == _x_s4_y)) && ((s4_z == _x_s4_z) && ((( !_x_s4_l2) && (( !_x_s4_l0) && ( !_x_s4_l1))) || (_x_s4_l2 && (_x_s4_l0 && ( !_x_s4_l1)))))) || ( !((s4_l2 && (( !s4_l0) && ( !s4_l1))) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && (((s4_evt0 && ( !s4_evt1)) && ((20.0 <= s4_x) && ( !(120.0 <= s4_y)))) || ( !(((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))) && ((s4_l2 && (( !s4_l0) && ( !s4_l1))) && (_x_s4_l2 && (_x_s4_l0 && ( !_x_s4_l1)))))))) && (((s4_evt1 && ( !s4_evt0)) && ((20.0 <= s4_x) && (120.0 <= s4_y))) || ( !(((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))) && ((( !_x_s4_l2) && (( !_x_s4_l0) && ( !_x_s4_l1))) && (s4_l2 && (( !s4_l0) && ( !s4_l1)))))))) && (((s4_z == _x_s4_z) && (((s4_x == _x_s4_x) && (s4_y == _x_s4_y)) && ((s4_evt1 && ( !s4_evt0)) && (( !_x_s4_l2) && (( !_x_s4_l0) && ( !_x_s4_l1)))))) || ( !((s4_l2 && (s4_l0 && ( !s4_l1))) && ((delta == 0.0) && ( !(( !s4_evt0) && ( !s4_evt1)))))))) && ((((((((((((((((((((( !_x_s3_evt0) && ( !_x_s3_evt1)) || (_x_s3_evt0 && ( !_x_s3_evt1))) || ((_x_s3_evt1 && ( !_x_s3_evt0)) || (_x_s3_evt0 && _x_s3_evt1))) && ((((( !_x_s3_l2) && (( !_x_s3_l0) && ( !_x_s3_l1))) || (( !_x_s3_l2) && (_x_s3_l0 && ( !_x_s3_l1)))) || ((( !_x_s3_l2) && (_x_s3_l1 && ( !_x_s3_l0))) || (( !_x_s3_l2) && (_x_s3_l0 && _x_s3_l1)))) || ((_x_s3_l2 && (( !_x_s3_l0) && ( !_x_s3_l1))) || (_x_s3_l2 && (_x_s3_l0 && ( !_x_s3_l1)))))) && ((_x_s3_x <= 20.0) || ( !(( !_x_s3_l2) && (_x_s3_l0 && ( !_x_s3_l1)))))) && ((_x_s3_x <= 120.0) || ( !(( !_x_s3_l2) && (_x_s3_l1 && ( !_x_s3_l0)))))) && ((_x_s3_x <= 120.0) || ( !(_x_s3_l2 && (_x_s3_l0 && ( !_x_s3_l1)))))) && ((delta <= 0.0) || ((((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0) && ((delta + (s3_y + (-1.0 * _x_s3_y))) == 0.0)) && ((((s3_l0 == _x_s3_l0) && (s3_l1 == _x_s3_l1)) && (s3_l2 == _x_s3_l2)) && ((delta + (s3_z + (-1.0 * _x_s3_z))) == 0.0))))) && ((((((s3_l0 == _x_s3_l0) && (s3_l1 == _x_s3_l1)) && (s3_l2 == _x_s3_l2)) && ((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0)) && (((delta + (s3_y + (-1.0 * _x_s3_y))) == 0.0) && ((delta + (s3_z + (-1.0 * _x_s3_z))) == 0.0))) || ( !(( !s3_evt0) && ( !s3_evt1))))) && (((((s3_evt0 && s3_evt1) && (( !_x_s3_l2) && (_x_s3_l0 && ( !_x_s3_l1)))) && ((_x_s3_x == 0.0) && (_x_s3_y == 0.0))) && (s3_z == _x_s3_z)) || ( !((( !s3_l2) && (( !s3_l0) && ( !s3_l1))) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && (((((( !_x_s3_l2) && (_x_s3_l1 && ( !_x_s3_l0))) || (( !_x_s3_l2) && (_x_s3_l0 && _x_s3_l1))) && (s3_x == _x_s3_x)) && ((s3_z == _x_s3_z) && (s3_y == _x_s3_y))) || ( !((( !s3_l2) && (s3_l0 && ( !s3_l1))) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && (((s3_evt0 && ( !s3_evt1)) && ((20.0 <= s3_x) && ( !(120.0 <= s3_z)))) || ( !(((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))) && ((( !s3_l2) && (s3_l0 && ( !s3_l1))) && (( !_x_s3_l2) && (_x_s3_l1 && ( !_x_s3_l0)))))))) && (((s3_evt1 && ( !s3_evt0)) && ((20.0 <= s3_x) && (120.0 <= s3_z))) || ( !(((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))) && ((( !s3_l2) && (s3_l0 && ( !s3_l1))) && (( !_x_s3_l2) && (_x_s3_l0 && _x_s3_l1))))))) && (((s3_z == _x_s3_z) && (((s3_evt1 && ( !s3_evt0)) && (( !_x_s3_l2) && (_x_s3_l0 && _x_s3_l1))) && ((s3_x == _x_s3_x) && (s3_y == _x_s3_y)))) || ( !((( !s3_l2) && (s3_l1 && ( !s3_l0))) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && (((((s3_evt0 && s3_evt1) && (_x_s3_l2 && (( !_x_s3_l0) && ( !_x_s3_l1)))) && ((_x_s3_x == 0.0) && (s3_y == _x_s3_y))) && (_x_s3_z == 0.0)) || ( !((( !s3_l2) && (s3_l0 && s3_l1)) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && ((((s3_x == _x_s3_x) && (s3_y == _x_s3_y)) && ((s3_z == _x_s3_z) && ((( !_x_s3_l2) && (( !_x_s3_l0) && ( !_x_s3_l1))) || (_x_s3_l2 && (_x_s3_l0 && ( !_x_s3_l1)))))) || ( !((s3_l2 && (( !s3_l0) && ( !s3_l1))) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && (((s3_evt0 && ( !s3_evt1)) && ((20.0 <= s3_x) && ( !(120.0 <= s3_y)))) || ( !(((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))) && ((s3_l2 && (( !s3_l0) && ( !s3_l1))) && (_x_s3_l2 && (_x_s3_l0 && ( !_x_s3_l1)))))))) && (((s3_evt1 && ( !s3_evt0)) && ((20.0 <= s3_x) && (120.0 <= s3_y))) || ( !(((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))) && ((( !_x_s3_l2) && (( !_x_s3_l0) && ( !_x_s3_l1))) && (s3_l2 && (( !s3_l0) && ( !s3_l1)))))))) && (((s3_z == _x_s3_z) && (((s3_x == _x_s3_x) && (s3_y == _x_s3_y)) && ((s3_evt1 && ( !s3_evt0)) && (( !_x_s3_l2) && (( !_x_s3_l0) && ( !_x_s3_l1)))))) || ( !((s3_l2 && (s3_l0 && ( !s3_l1))) && ((delta == 0.0) && ( !(( !s3_evt0) && ( !s3_evt1)))))))) && ((((((((((((((((((((( !_x_s2_evt0) && ( !_x_s2_evt1)) || (_x_s2_evt0 && ( !_x_s2_evt1))) || ((_x_s2_evt1 && ( !_x_s2_evt0)) || (_x_s2_evt0 && _x_s2_evt1))) && ((((( !_x_s2_l2) && (( !_x_s2_l0) && ( !_x_s2_l1))) || (( !_x_s2_l2) && (_x_s2_l0 && ( !_x_s2_l1)))) || ((( !_x_s2_l2) && (_x_s2_l1 && ( !_x_s2_l0))) || (( !_x_s2_l2) && (_x_s2_l0 && _x_s2_l1)))) || ((_x_s2_l2 && (( !_x_s2_l0) && ( !_x_s2_l1))) || (_x_s2_l2 && (_x_s2_l0 && ( !_x_s2_l1)))))) && ((_x_s2_x <= 20.0) || ( !(( !_x_s2_l2) && (_x_s2_l0 && ( !_x_s2_l1)))))) && ((_x_s2_x <= 120.0) || ( !(( !_x_s2_l2) && (_x_s2_l1 && ( !_x_s2_l0)))))) && ((_x_s2_x <= 120.0) || ( !(_x_s2_l2 && (_x_s2_l0 && ( !_x_s2_l1)))))) && ((delta <= 0.0) || ((((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0) && ((delta + (s2_y + (-1.0 * _x_s2_y))) == 0.0)) && ((((s2_l0 == _x_s2_l0) && (s2_l1 == _x_s2_l1)) && (s2_l2 == _x_s2_l2)) && ((delta + (s2_z + (-1.0 * _x_s2_z))) == 0.0))))) && ((((((s2_l0 == _x_s2_l0) && (s2_l1 == _x_s2_l1)) && (s2_l2 == _x_s2_l2)) && ((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0)) && (((delta + (s2_y + (-1.0 * _x_s2_y))) == 0.0) && ((delta + (s2_z + (-1.0 * _x_s2_z))) == 0.0))) || ( !(( !s2_evt0) && ( !s2_evt1))))) && (((((s2_evt0 && s2_evt1) && (( !_x_s2_l2) && (_x_s2_l0 && ( !_x_s2_l1)))) && ((_x_s2_x == 0.0) && (_x_s2_y == 0.0))) && (s2_z == _x_s2_z)) || ( !((( !s2_l2) && (( !s2_l0) && ( !s2_l1))) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && (((((( !_x_s2_l2) && (_x_s2_l1 && ( !_x_s2_l0))) || (( !_x_s2_l2) && (_x_s2_l0 && _x_s2_l1))) && (s2_x == _x_s2_x)) && ((s2_z == _x_s2_z) && (s2_y == _x_s2_y))) || ( !((( !s2_l2) && (s2_l0 && ( !s2_l1))) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && (((s2_evt0 && ( !s2_evt1)) && ((20.0 <= s2_x) && ( !(120.0 <= s2_z)))) || ( !(((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))) && ((( !s2_l2) && (s2_l0 && ( !s2_l1))) && (( !_x_s2_l2) && (_x_s2_l1 && ( !_x_s2_l0)))))))) && (((s2_evt1 && ( !s2_evt0)) && ((20.0 <= s2_x) && (120.0 <= s2_z))) || ( !(((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))) && ((( !s2_l2) && (s2_l0 && ( !s2_l1))) && (( !_x_s2_l2) && (_x_s2_l0 && _x_s2_l1))))))) && (((s2_z == _x_s2_z) && (((s2_evt1 && ( !s2_evt0)) && (( !_x_s2_l2) && (_x_s2_l0 && _x_s2_l1))) && ((s2_x == _x_s2_x) && (s2_y == _x_s2_y)))) || ( !((( !s2_l2) && (s2_l1 && ( !s2_l0))) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && (((((s2_evt0 && s2_evt1) && (_x_s2_l2 && (( !_x_s2_l0) && ( !_x_s2_l1)))) && ((_x_s2_x == 0.0) && (s2_y == _x_s2_y))) && (_x_s2_z == 0.0)) || ( !((( !s2_l2) && (s2_l0 && s2_l1)) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && ((((s2_x == _x_s2_x) && (s2_y == _x_s2_y)) && ((s2_z == _x_s2_z) && ((( !_x_s2_l2) && (( !_x_s2_l0) && ( !_x_s2_l1))) || (_x_s2_l2 && (_x_s2_l0 && ( !_x_s2_l1)))))) || ( !((s2_l2 && (( !s2_l0) && ( !s2_l1))) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && (((s2_evt0 && ( !s2_evt1)) && ((20.0 <= s2_x) && ( !(120.0 <= s2_y)))) || ( !(((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))) && ((s2_l2 && (( !s2_l0) && ( !s2_l1))) && (_x_s2_l2 && (_x_s2_l0 && ( !_x_s2_l1)))))))) && (((s2_evt1 && ( !s2_evt0)) && ((20.0 <= s2_x) && (120.0 <= s2_y))) || ( !(((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))) && ((( !_x_s2_l2) && (( !_x_s2_l0) && ( !_x_s2_l1))) && (s2_l2 && (( !s2_l0) && ( !s2_l1)))))))) && (((s2_z == _x_s2_z) && (((s2_x == _x_s2_x) && (s2_y == _x_s2_y)) && ((s2_evt1 && ( !s2_evt0)) && (( !_x_s2_l2) && (( !_x_s2_l0) && ( !_x_s2_l1)))))) || ( !((s2_l2 && (s2_l0 && ( !s2_l1))) && ((delta == 0.0) && ( !(( !s2_evt0) && ( !s2_evt1)))))))) && ((((((((((((((((((((( !_x_s1_evt0) && ( !_x_s1_evt1)) || (_x_s1_evt0 && ( !_x_s1_evt1))) || ((_x_s1_evt1 && ( !_x_s1_evt0)) || (_x_s1_evt0 && _x_s1_evt1))) && ((((( !_x_s1_l2) && (( !_x_s1_l0) && ( !_x_s1_l1))) || (( !_x_s1_l2) && (_x_s1_l0 && ( !_x_s1_l1)))) || ((( !_x_s1_l2) && (_x_s1_l1 && ( !_x_s1_l0))) || (( !_x_s1_l2) && (_x_s1_l0 && _x_s1_l1)))) || ((_x_s1_l2 && (( !_x_s1_l0) && ( !_x_s1_l1))) || (_x_s1_l2 && (_x_s1_l0 && ( !_x_s1_l1)))))) && ((_x_s1_x <= 20.0) || ( !(( !_x_s1_l2) && (_x_s1_l0 && ( !_x_s1_l1)))))) && ((_x_s1_x <= 120.0) || ( !(( !_x_s1_l2) && (_x_s1_l1 && ( !_x_s1_l0)))))) && ((_x_s1_x <= 120.0) || ( !(_x_s1_l2 && (_x_s1_l0 && ( !_x_s1_l1)))))) && ((delta <= 0.0) || ((((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0) && ((delta + (s1_y + (-1.0 * _x_s1_y))) == 0.0)) && ((((s1_l0 == _x_s1_l0) && (s1_l1 == _x_s1_l1)) && (s1_l2 == _x_s1_l2)) && ((delta + (s1_z + (-1.0 * _x_s1_z))) == 0.0))))) && ((((((s1_l0 == _x_s1_l0) && (s1_l1 == _x_s1_l1)) && (s1_l2 == _x_s1_l2)) && ((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0)) && (((delta + (s1_y + (-1.0 * _x_s1_y))) == 0.0) && ((delta + (s1_z + (-1.0 * _x_s1_z))) == 0.0))) || ( !(( !s1_evt0) && ( !s1_evt1))))) && (((((s1_evt0 && s1_evt1) && (( !_x_s1_l2) && (_x_s1_l0 && ( !_x_s1_l1)))) && ((_x_s1_x == 0.0) && (_x_s1_y == 0.0))) && (s1_z == _x_s1_z)) || ( !((( !s1_l2) && (( !s1_l0) && ( !s1_l1))) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && (((((( !_x_s1_l2) && (_x_s1_l1 && ( !_x_s1_l0))) || (( !_x_s1_l2) && (_x_s1_l0 && _x_s1_l1))) && (s1_x == _x_s1_x)) && ((s1_z == _x_s1_z) && (s1_y == _x_s1_y))) || ( !((( !s1_l2) && (s1_l0 && ( !s1_l1))) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && (((s1_evt0 && ( !s1_evt1)) && ((20.0 <= s1_x) && ( !(120.0 <= s1_z)))) || ( !(((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))) && ((( !s1_l2) && (s1_l0 && ( !s1_l1))) && (( !_x_s1_l2) && (_x_s1_l1 && ( !_x_s1_l0)))))))) && (((s1_evt1 && ( !s1_evt0)) && ((20.0 <= s1_x) && (120.0 <= s1_z))) || ( !(((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))) && ((( !s1_l2) && (s1_l0 && ( !s1_l1))) && (( !_x_s1_l2) && (_x_s1_l0 && _x_s1_l1))))))) && (((s1_z == _x_s1_z) && (((s1_evt1 && ( !s1_evt0)) && (( !_x_s1_l2) && (_x_s1_l0 && _x_s1_l1))) && ((s1_x == _x_s1_x) && (s1_y == _x_s1_y)))) || ( !((( !s1_l2) && (s1_l1 && ( !s1_l0))) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && (((((s1_evt0 && s1_evt1) && (_x_s1_l2 && (( !_x_s1_l0) && ( !_x_s1_l1)))) && ((_x_s1_x == 0.0) && (s1_y == _x_s1_y))) && (_x_s1_z == 0.0)) || ( !((( !s1_l2) && (s1_l0 && s1_l1)) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && ((((s1_x == _x_s1_x) && (s1_y == _x_s1_y)) && ((s1_z == _x_s1_z) && ((( !_x_s1_l2) && (( !_x_s1_l0) && ( !_x_s1_l1))) || (_x_s1_l2 && (_x_s1_l0 && ( !_x_s1_l1)))))) || ( !((s1_l2 && (( !s1_l0) && ( !s1_l1))) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && (((s1_evt0 && ( !s1_evt1)) && ((20.0 <= s1_x) && ( !(120.0 <= s1_y)))) || ( !(((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))) && ((s1_l2 && (( !s1_l0) && ( !s1_l1))) && (_x_s1_l2 && (_x_s1_l0 && ( !_x_s1_l1)))))))) && (((s1_evt1 && ( !s1_evt0)) && ((20.0 <= s1_x) && (120.0 <= s1_y))) || ( !(((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))) && ((( !_x_s1_l2) && (( !_x_s1_l0) && ( !_x_s1_l1))) && (s1_l2 && (( !s1_l0) && ( !s1_l1)))))))) && (((s1_z == _x_s1_z) && (((s1_x == _x_s1_x) && (s1_y == _x_s1_y)) && ((s1_evt1 && ( !s1_evt0)) && (( !_x_s1_l2) && (( !_x_s1_l0) && ( !_x_s1_l1)))))) || ( !((s1_l2 && (s1_l0 && ( !s1_l1))) && ((delta == 0.0) && ( !(( !s1_evt0) && ( !s1_evt1)))))))) && ((((((((((((((((((((( !_x_s0_evt0) && ( !_x_s0_evt1)) || (_x_s0_evt0 && ( !_x_s0_evt1))) || ((_x_s0_evt1 && ( !_x_s0_evt0)) || (_x_s0_evt0 && _x_s0_evt1))) && ((((( !_x_s0_l2) && (( !_x_s0_l0) && ( !_x_s0_l1))) || (( !_x_s0_l2) && (_x_s0_l0 && ( !_x_s0_l1)))) || ((( !_x_s0_l2) && (_x_s0_l1 && ( !_x_s0_l0))) || (( !_x_s0_l2) && (_x_s0_l0 && _x_s0_l1)))) || ((_x_s0_l2 && (( !_x_s0_l0) && ( !_x_s0_l1))) || (_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1)))))) && ((_x_s0_x <= 20.0) || ( !(( !_x_s0_l2) && (_x_s0_l0 && ( !_x_s0_l1)))))) && ((_x_s0_x <= 120.0) || ( !(( !_x_s0_l2) && (_x_s0_l1 && ( !_x_s0_l0)))))) && ((_x_s0_x <= 120.0) || ( !(_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1)))))) && ((delta <= 0.0) || ((((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0) && ((delta + (s0_y + (-1.0 * _x_s0_y))) == 0.0)) && ((((s0_l0 == _x_s0_l0) && (s0_l1 == _x_s0_l1)) && (s0_l2 == _x_s0_l2)) && ((delta + (s0_z + (-1.0 * _x_s0_z))) == 0.0))))) && ((((((s0_l0 == _x_s0_l0) && (s0_l1 == _x_s0_l1)) && (s0_l2 == _x_s0_l2)) && ((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0)) && (((delta + (s0_y + (-1.0 * _x_s0_y))) == 0.0) && ((delta + (s0_z + (-1.0 * _x_s0_z))) == 0.0))) || ( !(( !s0_evt0) && ( !s0_evt1))))) && (((((s0_evt0 && s0_evt1) && (( !_x_s0_l2) && (_x_s0_l0 && ( !_x_s0_l1)))) && ((_x_s0_x == 0.0) && (_x_s0_y == 0.0))) && (s0_z == _x_s0_z)) || ( !((( !s0_l2) && (( !s0_l0) && ( !s0_l1))) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && (((((( !_x_s0_l2) && (_x_s0_l1 && ( !_x_s0_l0))) || (( !_x_s0_l2) && (_x_s0_l0 && _x_s0_l1))) && (s0_x == _x_s0_x)) && ((s0_z == _x_s0_z) && (s0_y == _x_s0_y))) || ( !((( !s0_l2) && (s0_l0 && ( !s0_l1))) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && (((s0_evt0 && ( !s0_evt1)) && ((20.0 <= s0_x) && ( !(120.0 <= s0_z)))) || ( !(((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))) && ((( !s0_l2) && (s0_l0 && ( !s0_l1))) && (( !_x_s0_l2) && (_x_s0_l1 && ( !_x_s0_l0)))))))) && (((s0_evt1 && ( !s0_evt0)) && ((20.0 <= s0_x) && (120.0 <= s0_z))) || ( !(((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))) && ((( !s0_l2) && (s0_l0 && ( !s0_l1))) && (( !_x_s0_l2) && (_x_s0_l0 && _x_s0_l1))))))) && (((s0_z == _x_s0_z) && (((s0_evt1 && ( !s0_evt0)) && (( !_x_s0_l2) && (_x_s0_l0 && _x_s0_l1))) && ((s0_x == _x_s0_x) && (s0_y == _x_s0_y)))) || ( !((( !s0_l2) && (s0_l1 && ( !s0_l0))) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && (((((s0_evt0 && s0_evt1) && (_x_s0_l2 && (( !_x_s0_l0) && ( !_x_s0_l1)))) && ((_x_s0_x == 0.0) && (s0_y == _x_s0_y))) && (_x_s0_z == 0.0)) || ( !((( !s0_l2) && (s0_l0 && s0_l1)) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && ((((s0_x == _x_s0_x) && (s0_y == _x_s0_y)) && ((s0_z == _x_s0_z) && ((( !_x_s0_l2) && (( !_x_s0_l0) && ( !_x_s0_l1))) || (_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1)))))) || ( !((s0_l2 && (( !s0_l0) && ( !s0_l1))) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && (((s0_evt0 && ( !s0_evt1)) && ((20.0 <= s0_x) && ( !(120.0 <= s0_y)))) || ( !(((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))) && ((s0_l2 && (( !s0_l0) && ( !s0_l1))) && (_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1)))))))) && (((s0_evt1 && ( !s0_evt0)) && ((20.0 <= s0_x) && (120.0 <= s0_y))) || ( !(((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))) && ((( !_x_s0_l2) && (( !_x_s0_l0) && ( !_x_s0_l1))) && (s0_l2 && (( !s0_l0) && ( !s0_l1)))))))) && (((s0_z == _x_s0_z) && (((s0_x == _x_s0_x) && (s0_y == _x_s0_y)) && ((s0_evt1 && ( !s0_evt0)) && (( !_x_s0_l2) && (( !_x_s0_l0) && ( !_x_s0_l1)))))) || ( !((s0_l2 && (s0_l0 && ( !s0_l1))) && ((delta == 0.0) && ( !(( !s0_evt0) && ( !s0_evt1)))))))) && (((((((((((((((((((((((((((((_x_r_evt_id == 0) || (_x_r_evt_id == 1)) || (_x_r_evt_id == 2)) || (_x_r_evt_id == 3)) || (_x_r_evt_id == 4)) || (_x_r_evt_id == 5)) || (_x_r_evt_id == 6)) || (_x_r_evt_id == 7)) || (_x_r_evt_id == 8)) || (_x_r_evt_id == 9)) || (_x_r_evt_id == 10)) || (_x_r_evt_id == 11)) || (_x_r_evt_id == 12)) || (_x_r_evt_id == 13)) || (_x_r_evt_id == 14)) || (_x_r_evt_id == 15)) || (_x_r_evt_id == 16)) || (_x_r_evt_id == 17)) || (_x_r_evt_id == 18)) || (_x_r_evt_id == 19)) || (_x_r_evt_id == 20)) && (((((((((((((((((((((_x_r_counter == 0) || (_x_r_counter == 1)) || (_x_r_counter == 2)) || (_x_r_counter == 3)) || (_x_r_counter == 4)) || (_x_r_counter == 5)) || (_x_r_counter == 6)) || (_x_r_counter == 7)) || (_x_r_counter == 8)) || (_x_r_counter == 9)) || (_x_r_counter == 10)) || (_x_r_counter == 11)) || (_x_r_counter == 12)) || (_x_r_counter == 13)) || (_x_r_counter == 14)) || (_x_r_counter == 15)) || (_x_r_counter == 16)) || (_x_r_counter == 17)) || (_x_r_counter == 18)) || (_x_r_counter == 19)) || (_x_r_counter == 20))) && (( !_x_r_l) || (_x_r_x <= 0.0))) && ((delta <= 0.0) || (((delta + (r_x + (-1.0 * _x_r_x))) == 0.0) && ((r_l == _x_r_l) && (r_counter == _x_r_counter))))) && (((r_l == _x_r_l) && (((delta + (r_x + (-1.0 * _x_r_x))) == 0.0) && (r_counter == _x_r_counter))) || ( !(( !r_event0) && ( !r_event1))))) && (((((r_event1 && ( !r_event0)) && (r_x <= 0.0)) && (( !_x_r_l) && (r_evt_id == r_counter))) && ((r_counter == _x_r_counter) && (r_x == _x_r_x))) || ( !(r_l && (( !(( !r_event0) && ( !r_event1))) && (delta == 0.0)))))) && ((_x_r_l && (((r_event0 && ( !r_event1)) && (r_evt_id == r_counter)) && ((_x_r_x == 0.0) && ((r_counter + (-1 * _x_r_counter)) == -1)))) || ( !((( !(( !r_event0) && ( !r_event1))) && (delta == 0.0)) && (( !r_l) && ( !(20 <= r_counter))))))) && ((_x_r_l && (((r_event0 && ( !r_event1)) && (r_evt_id == r_counter)) && ((_x_r_counter == 0) && (_x_r_x == 0.0)))) || ( !((( !(( !r_event0) && ( !r_event1))) && (delta == 0.0)) && (( !r_l) && (r_counter == 20)))))) && (0.0 <= _x_delta))))))))))))))))))))))) && ((( !(( !s20_evt0) && ( !s20_evt1))) || (( !(( !s19_evt0) && ( !s19_evt1))) || (( !(( !s18_evt0) && ( !s18_evt1))) || (( !(( !s17_evt0) && ( !s17_evt1))) || (( !(( !s16_evt0) && ( !s16_evt1))) || (( !(( !s15_evt0) && ( !s15_evt1))) || (( !(( !s14_evt0) && ( !s14_evt1))) || (( !(( !s13_evt0) && ( !s13_evt1))) || (( !(( !s12_evt0) && ( !s12_evt1))) || (( !(( !s11_evt0) && ( !s11_evt1))) || (( !(( !s10_evt0) && ( !s10_evt1))) || (( !(( !s9_evt0) && ( !s9_evt1))) || (( !(( !s8_evt0) && ( !s8_evt1))) || (( !(( !s7_evt0) && ( !s7_evt1))) || (( !(( !s6_evt0) && ( !s6_evt1))) || (( !(( !s5_evt0) && ( !s5_evt1))) || (( !(( !s4_evt0) && ( !s4_evt1))) || (( !(( !s3_evt0) && ( !s3_evt1))) || (( !(( !s2_evt0) && ( !s2_evt1))) || (( !(( !s1_evt0) && ( !s1_evt1))) || (( !(( !r_event0) && ( !r_event1))) || ( !(( !s0_evt0) && ( !s0_evt1)))))))))))))))))))))))) || ( !(delta == 0.0)))) && (( !(delta == 0.0)) || ((s0_evt1 && ( !s0_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 0))))) && (( !(delta == 0.0)) || ((s0_evt0 && s0_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 0))))) && (( !(delta == 0.0)) || ((s1_evt1 && ( !s1_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 1))))) && (( !(delta == 0.0)) || ((s1_evt0 && s1_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 1))))) && (( !(delta == 0.0)) || ((s2_evt1 && ( !s2_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 2))))) && (( !(delta == 0.0)) || ((s2_evt0 && s2_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 2))))) && (( !(delta == 0.0)) || ((s3_evt1 && ( !s3_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 3))))) && (( !(delta == 0.0)) || ((s3_evt0 && s3_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 3))))) && (( !(delta == 0.0)) || ((s4_evt1 && ( !s4_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 4))))) && (( !(delta == 0.0)) || ((s4_evt0 && s4_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 4))))) && (( !(delta == 0.0)) || ((s5_evt1 && ( !s5_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 5))))) && (( !(delta == 0.0)) || ((s5_evt0 && s5_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 5))))) && (( !(delta == 0.0)) || ((s6_evt1 && ( !s6_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 6))))) && (( !(delta == 0.0)) || ((s6_evt0 && s6_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 6))))) && (( !(delta == 0.0)) || ((s7_evt1 && ( !s7_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 7))))) && (( !(delta == 0.0)) || ((s7_evt0 && s7_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 7))))) && (( !(delta == 0.0)) || ((s8_evt1 && ( !s8_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 8))))) && (( !(delta == 0.0)) || ((s8_evt0 && s8_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 8))))) && (( !(delta == 0.0)) || ((s9_evt1 && ( !s9_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 9))))) && (( !(delta == 0.0)) || ((s9_evt0 && s9_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 9))))) && (( !(delta == 0.0)) || ((s10_evt1 && ( !s10_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 10))))) && (( !(delta == 0.0)) || ((s10_evt0 && s10_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 10))))) && (( !(delta == 0.0)) || ((s11_evt1 && ( !s11_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 11))))) && (( !(delta == 0.0)) || ((s11_evt0 && s11_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 11))))) && (( !(delta == 0.0)) || ((s12_evt1 && ( !s12_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 12))))) && (( !(delta == 0.0)) || ((s12_evt0 && s12_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 12))))) && (( !(delta == 0.0)) || ((s13_evt1 && ( !s13_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 13))))) && (( !(delta == 0.0)) || ((s13_evt0 && s13_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 13))))) && (( !(delta == 0.0)) || ((s14_evt1 && ( !s14_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 14))))) && (( !(delta == 0.0)) || ((s14_evt0 && s14_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 14))))) && (( !(delta == 0.0)) || ((s15_evt1 && ( !s15_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 15))))) && (( !(delta == 0.0)) || ((s15_evt0 && s15_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 15))))) && (( !(delta == 0.0)) || ((s16_evt1 && ( !s16_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 16))))) && (( !(delta == 0.0)) || ((s16_evt0 && s16_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 16))))) && (( !(delta == 0.0)) || ((s17_evt1 && ( !s17_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 17))))) && (( !(delta == 0.0)) || ((s17_evt0 && s17_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 17))))) && (( !(delta == 0.0)) || ((s18_evt1 && ( !s18_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 18))))) && (( !(delta == 0.0)) || ((s18_evt0 && s18_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 18))))) && (( !(delta == 0.0)) || ((s19_evt1 && ( !s19_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 19))))) && (( !(delta == 0.0)) || ((s19_evt0 && s19_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 19))))) && (( !(delta == 0.0)) || ((s20_evt1 && ( !s20_evt0)) == ((r_event0 && ( !r_event1)) && (r_evt_id == 20))))) && (( !(delta == 0.0)) || ((s20_evt0 && s20_evt1) == ((r_event1 && ( !r_event0)) && (r_evt_id == 20))))) && (((delta == _x__diverge_delta) || ( !(1.0 <= _diverge_delta))) && ((1.0 <= _diverge_delta) || ((delta + (_diverge_delta + (-1.0 * _x__diverge_delta))) == 0.0)))) && ((((((_EL_U_5113 == (_x__EL_U_5113 || ( !(_x__EL_U_5111 || (1.0 <= _x__diverge_delta))))) && ((_EL_U_5111 == (_x__EL_U_5111 || (1.0 <= _x__diverge_delta))) && ((_EL_U_5115 == ((_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1))) || _x__EL_U_5115)) && (_EL_U_5117 == (_x__EL_U_5117 || ( !((_x_s0_l2 && (_x_s0_l0 && ( !_x_s0_l1))) || _x__EL_U_5115))))))) && (_x__J5137 == (( !(((_J5137 && _J5143) && _J5149) && _J5155)) && ((((_J5137 && _J5143) && _J5149) && _J5155) || (((s0_l2 && (s0_l0 && ( !s0_l1))) || ( !((s0_l2 && (s0_l0 && ( !s0_l1))) || _EL_U_5115))) || _J5137))))) && (_x__J5143 == (( !(((_J5137 && _J5143) && _J5149) && _J5155)) && ((((_J5137 && _J5143) && _J5149) && _J5155) || ((( !((s0_l2 && (s0_l0 && ( !s0_l1))) || _EL_U_5115)) || ( !(_EL_U_5117 || ( !((s0_l2 && (s0_l0 && ( !s0_l1))) || _EL_U_5115))))) || _J5143))))) && (_x__J5149 == (( !(((_J5137 && _J5143) && _J5149) && _J5155)) && ((((_J5137 && _J5143) && _J5149) && _J5155) || (((1.0 <= _diverge_delta) || ( !((1.0 <= _diverge_delta) || _EL_U_5111))) || _J5149))))) && (_x__J5155 == (( !(((_J5137 && _J5143) && _J5149) && _J5155)) && ((((_J5137 && _J5143) && _J5149) && _J5155) || ((( !((1.0 <= _diverge_delta) || _EL_U_5111)) || ( !(_EL_U_5113 || ( !((1.0 <= _diverge_delta) || _EL_U_5111))))) || _J5155))))));
s16_x = _x_s16_x;
s16_l1 = _x_s16_l1;
_diverge_delta = _x__diverge_delta;
delta = _x_delta;
r_x = _x_r_x;
s7_l1 = _x_s7_l1;
r_l = _x_r_l;
s7_l0 = _x_s7_l0;
s16_z = _x_s16_z;
s7_l2 = _x_s7_l2;
s16_y = _x_s16_y;
r_counter = _x_r_counter;
s7_x = _x_s7_x;
s7_z = _x_s7_z;
s16_evt1 = _x_s16_evt1;
s16_evt0 = _x_s16_evt0;
s7_y = _x_s7_y;
s17_l1 = _x_s17_l1;
s7_evt1 = _x_s7_evt1;
s17_l0 = _x_s17_l0;
s7_evt0 = _x_s7_evt0;
s17_l2 = _x_s17_l2;
s17_x = _x_s17_x;
s8_l1 = _x_s8_l1;
s8_l0 = _x_s8_l0;
s17_z = _x_s17_z;
s8_l2 = _x_s8_l2;
s17_y = _x_s17_y;
s8_x = _x_s8_x;
r_evt_id = _x_r_evt_id;
s8_z = _x_s8_z;
s17_evt1 = _x_s17_evt1;
s17_evt0 = _x_s17_evt0;
s8_y = _x_s8_y;
s18_l1 = _x_s18_l1;
s8_evt1 = _x_s8_evt1;
s18_l0 = _x_s18_l0;
s8_evt0 = _x_s8_evt0;
s18_l2 = _x_s18_l2;
s18_x = _x_s18_x;
r_event0 = _x_r_event0;
r_event1 = _x_r_event1;
s9_l1 = _x_s9_l1;
s9_l0 = _x_s9_l0;
s18_z = _x_s18_z;
s9_l2 = _x_s9_l2;
s18_y = _x_s18_y;
s9_x = _x_s9_x;
s0_l1 = _x_s0_l1;
s0_l0 = _x_s0_l0;
s0_l2 = _x_s0_l2;
s9_z = _x_s9_z;
s18_evt1 = _x_s18_evt1;
s18_evt0 = _x_s18_evt0;
s9_y = _x_s9_y;
s0_x = _x_s0_x;
s0_z = _x_s0_z;
s19_l1 = _x_s19_l1;
s9_evt1 = _x_s9_evt1;
s19_l0 = _x_s19_l0;
s9_evt0 = _x_s9_evt0;
s19_l2 = _x_s19_l2;
s0_y = _x_s0_y;
s19_x = _x_s19_x;
s10_l1 = _x_s10_l1;
s0_evt1 = _x_s0_evt1;
s10_l0 = _x_s10_l0;
s19_z = _x_s19_z;
s0_evt0 = _x_s0_evt0;
s19_y = _x_s19_y;
s10_l2 = _x_s10_l2;
s10_x = _x_s10_x;
s1_l1 = _x_s1_l1;
s1_l0 = _x_s1_l0;
s10_z = _x_s10_z;
s19_evt1 = _x_s19_evt1;
s19_evt0 = _x_s19_evt0;
s1_l2 = _x_s1_l2;
s10_y = _x_s10_y;
s1_x = _x_s1_x;
s1_z = _x_s1_z;
s20_l1 = _x_s20_l1;
s10_evt1 = _x_s10_evt1;
s20_l0 = _x_s20_l0;
s10_evt0 = _x_s10_evt0;
s20_l2 = _x_s20_l2;
s1_y = _x_s1_y;
s20_x = _x_s20_x;
s11_l1 = _x_s11_l1;
s1_evt1 = _x_s1_evt1;
s11_l0 = _x_s11_l0;
s20_z = _x_s20_z;
s1_evt0 = _x_s1_evt0;
s20_y = _x_s20_y;
s11_l2 = _x_s11_l2;
s11_x = _x_s11_x;
s2_l1 = _x_s2_l1;
s2_l0 = _x_s2_l0;
s11_z = _x_s11_z;
s20_evt1 = _x_s20_evt1;
s20_evt0 = _x_s20_evt0;
s2_l2 = _x_s2_l2;
s11_y = _x_s11_y;
s2_x = _x_s2_x;
s2_z = _x_s2_z;
s11_evt1 = _x_s11_evt1;
s11_evt0 = _x_s11_evt0;
s2_y = _x_s2_y;
_J5155 = _x__J5155;
_J5149 = _x__J5149;
_J5143 = _x__J5143;
_J5137 = _x__J5137;
_EL_U_5111 = _x__EL_U_5111;
_EL_U_5113 = _x__EL_U_5113;
_EL_U_5115 = _x__EL_U_5115;
s12_l1 = _x_s12_l1;
s2_evt1 = _x_s2_evt1;
s12_l0 = _x_s12_l0;
s2_evt0 = _x_s2_evt0;
s12_l2 = _x_s12_l2;
_EL_U_5117 = _x__EL_U_5117;
s12_x = _x_s12_x;
s3_l1 = _x_s3_l1;
s3_l0 = _x_s3_l0;
s12_z = _x_s12_z;
s3_l2 = _x_s3_l2;
s12_y = _x_s12_y;
s3_x = _x_s3_x;
s3_z = _x_s3_z;
s12_evt1 = _x_s12_evt1;
s12_evt0 = _x_s12_evt0;
s3_y = _x_s3_y;
s13_l1 = _x_s13_l1;
s3_evt1 = _x_s3_evt1;
s13_l0 = _x_s13_l0;
s3_evt0 = _x_s3_evt0;
s13_l2 = _x_s13_l2;
s13_x = _x_s13_x;
s4_l1 = _x_s4_l1;
s4_l0 = _x_s4_l0;
s13_z = _x_s13_z;
s4_l2 = _x_s4_l2;
s13_y = _x_s13_y;
s4_x = _x_s4_x;
s4_z = _x_s4_z;
s13_evt1 = _x_s13_evt1;
s13_evt0 = _x_s13_evt0;
s4_y = _x_s4_y;
s14_l1 = _x_s14_l1;
s4_evt1 = _x_s4_evt1;
s14_l0 = _x_s14_l0;
s4_evt0 = _x_s4_evt0;
s14_l2 = _x_s14_l2;
s14_x = _x_s14_x;
s5_l1 = _x_s5_l1;
s5_l0 = _x_s5_l0;
s14_z = _x_s14_z;
s5_l2 = _x_s5_l2;
s14_y = _x_s14_y;
s5_x = _x_s5_x;
s5_z = _x_s5_z;
s14_evt1 = _x_s14_evt1;
s14_evt0 = _x_s14_evt0;
s5_y = _x_s5_y;
s15_l1 = _x_s15_l1;
s5_evt1 = _x_s5_evt1;
s15_l0 = _x_s15_l0;
s5_evt0 = _x_s5_evt0;
s15_l2 = _x_s15_l2;
s15_x = _x_s15_x;
s6_l1 = _x_s6_l1;
s6_l0 = _x_s6_l0;
s15_z = _x_s15_z;
s6_l2 = _x_s6_l2;
s15_y = _x_s15_y;
s6_x = _x_s6_x;
s6_z = _x_s6_z;
s15_evt1 = _x_s15_evt1;
s15_evt0 = _x_s15_evt0;
s6_y = _x_s6_y;
s6_evt1 = _x_s6_evt1;
s6_evt0 = _x_s6_evt0;
s16_l0 = _x_s16_l0;
s16_l2 = _x_s16_l2;
}
}
|
the_stack_data/179831110.c
|
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <regex.h>
int main(int argc, char* argv[]) {
char *test_string = "SET_P99.9_D3_XDES2.5_";
char *match_string = "_P([0-9]*.[0-9]*)_";
char buffer[1000];
double P = 0;
regex_t compiled;
regmatch_t matches[4];
regcomp(&compiled, match_string, REG_EXTENDED);
//printf("%s\n", str);
if(regexec(&compiled, test_string, 4, matches, 0)==0){
sprintf(buffer, "%.*s\n", matches[1].rm_eo-matches[1].rm_so, test_string+matches[1].rm_so );
sscanf(buffer, "%lf", &P);
printf("%s\n", buffer);
printf("%f\n", P);
}
return 0;
}
|
the_stack_data/75055.c
|
#include <stdio.h>
#include <math.h>
#define MIN_TERM 1e-6
int main(void)
{
double pi = 0.0, n = 1.0, term = 1.0;
int sign = 1;
while (fabs(term) >= MIN_TERM)
{
pi += term;
n += 2;
sign *= -1;
term = sign / n;
}
pi = pi * 4;
printf("pi=%.8lf\n", pi);
return 0;
}
|
the_stack_data/52713.c
|
// Copyright (c) 2015, the Dartino project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE.md file.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
FILE* fopen$UNIX2003(const char* filename, const char* mode) {
return fopen(filename, mode);
}
size_t fwrite$UNIX2003(const void* a, size_t b, size_t c, FILE* d) {
return fwrite(a, b, c, d);
}
int fputs$UNIX2003(const char* restrict str, FILE* restrict stream) {
return fputs(str, stream);
}
pid_t waitpid$UNIX2003(pid_t pid, int* status, int options) {
return waitpid(pid, status, options);
}
char* strerror$UNIX2003(int errnum) {
return strerror(errnum);
}
|
the_stack_data/68888017.c
|
/*
american fuzzy lop++ - a trivial program to test the build
--------------------------------------------------------
Originally written by Michal Zalewski
Copyright 2014 Google Inc. All rights reserved.
Copyright 2019-2020 AFLplusplus Project. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at:
http://www.apache.org/licenses/LICENSE-2.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char **argv) {
int fd = 0;
char buff[8];
char *buf = buff;
// we support command line parameter and stdin
if (argc == 2) {
buf = argv[1];
printf("Input %s - ", buf);
} else {
if (argc >= 3 && strcmp(argv[1], "-f") == 0)
if ((fd = open(argv[2], O_RDONLY)) < 0) {
fprintf(stderr, "Error: unable to open %s\n", argv[2]);
exit(-1);
}
if (read(fd, buf, sizeof(buf)) < 1) {
printf("Hum?\n");
return 1;
}
}
// we support three input cases (plus a 4th if stdin is used but there is no
// input)
if (buf[0] == '0')
printf("Looks like a zero to me!\n");
else if (buf[0] == '1')
printf("Pretty sure that is a one!\n");
else
printf("Neither one or zero? How quaint!\n");
return 0;
}
|
the_stack_data/156392719.c
|
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// Definição das variaveis que controlam a medição de tempo
clock_t _ini, _fim;
// Definição do tipo booleano
unsigned char typedef bool;
#define TRUE 1
#define FALSE 0
int* ler_inteiros(const char * arquivo, const int n){
FILE* f = fopen(arquivo, "r");
int * inteiros = (int *) malloc(sizeof(int) * n);
for (int i = 0; !feof(f); i++)
fscanf(f, "%d\n", &inteiros[i]);
fclose(f);
return inteiros;
}
void inicia_tempo(){
srand(time(NULL));
_ini = clock();
}
double finaliza_tempo(){
_fim = clock();
return ((double) (_fim - _ini)) / CLOCKS_PER_SEC;
}
int busca_sequencial(int entradas[], int n, int e){
// iterador que conterá a posicao do elemento e procurado, caso seja encontrado
int pos;
// procura o elemento em todas as posições do vetor
for(pos = 0; pos < n; pos++)
// testa se o elemento da posição atual é o elemento procurado de um por um
if(entradas[pos] == e)
// para a busca segunrando a posição pos do elemento
break;
// retorna a posicao caso o elemento seja encontrado, cc retorna -1
return (pos == n) ? -1 : pos;
}
int main(int argc, char const *argv[]){
const int N = 50000;
unsigned encontrados = 0;
int* entradas = ler_inteiros("inteiros_entrada.txt", N);
int* consultas = ler_inteiros("inteiros_busca.txt", N);
// realiza busca sequencial
inicia_tempo();
for (int i = 0; i < N; i++)
// se a busca for bem sucedida, encontrados é incrementado
if(busca_sequencial(entradas, N, consultas[i]) != -1)
encontrados++;
double tempo_busca = finaliza_tempo();
printf("Tempo de busca :\t%fs\n", tempo_busca);
printf("Itens encontrados :\t%d\n", encontrados);
/*
int entradas[5] = {9, 6, 4, 3, 1};
int consultas[5] = {10, 6, 4, 0, 1};
int res;
for (int i = 0; i < 5; i++){
res = busca_sequencial(entradas, 5, consultas[i]);
printf("\nres = %d", res);
// buscar o elemento consultas[i] na entrada
}
*/
return 0;
}
|
the_stack_data/220455332.c
|
/**
* @file lv_port_fs_templ.c
*
*/
/*Copy this file as "lv_port_fs.c" and set this value to "1" to enable content*/
#if 0
/*********************
* INCLUDES
*********************/
#include "lv_port_fs_templ.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/* Create a type to store the required data about your file.
* If you are using a File System library
* it already should have a File type.
* For example FatFS has `FIL`. In this case use `typedef FIL file_t`*/
typedef struct {
/*Add the data you need to store about a file*/
uint32_t dummy1;
uint32_t dummy2;
}file_t;
/*Similarly to `file_t` create a type for directory reading too */
typedef struct {
/*Add the data you need to store about directory reading*/
uint32_t dummy1;
uint32_t dummy2;
}dir_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void fs_init(void);
static lv_fs_res_t fs_open (void * file_p, const char * path, lv_fs_mode_t mode);
static lv_fs_res_t fs_close (void * file_p);
static lv_fs_res_t fs_read (void * file_p, void * buf, uint32_t btr, uint32_t * br);
static lv_fs_res_t fs_write(void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
static lv_fs_res_t fs_seek (void * file_p, uint32_t pos);
static lv_fs_res_t fs_size (void * file_p, uint32_t * size_p);
static lv_fs_res_t fs_tell (void * file_p, uint32_t * pos_p);
static lv_fs_res_t fs_remove (const char *path);
static lv_fs_res_t fs_trunc (void * file_p);
static lv_fs_res_t fs_rename (const char * oldname, const char * newname);
static lv_fs_res_t fs_free (uint32_t * total_p, uint32_t * free_p);
static lv_fs_res_t fs_dir_open (void * rddir_p, const char *path);
static lv_fs_res_t fs_dir_read (void * rddir_p, char *fn);
static lv_fs_res_t fs_dir_close (void * rddir_p);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_port_fs_init(void)
{
/*----------------------------------------------------
* Initialize your storage device and File System
* -------------------------------------------------*/
fs_init();
/*---------------------------------------------------
* Register the file system interface in LittlevGL
*--------------------------------------------------*/
/* Add a simple drive to open images */
lv_fs_drv_t fs_drv; /*A driver descriptor*/
memset(&fs_drv, 0, sizeof(lv_fs_drv_t)); /*Initialization*/
/*Set up fields...*/
fs_drv.file_size = sizeof(file_t);
fs_drv.letter = 'P';
fs_drv.open = fs_open;
fs_drv.close = fs_close;
fs_drv.read = fs_read;
fs_drv.write = fs_write;
fs_drv.seek = fs_seek;
fs_drv.tell = fs_tell;
fs_drv.free = fs_free;
fs_drv.size = fs_size;
fs_drv.remove = fs_remove;
fs_drv.rename = fs_rename;
fs_drv.trunc = fs_trunc;
fs_drv.rddir_size = sizeof(dir_t);
fs_drv.dir_close = fs_dir_close;
fs_drv.dir_open = fs_dir_open;
fs_drv.dir_read = fs_dir_read;
lv_fs_add_drv(&fs_drv);
}
/**********************
* STATIC FUNCTIONS
**********************/
/* Initialize your Storage device and File system. */
static void fs_init(void)
{
/*E.g. for FatFS initalize the SD card and FatFS itself*/
/*You code here*/
}
/**
* Open a file
* @param file_p pointer to a file_t variable
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_open (void * file_p, const char * path, lv_fs_mode_t mode)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
if(mode == LV_FS_MODE_WR)
{
/*Open a file for write*/
/* Add your code here*/
}
else if(mode == LV_FS_MODE_RD)
{
/*Open a file for read*/
/* Add your code here*/
}
else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD))
{
/*Open a file for read and write*/
/* Add your code here*/
}
return res;
}
/**
* Close an opened file
* @param file_p pointer to a file_t variable. (opened with lv_ufs_open)
* @return LV_FS_RES_OK: no error, the file is read
* any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_close (void * file_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Read data from an opened file
* @param file_p pointer to a file_t variable.
* @param buf pointer to a memory block where to store the read data
* @param btr number of Bytes To Read
* @param br the real number of read bytes (Byte Read)
* @return LV_FS_RES_OK: no error, the file is read
* any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_read (void * file_p, void * buf, uint32_t btr, uint32_t * br)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Write into a file
* @param file_p pointer to a file_t variable
* @param buf pointer to a buffer with the bytes to write
* @param btr Bytes To Write
* @param br the number of real written bytes (Bytes Written). NULL if unused.
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_write(void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Set the read write pointer. Also expand the file size if necessary.
* @param file_p pointer to a file_t variable. (opened with lv_ufs_open )
* @param pos the new position of read write pointer
* @return LV_FS_RES_OK: no error, the file is read
* any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_seek (void * file_p, uint32_t pos)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Give the size of a file bytes
* @param file_p pointer to a file_t variable
* @param size pointer to a variable to store the size
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_size (void * file_p, uint32_t * size_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Give the position of the read write pointer
* @param file_p pointer to a file_t variable.
* @param pos_p pointer to to store the result
* @return LV_FS_RES_OK: no error, the file is read
* any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_tell (void * file_p, uint32_t * pos_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Delete a file
* @param path path of the file to delete
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_remove (const char *path)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Truncate the file size to the current position of the read write pointer
* @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open )
* @return LV_FS_RES_OK: no error, the file is read
* any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_trunc (void * file_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Rename a file
* @param oldname path to the file
* @param newname path with the new name
* @return LV_FS_RES_OK or any error from 'fs_res_t'
*/
static lv_fs_res_t fs_rename (const char * oldname, const char * newname)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Get the free and total size of a driver in kB
* @param letter the driver letter
* @param total_p pointer to store the total size [kB]
* @param free_p pointer to store the free size [kB]
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_free (uint32_t * total_p, uint32_t * free_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Initialize a 'fs_read_dir_t' variable for directory reading
* @param rddir_p pointer to a 'fs_read_dir_t' variable
* @param path path to a directory
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_dir_open (void * rddir_p, const char *path)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Read the next filename form a directory.
* The name of the directories will begin with '/'
* @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
* @param fn pointer to a buffer to store the filename
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_dir_read (void * rddir_p, char *fn)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
/**
* Close the directory reading
* @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/
static lv_fs_res_t fs_dir_close (void * rddir_p)
{
lv_fs_res_t res = LV_FS_RES_NOT_IMP;
/* Add your code here*/
return res;
}
#else /* Enable this file at the top */
/* This dummy typedef exists purely to silence -Wpedantic. */
typedef int keep_pedantic_happy;
#endif
|
the_stack_data/161080151.c
|
#include <stdio.h>
#include <stdlib.h>
#ifndef _WIN32
# include <unistd.h>
#endif
int stack[30000];
int size;
int memory;
struct { int x, y, d; } jump[300];
int jumps;
extern int display_code;
extern char buf[1000][1000];
int direction, skip, x, y, dx, dy;
enum { UNDEF, NORTHWEST, NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST };
void parse(char);
int swap(int*,int*);
void triangular(void)
{
direction = SOUTHEAST;
while (1)
{
if (!buf[y][0])
return;
parse(buf[y][x]);
switch (direction) {
case NORTHWEST: dx = -1; dy = -1; break;
case NORTH: dx = -1; dy = -2; break;
case NORTHEAST: dx = 0; dy = -1; break;
case WEST: dx = -1; dy = 0; break;
case EAST: dx = 1; dy = 0; break;
case SOUTHWEST: dx = 0; dy = 1; break;
case SOUTH: dx = 1; dy = 2; break;
case SOUTHEAST: dx = 1; dy = 1; break;
}
skip = skip < 0 ? 0 : skip;
x += dx * (skip + 1);
y += dy * (skip + 1);
skip = 0;
if (x < 0 || x > y || y < 0 || y >= 1000 || buf[y][x] <= 0)
exit(EXIT_SUCCESS);
}
}
int next_direction(int direction, int change)
{
if (change == 1) {
switch (direction) {
case NORTH: return NORTHEAST;
case NORTHEAST: return EAST;
case EAST: return SOUTHEAST;
case SOUTHEAST: return SOUTH;
case SOUTH: return SOUTHWEST;
case SOUTHWEST: return WEST;
case WEST: return NORTHWEST;
case NORTHWEST: return NORTH;
}
} else {
switch (direction) {
case NORTH: return NORTHWEST;
case NORTHEAST: return NORTH;
case EAST: return NORTHEAST;
case SOUTHEAST: return EAST;
case SOUTH: return SOUTHEAST;
case SOUTHWEST: return SOUTH;
case WEST: return SOUTHWEST;
case NORTHWEST: return WEST;
}
}
return -1;
}
void parse(char command)
{
if (display_code) {
printf("Executing %c\n",command);
usleep(500000);
}
switch (command) {
/* directional */
case '`': direction = NORTHWEST; break;
case '^': direction = NORTH; break;
case '/': direction = NORTHEAST; break;
case '<': direction = WEST; break;
case '>': direction = EAST; break;
case ',': direction = SOUTHWEST; break;
case 'v': direction = SOUTH; break;
case '\\':direction = SOUTHEAST; break;
case 'o': direction = next_direction(direction, 1); break;
case 'e': direction = next_direction(direction, -1); break;
case 'c': direction = next_direction(direction, 1); buf[y][x] = 'z'; break;
case 'z': direction = next_direction(direction, -1); buf[y][x] = 'c'; break;
/* more directionals jkmnqrtw */
case 'j': size && stack[size-1] > 0 && (direction = NORTHWEST); break;
case 'k': size && stack[size-1] > 0 && (direction = NORTH); break;
case 'y': size && stack[size-1] > 0 && (direction = NORTHEAST); break;
case 'n': size && stack[size-1] > 0 && (direction = EAST); break;
case 'q': size && stack[size-1] > 0 && (direction = SOUTHEAST); break;
case 'r': size && stack[size-1] > 0 && (direction = SOUTH); break;
case 't': size && stack[size-1] > 0 && (direction = SOUTHWEST); break;
case 'w': size && stack[size-1] > 0 && (direction = WEST); break;
/* program */
case '&': exit(EXIT_SUCCESS);
/* stack */
case 'p': size > 0 && (size--); break;
case ':': size > 0 && (stack[size] = stack[size-1]); size > 0 && (size++); break;
case '+': size > 1 && (stack[size-2] += stack[size-1]); size > 1 && (size--); break;
case '-': size > 1 && (stack[size-2] -= stack[size-1]); size > 1 && (size--); break;
case '*': size > 1 && (stack[size-2] *= stack[size-1]); size > 1 && (size--); break;
case '_': size > 1 && (stack[size-2] /= stack[size-1]); size > 1 && (size--); break;
case 'i': size > 0 ? (stack[size-1]++) : (stack[size++] = 1); break;
case 'd': size > 0 ? (stack[size-1]--) : (stack[size++] = -1); break;
case '|': size > 0 && (stack[size-1] = -stack[size-1]); break;
case 'm': size > 1 && (stack[size-2] %= stack[size-1]); size > 1 && (size--); break;
case '"': size > 1 && swap(&stack[size-2],&stack[size-1]); break;
case '$': scanf("%d",&stack[size++]); break;
case '~': stack[size++] = getchar(); break;
case '%': printf("%d",size ? stack[size-1] : 0); break;
case '@': size && putchar(stack[size-1]); break;
case '#': size && putchar(stack[size-1]) && (size--); break;
case '=': stack[size] = size > 1 ? (stack[size-2] == stack[size-1]) : 0;
size++;
break;
case 'l': size > 1 && (stack[size-2] = (stack[size-2] < stack[size-1])); size > 1 && (size--); break;
case 'g': size > 1 && (stack[size-2] = (stack[size-2] > stack[size-1])); size > 1 && (size--); break;
case 'u': size && stack[size-1] < 0 && (stack[size-1] = -stack[size-1]);
break;
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case'8': case '9':
stack[size++] = command - '0'; break;
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
stack[size++] = command - 'A' + 10; break;
/* memory */
case 'P': size && (memory = stack[size-1]); size && (size--); break;
case 'S': size && (memory = stack[size-1]); break;
case 'U': memory && (stack[size++] = memory); break;
/* conditionals */
case '?': skip = size ? (stack[size-1] <= 0) : 1; break;
case '!': skip = size ? (stack[size-1] > 0) : 0; break;
case 's': skip = (size ? stack[size-1] : 0); break;
case ';': if (!size || (stack[size-1] <= 0)) exit(EXIT_SUCCESS); break;
case 'x': jumps && (jumps--); break;
case '(':
jump[jumps].x = x;
jump[jumps].y = y;
jump[jumps].d = direction;
jumps++;
break;
case ')':
if (jumps) {
x = jump[jumps-1].x;
y = jump[jumps-1].y;
direction = jump[jumps-1].d;
}
break;
case ']':
if (jumps && size && stack[size-1]) {
x = jump[jumps-1].x;
y = jump[jumps-1].y;
direction = jump[jumps-1].d;
} else {
jumps && (jumps--);
}
break;
}
}
int swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
|
the_stack_data/179830298.c
|
/* file: es101.c
* job: soluzione 8 aprile 2005
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdarg.h>
int M; /* numero di processi figli */
int K; /* ultimo argomento */
pid_t pid; /* appoggio per valore pid */
int status; /* appoggio per wait */
int pfn[2]; /* pipe figlio-nipote, attenzione ogni processo figlio
ha la sua istanza di questa variabile quindi le pipe create sono "M" */
int fdr,fdw; /* file descriptors per read e write */
int indice; /* indice su linea */
char linea[256]; /* buffer di linea */
char FiK[80]; /* nome file di uscita */
int LP,LD; /* lunghezze linea */
int lineacorr; /* linea corrente */
int nonscritte; /* numero di linee non scritte */
/* abbinamento snprintf+write */
void zprintf(int fd, const char *fmt, ...);
/* funzione figlio */
int figlio(char *filename, int i);
/* funzione nipote */
int nipote(char *filename, int i);
int main(int argc, char **argv) {
int i; /* int di appoggio */
/* controllo numero di argomenti */
if (argc<3) {
zprintf(2,"Errore nel numero di argomenti\n");
return(1);
}
M=argc-2; /* numero di processi figli */
K=atoi(argv[argc-1]); /* numero K, ultimo argomento */
if ((K<=0)||(K>=7)||((K%2)!=0)) {
zprintf(2,"Parametro K non valido: %d\n",K);
return(2);
}
/* creazione figli e attribuzione argomenti */
for (i=0; i<M; i++) {
switch (fork()) {
case 0: /* figlio */
return(figlio(argv[i+1],i));
case -1:
/* errore */
zprintf(2,"Errore nella %d fork\n",i);
return(3);
}
}
/* recupero exit status dei figli (non dei nipoti) */
for (i=0; i<M; i++) {
pid=wait(&status);
if (WIFEXITED(status)) {
zprintf(1,
"Il figlio con pid %d ritorna %d\n",
pid, WEXITSTATUS(status));
} else {
zprintf(1,
"Il figlio con pid %d e' terminato per il segnale %d\n",
pid, WTERMSIG(status));
}
}
return(0);
}
void zprintf(int fd, const char *fmt, ...) {
/* printf wrapper using write instead */
static char msg[256];
va_list ap;
int n;
va_start(ap, fmt);
n=vsnprintf (msg, 256, fmt, ap);
write(fd,msg,n);
va_end(ap);
}
int figlio(char *filename, int i) {
char ch;
/* creo la pipe figlio-nipote */
if (pipe(pfn)!=0) {
zprintf(2,"Errore creazione pipe figlio-nipote %d\n",i);
abort(); /* termino per SIGABRT, il padre se ne accorge */
return(4);
}
/* creo il nipote */
switch (fork()) {
case 0:
return(nipote(filename,i));
case -1:
/* errore */
zprintf(2,"Errore nella %d fork (nipote)\n",i);
abort();
}
close(pfn[1]); /* non scrivo mai */
/* legge le linee 1,3,... evitando quelle pari */
fdr=open(filename,O_RDONLY);
if (fdr<0) {
zprintf(2,"Impossibile aprire %s\n",filename);
abort();
}
snprintf(FiK,sizeof(FiK),"%s%d",filename,K);
#ifdef DEBUG
zprintf(1,"Creato %s\n",FiK);
#endif
fdw=open(FiK,O_WRONLY|O_CREAT|O_EXCL,0666);
if (fdw<0) {
zprintf(2,"Impossibile aprire %s\n",FiK);
abort();
}
lineacorr=1;
indice=0;
for(;;) {
if (read(fdr,&ch,1)!=1) {
return(nonscritte);
}
#ifdef DEBUG1
zprintf(1,"Char %d\n",ch);
#endif
if (ch=='\n') {
/* fine linea */
if ((lineacorr%2)==1) {
LD=indice;
/* attendo info da nipote */
#ifdef DEBUG
zprintf(1,"Attendo info per linea %d lung %d\n",
lineacorr,LD);
#endif
if (read(pfn[0],&LP,sizeof(LP))!=sizeof(LP)) {
zprintf(2,"Errore lettura pipe\n");
abort();
}
if (LD>LP) {
write(fdw,linea,LD);
write(fdw,"\n",1); /* fine linea */
} else {
nonscritte++;
}
}
indice=0;
lineacorr++;
} else if ((lineacorr%2)==1) {
/* linea dispari, memorizzo */
if (indice<sizeof(linea)) {
linea[indice++]=ch;
}
}
}
/* fine figlio, mai qui */
abort();
return(0);
}
int nipote(char *filename, int i) {
char ch;
/* nipote, linee pari */
fdr=open(filename,O_RDONLY);
if (fdr<0) {
zprintf(2,"Impossibile aprire %s\n",filename);
return(1); /* recuperabile con wait dal figlio */
}
lineacorr=1;
indice=0;
for(;;) {
if (read(fdr,&ch,1)!=1) {
/* fine file */
return(0);
}
if (ch=='\n') {
/* fine linea */
if ((lineacorr%2)==0) {
LP=indice;
write(pfn[1],&LP,sizeof(LP));
#ifdef DEBUG
zprintf(1,"Inviata lung linea %d, pari a %d\n",
lineacorr,LP);
#endif
}
indice=0;
lineacorr++;
} else {
indice++;
}
}
return(0);
}
|
the_stack_data/414473.c
|
#include <stdio.h>
int main() {
char *string = "aouihuiahsudasduihqmdoiqjnduiamsdoqnwuidamodkjwodkaposdj";
int quantidade[26] = { 0 };
for (; *string != '\0'; string++) {
quantidade[*string - 'a']++;
}
for (int i = 0; i < 26; i++) {
printf("%c => %d\n", i + 'a', quantidade[i]);
}
}
//https://pt.stackoverflow.com/q/217720/101
|
the_stack_data/95513.c
|
#include <stdio.h>
// #define EX_RATE 1120 // #define으로 상수 선언
int main(void) {
// 변수 선언 연습
int iData = 50;
double dData = 7.7 ;
char ch = 'A';
const int EX_RATE = 1100;
printf("iData = %8d \n", iData);
printf("dData = %8.2f \n", dData);
printf("ch = %8c \n", ch);
// 10진수, 8진수, 16진수 예제
int x = 10; // 10진수
printf("%d = %d(%d) \n", x, x, 10);
printf("%d = %o(%d) \n", x, x, 8);
printf("%d = %x(%d) \n", x, x, 16);
// 상수가 필요할 때의 예제
int dollar1 = 10;
int dollar2 = 100;
int dollar3 = 1000;
// int won1 = 1120 * dollar1;
// int won2 = 1120 * dollar2;
// int won3 = 1120 * dollar3;
int won1 = EX_RATE * dollar1;
int won2 = EX_RATE * dollar2;
int won3 = EX_RATE * dollar3;
printf("%d원 = %d달러 \n", won1, dollar1);
printf("%d원 = %d달러 \n", won2, dollar2);
printf("%d원 = %d달러 \n", won3, dollar3);
return 0;
}
|
the_stack_data/68887001.c
|
/* { dg-do compile } */
/* { dg-options "-O2 -mno-indirect-branch-register -mfunction-return=keep -fno-pic" } */
typedef void (*dispatch_t)(long offset);
dispatch_t dispatch;
extern int male_indirect_jump (long)
__attribute__ ((indirect_branch("thunk-extern")));
int
male_indirect_jump (long offset)
{
dispatch(offset);
return 0;
}
/* { dg-final { scan-assembler "push(?:l|q)\[ \t\]*_?dispatch" { target { { ! x32 } && *-*-linux* } } } } */
/* { dg-final { scan-assembler-times "jmp\[ \t\]*\.LIND" 1 { target { ! x32 } } } } */
/* { dg-final { scan-assembler-times "call\[ \t\]*\.LIND" 1 { target { ! x32 } } } } */
/* { dg-final { scan-assembler "jmp\[ \t\]*__x86_indirect_thunk" { target { ! x32 } } } } */
/* { dg-final { scan-assembler "call\[ \t\]*__x86_indirect_thunk_(r|e)ax" { target x32 } } } */
/* { dg-final { scan-assembler-not {\t(lfence|pause)} } } */
|
the_stack_data/51699333.c
|
#include <pthread.h>
#define N 2
int num;
pthread_mutex_t m;
pthread_cond_t empty, full;
void* producer(void* arg) {
int i = 0;
while (i < N) {
pthread_mutex_lock(&m);
while (num > 0)
pthread_cond_wait(&empty, &m);
num++; //produce
pthread_mutex_unlock(&m);
pthread_cond_signal(&full);
i++;
} }
void* consumer(void* arg) {
int j = 0;
while (j < N){
pthread_mutex_lock(&m);
while (num == 0)
pthread_cond_wait(&full, &m);
num--; //consume
pthread_mutex_unlock(&m);
pthread_cond_signal(&empty);
j++;
} }
int main() {
pthread_t id1, id2;
num = 2;
pthread_mutex_init(&m, 0);
pthread_cond_init(&empty, 0);
pthread_cond_init(&full, 0);
pthread_create(&id1, 0, producer, 0);
pthread_create(&id2, 0, consumer, 0);
pthread_join(id1, 0);
pthread_join(id2, 0);
return 0;
}
|
the_stack_data/1184927.c
|
#include<stdio.h>
void main(){
void inv(int x[], int n);
int i, a[10]={3,7,9,11,0,6,7,5,4,2};
printf("The original array:\n");
for(i=0;i<10;i++)
printf("%d",a[i]);
printf("\n");
inv(a, 10);
printf("The array has been inverted:\n");
for(i=0;i<10;i++)
printf("%d",a[i]);
printf("\n");
}
void inv(int x[], int n){
int temp, i, j, m=(n-1)/2;
for(i=0;i<=m;i++){
j=n-i-1;
temp=x[i];x[i]=x[j];x[j]=temp;
}
return;
}
|
the_stack_data/72012756.c
|
/*
* $Id$
*
* Copyright (C) 2003 Pascal Brisset, Antoine Drouin
*
* This file is part of paparazzi.
*
* paparazzi is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* paparazzi 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 paparazzi; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
*/
/** \file main.c
* \brief Regroup main functions
*
*/
/* --- stuff pulled in from other files ---- sanjit */
// timer.h mostly
#define TCCR1A 0x00 /* sanjit guess from other files */
#define TCCR1B 0x01 /* sanjit guess from other files */
#define TCCR2 0x05 /* sanjit guess from other files */
#define TCNT1 0x1 /* sanjit BIG guess */
#define TCNT1L 0x1 /* sanjit BIG guess */
#define TIFR 0x1 /* sanjit BIG guess */
#define TOV2 0x1 /* sanjit BIG guess */
/*--------------------------------------------- sanjit */
/*
#include "link_autopilot.h"
//sanjit #include "timer.h"
#include "adc.h"
#include "pid.h"
#include "gps.h"
#include "infrared.h"
// sanjit #include "downlink.h"
#include "nav.h"
#include "autopilot.h"
#include "estimator.h"
#include "if_calib.h"
*/
/**** similar stuff as for cctask below ------------- */
#define PPRZ_MODE_MANUAL 0
#define PPRZ_MODE_AUTO1 1
#define PPRZ_MODE_AUTO2 2
#define PPRZ_MODE_HOME 3
#define PPRZ_MODE_NB 4
#define TRIM_PPRZ(pprz) (pprz < MIN_PPRZ ? MIN_PPRZ : \
(pprz > MAX_PPRZ ? MAX_PPRZ : \
pprz))
#define TRIM_UPPRZ(pprz) (pprz < 0 ? 0 : \
(pprz > MAX_PPRZ ? MAX_PPRZ : \
pprz))
/* from autopilot.h ends */
/* from include/std.h */
#define FALSE 0
#define TRUE (!FALSE)
/* include/std.h */
#define NAV_PITCH 0 /* from var/....h */
/* added by sanjit */
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef unsigned char bool_t;
/* sanjit add ends */
/* from sw/var/include/airframe.h */
#define ROLL_PGAIN 10000.
#define PITCH_OF_ROLL 0.0
#define PITCH_PGAIN 15000.
#define MAX_ROLL 0.35
#define MAX_PITCH 0.35
#define MIN_PITCH -0.35
#define CLIMB_PITCH_PGAIN -0.1
#define CLIMB_PITCH_IGAIN 0.025
#define CLIMB_PGAIN -0.03
#define CLIMB_IGAIN 0.1
#define CLIMB_MAX 1.
#define CLIMB_LEVEL_GAZ 0.31
#define CLIMB_PITCH_OF_VZ_PGAIN 0.05
#define CLIMB_GAZ_OF_CLIMB 0.2
/* airframe.h */
#define VERTICAL_MODE_MANUAL 0
#define VERTICAL_MODE_AUTO_GAZ 1
#define VERTICAL_MODE_AUTO_CLIMB 2
#define VERTICAL_MODE_AUTO_ALT 3
#define VERTICAL_MODE_NB 4
#define MAX_CLIMB_SUM_ERR 100
#define MAX_PITCH_CLIMB_SUM_ERR 100
/*---- from fly_by_wire/link_autopilot.h */
/*
* System clock in MHz.
*/
#define CLOCK 16
/* !!!!!!!!!!!!!!!!!!! Value used in gen_airframe.ml !!!!!!!!!!!!!!!!! */
#define MAX_PPRZ (600 * CLOCK)
#define MIN_PPRZ -MAX_PPRZ
/* --- fly_by_wire/link_autopilot.h */
/* from main.c */
// defined below uint8_t pprz_mode;
// defined below uint8_t vertical_mode = VERTICAL_MODE_MANUAL;
// static bool_t low_battery = FALSE;
/* end of stuff from main.c */
#define ALTITUDE_PGAIN -0.025
#define LATERAL_MODE_MANUAL 0
uint16_t nav_desired_gaz;
uint16_t estimator_flight_time;
//bool_t launch = FALSE;
float nav_pitch = NAV_PITCH;
float estimator_z_dot;
//bool_t auto_pitch = FALSE;
/* below vars from pid.c (mostly) */
//float desired_roll = 0.;
//float desired_pitch = 0.;
int16_t desired_gaz, desired_aileron, desired_elevator;
//float roll_pgain = ROLL_PGAIN;
//float pitch_pgain = PITCH_PGAIN;
//float pitch_of_roll = PITCH_OF_ROLL;
//float pitch_of_vz_pgain = CLIMB_PITCH_OF_VZ_PGAIN;
//float pitch_of_vz = 0.;
const float climb_pgain = CLIMB_PGAIN;
const float climb_igain = CLIMB_IGAIN;
// defined below float desired_climb = 0., pre_climb = 0.;
static const float level_gaz = CLIMB_LEVEL_GAZ;
float climb_sum_err = 0;
float climb_pitch_pgain = CLIMB_PITCH_PGAIN;
float climb_pitch_igain = CLIMB_PITCH_IGAIN;
float climb_pitch_sum_err = 0.;
float max_pitch = MAX_PITCH;
float min_pitch = MIN_PITCH;
/**** similar stuff as for cctask above ------------- */
#define IR_ESTIM_MODE_ON 1
#define IR_ROLL_NEUTRAL_DEFAULT -915
#define IR_PITCH_NEUTRAL_DEFAULT 110
#define AV_NB_SAMPLE 0x20
// from radio.h, airframe.h
#define RADIO_CTL_NB 9
#define RADIO_CTL_D 0
#define RADIO_THROTTLE RADIO_CTL_D
#define RADIO_CTL_C 1
#define RADIO_ROLL RADIO_CTL_C
#define RADIO_CTL_B 2
#define RADIO_PITCH RADIO_CTL_B
#define RADIO_CTL_E 5
#define RADIO_GAIN1 RADIO_CTL_E
#define IR_RollOfIrs(x1,x2) (-1*(x1)+ -1*(x2))
#define IR_PitchOfIrs(x1,x2) (-1*(x1)+ 1*(x2))
struct inter_mcu_msg {
int16_t channels[RADIO_CTL_NB];
uint8_t ppm_cpt;
uint8_t status;
uint8_t nb_err;
uint8_t vsupply; /* 1e-1 V */
};
//
//
// FIXME estimator_flight_time should not be manipuled here anymore
//
/** Define minimal speed for takeoff in m/s */
#define MIN_SPEED_FOR_TAKEOFF 5.
uint8_t fatal_error_nb = 0;
static const uint16_t version = 1;
/** in seconds */
static uint16_t cputime = 0;
uint8_t pprz_mode = PPRZ_MODE_MANUAL;
uint8_t vertical_mode = VERTICAL_MODE_MANUAL;
uint8_t lateral_mode = LATERAL_MODE_MANUAL;
uint8_t ir_estim_mode = IR_ESTIM_MODE_ON;
bool_t auto_pitch = FALSE;
bool_t rc_event_1, rc_event_2;
uint8_t vsupply;
static uint8_t mcu1_status, mcu1_ppm_cpt;
static bool_t low_battery = FALSE;
float slider_1_val, slider_2_val;
bool_t launch = FALSE;
#define Min(x, y) (x < y ? x : y)
#define Max(x, y) (x > y ? x : y)
#define NO_CALIB 0 /**< \enum No calibration state */
#define WAITING_CALIB_CONTRAST 1 /**< \enum Waiting calibration contrast state */
#define CALIB_DONE 2 /**< \enum Calibration done state */
/** Maximal delay for calibration */
#define MAX_DELAY_FOR_CALIBRATION 10
#ifdef EST_TEST
float est_pos_x;
float est_pos_y;
float est_fcourse;
uint8_t ticks_last_est; // 20Hz
#endif /* EST_TEST */
/*
called at 20Hz.
sends a serie of initialisation messages followed by a stream of periodic ones
*/
/** Define number of message at initialisation */
#define INIT_MSG_NB 2
/** @@@@@ A FIXER @@@@ */
#define HI_FREQ_PHASE_NB 5
//static char signature[16] = MESSAGES_MD5SUM;
/** \def PERIODIC_SEND_BAT()
* @@@@@ A FIXER @@@@@
*/
#define PERIODIC_SEND_BAT() DOWNLINK_SEND_BAT(&vsupply, &estimator_flight_time, &low_battery, &block_time, &stage_time)
/** \def EventPos(_cpt, _channel, _event)
* @@@@@ A FIXER @@@@@
*/
#define PERIODIC_SEND_DEBUG() DOWNLINK_SEND_DEBUG(&link_fbw_nb_err, &link_fbw_fbw_nb_err, &modem_nb_ovrn, &gps_nb_ovrn, &mcu1_ppm_cpt);
/** \def EventPos(_cpt, _channel, _event)
* @@@@@ A FIXER @@@@@
*/
#define PERIODIC_SEND_ATTITUDE() DOWNLINK_SEND_ATTITUDE(&estimator_phi, &estimator_psi, &estimator_theta);
/** \def EventPos(_cpt, _channel, _event)
* @@@@@ A FIXER @@@@@
*/
#define PERIODIC_SEND_ADC() DOWNLINK_SEND_ADC(&ir_roll, &ir_pitch);
/** \def EventPos(_cpt, _channel, _event)
* @@@@@ A FIXER @@@@@
*/
#define PERIODIC_SEND_STABILISATION() DOWNLINK_SEND_STABILISATION(&roll_pgain, &pitch_pgain);
#define PERIODIC_SEND_CLIMB_PID() DOWNLINK_SEND_CLIMB_PID(&desired_gaz, &desired_climb, &climb_sum_err, &climb_pgain);
#define PERIODIC_SEND_PPRZ_MODE() DOWNLINK_SEND_PPRZ_MODE(&pprz_mode, &vertical_mode, &inflight_calib_mode, &mcu1_status, &ir_estim_mode);
#define PERIODIC_SEND_DESIRED() DOWNLINK_SEND_DESIRED(&desired_roll, &desired_pitch, &desired_x, &desired_y, &desired_altitude);
#define PERIODIC_SEND_PITCH() DOWNLINK_SEND_PITCH(&ir_pitch, &ir_pitch_neutral, &ir_gain);
#define PERIODIC_SEND_NAVIGATION_REF() DOWNLINK_SEND_NAVIGATION_REF(&utm_east0, &utm_north0);
#ifdef RADIO_CALIB
#define PERIODIC_SEND_SETTINGS() if (inflight_calib_mode != IF_CALIB_MODE_NONE) DOWNLINK_SEND_SETTINGS(&inflight_calib_mode, &slider_1_val, &slider_2_val);
#else
#define PERIODIC_SEND_SETTINGS()
#endif
#define PERIOD (256. * 1024. / CLOCK / 1000000.)
/** Maximum time allowed for low battery level */
#define LOW_BATTERY_DELAY 5
/*====================================================================*/
struct adc_buf {
uint16_t sum;
uint16_t values[AV_NB_SAMPLE];
uint8_t head;
};
static struct adc_buf buf_ir1;
static struct adc_buf buf_ir2;
#define EstimatorIrGainIsCorrect() (TRUE)
float desired_roll = 0.;
float desired_pitch = 0.;
int16_t desired_gaz, desired_aileron, desired_elevator;
float roll_pgain = ROLL_PGAIN;
float pitch_pgain = PITCH_PGAIN;
float pitch_of_roll = PITCH_OF_ROLL;
float pitch_of_vz_pgain = CLIMB_PITCH_OF_VZ_PGAIN;
float pitch_of_vz = 0.;
/*--------------- variable defs pulled from other files -----------------------------------*/
/* infrared.c: */
int16_t ir_roll;
int16_t ir_roll_neutral = IR_ROLL_NEUTRAL_DEFAULT;
int16_t ir_pitch;
int16_t ir_pitch_neutral = IR_PITCH_NEUTRAL_DEFAULT;
/* estimator.c: */
float estimator_rad_of_ir, estimator_ir, estimator_rad;
float ir_rad_of_ir;
float rad_of_ir;
float estimator_phi, estimator_theta;
/* link_fbw.c: */
struct inter_mcu_msg to_fbw;
/*--------------- variable defs pulled from other files [above] --------------------------------*/
void stabilisation_task(void)
{
/* ---- inlined below: ir_update(); ---- */
// #ifndef SIMUL
int16_t x1_mean = buf_ir1.sum/AV_NB_SAMPLE;
int16_t x2_mean = buf_ir2.sum/AV_NB_SAMPLE;
/* simplesclar cannot have type decls in the middle of the func */
float rad_of_ir, err, tmp_sanjit;
ir_roll = IR_RollOfIrs(x1_mean, x2_mean) - ir_roll_neutral;
ir_pitch = IR_PitchOfIrs(x1_mean, x2_mean) - ir_pitch_neutral;
/*
#else
extern volatile int16_t simul_ir_roll, simul_ir_pitch;
ir_roll = simul_ir_roll - ir_roll_neutral;
ir_pitch = simul_ir_pitch - ir_pitch_neutral;
#endif
*/
/* ---- inlined below estimator_update_state_infrared(); ---- */
rad_of_ir = (ir_estim_mode == IR_ESTIM_MODE_ON && EstimatorIrGainIsCorrect()) ?
estimator_rad_of_ir : ir_rad_of_ir;
estimator_phi = rad_of_ir * ir_roll;
estimator_theta = rad_of_ir * ir_pitch;
/* --- inlined below roll_pitch_pid_run(); // Set desired_aileron & desired_elevator ---- */
err = estimator_phi - desired_roll;
desired_aileron = TRIM_PPRZ(roll_pgain * err);
if (pitch_of_roll <0.)
pitch_of_roll = 0.;
/* line below commented out by sanjit, to avoid use of fabs
err = -(estimator_theta - desired_pitch - pitch_of_roll * fabs(estimator_phi));
2 replacement lines are below
*/
tmp_sanjit = (estimator_phi < 0) ? -estimator_phi : estimator_phi;
err = -(estimator_theta - desired_pitch - pitch_of_roll * tmp_sanjit);
desired_elevator = TRIM_PPRZ(pitch_pgain * err);
/* --- end inline ---- */
to_fbw.channels[RADIO_THROTTLE] = desired_gaz; // desired_gaz is set upon GPS message reception
to_fbw.channels[RADIO_ROLL] = desired_aileron;
#ifndef ANTON_T7
to_fbw.channels[RADIO_PITCH] = desired_elevator;
#endif
// Code for camera stabilization, FIXME put that elsewhere
to_fbw.channels[RADIO_GAIN1] = TRIM_PPRZ(MAX_PPRZ/0.75*(-estimator_phi));
}
int main()
{
ir_estim_mode = 0;
roll_pgain = 0;
pitch_of_roll = 0;
/* stuff below makes pitch_pgain*err > 9600 */
buf_ir1.sum = AV_NB_SAMPLE;
buf_ir2.sum = AV_NB_SAMPLE;
ir_pitch_neutral = 1;
ir_rad_of_ir = -1;
/* makes estimator_theta = 2, estimator_phi = 3 */
desired_pitch = 9604;
/* This makes err = -2 + 9604 = 9602 > 9600 */
pitch_pgain = 1;
stabilisation_task();
#ifdef PRET
asm(".word 0x22222222");
#endif
}
|
the_stack_data/1023298.c
|
#include<stdio.h>
int sum(int m,int n)
{
if(n==m||n==0)
return 1;
else
return sum(m-1,n)+sum(m-1,n-1);
}
int main()
{
int m,n;
scanf("%d",&m);
scanf("%d",&n);
int t=sum(m,n);
printf("%d",t);
return 0;
}
|
the_stack_data/193894281.c
|
#include<stdio.h>
/* Dato un Array A di dimensione len, filtrare tutti gli elementi f.
* Questo significa restituire l'array compattato composta da tutti gli elementi originali di A meno gli elementi uguali ad f.
* ES: [1,24,3,4] 3 -> [1,24,4]
* ES: [1,2,1,3,4,6] 1 -> [2,3,4,6]
*/
void filter(int *A, unsigned int *plen, int f);
int main(){
unsigned int len;
int f;
scanf("%2u", &len);
int A[len];
for(int i = 0; i<len; i=i+1){
scanf("%d", A+i);
}
scanf("%d", &f);
unsigned int *plen = &len;
// definire ed utilizzare qui una funzione void filter(...)
filter(A, plen, f);
printf("[");
for (int i = 0; i<len; i+=1)
printf(" %d",A[i]);
printf(" ]\n");
}
void filter(int *A, unsigned int *plen, int f) {
for (int i = 0; i < (int) *plen;) {
if ( *(A + i) == f) {
*plen -= 1;
for (int y = i; y < (int) *plen; y++) {
*(A + y) = *(A + y + 1);
}
}
else i++;
}
}
|
the_stack_data/5602.c
|
#include<stdio.h>
int main()
{
int i,j,x=7,y=5;
for(i=1 ; i<=9 ; i=i+2)
{
for(j=x; j>=y ; j--)
{
printf("I=%d J=%d\n",i,j);
}
i=i+2;
j=j+2;
}
return 0;
}
|
the_stack_data/87638922.c
|
int foo(int f) {
return 2*f;
}
|
the_stack_data/13989.c
|
#include <stdio.h>
#define BUFSIZE 100
static char buf[BUFSIZE]; // dzięki static buf i bufp będąwidoczne wyłącznie dla getch i ungetch (od wystąpienia do końca pliku źródłowego)
static int bufp = 0;
int getch(void) /* weź znak, być może oddany na wejście */
{
return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c) /* oddaj znak z powrotem na wejście */
{
if (bufp >= BUFSIZE)
printf("ungetch: za wiele znaków\n");
else
buf[bufp++] = c;
}
|
the_stack_data/150139363.c
|
/*
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
* See the copyright notice in the ACK home directory, in the file "Copyright".
*/
/* $Header: /cvsup/minix/src/lib/ansi/strcat.c,v 1.1.1.1 2005/04/21 14:56:06 beng Exp $ */
#include <string.h>
char *
strcat(char *ret, register const char *s2)
{
register char *s1 = ret;
while (*s1++ != '\0')
/* EMPTY */ ;
s1--;
while (*s1++ = *s2++)
/* EMPTY */ ;
return ret;
}
|
the_stack_data/898124.c
|
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
volatile int counter = 10001;
volatile int running = 1;
volatile int has_to_die = 0;
static void signal_handler_sigusr1( int signal ) {
counter++;
}
static void signal_handler_sigusr2( int signal ) {
has_to_die = 1;
}
static void signal_handler_sigint( int signal ) {
running = 0;
}
int main() {
int last_counter = counter;
malloc( last_counter );
signal( SIGUSR1, signal_handler_sigusr1 );
signal( SIGUSR2, signal_handler_sigusr2 );
signal( SIGINT, signal_handler_sigint );
for( ;; ) {
usleep( 1000 );
if( counter != last_counter ) {
last_counter = counter;
malloc( last_counter );
}
if( !running ) {
return 0;
}
if( has_to_die ) {
kill( getpid(), SIGKILL );
for( ;; ) { usleep( 1000 ); }
}
}
}
|
the_stack_data/85449.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: atamraka <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/05/30 07:04:58 by atamraka #+# #+# */
/* Updated: 2021/05/30 12:40:12 by atamraka ### ########.fr */
/* */
/* ************************************************************************** */
int rush(int x, int y);
int main(void)
{
//rush(123, 42);
//rush(5, 3);
rush(5, 1);
rush(1, 1);
rush(1, 5);
//rush(4, 4);
rush(0, 4);
rush(4, 0);
return (0);
}
|
the_stack_data/64287.c
|
//Write a program to calculate n!/(n-r)! using functions.
#include<stdio.h>
int factorial(int);
int main()
{
int n, r, result1, result2, final_result;
printf("\nEnter the value of n & r: ");
scanf("%d%d", &n, &r);
result1 = factorial(n);
result2 = factorial(n-r);
final_result = result1/result2;
printf("Calculated value is: %d", final_result);
printf("\n");
return 0;
}
int factorial(int x)
{
int i, fact=1;
for(i=1; i<=x; i++)
fact *= i;
return fact;
}
|
the_stack_data/165767022.c
|
#include <stdio.h>
#include <stdlib.h>
void show(int *arr, int size, char *msg)
{
printf("\n%s: ", msg);
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
}
// Function for union.
void compute_union(int *arr1, int *arr2, int size_1, int size_2)
{
// Max possible size for union size_1 + size_2.
int *result = (int *)malloc(sizeof(int) * (size_2 + size_1));
// arr1 index i.
// arr2 index j.
// result index index.
int index, i, j;
index = i = j = 0;
// modified merge function from merge sort.
while ((i < size_1) && (j < size_2))
{
if (arr1[i] == arr2[j])
{
result[index++] = arr1[i++];
j++;
}
else if (arr1[i] < arr2[j])
result[index++] = arr1[i++];
else if (arr1[i] > arr2[j])
result[index++] = arr2[j++];
}
while (i < size_1)
result[index++] = arr1[i++];
while (j < size_2)
result[index++] = arr2[j++];
show(result, index, "UNION");
}
void compute_intersection(int *arr1, int *arr2, int size_1, int size_2)
{
// Max possible size for intersection min(size_1, size_2).
int *result = (int *)malloc(sizeof(int) * (size_1 < size_2 ? size_1 : size_2));
// arr1 index i.
// arr2 index j.
// result index index.
int index, i, j;
index = i = j = 0;
// modified merge function from merge sort.
while ((i < size_1) && (j < size_2))
{
if (arr1[i] == arr2[j])
{
result[index++] = arr1[i++];
j++;
}
else if (arr1[i] < arr2[j])
i++;
else if (arr1[i] > arr2[j])
j++;
}
show(result, index, "INTERSECTION");
}
void main()
{
int arr1[] = {1, 3, 4, 5, 7};
int arr2[] = {2, 3, 5, 6};
// int arr1[] = {2, 5, 6};
// int arr2[] = {4, 6, 8, 10};
int size_1 = sizeof(arr1) / sizeof(int);
int size_2 = sizeof(arr2) / sizeof(int);
compute_union(arr1, arr2, size_1, size_2);
compute_intersection(arr1, arr2, size_1, size_2);
printf("\n");
}
|
the_stack_data/117327515.c
|
// Copyright (c) 2013, Sergey Lyubka
// Copyright (c) 2017-2020, The BRT Project
// All rights reserved.
// Released under the MIT license.
// This program takes a list of files as an input, and produces C++ code that
// contains the contents of all these files as a collection of strings.
//
// Usage:
// 1. Compile this file:
// cc -o generate-translations-header generate-translations-header.c
//
// 2. Convert list of files into single header:
// ./generate-translations-header BRT_fr.qm BRT_it.qm > translations_files.h
//
// 3. In your application code, include translations_files.h, then you can
// access the files using this function:
// static bool find_embedded_file(const std::string &file_name, std::string &data);
// std::string data;
// find_embedded_file("BRT_fr.qm", data);
#include <stdio.h>
#include <stdlib.h>
static const char *code =
"static bool find_embedded_file(const std::string &name, std::string &data) {\n"
" const struct embedded_file *p;\n"
" for (p = embedded_files; p->name != NULL; p++) {\n"
" if (*p->name == name) {\n"
" data = *p->data;\n"
" return true;\n"
" }\n"
" }\n"
" return false;\n"
"}\n";
int main(int argc, char *argv[]) {
FILE *fp, *foutput;
int i, j, ch;
if((foutput = fopen("translation_files.h", "w")) == NULL) {
exit(EXIT_FAILURE);
}
fprintf(foutput, "#ifndef TRANSLATION_FILES_H\n");
fprintf(foutput, "#define TRANSLATION_FILES_H\n\n");
fprintf(foutput, "#include <string>\n\n");
for (i = 1; i < argc; i++) {
if ((fp = fopen(argv[i], "rb")) == NULL) {
fclose(foutput);
exit(EXIT_FAILURE);
} else {
fprintf(foutput, "static const std::string translation_file_name_%d = \"%s\";\n", i, argv[i]);
fprintf(foutput, "static const std::string translation_file_data_%d = std::string(", i);
for (j = 0; (ch = fgetc(fp)) != EOF; j++) {
if ((j % 16) == 0) {
if (j > 0) {
fprintf(foutput, "%s", "\"");
}
fprintf(foutput, "%s", "\n \"");
}
fprintf(foutput, "\\x%02x", ch);
}
fprintf(foutput, "\",\n %d);\n\n", j);
fclose(fp);
}
}
fprintf(foutput, "%s", "static const struct embedded_file {\n");
fprintf(foutput, "%s", " const std::string *name;\n");
fprintf(foutput, "%s", " const std::string *data;\n");
fprintf(foutput, "%s", "} embedded_files[] = {\n");
for (i = 1; i < argc; i++) {
fprintf(foutput, " {&translation_file_name_%d, &translation_file_data_%d},\n", i, i);
}
fprintf(foutput, "%s", " {NULL, NULL}\n");
fprintf(foutput, "%s", "};\n\n");
fprintf(foutput, "%s\n", code);
fprintf(foutput, "#endif /* TRANSLATION_FILES_H */\n");
fclose(foutput);
return EXIT_SUCCESS;
}
|
the_stack_data/42649.c
|
/* ,-----------------------------------------. ,-----------------------------------------.
* | GRV | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | GRV |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | ESC | Q | W | E | R | T | | Y | U | I | O | P | BSPC |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | TAB | A | S | D | F | G |,------. ,------.| H | J | K | L | SCLN | QUOT |
* |------+------+------+------+------+------|| MUTE | | ||------+------+------+------+------+------|
* | LSFT | Z | X | C | V | B |`------' `------'| N | M | COMM | DOT | SLSH | RSFT |
* `-------------+------+------+------+-.------------. ,------------.-+------+------+------+-------------'
* | LGUI | LALT |LCTRL |/LOWER / ENT / \ SPC \RAISE \|RCTRL | RALT | RGUI |
* | | | / / / \ \ \ | | |
* `---------------------------------' `---------------------------------'
* generated by [keymapviz] */
/* ,-----------------------------------------. ,-----------------------------------------.
* | GRV | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | GRV |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | ESC | Q | W | F | P | G | | J | L | U | Y | SCLN | BSPC |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | TAB | A | R | S | T | D |,------. ,------.| H | N | E | I | O | QUOT |
* |------+------+------+------+------+------|| MUTE | | ||------+------+------+------+------+------|
* | LSFT | Z | X | C | V | B |`------' `------'| K | M | COMM | DOT | SLSH | RSFT |
* `-------------+------+------+------+-.------------. ,------------.-+------+------+------+-------------'
* | LGUI | LALT |LCTRL |/LOWER / ENT / \ SPC \RAISE \|RCTRL | RALT | RGUI |
* | | | / / / \ \ \ | | |
* `---------------------------------' `---------------------------------'
* generated by [keymapviz] */
/* ,-----------------------------------------. ,-----------------------------------------.
* | | F1 | F2 | F3 | F4 | F5 | | F6 | F7 | F8 | F9 | F10 | F11 |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | GRV | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | F12 |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | EXLM | AT | HASH | DLR | PERC |,------. ,------.| CIRC | AMPR | ASTR | LPRN | RPRN | PIPE |
* |------+------+------+------+------+------|| | | ||------+------+------+------+------+------|
* | | EQL | MINS | PLUS | LCBR | RCBR |`------' `------'| LBRC | RBRC | SCLN | COLN | BSLS | |
* `-------------+------+------+------+-.------------. ,------------.-+------+------+------+-------------'
* | | | |/ / / \ \ \| | | |
* | | | / / / \ \ \ | | |
* `---------------------------------' `---------------------------------'
* generated by [keymapviz] */
/* ,-----------------------------------------. ,-----------------------------------------.
* | | | | | | | | | | | | | |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | INS | PSCR | APP | | | | PGUP |PRVWD | UP |NXTWD |DLINE | BSPC |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | LALT | LCTL | LSFT | | CAPS |,------. ,------.| PGDN | LEFT | DOWN | RGHT | DEL | BSPC |
* |------+------+------+------+------+------|| | | ||------+------+------+------+------+------|
* | | UNDO | CUT | COPY |PASTE | |`------' `------'| |LSTRT | | LEND | | |
* `-------------+------+------+------+-.------------. ,------------.-+------+------+------+-------------'
* | | | |/ / / \ \ \| | | |
* | | | / / / \ \ \ | | |
* `---------------------------------' `---------------------------------'
* generated by [keymapviz] */
/* ,-----------------------------------------. ,-----------------------------------------.
* | | | | | | | | | | | | | |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* |RESET | |QWERTY|COLEMA|CG_TOG| | | | | | | | |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | |CG_TOG| | | |,------. ,------.| | VOLD | MUTE | VOLU | | |
* |------+------+------+------+------+------|| | | ||------+------+------+------+------+------|
* | | | | | | |`------' `------'| | MPRV | MPLY | MNXT | | |
* `-------------+------+------+------+-.------------. ,------------.-+------+------+------+-------------'
* | | | |/ / / \ \ \| | | |
* | | | / / / \ \ \ | | |
* `---------------------------------' `---------------------------------'
* generated by [keymapviz] */
|
the_stack_data/41892.c
|
#include <stdio.h>
int main()
{
int n;
printf("Enter number: ");
scanf("%d",&n);
if(n>0)
printf("Number is positive");
else if(n<0)
printf("Number is negative");
else
printf("Number is Zero");
return 0;
}
/*program to find weather number is positive or negative or zero
if else
DAY_9*/
|
the_stack_data/173578703.c
|
/***** Problem 12 on Practice Test 2 *****/
// a.
#include <stdio.h>
/*
int main(int argc, char *argv[]) {
int flag=1;
for(int i=0; i < argc; i++) { // Don't what to include argv[0], the command, in the check.
if(argv[i] != argv[argc-i-1])
flag=0;
}
if(flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
// b.
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) { // Don't what to include argv[0], the command, in the check.
int flag=1;
for(int i=0; i < argc; i++) {
if(strcmp(argv[i], argv[argc-i-1]))
flag=0;
}
if(flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
*/
// c.
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
int flag=1;
for(int i=1; i < argc; i++) {
if(strcmp(argv[i], argv[argc-i]))
flag=0;
}
if(flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
/*
// d.
#include <stdio.h>
int main(int argc, char *argv[]) {
int flag=1;
for(int i=1; i < argc; i++) {
if(argv[i] != argv[argc-i]) // This will only compare the base addresses not the string values
flag=0;
}
if(flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
*/
/********************* OUTPUT **************************
*
* Input: /a.out i like computer science
* Output: NO
*
* Input: /a.out i like computer science computer like i
* Output: YES
*
*
********************************************************/
|
the_stack_data/76699157.c
|
#include <stdio.h>
int n, m, k, l, a, i, d[200001];
int main() {
scanf("%d%d%d", &n, &m, &k);
k *= n;
if (k >= m) {
printf("%d", k - m);
return 0;
}
l = 2 * m - k - 1;
d[k] = 1;
for (; n; --n) {
scanf("%d", &a);
a *= n;
for (i = l; i >= k + a; --i)
d[i] |= d[i - a];
}
for (i = 0; i <= m - k; ++i)
if (d[m - i] || d[m + i]) {
printf("%d", i);
break;
}
return 0;
}
|
the_stack_data/28158.c
|
/*
* Copyright (c) 1996, 1998 by Internet Software Consortium.
*
* 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM 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 <sys/cdefs.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <ctype.h>
#include <resolv.h>
static char
xtob(c)
int c;
{
return (c - (((c >= '0') && (c <= '9')) ? '0' : '7'));
}
u_int
inet_nsap_addr(ascii, binary, maxlen)
const char *ascii;
u_char *binary;
int maxlen;
{
u_char c, nib;
u_int len = 0;
while ((c = *ascii++) != '\0' && len < (u_int)maxlen) {
if (c == '.' || c == '+' || c == '/')
continue;
if (!isascii(c))
return (0);
if (islower(c))
c = toupper(c);
if (isxdigit(c)) {
nib = xtob(c);
c = *ascii++;
if (c != '\0') {
c = toupper(c);
if (isxdigit(c)) {
*binary++ = (nib << 4) | xtob(c);
len++;
} else
return (0);
}
else
return (0);
}
else
return (0);
}
return (len);
}
char *
inet_nsap_ntoa(binlen, binary, ascii)
int binlen;
const u_char *binary;
char *ascii;
{
int nib;
int i;
static char tmpbuf[255*3];
char *start;
if (ascii)
start = ascii;
else {
ascii = tmpbuf;
start = tmpbuf;
}
if (binlen > 255)
binlen = 255;
for (i = 0; i < binlen; i++) {
nib = *binary >> 4;
*ascii++ = nib + (nib < 10 ? '0' : '7');
nib = *binary++ & 0x0f;
*ascii++ = nib + (nib < 10 ? '0' : '7');
if (((i % 2) == 0 && (i + 1) < binlen))
*ascii++ = '.';
}
*ascii = '\0';
return (start);
}
/*
* Weak aliases for applications that use certain private entry points,
* and fail to include <arpa/inet.h>.
*/
#undef inet_nsap_addr
__weak_reference(__inet_nsap_addr, inet_nsap_addr);
#undef inet_nsap_ntoa
__weak_reference(__inet_nsap_ntoa, inet_nsap_ntoa);
|
the_stack_data/111077855.c
|
#include <stdio.h>
main()
{
int c, linestarted;
linestarted = 0;
while ((c = getchar()) != EOF)
if (c == ' ' || c == '\t' || c == '\n') {
if (!linestarted) {
putchar('\n');
linestarted = 1; }
} else {
putchar(c);
linestarted = 0;
}
return 0;
}
|
the_stack_data/82950626.c
|
/*
HELLO WORLD
++++++++. Gives us an H
---. Gives us an E
+++++++.. Gives us 2 Ls
+++. Gives us an O
>. Gives us a space
<++++++++. Gives us a W
--------. Gives us an O
+++. Gives us an R
------. Gives us an L
--------. Gives us a D
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAPE_SIZE 999
char tape[TAPE_SIZE];
int pointer = 0;
const static char alpha[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()_+-=,./;'[]{}:\"<>?";
void eval(int biti) {
switch (biti) {
case(0):
break;
// Increment Cell
case ('+'):
if(tape[pointer] < strlen(alpha) - 1) tape[pointer]++;
goto BITIDEF;
break;
// Decrement Cell
case ('-'):
if(tape[pointer] > 0) tape[pointer]--;
goto BITIDEF;
break;
// Select previous Cell
case ('<'):
if (pointer > 0) pointer--;
goto BITIDEF;
break;
// Select next Cell
case ('>'):
if (pointer < TAPE_SIZE) pointer++;
goto BITIDEF;
break;
// Print Alpha of current Cell
case ('.'):
printf("%c", alpha[tape[pointer]]);
goto BITIDEF;
break;
// Clear all Cells
case('@'):
for(int i = 0; i < TAPE_SIZE; ++i) tape[i] = 0;
goto BITIDEF;
break;
// Clear Screen
case ('#'):
for (int i = 50; i > 0; --i) printf("%c", '\n');
goto BITIDEF;
break;
// Print number literal of current Cell, followed by a newline. Mostly for debugging purposes.
case('!'):
printf("%d\r\n", tape[pointer]);
goto BITIDEF;
break;
BITIDEF:
default:
biti = 0;
break;
}
}
int main(int argc, char** argv) {
char* program;
FILE* fp = fopen(argv[1], "r");
if(fp == NULL) { printf("%s", "Error, file can't be opened. Does it exist?"); return -1;}
// Read length, and allocate memory for file size.
fseek(fp, 0, SEEK_END);
long int size = ftell(fp);
rewind(fp);
program = calloc(size + 1, 1);
//Read our data in!
fread(program, 1, size, fp);
for(int i = 0; i < strlen(program); ++i) {
eval(program[i]);
}
}
|
the_stack_data/106027.c
|
#include <stdio.h>
#include <string.h>
int f_calls = 0;
int fibo[50];
int fib(int n)
{
f_calls = f_calls + 1;
if (fibo[n] != 0) {
return fibo[n];
}
if (n == 1 || n == 2) {
return fibo[n];
}
fibo[n] = fib(n - 1) + fib(n - 2);
return fibo[n];
}
int main()
{
int n;
char s[3];
fibo[1] = 1;
fibo[2] = 1;
scanf("%d", &n);
if (n == 1) {
strcpy(s, "st");
}
else if (n == 2) {
strcpy(s, "nd");
}
else if (n == 3) {
strcpy(s, "rd");
}
else {
strcpy(s, "th");
}
printf("%d%s fibonacci number is %d\n", n, s, fib(n));
printf("Number of function calls : %d\n", f_calls);
for (n = 1; n < 12; n++) {
printf("%d: %d\n", n, fibo[n]);
}
return 0;
}
|
the_stack_data/121761.c
|
#include <limits.h>
int main(void)
{
return INT_MIN / -1;
}
|
the_stack_data/361533.c
|
#include <stdio.h>
#include <math.h>
int main()
{
int n,j,a=0,r;
scanf("%d",&n);
n=n+1;
while(a==0){
j=2;
do{
r=n%j;
j++;
}while(j<=sqrt(n) && r!=0);
if(r==0)
n=n+1;
else if(r!=0)
a=a+1;
}
printf("%d\n",n);
return 0;
}
|
the_stack_data/14199157.c
|
#include <complex.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef SAMPDELTA
#define SAMPDELTA (0.1)
#endif
#define DELTA_OMEGA (2 * M_PI * SAMPDELTA)
typedef struct twozero_state {
double x1;
double x2;
double b0;
double b1;
double b2;
} twozero_state;
typedef struct polezero_state {
double x1;
double y1;
double b0;
double b1;
double a1;
} polezero_state;
typedef struct biquad_state
{
double x1;
double x2;
double y1;
double y2;
double b0;
double b1;
double b2;
double a0;
double a1;
double a2;
} biquad_state;
typedef struct cpole_state
{
complex double y1;
complex double a1;
} cpole_state;
// Using cpole makes this design transientless with respect to parameter changes in contrast to biquad.
typedef struct filter_state
{
twozero_state twozero;
cpole_state cpole;
} filter_state;
typedef struct buffer_state
{
int num_samples;
int index;
double *samples;
} buffer_state;
typedef struct convolver_state {
int num_samples;
int index;
double *samples;
double *coefs;
} convolver_state;
void twozero_reset(twozero_state *t)
{
t->x1 = 0;
t->x2 = 0;
t->b0 = 0;
t->b1 = 0;
t->b2 = 0;
}
double twozero_step(twozero_state *t, double sample)
{
double y0 = t->b0 * sample + t->b1 * t->x1 + t->b2 * t->x2;
t->x2 = t->x1;
t->x1 = sample;
return y0;
}
void polezero_reset(polezero_state *p)
{
p->x1 = 0;
p->y1 = 0;
p->b0 = 0;
p->b1 = 0;
p->a1 = 0;
}
double polezero_step(polezero_state *p, double sample)
{
double y0 = p->b0 * sample + p->b1 * p->x1 - p->a1 * p->y1;
p->x1 = sample;
return p->y1 = y0;
}
void polezero_integrator(polezero_state *p, double gain, double leak_constant)
{
p->b0 = 0.5 * gain * SAMPDELTA;
p->b1 = 0.5 * gain * SAMPDELTA;
p->a1 = -leak_constant;
}
void polezero_apf(polezero_state *p, double g)
{
p->b0 = g;
p->b1 = 1;
p->a1 = g;
}
void biquad_reset(biquad_state *b)
{
b->x1 = 0;
b->x2 = 0;
b->y1 = 0;
b->y2 = 0;
b->b0 = 0;
b->b1 = 0;
b->b2 = 0;
b->a0 = 0;
b->a1 = 0;
b->a2 = 0;
}
double biquad_step(biquad_state *b, double sample)
{
double y0 = b->b0 * sample + b->b1 * b->x1 + b->b2 * b->x2 - b->a1 * b->y1 - b->a2 * b->y2;
y0 /= b->a0;
b->x2 = b->x1;
b->x1 = sample;
b->y2 = b->y1;
b->y1 = y0;
return y0;
}
void biquad_lpf(biquad_state *b, double freq, double Q)
{
double w0 = freq * DELTA_OMEGA;
double alpha = sin(w0) / (2 * Q);
b->b0 = (1 - cos(w0))/2;
b->b1 = 1 - cos(w0);
b->b2 = (1 - cos(w0))/2;
b->a0 = 1 + alpha;
b->a1 = -2*cos(w0);
b->a2 = 1 - alpha;
}
void cpole_reset(cpole_state *p)
{
p->y1 = 0;
p->a1 = 0;
}
complex double cpole_step(cpole_state *p, complex double sample)
{
return p->y1 = sample - p->a1 * p->y1;
}
void filter_reset(filter_state *filter)
{
twozero_reset(&filter->twozero);
cpole_reset(&filter->cpole);
}
double filter_step(filter_state *filter, double sample)
{
sample = twozero_step(&filter->twozero, sample);
return cimag(cpole_step(&filter->cpole, sample));
}
void filter_resonator(filter_state *filter, double freq, double decay)
{
filter->cpole.a1 = -cexp(SAMPDELTA * (2 * M_PI * I * freq - decay));
}
void filter_lpf(filter_state *filter, double freq, double decay)
{
filter_resonator(filter, freq, decay);
filter->twozero.b0 = filter->twozero.b2 = 0.25;
filter->twozero.b1 = 0.5;
}
void filter_hpf(filter_state *filter, double freq, double decay)
{
filter_resonator(filter, freq, decay);
filter->twozero.b0 = filter->twozero.b2 = 0.25;
filter->twozero.b1 = -0.5;
}
void filter_bpf(filter_state *filter, double freq, double decay)
{
filter_resonator(filter, freq, decay);
filter->twozero.b0 = 1;
filter->twozero.b1 = 0;
filter->twozero.b2 = -1;
}
void filter_notch(filter_state *filter, double freq, double decay)
{
filter_resonator(filter, freq, decay);
filter->twozero.b0 = 1;
filter->twozero.b1 = -2 * cos(freq * DELTA_OMEGA);
filter->twozero.b2 = 1;
}
void filter_apf(filter_state *filter, double freq, double decay)
{
filter_resonator(filter, freq, decay);
double r = creal(filter->cpole.a1);
double i = cimag(filter->cpole.a1);
double m = 1.0 / sin(freq * DELTA_OMEGA);
filter->twozero.b0 = (r * r + i * i) * m;
filter->twozero.b2 = m;
filter->twozero.b1 = 2 * r * m;
}
void buffer_preinit(buffer_state *b)
{
b->num_samples = 0;
b->samples = NULL;
}
void buffer_init(buffer_state *b, int num_samples)
{
b->num_samples = num_samples;
b->index = 0;
b->samples = calloc(num_samples, sizeof(double));
assert(b->samples);
}
void buffer_destroy(buffer_state *b)
{
double *samples = b->samples;
buffer_preinit(b);
free(samples);
}
void buffer_step(buffer_state *b, double sample)
{
if (b->samples) {
b->samples[b->index++] = sample;
if (b->index >= b->num_samples) {
b->index = 0;
}
}
}
double buffer_delay(const buffer_state b, int delay)
{
#ifdef DEBUG
assert(delay >= 0);
assert(delay <= b.num_samples);
#endif
if (!b.samples) {
return 0;
}
int index = b.index - delay;
if (index < 0) {
index += b.num_samples;
}
return b.samples[index];
}
void convolver_init(convolver_state *c, int num_samples)
{
c->num_samples = num_samples;
c->index = 0;
c->samples = malloc(num_samples * sizeof(double));
c->coefs = malloc(num_samples * sizeof(double));
}
void convolver_destroy(convolver_state *c)
{
free(c->samples);
free(c->coefs);
}
double convolver_step(convolver_state *c, double sample)
{
double v = 0;
c->samples[c->index] = sample;
for (int i = 0; i < c->num_samples; i++) {
v += c->coefs[i] * c->samples[(i + c->index) % c->num_samples];
}
c->index++;
if (c->index >= c->num_samples) {
c->index = 0;
}
return v;
}
#ifndef MAIN
int main()
{
cpole_state p;
cpole_reset(&p);
p.a1 = -cexp(0.2 * I);
complex double y = cpole_step(&p, 1);
for (int i = 0; i < 40; i++) {
printf("%g + (%g) * 1j,", creal(y), cimag(y));
y = cpole_step(&p, 0);
if (i > 25) {
p.a1 = -cexp(0.7 * I);
}
}
printf("\n");
return 0;
}
#endif
|
the_stack_data/242330435.c
|
/*
* ex4xc_cb.c
*
* C implementation of the external equations for example 4
* (DEA, parameter estimation) in the file ex4x.gms.
* Here, we use the callback capability for the messages.
* The special aspect of this implementation is that we tell the
* solvers that some of the derivatives are constant and we declare
* the derivate w.r.t cv to be constant = +1.
*
*/
#if 0
#include <math.h>
#include <assert.h>
#include "geheader.h"
#include "SiconosBlas.h"
#include "GlobalFrictionContactProblem.h"
#include "gfc3d_Gams.h"
#define BOGUS_EXTEQ 2
static int nchars;
static int mmode;
/* use the do-while loop so the macro acts like one statement */
#define MSGCB(mode,buf) do { mmode = mode; nchars=strlen(buf); msgcb(&mmode,&nchars,buf,nchars);} while (0)
/* Goal of this plugin: we want to compute v from the problem data and r */
/* Some general comments:
* - We need some data that are not going to be provided by the solvers: the
* matrix M, H and the vector f -> we have to resort using a static pointer
* to the problem data
*
* - gams will call this plugin for each component of v.
*/
/* TODO use thread local storage here ? */
static GlobalFrictionContactProblem* GFCP;
void set_pointer_data(GlobalFrictionContactProblem* gfcp)
{
GFCP = gfcp;
}
static inline double solve_lu(NumericsMatrix* M, unsigned i, rhs)
{
nb_matrix = div(i, 3);
}
GE_API int GE_CALLCONV
gefunc(int *icntr, double *x, double *func, double *d, msgcb_t msgcb)
{
assert(GFCP && "No GlobalFrictionContactProblem has been set!");
#if defined(SOME_DEBUG_STUFF)
char msgBuf[256];
#endif
double t, dtdh;
double t1, dt1dh;
double t2, dt2dh;
double h, cv, dfdh, dfdcv, f;
if(icntr[I_Mode] == DOINIT)
{
/*
* Initialization Mode:
* Write a "finger print" to the status file so errors in the DLL
* can be detected more easily. This should be done before anything
* can go wrong. Also write a line to the log just to show it.
*/
MSGCB(LOGFILE | STAFILE,"");
MSGCB(LOGFILE | STAFILE,"--- GEFUNC in ex4xc_cb.c is being initialized.");
/* Test the equation count and return 2 if bogus */
if(icntr[I_Neq] != 1)
{
MSGCB(LOGFILE | STAFILE,
"--- Model has the wrong number of external equations.");
return BOGUS_EXTEQ;
}
if(2 != icntr[I_Nz])
{
MSGCB(LOGFILE | STAFILE,
"--- The external equation should be fully dense.");
return BOGUS_EXTEQ;
}
if(2 != icntr[I_Nvar])
{
MSGCB(LOGFILE | STAFILE,
"--- The external equation should have 2 variables.");
return BOGUS_EXTEQ;
}
/* Define number of constant derivatives */
icntr[I_ConstDeriv] = 1;
/* Form */
NM_setup(GFCP->H);
return 0;
} /* initialization mode */
else if(icntr[I_Mode] == DOCONSTDERIV)
{
assert(0 && "Why are we here? icntr[I_Mode] == DOCONSTDERIV ");
}
else if(icntr[I_Mode] == DOTERM)
{
/* Termination mode: free allocated storage */
return 0;
} /* termination mode */
else if(icntr[I_Mode] == DOEVAL)
{
/*
* Function index: there is only one equation here,
* but we check the equation number just to show the principle.
*/
if(icntr[I_Eqno] != 1)
{
MSGCB(STAFILE | LOGFILE," ** Eqno has unexpected value.");
return BOGUS_EXTEQ;
}
NumericsMatrix Mlu = ((GFC3D_Gams*) GFCP->env)->Mlu;
double* rhs = ((GFC3D_Gams*) GFCP->env)->rhs;
/* set rhs = Hr + f */
cblas_dcopy(n, func, 1, rhs, 1);
/* solve Mv = Hr + f = rhs */
/* get our values from the array passed in, just to be neat */
h = x[0];
cv = x[1];
#if defined(SOME_DEBUG_STUFF)
sprintf(msgBuf, " dh = %g, dcv = %g, f = %f",
dfdh, dfdcv, f);
MSGCB(STAFILE | LOGFILE, msgBuf);
#endif
if(icntr[I_Dofunc])
{
*func = f;
}
if(icntr[I_Dodrv])
{
assert(0 && "Computing derivative is not implemented yet ...!");
}
return 0;
} /* Function and Derivative Evaluation Mode */
else
{
MSGCB(STAFILE | LOGFILE, " ** Mode not defined.");
return 2;
}
} /* gefunc */
#endif
|
the_stack_data/10752.c
|
#if defined(__GNUC__) || __has_attribute(target)
#define ATTRIBUTE_TARGET(x) __attribute__((target((x))))
#else
#define ATTRIBUTE_TARGET(x)
#endif
#if defined(SSE2) || defined(SSE4_1) || defined(AVX2)
#include <immintrin.h>
#if defined(SSE2)
ATTRIBUTE_TARGET("sse2") void test(void) {
__m128i v = _mm_setzero_si128();
(void)v;
}
#endif
#if defined(SSE4_1)
ATTRIBUTE_TARGET("sse4.1") void test(void) {
__m128i v = _mm_setzero_si128();
(void)_mm_testz_si128(v, v);
}
#endif
#if defined(AVX2)
ATTRIBUTE_TARGET("avx2") void test(void) {
__m256i v = _mm256_setzero_si256();
(void)v;
}
#endif
#endif
#if defined(NEON)
#include <arm_neon.h>
void test(void) {
uint32x4_t v = vmovq_n_u32(0);
(void)v;
}
#endif
int main(void) {
test();
}
|
the_stack_data/97012359.c
|
#include <stdio.h>
main()
{
float fahr, celsius;
float lower, upper, step;
lower = 0;
upper = 300;
step = 20;
printf("Celsius\tFahrenheit\n-------\t----------\n");
celsius = lower;
while (celsius <= upper) {
fahr = (9.0/5.0) * celsius + 32.0;
printf("%7.0f\t%10.0f\n", celsius, fahr);
celsius = celsius + step;
}
}
|
the_stack_data/98856.c
|
/**
* simple www client.
*
* compile and run:
* $ gcc -O3 -o wwwclient d69.c
* $ ./wwwclient google.com 80
*/
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <strings.h>
#include <sys/socket.h>
#include <sys/types.h>
#define DATA "GET /index.html HTTP1.0 \r\n\r\n"
int main(int argc, char *argv[])
{
int sock, rval;
struct sockaddr_in server;
struct hostent *hp, *gethostbyname();
char buf[1024];
if (argc != 3) {
printf("usage: %s {hostname} {port}", argv[0]);
return 1;
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("opening stream socket");
return 1;
}
server.sin_family = AF_INET;
hp = gethostbyname(argv[1]);
if (hp == 0) {
fprintf(stderr, "%s: unknown host\n", argv[1]);
return 2;
}
bcopy(hp->h_addr, &server.sin_addr, hp->h_length);
server.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror("connecting stream socket");
return 1;
}
if (write(sock, DATA, sizeof(DATA)) < 0)
perror("writing on stream socket");
do {
bzero(buf, sizeof(buf));
rval = read(sock,buf,1023);
if (rval != 0)
printf("%s",buf);
} while (rval != 0);
close(sock);
}
|
the_stack_data/37014.c
|
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
* Input to godefs
godefs -f -m64 defs.c >amd64/defs.h
godefs -f -m64 defs1.c >>amd64/defs.h
*/
#include <ucontext.h>
typedef __sigset_t $Usigset;
typedef struct _libc_fpxreg $Fpxreg;
typedef struct _libc_xmmreg $Xmmreg;
typedef struct _libc_fpstate $Fpstate;
typedef struct _libc_fpreg $Fpreg;
typedef struct _fpxreg $Fpxreg1;
typedef struct _xmmreg $Xmmreg1;
typedef struct _fpstate $Fpstate1;
typedef struct _fpreg $Fpreg1;
typedef struct sigaltstack $Sigaltstack;
typedef mcontext_t $Mcontext;
typedef ucontext_t $Ucontext;
typedef struct sigcontext $Sigcontext;
|
the_stack_data/140764216.c
|
#include<stdio.h>
int main()
{
int i,a[100],n,k,newindex,d;
printf("enter number of elements");
scanf("%d",&n);
printf("enter elements");
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
printf("enter the element random");
scanf("%d",&k);
for(i=0;i<n;i++)
{
if(a[i]==k)
newindex=i;
}
for(i=newindex;i<n;i++)
a[i]=a[i+1];
printf("%d",newindex);
for(i=0;i<n-1;i++)
printf("%d\n",a[i]);
}
|
the_stack_data/1049589.c
|
/*
Write a program to check whether the
given three digit integer is Armstrong or not.
*/
#include <stdio.h>
#include <math.h>
int main(void) {
int n, arm = 0, num, d;
printf("Enter three digit integer to check whether it is armstrong or not: ");
scanf("%d", &n);
num = n;
while(n != 0) {
d = n % 10;
arm = arm + pow(d, 3);
n = n / 10;
}
if(num == arm)
printf("\nThe given number %d is armstrong", num);
else
printf("\nThe given number %d is not an armstrong", num);
return 0;
}
|
the_stack_data/456432.c
|
#include <string.h>
#include <stdio.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
void base64e(const char* str, int len)
{
BIO *bmem, *b64;
BUF_MEM *bptr;
char* buff;
b64 = BIO_new(BIO_f_base64());
bmem = BIO_new(BIO_s_mem());
b64 = BIO_push(b64, bmem);
BIO_write(b64, str, len);
BIO_flush(b64);
BIO_get_mem_ptr(b64, &bptr);
buff = (char *)malloc(bptr->length);
memcpy(buff, bptr->data, bptr->length-1);
buff[bptr->length-1] = 0;
printf("%s\n", buff);
BIO_free_all(b64);
free(buff);
}
void base64d(const char* str, int len)
{
BIO *bmem, *b64;
char* in, *out;
in = (char *)malloc(len + 2);
out = (char *)malloc(len);
sprintf(in, "%s\n", str);
memset(out, 0, len);
b64 = BIO_new(BIO_f_base64());
bmem = BIO_new_mem_buf((unsigned char*)in, strlen(in));
bmem = BIO_push(b64, bmem);
BIO_read(bmem, out, len);
printf("%s\n", out);
BIO_free_all(bmem);
free(in);
free(out);
}
int main(int argc, char* argv[])
{
int enc;
if (argc < 3)
{
printf("укажите направление (d | e) и данные\n");
return 1;
}
enc = argv[1][0] == 'e' ? 0 : (argv[1][0] == 'd' ? 1 : -1);
switch (enc)
{
case 0:
base64e(argv[2], strlen(argv[2]));
break;
case 1:
base64d(argv[2], strlen(argv[2]));
break;
default:
printf("неверный ключ\n");
return 2;
}
return 0;
}
|
the_stack_data/359339.c
|
// RUN: %clang_cc1 -fsyntax-only -fopenmp -verify %s
// RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -verify %s
void foo();
// expected-error@+1 {{unexpected OpenMP directive '#pragma omp sections'}}
#pragma omp sections
// expected-error@+1 {{unexpected OpenMP directive '#pragma omp sections'}}
#pragma omp sections foo
void test_no_clause() {
int i;
#pragma omp sections
{
foo();
}
// expected-error@+2 {{the statement for '#pragma omp sections' must be a compound statement}}
#pragma omp sections
++i;
#pragma omp sections
{
foo();
foo(); // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}}
}
}
void test_branch_protected_scope() {
int i = 0;
L1:
++i;
int x[24];
#pragma omp parallel
#pragma omp sections
{
if (i == 5)
goto L1; // expected-error {{use of undeclared label 'L1'}}
else if (i == 6)
return; // expected-error {{cannot return from OpenMP region}}
else if (i == 7)
goto L2;
else if (i == 8) {
L2:
x[i]++;
}
#pragma omp section
if (i == 5)
goto L1; // expected-error {{use of undeclared label 'L1'}}
else if (i == 6)
return; // expected-error {{cannot return from OpenMP region}}
else if (i == 7)
goto L3;
else if (i == 8) {
L3:
x[i]++;
}
}
if (x[0] == 0)
goto L2; // expected-error {{use of undeclared label 'L2'}}
else if (x[1] == 1)
goto L1;
goto L3; // expected-error {{use of undeclared label 'L3'}}
}
void test_invalid_clause() {
int i;
#pragma omp parallel
// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}}
#pragma omp sections foo bar
{
foo();
// expected-error@+1 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp section'}}
#pragma omp section nowait
;
}
}
void test_non_identifiers() {
int i, x;
#pragma omp parallel
// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}}
#pragma omp sections;
{
foo();
}
#pragma omp parallel
// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp sections'}}
// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}}
#pragma omp sections linear(x);
{
foo();
}
#pragma omp parallel
// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}}
#pragma omp sections private(x);
{
foo();
}
#pragma omp parallel
// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}}
#pragma omp sections, private(x);
{
foo();
}
}
void test_private() {
int i;
#pragma omp parallel
// expected-error@+2 {{expected expression}}
// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
#pragma omp sections private(
{
foo();
}
#pragma omp parallel
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
// expected-error@+1 2 {{expected expression}}
#pragma omp sections private(,
{
foo();
}
#pragma omp parallel
// expected-error@+1 2 {{expected expression}}
#pragma omp sections private(, )
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections private()
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections private(int)
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected variable name}}
#pragma omp sections private(0)
{
foo();
}
int x, y, z;
#pragma omp parallel
#pragma omp sections private(x)
{
foo();
}
#pragma omp parallel
#pragma omp sections private(x, y)
{
foo();
}
#pragma omp parallel
#pragma omp sections private(x, y, z)
{
foo();
}
}
void test_lastprivate() {
int i;
#pragma omp parallel
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
// expected-error@+1 {{expected expression}}
#pragma omp sections lastprivate(
{
foo();
}
#pragma omp parallel
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
// expected-error@+1 2 {{expected expression}}
#pragma omp sections lastprivate(,
{
foo();
}
#pragma omp parallel
// expected-error@+1 2 {{expected expression}}
#pragma omp sections lastprivate(, )
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections lastprivate()
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections lastprivate(int)
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected variable name}}
#pragma omp sections lastprivate(0)
{
foo();
}
int x, y, z;
#pragma omp parallel
#pragma omp sections lastprivate(x)
{
foo();
}
#pragma omp parallel
#pragma omp sections lastprivate(x, y)
{
foo();
}
#pragma omp parallel
#pragma omp sections lastprivate(x, y, z)
{
foo();
}
}
void test_firstprivate() {
int i;
#pragma omp parallel
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
// expected-error@+1 {{expected expression}}
#pragma omp sections firstprivate(
{
foo();
}
#pragma omp parallel
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
// expected-error@+1 2 {{expected expression}}
#pragma omp sections firstprivate(,
{
foo();
}
#pragma omp parallel
// expected-error@+1 2 {{expected expression}}
#pragma omp sections firstprivate(, )
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections firstprivate()
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected expression}}
#pragma omp sections firstprivate(int)
{
foo();
}
#pragma omp parallel
// expected-error@+1 {{expected variable name}}
#pragma omp sections firstprivate(0)
{
foo();
}
int x, y, z;
#pragma omp parallel
#pragma omp sections lastprivate(x) firstprivate(x)
{
foo();
}
#pragma omp parallel
#pragma omp sections lastprivate(x, y) firstprivate(x, y)
{
foo();
}
#pragma omp parallel
#pragma omp sections lastprivate(x, y, z) firstprivate(x, y, z)
{
foo();
}
}
void test_nowait() {
#pragma omp parallel
#pragma omp sections nowait nowait // expected-error {{directive '#pragma omp sections' cannot contain more than one 'nowait' clause}}
{
;
}
}
|
the_stack_data/103265736.c
|
//1914 - De Quem é a Vez?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
char p1Name[1005], p1Type[10],p2Name[1005], p2Type[10];
int casos, p1, p2, total;
scanf("%d", &casos);
getchar(); //limpa \n
while(casos--){
scanf("%s %s %s %s", p1Name, p1Type, p2Name, p2Type);
scanf("%d %d", &p1, &p2);
total = p1 + p2;
if(!(strcmp(p1Type, "PAR"))){ // p1 PAR
if(total % 2 == 0){
printf("%s\n", p1Name);
}
else{
printf("%s\n", p2Name);
}
}
else{ // p2 PAR
if(total % 2 == 0){
printf("%s\n", p2Name);
}
else{
printf("%s\n", p1Name);
}
}
// printf("%s %s - %d\n", p1Name, p1Type, p1);
// printf("%s %s - %d\n", p2Name, p2Type, p2);
}
return 0;
}
|
the_stack_data/247017492.c
|
/* An example to show how to use the math library in C */
#include <stdio.h>
#include <math.h>
/* For this code to compile, you need to tell the linker to link */
/* in the "math" library (Look at the script in this directory) */
int main (void)
{
float radians = 1.345;
/* The cos function comes from the math.h file */
printf("cos(%f) = %f\n", radians, cos(radians));
return 0;
}
|
the_stack_data/136014.c
|
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv){
FILE *fp = fopen(argv[1], "r");
if (!fp) {printf("File Read Error!\n");return 1;}
char buf[17];
while ( fread(buf, 1, sizeof(buf), fp)){
int i=0;
int ins=0;
for (i=0; i<16; i++){
printf("%c",buf[i]);
ins = ins*2 + (buf[i] - 48);
}
printf(" -> %u \n",ins);
}
fclose(fp);
return 0;
}
|
the_stack_data/1120987.c
|
foo (a, b)
{
if (a == 1)
goto foo1;
if (a == 2)
goto foo2;
foo1:
return 2;
foo2:
return 3;
}
|
the_stack_data/215766910.c
|
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
main()
{
int n,k,i;
struct node* head , *t , *newhead,*temp;
head = NULL;
t = head;
scanf("%d",&n);
for(i=0;i<n;i++)
{
struct node* nnode = (struct node*)malloc(8);
scanf("%d",&nnode->data);
if(head==NULL)
{
head = nnode;
}
else
{
t->next = nnode;
}
t=nnode;
}
t->next = NULL;
i=0;
temp=head;
scanf("%d",&k);
while(i<k-1)
{
temp=temp->next;
i++;
}
newhead = temp->next;
temp->next = NULL;
temp = head;
printf("Linked List 1 : ");
while (temp)
{
printf("%d ",temp->data);
temp=temp->next;
}
temp = newhead;
printf("\nLinked List 2 : ");
while (temp)
{
printf("%d ",temp->data);
temp=temp->next;
}
}
|
the_stack_data/199856.c
|
#include <unistd.h>
void ft_is_negative(int n)
{
if (n < 0)
{
write(1, "N", 1);
}
else
{
write(1, "P", 1);
}
}
|
the_stack_data/111752.c
|
// Liao, 3/13/2012
// test cases for various function objects
// named, expression, and aliased, pointer to function
void foo ();
void foo ()
{
}
void bar()
{
// pointer to a function
void (*func) (void) ;
func = foo;
foo();
(*func)();
}
|
the_stack_data/150144307.c
|
//===-- ARMInstPrinter.cpp - Convert ARM MCInst to assembly syntax --------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class prints an ARM MCInst to a .s file.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2014 */
#ifdef CAPSTONE_HAS_ARM
#include <stdio.h> // DEBUG
#include <stdlib.h>
#include <string.h>
#include "../../inttypes.h"
#include "ARMInstPrinter.h"
#include "ARMAddressingModes.h"
#include "ARMBaseInfo.h"
#include "ARMDisassembler.h"
#include "../../MCInst.h"
#include "../../SStream.h"
#include "../../MCRegisterInfo.h"
#include "../../utils.h"
#include "ARMMapping.h"
#define GET_SUBTARGETINFO_ENUM
#include "ARMGenSubtargetInfo.inc"
static void printRegName(cs_struct *h, SStream *OS, unsigned RegNo);
// Autogenerated by tblgen.
static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI);
static void printOperand(MCInst *MI, unsigned OpNo, SStream *O);
static void printSORegRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printSORegImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrModeTBB(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrModeTBH(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode2Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAM2PreOrOffsetIndexOp(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode2OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode3Operand(MCInst *MI, unsigned OpNum, SStream *O, bool AlwaysPrintImm0);
static void printAddrMode3OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAM3PreOrOffsetIndexOp(MCInst *MI, unsigned Op, SStream *O, bool AlwaysPrintImm0);
static void printPostIdxImm8Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printPostIdxRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printPostIdxImm8s4Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode5Operand(MCInst *MI, unsigned OpNum, SStream *O, bool AlwaysPrintImm0);
static void printAddrMode6Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode7Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrMode6OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printBitfieldInvMaskImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printMemBOption(MCInst *MI, unsigned OpNum, SStream *O);
static void printShiftImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printPKHLSLShiftImm(MCInst *MI, unsigned OpNum, SStream *O);
static void printPKHASRShiftImm(MCInst *MI, unsigned OpNum, SStream *O);
static void printAdrLabelOperand(MCInst *MI, unsigned OpNum, SStream *O, unsigned);
static void printThumbS4ImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbSRImm(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbITMask(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbAddrModeRROperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbAddrModeImm5SOperand(MCInst *MI, unsigned OpNum, SStream *O, unsigned Scale);
static void printThumbAddrModeImm5S1Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbAddrModeImm5S2Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbAddrModeImm5S4Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printThumbAddrModeSPOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printT2SOOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printAddrModeImm12Operand(MCInst *MI, unsigned OpNum, SStream *O, bool AlwaysPrintImm0);
static void printT2AddrModeImm8Operand(MCInst *MI, unsigned OpNum, SStream *O, bool);
static void printT2AddrModeImm8s4Operand(MCInst *MI, unsigned OpNum, SStream *O, bool);
static void printT2AddrModeImm0_1020s4Operand(MCInst *MI, unsigned OpNum, SStream *O);
static void printT2AddrModeImm8OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printT2AddrModeImm8s4OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printT2AddrModeSoRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printSetendOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printCPSIMod(MCInst *MI, unsigned OpNum, SStream *O);
static void printCPSIFlag(MCInst *MI, unsigned OpNum, SStream *O);
static void printMSRMaskOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printMandatoryPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printSBitModifierOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printRegisterList(MCInst *MI, unsigned OpNum, SStream *O);
static void printNoHashImmediate(MCInst *MI, unsigned OpNum, SStream *O);
static void printPImmediate(MCInst *MI, unsigned OpNum, SStream *O);
static void printCImmediate(MCInst *MI, unsigned OpNum, SStream *O);
static void printCoprocOptionImm(MCInst *MI, unsigned OpNum, SStream *O);
static void printFPImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printNEONModImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printImmPlusOneOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printRotImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printGPRPairOperand(MCInst *MI, unsigned OpNum, SStream *O, MCRegisterInfo *MRI);
static void printThumbLdrLabelOperand(MCInst *MI, unsigned OpNum, SStream *O);
static void printFBits16(MCInst *MI, unsigned OpNum, SStream *O);
static void printFBits32(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorIndex(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListOne(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListTwo(MCInst *MI, unsigned OpNum, SStream *O, MCRegisterInfo *MRI);
static void printVectorListTwoSpaced(MCInst *MI, unsigned OpNum, SStream *O, MCRegisterInfo *RI);
static void printVectorListThree(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListFour(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListOneAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListTwoAllLanes(MCInst *MI, unsigned OpNum, SStream *O, MCRegisterInfo *RI);
static void printVectorListThreeAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListFourAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListTwoSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O, MCRegisterInfo *MRI);
static void printVectorListThreeSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListFourSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListThreeSpaced(MCInst *MI, unsigned OpNum, SStream *O);
static void printVectorListFourSpaced(MCInst *MI, unsigned OpNum, SStream *O);
static void printInstSyncBOption(MCInst *MI, unsigned OpNum, SStream *O);
static void set_mem_access(MCInst *MI, bool status)
{
if (MI->csh->detail != CS_OPT_ON)
return;
MI->csh->doing_mem = status;
if (status) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_MEM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = ARM_REG_INVALID;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = ARM_REG_INVALID;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.scale = 1;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = 0;
} else {
// done, create the next operand slot
MI->flat_insn->detail->arm.op_count++;
}
}
static void op_addImm(MCInst *MI, int v)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = v;
MI->flat_insn->detail->arm.op_count++;
}
}
#define GET_INSTRINFO_ENUM
#include "ARMGenInstrInfo.inc"
//#define PRINT_ALIAS_INSTR
#include "ARMGenAsmWriter.inc"
void ARM_getRegName(cs_struct *handle, int value)
{
if (value == CS_OPT_SYNTAX_NOREGNAME) {
handle->get_regname = getRegisterName2;
handle->reg_name = ARM_reg_name2;;
} else {
handle->get_regname = getRegisterName;
handle->reg_name = ARM_reg_name;;
}
}
/// translateShiftImm - Convert shift immediate from 0-31 to 1-32 for printing.
///
/// getSORegOffset returns an integer from 0-31, representing '32' as 0.
static unsigned translateShiftImm(unsigned imm)
{
// lsr #32 and asr #32 exist, but should be encoded as a 0.
//assert((imm & ~0x1f) == 0 && "Invalid shift encoding");
if (imm == 0)
return 32;
return imm;
}
/// Prints the shift value with an immediate value.
static void printRegImmShift(MCInst *MI, SStream *O, ARM_AM_ShiftOpc ShOpc, unsigned ShImm)
{
if (ShOpc == ARM_AM_no_shift || (ShOpc == ARM_AM_lsl && !ShImm))
return;
SStream_concat0(O, ", ");
//assert (!(ShOpc == ARM_AM_ror && !ShImm) && "Cannot have ror #0");
SStream_concat0(O, ARM_AM_getShiftOpcStr(ShOpc));
if (MI->csh->detail) {
if (MI->csh->doing_mem)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.type = (arm_shifter)ShOpc;
else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = (arm_shifter)ShOpc;
}
if (ShOpc != ARM_AM_rrx) {
SStream_concat0(O, " ");
SStream_concat(O, "#%u", translateShiftImm(ShImm));
if (MI->csh->detail) {
if (MI->csh->doing_mem)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.value = translateShiftImm(ShImm);
else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = translateShiftImm(ShImm);
}
}
}
static void printRegName(cs_struct *h, SStream *OS, unsigned RegNo)
{
#ifndef CAPSTONE_DIET
SStream_concat0(OS, h->get_regname(RegNo));
#endif
}
static name_map insn_update_flgs[] = {
{ ARM_INS_CMN, "cmn" },
{ ARM_INS_CMP, "cmp" },
{ ARM_INS_TEQ, "teq" },
{ ARM_INS_TST, "tst" },
{ ARM_INS_ADC, "adcs" },
{ ARM_INS_ADD, "adds" },
{ ARM_INS_AND, "ands" },
{ ARM_INS_ASR, "asrs" },
{ ARM_INS_BIC, "bics" },
{ ARM_INS_EOR, "eors" },
{ ARM_INS_LSL, "lsls" },
{ ARM_INS_LSR, "lsrs" },
{ ARM_INS_MLA, "mlas" },
{ ARM_INS_MOV, "movs" },
{ ARM_INS_MUL, "muls" },
{ ARM_INS_MVN, "mvns" },
{ ARM_INS_ORN, "orns" },
{ ARM_INS_ORR, "orrs" },
{ ARM_INS_ROR, "rors" },
{ ARM_INS_RRX, "rrxs" },
{ ARM_INS_RSB, "rsbs" },
{ ARM_INS_RSC, "rscs" },
{ ARM_INS_SBC, "sbcs" },
{ ARM_INS_SMLAL, "smlals" },
{ ARM_INS_SMULL, "smulls" },
{ ARM_INS_SUB, "subs" },
{ ARM_INS_UMLAL, "umlals" },
{ ARM_INS_UMULL, "umulls" },
};
void ARM_post_printer(csh ud, cs_insn *insn, char *insn_asm, MCInst *mci)
{
if (((cs_struct *)ud)->detail != CS_OPT_ON)
return;
// check if this insn requests write-back
if (strrchr(insn_asm, '!') != NULL) {
insn->detail->arm.writeback = true;
}
// check if this insn requests update flags
if (insn->detail->arm.update_flags == false) {
// some insn still update flags, regardless of tabgen info
unsigned int i, j;
for (i = 0; i < ARR_SIZE(insn_update_flgs); i++) {
if (insn->id == insn_update_flgs[i].id &&
!strncmp(insn_asm, insn_update_flgs[i].name,
strlen(insn_update_flgs[i].name))) {
insn->detail->arm.update_flags = true;
// we have to update regs_write array as well
for (j = 0; j < ARR_SIZE(insn->detail->regs_write); j++) {
if (insn->detail->regs_write[j] == 0) {
insn->detail->regs_write[j] = ARM_REG_CPSR;
break;
}
}
break;
}
}
}
// instruction should not have invalid CC
if (insn->detail->arm.cc == ARM_CC_INVALID) {
insn->detail->arm.cc = ARM_CC_AL;
}
// manual fix for some special instructions
// printf(">>> id: %u, mcid: %u\n", insn->id, mci->Opcode);
switch(mci->Opcode) {
default:
break;
case ARM_MOVPCLR:
insn->detail->arm.operands[0].type = ARM_OP_REG;
insn->detail->arm.operands[0].reg = ARM_REG_PC;
insn->detail->arm.operands[1].type = ARM_OP_REG;
insn->detail->arm.operands[1].reg = ARM_REG_LR;
insn->detail->arm.op_count = 2;
break;
}
}
void ARM_printInst(MCInst *MI, SStream *O, void *Info)
{
MCRegisterInfo *MRI = (MCRegisterInfo *)Info;
unsigned Opcode = MCInst_getOpcode(MI), tmp, i, pubOpcode;
switch(Opcode) {
// Check for HINT instructions w/ canonical names.
case ARM_HINT:
case ARM_tHINT:
case ARM_t2HINT:
switch (MCOperand_getImm(MCInst_getOperand(MI, 0))) {
case 0: SStream_concat0(O, "nop"); pubOpcode = ARM_INS_NOP; break;
case 1: SStream_concat0(O, "yield"); pubOpcode = ARM_INS_YIELD; break;
case 2: SStream_concat0(O, "wfe"); pubOpcode = ARM_INS_WFE; break;
case 3: SStream_concat0(O, "wfi"); pubOpcode = ARM_INS_WFI; break;
case 4: SStream_concat0(O, "sev"); pubOpcode = ARM_INS_SEV; break;
case 5:
if ((ARM_getFeatureBits(MI->csh->mode) & ARM_HasV8Ops)) {
SStream_concat0(O, "sevl");
pubOpcode = ARM_INS_SEVL;
break;
}
// Fallthrough for non-v8
default:
// Anything else should just print normally.
printInstruction(MI, O, MRI);
return;
}
printPredicateOperand(MI, 1, O);
if (Opcode == ARM_t2HINT)
SStream_concat0(O, ".w");
MCInst_setOpcodePub(MI, pubOpcode);
return;
// Check for MOVs and print canonical forms, instead.
case ARM_MOVsr: {
// FIXME: Thumb variants?
MCOperand *Dst = MCInst_getOperand(MI, 0);
MCOperand *MO1 = MCInst_getOperand(MI, 1);
MCOperand *MO2 = MCInst_getOperand(MI, 2);
MCOperand *MO3 = MCInst_getOperand(MI, 3);
SStream_concat0(O, ARM_AM_getShiftOpcStr(ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO3))));
printSBitModifierOperand(MI, 6, O);
printPredicateOperand(MI, 4, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, MCOperand_getReg(Dst));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(Dst);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO2);
MI->flat_insn->detail->arm.op_count++;
}
//assert(ARM_AM_getSORegOffset(MO3.getImm()) == 0);
return;
}
case ARM_MOVsi: {
// FIXME: Thumb variants?
MCOperand *Dst = MCInst_getOperand(MI, 0);
MCOperand *MO1 = MCInst_getOperand(MI, 1);
MCOperand *MO2 = MCInst_getOperand(MI, 2);
SStream_concat0(O, ARM_AM_getShiftOpcStr(ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2))));
printSBitModifierOperand(MI, 5, O);
printPredicateOperand(MI, 3, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, MCOperand_getReg(Dst));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(Dst);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.op_count++;
}
if (ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2)) == ARM_AM_rrx) {
//printAnnotation(O, Annot);
return;
}
SStream_concat0(O, ", ");
tmp = translateShiftImm(getSORegOffset((unsigned int)MCOperand_getImm(MO2)));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type =
(arm_shifter)ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2));
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = tmp;
}
return;
}
// A8.6.123 PUSH
case ARM_STMDB_UPD:
case ARM_t2STMDB_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP &&
MCInst_getNumOperands(MI) > 5) {
// Should only print PUSH if there are at least two registers in the list.
SStream_concat0(O, "push");
MCInst_setOpcodePub(MI, ARM_INS_PUSH);
printPredicateOperand(MI, 2, O);
if (Opcode == ARM_t2STMDB_UPD)
SStream_concat0(O, ".w");
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_STR_PRE_IMM:
if (MCOperand_getReg(MCInst_getOperand(MI, 2)) == ARM_SP &&
MCOperand_getImm(MCInst_getOperand(MI, 3)) == -4) {
SStream_concat0(O, "push");
MCInst_setOpcodePub(MI, ARM_INS_PUSH);
printPredicateOperand(MI, 4, O);
SStream_concat0(O, "\t{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, 1)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, 1));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
return;
}
break;
// A8.6.122 POP
case ARM_LDMIA_UPD:
case ARM_t2LDMIA_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP &&
MCInst_getNumOperands(MI) > 5) {
// Should only print POP if there are at least two registers in the list.
SStream_concat0(O, "pop");
MCInst_setOpcodePub(MI, ARM_INS_POP);
printPredicateOperand(MI, 2, O);
if (Opcode == ARM_t2LDMIA_UPD)
SStream_concat0(O, ".w");
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_LDR_POST_IMM:
if (MCOperand_getReg(MCInst_getOperand(MI, 2)) == ARM_SP &&
MCOperand_getImm(MCInst_getOperand(MI, 4)) == 4) {
SStream_concat0(O, "pop");
MCInst_setOpcodePub(MI, ARM_INS_POP);
printPredicateOperand(MI, 5, O);
SStream_concat0(O, "\t{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, 0)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, 0));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
return;
}
break;
// A8.6.355 VPUSH
case ARM_VSTMSDB_UPD:
case ARM_VSTMDDB_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP) {
SStream_concat0(O, "vpush");
MCInst_setOpcodePub(MI, ARM_INS_VPUSH);
printPredicateOperand(MI, 2, O);
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
// A8.6.354 VPOP
case ARM_VLDMSIA_UPD:
case ARM_VLDMDIA_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP) {
SStream_concat0(O, "vpop");
MCInst_setOpcodePub(MI, ARM_INS_VPOP);
printPredicateOperand(MI, 2, O);
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_tLDMIA: {
bool Writeback = true;
unsigned BaseReg = MCOperand_getReg(MCInst_getOperand(MI, 0));
unsigned i;
for (i = 3; i < MCInst_getNumOperands(MI); ++i) {
if (MCOperand_getReg(MCInst_getOperand(MI, i)) == BaseReg)
Writeback = false;
}
SStream_concat0(O, "ldm");
MCInst_setOpcodePub(MI, ARM_INS_LDM);
printPredicateOperand(MI, 1, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, BaseReg);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = BaseReg;
MI->flat_insn->detail->arm.op_count++;
}
if (Writeback)
SStream_concat0(O, "!");
SStream_concat0(O, ", ");
printRegisterList(MI, 3, O);
return;
}
// Combine 2 GPRs from disassember into a GPRPair to match with instr def.
// ldrexd/strexd require even/odd GPR pair. To enforce this constraint,
// a single GPRPair reg operand is used in the .td file to replace the two
// GPRs. However, when decoding them, the two GRPs cannot be automatically
// expressed as a GPRPair, so we have to manually merge them.
// FIXME: We would really like to be able to tablegen'erate this.
case ARM_LDREXD:
case ARM_STREXD:
case ARM_LDAEXD:
case ARM_STLEXD: {
MCRegisterClass* MRC = MCRegisterInfo_getRegClass(MRI, ARM_GPRRegClassID);
bool isStore = Opcode == ARM_STREXD || Opcode == ARM_STLEXD;
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, isStore ? 1 : 0));
if (MCRegisterClass_contains(MRC, Reg)) {
MCInst NewMI;
MCInst_Init(&NewMI);
MCInst_setOpcode(&NewMI, Opcode);
if (isStore)
MCInst_addOperand2(&NewMI, MCInst_getOperand(MI, 0));
MCOperand_CreateReg0(&NewMI, MCRegisterInfo_getMatchingSuperReg(MRI, Reg, ARM_gsub_0,
MCRegisterInfo_getRegClass(MRI, ARM_GPRPairRegClassID)));
// Copy the rest operands into NewMI.
for(i = isStore ? 3 : 2; i < MCInst_getNumOperands(MI); ++i)
MCInst_addOperand2(&NewMI, MCInst_getOperand(MI, i));
printInstruction(&NewMI, O, MRI);
return;
}
}
}
//if (printAliasInstr(MI, O, MRI))
// printInstruction(MI, O, MRI);
printInstruction(MI, O, MRI);
}
static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
int32_t imm;
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned Reg = MCOperand_getReg(Op);
printRegName(MI->csh, O, Reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
if (MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base == ARM_REG_INVALID)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = Reg;
else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = Reg;
} else {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg;
MI->flat_insn->detail->arm.op_count++;
}
}
} else if (MCOperand_isImm(Op)) {
unsigned int opc = MCInst_getOpcode(MI);
imm = (int32_t)MCOperand_getImm(Op);
// relative branch only has relative offset, so we have to update it
// to reflect absolute address.
// Note: in ARM, PC is always 2 instructions ahead, so we have to
// add 8 in ARM mode, or 4 in Thumb mode
// printf(">> opcode: %u\n", MCInst_getOpcode(MI));
if (ARM_rel_branch(MI->csh, opc)) {
// only do this for relative branch
if (MI->csh->mode & CS_MODE_THUMB) {
imm += (int32_t)MI->address + 4;
if (ARM_blx_to_arm_mode(MI->csh, opc)) {
// here need to align down to the nearest 4-byte address
#define _ALIGN_DOWN(v, align_width) ((v/align_width)*align_width)
imm = _ALIGN_DOWN(imm, 4);
#undef _ALIGN_DOWN
}
} else {
imm += (int32_t)MI->address + 8;
}
if (imm >= 0) {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", imm);
else
SStream_concat(O, "#%u", imm);
} else {
SStream_concat(O, "#0x%x", imm);
}
} else {
switch(MI->flat_insn->id) {
default:
if (imm >= 0) {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", imm);
else
SStream_concat(O, "#%u", imm);
} else {
if (imm < -HEX_THRESHOLD)
SStream_concat(O, "#-0x%x", -imm);
else
SStream_concat(O, "#-%u", -imm);
}
break;
case ARM_INS_AND:
case ARM_INS_ORR:
case ARM_INS_EOR:
case ARM_INS_BIC:
// do not print number in negative form
if (imm >= 0 && imm <= HEX_THRESHOLD)
SStream_concat(O, "#%u", imm);
else
SStream_concat(O, "#0x%x", imm);
break;
}
}
if (MI->csh->detail) {
if (MI->csh->doing_mem)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = imm;
else {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = imm;
MI->flat_insn->detail->arm.op_count++;
}
}
}
}
static void printThumbLdrLabelOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
int32_t OffImm;
bool isSub;
SStream_concat0(O, "[pc, ");
OffImm = (int32_t)MCOperand_getImm(MO1);
isSub = OffImm < 0;
// Special value for #-0. All others are normal.
if (OffImm == INT32_MIN)
OffImm = 0;
if (isSub) {
SStream_concat(O, "#-0x%x", -OffImm);
} else {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", OffImm);
else
SStream_concat(O, "#%u", OffImm);
}
SStream_concat0(O, "]");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_MEM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = ARM_REG_PC;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = ARM_REG_INVALID;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.scale = 1;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = OffImm;
MI->flat_insn->detail->arm.op_count++;
}
}
// so_reg is a 4-operand unit corresponding to register forms of the A5.1
// "Addressing Mode 1 - Data-processing operands" forms. This includes:
// REG 0 0 - e.g. R5
// REG REG 0,SH_OPC - e.g. R5, ROR R3
// REG 0 IMM,SH_OPC - e.g. R5, LSL #3
static void printSORegRegOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
MCOperand *MO3 = MCInst_getOperand(MI, OpNum+2);
ARM_AM_ShiftOpc ShOpc;
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.type = (MCOperand_getImm(MO3) & 7) + ARM_SFT_ASR_REG - 1;
MI->flat_insn->detail->arm.op_count++;
}
// Print the shift opc.
ShOpc = ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO3));
SStream_concat0(O, ", ");
SStream_concat0(O, ARM_AM_getShiftOpcStr(ShOpc));
if (ShOpc == ARM_AM_rrx)
return;
SStream_concat0(O, " ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = MCOperand_getReg(MO2);
//assert(ARM_AM_getSORegOffset(MO3.getImm()) == 0);
}
static void printSORegImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.type = MCOperand_getImm(MO2) & 7;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.value = (unsigned int)MCOperand_getImm(MO2) >> 3;
MI->flat_insn->detail->arm.op_count++;
}
// Print the shift opc.
printRegImmShift(MI, O, ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2)),
getSORegOffset((unsigned int)MCOperand_getImm(MO2)));
}
//===--------------------------------------------------------------------===//
// Addressing Mode #2
//===--------------------------------------------------------------------===//
static void printAM2PreOrOffsetIndexOp(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op + 1);
MCOperand *MO3 = MCInst_getOperand(MI, Op + 2);
ARM_AM_AddrOpc subtracted = getAM2Op((unsigned int)MCOperand_getImm(MO3));
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
}
if (!MCOperand_getReg(MO2)) {
unsigned tmp = getAM2Offset((unsigned int)MCOperand_getImm(MO3));
if (tmp) { // Don't print +0.
subtracted = getAM2Op((unsigned int)MCOperand_getImm(MO3));
SStream_concat0(O, ", ");
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#%s0x%x", ARM_AM_getAddrOpcStr(subtracted), tmp);
else
SStream_concat(O, "#%s%u", ARM_AM_getAddrOpcStr(subtracted), tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.type = (arm_shifter)getAM2Op((unsigned int)MCOperand_getImm(MO3));
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.value = tmp;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = subtracted == ARM_AM_sub;
}
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
return;
}
SStream_concat0(O, ", ");
SStream_concat0(O, ARM_AM_getAddrOpcStr(subtracted));
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = MCOperand_getReg(MO2);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = subtracted == ARM_AM_sub;
}
printRegImmShift(MI, O, getAM2ShiftOpc((unsigned int)MCOperand_getImm(MO3)),
getAM2Offset((unsigned int)MCOperand_getImm(MO3)));
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printAddrModeTBB(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op+1);
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = MCOperand_getReg(MO2);
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printAddrModeTBH(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op+1);
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = MCOperand_getReg(MO2);
SStream_concat0(O, ", lsl #1]");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.type = ARM_SFT_LSL;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].shift.value = 1;
}
set_mem_access(MI, false);
}
static void printAddrMode2Operand(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, Op, O);
return;
}
printAM2PreOrOffsetIndexOp(MI, Op, O);
}
static void printAddrMode2OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
ARM_AM_AddrOpc subtracted = getAM2Op((unsigned int)MCOperand_getImm(MO2));
if (!MCOperand_getReg(MO1)) {
unsigned ImmOffs = getAM2Offset((unsigned int)MCOperand_getImm(MO2));
if (ImmOffs > HEX_THRESHOLD)
SStream_concat(O, "#%s0x%x",
ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
else
SStream_concat(O, "#%s%u",
ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = ImmOffs;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = subtracted == ARM_AM_sub;
MI->flat_insn->detail->arm.op_count++;
}
return;
}
SStream_concat0(O, ARM_AM_getAddrOpcStr(subtracted));
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = subtracted == ARM_AM_sub;
MI->flat_insn->detail->arm.op_count++;
}
printRegImmShift(MI, O, getAM2ShiftOpc((unsigned int)MCOperand_getImm(MO2)),
getAM2Offset((unsigned int)MCOperand_getImm(MO2)));
}
//===--------------------------------------------------------------------===//
// Addressing Mode #3
//===--------------------------------------------------------------------===//
static void printAM3PreOrOffsetIndexOp(MCInst *MI, unsigned Op, SStream *O,
bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op+1);
MCOperand *MO3 = MCInst_getOperand(MI, Op+2);
ARM_AM_AddrOpc subtracted = getAM3Op((unsigned int)MCOperand_getImm(MO3));
unsigned ImmOffs;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
if (MCOperand_getReg(MO2)) {
SStream_concat0(O, ", ");
SStream_concat0(O, ARM_AM_getAddrOpcStr(subtracted));
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = MCOperand_getReg(MO2);
if (subtracted) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.scale = -1;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = true;
}
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
return;
}
//If the op is sub we have to print the immediate even if it is 0
ImmOffs = getAM3Offset((unsigned int)MCOperand_getImm(MO3));
if (AlwaysPrintImm0 || ImmOffs || (subtracted == ARM_AM_sub)) {
if (ImmOffs > HEX_THRESHOLD)
SStream_concat(O, ", #%s0x%x", ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
else
SStream_concat(O, ", #%s%u", ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
}
if (MI->csh->detail) {
if (subtracted) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = (int)MCOperand_getImm(MO3);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = true;
} else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = (int)-MCOperand_getImm(MO3);
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printAddrMode3Operand(MCInst *MI, unsigned Op, SStream *O,
bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
if (!MCOperand_isReg(MO1)) { // For label symbolic references.
printOperand(MI, Op, O);
return;
}
printAM3PreOrOffsetIndexOp(MI, Op, O, AlwaysPrintImm0);
}
static void printAddrMode3OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
ARM_AM_AddrOpc subtracted = getAM3Op((unsigned int)MCOperand_getImm(MO2));
unsigned ImmOffs;
if (MCOperand_getReg(MO1)) {
SStream_concat0(O, ARM_AM_getAddrOpcStr(subtracted));
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = subtracted == ARM_AM_sub;
MI->flat_insn->detail->arm.op_count++;
}
return;
}
ImmOffs = getAM3Offset((unsigned int)MCOperand_getImm(MO2));
if (ImmOffs > HEX_THRESHOLD)
SStream_concat(O, "#%s0x%x", ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
else
SStream_concat(O, "#%s%u", ARM_AM_getAddrOpcStr(subtracted), ImmOffs);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
if (subtracted) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = ImmOffs;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].subtracted = true;
} else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = -(int)ImmOffs;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printPostIdxImm8Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
unsigned Imm = (unsigned int)MCOperand_getImm(MO);
if ((Imm & 0xff) > HEX_THRESHOLD)
SStream_concat(O, "#%s0x%x", ((Imm & 256) ? "" : "-"), (Imm & 0xff));
else
SStream_concat(O, "#%s%u", ((Imm & 256) ? "" : "-"), (Imm & 0xff));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = Imm & 0xff;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printPostIdxRegOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
SStream_concat0(O, (MCOperand_getImm(MO2) ? "" : "-"));
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.op_count++;
}
}
static void printPostIdxImm8s4Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
unsigned Imm = (unsigned int)MCOperand_getImm(MO);
if (((Imm & 0xff) << 2) > HEX_THRESHOLD)
SStream_concat(O, "#%s0x%x", ((Imm & 256) ? "" : "-"), ((Imm & 0xff) << 2));
else
SStream_concat(O, "#%s%u", ((Imm & 256) ? "" : "-"), ((Imm & 0xff) << 2));
}
static void printAddrMode5Operand(MCInst *MI, unsigned OpNum, SStream *O,
bool AlwaysPrintImm0)
{
unsigned ImmOffs;
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
ARM_AM_AddrOpc subtracted = ARM_AM_getAM5Op((unsigned int)MCOperand_getImm(MO2));
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, OpNum, O);
return;
}
SStream_concat0(O, "[");
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_MEM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = ARM_REG_INVALID;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.scale = 1;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = 0;
}
ImmOffs = ARM_AM_getAM5Offset((unsigned int)MCOperand_getImm(MO2));
if (AlwaysPrintImm0 || ImmOffs || subtracted == ARM_AM_sub) {
if (ImmOffs * 4 > HEX_THRESHOLD)
SStream_concat(O, ", #%s0x%x",
ARM_AM_getAddrOpcStr(subtracted),
ImmOffs * 4);
else
SStream_concat(O, ", #%s%u",
ARM_AM_getAddrOpcStr(subtracted),
ImmOffs * 4);
if (MI->csh->detail) {
if (subtracted)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = ImmOffs * 4;
else
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = -(int)ImmOffs * 4;
}
}
SStream_concat0(O, "]");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.op_count++;
}
}
static void printAddrMode6Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
unsigned tmp;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
tmp = (unsigned int)MCOperand_getImm(MO2);
if (tmp) {
if (tmp << 3 > HEX_THRESHOLD)
SStream_concat(O, ":0x%x", (tmp << 3));
else
SStream_concat(O, ":%u", (tmp << 3));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = tmp << 3;
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printAddrMode7Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printAddrMode6OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
if (MCOperand_getReg(MO) == 0)
SStream_concat0(O, "!");
else {
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO);
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printBitfieldInvMaskImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
uint32_t v = ~(uint32_t)MCOperand_getImm(MO);
int32_t lsb = CountTrailingZeros_32(v);
int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb;
//assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
if (lsb > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", lsb);
else
SStream_concat(O, "#%u", lsb);
if (width > HEX_THRESHOLD)
SStream_concat(O, ", #0x%x", width);
else
SStream_concat(O, ", #%u", width);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = lsb;
MI->flat_insn->detail->arm.op_count++;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = width;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printMemBOption(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned val = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat0(O, ARM_MB_MemBOptToString(val + 1,
(ARM_getFeatureBits(MI->csh->mode) & ARM_HasV8Ops)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.mem_barrier = (arm_mem_barrier)(val + 1);
}
}
void printInstSyncBOption(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned val = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat0(O, ARM_ISB_InstSyncBOptToString(val));
}
static void printShiftImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned ShiftOp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
bool isASR = (ShiftOp & (1 << 5)) != 0;
unsigned Amt = ShiftOp & 0x1f;
if (isASR) {
unsigned tmp = Amt == 0 ? 32 : Amt;
if (tmp > HEX_THRESHOLD)
SStream_concat(O, ", asr #0x%x", tmp);
else
SStream_concat(O, ", asr #%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_ASR;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = tmp;
}
} else if (Amt) {
if (Amt > HEX_THRESHOLD)
SStream_concat(O, ", lsl #0x%x", Amt);
else
SStream_concat(O, ", lsl #%u", Amt);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_LSL;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = Amt;
}
}
}
static void printPKHLSLShiftImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (Imm == 0)
return;
//assert(Imm > 0 && Imm < 32 && "Invalid PKH shift immediate value!");
if (Imm > HEX_THRESHOLD)
SStream_concat(O, ", lsl #0x%x", Imm);
else
SStream_concat(O, ", lsl #%u", Imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_LSL;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = Imm;
}
}
static void printPKHASRShiftImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
// A shift amount of 32 is encoded as 0.
if (Imm == 0)
Imm = 32;
//assert(Imm > 0 && Imm <= 32 && "Invalid PKH shift immediate value!");
if (Imm > HEX_THRESHOLD)
SStream_concat(O, ", asr #0x%x", Imm);
else
SStream_concat(O, ", asr #%u", Imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_ASR;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = Imm;
}
}
// FIXME: push {r1, r2, r3, ...} can exceed the number of operands in MCInst struct
static void printRegisterList(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned i, e;
SStream_concat0(O, "{");
for (i = OpNum, e = MCInst_getNumOperands(MI); i != e; ++i) {
if (i != OpNum) SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, i)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, i));
MI->flat_insn->detail->arm.op_count++;
}
}
SStream_concat0(O, "}");
}
static void printGPRPairOperand(MCInst *MI, unsigned OpNum, SStream *O,
MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
printRegName(MI->csh, O, MCRegisterInfo_getSubReg(MRI, Reg, ARM_gsub_0));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCRegisterInfo_getSubReg(MRI, Reg, ARM_gsub_0);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCRegisterInfo_getSubReg(MRI, Reg, ARM_gsub_1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCRegisterInfo_getSubReg(MRI, Reg, ARM_gsub_1);
MI->flat_insn->detail->arm.op_count++;
}
}
// SETEND BE/LE
static void printSetendOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
if (MCOperand_getImm(Op)) {
SStream_concat0(O, "be");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_SETEND;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].setend = ARM_SETEND_BE;
MI->flat_insn->detail->arm.op_count++;
}
} else {
SStream_concat0(O, "le");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_SETEND;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].setend = ARM_SETEND_LE;
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printCPSIMod(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
unsigned int mode = (unsigned int)MCOperand_getImm(Op);
SStream_concat0(O, ARM_PROC_IModToString(mode));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.cps_mode = mode;
}
}
static void printCPSIFlag(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
unsigned IFlags = (unsigned int)MCOperand_getImm(Op);
int i;
for (i = 2; i >= 0; --i)
if (IFlags & (1 << i)) {
SStream_concat0(O, ARM_PROC_IFlagsToString(1 << i));
}
if (IFlags == 0) {
SStream_concat0(O, "none");
IFlags = ARM_CPSFLAG_NONE;
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm.cps_flag = IFlags;
}
}
static void printMSRMaskOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
unsigned SpecRegRBit = (unsigned)MCOperand_getImm(Op) >> 4;
unsigned Mask = MCOperand_getImm(Op) & 0xf;
unsigned reg;
if (ARM_getFeatureBits(MI->csh->mode) & ARM_FeatureMClass) {
unsigned SYSm = (unsigned)MCOperand_getImm(Op);
unsigned Opcode = MCInst_getOpcode(MI);
// For reads of the special registers ignore the "mask encoding" bits
// which are only for writes.
if (Opcode == ARM_t2MRS_M)
SYSm &= 0xff;
switch (SYSm) {
default: //llvm_unreachable("Unexpected mask value!");
case 0:
case 0x800: SStream_concat0(O, "apsr"); ARM_addSysReg(MI, ARM_SYSREG_APSR); return; // with _nzcvq bits is an alias for aspr
case 0x400: SStream_concat0(O, "apsr_g"); ARM_addSysReg(MI, ARM_SYSREG_APSR_G); return;
case 0xc00: SStream_concat0(O, "apsr_nzcvqg"); ARM_addSysReg(MI, ARM_SYSREG_APSR_NZCVQG); return;
case 1:
case 0x801: SStream_concat0(O, "iapsr"); ARM_addSysReg(MI, ARM_SYSREG_IAPSR); return; // with _nzcvq bits is an alias for iapsr
case 0x401: SStream_concat0(O, "iapsr_g"); ARM_addSysReg(MI, ARM_SYSREG_IAPSR_G); return;
case 0xc01: SStream_concat0(O, "iapsr_nzcvqg"); ARM_addSysReg(MI, ARM_SYSREG_IAPSR_NZCVQG); return;
case 2:
case 0x802: SStream_concat0(O, "eapsr"); ARM_addSysReg(MI, ARM_SYSREG_EAPSR); return; // with _nzcvq bits is an alias for eapsr
case 0x402: SStream_concat0(O, "eapsr_g"); ARM_addSysReg(MI, ARM_SYSREG_EAPSR_G); return;
case 0xc02: SStream_concat0(O, "eapsr_nzcvqg"); ARM_addSysReg(MI, ARM_SYSREG_EAPSR_NZCVQG); return;
case 3:
case 0x803: SStream_concat0(O, "xpsr"); ARM_addSysReg(MI, ARM_SYSREG_XPSR); return; // with _nzcvq bits is an alias for xpsr
case 0x403: SStream_concat0(O, "xpsr_g"); ARM_addSysReg(MI, ARM_SYSREG_XPSR_G); return;
case 0xc03: SStream_concat0(O, "xpsr_nzcvqg"); ARM_addSysReg(MI, ARM_SYSREG_XPSR_NZCVQG); return;
case 5:
case 0x805: SStream_concat0(O, "ipsr"); ARM_addSysReg(MI, ARM_SYSREG_IPSR); return;
case 6:
case 0x806: SStream_concat0(O, "epsr"); ARM_addSysReg(MI, ARM_SYSREG_EPSR); return;
case 7:
case 0x807: SStream_concat0(O, "iepsr"); ARM_addSysReg(MI, ARM_SYSREG_IEPSR); return;
case 8:
case 0x808: SStream_concat0(O, "msp"); ARM_addSysReg(MI, ARM_SYSREG_MSP); return;
case 9:
case 0x809: SStream_concat0(O, "psp"); ARM_addSysReg(MI, ARM_SYSREG_PSP); return;
case 0x10:
case 0x810: SStream_concat0(O, "primask"); ARM_addSysReg(MI, ARM_SYSREG_PRIMASK); return;
case 0x11:
case 0x811: SStream_concat0(O, "basepri"); ARM_addSysReg(MI, ARM_SYSREG_BASEPRI); return;
case 0x12:
case 0x812: SStream_concat0(O, "basepri_max"); ARM_addSysReg(MI, ARM_SYSREG_BASEPRI_MAX); return;
case 0x13:
case 0x813: SStream_concat0(O, "faultmask"); ARM_addSysReg(MI, ARM_SYSREG_FAULTMASK); return;
case 0x14:
case 0x814: SStream_concat0(O, "control"); ARM_addSysReg(MI, ARM_SYSREG_CONTROL); return;
}
}
// As special cases, CPSR_f, CPSR_s and CPSR_fs prefer printing as
// APSR_nzcvq, APSR_g and APSRnzcvqg, respectively.
if (!SpecRegRBit && (Mask == 8 || Mask == 4 || Mask == 12)) {
SStream_concat0(O, "apsr_");
switch (Mask) {
default: // llvm_unreachable("Unexpected mask value!");
case 4: SStream_concat0(O, "g"); ARM_addSysReg(MI, ARM_SYSREG_APSR_G); return;
case 8: SStream_concat0(O, "nzcvq"); ARM_addSysReg(MI, ARM_SYSREG_APSR_NZCVQ); return;
case 12: SStream_concat0(O, "nzcvqg"); ARM_addSysReg(MI, ARM_SYSREG_APSR_NZCVQG); return;
}
}
reg = 0;
if (SpecRegRBit) {
SStream_concat0(O, "spsr");
if (Mask) {
SStream_concat0(O, "_");
if (Mask & 8) {
SStream_concat0(O, "f");
reg += ARM_SYSREG_SPSR_F;
}
if (Mask & 4) {
SStream_concat0(O, "s");
reg += ARM_SYSREG_SPSR_S;
}
if (Mask & 2) {
SStream_concat0(O, "x");
reg += ARM_SYSREG_SPSR_X;
}
if (Mask & 1) {
SStream_concat0(O, "c");
reg += ARM_SYSREG_SPSR_C;
}
ARM_addSysReg(MI, reg);
}
} else {
SStream_concat0(O, "cpsr");
if (Mask) {
SStream_concat0(O, "_");
if (Mask & 8) {
SStream_concat0(O, "f");
reg += ARM_SYSREG_CPSR_F;
}
if (Mask & 4) {
SStream_concat0(O, "s");
reg += ARM_SYSREG_CPSR_S;
}
if (Mask & 2) {
SStream_concat0(O, "x");
reg += ARM_SYSREG_CPSR_X;
}
if (Mask & 1) {
SStream_concat0(O, "c");
reg += ARM_SYSREG_CPSR_C;
}
ARM_addSysReg(MI, reg);
}
}
}
static void printPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
ARMCC_CondCodes CC = (ARMCC_CondCodes)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
// Handle the undefined 15 CC value here for printing so we don't abort().
if ((unsigned)CC == 15) {
SStream_concat0(O, "<und>");
if (MI->csh->detail)
MI->flat_insn->detail->arm.cc = ARM_CC_INVALID;
} else {
if (CC != ARMCC_AL) {
SStream_concat0(O, ARMCC_ARMCondCodeToString(CC));
}
if (MI->csh->detail)
MI->flat_insn->detail->arm.cc = CC + 1;
}
}
// TODO: test this
static void printMandatoryPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
ARMCC_CondCodes CC = (ARMCC_CondCodes)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat0(O, ARMCC_ARMCondCodeToString(CC));
if (MI->csh->detail)
MI->flat_insn->detail->arm.cc = CC + 1;
}
static void printSBitModifierOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
if (MCOperand_getReg(MCInst_getOperand(MI, OpNum))) {
//assert(MCOperand_getReg(MCInst_getOperand(MI, OpNum)) == ARM_CPSR &&
// "Expect ARM CPSR register!");
SStream_concat0(O, "s");
if (MI->csh->detail)
MI->flat_insn->detail->arm.update_flags = true;
}
}
static void printNoHashImmediate(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "0x%x", tmp);
else
SStream_concat(O, "%u", tmp);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = tmp;
} else {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printPImmediate(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat(O, "p%u", imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_PIMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = imm;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printCImmediate(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat(O, "c%u", imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_CIMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = imm;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printCoprocOptionImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "{0x%x}", tmp);
else
SStream_concat(O, "{%u}", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printAdrLabelOperand(MCInst *MI, unsigned OpNum, SStream *O, unsigned scale)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
int32_t OffImm = (int32_t)MCOperand_getImm(MO) << scale;
if (OffImm == INT32_MIN) {
SStream_concat0(O, "#-0");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = 0;
MI->flat_insn->detail->arm.op_count++;
}
} else {
if (OffImm < 0)
SStream_concat(O, "#-0x%x", -OffImm);
else {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", OffImm);
else
SStream_concat(O, "#%u", OffImm);
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = OffImm;
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printThumbS4ImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum)) * 4;
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printThumbSRImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
unsigned tmp = Imm == 0 ? 32 : Imm;
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printThumbITMask(MCInst *MI, unsigned OpNum, SStream *O)
{
// (3 - the number of trailing zeros) is the number of then / else.
unsigned Mask = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
unsigned Firstcond = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum-1));
unsigned CondBit0 = Firstcond & 1;
unsigned NumTZ = CountTrailingZeros_32(Mask);
//assert(NumTZ <= 3 && "Invalid IT mask!");
unsigned Pos, e;
for (Pos = 3, e = NumTZ; Pos > e; --Pos) {
bool T = ((Mask >> Pos) & 1) == CondBit0;
if (T)
SStream_concat0(O, "t");
else
SStream_concat0(O, "e");
}
}
static void printThumbAddrModeRROperand(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op + 1);
unsigned RegNum;
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, Op, O);
return;
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
RegNum = MCOperand_getReg(MO2);
if (RegNum) {
SStream_concat0(O, ", ");
printRegName(MI->csh, O, RegNum);
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = RegNum;
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printThumbAddrModeImm5SOperand(MCInst *MI, unsigned Op, SStream *O,
unsigned Scale)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op + 1);
unsigned ImmOffs, tmp;
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, Op, O);
return;
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
ImmOffs = (unsigned int)MCOperand_getImm(MO2);
if (ImmOffs) {
tmp = ImmOffs * Scale;
SStream_concat0(O, ", ");
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = tmp;
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printThumbAddrModeImm5S1Operand(MCInst *MI, unsigned Op, SStream *O)
{
printThumbAddrModeImm5SOperand(MI, Op, O, 1);
}
static void printThumbAddrModeImm5S2Operand(MCInst *MI, unsigned Op, SStream *O)
{
printThumbAddrModeImm5SOperand(MI, Op, O, 2);
}
static void printThumbAddrModeImm5S4Operand(MCInst *MI, unsigned Op, SStream *O)
{
printThumbAddrModeImm5SOperand(MI, Op, O, 4);
}
static void printThumbAddrModeSPOperand(MCInst *MI, unsigned Op, SStream *O)
{
printThumbAddrModeImm5SOperand(MI, Op, O, 4);
}
// Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
// register with shift forms.
// REG 0 0 - e.g. R5
// REG IMM, SH_OPC - e.g. R5, LSL #3
static void printT2SOOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
unsigned Reg = MCOperand_getReg(MO1);
printRegName(MI->csh, O, Reg);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg;
MI->flat_insn->detail->arm.op_count++;
}
// Print the shift opc.
//assert(MO2.isImm() && "Not a valid t2_so_reg value!");
printRegImmShift(MI, O, ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2)),
getSORegOffset((unsigned int)MCOperand_getImm(MO2)));
}
static void printAddrModeImm12Operand(MCInst *MI, unsigned OpNum,
SStream *O, bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
int32_t OffImm;
bool isSub;
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, OpNum, O);
return;
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
OffImm = (int32_t)MCOperand_getImm(MO2);
isSub = OffImm < 0;
// Special value for #-0. All others are normal.
if (OffImm == INT32_MIN)
OffImm = 0;
if (isSub) {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, ", #-0x%x", -OffImm);
else
SStream_concat(O, ", #-%u", -OffImm);
} else if (AlwaysPrintImm0 || OffImm > 0) {
if (OffImm >= 0) {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, ", #0x%x", OffImm);
else
SStream_concat(O, ", #%u", OffImm);
} else {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, ", #-0x%x", -OffImm);
else
SStream_concat(O, ", #-%u", -OffImm);
}
}
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = OffImm;
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printT2AddrModeImm8Operand(MCInst *MI, unsigned OpNum, SStream *O,
bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
int32_t OffImm;
bool isSub;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
OffImm = (int32_t)MCOperand_getImm(MO2);
isSub = OffImm < 0;
// Don't print +0.
if (OffImm == INT32_MIN)
OffImm = 0;
if (isSub)
SStream_concat(O, ", #-0x%x", -OffImm);
else if (AlwaysPrintImm0 || OffImm > 0) {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, ", #0x%x", OffImm);
else
SStream_concat(O, ", #%u", OffImm);
}
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = OffImm;
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printT2AddrModeImm8s4Operand(MCInst *MI,
unsigned OpNum, SStream *O, bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
int32_t OffImm;
bool isSub;
if (!MCOperand_isReg(MO1)) { // For label symbolic references.
printOperand(MI, OpNum, O);
return;
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
OffImm = (int32_t)MCOperand_getImm(MO2);
isSub = OffImm < 0;
//assert(((OffImm & 0x3) == 0) && "Not a valid immediate!");
// Don't print +0.
if (OffImm == INT32_MIN)
OffImm = 0;
if (isSub) {
SStream_concat(O, ", #-0x%x", -OffImm);
} else if (AlwaysPrintImm0 || OffImm > 0) {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, ", #0x%x", OffImm);
else
SStream_concat(O, ", #%u", OffImm);
}
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = OffImm;
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printT2AddrModeImm0_1020s4Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
unsigned tmp;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
if (MCOperand_getImm(MO2)) {
SStream_concat0(O, ", ");
tmp = (unsigned int)MCOperand_getImm(MO2) * 4;
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = tmp;
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printT2AddrModeImm8OffsetOperand(MCInst *MI,
unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
int32_t OffImm = (int32_t)MCOperand_getImm(MO1);
SStream_concat0(O, ", ");
if (OffImm == INT32_MIN) {
SStream_concat0(O, "#-0");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = 0;
MI->flat_insn->detail->arm.op_count++;
}
} else {
if (OffImm < 0) {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, "#-0x%x", -OffImm);
else
SStream_concat(O, "#-%u", -OffImm);
} else {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", OffImm);
else
SStream_concat(O, "#%u", OffImm);
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = OffImm;
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printT2AddrModeImm8s4OffsetOperand(MCInst *MI,
unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
int32_t OffImm = (int32_t)MCOperand_getImm(MO1);
//assert(((OffImm & 0x3) == 0) && "Not a valid immediate!");
SStream_concat0(O, ", ");
if (OffImm == INT32_MIN) {
SStream_concat0(O, "#-0");
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = 0;
MI->flat_insn->detail->arm.op_count++;
}
} else {
if (OffImm < 0) {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, "#-0x%x", -OffImm);
else
SStream_concat(O, "#-%u", -OffImm);
} else {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", OffImm);
else
SStream_concat(O, "#%u", OffImm);
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = OffImm;
MI->flat_insn->detail->arm.op_count++;
}
}
}
static void printT2AddrModeSoRegOperand(MCInst *MI,
unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
MCOperand *MO3 = MCInst_getOperand(MI, OpNum+2);
unsigned ShAmt;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
//assert(MCOperand_getReg(MO2.getReg() && "Invalid so_reg load / store address!");
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.index = MCOperand_getReg(MO2);
ShAmt = (unsigned int)MCOperand_getImm(MO3);
if (ShAmt) {
//assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
SStream_concat0(O, ", lsl ");
SStream_concat(O, "#%d", ShAmt);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_LSL;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = ShAmt;
}
}
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printFPImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO = MCInst_getOperand(MI, OpNum);
SStream_concat(O, "#%e", getFPImmFloat((unsigned int)MCOperand_getImm(MO)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_FP;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].fp = getFPImmFloat((unsigned int)MCOperand_getImm(MO));
MI->flat_insn->detail->arm.op_count++;
}
}
static void printNEONModImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned EncodedImm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
unsigned EltBits;
uint64_t Val = ARM_AM_decodeNEONModImm(EncodedImm, &EltBits);
if (Val > HEX_THRESHOLD)
SStream_concat(O, "#0x%"PRIx64, Val);
else
SStream_concat(O, "#%"PRIu64, Val);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = (unsigned int)Val;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printImmPlusOneOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (Imm + 1 > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", Imm + 1);
else
SStream_concat(O, "#%u", Imm + 1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = Imm + 1;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printRotImmOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (Imm == 0)
return;
SStream_concat0(O, ", ror #");
switch (Imm) {
default: //assert (0 && "illegal ror immediate!");
case 1: SStream_concat0(O, "8"); break;
case 2: SStream_concat0(O, "16"); break;
case 3: SStream_concat0(O, "24"); break;
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type = ARM_SFT_ROR;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = Imm * 8;
}
}
static void printFBits16(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp;
tmp = 16 - (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printFBits32(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp;
tmp = 32 - (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
}
static void printVectorIndex(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "[0x%x]",tmp);
else
SStream_concat(O, "[%u]",tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].vector_index = tmp;
}
}
static void printVectorListOne(MCInst *MI, unsigned OpNum, SStream *O)
{
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListTwo(MCInst *MI, unsigned OpNum,
SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_1);
SStream_concat0(O, "{");
printRegName(MI->csh, O, Reg0);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg0;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, Reg1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListTwoSpaced(MCInst *MI, unsigned OpNum,
SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_2);
SStream_concat0(O, "{");
printRegName(MI->csh, O, Reg0);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg0;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, Reg1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListThree(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListFour(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 3);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 3;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListOneAllLanes(MCInst *MI, unsigned OpNum, SStream *O)
{
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListTwoAllLanes(MCInst *MI, unsigned OpNum,
SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_1);
SStream_concat0(O, "{");
printRegName(MI->csh, O, Reg0);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg0;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, Reg1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListThreeAllLanes(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListFourAllLanes(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 3);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 3;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListTwoSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_2);
SStream_concat0(O, "{");
printRegName(MI->csh, O, Reg0);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg0;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, Reg1);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = Reg1;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListThreeSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListFourSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[], ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 6);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 6;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "[]}");
}
static void printVectorListThreeSpaced(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
static void printVectorListFourSpaced(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 2;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 4;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 6);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum)) + 6;
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
}
void ARM_addVectorDataType(MCInst *MI, arm_vectordata_type vd)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.vector_data = vd;
}
}
void ARM_addVectorDataSize(MCInst *MI, int size)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.vector_size = size;
}
}
void ARM_addReg(MCInst *MI, int reg)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = reg;
MI->flat_insn->detail->arm.op_count++;
}
}
void ARM_addUserMode(MCInst *MI)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.usermode = true;
}
}
void ARM_addSysReg(MCInst *MI, arm_sysreg reg)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_SYSREG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = reg;
MI->flat_insn->detail->arm.op_count++;
}
}
#endif
|
the_stack_data/28262659.c
|
#include <stdlib.h>
#define LEN(a) (sizeof(a) / sizeof((a)[0]))
/* sorted list of characters that can be shaped */
static struct achar {
unsigned c; /* utf-8 code */
unsigned s; /* single form */
unsigned i; /* initial form */
unsigned m; /* medial form */
unsigned f; /* final form */
} achars[] = {
{0x0621, 0xfe80}, /* hamza */
{0x0622, 0xfe81, 0, 0, 0xfe82}, /* alef madda */
{0x0623, 0xfe83, 0, 0, 0xfe84}, /* alef hamza above */
{0x0624, 0xfe85, 0, 0, 0xfe86}, /* waw hamza */
{0x0625, 0xfe87, 0, 0, 0xfe88}, /* alef hamza below */
{0x0626, 0xfe89, 0xfe8b, 0xfe8c, 0xfe8a}, /* yeh hamza */
{0x0627, 0xfe8d, 0, 0, 0xfe8e}, /* alef */
{0x0628, 0xfe8f, 0xfe91, 0xfe92, 0xfe90}, /* beh */
{0x0629, 0xfe93, 0, 0, 0xfe94}, /* teh marbuta */
{0x062a, 0xfe95, 0xfe97, 0xfe98, 0xfe96}, /* teh */
{0x062b, 0xfe99, 0xfe9b, 0xfe9c, 0xfe9a}, /* theh */
{0x062c, 0xfe9d, 0xfe9f, 0xfea0, 0xfe9e}, /* jeem */
{0x062d, 0xfea1, 0xfea3, 0xfea4, 0xfea2}, /* hah */
{0x062e, 0xfea5, 0xfea7, 0xfea8, 0xfea6}, /* khah */
{0x062f, 0xfea9, 0, 0, 0xfeaa}, /* dal */
{0x0630, 0xfeab, 0, 0, 0xfeac}, /* thal */
{0x0631, 0xfead, 0, 0, 0xfeae}, /* reh */
{0x0632, 0xfeaf, 0, 0, 0xfeb0}, /* zain */
{0x0633, 0xfeb1, 0xfeb3, 0xfeb4, 0xfeb2}, /* seen */
{0x0634, 0xfeb5, 0xfeb7, 0xfeb8, 0xfeb6}, /* sheen */
{0x0635, 0xfeb9, 0xfebb, 0xfebc, 0xfeba}, /* sad */
{0x0636, 0xfebd, 0xfebf, 0xfec0, 0xfebe}, /* dad */
{0x0637, 0xfec1, 0xfec3, 0xfec4, 0xfec2}, /* tah */
{0x0638, 0xfec5, 0xfec7, 0xfec8, 0xfec6}, /* zah */
{0x0639, 0xfec9, 0xfecb, 0xfecc, 0xfeca}, /* ain */
{0x063a, 0xfecd, 0xfecf, 0xfed0, 0xfece}, /* ghain */
{0x0640, 0x640, 0x640, 0x640}, /* tatweel */
{0x0641, 0xfed1, 0xfed3, 0xfed4, 0xfed2}, /* feh */
{0x0642, 0xfed5, 0xfed7, 0xfed8, 0xfed6}, /* qaf */
{0x0643, 0xfed9, 0xfedb, 0xfedc, 0xfeda}, /* kaf */
{0x0644, 0xfedd, 0xfedf, 0xfee0, 0xfede}, /* lam */
{0x0645, 0xfee1, 0xfee3, 0xfee4, 0xfee2}, /* meem */
{0x0646, 0xfee5, 0xfee7, 0xfee8, 0xfee6}, /* noon */
{0x0647, 0xfee9, 0xfeeb, 0xfeec, 0xfeea}, /* heh */
{0x0648, 0xfeed, 0, 0, 0xfeee}, /* waw */
{0x0649, 0xfeef, 0, 0, 0xfef0}, /* alef maksura */
{0x064a, 0xfef1, 0xfef3, 0xfef4, 0xfef2}, /* yeh */
{0x067e, 0xfb56, 0xfb58, 0xfb59, 0xfb57}, /* peh */
{0x0686, 0xfb7a, 0xfb7c, 0xfb7d, 0xfb7b}, /* tcheh */
{0x0698, 0xfb8a, 0, 0, 0xfb8b}, /* jeh */
{0x06a9, 0xfb8e, 0xfb90, 0xfb91, 0xfb8f}, /* fkaf */
{0x06af, 0xfb92, 0xfb94, 0xfb95, 0xfb93}, /* gaf */
{0x06cc, 0xfbfc, 0xfbfe, 0xfbff, 0xfbfd}, /* fyeh */
{0x200c}, /* ZWNJ */
{0x200d, 0, 0x200d, 0x200d}, /* ZWJ */
};
static struct achar *find_achar(int c)
{
int h, m, l;
h = LEN(achars);
l = 0;
/* using binary search to find c */
while (l < h) {
m = (h + l) >> 1;
if (achars[m].c == c)
return &achars[m];
if (c < achars[m].c)
h = m;
else
l = m + 1;
}
return NULL;
}
static int can_join(int c1, int c2)
{
struct achar *a1 = find_achar(c1);
struct achar *a2 = find_achar(c2);
return a1 && a2 && (a1->i || a1->m) && (a2->f || a2->m);
}
int uc_shape(int cur, int prev, int next)
{
int c = cur;
int join_prev, join_next;
struct achar *ac = find_achar(c);
if (!ac) /* ignore non-Arabic characters */
return c;
join_prev = can_join(prev, c);
join_next = can_join(c, next);
if (join_prev && join_next)
c = ac->m;
if (join_prev && !join_next)
c = ac->f;
if (!join_prev && join_next)
c = ac->i;
if (!join_prev && !join_next)
c = ac->c; /* some fonts do not have a glyph for ac->s */
return c ? c : cur;
}
/*
* return nonzero for Arabic combining characters
*
* The standard Arabic diacritics:
* + 0x064b: fathatan
* + 0x064c: dammatan
* + 0x064d: kasratan
* + 0x064e: fatha
* + 0x064f: damma
* + 0x0650: kasra
* + 0x0651: shadda
* + 0x0652: sukun
* + 0x0653: madda above
* + 0x0654: hamza above
* + 0x0655: hamza below
* + 0x0670: superscript alef
*/
int uc_comb(int c)
{
return (c >= 0x064b && c <= 0x0655) || /* the standard diacritics */
(c >= 0xfc5e && c <= 0xfc63) || /* shadda ligatures */
c == 0x0670; /* superscript alef */
}
int uc_lig2(int a1, int a2)
{
if (a1 == 0xfedf && a2 == 0xfe8e) /* lam alef isolated */
return 0xfefb;
if (a1 == 0xfee0 && a2 == 0xfe8e) /* lam alef final */
return 0xfefc;
if (a1 == 0x0651 && a2 == 0x064c) /* shadda dammatan */
return 0xfc5e;
if (a1 == 0x0651 && a2 == 0x064d) /* shadda kasratan */
return 0xfc5f;
if (a1 == 0x0651 && a2 == 0x064e) /* shadda fatha */
return 0xfc60;
if (a1 == 0x0651 && a2 == 0x064f) /* shadda damma */
return 0xfc61;
if (a1 == 0x0651 && a2 == 0x0650) /* shadda kasra */
return 0xfc62;
return 0;
}
int uc_lig3(int a1, int a2, int a3)
{
if (a1 == 0xfedf && a3 == 0xfe8e) { /* lam alef isolated */
if (a2 == 0x0653)
return 0xfef5;
if (a2 == 0x0654)
return 0xfef7;
if (a2 == 0x0655)
return 0xfef9;
}
if (a1 == 0xfee0 && a3 == 0xfe8e) { /* lam alef final */
if (a2 == 0x0653)
return 0xfef6;
if (a2 == 0x0654)
return 0xfef8;
if (a2 == 0x0655)
return 0xfefa;
}
return 0;
}
/* return the length of the ligature in src; writes the ligature to dst */
int uc_lig(int *dst, int *src)
{
if (src[1] && uc_lig2(src[0], src[1])) {
*dst = uc_lig2(src[0], src[1]);
return 2;
}
if (src[1] && src[2] && uc_lig3(src[0], src[1], src[2])) {
*dst = uc_lig3(src[0], src[1], src[2]);
return 3;
}
return 0;
}
|
the_stack_data/36075019.c
|
/* $title: 'LFIN.C ===== Insert all line feeds to file =====' */
/* $subtitle: 'Elipse Ltd. [jms] Revised: 1996 Oct 30' */
#include <stdio.h>
int main( int argc, const char *argv[] );
int lfout( const char *namein, const char *nameout );
void fcopy( FILE *fin, FILE *fout );
/* MAIN ===== Starting point ===== $pageif:6 */
int main( int argc, const char *argv[] )
{ /* main */
fprintf( stderr, "\nLFIN: Insert line feeds\n" );
if (argc < 3)
{
fprintf( stderr, "\nMust name input and output files\n" );
return 1;
}
return lfout( argv[1], argv[2] );
} /* main */
/* LFOUT ===== Body of program ===== $pageif:6 */
int lfout( const char *namein, const char *nameout )
{ /* lfout */
FILE *from, *to;
if ((from = fopen( namein, "rb" )) == NULL)
{
fprintf( stderr, "\nCannot open input file: %s\n", namein );
return 2;
}
if ((to = fopen( nameout, "wb" )) == NULL)
{
fprintf( stderr, "\nCannot open output file: %s\n", nameout );
return 3;
}
fcopy( from, to );
fclose( to );
fclose( from );
return 0; /* success */
} /* lfout */
/* FCOPY ===== Actual byte copy loop ===== $pageif:6 */
void fcopy( FILE *fin, FILE *fout )
{ /* fcopy */
int ch;
while ((ch = getc( fin )) != EOF)
{
putc( ch, fout );
if (ch == '\r')
putc( '\n', fout );
}
} /* fcopy */
|
the_stack_data/212644300.c
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
|
the_stack_data/396700.c
|
/* Copyright (C) 1995, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <[email protected]>, August 1995.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
/* Dong Xie 2012-05-08, modified for Windows use
be careful about #include "stdlib.h", Windows has its own header
*/
#include "stdlib.h"
#include <limits.h>
int
__srand48_r (seedval, buffer)
long int seedval;
struct drand48_data *buffer;
{
/* The standards say we only have 32 bits. */
if (sizeof (long int) > 4)
seedval &= 0xffffffffl;
buffer->__x[2] = seedval >> 16;
buffer->__x[1] = seedval & 0xffffl;
buffer->__x[0] = 0x330e;
buffer->__a = 0x5deece66dull;
buffer->__c = 0xb;
buffer->__init = 1;
return 0;
}
/*Dong Xie, MSC does not support weak_alias as GCC*/
int
srand48_r (seedval, buffer)
long int seedval;
struct drand48_data *buffer;
{
/* The standards say we only have 32 bits. */
if (sizeof (long int) > 4)
seedval &= 0xffffffffl;
buffer->__x[2] = seedval >> 16;
buffer->__x[1] = seedval & 0xffffl;
buffer->__x[0] = 0x330e;
buffer->__a = 0x5deece66dull;
buffer->__c = 0xb;
buffer->__init = 1;
return 0;
}
|
the_stack_data/14200605.c
|
/********************************************************************
* File : sat_bp.c
* Author : Neng-Fa ZHOU Copyright (C) 1994-2021
* Purpose: interface between B-Prolog and GLPK
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
********************************************************************/
#include <stdlib.h>
#ifdef GLPK
#include "glpk.h"
#include "bprolog.h"
extern double floatval();
#define GLP_SET_OBJ_COEF(lp, i, Pval, deft) { \
if (ISREF(Pval)) { \
glp_set_obj_coef(lp, i, deft); \
} else if (ISINT(Pval)) { \
glp_set_obj_coef(lp, i, (double)INTVAL(Pval)); \
} else { \
glp_set_obj_coef(lp, i, floatval(Pval)); \
} \
}
#define GLP_SET_COL_BOUNDS(lp, i, lower, upper) { \
if (ISREF(lower)) { \
dob_val = 0.0; \
} else if (ISINT(lower)) { \
dob_val = (double)INTVAL(lower); \
} else { \
dob_val = floatval(lower); \
}; \
if (ISREF(upper)) { \
glp_set_col_bnds(lp, i, GLP_LO, dob_val, 0.0); \
} else if (ISINT(upper)) { \
glp_set_col_bnds(lp, i, GLP_DB, dob_val, (double)INTVAL(upper)); \
} else { \
glp_set_col_bnds(lp, i, GLP_DB, dob_val, floatval(upper)); \
} \
}
#define FREE_IF_NOT_NULL(ptr) if (ptr != NULL) free(ptr)
#define RELEASE_SOL_SPACE { \
FREE_IF_NOT_NULL(x); \
}
#define RELEASE_PROB_SPACE { \
FREE_IF_NOT_NULL(rn); \
FREE_IF_NOT_NULL(cn); \
FREE_IF_NOT_NULL(rmatval); \
}
int glpk_error(error_msg)
char *error_msg;
{
fprintf(stderr, "GLPK ERROR: %s\n ", error_msg);
return BP_FALSE;
}
void dummy_print(const char *fmt, ...) {};
int c_lp_solve() {
BPLONG NCols, NRows, NNZs, VarAttrs, ObjVector, ObjSense, Constrs, Sol;
BPLONG_PTR top, ptr;
BPLONG temp, lst;
glp_prob *lp;
int i, j, row;
int status;
int is_mip = 0;
int *rn, *cn;
double *rmatval, *x;
double dob_val;
NCols = ARG(1, 8); DEREF_NONVAR(NCols); NCols = INTVAL(NCols);
NRows = ARG(2, 8); DEREF_NONVAR(NRows); NRows = INTVAL(NRows);
NNZs = ARG(3, 8); DEREF_NONVAR(NNZs); NNZs = INTVAL(NNZs);
VarAttrs = ARG(4, 8); DEREF_NONVAR(VarAttrs);
ObjVector = ARG(5, 8); DEREF_NONVAR(ObjVector);
ObjSense = ARG(6, 8); DEREF_NONVAR(ObjSense); ObjSense = INTVAL(ObjSense);
Constrs = ARG(7, 8); DEREF_NONVAR(Constrs);
Sol = ARG(8, 8);
/* Create the problem. */
lp = glp_create_prob();
if ( lp == NULL ) {
return glpk_error("lpx_create_prob()");
}
rn = (int *)malloc(sizeof(int)*(NNZs+1));
cn = (int *)malloc(sizeof(int)*(NNZs+1));
rmatval = (double *)malloc(sizeof(double)*(NNZs+1));
if (rn == NULL ||
cn == NULL ||
rmatval == NULL) {
RELEASE_PROB_SPACE;
return glpk_error("No enough memory (GLPK)");
}
glp_add_rows(lp, NRows);
glp_add_cols(lp, NCols);
if (ObjSense == 0)
glp_set_obj_dir(lp, GLP_MIN);
else
glp_set_obj_dir(lp, GLP_MAX);
/* coefficients of the objective expression */
// printf("ObjSense=%d\n",ObjSense);
// write_term(ObjVector);
ptr = (BPLONG_PTR)UNTAGGED_ADDR(ObjVector);
for (i = 1; i <= NCols; i++) {
temp = FOLLOW(ptr+i);
DEREF(temp);
GLP_SET_OBJ_COEF(lp, i, temp, 0.0);
// printf("obj[%d]=",i);write_term(temp);printf("\n");
}
/* lower and upper bounds */
i = 1;
lst = VarAttrs;
while (ISLIST(lst)) {
BPLONG lower, upper, VarAttr, varType;
ptr = (BPLONG_PTR)UNTAGGED_ADDR(lst);
VarAttr = FOLLOW(ptr); DEREF_NONVAR(VarAttr);
lst = FOLLOW(ptr+1); DEREF_NONVAR(lst);
ptr = (BPLONG_PTR)UNTAGGED_ADDR(VarAttr); /* $cplex_x(ColNo,Type,L,U,Constrs) */
lower = FOLLOW(ptr+3); DEREF(lower);
upper = FOLLOW(ptr+4); DEREF(upper);
GLP_SET_COL_BOUNDS(lp, i, lower, upper);
// printf("col[%d] ",i); write_term(lower); printf(" "); write_term(upper); printf("\n");
varType = FOLLOW(ptr+2); DEREF(varType);
if (!ISREF(varType)) {
is_mip = 1;
}
i++;
}
if (is_mip) {
/* lpx_set_class(lp,GLP_MIP); */
i = 1;
lst = VarAttrs;
while (ISLIST(lst)) {
BPLONG VarAttr, varType;
ptr = (BPLONG_PTR)UNTAGGED_ADDR(lst);
VarAttr = FOLLOW(ptr); DEREF_NONVAR(VarAttr);
lst = FOLLOW(ptr+1); DEREF_NONVAR(lst);
ptr = (BPLONG_PTR)UNTAGGED_ADDR(VarAttr); /* $cplex_x(ColNo,Type,L,U,Constrs) */
varType = FOLLOW(ptr+2); DEREF(varType);
if (!ISREF(varType)) {
glp_set_col_kind(lp, i, GLP_IV);
}
i++;
}
}
/*
printf("constrs:");
write_term(Constrs);
printf("\n");
*/
/* Now add the constraints */
i = 1; /* next nonzero to be put at index i */
row = 1; /* the current row number */
while (ISLIST(Constrs)) {
BPLONG CoeCols, Constr, Const, Coe, Col, ConstrType, pair;
ptr = (BPLONG_PTR)UNTAGGED_ADDR(Constrs);
Constr = FOLLOW(ptr); DEREF_NONVAR(Constr);
// printf("constr:"); write_term(Constr); printf("\n");
Constrs = FOLLOW(ptr+1); DEREF_NONVAR(Constrs);
ptr = (BPLONG_PTR)UNTAGGED_ADDR(Constr); /* $cplex_c(NNZs,CoeCols,Const,ConstrType) */
CoeCols = FOLLOW(ptr+2); DEREF_NONVAR(CoeCols);
Const = FOLLOW(ptr+3); DEREF_NONVAR(Const);
ConstrType = FOLLOW(ptr+4); DEREF_NONVAR(ConstrType); ConstrType = INTVAL(ConstrType);
dob_val = (ISINT(Const)) ? (double)INTVAL(Const) : floatval(Const);
if (ConstrType == 0)
glp_set_row_bnds(lp, row, GLP_FX, dob_val, dob_val);
else
glp_set_row_bnds(lp, row, GLP_UP, 0.0, dob_val);
while (ISLIST(CoeCols)) { /* [(Coe1,Col1),...,(ColN,ColN)] */
ptr = (BPLONG_PTR)UNTAGGED_ADDR(CoeCols);
pair = FOLLOW(ptr); DEREF_NONVAR(pair);
CoeCols = FOLLOW(ptr+1); DEREF_NONVAR(CoeCols);
ptr = (BPLONG_PTR)UNTAGGED_ADDR(pair); /* (Coe,Col) */
Col = FOLLOW(ptr+2); DEREF_NONVAR(Col);
rn[i] = row; cn[i] = (INTVAL(Col)+1);
Coe = FOLLOW(ptr+1); DEREF_NONVAR(Coe);
dob_val = (ISINT(Coe)) ? (double)INTVAL(Coe) : floatval(Coe);
rmatval[i] = -dob_val;
i++;
}
row++;
}
/*
printf("lp=%x\n",lp);
for (i=1;i<=NNZs;i++){
printf("rn[%d]=%d\n",i,rn[i]);
printf("cn[%d]=%d\n",i,cn[i]);
printf("a[%d]=%f\n",i,rmatval[i]);
}
*/
glp_load_matrix(lp, NNZs, rn, cn, rmatval);
// printf("=>simplex\n");
status = lpx_simplex(lp);
if (status != LPX_E_OK) goto exit_glpk;
if (is_mip) {
status = lpx_integer(lp);
}
exit_glpk:
// printf("exit status = %d\n",status);
if (status != LPX_E_OK) {
RELEASE_PROB_SPACE;
switch (status) {
case LPX_E_FAULT:
return glpk_error("unable to start search");
case LPX_E_OBJLL:
case LPX_E_OBJUL:
return glpk_error("the objective function has reached its limit");
case LPX_E_ITLIM:
return glpk_error("Simplex has reached its iterations limit");
case LPX_E_TMLIM:
return glpk_error("Time limit has been reached");
default:
// return glpk_error("solver failure");
return BP_FALSE;
}
}
x = (double *) malloc (NCols * sizeof(double));
if ( x == NULL) {
RELEASE_PROB_SPACE;
return glpk_error("No enough memory (GLPK)");
}
lst = nil_sym;
for (j = NCols; j >= 1; j--) {
BPLONG int_val;
if (lpx_get_col_kind(lp, j) == LPX_CV) {
dob_val = glp_get_col_prim(lp, j);
temp = encodefloat1(dob_val);
} else {
int_val = lpx_mip_col_val(lp, j);
temp = MAKEINT(int_val);
}
FOLLOW(heap_top) = temp;
FOLLOW(heap_top+1) = lst;
lst = ADDTAG(heap_top, LST);
heap_top += 2;
}
/* write_term(lst); */
unify(lst, Sol);
RELEASE_PROB_SPACE;
RELEASE_SOL_SPACE;
glp_delete_prob(lp);
return BP_TRUE;
}
void Cboot_glpk() {
insert_cpred("c_lp_solve", 8, c_lp_solve);
}
#endif
|
the_stack_data/36074391.c
|
/*-------------------------------------------------------------------------
*
* cstatistic.c
*
* Statistics for vDriver & vanilla Implementation
*
*
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/backend/storage/vcluster/cstatistic.c
*
*-------------------------------------------------------------------------
*/
#ifdef HYU_COMMON_STAT
#include "postgres.h"
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include "storage/lwlock.h"
#include "storage/proc.h"
#include "storage/shmem.h"
#include "storage/procarray.h"
#include "storage/lwlock.h"
#include "postmaster/fork_process.h"
#include "miscadmin.h"
#include "postmaster/postmaster.h"
#include "tcop/tcopprot.h"
#include "storage/sinvaladt.h"
#include "libpq/pqsignal.h"
#include "storage/cstatistic.h"
/* Statistic info in shared memory */
CStatisticDesc* cstatistic_desc;
uint64_t cnt_version_chain_vanilla;
uint64_t cnt_version_chain_vdriver;
/*
* CStatisticShmemSize
*
* compute the size of shared memory
*/
Size
CStatisticShmemSize(void)
{
Size size = 0;
size = add_size(size, sizeof(CStatisticDesc));
return size;
}
/*
* CStatisticInit
*
* Initialize shared data structures related to statistics in shared memory
*/
void
CStatisticInit(void)
{
bool foundDesc;
cstatistic_desc = (CStatisticDesc*)
ShmemInitStruct("vDriver and vanilla Statistics Descriptor",
sizeof(CStatisticDesc), &foundDesc);
/* Initialize statistics */
cstatistic_desc->cnt_chain = 0;
}
#endif /* HYU_COMMON_STAT */
|
the_stack_data/7950014.c
|
/*
* Copyright (c) Meta Platforms, Inc. and its affiliates.
*
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
// Two threads in the same process both call `SYS_exit` (not group exit) with
// the main thread calling it first.
#include <errno.h>
// #include <limits.h>
#include <pthread.h>
// #include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/time.h>
// #include <sys/types.h>
#include <unistd.h>
#define NTHREADS 8
// do `exit` syscall directly, avoid libc doing sth smart by replacing
// `_exit` with `exit_group`.
static void sys_exit(int code) {
(void)syscall(SYS_exit, code);
}
// do futex wait with timeout 600s. 600s is to make sure it can timeout
// on sandcastle default configuration.
void* thread_fn(void* _param) {
printf("Child thread, sleeping...\n");
struct timespec tp = {0, 500000000};
clock_nanosleep(CLOCK_MONOTONIC, 0, &tp, NULL);
printf("Child thread, exiting...\n");
sys_exit(0);
return NULL;
}
int main(int argc, char* argv[], char* envp[]) {
pthread_t child;
if (pthread_create(&child, NULL, thread_fn, NULL) != 0) {
fprintf(stderr, "pthread_create failed: %s\n", strerror(errno));
abort();
}
printf("Parent thread, exiting...\n");
sys_exit(0);
}
|
the_stack_data/140892.c
|
int reg(int a) {
return a;
}
int main(void) {
int t = 1;
return reg(t);
}
|
the_stack_data/129158.c
|
/*
* Copyright 2014 The Emscripten Authors. All rights reserved.
* Emscripten is available under two separate licenses, the MIT license and the
* University of Illinois/NCSA Open Source License. Both these licenses can be
* found in the LICENSE file.
*/
#include <stdlib.h>
#include <stdio.h>
extern char **environ;
int main(int argc, char *argv[])
{
int i;
if (!environ) {
puts("environ is NULL - not enough memory?");
return 1;
}
for(i=0; environ[i] != NULL; i ++ ) {
printf("%s\n", environ[i]);
}
}
|
the_stack_data/151705726.c
|
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main() {
int a;
scanf("%d",&a);
int arr[a];
float count = 0;
float cou=0;
float num=0;
for (int i = 0; i < a; ++i)
{
scanf("%d",&arr[i]);
if (arr[i] > 0)
{
count=count +1;
/* code */
}
else if(arr[i] == 0)
{
cou=cou+1;
}
else if(arr[i] < 0)
{
num=num+1;
}
/* code */
}
printf("%f\n",count/a );
printf("%f\n",num/a );
printf("%f\n",cou/a );
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
return 0;
}
|
the_stack_data/247439.c
|
extern int printf(const char *str, ...);
void test(double X) {
printf("%f %f\n", -0.0 - X, -X);
}
int main() {
test(+0.0);
test(-0.0);
printf("negzero = %f poszero = %f\n", -0.0, +0.0);
return 0;
}
|
the_stack_data/20761.c
|
#include <stdio.h>
#include <stdarg.h>
#include <pmix.h>
static void hide_unused_params(int x, ...)
{
va_list ap;
va_start(ap, x);
va_end(ap);
}
//<EG BEGIN ID="declare_model_cb">
static void model_declared_cb(size_t evhdlr_registration_id, pmix_status_t status,
const pmix_proc_t *source, pmix_info_t info[], size_t ninfo,
pmix_info_t results[], size_t nresults,
pmix_event_notification_cbfunc_fn_t cbfunc, void *cbdata)
{
printf("Entered %s\n", __func__);
size_t n;
hide_unused_params(evhdlr_registration_id, status, source, results, nresults);
for (n = 0; n < ninfo; n++) {
if (PMIX_CHECK_KEY(&info[n], PMIX_PROGRAMMING_MODEL)
&& strcmp(info[n].value.data.string, "MPI") == 0) {
/* ignore our own declaration */
break;
} else {
/* actions to perform when another model registers */
}
}
if (NULL != cbfunc) {
/* tell the event handler that we are only a partial step */
cbfunc(PMIX_EVENT_PARTIAL_ACTION_TAKEN, NULL, 0, NULL, NULL, cbdata);
}
}
//<EG END ID="declare_model_cb">
//<EG BEGIN ID="omp_thread">
static void parallel_region_OMP_cb(size_t evhdlr_registration_id, pmix_status_t status,
const pmix_proc_t *source, pmix_info_t info[], size_t ninfo,
pmix_info_t results[], size_t nresults,
pmix_event_notification_cbfunc_fn_t cbfunc, void *cbdata)
{
hide_unused_params(evhdlr_registration_id, status, source, info, ninfo,
results, nresults);
printf("Entered %s\n", __func__);
/* do what we need OpenMP to do on entering a parallel region */
if (NULL != cbfunc) {
/* tell the event handler that we are only a partial step */
cbfunc(PMIX_EVENT_PARTIAL_ACTION_TAKEN, NULL, 0, NULL, NULL, cbdata);
}
}
//<EG END ID="omp_thread">
//<EG BEGIN ID="mpi_thread">
static void parallel_region_MPI_cb(size_t evhdlr_registration_id, pmix_status_t status,
const pmix_proc_t *source, pmix_info_t info[], size_t ninfo,
pmix_info_t results[], size_t nresults,
pmix_event_notification_cbfunc_fn_t cbfunc, void *cbdata)
{
hide_unused_params(evhdlr_registration_id, status, source, info, ninfo,
results, nresults);
printf("Entered %s\n", __func__);
/* do what we need MPI to do on entering a parallel region */
if (NULL != cbfunc) {
/* do what we need MPI to do on entering a parallel region */
cbfunc(PMIX_EVENT_ACTION_COMPLETE, NULL, 0, NULL, NULL, cbdata);
}
}
//<EG END ID="mpi_thread">
static int openmp_handler(void)
{
pmix_info_t *info;
int rc;
printf("Entered %s\n", __func__);
//<EG BEGIN ID="omp_thread">
bool is_true = true;
pmix_status_t code = PMIX_OPENMP_PARALLEL_ENTERED;
PMIX_INFO_CREATE(info, 2);
PMIX_INFO_LOAD(&info[0], PMIX_EVENT_HDLR_NAME, "OpenMP-Master", PMIX_STRING);
PMIX_INFO_LOAD(&info[1], PMIX_EVENT_HDLR_FIRST, &is_true, PMIX_BOOL);
rc = PMIx_Register_event_handler(&code, 1, info, 2, parallel_region_OMP_cb, NULL, NULL);
if (rc < 0)
fprintf(stderr, "%s: Failed to register event handler for OpenMP region entrance\n",
__func__);
PMIX_INFO_FREE(info, 2);
//<EG END ID="omp_thread">
printf("Registered OpenMP event handler for OpenMP parallel region entered\n");
return rc;
}
static int mpi_handler(void)
{
pmix_info_t *info;
int rc;
printf("Entered %s\n", __func__);
//<EG BEGIN ID="mpi_thread">
pmix_status_t code = PMIX_OPENMP_PARALLEL_ENTERED;
PMIX_INFO_CREATE(info, 2);
PMIX_INFO_LOAD(&info[0], PMIX_EVENT_HDLR_NAME, "MPI-Thread", PMIX_STRING);
PMIX_INFO_LOAD(&info[1], PMIX_EVENT_HDLR_AFTER, "OpenMP-Master", PMIX_STRING);
rc = PMIx_Register_event_handler(&code, 1, info, 2, parallel_region_MPI_cb, NULL, NULL);
if (rc < 0)
fprintf(stderr, "%s: Failed to register event handler for OpenMP region entrance\n",
__func__);
PMIX_INFO_FREE(info, 2);
//<EG END ID="mpi_thread">
printf("Registered MPI event handler for OpenMP parallel region entered\n");
return rc;
}
static void notify_complete(pmix_status_t status, void *cbdata)
{
volatile bool *flag = (volatile bool *) cbdata;
hide_unused_params(status);
*flag = true;
}
int main(int argc, char **argv)
{
//<EG BEGIN ID="declare_model">
pmix_proc_t myproc;
pmix_info_t *info;
volatile bool wearedone = false;
hide_unused_params(argc, argv);
PMIX_INFO_CREATE(info, 4);
PMIX_INFO_LOAD(&info[0], PMIX_PROGRAMMING_MODEL, "MPI", PMIX_STRING);
PMIX_INFO_LOAD(&info[1], PMIX_MODEL_LIBRARY_NAME, "FooMPI", PMIX_STRING);
PMIX_INFO_LOAD(&info[2], PMIX_MODEL_LIBRARY_VERSION, "1.0.0", PMIX_STRING);
PMIX_INFO_LOAD(&info[3], PMIX_THREADING_MODEL, "pthread", PMIX_STRING);
pmix_status_t rc = PMIx_Init(&myproc, info, 4);
PMIX_INFO_FREE(info, 4);
//<EG END ID="declare_model">
printf("Registered MPI programming model\n");
printf("Registering event handler for model declaration\n");
//<EG BEGIN ID="declare_model_cb">
pmix_status_t code = PMIX_MODEL_DECLARED;
rc = PMIx_Register_event_handler(&code, 1, NULL, 0, model_declared_cb, NULL, NULL);
//<EG END ID="declare_model_cb">
if (rc < 0) {
fprintf(stderr, "Failed to register event handler for model declaration\n");
goto fin;
}
printf("Registered event handler for model declaration\n");
openmp_handler();
mpi_handler();
printf("Notifying OpenMP parallel region about to be entered\n");
//<EG BEGIN ID="notify_event">
PMIX_INFO_CREATE(info, 1);
PMIX_INFO_LOAD(&info[0], PMIX_EVENT_NON_DEFAULT, NULL, PMIX_BOOL);
rc = PMIx_Notify_event(PMIX_OPENMP_PARALLEL_ENTERED, &myproc, PMIX_RANGE_PROC_LOCAL, info, 1,
notify_complete, (void *) &wearedone);
if (rc < 0) {
fprintf(stderr, "Failed to notify OpenMP region entered\n");
goto fin;
}
while (!wearedone) {
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 100000;
nanosleep(&ts, NULL);
}
fprintf(stderr, "Test completed\n");
fin:
PMIx_Finalize(NULL, 0);
//<EG END ID="notify_event">
}
|
the_stack_data/486147.c
|
/*
Fontname: -Efont-Fixed-Bold-R-Normal--12-120-75-75-C-120-ISO10646-1
Copyright: (c) Copyright 2000-2003 /efont/ The Electronic Font Open Laboratory.
Glyphs: 1189/21527
BBX Build Mode: 0
*/
#ifdef U8G2_USE_LARGE_FONTS
const uint8_t u8g2_font_f12_b_t_japanese1[32826] U8G2_FONT_SECTION("u8g2_font_f12_b_t_japanese1") =
"\245\0\3\3\4\4\4\4\5\14\14\0\376\0\0\0\0\0\0\0\0\0\33\134\31\314h\34q\240\34("
"\7\312\201r\240\34(\7\312\201r\240\34(\7\12\0\0\60A\21xy\134\322\242$f\242PB\22"
"\221\4\0\60B\31\272x|r\210\370*\207\24%\222\320DBI\242\214(\42\321d\4\60C\14W"
"\211<R\211\32%\242\10\60D\25\212\210<r\210L$\225H%b\212L\42\211\211\304\0\60E\16"
"vy<\322\21E$\224\211F\0\60F\22\270y\134r\300\34J\32\311\1bU\341l\10\60G\17"
"xx\134r\200\320*\34JD\42\2\60H\27\272x|r\320\34\305\16\221\3\344\0\71`,\21\212"
"dB\2\60I\22xy\134\302JL$\242MT\42\42\211\10\0\60J\32\273x|r\220\34D\221"
"\24eBYu$\223\304$j\22%\331d\6\60K\32\253x\134r\220Ld\222I\324$\42\25\221"
"D$\25\11%\21\71`\12\60L\33\253x\134\62IH&\71\311$j\22\221\212H\42\222\212\204\222"
"\210\34\60\5\60M\25\270y|bJ\35p\230\3d\224\210\250\16\220\3*\0\60N\27\271y|\222"
"\64\212\35B\261C\204\224\220h\42\207\310!%\0\60O\13\245z|J\332\204\332\4\60P\24\250y"
"|\342IH\222\42\25\313\1r\200\34 \226\1\60Q\32\273x\374\0\231P&\244HJR\221T$"
"\25Ib\212r\210\34\60\4\60R\33\274x\334\222\24\231$EH\222\324\244\62\251L*\223\304\204\352"
" \71d\12\60S\17\231\211<r\210\35Or\200Tr\1\60T\21\232\210<\62I\310\22\307\253\34"
"\42\25\235\0\60U\30\271y|r\200\34\42\71\210\345\20Y%\42\233\310!s\10\11\0\60V\32\272"
"x|\22IL\42\11J$w\200\34$\254\204d#\71h\16\242\1\60W\15\250z\34b\375(\221"
"\314f\0\60X\21\250z\34b\221d$\31\353(\221\314f\0\60Y\26\272x\274r\210\354\60\25S"
"%R\211\230\16\221\3\304S\0\60Z\31\273x\274\222TI\344@\226\3\310\22\261D\16\240\203\344\20"
"\71`\14\60[\26\253x\334R\221Tt\260\212\244\42\251D,\207\311a%\0\60\134\30\253x\274\222"
"\24\221$ED\272\212\244\42\251D,\207\311a\65\0\60]\30\252x\134v\200\34 \7H\16t\200"
"\34 \207\310Ar\320\10\0\60^\30\253x\134\227\250$Q\16\221P\356\20\71D\16\222\303\344\260\31"
"\0\60_\27\272x|r\210\364*\207\310F\222\231\34\42\207(\212\204\262\2\60`\32\273x|r\220"
"\312!\222$\7\311f\222\241\34$\7I\244\42\251\254\2\60a\27\271x\134r\200\364\20\223\3\304\222"
"\31E$\224\3\244\63\32\0\60b\31\272x\134r\210Hr\220\204\344\20\71@\62\244\310\204r\210x"
"H\4\60c\14Wy\134\224\221T(\33\1\60d\21z\230|%\232\34$\207\310\1\342\351\20\0\60"
"e\25\213\230\374\0I\250\22\241\311ar\220\34\42\7\214\307\0\60f\25\232\210\334\7:D\16\220\3"
"\344\20\71D\16\222\203(\0\60g\26\232\210\274\24;D\222&\221\204\344\20\71D\16\222\203H\0\60"
"h\24\251y\134r\200\34 \207Hf\304\251X\16\221C\16\60i\26\252y\134*!\225\220\34$\31"
"R\307r\200\34$\7]\0\60j\32\273x|r\220\34`\221\251\204d\212\62\241HT\25\15E\222"
" \15\0\60k\30\252x<r\210l$\231\311!r\210\34\42\22\212\204\222HE\16\60l\30\253x"
"\274JRIm\242\244e\22\243\244Q$+\222\210hD\1\60m\34\273x\134r\220\34$\7T\206"
"\222\220l\246(\32\212F\24ID\62\22\215\0\60n\30\233\210|UID&\21ID\62\222\214\42"
"\244\310D\63\71`\6\60o\32\253x<B\231\220\42)IER\221T$*ID\23%IDB"
"\3\60p\36\274x\374\20ID\70\211\10ULR\231T&\225\211j\22\321H\42\222\204$D\0\60"
"q\35\274x\374\220\221P\242H\222\324\244\62\251L*\23\325$\242\221D$\11I\210\0\60r\25\252"
"y\234R:@$\323\66\21J\206\42\241L$%\2\60s\31\254x\234\42I\204&\11\251\312\244\262"
"\231P\22\22j\25\311\1d\0\60t\32\274x\374\220\241Hb\234\211\244\62\251l&\224\204\204ZE"
"r\0\31\0\60u\30\253x|r\30\35Q\16\222\10%j\22\221D&\241\204\304D\0\60v\32\253"
"x|\42I\260\22G\221\203$B\211\232D$\221I(!\61\21\0\60w\32\254x|\262iE\16"
"\231\312a\22\251DQ\42R\223\250\204\344\0*\0\60x\21k\230|s\200D\70\223\303\344\60\71L"
"\0\60y\26\213\230\374\0I\34 \211\315\1\22\341L\16\223\303\344\60\1\60z\24\213\230\374\200\71@"
"\42\233\314$R\231\252\34&\207\11\60{\32\253x<\222\213P&\24\211,R\221T$*ID\23"
"%IDB\3\60|\35\274x\374\20IDb\211\10\265\211LR\231T&\252ID#\211H\22\222"
"\20\1\60}\35\274x\374\220\221\244\242H\22\312D&\251L*\23\325$\242\221D$\11I\210\0\60"
"~\27\271y\234r\200\354 \224\3(v\200\260&\242\210$\22\42\0\60\30\253x<u\220\34$"
"\21K\204\67Ih\242$\231\304\264C\204\0\60\200\30\273x|r\220\330\62T!K\304\22\261$("
"\32\312\204B\23\0\60\201\30\253x\274*DI\266\211\222DFI\243\10)\62\321L\16\230\1\60\202"
"\25\271x|r\200\324*\26I\216r\200L$S\221\216\0\60\203\22yy\134\222\250dRI\222\251"
"\10\345\0!\0\60\204\31\273x\234b\211XD\224(QB\224\240\312T\16\222\303\344 )\0\60\205"
"\16xz|*\24\225J\204Q*\4\60\206\33\273x\274r\220PT\222H\42*\21QITIQ"
"*\311\344\20\71D\14\60\207\16xy|b\242XX\222\250\14\1\60\210\27\272x\234r\210\34\42\207"
"T\345\20\71DZ\24\221T&T\0\60\211\22\270y\134r\300\34&V\241\314\210b\341\210\6\60\212"
"\21\267z\234\42\25\21\215KDI*\224\215\0\60\213\25\252x\134v\200\34 \7\24G\252d\331D"
"&\231\322\0\60\214\33\273x\134r\220\34$\231J\42\242\222P&\224\311f\262\231H\22\34\311\1\60"
"\215\25\252x\134v\200\34 \7\24G\252d\71@\16\220\322\0\60\216\21yy\134b\262d\66\222\314"
"(!\231D\4\60\217\32\273x\134r\220\34$\7MF\224\220l(\222J\246\224\240L\64\224\3\60"
"\220\30\253x\134u\220\34$\7\30%!\25\31EH\321\62\211\214I\0\60\221\27\253x\134w\200\34"
"`T\222L\204\222\361\34I\42\231\310&\2\60\222\30\272x\234r\210\364*\7\310&\24\221h,\211"
"J\244r\220\5\0\60\223\30\253x\234r\220\34\42\7\311!r\20Y$\25\211h\22\305\21\0\60\224"
"\33\273i\134*\301\211$\16\220L\250#\71H\16\222C\344 \71D\16\21\3\60\233\12D\350<\222"
"\10e\4\60\234\12C\330\34\222\210d\2\60\235\13W\232\34\343\261\220$\3\60\236\21\210\231\274B\211"
"P\64\7\314\1R\232\20\0\60\241\15gy\34'\211\210&\25\12\1\60\242\25\232x\34\207\71D&"
"\22J\244d\71D\16\220\3\344\0\60\243\14vy\234j\262\311$\250\2\60\244\15\250y\334\252\212\244"
"\211X'\0\60\245\16wy\134R\331AF\22\312f\0\60\246\24\272x\234r\210\34\42<\224Y\345"
"\20\71@<\235\2\60\247\12H\211<F\261\354\20\60\250\21{\210<\7\251\34$\7\311Ar\220\364"
"@\60\251\20xy\234b\321!\66\224\204&\322\21\0\60\252\30\272y\274r\210\34\42;\14\347\200\261"
"$*\221\215\344\20\71`\6\60\253\30\271y|r\200\34 <\310D\62\221L\244&\222I\204\264\11"
"\0\60\254\31\272y|\22IL\42\211I\17B\221P$\24\311t\22Jd#\0\60\255\30\272x\234"
"r\210\34R\261C\344\220\203\35\42\207\310!r\210\14\0\60\256\31\273x\234\22IP\42\11\226\354 "
"\71\310r\7\311Ar\220\34$\4\60\257\23\251y|r\200M\244&\221I\204b\325\341\30\0\60\260"
"\31\273y\374\0IL$\211YEB\231\216r\210\34\42\7\214\347\20\0\60\261\27\253x\134r\220\34"
"t\20)\312\24\345 \71D\16\221\3\306\0\60\262\31\254x\134BIH(\11\35\202\42\251L\250\16"
"\223\203\344 \71d\16\60\263\23\211\211\34\7\71@\16\220\3\344\0\71\340@\7\10\60\264\31\253x\374"
"\0I\34 \71\314Ar\220\34$\7\311A\242\203\34$\2\60\265\30\253x|\42\251H*\22\35h"
"\42\251H*\222C\344\20\71`\12\60\266\30\254x\134*I*I\212\207\241H,\22\213\344 \71H"
"\16\231\3\60\267\25\252x<s\220\34\134\25\311\344\20\71@\16\20\17\311\0\60\270\30\253x<\63I"
"L$\211\3\247\62\241\34\42\207\310!r\300\224\16\60\271\26\233x<\207\70H\16\222C\344 \71D"
"\22\26\311\206e\1\60\272\31\253x\374\0I\344\20\211\3\344 \71D\16\222C$a\221lX\26\60"
"\273\26\252x\134r\210\34\42\42UlJB\211T\16\221\203,\0\60\274\31\253x\134\62IH&\11"
"\211h\25\11M(\222J\304r\220\34f\2\60\275\22\231y\34R\211P\42\24\313\1b\325\341\30\0"
"\60\276\27\252y\334\222\241$\42\24\11\345\0\71D\16\220\3\304\323\71\0\60\277\25\252x\234r\210M"
"IX\231\304\1s\200\34 \236\216\1\60\300\32\254x\234\42I\320\22ST\232L\342\240\71H\16\222"
"C\346\200\71\4\0\60\301\26\253x\334\63;H\16\22\36\250r\220\34$\207\310\1c\0\60\302\30\254"
"x\334\224\210E\22\225\303\244\7\262\34&\207\311Ar\310\34\0\60\303\17xy\134B\211\226\210\222X"
"\70\33\2\60\304\26\252x|R\221\212\222DI\42\224C\344\0\71@<\35\3\60\305\32\273x\374\0"
"IL$\31\211%\42\25\221\242\34$\207\310!r\300x\16\60\306\23\233x\134wl\7\252\34$\207"
"\310!r\300\34\0\60\307\26\253x\374\0I\350\22\307r\240\312Ar\210\34\42\7\314\1\60\310\16\267"
"z\34R\255\64\311DF\325\12\60\311\23\270z\34b\221d$\31\23%#\231D\254\31\0\60\312\30"
"\273x\274r\220\34$<P\345 \71H\16\221\203\344\20\71`\16\60\313\12k\230\134w|<\20\60"
"\314\27\233x\134\207\70H\16\221N\344\200\71D\22\26\311\206u\10\0\60\315\31\273x\234r\220\370\20"
"\7\311!r\300\230\42\232\210\206r\220\34$\5\60\316\20\211\211\374\0\71@,\7\210U\207c\0\60"
"\317\23\213x|\22\261H*\22\252\11eR\211\230\16\20\60\320\32\254x\374\20I\34\42\211I\344\0"
"\221X$\25\352*\22K\344\0\11\0\60\321\27\254x\374\220\71DM\242(\22\213\244B]Eb\211"
"\34 \1\60\322\25\231\211\34r\200\34 \7\310&\66\71@\16\220C\16\1\60\323\26\232\211\34B\311"
"P\62\207\210HU\71D\16\221\203\16\21\0\60\324\26\232\211\34\302\211LB\234\210HU\71D\16\221"
"\203\16\21\0\60\325\25\232x\34\207\71D\16\221\3\344\20\71@\16\20O\307\0\60\326\30\272x\334\222"
"\260\344\60\207\310!r\200\34\42\7\310\1\342\351\34\0\60\327\32\273x\374\200\71@r\250C\344 \71"
"D\16\222C\344\20\71`<\207\0\60\330\20k\230|s\200D*S\225\303\344\60\1\60\331\25\213\230"
"\374\0I\34 \211\315\1\22\251LU\16\223\303\4\60\332\24\213\230\374\200\71@\42\233\314$R\231\252"
"\34&\207\11\60\333\32\272x\234r\210\34\42<\14\305\222DID$\21I\224Hr\300\20\0\60\334"
"\33\272x|r\210JL\42\71\14\305\222DID$\21I\224$!\71`\12\60\335\35\273x|r"
"\220h(\221\34$B\71@\222*\211\310$\42\25\221($\207\214\1\60\336\24\212\210\34\207\71D\16"
"\220\3d\23\361\34$\7\211\0\60\337\23\250y<t\300\34 \7\321\1r\30\35\60\7\14\60\340\27"
"\252x\234r\210\34\42\7\310!\222\250H(\23I\332\344\20\1\60\341\27\252y\374\0\71D\16\221\215"
"\244t\210\34 \211\212D\323\71\0\60\342\23\213\210<\207\250\34$>\320\344 \71H\16\263\0\60\343"
"\22yy\134r\200\34 \71H\204\222\250\34 \4\60\344\30\253x\134r\220\34$j\221LBR\211"
"X\16\223\203\344 )\0\60\345\12H\211<e\245C\0\60\346\22{\210<\207\70H\16\222C\344 "
"\71Hv \60\347\13gy\34W\211Uz\20\60\350\25\232x\34\207\71D\16\221\34\344\20\71D\16"
"\71\324!\2\60\351\24\252x<\207\70\206\303\34\42\7\310!r\200xH\5\60\352\16\247z\34\62\276"
"\11\245B\331\14\0\60\353\30\253x\274b\211X\42\226\210%\42\25\221\212\222JL\64\223\203\0\60\354"
"\17\250y\34b=\322$\42\25\331\24\0\60\355\14\211\211\34\7*\257\7\253\0\60\356\14gy\34\7"
"\31M\250\66\3\60\357\20\231y\34\7*\253X\16\20K\207S\0\60\360\30\273x\334r\220\34$;"
"\314DR\221T$;\220\345 \71H\6\60\361\23\212\210<\207\70D*\11\317\1r\210\34\42<\14"
"\60\362\23\231y\34\7\71@\16\220\34\302r\200X:\243\2\60\363\25\232x\34s\220P\16\221\3\344"
"\20\71@\16\20\17\311\0\60\364\32\273x\234\22IP\42\11J\17\23\261D,\207\310Ar\210\34\60"
"\36\3\60\365\17wy\134R\331I\42\222(Q&\0\60\366\16xy\134b\361A\42\226\12\207\0\60"
"\367\33\254x\374\0IDDI\241HRdb\221X$\7\311ar\220\34$\7\60\370\32\273i\234"
"\222dIb\305\22\25\211%b\11\251\22\21\313Ar\220\20\0\60\371\30\234\210\374\0I\34$\211V"
"\42%\261D\16\221\303\344\60\313M\0\60\372\32\254x\374\0IDDI\241H\222\345\20*E\16\223"
"\203\344 \71d\16\60\373\7#\274\34\6\60\374\10\31\311\34\7\1\60\375\11G\231\34\343\261\2\60\376"
"\21x\231\274B\211P\64\7\314\1r\200\4\0N\0\10\33\310\34\7\2N\1\31\273h\34\7\242\34"
"$\7\311Ar\220\34$\7\311Ar\220\34\62\5N\3\32\313h\134r\220\34$\7\311A\242CY"
"\16\222\203\344 \241L(\274\0N\7\31\273h\34\7\232\34$\7YER\221T$\224\11e\212\42"
"\331\14\0N\11\16\253x\34\207\71\36\16q|<\20N\12\31\313h\234r\220\34$\7\311Ar\220"
"U\16\222\203\344 \71Hz N\13\31\273h\34\7\242\34$\7\321\1\22\261H*\7\311Ar\220"
"\34$\5N\15\33\273h\34\7\252\34\42\7\315\1\23\331$$\21\311\204r\220\34$\7I\1N\26"
"\33\313h<\332$j\22\65\211\322\201\242M\242&Q\223\324\344 \71\350 \1N!\31\273h\34\7"
"\242\34$=\324d\223\210\226\210\226\210\226\213$<\7\14N&\34\273x<B%\251Dx\240I\202"
"\22ID$I\21I\262I\42bI\360@N-\31\312h\234r\210\360P\22\221D$\321\241(\207"
"\310!r\210\34\42\4N\70\36\313h\134r\220\34$\7\34\242\42\251H&\11\11G\322\211P\42\211"
"\220$\221\61\1N;\30\313h|r\230\364\60\225\203\344 \361!,\7\311Ar\220\364@NE\32"
"\313h|r\220\34T\25IEB\221P&\207\310!\222\260H\250$\36NW\31\313h\274\64;D"
"z\240h:\214$J\7\32u\22\21)\15\245\0N]\32\313h|r\220\34$>\204%b\211X"
"\42\226HER\221DMB%Nq\36\313h\234\222\260DF\222\212\244\42\331!*\222\212d\226\230"
"H\22!I\42\207\10\1Ns\35\313h|\223\30%-\42I\223\250\203d\226\260D*\222Y\242\42"
"\211HE\62#N\210\31\273h<\207\70D:\211C\244\7\242H*\21\313Ar\220\34\62\5N\211"
"\32\313h|rPq$\207H\17a\211\350@\224\310\16a\71H\16\231\2N\213\31\313h\234\322\3"
"E\333!,=\210%\242\3Q\42:\210\345\220)\0N\214\13\213\210\34\207\71\376\361@N\224\30\273"
"h<\7\251\34$\7\211\17a\211X\42\25IER\221\350@N\241\31\273x\234r\220\34$=P"
"\344 \71H\16\222\203\344 \71\354\20\1N\244\33\313h\234r\220\364@R\225i\211HBbI\34"
"\42\207H\242\243\221x\0N\254\31\313h\234\322\3\35z\210\11eB\331!\254\242&\21ID\212S"
"\0N\272\34\313h\234r\220\34$\7\311Ar\220\34\42\211\3$a\221PI,\211C\4N\301\34"
"\313h\134r\220\34\42\61\311!sH:H\16\222\203\344 \71Hr\221C\0N\312\33\313h\234r"
"\220\34\42\11\213\204\207\220x\16=\304!r\210\34$\207H\1N\317\35\313h\134\22\261D,\221\212"
"\244\42\341H\30\211\250ID*\42\225H\305$\21\13N\325\33\314h\134\312\42\261H*\223\36n\302"
"HL*\223\312\244\62\251\304&\7\1N\326 \313h\134\252\222D\211$(\221\254PR(I\22I"
"\222D\222$Q\223\310$j\22\221\1N\330\35\313h\134\62\241L(S\271\10E\223\220(\22Q\223"
"\250\11eB\231P&\33\1N\343\34\313h\134\22IP\242&\221\212,\306\231,\22\23\312\204jB"
"ID:\21\13N\344\33\313h\234r\220\34\42\11\213\204\207\220xr\220\212\244\42\251D,\7I\1"
"N\345\37\314h<R\231T&\211\251\210d\22\221L$\221Ie\222\230lI*I\34\311\306\0N"
"\356\37\313h\134r\220\304$\11K\304\22\313\212$E\222$Q\223\204d\222\310l\242$\221\11N\362"
"\36\313h\134\252\42\351A\42\211h\211H*\21\311$r\221\11eB\231P&\224\311\0N\366\35\313"
"h\134\252\222TI\242\304$\211\310H\262\310A\42\23\312\204\62\241L(\223\1N\373\33\314h\134\262"
"\241Y$\225Ie\302\203%&\225IeR\231Tr\222\203\0O\21\36\314h\134\312\42\261Hz\30"
"\311\204#Z$D\224H\322$\21\245\221\212L*\23\2O\32\33\313h\234r\220\34\42\11\213\204\207"
"\220x\16<\14%a\311\314\42\7\211\0O\35\37\313h\134r\220\244&\207\310A\222\303H\30\11I"
"E\222\230D\244\42\31IF\22\261\0O<&\314h<R\231$\246\22\23I$\21\221D%$\221"
"\211$\62\221D&\222H\42\42\311D\22!\211hR\0OM\33\313h\134\252\42\251H(\271H%"
"\223\230$E\244\42RQ\223\250)\36\6ON \313h\134\262\231u\42\224D\204\222\303$\42\213\244"
"\10%!\231d\22\233I\42\322\211\244\22OO\34\313h\134\22\261Hz\220\310\204\62\331L\26\211\230"
"dB\231P&\224\11%\7OS\37\314h\134\312\42\261Hz\30\311\204#Z$D\224H\322$\21"
"\245I%\42\223\312\204\0OU#\314h\134r\330a$\224Ie\22Jh\22\221\204\42)\222\230$"
"\42\211I(\61\251L*\23\216\0OY\33\313h\234r\220\34\42\211\216F\222\212Pz\230\212%j"
"\22\221D\244\70\5O\134\36\313h\134\22\261D,\261\250\4%\222\330$b\211\11eBYE&\224"
"\11e\62\0O\36\313h\134\252\7\221\242\344\42\211H*\21\311$r\221D\204\22IP\64\224\250"
"\321\6O\213\42\313h<b\311!\22\221\204$\23\221dB\211L\42\222\310D\222BQ\31I$\23"
"!%Z\35O\233\42\314h\134\22E\211\242DMrR\21\215$\242HH\42;P\344\60\221D&"
"\221\211$A\11\0O\241 \313h\134r\320A$\221\304D\222\230\344\60\311\42\311\213$\27I.\222"
"\134$\27I\30\0O\277\34\313h\134r\320A\244(\271H\42\222\312!\222\242\345\242\22\24\15%j"
"\264\1O\302\37\313h\134\262\231U\242$Q\23\315F\22IJ%\42\23J$I\22ID%\242M"
"\6O\335\36\313h<r\220\304$\211I\324$\222\213Lx\60\321$\222$IDe$\242\11\1O"
"\341\34\313h\134\22\242\34t\220\310A\22\313\34\222b\222\203$&\211HE\244b\1O\356$\314h"
"<\352\0\311I\42R\211Hb\222\320LB\21IB\222JD\22\223\204$*\21%\341LB\5O"
"\363 \313h<*A\211$X\61Ib\42IL\62\61Ib\42I\314bQ\223\250IB\62\0O"
"\365!\314h<\62\251\344$\23J\16\21\241\312\201&\25I\42*\223$I\212LD\11If\22\0"
"P\11\36\313h\234r\210$:\32\35(B\331!&\224\35br\320A\42\11J\42\207\10\0P\13"
"!\313h<r\320a\62\21Q\42\42\312a\22\21Q\42\224I\212d\222\42\231D(\223(\345\20P"
"\15\33\313h\134\252\42\351A\242\244%t\250\304A\22\223D\244\42R\21\251X\0P\31\36\313h<"
"r\220\304$\225H\16\223TI\244\242M\22\222I\16\223\210$\244EQ\0P\37 \313h\134\222\210"
"P\22\21\36B\22\265\203\35\222b\222\304D\22\223$&\222\304D\22\13\0P$\42\313h<\62\241"
"\344\42S\262H\222$\222HE\222$\221D*\222$\211$R\221\304\1\222C\0P\134\33\314h\134"
"\312\7\231\34$\261ID\242\203E,\221\330TeR\231T\64\4Pe\42\314h<B%SE\22"
"\21\35&\42IDr\210\210$\62I\304\42\231\310D\27\225\64I\310\0Pt&\313h<b\211%"
"e\42\211L\42\222\310\204\22\231D$\221\11%\62\211H\42\23Jd$\243HB\224\340\0P\231 "
"\313h<\332$\27M\222\303$\16\220D\16\221,\224\310!\222\205\22\71H$\21\222$\42P\267\42"
"\314h\134\222\70Db\222\210d\223\322D$\212\34&\352\0\311i\42I\222H\42\42]$#\0P"
"\315\42\314h<\22J\254$\223H.\225\310$\227I%\62\311eR\211\214T&\24\311\250B\21I"
"\4P\317 \314h<\42\242D\22=L\364r\210\310&*\223$\321$&\221\220D\223\24%\11m"
"\10Q\4\36\313h<\62\241\304$Q;Td\22\311EM\42\271H\42BI.\23\225\31\11\0Q"
"*\42\313h<\207\211H*)\251\210$\207ID\22\231\250D$\21\312\212H\22\231\211&!\211l"
"\0QC\26\273h\134wl\7\232D,\21K\244\42\251H\242&\241\22QD\34\273h<\207\230P"
"&\224\11e\207\250$\16\220\304\1\222\260D$\21\211\210\5QF \313h|\222\70@\22\321\22\21"
"I\262I\42bIx\42\224\244\250D\304\22\221D$\42\26QH\34\313h\234b\211X\42>\304$"
"R\221\364@\223\304\1\222\260D$\21\211\210\5QI\36\313h\234R\221D&Q\223H\342\0\351\201"
"&\211\3$a\211X\42\222\210D\304\2QP\34\313h\34\22\223D\244\42R\61ID*\42\25\223"
"L,\21KD\22\221\210XQZ\33\313h<\32%i\207:dr\211\10eB\331!*\211\3$"
"\321\211\210XQe\32\273h\134t\220\34$\7\311Ar\210$\16\220\204EB%\261$\16\21Qh"
"\31\313h\234r\220\34\42\11\213\204J\7\242\34$>\204\345 \351\201\0Qk\31\273h\134v\220\34"
"$\25IER\221T\246(\223J\304\222\70D\0Ql\33\313h\134\252\42\251H\250&\21ID\262"
"\231\34\242,\22JH\65\71H\2Qm\31\273x\234r\220\34$=\320\301\22\261H\250&\225\210%"
"q\200\4\0Qq\32\313h\134\252\42\251Hv\230\211\244\42\251Hv Ke\252\22\261\4\0Qu"
"\32\313h\274\303\262\34$\7\35D\62\241L(\223\35H\22\251l$\226\0Qw\30\313h<G\231"
"\360(\23\36e\302;\302\201$\221\312Fb\11\0Qx\37\313h|\222\70@\22<LT\42Z\42"
"\222\303D%\242%\42\71\220\24\205\23\71@\0Q\205\33\313h\234r\220\364`\222\221d\24I\210\22"
"\222\24%s\0\35@\7\220\7Q\206\20\272h\34\207\222\210$\42\211\16g\276\16Q\212(\273h<"
"\7\221$\42\11I\42\222\220$\42\11I\42\222\310\201\42\211HB\222\210$$\211HB\222\210$$"
"\234\0Q\215\32\273h\34\207\251\370\20\223\250\35b\22\65\211\322\201\42\224\11e\262\21\0Q\231\30\273"
"h\34\207\212t\42\25\35\345 ;Hv \313Ar\300\20\0Q\254\33\313h\234r\210Q\246\22\221"
"\211\346\0It\64\222\214\246\342\71l\16\223\1Q\267\33\313h\274\302\240\222$&\221\14\17!\261\354"
"\244\242&Q#\5\205A!\0Q\346!\314h<r\230\210HI\224d\223H\322$\222\264H\336$"
"\222\64Ih$\211\3D\323\250\1Q\372\32\312h\234r\210T\242$Q\222(\35\242B\221\210$\42"
"\211H\242C\1R\0\31\273h\34\7\252H*\222\212\244\42\241L(S\224\11ER\211p\2R\6"
" \314h|\22\71@\42\7\210\244\62\241T$\261\244I\24%r\200D,\222\312\204\242!\0R\7"
"\33\273h\34\222\303PB\231DL\22\242\204(\241h\241\204\244\42\241L\264\2R\12\36\313h\374\240"
"C$\42R\21\251\210T\16\221\210HE\244\42R\21IER\221p\0R\27\35\313h\374\240C$"
"\242&Q\223H*\21\222$R\221DV\324$JR\211\230<R\35 \313h<r\220\344PQ\223"
"(\251h\211H(\222JD\62\211\214$\42\25\65\211$\64\1R$\36\313h\134\322\211$\205\222\205"
"\242r\210DD*\42\225\303D\244\42\222\212\244\42\341\0R%\37\313h\374\240C$B\222DH\222"
"\310!\22Q\223H*\21-\21-\21m$\331d\66R)\36\313h|\63\223D\244\42R\71D\42"
"\222\221DB\221P\262P\242\23\251H*\22\16R\66 \313h\34\222(%$\71D\42\23\221\344\60"
"\21\251\34\42\21J\26J\26J\26\212P$\34R\67 \313h\34\66\222$B\222D\16\221\10%$"
"\71D\42\224,\224,\224,\224\64\312L$\34R\70\34\313h<\32%\21\241$\355\60\224\4\17$"
"\305CH\242M\42\25\11%C\0R;\35\313h\134R\221\312a\42RQ\211H*\21%I\212\226"
"\10E(\32J\324\310\3RG\33\313h\374\240\213\204\242r\221PT.\22\212\12E\345\242%H\222"
"\315\1\3RM\36\313h<\62\251Dx\240\3+\21-\21I%\242%\42\251D\264D\264I\224&"
"\0Ro!\313h\374\240C$\42\226\34\42\21\222$r\210D\304\222C$\62\221\244\34b\23I\354"
"\20\32Rr\36\313h\134\322\303d\42\231\34\42\21\221\312!\22\21\251\34&b\311!F\222\35B\3"
"Ru\42\313h\134R\211$H\222D\16\221\10I\22\71D\42$I\344\20\211\20%\23\332$\42\223"
"\224\6R\207\37\313h\134\64\221\312!\22\251H\42\27\11Qr\210D(\221IE\22\241\314&\231\24"
"\7R\233\30\312h\234r\210\34\42<\14EB\221P$\323I(\221\22'\0R\237\35\313h\334r"
"\220\214$\224\134d\22\65\211\232D%\242\62\21\321DB\231\322\4\0R\240\36\313h<r\220\34$"
";P\42Z\42Z\42Z\42Z\42Z\42$I\204$\251\214\1R\251\33\313h\334\262\212L\242&\71"
"X$\24\25\212\312EBQa*)J&\0R\252\35\313h\134r@\205$\211IT\322FB\311"
"$\244t\260\212\244\42\331L\62\33\1R\264\35\313h\34\22\231H\42\222I\42\242CI\70\22\36\250"
"\42\251H(S\24\311f\0R\271\37\313h\134\252\42\231%(\71HTF\223\210JDIE$\21"
"I$I$\331H\64\1R\307\34\313h<\207\250Dx\20ID\242\203H\42\22\35\244\322\3M("
"\231R'\0R\311$\314h<BaE&\21\311\16\24I\212$\42I\221D,\222\330DI\22Q"
"\222\244\210$\322\331!\0R\325\36\313h\134\224\30I*\71T\42\224,\207H\204\222\345\20\211\210T"
".!Q\213d\2R\331!\313h\274\302Jm\42\222D$\61\331\350\62\221D\204\22\313L\222I\42"
"\222\210$\223\310\10\0R\335\42\314h\334BJ&\311!\42\11\11\17\24ID\22\223\344t\240H\42"
"*\223\210\222$I\24Y\3R\342\34\313h\134j\25\251\244bIQ\241D$)\7\221Pz\230\212"
"\204\62\321\22\0R\344\37\313h<\222\210\314\22\224Dd\7K\226C$\42R\71D\42\42\225\213R"
"\311\22\231\0S\5\34\313h\134r\220\34t\10I%\22\212X\42\226\210,\42\241L,\21\213\16\2"
"S\26\34\313h\134\22\261D,QR\21\251\204\326\42!\251H*\222\212TD*\262\2S\27\34\313"
"h\134\22\261D,\21K$\27\242D,\21K\244\23\241$\42R\21)\25S:\33\273h\34\7\253"
"H*\222\250\211$\61E\221$&\21\251\304\1\7;\10\0S;\33\273h\34\7\213Xb\222D\204"
"#\241\344\42\23\212$\61\211H%\16\70\20SA\32\313h\234r\220\34$\7I\17D\71H\16\222"
"\203\344 \71H\16\222\2SC\31\313h\374\0\61\315\16\222\203\244\7\242\34$\7\311Ar\220\34$"
"\5SH\32\313h\134r\220\34t\10)\312\344 \341\201*\7\311Ar\220\34$\4SJ\32\313h"
"\234b\211\242$\42\224\244\35\246r\220\364@\224\203\344 \71H\12SR\32\313h\234r\220\364\60\23"
"IEBI&-\7\242\34$\7\311AR\0ST\37\313h\34\62\241\344\42\223H(\232TTF"
"\22\221\350`I\221LR$\24I\204e\0SW\37\313h\234\322\3Q\16\222\36&\222\220$\242\22"
"Q\251DD*\222JD\244\42\222L\0SX\33\313h<J\62\211$v\210I\324\16\61\211\332!"
",=\20\345 \71H\12SZ\34\313h\34\62\211\312a&\224\134(Z.\222\210\312\301*\222\210\264"
"\210\204#\0Sp\33\313h|b\312!&\242\211.!\232\210&\242\211.\21\65\71H\16\22\2S"
"q\33\313h|r\210m$\207\210\17\23\71HR\223\204TD*\222\211H(<Su \313h|"
"S\322I\22\251H\42\224\24\311H\22!I\42\24\225J\204(\221\212\204\62\31\0S\232\32\273h\34"
"\7KL$\61Ib\42\211I\16\222\230\204\262CQ\16\31\2S\237\35\273h<\207\211H*\61I"
"b\42\211I\22\23I,\62IH\22QIR\34\2S\263\37\313h<J\62\211$t\60\312$\65"
"\211\344PQ\311EB\11IR&\21JD\70\22S\273\31\313h\234r\220\364\60\225\203\244\7\242\34"
"\242,\22JH&\71H\2S\302\34\313h|\222\260Hv\11K\17$\311P\242D\231$M$\221"
"\221\34\60%\3S\313\32\313h|r\220\370@\223\203\344\220\243L(I\24\11E\264\310H\64\35S"
"\315\34\272h<\7\211\34\42\207\34BB\221$\42\223DD\242\231h\26\231\210\206\3S\316\36\313h"
"|b\311EM\42\31I$#\211J\222D\222$Q\253\310$\222\324\221P\1S\326\36\274h\34f"
"\211\244\242(\251\204$ZB\25IH\42\222Uf\22ID:\23J\5S\327\34\313h\334\224\213H"
"\42\222I$\241C\35\62\261\210\224%q\310x\42\33N\0S\343\27\253h\34\7;\200\16\240\3\350"
"\0:\200\16\240\3\36\342\0\1S\344\32\313h\234r\220\34$=\20\345 \71H|\210\11eB\231"
"Pv\10\1S\345\35\313h\134r\220\34r\230\210)\225\211H\42R\21\251\210,r\220\34$\7L"
"\0S\357\35\273h\34\7:@f\211\211$\61\221$&\222\304,\61\241\34$\7\311!#\0S\360"
"\33\313h\234r\220\34\42\22*\211*\66\71Hr\20IER\221Tt\220\0S\362\34\313h\234r"
"\220\364\60\21\251\210T\16#\211\34 \211C\346\20It\64\22\17S\363\35\313h|r\220\34$>"
"\320\344 \71D\16:\204\206\22IP\22\21\312\16\21\0S\367\30\273h<\207\230Pv\210\203\17$"
"\71\350&\224\203\344 \71`\6S\370\33\273h\34\7:Hr\210\304A\42\213HE\244\42\262\310A"
"r\220\34\60\1T\4\35\313h|r\220Q\246\22\221\211\346\0\211T&;H$\61IH&\224\11"
"O\0T\10\33\313h\234r\220\34\42\11\213\204\207\220x\16=\304\204\62\241L(;\204\0T\14\32"
"\273h\34\7;\200\16\240X\346\0\212e\22\223Lb\222\211e\16 \17T\15\33\313h\234r\220\34"
"b\224\251Dd\242\71D\16\71D\210\24\241L(;\4T\16\32\313h\334$\253\34$\7\35&r"
"\220\34$\261\250I\324$!\231\360\2T\21\32\313h\234r\210\34\42\7\34\354\0:\200R\241\250P"
"T(\25:\200<T\33\33\273h\34\7\251Ht\240\211\244\42\321A(\207\34B\222\230(\42\23\236"
"\0T&\33\273h\34\7\342\34\60\221MB\22\221L(>\210\244\42\251H*:H\0T\70!\274"
"h|'\212RD%\26Q\231D\224$\21\311D\22\221d\242D\344\0\311T\242&\221\11TJ\32"
"\313h\234b\211X\42>\210$R\221\364@\207\36bB\231Pv\10\1Th\30\272h\34\207\222\210"
"R\31\211\16gJe\22\222L*r\300x\0Ts\36\313h\274r\220pbI\22FB\302\310a"
"\22\22F\42\264HN\24\311T\16\22\2T|\35\313h\374\200\231m$\221D\264\344)\222\61r\230"
"\204\204#\71H\16\222C\206\0T}\35\313h\234r\210$,\22ZB\342C\204\242\22\321\22\321\22"
"\221T\346\0\71H\10T\214\37\313h|S:Hb\222\210\16\42\25\221\204\22\222LD\224\210\210\22"
"\21M$&\71\0T\301\31\273h<G\231P&\224\11\357\10\25\223$\64\222\204F\222\320\245\0T"
"\341\31\313h\134G\231\360v\20IE\7\221Tt\20IE\7\331d\64\35U\61\34\273h\234\226\211"
"H\222bI\21IR,\351\220\224\303$(;\304\204\262C\0UF\31\314h\234\342CI&\226\10"
"\17\24\275\204$\222\311E\377RQ\236\0UO\35\313h\34\25\223$t\61IB\27;db\231\210"
"$\23\221db\231C\346\200\1U\204\31\313h\134j\207\251\370\20\226\36F\22\245\3\35z\210\11e"
"\207\20\0U\234\31\313h\234\322\3Qz\30\11e\207\240Hv\240C\17\61\241\354\20\2U\266\32\313"
"h<\222\220P\222v\250C&\26\65\341Y|\20IER\321A\4Vh\33\273h\34\25\212JD"
"R\241J\17\64It\64\252\134$\21-\21I\205\2V\333\30\233\210\34\207\222$\64\222\204F\222\320"
"D\205\22\273\3\346\220\203\1V\336\27\253x\34\7;\200\16\240T(*\24\25J\205\16\240\3\16\6"
"V\340\32\273h\34\7\223\214$;PF\62\222\214\42\11QB\222\242d\16\70\30V\343\31\273h\34"
"\7\243\204(\71\34\202\22JHBQ!Jh\23:\340`V\360\31\273h\34\7\223\214$;PF"
"\62\312\214B\242d\251\250\214d\7\3V\362\31\273h\34\7\213\12E\345p\210\250PT\16\207\210\12"
"E\205\22=\30V\363\34\273h\34\7\223D\62\211H\42\23\25\242\304\42\242\220H\222\10E$\251\36"
"\14V\372\32\273h\34\7\223\214$;\34B\62\212e\22\223Lb\222\211e\16\70\30V\375\32\273h"
"\34\7;\340@\31\311H\62J\205$\211\220$\222\303d\16\70\30W\22\33\273h\34\7\223\214b\31"
"\311\16\207HL\62\261L(\221J\12I\42\71\24W\37\30\273x\234r\220\34$\7I\17S\71H"
"\16\222\203\344 \351\201\0W'\31\273h<\207\211\34\244*\222\36D\252\42\251H(\23J\16r\30"
"\0W(\33\313h\234r\220\364@\223\3&R\221\360\60I\222\212\244\42\351a\42\207\0W\60 \313"
"h\334B\211$(\221\304(\221\221\204\22\252$I$I\22I\322$\42R\7\311\244\6WB\34\273"
"h<\222\213\262DJ)I&\42\311D$\221$\221T$C\211\342L\0WG\37\313h<\42\251"
"H*\71Pb\22IP\62\21I\204\222\310\212\66:@\16\222\3&\0W\202\30\313h\334\63;D"
"z\30I\224\16\24m\22\245\303T\16\222\36\10W\213\34\313h\374\240\303D%\242%\42\71LT\42"
"\22\212p&\232\34\302r\220\364@W\316$\314h\374\200\231P\22\222\234$!YI\22\222L\222$"
")\62JD$\221D\204\223\210$\242\22\251)W\337\37\313h\334#\241$\42\71\14e\226\10%\13"
"%\27\311&IH\62\221DF\22\251H\0W\372\31\313h\134j\207\231Hj\25I\255\42\331\201\242"
"IR\21J\17\23\0X\2\30\313h<\32%i\207:db\21\251\212\244v\200\364\60\225\36\10X"
"\61\37\314h<rP\245\244\345\42\222HJ\23\221\344\222\244\42\252Dd\42\211L\64\21\251\11X\64"
"!\314h<r\230\304&\21\311$&JH&\71D\324\1\222\323D\222\42\231D\304\42\341d\4X"
"i\36\314h<\352\0\311I\22\7Pj\22\221Lb\223\203\16\24\225\214\222\214\222L\7\2X\203\33"
"\313h\34\62\241\344\242\244%v\260\210TL\22\221\350 R\11KTf\4X\223\32\313h\134j\7"
"\222\342!&\224\35bB\321\201\242IRI\223\35*\0X\227\34\313h\234\42-\61\311E\22\221\34"
",\222\210\226\213\222hR\21\251\212\244\26\0X\353\30\273x\234r\220\34$\7I\17D\71H\16\222"
"\203\344 \351a\2X\360\32\313h\274\302\3Uz\220\203\17\42\211Ht\20\311!r\220\34\24\207\1"
"X\362\31\313h\234\322\3Q|\210\203\17u\310DIE,\21ID\42b\1Y\11\36\313h\234\322"
"\3M\42\224Df\222\210$\42\211,\11E\247ID\16\30OF\323\1Y\17\30\273h\34\7\232\34"
"p\210\11e\207\230Pv\10\332Hb\42\251\0Y\25\30\312h\234r\210\34pS\22Jt\223\304\1"
"r\200\34 \236\316\1Y\26\36\313h<\62\241LX\11J$\61\221$\66Q\212L$A\211\222\252"
"H(S\224\1Y\32\32\313h\234rPU$\233\244\3&\301\311!\244F\21\255\3\306S:\0Y"
"\34\32\313h\234r\220\364@\222\210%%\25\311D\222\337FB\321P\242\66\34Y\42\33\313h\134\22"
"\341\201$\21\36&*\21\311a\16=\224*\22\212\34\60,\3Y'\32\313h\234r\220\34$\7I"
"\17D\71D\22\7H\302\42\251H\250$\36Y)\31\273h\34\207\251\34$\7I\17D\71D\22\7"
"H\302\42\241\222x\0Y*\35\313h\234r\220\34$=\20\345 \71D\22\7H\302\42\351H&\21"
"I\344\0\1Y+\31\313h\234r\220\34$=L\345 \351\201&\211\3$a\221PI<Y.\32"
"\313h\234r\220\370\20\223\250I\324$J\7\332\34\42\11\213\204J\342\1Y\61\31\313h\234b\211X"
"\42>\204TE\322\3Q\16\221\204EB%\361\0YO\32\313h\234\322\303T|\20J\202\7\212l"
"$\241\14\245\207\331D\66\234\0Yn\33\313h\234\322\3I\222v\220ID\207\232Dz\230\210T\16"
"\23\221\312a\2Ys\32\313h\234r\220\34$=\320$b\211T$\25\11%s\310x\62\232\16Y"
"}\37\313h<r\220\304$\225\224TB\62IH&\71HD\62\222P\22\221\11e\301\31\0Y\271"
" \313h\34B\231P&\262\220d\222\220Lr\230\204d\21\11\211\222I\22\221\20eQ\31\0Y\273"
"\31\313h\234\322\3Q|\10KD\7\242Dt )\216\304D\322\10\0Y\311\36\313h\34B\231P"
"&\71\224d\222HE\222\213$/\222,\224L\22%\241,*\3Y\313\42\313h\34\62\241L(\211"
"HB\224\220D\222\62\221T(\321\211\244B\11\251\210$\42\225\230\5\0Y\324\32\313h\334\63;D"
"z\240Q'\21\221Dv\260\211\204v\300DD\224\0Y\377\35\313h\234R\321E%\42\223HB*"
"!\311h(=\320D\302\211\34@$M\0Zf\42\314h<\22\233T&*\21E\222\310A\222\211"
"\22\71D$)\22J\212H\42\211(\12\243B\0[P\31\273h<\207\70D\16\221C\344 \351\201"
"(\7\311Ar\220\34\62\5[W\31\313h\234r\220\364P\207L,R\71Dz \312Ar\220\34"
"\62\5[X\32\313h|r\220\370@\223C$\65\335&\207HL(\23\312\204\242\31\0[]\31\313"
"h\234r\220\322!,\211\35\210r\300i\355@\224\203\344\220)\0[c\31\313h\274$;Hz\240"
"Q'\21\221\244\42\25\36\246r\220\34\62\5[f\33\313h<J\62\211$t\250C&\26\251\34\42"
"=\20\345 \71H\16\231\2[k\37\313h\374\20\11\243H(\231\210d+*\223JD&\321\222$"
"\221DT\42\222\232\14\0[\205\30\313h\234\322C\35\62\225\310\210u\220\34t\260\203\344 \231\324\2"
"[\207\31\313h\234\322C\35\62\271\4\345 \351a*\7\311Ar\220\34\62\5[\210\32\313h\234\322"
"C\35\62\225\210e\207\71@*\22K\344 \71H\16\231\1[\211\31\313h\234\322CI\70\22\312\304"
"\7\222\252HX\211\3\306\223\321T\2[\214\32\313h\234\322C\35\62\261\310\261\34h\222\70@\22\226"
"\210$\42\21\261\0[\227\31\313h\234\322C\35\62\261\310\261\34\210\222\240DM\42\222\210\24\247\0["
"\230\30\313h\234\322C\35\62\261\210TER\253\34t\224\11e\302\23\0[\231\31\273x\234\322CM"
"\66S\71\304$j\22\265CL\242&Q;\204\0[\232\31\313h\234\322C\35\62\207H\16a\71H"
",\251I\304\223\250d\32\64[\235\31\313h\234\322C\35\62\207H\16a\71H|\7\310A\22\261H"
"r [\237\30\313h\234\322CM\66S\71\204\305\207\260\364@\223DG#\361\0[\242\32\313h\234"
"\322CI\70\252\210\324&\351\220)e$\71\204dB\231\360\4[\243\30\313h\234\322C\35\62\271\304"
"\241\207\230Pv\210\11e\207\70\370@[\244\30\313h\234\322C\35\62\271\304$a\321\350\42\225\36\246"
"r\220\364@[\256\31\313h\234\322C\35\62\261\210TER\263\34p\210\11eB\331!\4[\263\30"
"\313h\234\322CM\66\271\4\305\207\260\364\60\7\37bB\331!\4[\266\36\313h\234\322C\35\62\271"
"\304\344\20I\226ID\22\223HB\223\214\22\225\221\332\24\0[\271\33\313h\234\322CEi\42\222\350"
"$\221$\212\204J\7\212P&\224\35B\0[\277\34\313h\234\322C\35\62\71\210\24%\226\211H\222"
"\42R\61ID*\42\25\13\0[\304\33\313h\234\322CMv\240J\242#\331\201\16\220Yb\42I"
"\314\22\207\214\0[\306 \313h\234\322CI\70\223D(!ID\22\21M$\21I\350&\221\212T"
"D*\207\11\0[\314\32\313h\234\322C\35r(\11e\207\70\370\60\21\251\34&\42\225\303\4\0["
"\322\35\313h\234\322CE\351@\11I\204\7\241Dx\30I\42\62\221D\24\231\15\207\0[\337\33\313"
"h\234\322C\35\262r\221D$\21\321LB\211\310\1\7\213&\215S\0[\370\32\313h\334r\220\34"
"$;\220\345 \241L*\222\212\344 \71H\16\231\1[\372\31\313h\234\322\303T\16\222\36\310\262\3"
"IY\42\226\310Ar\310\14\0[\376\37\314h<R\231T&\25\35jJ\22ID&\211H\202\42"
"IPM\22\23i\12\217\0\134\2\32\313h\234\322\3Q|\210I\324\16\61\211\322\201\42\223\212\344 "
"\71d\6\134\4\37\313h<RIM\242&\71Xd\222JDe\222R\221\304f\42IL\242&\33"
"M\0\134\6\36\313h<\302\221\204\26\311\42\231H\222$jB\331\301(\212$\311$jB\231l\4"
"\134\12\33\313h\134j\7\232$z\20IRD\223\322A\16\220\35H\312\22\71d\6\134\16\34\313h"
"\34\42\211Lb\26NL\22\221\212E\62\222\204\16a\331\201\244\16\231\1\134\17\34\313h\234r\220\34"
"$\7I\202\22\65\211H\42R\21\311f\212r\220\34\62\5\134\21\34\313h\234r\220\34$\11J\324"
"$\42\25\31I\242\64\221C\344\20\71`<\7\134\61\37\313h<\62\231%\35 \71\34\42j\22\265"
"\212P\64\233Dd\221\210$\242\22\221\24\11\134:\32\273h\134\207\230P&\224\11e\207\230$\16\220"
"\204ER\231\252(\16\30\134@\33\273h<\7\221Tt\20\311A\207\211X\42aQ\241\250\214*r"
"\300\4\0\134E\33\273h<\7\221Tt\20\251\36&\42\251H(\271H\202\222\210Pv\210\0\134J"
"\34\273h<\207\211Xr\230\210\244\207\311D$\231\210(\207ID\64Q\22\35\4\134K\33\313h<"
"\7\221Tt\20\311A\207\211JP\22\32]hB\311%(<\20\134U\32\273h\34\207\211Xr\230"
"h\223\134\264\35&*\241\221D\222D\211\15\7\134^\34\313h<\7\221Tt\230Hj\224\64IM"
"$=\230$\21\312!\62\224H\7\134d\33\313h\34\7;\340!\22\321r\221D\264\134$&\211H"
"\24\62\205TM\0\134q\31\312h\234r\210\34\42\207\310!B\221\210$\42\211H\42\222\350p\26\134"
"\251\34\313h\234R\221\212H\345\60\207\36Hr\220\34r\220H\202\222\210Pv\210\0\134\270\32\313h"
"\34\42\25\221\312a\16=\330A\222\213Lx\260\11\203r\220\20\0\134\366\34\313h|r\300!&\224"
"\35bB\331a\42\7\35fB\212\312a\42\7L\0]\335\35\313h<b\211HE\244\42R\21\251"
"\210TD*\42\25\221\210&\242\3\346\20\1]\336\37\313h\134R\221D\244\42R\21QT(\21I"
"DK\222D\244\42\222\210T\304t\200\0]\343\33\313h<\222\220P\222v\230\210T\16\23\221\312a"
"*=\220l\23\11Q\12]\345\25\233x\34\207\251\34$\7\311Ar\220\34$\7I\17\4]\346\31"
"\313h|r\220\34$>\320\344 \71D\16:\204\24e\302\240\364\60]\356\31\313h\134\312\222\340a"
"*>\204\245\7\212\34t\220\310\204A\351a\0]\361\27\272h\34\7\71D\16\221C$\7\211\34\42"
"\207\210\231%\7\1]\373\32\313h\234b\211\242$\355\60\224\4\17$\305CH(\21Y\205\302\13\0"
"^\2\32\313h\234r\220\364@\24\37D\22\221\212HE\244\42RQ\226\203\244\0^\3\35\313h\234"
"r\220\364@\223\304\1\222\360!\64\321\22Q\211h\223\250I\350\0!\0^\14\33\313h\134#\61\255"
"$\25\37H\22\351A\42\211\250D\264I\210\22\71H\10^+ \313h\34r\220\350@\222ED\62"
"\312M\22\261\244L$)\23I\312D\222b\222\203d\0^-\34\313h\274\302\203E$:XD*"
"&\231Pr\221DT\42Z\42\22:@\10^/\31\313h<\232\16\24m\207\70\370P\223M.\21"
"m\22\65\11\35 \5^\60 \313h<\222\232P\24\211\224\42AQ\344\60Q\232D.\222\24\221$"
"EKDM\30\24\2^\63!\314h<\42\223j\205\24\311\32I!E\262F\42\227,*\221ID"
"&\222\4E\223\230d\64^\70\33\313h<\32%i\207\212e\42\222\210\354\0\361A$\21\251\210T"
"\224\245\0^U\31\313h\134j\7\222\342!v\210\11E\7\212\246\303$E%\242Y\12^r\30\273"
"h\34\207\251\34$\7I\17D\71H\16\222\203\344 \71H\12^s\32\273h\34\207\251D&Q\224"
"\244J\242\7\242\34$\7\311Ar\220\24\0^t\33\313h\134r\220\34t\10)\312\204\221CL\42"
"\226\10\17T\71H\16\22\2^x\30\313h\234r\220\364\60\225\36(B%\331\201(=L\345 )"
"\0^y\34\314h<BYI(\223\204*!I\350b\222\205\324\16$\241\254$\324\15\0^|\35"
"\313h\134\252\42\241L\26\211\34$\272D\224TT\42\272D$&\322H(\231\0^\201\32\313h\274"
"\322\303D\16\222\203\16\23\231P&\224)\312\204\262\250\34\62\3^\203\32\313h\274\322\303D\16R\25"
"IER\221T\242\244Ee\42\241\311A\2^\217\32\313h\274\302\203\35$\271HE\42\332\301&Q"
"\223\204\202\302\240\34\62\4^\225\35\313h\234\322\203q$!J\42BID(\271HB\62IHf"
"Q\7\34(\2^\227\35\313h\274r\220\364\60\21IER\221E$\25\11%\27IP\22\21\312\16"
"\21\0^\234\42\313h\234\322\203E\244\42R\211\34\42\61\21%\42\222D$!ID\22\222\304D\21"
"\231P\64\2^\246\32\313h\234\322\203E\355`Q\223\324\344 \211I\242\26\33\206&\42\342\0^\247"
"\37\313h\274\302\203\35$\211HB\222\210$$\221$M(\21\231\210r\11\12\203\322\303\0^\253\32"
"\313h\274\302\203Mx\260D\264\134$\21-\27\231\60r\30\312AB\0^\255\33\313h\274\302\203\35"
"T\253HF\222\230\350`\21\211&!\25\211%\62\24\26^\267\33\313h\274\302\203M(\271\310$\222"
"\203M\242r\221DTB\246\210\312p\10^\366\34\314h\374\220\11\253H*\23\212$,\311\222DI"
"V\211$z\230H\306\301\3^\372\35\314h\334BJQ$\211I.BI\210R\24\11%\221\232\352"
"\304\42\231\4\203\7_\1\32\313h|r\220$,\32]d\42\251H*\222\35H\252\42\241LQ\6"
"_\17\33\313h\274r\220$\16\220H\16T\341Y\42\26IERJ\312p\16\222\0_\23\31\311i"
"<w\200\34 \71D\344\0\71\340 \7\310\1r\200XH\2_\25\32\312h\374\220CH(\22\212"
"\16!\362!$\24\11EB\221P$\241\11_\37\33\313h\134\312\222\340a*\22\35$\42\351\201("
"\223\315$\223\30I\62\225\2_\61\27\273h\34\225\232\360b\24VjB\212\26\222E\233P\62\233\0"
"_\65\35\273h\34\224\232$\16\220T(\321\230\205\22\7\34D\222l\222\210LB\211(\12_\67\34"
"\313h\274B\212$(\11\311\16&\311\314B\311&\251I\262\211$j\27\222\0_S\32\312h\234R"
"\211\232$\42\223$\35\346\20\71Dr\220C\344\220C\35\42_b \313h\374\0\221E$Q\223\250"
"DT\42\22\213H\42RQ\241\10)\62\211\222($\221\1_y\37\313h<\222\232DI\222\242%"
"\42\211Hb\223Ch\242\24\211\250\211\206\242\241D\215\66_\200\35\313h<\42\251L\345\60\11\311\42"
"\42\241L(\261\314d\221\230P&\224\11%\7_\204\37\313h<r\220\304\42\11J\42*\61E\221"
"$\64\221D&\61\241\304$\23\312\204\207\1_\205\35\313h<\42\251\304\42\211\10#\252\207\211Pt"
"\250$\311$jB\231P&\33\1_\213\36\313h<\42\251\304\42\223H\42\7\211H\242r\221\11%"
"\27\231Pr\230\11eB\0_\214 \313h<\42\251DI\242\26\211Lb\22\221Db\231\211H%"
"\311D$\233\211&\241\332\0_\222\36\313h<\42\251H(\271$IEB\311a&\224H\202\22\11"
"E\22\21\216fR\2_\223\34\313h<JZ\324$\241H\344\42SQ\223H.j\22\65I\66I"
"d\66$_\227\35\313h<r\220\244$\21\211\42\221\232$\244r\230\212\16\26\221\26\221T$\34\1"
"_\251\35\313h<\312\222\203$I\22\71\204$\42\25\313H\30\11\225$j\242\241D\215\66_\263\42"
"\313h<\62\241\344 \11\311$\7I^$\271H\16#a$\42I\222H\42\222Ih\42\252\0_"
"\303\35\313h|r\230\34&\7H\342\0\71@\22\23I\202\24!E\70R\25\211K\0_\305 \313"
"h|r\230D,\21\312\204\42\231$$\211H\42\42J\332d\16\221\311f\42\211\11\0_\327\34\313"
"h\234r\220\364@\224\203\244\207\71\202$*\211h\211H\42j\222\230\11\0_\330\33\313h\234r\220"
"\364@\221\203\344\260\263\34 \21J\42Z\242\23\231$f\2_\334\36\313h\234r\220\364`\23\252\211"
"$\61I\222D\222FI\233D\224\42\21u\0\11\0_\340\35\313h\234r\220\364\60\21\251\210T\16"
"S\71@\22\225D\264DD\23\231$f\2_\353\35\313h<\42\251H*\61\251H(*\223C$"
"$\25\15EC\211\232$&\232\12_\365\37\313h\234r\210$,\22J&!\361\344\20\207\310\1C"
"IDKD\64\221Ib&\0`\35\36\273h<\7\221D$:\210$\42\25\221\350 \223D%\21"
"-\21IDM\22\63\1`%\33\313h\134r\220Q$<\310A\302;Ht\20\251J\42*\21\231"
"$f\2`'\37\313h<\62\241D\22\224\230$\222\30%m\22\221E\42&\231P&\224\11eB"
"\311\1`i\35\273h\34\207\211H\345\60Q\211HH\224\303L\22\225D\264DD\23\231$f\2`"
"o\37\313h|r\300!&\224\35bB\331!&\224\35B\222$\211$\42\232\310$\61\23\0`\252"
"\34\273h\34\7\232$x\230\250D$\207\241$x\260\244J\42*\21\231$f\2`\262\36\313h|"
"\222`\205(\11V\210\222`\245&\11K\204\42\25ID\64\221Ib&\0`\305 \314h<\62\251"
"\344$\223JL$\341\344 \211\210d\22\233D$\223\330$\42\231D\62\2`\363 \313h<r\310"
"a$\21I&\26JH\222bI\21\251X$\251\222\210JD$\221\325\0a\17\35\313h\234\322\303"
"L$;P\204\262CL(;\204$\251\222\210JD&\211\231\0a\33\33\313h\334\224KP\222v"
"(IB\223\24IHR\231TLb\362D\66$a\37\37\313h\274\22\311\301&\264\244\10%\21\213"
"JD\22\221\230\204RID%\42\223\304L\0aK \313h<\42\211\226Q%D\231\34$\21-"
"\243J\210\42)I\242\222\210JD&\211\231\0ac \313h<\42\213H\222\42\71P\262L,)"
"\207HD&\221\134\324$\222\213H\42\222\310\4a\262\35\313h\234\322CM\66\271\4\245\7\213$\42"
"\71L$\251\222\210JD&\211\231\0b\20\37\313h\274\222\70@\42\71\330\204\62\211\244\22\321\222$"
"\221\214$j\223,\223$\222P\0b\21\36\313h|\222 E\22\224\250I\204\7\222DM\242FI"
"!\15%\222$Ih\62\25b&\36\313h<*Y$)\24\65\213%\62\263\244Hr\261\10E\243"
"K\222D\62\222\304\4b\70\31\273h\34\7:\364 \222\212\244\242\203H\16\222C\344 \71(\16\3"
"b@ \314h\374\220Ie\16\221V\242\22\311!\42\211\210*\21\221L\42\322\247\220L\24\7\210\0"
"bK\31\313h\374\0\71`X\7I\17S\71Hz \312Ar\220\34\62\5bM\33\313h\274r"
"\220\34$<P\345 I\34\60\7\214'\301\221\34$\207\14\1bS\33\313h<r\220\344\42\24\321"
"\24eB\331L\64\224\11eB\231P\64\33\1by\34\314h<\32%\212\22\65JD\213M\242\70"
"\211\310&\212\22E\211.-\42\2b\34\273h<\207\70D\16\21U(!\211\332!&Q\222T"
"\42\42\225\230\332\24\0b\200\36\313h<\62\241L(\71\220\204\62\241\304\64\224\214$\61\331L\66\23"
"I$\23\231\0b\225\36\313h<\222\232DM\242D\211H\42\222\330d\16\221X\246\42\225\230\242d"
"\22\252\15b\230\36\313h<R\221\244&\221R\302\222\213\266ID\64Q\223\204d\222\220l&\32\212"
"\0b\305\37\314h<r\230\304&\21\211L\62\211M\42\222MB\242\211H&\261\311ar\320\344\20"
"b\333\32\313h<r\220\344\42\223\230$J**#\362\344\242&Q\223\250U\16b\335\34\313h<"
"r\220\344\42\223QJ\62\241\304\64\222\315\204\222\213L(\223\315d\0b\341\36\313h<\62\241L("
"\71\324\1\222\210P\22\21Rd\223l\222\24\221$eKY\0b\376 \314h<\62\251L*\222\304"
"(!\231\344\64\226\314!\23\233D$\223\210d\22\221hb\2c\1\33\313h<\42\251\304\244H\221"
"J.B\331\301\22\222I\324\204\62\241h\66\2c\7 \313h<\222\70@\22\32IhE\211\344\42"
"\7\35$\223\230Hb\222\304D\222\230db\1c\31\34\313h\34\22\221L\242t I\244\67\211H"
"\24\261\10\245\7\261\34$\7\214\1ch\35\313h<\62\241L(\222\204,\21\25\223Lx\260\203$"
"&\211HE$\231X\0c\210\36\313h<\302\221\204\242%b\11\251\134$A\311\244\62Q\23Ib"
"\212\42Ih\42\32c\241 \314h<B\222\204\42\222DT(\331$\212\62\351a\62\42J$i\222"
"\210\322HT\23\2c\242 \314h<r\230\344$\311\205\42\11J$$\231\364\60\231IED\211$"
"M\22\221\330\204\0c\245!\314h<\62\251\344$\21\211(\222\240\344\20\221I\17'\211L$\221I"
"\212\62Ih\62\222\0c\250\36\313h<\42\211H%&\71P\42\62\211\232\304\64\211\210&j\22\223"
"DM\242\64\71c\320\37\314h<r\230\304&\21\211(\65\211Hv\30\311\204\23IT\42\231I$"
"\321\311pXc\356\35\314h<r\230\344$\211\250Pj\252\222\23Eer\222I%\207\210L\70\23"
"\2d\15\37\313h<\22\223$&\222X\350\20\211I\22\23\35$\23\223$&\222\230$\222IQ\0"
"d\315\36\313h<\22\223D\244b\271L$\271H\66\311&\27\21M\42I\222D$\65\31\0e/"
"\32\313h\274\302\3U\16\222\36\242\42\251H,\211C\344\20It$\232\16e\71\37\313h\274\302J"
"\34 \251I\42\22\223$\66\221\204$IQYH\62\252$\213dC\1e>\34\313h<\42\251H"
"x\25Y\224D%\225l\222L\22\65\211$)\64\22\21\5e? \314h\274\322;@\42\7H,"
"\22\212H\22Q\222\344$\211\251\244\310$*\241\221\342P\0eE\36\313h<\62\241L(\22V*"
"J*)\222JD\313H\42R\221\214*\21\341L\0eQ\36\313h\134\23\251$\315B\222\250Dt"
"\311EI\66\211\210$)\242\210\66IHD\24eW\37\313h\274\302JP\42\271H\42\22\223D\62"
"I\251\214$\42Qe&IQR\11\11\5eY\37\313h<\62\241D\22\253\10%\221CE$\231"
"H*\222\24\321\220\42\42\15%J\65\1ec\37\313h\34\222\210\260\22\224D\16\224\210T$\61I"
"T\222*I\22\265J\222d$Q\24el!\313h<\222\210\314\22\224D*\42\211\344\242$I\241"
"d\221\244\210$)\42JD<\221\15\5ep!\313h<\222\304HF\312\201\22\21MB\222I\212"
"$I\22\262\210$\42\21i&IQ\222\11et\35\313h<\42a\305\222ER\211H(\21Q$"
"E\22R:T\305\22\223Dz eu \313h<\42a%(\211\34\42\21\25\223$E\222R\221"
"\344$*\251\250D*\21Ih&e\207\32\313h\234r\220\364@\222\11eR\211X\42\7\314!r"
"\210$,Z\35e\231\42\314h<RQ$\213\210$\211IE\225\210L%D\274DH\221\310D\24"
"\211\312\244\62\251\10\0e\255 \313h\134BIDB\222H\202\21\305CEKd\22\221Dt\211\250"
"D\264\230\344 \11\0e\260\42\313h<R\311A$\221\4%\222\340\201\42\222H*\21\321De\222"
"\42\231\210$\331DR\11\0e\271\31\313h\234r\220\364@\223\203\344 \253H*\22\312\204\62E\221"
"l\6e\305$\314h<\42\261Hz \251\4%*!\212$&\211\14%\21IH\62I\222h\11"
"ID\222\221\20\0e\317\37\313h<\42\251Hx\240\250\4%\221\26\231$$\223\34$\42\25\225$"
"ID\64\211\11e\327\42\313h<\42\251\344P\211\210$\27\221DD!IRD\222\10E%\242r"
"\20I$\241\211H\0e\345\16\270i\34\207!\307C\221\343a\0e\347\34\312h\34r\210\344 \221"
"Qd\24\31\345 \221Qd\24\31EF\71\310!\0e\351\30\273h<\7\221Tt\20IE\7\251"
"\34$=\20\345 \71H\12f\16\34\273h\34\225\213$D\221\204.\27I\210\42\11Q$\207I\210"
"&\22\312\324\6f\23\33\273h\134\207\230Pv\210\11e\207\240\34r\250\250\304$*\23\221l\62\1"
"f\24\32\313h\134j\207\231H*\222\35\350\320CL(;\304\204\62\241\354\20\2f\37\30\273h<"
"\7\221Tt\20IE\7\221D|\220\210\244\221\263\364@f \313h\274\302\221\60\22\261\344\42\311"
"E\62I\221D\16\223\320,\22\221\304&\252\62\321T\0f%\32\313h\234\342CXz\30J\202\7"
"\212P$\251\244\210$\42\253Hj\3f(!\314h\274R\212\64\42\71D$\211\21Ib\245\22\21"
"\11#\42aDT!\311ar\230\20\0f-\34\273h\34\207\212H\62\21I&J\226\310$\62\216"
"H.\222\230%&\224\11\17f<\32\274h\134\207\240\342!(\23\36D\222\230$\345\42\222I\357("
"\7\12\0fB\37\313h\274\302\211%I\30\11\11#\207\242(r\230$\211\42\21\245HP\64\224C"
"F\0fi!\313h\274rHi\22\221E\16\221\134$\223\24I\212%E\22\213D$\261IDI"
"E\221\0fo\34\313h<\207\230Pv\210\11E\7:\364\20\23\312\16aIP\242$\31I\0f"
"t \313h\334\262CE$\213H*\21\221\354P\221\204$\21I%\42\11I(U\221T\62\1f"
"\221\31\273h<\207\230Pv\210I\224\16SI\354@\231\211$F\231\360\4f\226!\313h\374\200\13"
"e\22\221\344r\210\204\204\207JH\30\211XR&\222Id(\231\204$\62\1f\227!\313h\334\262"
"CE\22\222D$\21Q\344`\7D$\225\210$$\211H*\224\220T$\265\0f\256\33\313h\134"
"j\7\222\342!&\224\35bB\321\201\62\32I*)\42\211\310\6f\264\33\313h<\207\230Pv\210"
"\11E\207\231Hv\240h\222\344\305R\221\14\247\0f\334\35\273h\34\207JH\64\211L(!\321\341"
"\222\42\213D\16\221\211lb\224\210\17\1f\362\33\313h|\22\261D,\221\35,*\24\225\303!\242"
"BQ\241\250PT\16\6f\370\32\313h\234\322\303T$\71\20E\222\303Tz\240\10e\207\230Pv"
"\10\1g\0\35\313h<\207\230Pv\210\11E\7\213\370\60Q\211H*\222\210\312\250\22\21\316\4g"
"\10\30\272h\134\207\220P$\24\35BB\221Pt\10\11%R\211\224:g\11\33\313h\234\322\3Q"
"\16\221C\16\261\231HbQ\223\204\216\62\241L(\232\0g\15!\273h\34\224C$\215\222\62\241D"
"%\221\212$IB\311\42I\21IRD\222\210JD\22\23g\27\37\313h\134r\200\305$\211\34\42"
"&I\344\20\211PB\27\25\312$b\21\321DB\321\0g\33\31\313h<\242\312E\255\42\223\250\225"
"JB\311\350\60\25\37\302\322\3\1g\35\36\313h<rH\213Ht\11\215$\207Ih$\11]*"
"\42\321%$Q\223Hb\3g\37\34\313h<\312\22\311\241\242%\42\251PT\42\222JD\313\241\242"
"\222DZ\23\15g(\31\313h\234r\220\34$=\320\350\0\262$Q\242\244%\246(\7I\1g*"
"\31\313h\234r\220\370\20\226\203\244\7\242\34B\235DDJC\71H\12g+\31\313h\234r\220\364"
"@\224\203\304\207\260\34B\235DDJC\71H\12g,\32\313h\234r\220\34$=\320\350\0\262$"
"Q\242$\251\244)\312AR\0g-\33\313h\134\22\261Dx\226\210%RJt\42\224D\204\21e"
"\211HE\244Tg:&\314h<r\230\250&\222\210*\21\231H\42\32ID\24\245I\212(\22\222"
"\210\42\21\221$\242$\211H\202\3gP\35\313h<B\231P&\24\35(B\321lDZ\311\24\211"
"(E\222dB\231l\4gQ\33\314h\134BM\207\222P\66\224Q\42\42IN\222\220$\24\21\352"
"\333\10\0g_\32\313h\234\322\3Q|\20ID*\42\321AH\226$J\224\224\206R\0ga\32"
"\313h|r\310m$\223H\302\266\211\204(=\320\250\223\210Hi(\5ge\33\313h\234r\220\364"
"\60\222(J\42BI\332\201F\226$J\224\224\206R\0gq\32\313h\234\322\3Qz\230\210T\16"
"\23\221\312aH\235DDJC)\0g~\42\313h<\42\232H\22\242Hb\22\221\212$e\22\221"
"\230d\221\214\221\220$&\221\214$\24e\1g\37\313h<r\220\344\242j\226X&\42\11%\313"
"D)\22Q\212\244HB\222\24\321$&g\227\36\313h<\62\241Lv\240\310\204\23\22\205\64\221\344"
"\42\211LR\204\62\241L(\223\1g\232\42\313h<\42\251H*:P\42\42\211HB\11I&\231"
"&\231\42\61Y$\66\23ID\22\231\0g\234\32\273h<\7\221D$:\210$\42\321A*=\320"
"\250\223\210Hi(\5g\235\37\313h<\62\241L(\71T\204\62\331\304B\224\254\204\42\61Y$$"
"\211ID\42\242\0g\323\35\313h<\42\261D(\261\3$)\23Id$\32J\17\64\352$\42R"
"\32J\1g\361\35\313h<\42\251L(\71\220\204\62\341H\66\261\314d\221\230,\22\23\312\204\222\3"
"g\373\30\313h\234\322\3\215,I\224(I*\42U\253Hj\25\311\16\4h\4\34\313h\34\22\231"
"H\242&\221\304\16\65\331Lv(\222%\211\22%\245\241\24\0h!\42\313h<\62\241L(\71P"
"$\61\211H\62Q\251HB#I(\22\223EB\222\230D$\42\12h*!\313h<\62\241D\22"
"\224\270\4%\21\331\344@\222M\42\243H\210\24\211H\222$\21m\62\0h\71 \313h<r\220\304"
"$\21I(%\211H\62\261PD\25I.J\221\210\232\204\22\222\310\4h<$\314h<\42\261\250"
"&\222\210(j\222\310l&\11QD\222\211E\22\222\210\42!\211L$\221\211J\0hH\32\313h"
"\234\322CI\70\271\204\224\251\223\210\350@\243N\42\42\245\241\24\0h\134#\313h<\42\211H\22\221"
"\204$\222\24\213L\215\42\234\34&J\221\210R$B\24Ib\22\221\4\0h\205\36\313h<\312\222"
"\3%,\61I$)\224,\223\303D\222\213$\227\213$&\222\215\0h\260\42\314h<\322\221T\22"
"\221\34\212\62\211$\211\222ib\241HR$\21ID\222Ei&Q\23\11h\322\37\313h<\62\241"
"\344\42\223QJ*\241\311\201\222e\22\231Hb\262H\344\42\23\312d\0h\356 \313h\234\322\303\220"
":\211\210\224F\222\210P&:PF#\211$\42\211H\42\222\220L\4i\15\37\313h<B\231\344"
"\42\24UH*\42I\204R\211H&\21J.\222,$I\34 \71i\34!\313h<\62\241H\22"
"\223\210$\7ID&\233X*\222\310\304\222&\213\204$\61\211HD\24im\31\313h|\222\250$"
"\323\201\244v\230\212\17a\351\201$I\224(i\1iu\36\313h<r\220\344\42\22R\302\222\211M"
"r\210H*\271Hr\241H\42\242\241\344\0i}\33\313h|\342\210\205\22\222\304\214#\212\244\42\224"
"\36h\324ID\244\64\224\2i\313\35\313h<\332$&\211\322a$Q\232\34(Y&\226\24I."
"\27%\25\311\4\0i\330\37\313h<\42\211Hr\221\311(%\231lr\250H*\222\234H\221\210$"
"I&Q\232\1j\31\36\313h<\222\213H\22:P$\271H\16t\300\304\222\16I\271\250$I\42"
"\232f\0j!\36\313h<\42ILr\250\244I,\224\220db\231X\322d\221\310E\64\224\250\321"
"\6j) \313h<\312\22\223$\42\243XD\222\330\344 \221\304(\225\24I,\22\61I$A\311"
"\1j*\42\314h<\42\211Lr\241\250I\16\21\231pr\241\244H&\227\24ID\222rR\221I"
"d\22\0j\71\37\314h<\42-\24\221\226CE,\231T\42\25\225\11E\222E%\245\22\42\212\244"
"\23\0jK#\313h<\22\223L(\71P$\61\211H\62\211L*\222\320\344\20I\231H\362\42\211"
"L\42\222\330\0j_!\313h<\42\211H\242&\261P\42\222\210\344\60\223D\16\227\210$\213R$"
"/#\211\312H\0k \32\313h\134r\220\34$\7\35$J*J\352\240\71@\22\26\11\225\304\3"
"k!\35\313h\234R\221X\42\226\334$!\25e\251h&\222\304D\22QH&\211H\5k\62 "
"\313h<\222TI\242\350\20QR\311$\211\310D\222\230%&\221$I$I\222\221\244(kL "
"\314h\334BKp\22\251\344\313$E:\221\225\304\222\331$\42\11E\262\210&\62\331T\0kb\32"
"\313h\234r\220\34$\7\211%b\211I\42\226\210%b\211X\42=\20kc\30\273h\34\207\251\34"
"$\7\211%&\211X\42\226\210%b\211\364@kf\35\313h\334\222\210%\42\226\35H\252\42\231\244"
"&\11\311$\61\311\204\22)\316A\2ki\33\313h\234b\211XR\223\210%\322\3Q\22\224(I"
"&\31%\302)\35\0ko\35\313h\234bIM\42=\134$\23I.\207\211\204\242\222\313D\62\21"
"\251\34&\0kt\33\273h\34\7\213Hd\261\210T\266d\231H\222$\21aDR\211(\36\10k"
"{\34\273h\34\7\212H*\222\210(\21-I\22\265Hf\211X\42\222\210D\304\2k\213\35\313h"
"\334\222\210%\242b\242\10%\26m\223CD&\11\311F\262\311hB\207\10k\265\34\313h\134\22\322"
"DIE\244\42\261\225,D\211L\22\222H\222fZBJ\3k\272&\313h\34\21\11I\22\221\304"
"D\222\220D\222\42\23M\344\20JI\42\222P$\241ID\26\11Ib\22\321\0k\315\33\274h\134"
"\207\240$$\224(*\35*J\62\221D&\25\35(R\71d\10k\316\33\313h<r\320\241\16\212"
"\34%\21\241$\42:P\264I\224\16V\71`\6k\322\31\313h\234\322\303Tz\230J\17\24M\7"
"\213Ht\220\203\344\200\31\0k\324\35\313h\34\62\241L(\23\312$\222JDM\22\222\315\24eB"
"\211$T\22\21\13k\333\27\313h\334Sb\35$>\14\345 \361\201&\7\11eB\341\1l\17\31"
"\313h\334r\300\320*\222\212\244\42\213U&\224\11U(\42\11u\0l\21\30\273h<\7\221T$"
"\25\35D\252\207\211L(\23\252Dhf\1l\27\36\313h<r\320A$\207Hjq\330A,\221"
"M\42R\221P\22\221D\244u\200\0l\64\35\313h\234r\220\34\244:\221\134\242\223\360$*\211\310"
"$\42\211H&\224C\246\0l\67\36\313h\234R\221X\42R\231H'!J\252$U\22\221ID"
"\22\221l&\207L\1l\70\34\313h|s\230\34\215$\235\204\16QI\252$\42\223\210$\42\231P"
"\16\231\2lB\35\313h\234r\220$\16\220\210\16D\251h\42\222L\242\223\340$\42\322*\223M\1"
"l`\37\313h\34B\25I\34 \211\305$\23\21%FI\225$I$)\42\211H\65&\33\32l"
"z#\314h\34\62\261H\16\70\204\202\22\221L\42\7Hd\7\212h(\222\4E\22YH&\212H"
"%\0l}\35\313h\34\222\70\344 \223\3\42\221\222\34x\7\311\204\42\251d*\221\3\350\20\1l"
"\263!\313h\34r\230\344\16\221\304\1\22I%(\221\4%\222\220\204\22\21K\304\222\70@\22\236\0"
"l\271\34\313h\34B\65\71H\26:L\264I\324$Z\16\22\25\212\312H\42\31\35\2l\273\36\313"
"h\34\62\251H\16\222\204b\42\211J\251$\207J,j\22\65IH&\11]\0l\277!\313h\34"
"\42IP\42\211\3$a\221(\244%(\222T\42\222\220\212HE$\12)\205L\0l\311\33\313h"
"|r\300!&\224\35bB\331!,\222X\204\222D\211\222\322l\12l\325\36\314h\34B\251L\16"
"\70D\242B\345\303X*\222\304TD*\243\20I\22\207H\0l\342\36\313h\34B\65\361A$\221"
"PT\202G\231H\242$Q\223Df\21ID\24\231\15l\343\37\313h\34\62\251H\16\22F\16d"
"\241L(\23ID\22\221D\244\42\212ID\221\203\0l\350\32\313h\34\62\251L|\220\312\204r\220"
"\34`\222)\312\204\262\250,t\10l\363\35\314h\34\262\251P\216\22\243(\262\310\1\22\241D\222$"
"\321%$\232\12\203C\0m\13\34\313h\34\22\221L\242,\211E\16\64\71\340,\25\11%\207\231\60"
"(\14\12\1m\27 \313h\34\22IT\222\16\270D\24%\21\351a(\11J$\61\211\232De\42"
"\222L\202\4m;\34\313h\34\322\221\204\16\21\6U\16Q\71H*\261\250I\324$!\231$t\1"
"m>\42\313h\34\322\221\204,\223\204$#\211$$\223\20%BID&\221$I\42*\21\245I"
"H\10mA\37\313h\34\62\351A,\214ID\222J\34$\224\244I\62I$I\22I\212\226\210$"
":mE\34\313h\34\62ILT+\6+\22:H\62\262\204d\63M\223\310DF\207\10mt\37"
"\313h\34\22\221L\222Q\242\22\223\304D\222\260H\250$\251LD*\42QH)d\2mw\36\313"
"h\34\42\261\344(\15]$\271JR/\222\210$\242%\42\71\310\1\222\350\10\0m\210\33\312h\34"
"\62\341DM\22\31IR$\67\265\213$F\71Hd#\331H\64m\262 \313h\34B\225\243$\26"
"\223X\264I&\241ID\62\211H\42\222\211H\242\222$\11\255\11m\361\37\313h\34r\330a$I"
"\231HR(\252\22\311T\345 \232\204$\222\210$\242\64\24\2m\367\32\313h\34r\230\304(\223\204"
".j\302\243D(a\221P\264\205*K\4n\5\34\313h\34\62\351A,\14\231d\322\303L$\223"
"\224$\42\25SH)$\31\1n\10\37\313h\34\62\351a&\22\305h\222\211\214D\263IB*&"
"\211H\24\221\211\42A\21\0n\33\42\314h\34\322\231P\22;\310\324\42\225\24IL\22\253\310(i"
"\22ID$\251D\64Q\42B\1n)\34\313h\34r\230\244*\22\205L\22\221\324\216p\220Hr"
"\221\344E\222\313A\0n,!\313h\34q\10K\222D\22\321\22\231P\222$\222\244J\312D\22\231"
"P\42k\23\245It\0n/\35\313h\34!\211L\242z\210\204$\262\3Q\22\26\251\264\311B\265"
"\220L\22\263\0nV\35\313h\34!\261DR\223\250\134F\222\213&\213dr\210D&\224\312P\64"
"\23\15no!\314h\34r\240\304,\22\305L\32\17C\71@r\221D$)\222ID\22\24IB"
"\223\21\0n\200\35\313h\34!\211Lr\224\10\17D\341\201\42R\221d\241d\241T$\211\223\350\0"
"n\220!\313h\34r\330a\244\26\221T$I\62IM\22\22M*\222\220$\42\311\62I\221\320f"
"\0n\226\35\313h\34\42\211L\42\211\205\16\23\345\223$\42\223\34d\322\3Q\16\222\203\244\0o\1"
" \314h\34\62\261\250,\221E&B\311!(Q<\204$\21-\207\210\34\26\222\344\242%\0o\24"
"\34\313h\34A\341\201\42\26\35\42A\225\233D\351 \221D\264\134B\62ID*o\42\34\313h\34"
"!\211\354@\223H\17\221\210.g\351A\42\23J.\61\211(\62\33oT\37\313h\34\22I\305\222"
"&\222D*J\25\213\32%(\231\250X&\222\244\210\226\240\20\0on!\313h\34!\361e&\222"
"H*\21\222dbI\21IR,\25\221\344\20\211\210$\222\221$\62o\300 \313h\34\22\305JT"
"\22\251PR$\21\265\212P\42\11YB\22\221\312$\213\226\24\231\0pk\34\313h\234r\220\34\244"
"E\244\242\244\22\23\311As\200$\16\220\10g\42\361\0po\37\313h<r\220\344\42\24E\222D"
"\21\231\242L(\23\212$\61\221D$\12\313!#\0pp\37\273h<\207\211H*\222\210$)\42"
"I\212h\42\211\211\204\42IL$\211\205\324\206\3p}\33\313h\134\22%\211\222DQ\242&QG"
"\23\251\210T\224$\222\350h$\36p\255\36\313h\34\42\25\221\312a\16=L$)\42I\212H\222"
"M\64\224\250Ed\242\351\0p\271\31\313h\234r\220\34t\24\37bB\231Pv\210\203%\21\275\214"
"$\12q!\34\313h<r\320\301\222)\222\323a$\311&\311t\240\3%\222\210.#\211\2q\66"
"\36\313h\134*\61JD\62I\223\34$)R\321L$Q\231\311\201\222\210^\346\20\1q<!\313"
"h<\42\251\304\244\70\231\204\16\223\24\245H\344\42\222\204$\21IH\62\221LD\22\305\1qg "
"\273h\34\207IDKD\13%\42\212\34\42\21IH\22\221\204$\224:T\22Q\11I\24q\237\36"
"\313h\134j\226X\205\242%R\221\304D\222H%\42\223\204&DJD/#\211\2q\261!\313h"
"<\62YE(\261T$\21Id\22\251HB*\42JDIT\25I\42*!\211\2q\303!\313"
"h<*#\311$E\222ir\250$E\42j\22I\222$I\62\7HrQI\321\222\0r\66\36"
"\313h|\222\70@\42\225\251J$!\211HE&\21K\342\20\71D\22\35\215\304\3rG\31\312h"
"\134\22\251D*\221\36Br\210\34r\23\311t\22\212\242\42\0rH$\313h\34\222\70@\22\71D"
"R%\251\207\211H\205\242%\42\11IRD\222\24Qd\22\221D$\61\1r[\32\313h\234b\211"
"X\42>HD\322\230\34$=\20\345 \71H\16\222\2rg\42\313h\134\22\241$\42\224D\204\225"
"K\222$\42\11\311&i\23IH\22\222J$AIH\66\24ri\42\313h<\252\221\210\64\22\71"
"P$\21Id\22\221\344\205\222BQ\211\250DT\42\232TT&\0ry \314h<BY$r"
"I\224\225d\221\310A\22\225M,#\211L%&\225Ie\302\21\0r\254\32\313h\234r\220D,"
"\222J\17D\71D\22\7H\302\42\251H\250$\36r\257\36\313h\34\21\71`b\21\251\244\210TD"
"*\42\311D)\22\21K\304\22\231D\215fr\266\36\313h\134\252\42I\212HB\11I\17\42\305\221"
"L\22\221\204\42*AIH\66S\25r\354\37\313h\34\21\305\221P&\214\34B\23\245\211\312a\222"
"$\25Ib\42\211Ht\210\314\4s\207\34\313h\234\322\3Q*\321e\42\222D$\21IE(\211"
"\35\210r\220\34$\5s\211\31\273h\34\207\251\34$\7\311A\342CX\16\222\304\1\22\261Dt "
"s\213\30\273h\34\207\251\34$\7\311A\342CX\16\222\203\344 \351\201\0s\355\35\313h\274B\212"
"E\222M\222M\222\251R\221d\223d\23Ib\223\210h\242*)s\376\36\314h\234\27\233Hr\222"
"\310D\222\213M$\71\251\4'\222\230H\242&\222H\206\4t\3\36\314h\334B\322P&\211I."
"$\251$\242$\261\211\210\223L\223\210d,\7\15\1t\6\32\274h|\207HEIr\222DT*"
"J\222\223L*\261\215\204\312\207\1u\37\31\313h\234b\211X\42=LD\322\230\34$>\204\345 "
"\71Hz u#\32\313h\274\302\3I&\225\10\17\23I\252\304\64\21J.\62aPz\30u("
"\33\273h<\207\211HE\244r\230\210TD*\207\211HE$\242\211\206\222\1u\60\26\252x\34\207"
"\222\210$\42\211\16'\21ID\22\221D\207\2u\61\30\312h\234r\210\34\42<\224D$\21It"
"\70\211H\42\222\350Pu\63\30\312h\234r\210\360P\22\35N\42\222\350P\224C\344\20\71D\10u"
"\67\32\273h<\7\221D$:\210$\42\321A*=\20eB\231hX\234\0u:\36\273h\34\326"
"H\344\20\211(YD\221\210R$\242\24\211(Y\344 \71H\16\31\1u;\31\273h\34\7\242\370"
"\20\212D\264D\264\134$\21-\21-\27\71\344`uL\34\273h<\7\221D$:\210$\42\321A"
"(\211\216F\22m\22\251H(\223\1uQ \313h<r\220\344\242\22\321\22\261\244T\16\221\210$"
"\242%\42\231\244P&\21\322!&\5uY\37\313h\134\343\311A(\241\204$\24I\310\22\243\210F"
"\7\221D$:\210$\42\321A\2ue$\314h\334\302\12)\222E\24\211H\222\42I\262\212$\24"
"\311$I\261H\262\210*\21\71@\42\7\224\0uj\33\313h\334\224KL\242(I;\320\250\223\210"
"\350@\321v\210I\324\16!\0up\32\273h\34\207\211H\345\60\21\251\34f\42\331a&\222\35("
"\262\221X\2u\221\37\313h\34\242CM\42\223\204$\222\331\241(\271HR$i\226\221\204&I\21"
"\205d\3u\305\36\314h\334\322C%\16\232\234dR\311e\22Q\311'I.\222\321DQ\22\222M"
"\0u\333\37\313h\274\322\3%\16\231\134$\223\230\344\60\211H&\221\213$\42\241\34&*#\211\2"
"vz\36\313h<\224\210P\222$\321\62\222\204\16!\211J\222Dr\260I\304\22\225\221\204Jv{"
"\37\313h<\224\210P\222$\321\62\222\204\16!\261$r\211\10e\207\240H,\11\36&\0v}\20"
"\310i|b\251\360\60d<\24\31\17\3v~\32\273h\34\7\242\34\42\7\34bB\231Pv\210\11"
"eB\231Pv\10\1v\204\37\313h\134\212\62Y\345\42\11Q$\241C$B\21I&\42\311Dx"
"\224\203\344\200\11\0v\207\30\313h|r\300!&\224\35bB\331!\16>L\305\207\260\364@v\256"
"\36\313h\274r\220\364\60\21\251\210$\242CL(\223D\204\22ILQ\62\21E\204\3v\277\42\234"
"x<\7\231$\42\211I\42\222\230$\42\211I\42\222\230$\42\211I\42\222\230$\42\11\35\12v\312"
"\31\313h<B\65\251Dv \251\212\204J\207I\276H\262I\62\35\10v\333\36\313h\274\222\70@"
"\42\71\330\204\225\210\226\221D\62\221L\42\7\213JDKDr v\337\35\273h\34\25\212JDR"
"\241\250D$\25\252H(\232\34&*\21-\21\311\201\0v\356\20\270i\34\207!\361P$\36\212\214"
"\207\1v\364\34\313h\234\322\3Q\32\71Ed\242\310)\42\23EN\21\231(r\212\303\16\4v\370"
"\36\313h\134r\220\304$\21\35D*\226\211HB\11Q\42\207HD\64QR\21\251\30w\1\33\313"
"h\234r\200$\42\223\210$\222\211$,=\321\204G\231\360(\23\236\0w\13\32\313h\374\200\311!"
",>\220\344\200\3e&\222\230\42\62\341Q&<\1w\14\33\273h\134\247\210L\24\71Ed\242\310"
")\42\23ENq\330\201\242Ii\0w\37\30\313h\234\322\3Q|\224\11\217\62\341Q&;\220$"
"\263\341\4\0w<\42\273h\34\224JD\22\222D$\25JH\22\221\204$\21I\205\22\233Hr\221"
"DD\224Ip&w@\31\313h\134j\7\242\364\60\225\36H\62\331!$\211\211\42G\231\360\4w"
"\342\33\313h\134r\220\34t\10I\244\42\71Hz \312As\200D\70\23\211\7w\345\36\313h<"
"r\220\34r\260DD\23\245\203HE\244\42\222H\222$\222\203L\30\207\1w\355 \314h\34r\230"
"\350R\7H\42\245\210F\211R\205(\7ID\62I\212H&\211\205\16\2w\363\33\273h\34\7\242"
"\34$\207\310Ar\310!$\211I\324$!\231P&\274\0x\2\37\313h\334\62KP\66\223HR"
"D\222\24J\12E\205\22\231D$\61\21I\16\30\217\1x\24\35\273h\34\7\212H\42RQ\223H"
"\16\26IDKDKDb\222\212\204\62\11\0x\64\37\313h\334\262\212PrQ\211\220$)\224\212"
"$I\42\211hI\21U\246\222\210L\22\23x\272 \313h\334\262\3E\222$\21IB\242\203E$"
"\211T$)\42I\244\42I\21Q\42\342\3x\301\37\313h\234\42\11E\22\223\134D\22\65\211\304\42"
"\231\244H&\21-\21-)\222CY\42y:\27\273h<\207\70\266\3Q,Q\223\210$\42\331L"
"Q\16\231\2y<\35\313h<\42\251HX\211\3$a\211t\42\234$F\42S\221T\244\42R\221"
"\25y>\36\313h<\62\241LV\221\212\244\222\222LF\222M\42\262HL(\23J.r\10\0y"
"V\36\313h<r\220\304B\11\311$!\25\223D$\241\204$)&\211HE\244\42R\71y] "
"\313h<r\220\304B\11\311$!\25\221\212\205\42\11Er\23Ib\22\225\210\226\210$\66y^\37"
"\313h<\62\241Lv IRD\22\213JD\62I\251\34\42\61\241L(\23\312d\0yh\32\313"
"h\34\7\232$x\230\250D$\207\71\364\60\207\36(\232\224fS\0ym\37\313h<r\320A\242"
"\222\24I\221I\42\222\230DT\261\203\17\24\225\240DI\62\222\0y\201\32\313h<\62\331\201\262("
"Q\232Hr\223H\16q\360\201\242I\343\24\0y\217\34\313h<\222\213\34B\251IB*\246\71`"
"r\210\244h\271H\42Z\42Z\16y\301\35\313h|\223\30I*\222\212d\226\340DJI\222D\264"
"DT\42\222\10\251\244*y\313#\313h\134\23\331L(\223h\211\34\42I\222\310\210$\233Dd\221"
"\220$\24\11Ib\22\221JP\0y\321 \314h\134\63\321H\42S\211IE\225\210l$\11Mb"
"\242\241%B\211IeR\231T\4y\322!\313h<#\331L(Q\223HR()*\21\211I\22"
"\231DF\221\240(\22\23J\246d\0y\330!\313h\134\22\341L(\223D(J\222L\223L\25I"
"d\22\221L\224&\221)%\42\222Q\0y\373\37\313h\134\223\340\250$\21I*ij\24Ih\22"
"\71\204D\223\210$G\231h(\221\2z\13\35\313h\134\343\211I\42R\21I\16#\71\204R\231D"
"d\221\210%M(\23J\16z\16\42\313h\134\222\220d$\211IL\22\221\304\244b!\255DF\221"
"\220$\24\11IR\264D$\261\1z.\34\313h\134+\23\242L(\71X\222$\26J\226\211%M"
"\26\211\230dB\311\1z@!\313h<\42R%M$\11URD\223\203\34 \252\324$\24Ih"
"\22\221EB\222\230D\64zM\35\313h\134j\223\213L(\261\220\204\222\3%$\231XRD\222\24"
"\223\212H\42\23zt\32\313h\234r\220\364P\207\314!\42\311T$\25\11\325\204\42\261$\16\21z"
"v\32\313h\234\322CEi\242\244\242$\221LD\322CX\42\226(\251\24\11zz\31\313h\234\322"
"CEi\242\244\242$\243\310a\7\251\34$\7I\17\4z\223\33\313h\234\322CEi\222r\221\204"
"E\243\213T%\242%:\21Id\65\0z\313\31\313h\234r\220\34$=\314!\62\241\232P&\225"
"\210%r\210\360@z\340\31\313h\234\322\303L$;P\204\262CL(;\204\245\7\242\34$\5z"
"\345\30\313h\234\322\303L$;P\264\35b\22\265CXz\230J\17\4z\366\35\313h\134j\207\211"
"$\42\11\35\350\300\12E%\42\251\220$\331$YV\224d\3z\371 \313h<\42\251H*\222R"
".\21IH\222\42\212H\42B\231P&\224\11eB\321\10\0{\21\31\313h\34B\231\245\22\222\4"
"\225\207u\220\364@\224C$\321\321H<{\33 \313h\34\62a\345\22\221\204\42\222\210L\42\211\3"
"\244\207\211H\345\60\21\251\210T\16\23\0{,\35\313h\34\62a\305\42\211\210\16S\221\344\60\21I"
"\17\264\231d\22#I\246R\0{F\33\313h\34\62a\305\42\211\310\16a\211\350@\224\310\16a\351"
"a*\7I\1{I\33\313h\34\62a\205\222\242(I;L\245\7\262\354\60\23\211%r\310\14\0"
"{K \313h\34\62a\305\42\211\210*\62\311\301\42\241\250PT.\22\212$D\221\204&\224\11\0"
"{T\36\313h\34BY\305\22Q\224D\244\222\260H(\231\204\304\223CL(\23\312\16!\0{V"
"\34\313h\34\62a\305\42\211\310\324\16D\351a\42R\221PD\223\210Hi(\5{\227\34\313h\34"
"\62a\305\42\211\310\16\61\241\354\20\23\312\16\61\241\350@R\224\311\0{\241\30\313h\34B\231\245\242"
"\345P\207L,\42U\253\34t\224\11O\0{\261\34\313h\34\62a\305\42\211\310\24E\7JH\42"
":LD\226K\246IHEd{\300 \313h\34\62a\305\42\211\310\324,&I\344\20\211\220$\221"
"C$B\11Q*\62\221$\6{\311\34\313h\34\62a\305\42\211\210*$\25\11%E(=\320\250"
"\223\210Hi(\5|!\33\314h\34B\241\305\242\251RQ\11IZ$$I\213\244\242/\25\345\11"
"\0|s\34\313h\234R\221D&Q\223Hb\7\32\35@\226$J\224\224\206r\220\24\0|\211%"
"\314h<\42I,\222\33E\22\233\210DE\221\304R\222\204H\222P$\213(\22\222\310$\42\231$"
"\62\3|\276 \313h<\62Y$r \11%\226\212Pr\240\204$\224J\212H\222b\222\210T$"
"\23\0|\326%\314h<\222\220,\22\71T\42B\211\204b\221\204$\7\212J\204\22\241\244\210#\21"
"\11I\22Q\32U\0|\370\35\313h\234r\210\34\60\22K\342\200IT\66\71D\204b\211\232D$"
"\21\251J\1|\373\33\313h\334\224;DM\22\221J\344\200\211\350\60\225IT\202\22%\255R\0}"
"\0\36\313h<r\220\304\42\11J$A\221T\42\211\264DE\302\210b$\323$\244\42+}\4\37"
"\313h<\42\251H(\211\34\42\21\221D\215\42\11]\264I&\322I\342$,\21N\0}\5!\313"
"h<r\220\304\42\11\311$!\241L%$\253\10%\21YD$\213\244\310\42\221\213\34\2}\15\37"
"\313h<\62EYD$\233\34$*\27-Y$\223\24IDDI\234$J$\261\1}\24!\313"
"h<\62\211\32ER\223\204$!\211$E\222\213%Ib\211\210d\221\24\311$&Q$}\31!"
"\313h<\302\221\204&\311&\311(\221D(\21\222%(Q\212H\42\242HDK\204\242M\0}\32"
"#\313h<r\220\244$I\21I\62J$\23ID\305\222$Q\212H\42\242H\212$/\242IL"
"\0} \33\313h\234\322\303T|\10K\17\244\211\230\42\241\244\210$\21\321D$\225\2}\60\42\313"
"h\134r\220\344 \222\244Hr\222HR$\221C%I\42\211L$)\223\210$\242b\222\3}B"
"!\313h<\62\241\214\42\211h\211Hb\262\221$\242b\223H\42\243\210P\222E\26\11\216\304\2}"
"D \313h<r\220\304\42I\222H\222T,\222$\211I\305\22\221\204$)\42I\212Ht\30}"
"L \313h<r\220\304\42\211h\11\315D\222\220$\351\20\21\312d\21I%\213,\22\23J\16}"
"P\36\313h<\62\241L\345\60\11\11e*\221v\200\304\22\221\204$)\42I\212H\305\2}f "
"\313h<\62\241L%\42\11I\222T,\222\350\35 \261D$!I\212H\222\42R\261\0}q\42"
"\313h<\62\241L%r\210\204\204\42\211J\244%\213H\22\212\250\204\42\271H\42*\21Il\0}"
"u\42\313h<\62\241L%\42\11I\222T\42+q\300\201\42\22FTB\221\210R$B\11I%"
"\0}v!\313h<\42\251\210$I\21IBB\211E\222\213%Ib\211H\242\221\210l\22\221I"
"D\6}y\37\313h<\242CL\64\221\34\344\20\225\303$$\221D,J\223\24K\246IHE$"
"\31}\232\42\313h<\62\241\344 \11\311$\221\222\34\42\211\34j\22\221$\24Q\11Er\212\204$"
")J\3}\277#\313h<\62\241\304\42I\222H\42%\211H\42\211\264\10%\207\210$e\22\221D"
"&\21IDM\6}\317#\313h<\42IL$\11Ir\221\204$J\222\220$\322&\222Hb\21"
"Id\222\27I&\211l\4}\321!\313h<r\220\304\42\11J$\221\222T\42\211\34(\222\220D"
"\222EB\212D$y\321\64\3}\332 \313h<\62\241\304\42I\222H\42%\211H\42\211\264\350\222"
"EB\212D$\271I\224f\0}\350\36\313h<\222\213\34\42\211T$I*\26I\352\201\42\231D"
"T.\271hI\21I\6}\364 \313h<\62\241\344 \11\311$\221\222D\222\42\211T,I\22K"
"\22)\42\311\27m\62\0~&\42\313h<\312\22I\204\42\232H\42\26M\222\210$TI\223\244P"
"&I\221\210R$\242&\211\15~.#\313h<\62\225\203dX\211\134$I\224\10E%\62\211H"
"\42\23I\244\22\221D&\21ID\13\1~> \313h<\62\241\344 \11\311$\221\222L\345P\11"
"\251X\42\222\220$\305\222$\21Id\2~T \314h<\32\17\42\211$\313$\343\301\22\223]\222"
"$y\251\210\42YD\221\10E\244\5\0j\33\273h\34\207\211JDr\30J\202\25\242$X!"
"J\202\24\223D*\22\2n\32\273h\34\207\211JDr\230J\17D\251\304$\211\211$&IL"
"t r\32\313h\34\207\211JDr\230J\17SI\354@\272\315D\22\243Lx\2\212\31\313"
"h<B%\331\201(\7I\17S\71Hz \312Ar\220\24\0\216\30\313h<B%\331a*"
">\204\245\207\251\364@\223DG#\361\0\244\35\313h\274\242C$Ir\270\304$J\7\212PV"
"\21M\16\23\245HD\255\42\2\251\33\313h\134j\7\242\370 \225\36H\22\225\3I%b\221\204"
"$\23\311T\0\275\34\273h\34\7\232\220\42\11I$\21\65\241h\66\221\204$\23mB\231P\64"
"\33\314\30\273h\34\225\213.!\311D\323l(=\314Db\211X\22<\20\322\31\273h\34\225"
"\213\26\222E\323l&\7\34bB\331!&\224\35B\0\200\1\34\313h\234r\220\364\60\225\304\1\303"
"\3i\16\220DF\22:@\16\222I-\0\200\3\31\313h\234r\220\322!,\211\35\210r\310\211,"
"\261\203\344 \71`\6\200\5\31\313h\234\342CX\42\226\304\16D\71\340\66\23I\214\62\241Lx\2"
"\200\25!\313h<\42\211HER\211\210$\207JD\244\42\251D$\223\3E%\27I\212H%&"
"\1\200\63\30\273h\34\7\212L(\23\36e\302\243L(\253\334fr\220\14\0\200V\30\273h\34\7"
"\213$t\11Q$\241KM| \312\1g\351\201\0\200^\34\313h\34\25\223$t\61IB\27;"
"drQ\222L,\23\221db\231J\4\200w\42\314h\274\22\321\201\42\311e\222\323\341\22\24Q&"
"\221I.\223\310DB\211H\42\222\10%&R\200\211\36\313h\234r\220\364P\223\215$\241\211h\42"
"\223\315d#Ih\42\232\310!s\300\0\200\245\34\273h\34\224C$\13%\213%\205\22\71DR)"
"QI\252$\215\222\66\221\30\200\262\33\313h\234\322\3M\42\225\220L\242CL(;\304\204\262CL"
"(\223\215\0\200\272\37\313h\334\62\222Lr\230\204d$\231$r\210d\261\244P\262P\262PB\262"
"\210H\6\200\303\30\272h\34\207\222\350p\22\35*B\321!$\24\35BB\221l\2\200\314\36\313h"
"|\222`%\62\223\314(!\212\244r\210\11e\207\230Pv\210\11e\262\21\0\200\370\37\313h\234\322"
"\211\64\22\71D\22m\22IDK.\24-I\22I\244\42\11O\202\23\0\200\375\35\313h<\42\251"
"H\242eD\221CF\227\213$X\211h\31U\202\22I\210\42)\201\10#\314h\374\200\21e(I"
"\223HRF\224$J\26\225\224\21%\42\223\344$\311I\222E\22\231\210\4\201\63!\313h\274\242J"
"D\62\211HrQ\232C\62I$\221I\204\22\221Lr\221D\264$N\42\7\201x\42\274h\34\224"
"\222$I%R\242\204T\16\224\344\3E\22\221\244H&\21IDI\22\221DF\0\201y\42\313h"
"\234R\312!\62\222H\42\25JH\42\211T$\21!\245\42I\21I\324$\21I(B\32\201\323\42"
"\314h\274\22\321\341\22Q\222\4E\224\203$\62\11I\222$\225\211JN\222\212\312D\62\221\214\4\201"
"\343\30\273h\34\7\223T$=L\304\22\261\344\60\21IER\221\364@\201\350\37\313h\234RJ\64"
"\22\71D\222)\225\210$$\211H*t@$\62\241\344b\311F\31\201\352\21\310i|R\341aH"
"<\24\211\207\42\361\60\201\363\30\273h\34\7\242\34\242*!\231\244\42\311a*\7\311A\322\3\1\202"
"\10\37\313h\134r\300\304\242\22\221\34&*\21\25\212\244B\221P$\7\232D*\23M%\0\202\14"
"\31\313h\334\243;D\16\222\36\210r\220\370\20\23\312\204\62\241\354\20\2\202\16\32\313h\234r\210$"
":\32)M\16a\351a\16>\304\204\62\241\354\20\2\202*!\313h\134\212\62\331\301\22\7PH\222"
"\210$t\11I\42\222\20%\42\222\244H&\42\211\342\0\202\71\42\313h<\42I\250\222$\221$M"
"RTf\24\361a\242\22\221LR\264D\264D$\221\11\5\0\202o\25\312h|\342\233n\67\265\233"
"P$\211\310$C\212h\70\202r\32\312h\134r\210M$\23\11\17\22%\211\222\344 \221C\304d"
"\311A\0\202\261\34\313h\134\252\42\331\201\64\21K\302\22\221d\242%\62\213(KD*\42\245\2\202"
"\270\31\313h\134j\7\222\252Hv\230C\17D\71DUB\62\311A\22\0\202\275\32\313h\134j\7"
"\222\332\201\42\23\312d\7\242$,\21\216dB\71d\6\202\345\32\313h\134j\7\222\262\34$>\320"
"\344\220\333L$\211\211\42\62\341\11\0\202\346\32\313h\134j\7\222\252$\35 =\20\345 \361!&"
"\224\11e\207\20\0\202\361\33\313h\134j\207\231$\35 >\304$j\22\245\3Q\16\221DG#\361"
"\0\203\66\31\313h\134j\7\222$Y\22\35\215\224\16V\71@\222(Q\322*\5\203I\31\313h\134"
"j\7\222\342!&\224\35bB\331!,=\20\345 )\0\203w \313h\134j\7\232D(\7\35"
"\252\42\11%$\211HB\222\210$$\241\204\244\42\341\10\0\203\334\33\313h\134j\7\222\204d\221I"
"\24%\351\0\351\201F\235DDJC)\0\204=\35\313h\134j\7\222$M\22\241I\224B\22\231"
"l<\221\35*\42QH)d\2\204I\33\313h\134\62\321\201\244(\221\304\16\24\225\340!,=P"
"&\21\221\322P\12\204W\31\313h\134j\7\222$\355 \36\36hr\310m&\222\30e\302\23\0\204"
"\270\35\313h\134j\7\222\342!\16\20Y\42\63I\242DIR\221\3%\222\210$$Q\205\65\37\313"
"h\134j\7\222J\344`\224I*\21I.\222JD\22\221\204$\224\310$\313\244$\205\254\35\314h"
"\134\212\7\232$QR\211\215f\222\212L$<\324\310\223\210L$\232\212\1\206k\32\313h\234r\220"
"\34$=\210TD*\242\203X\16\222\210E\322CQ\0\206\225\30\273h\34\7\242\364\60\224D'\21"
"\321\201\242\355\20\26I\17E\1\210@\34\273x|r\220\34\42\7\34&*\21-\21-\21-\21-"
"\21-\21\311\201\0\210F\36\313h|\342\303D%\242%\42\71\220$R\211H\42\241\4%\211\22%"
"\245\241\24\0\210L\37\313h<r\220\304\42\7I\342\200\310A\42\224\11ECQ$(\23\312\204\62"
"\331\10\0\210S \313h<\312\222II\22\213\34$J\22\321D%\242%\27I.\23\221D\244\42"
"\222L\0\210W \313h<\312\22\211\205\30\211H(J\22I%\42R\221T\42\42\25\21%\242&"
"\221N\0\210[\36\314h<\222\70\304\62Q\211F\254\223\203\204\42\322\205\42\222$\211\16\221\220^F"
"\0\210c\35\313h\234r\220\364@\223\203F\62IH\64\221\204$\21\261H*\23\222$T\1\210h"
"\33\313h\234\322\303Tz\230J\17$ID\66\221\204$\221\251HJ\21\21\7\210\301 \313h\134*"
"\21KD\244v \251\35\42!\321$B\211\210\42I\62\211Jd\42\261\310\4\210\305\37\313h<\42"
"a$$<PD\302\221\60\22\261J\17\244ID$\211\214$\224\30m\0\210\317\33\313h\234\322\3"
"E\333!&Q:L\245\7\312$$\221D$A\212\210\70\210\334\35\313h<\62IH&qR\224"
"\134T\42\226KD\22Q\271\250D\264D\264D\4\210\375 \313h\34\222\240\304\222E$\211XR$"
"\271HF\62Idr\240Md\223\231d\42\33\16\211\7\35\313h<\312\222\203I&)ID*\26"
"\212\60\222B\222\250I\42B\311$F\33\211\33\253x\34\7\232$\16\220\4\17\23\225\210\226\210J"
"\210\62\225\210%\207\11\0\211\201\32\273h\34\7\232$x\230\250D$\207\241\370@R\235\304!\264\322"
"\4\0\211\213\32\273h<\207\230Pv\210\11e\207\230Pv\210J\302\22\221D$\42\26\211\217\36\313"
"h<\22\223D$\61\251\230$\42\311a$\21\251\230&\222\220D\222\244\242$\33\211\226 \313h<"
"r\220\304B\11\311$%\211H\305B\11IRL*\61\221$&Q\211Hb\3\211\232\35\313h<"
"\222\220P\222v\250\4%\222KD(;\304\204\262CT\22\235\210\210\5\211\247\35\313h\34\225`D"
"r\250F$\7:\340\20\23\312\16\61\241\354\20\11MB\265\2\211\252 \313h<\22'\211$R\221"
"$I\16#\211Hb\222P*\223L\221\334$*\21Il\0\211\263\42\314h\34\62\313I\42\211\210"
"$\7JN\222\3E\22\21I\16\24IH\22\262$I\42*\267\1\211\322\32\312h|r\200M$"
";L\224$\7\211\222\344 \221J\244\22)u\0\211\343 \314h<r\330a\242KDIb\31I"
"R(\227\230$Ev\70Id\42\211,\64\221\1\212\0\26\313h\134v\204\3\35lG\262\243\34b"
"B\231Pv\10\1\212\10\35\313h\34$\71HV\221\203d\7\262\214$\7\311H\262\210H\26\21\311"
"H\62\0\212\16\36\313h\34C\71HD\223\36jR\221\210\22\21KD\64QD&\212\310D\244\21"
"\0\212\23 \313h\34\24\221T\22\261d\225D*\222TI\244\42I\225D*\222\210\226\210J\314\22"
"\23\212\30\33\313h\34t\240\245&\7Ij\342J%\16\22V\202!Ih$\11]\12\212*\37\313"
"h\34#\71Hx\240\12)rP\205\242,\221PB\222\210$$\211\314$\244\21\0\212-\37\313h"
"\34\24\262DD\211H\202\22\211mh!J%\42\212$\24\21\311\42*!\323\0\212\61\35\313h\34"
"\224\70HJ)Jd$\71Hv \313H\262\210H\26\21\311H\62\0\212\63 \313h\34t\350\201"
"\22\222\212,VI\210\42\211\3$!\212$\24\221\204$\21IHR\24\212<\36\313h\34s\340\241"
"$\7\311(\351\0I\214\22\231Jb\224\264\210$-\42I;\20\212U\37\313h\34s\340\241$\11"
"J$\21JD,\211\35\310\62\222,\42\222ED\62\222\14\0\212^\31\313h\34t\340\241(\254T"
"\205\225JD\22\224H*\24\325\211\324\70\212f\33\313h\34\303\71Db\222\36jR\23E\22\7H"
"B\24IDe\205t\25\212i\37\313h\34$\71\300R\221\203d\7:@t\240\3D\224\210(\242"
"\22\212\310D\244\21\0\212q\37\313h\34\264)\215$\7\311\16d\31I\16\260PB\222\210$$\211"
"HB\22J\5\0\212\214\34\313h\34\63\71Hv \313H\342\13\35*\221P$\21\311$\64\321B"
"\242\0\212\215\35\313h\34t\340\201$\221NL\223\250\310\22\31\13)\222PD%\42\231\204L\5\212"
"\225#\314h\34\323\31e\64\21\211%I\223\210$H\211H&\222DI\246\211$)\22\71HR\204"
"\264\2\212\236\37\313h\34t\330\205\42\7\230(\21\261Dt\240\3)\225\210$$\211HB\22J\5"
"\0\212\240!\314h\34\303\71H\22\241\211\17\221IHL\211Mr\224d\231\244\210\42YD\221\274P"
"F\2\212\244\35\313h\34\243\242$\42\251D\204\22J\35t!\312A\222CE%\24\321B\211\11\212"
"\254 \313h\34\23\221X\42\241H\302\26JH*\222P\312\222\20E\22\212\250DT\42\22\333\0\212"
"\255\36\313h\34\63\361\241$\7X\350\300\3%&\225D*\222PD%\24\221D$&\2\212\262\34"
"\313h\34\24\243$\342(\211XR\204\7\222\370P!E$\271L$&\31\0\212\277\34\313h\34s"
"\340\301\242v\240D\324\16\224\240L\62\261\244H&)\222\25\333\0\212\307 \313h\34\63\71@\222B"
"\311\16\220Q$\321I\304$\7HR(\271\250\204\42\222\220\244(\212\326\36\313h\34$\71D\22\242"
"H\302\42\311A\22\7\36h\222\224\203e\222\42\231\244\330\6\212\370\37\313h\34\24\71\304BQ\226\204"
"\16T!\245\70\222P*\21IH\22\221\204$\224\12\0\213\33\35\313h\34\24I\370PI>P$"
"\321C%\253\205\222\313a\42\11I(\221\11\0\213\35\42\313h\34\23\221\220\42\251D\204\7J\212\220"
"\42\231D$\261\212\204\242\22\231D$\21-\24\25\0\213X \314h\34\42\211\264\42\232\344(I;"
"\324\1\262\311$Q\222e%_D\221\310D\264\42\1\213f\34\314h<\222\210\320r\32I(\231$"
")#\312\332\370@\254\36dR\331A\4\213p!\314h\34\24\325C\204$\207\230Hr\300!B\211"
"H\202\7Kd\24\251d\221\244Hl\22\0\213w\37\313h\34#I\364P\221\204\17\24ITr\220"
"H\302\7JH\22\221\220\42*!\323\0\214\67\33\313h\134\252\62\25\221D\244(\11\213\204J\7\212"
"P&\224\11e\207\20\0\214F\30\273h\34\7:\364 \222\212\244\242\203H\250&\225\310A\262\3\1"
"\214J\34\313h|\222\340a\242\22\221\34&*\21\311\201\16=\304\204\262CP$;\20\214a\35\313"
"h\134\305\211\370\20\223\250\35\42!\222dR\234\310&\223\340$\42\31\251M\1\214\235\31\272h<\207"
"\220P$\24\35BB\321!$\24\11E\207\330D\64\34\214\240\32\312h|r\200i$<\204\204\242"
"CH(:\204\204\242Cl\42\32\16\214\241\36\313h\374\20IM\242&\71Xd\222\322Di\242%"
"R\211\210$\42\211H%<\1\214\247\35\313h|\222\260Hx\10\251DD\23\341!&\224\35bB"
"\331!*\221\321&\0\214\250\36\313h|\222\310\12I\22\21I\16\23\241\354\20\23\312\16\61\241\354\20"
"\33\215\304\22\0\214\254\31\313h\234\322\303T|\10K\17\24\241\354\20\23\312\16\301\211l\70\1\214\257"
"\34\313h\334\262Ce\70\221\3(\27\221\214$\213\210d$\341H&Q\13\316\0\214\264\32\313h\234"
"\342CL\242t\240C\17\61\241\354\20\23\312\16A\321\252\4\0\214\267\31\272h\34\207\212$r\250\10"
"E\207\220Pt\10\11E\207\230h\62\25\214\270\33\313h\134\22%\311a$\225I\24)\207HD("
";\304\204\262CP\264:\214\273\33\313h\134j\207\211$$\211\34H*\222\203H(;\304\204\262C"
"P\264:\214\277\34\313h\34\225\243\204\22\222\134\42\225\361!&\224\35bB\331!\70\221\15'\0\214"
"\300\35\313h<rH\213$\211\42\11M&\225CL(;\304\204\262CP$\33N\0\214\303\34\313"
"h<\22\223Lv\250\304\204\22\323!&\224\35bB\331!\70\221\15'\0\214\307\37\313h\34\42\261"
"\344&\221\304$C\211dr\220D\204\262CL(;\4G\242\251\4\0\214\333\35\313h<BQ\205"
"$\24U.!I\312%\42\224\35bB\331!\70\31M%\0\214\336\34\313h<\32%i\207\212e"
"\42\222H\16\61\241\354\20\23\312\16Q\211\214\66\1\214\352\35\313h\134+\243Y\345\22\221\204\42\222\210"
"\354\20\23\312\16\61\241\354\20\24\255J\0\215d\34\313h\234r\220\370\20\226\203\244\7\232D(\211H"
"B\222\210\204\242IQ\64\3\215p\30\313h\234r\220\364\60\225\203\244\7\242X\42\226\230&Q\311\64"
"h\215w\36\314h\134r\230\244d\22*\35\206\22\251$\42\225\220$\24\221D\22\252\204\306\301\3\215"
"\263\30\273h<\7\221T$\25\35\244b\211Xb\222\210'Q\11\61Z\215\357\42\314h\274RJ)"
"\242)\242\22#IE\22Q$\42\243LH\221\220D\24\311\42\212h\222\225\0\216\253\34\314h\234r"
"\310U&\275\312$\242KL\66:\310\1\223\350H\66\224\203f\0\216\312\31\313h\234\322\3Qz\230"
"\210T\16\23\221\312a*=\20\345 )\0\216\315\32\313h\34\207\232lr\11J\17\23\221\312a\42"
"R\71L\245\7\242\24\0\216\342\36\313h<rH\205$\207\224#\221CE\26I\221Uf\42\211\244"
"\22\21I(\312\2\216\375\35\314h<rP\245$\226T$\241H\222\254\242\222IV\22\212,%\241"
"\226C\0\217*\37\314h<\62aE*\222\304L\242H\344R\235D.\225L\222K%\223$'I"
"l\2\217\70!\313h<\62Y%M\42\222T&\222\344KD\222\313!\222\42\311r\210\244H\222$"
"\222\224\1\217\236\37\313h\134\23\331\344\42\222\210T$\7\212L(\223\35J\22YH\42\13Id\25"
"\31\0\217\262 \313h|\22\341A$\211HB\7\221$\42\211\34\354\240\203e$QI\222LD\221"
"\331\0\217\272\34\274h\34\222CH\263H,\222\214\364E&\222\310D\222\320H\42\7\304\16\1\217\321"
"\35\314h\374\220\211\250(\221\303\344\260\313DQ\242(Q\224\204\204\63\25\71 v\10\217\324\37\314h"
"|\207\210:D\22\207]e\242I\212L\22\31\216\206\23\65\211L\242\16\210\35\2\217\360 \314h\274"
"\222\230\212L$\7\34\342\0\351$\243$E&I\221M\324DR\211\34\20;\4\217\367 \314h\274"
"*\222\210L\62\211C\344\200\203d\64\225L\202\222\24\331D\244U\42\7\304\16\1\217\375\34\314h\274"
"Jr\200\304*\223\236&q\210\304&\211\251\304TL\22\71 v\10\220\0\36\314h\234&m\22\263"
"Hl\232H\42\42\211$M\242(\21\311$#\211: v\10\220\1\37\314h\234\42\65\211L$\11"
"\37\342\0\341L*\71\311\206\42\211L\42\223\250\3b\207\0\220\6 \314h\234\42\65IPr\7\310"
"\1\22\225IDIr\222D\244\62\251H*\221\3b\207\0\220\32\37\314h|'\25\241h\16\70\4"
"%*\223\223$\242$\71I\42J\222\210\356\200\330!\0\220\37 \314h\334B\311!$\223\3\16A"
"\211\312\344$\42J$i\222\210\222L(\221\3b\207\0\220 \36\314h\234\222\240H\22\225X%\342"
"\203d\16\223\330$\42\231D$\233\224$\343\340\1\220#\35\314h\334B\311!$\223\3\16A\211\312"
"\344$\211(IN\62\251\344\242\61v\10\220\61!\274h\34\222CH\22Q\224L\202\22\225\311I\22"
"\231\204$\71I\42\223\320p\242\16\210\35\2\220\62 \314h\234\22\231H\22\225\334&r\300i\22\221"
"Jl\222\210T\22\221J.\352\200\330!\0\220J\42\314h|\42\231H\42\264\320$r\300!\62I"
"\221I\42\26I\212l\242&\231\210$r@\354\20\220K\37\314h\134\7\211$$\21\35\206\22I\364"
"\64\211Hb\22\233\352a$\23J\24c\207\0\220N!\314h\234&m\22\311X\222z\210L\202\42"
"Id\22\222\344$\211LB\222\330D\35\20;\4\220S\35\314h\234\22\231\344\20R\7\231E\242\211"
"M\42\222Il\22\221lR\222\214\203\7\220T\33\314h\334B\221M\35p\210Jd\207\212L*\71"
"\311\244\222\213\306\330!\0\220`\34\314h\274*\67\221\34p\20\236&\61\25\233\204\22\223d\234H&"
"\32c\207\0\220i#\314h\334B\311!\244\22>\4%\223\310$\242$\211LB\222\234$\221IH"
"\22\233\250\3b\207\0\220x\34\314h|\224\211L\244\262(\22SV\24%'\211\342\201\242M\42\23"
"\305\16\1\220z\34\314h\274*\67I\212\360 \7Ol\222\230\212M\22S\61IF\223\320A\0\220"
"\341\37\273h\34\26\212J\344\60\11I\224,I\62\211\244\22\251H\42\25\311$E\22\254\304\0\220\350"
"\42\313h\134\42\312!\22\21I\222$j\222\210$r\210\210%\207H\204$\231\210$\61K\34$\3"
"\220\365 \313h\234\322\12M$\211\34\42\21I\212\350\20\211H\262P\262\34&\42\21\215\22#\311\0"
"\220\367\36\314h\34r\230\204\62\311\227\225$I\212HB\311\223\244\242K\26-\24\225YX\6\220\375"
"!\313h\134r\200e&\311\66\221D\16B\221$T\211T$\221\11%\242e$\221\4+\61\0\221"
"M\35\273h\34\25\212$(\221\4%\65I\26J\216\22I\60$\11VB#I\350R\221R\35\313"
"h\34r\230\344*\11\5%!\311!&\311&\311\242b\21R\16\42\341\350\20\221x#\313h\334\262"
"\212$\42\211\34\42\21I\250\222\42\211H*)\62\211\204\22\242H*\243\220$\42\261\11\221\314\31\273"
"h<\7\221D$:\210$\42\25\221\350 \25\37\244r\220\364@\221\315\27\313h\334\63;Dz\240"
"h;\304$j\207\260\364\60\225\36\10\221\316\35\273h\34\207I\212RE\26I\221E\42\207\212$$"
"\33U\204\62!E\66\232\1\221\317\32\313h<\207\230Pv\210\11E\7\312!&Q;\304$J\207"
"\251\364@\221\321\32\313h\234r\220\34\42\11\213\204\207\220\322Pz\230\212%\212\222\264\3\1\221\335\36"
"\313h<B\231P$\211\211$\42\321\201\42\24\225dBQ$ID\223\221TE\0\222D\36\313h"
"<\62\241D\22\223d\223\134*B\231\354@\221\311\42*\241I\266IH\242(\222q\36\313h<B"
"\331L$\71\310\244\26\231D\211\22\221I\224\42\21I\12%ER\261h\222\200\37\313h<r\220\304"
"\42I\222H.\224\220\212KDK\26ID\64Q\233L\42\222\231\0\222\205\36\313h<r\320\344\20"
"\231\215,\225\230D\322\42I\221L\42\222HKLR#\211\6\222\255 \313h<\262\231JD\22\242"
"Hj\25\222\204V\251H()\62\321$\62\211L$u\200\0\222\374\35\313h<r\320\241\62\42I"
"R\16\25IDr\321%\62\211H\42\7\13\221\42\33\223\62 \313h<r\220\304\42\11JT(\65"
"\221\344P\221\204$J\21\11i\42I\32Ih\63\0\223\341\36\313h<\62\241\304\42\211HB\222C"
"%\244\342\244b\211\250\204&\331&\21\311D\66\225w\30\273h\134G\71\310*\7Y\345\200\3I\22"
"\21J\246\24\21q\0\225\200\33\313h\34\25\223$t\61IB\27;d\16\231C\346\220\71d\16\231"
"\3\6\225\211\35\313h\34\25\223$t\61IB\27\243hr\221\215F\222\320Di\22\31\315\1\3\225"
"\213\34\313h\34\25\223$t\61IB\27;dr\21IB\223\213\246IH\64\224\14\225\223\35\313h"
"\34\25\223$t\61IB\27;db\231\210$\23\313D$\231X\346\200\1\225\242\36\313h\34\25\223"
"$t\61IB\27\223$\64\271\310d\223\213H\22\232\210$\223\350\0\225\243\36\313h\34\25\223$t"
"\61IB\207\213\322$\42\233(M,\224\210$\42)\315\1\3\226\62\42\313h\274\302\221\60r\230\204"
"\204\62a$T\211h\211HB\222\211H\22\222I\42BI\332\10\0\226M#\314h\274\322Q)\22"
"\231\210\42)\63\331$\24\211\250Ld\262\210\244\24\221Dd\223KX\26\226\1\226P\42\273h\34\223"
"R$I\24\211\224$\42Q$I\24\71E&\21\311$\62\12I\222B#ID*\226[!\313h"
"\34\223\210,\222\42\231D,\332\42)\222\11\245\22\22FBB\311%(\14\12#\7\1\226b \313"
"h\34\63Y\344\60\221R,\222\70$r\230\204$\241HH\22R\21\305$J*\212\3\226d \313"
"h\274\302\321,\22Q\212\244I$\26IH\30\71L\24'\231B\222\210$\242\64\33\2\226x\35\313"
"h\334\262\211%M\26\71\320$\241HD)\62\252\304T.QYT\26\71\10\226z#\313h\34#"
"a$\42\211E\222D\21\13M\30\71D\42Z\42\207\210L\30\223\304BJ\21\241\4\0\226}#\274"
"h\34\23S$\42\22E\42&M\221\3%\42\216D.\21\225\224\211$\42\11\212$\241\311\10\0\226"
"\212!\313h\234\42\311H\22\212D\16\221\220P\64\221D&\222,J\221%\225,\23\311T\26\33\2"
"\226\216\42\313h|\22\331$\42\231D,Yd\22\225IDRQ\214D,\223\230$t\11\311$\241"
"\13\0\226\233%\314h|r\300\304\24\311\42\212H\42\62\211J(\22\251\244\210'\207P$$\211M"
"RD\21%Il\12\226\234\35\313h\274\302\211%E)r\240\310$)\226l\222\24\213L\30\71\14"
"\205A!\0\226\306\33\313h<\42\351A\62\221Fn\22\361!&\221\36h\324ID\244\64\224\2\226"
"\321\37\313h\34\62\211\204\42\11I\42\207H\212(B\221I\134d\22%J%EM\242&\71\226\343"
"\37\313h\34\222\220\344\22Q\211\34,\241HN\225\212H\22\252\244\211\16\226\220D\222\24\64\226\350\34"
"\273h\34\7\242\34$=\134$\21J\212d$\253H\42\224\24\311HF\22\15\226\352\35\313h\34\207"
"\251\364P\221D\324d\23ID\22\207\36\342 \331!\16\222\35B\0\226\362\33\313h\34\207\251\364P"
"\223M$\21IP|\210\203\17\64\211TB\62I\0\226\373\35\313h\34\207\251\364P\211H\42\23I"
"Dr\30\251\210\16\42\25\321A\22\224I\15\227R\30\313h\234\322\303T|\10K\17$\231\360(\23"
"\36eB\321\10\0\227Y!\314h<\62RE\22\23Ib\7\222P\22\71\134D\222HI\22Qi"
"\222ID\62\211d\6\227^\34\313h\134\22\261DH\61I\304\22!\245&\21K\204\24\223D*\22"
"\312\204\0\227b\30\273h\34\7\242\34\42>XT(\25\212\12\245BQ\241\250\34\14\227i\30\313h"
"\134j\7\222\252\35 =LD*\207\251\364@\224\203\244\0\227\363\30\313h\234\322\303L$\226\4\17"
"t\360Q&<\312\204\62\341\11\0\230\2\33\273h\34\7\212H*\61ID*&\211H\305$\21\251"
"\230T$\23\231\0\230\6\42\314h\34!\71 t\230\244\10#)\225\234$Y*\71I\262Tr\222"
"d\251\204$*!\232\0\230\20\31\274h\34\207\222\242$b\322\322$I\22ML:\231d\22\311\232"
"\0\230\30 \313h<r\320\304\42\211\310D\207Jhx\240\204$\222HE\222$\241Td\222\220d"
"$\230-\34\273h\34\7\262\254r\221\204(\222\303$\64\222\134$!J\304\64\221D\226\4\230L\36"
"\314h\34\7\212\306JE%$i\26I\16\64\211H\42\71DH\222\220\204$\11\36\230M\35\313h"
"\134r\300\241&\211U.\222\20%rQ\242H\16%\212\344\242\22\251\204\4\230T\35\313h\134r\300"
"\301\242\70\71\230(\222\203DD\221\34$\242\221\304\42\222D\226\4\230X\36\274h\34/\42\231\205\62"
"\221D$\26\312D\22\221X(\272P\42\24Ih\222\242&\230^ \313h<\222p$r \311\16"
"\224\211\250\22\261d\222\210\16&\211\350\20\11I\222$!\1\230\250\37\273h\34\7\221h\22\222\210D"
"\227\320$\323$\323%$\21I&\222\224Ie\42\222\10\230\333\37\273h\34\207\210hB\231D$!"
"IDK\350P\11I\42#\211JD\313H%&\33\230\337\34\313h\234r\210$,I<\204$\61"
"\322Q&<JB\62\211$H\21\21\7\230\357\42\314h<r\330\304\242\22\215\250J$-!\211J"
"DT\221\204$\21IL\262$\311\42\231\244\11\230\362$\314h<\62\351H(\231\4#\242CD\222"
"\245\222E\62\221\225d\222\220$$Q\11I\42\42\311D(\230\374\36\313h<r\320\344\20\21N$"
"\207\210\360\262\42I\261\244L\42\222\310D\262\222V\35\231\12\34\313h\134j\7\242\364\60\223$J\224"
"$\25\221\252%&\211\10%\63\313\4\0\231(\37\313h<\62\241\344 I\273P$\24I%\242\205"
"R\11J\42\207\210$D\211\210J\6\231\226\34\313h<\62\251Dx\240\311\1\207\230Pv\210\11e"
"\207\230P&\224\35B\0\231\254\30\273h<\207\211Hz\20\251\36D\252\207\71\210\222\205\222\66\245\0"
"\231\305\42\274h\34\225J\222\12E$I\262P$\261HH\22\253$K\42\242H\26QH\22\22M"
"\202\2\232\23#\313h\334\262JR$\42\222\34$\222\230\214RI\221\244\34F\222\210,\222\62\12I"
"\42\242IL\0\232\250\33\313h\134G\231PB\224DD\7\213e\22\223\204\216\62\341Q&\24\215\0"
"\232\330\27\313h\274\302\3\35|\224\11O\7;\200R\241\250P*\344\1\233Z\36\313h|rPU"
"$\24\11\17\223\24\221\350 \222\210D\7\71T\42\211HB\22\5\234\345\35\313h|r\300!&\224"
"\35bB\331a\42\7\35\306\22J\212d\42\11\215'\0\234\364 \313h\234r\210i\22\22E\42\245"
"H\222(\22\261d\216D\16c\221$E$IQ\234\0\236\246\30\313h\234\322\303Tz\230J\17\64"
"\71\344\64\211\310\1\343\211lH\236\304\31\313h\134j\207\231Hv \212\17\61\211\332!&Q;\4"
"E\253\3\236\322\33\273h\34\7\221D$:\210$\42\321A*>H\305\207\211$\242\22\222(\237;"
"\32\313h\234r\200U$\265\212\204\207\230D\355\20\223(\35Hj\63\31\0\0";
#endif /* U8G2_USE_LARGE_FONTS */
|
the_stack_data/125139531.c
|
#include <stdio.h>
#include<stdlib.h>
typedef struct l{
int valor;
struct l *prox;
struct l *ant;
}lista;
void inicia(lista **inicio, lista **fim){
*inicio = *fim = NULL;
}
void aloca(lista **No, int valor){
lista *novo;
novo = (lista*)malloc(sizeof(lista));
novo->valor = valor;
novo->prox = novo->ant = NULL; //inicia anterior e prox com null
*No = novo;
}
void insere(lista **inicio, lista **fim, lista **No){
lista *aux;
aux = *inicio;
if (*inicio == NULL){ //primeiro caso
*inicio = *fim = *No;
(**No).ant = *inicio;
(**No).prox = *fim;
}else if ( (**No).valor < (**inicio).valor){ // insere no inicio
(**No).ant = *fim; //faz o NO.ant apontar para o fim
(**No).prox = *inicio; //o NO. prox aponta para o inicio
(**inicio).ant = *No; // o inicio. ant aponta para o NO
*inicio = *No; // O inicio recebe o No
(**fim).prox = *inicio; // faz o fim.prox apontar para o novo inicio
}else if ((**No).valor > (**fim).valor){ //insere no fim
(**fim).prox = *No; //o fim.prox aponta para o NO
(**No).ant = *fim; //O No.ant aponta para o fim
(**No).prox = *inicio; //faz o novo fim apontar para o inicio
*fim = *No; //fim recebe o No
(**inicio).ant = *fim; //faz o inicio.ant apontar para novo fim
}else{ // se o valor nao foi inserido no inicio nem no fim
while((**No).valor > aux->valor){ // busca a posisao no qual vai ser inserido o valor
aux= aux->prox;
}
if ((**No).valor != aux->valor){
(**No).ant = aux->ant;
(*(*aux).ant).prox = *No;
aux->ant = *No;
(**No).prox = aux;
} // se nao entrar neste caso que dizer que o valor que o usuario quer inserir ja foi inserido
// e este valor é o que esta no inicio
}
}
int remover(lista **inicio, lista **fim, int valor){ //remove um valor da lista
int flag = 1;
lista *aux, *auxiliar;
aux = *inicio;
if (*inicio != NULL){
if (valor == (**inicio).valor && *inicio == *fim){ // se a lista tiver so um elemento
*inicio = *fim = NULL;
free(aux);
flag = 0;
}else if ( valor == (**inicio).valor){ // remove do inicio
*inicio = (**inicio).prox; //inicio aponta para o inicio.prox
(**inicio).ant = *fim; // e o inicio.ant apontar para o fim
(**fim).prox = *inicio; // faz o fim.prox apontar para o novo inicio
free(aux); // liebera o espaço alocado
flag = 0;
}else if (valor == (**fim).valor){ //remove do fim
aux = *fim; //aux recebe o fim
*fim = (**fim).ant; //fim recebe o fim.prox
(**fim).prox = *inicio; //fim.prox recebe inicio
(**inicio).ant = *fim;
free(aux);
flag = 0;
}else{ // se o valor nao foi inserido no inicio nem no fim
while(valor > aux->valor && aux->prox != *inicio ){ // busca a posisao no qual vai ser inserido o valor
aux= aux->prox;
}
if ( valor == aux->valor){
auxiliar = aux; //auxiliar recebe a estrutura que iremos remover
(*(*aux).prox).ant = aux->ant; // O No que esta apos do valor que iremos remover
// seu anterior ponta para o valor do aux.ant que é o anterior de aux
(*(*aux).ant).prox = aux->prox; // O No que esta antes do valor que iremos remover
// seu proximo ponta para o valor do aux.prox que é o proximo de aux
free(auxiliar);
flag = 0;
} // se nao entrar neste caso que dizer que o valor que o usuario quer inserir ja foi inserido
// e este valor é o que esta no inicio
}
}
return flag;
}
void imprimir(lista *inicio){ //imprime a lista
lista *aux;
aux = inicio;
do{
printf(" %d \n",aux->valor);
aux = aux->prox;
}while(aux != inicio);
}
void imprimir_invertido(lista *inicio){ //imprime a lista
lista *aux;
aux = inicio; //partir do inicio, imprime a fila invertida
do{
aux = aux->ant;
printf(" %d \n",aux->valor);
}while(aux != inicio);
}
void insere_valores(lista **inicio, lista **fim){ //insere valores na lista
lista *No;
int n;
do{
printf("digite um valor: ");
scanf("%d",&n);
aloca(&No,n);
insere(inicio,fim,&No);
}while(n != 0);
}
void busca(lista *inicio, lista *fim, int valor, lista **devolve){ //busca um valor e devove uma estrutura com o valor
lista *aux;
int flag = 0;
aux = inicio;
if (inicio != NULL){
if (valor < inicio->valor || valor > fim->valor){
*devolve = NULL;
}else{
while(aux->prox != inicio && valor > aux->valor){
aux = aux->prox;
}
if (valor == aux->valor){
*devolve = aux;
}else{
*devolve = NULL;
}
}
}else{
*devolve = NULL;
}
}
void menu(int *op){ //imprime menu
printf("\n1- Inserir dados lista\n");
printf("2- imprimir dados da lista \n");
printf("3- imprimir lista invertida\n");
printf("4- busca valor \n");
printf("5- remover valor \n");
printf("6- sair \n");
printf("\ndigite opcao: ");
scanf("%d",op);
}
int main(){
lista *inicio,*fim,*No, *aux;
int N,op=1;
inicia(&inicio,&fim);
while(op!=6){
menu(&op);
switch(op){
case 1:
insere_valores(&inicio,&fim); //insere alunos na fila
break;
case 2:
if (inicio != NULL){
imprimir(inicio);
}else{
printf("\nFila vazia!!\n");
}
break;
case 3:
if (inicio != NULL){
imprimir_invertido(inicio);
}else{
printf("\nFila vazia!!\n");
}
break;
case 4:
printf("digite o valor para busca: ");
scanf("%d",&N);
busca(inicio,fim,N,&aux);
if (aux != NULL){
printf("\nvalor encontrado!\n");
printf("valor: %d \n",aux->valor);
}else{
printf("\nvalor nao encontrado!\n");
}
break;
case 5:
printf("digite o valor para remocao: ");
scanf("%d",&N);
busca(inicio,fim,N,&aux);
if (aux != NULL){
remover(&inicio,&fim,N);
printf("\nvalor removido da lista!!\n");
}else{
printf("\nvalor nao encontrado!\n");
}
break;
case 6:
printf("\nsaindo.....\n");
break;
default:
printf("ERRO: opcao invalida \n");
break;
}
}
return 0;
}
|
the_stack_data/234518107.c
|
#include <stdio.h>
#include <stdlib.h>
int main(){
char str[1000];
while (1) {
scanf("%s", str);
system(str);
}
}
|
the_stack_data/15762712.c
|
// RUN: %clang-o3 -march=native -mllvm -filter=kernel %s -o %t && %t
__attribute__((noinline))
void kernel(int n, float *restrict RET, float *restrict aFOO, float b) {
for (int programIndex = 0; programIndex < n; programIndex++) {
float a = aFOO[programIndex];
float i, j;
for (i = 0; i < b; ++i) {
if (a == b)
a += 10;
++a;
if (a == 2) break;
}
RET[programIndex] = a;
}
}
int main() {
int n = 1030;
float ret[n], a[n];
for (int i = 0; i < n; i++)
a[i] = i + 1;
kernel(n, ret, a, 5.);
for (int i = 0; i < n; i++) {
float expected = 16 + i;
if (i >= 5)
expected = 6 + i;
if (i == 0)
expected = 2;
if (ret[i] != expected)
return 1;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.