file
stringlengths 18
26
| data
stringlengths 4
1.03M
|
|---|---|
the_stack_data/1022683.c | // PARAM: --sets solver td3 --enable ana.int.interval --disable ana.int.def_exc --disable exp.fast_global_inits --enable exp.partition-arrays.enabled --set ana.activated "['base','expRelation','octagon']"
// These examples were cases were we saw issues of not reaching a fixpoint during development of the octagon domain. Since those issues might
// resurface, these tests without asserts are included
int main(int argc, char const *argv[])
{
int top;
int pad = 0;
int to_uppcase;
int change_case = 0;
while (change_case != 1 && to_uppcase != 0) {
if(top == 1) {
to_uppcase = 1;
continue;
}
if(top == 2) {
change_case = 1;
continue;
}
break;
}
return 0;
}
|
the_stack_data/68887792.c | #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#define N 50
int main (int argc, char *argv[])
{
int i, nthreads, tid;
float a[N], b[N], c[N], d[N];
/* Some initializations */
for (i=0; i<N; i++) {
a[i] = i * 1.5;
b[i] = i + 22.35;
c[i] = d[i] = 0.0;
}
#pragma omp parallel shared(a,b,c,d,nthreads) private(i,tid) num_threads(4)
{
tid = omp_get_thread_num();
if (tid == 0)
{
nthreads = omp_get_num_threads();
printf("Number of threads = %d\n", nthreads);
}
printf("Thread %d starting...\n",tid);
#pragma omp sections nowait
{
#pragma omp section
{
printf("Thread %d doing section 1\n",tid);
for (i=0; i<N; i++)
{
c[i] = a[i] + b[i];
printf("Thread %d: c[%d]= %f\n",tid,i,c[i]);
}
}
#pragma omp section
{
printf("Thread %d doing section 2\n",tid);
for (i=0; i<N; i++)
{
d[i] = a[i] * b[i];
printf("Thread %d: d[%d]= %f\n",tid,i,d[i]);
}
}
} /* end of sections */
printf("Thread %d done.\n",tid);
} /* end of parallel section */
}
|
the_stack_data/4219.c | #include<stdio.h>
int main(){
int n, count = 0;
scanf("%d", &n);
while(n > 1) {
if(n % 2 == 1) n = n*3+1;
else n /= 2;
count++;
}
printf("%d\n", count);
return 0;
}
|
the_stack_data/192727.c |
/*============================================================================
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
Package, Release 3e, by John R. Hauser.
Copyright 2011, 2012, 2013, 2014, 2015 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.
=============================================================================*/
#ifdef HAVE_PLATFORM_H
#include "platform.h"
#endif
#if !defined(false)
#include <stdbool.h>
#endif
#if !defined(int32_t)
#include <stdint.h> /* C99 standard integers */
#endif
#ifndef softfloat_le128
bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
{
return (a64 < b64) || ((a64 == b64) && (a0 <= b0));
}
#endif
|
the_stack_data/155527.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
int main ()
{
int m,n;
scanf("%d %d",&m,&n);
int combine ();
printf("%d",combine(m,n));
return 0;
}
int combine (int m,int n)
{
if ((n==0)||(m==n))
return 1;
else
{
return combine (m-1,n) + combine (m-1,n-1);
}
} |
the_stack_data/3261481.c |
#include <stdio.h>
void scilab_rt_contour_i2i2i2i2d0d0s0d2d2i0_(int in00, int in01, int matrixin0[in00][in01],
int in10, int in11, int matrixin1[in10][in11],
int in20, int in21, int matrixin2[in20][in21],
int in30, int in31, int matrixin3[in30][in31],
double scalarin0,
double scalarin1,
char* scalarin2,
int in40, int in41, double matrixin4[in40][in41],
int in50, int in51, double matrixin5[in50][in51],
int scalarin3)
{
int i;
int j;
int val0 = 0;
int val1 = 0;
int val2 = 0;
int val3 = 0;
double val4 = 0;
double val5 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%d", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%d", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%d", val2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%d", val3);
printf("%f", scalarin0);
printf("%f", scalarin1);
printf("%s", scalarin2);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%f", val4);
for (i = 0; i < in50; ++i) {
for (j = 0; j < in51; ++j) {
val5 += matrixin5[i][j];
}
}
printf("%f", val5);
printf("%d", scalarin3);
}
|
the_stack_data/5191.c | #include <stdio.h>
void main() {
int x, sum = 0, i = 0;
do
{
printf("Write your mark: ");
scanf("%d",&x);
if(x > 0 && x <= 100)
{
sum += x;
i++;
}
}
while (x != 0);
printf("Average mark is %d\n", sum/i);
}
|
the_stack_data/165766439.c | #include <math.h>
#include <stdio.h>
void solve(double meal_cost, int tip_percent, int tax_percent)
{
double tip_cost = meal_cost * tip_percent / 100;
double tax_cost = meal_cost * tax_percent / 100;
double total_cost = meal_cost + tip_cost + tax_cost;
printf("%d\n", (int)round(total_cost));
}
int main()
{
double meal_cost = 0.0;
int tip_percent = 0;
int tax_percent = 0;
scanf("%lf%d%d", &meal_cost, &tip_percent, &tax_percent);
solve(meal_cost, tip_percent, tax_percent);
return 0;
}
|
the_stack_data/48575834.c | #include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include <string.h>
typedef struct node
{
int data;
struct node * left;
struct node * right;
struct node * parent;
} node;
typedef struct tree
{
struct node * root; // указатель на корень дерева
int count; // количество узлов в дереве
} tree;
void init(tree * t)
{
t->root = NULL;
t->count = 0;
}
node* getFreeNode(int value, node* parent) // Новый узел
{
node* tmp = (struct node*)malloc(sizeof(struct node));
tmp->left = tmp->right = NULL;
tmp->data = value;
tmp->parent = parent;
return tmp;
}
int insert(tree* t, int value) // Вставка узла
{
if (t->root == NULL)
{ // Проверка корня
t->root = getFreeNode(value, NULL); //занесение корня
t->count++;
return 0;
}
struct node* tmp = t->root;
while (tmp != NULL)
{
if (value > tmp->data)
{
if (tmp->right != NULL)
{
tmp = tmp->right;
continue;
}
else
{
tmp->right = getFreeNode(value, tmp);
t->count++;
return 0;
}
}
else if (value < tmp->data)
{
if (tmp->left != NULL)
{
tmp = tmp->left;
continue;
}
else
{
tmp->left = getFreeNode(value, tmp);
t->count++;
return 0;
}
}
else if (value == tmp->data) return 0;
else
{
exit(2);
}
}
return 1;
}
int deepness(struct node * t){
/*
if (n == NULL){
return deep;
}
int d1 = deepness(n->left, deep + 1);
int d2 = deepness(n->right, deep + 1);
return (d1 > d2) ? d1 : d2;
*/
int r=0, l=0;
if ((t->right) != NULL) r = deepness(t->right);
if ((t->left) != NULL) l = deepness(t->left);
if (r > l) return (r+1);
return (l+1);
}
int printTree(struct node *t)
{
if (t == NULL)
{
printf("-\n");
return 1;
}
struct node *Temp=t;
int Rang=0, i, j, k, sk;
int *comb;
Rang = deepness(t);
comb = (int*)malloc(sizeof(int));
for (i = 0; i < Rang; i++)
{
if (i != 0)
{
comb = (int*)realloc(comb, i* sizeof(int));
for (j = 0; j < i; j++)
{
comb[j] = 0;
}
}
j = 1;
sk = i;
while (sk != 0)
{
j = j * 2;
sk--;
}
while (j != 0)
{
k = 0;
Temp = t;
for (k = 0; k < i; k++)
{
if (comb[k] == 0)
{
if ((Temp->left) != NULL) Temp = Temp->left;
else
{
k = -1;
break;
}
}
else
{
if ((Temp->right) != NULL) Temp = Temp->right;
else
{
k = -1;
break;
}
}
}
if (i != 0)
{
sk=i-1;
comb[sk]++;
while (1)
{
if (comb[sk] == 2)
{
comb[sk] = 0;
sk--;
if (sk < 0) break;
else comb[sk]++;
}
else break;
}
}
if (k==-1) printf("_");
else printf("%d", (int)Temp->data);
j--;
if (j != 0) printf(" ");
}
printf("\n");
}
return 1;
}
node* get_root(tree * t)
{
return t->root;
}
int get_count(tree * t)
{
return t->count;
}
int printWidth(struct node* t)
{
struct node *Temp = t;
int Rang = 0, i, j, k, sk, Spaces = 0;
int *comb;
Rang = deepness(t);
comb = (int*)malloc(sizeof(int));
for (i = 0; i < Rang; i++)//обработка рангов
{
if (i != 0)//объявление-зануление
{
comb = (int*)realloc(comb, i * sizeof(int));
for (j = 0; j < i; j++)
comb[j] = 0;
}
j = 1;
sk = i;
while (sk != 0)//получение кол-ва элементов на уровне
{
j = j * 2;
sk--;
}
while (j != 0)//проход для каждого элемент
{
k = 0;
Temp = t;
for (k = 0; k < i; k++)//проход до определённого узла
{
if (comb[k] == 0)
{
if ((Temp->left) != NULL)
Temp = Temp->left;
else
{
k = -1;
break;
}
}
else
{
if ((Temp->right) != NULL)
Temp = Temp->right;
else
{
k = -1;
break;
}
}
}
if (i != 0)//изменяем массив, если он вообще существует
{
sk = i - 1;
comb[sk]++;
while (1)
{
if (comb[sk] == 2)
{
comb[sk] = 0;
sk--;
if (sk < 0)
break;
else
comb[sk]++;
}
else
break;
}
}
if (k != -1)//если элемент есть вообще
{
if (Spaces == 1)
{
printf(" ");
Spaces = 1;
}
printf("%d", (int)Temp->data);
Spaces = 1;
}
j--;
}//конец ряда
}
return 0;
}
int main(){
int x, i;
struct tree tr;
init(&tr);
for (i = 0; i < 7; i++){
scanf("%d", &x);
insert(&tr, x);
}
printWidth(get_root(&tr));
printf("\n");
return 0;
}
|
the_stack_data/43252.c | // KASAN: slab-out-of-bounds Write in sysrq_filter
// https://syzkaller.appspot.com/bug?id=3c08d9454c8384a6dac0a9bc0968c4aad2d17b4b
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <sched.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_link.h>
#include <linux/in6.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/usb/ch9.h>
#include <linux/veth.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \
*(type*)(addr) = \
htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \
(((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
};
static struct nlmsg nlmsg;
static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
const void* data, int size)
{
memset(nlmsg, 0, sizeof(*nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len)
{
if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
if (hdr->nlmsg_type == NLMSG_DONE) {
*reply_len = 0;
return 0;
}
if (n < sizeof(struct nlmsghdr))
exit(1);
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 0;
}
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static int netlink_send(struct nlmsg* nlmsg, int sock)
{
return netlink_send_ext(nlmsg, sock, 0, NULL);
}
static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset,
unsigned int total_len)
{
struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset);
if (offset == total_len || offset + hdr->nlmsg_len > total_len)
return -1;
return hdr->nlmsg_len;
}
static void netlink_device_change(struct nlmsg* nlmsg, int sock,
const char* name, bool up, const char* master,
const void* mac, int macsize,
const char* new_name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
hdr.ifi_index = if_nametoindex(name);
netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
if (new_name)
netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
const int kInitNetNsFd = 239;
#define DEVLINK_FAMILY_NAME "devlink"
#define DEVLINK_CMD_PORT_GET 5
#define DEVLINK_CMD_RELOAD 37
#define DEVLINK_ATTR_BUS_NAME 1
#define DEVLINK_ATTR_DEV_NAME 2
#define DEVLINK_ATTR_NETDEV_NAME 7
#define DEVLINK_ATTR_NETNS_FD 138
static int netlink_devlink_id_get(struct nlmsg* nlmsg, int sock)
{
struct genlmsghdr genlhdr;
struct nlattr* attr;
int err, n;
uint16_t id = 0;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, DEVLINK_FAMILY_NAME,
strlen(DEVLINK_FAMILY_NAME) + 1);
err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
if (err) {
return -1;
}
attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); /* recv ack */
return id;
}
static void netlink_devlink_netns_move(const char* bus_name,
const char* dev_name, int netns_fd)
{
struct genlmsghdr genlhdr;
int sock;
int id, err;
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_RELOAD;
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_NETNS_FD, &netns_fd, sizeof(netns_fd));
err = netlink_send(&nlmsg, sock);
if (err) {
}
error:
close(sock);
}
static struct nlmsg nlmsg2;
static void initialize_devlink_ports(const char* bus_name, const char* dev_name,
const char* netdev_prefix)
{
struct genlmsghdr genlhdr;
int len, total_len, id, err, offset;
uint16_t netdev_index;
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (rtsock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_PORT_GET;
netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
err = netlink_send_ext(&nlmsg, sock, id, &total_len);
if (err) {
goto error;
}
offset = 0;
netdev_index = 0;
while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) {
struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg.buf + offset + len;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) {
char* port_name;
char netdev_name[IFNAMSIZ];
port_name = (char*)(attr + 1);
snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix,
netdev_index);
netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0,
netdev_name);
break;
}
}
offset += len;
netdev_index++;
}
error:
close(rtsock);
close(sock);
}
static void initialize_devlink_pci(void)
{
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
exit(1);
int ret = setns(kInitNetNsFd, 0);
if (ret == -1)
exit(1);
netlink_devlink_netns_move("pci", "0000:00:10.0", netns);
ret = setns(netns, 0);
if (ret == -1)
exit(1);
close(netns);
initialize_devlink_ports("pci", "0000:00:10.0", "netpci");
}
#define MAX_FDS 30
#define USB_MAX_IFACE_NUM 4
#define USB_MAX_EP_NUM 32
struct usb_iface_index {
struct usb_interface_descriptor* iface;
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t bInterfaceClass;
struct usb_endpoint_descriptor eps[USB_MAX_EP_NUM];
int eps_num;
};
struct usb_device_index {
struct usb_device_descriptor* dev;
struct usb_config_descriptor* config;
uint8_t bDeviceClass;
uint8_t bMaxPower;
int config_length;
struct usb_iface_index ifaces[USB_MAX_IFACE_NUM];
int ifaces_num;
int iface_cur;
};
static bool parse_usb_descriptor(char* buffer, size_t length,
struct usb_device_index* index)
{
if (length < sizeof(*index->dev) + sizeof(*index->config))
return false;
memset(index, 0, sizeof(*index));
index->dev = (struct usb_device_descriptor*)buffer;
index->config = (struct usb_config_descriptor*)(buffer + sizeof(*index->dev));
index->bDeviceClass = index->dev->bDeviceClass;
index->bMaxPower = index->config->bMaxPower;
index->config_length = length - sizeof(*index->dev);
index->iface_cur = -1;
size_t offset = 0;
while (true) {
if (offset + 1 >= length)
break;
uint8_t desc_length = buffer[offset];
uint8_t desc_type = buffer[offset + 1];
if (desc_length <= 2)
break;
if (offset + desc_length > length)
break;
if (desc_type == USB_DT_INTERFACE &&
index->ifaces_num < USB_MAX_IFACE_NUM) {
struct usb_interface_descriptor* iface =
(struct usb_interface_descriptor*)(buffer + offset);
index->ifaces[index->ifaces_num].iface = iface;
index->ifaces[index->ifaces_num].bInterfaceNumber =
iface->bInterfaceNumber;
index->ifaces[index->ifaces_num].bAlternateSetting =
iface->bAlternateSetting;
index->ifaces[index->ifaces_num].bInterfaceClass = iface->bInterfaceClass;
index->ifaces_num++;
}
if (desc_type == USB_DT_ENDPOINT && index->ifaces_num > 0) {
struct usb_iface_index* iface = &index->ifaces[index->ifaces_num - 1];
if (iface->eps_num < USB_MAX_EP_NUM) {
memcpy(&iface->eps[iface->eps_num], buffer + offset,
sizeof(iface->eps[iface->eps_num]));
iface->eps_num++;
}
}
offset += desc_length;
}
return true;
}
struct usb_raw_init {
__u64 speed;
const __u8* driver_name;
const __u8* device_name;
};
enum usb_raw_event_type {
USB_RAW_EVENT_INVALID,
USB_RAW_EVENT_CONNECT,
USB_RAW_EVENT_CONTROL,
};
struct usb_raw_event {
__u32 type;
__u32 length;
__u8 data[0];
};
struct usb_raw_ep_io {
__u16 ep;
__u16 flags;
__u32 length;
__u8 data[0];
};
#define USB_RAW_IOCTL_INIT _IOW('U', 0, struct usb_raw_init)
#define USB_RAW_IOCTL_RUN _IO('U', 1)
#define USB_RAW_IOCTL_EVENT_FETCH _IOR('U', 2, struct usb_raw_event)
#define USB_RAW_IOCTL_EP0_WRITE _IOW('U', 3, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP0_READ _IOWR('U', 4, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP_ENABLE _IOW('U', 5, struct usb_endpoint_descriptor)
#define USB_RAW_IOCTL_EP_DISABLE _IOW('U', 6, __u32)
#define USB_RAW_IOCTL_EP_WRITE _IOW('U', 7, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP_READ _IOWR('U', 8, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_CONFIGURE _IO('U', 9)
#define USB_RAW_IOCTL_VBUS_DRAW _IOW('U', 10, __u32)
static int usb_raw_open()
{
return open("/dev/raw-gadget", O_RDWR);
}
static int usb_raw_init(int fd, uint32_t speed, const char* driver,
const char* device)
{
struct usb_raw_init arg;
arg.speed = speed;
arg.driver_name = (const __u8*)driver;
arg.device_name = (const __u8*)device;
return ioctl(fd, USB_RAW_IOCTL_INIT, &arg);
}
static int usb_raw_run(int fd)
{
return ioctl(fd, USB_RAW_IOCTL_RUN, 0);
}
static int usb_raw_event_fetch(int fd, struct usb_raw_event* event)
{
return ioctl(fd, USB_RAW_IOCTL_EVENT_FETCH, event);
}
static int usb_raw_ep0_write(int fd, struct usb_raw_ep_io* io)
{
return ioctl(fd, USB_RAW_IOCTL_EP0_WRITE, io);
}
static int usb_raw_ep0_read(int fd, struct usb_raw_ep_io* io)
{
return ioctl(fd, USB_RAW_IOCTL_EP0_READ, io);
}
static int usb_raw_ep_enable(int fd, struct usb_endpoint_descriptor* desc)
{
return ioctl(fd, USB_RAW_IOCTL_EP_ENABLE, desc);
}
static int usb_raw_ep_disable(int fd, int ep)
{
return ioctl(fd, USB_RAW_IOCTL_EP_DISABLE, ep);
}
static int usb_raw_configure(int fd)
{
return ioctl(fd, USB_RAW_IOCTL_CONFIGURE, 0);
}
static int usb_raw_vbus_draw(int fd, uint32_t power)
{
return ioctl(fd, USB_RAW_IOCTL_VBUS_DRAW, power);
}
#define MAX_USB_FDS 6
struct usb_info {
int fd;
struct usb_device_index index;
};
static struct usb_info usb_devices[MAX_USB_FDS];
static int usb_devices_num;
static struct usb_device_index* add_usb_index(int fd, char* dev, size_t dev_len)
{
int i = __atomic_fetch_add(&usb_devices_num, 1, __ATOMIC_RELAXED);
if (i >= MAX_USB_FDS)
return NULL;
int rv = 0;
rv = parse_usb_descriptor(dev, dev_len, &usb_devices[i].index);
if (!rv)
return NULL;
__atomic_store_n(&usb_devices[i].fd, fd, __ATOMIC_RELEASE);
return &usb_devices[i].index;
}
static struct usb_device_index* lookup_usb_index(int fd)
{
int i;
for (i = 0; i < MAX_USB_FDS; i++) {
if (__atomic_load_n(&usb_devices[i].fd, __ATOMIC_ACQUIRE) == fd) {
return &usb_devices[i].index;
}
}
return NULL;
}
static int lookup_interface(int fd, uint8_t bInterfaceNumber,
uint8_t bAlternateSetting)
{
struct usb_device_index* index = lookup_usb_index(fd);
int i;
if (!index)
return -1;
for (i = 0; i < index->ifaces_num; i++) {
if (index->ifaces[i].bInterfaceNumber == bInterfaceNumber &&
index->ifaces[i].bAlternateSetting == bAlternateSetting)
return i;
}
return -1;
}
static void set_interface(int fd, int n)
{
struct usb_device_index* index = lookup_usb_index(fd);
int ep;
if (!index)
return;
if (index->iface_cur >= 0 && index->iface_cur < index->ifaces_num) {
for (ep = 0; ep < index->ifaces[index->iface_cur].eps_num; ep++) {
int rv = usb_raw_ep_disable(fd, ep);
if (rv < 0) {
} else {
}
}
}
if (n >= 0 && n < index->ifaces_num) {
for (ep = 0; ep < index->ifaces[n].eps_num; ep++) {
int rv = usb_raw_ep_enable(fd, &index->ifaces[n].eps[ep]);
if (rv < 0) {
} else {
}
}
index->iface_cur = n;
}
}
static int configure_device(int fd)
{
struct usb_device_index* index = lookup_usb_index(fd);
if (!index)
return -1;
int rv = usb_raw_vbus_draw(fd, index->bMaxPower);
if (rv < 0) {
return rv;
}
rv = usb_raw_configure(fd);
if (rv < 0) {
return rv;
}
set_interface(fd, 0);
return 0;
}
#define USB_MAX_PACKET_SIZE 1024
struct usb_raw_control_event {
struct usb_raw_event inner;
struct usb_ctrlrequest ctrl;
char data[USB_MAX_PACKET_SIZE];
};
struct usb_raw_ep_io_data {
struct usb_raw_ep_io inner;
char data[USB_MAX_PACKET_SIZE];
};
struct vusb_connect_string_descriptor {
uint32_t len;
char* str;
} __attribute__((packed));
struct vusb_connect_descriptors {
uint32_t qual_len;
char* qual;
uint32_t bos_len;
char* bos;
uint32_t strs_len;
struct vusb_connect_string_descriptor strs[0];
} __attribute__((packed));
static const char default_string[] = {8, USB_DT_STRING, 's', 0, 'y', 0, 'z', 0};
static const char default_lang_id[] = {4, USB_DT_STRING, 0x09, 0x04};
static bool lookup_connect_response(int fd,
struct vusb_connect_descriptors* descs,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length)
{
struct usb_device_index* index = lookup_usb_index(fd);
uint8_t str_idx;
if (!index)
return false;
switch (ctrl->bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD:
switch (ctrl->bRequest) {
case USB_REQ_GET_DESCRIPTOR:
switch (ctrl->wValue >> 8) {
case USB_DT_DEVICE:
*response_data = (char*)index->dev;
*response_length = sizeof(*index->dev);
return true;
case USB_DT_CONFIG:
*response_data = (char*)index->config;
*response_length = index->config_length;
return true;
case USB_DT_STRING:
str_idx = (uint8_t)ctrl->wValue;
if (descs && str_idx < descs->strs_len) {
*response_data = descs->strs[str_idx].str;
*response_length = descs->strs[str_idx].len;
return true;
}
if (str_idx == 0) {
*response_data = (char*)&default_lang_id[0];
*response_length = default_lang_id[0];
return true;
}
*response_data = (char*)&default_string[0];
*response_length = default_string[0];
return true;
case USB_DT_BOS:
*response_data = descs->bos;
*response_length = descs->bos_len;
return true;
case USB_DT_DEVICE_QUALIFIER:
if (!descs->qual) {
struct usb_qualifier_descriptor* qual =
(struct usb_qualifier_descriptor*)response_data;
qual->bLength = sizeof(*qual);
qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
qual->bcdUSB = index->dev->bcdUSB;
qual->bDeviceClass = index->dev->bDeviceClass;
qual->bDeviceSubClass = index->dev->bDeviceSubClass;
qual->bDeviceProtocol = index->dev->bDeviceProtocol;
qual->bMaxPacketSize0 = index->dev->bMaxPacketSize0;
qual->bNumConfigurations = index->dev->bNumConfigurations;
qual->bRESERVED = 0;
*response_length = sizeof(*qual);
return true;
}
*response_data = descs->qual;
*response_length = descs->qual_len;
return true;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
return false;
}
static volatile long syz_usb_connect(volatile long a0, volatile long a1,
volatile long a2, volatile long a3)
{
uint64_t speed = a0;
uint64_t dev_len = a1;
char* dev = (char*)a2;
struct vusb_connect_descriptors* descs = (struct vusb_connect_descriptors*)a3;
if (!dev) {
return -1;
}
int fd = usb_raw_open();
if (fd < 0) {
return fd;
}
if (fd >= MAX_FDS) {
close(fd);
return -1;
}
struct usb_device_index* index = add_usb_index(fd, dev, dev_len);
if (!index) {
return -1;
}
char device[32];
sprintf(&device[0], "dummy_udc.%llu", procid);
int rv = usb_raw_init(fd, speed, "dummy_udc", &device[0]);
if (rv < 0) {
return rv;
}
rv = usb_raw_run(fd);
if (rv < 0) {
return rv;
}
bool done = false;
while (!done) {
struct usb_raw_control_event event;
event.inner.type = 0;
event.inner.length = sizeof(event.ctrl);
rv = usb_raw_event_fetch(fd, (struct usb_raw_event*)&event);
if (rv < 0) {
return rv;
}
if (event.inner.type != USB_RAW_EVENT_CONTROL)
continue;
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
if (event.ctrl.bRequestType & USB_DIR_IN) {
response_found = lookup_connect_response(
fd, descs, &event.ctrl, &response_data, &response_length);
if (!response_found) {
return -1;
}
} else {
if ((event.ctrl.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD ||
event.ctrl.bRequest != USB_REQ_SET_CONFIGURATION) {
exit(1);
return -1;
}
done = true;
}
if (done) {
rv = configure_device(fd);
if (rv < 0) {
return rv;
}
}
struct usb_raw_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
if (event.ctrl.wLength < response_length)
response_length = event.ctrl.wLength;
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
else
memset(&response.data[0], 0, response_length);
if (event.ctrl.bRequestType & USB_DIR_IN) {
rv = usb_raw_ep0_write(fd, (struct usb_raw_ep_io*)&response);
} else {
rv = usb_raw_ep0_read(fd, (struct usb_raw_ep_io*)&response);
}
if (rv < 0) {
return rv;
}
}
sleep_ms(200);
return fd;
}
struct vusb_descriptor {
uint8_t req_type;
uint8_t desc_type;
uint32_t len;
char data[0];
} __attribute__((packed));
struct vusb_descriptors {
uint32_t len;
struct vusb_descriptor* generic;
struct vusb_descriptor* descs[0];
} __attribute__((packed));
struct vusb_response {
uint8_t type;
uint8_t req;
uint32_t len;
char data[0];
} __attribute__((packed));
struct vusb_responses {
uint32_t len;
struct vusb_response* generic;
struct vusb_response* resps[0];
} __attribute__((packed));
static bool lookup_control_response(struct vusb_descriptors* descs,
struct vusb_responses* resps,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length)
{
int descs_num = 0;
int resps_num = 0;
if (descs)
descs_num = (descs->len - offsetof(struct vusb_descriptors, descs)) /
sizeof(descs->descs[0]);
if (resps)
resps_num = (resps->len - offsetof(struct vusb_responses, resps)) /
sizeof(resps->resps[0]);
uint8_t req = ctrl->bRequest;
uint8_t req_type = ctrl->bRequestType & USB_TYPE_MASK;
uint8_t desc_type = ctrl->wValue >> 8;
if (req == USB_REQ_GET_DESCRIPTOR) {
int i;
for (i = 0; i < descs_num; i++) {
struct vusb_descriptor* desc = descs->descs[i];
if (!desc)
continue;
if (desc->req_type == req_type && desc->desc_type == desc_type) {
*response_length = desc->len;
if (*response_length != 0)
*response_data = &desc->data[0];
else
*response_data = NULL;
return true;
}
}
if (descs && descs->generic) {
*response_data = &descs->generic->data[0];
*response_length = descs->generic->len;
return true;
}
} else {
int i;
for (i = 0; i < resps_num; i++) {
struct vusb_response* resp = resps->resps[i];
if (!resp)
continue;
if (resp->type == req_type && resp->req == req) {
*response_length = resp->len;
if (*response_length != 0)
*response_data = &resp->data[0];
else
*response_data = NULL;
return true;
}
}
if (resps && resps->generic) {
*response_data = &resps->generic->data[0];
*response_length = resps->generic->len;
return true;
}
}
return false;
}
static volatile long syz_usb_control_io(volatile long a0, volatile long a1,
volatile long a2)
{
int fd = a0;
struct vusb_descriptors* descs = (struct vusb_descriptors*)a1;
struct vusb_responses* resps = (struct vusb_responses*)a2;
struct usb_raw_control_event event;
event.inner.type = 0;
event.inner.length = USB_MAX_PACKET_SIZE;
int rv = usb_raw_event_fetch(fd, (struct usb_raw_event*)&event);
if (rv < 0) {
return rv;
}
if (event.inner.type != USB_RAW_EVENT_CONTROL) {
return -1;
}
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
if ((event.ctrl.bRequestType & USB_DIR_IN) && event.ctrl.wLength) {
response_found = lookup_control_response(descs, resps, &event.ctrl,
&response_data, &response_length);
if (!response_found) {
return -1;
}
} else {
if ((event.ctrl.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD ||
event.ctrl.bRequest == USB_REQ_SET_INTERFACE) {
int iface_num = event.ctrl.wIndex;
int alt_set = event.ctrl.wValue;
int iface_index = lookup_interface(fd, iface_num, alt_set);
if (iface_index < 0) {
} else {
set_interface(fd, iface_index);
}
}
response_length = event.ctrl.wLength;
}
struct usb_raw_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
if (event.ctrl.wLength < response_length)
response_length = event.ctrl.wLength;
if ((event.ctrl.bRequestType & USB_DIR_IN) && !event.ctrl.wLength) {
response_length = USB_MAX_PACKET_SIZE;
}
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
else
memset(&response.data[0], 0, response_length);
if ((event.ctrl.bRequestType & USB_DIR_IN) && event.ctrl.wLength) {
rv = usb_raw_ep0_write(fd, (struct usb_raw_ep_io*)&response);
} else {
rv = usb_raw_ep0_read(fd, (struct usb_raw_ep_io*)&response);
}
if (rv < 0) {
return rv;
}
sleep_ms(200);
return 0;
}
static volatile long syz_usb_disconnect(volatile long a0)
{
int fd = a0;
int rv = close(fd);
sleep_ms(200);
return rv;
}
static long syz_open_dev(volatile long a0, volatile long a1, volatile long a2)
{
if (a0 == 0xc || a0 == 0xb) {
char buf[128];
sprintf(buf, "/dev/%s/%d:%d", a0 == 0xc ? "char" : "block", (uint8_t)a1,
(uint8_t)a2);
return open(buf, O_RDWR, 0);
} else {
char buf[1024];
char* hash;
strncpy(buf, (char*)a0, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = 0;
while ((hash = strchr(buf, '#'))) {
*hash = '0' + (char)(a1 % 10);
a1 /= 10;
}
return open(buf, a2, 0);
}
}
uint64_t r[3] = {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff};
int main(void)
{
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 3ul, 0x32ul, -1, 0);
intptr_t res = 0;
*(uint8_t*)0x20000040 = 0x12;
*(uint8_t*)0x20000041 = 1;
*(uint16_t*)0x20000042 = 0;
*(uint8_t*)0x20000044 = 0;
*(uint8_t*)0x20000045 = 0;
*(uint8_t*)0x20000046 = 0;
*(uint8_t*)0x20000047 = 0x10;
*(uint16_t*)0x20000048 = 0x45e;
*(uint16_t*)0x2000004a = 0x7da;
*(uint16_t*)0x2000004c = 0;
*(uint8_t*)0x2000004e = 0;
*(uint8_t*)0x2000004f = 0;
*(uint8_t*)0x20000050 = 0;
*(uint8_t*)0x20000051 = 1;
*(uint8_t*)0x20000052 = 9;
*(uint8_t*)0x20000053 = 2;
*(uint16_t*)0x20000054 = 0x24;
*(uint8_t*)0x20000056 = 1;
*(uint8_t*)0x20000057 = 0;
*(uint8_t*)0x20000058 = 0;
*(uint8_t*)0x20000059 = 0;
*(uint8_t*)0x2000005a = 0;
*(uint8_t*)0x2000005b = 9;
*(uint8_t*)0x2000005c = 4;
*(uint8_t*)0x2000005d = 0;
*(uint8_t*)0x2000005e = 0;
*(uint8_t*)0x2000005f = 9;
*(uint8_t*)0x20000060 = 3;
*(uint8_t*)0x20000061 = 0;
*(uint8_t*)0x20000062 = 0;
*(uint8_t*)0x20000063 = 0;
*(uint8_t*)0x20000064 = 9;
*(uint8_t*)0x20000065 = 0x21;
*(uint16_t*)0x20000066 = 0;
*(uint8_t*)0x20000068 = 0;
*(uint8_t*)0x20000069 = 1;
*(uint8_t*)0x2000006a = 0x22;
*(uint16_t*)0x2000006b = 0x22;
*(uint8_t*)0x2000006d = 9;
*(uint8_t*)0x2000006e = 5;
*(uint8_t*)0x2000006f = 0x81;
*(uint8_t*)0x20000070 = 3;
*(uint16_t*)0x20000071 = 0;
*(uint8_t*)0x20000073 = 0;
*(uint8_t*)0x20000074 = 0;
*(uint8_t*)0x20000075 = 0;
res = syz_usb_connect(0, 0x36, 0x20000040, 0);
if (res != -1)
r[0] = res;
syz_usb_disconnect(r[0]);
*(uint8_t*)0x20005380 = 0x12;
*(uint8_t*)0x20005381 = 1;
*(uint16_t*)0x20005382 = 0;
*(uint8_t*)0x20005384 = 0;
*(uint8_t*)0x20005385 = 0;
*(uint8_t*)0x20005386 = 0;
*(uint8_t*)0x20005387 = 0;
*(uint16_t*)0x20005388 = 0x45e;
*(uint16_t*)0x2000538a = 0xdb;
*(uint16_t*)0x2000538c = 0;
*(uint8_t*)0x2000538e = 0;
*(uint8_t*)0x2000538f = 0;
*(uint8_t*)0x20005390 = 0;
*(uint8_t*)0x20005391 = 1;
*(uint8_t*)0x20005392 = 9;
*(uint8_t*)0x20005393 = 2;
*(uint16_t*)0x20005394 = 0xff66;
*(uint8_t*)0x20005396 = 1;
*(uint8_t*)0x20005397 = 0;
*(uint8_t*)0x20005398 = 0;
*(uint8_t*)0x20005399 = 0;
*(uint8_t*)0x2000539a = 0;
*(uint8_t*)0x2000539b = 9;
*(uint8_t*)0x2000539c = 4;
*(uint8_t*)0x2000539d = 0;
*(uint8_t*)0x2000539e = 0;
*(uint8_t*)0x2000539f = 0;
*(uint8_t*)0x200053a0 = 3;
*(uint8_t*)0x200053a1 = 0;
*(uint8_t*)0x200053a2 = 0;
*(uint8_t*)0x200053a3 = 0;
*(uint8_t*)0x200053a4 = 9;
*(uint8_t*)0x200053a5 = 0x21;
*(uint16_t*)0x200053a6 = 0;
*(uint8_t*)0x200053a8 = 0;
*(uint8_t*)0x200053a9 = 1;
*(uint8_t*)0x200053aa = 0x22;
*(uint16_t*)0x200053ab = 0;
*(uint8_t*)0x200053ad = 9;
*(uint8_t*)0x200053ae = 5;
*(uint8_t*)0x200053af = 0x81;
*(uint8_t*)0x200053b0 = 3;
*(uint16_t*)0x200053b1 = 0;
*(uint8_t*)0x200053b3 = 0;
*(uint8_t*)0x200053b4 = 0;
*(uint8_t*)0x200053b5 = 0;
res = syz_usb_connect(0, 0x10147, 0x20005380, 0);
if (res != -1)
r[1] = res;
syz_usb_control_io(r[1], 0, 0);
*(uint32_t*)0x200001c0 = 0x24;
*(uint64_t*)0x200001c4 = 0;
*(uint64_t*)0x200001cc = 0;
*(uint64_t*)0x200001d4 = 0x20000000;
*(uint8_t*)0x20000000 = 0;
*(uint8_t*)0x20000001 = 0x22;
*(uint32_t*)0x20000002 = 0x22;
STORE_BY_BITMASK(uint8_t, , 0x20000006, 2, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000006, 1, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000006, 9, 4, 4);
memcpy((void*)0x20000007, "\x01\x13", 2);
STORE_BY_BITMASK(uint8_t, , 0x20000009, 2, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000009, 1, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000009, 0, 4, 4);
memcpy((void*)0x2000000a, "\xe5\x3f", 2);
STORE_BY_BITMASK(uint8_t, , 0x2000000c, 3, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x2000000c, 2, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x2000000c, 1, 4, 4);
memcpy((void*)0x2000000d, "\x3e\xf7\xb1\x34", 4);
STORE_BY_BITMASK(uint8_t, , 0x20000011, 2, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000011, 2, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000011, 2, 4, 4);
memcpy((void*)0x20000012, "\xe5\xfa", 2);
STORE_BY_BITMASK(uint8_t, , 0x20000014, 3, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000014, 1, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000014, 0, 4, 4);
memcpy((void*)0x20000015, "\x09\x00\xbe\x00", 4);
STORE_BY_BITMASK(uint8_t, , 0x20000019, 3, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000019, 0, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000019, 8, 4, 4);
memcpy((void*)0x2000001a, "\000\000\000\000", 4);
STORE_BY_BITMASK(uint8_t, , 0x2000001e, 3, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x2000001e, 0, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x2000001e, 0, 4, 4);
memcpy((void*)0x2000001f, "\x7d\x02\x08\x56", 4);
STORE_BY_BITMASK(uint8_t, , 0x20000023, 3, 0, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000023, 2, 2, 2);
STORE_BY_BITMASK(uint8_t, , 0x20000023, 0, 4, 4);
memcpy((void*)0x20000024, "\x7d\x8c\x3d\xda", 4);
*(uint64_t*)0x200001dc = 0;
syz_usb_control_io(r[0], 0x200001c0, 0);
memcpy((void*)0x20000000, "/dev/input/event#\000", 18);
res = syz_open_dev(0x20000000, 0xea, 0);
if (res != -1)
r[2] = res;
*(uint8_t*)0x200000c0 = 7;
*(uint8_t*)0x200000c1 = 0;
*(uint16_t*)0x200000c2 = 0x11ee;
*(uint32_t*)0x200000c4 = 0;
memcpy((void*)0x200000c8, "\xf0\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00"
"\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00",
32);
syscall(__NR_ioctl, r[2], 0x40284504ul, 0x200000c0ul);
return 0;
}
|
the_stack_data/64514.c | /* A quick test to read the ssb core registers from ecos */
#include <stdio.h>
static inline int readl(int addr)
{
return *(int*)addr;
}
char __ramfs_runtime_data[1024];
char flash_block_array[1024];
int main(void)
{
printf("Hello, eCos world!\n");
printf("chip id: 0x%x\n" , readl(0xa0000000 + 0x18000000 + 0x0000)&0x0000FFFF);
printf("chip revision: 0x%x\n" , readl(0xa0000000 + 0x18000000 + 0x0000)&0x000F0000);
printf("package Options: 0x%x\n", readl(0xa0000000 + 0x18000000 + 0x0000)&0x00F00000);
printf("number of cores 0x%x\n" , readl(0xa0000000 + 0x18000000 + 0x0000)&0x0F000000);
printf("0:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18000000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18000000 + 0x0FFC));
printf("2:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18002000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18002000 + 0x0FFC));
printf("1:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18001000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18001000 + 0x0FFC));
printf("2:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18002000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18002000 + 0x0FFC));
printf("3:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18003000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18003000 + 0x0FFC));
printf("4:\n");
printf("core id low: 0x%x\n", readl(0xa0000000 + 0x18004000 + 0x0FF8));
printf("core id high: 0x%x\n", readl(0xa0000000 + 0x18004000 + 0x0FFC));
return 0;
}
|
the_stack_data/117327286.c | /**
* 获取最长的字符数组并打印
*/
#include <stdio.h>
#define MAXLINE 1000
int getLine(char line[], int maxLine);
void copy(char to[], char from[]);
int main()
{
int len;
int max;
char line[MAXLINE];
char longest[MAXLINE];
max = 0;
while ((len = getLine(line, MAXLINE)) > 0)
{
if (len > max)
{
max = len;
copy(longest, line);
}
}
if (max > 0)
{
printf("%s", longest);
}
return 0;
}
int getLine(char s[], int lim)
{
int c;
int i;
for (i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
{
s[i] = c; // 字符数组赋值
}
if (c == '\n')
{
s[i] = c; // 紧接添加换行符
++i;
}
s[i] = '\0'; // 结尾添加字符数组结束符
return i;
}
void copy(char to[], char from[])
{
int i;
i = 0;
// 字符数组拷贝操作，方式很新颖
while ((to[i] = from[i]) != '\0')
{
++i;
}
}
|
the_stack_data/971384.c | /*
* MIT License
*
* Copyright (c) 2019 Red Hat Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/** @file Main test runner – executes tests from other files. */
#include <stdlib.h>
#include <check.h>
int main()
{
Suite *dummy = suite_create("dummy");
SRunner *runner = srunner_create(dummy);
srunner_run_all(runner, CK_NORMAL);
int num_of_failures = srunner_ntests_failed(runner);
srunner_free(runner);
runner = NULL;
return (num_of_failures == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
|
the_stack_data/84052.c | // Copyright 2021 University of Nottingham Ningbo China
// Author: Filippo Savi <[email protected]>
//
// 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.07/07/2021.
//
int main(){
int a[7];
int b[7];
a[0] = b[0]*2;
b[1] = a[0]*3;
a[1] = b[1]*b[0];
b[2] = a[1]*b[1]*b[0];
} |
the_stack_data/25138651.c | #define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
static void *mkmap(unsigned sz)
{
int shmid = shmget(IPC_PRIVATE, sz,
IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
assert(shmid != -1);
void *addr = shmat(shmid, NULL, 0);
assert(addr != (void *)-1);
return addr;
}
int main()
{
void *np, *p;
p = mkmap(1024*1024);
np = mremap(p, 1024*1024, 2048*1024, MREMAP_MAYMOVE); /* grow, maymove */
assert(np != (void *)-1);
return 0;
}
|
the_stack_data/173578090.c | /* a37.c */
/* Chandra bug, 5/25/99 */
void f(void) {
}
int main()
{
f();
return 0;
}
|
the_stack_data/66847.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
typedef struct Pessoa
{
char nome[30];
int idade;
int altura;
struct Pessoa *prox;
} Pessoa;
int menu();
Pessoa *cria_lista();
void insere(Pessoa *head);
void listar(Pessoa *head);
void deletar(Pessoa *head);
int main()
{
Pessoa *head = NULL;
int escolha;
head = cria_lista();
for (;;)
{
escolha = menu();
switch (escolha)
{
case 1:
insere(head);
break;
case 2:
listar(head);
break;
case 3:
deletar(head);
break;
case 4:
while (head != NULL)
{
Pessoa *del = head;
head = head->prox;
free(del);
}
exit(0);
break;
}
}
return 0;
}
int menu()
{
int menu;
do
{
printf("\n----------MENU----------");
printf("\n1 - Inserir novo usuario");
printf("\n2 - Listar usuarios");
printf("\n3 - Deletar usuario");
printf("\n4 - Sair ");
printf("\nEscolha uma opcao: ");
scanf("%d", &menu);
} while (menu <= 0 || menu > 4);
return menu;
}
Pessoa *cria_lista()
{
Pessoa *novo = NULL;
novo = (Pessoa *)(malloc(sizeof(Pessoa)));
if (novo == NULL)
{
printf("Nao foi possivel alocar memoria!");
exit(1);
}
novo->prox = NULL;
return novo;
}
void insere(Pessoa *head)
{
Pessoa *novo = NULL;
novo = (Pessoa *)(malloc(sizeof(Pessoa)));
printf("\n------NOVO USUARIO------");
printf("\nDigite seu nome: ");
scanf("%s", &novo->nome);
printf("Digite sua idade: ");
scanf("%d", &novo->idade);
printf("Digite sua altura: ");
scanf("%d", &novo->altura);
novo->prox = head->prox;
head->prox = novo;
}
void listar(Pessoa *head)
{
Pessoa *elem = NULL;
printf("\n----LISTA DE USUARIOS---");
for (elem = head->prox; elem != NULL; elem = elem->prox)
{
printf("\nNome: %s", elem->nome);
printf("\nIdade: %d", elem->idade);
printf("\nAltura: %d", elem->altura);
printf("\n");
}
}
void deletar(Pessoa *head)
{
Pessoa *elem = NULL;
char nome[30];
bool encontrado = false;
printf("\n----DELETAR USUARIO-----");
printf("\nDigite um nome: ");
scanf("%s", &nome);
for (elem = head; elem != NULL; elem = elem->prox)
{
if (elem->prox)
{
if (strcmp(elem->prox->nome, nome) == 0)
{
encontrado = true;
elem->prox = elem->prox->prox;
printf("\nUsuario deletado!");
}
}
}
if (!encontrado)
{
printf("\nUsuario nao encontrado!");
}
printf("\n");
} |
the_stack_data/95449372.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main() {
float distance;
float amount = 0;
printf("Enter the distance : ");
scanf("%f", &distance);
if(distance < 30)
{
amount = distance * 50 ;
}
else
{
amount = 30 * 50 + ((distance - 30 ) * 40);
}
printf("Amount is : %.2f", amount);
return 0;
}
|
the_stack_data/168893947.c | // WARNING in submit_rx_urb/usb_submit_urb
// https://syzkaller.appspot.com/bug?id=97fff2c33c48264fba4d185f5f0f0961bdcd2ae2
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/usb/ch9.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
#define USB_MAX_EP_NUM 32
struct usb_device_index {
struct usb_device_descriptor* dev;
struct usb_config_descriptor* config;
unsigned config_length;
struct usb_interface_descriptor* iface;
struct usb_endpoint_descriptor* eps[USB_MAX_EP_NUM];
unsigned eps_num;
};
static bool parse_usb_descriptor(char* buffer, size_t length,
struct usb_device_index* index)
{
if (length <
sizeof(*index->dev) + sizeof(*index->config) + sizeof(*index->iface))
return false;
index->dev = (struct usb_device_descriptor*)buffer;
index->config = (struct usb_config_descriptor*)(buffer + sizeof(*index->dev));
index->config_length = length - sizeof(*index->dev);
index->iface =
(struct usb_interface_descriptor*)(buffer + sizeof(*index->dev) +
sizeof(*index->config));
index->eps_num = 0;
size_t offset = 0;
while (true) {
if (offset == length)
break;
if (offset + 1 < length)
break;
uint8_t length = buffer[offset];
uint8_t type = buffer[offset + 1];
if (type == USB_DT_ENDPOINT) {
index->eps[index->eps_num] =
(struct usb_endpoint_descriptor*)(buffer + offset);
index->eps_num++;
}
if (index->eps_num == USB_MAX_EP_NUM)
break;
offset += length;
}
return true;
}
enum usb_fuzzer_event_type {
USB_FUZZER_EVENT_INVALID,
USB_FUZZER_EVENT_CONNECT,
USB_FUZZER_EVENT_DISCONNECT,
USB_FUZZER_EVENT_SUSPEND,
USB_FUZZER_EVENT_RESUME,
USB_FUZZER_EVENT_CONTROL,
};
struct usb_fuzzer_event {
uint32_t type;
uint32_t length;
char data[0];
};
struct usb_fuzzer_init {
uint64_t speed;
const char* driver_name;
const char* device_name;
};
struct usb_fuzzer_ep_io {
uint16_t ep;
uint16_t flags;
uint32_t length;
char data[0];
};
#define USB_FUZZER_IOCTL_INIT _IOW('U', 0, struct usb_fuzzer_init)
#define USB_FUZZER_IOCTL_RUN _IO('U', 1)
#define USB_FUZZER_IOCTL_EP0_READ _IOWR('U', 2, struct usb_fuzzer_event)
#define USB_FUZZER_IOCTL_EP0_WRITE _IOW('U', 3, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_EP_ENABLE _IOW('U', 4, struct usb_endpoint_descriptor)
#define USB_FUZZER_IOCTL_EP_WRITE _IOW('U', 6, struct usb_fuzzer_ep_io)
#define USB_FUZZER_IOCTL_CONFIGURE _IO('U', 8)
#define USB_FUZZER_IOCTL_VBUS_DRAW _IOW('U', 9, uint32_t)
int usb_fuzzer_open()
{
return open("/sys/kernel/debug/usb-fuzzer", O_RDWR);
}
int usb_fuzzer_init(int fd, uint32_t speed, const char* driver,
const char* device)
{
struct usb_fuzzer_init arg;
arg.speed = speed;
arg.driver_name = driver;
arg.device_name = device;
return ioctl(fd, USB_FUZZER_IOCTL_INIT, &arg);
}
int usb_fuzzer_run(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_RUN, 0);
}
int usb_fuzzer_ep0_read(int fd, struct usb_fuzzer_event* event)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_READ, event);
}
int usb_fuzzer_ep0_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP0_WRITE, io);
}
int usb_fuzzer_ep_write(int fd, struct usb_fuzzer_ep_io* io)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_WRITE, io);
}
int usb_fuzzer_ep_enable(int fd, struct usb_endpoint_descriptor* desc)
{
return ioctl(fd, USB_FUZZER_IOCTL_EP_ENABLE, desc);
}
int usb_fuzzer_configure(int fd)
{
return ioctl(fd, USB_FUZZER_IOCTL_CONFIGURE, 0);
}
int usb_fuzzer_vbus_draw(int fd, uint32_t power)
{
return ioctl(fd, USB_FUZZER_IOCTL_VBUS_DRAW, power);
}
#define USB_MAX_PACKET_SIZE 1024
struct usb_fuzzer_control_event {
struct usb_fuzzer_event inner;
struct usb_ctrlrequest ctrl;
};
struct usb_fuzzer_ep_io_data {
struct usb_fuzzer_ep_io inner;
char data[USB_MAX_PACKET_SIZE];
};
struct vusb_connect_string_descriptor {
uint32_t len;
char* str;
} __attribute__((packed));
struct vusb_connect_descriptors {
uint32_t qual_len;
char* qual;
uint32_t bos_len;
char* bos;
uint32_t strs_len;
struct vusb_connect_string_descriptor strs[0];
} __attribute__((packed));
static bool lookup_connect_response(struct vusb_connect_descriptors* descs,
struct usb_device_index* index,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length, bool* done)
{
uint8_t str_idx;
switch (ctrl->bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD:
switch (ctrl->bRequest) {
case USB_REQ_GET_DESCRIPTOR:
switch (ctrl->wValue >> 8) {
case USB_DT_DEVICE:
*response_data = (char*)index->dev;
*response_length = sizeof(*index->dev);
return true;
case USB_DT_CONFIG:
*response_data = (char*)index->config;
*response_length = index->config_length;
return true;
case USB_DT_STRING:
str_idx = (uint8_t)ctrl->wValue;
if (str_idx >= descs->strs_len)
return false;
*response_data = descs->strs[str_idx].str;
*response_length = descs->strs[str_idx].len;
return true;
case USB_DT_BOS:
*response_data = descs->bos;
*response_length = descs->bos_len;
return true;
case USB_DT_DEVICE_QUALIFIER:
*response_data = descs->qual;
*response_length = descs->qual_len;
return true;
default:
exit(1);
return false;
}
break;
case USB_REQ_SET_CONFIGURATION:
*response_length = 0;
*response_data = NULL;
*done = true;
return true;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
return false;
}
static volatile long syz_usb_connect(volatile long a0, volatile long a1,
volatile long a2, volatile long a3)
{
int64_t speed = a0;
int64_t dev_len = a1;
char* dev = (char*)a2;
struct vusb_connect_descriptors* descs = (struct vusb_connect_descriptors*)a3;
if (!dev)
return -1;
struct usb_device_index index;
memset(&index, 0, sizeof(index));
int rv = false;
rv = parse_usb_descriptor(dev, dev_len, &index);
if (!rv)
return -1;
int fd = usb_fuzzer_open();
if (fd < 0)
return -1;
char device[32];
sprintf(&device[0], "dummy_udc.%llu", procid);
rv = usb_fuzzer_init(fd, speed, "dummy_udc", &device[0]);
if (rv < 0)
return -1;
rv = usb_fuzzer_run(fd);
if (rv < 0)
return -1;
bool done = false;
while (!done) {
struct usb_fuzzer_control_event event;
event.inner.type = 0;
event.inner.length = sizeof(event.ctrl);
rv = usb_fuzzer_ep0_read(fd, (struct usb_fuzzer_event*)&event);
if (rv < 0)
return -1;
if (event.inner.type != USB_FUZZER_EVENT_CONTROL)
continue;
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
response_found = lookup_connect_response(
descs, &index, &event.ctrl, &response_data, &response_length, &done);
if (!response_found)
return -1;
if (done) {
int rv = usb_fuzzer_vbus_draw(fd, index.config->bMaxPower);
if (rv < 0)
return -1;
rv = usb_fuzzer_configure(fd);
if (rv < 0)
return -1;
unsigned ep;
for (ep = 0; ep < index.eps_num; ep++) {
rv = usb_fuzzer_ep_enable(fd, index.eps[ep]);
if (rv < 0)
exit(1);
}
}
struct usb_fuzzer_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
if (event.ctrl.wLength < response.inner.length)
response.inner.length = event.ctrl.wLength;
usb_fuzzer_ep0_write(fd, (struct usb_fuzzer_ep_io*)&response);
}
sleep_ms(200);
return fd;
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
*(uint8_t*)0x20000040 = 0x12;
*(uint8_t*)0x20000041 = 1;
*(uint16_t*)0x20000042 = 0;
*(uint8_t*)0x20000044 = 0x94;
*(uint8_t*)0x20000045 = 0x10;
*(uint8_t*)0x20000046 = 0xcd;
*(uint8_t*)0x20000047 = 0x40;
*(uint16_t*)0x20000048 = 0x8de;
*(uint16_t*)0x2000004a = 0x7a01;
*(uint16_t*)0x2000004c = 0x4ab7;
*(uint8_t*)0x2000004e = 0;
*(uint8_t*)0x2000004f = 0;
*(uint8_t*)0x20000050 = 0;
*(uint8_t*)0x20000051 = 1;
*(uint8_t*)0x20000052 = 9;
*(uint8_t*)0x20000053 = 2;
*(uint16_t*)0x20000054 = 0x1f;
*(uint8_t*)0x20000056 = 1;
*(uint8_t*)0x20000057 = 0;
*(uint8_t*)0x20000058 = 0;
*(uint8_t*)0x20000059 = 3;
*(uint8_t*)0x2000005a = 0;
*(uint8_t*)0x2000005b = 9;
*(uint8_t*)0x2000005c = 4;
*(uint8_t*)0x2000005d = 0xbc;
*(uint8_t*)0x2000005e = 0;
*(uint8_t*)0x2000005f = 1;
*(uint8_t*)0x20000060 = 0xe8;
*(uint8_t*)0x20000061 = 0x31;
*(uint8_t*)0x20000062 = 0x74;
*(uint8_t*)0x20000063 = 0;
*(uint8_t*)0x20000064 = 7;
*(uint8_t*)0x20000065 = 5;
*(uint8_t*)0x20000066 = 0x81;
*(uint8_t*)0x20000067 = 3;
*(uint16_t*)0x20000068 = 0xb;
*(uint8_t*)0x2000006a = 0xbf;
*(uint8_t*)0x2000006b = 0;
*(uint8_t*)0x2000006c = 0;
*(uint8_t*)0x2000006d = 2;
*(uint8_t*)0x2000006e = 0x23;
*(uint8_t*)0x2000006f = 2;
*(uint8_t*)0x20000070 = 0x23;
syz_usb_connect(3, 0x31, 0x20000040, 0);
return 0;
}
|
the_stack_data/32949689.c | int add(int a, int b) {
return a + b;
}
int main() {
int sum = add(1 + 2, 4);
return sum + sum;
} |
the_stack_data/1137961.c | /*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (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.openairinterface.org/?page_id=698
*
* 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.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* [email protected]
*/
/*! \file rijndael.c
\brief
\author Keliang DU, BUPT
\date 2020
\email: [email protected]
*/
#include <stdint.h>
/* Rijndael S-box SR */
uint8_t SR[256] = {
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B,
0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26,
0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2,
0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED,
0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F,
0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC,
0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14,
0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D,
0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F,
0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11,
0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F,
0xB0, 0x54, 0xBB, 0x16};
/* S-box SQ */
uint8_t SQ[256] = {
0x25, 0x24, 0x73, 0x67, 0xD7, 0xAE, 0x5C, 0x30, 0xA4, 0xEE, 0x6E, 0xCB,
0x7D, 0xB5, 0x82, 0xDB, 0xE4, 0x8E, 0x48, 0x49, 0x4F, 0x5D, 0x6A, 0x78,
0x70, 0x88, 0xE8, 0x5F, 0x5E, 0x84, 0x65, 0xE2, 0xD8, 0xE9, 0xCC, 0xED,
0x40, 0x2F, 0x11, 0x28, 0x57, 0xD2, 0xAC, 0xE3, 0x4A, 0x15, 0x1B, 0xB9,
0xB2, 0x80, 0x85, 0xA6, 0x2E, 0x02, 0x47, 0x29, 0x07, 0x4B, 0x0E, 0xC1,
0x51, 0xAA, 0x89, 0xD4, 0xCA, 0x01, 0x46, 0xB3, 0xEF, 0xDD, 0x44, 0x7B,
0xC2, 0x7F, 0xBE, 0xC3, 0x9F, 0x20, 0x4C, 0x64, 0x83, 0xA2, 0x68, 0x42,
0x13, 0xB4, 0x41, 0xCD, 0xBA, 0xC6, 0xBB, 0x6D, 0x4D, 0x71, 0x21, 0xF4,
0x8D, 0xB0, 0xE5, 0x93, 0xFE, 0x8F, 0xE6, 0xCF, 0x43, 0x45, 0x31, 0x22,
0x37, 0x36, 0x96, 0xFA, 0xBC, 0x0F, 0x08, 0x52, 0x1D, 0x55, 0x1A, 0xC5,
0x4E, 0x23, 0x69, 0x7A, 0x92, 0xFF, 0x5B, 0x5A, 0xEB, 0x9A, 0x1C, 0xA9,
0xD1, 0x7E, 0x0D, 0xFC, 0x50, 0x8A, 0xB6, 0x62, 0xF5, 0x0A, 0xF8, 0xDC,
0x03, 0x3C, 0x0C, 0x39, 0xF1, 0xB8, 0xF3, 0x3D, 0xF2, 0xD5, 0x97, 0x66,
0x81, 0x32, 0xA0, 0x00, 0x06, 0xCE, 0xF6, 0xEA, 0xB7, 0x17, 0xF7, 0x8C,
0x79, 0xD6, 0xA7, 0xBF, 0x8B, 0x3F, 0x1F, 0x53, 0x63, 0x75, 0x35, 0x2C,
0x60, 0xFD, 0x27, 0xD3, 0x94, 0xA5, 0x7C, 0xA1, 0x05, 0x58, 0x2D, 0xBD,
0xD9, 0xC7, 0xAF, 0x6B, 0x54, 0x0B, 0xE0, 0x38, 0x04, 0xC8, 0x9D, 0xE7,
0x14, 0xB1, 0x87, 0x9C, 0xDF, 0x6F, 0xF9, 0xDA, 0x2A, 0xC4, 0x59, 0x16,
0x74, 0x91, 0xAB, 0x26, 0x61, 0x76, 0x34, 0x2B, 0xAD, 0x99, 0xFB, 0x72,
0xEC, 0x33, 0x12, 0xDE, 0x98, 0x3B, 0xC0, 0x9B, 0x3E, 0x18, 0x10, 0x3A,
0x56, 0xE1, 0x77, 0xC9, 0x1E, 0x9E, 0x95, 0xA3, 0x90, 0x19, 0xA8, 0x6C,
0x09, 0xD0, 0xF0, 0x86};
|
the_stack_data/1198123.c | /******************************************************************************
*
* Copyright(c) 2013 Realtek Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
*
*
******************************************************************************/
#ifdef CONFIG_BT_COEXIST
#include <rtw_btcoex.h>
#include <hal_btcoex.h>
void rtw_btcoex_Initialize(PADAPTER padapter)
{
hal_btcoex_Initialize(padapter);
}
void rtw_btcoex_PowerOnSetting(PADAPTER padapter)
{
hal_btcoex_PowerOnSetting(padapter);
}
void rtw_btcoex_PreLoadFirmware(PADAPTER padapter)
{
hal_btcoex_PreLoadFirmware(padapter);
}
void rtw_btcoex_HAL_Initialize(PADAPTER padapter, u8 bWifiOnly)
{
hal_btcoex_InitHwConfig(padapter, bWifiOnly);
}
void rtw_btcoex_IpsNotify(PADAPTER padapter, u8 type)
{
hal_btcoex_IpsNotify(padapter, type);
}
void rtw_btcoex_LpsNotify(PADAPTER padapter, u8 type)
{
hal_btcoex_LpsNotify(padapter, type);
}
void rtw_btcoex_ScanNotify(PADAPTER padapter, u8 type)
{
#ifdef CONFIG_CONCURRENT_MODE
if ((_FALSE == type) && (padapter->pbuddy_adapter))
{
PADAPTER pbuddy = padapter->pbuddy_adapter;
if (check_fwstate(&pbuddy->mlmepriv, WIFI_SITE_MONITOR) == _TRUE)
return;
}
#endif
hal_btcoex_ScanNotify(padapter, type);
}
void rtw_btcoex_ConnectNotify(PADAPTER padapter, u8 action)
{
#ifdef DBG_CONFIG_ERROR_RESET
if (_TRUE == rtw_hal_sreset_inprogress(padapter))
{
DBG_8192C(FUNC_ADPT_FMT ": [BTCoex] under reset, skip notify!\n",
FUNC_ADPT_ARG(padapter));
return;
}
#endif // DBG_CONFIG_ERROR_RESET
#ifdef CONFIG_CONCURRENT_MODE
if ((_FALSE == action) && (padapter->pbuddy_adapter))
{
PADAPTER pbuddy = padapter->pbuddy_adapter;
if (check_fwstate(&pbuddy->mlmepriv, WIFI_UNDER_LINKING) == _TRUE)
return;
}
#endif
hal_btcoex_ConnectNotify(padapter, action);
}
void rtw_btcoex_MediaStatusNotify(PADAPTER padapter, u8 mediaStatus)
{
#ifdef DBG_CONFIG_ERROR_RESET
if (_TRUE == rtw_hal_sreset_inprogress(padapter))
{
DBG_8192C(FUNC_ADPT_FMT ": [BTCoex] under reset, skip notify!\n",
FUNC_ADPT_ARG(padapter));
return;
}
#endif // DBG_CONFIG_ERROR_RESET
#ifdef CONFIG_CONCURRENT_MODE
if ((RT_MEDIA_DISCONNECT == mediaStatus) && (padapter->pbuddy_adapter))
{
PADAPTER pbuddy = padapter->pbuddy_adapter;
if (check_fwstate(&pbuddy->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
return;
}
#endif // CONFIG_CONCURRENT_MODE
if ((RT_MEDIA_CONNECT == mediaStatus)
&& (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE))
{
rtw_hal_set_hwreg(padapter, HW_VAR_DL_RSVD_PAGE, NULL);
}
hal_btcoex_MediaStatusNotify(padapter, mediaStatus);
}
void rtw_btcoex_SpecialPacketNotify(PADAPTER padapter, u8 pktType)
{
hal_btcoex_SpecialPacketNotify(padapter, pktType);
}
void rtw_btcoex_IQKNotify(PADAPTER padapter, u8 state)
{
hal_btcoex_IQKNotify(padapter, state);
}
void rtw_btcoex_BtInfoNotify(PADAPTER padapter, u8 length, u8 *tmpBuf)
{
hal_btcoex_BtInfoNotify(padapter, length, tmpBuf);
}
void rtw_btcoex_SuspendNotify(PADAPTER padapter, u8 state)
{
hal_btcoex_SuspendNotify(padapter, state);
}
void rtw_btcoex_HaltNotify(PADAPTER padapter)
{
if (_FALSE == padapter->bup)
{
DBG_871X(FUNC_ADPT_FMT ": bup=%d Skip!\n",
FUNC_ADPT_ARG(padapter), padapter->bup);
return;
}
if (_TRUE == padapter->bSurpriseRemoved)
{
DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved=%d Skip!\n",
FUNC_ADPT_ARG(padapter), padapter->bSurpriseRemoved);
return;
}
hal_btcoex_HaltNotify(padapter);
}
void rtw_btcoex_SwitchBtTRxMask(PADAPTER padapter)
{
hal_btcoex_SwitchBtTRxMask(padapter);
}
void rtw_btcoex_Switch(PADAPTER padapter, u8 enable)
{
hal_btcoex_SetBTCoexist(padapter, enable);
}
u8 rtw_btcoex_IsBtDisabled(PADAPTER padapter)
{
return hal_btcoex_IsBtDisabled(padapter);
}
void rtw_btcoex_Handler(PADAPTER padapter)
{
#if defined(CONFIG_CONCURRENT_MODE)
if (padapter->adapter_type != PRIMARY_ADAPTER)
return;
#endif
hal_btcoex_Hanlder(padapter);
}
s32 rtw_btcoex_IsBTCoexCtrlAMPDUSize(PADAPTER padapter)
{
s32 coexctrl;
coexctrl = hal_btcoex_IsBTCoexCtrlAMPDUSize(padapter);
return coexctrl;
}
u32 rtw_btcoex_GetAMPDUSize(PADAPTER padapter)
{
u32 size;
size = hal_btcoex_GetAMPDUSize(padapter);
return size;
}
void rtw_btcoex_SetManualControl(PADAPTER padapter, u8 manual)
{
if (_TRUE == manual)
{
hal_btcoex_SetManualControl(padapter, _TRUE);
}
else
{
hal_btcoex_SetManualControl(padapter, _FALSE);
}
}
u8 rtw_btcoex_1Ant(PADAPTER padapter)
{
return hal_btcoex_1Ant(padapter);
}
u8 rtw_btcoex_IsBtControlLps(PADAPTER padapter)
{
return hal_btcoex_IsBtControlLps(padapter);
}
u8 rtw_btcoex_IsLpsOn(PADAPTER padapter)
{
return hal_btcoex_IsLpsOn(padapter);
}
u8 rtw_btcoex_RpwmVal(PADAPTER padapter)
{
return hal_btcoex_RpwmVal(padapter);
}
u8 rtw_btcoex_LpsVal(PADAPTER padapter)
{
return hal_btcoex_LpsVal(padapter);
}
void rtw_btcoex_SetBTCoexist(PADAPTER padapter, u8 bBtExist)
{
hal_btcoex_SetBTCoexist(padapter, bBtExist);
}
void rtw_btcoex_SetChipType(PADAPTER padapter, u8 chipType)
{
hal_btcoex_SetChipType(padapter, chipType);
}
void rtw_btcoex_SetPGAntNum(PADAPTER padapter, u8 antNum)
{
hal_btcoex_SetPgAntNum(padapter, antNum);
}
u8 rtw_btcoex_GetPGAntNum(PADAPTER padapter)
{
return hal_btcoex_GetPgAntNum(padapter);
}
void rtw_btcoex_SetSingleAntPath(PADAPTER padapter, u8 singleAntPath)
{
hal_btcoex_SetSingleAntPath(padapter, singleAntPath);
}
u32 rtw_btcoex_GetRaMask(PADAPTER padapter)
{
return hal_btcoex_GetRaMask(padapter);
}
void rtw_btcoex_RecordPwrMode(PADAPTER padapter, u8 *pCmdBuf, u8 cmdLen)
{
hal_btcoex_RecordPwrMode(padapter, pCmdBuf, cmdLen);
}
void rtw_btcoex_DisplayBtCoexInfo(PADAPTER padapter, u8 *pbuf, u32 bufsize)
{
hal_btcoex_DisplayBtCoexInfo(padapter, pbuf, bufsize);
}
void rtw_btcoex_SetDBG(PADAPTER padapter, u32 *pDbgModule)
{
hal_btcoex_SetDBG(padapter, pDbgModule);
}
u32 rtw_btcoex_GetDBG(PADAPTER padapter, u8 *pStrBuf, u32 bufSize)
{
return hal_btcoex_GetDBG(padapter, pStrBuf, bufSize);
}
u8 rtw_btcoex_IncreaseScanDeviceNum(PADAPTER padapter)
{
return hal_btcoex_IncreaseScanDeviceNum(padapter);
}
u8 rtw_btcoex_IsBtLinkExist(PADAPTER padapter)
{
return hal_btcoex_IsBtLinkExist(padapter);
}
// ==================================================
// Below Functions are called by BT-Coex
// ==================================================
void rtw_btcoex_RejectApAggregatedPacket(PADAPTER padapter, u8 enable)
{
struct mlme_ext_info *pmlmeinfo;
pmlmeinfo = &padapter->mlmeextpriv.mlmext_info;
if (_TRUE == enable)
{
struct sta_info *psta = NULL;
pmlmeinfo->bAcceptAddbaReq = _FALSE;
if ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) {
psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
if (psta)
send_delba(padapter, 0, psta->hwaddr);
} else if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
_irqL irqL;
_list *phead, *plist;
u8 peer_num = 0;
char peers[NUM_STA];
struct sta_priv *pstapriv = &padapter->stapriv;
int i;
_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
int stainfo_offset;
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
peers[peer_num++] = stainfo_offset;
}
_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
if (peer_num) {
for (i = 0; i < peer_num; i++) {
psta = rtw_get_stainfo_by_offset(pstapriv, peers[i]);
if (psta)
send_delba(padapter, 0, psta->hwaddr);
}
}
}
}
else
{
pmlmeinfo->bAcceptAddbaReq = _TRUE;
}
}
void rtw_btcoex_LPS_Enter(PADAPTER padapter)
{
struct pwrctrl_priv *pwrpriv;
u8 lpsVal;
pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->bpower_saving = _TRUE;
lpsVal = rtw_btcoex_LpsVal(padapter);
rtw_set_ps_mode(padapter, PS_MODE_MIN, 0, lpsVal, "BTCOEX");
}
void rtw_btcoex_LPS_Leave(PADAPTER padapter)
{
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
if (pwrpriv->pwr_mode != PS_MODE_ACTIVE)
{
rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "BTCOEX");
LPS_RF_ON_check(padapter, 100);
pwrpriv->bpower_saving = _FALSE;
}
}
#endif // CONFIG_BT_COEXIST
|
the_stack_data/29543.c | #include <stdio.h>
#include <unistd.h>
#include <omp.h>
#define N 20
int main() {
int tid;
omp_set_num_threads(4);
#pragma omp parallel private(tid)
{
tid = omp_get_thread_num();
printf("Hello %d\n", tid);
#pragma omp sections
{
#pragma omp section
{
printf("Seção 1 - thread %d\n", tid);
sleep(1);
}
#pragma omp section
{
printf("Seção 2 - thread %d\n", tid);
sleep(1);
}
#pragma omp section
{
printf("Seção 3 - thread %d\n", tid);
sleep(1);
}
#pragma omp section
{
printf("Seção 4 - thread %d\n", tid);
sleep(1);
}
}
}
return 0;
}
|
the_stack_data/148938.c | #include <stdio.h>
int print_hash_value = 1;
static void platform_main_begin(void)
{
}
static unsigned crc32_tab[256];
static unsigned crc32_context = 0xFFFFFFFFUL;
static void
crc32_gentab (void)
{
unsigned crc;
unsigned poly = 0xEDB88320UL;
int i, j;
for (i = 0; i < 256; i++) {
crc = i;
for (j = 8; j > 0; j--) {
if (crc & 1) {
crc = (crc >> 1) ^ poly;
} else {
crc >>= 1;
}
}
crc32_tab[i] = crc;
}
}
static void
crc32_byte (unsigned char b) {
crc32_context =
((crc32_context >> 8) & 0x00FFFFFF) ^
crc32_tab[(crc32_context ^ b) & 0xFF];
}
extern int strcmp ( char *, char *);
static void
crc32_8bytes (unsigned val)
{
crc32_byte ((val>>0) & 0xff);
crc32_byte ((val>>8) & 0xff);
crc32_byte ((val>>16) & 0xff);
crc32_byte ((val>>24) & 0xff);
}
static void
transparent_crc (unsigned val, char* vname, int flag)
{
crc32_8bytes(val);
if (flag) {
printf("...checksum after hashing %s : %X\n", vname, crc32_context ^ 0xFFFFFFFFU);
}
}
static void
platform_main_end (int x, int flag)
{
if (!flag) printf ("checksum = %x\n", x);
}
static long __undefined;
void csmith_compute_hash(void);
void step_hash(int stmt_id);
static int g_2 = (-1L);
static int **g_50 = (void*)0;
static int g_58 = (-4L);
static signed char g_149 = (-1L);
static int *g_197 = &g_58;
static int g_232 = 1L;
static int g_263 = (-1L);
static int *g_280 = &g_2;
static int ***g_568 = (void*)0;
static int g_585 = 0xF8CFA4ABL;
static unsigned func_1(void);
static unsigned short func_7(int p_8);
static int func_9(short p_10, unsigned p_11, unsigned p_12, unsigned p_13, unsigned short p_14);
static unsigned func_16(unsigned char p_17, unsigned char p_18);
static int func_21(signed char p_22, unsigned p_23);
static signed char func_27(signed char p_28);
static int * func_32(int * p_33, int ** p_34, int * p_35, int ** p_36, unsigned short p_37);
static int * func_38(int p_39, int * p_40, unsigned p_41, int ** p_42);
static int * func_43(unsigned p_44, unsigned short p_45);
static unsigned short func_51(int * p_52, int * p_53, int * p_54, int * p_55, unsigned short p_56);
static unsigned func_1(void)
{
unsigned l_590 = 1UL;
int ***l_593 = &g_50;
int *l_610 = &g_58;
int *l_616 = &g_232;
step_hash(375);
for (g_2 = (-13); (g_2 > (-9)); g_2 += 2)
{
unsigned char l_15 = 8UL;
int l_24 = (-1L);
int *l_584 = &g_585;
int ***l_596 = &g_50;
int l_602 = 0xFAFA2276L;
signed char l_605 = 0L;
int *l_607 = &g_58;
int *l_613 = (void*)0;
}
step_hash(376);
return (*l_610);
}
static unsigned short func_7(int p_8)
{
int ***l_571 = (void*)0;
signed char l_576 = 0x0BL;
int l_577 = (-1L);
int *l_578 = &l_577;
short l_579 = 0xC392L;
step_hash(338);
l_577 |= ((signed char)(((unsigned short)(!g_232) >> (unsigned short)4) == (g_568 != &g_50)) * (signed char)(((func_9(p_8, ((signed char)((void*)0 == l_571) - (signed char)(p_8 | (g_149 < (((short)p_8 << (short)p_8) | p_8)))), p_8, g_232, g_2) < 1L) || l_576) && p_8));
step_hash(339);
(*l_578) &= (-2L);
step_hash(340);
(*l_578) = l_579;
step_hash(345);
for (g_232 = 0; (g_232 <= (-15)); g_232 -= 6)
{
step_hash(344);
(*l_578) ^= ((unsigned short)8UL >> (unsigned short)0);
}
step_hash(346);
return g_232;
}
static int func_9(short p_10, unsigned p_11, unsigned p_12, unsigned p_13, unsigned short p_14)
{
step_hash(336);
return g_2;
}
static unsigned func_16(unsigned char p_17, unsigned char p_18)
{
int *l_523 = &g_58;
step_hash(322);
l_523 = l_523;
step_hash(323);
g_232 |= (*l_523);
step_hash(334);
if ((p_17 ^ (((unsigned char)(((unsigned)(*l_523) / (unsigned)p_17) & ((unsigned short)(p_18 < g_232) << (unsigned short)((unsigned short)((*l_523) == (g_149 >= ((signed char)(((int)((short)(func_51(l_523, l_523, &g_2, l_523, p_17) | g_58) * (short)(*l_523)) - (int)0x5ACF4406L) < 1L) >> (signed char)0))) % (unsigned short)g_2))) / (unsigned char)g_263) <= p_17)))
{
unsigned l_538 = 0x7B8C2826L;
int *l_550 = &g_58;
int ***l_558 = &g_50;
step_hash(325);
(*l_523) = l_538;
step_hash(330);
if (((unsigned short)g_149 << (unsigned short)5))
{
int ***l_557 = (void*)0;
int l_559 = 0xEA661446L;
step_hash(327);
(*l_550) = ((unsigned char)(((-1L) != ((signed char)((unsigned short)(*l_550) * (unsigned short)0x8EC4L) - (signed char)p_18)) <= l_559) + (unsigned char)p_17);
}
else
{
int *l_560 = &g_263;
int **l_561 = &l_550;
step_hash(329);
(*l_561) = l_560;
}
step_hash(331);
return p_18;
}
else
{
step_hash(333);
return g_2;
}
}
static int func_21(signed char p_22, unsigned p_23)
{
int *l_248 = &g_232;
int *l_259 = &g_58;
signed char l_296 = (-10L);
int *l_353 = &g_2;
short l_363 = (-3L);
int **l_364 = &l_259;
int l_371 = 0x30767012L;
short l_380 = 0x4607L;
unsigned l_406 = 0x5528EACBL;
unsigned l_411 = 0x6C442C3BL;
int l_460 = (-9L);
int **l_481 = &g_197;
step_hash(181);
for (p_23 = 0; (p_23 == 24); p_23++)
{
int *l_249 = &g_232;
int ***l_258 = &g_50;
int **l_293 = &g_280;
}
step_hash(210);
if ((((((unsigned char)g_58 + (unsigned char)g_2) > 0L) || p_22) != l_296))
{
short l_298 = 0x4A64L;
int *l_331 = &g_58;
step_hash(206);
if ((*l_248))
{
int *l_297 = &g_263;
int **l_307 = (void*)0;
int **l_308 = (void*)0;
int **l_309 = &g_280;
step_hash(184);
(*l_309) = func_32(l_297, &g_280, &g_58, &l_297, p_22);
step_hash(202);
for (g_232 = 12; (g_232 >= 7); g_232 -= 8)
{
int l_316 = 0L;
int *l_332 = (void*)0;
step_hash(201);
if ((g_58 ^ (*l_259)))
{
int *l_329 = &g_58;
step_hash(193);
for (g_263 = (-13); (g_263 < (-3)); ++g_263)
{
int *l_330 = &g_232;
step_hash(192);
(*l_259) = ((short)l_316 * (short)((unsigned short)func_51((*l_309), l_248, &g_2, &g_232, (*l_248)) / (unsigned short)p_23));
}
step_hash(194);
l_332 = &l_316;
step_hash(195);
(*l_329) = ((-1L) && (*l_332));
}
else
{
int *l_333 = &l_316;
step_hash(197);
l_333 = l_248;
step_hash(198);
if (p_22)
continue;
step_hash(199);
if (p_22)
continue;
step_hash(200);
l_316 |= (0x7D9984E9L && ((unsigned short)(((short)((((((unsigned char)251UL << (unsigned char)6) && 1UL) < ((unsigned)(p_22 & ((0x0B31L <= (+p_22)) >= func_51((*l_309), l_333, l_331, &g_2, p_23))) % (unsigned)p_22)) | p_22) && 0x6EC9L) - (short)(*l_259)) > 248UL) / (unsigned short)(*l_259)));
}
}
}
else
{
step_hash(204);
l_331 = l_331;
step_hash(205);
(*l_248) = ((~(g_232 || (p_23 < ((void*)0 != l_259)))) ^ ((*l_331) != p_23));
}
step_hash(207);
(*g_197) = (((unsigned char)(*l_248) << (unsigned char)g_58) > (((void*)0 != l_248) <= ((((((short)g_232 + (short)g_232) <= (*l_331)) | ((unsigned)g_2 - (unsigned)(*l_259))) > 0L) == (-1L))));
}
else
{
step_hash(209);
(*l_248) = (-(unsigned)(~0xADD14F1AL));
}
step_hash(318);
if ((((signed char)((((unsigned char)(*l_248) >> (unsigned char)(g_58 < 0UL)) ^ 0x4957L) > ((func_51(l_248, l_259, l_248, l_353, g_149) | g_2) <= g_2)) >> (signed char)g_2) || p_23))
{
int *l_362 = &g_2;
unsigned short l_377 = 0xD1A0L;
step_hash(212);
(*l_364) = func_32(l_248, l_364, l_362, &l_248, (*l_362));
step_hash(213);
(*l_248) = ((8L < (l_362 == (void*)0)) > (((signed char)(*l_362) + (signed char)(((short)((unsigned char)l_371 >> (unsigned char)3) % (short)(-(short)(((*l_362) >= ((unsigned short)(((int)(((&g_197 != &g_280) == (**l_364)) >= 1UL) % (int)0x7B2F358DL) == p_22) << (unsigned short)4)) && 0x35L))) > l_377)) <= p_22));
step_hash(214);
l_380 &= (((((signed char)g_149 >> (signed char)7) ^ g_58) >= (+((void*)0 != l_362))) < p_23);
step_hash(215);
(*l_364) = func_38((g_2 || (((unsigned short)(!((((unsigned char)((unsigned char)(p_23 | ((void*)0 != &l_362)) / (unsigned char)(p_23 ^ p_23)) * (unsigned char)((p_23 ^ g_58) <= p_23)) != g_263) > p_23)) / (unsigned short)0x006DL) & p_22)), l_362, p_22, &l_353);
}
else
{
unsigned short l_397 = 1UL;
int *l_413 = &g_58;
int l_414 = 1L;
int *l_415 = &l_371;
int *l_416 = (void*)0;
int **l_478 = (void*)0;
int *l_479 = (void*)0;
step_hash(217);
(*l_248) ^= (*l_259);
step_hash(229);
for (g_232 = 2; (g_232 != 18); g_232++)
{
step_hash(221);
(**l_364) |= p_23;
step_hash(228);
for (p_23 = 0; (p_23 == 24); p_23 += 4)
{
int l_393 = 0x67CB0065L;
int *l_394 = &l_371;
step_hash(225);
(**l_364) &= 0xB77967D7L;
step_hash(226);
(*l_394) ^= ((unsigned short)(*l_259) << (unsigned short)((*l_248) < l_393));
step_hash(227);
(*l_364) = &g_58;
}
}
step_hash(317);
if ((*g_197))
{
int *l_412 = &g_2;
int ***l_446 = &l_364;
step_hash(231);
l_397 = p_23;
step_hash(232);
l_414 &= ((signed char)0x70L * (signed char)((signed char)((unsigned char)(+p_22) * (unsigned char)(((short)l_406 % (short)(((signed char)g_232 - (signed char)(2L || 0x9639L)) ^ ((short)((p_23 >= func_51(&g_263, l_412, l_413, l_413, (*l_353))) || 0L) % (short)g_2))) & 0x35L)) * (signed char)g_263));
step_hash(292);
if ((*l_248))
{
int **l_421 = &l_412;
int l_453 = (-9L);
step_hash(267);
if (p_23)
{
step_hash(235);
(*l_413) = 1L;
step_hash(246);
if (func_51(l_415, (*l_364), (*l_364), (*l_364), g_2))
{
step_hash(237);
(**l_364) = (**l_364);
step_hash(238);
(*l_364) = l_416;
step_hash(239);
(*l_415) ^= ((unsigned short)func_51(&l_414, (*l_364), func_38(((signed char)((void*)0 == l_421) - (signed char)1UL), &l_414, ((signed char)1L + (signed char)(((*l_421) != (*l_364)) || p_22)), &l_353), &l_414, (*l_412)) + (unsigned short)p_23);
step_hash(240);
(*l_364) = (void*)0;
}
else
{
int ***l_424 = (void*)0;
int ***l_425 = &l_364;
step_hash(242);
(**l_364) = ((void*)0 == (*l_421));
step_hash(243);
(*l_425) = l_421;
step_hash(244);
(*l_259) = (p_23 != (p_22 | (((signed char)((short)((*g_280) < g_263) << (short)(&l_248 == &l_259)) << (signed char)0) < (0x0FC0L == 0x5321L))));
step_hash(245);
g_263 &= (g_58 || ((~((unsigned char)(0xEBABB2D7L && ((-(unsigned char)p_22) && g_232)) / (unsigned char)((unsigned short)g_232 >> (unsigned short)10))) > p_22));
}
}
else
{
signed char l_441 = 8L;
int *l_442 = &g_2;
int *l_467 = &g_58;
step_hash(255);
for (l_363 = 0; (l_363 == (-29)); --l_363)
{
signed char l_443 = (-6L);
step_hash(251);
(*l_248) = (4L != ((void*)0 != &g_280));
step_hash(252);
(*l_413) = (&g_197 != (void*)0);
step_hash(253);
(*l_415) |= (*l_413);
step_hash(254);
(*l_248) |= ((short)(p_22 | ((signed char)(func_51(&l_414, &g_58, l_442, (*l_421), l_443) && 0xBA4620ADL) % (signed char)6L)) / (short)g_58);
}
step_hash(265);
if (func_51(func_38(((signed char)(l_446 == (void*)0) + (signed char)p_22), (**l_446), ((g_58 < g_149) <= 0xB00DE351L), &l_248), (**l_446), &g_58, (*l_421), (*l_442)))
{
short l_447 = 0x578FL;
int *l_452 = &l_414;
step_hash(257);
(*l_248) = l_447;
step_hash(258);
(*l_415) &= ((*g_197) < ((unsigned)((func_51(l_442, (*l_364), func_32((*l_421), l_421, (**l_446), l_421, p_22), (*l_364), (*l_452)) > l_453) && 0x57L) - (unsigned)(*g_280)));
step_hash(259);
g_197 = (*l_364);
}
else
{
step_hash(261);
(**l_364) = ((short)(p_22 ^ (+((int)(*l_442) + (int)((signed char)g_58 - (signed char)g_149)))) - (short)65533UL);
step_hash(262);
(*l_413) = 0x70DE6C0FL;
step_hash(263);
(*l_259) |= ((*g_280) || (0x461B6927L > l_460));
step_hash(264);
(***l_446) = ((unsigned)(p_22 <= (((unsigned char)func_51(&g_2, l_442, (*l_421), (**l_446), (((unsigned short)((l_467 == (**l_446)) & p_22) << (unsigned short)((p_23 & 1UL) != p_23)) & 0x617B7643L)) - (unsigned char)g_149) <= p_22)) % (unsigned)0xFB529590L);
}
step_hash(266);
(*l_364) = (**l_446);
}
step_hash(272);
if ((g_58 < (p_23 > (p_22 >= 4294967286UL))))
{
int **l_468 = &l_413;
step_hash(269);
(*l_446) = l_468;
}
else
{
int *l_471 = &g_58;
step_hash(271);
(*l_415) ^= ((unsigned char)(g_232 >= g_232) * (unsigned char)func_51(&g_263, (**l_446), l_471, (**l_446), p_23));
}
step_hash(273);
(*l_248) = 1L;
}
else
{
int *l_472 = &l_414;
int *l_483 = &l_414;
step_hash(275);
l_472 = (*l_364);
step_hash(291);
for (l_406 = 0; (l_406 == 42); l_406 += 4)
{
int *l_477 = &l_414;
step_hash(285);
for (g_58 = 0; (g_58 != 4); g_58 += 1)
{
unsigned l_480 = 6UL;
int *l_482 = &l_414;
step_hash(282);
g_197 = (*l_364);
step_hash(283);
(*l_248) = func_51((*l_364), l_479, func_38((*g_197), &l_414, l_480, l_481), l_482, g_58);
step_hash(284);
(*l_364) = l_483;
}
step_hash(290);
for (l_460 = 25; (l_460 <= (-8)); --l_460)
{
step_hash(289);
(*l_477) = p_22;
}
}
}
}
else
{
int *l_499 = (void*)0;
int l_508 = (-1L);
step_hash(294);
(**l_481) |= (g_232 > g_232);
step_hash(295);
(*l_415) = (((signed char)g_232 << (signed char)1) != 0x302BL);
step_hash(315);
for (p_22 = 8; (p_22 == 14); p_22++)
{
int *l_497 = &g_232;
signed char l_509 = 0x2EL;
step_hash(313);
for (l_363 = 18; (l_363 == 3); --l_363)
{
unsigned short l_492 = 0x25CFL;
step_hash(302);
(**l_481) ^= l_492;
step_hash(310);
for (l_371 = (-6); (l_371 != (-1)); l_371++)
{
int *l_498 = &l_414;
step_hash(306);
(*l_413) ^= (p_22 & p_22);
step_hash(307);
(*l_498) ^= ((0xE5L && ((short)func_51(l_497, l_498, l_499, l_498, l_492) >> (short)p_22)) == g_232);
step_hash(308);
(**l_481) = ((unsigned char)((((l_492 > g_2) || (l_497 != l_497)) <= (((g_263 != (g_232 < (0x08L > (((int)(g_149 >= p_22) + (int)l_508) | g_2)))) & (*l_497)) <= 0x6FL)) > (*g_197)) % (unsigned char)0xCEL);
step_hash(309);
(*l_364) = l_498;
}
step_hash(311);
if (l_509)
continue;
step_hash(312);
if ((*g_280))
break;
}
step_hash(314);
(*l_481) = &l_508;
}
step_hash(316);
(*l_481) = (*l_481);
}
}
step_hash(319);
g_58 &= (*l_353);
step_hash(320);
return (*g_280);
}
static signed char func_27(signed char p_28)
{
int **l_29 = (void*)0;
int *l_31 = &g_2;
int **l_30 = &l_31;
int l_235 = 0xC0EB3422L;
step_hash(5);
(*l_30) = (void*)0;
step_hash(136);
(*l_30) = func_32(func_38(p_28, func_43(((p_28 & ((unsigned char)((unsigned short)(g_50 == &l_31) + (unsigned short)func_51((*l_30), (*l_30), (*l_30), &g_2, p_28)) + (unsigned char)p_28)) == p_28), g_2), p_28, &l_31), l_30, &g_2, &g_197, p_28);
step_hash(137);
l_235 ^= p_28;
step_hash(138);
(*g_197) = ((short)((unsigned short)((*l_30) != (void*)0) % (unsigned short)((p_28 || (&g_197 != (void*)0)) & 65526UL)) % (short)g_2);
step_hash(139);
return (**l_30);
}
static int * func_32(int * p_33, int ** p_34, int * p_35, int ** p_36, unsigned short p_37)
{
int *l_233 = &g_2;
int *l_234 = &g_2;
step_hash(133);
g_232 ^= (func_51(&g_2, l_233, (*p_34), l_234, p_37) <= 0x94L);
step_hash(134);
(*p_34) = (*p_36);
step_hash(135);
return l_233;
}
static int * func_38(int p_39, int * p_40, unsigned p_41, int ** p_42)
{
int *l_231 = &g_232;
step_hash(129);
(*l_231) |= (*g_197);
step_hash(130);
(*p_42) = (*p_42);
step_hash(131);
return (*p_42);
}
static int * func_43(unsigned p_44, unsigned short p_45)
{
signed char l_63 = 0x79L;
int *l_72 = &g_58;
int *l_78 = &g_58;
int *l_118 = &g_58;
unsigned char l_123 = 0xE1L;
unsigned l_156 = 0x28D9C3D7L;
step_hash(11);
(*l_72) = ((unsigned char)((unsigned short)(l_63 != ((unsigned short)p_44 % (unsigned short)((unsigned)(~((unsigned char)0x03L >> (unsigned char)1)) + (unsigned)(((-1L) > ((int)(p_44 < (4294967294UL != p_44)) % (int)0xF6679856L)) & 9UL)))) + (unsigned short)p_44) >> (unsigned char)l_63);
step_hash(124);
if (((void*)0 != &g_2))
{
int **l_76 = &l_72;
int l_77 = 0L;
short l_86 = 0xE086L;
int *l_94 = &g_58;
unsigned l_120 = 0x3E316ED2L;
step_hash(24);
for (g_58 = (-30); (g_58 != 19); ++g_58)
{
int **l_75 = (void*)0;
step_hash(23);
if ((l_75 != l_76))
{
step_hash(17);
l_72 = (void*)0;
step_hash(18);
l_77 ^= func_51(l_72, &g_2, l_72, (*l_76), g_58);
step_hash(19);
l_78 = l_78;
step_hash(20);
(*l_76) = l_78;
}
else
{
step_hash(22);
return &g_2;
}
}
step_hash(73);
if ((func_51((*l_76), (*l_76), l_78, l_78, ((signed char)func_51(l_78, (*l_76), l_72, &g_58, g_58) - (signed char)p_44)) & p_44))
{
int l_95 = 1L;
int l_119 = (-8L);
step_hash(42);
for (l_63 = 16; (l_63 > 16); l_63 += 4)
{
step_hash(41);
if (p_45)
{
int l_83 = 1L;
step_hash(30);
(**l_76) ^= p_45;
step_hash(31);
l_86 = (l_83 | (((short)p_45 * (short)(p_45 ^ func_51((*l_76), &l_83, &l_83, (*l_76), g_58))) == p_45));
step_hash(36);
for (p_45 = (-8); (p_45 >= 23); p_45 += 1)
{
step_hash(35);
(*l_76) = (void*)0;
}
step_hash(37);
return l_72;
}
else
{
int *l_89 = &l_77;
step_hash(39);
(*l_89) &= g_58;
step_hash(40);
if ((*l_72))
break;
}
}
step_hash(56);
if (g_58)
{
unsigned char l_90 = 255UL;
step_hash(44);
(*l_72) = l_90;
step_hash(45);
(*l_76) = &g_58;
step_hash(46);
(*l_76) = (void*)0;
}
else
{
int *l_91 = &g_2;
int *l_100 = &g_58;
step_hash(48);
l_72 = l_91;
step_hash(49);
(*l_94) = (((unsigned char)254UL % (unsigned char)g_58) <= func_51((*l_76), l_91, &g_2, l_94, l_95));
step_hash(54);
for (l_77 = 0; (l_77 > (-22)); l_77 -= 5)
{
int *l_101 = &l_77;
step_hash(53);
(*l_100) = ((short)(func_51(l_78, l_100, l_91, l_91, (func_51(l_101, l_100, l_72, l_100, ((unsigned)(((signed char)0xA1L / (signed char)g_2) | 255UL) - (unsigned)p_45)) && (*l_100))) & p_45) / (short)g_58);
}
step_hash(55);
(*l_78) ^= p_44;
}
step_hash(57);
l_119 = ((unsigned char)((((int)((unsigned char)((unsigned char)((unsigned short)((void*)0 != g_50) / (unsigned short)g_2) << (unsigned char)((int)((func_51(l_72, l_118, l_118, l_72, (*l_78)) || p_44) | g_2) - (int)l_95)) / (unsigned char)0x0BL) + (int)4294967294UL) || 0xCCL) < (-2L)) >> (unsigned char)l_95);
}
else
{
short l_121 = 0xB233L;
int *l_126 = &g_58;
step_hash(72);
if (l_120)
{
int *l_122 = &l_77;
int *l_129 = &g_2;
step_hash(60);
(*l_76) = l_72;
step_hash(61);
(*l_122) ^= (((l_121 >= 1UL) < g_58) || g_2);
step_hash(62);
(*l_122) &= ((((p_44 < l_123) <= (((short)0x3792L * (short)l_121) > ((0x0DBEA549L >= ((-8L) && ((l_126 != l_122) && (*l_72)))) >= g_58))) == 252UL) ^ 1UL);
step_hash(68);
for (l_120 = 0; (l_120 < 56); l_120 += 2)
{
step_hash(66);
(*l_126) = (p_45 < g_2);
step_hash(67);
(*l_76) = l_129;
}
}
else
{
step_hash(70);
(*l_78) ^= (0xD077L < p_45);
step_hash(71);
(*l_76) = (*l_76);
}
}
step_hash(74);
(*l_94) ^= ((unsigned char)0UL >> (unsigned char)3);
}
else
{
int *l_139 = (void*)0;
int *l_148 = &g_58;
unsigned l_202 = 4294967293UL;
step_hash(123);
for (p_44 = 0; (p_44 != 44); ++p_44)
{
int *l_138 = &g_2;
short l_161 = 0x451BL;
int **l_224 = &l_78;
step_hash(79);
g_149 |= (((((unsigned char)(((signed char)(func_51(l_138, l_139, l_139, l_78, ((unsigned)((unsigned char)((unsigned short)((unsigned char)func_51(l_148, l_148, l_118, l_138, g_2) >> (unsigned char)3) * (unsigned short)g_2) + (unsigned char)p_45) - (unsigned)0x0E7D168DL)) || g_58) >> (signed char)4) | 65535UL) << (unsigned char)5) >= g_58) > g_58) & (*l_148));
step_hash(108);
if (((func_51(l_148, l_148, l_78, l_118, p_44) | ((((((signed char)((unsigned char)(((unsigned char)(246UL | (*l_78)) >> (unsigned char)0) > ((g_149 != (*l_138)) > (*l_148))) >> (unsigned char)g_58) + (signed char)(-10L)) == l_156) != 1UL) || (*l_138)) | p_45)) != 255UL))
{
unsigned l_164 = 0x0DB9FFA4L;
short l_172 = 0x2394L;
int l_173 = 1L;
int **l_190 = &l_139;
step_hash(103);
for (l_123 = 0; (l_123 < 44); l_123++)
{
int *l_169 = (void*)0;
}
step_hash(104);
(*l_148) ^= p_44;
}
else
{
step_hash(106);
(*l_78) = ((!g_149) || 0L);
step_hash(107);
(*l_118) = (*l_138);
}
step_hash(121);
for (p_45 = (-26); (p_45 != 32); p_45 += 8)
{
int *l_193 = &g_2;
int ***l_194 = &g_50;
step_hash(112);
(*l_118) = (func_51(l_118, &g_58, l_148, l_193, (*l_193)) || (func_51(l_138, l_139, l_148, l_193, (*l_72)) < p_45));
step_hash(113);
(*l_194) = &l_138;
step_hash(114);
l_202 = (((((unsigned short)func_51(l_72, (*g_50), g_197, l_138, (((short)(*l_138) << (short)2) ^ ((int)0x70531B4AL - (int)g_58))) >> (unsigned short)(g_2 || 0x9095L)) || (*g_197)) == 0x3E1635C7L) || g_2);
step_hash(120);
for (l_63 = (-23); (l_63 == 29); l_63 += 1)
{
int *l_221 = &g_2;
int *l_222 = &g_58;
int l_223 = 0x2AF5FF99L;
step_hash(118);
(*g_50) = l_138;
step_hash(119);
l_223 &= (((unsigned char)((short)((short)(((unsigned short)(((unsigned short)((unsigned char)g_2 / (unsigned char)((unsigned)((signed char)((*l_118) < (p_44 == ((void*)0 == l_221))) >> (signed char)0) % (unsigned)func_51(l_118, l_138, (*g_50), l_222, p_45))) * (unsigned short)p_44) < p_45) % (unsigned short)0x59C8L) && 4294967293UL) * (short)(***l_194)) >> (short)g_149) % (unsigned char)p_44) == g_58);
}
}
step_hash(122);
(*l_224) = l_72;
}
}
step_hash(125);
l_118 = l_118;
step_hash(126);
(*g_197) |= ((signed char)((unsigned char)(0L == ((p_45 <= 4294967295UL) ^ (((short)p_44 << (short)5) == p_44))) - (unsigned char)(l_72 != l_72)) + (signed char)((void*)0 != l_118));
step_hash(127);
return &g_2;
}
static unsigned short func_51(int * p_52, int * p_53, int * p_54, int * p_55, unsigned short p_56)
{
int *l_57 = &g_58;
step_hash(7);
l_57 = &g_2;
step_hash(8);
l_57 = p_53;
step_hash(9);
return g_58;
}
void csmith_compute_hash(void)
{
transparent_crc(g_2, "g_2", print_hash_value);
transparent_crc(g_58, "g_58", print_hash_value);
transparent_crc(g_149, "g_149", print_hash_value);
transparent_crc(g_232, "g_232", print_hash_value);
transparent_crc(g_263, "g_263", print_hash_value);
transparent_crc(g_585, "g_585", print_hash_value);
}
void step_hash(int stmt_id)
{
int i = 0;
csmith_compute_hash();
printf("before stmt(%d): checksum = %X\n", stmt_id, crc32_context ^ 0xFFFFFFFFUL);
crc32_context = 0xFFFFFFFFUL;
for (i = 0; i < 256; i++) {
crc32_tab[i] = 0;
}
crc32_gentab();
}
int main (void)
{
int print_hash_value = 0;
platform_main_begin();
crc32_gentab();
func_1();
csmith_compute_hash();
platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
return 0;
}
|
the_stack_data/173579318.c | /*
* main.c
*
* Created on: 4 Jun 2020
* Author: wudi
*/
int main(int argc, char *argv[]) {
printf("this is latest linux-kernel-cli\n");
}
|
the_stack_data/145454257.c | #include<stdio.h>
#include<stdlib.h>
#include<omp.h>
#include<stdint.h>
#include<time.h>
uint32_t __GetTickCount(void) {
struct timespec ts;
uint32_t tick = 0U;
clock_gettime(CLOCK_REALTIME, &ts);
tick = ts.tv_nsec / 1000000;
tick += ts.tv_sec * 1000;
return tick;
}
void PI(double a, double b, int numIntervals, double* global_result_p) {
int i;
double x, my_result, sum = 0.0, interval, local_a, local_b, local_numIntervals;
int myThread = omp_get_thread_num();
int numThreads = omp_get_num_threads();
interval = (b-a)/ (double) numIntervals;
local_numIntervals = numIntervals/numThreads;
local_a = a + myThread*local_numIntervals*interval;
local_b = local_a + local_numIntervals*interval;
sum = 0.0;
for (i = 0; i < local_numIntervals; i++) {
x = local_a + i*interval;
sum = sum + 4.0 / (1.0 + x*x);
};
my_result = interval * sum;
#pragma om critical
*global_result_p += my_result;
}
int main(int argc, char** argv) {
double global_result = 0.0;
volatile uint32_t dwStart;
if (argc < 2) {
fprintf(stderr, "argerr\n");
return 1;
}
int n = 100000000;
printf("numberInterval %d \n", n);
int numThreads = strtol(argv[1], NULL, 10);
dwStart = __GetTickCount();
#pragma omp parallel num_threads(numThreads)
PI(0, 1, n, &global_result);
printf("number of threads %d \n", numThreads);
printf("Pi = %f \n", global_result);
printf("milliseconds %d \n", __GetTickCount() - dwStart);
}
|
the_stack_data/118570.c | #include<stdio.h>
void main()
{
int a,b;
clrscr();
printf("Enter any two nos=");
scanf("%d%d",&a,&b);
a=a+b;
b=a-b;
a=a-b;
printf("After swaping= %d %d",b,a);
getch();
}
|
the_stack_data/37787.c | #include<stdio.h>
main()
{
int n;
printf("Enter number of elements: ");
scanf("%d",&n);
int arr[n], i;
printf("\nEnter %d elements: ", n);
for(i = 0 ;i < n ;i++)
{
scanf("\n%d",&arr[i]);
}
int one = 0;
int two = 0;
int n_t, x;
for(i = 0; i < n; i++)
{
x = arr[i];
two |=one & x;
one ^= x;
n_t =~(one & two);
one &= n_t;
two &= n_t;
}
printf("\nThe number that occurs only once is %d \n", one);
}
/*
Time complexity: O(n)
Space complexity: O(n)
Example 1:
Sample input:
Enter number of elements: 7
Enter 7 elements: 6
2
5
2
2
6
6
Output: The number that occurs only once is 5
Example 2:
Sample Input:
Enter number of elements: 4
Enter 4 elements: 3
3
1
3
Output: The number that occurs only once is 1
*/
|
the_stack_data/140764585.c | #include <stdio.h>
// This is a comment
int main(int argc, char *argv[])
{
int distance = 100;
/* This is also a comment*/
printf("You are %d miles away.\n", distance);
return 0;
}
|
the_stack_data/11349.c | extern void __VERIFIER_error() __attribute__ ((__noreturn__));
void __VERIFIER_assert(int cond) { if(!(cond)) { ERROR: __VERIFIER_error(); } }
#define size 75
int main()
{
int a[size];
int b[size];
int i = 1;
int j = 0;
while( i < size )
{
a[j] = b[i];
i = i+2;
j = j+1;
}
i = 1;
j = 0;
while( i < size )
{
__VERIFIER_assert( a[j] == b[2*j+1] );
i = i+2;
j = j+1;
}
return 0;
}
|
the_stack_data/97013742.c | #include<stdio.h>
#include<stdlib.h>
#include<string.h>
int remainder_check(char* parameter_1,int checksum_div,int length);
int remainder_check(char* parameter_1,int checksum_div,int length)
{
if(strlen(parameter_1)!=length) return 0;
int sum = 0;
for(int i=0;i<length;i++) sum = sum + parameter_1[i];
if((sum % checksum_div==0)) return 1;
else return 0;
}
float v_core_ctx_destroy();
void v_core_stop( int parameter_1);
char v_stats_metric_reset( float parameter_1);
int v_stats_pool_reset( unsigned int parameter_1);
void v_array_swap( unsigned int parameter_1,char parameter_2);
void v_stats_swap( double parameter_1);
char v_core_timeout_handle_common( unsigned int parameter_1,double parameter_2);
char v_core_timeout_handle_sentinel_reconn( char parameter_1,int parameter_2);
double v_core_timeout_handle_sentinel_heartb( int parameter_1,unsigned int parameter_2);
short v_core_timeout_handle( int parameter_1,unsigned int parameter_2);
short v_msg_from_rbe( long parameter_1);
char v_rbtree_min( int parameter_1);
unsigned int v_msg_tmo_min();
long v_core_timeout( char parameter_1);
int v_event_wait( int parameter_1,int parameter_2);
char v_core_loop( int parameter_1);
unsigned int v_mbuf_free();
void v_mbuf_deinit();
short v_msg_free( int parameter_1);
void v_msg_deinit();
long v_conn_free( int parameter_1);
void v_conn_deinit();
float v_proxy_each_deinit();
void v_proxy_deinit( float parameter_1);
unsigned int v_proxy_reuse( float parameter_1);
int v_proxy_listen( char parameter_1,double parameter_2);
void v_proxy_unref();
void v_proxy_ref( unsigned int parameter_1);
void v_proxy_close( int parameter_1,float parameter_2);
int v_nc_set_tcpkeepalive( int parameter_1);
void v_req_client_dequeue_omsgq( char parameter_1,unsigned int parameter_2,long parameter_3);
void v_req_client_enqueue_omsgq( double parameter_1,unsigned int parameter_2,long parameter_3);
void v_client_unref( int parameter_1);
void v_client_ref( short parameter_1);
char v_client_active( int parameter_1);
void v_client_close_stats( unsigned int parameter_1,unsigned int parameter_2,long parameter_3,double parameter_4);
void v_client_close( unsigned int parameter_1,double parameter_2);
void v_rsp_send_done( long parameter_1,int parameter_2,char parameter_3);
void v_msg_get_error( float parameter_1,short parameter_2);
unsigned int v_rsp_make_error( long parameter_1,int parameter_2,short parameter_3);
unsigned int v_req_error( short parameter_1,float parameter_2);
float v_rsp_send_next( char parameter_1,double parameter_2);
unsigned int v_req_forward_stats( char parameter_1,float parameter_2,char parameter_3);
long v_server_pool_server( int parameter_1,float parameter_2,int parameter_3);
int v_server_pool_conn( short parameter_1,char parameter_2,int parameter_3,double parameter_4,int uni_para);
long v_req_forward( float parameter_1,int parameter_2,double parameter_3,int uni_para);
long v_req_forward_error( int parameter_1,long parameter_2,unsigned int parameter_3);
float v_req_make_reply( int parameter_1,int parameter_2,float parameter_3);
float v_req_filter( float parameter_1,float parameter_2,char parameter_3);
void v_req_recv_done( short parameter_1,double parameter_2,short parameter_3,char parameter_4,int uni_para);
char v_req_get();
char v_req_recv_next( char parameter_1,double parameter_2,double parameter_3);
long v_conn_get_client(int uni_para);
double v_conn_ncurr_cconn();
long v_proxy_accept( int parameter_1,unsigned int parameter_2,int uni_para);
float v_proxy_recv( short parameter_1,float parameter_2,int uni_para);
long v_conn_get_proxy(int uni_para);
double v_proxy_each_init(int uni_para);
float v_proxy_init( short parameter_1,int uni_para);
void v_event_base_destroy();
float v_server_each_disconnect();
void v_server_pool_each_disconnect();
void v_server_pool_disconnect( int parameter_1);
long v_req_sentinel_send_get_master_addr( short parameter_1,unsigned int parameter_2);
short v_sentinel_swallow_recv_pub( double parameter_1,unsigned int parameter_2,double parameter_3);
char v_sentinel_swallow_psub_pub( int parameter_1,char parameter_2,int parameter_3);
long v_sentinel_swallow_psub_rsp( short parameter_1,float parameter_2,long parameter_3);
short v_redis_add_role( short parameter_1,int parameter_2);
short v_req_server_send_role( short parameter_1,long parameter_2);
int v_event_add_conn( short parameter_1,long parameter_2);
int v_nc_set_tcpnodelay( int parameter_1);
int v_nc_set_nonblocking( int parameter_1);
float v_server_connect( float parameter_1,double parameter_2,char parameter_3);
char v_req_sentinel_send_heartbeat( long parameter_1,long parameter_2,int uni_para);
void v_server_swallow_role_rsp( unsigned int parameter_1,short parameter_2,int uni_para);
char v_redis_error( long parameter_1);
void v_redis_swallow_msg( long parameter_1,int parameter_2,int parameter_3,int uni_para);
void v_req_server_enqueue_imsgq_head( long parameter_1,double parameter_2,int parameter_3);
void v_redis_post_connect( short parameter_1,double parameter_2,float parameter_3);
void v_req_server_dequeue_omsgq( int parameter_1,int parameter_2,short parameter_3);
void v_req_server_enqueue_omsgq( float parameter_1,float parameter_2,double parameter_3);
void v_req_server_dequeue_imsgq( unsigned int parameter_1,double parameter_2,short parameter_3);
int v_server_timeout( unsigned int parameter_1);
void v_msg_tmo_insert( short parameter_1,short parameter_2);
void v_req_server_enqueue_imsgq( long parameter_1,unsigned int parameter_2,char parameter_3);
void v_server_unref( int parameter_1);
char v_server_resolve( double parameter_1,short parameter_2);
void v_server_ref( short parameter_1);
unsigned int v_rsp_forward_stats( short parameter_1,float parameter_2,short parameter_3,float parameter_4);
short v_rsp_forward( float parameter_1,short parameter_2,float parameter_3);
double v_rsp_filter( long parameter_1,double parameter_2,float parameter_3);
void v_rsp_recv_done( float parameter_1,float parameter_2,float parameter_3,unsigned int parameter_4);
char v_conn_get_redis(int uni_para);
float v_server_conn( int parameter_1,int uni_para);
double v_server_each_connect();
double v_server_pool_connect( double parameter_1,long parameter_2);
short v_server_reset( double parameter_1,char parameter_2,long parameter_3);
char v_sentinel_swallow_addr_rsp( short parameter_1,long parameter_2,float parameter_3);
void v_sentinel_swallow_msg( long parameter_1,char parameter_2,unsigned int parameter_3);
void v_sentinel_post_connect( int parameter_1,double parameter_2,double parameter_3);
int v_server_active( int parameter_1);
void v_rbtree_insert( float parameter_1,float parameter_2);
char v_nc_msec_now();
void v_msg_timer( long parameter_1,unsigned int parameter_2);
void v_sentinel_close( int parameter_1,int parameter_2);
void v_req_send_done( short parameter_1,unsigned int parameter_2,short parameter_3);
int v_event_del_out( short parameter_1,int parameter_2);
void v_server_connected( float parameter_1,unsigned int parameter_2);
long v_req_send_next( long parameter_1,unsigned int parameter_2);
char v_conn_sendv( long parameter_1,long parameter_2,char parameter_3);
unsigned int v_array_set( long parameter_1,double parameter_3,int parameter_4);
long v_msg_send_chain( short parameter_1,char parameter_2,char parameter_3);
void v_msg_send( double parameter_1,char parameter_2);
int v_sentinel_rsp_forward( double parameter_1,short parameter_2,long parameter_3);
long v_sentinel_rsp_filter( short parameter_1,float parameter_2,char parameter_3);
void v_rsp_sentinel_recv_done( double parameter_1,unsigned int parameter_2,int parameter_3,long parameter_4);
int v_rsp_get( long parameter_1);
double v_rsp_recv_next( int parameter_1,unsigned int parameter_2,int parameter_3);
char v_msg_repair( char parameter_1,double parameter_2,long parameter_3);
void v_redis_post_coalesce_mset( long parameter_1);
void v_redis_post_coalesce_del( long parameter_1);
double v_redis_post_coalesce_mget();
void v_redis_post_coalesce( short parameter_1);
void v_mbuf_rewind( char parameter_1);
void v_redis_pre_coalesce( float parameter_1);
unsigned int v_redis_failure( unsigned int parameter_1);
void v_redis_handle_select_req( long parameter_1,char parameter_2);
double v_redis_handle_time_req( char parameter_1,short parameter_2);
float v_redis_handle_echo_req( long parameter_1,char parameter_2);
double v_redis_handle_ping_req( short parameter_1,double parameter_2);
unsigned int v_redis_handle_auth_req( int parameter_1,double parameter_2);
void v_redis_reply( float parameter_1,int uni_para);
int v_msg_append( double parameter_1,int parameter_2,double parameter_3,int uni_para);
void v_mbuf_empty( char parameter_1);
unsigned int v_redis_copy_bulk( long parameter_1,long parameter_2);
double v_msg_ensure_mbuf( double parameter_1,float parameter_2);
float v_redis_append_key( double parameter_1,float parameter_2,float parameter_3);
int v_random_dispatch( double parameter_1,short parameter_2,char parameter_3);
int v_modula_dispatch( short parameter_1,short parameter_2,double parameter_3);
long v_ketama_dispatch( int parameter_1,char parameter_2,char parameter_3);
long v_server_pool_hash( short parameter_1,double parameter_2,int parameter_3);
int v_server_pool_idx( double parameter_1,char parameter_2,int parameter_3);
int v_msg_backend_idx( char parameter_1,double parameter_2,long parameter_3);
char v_msg_gen_frag_id();
long v_redis_fragment_argx( float parameter_1,long parameter_2,char parameter_3,short parameter_4);
long v_redis_fragment( int parameter_1,char parameter_2,float parameter_3);
int v_msg_prepend_format( int parameter_1,long parameter_2,short parameter_3);
float v_conn_authenticated( char parameter_1);
short v_redis_add_auth( unsigned int parameter_1,char parameter_2,double parameter_3);
char v_redis_argkvx( double parameter_1);
int v_redis_argx( unsigned int parameter_1);
float v_redis_argn( int parameter_1);
char v_redis_arg3( unsigned int parameter_1);
double v_redis_arg2( long parameter_1);
short v_redis_arg1( char parameter_1);
void v_redis_arg0( char parameter_1);
char v_mbuf_data_size();
unsigned int v_redis_argeval( long parameter_1);
void v_redis_argz( unsigned int parameter_1);
void v_redis_parse_req( double parameter_1);
void v_redis_parse_rsp( short parameter_1);
void v_sentinel_parse_rsp( unsigned int parameter_1);
void v_sentinel_parse_req();
unsigned int v_msg_get( char parameter_1,char parameter_2,int uni_para);
float v_mbuf_length();
void v_mbuf_copy( float parameter_1,double parameter_2,int parameter_3,int uni_para);
void v_mbuf_split( char parameter_1,double parameter_2,double parameter_3);
void v_msg_parsed( unsigned int parameter_1,long parameter_2,int parameter_3);
short v_msg_empty( char parameter_1);
short v_msg_parse( char parameter_1,short parameter_2,short parameter_3);
int v_conn_recv( double parameter_1,char parameter_3);
long v_mbuf_size( double parameter_1);
void v_mbuf_insert( int parameter_1,char parameter_2);
void v__mbuf_get();
short v_mbuf_get();
unsigned int v_mbuf_full(int uni_para);
short v_msg_recv_chain( char parameter_1,short parameter_2,char parameter_3);
long v_msg_recv( char parameter_1,long parameter_2);
char v__conn_get();
double v_conn_get_sentinel();
long v_sentinel_conn( char parameter_1);
int v_event_add_out( unsigned int parameter_1,short parameter_2);
int v_req_done( double parameter_1,long parameter_2);
double v_rbtree_right_rotate( short parameter_1,float parameter_2,unsigned int parameter_3);
char v_rbtree_left_rotate( float parameter_1,short parameter_2,double parameter_3);
void v_rbtree_node_min( char parameter_1,long parameter_2);
void v_rbtree_delete( unsigned int parameter_1,double parameter_2);
void v_msg_tmo_delete( short parameter_1);
void v_rsp_put( short parameter_1);
float v_msg_type_string( double parameter_1);
int v_log_loggable( int parameter_1);
short v_req_log( int parameter_1);
void v_req_put( double parameter_1);
void v_conn_put( long parameter_1);
double v_nc_usec_now();
short v_server_failure( float parameter_1,float parameter_2);
float v_server_close_stats( char parameter_1,float parameter_2,char parameter_3,char parameter_4,int parameter_5);
void v_server_close( short parameter_1,char parameter_2);
int v_sentinel_get();
int v_sentinel_connect( short parameter_1);
float v_server_pool_each_preconnect();
unsigned int v_server_pool_preconnect( int parameter_1);
char v_core_send( float parameter_1,long parameter_2);
unsigned int v_core_recv( double parameter_1,short parameter_2);
int v_event_del_conn( float parameter_1,short parameter_2);
float v_nc_unresolve_addr( unsigned int parameter_1,unsigned int parameter_2);
long v_nc_unresolve_peer_desc( int parameter_1);
double v_core_close( short parameter_1,unsigned int parameter_2);
int v_nc_get_soerror( int parameter_1);
int v_core_error( int parameter_1,long parameter_2);
double v_conn_to_ctx( short parameter_1);
int v_core_core(unsigned int parameter_2);
void v_event_base_create( int parameter_1,double parameter_2);
void v_stats_destroy_buf( unsigned int parameter_1);
char v_stats_server_unmap( long parameter_1);
float v_stats_pool_unmap( short parameter_1);
void v_stats_stop_aggregator( char parameter_1);
void v_stats_destroy( short parameter_1);
char v_stats_add_footer( float parameter_1);
unsigned int v_stats_end_nesting();
long v_stats_copy_metric( char parameter_1,long parameter_2);
float v_stats_begin_nesting( long parameter_1,double parameter_2);
int v_conn_ncurr_conn();
float v_conn_ntotal_conn();
long v_stats_add_num( int parameter_1,char parameter_2,short parameter_3);
short v_stats_add_string( int parameter_1,float parameter_2,long parameter_3);
int v_stats_add_header( int parameter_1);
void v_stats_make_rsp();
double v_stats_send_rsp();
float v_stats_aggregate_metric( float parameter_1,char parameter_2);
unsigned int v_stats_aggregate( double parameter_1);
double v_stats_loop_callback();
void v_event_loop_stats( float parameter_1);
long v_stats_loop();
int v_nc_set_reuseaddr( int parameter_1);
double v_nc_resolve_inet( float parameter_1,int parameter_2,double parameter_3);
char v_nc_resolve_unix( int parameter_1,short parameter_2);
int v_nc_resolve( double parameter_1,int parameter_2,short parameter_3);
char v_stats_listen( float parameter_1);
float v_stats_start_aggregator( unsigned int parameter_1);
void v_stats_create_buf( long parameter_1);
char v_stats_metric_deinit( char parameter_1);
float v_stats_server_metric_init( int parameter_1);
int v_stats_server_init( long parameter_1,unsigned int parameter_2);
char v_stats_server_map( char parameter_1,float parameter_2);
char v_stats_metric_init( unsigned int parameter_1);
short v_stats_pool_metric_init( float parameter_1);
int v_stats_pool_init( float parameter_1,unsigned int parameter_2);
unsigned int v_stats_pool_map( float parameter_1,unsigned int parameter_2);
long v_stats_create( double parameter_1,char parameter_2,int parameter_3,char parameter_4,short parameter_5);
int v_core_calc_connections( short parameter_1);
short v_random_update( long parameter_1);
void v_modula_update( int parameter_1);
unsigned int v_ketama_item_cmp( long parameter_1,float parameter_2);
void v_md5_signature( float parameter_1,long parameter_2,double parameter_3);
long v_ketama_hash( unsigned int parameter_1,unsigned int parameter_2,unsigned int parameter_3);
double v_ketama_update( int parameter_1);
char v_server_pool_run();
unsigned int v_server_pool_each_run();
float v_server_pool_each_calc_connections();
char v_server_pool_each_set_owner();
void v_server_pool_deinit( long parameter_1);
int v_sentinel_each_set_owner();
void v_array_destroy( unsigned int parameter_1);
void v_mbuf_put( short parameter_1);
void v_mbuf_remove( double parameter_1,short parameter_2);
void v_msg_put( long parameter_1);
void v_sentinel_deinit( int parameter_1);
void v_array_create( char parameter_1,unsigned int parameter_2);
long v__msg_get();
double v_msg_get_raw();
void v_conf_sentinel_each_transform();
char v_sentinel_init( short parameter_1,unsigned int parameter_2,int parameter_3);
void v_server_each_set_owner();
void v_server_deinit( int parameter_1);
int v_conf_server_each_transform();
long v_server_init( int parameter_1,unsigned int parameter_2,int parameter_3);
void v_array_idx( float parameter_1);
char v_conf_pool_each_transform();
short v_array_each( long parameter_1);
int v_server_pool_init( char parameter_1,int parameter_2,float parameter_3);
unsigned int v_core_ctx_create( short parameter_1,int uni_para);
void v_conn_init();
void v_rbtree_node_init( unsigned int parameter_1);
void v_rbtree_init( float parameter_1,short parameter_2);
void v_msg_init();
void v_mbuf_init( float parameter_1);
short v_core_start( char parameter_1,int uni_para);
void v_nc_run( short parameter_1,int uni_para);
void v_log_deinit();
double v_nc_print_done();
void v_signal_deinit();
float v_nc_remove_pidfile( char parameter_1);
int v_nc_post_run( long parameter_1);
int v_nc_print_run( long parameter_1);
long v_nc_create_pidfile( unsigned int parameter_1);
float v_signal_init();
float v_nc_daemonize( int parameter_1);
int v_log_init( int parameter_1,char parameter_2);
unsigned int v_nc_pre_run( unsigned int parameter_1);
int v_conf_server_deinit();
long v_conf_pool_deinit( long parameter_1);
void v_conf_destroy();
unsigned int v_conf_dump( short parameter_1);
int v_conf_pool_name_cmp( char parameter_1,long parameter_2);
double v_conf_pool_listen_cmp( unsigned int parameter_1,unsigned int parameter_2);
char v_conf_sentinel_name_cmp( long parameter_1,long parameter_2);
short v_conf_validate_sentinel( unsigned int parameter_1,int parameter_2);
double v_conf_group_name_cmp( float parameter_1,int parameter_2);
void v_array_sort( float parameter_1,float parameter_2);
char v_conf_validate_group( unsigned int parameter_1,float parameter_2);
long v_string_empty( double parameter_1);
float v_conf_validate_pool( int parameter_1,float parameter_2);
float v_conf_post_validate( float parameter_1);
float v_conf_end_parse( char parameter_1);
int v_string_compare( char parameter_1,int parameter_2);
char v_string_duplicate( short parameter_1,unsigned int parameter_2);
int v_array_null( float parameter_1);
void v_conf_pool_init( double parameter_1,float parameter_2);
long v_array_get( long parameter_1,char parameter_2);
char v_array_top( int parameter_1);
double v_conf_handler( double parameter_1);
char v_string_copy( unsigned int parameter_1,double parameter_2,char parameter_3);
float v_array_push( float parameter_1);
char v_conf_push_scalar( float parameter_1);
void v_string_init( float parameter_1);
void v_string_deinit();
double v_array_pop( char parameter_1);
float v_conf_pop_scalar( char parameter_1);
void v_conf_parse_core( unsigned int parameter_1);
long v_conf_begin_parse( long parameter_1);
unsigned int v_array_n( float parameter_1);
short v_conf_parse( char parameter_1);
unsigned int v_conf_event_done( char parameter_1);
void v_conf_event_next( char parameter_1);
short v_conf_validate_structure( int parameter_1);
double v_conf_token_done( float parameter_1);
char v_conf_token_next( float parameter_1);
float v_conf_validate_tokens();
float v_conf_yaml_deinit( unsigned int parameter_1);
float v_conf_yaml_init();
short v_conf_validate_document( float parameter_1);
float v_conf_pre_validate( short parameter_1);
void v_array_deinit( unsigned int parameter_1);
void v_array_init( char parameter_1,float parameter_2,long parameter_3);
float v_conf_open( char parameter_1);
int v_conf_create( char parameter_1);
int v_nc_test_conf( char parameter_1);
void v_stats_describe();
int v_nc_show_usage();
short v_nc_valid_port( int parameter_1);
int v_nc_get_options( int parameter_1,char parameter_2,int parameter_3);
float v_nc_set_default_options();
float v_core_ctx_destroy()
{
short short_1 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
float float_2 = 1;
double double_3 = 1;
int int_3 = 1;
float float_3 = 1;
long long_3 = 1;
short_1 = short_1;
v_proxy_deinit(float_1);
int_1 = int_1 * int_2;
v_event_base_destroy();
double_1 = double_1 * double_2;
v_stats_destroy(short_1);
long_1 = long_2;
float_2 = float_2 * float_2;
v_conf_destroy();
double_1 = double_1 * double_3;
v_server_pool_disconnect(int_3);
int_1 = int_2;
double_1 = double_3 + double_3;
return float_3;
v_server_pool_deinit(long_3);
}
void v_core_stop( int parameter_1)
{
unsigned int unsigned_int_1 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
float float_1 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
long_1 = long_2;
v_conn_deinit();
v_mbuf_deinit();
char_2 = char_1 + char_2;
short_1 = short_1 + short_1;
v_msg_deinit();
float_1 = v_core_ctx_destroy();
}
char v_stats_metric_reset( float parameter_1)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
char char_2 = 1;
long long_2 = 1;
long long_3 = 1;
unsigned_int_1 = v_array_n(float_1);
char_1 = v_stats_metric_init(unsigned_int_1);
short_1 = short_2;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
long_1 = v_array_get(long_1,char_2);
long_2 = long_2 + long_3;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
unsigned_int_4 = unsigned_int_1 + unsigned_int_3;
unsigned_int_5 = unsigned_int_5 + unsigned_int_3;
}
return char_2;
}
int v_stats_pool_reset( unsigned int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_2 = 1;
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_2 = 1;
double_1 = double_2;
long_2 = long_1 * long_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short_3 = short_1 * short_2;
int_2 = int_1 + int_2;
long_2 = v_array_get(long_1,char_1);
char_2 = v_stats_metric_reset(float_1);
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
short_2 = short_3 * short_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
double double_3 = 1;
char char_3 = 1;
char char_4 = 1;
double_3 = double_3 + double_3;
unsigned_int_2 = v_array_n(float_1);
char_4 = char_3 * char_1;
}
}
return int_2;
}
void v_array_swap( unsigned int parameter_1,char parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
int_3 = int_1 + int_2;
long_2 = long_1 * long_2;
float_2 = float_1 + float_2;
}
void v_stats_swap( double parameter_1)
{
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_3 = 1;
float float_4 = 1;
int int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
char char_3 = 1;
char char_4 = 1;
if(1)
{
}
if(1)
{
float float_2 = 1;
float_2 = float_1 + float_2;
}
if(1)
{
char_2 = char_1 * char_1;
}
short_1 = short_1 * short_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
float_4 = float_1 * float_3;
int_1 = v_stats_pool_reset(unsigned_int_2);
int_2 = int_1 * int_1;
v_array_swap(unsigned_int_2,char_2);
char_4 = char_1 * char_3;
}
char v_core_timeout_handle_common( unsigned int parameter_1,double parameter_2)
{
double double_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
double double_2 = 1;
long long_1 = 1;
int int_1 = 1;
int int_2 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
double_1 = v_core_close(short_1,unsigned_int_1);
char_1 = char_1;
double_2 = double_2 * double_1;
long_1 = long_1;
int_1 = int_1 * int_2;
v_msg_tmo_delete(short_2);
int_1 = int_1 * int_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
return char_2;
}
char v_core_timeout_handle_sentinel_reconn( char parameter_1,int parameter_2)
{
int int_1 = 1;
short short_1 = 1;
char char_1 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
int_1 = v_sentinel_connect(short_1);
char_1 = char_1 * char_1;
v_msg_tmo_delete(short_1);
long_2 = long_1 * long_1;
double_2 = double_1 + double_1;
int_1 = int_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
double_1 = double_1 * double_2;
unsigned_int_5 = unsigned_int_4 * unsigned_int_4;
return char_1;
}
double v_core_timeout_handle_sentinel_heartb( int parameter_1,unsigned int parameter_2)
{
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
long long_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_4 = 1;
double double_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_5 = 1;
long long_3 = 1;
long long_4 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
double double_2 = 1;
int int_1 = 1;
short short_2 = 1;
double double_3 = 1;
v_msg_tmo_delete(short_1);
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
char_1 = v_req_sentinel_send_heartbeat(long_1,long_1,-1 );
char_2 = char_2 * char_1;
unsigned_int_1 = unsigned_int_4 * unsigned_int_3;
long_1 = v_sentinel_conn(char_2);
double_1 = double_1 * double_1;
v_msg_timer(long_2,unsigned_int_4);
unsigned_int_4 = unsigned_int_5 + unsigned_int_5;
long_2 = long_3 * long_4;
float_3 = float_1 * float_2;
double_1 = double_1 * double_2;
if(1)
{
long long_5 = 1;
long_5 = long_1;
int_1 = v_sentinel_connect(short_1);
double_1 = double_1 + double_1;
}
short_2 = short_1;
return double_3;
}
short v_core_timeout_handle( int parameter_1,unsigned int parameter_2)
{
int int_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
char char_2 = 1;
short short_1 = 1;
char char_3 = 1;
double double_2 = 1;
int int_2 = 1;
int_1 = int_1 * int_1;
char_1 = v_core_timeout_handle_common(unsigned_int_1,double_1);
double_1 = double_1 * double_1;
unsigned_int_2 = unsigned_int_3;
unsigned_int_4 = unsigned_int_3 * unsigned_int_2;
char_2 = v_core_timeout_handle_sentinel_reconn(char_1,int_1);
short_1 = short_1 + short_1;
char_1 = char_2 * char_3;
return short_1;
double_2 = v_core_timeout_handle_sentinel_heartb(int_2,unsigned_int_2);
}
short v_msg_from_rbe( long parameter_1)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_1 = 1;
float_2 = float_1 * float_1;
int_1 = int_1 + int_2;
char_1 = char_2;
double_3 = double_1 * double_2;
return short_1;
}
char v_rbtree_min( int parameter_1)
{
char char_1 = 1;
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
v_rbtree_node_min(char_1,long_1);
double_2 = double_1 + double_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
}
return char_1;
}
unsigned int v_msg_tmo_min()
{
int int_1 = 1;
char char_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
long long_1 = 1;
int_1 = int_1 + int_1;
char_1 = v_rbtree_min(int_1);
double_1 = double_1;
if(1)
{
}
return unsigned_int_1;
short_1 = v_msg_from_rbe(long_1);
}
long v_core_timeout( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
long long_2 = 1;
short short_2 = 1;
short short_3 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_2 = 1;
long long_1 = 1;
int int_3 = 1;
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
int_2 = int_1 + int_2;
long_1 = long_1 * long_2;
if(1)
{
int_2 = int_1;
}
if(1)
{
long_2 = long_1;
int_1 = int_3;
}
float_2 = float_1 + float_1;
unsigned_int_1 = v_msg_tmo_min();
int_1 = int_1 * int_3;
if(1)
{
short short_1 = 1;
short short_4 = 1;
short_2 = short_1 * short_2;
short_1 = short_3 + short_4;
}
v_msg_tmo_delete(short_3);
short_2 = v_core_timeout_handle(int_1,unsigned_int_2);
double_1 = double_1 * double_2;
}
return long_2;
char_1 = v_nc_msec_now();
}
int v_event_wait( int parameter_1,int parameter_2)
{
double double_1 = 1;
long long_1 = 1;
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
double_1 = double_1 * double_1;
long_1 = long_1;
short_2 = short_1 + short_1;
if(1)
{
}
char_2 = char_1 + char_1;
int_1 = int_1 * int_1;
if(1)
{
short_1 = short_2 + short_2;
}
if(1)
{
float float_1 = 1;
float float_2 = 1;
double double_2 = 1;
short_2 = short_1;
float_1 = float_1 * float_2;
char_2 = char_1 + char_1;
double_4 = double_2 + double_3;
}
if(1)
{
int int_2 = 1;
int int_3 = 1;
int_2 = int_1 * int_1;
int_3 = int_1;
}
if(1)
{
long long_2 = 1;
long_2 = long_2;
}
if(1)
{
unsigned int unsigned_int_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
}
if(1)
{
double_1 = double_5;
}
double_3 = double_4 * double_5;
return int_1;
}
char v_core_loop( int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
char char_1 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
int int_3 = 1;
int int_4 = 1;
v_stats_swap(double_1);
double_2 = double_2 + double_2;
int_1 = v_event_wait(int_2,int_2);
long_1 = v_core_timeout(char_1);
double_3 = double_1 * double_1;
if(1)
{
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
int_3 = int_3 * int_4;
return char_1;
}
unsigned int v_mbuf_free()
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
double_3 = double_1 * double_2;
short_1 = short_1;
unsigned_int_1 = unsigned_int_2;
unsigned_int_3 = unsigned_int_3 * unsigned_int_1;
double_1 = double_2;
float_3 = float_1 + float_2;
return unsigned_int_2;
}
void v_mbuf_deinit()
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
int_1 = int_1 * int_1;
unsigned_int_1 = v_mbuf_free();
double_2 = double_1 + double_1;
v_mbuf_remove(double_1,short_1);
}
short v_msg_free( int parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_3 = unsigned_int_2 * unsigned_int_1;
short_1 = short_1 * short_2;
return short_1;
}
void v_msg_deinit()
{
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int_2 = int_1 + int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_2 = 1;
short short_3 = 1;
int int_3 = 1;
long long_1 = 1;
short_1 = v_msg_free(int_1);
short_1 = short_2 + short_3;
int_3 = int_2 + int_2;
long_1 = long_1 * long_1;
}
double_3 = double_1 * double_2;
}
long v_conn_free( int parameter_1)
{
char char_1 = 1;
int int_1 = 1;
long long_1 = 1;
char_1 = char_1 * char_1;
int_1 = int_1 + int_1;
return long_1;
}
void v_conn_deinit()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_1 = 1;
int int_1 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned_int_3 = unsigned_int_3 * unsigned_int_1;
unsigned_int_4 = unsigned_int_4 * unsigned_int_5;
long_1 = v_conn_free(int_1);
double_2 = double_1 * double_1;
}
unsigned_int_2 = unsigned_int_2 + unsigned_int_3;
}
float v_proxy_each_deinit()
{
double double_1 = 1;
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
double_1 = double_1 + double_1;
float_2 = float_1 * float_1;
int_1 = int_2;
if(1)
{
char char_1 = 1;
char_1 = char_1 + char_1;
}
return float_1;
}
void v_proxy_deinit( float parameter_1)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
int int_1 = 1;
double double_1 = 1;
short short_1 = 1;
long long_1 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
unsigned_int_1 = unsigned_int_1;
unsigned_int_1 = v_array_n(float_1);
float_1 = v_proxy_each_deinit();
int_1 = int_1 + int_1;
if(1)
{
}
double_1 = double_1;
short_1 = v_array_each(long_1);
}
unsigned int v_proxy_reuse( float parameter_1)
{
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
float float_1 = 1;
float float_2 = 1;
char char_2 = 1;
int int_4 = 1;
double_1 = double_1 * double_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_2 = unsigned_int_2 + unsigned_int_1;
char_1 = char_1 * char_1;
int_1 = int_1 * int_2;
int_3 = int_3;
float_2 = float_1 * float_2;
unsigned_int_3 = unsigned_int_3 + unsigned_int_2;
int_1 = v_nc_set_reuseaddr(int_1);
char_1 = char_2;
int_1 = int_4 * int_2;
return unsigned_int_2;
}
int v_proxy_listen( char parameter_1,double parameter_2)
{
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_3 = 1;
char char_2 = 1;
char char_3 = 1;
float float_2 = 1;
float float_3 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
long long_1 = 1;
int int_3 = 1;
short short_2 = 1;
short short_3 = 1;
int int_5 = 1;
short short_4 = 1;
int int_7 = 1;
double double_1 = 1;
int int_8 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
char_1 = char_1 * char_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
unsigned_int_1 = v_proxy_reuse(float_1);
unsigned_int_2 = unsigned_int_2 + unsigned_int_3;
char_2 = char_3;
if(1)
{
float_3 = float_1 * float_2;
}
int_2 = int_1 * int_1;
if(1)
{
int_2 = v_event_add_conn(short_1,long_1);
int_3 = v_event_del_out(short_1,int_2);
float_2 = float_2 * float_2;
}
short_1 = short_2 * short_1;
if(1)
{
int int_4 = 1;
int_3 = int_3 * int_4;
}
if(1)
{
short_1 = short_3 * short_1;
float_2 = float_2 + float_2;
if(1)
{
int int_6 = 1;
int_6 = int_1 * int_5;
}
}
float_1 = float_3 + float_2;
if(1)
{
short_4 = short_4 + short_3;
}
int_7 = v_nc_set_nonblocking(int_5);
double_1 = double_1 * double_1;
if(1)
{
int int_9 = 1;
int_8 = int_9;
}
int_7 = int_3 + int_1;
if(1)
{
int_1 = int_8;
}
double_4 = double_2 * double_3;
if(1)
{
short_3 = short_4 * short_2;
}
return int_3;
}
void v_proxy_unref()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_3 = int_1 + int_2;
short_2 = short_1 + short_1;
float_1 = float_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
long_3 = long_1 + long_2;
double_1 = double_1;
}
void v_proxy_ref( unsigned int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
int int_3 = 1;
long_1 = long_2;
int_2 = int_1 * int_1;
char_1 = char_1 * char_2;
double_2 = double_1 * double_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
unsigned_int_2 = unsigned_int_2 + unsigned_int_3;
unsigned_int_4 = unsigned_int_4 * unsigned_int_2;
unsigned_int_3 = unsigned_int_2 + unsigned_int_1;
int_3 = int_3 * int_1;
}
void v_proxy_close( int parameter_1,float parameter_2)
{
int int_1 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
long long_2 = 1;
long long_3 = 1;
float float_1 = 1;
float float_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_5 = 1;
int_1 = int_1 + int_1;
v_conn_put(long_1);
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
int int_4 = 1;
long_1 = long_1 * long_1;
int_4 = int_2 * int_3;
}
unsigned_int_1 = unsigned_int_2 + unsigned_int_3;
double_3 = double_1 * double_2;
long_3 = long_2 * long_1;
float_1 = float_1 * float_2;
short_1 = short_1 + short_1;
short_2 = short_2 * short_3;
if(1)
{
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
}
int_2 = int_3 + int_1;
int_3 = int_5 + int_2;
}
int v_nc_set_tcpkeepalive( int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
double_3 = double_1 + double_2;
return int_1;
}
void v_req_client_dequeue_omsgq( char parameter_1,unsigned int parameter_2,long parameter_3)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
long long_1 = 1;
double_3 = double_1 * double_2;
unsigned_int_1 = unsigned_int_1;
long_1 = long_1;
}
void v_req_client_enqueue_omsgq( double parameter_1,unsigned int parameter_2,long parameter_3)
{
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
double_1 = double_1 + double_2;
short_1 = short_1 * short_2;
double_1 = double_1 + double_1;
}
void v_client_unref( int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int_1 = int_1 + int_2;
double_1 = double_1 * double_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
long_1 = long_1 * long_2;
long_1 = long_2 * long_3;
char_1 = char_1;
double_1 = double_1 + double_1;
short_2 = short_1 * short_2;
short_3 = short_2 + short_3;
}
void v_client_ref( short parameter_1)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_3 = 1;
char char_3 = 1;
short short_1 = 1;
short short_2 = 1;
double double_4 = 1;
int_2 = int_1 + int_1;
float_2 = float_1 * float_1;
int_1 = int_1 * int_1;
char_2 = char_1 + char_1;
double_3 = double_1 + double_2;
int_2 = int_2 + int_3;
char_2 = char_3 * char_3;
char_3 = char_2 * char_3;
short_2 = short_1 + short_1;
double_4 = double_1;
}
char v_client_active( int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
long_2 = long_1 + long_1;
int_2 = int_1 * int_1;
if(1)
{
long_2 = long_2;
}
if(1)
{
int int_3 = 1;
int int_4 = 1;
int_4 = int_2 + int_3;
}
if(1)
{
double double_1 = 1;
double_1 = double_1;
}
short_2 = short_1 + short_2;
return char_1;
}
void v_client_close_stats( unsigned int parameter_1,unsigned int parameter_2,long parameter_3,double parameter_4)
{
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char_1 = char_1 * char_2;
if(1)
{
short short_1 = 1;
short_1 = short_1 + short_1;
}
double_1 = double_1 + double_2;
unsigned_int_1 = unsigned_int_2;
}
void v_client_close( unsigned int parameter_1,double parameter_2)
{
char char_1 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_2 = 1;
long long_1 = 1;
double double_5 = 1;
unsigned int unsigned_int_4 = 1;
int int_3 = 1;
unsigned int unsigned_int_5 = 1;
char char_2 = 1;
char char_3 = 1;
short short_2 = 1;
double double_6 = 1;
int int_5 = 1;
unsigned int unsigned_int_6 = 1;
char_1 = char_1 * char_1;
int_1 = int_1 + int_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
double_3 = double_1 * double_2;
if(1)
{
double double_4 = 1;
int_1 = int_2 * int_2;
v_conn_put(long_1);
double_4 = double_4 + double_5;
}
v_client_close_stats(unsigned_int_3,unsigned_int_4,long_1,double_2);
int_3 = int_2 * int_1;
if(1)
{
char char_4 = 1;
short short_1 = 1;
char char_5 = 1;
unsigned_int_5 = unsigned_int_4 + unsigned_int_1;
char_2 = char_2 * char_3;
char_4 = char_3 + char_3;
short_2 = short_1 * short_1;
char_4 = char_5;
}
double_6 = double_3 * double_2;
unsigned_int_2 = unsigned_int_4;
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_3 = 1;
short short_4 = 1;
short_4 = short_3 * short_2;
char_2 = char_1 * char_2;
if(1)
{
char char_6 = 1;
int_1 = int_1;
char_3 = char_6 + char_3;
}
if(1)
{
int int_4 = 1;
int_4 = int_3 + int_3;
int_5 = int_4 + int_5;
v_req_put(double_6);
int_1 = int_1 + int_1;
unsigned_int_3 = unsigned_int_5 + unsigned_int_5;
}
}
unsigned_int_4 = unsigned_int_1 + unsigned_int_6;
int_1 = int_5 * int_2;
unsigned_int_1 = unsigned_int_6 * unsigned_int_1;
if(1)
{
long long_2 = 1;
long long_3 = 1;
long_2 = long_2 * long_3;
}
double_5 = double_3 * double_5;
unsigned_int_6 = unsigned_int_3 * unsigned_int_2;
}
void v_rsp_send_done( long parameter_1,int parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
long long_4 = 1;
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
long_1 = long_1 * long_1;
long_1 = long_2 * long_2;
long_3 = long_2 * long_3;
v_req_put(double_1);
unsigned_int_2 = unsigned_int_3 + unsigned_int_4;
long_4 = long_2 * long_2;
unsigned_int_1 = unsigned_int_2 * unsigned_int_1;
char_2 = char_1 * char_2;
float_2 = float_1 * float_1;
unsigned_int_5 = unsigned_int_5 + unsigned_int_6;
}
void v_msg_get_error( float parameter_1,short parameter_2)
{
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_2 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_5 = 1;
double double_6 = 1;
char char_1 = 1;
int int_3 = 1;
int int_4 = 1;
long long_3 = 1;
int int_5 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
v_msg_put(long_1);
double_1 = double_1 * double_1;
long_1 = v_mbuf_size(double_2);
int_2 = int_1 * int_1;
short_1 = short_1 + short_2;
long_1 = long_2 + long_2;
double_4 = double_3 + double_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
if(1)
{
}
double_5 = double_2 + double_4;
double_6 = double_2 * double_2;
long_1 = long_1 * long_1;
if(1)
{
short_2 = v_mbuf_get();
v_mbuf_insert(int_2,char_1);
unsigned_int_1 = unsigned_int_2 * unsigned_int_1;
}
int_4 = int_2 + int_3;
long_3 = v__msg_get();
int_2 = int_2 * int_5;
short_2 = short_2;
unsigned_int_4 = unsigned_int_3 + unsigned_int_2;
short_2 = short_2;
}
unsigned int v_rsp_make_error( long parameter_1,int parameter_2,short parameter_3)
{
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
float float_2 = 1;
char char_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_4 = 1;
char char_5 = 1;
char char_6 = 1;
int int_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
double double_5 = 1;
unsigned int unsigned_int_6 = 1;
char_2 = char_1 + char_1;
float_2 = float_1 + float_1;
char_3 = char_3 + char_3;
unsigned_int_1 = unsigned_int_2;
double_2 = double_1 + double_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_3;
char_6 = char_4 * char_5;
int_1 = int_1;
if(1)
{
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_4 = 1;
double double_3 = 1;
double double_4 = 1;
float float_3 = 1;
unsigned_int_1 = unsigned_int_4;
v_rsp_put(short_1);
double_4 = double_1 + double_3;
if(1)
{
char_5 = char_2 * char_6;
}
unsigned_int_3 = v_req_error(short_2,float_1);
float_3 = float_2 + float_1;
}
}
if(1)
{
unsigned int unsigned_int_5 = 1;
unsigned_int_3 = unsigned_int_5 + unsigned_int_1;
}
short_3 = short_1;
if(1)
{
unsigned_int_3 = unsigned_int_2 * unsigned_int_2;
v_req_put(double_5);
v_msg_get_error(float_2,short_3);
char_3 = char_3 * char_4;
char_5 = char_3 + char_2;
short_3 = short_3;
}
return unsigned_int_6;
}
unsigned int v_req_error( short parameter_1,float parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
long long_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_5 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
unsigned_int_2 = unsigned_int_1;
short_1 = short_1;
long_1 = long_1 * long_1;
if(1)
{
}
int_3 = int_1 * int_2;
if(1)
{
}
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
if(1)
{
long long_3 = 1;
long_2 = long_3;
}
}
for(int looper_2=0; looper_2<1;looper_2++)
{
if(1)
{
long_2 = long_2 * long_1;
}
}
double_1 = double_1 + double_1;
int_3 = int_3 * int_2;
for(int looper_3=0; looper_3<1;looper_3++)
{
double double_4 = 1;
int_2 = v_req_done(double_2,long_2);
double_4 = double_1 * double_3;
double_2 = double_2 + double_4;
}
for(int looper_4=0; looper_4<1;looper_4++)
{
double_5 = double_2 + double_2;
short_1 = short_1 * short_1;
}
double_5 = double_3 * double_1;
return unsigned_int_2;
}
float v_rsp_send_next( char parameter_1,double parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
float float_2 = 1;
short short_3 = 1;
int int_2 = 1;
int int_3 = 1;
short short_4 = 1;
float float_3 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_4 = 1;
int int_4 = 1;
int int_5 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_5 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_6 = 1;
int int_6 = 1;
short short_5 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_1 = int_1;
short_2 = short_1 * short_1;
float_1 = float_2;
if(1)
{
if(1)
{
short_3 = short_3 + short_1;
int_2 = int_2 + int_1;
}
int_3 = v_event_del_out(short_1,int_2);
short_1 = short_2 * short_4;
if(1)
{
unsigned_int_2 = v_req_error(short_3,float_3);
double_1 = double_1 + double_2;
}
}
short_2 = short_2 * short_3;
if(1)
{
short_1 = short_3 + short_2;
unsigned_int_4 = unsigned_int_1 * unsigned_int_3;
double_2 = double_2;
}
char controller_5[3];
fgets(controller_5 ,3 ,stdin);
if( strcmp( controller_5, "1)") < 0)
{
unsigned_int_2 = unsigned_int_3 + unsigned_int_1;
}
int_5 = int_3 * int_4;
if(1)
{
double double_3 = 1;
double_3 = double_1 * double_2;
if(1)
{
long_2 = long_1 + long_2;
}
double_3 = double_2 * double_1;
short_3 = short_4 * short_4;
int_5 = v_req_done(double_2,long_2);
unsigned_int_2 = unsigned_int_5 * unsigned_int_2;
}
if(1)
{
unsigned_int_1 = unsigned_int_2 + unsigned_int_3;
}
unsigned_int_5 = unsigned_int_4 + unsigned_int_4;
char_2 = char_1 + char_1;
unsigned_int_6 = v_rsp_make_error(long_1,int_6,short_5);
float_3 = float_3;
return float_2;
}
unsigned int v_req_forward_stats( char parameter_1,float parameter_2,char parameter_3)
{
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
double_1 = double_1;
double_1 = double_1 + double_1;
short_2 = short_1 * short_1;
return unsigned_int_1;
}
long v_server_pool_server( int parameter_1,float parameter_2,int parameter_3)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
double double_3 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_2 = 1;
double double_4 = 1;
double double_5 = 1;
double_2 = double_1 + double_2;
int_1 = int_1 + int_1;
double_3 = double_3;
long_1 = v_array_get(long_2,char_1);
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_1 = v_server_pool_idx(double_3,char_2,int_1);
double_5 = double_4 * double_4;
return long_1;
}
int v_server_pool_conn( short parameter_1,char parameter_2,int parameter_3,double parameter_4,int uni_para)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
float float_1 = 1;
double double_5 = 1;
int int_3 = 1;
char char_1 = 1;
char char_2 = 1;
int_1 = int_2;
double_2 = double_1 + double_2;
double_3 = double_3 * double_4;
char controller4vul_2077[3];
fgets(controller4vul_2077 ,3 ,stdin);
if( strcmp( controller4vul_2077, "ur") < 0)
{
float_1 = v_server_conn(int_2,uni_para);
double_2 = double_3 + double_5;
}
double_5 = double_5 + double_1;
if(1)
{
}
int_1 = int_1 * int_3;
if(1)
{
}
char_1 = char_2;
if(1)
{
double_3 = double_1;
}
return int_2;
}
long v_req_forward( float parameter_1,int parameter_2,double parameter_3,int uni_para)
{
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
short short_2 = 1;
double double_3 = 1;
int int_3 = 1;
double double_4 = 1;
double double_5 = 1;
long long_1 = 1;
unsigned int unsigned_int_4 = 1;
int_1 = int_1 + int_1;
double_2 = double_1 * double_2;
char_2 = char_1 * char_1;
unsigned_int_1 = unsigned_int_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
int_2 = int_2 + int_2;
if(1)
{
unsigned_int_3 = unsigned_int_3 * unsigned_int_2;
}
short_2 = short_1 * short_1;
double_1 = double_3 * double_2;
int_3 = int_1 + int_2;
double_4 = double_3 + double_2;
double_3 = double_3 + double_5;
if(1)
{
short_2 = short_2 * short_2;
}
long_1 = long_1 + long_1;
char controller4vul_2075[3];
fgets(controller4vul_2075 ,3 ,stdin);
if( strcmp( controller4vul_2075, "qA") < 0)
{
int_1 = int_3;
char controller4vul_2076[2];
fgets(controller4vul_2076 ,2 ,stdin);
if( strcmp( controller4vul_2076, "G") < 0)
{
char char_3 = 1;
int_3 = v_server_pool_conn(short_2,char_2,int_3,double_3,uni_para);
char_3 = char_2 + char_1;
double_2 = double_3 + double_4;
}
}
if(1)
{
int int_4 = 1;
int int_5 = 1;
int_5 = int_4 + int_2;
if(1)
{
int int_6 = 1;
unsigned_int_2 = unsigned_int_2 + unsigned_int_3;
int_6 = int_4;
}
}
char_2 = char_2;
unsigned_int_4 = unsigned_int_1;
double_1 = double_3 + double_4;
return long_1;
}
long v_req_forward_error( int parameter_1,long parameter_2,unsigned int parameter_3)
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
float float_1 = 1;
float float_2 = 1;
int int_3 = 1;
int_1 = v_event_add_out(unsigned_int_1,short_1);
int_2 = int_1 + int_1;
long_1 = long_1 + long_2;
double_2 = double_1 * double_1;
int_2 = v_req_done(double_3,long_2);
float_2 = float_1 + float_1;
short_1 = short_1;
v_req_put(double_2);
int_3 = int_1 * int_1;
if(1)
{
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
}
if(1)
{
int_1 = int_1 + int_1;
if(1)
{
int int_4 = 1;
int_4 = int_4 + int_4;
}
}
return long_1;
}
float v_req_make_reply( int parameter_1,int parameter_2,float parameter_3)
{
short short_1 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
char char_3 = 1;
double double_1 = 1;
double double_2 = 1;
long long_3 = 1;
int int_3 = 1;
int int_4 = 1;
float float_1 = 1;
short_1 = short_1 + short_1;
int_1 = int_2;
if(1)
{
long_2 = long_1 + long_1;
}
unsigned_int_1 = v_msg_get(char_1,char_1,-1 );
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
char_2 = char_3;
double_1 = double_1 * double_2;
long_2 = long_3 * long_1;
int_2 = int_3 * int_4;
return float_1;
}
float v_req_filter( float parameter_1,float parameter_2,char parameter_3)
{
float float_1 = 1;
float float_2 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
float float_4 = 1;
short short_1 = 1;
float_1 = float_1 * float_2;
if(1)
{
double double_2 = 1;
float float_3 = 1;
char_1 = char_1;
float_1 = v_conn_authenticated(char_2);
double_2 = double_1 + double_2;
v_req_put(double_1);
float_3 = float_2 + float_1;
}
if(1)
{
unsigned int unsigned_int_1 = 1;
double double_3 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
char_1 = char_1 * char_1;
if(1)
{
unsigned_int_1 = unsigned_int_1;
}
double_1 = double_1 + double_3;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
int_1 = int_1;
}
if(1)
{
double double_4 = 1;
double_4 = double_1 + double_1;
}
return float_4;
short_1 = v_msg_empty(char_1);
}
void v_req_recv_done( short parameter_1,double parameter_2,short parameter_3,char parameter_4,int uni_para)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
float float_1 = 1;
float float_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
int int_4 = 1;
int int_5 = 1;
int int_6 = 1;
short short_3 = 1;
long long_1 = 1;
double double_6 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_3 = 1;
int_2 = int_1 * int_1;
int_2 = int_3 * int_1;
char_1 = char_1 + char_1;
float_2 = float_1 + float_1;
short_2 = short_1 * short_2;
float_1 = float_1;
double_3 = double_1 + double_2;
double_5 = double_4 + double_1;
int_3 = int_4 * int_2;
int_1 = int_1;
int_6 = int_5 * int_6;
if(1)
{
}
char controller4vul_2073[2];
fgets(controller4vul_2073 ,2 ,stdin);
if( strcmp( controller4vul_2073, "d") > 0)
{
short_3 = short_2 * short_3;
char controller4vul_2074[2];
fgets(controller4vul_2074 ,2 ,stdin);
if( strcmp( controller4vul_2074, "=") > 0)
{
long_1 = v_req_forward(float_1,int_4,double_6,uni_para);
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
}
unsigned_int_1 = unsigned_int_2 * unsigned_int_1;
if(1)
{
int int_7 = 1;
int_7 = int_5 + int_1;
}
int_6 = int_1 + int_1;
if(1)
{
double_6 = double_2;
}
}
long_1 = long_2 + long_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_3;
short_2 = short_3 * short_1;
if(1)
{
if(1)
{
double double_7 = 1;
double_7 = double_5;
}
double_6 = double_3;
}
if(1)
{
float float_4 = 1;
float_4 = float_3 + float_4;
}
unsigned_int_3 = unsigned_int_3;
if(1)
{
char char_2 = 1;
if(1)
{
int_3 = int_1 * int_5;
}
char_1 = char_2 + char_1;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_3 = 1;
char char_4 = 1;
double double_8 = 1;
unsigned_int_2 = unsigned_int_1;
char_4 = char_3 * char_1;
double_3 = double_3 + double_8;
}
float_2 = float_3 * float_3;
}
char v_req_get()
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
float float_4 = 1;
int int_1 = 1;
float_3 = float_1 + float_2;
unsigned_int_1 = v_msg_get(char_1,char_1,-1 );
float_4 = float_1 + float_4;
int_1 = int_1;
if(1)
{
double double_1 = 1;
double double_2 = 1;
double_2 = double_1 + double_1;
}
return char_1;
}
char v_req_recv_next( char parameter_1,double parameter_2,double parameter_3)
{
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
int int_3 = 1;
float float_1 = 1;
int int_5 = 1;
char char_3 = 1;
char char_4 = 1;
v_req_put(double_1);
short_2 = short_1 * short_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
if(1)
{
double double_2 = 1;
double_2 = double_2;
if(1)
{
unsigned int unsigned_int_3 = 1;
double double_3 = 1;
double double_4 = 1;
int_1 = int_1 * int_2;
unsigned_int_2 = unsigned_int_3 * unsigned_int_2;
char_1 = v_req_get();
int_3 = int_3;
double_3 = double_4;
float_1 = float_1 * float_1;
}
if(1)
{
int int_4 = 1;
char char_2 = 1;
int_4 = int_3 + int_2;
char_2 = char_1 + char_1;
}
}
int_1 = int_5;
if(1)
{
float_1 = float_1 + float_1;
}
if(1)
{
}
char_1 = char_1 + char_3;
if(1)
{
int_3 = int_2 * int_3;
}
return char_4;
}
long v_conn_get_client(int uni_para)
{
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_2 = 1;
double double_1 = 1;
short short_3 = 1;
char char_1 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
char char_2 = 1;
char char_3 = 1;
double double_2 = 1;
char char_4 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
short short_4 = 1;
unsigned int unsigned_int_5 = 1;
int int_3 = 1;
short short_5 = 1;
unsigned int unsigned_int_6 = 1;
short short_6 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
short_1 = short_1 + short_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
char controller4vul_2072[3];
fgets(controller4vul_2072 ,3 ,stdin);
if( strcmp( controller4vul_2072, "w{") < 0)
{
v_req_recv_done(short_2,double_1,short_3,char_1,uni_para);
}
unsigned_int_3 = unsigned_int_2 + unsigned_int_1;
unsigned_int_3 = unsigned_int_4 + unsigned_int_3;
char_1 = char_2;
char_2 = char_3 + char_2;
unsigned_int_1 = unsigned_int_2 * unsigned_int_4;
double_2 = double_1 * double_2;
char_2 = char_4 * char_4;
double_3 = double_1 + double_2;
int_1 = int_1 + int_2;
short_4 = short_1 * short_2;
short_2 = short_4 + short_3;
unsigned_int_4 = unsigned_int_4;
unsigned_int_4 = unsigned_int_5;
int_2 = int_1 + int_3;
int_3 = int_2;
int_1 = int_1 * int_2;
short_3 = short_5 * short_4;
unsigned_int_1 = unsigned_int_6 + unsigned_int_6;
short_4 = short_6 * short_1;
float_1 = float_1 + float_2;
return long_1;
}
double v_conn_ncurr_cconn()
{
double double_1 = 1;
return double_1;
}
long v_proxy_accept( int parameter_1,unsigned int parameter_2,int uni_para)
{
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
int int_5 = 1;
unsigned int unsigned_int_3 = 1;
double double_5 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
int int_6 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
int int_7 = 1;
int int_8 = 1;
double double_6 = 1;
unsigned int unsigned_int_6 = 1;
short_3 = short_1 * short_2;
float_1 = float_1;
double_2 = double_1 + double_1;
double_4 = double_3 * double_4;
char_1 = char_2;
char_1 = char_1 + char_2;
int_2 = int_1 * int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
char controller4vul_2070[2];
fgets(controller4vul_2070 ,2 ,stdin);
if( strcmp( controller4vul_2070, "<") > 0)
{
char controller4vul_2071[3];
fgets(controller4vul_2071 ,3 ,stdin);
if( strcmp( controller4vul_2071, "BH") < 0)
{
int int_3 = 1;
long_1 = v_conn_get_client(uni_para);
int_2 = int_3 * int_3;
short_2 = short_3 + short_3;
}
if(1)
{
int int_4 = 1;
int_1 = int_4 + int_5;
double_4 = double_1 + double_3;
}
if(1)
{
double_4 = double_3 * double_3;
unsigned_int_3 = unsigned_int_3 + unsigned_int_1;
}
double_5 = double_1 + double_2;
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_4;
}
if(1)
{
float float_2 = 1;
float_1 = float_2 * float_1;
unsigned_int_4 = unsigned_int_3 + unsigned_int_3;
if(1)
{
long_1 = long_1 * long_1;
}
}
if(1)
{
int_2 = int_5 + int_2;
unsigned_int_5 = unsigned_int_5 + unsigned_int_4;
if(1)
{
int_6 = int_1;
}
}
long_4 = long_2 + long_3;
if(1)
{
short_2 = short_3;
long_3 = long_4 * long_4;
if(1)
{
unsigned_int_5 = unsigned_int_2;
}
}
int_8 = int_6 + int_7;
double_6 = double_2 * double_3;
double_6 = double_5 + double_6;
if(1)
{
char char_3 = 1;
double_5 = double_5 * double_3;
char_3 = char_1 + char_3;
}
if(1)
{
double_1 = double_6 + double_3;
if(1)
{
char_2 = char_1 * char_2;
}
}
if(1)
{
unsigned_int_5 = unsigned_int_4 * unsigned_int_5;
if(1)
{
unsigned_int_5 = unsigned_int_4 + unsigned_int_4;
}
}
unsigned_int_1 = unsigned_int_5 * unsigned_int_6;
if(1)
{
unsigned int unsigned_int_7 = 1;
double_5 = double_4 * double_5;
unsigned_int_1 = unsigned_int_1 + unsigned_int_7;
}
unsigned_int_5 = unsigned_int_1;
return long_4;
}
float v_proxy_recv( short parameter_1,float parameter_2,int uni_para)
{
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
long long_2 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
short short_1 = 1;
short short_2 = 1;
char char_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
long long_3 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
float float_3 = 1;
char_2 = char_1 * char_1;
char_2 = char_1 * char_1;
char controller4vul_2069[3];
fgets(controller4vul_2069 ,3 ,stdin);
if( strcmp( controller4vul_2069, " t") < 0)
{
long_1 = v_proxy_accept(int_1,unsigned_int_1,uni_para);
}
if(1)
{
}
long_2 = long_2;
int_4 = int_2 + int_3;
short_1 = short_2;
if(1)
{
char_2 = char_3 * char_2;
}
if(1)
{
float float_1 = 1;
float float_2 = 1;
float_2 = float_1 * float_2;
}
double_2 = double_1 * double_1;
int_2 = int_2;
char_3 = char_3;
double_1 = double_1 * double_3;
long_3 = long_2 * long_2;
long_2 = long_2 + long_2;
unsigned_int_3 = unsigned_int_2 + unsigned_int_1;
double_2 = double_3 + double_1;
double_4 = double_1 * double_1;
return float_3;
}
long v_conn_get_proxy(int uni_para)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
short short_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_4 = 1;
long long_1 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
unsigned int unsigned_int_5 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
double double_3 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
double_1 = double_1 + double_2;
char controller4vul_2068[2];
fgets(controller4vul_2068 ,2 ,stdin);
if( strcmp( controller4vul_2068, "q") > 0)
{
float_1 = v_proxy_recv(short_1,float_2,uni_para);
}
unsigned_int_3 = unsigned_int_4 * unsigned_int_4;
unsigned_int_3 = unsigned_int_2;
long_1 = long_1;
char_3 = char_1 * char_2;
unsigned_int_4 = unsigned_int_5;
long_2 = long_1;
long_1 = long_1 + long_1;
unsigned_int_1 = unsigned_int_2 + unsigned_int_3;
unsigned_int_4 = unsigned_int_2 + unsigned_int_1;
double_2 = double_2 + double_1;
short_1 = short_1 * short_1;
long_1 = long_2 + long_1;
long_1 = long_1 * long_1;
int_2 = int_1 + int_1;
int_3 = int_4;
double_3 = double_2 + double_3;
unsigned_int_1 = unsigned_int_5 + unsigned_int_1;
return long_2;
}
double v_proxy_each_init(int uni_para)
{
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
float_2 = float_1 + float_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
long_1 = long_1;
char_1 = char_1 * char_2;
char controller4vul_2067[3];
fgets(controller4vul_2067 ,3 ,stdin);
if( strcmp( controller4vul_2067, "_&") > 0)
{
long_1 = v_conn_get_proxy(uni_para);
}
int_1 = int_1 * int_2;
if(1)
{
int int_3 = 1;
int_1 = int_3 + int_3;
}
char_2 = char_2 * char_1;
return double_1;
}
float v_proxy_init( short parameter_1,int uni_para)
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
unsigned_int_1 = unsigned_int_1;
char_2 = char_1 * char_2;
int_1 = int_1 + int_1;
char controller4vul_2066[3];
fgets(controller4vul_2066 ,3 ,stdin);
if( strcmp( controller4vul_2066, "|y") < 0)
{
char char_3 = 1;
double_1 = v_proxy_each_init(uni_para);
char_2 = char_2 * char_3;
}
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
return float_1;
}
void v_event_base_destroy()
{
short short_1 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
short_1 = short_1;
double_2 = double_1 * double_1;
unsigned_int_1 = unsigned_int_1;
}
float v_server_each_disconnect()
{
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
double_1 = double_2;
char_1 = char_1;
int_1 = int_1 + int_2;
int_2 = int_2 + int_2;
return float_1;
}
void v_server_pool_each_disconnect()
{
long long_1 = 1;
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
char char_2 = 1;
int int_3 = 1;
float float_1 = 1;
short short_1 = 1;
long long_2 = 1;
long_1 = long_1 * long_1;
int_1 = int_1 * int_2;
char_1 = char_2;
int_3 = int_3 * int_3;
float_1 = v_server_each_disconnect();
short_1 = v_array_each(long_2);
int_2 = int_3 * int_1;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if(remainder_check(controller_1,100,1))
{
}
}
void v_server_pool_disconnect( int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
long long_1 = 1;
v_server_pool_each_disconnect();
int_2 = int_1 * int_1;
short_1 = v_array_each(long_1);
}
long v_req_sentinel_send_get_master_addr( short parameter_1,unsigned int parameter_2)
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_2 = 1;
long long_3 = 1;
char char_1 = 1;
int int_3 = 1;
short short_2 = 1;
double double_3 = 1;
char char_2 = 1;
char char_3 = 1;
float float_1 = 1;
char char_4 = 1;
int_1 = v_event_add_out(unsigned_int_1,short_1);
double_2 = double_1 + double_2;
long_1 = long_2;
int_1 = int_1 + int_1;
int_2 = int_1 * int_2;
long_3 = v_array_get(long_1,char_1);
double_1 = double_2 + double_1;
int_3 = v_msg_prepend_format(int_2,long_2,short_2);
double_3 = double_2 * double_3;
double_3 = double_3;
char_2 = char_1 * char_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
float float_3 = 1;
char_1 = char_3 * char_3;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
if(1)
{
char_1 = char_1 * char_3;
}
v_msg_put(long_1);
int_3 = int_3 * int_1;
if(1)
{
unsigned_int_1 = v_array_n(float_1);
char_3 = char_3 * char_4;
double_1 = double_2 + double_2;
}
if(1)
{
unsigned_int_2 = unsigned_int_2 + unsigned_int_2;
if(1)
{
unsigned_int_1 = v_msg_get(char_4,char_3,-1 );
double_3 = double_3 * double_3;
unsigned_int_2 = unsigned_int_2;
unsigned_int_2 = unsigned_int_2 * unsigned_int_2;
}
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_3;
float_3 = float_2 + float_2;
}
return long_1;
}
short v_sentinel_swallow_recv_pub( double parameter_1,unsigned int parameter_2,double parameter_3)
{
double double_1 = 1;
long long_1 = 1;
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
float float_2 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
long long_3 = 1;
long long_4 = 1;
unsigned int unsigned_int_5 = 1;
char char_3 = 1;
short short_3 = 1;
unsigned int unsigned_int_6 = 1;
long long_5 = 1;
double double_5 = 1;
double double_6 = 1;
char char_4 = 1;
char char_5 = 1;
short short_4 = 1;
int int_4 = 1;
unsigned int unsigned_int_9 = 1;
int int_5 = 1;
int int_6 = 1;
char char_7 = 1;
short short_6 = 1;
double_1 = double_1 * double_1;
long_1 = long_1;
char_2 = char_1 + char_2;
float_2 = float_1 + float_1;
short_2 = short_1 * short_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
long_2 = long_2;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
int_3 = int_1 + int_2;
double_3 = double_2 * double_2;
int_2 = int_1 + int_1;
double_4 = double_1 + double_1;
unsigned_int_2 = unsigned_int_3 + unsigned_int_4;
short_2 = short_1;
long_2 = long_3 * long_4;
unsigned_int_5 = v_array_n(float_1);
char_3 = char_2 + char_2;
char_2 = char_1 * char_3;
long_3 = long_3 + long_3;
double_4 = double_4 + double_3;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned_int_5 = unsigned_int_1;
if(1)
{
double_4 = double_3 * double_2;
}
if(1)
{
float float_3 = 1;
float_3 = float_2;
}
if(1)
{
int_2 = int_1 + int_3;
}
if(1)
{
short_1 = short_3 + short_2;
}
if(1)
{
unsigned_int_3 = unsigned_int_6 + unsigned_int_6;
}
if(1)
{
int_1 = int_2 * int_2;
}
long_5 = long_3;
}
if(1)
{
unsigned int unsigned_int_7 = 1;
unsigned int unsigned_int_8 = 1;
unsigned_int_8 = unsigned_int_2 * unsigned_int_7;
}
if(1)
{
long_4 = long_4 * long_1;
}
double_3 = double_5 * double_6;
char_4 = char_1 * char_1;
long_3 = v_array_get(long_1,char_5);
short_4 = short_1 + short_1;
double_3 = double_6 * double_4;
int_4 = int_1 * int_3;
for(int looper_2=0; looper_2<1;looper_2++)
{
short short_5 = 1;
char char_6 = 1;
short_4 = short_2 * short_5;
if(1)
{
unsigned_int_6 = unsigned_int_3 + unsigned_int_2;
}
char_6 = char_4 + char_3;
if(1)
{
double_3 = double_2 * double_6;
}
if(1)
{
unsigned_int_2 = unsigned_int_1 * unsigned_int_3;
}
if(1)
{
double double_7 = 1;
double_7 = double_2 + double_6;
}
if(1)
{
unsigned_int_9 = unsigned_int_9 + unsigned_int_6;
}
short_2 = short_3 * short_2;
}
unsigned_int_5 = unsigned_int_3 * unsigned_int_9;
unsigned_int_3 = unsigned_int_3;
for(int looper_3=0; looper_3<1;looper_3++)
{
int_3 = int_4 * int_2;
if(1)
{
int int_7 = 1;
int_6 = int_1 * int_5;
int_7 = int_5 + int_4;
}
}
if(1)
{
char_7 = char_3;
}
int_3 = int_5 * int_6;
char_5 = char_7 * char_7;
if(1)
{
short_4 = v_server_reset(double_1,char_7,long_5);
char_4 = char_4 + char_1;
}
int_5 = int_5;
float_1 = float_1 + float_1;
return short_6;
}
char v_sentinel_swallow_psub_pub( int parameter_1,char parameter_2,int parameter_3)
{
long long_1 = 1;
short short_1 = 1;
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
long long_2 = 1;
long long_3 = 1;
short short_2 = 1;
short short_3 = 1;
char char_3 = 1;
float float_2 = 1;
float float_3 = 1;
double double_4 = 1;
short short_4 = 1;
unsigned int unsigned_int_1 = 1;
long_1 = v_sentinel_swallow_psub_rsp(short_1,float_1,long_1);
char_2 = char_1 + char_1;
double_2 = double_1 + double_1;
long_3 = long_2 + long_2;
short_3 = short_2 + short_2;
char_1 = char_2 * char_3;
float_3 = float_2 + float_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
double double_3 = 1;
double double_5 = 1;
double_4 = double_1 + double_3;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "j4") > 0)
{
float_2 = float_2 * float_2;
}
if(1)
{
char_3 = char_3 * char_2;
if(1)
{
}
if(1)
{
}
if(1)
{
double_2 = double_1 * double_2;
double_2 = double_3;
}
}
short_4 = v_sentinel_swallow_recv_pub(double_1,unsigned_int_1,double_4);
double_5 = double_1 + double_3;
}
return char_3;
}
long v_sentinel_swallow_psub_rsp( short parameter_1,float parameter_2,long parameter_3)
{
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
int int_4 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
short short_4 = 1;
char char_2 = 1;
long long_3 = 1;
float_1 = float_1 * float_1;
double_3 = double_1 + double_2;
v_msg_timer(long_1,unsigned_int_1);
long_1 = long_1 + long_2;
short_1 = short_2;
short_1 = short_3 * short_3;
int_1 = int_1;
int_3 = int_1 + int_2;
char_1 = char_1 + char_1;
int_4 = int_1 + int_4;
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
short_1 = short_2 + short_1;
int_4 = int_2 + int_4;
v_msg_tmo_delete(short_3);
unsigned_int_3 = unsigned_int_4 * unsigned_int_4;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_5 = 1;
int_2 = int_1 + int_1;
if(1)
{
short_2 = short_2 * short_4;
}
if(1)
{
unsigned_int_5 = unsigned_int_5 + unsigned_int_4;
}
if(1)
{
int_2 = int_4 + int_1;
}
unsigned_int_5 = unsigned_int_1;
}
char_1 = char_1 + char_2;
if(1)
{
short_4 = short_4 * short_3;
}
if(1)
{
int int_5 = 1;
int_1 = int_4 + int_5;
}
if(1)
{
short_2 = short_1 + short_3;
}
if(1)
{
char char_3 = 1;
short short_5 = 1;
short short_6 = 1;
long_3 = long_1 + long_1;
char_3 = char_3 + char_2;
short_6 = short_5 * short_4;
short_3 = short_4 * short_6;
char_2 = char_2 + char_3;
}
return long_3;
}
short v_redis_add_role( short parameter_1,int parameter_2)
{
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_1 = 1;
short short_2 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
int int_3 = 1;
long long_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_2 = 1;
char char_3 = 1;
double double_5 = 1;
int int_4 = 1;
char_1 = char_2;
int_1 = int_2;
double_3 = double_1 + double_2;
short_2 = short_1 * short_1;
int_1 = int_2 * int_1;
double_2 = double_4;
unsigned_int_1 = v_msg_get(char_2,char_2,-1 );
int_3 = v_msg_prepend_format(int_3,long_1,short_1);
unsigned_int_1 = unsigned_int_2 * unsigned_int_2;
if(1)
{
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned_int_2 = unsigned_int_3 * unsigned_int_4;
}
int_2 = int_2 + int_1;
if(1)
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
v_msg_put(long_2);
float_3 = float_1 + float_2;
}
char_1 = char_2 * char_3;
char_3 = char_1;
double_2 = double_5;
int_4 = int_3 * int_3;
return short_2;
}
short v_req_server_send_role( short parameter_1,long parameter_2)
{
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_3 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_4 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
char char_2 = 1;
double_1 = double_1 * double_1;
if(1)
{
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
if(1)
{
short_1 = v_redis_add_role(short_2,int_1);
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
}
}
if(1)
{
short_3 = v_redis_add_auth(unsigned_int_3,char_1,double_2);
unsigned_int_4 = unsigned_int_1 + unsigned_int_3;
if(1)
{
unsigned int unsigned_int_5 = 1;
short short_4 = 1;
unsigned_int_5 = unsigned_int_4 * unsigned_int_1;
short_1 = short_4 * short_2;
}
}
int_1 = v_event_add_out(unsigned_int_2,short_2);
long_2 = long_1 * long_1;
if(1)
{
long long_3 = 1;
unsigned_int_3 = unsigned_int_4 + unsigned_int_4;
long_3 = long_1 + long_2;
}
return short_2;
float_1 = v_conn_authenticated(char_2);
}
int v_event_add_conn( short parameter_1,long parameter_2)
{
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
long long_1 = 1;
char char_2 = 1;
int int_3 = 1;
short short_1 = 1;
char char_5 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_4 = 1;
double_2 = double_1 + double_2;
char_1 = char_1 * char_1;
long_1 = long_1;
if(1)
{
int int_1 = 1;
int int_2 = 1;
char char_3 = 1;
int int_4 = 1;
double double_3 = 1;
int int_5 = 1;
char_1 = char_1 + char_2;
int_1 = int_2;
int_3 = int_2 + int_1;
char_2 = char_1 * char_3;
int_1 = int_4 * int_2;
double_1 = double_3;
double_1 = double_1 * double_1;
short_1 = short_1 * short_1;
int_2 = int_2 * int_2;
if(1)
{
for(int looper_1=0; looper_1<1;looper_1++)
{
int_3 = int_5 * int_3;
}
}
if(1)
{
int_3 = int_4;
}
if(1)
{
char char_4 = 1;
char_5 = char_4 * char_4;
}
short_2 = short_1 + short_1;
if(1)
{
long long_2 = 1;
int int_6 = 1;
char char_6 = 1;
char char_7 = 1;
long_2 = long_2 + long_1;
int_6 = int_5 + int_4;
char_5 = char_1;
char_7 = char_6 * char_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
}
unsigned_int_2 = unsigned_int_3 + unsigned_int_2;
}
if(1)
{
float_1 = float_1 + float_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_3;
float_2 = float_1 * float_2;
float_2 = float_1 * float_1;
char_1 = char_2 * char_5;
}
if(1)
{
short_1 = short_1 + short_2;
float_2 = float_1 + float_2;
double_2 = double_1;
short_1 = short_2 + short_1;
double_1 = double_2 + double_2;
}
if(1)
{
short short_3 = 1;
short short_4 = 1;
short_4 = short_3 + short_3;
}
unsigned_int_2 = unsigned_int_4 + unsigned_int_3;
return int_3;
}
int v_nc_set_tcpnodelay( int parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
int int_1 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
unsigned_int_3 = unsigned_int_1;
float_2 = float_1 * float_1;
double_1 = double_1;
return int_1;
}
int v_nc_set_nonblocking( int parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
unsigned_int_1 = unsigned_int_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
}
return int_1;
}
float v_server_connect( float parameter_1,double parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_3 = 1;
double double_4 = 1;
float float_3 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
long_2 = long_1 * long_2;
if(1)
{
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
float_2 = float_1 + float_2;
}
if(1)
{
}
double_1 = double_1;
int_2 = int_1 * int_2;
if(1)
{
double_1 = double_1 * double_2;
double_1 = double_1;
int_1 = int_1 + int_1;
}
short_2 = short_1 * short_1;
if(1)
{
char char_1 = 1;
int_1 = v_nc_set_nonblocking(int_1);
char_1 = char_1 + char_1;
double_2 = double_3;
}
if(1)
{
unsigned_int_1 = unsigned_int_1;
if(1)
{
long long_3 = 1;
long_1 = long_2 + long_3;
}
}
int_2 = int_1 * int_2;
if(1)
{
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
double_2 = double_4 * double_2;
char_4 = char_2 * char_3;
}
float_3 = float_3;
double_2 = double_1 * double_3;
if(1)
{
double double_5 = 1;
if(1)
{
double_4 = double_2 * double_1;
int_1 = v_nc_set_tcpnodelay(int_1);
int_2 = int_3 * int_2;
}
double_5 = double_3 * double_1;
int_1 = int_1 * int_1;
}
unsigned_int_2 = unsigned_int_3 + unsigned_int_1;
int_3 = v_event_add_conn(short_2,long_1);
float_3 = float_3 + float_3;
float_2 = float_1 * float_2;
int_3 = int_2;
return float_3;
}
char v_req_sentinel_send_heartbeat( long parameter_1,long parameter_2,int uni_para)
{
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
char char_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_3 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_4 = 1;
double double_4 = 1;
char char_7 = 1;
char_1 = char_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
double_3 = double_1 * double_2;
char_1 = char_2 * char_2;
unsigned_int_3 = unsigned_int_2;
if(1)
{
char_3 = char_3 * char_3;
}
long_2 = long_1 + long_2;
if(1)
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
float_3 = float_1 * float_2;
long_1 = long_1 * long_2;
}
char controller4vul_2084[2];
fgets(controller4vul_2084 ,2 ,stdin);
if( strcmp( controller4vul_2084, "}") < 0)
{
char char_4 = 1;
char_3 = char_1 * char_4;
char controller4vul_2085[2];
fgets(controller4vul_2085 ,2 ,stdin);
if( strcmp( controller4vul_2085, "E") < 0)
{
char char_5 = 1;
float float_4 = 1;
float float_5 = 1;
char char_6 = 1;
unsigned_int_4 = v_msg_get(char_1,char_2,uni_para);
char_4 = char_2 * char_5;
float_4 = float_5;
char_6 = char_2 * char_2;
}
}
double_4 = double_4 + double_4;
unsigned_int_1 = unsigned_int_2 + unsigned_int_4;
return char_7;
}
void v_server_swallow_role_rsp( unsigned int parameter_1,short parameter_2,int uni_para)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_3 = 1;
int int_4 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
unsigned int unsigned_int_2 = 1;
float float_2 = 1;
float float_4 = 1;
float float_5 = 1;
short short_1 = 1;
int_2 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
char_2 = char_1 + char_2;
int_2 = int_2 + int_3;
int_2 = int_4 * int_1;
double_1 = double_1 + double_2;
double_3 = double_1 + double_2;
double_4 = double_4 + double_4;
long_1 = long_2;
int_2 = int_1;
if(1)
{
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
}
double_1 = double_4 + double_3;
long_3 = long_3 + long_3;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
if(1)
{
float float_1 = 1;
float float_3 = 1;
float_3 = float_1 * float_2;
}
int_3 = int_1 + int_1;
}
float_4 = float_4 + float_4;
if(1)
{
unsigned_int_1 = unsigned_int_2 + unsigned_int_1;
}
float_5 = float_2 + float_4;
short_1 = short_1 * short_1;
char controller4vul_2082[3];
fgets(controller4vul_2082 ,3 ,stdin);
if( strcmp( controller4vul_2082, "Sh") > 0)
{
unsigned int unsigned_int_4 = 1;
float float_6 = 1;
for(int looper_2=0; looper_2<1;looper_2++)
{
unsigned int unsigned_int_3 = 1;
unsigned_int_4 = unsigned_int_3 + unsigned_int_1;
char controller4vul_2083[2];
fgets(controller4vul_2083 ,2 ,stdin);
if( strcmp( controller4vul_2083, "L") < 0)
{
char_1 = v_req_sentinel_send_heartbeat(long_1,long_2,uni_para);
}
}
float_5 = float_6 + float_4;
if(1)
{
float float_7 = 1;
unsigned_int_4 = unsigned_int_1;
float_6 = float_4 * float_7;
}
}
}
char v_redis_error( long parameter_1)
{
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
char char_1 = 1;
long_3 = long_1 + long_2;
return char_1;
}
void v_redis_swallow_msg( long parameter_1,int parameter_2,int parameter_3,int uni_para)
{
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
float float_1 = 1;
short short_2 = 1;
char_2 = char_1 + char_2;
unsigned_int_1 = unsigned_int_2;
int_2 = int_1 + int_1;
short_1 = short_1 + short_1;
char_1 = char_2 + char_1;
unsigned_int_4 = unsigned_int_2 * unsigned_int_3;
if(1)
{
long long_1 = 1;
long long_2 = 1;
long_2 = long_1 * long_1;
}
if(1)
{
float_1 = float_1 + float_1;
}
char controller4vul_2080[2];
fgets(controller4vul_2080 ,2 ,stdin);
if( strcmp( controller4vul_2080, "|") < 0)
{
double double_1 = 1;
double double_2 = 1;
char controller4vul_2081[2];
fgets(controller4vul_2081 ,2 ,stdin);
if( strcmp( controller4vul_2081, "c") < 0)
{
float float_2 = 1;
v_server_swallow_role_rsp(unsigned_int_4,short_2,uni_para);
float_1 = float_2;
}
double_2 = double_1 * double_1;
}
}
void v_req_server_enqueue_imsgq_head( long parameter_1,double parameter_2,int parameter_3)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_2 = 1;
int int_3 = 1;
float_1 = float_2;
int_1 = int_1 + int_1;
if(1)
{
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
}
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
if(1)
{
}
v_msg_tmo_insert(short_1,short_2);
short_1 = short_1 * short_3;
int_2 = int_2 + int_3;
}
void v_redis_post_connect( short parameter_1,double parameter_2,float parameter_3)
{
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
double double_1 = 1;
int int_1 = 1;
short short_4 = 1;
float float_3 = 1;
float float_4 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
long long_2 = 1;
long long_3 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_2 = 1;
int int_2 = 1;
char_1 = char_1 + char_1;
short_3 = short_1 + short_2;
float_1 = float_1 * float_2;
v_msg_put(long_1);
v_req_server_enqueue_imsgq_head(long_1,double_1,int_1);
short_3 = short_4 * short_1;
float_4 = float_2 * float_3;
if(1)
{
}
double_1 = double_1 + double_1;
if(1)
{
}
double_2 = double_1 + double_2;
double_2 = double_2 + double_1;
if(1)
{
double_2 = double_3 + double_4;
}
v_msg_send(double_4,char_1);
unsigned_int_1 = unsigned_int_1;
long_1 = long_2 * long_3;
double_1 = double_2 + double_4;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
unsigned_int_3 = unsigned_int_3 * unsigned_int_1;
unsigned_int_2 = v_msg_get(char_1,char_2,-1 );
int_1 = int_1 + int_1;
int_2 = v_msg_prepend_format(int_2,long_1,short_3);
double_3 = double_4 + double_3;
}
void v_req_server_dequeue_omsgq( int parameter_1,int parameter_2,short parameter_3)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
short short_1 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_4 = 1;
int int_5 = 1;
double_1 = double_2;
int_2 = int_1 + int_1;
float_1 = float_1 + float_2;
v_msg_tmo_delete(short_1);
int_3 = int_3 + int_2;
if(1)
{
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_4 = int_5;
}
void v_req_server_enqueue_omsgq( float parameter_1,float parameter_2,double parameter_3)
{
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
short short_2 = 1;
short short_3 = 1;
short short_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
short_1 = short_1 * short_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
char_2 = char_1 + char_2;
if(1)
{
}
short_4 = short_2 * short_3;
int_3 = int_1 + int_2;
}
void v_req_server_dequeue_imsgq( unsigned int parameter_1,double parameter_2,short parameter_3)
{
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
long_2 = long_1 * long_1;
short_2 = short_1 * short_1;
int_1 = int_1 * int_1;
if(1)
{
}
float_1 = float_1;
char_1 = char_1 + char_2;
}
int v_server_timeout( unsigned int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
long long_4 = 1;
long long_5 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
long_3 = long_1 + long_2;
double_1 = double_1 + double_1;
long_5 = long_1 * long_4;
float_1 = float_1;
int_1 = int_1 + int_2;
return int_2;
}
void v_msg_tmo_insert( short parameter_1,short parameter_2)
{
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_3 = 1;
short short_4 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
long long_1 = 1;
char char_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
short_2 = short_1 * short_1;
int_1 = v_server_timeout(unsigned_int_1);
short_2 = short_3 + short_4;
short_1 = short_2 + short_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
double_1 = double_1;
if(1)
{
}
long_1 = long_1 * long_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
char_1 = v_nc_msec_now();
double_1 = double_2 + double_2;
double_2 = double_2 + double_2;
double_1 = double_2 + double_1;
v_rbtree_insert(float_1,float_2);
}
void v_req_server_enqueue_imsgq( long parameter_1,unsigned int parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
v_msg_tmo_insert(short_1,short_2);
long_3 = long_1 + long_2;
if(1)
{
double double_3 = 1;
double_3 = double_1 * double_2;
}
double_2 = double_1 * double_1;
if(1)
{
}
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
char_1 = char_2;
}
void v_server_unref( int parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
int int_4 = 1;
int int_5 = 1;
char char_1 = 1;
short short_2 = 1;
short short_3 = 1;
short short_4 = 1;
unsigned_int_1 = unsigned_int_2;
int_1 = int_2;
short_1 = short_1 * short_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
int_3 = int_2 + int_1;
double_1 = double_1 * double_2;
int_4 = int_5;
char_1 = char_1;
short_4 = short_2 * short_3;
}
char v_server_resolve( double parameter_1,short parameter_2)
{
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
char_1 = char_1 + char_2;
long_1 = long_1;
if(1)
{
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long_1 = long_1 + long_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
}
int_1 = int_2;
unsigned_int_5 = unsigned_int_3 * unsigned_int_4;
short_2 = short_1 * short_2;
return char_2;
int_1 = v_nc_resolve(double_1,int_2,short_2);
}
void v_server_ref( short parameter_1)
{
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
int int_2 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
double double_6 = 1;
char char_1 = 1;
short short_1 = 1;
double_2 = double_1 + double_1;
double_2 = double_2 + double_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
int_1 = int_2;
double_4 = double_2 * double_3;
int_2 = int_1 * int_1;
double_2 = double_1 * double_5;
double_6 = double_1 + double_3;
char_1 = v_server_resolve(double_6,short_1);
}
unsigned int v_rsp_forward_stats( short parameter_1,float parameter_2,short parameter_3,float parameter_4)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
int_1 = int_1 * int_2;
double_1 = double_1 + double_2;
char_1 = char_1 * char_1;
return unsigned_int_1;
}
short v_rsp_forward( float parameter_1,short parameter_2,float parameter_3)
{
long long_1 = 1;
int int_1 = 1;
double double_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
float float_4 = 1;
int int_2 = 1;
short short_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_2 = 1;
short short_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_3 = 1;
long long_3 = 1;
long long_4 = 1;
int int_3 = 1;
int int_4 = 1;
long long_5 = 1;
double double_5 = 1;
float float_5 = 1;
long_1 = long_1 * long_1;
int_1 = v_req_done(double_1,long_2);
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
float_1 = float_1 + float_2;
float_4 = float_3 * float_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
int_2 = v_event_add_out(unsigned_int_1,short_1);
double_3 = double_2 + double_2;
short_2 = short_2 + short_3;
unsigned_int_2 = v_rsp_forward_stats(short_1,float_2,short_3,float_4);
double_2 = double_3 * double_4;
short_2 = short_2 + short_1;
unsigned_int_3 = unsigned_int_2;
long_3 = long_4;
int_1 = int_1;
int_2 = int_3 + int_4;
long_2 = long_3 * long_1;
long_5 = long_4 * long_4;
double_2 = double_4 + double_5;
if(1)
{
unsigned_int_3 = unsigned_int_2 * unsigned_int_3;
char controller_2[3];
fgets(controller_2 ,3 ,stdin);
if( strcmp( controller_2, "qL") < 0)
{
float_3 = float_1 * float_2;
}
}
float_3 = float_4 + float_5;
return short_3;
}
double v_rsp_filter( long parameter_1,double parameter_2,float parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_2 = 1;
float float_3 = 1;
double double_1 = 1;
float float_4 = 1;
short short_1 = 1;
unsigned int unsigned_int_3 = 1;
short short_2 = 1;
double double_2 = 1;
unsigned_int_1 = unsigned_int_2;
char_2 = char_1 * char_2;
if(1)
{
long long_1 = 1;
float float_1 = 1;
long_2 = long_1 + long_2;
int_1 = int_1 * int_2;
float_3 = float_1 + float_2;
}
double_1 = double_1 + double_1;
if(1)
{
float float_5 = 1;
float float_6 = 1;
long long_3 = 1;
long long_4 = 1;
float_5 = float_2 + float_4;
float_4 = float_6 * float_5;
int_1 = int_2 + int_2;
v_rsp_put(short_1);
long_3 = long_4;
}
unsigned_int_1 = unsigned_int_2 * unsigned_int_3;
float_3 = float_2 * float_4;
if(1)
{
int_1 = int_2 + int_2;
double_1 = double_1 * double_1;
short_2 = short_2 * short_1;
double_1 = double_2 + double_1;
}
if(1)
{
long long_5 = 1;
long long_6 = 1;
double double_3 = 1;
long_2 = long_5 * long_6;
short_2 = v_msg_empty(char_1);
double_3 = double_1 + double_2;
double_2 = double_3 + double_2;
unsigned_int_2 = unsigned_int_1;
char_2 = char_1 + char_2;
int_1 = int_2;
}
return double_1;
v_req_put(double_1);
}
void v_rsp_recv_done( float parameter_1,float parameter_2,float parameter_3,unsigned int parameter_4)
{
short short_1 = 1;
float float_1 = 1;
short short_2 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
short short_3 = 1;
short_1 = v_rsp_forward(float_1,short_2,float_2);
int_1 = int_2;
char_2 = char_1 + char_2;
double_2 = double_1 * double_2;
double_2 = v_rsp_filter(long_1,double_1,float_3);
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_1 = int_3;
double_1 = double_2;
if(1)
{
}
short_3 = short_3 + short_3;
}
char v_conn_get_redis(int uni_para)
{
int int_1 = 1;
long long_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
double double_3 = 1;
double double_4 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_2 = 1;
float float_3 = 1;
double double_5 = 1;
int int_3 = 1;
int_1 = int_1 + int_1;
int_1 = int_1;
char controller4vul_2079[2];
fgets(controller4vul_2079 ,2 ,stdin);
if( strcmp( controller4vul_2079, "F") < 0)
{
v_redis_swallow_msg(long_1,int_1,int_1,uni_para);
}
char_2 = char_1 * char_1;
double_1 = double_1 * double_1;
double_1 = double_2;
float_1 = float_1 + float_2;
double_3 = double_2;
double_3 = double_4;
long_1 = long_1 * long_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
short_2 = short_1 * short_2;
char_2 = char_2 * char_1;
double_2 = double_1 * double_1;
int_1 = int_1 * int_2;
float_3 = float_1 * float_2;
int_2 = int_1 + int_2;
int_2 = int_1 * int_2;
double_5 = double_2 * double_1;
int_2 = int_1 + int_3;
double_4 = double_4 * double_1;
return char_1;
}
float v_server_conn( int parameter_1,int uni_para)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
int int_3 = 1;
char char_1 = 1;
int int_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_1 = 1;
long long_2 = 1;
float float_2 = 1;
int_2 = int_1 * int_1;
float_1 = float_1;
int_1 = int_3;
char controller4vul_2078[2];
fgets(controller4vul_2078 ,2 ,stdin);
if( strcmp( controller4vul_2078, "?") < 0)
{
char_1 = v_conn_get_redis(uni_para);
}
int_2 = int_4 * int_2;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_3 = unsigned_int_2 * unsigned_int_2;
unsigned_int_3 = unsigned_int_3 + unsigned_int_3;
long_2 = long_1 + long_2;
return float_2;
}
double v_server_each_connect()
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
float float_3 = 1;
double double_3 = 1;
char char_1 = 1;
short short_1 = 1;
long long_1 = 1;
int int_4 = 1;
short short_2 = 1;
short short_3 = 1;
short short_4 = 1;
char char_2 = 1;
char char_3 = 1;
float float_4 = 1;
double double_4 = 1;
double_2 = double_1 + double_1;
int_1 = int_1 + int_2;
float_1 = v_server_conn(int_3,-1 );
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
float_2 = v_server_connect(float_3,double_3,char_1);
short_1 = v_req_server_send_role(short_1,long_1);
int_1 = int_4 + int_2;
short_3 = short_2 + short_1;
v_server_close(short_4,char_2);
double_1 = double_1 + double_3;
int_2 = int_1 * int_3;
char_3 = char_1 + char_3;
if(1)
{
}
float_3 = float_4 + float_4;
if(1)
{
float float_5 = 1;
int_4 = int_4 + int_3;
float_2 = float_5;
}
short_2 = short_3 * short_1;
if(1)
{
}
return double_4;
}
double v_server_pool_connect( double parameter_1,long parameter_2)
{
short short_1 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_2 = 1;
short_1 = v_array_each(long_1);
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
double_1 = v_server_each_connect();
int_2 = int_1 * int_1;
if(1)
{
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
unsigned_int_1 = unsigned_int_4 * unsigned_int_5;
}
return double_2;
}
short v_server_reset( double parameter_1,char parameter_2,long parameter_3)
{
long long_3 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
double double_3 = 1;
char char_2 = 1;
double double_4 = 1;
short short_2 = 1;
int int_1 = 1;
float float_1 = 1;
short short_3 = 1;
if(1)
{
}
if(1)
{
long long_1 = 1;
long long_2 = 1;
long_3 = long_1 + long_2;
long_3 = v_string_empty(double_1);
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
double_1 = double_2 + double_1;
v_string_deinit();
unsigned_int_3 = unsigned_int_3;
if(1)
{
char_1 = v_string_copy(unsigned_int_1,double_3,char_2);
double_3 = double_1;
}
if(1)
{
double_1 = double_2 * double_4;
}
}
if(1)
{
char char_3 = 1;
char char_4 = 1;
unsigned int unsigned_int_4 = 1;
char_3 = char_3 * char_4;
unsigned_int_3 = unsigned_int_2 * unsigned_int_4;
if(1)
{
short short_1 = 1;
short_1 = short_1 * short_2;
}
}
int_1 = v_event_del_conn(float_1,short_3);
double_4 = double_1 + double_2;
return short_2;
}
char v_sentinel_swallow_addr_rsp( short parameter_1,long parameter_2,float parameter_3)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
char char_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_3 = 1;
short short_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
float float_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_2 = 1;
double double_5 = 1;
char char_3 = 1;
int int_4 = 1;
long long_3 = 1;
long long_4 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
long long_5 = 1;
long long_6 = 1;
char char_5 = 1;
float_1 = float_1 + float_2;
int_1 = int_2;
long_1 = v_array_get(long_1,char_1);
double_3 = double_1 + double_2;
int_2 = int_3 + int_3;
short_1 = v_server_reset(double_1,char_2,long_1);
unsigned_int_1 = v_array_n(float_3);
double_3 = double_3;
double_1 = double_2 * double_4;
unsigned_int_3 = unsigned_int_2 * unsigned_int_3;
long_2 = v_string_empty(double_5);
double_5 = v_server_pool_connect(double_1,long_1);
int_1 = int_2 + int_1;
char_3 = char_2 * char_2;
float_3 = float_2 * float_3;
int_4 = int_1 * int_2;
long_2 = long_3 * long_4;
int_4 = int_2;
long_1 = long_4 * long_3;
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_4 = 1;
double double_6 = 1;
float_3 = float_2 + float_3;
if(1)
{
unsigned_int_2 = unsigned_int_4 + unsigned_int_4;
}
if(1)
{
char_2 = char_4;
}
if(1)
{
char_1 = char_4 * char_3;
}
if(1)
{
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
}
if(1)
{
unsigned_int_1 = unsigned_int_5 + unsigned_int_1;
}
double_6 = double_6 * double_6;
}
if(1)
{
unsigned_int_2 = unsigned_int_5 * unsigned_int_5;
}
unsigned_int_4 = unsigned_int_2 + unsigned_int_5;
if(1)
{
long_2 = long_1 * long_4;
}
long_6 = long_5 * long_3;
float_3 = float_3 * float_1;
if(1)
{
char_2 = char_3 * char_1;
if(1)
{
}
}
if(1)
{
int_4 = int_2 * int_2;
}
if(1)
{
float float_4 = 1;
float float_5 = 1;
float_5 = float_4 * float_2;
unsigned_int_1 = unsigned_int_4;
}
return char_5;
}
void v_sentinel_swallow_msg( long parameter_1,char parameter_2,unsigned int parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
int int_5 = 1;
long long_1 = 1;
short short_1 = 1;
float float_1 = 1;
long long_2 = 1;
int int_6 = 1;
char char_1 = 1;
int int_7 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_3 = 1;
short short_2 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
int_2 = int_1 + int_1;
int_4 = int_2 + int_3;
int_5 = int_4 * int_1;
int_1 = int_5 * int_2;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
unsigned_int_1 = unsigned_int_2 + unsigned_int_1;
long_1 = v_sentinel_swallow_psub_rsp(short_1,float_1,long_2);
int_4 = int_1 * int_6;
int_1 = int_6;
int_1 = int_6;
unsigned_int_2 = unsigned_int_2;
char_1 = v_sentinel_swallow_psub_pub(int_6,char_1,int_7);
float_3 = float_2 + float_2;
float_2 = float_1 * float_3;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
int_2 = int_6;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
if(1)
{
char char_2 = 1;
char char_3 = 1;
long long_3 = 1;
char_1 = v_sentinel_swallow_addr_rsp(short_2,long_2,float_2);
char_3 = char_2 * char_3;
long_3 = long_2 * long_1;
}
}
void v_sentinel_post_connect( int parameter_1,double parameter_2,double parameter_3)
{
}
int v_server_active( int parameter_1)
{
char char_1 = 1;
int int_1 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
int int_4 = 1;
char_1 = char_1;
if(1)
{
short short_1 = 1;
short short_2 = 1;
short_2 = short_1 + short_2;
}
if(1)
{
int_1 = int_1 * int_1;
}
if(1)
{
int int_2 = 1;
int_3 = int_1 * int_2;
}
char controller_4[2];
fgets(controller_4 ,2 ,stdin);
if( strcmp( controller_4, " ") > 0)
{
int_1 = int_3 * int_3;
}
double_1 = double_1 + double_2;
return int_4;
}
void v_rbtree_insert( float parameter_1,float parameter_2)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_2 = 1;
float float_1 = 1;
char char_3 = 1;
double double_4 = 1;
float float_2 = 1;
int int_4 = 1;
int int_5 = 1;
unsigned int unsigned_int_3 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
double double_5 = 1;
short short_3 = 1;
float float_5 = 1;
float float_6 = 1;
unsigned int unsigned_int_6 = 1;
unsigned int unsigned_int_7 = 1;
double_3 = double_1 * double_2;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
if(1)
{
long long_1 = 1;
long long_2 = 1;
long_1 = long_1 + long_2;
}
if(1)
{
char_1 = char_1 * char_1;
}
short_2 = short_1 * short_1;
if(1)
{
int_1 = int_1 + int_1;
}
int_1 = int_2 + int_3;
char_2 = v_rbtree_left_rotate(float_1,short_1,double_2);
char_2 = char_3;
double_4 = v_rbtree_right_rotate(short_1,float_2,unsigned_int_1);
char_1 = char_2 + char_3;
double_4 = double_4 * double_1;
int_5 = int_4 + int_2;
unsigned_int_3 = unsigned_int_3 * unsigned_int_2;
double_4 = double_2 + double_1;
unsigned_int_3 = unsigned_int_3 + unsigned_int_1;
float_3 = float_3 + float_4;
unsigned_int_2 = unsigned_int_4;
unsigned_int_4 = unsigned_int_2 * unsigned_int_5;
float_1 = float_2;
char_1 = char_1 * char_2;
double_5 = double_3 * double_2;
short_2 = short_3 * short_3;
unsigned_int_3 = unsigned_int_2 + unsigned_int_3;
float_1 = float_5 + float_6;
unsigned_int_7 = unsigned_int_1 * unsigned_int_6;
}
char v_nc_msec_now()
{
char char_1 = 1;
double double_1 = 1;
return char_1;
double_1 = v_nc_usec_now();
}
void v_msg_timer( long parameter_1,unsigned int parameter_2)
{
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
short short_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
char char_1 = 1;
long_1 = long_1 * long_2;
short_1 = short_1 * short_2;
v_rbtree_insert(float_1,float_1);
short_2 = short_2 * short_3;
double_3 = double_1 * double_2;
double_2 = double_3 + double_2;
char_1 = v_nc_msec_now();
short_2 = short_2 * short_3;
}
void v_sentinel_close( int parameter_1,int parameter_2)
{
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_3 = 1;
long long_2 = 1;
int int_1 = 1;
short short_1 = 1;
double double_4 = 1;
int int_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_3 = 1;
int int_4 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
double_2 = double_1 + double_2;
v_msg_timer(long_1,unsigned_int_1);
double_1 = double_1 * double_3;
long_2 = long_1 * long_1;
int_1 = int_1 * int_1;
v_msg_tmo_delete(short_1);
double_2 = double_3;
double_4 = double_1;
int_1 = int_2;
v_server_close(short_1,char_1);
unsigned_int_1 = unsigned_int_2 + unsigned_int_2;
char_1 = char_1 + char_1;
int_2 = int_3 * int_4;
float_1 = float_2;
float_3 = float_1;
}
void v_req_send_done( short parameter_1,unsigned int parameter_2,short parameter_3)
{
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
short_2 = short_1 * short_2;
char_3 = char_1 * char_2;
v_req_put(double_1);
double_2 = double_2 + double_2;
char_3 = char_3 + char_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
if(1)
{
double double_3 = 1;
double_2 = double_3 * double_2;
}
if(1)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int_3 = int_1 * int_2;
}
}
int v_event_del_out( short parameter_1,int parameter_2)
{
double double_1 = 1;
int int_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
short short_1 = 1;
int int_3 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
int int_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_4 = 1;
double double_4 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
double_1 = double_1;
int_1 = int_1 + int_1;
double_3 = double_1 * double_2;
int_2 = int_1 * int_1;
int_1 = int_1;
int_1 = int_2 * int_2;
int_1 = int_2 * int_1;
int_1 = int_1 * int_2;
long_3 = long_1 + long_2;
long_1 = long_2 * long_1;
double_2 = double_2;
short_1 = short_1;
if(1)
{
}
int_1 = int_3;
int_2 = int_1 + int_3;
char_2 = char_1 + char_1;
double_2 = double_1;
char_3 = char_3;
int_3 = int_1 * int_4;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
double_1 = double_3 * double_3;
char_4 = char_1;
double_1 = double_2;
int_2 = int_2 * int_2;
double_3 = double_4 * double_3;
float_2 = float_1 + float_2;
unsigned_int_4 = unsigned_int_2 * unsigned_int_3;
if(1)
{
float_2 = float_2 + float_1;
double_4 = double_2;
}
double_2 = double_4 + double_1;
return int_1;
}
void v_server_connected( float parameter_1,unsigned int parameter_2)
{
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_3 = 1;
long_2 = long_1 * long_1;
unsigned_int_1 = unsigned_int_2;
int_1 = int_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "i$") > 0)
{
int int_2 = 1;
int int_3 = 1;
int_2 = int_2 + int_3;
}
unsigned_int_2 = unsigned_int_2 + unsigned_int_1;
double_1 = double_2;
long_1 = long_1 + long_2;
unsigned_int_2 = unsigned_int_3;
}
long v_req_send_next( long parameter_1,unsigned int parameter_2)
{
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_2 = 1;
float float_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_4 = 1;
short short_1 = 1;
long long_1 = 1;
long long_2 = 1;
v_server_connected(float_1,unsigned_int_1);
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
float_3 = float_2 + float_2;
double_2 = double_1 * double_2;
if(1)
{
unsigned_int_2 = unsigned_int_2 + unsigned_int_2;
}
double_4 = double_3 * double_4;
if(1)
{
int_2 = int_1 + int_1;
if(1)
{
double_4 = double_4 + double_2;
}
}
double_1 = double_4 + double_1;
if(1)
{
int int_3 = 1;
char char_1 = 1;
char char_2 = 1;
int_3 = int_1 + int_1;
int_4 = v_event_del_out(short_1,int_2);
char_2 = char_1 * char_1;
}
long_1 = long_1 + long_1;
if(1)
{
}
float_1 = float_2 * float_2;
long_2 = long_1 * long_1;
return long_1;
}
char v_conn_sendv( long parameter_1,long parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
float float_3 = 1;
char char_1 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
int_1 = int_1 + int_1;
float_2 = float_1 + float_1;
long_1 = long_1 + long_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_2 = 1;
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
int int_4 = 1;
long long_2 = 1;
int_3 = int_2 + int_2;
short_1 = short_2;
if(1)
{
char controller_2[3];
fgets(controller_2 ,3 ,stdin);
if( strcmp( controller_2, "EF") > 0)
{
unsigned_int_2 = v_array_n(float_2);
int_3 = int_3;
}
int_4 = int_4 * int_2;
}
if(1)
{
int_3 = int_2 + int_4;
long_2 = long_2 + long_1;
}
if(1)
{
int int_5 = 1;
int_5 = int_2 + int_2;
int_3 = int_2 * int_4;
}
if(1)
{
int int_6 = 1;
long_2 = long_1 * long_2;
int_2 = int_4 + int_6;
}
if(1)
{
unsigned int unsigned_int_3 = 1;
short short_3 = 1;
unsigned_int_3 = unsigned_int_2 * unsigned_int_3;
short_3 = short_3 * short_2;
unsigned_int_2 = unsigned_int_2;
}
}
float_2 = float_1 + float_3;
return char_1;
}
unsigned int v_array_set( long parameter_1,double parameter_3,int parameter_4)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
float_2 = float_1 + float_1;
int_1 = int_1 + int_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
double_2 = double_1 * double_1;
return unsigned_int_2;
}
long v_msg_send_chain( short parameter_1,char parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
float float_2 = 1;
float float_3 = 1;
double double_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_3 = 1;
char char_3 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_2 = 1;
double double_4 = 1;
float float_4 = 1;
char char_4 = 1;
double double_5 = 1;
short short_1 = 1;
short short_2 = 1;
long long_3 = 1;
float float_6 = 1;
unsigned int unsigned_int_4 = 1;
int int_4 = 1;
unsigned int unsigned_int_5 = 1;
double double_7 = 1;
double double_8 = 1;
unsigned_int_1 = v_array_n(float_1);
int_2 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
long_1 = long_2;
float_1 = float_2 + float_3;
double_1 = double_1;
char_1 = char_1 * char_1;
char_2 = char_2 + char_2;
int_1 = int_3;
char_3 = char_2;
double_1 = double_2 + double_3;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
long_2 = long_1 + long_2;
double_1 = double_4 + double_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
float float_5 = 1;
unsigned int unsigned_int_3 = 1;
double double_6 = 1;
float_4 = float_5;
unsigned_int_3 = unsigned_int_1 * unsigned_int_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
char_4 = char_1 + char_2;
if(1)
{
double_4 = double_5 * double_6;
}
char_2 = v_conn_sendv(long_1,long_2,char_3);
unsigned_int_1 = unsigned_int_3 + unsigned_int_2;
if(1)
{
double_4 = double_1 * double_2;
}
short_2 = short_1 * short_2;
double_1 = double_4 + double_2;
long_3 = long_2 * long_2;
double_1 = double_6 + double_3;
}
if(1)
{
unsigned_int_3 = unsigned_int_3 * unsigned_int_1;
}
float_4 = float_6 + float_3;
if(1)
{
double_4 = double_5 + double_6;
}
}
short_1 = short_2 + short_2;
if(1)
{
unsigned_int_1 = unsigned_int_2 * unsigned_int_2;
}
if(1)
{
char_2 = char_4;
}
unsigned_int_4 = v_array_set(long_2,double_4,int_1);
v_mbuf_empty(char_2);
int_4 = int_1 * int_3;
for(int looper_3=0; looper_3<1;looper_3++)
{
long long_4 = 1;
float float_7 = 1;
long_4 = long_1 + long_3;
float_1 = v_array_push(float_6);
float_2 = float_7;
if(1)
{
if(1)
{
float_3 = v_mbuf_length();
float_3 = float_3 * float_4;
}
unsigned_int_2 = unsigned_int_1 * unsigned_int_4;
}
for(int looper_4=0; looper_4<1;looper_4++)
{
unsigned int unsigned_int_6 = 1;
unsigned int unsigned_int_7 = 1;
char char_5 = 1;
int_4 = int_1 + int_3;
if(1)
{
double_1 = double_5 + double_4;
}
unsigned_int_5 = unsigned_int_4;
if(1)
{
long long_5 = 1;
short short_3 = 1;
short short_4 = 1;
long_4 = long_5 * long_4;
short_3 = short_3 * short_1;
short_4 = short_4 + short_4;
int_4 = int_1;
}
unsigned_int_7 = unsigned_int_6 + unsigned_int_2;
char_5 = char_5 + char_5;
}
if(1)
{
char_4 = char_3 + char_1;
}
}
double_1 = double_7 + double_8;
if(1)
{
}
unsigned_int_5 = unsigned_int_1 + unsigned_int_5;
return long_3;
}
void v_msg_send( double parameter_1,char parameter_2)
{
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char_1 = char_1 + char_2;
int_2 = int_1 + int_1;
int_2 = int_1;
long_1 = v_msg_send_chain(short_1,char_2,char_2);
short_2 = short_2 * short_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
}
int v_sentinel_rsp_forward( double parameter_1,short parameter_2,long parameter_3)
{
int int_1 = 1;
return int_1;
}
long v_sentinel_rsp_filter( short parameter_1,float parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
short short_3 = 1;
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
char_2 = char_1 + char_1;
if(1)
{
unsigned int unsigned_int_3 = 1;
int_2 = int_1 + int_1;
short_1 = short_1 * short_2;
unsigned_int_3 = unsigned_int_2 * unsigned_int_1;
}
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
if(1)
{
long long_2 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
int int_3 = 1;
long_2 = long_1 * long_1;
short_3 = v_msg_empty(char_1);
unsigned_int_5 = unsigned_int_4 * unsigned_int_4;
int_1 = int_1 + int_3;
}
float_2 = float_1 * float_2;
v_req_put(double_1);
int_2 = int_2;
if(1)
{
int int_4 = 1;
int int_5 = 1;
int int_6 = 1;
v_rsp_put(short_2);
double_1 = double_1 + double_1;
double_1 = double_1 * double_1;
int_1 = int_4 * int_2;
int_5 = int_4 * int_4;
short_1 = short_3 + short_2;
int_2 = int_6;
}
return long_1;
}
void v_rsp_sentinel_recv_done( double parameter_1,unsigned int parameter_2,int parameter_3,long parameter_4)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
short short_1 = 1;
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
char char_3 = 1;
long long_2 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
int_1 = int_2;
long_1 = v_sentinel_rsp_filter(short_1,float_1,char_1);
char_2 = char_2 * char_1;
int_2 = v_sentinel_rsp_forward(double_1,short_1,long_1);
double_1 = double_1;
char_2 = char_3;
int_1 = int_2 * int_1;
if(1)
{
}
long_2 = long_2 + long_1;
}
int v_rsp_get( long parameter_1)
{
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_4 = 1;
int int_2 = 1;
int_1 = int_1 * int_1;
double_3 = double_1 * double_2;
unsigned_int_1 = v_msg_get(char_1,char_2,-1 );
double_4 = double_1 + double_4;
if(1)
{
double_1 = double_1 + double_2;
}
return int_2;
}
double v_rsp_recv_next( int parameter_1,unsigned int parameter_2,int parameter_3)
{
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_1 = 1;
char char_1 = 1;
double double_3 = 1;
char char_3 = 1;
float float_1 = 1;
float float_2 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
short short_3 = 1;
long long_3 = 1;
double_1 = double_1 * double_2;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
if(1)
{
short short_1 = 1;
short short_2 = 1;
long_1 = long_1;
if(1)
{
int int_1 = 1;
char char_2 = 1;
double double_4 = 1;
int_1 = int_1 * int_1;
char_1 = char_1 * char_2;
double_2 = double_1 + double_3;
char_3 = char_1 * char_3;
double_4 = double_3;
}
short_1 = short_1 * short_1;
short_2 = short_1 + short_1;
}
float_1 = float_1 + float_2;
if(1)
{
char_1 = char_3 + char_3;
}
if(1)
{
}
int_4 = int_2 * int_3;
if(1)
{
long long_2 = 1;
long_2 = long_1 + long_1;
}
return double_3;
v_rsp_put(short_3);
int_2 = v_rsp_get(long_3);
}
char v_msg_repair( char parameter_1,double parameter_2,long parameter_3)
{
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
short_2 = short_1 + short_1;
v_mbuf_insert(int_1,char_1);
short_1 = short_1 * short_1;
if(1)
{
}
v_mbuf_split(char_2,double_1,double_1);
float_3 = float_1 + float_2;
short_1 = short_2 * short_1;
return char_2;
}
void v_redis_post_coalesce_mset( long parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_3 = 1;
double_2 = double_1 + double_1;
int_2 = int_1 + int_2;
int_1 = int_2 * int_2;
if(1)
{
double double_4 = 1;
char char_1 = 1;
int_3 = v_msg_append(double_1,int_1,double_3,-1 );
double_4 = double_4 + double_3;
char_1 = char_1 + char_1;
}
}
void v_redis_post_coalesce_del( long parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
double_1 = double_1 * double_2;
int_2 = int_1 * int_1;
int_2 = v_msg_prepend_format(int_2,long_1,short_1);
short_1 = short_2 * short_3;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "@") < 0)
{
long long_2 = 1;
long long_3 = 1;
char char_1 = 1;
char char_2 = 1;
long_3 = long_1 + long_2;
char_2 = char_1 + char_1;
}
}
double v_redis_post_coalesce_mget()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
long long_4 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
int_2 = int_1 + int_2;
short_3 = short_1 + short_2;
int_2 = v_msg_prepend_format(int_3,long_1,short_3);
unsigned_int_3 = v_redis_copy_bulk(long_2,long_3);
double_2 = double_1 + double_2;
float_2 = float_1 + float_2;
if(1)
{
unsigned_int_2 = v_array_n(float_3);
long_4 = long_1;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
unsigned_int_1 = unsigned_int_2 + unsigned_int_1;
if(1)
{
char char_1 = 1;
char_3 = char_1 + char_2;
}
char_4 = char_2 + char_3;
if(1)
{
long_4 = long_2 * long_1;
}
}
return double_2;
}
void v_redis_post_coalesce( short parameter_1)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
long long_1 = 1;
float float_1 = 1;
float float_2 = 1;
long long_2 = 1;
long long_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int_2 = int_1 * int_2;
double_1 = v_redis_post_coalesce_mget();
v_redis_post_coalesce_del(long_1);
float_2 = float_1 * float_2;
v_redis_post_coalesce_mset(long_2);
long_3 = long_2 * long_3;
if(1)
{
}
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
}
void v_mbuf_rewind( char parameter_1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
float float_1 = 1;
double_3 = double_1 + double_2;
float_1 = float_1 + float_1;
}
void v_redis_pre_coalesce( float parameter_1)
{
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
double double_2 = 1;
short short_3 = 1;
short short_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_3 = 1;
short short_5 = 1;
long long_4 = 1;
float float_1 = 1;
double double_3 = 1;
double double_4 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_5 = 1;
char char_1 = 1;
unsigned int unsigned_int_4 = 1;
char char_2 = 1;
float float_4 = 1;
double double_6 = 1;
double double_7 = 1;
long_2 = long_1 * long_2;
short_1 = short_1 * short_2;
double_2 = double_1 + double_2;
short_4 = short_2 * short_3;
if(1)
{
}
int_3 = int_1 + int_2;
int_2 = int_2 + int_2;
long_1 = long_3;
short_1 = short_5 * short_3;
long_1 = long_3 * long_4;
float_1 = float_1 * float_1;
double_4 = double_3 + double_2;
float_2 = float_2 + float_2;
double_1 = double_3 * double_1;
short_1 = short_5 * short_5;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
double_1 = double_5 + double_1;
double_2 = double_2;
double_1 = double_1 + double_2;
char_1 = char_1 + char_1;
unsigned_int_4 = unsigned_int_4 * unsigned_int_2;
v_mbuf_rewind(char_1);
char_1 = char_2 + char_2;
if(1)
{
float float_3 = 1;
float_2 = float_3 + float_3;
double_2 = double_5 * double_1;
unsigned_int_4 = unsigned_int_1 + unsigned_int_1;
}
float_4 = float_1 * float_4;
long_2 = long_4 * long_4;
double_2 = double_4 * double_3;
double_2 = double_5 + double_6;
float_2 = v_mbuf_length();
double_6 = double_4 * double_5;
double_7 = double_6 * double_2;
}
unsigned int v_redis_failure( unsigned int parameter_1)
{
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float_2 = float_1 + float_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
return unsigned_int_2;
}
void v_redis_handle_select_req( long parameter_1,char parameter_2)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
long long_1 = 1;
char char_1 = 1;
long long_2 = 1;
int_2 = int_1 + int_2;
float_2 = float_1 + float_2;
float_1 = float_2 * float_1;
int_1 = v_msg_append(double_1,int_1,double_2,-1 );
int_1 = int_2 + int_3;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
long_1 = v_array_get(long_1,char_1);
long_1 = long_2 + long_1;
if(1)
{
}
if(1)
{
}
}
double v_redis_handle_time_req( char parameter_1,short parameter_2)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
float_1 = float_1;
int_1 = int_2;
int_1 = v_msg_prepend_format(int_3,long_1,short_1);
char_2 = char_1 + char_1;
int_1 = int_3 + int_3;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
return double_1;
}
float v_redis_handle_echo_req( long parameter_1,char parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
char char_1 = 1;
short short_1 = 1;
long long_2 = 1;
short short_2 = 1;
short short_3 = 1;
short short_4 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_3 = int_1 * int_2;
long_1 = v_array_get(long_1,char_1);
int_2 = v_msg_prepend_format(int_3,long_1,short_1);
long_2 = long_1 * long_2;
short_4 = short_2 * short_3;
float_3 = float_1 * float_2;
short_2 = short_2 + short_4;
unsigned_int_3 = unsigned_int_1;
return float_1;
}
double v_redis_handle_ping_req( short parameter_1,double parameter_2)
{
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_2 = 1;
return double_1;
int_1 = v_msg_append(double_1,int_2,double_2,-1 );
}
unsigned int v_redis_handle_auth_req( int parameter_1,double parameter_2)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
double double_4 = 1;
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
char char_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double_3 = double_1 + double_2;
int_2 = int_1 * int_2;
double_3 = double_3 * double_3;
int_3 = int_2 * int_3;
int_4 = int_2 * int_3;
double_3 = double_3;
int_3 = int_2 + int_3;
int_1 = v_msg_append(double_2,int_2,double_2,-1 );
double_3 = double_2 + double_2;
if(1)
{
}
double_4 = double_2 * double_3;
char_2 = char_1 * char_1;
long_1 = v_array_get(long_2,char_2);
short_1 = short_1;
char_3 = char_1 * char_2;
if(1)
{
unsigned_int_1 = unsigned_int_1;
}
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
return unsigned_int_3;
}
void v_redis_reply( float parameter_1,int uni_para)
{
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
double double_1 = 1;
long long_1 = 1;
long long_2 = 1;
short_2 = short_1 + short_1;
short_2 = short_2 * short_2;
char_1 = char_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
char controller4vul_2088[2];
fgets(controller4vul_2088 ,2 ,stdin);
if( strcmp( controller4vul_2088, "n") < 0)
{
int_1 = v_msg_append(double_1,int_1,double_1,uni_para);
}
if(1)
{
}
long_2 = long_1 * long_1;
}
int v_msg_append( double parameter_1,int parameter_2,double parameter_3,int uni_para)
{
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
double double_1 = 1;
int int_1 = 1;
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_2 = 1;
float_1 = float_1 * float_1;
char_2 = char_1 + char_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
char controller4vul_2089[2];
fgets(controller4vul_2089 ,2 ,stdin);
if( strcmp( controller4vul_2089, "6") < 0)
{
v_mbuf_copy(float_2,double_1,int_1,uni_para);
}
long_1 = long_1 * long_2;
short_2 = short_1 * short_2;
int_2 = int_2;
return int_1;
}
void v_mbuf_empty( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned_int_1 = unsigned_int_2;
}
unsigned int v_redis_copy_bulk( long parameter_1,long parameter_2)
{
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
char char_1 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
int int_1 = 1;
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_2 = 1;
short short_4 = 1;
int int_3 = 1;
char char_3 = 1;
char char_4 = 1;
char char_5 = 1;
double double_3 = 1;
unsigned int unsigned_int_3 = 1;
int int_4 = 1;
double double_4 = 1;
int int_5 = 1;
double double_5 = 1;
long_3 = long_1 + long_2;
char_1 = char_1 + char_1;
float_3 = float_1 + float_2;
int_1 = v_msg_append(double_1,int_1,double_1,-1 );
short_3 = short_1 * short_2;
int_1 = int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
double_2 = double_1 + double_1;
}
long_1 = long_1 * long_3;
if(1)
{
}
double_2 = double_2 * double_1;
v_mbuf_remove(double_2,short_4);
double_2 = double_1;
int_1 = int_3 * int_2;
if(1)
{
char char_2 = 1;
short_1 = short_2 * short_4;
char_3 = char_1 + char_2;
}
if(1)
{
long long_4 = 1;
char_4 = char_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
v_mbuf_insert(int_2,char_5);
double_2 = double_1 * double_3;
}
double_2 = double_1 * double_2;
long_4 = long_1 * long_3;
}
unsigned_int_2 = unsigned_int_3;
for(int looper_3=0; looper_3<1;looper_3++)
{
if(1)
{
char_1 = char_4;
v_mbuf_empty(char_3);
int_1 = int_3 * int_4;
if(1)
{
int_1 = int_3 + int_4;
}
float_2 = float_2;
v_mbuf_put(short_1);
int_2 = int_4 * int_2;
}
if(1)
{
if(1)
{
unsigned_int_3 = unsigned_int_1;
if(1)
{
}
}
float_1 = v_mbuf_length();
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
double_4 = double_2 + double_3;
}
}
if(1)
{
double_1 = double_3 + double_2;
}
int_5 = int_4 + int_2;
double_4 = double_3 * double_5;
return unsigned_int_2;
}
double v_msg_ensure_mbuf( double parameter_1,float parameter_2)
{
long long_1 = 1;
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
double double_2 = 1;
short short_3 = 1;
long_1 = v_mbuf_size(double_1);
int_3 = int_1 * int_2;
if(1)
{
short short_1 = 1;
short short_2 = 1;
int_2 = int_3 * int_1;
if(1)
{
}
short_2 = short_1 + short_1;
}
if(1)
{
long long_2 = 1;
long long_3 = 1;
v_mbuf_insert(int_1,char_1);
long_3 = long_2 + long_2;
}
return double_2;
short_3 = v_mbuf_get();
}
float v_redis_append_key( double parameter_1,float parameter_2,float parameter_3)
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
float float_3 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
double double_3 = 1;
long long_3 = 1;
long long_4 = 1;
int int_2 = 1;
float float_4 = 1;
float float_5 = 1;
unsigned int unsigned_int_2 = 1;
long_2 = long_1 * long_2;
double_1 = double_1 + double_1;
float_1 = v_array_push(float_2);
int_1 = int_1 * int_1;
long_1 = long_1 + long_2;
double_1 = v_msg_ensure_mbuf(double_1,float_3);
double_2 = double_1 * double_2;
unsigned_int_1 = unsigned_int_1;
if(1)
{
}
short_1 = short_1 + short_2;
int_1 = int_1 * int_1;
double_3 = double_1 + double_1;
if(1)
{
}
double_3 = double_2 + double_2;
if(1)
{
}
long_3 = long_1 + long_2;
long_4 = long_1 * long_4;
int_2 = int_1 * int_1;
float_4 = float_2 * float_1;
float_2 = float_2 * float_1;
if(1)
{
}
float_2 = float_5 + float_5;
v_mbuf_copy(float_5,double_2,int_1,-1 );
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
return float_3;
}
int v_random_dispatch( double parameter_1,short parameter_2,char parameter_3)
{
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
short short_1 = 1;
double double_3 = 1;
double double_4 = 1;
int int_1 = 1;
double_1 = double_1 * double_2;
long_3 = long_1 * long_2;
short_1 = short_1 * short_1;
double_4 = double_3 + double_1;
return int_1;
}
int v_modula_dispatch( short parameter_1,short parameter_2,double parameter_3)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
int_1 = int_2;
unsigned_int_1 = unsigned_int_2;
char_2 = char_1 * char_1;
unsigned_int_4 = unsigned_int_1 * unsigned_int_3;
return int_2;
}
long v_ketama_dispatch( int parameter_1,char parameter_2,char parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
long long_1 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
short_1 = short_1 + short_1;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "n") > 0)
{
}
int_2 = int_1 + int_2;
int_3 = int_3 * int_3;
char_1 = char_1 + char_1;
return long_1;
}
long v_server_pool_hash( short parameter_1,double parameter_2,int parameter_3)
{
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
float float_1 = 1;
short_1 = short_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
if(1)
{
}
char controller_2[2];
fgets(controller_2 ,2 ,stdin);
if( strcmp( controller_2, "Z") > 0)
{
}
return long_1;
unsigned_int_1 = v_array_n(float_1);
}
int v_server_pool_idx( double parameter_1,char parameter_2,int parameter_3)
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_3 = 1;
short short_4 = 1;
int int_1 = 1;
int int_2 = 1;
long long_3 = 1;
short short_5 = 1;
double double_5 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
char char_1 = 1;
int int_4 = 1;
int int_5 = 1;
char char_2 = 1;
float float_1 = 1;
int int_6 = 1;
float float_2 = 1;
int int_7 = 1;
short short_6 = 1;
long long_4 = 1;
long_2 = long_1 + long_2;
double_2 = double_1 + double_1;
short_1 = short_2;
if(1)
{
double double_3 = 1;
double_4 = double_3 * double_4;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
if(1)
{
short_3 = short_3 + short_4;
if(1)
{
int_2 = int_1 * int_1;
long_3 = v_server_pool_hash(short_5,double_4,int_1);
double_1 = double_4 * double_5;
}
}
}
long_1 = long_1 + long_2;
short_1 = short_3 * short_2;
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
int_3 = v_random_dispatch(double_4,short_5,char_1);
int_5 = int_4 + int_3;
long_2 = v_ketama_dispatch(int_5,char_1,char_2);
int_2 = v_modula_dispatch(short_4,short_2,double_5);
unsigned_int_1 = unsigned_int_3 * unsigned_int_1;
int_3 = int_2 * int_3;
unsigned_int_3 = v_array_n(float_1);
int_6 = int_2 * int_1;
float_1 = float_2;
int_6 = int_4 * int_7;
short_1 = short_6 + short_2;
return int_5;
long_4 = v_string_empty(double_2);
}
int v_msg_backend_idx( char parameter_1,double parameter_2,long parameter_3)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
char char_1 = 1;
int_1 = int_1 * int_2;
int_2 = int_1 * int_1;
return int_2;
int_3 = v_server_pool_idx(double_1,char_1,int_3);
}
char v_msg_gen_frag_id()
{
char char_1 = 1;
return char_1;
}
long v_redis_fragment_argx( float parameter_1,long parameter_2,char parameter_3,short parameter_4)
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
int int_4 = 1;
int int_5 = 1;
unsigned int unsigned_int_4 = 1;
long long_3 = 1;
long long_4 = 1;
char char_2 = 1;
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
long long_5 = 1;
float float_1 = 1;
float float_2 = 1;
char char_3 = 1;
long long_6 = 1;
double double_3 = 1;
float float_3 = 1;
char char_4 = 1;
float float_4 = 1;
int int_6 = 1;
char char_6 = 1;
long long_7 = 1;
unsigned int unsigned_int_8 = 1;
float float_5 = 1;
float float_6 = 1;
unsigned_int_1 = v_msg_get(char_1,char_1,-1 );
short_2 = short_1 * short_2;
int_1 = int_1;
unsigned_int_3 = unsigned_int_2 * unsigned_int_1;
int_2 = int_3;
long_1 = long_2;
double_1 = double_1 * double_2;
if(1)
{
}
int_1 = int_4 * int_2;
int_4 = int_5 + int_4;
if(1)
{
unsigned_int_4 = v_redis_copy_bulk(long_3,long_1);
long_2 = long_1 * long_4;
}
char_2 = char_1 * char_2;
unsigned_int_6 = unsigned_int_2 * unsigned_int_5;
for(int looper_1=0; looper_1<1;looper_1++)
{
for(int looper_2=0; looper_2<1;looper_2++)
{
long_5 = long_1 + long_5;
}
float_2 = float_1 + float_1;
}
char_1 = char_3 * char_3;
unsigned_int_2 = unsigned_int_2 + unsigned_int_6;
long_1 = long_2 * long_6;
for(int looper_3=0; looper_3<1;looper_3++)
{
double double_4 = 1;
double_2 = double_3 + double_3;
float_3 = float_3 + float_2;
double_1 = double_4 * double_1;
if(1)
{
int_2 = int_5 + int_4;
if(1)
{
unsigned int unsigned_int_7 = 1;
unsigned_int_2 = unsigned_int_7 + unsigned_int_1;
}
}
char_4 = char_3 * char_1;
float_4 = float_4 * float_1;
float_2 = float_2 + float_1;
if(1)
{
char_1 = v_msg_gen_frag_id();
int_4 = v_msg_prepend_format(int_4,long_1,short_1);
long_1 = long_1 + long_4;
}
if(1)
{
int_6 = int_2 + int_4;
}
if(1)
{
char char_5 = 1;
double double_5 = 1;
char_5 = char_5 * char_4;
if(1)
{
unsigned_int_1 = unsigned_int_4;
}
int_5 = v_msg_backend_idx(char_6,double_3,long_7);
double_3 = double_3;
if(1)
{
double_1 = double_3;
}
double_5 = double_5;
}
}
for(int looper_4=0; looper_4<1;looper_4++)
{
unsigned int unsigned_int_9 = 1;
unsigned int unsigned_int_10 = 1;
char char_7 = 1;
unsigned_int_8 = unsigned_int_8 + unsigned_int_9;
if(1)
{
float_3 = float_3;
}
if(1)
{
int_6 = int_2 * int_4;
}
if(1)
{
long_4 = long_7 * long_7;
}
if(1)
{
float_5 = float_3 * float_2;
}
if(1)
{
int int_7 = 1;
float_6 = v_redis_append_key(double_2,float_4,float_5);
int_7 = int_6 + int_2;
}
if(1)
{
float float_7 = 1;
float float_8 = 1;
float_7 = float_7 * float_8;
}
unsigned_int_10 = unsigned_int_1 * unsigned_int_10;
long_2 = v_array_get(long_5,char_3);
char_2 = char_6;
char_1 = char_7 * char_4;
long_7 = long_6 * long_5;
unsigned_int_8 = v_array_n(float_4);
unsigned_int_3 = unsigned_int_4 + unsigned_int_1;
}
int_2 = int_4 + int_6;
return long_4;
}
long v_redis_fragment( int parameter_1,char parameter_2,float parameter_3)
{
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
long long_2 = 1;
float float_2 = 1;
char char_1 = 1;
short short_1 = 1;
if(1)
{
}
return long_1;
unsigned_int_1 = v_array_n(float_1);
long_2 = v_redis_fragment_argx(float_2,long_2,char_1,short_1);
}
int v_msg_prepend_format( int parameter_1,long parameter_2,short parameter_3)
{
float float_1 = 1;
long long_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_3 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
float_1 = float_1;
long_1 = v_mbuf_size(double_1);
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
long_1 = long_2;
unsigned_int_3 = unsigned_int_3 * unsigned_int_3;
float_1 = float_2 + float_1;
if(1)
{
}
int_2 = int_1 + int_1;
double_1 = double_1;
short_1 = v_mbuf_get();
short_1 = short_1 + short_1;
short_1 = short_1 * short_2;
if(1)
{
}
int_3 = int_1;
char_2 = char_1 + char_1;
char_4 = char_3 * char_2;
return int_3;
}
float v_conn_authenticated( char parameter_1)
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
int_1 = int_1 * int_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_1 = int_1;
if(1)
{
}
if(1)
{
}
return float_1;
}
short v_redis_add_auth( unsigned int parameter_1,char parameter_2,double parameter_3)
{
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
double double_3 = 1;
char char_3 = 1;
char char_4 = 1;
char char_5 = 1;
long long_3 = 1;
long long_4 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
char_2 = char_1 * char_1;
double_2 = double_1 * double_2;
v_msg_put(long_1);
long_2 = long_1 + long_1;
float_1 = v_conn_authenticated(char_1);
int_1 = v_msg_prepend_format(int_2,long_1,short_1);
short_2 = short_2 + short_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
int_2 = int_1;
char_1 = char_1 * char_1;
double_3 = double_3 + double_1;
unsigned_int_1 = v_msg_get(char_3,char_4,-1 );
char_3 = char_5 * char_3;
if(1)
{
double_2 = double_2;
}
long_3 = long_3 * long_4;
if(1)
{
float float_2 = 1;
float float_3 = 1;
float_3 = float_2 * float_3;
}
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
unsigned_int_1 = unsigned_int_3;
double_3 = double_3 + double_3;
double_3 = double_1 * double_4;
double_1 = double_3 + double_1;
return short_2;
}
char v_redis_argkvx( double parameter_1)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
int_3 = int_1 * int_2;
return char_1;
}
int v_redis_argx( unsigned int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
double_1 = double_2;
return int_1;
}
float v_redis_argn( int parameter_1)
{
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
short_1 = short_1 + short_2;
return float_1;
}
char v_redis_arg3( unsigned int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
int_2 = int_1 * int_1;
return char_1;
}
double v_redis_arg2( long parameter_1)
{
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
float_1 = float_2;
return double_1;
}
short v_redis_arg1( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
unsigned_int_1 = unsigned_int_2;
return short_1;
}
void v_redis_arg0( char parameter_1)
{
float float_1 = 1;
float float_2 = 1;
float_2 = float_1 * float_1;
}
char v_mbuf_data_size()
{
char char_1 = 1;
return char_1;
}
unsigned int v_redis_argeval( long parameter_1)
{
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
long_2 = long_1 * long_2;
return unsigned_int_1;
}
void v_redis_argz( unsigned int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
long_2 = long_1 + long_1;
}
void v_redis_parse_req( double parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
char char_1 = 1;
float float_1 = 1;
short short_1 = 1;
char char_2 = 1;
double double_1 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_4 = 1;
double double_2 = 1;
for(int looper_1=0; looper_1<1;looper_1++)
{
if(1)
{
}
}
v_redis_argz(unsigned_int_1);
unsigned_int_2 = v_redis_argeval(long_1);
char_1 = v_mbuf_data_size();
float_1 = v_array_push(float_1);
v_redis_arg0(char_1);
short_1 = v_redis_arg1(char_2);
double_1 = v_redis_arg2(long_1);
char_1 = v_redis_arg3(unsigned_int_3);
float_2 = v_redis_argn(int_1);
int_2 = v_redis_argx(unsigned_int_4);
char_1 = v_redis_argkvx(double_2);
float_2 = v_mbuf_length();
}
void v_redis_parse_rsp( short parameter_1)
{
float float_1 = 1;
int int_1 = 1;
long long_1 = 1;
long long_2 = 1;
int int_2 = 1;
int int_3 = 1;
float_1 = v_mbuf_length();
int_1 = int_1 + int_1;
long_2 = long_1 + long_1;
int_1 = int_2 + int_3;
}
void v_sentinel_parse_rsp( unsigned int parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
v_redis_parse_rsp(short_1);
}
void v_sentinel_parse_req()
{
}
unsigned int v_msg_get( char parameter_1,char parameter_2,int uni_para)
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
unsigned int unsigned_int_8 = 1;
int int_2 = 1;
int_1 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
if(1)
{
}
float_1 = float_1 * float_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
char controller4vul_2086[2];
fgets(controller4vul_2086 ,2 ,stdin);
if( strcmp( controller4vul_2086, "B") < 0)
{
short short_1 = 1;
short short_2 = 1;
char controller4vul_2087[2];
fgets(controller4vul_2087 ,2 ,stdin);
if( strcmp( controller4vul_2087, "c") < 0)
{
float float_3 = 1;
v_redis_reply(float_2,uni_para);
short_1 = short_1 * short_2;
float_1 = float_2 * float_3;
}
if(1)
{
short short_3 = 1;
short_3 = short_2 + short_1;
}
}
if(1)
{
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
if(1)
{
unsigned int unsigned_int_4 = 1;
unsigned_int_5 = unsigned_int_2 + unsigned_int_4;
}
if(1)
{
unsigned int unsigned_int_7 = 1;
unsigned_int_7 = unsigned_int_2 * unsigned_int_6;
}
unsigned_int_8 = unsigned_int_5 + unsigned_int_6;
double_2 = double_1 * double_2;
double_5 = double_3 + double_4;
char_1 = char_1 * char_2;
long_1 = long_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
}
if(1)
{
float_1 = float_1 * float_2;
}
int_2 = int_1 * int_2;
return unsigned_int_8;
}
float v_mbuf_length()
{
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
short_1 = short_2;
return float_1;
}
void v_mbuf_copy( float parameter_1,double parameter_2,int parameter_3,int uni_para)
{
unsigned int unsigned_int_1 = 1;
long long_1 = 1;
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
long long_2 = 1;
char controller4vul_2090[2];
fgets(controller4vul_2090 ,2 ,stdin);
if( strcmp( controller4vul_2090, "o") < 0)
{
unsigned_int_1 = v_mbuf_full(uni_para);
}
long_1 = long_1;
char_1 = char_1;
short_2 = short_1 * short_1;
long_2 = long_1 * long_1;
}
void v_mbuf_split( char parameter_1,double parameter_2,double parameter_3)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
long long_1 = 1;
long long_2 = 1;
short short_3 = 1;
short short_4 = 1;
double double_2 = 1;
int int_3 = 1;
int_2 = int_1 + int_2;
float_1 = v_mbuf_length();
char_2 = char_1 * char_2;
short_2 = short_1 * short_2;
double_1 = double_1 * double_1;
int_2 = int_1 * int_2;
long_2 = long_1 * long_1;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "X") < 0)
{
}
char controller_2[2];
fgets(controller_2 ,2 ,stdin);
if( strcmp( controller_2, "?") > 0)
{
char char_3 = 1;
char char_4 = 1;
char char_5 = 1;
char_5 = char_3 + char_4;
}
short_4 = short_2 * short_3;
v_mbuf_copy(float_1,double_2,int_1,-1 );
int_1 = int_2 * int_3;
short_2 = v_mbuf_get();
long_1 = long_1 * long_1;
double_2 = double_1;
}
void v_msg_parsed( unsigned int parameter_1,long parameter_2,int parameter_3)
{
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_2 = 1;
short short_3 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
char char_3 = 1;
char char_4 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
float float_1 = 1;
char char_5 = 1;
float float_2 = 1;
float float_3 = 1;
float float_4 = 1;
double double_1 = 1;
double double_2 = 1;
v_mbuf_put(short_1);
char_1 = char_1 * char_2;
int_2 = int_1 * int_1;
short_2 = short_2 * short_2;
if(1)
{
short_3 = short_1 + short_2;
}
short_3 = short_3 + short_1;
if(1)
{
}
int_3 = int_1;
if(1)
{
unsigned_int_1 = v_msg_get(char_3,char_4,-1 );
short_2 = short_1 * short_3;
}
v_mbuf_insert(int_2,char_4);
short_2 = short_3 * short_2;
long_3 = long_1 + long_2;
float_1 = v_mbuf_length();
char_3 = char_3 * char_5;
char_3 = char_4 + char_4;
float_4 = float_2 * float_3;
v_mbuf_split(char_2,double_1,double_2);
}
short v_msg_empty( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
return short_1;
}
short v_msg_parse( char parameter_1,short parameter_2,short parameter_3)
{
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
float float_1 = 1;
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
short short_2 = 1;
float float_2 = 1;
int int_2 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
short short_3 = 1;
long long_3 = 1;
int int_3 = 1;
float float_3 = 1;
long_2 = long_1 * long_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "HC") < 0)
{
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
}
v_msg_parsed(unsigned_int_1,long_2,int_1);
float_1 = float_1 + float_1;
short_1 = v_msg_empty(char_1);
char_2 = v_msg_repair(char_1,double_1,long_2);
short_1 = short_1 * short_2;
float_2 = float_1 + float_2;
int_2 = int_2;
double_2 = double_2 + double_3;
unsigned_int_4 = unsigned_int_2 * unsigned_int_3;
float_2 = float_1 + float_1;
short_3 = short_1 * short_1;
long_2 = long_2 * long_3;
int_3 = int_3 + int_1;
float_3 = float_2 + float_3;
return short_3;
}
int v_conn_recv( double parameter_1,char parameter_3)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
int_2 = int_1 + int_1;
double_3 = double_1 * double_2;
int_1 = int_2 + int_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
long_1 = long_2;
unsigned_int_1 = unsigned_int_1;
if(1)
{
if(1)
{
int int_3 = 1;
int_3 = int_3;
}
short_2 = short_1 + short_1;
}
if(1)
{
short short_3 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
long_1 = long_1;
short_3 = short_2 + short_1;
}
if(1)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
double_2 = double_3 + double_3;
char_3 = char_1 * char_2;
}
if(1)
{
int_2 = int_1;
unsigned_int_1 = unsigned_int_2 * unsigned_int_1;
}
if(1)
{
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
float_2 = float_1 * float_1;
unsigned_int_3 = unsigned_int_4;
unsigned_int_3 = unsigned_int_3 * unsigned_int_4;
}
}
double_2 = double_3 * double_3;
return int_2;
}
long v_mbuf_size( double parameter_1)
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
int_1 = int_2;
return long_1;
}
void v_mbuf_insert( int parameter_1,char parameter_2)
{
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double_1 = double_1 * double_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
}
void v__mbuf_get()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
double double_1 = 1;
int int_3 = 1;
double double_2 = 1;
double double_3 = 1;
float float_1 = 1;
float float_2 = 1;
double double_4 = 1;
int int_4 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
long_1 = long_1 * long_1;
if(1)
{
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int_2 = int_1 * int_1;
double_1 = double_1 + double_1;
int_2 = int_3;
short_3 = short_1 + short_2;
short_3 = short_1 * short_2;
double_2 = double_3;
}
float_1 = float_1 * float_2;
if(1)
{
}
double_2 = double_1 + double_2;
double_4 = double_3 * double_1;
int_3 = int_4 * int_4;
}
short v_mbuf_get()
{
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
int int_4 = 1;
double double_1 = 1;
int int_5 = 1;
float float_1 = 1;
float float_2 = 1;
short short_3 = 1;
short_1 = short_1 * short_2;
v__mbuf_get();
int_1 = int_2;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "CO") < 0)
{
}
int_4 = int_1 * int_3;
unsigned_int_3 = unsigned_int_2 * unsigned_int_2;
int_2 = int_4 * int_4;
double_1 = double_1 * double_1;
unsigned_int_3 = unsigned_int_1;
int_2 = int_3 + int_3;
int_4 = int_5 * int_5;
float_1 = float_2;
return short_3;
}
unsigned int v_mbuf_full(int uni_para)
{
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char * vul_var;
vul_var=(char*)malloc(20*sizeof(char));
strcpy(vul_var, "CWE-761");
if(uni_para == 985)
{
vul_var = vul_var + 1;
}
free(vul_var);
double_1 = double_1 * double_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
}
short v_msg_recv_chain( char parameter_1,short parameter_2,char parameter_3)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_4 = 1;
double double_2 = 1;
short short_2 = 1;
short short_3 = 1;
long long_1 = 1;
double double_3 = 1;
long long_2 = 1;
int int_5 = 1;
int_1 = int_1;
int_1 = int_2 * int_3;
double_1 = double_1;
unsigned_int_1 = unsigned_int_2;
short_1 = v_mbuf_get();
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
char_1 = char_1 + char_2;
if(1)
{
int_1 = int_3 + int_3;
if(1)
{
}
int_4 = int_3 * int_2;
int_2 = v_conn_recv(double_2,char_2);
int_3 = int_3 + int_4;
}
v_mbuf_insert(int_3,char_1);
short_1 = short_2 + short_3;
double_1 = double_1;
long_1 = v_mbuf_size(double_2);
double_3 = double_1 * double_1;
if(1)
{
if(1)
{
}
}
unsigned_int_1 = v_mbuf_full(-1 );
long_1 = long_2 * long_2;
int_3 = int_2 * int_1;
int_5 = int_5 * int_4;
for(int looper_1=0; looper_1<1;looper_1++)
{
double double_4 = 1;
double_3 = double_3 + double_4;
if(1)
{
}
unsigned_int_2 = unsigned_int_2 * unsigned_int_2;
if(1)
{
unsigned int unsigned_int_3 = 1;
short_3 = v_msg_parse(char_1,short_2,short_1);
unsigned_int_2 = unsigned_int_3;
}
int_5 = int_2 + int_1;
}
return short_2;
}
long v_msg_recv( char parameter_1,long parameter_2)
{
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
char char_2 = 1;
long_1 = long_2;
short_2 = short_1 + short_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_3 = 1;
float float_1 = 1;
float float_2 = 1;
short short_3 = 1;
double double_1 = 1;
double double_2 = 1;
short short_4 = 1;
short_2 = v_msg_recv_chain(char_1,short_2,char_2);
char_3 = char_3 + char_3;
float_2 = float_1 + float_1;
short_2 = short_3;
float_2 = float_2 + float_1;
double_2 = double_1 + double_1;
short_4 = short_3;
}
return long_1;
}
char v__conn_get()
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
char char_1 = 1;
char char_2 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
int int_4 = 1;
char char_3 = 1;
int int_5 = 1;
double double_6 = 1;
unsigned int unsigned_int_6 = 1;
int int_6 = 1;
float float_1 = 1;
float float_2 = 1;
double_2 = double_1 + double_1;
if(1)
{
long long_1 = 1;
int_1 = int_1 * int_2;
long_1 = long_1 * long_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
unsigned_int_5 = unsigned_int_3 * unsigned_int_4;
}
if(1)
{
int_2 = int_2 + int_2;
if(1)
{
}
}
double_1 = double_2;
char_2 = char_1 + char_1;
double_4 = double_2 * double_3;
double_5 = double_4 + double_5;
double_1 = double_3 * double_2;
int_2 = int_3 * int_3;
short_1 = short_2;
double_2 = double_4 * double_5;
int_4 = int_2 + int_1;
char_1 = char_3;
unsigned_int_1 = unsigned_int_4 * unsigned_int_3;
unsigned_int_5 = unsigned_int_1 * unsigned_int_5;
double_1 = double_3 + double_3;
int_1 = int_5 + int_3;
int_4 = int_1;
double_6 = double_1 + double_4;
unsigned_int_2 = unsigned_int_6 * unsigned_int_4;
int_6 = int_3 * int_1;
double_6 = double_1 + double_5;
short_1 = short_1 + short_2;
float_1 = float_1 + float_2;
unsigned_int_1 = unsigned_int_2 + unsigned_int_2;
double_6 = double_1 + double_1;
short_1 = short_2 * short_2;
return char_1;
}
double v_conn_get_sentinel()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
unsigned int unsigned_int_4 = 1;
long long_1 = 1;
float float_1 = 1;
float float_2 = 1;
double double_2 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
char char_3 = 1;
long long_5 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_5 = 1;
char char_4 = 1;
short short_1 = 1;
long long_6 = 1;
int int_3 = 1;
double double_3 = 1;
short short_2 = 1;
short short_3 = 1;
int int_4 = 1;
double double_4 = 1;
double double_5 = 1;
unsigned int unsigned_int_6 = 1;
double double_6 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
int_1 = v_server_active(int_2);
unsigned_int_2 = unsigned_int_3;
if(1)
{
}
char_1 = char_1 + char_2;
v_rsp_sentinel_recv_done(double_1,unsigned_int_4,int_1,long_1);
v_req_server_enqueue_omsgq(float_1,float_2,double_1);
unsigned_int_3 = unsigned_int_1 * unsigned_int_1;
double_1 = double_2 * double_1;
long_4 = long_2 * long_3;
long_2 = v_msg_recv(char_3,long_1);
v_sentinel_swallow_msg(long_4,char_3,unsigned_int_2);
long_2 = long_2;
v_sentinel_close(int_1,int_2);
v_req_server_enqueue_imsgq(long_5,unsigned_int_1,char_1);
double_2 = double_2 * double_1;
float_4 = float_3 * float_4;
v_msg_send(double_1,char_3);
unsigned_int_5 = unsigned_int_4 + unsigned_int_3;
char_4 = v__conn_get();
short_1 = short_1 * short_1;
double_1 = double_2 + double_2;
v_server_ref(short_1);
long_1 = long_4 * long_4;
long_3 = long_4 + long_6;
float_4 = float_1 * float_1;
v_req_server_dequeue_omsgq(int_2,int_3,short_1);
double_3 = double_1 * double_1;
double_3 = v_rsp_recv_next(int_2,unsigned_int_3,int_2);
int_3 = int_1 * int_3;
short_3 = short_1 * short_2;
v_server_unref(int_3);
int_1 = int_2 + int_1;
int_4 = int_4 + int_3;
long_5 = v_req_send_next(long_5,unsigned_int_3);
v_sentinel_post_connect(int_2,double_4,double_5);
unsigned_int_6 = unsigned_int_3 + unsigned_int_1;
return double_3;
v_req_send_done(short_2,unsigned_int_6,short_3);
v_req_server_dequeue_imsgq(unsigned_int_3,double_6,short_3);
}
long v_sentinel_conn( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_1 = 1;
double double_1 = 1;
long long_2 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
if(1)
{
}
long_1 = long_1 * long_1;
double_1 = v_conn_get_sentinel();
unsigned_int_2 = unsigned_int_1;
unsigned_int_1 = unsigned_int_3 * unsigned_int_3;
return long_2;
}
int v_event_add_out( unsigned int parameter_1,short parameter_2)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_4 = 1;
int_2 = int_1 + int_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
if(1)
{
short short_1 = 1;
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
unsigned int unsigned_int_4 = 1;
long long_2 = 1;
char char_1 = 1;
short short_3 = 1;
if(1)
{
short_1 = short_1 * short_1;
}
if(1)
{
long_1 = long_1;
}
if(1)
{
}
double_2 = double_1 * double_1;
double_1 = double_3;
double_2 = double_2 + double_2;
unsigned_int_2 = unsigned_int_2 * unsigned_int_3;
if(1)
{
int_1 = int_1 * int_3;
}
if(1)
{
int_3 = int_3 + int_2;
}
if(1)
{
double double_4 = 1;
double_4 = double_2 * double_1;
}
if(1)
{
unsigned_int_2 = unsigned_int_4;
}
if(1)
{
long_1 = long_1 + long_1;
long_2 = long_2 + long_2;
}
if(1)
{
char char_2 = 1;
float float_1 = 1;
float float_2 = 1;
short short_2 = 1;
short short_4 = 1;
if(1)
{
}
char_1 = char_1 * char_2;
long_2 = long_1;
float_2 = float_1 * float_1;
short_2 = short_2 * short_3;
short_2 = short_4 * short_4;
}
if(1)
{
char char_3 = 1;
if(1)
{
}
short_3 = short_1;
unsigned_int_3 = unsigned_int_4 * unsigned_int_3;
char_3 = char_1 + char_1;
}
}
if(1)
{
if(1)
{
int int_5 = 1;
int_5 = int_4 * int_2;
}
}
return int_4;
}
int v_req_done( double parameter_1,long parameter_2)
{
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
float float_3 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
double_1 = double_1;
char_2 = char_1 + char_2;
int_2 = int_1 * int_1;
float_2 = float_1 * float_1;
if(1)
{
}
long_1 = long_1 + long_2;
if(1)
{
}
if(1)
{
}
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
if(1)
{
}
}
for(int looper_2=0; looper_2<1;looper_2++)
{
if(1)
{
}
}
double_3 = double_2 + double_2;
double_5 = double_4 + double_5;
for(int looper_3=0; looper_3<1;looper_3++)
{
float float_4 = 1;
float_4 = float_1 * float_3;
int_1 = int_2 * int_2;
}
for(int looper_4=0; looper_4<1;looper_4++)
{
float float_5 = 1;
float_3 = float_1 * float_5;
int_2 = int_1 * int_2;
}
char_1 = char_2;
double_2 = double_3;
short_1 = short_2;
return int_1;
}
double v_rbtree_right_rotate( short parameter_1,float parameter_2,unsigned int parameter_3)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
int int_3 = 1;
long long_5 = 1;
long long_6 = 1;
double double_3 = 1;
int_2 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
float_2 = float_1 * float_1;
if(1)
{
float_2 = float_1 + float_2;
}
long_3 = long_1 + long_2;
if(1)
{
double double_1 = 1;
double double_2 = 1;
double_2 = double_1 * double_1;
}
if(1)
{
long long_4 = 1;
long_2 = long_3 + long_4;
}
if(1)
{
short short_1 = 1;
short_1 = short_1;
}
int_3 = int_1 + int_3;
long_5 = long_5 * long_6;
return double_3;
}
char v_rbtree_left_rotate( float parameter_1,short parameter_2,double parameter_3)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_2 = int_1 * int_1;
int_1 = int_2 * int_3;
if(1)
{
double_1 = double_1 + double_1;
}
int_1 = int_1 * int_2;
if(1)
{
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
short_3 = short_1 + short_2;
}
if(1)
{
int int_4 = 1;
int int_5 = 1;
int_5 = int_4 * int_4;
}
if(1)
{
double double_2 = 1;
double_2 = double_1 + double_1;
}
long_2 = long_1 + long_1;
int_1 = int_1 + int_1;
return char_1;
}
void v_rbtree_node_min( char parameter_1,long parameter_2)
{
long long_1 = 1;
long_1 = long_1;
}
void v_rbtree_delete( unsigned int parameter_1,double parameter_2)
{
char char_1 = 1;
long long_1 = 1;
float float_1 = 1;
short short_1 = 1;
double double_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_2 = 1;
v_rbtree_node_min(char_1,long_1);
char_1 = v_rbtree_left_rotate(float_1,short_1,double_1);
double_1 = v_rbtree_right_rotate(short_2,float_1,unsigned_int_1);
int_1 = int_1 + int_2;
v_rbtree_node_init(unsigned_int_2);
}
void v_msg_tmo_delete( short parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
double double_1 = 1;
unsigned_int_1 = unsigned_int_2;
short_1 = short_2;
if(1)
{
}
long_1 = long_1 * long_1;
double_1 = double_1;
v_rbtree_delete(unsigned_int_2,double_1);
}
void v_rsp_put( short parameter_1)
{
long long_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
double double_2 = 1;
v_msg_put(long_1);
short_2 = short_1 + short_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
double_1 = double_1 * double_2;
}
float v_msg_type_string( double parameter_1)
{
float float_1 = 1;
return float_1;
}
int v_log_loggable( int parameter_1)
{
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
char_2 = char_1 + char_2;
if(1)
{
}
return int_1;
}
short v_req_log( int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
int int_4 = 1;
int int_5 = 1;
long long_1 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_2 = 1;
char char_3 = 1;
unsigned int unsigned_int_4 = 1;
float float_3 = 1;
unsigned int unsigned_int_5 = 1;
short short_2 = 1;
double_1 = double_1 * double_2;
int_3 = int_1 + int_2;
double_2 = double_1 + double_3;
unsigned_int_1 = unsigned_int_2;
char_1 = char_1 * char_2;
short_1 = short_1 * short_1;
if(1)
{
}
if(1)
{
}
if(1)
{
}
if(1)
{
}
int_4 = int_5;
int_4 = v_log_loggable(int_5);
long_1 = long_1 + long_1;
double_3 = v_nc_usec_now();
long_1 = v_nc_unresolve_peer_desc(int_3);
float_2 = float_1 + float_2;
short_1 = short_1 * short_1;
if(1)
{
}
unsigned_int_3 = v_array_n(float_1);
long_2 = v_array_get(long_1,char_3);
unsigned_int_3 = unsigned_int_4 + unsigned_int_3;
if(1)
{
char_2 = char_1 + char_1;
}
float_3 = v_msg_type_string(double_1);
unsigned_int_5 = unsigned_int_1 * unsigned_int_4;
int_2 = int_3;
double_1 = double_2 + double_2;
return short_2;
}
void v_req_put( double parameter_1)
{
short short_1 = 1;
long long_1 = 1;
long long_2 = 1;
short short_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
int int_1 = 1;
long long_3 = 1;
long long_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
v_rsp_put(short_1);
long_1 = long_1 * long_1;
long_2 = long_2;
v_msg_tmo_delete(short_2);
float_1 = float_2;
float_1 = float_3;
if(1)
{
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int_2 = int_1 + int_1;
long_3 = long_2 * long_3;
short_2 = short_2 * short_2;
v_msg_put(long_4);
double_3 = double_1 * double_2;
}
long_2 = long_4 * long_3;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
short_2 = v_req_log(int_1);
}
void v_conn_put( long parameter_1)
{
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
double double_4 = 1;
double double_5 = 1;
char char_2 = 1;
float_2 = float_1 + float_1;
double_3 = double_1 + double_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
char_1 = char_1 * char_1;
double_5 = double_1 + double_4;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, ":") > 0)
{
short short_1 = 1;
short short_2 = 1;
short_1 = short_2;
}
char_2 = char_1 * char_2;
}
double v_nc_usec_now()
{
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_3 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
short_2 = short_1 * short_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
short_2 = short_1 * short_3;
unsigned_int_3 = unsigned_int_3;
if(1)
{
unsigned_int_2 = unsigned_int_2 + unsigned_int_2;
}
short_2 = short_2;
return double_1;
}
short v_server_failure( float parameter_1,float parameter_2)
{
short short_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
double double_3 = 1;
short short_2 = 1;
short_1 = short_1 + short_1;
double_1 = v_nc_usec_now();
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
unsigned_int_1 = unsigned_int_3 * unsigned_int_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "J ") < 0)
{
}
unsigned_int_1 = unsigned_int_2 + unsigned_int_1;
if(1)
{
}
double_1 = double_2 * double_2;
float_1 = float_1 + float_2;
double_2 = double_3 + double_1;
return short_2;
}
float v_server_close_stats( char parameter_1,float parameter_2,char parameter_3,char parameter_4,int parameter_5)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
if(1)
{
int_2 = int_1 * int_2;
}
if(1)
{
int_1 = int_2 * int_3;
}
double_3 = double_1 + double_2;
int_2 = int_2 + int_3;
short_1 = short_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
return float_1;
}
void v_server_close( short parameter_1,char parameter_2)
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
int int_2 = 1;
int int_3 = 1;
short short_2 = 1;
float float_1 = 1;
int int_4 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
float float_2 = 1;
char char_2 = 1;
int int_5 = 1;
double double_1 = 1;
double double_2 = 1;
short short_3 = 1;
double double_3 = 1;
double double_4 = 1;
float float_3 = 1;
float float_4 = 1;
float float_5 = 1;
int int_6 = 1;
int int_7 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
int int_9 = 1;
double double_5 = 1;
short short_4 = 1;
char char_3 = 1;
int int_10 = 1;
char char_5 = 1;
long long_3 = 1;
long long_4 = 1;
long long_5 = 1;
long long_6 = 1;
double double_10 = 1;
int_1 = v_event_add_out(unsigned_int_1,short_1);
int_1 = int_1 + int_1;
int_3 = int_2 * int_3;
short_2 = v_server_failure(float_1,float_1);
int_4 = int_3 + int_3;
int_1 = int_4 + int_4;
if(1)
{
int_1 = int_4;
}
int_3 = int_2 * int_3;
if(1)
{
long_2 = long_1 + long_2;
float_1 = v_server_close_stats(char_1,float_2,char_1,char_2,int_5);
double_1 = double_2;
char_1 = char_2 + char_2;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
short_2 = short_2 * short_3;
double_3 = double_2 * double_1;
if(1)
{
double_1 = double_4 * double_3;
float_3 = float_2 * float_3;
}
if(1)
{
int int_8 = 1;
float_4 = float_5;
int_2 = int_5 + int_6;
int_1 = int_7 * int_3;
int_4 = int_3;
int_5 = int_3 * int_8;
if(1)
{
float_1 = float_5 + float_3;
}
if(1)
{
unsigned_int_3 = unsigned_int_2 * unsigned_int_1;
}
int_1 = int_8;
}
}
unsigned_int_5 = unsigned_int_3 * unsigned_int_4;
for(int looper_2=0; looper_2<1;looper_2++)
{
float_3 = float_1 + float_5;
int_2 = int_7 + int_9;
if(1)
{
unsigned_int_5 = unsigned_int_4 * unsigned_int_2;
float_5 = float_1 * float_4;
}
if(1)
{
unsigned int unsigned_int_6 = 1;
char char_4 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_6;
double_2 = double_3 + double_5;
v_req_put(double_4);
int_5 = int_5 + int_5;
v_rsp_put(short_4);
char_1 = char_3 + char_4;
unsigned_int_6 = unsigned_int_4;
if(1)
{
long_2 = long_2 + long_2;
}
if(1)
{
v_conn_put(long_2);
int_10 = int_5 * int_9;
}
short_1 = short_3;
}
}
int_2 = int_10 * int_9;
char_3 = char_5 + char_2;
if(1)
{
double double_6 = 1;
double double_7 = 1;
double double_8 = 1;
double double_9 = 1;
double_6 = double_5;
double_1 = double_4 * double_6;
double_7 = double_4 + double_4;
char_1 = char_2 * char_2;
double_9 = double_8 + double_9;
}
long_1 = long_3 * long_1;
double_4 = double_2 * double_2;
long_5 = long_3 + long_4;
long_5 = long_6 + long_2;
if(1)
{
unsigned_int_3 = unsigned_int_5 + unsigned_int_5;
}
int_9 = int_3;
int_6 = v_req_done(double_10,long_3);
short_1 = short_1 * short_3;
}
int v_sentinel_get()
{
long long_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
short short_1 = 1;
long_1 = v_sentinel_conn(char_1);
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
long_1 = v_array_get(long_2,char_1);
double_1 = double_1 * double_2;
if(1)
{
unsigned_int_1 = v_array_n(float_1);
long_1 = long_2;
}
if(1)
{
float float_2 = 1;
float_2 = float_2 + float_2;
int_1 = int_1 * int_2;
}
int_2 = int_3;
return int_1;
v_server_close(short_1,char_1);
}
int v_sentinel_connect( short parameter_1)
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_3 = 1;
double double_4 = 1;
long long_1 = 1;
unsigned int unsigned_int_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
char char_2 = 1;
long long_2 = 1;
long long_3 = 1;
char char_3 = 1;
unsigned int unsigned_int_6 = 1;
char char_4 = 1;
int int_4 = 1;
short short_3 = 1;
short short_4 = 1;
short short_5 = 1;
float_1 = float_2;
float_3 = float_3;
double_2 = double_1 + double_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
short_1 = short_2;
double_2 = double_3 * double_4;
if(1)
{
v_msg_timer(long_1,unsigned_int_3);
float_4 = float_3 * float_2;
}
unsigned_int_2 = unsigned_int_3 + unsigned_int_4;
int_3 = int_1 * int_2;
if(1)
{
unsigned int unsigned_int_5 = 1;
unsigned_int_4 = unsigned_int_3 + unsigned_int_5;
}
int_2 = int_1 * int_2;
if(1)
{
double double_5 = 1;
long_1 = v_sentinel_conn(char_1);
double_2 = double_5 * double_4;
}
char_2 = char_1 * char_1;
if(1)
{
char_2 = char_2 * char_2;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
int_3 = v_sentinel_get();
long_2 = v_array_get(long_3,char_3);
unsigned_int_3 = unsigned_int_1;
unsigned_int_6 = v_array_n(float_4);
char_1 = char_1 * char_4;
}
v_sentinel_close(int_4,int_4);
double_3 = double_1;
float_1 = v_server_connect(float_2,double_4,char_3);
short_1 = short_2 * short_3;
long_3 = v_req_sentinel_send_get_master_addr(short_4,unsigned_int_3);
char_3 = char_1;
char_2 = char_2 * char_4;
long_3 = long_2 * long_3;
return int_3;
v_msg_tmo_delete(short_5);
}
float v_server_pool_each_preconnect()
{
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
double double_1 = 1;
float float_1 = 1;
int_1 = int_1 + int_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
int_1 = v_sentinel_connect(short_1);
double_1 = double_1;
if(1)
{
}
return float_1;
}
unsigned int v_server_pool_preconnect( int parameter_1)
{
short short_1 = 1;
long long_1 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
short short_2 = 1;
short short_3 = 1;
unsigned int unsigned_int_1 = 1;
short_1 = v_array_each(long_1);
float_3 = float_1 + float_2;
float_3 = v_server_pool_each_preconnect();
short_3 = short_2 * short_2;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "W") > 0)
{
}
return unsigned_int_1;
}
char v_core_send( float parameter_1,long parameter_2)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
char char_1 = 1;
int_2 = int_1 * int_1;
float_1 = float_1 + float_2;
if(1)
{
short short_1 = 1;
short short_2 = 1;
short_2 = short_1 + short_1;
}
return char_1;
}
unsigned int v_core_recv( double parameter_1,short parameter_2)
{
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
double_1 = double_1;
int_1 = int_2;
if(1)
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
float_3 = float_1 + float_2;
}
return unsigned_int_1;
}
int v_event_del_conn( float parameter_1,short parameter_2)
{
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
char_2 = char_1 * char_1;
return int_1;
}
float v_nc_unresolve_addr( unsigned int parameter_1,unsigned int parameter_2)
{
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
long long_3 = 1;
float float_1 = 1;
char_1 = char_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
long_1 = long_1 + long_2;
double_1 = double_2;
if(1)
{
}
long_3 = long_3 * long_1;
return float_1;
}
long v_nc_unresolve_peer_desc( int parameter_1)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
int int_4 = 1;
int int_5 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
char_3 = char_1 * char_2;
int_3 = int_1 + int_2;
float_1 = v_nc_unresolve_addr(unsigned_int_1,unsigned_int_1);
float_1 = float_2 * float_1;
double_2 = double_1 * double_2;
int_1 = int_2 + int_1;
double_1 = double_2 + double_2;
int_2 = int_4 + int_5;
unsigned_int_1 = unsigned_int_2;
if(1)
{
}
return long_1;
}
double v_core_close( short parameter_1,unsigned int parameter_2)
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
int int_3 = 1;
int int_4 = 1;
unsigned int unsigned_int_1 = 1;
float float_2 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_3 = 1;
double double_3 = 1;
int_1 = int_1 + int_2;
long_1 = long_1 * long_1;
double_1 = double_1 + double_1;
if(1)
{
double double_2 = 1;
short_2 = short_1 * short_1;
int_1 = v_event_del_conn(float_1,short_1);
double_2 = double_2 + double_1;
}
if(1)
{
short short_3 = 1;
int_4 = int_3 * int_3;
long_1 = v_nc_unresolve_peer_desc(int_3);
short_2 = short_2 + short_3;
}
if(1)
{
unsigned int unsigned_int_2 = 1;
int int_5 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_5 = int_2 * int_4;
}
float_1 = float_1 * float_1;
float_3 = float_2 * float_1;
if(1)
{
int int_6 = 1;
int_2 = int_6;
}
float_4 = v_nc_unresolve_addr(unsigned_int_1,unsigned_int_3);
float_2 = float_3;
return double_3;
}
int v_nc_get_soerror( int parameter_1)
{
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
char_1 = char_2;
double_1 = double_1 * double_2;
short_2 = short_1 + short_2;
unsigned_int_1 = unsigned_int_2;
double_1 = double_2 * double_1;
if(1)
{
int int_2 = 1;
int_1 = int_1 + int_2;
}
return int_1;
}
int v_core_error( int parameter_1,long parameter_2)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
char char_3 = 1;
unsigned int unsigned_int_2 = 1;
int_1 = int_1 + int_2;
double_1 = v_core_close(short_1,unsigned_int_1);
char_1 = char_1 + char_1;
double_1 = double_1;
if(1)
{
char char_2 = 1;
int_2 = v_nc_get_soerror(int_2);
char_1 = char_2 * char_2;
}
char_3 = char_3;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
return int_1;
}
double v_conn_to_ctx( short parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_3 = 1;
double double_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
if(1)
{
int int_1 = 1;
int int_2 = 1;
int_3 = int_1 + int_2;
}
if(1)
{
unsigned int unsigned_int_3 = 1;
int int_4 = 1;
unsigned_int_1 = unsigned_int_3 * unsigned_int_3;
int_3 = int_4;
}
return double_1;
}
int v_core_core(unsigned int parameter_2)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_2 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
float float_2 = 1;
int int_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int_1 = int_1 * int_2;
double_1 = v_conn_to_ctx(short_1);
char_2 = char_1 + char_2;
double_2 = double_1 + double_1;
if(1)
{
int_3 = int_2;
}
int_1 = int_1 * int_3;
long_1 = long_2;
float_2 = float_1 + float_1;
if(1)
{
int_4 = int_2;
}
if(1)
{
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
int_4 = v_core_error(int_2,long_2);
char_1 = v_core_send(float_2,long_1);
float_2 = float_1 + float_1;
}
}
if(1)
{
double double_3 = 1;
double_1 = v_core_close(short_1,unsigned_int_2);
double_2 = double_3 * double_1;
if(1)
{
char char_3 = 1;
char_3 = char_3 + char_2;
}
}
return int_4;
unsigned_int_1 = v_core_recv(double_1,short_1);
}
void v_event_base_create( int parameter_1,double parameter_2)
{
int int_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
double double_3 = 1;
unsigned int unsigned_int_4 = 1;
long long_4 = 1;
int_1 = int_1 * int_1;
short_1 = short_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
double_1 = double_1 * double_1;
double_1 = double_2 + double_2;
float_1 = float_1 + float_2;
unsigned_int_2 = unsigned_int_2;
double_2 = double_1 * double_1;
int_1 = int_2 * int_2;
double_2 = double_2;
long_3 = long_1 * long_2;
int_1 = int_3;
unsigned_int_2 = unsigned_int_3 * unsigned_int_1;
double_3 = double_1 * double_2;
unsigned_int_1 = unsigned_int_4 + unsigned_int_1;
int_2 = int_2 * int_2;
int_3 = int_1 + int_1;
long_4 = long_3 * long_3;
}
void v_stats_destroy_buf( unsigned int parameter_1)
{
if(1)
{
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
char_1 = char_1 + char_1;
int_2 = int_1 + int_2;
double_1 = double_1 + double_1;
}
}
char v_stats_server_unmap( long parameter_1)
{
long long_1 = 1;
float float_1 = 1;
double double_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_2 = 1;
char char_2 = 1;
char char_3 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
long_1 = long_1 + long_1;
float_1 = float_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
double double_2 = 1;
double_1 = v_array_pop(char_1);
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
unsigned_int_1 = v_array_n(float_2);
double_2 = double_1 * double_1;
}
char_2 = v_stats_metric_deinit(char_3);
double_3 = double_1;
v_array_deinit(unsigned_int_1);
int_2 = int_1 + int_2;
return char_3;
}
float v_stats_pool_unmap( short parameter_1)
{
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
float float_1 = 1;
double double_1 = 1;
unsigned int unsigned_int_5 = 1;
long long_1 = 1;
char_2 = char_1 + char_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_1 = 1;
short short_2 = 1;
unsigned_int_4 = v_array_n(float_1);
unsigned_int_2 = unsigned_int_2;
v_array_deinit(unsigned_int_4);
short_1 = short_1 * short_2;
char_2 = char_1 * char_2;
}
double_1 = v_array_pop(char_1);
unsigned_int_5 = unsigned_int_1 + unsigned_int_5;
char_2 = v_stats_metric_deinit(char_1);
long_1 = long_1;
return float_1;
char_1 = v_stats_server_unmap(long_1);
}
void v_stats_stop_aggregator( char parameter_1)
{
int int_1 = 1;
int int_2 = 1;
if(1)
{
}
int_1 = int_2;
}
void v_stats_destroy( short parameter_1)
{
char char_1 = 1;
short short_1 = 1;
short short_2 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_3 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
short short_4 = 1;
v_stats_stop_aggregator(char_1);
short_2 = short_1 * short_2;
char_1 = char_1 + char_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
short_1 = short_1 + short_3;
v_stats_destroy_buf(unsigned_int_2);
double_2 = double_1 + double_1;
float_2 = float_1 * float_2;
float_3 = v_stats_pool_unmap(short_4);
}
char v_stats_add_footer( float parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_2 = 1;
int int_3 = 1;
float float_1 = 1;
float float_2 = 1;
char char_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
short_2 = short_1 + short_1;
int_1 = int_1 * int_1;
if(1)
{
}
double_3 = double_1 + double_2;
int_3 = int_1 + int_2;
double_1 = double_3 + double_3;
float_2 = float_1 + float_1;
return char_1;
}
unsigned int v_stats_end_nesting()
{
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
char char_1 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_5 = 1;
int int_3 = 1;
char char_2 = 1;
short short_3 = 1;
long_1 = long_1 * long_1;
double_2 = double_1 + double_1;
long_4 = long_2 * long_3;
char_1 = char_1;
double_2 = double_3 + double_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
unsigned_int_2 = unsigned_int_3 + unsigned_int_1;
double_4 = double_3 + double_1;
short_2 = short_1 + short_1;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "r") > 0)
{
}
int_1 = int_1 + int_1;
int_2 = int_1;
double_5 = double_3 * double_3;
int_3 = int_2 + int_3;
char_1 = char_1 * char_2;
short_1 = short_3 + short_3;
return unsigned_int_3;
}
long v_stats_copy_metric( char parameter_1,long parameter_2)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
int_1 = int_1 * int_1;
int_1 = int_1 * int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_2 = 1;
unsigned_int_1 = v_array_n(float_1);
long_1 = v_array_get(long_2,char_1);
unsigned_int_1 = unsigned_int_2 + unsigned_int_1;
char_1 = char_2 + char_2;
if(1)
{
}
}
return long_2;
long_2 = v_stats_add_num(int_1,char_2,short_1);
}
float v_stats_begin_nesting( long parameter_1,double parameter_2)
{
long long_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
short short_3 = 1;
short short_4 = 1;
double double_1 = 1;
long long_5 = 1;
float float_1 = 1;
long_1 = long_1 * long_1;
short_1 = short_1 * short_2;
int_1 = int_2;
long_4 = long_2 + long_3;
short_2 = short_3 + short_4;
long_1 = long_2 + long_3;
double_1 = double_1;
long_3 = long_4;
if(1)
{
}
long_3 = long_4 * long_5;
return float_1;
}
int v_conn_ncurr_conn()
{
int int_1 = 1;
return int_1;
}
float v_conn_ntotal_conn()
{
float float_1 = 1;
return float_1;
}
long v_stats_add_num( int parameter_1,char parameter_2,short parameter_3)
{
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
unsigned_int_1 = unsigned_int_1;
double_1 = double_1 * double_2;
int_2 = int_1 + int_1;
double_1 = double_1 + double_3;
unsigned_int_2 = unsigned_int_2 + unsigned_int_3;
float_2 = float_1 + float_2;
short_1 = short_2;
long_3 = long_1 * long_2;
if(1)
{
}
long_2 = long_3 * long_3;
return long_1;
}
short v_stats_add_string( int parameter_1,float parameter_2,long parameter_3)
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_3 = 1;
long long_4 = 1;
long long_5 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
long_1 = long_1 * long_2;
double_2 = double_1 * double_1;
double_3 = double_3;
unsigned_int_1 = unsigned_int_1;
int_3 = int_1 + int_2;
double_3 = double_1 * double_2;
long_5 = long_3 * long_4;
char_2 = char_1 + char_1;
if(1)
{
}
short_1 = short_1 + short_2;
return short_3;
}
int v_stats_add_header( int parameter_1)
{
double double_1 = 1;
long long_1 = 1;
int int_1 = 1;
char char_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_2 = 1;
float float_1 = 1;
int int_3 = 1;
char char_2 = 1;
float float_2 = 1;
short short_2 = 1;
short short_3 = 1;
short short_4 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
float float_3 = 1;
float float_4 = 1;
int int_4 = 1;
double_1 = double_1 * double_1;
long_1 = v_stats_add_num(int_1,char_1,short_1);
unsigned_int_1 = unsigned_int_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
short_1 = v_stats_add_string(int_2,float_1,long_1);
int_3 = int_3 + int_2;
int_3 = int_1;
long_1 = long_1 * long_1;
char_1 = char_1 + char_2;
float_2 = v_conn_ntotal_conn();
short_4 = short_2 * short_3;
double_1 = double_2 + double_2;
if(1)
{
}
int_1 = v_conn_ncurr_conn();
short_1 = short_1;
if(1)
{
}
double_2 = double_3 * double_4;
if(1)
{
}
float_4 = float_1 + float_3;
if(1)
{
}
double_2 = double_3 * double_1;
if(1)
{
}
double_1 = double_2 * double_4;
if(1)
{
}
float_2 = float_1;
if(1)
{
}
return int_4;
}
void v_stats_make_rsp()
{
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
long long_1 = 1;
double double_3 = 1;
long long_2 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
unsigned int unsigned_int_1 = 1;
float float_2 = 1;
long long_3 = 1;
long long_4 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_4 = 1;
int int_3 = 1;
int int_4 = 1;
double_2 = double_1 * double_2;
float_1 = v_stats_begin_nesting(long_1,double_3);
long_2 = v_stats_copy_metric(char_1,long_1);
char_1 = char_1 * char_2;
char_1 = char_1 * char_3;
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned_int_1 = v_array_n(float_2);
double_3 = double_1;
long_3 = v_array_get(long_4,char_2);
short_1 = short_1 * short_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
if(1)
{
}
int_1 = v_stats_add_header(int_2);
int_1 = int_1;
char controller_3[2];
fgets(controller_3 ,2 ,stdin);
if( strcmp( controller_3, "Q") < 0)
{
}
for(int looper_2=0; looper_2<1;looper_2++)
{
int_1 = int_2;
unsigned_int_4 = v_stats_end_nesting();
double_3 = double_1 + double_3;
if(1)
{
}
char_1 = char_1 * char_3;
if(1)
{
}
double_3 = double_2 + double_2;
if(1)
{
}
}
long_2 = long_1 + long_3;
if(1)
{
}
}
int_4 = int_3 + int_1;
if(1)
{
}
char_2 = v_stats_add_footer(float_2);
}
double v_stats_send_rsp()
{
float float_1 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
char char_2 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
float float_4 = 1;
short short_3 = 1;
float_1 = float_1;
long_2 = long_1 * long_1;
double_1 = double_1 + double_2;
char_2 = char_1 * char_2;
if(1)
{
}
float_2 = float_2 + float_3;
if(1)
{
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
}
short_2 = short_1 * short_1;
float_4 = float_1 * float_1;
if(1)
{
unsigned int unsigned_int_3 = 1;
unsigned_int_2 = unsigned_int_3 * unsigned_int_1;
short_2 = short_3 + short_2;
}
short_2 = short_3 + short_2;
return double_1;
v_stats_make_rsp();
}
float v_stats_aggregate_metric( float parameter_1,char parameter_2)
{
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_4 = 1;
float float_5 = 1;
long_1 = v_array_get(long_2,char_1);
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
short short_1 = 1;
short short_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_4 = 1;
double double_3 = 1;
char char_2 = 1;
double_1 = double_2;
int_1 = int_1 * int_2;
double_1 = double_2 + double_2;
float_3 = float_1 * float_2;
short_1 = short_2;
int_1 = int_3 * int_3;
unsigned_int_3 = v_array_n(float_4);
unsigned_int_2 = unsigned_int_2 * unsigned_int_3;
unsigned_int_4 = unsigned_int_3 + unsigned_int_4;
if(1)
{
float_1 = float_3 + float_1;
}
double_2 = double_3 * double_3;
char_2 = char_1 * char_2;
}
return float_5;
}
unsigned int v_stats_aggregate( double parameter_1)
{
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_3 = 1;
short short_1 = 1;
short short_2 = 1;
long_1 = long_1 * long_1;
if(1)
{
unsigned_int_1 = v_array_n(float_1);
double_1 = double_2;
}
long_1 = v_array_get(long_1,char_1);
unsigned_int_2 = unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
float float_2 = 1;
double double_3 = 1;
long long_2 = 1;
unsigned int unsigned_int_3 = 1;
float_2 = float_2;
double_3 = double_2 + double_1;
long_1 = long_1;
long_1 = long_2 * long_2;
unsigned_int_1 = unsigned_int_3;
for(int looper_2=0; looper_2<1;looper_2++)
{
long long_3 = 1;
double double_4 = 1;
long_1 = long_1 + long_2;
float_3 = v_stats_aggregate_metric(float_1,char_1);
long_3 = long_3 * long_3;
double_4 = double_4 + double_4;
double_1 = double_1;
}
}
short_2 = short_1 * short_1;
return unsigned_int_2;
}
double v_stats_loop_callback()
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
char char_1 = 1;
char char_2 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
double double_5 = 1;
long_1 = long_2;
double_1 = v_stats_send_rsp();
char_2 = char_1 * char_2;
double_4 = double_2 * double_3;
if(1)
{
}
unsigned_int_1 = v_stats_aggregate(double_1);
double_5 = double_4 * double_1;
return double_2;
}
void v_event_loop_stats( float parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
int int_4 = 1;
int int_5 = 1;
double double_3 = 1;
double double_4 = 1;
long long_1 = 1;
long long_2 = 1;
double double_5 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
double double_7 = 1;
unsigned int unsigned_int_3 = 1;
double double_9 = 1;
int int_6 = 1;
int int_7 = 1;
int int_8 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
double_2 = double_1 * double_2;
int_3 = int_1 * int_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
short_1 = short_1 + short_1;
char_3 = char_1 + char_2;
int_5 = int_3 + int_4;
if(1)
{
}
double_3 = double_4;
long_2 = long_1 * long_2;
double_2 = double_5 * double_3;
short_2 = short_2 + short_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
int_3 = int_2 + int_1;
if(1)
{
double_1 = double_1 + double_3;
}
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
unsigned_int_2 = unsigned_int_1;
}
if(1)
{
short_2 = short_1 * short_1;
}
}
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
char char_4 = 1;
double double_6 = 1;
char_1 = char_2 + char_4;
double_7 = double_3 + double_6;
double_3 = double_3 * double_1;
short_1 = short_1 + short_2;
unsigned_int_1 = unsigned_int_3 + unsigned_int_2;
for(int looper_3=0; looper_3<1;looper_3++)
{
float float_1 = 1;
float float_2 = 1;
short short_3 = 1;
char char_5 = 1;
double double_8 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
float_2 = float_1 + float_1;
short_3 = short_3 * short_3;
int_4 = int_2 + int_5;
char_5 = char_5 * char_2;
double_8 = double_5;
double_6 = double_3 + double_6;
int_3 = int_2 + int_5;
if(1)
{
double_9 = double_2;
}
if(1)
{
int_5 = int_1;
}
if(1)
{
char_5 = char_1 + char_2;
}
unsigned_int_1 = unsigned_int_2 + unsigned_int_2;
if(1)
{
double_1 = double_1 * double_1;
if(1)
{
double_6 = double_3 * double_6;
}
}
if(1)
{
int_4 = int_6 * int_3;
}
if(1)
{
int int_9 = 1;
short short_4 = 1;
int_7 = int_5;
double_5 = double_9 * double_1;
unsigned_int_3 = unsigned_int_3 * unsigned_int_1;
unsigned_int_2 = unsigned_int_1;
short_2 = short_1 * short_2;
int_9 = int_8 * int_3;
short_4 = short_1 + short_3;
}
}
}
if(1)
{
unsigned_int_5 = unsigned_int_3 * unsigned_int_4;
}
int_7 = int_8 + int_6;
unsigned_int_5 = unsigned_int_5 * unsigned_int_5;
for(int looper_4=0; looper_4<1;looper_4++)
{
unsigned int unsigned_int_6 = 1;
unsigned_int_6 = unsigned_int_5;
}
if(1)
{
double double_10 = 1;
double_3 = double_10 + double_9;
double_1 = double_7 + double_7;
}
unsigned_int_1 = unsigned_int_4 * unsigned_int_4;
}
long v_stats_loop()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
float float_1 = 1;
double double_1 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
return long_1;
v_event_loop_stats(float_1);
double_1 = v_stats_loop_callback();
}
int v_nc_set_reuseaddr( int parameter_1)
{
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
int int_4 = 1;
float_1 = float_1;
int_3 = int_1 + int_2;
double_2 = double_1 + double_2;
int_3 = int_2 + int_3;
return int_4;
}
double v_nc_resolve_inet( float parameter_1,int parameter_2,double parameter_3)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
double double_2 = 1;
double double_3 = 1;
float float_1 = 1;
float float_2 = 1;
long long_2 = 1;
short short_4 = 1;
float float_3 = 1;
int int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_2 = 1;
int int_3 = 1;
float float_5 = 1;
float float_6 = 1;
char_3 = char_1 * char_2;
long_1 = long_1 * long_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
double_1 = double_1;
double_1 = double_1;
short_3 = short_1 * short_2;
double_3 = double_2 + double_1;
float_2 = float_1 * float_2;
long_1 = long_2 + long_2;
short_1 = short_2 + short_3;
short_1 = short_4 + short_3;
float_1 = float_3;
int_1 = int_1 + int_1;
if(1)
{
unsigned_int_1 = unsigned_int_2 * unsigned_int_3;
}
if(1)
{
short_1 = v_nc_valid_port(int_2);
double_1 = double_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_3;
}
int_1 = int_3 * int_2;
unsigned_int_3 = unsigned_int_3;
if(1)
{
float float_4 = 1;
float_4 = float_4 + float_5;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_3 = 1;
unsigned int unsigned_int_4 = 1;
int_3 = int_1 * int_1;
long_3 = long_1 + long_3;
double_1 = double_2 * double_3;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_4 = unsigned_int_3 * unsigned_int_4;
}
float_5 = float_2 + float_6;
float_6 = float_5 + float_2;
return double_1;
}
char v_nc_resolve_unix( int parameter_1,short parameter_2)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
char char_1 = 1;
double_1 = double_2;
if(1)
{
}
double_4 = double_3 * double_2;
int_3 = int_1 + int_2;
int_3 = int_3 * int_2;
int_2 = int_2 * int_2;
int_1 = int_4 + int_3;
double_1 = double_4;
return char_1;
}
int v_nc_resolve( double parameter_1,int parameter_2,short parameter_3)
{
int int_1 = 1;
char char_1 = 1;
int int_2 = 1;
short short_1 = 1;
double double_1 = 1;
float float_1 = 1;
double double_2 = 1;
if(1)
{
}
return int_1;
char_1 = v_nc_resolve_unix(int_2,short_1);
double_1 = v_nc_resolve_inet(float_1,int_2,double_2);
}
char v_stats_listen( float parameter_1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
double double_4 = 1;
double double_5 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
short short_4 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
char char_1 = 1;
double_1 = double_1;
double_3 = double_2 * double_3;
short_1 = short_1 + short_2;
if(1)
{
}
short_3 = short_2 + short_2;
if(1)
{
double_1 = double_1;
}
double_4 = double_2;
if(1)
{
double double_6 = 1;
double_5 = double_6;
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
if(1)
{
int_1 = v_nc_resolve(double_4,int_1,short_4);
int_1 = v_nc_set_reuseaddr(int_2);
int_3 = int_3;
}
int_4 = int_3 + int_2;
if(1)
{
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
unsigned_int_5 = unsigned_int_3 + unsigned_int_4;
}
double_1 = double_3 * double_5;
return char_1;
}
float v_stats_start_aggregator( unsigned int parameter_1)
{
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
float float_1 = 1;
long long_1 = 1;
int int_1 = 1;
long long_2 = 1;
short_1 = short_1 + short_2;
if(1)
{
}
char_1 = v_stats_listen(float_1);
long_1 = long_1 * long_1;
if(1)
{
}
int_1 = int_1 * int_1;
if(1)
{
long_2 = v_stats_loop();
short_1 = short_2 + short_1;
}
return float_1;
}
void v_stats_create_buf( long parameter_1)
{
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
float float_1 = 1;
double double_3 = 1;
double double_4 = 1;
int int_5 = 1;
int int_6 = 1;
unsigned int unsigned_int_1 = 1;
int int_7 = 1;
short short_3 = 1;
short short_4 = 1;
char char_4 = 1;
unsigned int unsigned_int_2 = 1;
double double_5 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
unsigned int unsigned_int_4 = 1;
float float_3 = 1;
double double_6 = 1;
float float_4 = 1;
long long_2 = 1;
short short_5 = 1;
float float_5 = 1;
float float_6 = 1;
long long_3 = 1;
long long_4 = 1;
char char_5 = 1;
int_1 = int_1 * int_1;
double_2 = double_1 + double_2;
short_1 = short_1 + short_2;
double_2 = double_2 * double_2;
short_2 = short_1 + short_1;
short_1 = short_1 + short_2;
double_1 = double_2 + double_2;
double_2 = double_1 * double_2;
int_4 = int_2 + int_3;
char_2 = char_1 + char_1;
char_3 = char_2 + char_1;
float_1 = float_1;
double_4 = double_1 * double_3;
int_5 = int_6;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
int_7 = int_2 * int_7;
short_4 = short_3 + short_1;
char_4 = char_1 * char_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
double_5 = double_3 + double_1;
unsigned_int_2 = v_array_n(float_1);
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
unsigned_int_1 = unsigned_int_3;
float_2 = float_2 * float_1;
int_5 = int_3 * int_6;
unsigned_int_4 = unsigned_int_1 * unsigned_int_3;
double_5 = double_4 * double_3;
float_3 = float_2 * float_2;
unsigned_int_4 = unsigned_int_1 + unsigned_int_4;
double_1 = double_4 + double_6;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_8 = 1;
int_8 = int_1;
unsigned_int_4 = unsigned_int_3 + unsigned_int_1;
double_3 = double_4 * double_1;
int_1 = int_8;
for(int looper_2=0; looper_2<1;looper_2++)
{
long long_1 = 1;
unsigned int unsigned_int_5 = 1;
float_4 = float_3 * float_3;
unsigned_int_3 = unsigned_int_4 + unsigned_int_1;
long_2 = long_1 * long_2;
unsigned_int_5 = unsigned_int_1;
}
for(int looper_3=0; looper_3<1;looper_3++)
{
short_1 = short_2 * short_1;
short_2 = short_5 + short_5;
float_1 = float_3 * float_3;
float_6 = float_2 + float_5;
for(int looper_4=0; looper_4<1;looper_4++)
{
unsigned int unsigned_int_6 = 1;
unsigned int unsigned_int_7 = 1;
unsigned_int_6 = unsigned_int_4 + unsigned_int_4;
long_4 = long_3 * long_4;
long_2 = v_array_get(long_4,char_5);
unsigned_int_4 = unsigned_int_1 * unsigned_int_1;
unsigned_int_7 = unsigned_int_3 * unsigned_int_7;
}
}
}
int_6 = int_6 + int_3;
float_6 = float_5 * float_4;
double_3 = double_6 + double_6;
if(1)
{
float_1 = float_2;
}
short_5 = short_3 + short_1;
long_4 = long_3 + long_4;
}
char v_stats_metric_deinit( char parameter_1)
{
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
double double_1 = 1;
char char_1 = 1;
double double_2 = 1;
int int_3 = 1;
int int_4 = 1;
short_2 = short_1 + short_1;
unsigned_int_1 = v_array_n(float_1);
double_1 = v_array_pop(char_1);
double_2 = double_2 + double_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_1 = 1;
int int_2 = 1;
v_array_deinit(unsigned_int_1);
int_1 = int_1 + int_2;
}
int_4 = int_3 * int_4;
return char_1;
}
float v_stats_server_metric_init( int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
float float_1 = 1;
float float_3 = 1;
float float_4 = 1;
long_2 = long_1 * long_2;
double_2 = double_1 * double_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "=") < 0)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_4 = 1;
int int_1 = 1;
float float_2 = 1;
unsigned_int_3 = unsigned_int_4;
int_1 = int_1;
v_array_init(char_1,float_1,long_1);
char_1 = v_stats_metric_init(unsigned_int_3);
float_1 = float_2 + float_2;
}
return float_3;
float_3 = v_array_push(float_4);
}
int v_stats_server_init( long parameter_1,unsigned int parameter_2)
{
int int_1 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
int_1 = v_array_null(float_1);
unsigned_int_1 = v_array_n(float_1);
short_2 = short_1 + short_1;
float_1 = v_stats_server_metric_init(int_2);
double_3 = double_1 * double_2;
int_2 = int_2 + int_1;
long_3 = long_1 * long_2;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "eR") > 0)
{
}
int_1 = int_2;
return int_1;
}
char v_stats_server_map( char parameter_1,float parameter_2)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
int int_4 = 1;
unsigned int unsigned_int_2 = 1;
float float_2 = 1;
unsigned int unsigned_int_4 = 1;
char char_2 = 1;
unsigned_int_1 = v_array_n(float_1);
double_2 = double_1 * double_1;
double_3 = double_1 + double_1;
int_1 = int_1;
int_3 = int_1 * int_2;
v_array_init(char_1,float_1,long_1);
long_2 = long_1 * long_2;
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
short short_2 = 1;
long_2 = long_2 + long_3;
int_4 = v_stats_server_init(long_3,unsigned_int_2);
unsigned_int_2 = unsigned_int_1 + unsigned_int_3;
short_2 = short_1 + short_1;
if(1)
{
}
}
float_2 = v_array_push(float_2);
unsigned_int_1 = unsigned_int_4 * unsigned_int_1;
return char_2;
long_3 = v_array_get(long_3,char_1);
}
char v_stats_metric_init( unsigned int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
float float_1 = 1;
float float_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
int_2 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
double_1 = double_1 + double_1;
float_2 = float_1 + float_1;
double_1 = double_1 + double_1;
int_1 = int_3 * int_1;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
return char_1;
}
short v_stats_pool_metric_init( float parameter_1)
{
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
float float_1 = 1;
char char_2 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
char_1 = char_1;
int_1 = int_1 * int_2;
int_2 = int_3 * int_2;
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_2 = 1;
int int_4 = 1;
double double_1 = 1;
double double_2 = 1;
long_2 = long_1 * long_1;
float_1 = v_array_push(float_1);
int_3 = int_4 * int_2;
v_array_init(char_2,float_2,long_1);
char_1 = v_stats_metric_init(unsigned_int_1);
double_1 = double_2;
}
return short_1;
}
int v_stats_pool_init( float parameter_1,unsigned int parameter_2)
{
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_2 = 1;
int int_3 = 1;
float float_3 = 1;
short short_1 = 1;
short short_2 = 1;
char_1 = v_stats_metric_deinit(char_2);
double_3 = double_1 * double_2;
int_2 = int_1 * int_1;
char_1 = v_stats_server_map(char_1,float_1);
unsigned_int_1 = v_array_n(float_1);
unsigned_int_1 = unsigned_int_2 * unsigned_int_2;
int_2 = v_array_null(float_2);
int_3 = int_3;
float_3 = float_1;
if(1)
{
}
short_1 = v_stats_pool_metric_init(float_2);
short_2 = short_1 * short_1;
if(1)
{
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
}
unsigned_int_2 = unsigned_int_2 + unsigned_int_1;
return int_3;
}
unsigned int v_stats_pool_map( float parameter_1,unsigned int parameter_2)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
double double_1 = 1;
float float_2 = 1;
float float_3 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
long long_1 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
unsigned_int_1 = v_array_n(float_1);
double_1 = double_1;
float_2 = v_array_push(float_3);
int_2 = int_1 + int_1;
unsigned_int_2 = unsigned_int_2 + unsigned_int_1;
v_array_init(char_1,float_2,long_1);
float_2 = float_3 + float_3;
float_3 = float_1 + float_2;
if(1)
{
}
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_3 = int_2 + int_3;
long_1 = v_array_get(long_1,char_1);
int_3 = int_2 * int_1;
if(1)
{
}
}
int_3 = v_stats_pool_init(float_3,unsigned_int_3);
unsigned_int_2 = unsigned_int_2 * unsigned_int_3;
return unsigned_int_3;
}
long v_stats_create( double parameter_1,char parameter_2,int parameter_3,char parameter_4,short parameter_5)
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_3 = 1;
int int_4 = 1;
unsigned int unsigned_int_3 = 1;
char char_1 = 1;
char char_2 = 1;
short short_1 = 1;
short short_2 = 1;
int int_5 = 1;
double double_3 = 1;
double double_4 = 1;
long long_3 = 1;
long long_4 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_4 = 1;
float float_5 = 1;
float float_6 = 1;
int int_6 = 1;
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
unsigned int unsigned_int_7 = 1;
int int_7 = 1;
int int_8 = 1;
int_2 = int_1 + int_1;
float_2 = float_1 * float_2;
long_2 = long_1 + long_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, ".6") > 0)
{
}
double_1 = double_1 + double_2;
double_1 = double_1;
float_2 = v_stats_start_aggregator(unsigned_int_1);
unsigned_int_2 = unsigned_int_2;
int_2 = int_3 + int_4;
int_3 = int_3 * int_3;
unsigned_int_2 = unsigned_int_3 + unsigned_int_2;
char_2 = char_1 * char_2;
int_2 = int_4 * int_2;
short_2 = short_1 + short_1;
int_5 = int_4 + int_5;
double_4 = double_1 * double_3;
long_3 = long_1 + long_3;
float_1 = float_2;
v_stats_create_buf(long_4);
long_2 = long_3 * long_3;
int_4 = v_array_null(float_2);
int_3 = int_2 * int_1;
int_1 = int_3 * int_3;
float_3 = float_1 + float_3;
double_4 = double_4;
float_4 = float_1 * float_2;
unsigned_int_1 = unsigned_int_4 + unsigned_int_3;
unsigned_int_3 = unsigned_int_2;
float_6 = float_5 * float_2;
int_6 = int_4 + int_2;
long_3 = long_4 * long_1;
float_1 = float_6 * float_5;
if(1)
{
unsigned_int_5 = unsigned_int_5;
}
unsigned_int_1 = unsigned_int_5;
if(1)
{
unsigned_int_4 = v_stats_pool_map(float_6,unsigned_int_3);
unsigned_int_7 = unsigned_int_6 + unsigned_int_7;
}
unsigned_int_6 = unsigned_int_1 + unsigned_int_7;
if(1)
{
int_4 = int_7;
}
v_stats_destroy(short_1);
int_4 = int_7 + int_8;
if(1)
{
unsigned int unsigned_int_8 = 1;
unsigned_int_2 = unsigned_int_8 * unsigned_int_4;
}
int_8 = int_7 + int_3;
if(1)
{
double double_5 = 1;
double_4 = double_5 + double_1;
}
int_2 = int_2 * int_5;
return long_3;
}
int v_core_calc_connections( short parameter_1)
{
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
int int_4 = 1;
char_1 = char_1 + char_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
if(1)
{
int int_1 = 1;
int_2 = int_1 + int_1;
}
int_2 = int_2 + int_3;
char_1 = char_2 + char_2;
long_2 = long_1 + long_1;
return int_4;
}
short v_random_update( long parameter_1)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_4 = 1;
double double_3 = 1;
double double_4 = 1;
short short_3 = 1;
float float_3 = 1;
short short_4 = 1;
int_1 = int_2;
double_1 = double_2;
unsigned_int_1 = unsigned_int_2;
short_1 = short_1 + short_2;
char_3 = char_1 + char_2;
int_1 = int_2 + int_2;
long_2 = long_1 + long_1;
short_2 = short_2 * short_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_3;
short_1 = short_2 + short_2;
float_2 = float_1 + float_1;
unsigned_int_2 = unsigned_int_4 + unsigned_int_1;
double_2 = double_3 + double_4;
if(1)
{
double_4 = double_3 * double_4;
long_2 = long_1 * long_1;
unsigned_int_1 = v_array_n(float_2);
char_1 = char_2 + char_3;
unsigned_int_1 = unsigned_int_3 * unsigned_int_3;
if(1)
{
}
short_2 = short_1 + short_3;
double_2 = double_2 * double_3;
double_1 = double_4;
}
float_2 = float_2 + float_1;
float_2 = float_3 * float_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_3 = 1;
long long_4 = 1;
unsigned int unsigned_int_5 = 1;
short_2 = short_3 * short_3;
long_4 = long_1 * long_3;
unsigned_int_4 = unsigned_int_4 * unsigned_int_5;
unsigned_int_1 = unsigned_int_4 + unsigned_int_5;
}
short_1 = short_4 * short_4;
int_1 = int_1;
return short_4;
}
void v_modula_update( int parameter_1)
{
float float_1 = 1;
long long_1 = 1;
char char_1 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
int int_4 = 1;
int int_5 = 1;
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
float float_2 = 1;
float float_3 = 1;
double double_7 = 1;
float float_4 = 1;
float float_5 = 1;
short short_4 = 1;
float float_6 = 1;
float_1 = float_1;
long_1 = v_array_get(long_1,char_1);
long_4 = long_2 * long_3;
short_2 = short_1 + short_1;
int_1 = int_2;
double_1 = double_1 + double_2;
double_4 = double_3 + double_2;
unsigned_int_1 = unsigned_int_2;
unsigned_int_3 = v_array_n(float_1);
int_2 = int_3 + int_4;
int_5 = int_1 + int_3;
unsigned_int_1 = unsigned_int_2 * unsigned_int_3;
char_2 = char_1;
char_4 = char_3 + char_3;
long_4 = long_1 * long_3;
float_3 = float_2 * float_3;
char_2 = char_3;
int_5 = int_4 * int_3;
if(1)
{
double double_5 = 1;
double double_6 = 1;
long_4 = long_3 + long_4;
long_2 = long_4 + long_4;
double_5 = double_3 * double_5;
double_4 = double_6 * double_7;
if(1)
{
}
int_1 = int_2 + int_5;
char_1 = char_3;
}
double_1 = double_7;
float_3 = float_4 * float_5;
for(int looper_1=0; looper_1<1;looper_1++)
{
short_2 = short_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
short short_3 = 1;
int_3 = int_5 + int_3;
short_1 = short_1 * short_2;
short_2 = short_3;
float_3 = float_4 * float_3;
}
}
short_4 = short_2;
float_6 = float_1 + float_3;
}
unsigned int v_ketama_item_cmp( long parameter_1,float parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
if(1)
{
}
if(1)
{
}
if(1)
{
}
return unsigned_int_1;
}
void v_md5_signature( float parameter_1,long parameter_2,double parameter_3)
{
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_4 = 1;
char_2 = char_1 + char_1;
double_3 = double_1 * double_2;
unsigned_int_1 = unsigned_int_1;
int_3 = int_1 * int_2;
double_4 = double_3 * double_2;
}
long v_ketama_hash( unsigned int parameter_1,unsigned int parameter_2,unsigned int parameter_3)
{
float float_1 = 1;
long long_1 = 1;
double double_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
long long_2 = 1;
v_md5_signature(float_1,long_1,double_1);
char_1 = char_1 * char_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
return long_2;
}
double v_ketama_update( int parameter_1)
{
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
float float_2 = 1;
long long_2 = 1;
long long_3 = 1;
long long_4 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
double double_3 = 1;
double double_4 = 1;
double double_5 = 1;
double double_6 = 1;
double double_7 = 1;
int int_1 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
float float_3 = 1;
int int_2 = 1;
double double_8 = 1;
int int_3 = 1;
int int_5 = 1;
int int_6 = 1;
int int_7 = 1;
unsigned int unsigned_int_3 = 1;
long_1 = long_1 + long_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
float_2 = float_1 + float_2;
long_3 = long_2 * long_3;
long_2 = long_4;
long_3 = long_4 + long_4;
long_3 = long_1 + long_2;
double_1 = double_2;
short_1 = short_1 + short_1;
double_3 = double_2 * double_3;
double_5 = double_4 * double_2;
double_7 = double_6 + double_4;
int_1 = int_1 * int_1;
char_3 = char_1 * char_2;
unsigned_int_1 = v_ketama_item_cmp(long_4,float_3);
double_2 = double_5 * double_4;
int_2 = int_1 + int_1;
double_5 = double_8 * double_5;
int_3 = int_1 * int_1;
if(1)
{
int int_4 = 1;
short short_2 = 1;
short short_3 = 1;
long_1 = long_4 * long_4;
double_6 = double_3 + double_7;
int_4 = int_4;
int_1 = int_5 * int_1;
if(1)
{
}
short_2 = short_3;
int_2 = int_6;
}
double_2 = double_3 + double_6;
int_3 = int_2 + int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
double_3 = double_4 * double_7;
int_1 = int_3;
unsigned_int_2 = v_array_n(float_2);
float_2 = float_2 + float_2;
char_2 = char_3;
long_1 = long_4 * long_1;
float_2 = float_3 + float_3;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
for(int looper_2=0; looper_2<1;looper_2++)
{
unsigned_int_2 = unsigned_int_2 + unsigned_int_2;
long_3 = v_array_get(long_1,char_3);
long_2 = long_2 * long_4;
int_1 = int_3 * int_1;
long_3 = long_2;
for(int looper_3=0; looper_3<1;looper_3++)
{
double_3 = double_2 * double_2;
double_2 = double_5 * double_2;
int_1 = int_3 * int_5;
}
}
long_3 = long_3 + long_3;
}
double_2 = double_7;
int_6 = int_2 * int_5;
for(int looper_4=0; looper_4<1;looper_4++)
{
char char_4 = 1;
if(1)
{
double double_9 = 1;
double_9 = double_7 + double_1;
}
char_4 = char_4 + char_3;
}
int_7 = int_1 * int_5;
return double_6;
long_4 = v_ketama_hash(unsigned_int_1,unsigned_int_2,unsigned_int_3);
}
char v_server_pool_run()
{
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
char char_1 = 1;
short short_1 = 1;
long long_1 = 1;
v_modula_update(int_1);
double_3 = double_1 + double_2;
unsigned_int_1 = v_array_n(float_1);
double_1 = double_2 * double_2;
return char_1;
double_2 = v_ketama_update(int_1);
short_1 = v_random_update(long_1);
}
unsigned int v_server_pool_each_run()
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
return unsigned_int_1;
char_1 = v_server_pool_run();
}
float v_server_pool_each_calc_connections()
{
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_3 = 1;
short short_4 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
float float_2 = 1;
short_2 = short_1 * short_2;
short_1 = short_2 * short_2;
int_2 = int_1 + int_2;
short_2 = short_3 * short_4;
unsigned_int_1 = v_array_n(float_1);
short_3 = short_4 + short_1;
return float_2;
}
char v_server_pool_each_set_owner()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
int int_1 = 1;
char char_1 = 1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_3 = unsigned_int_4 + unsigned_int_1;
int_1 = int_1 * int_1;
return char_1;
}
void v_server_pool_deinit( long parameter_1)
{
double double_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
int int_3 = 1;
double double_2 = 1;
float float_4 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
double_1 = v_array_pop(char_1);
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_1 = 1;
int int_4 = 1;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
char char_2 = 1;
char char_3 = 1;
double double_3 = 1;
int_1 = int_1 + int_2;
v_array_deinit(unsigned_int_2);
int_4 = int_3 * int_1;
long_1 = long_1 + long_2;
float_3 = float_1 * float_2;
char controller_1[2];
fgets(controller_1 ,2 ,stdin);
if( strcmp( controller_1, "o") > 0)
{
short short_1 = 1;
v_sentinel_deinit(int_3);
double_1 = double_1 * double_2;
short_1 = short_1 * short_1;
int_3 = int_4 * int_4;
unsigned_int_1 = unsigned_int_2 + unsigned_int_2;
}
unsigned_int_1 = v_array_n(float_4);
v_server_deinit(int_2);
char_3 = char_1 * char_2;
double_2 = double_1 * double_2;
double_2 = double_3;
}
unsigned_int_3 = unsigned_int_3 + unsigned_int_1;
double_4 = double_1 * double_2;
}
int v_sentinel_each_set_owner()
{
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
float_1 = float_1 * float_1;
double_2 = double_1 * double_2;
int_1 = int_1 * int_1;
return int_1;
}
void v_array_destroy( unsigned int parameter_1)
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
v_array_deinit(unsigned_int_1);
char_1 = char_2;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
}
void v_mbuf_put( short parameter_1)
{
short short_1 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
int int_1 = 1;
int int_2 = 1;
double double_3 = 1;
short_1 = short_1 * short_1;
double_1 = double_2;
float_3 = float_1 + float_2;
int_2 = int_1 + int_1;
double_3 = double_3 + double_2;
}
void v_mbuf_remove( double parameter_1,short parameter_2)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
char char_1 = 1;
char char_2 = 1;
double_2 = double_1 + double_1;
double_3 = double_3;
char_2 = char_1 + char_1;
}
void v_msg_put( long parameter_1)
{
double double_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
v_mbuf_remove(double_1,short_1);
v_mbuf_put(short_1);
v_array_destroy(unsigned_int_1);
}
void v_sentinel_deinit( int parameter_1)
{
double double_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
double_1 = v_array_pop(char_1);
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
double double_2 = 1;
char_4 = char_2 + char_3;
v_array_deinit(unsigned_int_3);
double_2 = double_1 + double_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "=/") < 0)
{
unsigned_int_3 = unsigned_int_2 * unsigned_int_1;
}
unsigned_int_1 = unsigned_int_3;
}
unsigned_int_2 = v_array_n(float_1);
int_2 = int_1 + int_1;
v_msg_put(long_1);
}
void v_array_create( char parameter_1,unsigned int parameter_2)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float_1 = float_1 * float_2;
int_1 = int_2;
int_1 = int_3 * int_1;
if(1)
{
}
double_1 = double_1 * double_2;
if(1)
{
float float_3 = 1;
float_1 = float_3 + float_1;
}
char_1 = char_2;
unsigned_int_1 = unsigned_int_1;
unsigned_int_1 = unsigned_int_2;
}
long v__msg_get()
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
int int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
double double_3 = 1;
double double_4 = 1;
char char_5 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
double double_5 = 1;
float float_4 = 1;
float float_5 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
float float_6 = 1;
short short_4 = 1;
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
char char_6 = 1;
int int_3 = 1;
unsigned int unsigned_int_7 = 1;
int int_4 = 1;
int int_5 = 1;
float float_7 = 1;
int int_6 = 1;
short short_5 = 1;
long long_3 = 1;
long long_4 = 1;
int int_7 = 1;
int int_8 = 1;
char_3 = char_1 * char_2;
if(1)
{
long long_2 = 1;
char_1 = char_4 + char_4;
long_1 = long_1 + long_2;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
int_1 = int_1;
double_2 = double_1 + double_1;
}
int_2 = int_1 + int_2;
if(1)
{
}
v_rbtree_node_init(unsigned_int_1);
v_array_create(char_2,unsigned_int_2);
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_4 = unsigned_int_1;
double_3 = double_2 + double_3;
double_4 = double_3 * double_1;
char_5 = char_1 + char_2;
float_3 = float_1 + float_2;
double_5 = double_4 + double_3;
long_1 = long_1;
float_2 = float_1 * float_4;
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
float_5 = float_5;
short_3 = short_1 + short_2;
float_4 = float_6 * float_6;
short_4 = short_2 + short_1;
unsigned_int_5 = unsigned_int_1 + unsigned_int_5;
unsigned_int_2 = unsigned_int_6 * unsigned_int_4;
double_5 = double_3;
char_3 = char_6 + char_6;
char_6 = char_1 * char_4;
if(1)
{
int_1 = int_1 * int_2;
}
char_1 = char_1 * char_4;
float_4 = float_1 * float_2;
unsigned_int_3 = unsigned_int_3 + unsigned_int_5;
int_1 = int_3;
double_4 = double_1 * double_3;
unsigned_int_1 = unsigned_int_2 + unsigned_int_6;
unsigned_int_4 = unsigned_int_4 * unsigned_int_1;
unsigned_int_4 = unsigned_int_6 + unsigned_int_4;
double_4 = double_2;
short_4 = short_4 * short_2;
unsigned_int_4 = unsigned_int_7 * unsigned_int_3;
int_5 = int_2 + int_4;
double_1 = double_5 + double_4;
float_6 = float_7 + float_3;
int_4 = int_3 + int_6;
short_5 = short_5;
unsigned_int_6 = unsigned_int_1 * unsigned_int_2;
int_5 = int_5 * int_5;
long_3 = long_4;
float_4 = float_2 * float_5;
long_1 = long_3;
float_1 = float_4 * float_6;
int_8 = int_7 + int_4;
return long_4;
}
double v_msg_get_raw()
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
long long_1 = 1;
double double_4 = 1;
int_2 = int_1 * int_2;
double_3 = double_1 * double_2;
if(1)
{
}
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
long_1 = v__msg_get();
double_3 = double_2 + double_1;
return double_4;
}
void v_conf_sentinel_each_transform()
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
float float_1 = 1;
float float_2 = 1;
int int_4 = 1;
char char_1 = 1;
short short_3 = 1;
double double_4 = 1;
int int_5 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_6 = 1;
long long_3 = 1;
long long_4 = 1;
float float_3 = 1;
double_2 = double_1 * double_1;
double_1 = double_3 + double_2;
int_2 = int_1 * int_2;
long_2 = long_1 * long_1;
double_3 = double_3 * double_1;
int_3 = int_2 + int_1;
short_2 = short_1 * short_1;
float_1 = v_array_push(float_2);
int_3 = int_3 * int_4;
char_1 = char_1;
short_1 = short_3 + short_1;
double_3 = double_1 + double_4;
int_5 = int_4 * int_2;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
v_array_idx(float_2);
int_1 = int_6 + int_4;
unsigned_int_2 = unsigned_int_2;
double_2 = double_3 + double_1;
char_1 = char_1 * char_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "jN") > 0)
{
}
double_2 = v_msg_get_raw();
long_3 = long_3 * long_4;
float_3 = float_3;
}
char v_sentinel_init( short parameter_1,unsigned int parameter_2,int parameter_3)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
short short_1 = 1;
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
short short_2 = 1;
long long_2 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
short short_3 = 1;
short short_4 = 1;
double double_3 = 1;
char_3 = char_1 + char_2;
short_1 = v_array_each(long_1);
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
unsigned_int_1 = v_array_n(float_1);
v_conf_sentinel_each_transform();
v_sentinel_deinit(int_1);
double_2 = double_1 + double_1;
short_2 = short_1 * short_2;
v_array_init(char_1,float_1,long_2);
long_1 = long_2 + long_1;
int_3 = int_2 + int_1;
if(1)
{
}
char_2 = char_2 + char_1;
if(1)
{
int_4 = int_4 + int_1;
}
short_4 = short_1 * short_3;
int_3 = int_3 * int_2;
if(1)
{
long long_3 = 1;
long_3 = long_2;
}
double_1 = double_1 * double_3;
return char_2;
int_4 = v_sentinel_each_set_owner();
}
void v_server_each_set_owner()
{
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
short_1 = short_2;
double_2 = double_1 + double_2;
}
void v_server_deinit( int parameter_1)
{
short short_1 = 1;
short short_2 = 1;
long long_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
float float_2 = 1;
v_string_deinit();
short_2 = short_1 + short_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_1 = 1;
double double_3 = 1;
long_2 = long_1 + long_2;
float_1 = float_1 + float_1;
if(1)
{
unsigned_int_1 = v_array_n(float_1);
double_1 = double_1 + double_1;
}
if(1)
{
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
}
double_2 = v_array_pop(char_1);
double_3 = double_1;
}
long_2 = v_string_empty(double_1);
float_1 = float_2 * float_2;
v_array_deinit(unsigned_int_1);
}
int v_conf_server_each_transform()
{
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
double double_3 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_4 = 1;
float float_5 = 1;
float float_6 = 1;
double double_5 = 1;
short short_1 = 1;
short short_2 = 1;
double double_6 = 1;
short short_3 = 1;
short short_4 = 1;
int int_2 = 1;
v_array_idx(float_1);
float_1 = float_2 + float_2;
double_2 = double_1 * double_1;
v_string_init(float_1);
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
int_1 = int_1;
double_1 = double_1;
float_2 = v_array_push(float_2);
double_3 = double_3 * double_3;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
double_3 = double_1 * double_2;
unsigned_int_3 = unsigned_int_3 * unsigned_int_3;
double_4 = double_3 + double_2;
float_4 = float_1 * float_3;
unsigned_int_3 = unsigned_int_4 + unsigned_int_2;
float_5 = float_6;
double_5 = double_3;
short_2 = short_1 * short_1;
float_1 = float_3;
double_6 = double_4 * double_4;
short_1 = short_3 * short_4;
return int_2;
}
long v_server_init( int parameter_1,unsigned int parameter_2,int parameter_3)
{
short short_1 = 1;
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
long long_2 = 1;
char char_2 = 1;
char char_3 = 1;
double double_3 = 1;
double double_4 = 1;
char char_4 = 1;
int int_1 = 1;
int int_2 = 1;
long long_3 = 1;
short_1 = v_array_each(long_1);
double_2 = double_1 * double_2;
float_3 = float_1 + float_2;
unsigned_int_1 = unsigned_int_2;
v_array_init(char_1,float_2,long_2);
char_3 = char_2 * char_1;
double_2 = double_2 * double_2;
double_3 = double_4;
if(1)
{
}
v_server_each_set_owner();
char_1 = char_1;
if(1)
{
long_1 = long_1 * long_1;
}
char_1 = char_4 * char_1;
double_3 = double_1 + double_1;
if(1)
{
unsigned int unsigned_int_3 = 1;
unsigned_int_2 = v_array_n(float_2);
v_server_deinit(int_1);
unsigned_int_3 = unsigned_int_1 * unsigned_int_1;
}
int_2 = int_1;
return long_3;
int_1 = v_conf_server_each_transform();
}
void v_array_idx( float parameter_1)
{
int int_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
int int_3 = 1;
int_1 = int_1 * int_2;
double_2 = double_1 + double_2;
double_1 = double_3;
long_1 = long_1 + long_1;
long_2 = long_1;
short_1 = short_1 + short_1;
long_2 = long_2;
int_3 = int_2 + int_2;
}
char v_conf_pool_each_transform()
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
float float_1 = 1;
float float_2 = 1;
char char_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_4 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
float float_3 = 1;
short short_2 = 1;
double double_5 = 1;
double double_6 = 1;
double double_7 = 1;
long long_1 = 1;
float float_4 = 1;
double double_8 = 1;
int int_4 = 1;
int int_5 = 1;
long long_2 = 1;
float float_5 = 1;
short short_3 = 1;
short short_4 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
unsigned_int_1 = unsigned_int_3 * unsigned_int_3;
double_2 = double_1 * double_1;
double_4 = double_2 + double_3;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
float_2 = float_1 * float_2;
char_1 = v_sentinel_init(short_1,unsigned_int_4,int_1);
int_1 = int_1 * int_1;
int_2 = int_1 * int_1;
int_2 = int_2 * int_3;
char_4 = char_2 * char_3;
int_3 = int_2 + int_2;
unsigned_int_4 = unsigned_int_2 + unsigned_int_1;
double_4 = double_2 * double_2;
unsigned_int_1 = unsigned_int_1;
char_1 = char_3 + char_1;
double_2 = double_4 * double_3;
int_3 = int_2 + int_3;
short_1 = short_1;
float_2 = v_array_push(float_3);
char_2 = char_4 + char_1;
short_1 = short_2 * short_1;
double_6 = double_5 * double_2;
double_2 = double_7 * double_5;
long_1 = long_1;
unsigned_int_2 = unsigned_int_3 * unsigned_int_1;
int_1 = int_2 * int_3;
int_2 = v_array_null(float_1);
double_6 = double_6 * double_5;
char_4 = char_1;
float_4 = float_4 * float_3;
double_8 = double_4 + double_7;
int_4 = int_2 + int_2;
v_array_idx(float_4);
unsigned_int_1 = unsigned_int_2 * unsigned_int_2;
short_1 = short_1;
int_1 = int_4;
unsigned_int_2 = unsigned_int_3 * unsigned_int_4;
int_4 = int_1 + int_5;
double_7 = double_7 + double_1;
long_2 = long_1 * long_2;
float_5 = float_1 + float_4;
float_3 = float_1;
short_3 = short_2 * short_2;
double_3 = double_1 + double_5;
if(1)
{
}
short_4 = short_3;
if(1)
{
}
long_2 = v_server_init(int_4,unsigned_int_4,int_2);
long_1 = long_2;
return char_2;
}
short v_array_each( long parameter_1)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
long long_1 = 1;
short short_4 = 1;
char_2 = char_1 * char_2;
char_3 = char_2 * char_2;
short_2 = short_1 * short_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_4 = 1;
short short_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
char_2 = char_2 * char_4;
short_3 = short_1 * short_3;
unsigned_int_1 = v_array_n(float_1);
long_1 = v_array_get(long_1,char_2);
double_3 = double_1 + double_2;
if(1)
{
}
}
return short_4;
}
int v_server_pool_init( char parameter_1,int parameter_2,float parameter_3)
{
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
double double_3 = 1;
double double_4 = 1;
char char_1 = 1;
float float_2 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_3 = 1;
char char_2 = 1;
char char_3 = 1;
int int_3 = 1;
char char_4 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_4 = 1;
unsigned int unsigned_int_4 = 1;
float float_4 = 1;
float_1 = v_server_pool_each_calc_connections();
double_2 = double_1 * double_1;
float_1 = float_1;
v_server_pool_deinit(long_1);
double_2 = double_3 + double_4;
char_1 = char_1 + char_1;
char_1 = v_server_pool_each_set_owner();
float_2 = float_2 + float_2;
v_array_init(char_1,float_1,long_2);
int_2 = int_1 * int_1;
if(1)
{
}
short_2 = short_1 + short_2;
if(1)
{
short_2 = v_array_each(long_3);
char_1 = char_1 * char_1;
}
char_3 = char_2 + char_3;
int_3 = int_2 * int_2;
if(1)
{
char_4 = char_2 * char_4;
}
float_3 = float_3 + float_2;
char_4 = char_1;
if(1)
{
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
}
int_2 = int_1 + int_3;
if(1)
{
unsigned int unsigned_int_3 = 1;
char_4 = v_conf_pool_each_transform();
unsigned_int_2 = v_server_pool_each_run();
unsigned_int_1 = unsigned_int_3 + unsigned_int_2;
}
double_1 = double_1;
return int_4;
unsigned_int_4 = v_array_n(float_4);
}
unsigned int v_core_ctx_create( short parameter_1,int uni_para)
{
float float_1 = 1;
short short_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
short short_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
short short_3 = 1;
unsigned int unsigned_int_6 = 1;
int int_3 = 1;
int int_4 = 1;
short short_4 = 1;
short short_5 = 1;
double double_3 = 1;
int int_5 = 1;
double double_4 = 1;
double double_5 = 1;
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_7 = 1;
int int_6 = 1;
char char_3 = 1;
int int_7 = 1;
float_1 = float_1 * float_1;
short_1 = short_1 + short_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
char controller4vul_2065[2];
fgets(controller4vul_2065 ,2 ,stdin);
if( strcmp( controller4vul_2065, "s") > 0)
{
float_1 = v_proxy_init(short_1,uni_para);
}
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
double_2 = double_1 + double_2;
unsigned_int_3 = unsigned_int_2 * unsigned_int_2;
float_1 = float_2 * float_1;
short_2 = short_1 * short_1;
int_1 = int_2;
unsigned_int_5 = unsigned_int_3 + unsigned_int_4;
short_1 = short_2 + short_3;
unsigned_int_1 = unsigned_int_6 * unsigned_int_6;
float_2 = float_1 + float_2;
int_2 = int_1;
if(1)
{
int_2 = int_2 + int_3;
}
int_2 = int_3 * int_1;
char controller_2[2];
fgets(controller_2 ,2 ,stdin);
if( strcmp( controller_2, "@") < 0)
{
int_1 = int_4 * int_1;
unsigned_int_5 = unsigned_int_5 * unsigned_int_5;
}
short_3 = short_4 * short_5;
if(1)
{
unsigned_int_1 = unsigned_int_5 + unsigned_int_1;
double_3 = double_3;
short_2 = short_4 * short_4;
}
int_4 = int_5 * int_1;
if(1)
{
double_1 = double_2 + double_4;
double_5 = double_1 + double_5;
char_2 = char_1 + char_1;
}
long_1 = long_1 + long_2;
if(1)
{
double double_6 = 1;
double_7 = double_6 * double_5;
int_2 = int_6 + int_2;
float_2 = float_1 * float_2;
double_6 = double_4 * double_6;
}
short_2 = short_1 * short_1;
if(1)
{
double double_8 = 1;
unsigned_int_2 = unsigned_int_3;
char_1 = char_3 * char_3;
int_6 = int_1;
double_8 = double_3 * double_8;
unsigned_int_6 = unsigned_int_1 + unsigned_int_4;
unsigned_int_3 = unsigned_int_2 + unsigned_int_1;
}
int_1 = int_7 * int_5;
if(1)
{
float float_3 = 1;
char char_4 = 1;
double_7 = double_2;
unsigned_int_4 = unsigned_int_5 + unsigned_int_3;
float_1 = float_3;
char_2 = char_4 * char_3;
double_3 = double_4 + double_2;
int_4 = int_4 * int_5;
}
double_4 = double_4 * double_7;
return unsigned_int_3;
}
void v_conn_init()
{
int int_1 = 1;
long long_1 = 1;
char char_1 = 1;
char char_2 = 1;
int_1 = int_1;
long_1 = long_1 + long_1;
char_1 = char_1 * char_2;
}
void v_rbtree_node_init( unsigned int parameter_1)
{
long long_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_3 = 1;
long_1 = long_1 + long_1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
double_1 = double_2;
char_1 = char_1;
unsigned_int_1 = unsigned_int_3 * unsigned_int_3;
}
void v_rbtree_init( float parameter_1,short parameter_2)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
int_2 = int_1 + int_1;
v_rbtree_node_init(unsigned_int_1);
int_3 = int_2 + int_1;
double_2 = double_1 * double_2;
short_1 = short_1 * short_2;
}
void v_msg_init()
{
double double_1 = 1;
double double_2 = 1;
float float_1 = 1;
short short_1 = 1;
float float_2 = 1;
float float_3 = 1;
float float_4 = 1;
float float_5 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
double_1 = double_1 * double_2;
v_rbtree_init(float_1,short_1);
float_1 = float_2 * float_3;
float_5 = float_4 + float_1;
char_2 = char_1 + char_2;
int_3 = int_1 + int_2;
int_3 = int_4 + int_4;
}
void v_mbuf_init( float parameter_1)
{
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
double double_4 = 1;
double double_5 = 1;
int int_2 = 1;
int_1 = int_1;
double_3 = double_1 * double_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
double_5 = double_4 * double_1;
int_1 = int_2 * int_2;
}
short v_core_start( char parameter_1,int uni_para)
{
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
char char_4 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_3 = 1;
short_1 = short_1 * short_2;
double_2 = double_1 + double_2;
char_3 = char_1 + char_2;
char_1 = char_4 + char_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
char controller4vul_2064[2];
fgets(controller4vul_2064 ,2 ,stdin);
if( strcmp( controller4vul_2064, "6") < 0)
{
long long_1 = 1;
long long_2 = 1;
unsigned_int_2 = v_core_ctx_create(short_1,uni_para);
long_2 = long_1 * long_1;
}
double_2 = double_2;
int_2 = int_1 + int_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_3;
return short_2;
}
void v_nc_run( short parameter_1,int uni_para)
{
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short_3 = short_1 * short_2;
double_2 = double_1 * double_2;
double_3 = double_2 + double_2;
char controller4vul_2063[3];
fgets(controller4vul_2063 ,3 ,stdin);
if( strcmp( controller4vul_2063, "7#") < 0)
{
short_2 = v_core_start(char_1,uni_para);
}
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_2 = 1;
char char_3 = 1;
char_3 = char_2 * char_2;
if(1)
{
float float_1 = 1;
float float_2 = 1;
float_2 = float_1 + float_2;
}
}
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
}
void v_log_deinit()
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
int_3 = int_1 * int_2;
if(1)
{
}
long_1 = long_1;
}
double v_nc_print_done()
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
double_3 = double_1 + double_2;
return double_4;
}
void v_signal_deinit()
{
}
float v_nc_remove_pidfile( char parameter_1)
{
float float_1 = 1;
long long_1 = 1;
float_1 = float_1;
long_1 = long_1 + long_1;
if(1)
{
int int_1 = 1;
int int_2 = 1;
int_1 = int_2;
}
return float_1;
}
int v_nc_post_run( long parameter_1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double double_4 = 1;
int int_1 = 1;
char char_1 = 1;
char char_2 = 1;
int int_2 = 1;
float float_1 = 1;
char char_3 = 1;
if(1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double_1 = v_nc_print_done();
v_log_deinit();
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
}
double_4 = double_2 * double_3;
int_1 = int_1 * int_1;
char_2 = char_1 * char_1;
return int_2;
float_1 = v_nc_remove_pidfile(char_3);
v_signal_deinit();
}
int v_nc_print_run( long parameter_1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
float float_2 = 1;
double_1 = double_2;
double_2 = double_3 * double_1;
int_2 = int_1 * int_1;
if(1)
{
short short_1 = 1;
short short_2 = 1;
short_1 = short_1 + short_2;
}
if(1)
{
float float_3 = 1;
float_3 = float_1 * float_2;
}
float_2 = float_2 + float_1;
return int_1;
}
long v_nc_create_pidfile( unsigned int parameter_1)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_3 = 1;
long long_1 = 1;
long long_2 = 1;
double double_4 = 1;
float float_1 = 1;
char char_1 = 1;
char char_2 = 1;
double_2 = double_1 * double_2;
int_1 = int_1 * int_2;
double_1 = double_1 + double_3;
long_1 = long_1 * long_2;
if(1)
{
long_1 = long_2;
}
double_4 = double_3 + double_1;
float_1 = float_1 * float_1;
double_3 = double_3 * double_2;
if(1)
{
unsigned int unsigned_int_1 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
}
char_1 = char_1 + char_2;
return long_2;
}
float v_signal_init()
{
long long_1 = 1;
float float_1 = 1;
long_1 = long_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int_3 = int_1 + int_2;
int_2 = int_3 * int_1;
char_1 = char_1 * char_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
double_3 = double_1 + double_2;
unsigned_int_1 = unsigned_int_1;
float_1 = float_1;
if(1)
{
int int_4 = 1;
int int_5 = 1;
int_5 = int_1 + int_4;
}
}
return float_1;
}
float v_nc_daemonize( int parameter_1)
{
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
double double_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
char char_2 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
double double_3 = 1;
double double_4 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
char char_3 = 1;
float float_1 = 1;
unsigned int unsigned_int_5 = 1;
long long_4 = 1;
long long_5 = 1;
short short_2 = 1;
int int_3 = 1;
int int_4 = 1;
int int_5 = 1;
long_2 = long_1 + long_1;
long_2 = long_3;
double_1 = double_1 * double_1;
unsigned_int_1 = unsigned_int_2;
char_2 = char_1 + char_1;
int_2 = int_1 + int_2;
int_2 = int_2 + int_2;
short_1 = short_1 * short_1;
if(1)
{
double double_2 = 1;
double_4 = double_2 + double_3;
}
if(1)
{
unsigned_int_4 = unsigned_int_1 + unsigned_int_3;
}
long_2 = long_2 + long_3;
int_2 = int_1 * int_2;
char_2 = char_1;
unsigned_int_4 = unsigned_int_2 * unsigned_int_2;
if(1)
{
char_2 = char_1 + char_3;
if(1)
{
float_1 = float_1 * float_1;
}
}
unsigned_int_5 = unsigned_int_2 * unsigned_int_3;
long_5 = long_3 * long_4;
if(1)
{
short_1 = short_2;
}
double_4 = double_3 * double_3;
if(1)
{
float float_2 = 1;
float_2 = float_2 + float_2;
int_1 = int_3;
}
int_3 = int_3 + int_4;
if(1)
{
double_4 = double_3;
char_3 = char_3;
}
int_1 = int_5 * int_1;
if(1)
{
int int_6 = 1;
double double_5 = 1;
int_6 = int_4 * int_2;
double_5 = double_4 * double_4;
}
if(1)
{
short_2 = short_2 * short_2;
if(1)
{
char_3 = char_2;
}
}
return float_1;
}
int v_log_init( int parameter_1,char parameter_2)
{
char char_1 = 1;
char char_2 = 1;
char char_3 = 1;
long long_1 = 1;
long long_2 = 1;
int int_2 = 1;
char_3 = char_1 * char_2;
long_1 = long_2;
long_2 = long_2 * long_2;
if(1)
{
long long_3 = 1;
long_3 = long_2 + long_1;
}
if(1)
{
short short_1 = 1;
short_1 = short_1 * short_1;
if(1)
{
int int_1 = 1;
int_2 = int_1 + int_1;
}
}
return int_2;
}
unsigned int v_nc_pre_run( unsigned int parameter_1)
{
float float_1 = 1;
float float_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
float float_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
int int_4 = 1;
char char_1 = 1;
long long_3 = 1;
float_1 = v_signal_init();
float_1 = float_2 + float_1;
int_3 = int_1 + int_2;
if(1)
{
}
if(1)
{
float_1 = v_nc_daemonize(int_1);
int_1 = v_nc_print_run(long_1);
float_2 = float_2 + float_1;
if(1)
{
}
}
float_1 = float_2 + float_3;
double_2 = double_1 * double_2;
if(1)
{
}
if(1)
{
long long_2 = 1;
long_2 = long_1 * long_2;
if(1)
{
}
}
double_1 = double_3 + double_1;
return unsigned_int_1;
int_2 = v_log_init(int_4,char_1);
long_3 = v_nc_create_pidfile(unsigned_int_1);
}
int v_conf_server_deinit()
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
int int_3 = 1;
int int_4 = 1;
int_1 = int_1;
int_2 = int_2 * int_1;
long_1 = long_1 * long_1;
int_1 = int_2 * int_1;
int_4 = int_2 * int_3;
return int_3;
v_string_deinit();
}
long v_conf_pool_deinit( long parameter_1)
{
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
int int_1 = 1;
int int_2 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
char char_3 = 1;
int int_3 = 1;
int int_4 = 1;
int int_5 = 1;
double double_3 = 1;
long long_1 = 1;
char char_4 = 1;
long long_2 = 1;
double double_5 = 1;
double double_6 = 1;
long long_4 = 1;
float_1 = float_1 * float_2;
v_string_deinit();
double_1 = double_1 * double_1;
int_1 = int_2;
double_2 = v_array_pop(char_1);
unsigned_int_1 = unsigned_int_2;
char_2 = char_3;
int_5 = int_3 + int_4;
v_array_deinit(unsigned_int_2);
double_3 = double_2 + double_3;
long_1 = long_1 + long_1;
char_4 = char_4 + char_4;
if(1)
{
double_3 = double_3 + double_1;
long_1 = long_1 + long_2;
unsigned_int_2 = v_array_n(float_2);
long_1 = long_1 + long_2;
}
if(1)
{
long long_3 = 1;
long_3 = long_2 * long_3;
}
if(1)
{
double double_4 = 1;
int_5 = v_conf_server_deinit();
double_5 = double_3 + double_4;
char_2 = char_1 * char_4;
}
if(1)
{
char_1 = char_3 * char_1;
double_1 = double_3 * double_5;
}
char controller_5[2];
fgets(controller_5 ,2 ,stdin);
if( strcmp( controller_5, "6") > 0)
{
short short_1 = 1;
short short_2 = 1;
short_1 = short_1 * short_2;
}
double_3 = double_6 * double_2;
return long_4;
}
void v_conf_destroy()
{
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
double double_1 = 1;
char char_1 = 1;
long long_1 = 1;
long long_2 = 1;
long long_3 = 1;
short short_2 = 1;
short short_3 = 1;
int int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
float float_2 = 1;
char char_2 = 1;
long long_4 = 1;
int int_2 = 1;
unsigned_int_1 = unsigned_int_1;
short_1 = short_1;
double_1 = v_array_pop(char_1);
long_3 = long_1 + long_2;
short_3 = short_2 * short_1;
v_array_deinit(unsigned_int_1);
int_1 = int_1;
unsigned_int_2 = v_array_n(float_1);
unsigned_int_4 = unsigned_int_2 * unsigned_int_3;
unsigned_int_2 = unsigned_int_3 + unsigned_int_1;
float_2 = v_conf_pop_scalar(char_2);
long_3 = v_conf_pool_deinit(long_4);
int_1 = int_2;
unsigned_int_3 = unsigned_int_4;
}
unsigned int v_conf_dump( short parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_4 = 1;
double double_1 = 1;
double double_2 = 1;
long long_2 = 1;
long long_3 = 1;
char char_2 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
char_1 = char_1 + char_1;
unsigned_int_2 = unsigned_int_3 + unsigned_int_3;
float_3 = float_1 + float_2;
if(1)
{
}
unsigned_int_4 = v_array_n(float_1);
double_2 = double_1 * double_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_5 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
int int_4 = 1;
double double_3 = 1;
long long_1 = 1;
short short_3 = 1;
unsigned int unsigned_int_6 = 1;
short_2 = short_1 * short_2;
unsigned_int_4 = unsigned_int_4 * unsigned_int_5;
int_2 = int_1 * int_1;
unsigned_int_5 = unsigned_int_5 + unsigned_int_1;
int_4 = int_3 + int_4;
double_2 = double_2 * double_3;
float_2 = float_1 * float_2;
float_1 = float_1 + float_1;
long_3 = long_1 + long_2;
int_1 = int_4 * int_2;
long_3 = v_array_get(long_2,char_2);
short_1 = short_2 + short_3;
int_3 = int_2 * int_2;
long_1 = long_2 + long_3;
unsigned_int_4 = unsigned_int_3;
int_3 = int_4 + int_3;
for(int looper_2=0; looper_2<1;looper_2++)
{
int int_5 = 1;
short short_4 = 1;
int_5 = int_2 + int_5;
short_1 = short_4 + short_2;
}
long_3 = long_2;
unsigned_int_5 = unsigned_int_4 + unsigned_int_6;
long_2 = long_3 + long_2;
for(int looper_3=0; looper_3<1;looper_3++)
{
float float_4 = 1;
short_3 = short_3 + short_1;
float_4 = float_2 * float_4;
}
}
return unsigned_int_4;
}
int v_conf_pool_name_cmp( char parameter_1,long parameter_2)
{
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
int int_3 = 1;
int_2 = int_1 + int_1;
return int_1;
int_1 = v_string_compare(char_1,int_3);
}
double v_conf_pool_listen_cmp( unsigned int parameter_1,unsigned int parameter_2)
{
int int_1 = 1;
char char_1 = 1;
double double_1 = 1;
int_1 = v_string_compare(char_1,int_1);
char_1 = char_1 + char_1;
return double_1;
}
char v_conf_sentinel_name_cmp( long parameter_1,long parameter_2)
{
int int_1 = 1;
char char_1 = 1;
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_2 = 1;
int_1 = v_string_compare(char_1,int_2);
double_1 = double_1 + double_2;
return char_2;
}
short v_conf_validate_sentinel( unsigned int parameter_1,int parameter_2)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
float float_2 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
long long_4 = 1;
long long_5 = 1;
int int_3 = 1;
char char_3 = 1;
double_1 = double_2;
int_1 = int_1 * int_1;
int_2 = int_1 + int_1;
if(1)
{
float float_1 = 1;
float_2 = float_1 * float_2;
}
short_2 = short_1 + short_2;
for(int looper_1=0; looper_1<1;looper_1++)
{
long long_3 = 1;
float float_3 = 1;
float float_4 = 1;
long_1 = v_array_get(long_2,char_1);
long_3 = long_1 + long_1;
float_3 = float_2 + float_2;
unsigned_int_1 = v_array_n(float_2);
float_4 = float_3 + float_4;
if(1)
{
char char_2 = 1;
long long_6 = 1;
char_1 = v_conf_sentinel_name_cmp(long_4,long_5);
char_2 = char_2;
short_1 = short_2;
v_array_sort(float_2,float_2);
long_5 = long_6 + long_3;
}
}
if(1)
{
}
return short_2;
int_3 = v_string_compare(char_3,int_1);
}
double v_conf_group_name_cmp( float parameter_1,int parameter_2)
{
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
int int_1 = 1;
char char_1 = 1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
return double_1;
int_1 = v_string_compare(char_1,int_1);
}
void v_array_sort( float parameter_1,float parameter_2)
{
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
double_1 = double_1 + double_2;
int_1 = int_1 * int_2;
}
char v_conf_validate_group( unsigned int parameter_1,float parameter_2)
{
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
double double_1 = 1;
float float_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
float float_3 = 1;
long long_1 = 1;
long long_2 = 1;
char char_3 = 1;
int int_2 = 1;
char char_4 = 1;
unsigned int unsigned_int_3 = 1;
char_1 = char_2;
v_array_sort(float_1,float_1);
double_1 = v_conf_group_name_cmp(float_2,int_1);
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
short_1 = short_2;
if(1)
{
short_2 = short_2 * short_2;
}
unsigned_int_2 = v_array_n(float_3);
long_1 = v_array_get(long_2,char_3);
int_2 = v_string_compare(char_4,int_1);
unsigned_int_2 = unsigned_int_1 * unsigned_int_3;
for(int looper_1=0; looper_1<1;looper_1++)
{
double double_2 = 1;
double double_3 = 1;
int int_3 = 1;
int int_4 = 1;
double_2 = double_2 + double_1;
double_3 = double_2 + double_3;
int_4 = int_3 + int_4;
if(1)
{
unsigned int unsigned_int_4 = 1;
char_4 = char_2;
unsigned_int_4 = unsigned_int_2 * unsigned_int_3;
char_1 = char_3 + char_2;
}
}
if(1)
{
}
return char_2;
}
long v_string_empty( double parameter_1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
int_2 = int_1 * int_2;
return long_1;
}
float v_conf_validate_pool( int parameter_1,float parameter_2)
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
double double_1 = 1;
double double_2 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_3 = 1;
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
long long_4 = 1;
long long_5 = 1;
short short_2 = 1;
int int_3 = 1;
int_2 = int_1 * int_2;
long_1 = long_1;
double_1 = double_1 * double_2;
if(1)
{
long_1 = long_2;
}
if(1)
{
double double_3 = 1;
double_3 = double_2 * double_3;
}
if(1)
{
float float_1 = 1;
float_1 = float_1 * float_1;
}
if(1)
{
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
}
char controller_5[2];
fgets(controller_5 ,2 ,stdin);
if( strcmp( controller_5, "i") == 0)
{
short short_1 = 1;
short_1 = short_1;
}
char_1 = v_conf_validate_group(unsigned_int_1,float_2);
unsigned_int_2 = unsigned_int_2 * unsigned_int_3;
if(1)
{
unsigned_int_3 = unsigned_int_1 * unsigned_int_1;
}
if(1)
{
long long_3 = 1;
long_3 = long_2 * long_2;
}
if(1)
{
long_2 = v_string_empty(double_2);
float_2 = float_2 * float_3;
}
if(1)
{
double double_4 = 1;
double double_5 = 1;
double_5 = double_4 + double_2;
}
unsigned_int_4 = unsigned_int_5;
if(1)
{
}
if(1)
{
int_1 = int_2;
}
long_1 = long_4 * long_5;
if(1)
{
}
char_1 = char_1;
return float_3;
short_2 = v_conf_validate_sentinel(unsigned_int_1,int_3);
}
float v_conf_post_validate( float parameter_1)
{
int int_1 = 1;
long long_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_2 = 1;
long long_3 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
int int_2 = 1;
int int_3 = 1;
char char_3 = 1;
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
long long_4 = 1;
int int_4 = 1;
int_1 = int_1 + int_1;
long_1 = long_2;
short_2 = short_1 * short_2;
double_2 = double_1 * double_1;
long_1 = v_array_get(long_1,char_1);
unsigned_int_1 = unsigned_int_1;
char_2 = char_1 * char_2;
if(1)
{
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
}
for(int looper_1=0; looper_1<1;looper_1++)
{
long_2 = long_1 + long_3;
unsigned_int_2 = unsigned_int_2;
if(1)
{
}
}
unsigned_int_3 = unsigned_int_4;
for(int looper_2=0; looper_2<1;looper_2++)
{
double_2 = v_conf_pool_listen_cmp(unsigned_int_1,unsigned_int_3);
int_3 = int_2 * int_1;
double_1 = double_2 * double_2;
char_3 = char_2 * char_1;
if(1)
{
short short_3 = 1;
float_1 = v_conf_validate_pool(int_2,float_2);
int_2 = v_conf_pool_name_cmp(char_3,long_1);
unsigned_int_2 = unsigned_int_4;
unsigned_int_2 = v_array_n(float_3);
short_3 = short_1 + short_3;
short_2 = short_1;
}
}
if(1)
{
}
long_3 = long_4;
for(int looper_3=0; looper_3<1;looper_3++)
{
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
int_3 = v_string_compare(char_3,int_4);
unsigned_int_4 = unsigned_int_5 * unsigned_int_5;
int_1 = int_3 + int_1;
unsigned_int_6 = unsigned_int_4 + unsigned_int_5;
if(1)
{
unsigned int unsigned_int_7 = 1;
unsigned int unsigned_int_8 = 1;
unsigned_int_1 = unsigned_int_5;
unsigned_int_6 = unsigned_int_7 + unsigned_int_8;
int_3 = int_1 + int_1;
}
}
if(1)
{
}
return float_1;
v_array_sort(float_3,float_2);
}
float v_conf_end_parse( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned_int_1 = v_conf_event_done(char_1);
unsigned_int_2 = unsigned_int_2;
char_1 = char_1 + char_2;
v_conf_event_next(char_2);
long_2 = long_1 * long_2;
int_1 = int_1 + int_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
int int_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
int_3 = int_2 + int_3;
float_1 = v_conf_yaml_deinit(unsigned_int_1);
unsigned_int_3 = unsigned_int_3 + unsigned_int_2;
}
return float_2;
}
int v_string_compare( char parameter_1,int parameter_2)
{
int int_1 = 1;
if(1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
}
return int_1;
}
char v_string_duplicate( short parameter_1,unsigned int parameter_2)
{
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
short short_2 = 1;
char char_1 = 1;
long_2 = long_1 + long_1;
int_1 = int_1;
unsigned_int_2 = unsigned_int_1 + unsigned_int_2;
if(1)
{
}
double_1 = double_1 + double_2;
short_1 = short_1 * short_2;
return char_1;
}
int v_array_null( float parameter_1)
{
short short_1 = 1;
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
char char_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
short_1 = short_1 * short_1;
double_2 = double_1 * double_1;
char_1 = char_1 + char_2;
long_2 = long_1 + long_2;
return int_1;
}
void v_conf_pool_init( double parameter_1,float parameter_2)
{
float float_1 = 1;
float float_2 = 1;
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
double double_3 = 1;
unsigned int unsigned_int_1 = 1;
long long_2 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_2 = 1;
int int_3 = 1;
int int_4 = 1;
float float_3 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
short short_3 = 1;
float float_4 = 1;
int int_5 = 1;
int int_6 = 1;
double double_4 = 1;
double double_5 = 1;
int int_7 = 1;
int int_8 = 1;
char char_1 = 1;
float_1 = float_2;
double_1 = double_1 * double_2;
int_1 = int_2;
long_1 = long_1 * long_1;
double_1 = double_2 * double_3;
v_string_deinit();
v_array_deinit(unsigned_int_1);
long_2 = long_1 * long_2;
short_1 = short_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
int_2 = int_1 + int_2;
unsigned_int_1 = unsigned_int_2 * unsigned_int_2;
int_4 = int_3 * int_1;
float_2 = float_3 * float_2;
unsigned_int_4 = unsigned_int_3 + unsigned_int_4;
short_3 = short_3;
float_4 = float_2 + float_3;
v_string_init(float_4);
int_6 = int_2 + int_5;
double_5 = double_4 + double_3;
unsigned_int_3 = unsigned_int_3;
short_1 = short_1 + short_1;
int_3 = int_4 + int_4;
unsigned_int_3 = unsigned_int_2;
int_6 = v_array_null(float_2);
int_7 = int_8;
if(1)
{
}
char_1 = v_string_duplicate(short_3,unsigned_int_3);
float_1 = float_3 * float_2;
if(1)
{
int int_9 = 1;
int_9 = int_2 * int_5;
}
int_6 = int_3 * int_5;
if(1)
{
unsigned int unsigned_int_5 = 1;
double_3 = double_4;
v_array_init(char_1,float_3,long_2);
unsigned_int_4 = unsigned_int_5 * unsigned_int_2;
}
short_2 = short_1 + short_1;
}
long v_array_get( long parameter_1,char parameter_2)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_4 = 1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
float_2 = float_1 + float_1;
long_1 = long_2;
unsigned_int_4 = unsigned_int_3 * unsigned_int_4;
return long_1;
}
char v_array_top( int parameter_1)
{
long long_1 = 1;
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
long_1 = v_array_get(long_1,char_1);
int_1 = int_2;
return char_1;
}
double v_conf_handler( double parameter_1)
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
int int_4 = 1;
int int_5 = 1;
double double_2 = 1;
double double_3 = 1;
long long_3 = 1;
char char_1 = 1;
char char_2 = 1;
float float_1 = 1;
int int_6 = 1;
int int_7 = 1;
int int_8 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
double double_4 = 1;
int_2 = int_1 + int_1;
long_1 = long_1 * long_2;
double_1 = double_1 * double_1;
if(1)
{
int int_3 = 1;
int_5 = int_3 + int_4;
double_3 = double_2 + double_1;
}
long_3 = long_1 + long_1;
long_3 = v_array_get(long_2,char_1);
char_1 = char_1 * char_2;
v_conf_pool_init(double_1,float_1);
int_6 = int_4 * int_5;
int_5 = int_7 * int_8;
for(int looper_1=0; looper_1<1;looper_1++)
{
unsigned int unsigned_int_1 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
if(1)
{
double_3 = double_2;
}
char_1 = v_array_top(int_1);
unsigned_int_2 = unsigned_int_2 * unsigned_int_2;
if(1)
{
unsigned_int_2 = v_array_n(float_1);
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
}
}
unsigned_int_2 = unsigned_int_2 * unsigned_int_3;
return double_4;
int_2 = v_string_compare(char_2,int_8);
}
char v_string_copy( unsigned int parameter_1,double parameter_2,char parameter_3)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_2 = 1;
char char_1 = 1;
double_3 = double_1 + double_2;
int_3 = int_1 + int_2;
float_1 = float_1 * float_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "U2") > 0)
{
}
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
float_1 = float_2 + float_1;
return char_1;
}
float v_array_push( float parameter_1)
{
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
float float_1 = 1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
int_2 = int_1 + int_1;
if(1)
{
char char_1 = 1;
char char_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
char_2 = char_1 * char_2;
unsigned_int_1 = unsigned_int_1;
if(1)
{
}
unsigned_int_1 = unsigned_int_2 * unsigned_int_3;
unsigned_int_4 = unsigned_int_1 + unsigned_int_3;
}
int_1 = int_3 * int_1;
double_3 = double_1 + double_2;
return float_1;
}
char v_conf_push_scalar( float parameter_1)
{
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
double double_1 = 1;
char char_2 = 1;
double double_2 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
int int_3 = 1;
float float_1 = 1;
double double_3 = 1;
float float_2 = 1;
char char_3 = 1;
char_1 = v_string_copy(unsigned_int_1,double_1,char_1);
double_1 = v_array_pop(char_2);
double_2 = double_1 + double_1;
unsigned_int_4 = unsigned_int_2 + unsigned_int_3;
int_2 = int_1 + int_2;
char_2 = char_2;
short_1 = short_1 * short_1;
int_1 = int_3 * int_3;
if(1)
{
}
short_1 = short_1;
float_1 = v_array_push(float_1);
double_3 = double_3 + double_2;
if(1)
{
}
float_2 = float_1 * float_1;
v_string_init(float_1);
char_1 = char_2;
if(1)
{
int int_4 = 1;
int_4 = int_1 + int_4;
}
return char_3;
}
void v_string_init( float parameter_1)
{
float float_1 = 1;
float float_2 = 1;
float float_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float_3 = float_1 * float_2;
unsigned_int_2 = unsigned_int_1 + unsigned_int_1;
}
void v_string_deinit()
{
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
int_2 = int_1 + int_2;
if(1)
{
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
v_string_init(float_1);
int_3 = int_1 * int_3;
short_1 = short_2;
}
}
double v_array_pop( char parameter_1)
{
double double_1 = 1;
double double_2 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
double_2 = double_1 * double_1;
char_1 = char_1 * char_1;
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
char_2 = char_1 + char_1;
return double_1;
}
float v_conf_pop_scalar( char parameter_1)
{
double double_1 = 1;
char char_1 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
double_1 = v_array_pop(char_1);
int_1 = int_1 * int_1;
int_2 = int_2 * int_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
unsigned_int_1 = unsigned_int_2;
return float_1;
v_string_deinit();
}
void v_conf_parse_core( unsigned int parameter_1)
{
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
double double_1 = 1;
double double_2 = 1;
int int_1 = 1;
int int_2 = 1;
char char_2 = 1;
double double_3 = 1;
short short_1 = 1;
short short_2 = 1;
int int_3 = 1;
double double_4 = 1;
double double_5 = 1;
char char_3 = 1;
float float_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_2 = 1;
double double_6 = 1;
long long_1 = 1;
long long_2 = 1;
float float_3 = 1;
float float_4 = 1;
int int_4 = 1;
unsigned_int_1 = v_conf_event_done(char_1);
double_1 = double_1 + double_1;
double_2 = double_1 * double_2;
int_2 = int_1 + int_2;
char_2 = char_1 * char_1;
if(1)
{
}
double_3 = double_1 + double_2;
short_2 = short_1 * short_2;
int_2 = int_3 + int_1;
int_3 = int_2 * int_2;
double_2 = v_conf_handler(double_4);
double_1 = double_5;
if(1)
{
char_3 = char_1 + char_3;
}
if(1)
{
char_1 = char_2;
}
float_1 = float_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
unsigned_int_3 = unsigned_int_3;
unsigned_int_3 = unsigned_int_3 + unsigned_int_1;
float_2 = v_array_push(float_2);
double_6 = double_3;
float_2 = float_1 * float_1;
v_conf_event_next(char_3);
float_1 = float_1 * float_2;
unsigned_int_2 = v_array_n(float_1);
long_1 = long_2;
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
if(1)
{
float_2 = float_3 + float_3;
}
if(1)
{
double_5 = double_5;
char_2 = char_2;
}
if(1)
{
double double_7 = 1;
char_1 = char_1 * char_3;
if(1)
{
unsigned int unsigned_int_4 = 1;
unsigned_int_1 = unsigned_int_4 * unsigned_int_1;
short_2 = short_1;
}
double_1 = double_7;
}
if(1)
{
float_1 = float_1 + float_2;
char_2 = v_conf_push_scalar(float_3);
int_3 = int_3 * int_3;
}
float_4 = v_conf_pop_scalar(char_3);
long_1 = long_2 * long_2;
double_5 = double_4;
short_2 = short_2 + short_1;
int_4 = int_2 + int_2;
if(1)
{
}
if(1)
{
}
if(1)
{
double_5 = double_4 * double_4;
if(1)
{
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
unsigned_int_2 = unsigned_int_5 + unsigned_int_6;
if(1)
{
int int_5 = 1;
int int_6 = 1;
int_5 = int_6;
}
}
if(1)
{
}
}
}
long v_conf_begin_parse( long parameter_1)
{
float float_1 = 1;
short short_1 = 1;
short short_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_3 = 1;
char char_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
unsigned int unsigned_int_4 = 1;
char char_2 = 1;
char char_3 = 1;
long long_1 = 1;
float_1 = v_conf_yaml_init();
short_2 = short_1 * short_2;
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
if(1)
{
int int_2 = 1;
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
int_3 = int_1 * int_2;
if(1)
{
unsigned_int_1 = v_conf_event_done(char_1);
double_2 = double_1 * double_1;
}
v_conf_event_next(char_1);
double_3 = double_2 + double_1;
}
unsigned_int_2 = unsigned_int_2 * unsigned_int_2;
unsigned_int_1 = unsigned_int_3 + unsigned_int_4;
char_2 = char_2 + char_3;
int_1 = int_3 + int_1;
return long_1;
}
unsigned int v_array_n( float parameter_1)
{
unsigned int unsigned_int_1 = 1;
return unsigned_int_1;
}
short v_conf_parse( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
float float_1 = 1;
float float_2 = 1;
long long_1 = 1;
long long_2 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_3 = 1;
char char_1 = 1;
char char_2 = 1;
double double_1 = 1;
double double_2 = 1;
short short_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned_int_1 = v_array_n(float_1);
float_1 = float_2 + float_2;
long_2 = long_1 + long_1;
int_1 = int_1 + int_2;
int_2 = int_3 + int_3;
if(1)
{
}
long_2 = v_conf_begin_parse(long_3);
char_2 = char_1 * char_2;
if(1)
{
}
double_1 = double_1 + double_2;
if(1)
{
}
unsigned_int_1 = unsigned_int_1 + unsigned_int_1;
return short_1;
v_conf_parse_core(unsigned_int_2);
float_2 = v_conf_end_parse(char_1);
}
unsigned int v_conf_event_done( char parameter_1)
{
unsigned int unsigned_int_1 = 1;
if(1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
double_2 = double_1 * double_1;
double_1 = double_3;
}
return unsigned_int_1;
}
void v_conf_event_next( char parameter_1)
{
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
float float_2 = 1;
short_1 = short_1 * short_2;
short_2 = short_3 + short_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
if(1)
{
char char_1 = 1;
char char_2 = 1;
char_1 = char_2;
}
float_1 = float_1 * float_2;
}
short v_conf_validate_structure( int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_1 = 1;
char char_1 = 1;
float float_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_2 = 1;
char char_3 = 1;
short short_1 = 1;
float float_2 = 1;
char char_4 = 1;
int_3 = int_1 + int_2;
unsigned_int_1 = v_conf_event_done(char_1);
float_1 = v_conf_yaml_deinit(unsigned_int_2);
char_3 = char_1 + char_2;
return short_1;
float_2 = v_conf_yaml_init();
v_conf_event_next(char_4);
}
double v_conf_token_done( float parameter_1)
{
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
long_1 = long_1 + long_2;
if(1)
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
int_2 = int_1 + int_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
}
return double_1;
}
char v_conf_token_next( float parameter_1)
{
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_4 = 1;
char char_1 = 1;
float_1 = float_1;
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
int_2 = int_1 + int_1;
if(1)
{
float_1 = float_1 + float_1;
}
unsigned_int_1 = unsigned_int_4 * unsigned_int_1;
return char_1;
}
float v_conf_validate_tokens()
{
float float_1 = 1;
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
char char_1 = 1;
float float_2 = 1;
double double_1 = 1;
float float_3 = 1;
float float_4 = 1;
unsigned int unsigned_int_1 = 1;
float_1 = v_conf_yaml_init();
short_2 = short_1 + short_2;
long_1 = long_1;
return float_1;
char_1 = v_conf_token_next(float_2);
double_1 = v_conf_token_done(float_3);
float_4 = v_conf_yaml_deinit(unsigned_int_1);
}
float v_conf_yaml_deinit( unsigned int parameter_1)
{
float float_1 = 1;
if(1)
{
int int_1 = 1;
int int_2 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
int_2 = int_1 * int_2;
short_3 = short_1 * short_2;
}
return float_1;
}
float v_conf_yaml_init()
{
double double_1 = 1;
double double_2 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
unsigned int unsigned_int_3 = 1;
float float_1 = 1;
double_2 = double_1 + double_1;
long_1 = long_1 + long_2;
unsigned_int_1 = unsigned_int_1 * unsigned_int_1;
char controller_1[3];
fgets(controller_1 ,3 ,stdin);
if( strcmp( controller_1, "8h") == 0)
{
int_2 = int_1 + int_1;
}
int_3 = int_2 * int_1;
if(1)
{
unsigned int unsigned_int_2 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_2;
}
unsigned_int_1 = unsigned_int_3 + unsigned_int_1;
int_3 = int_2;
return float_1;
}
short v_conf_validate_document( float parameter_1)
{
float float_1 = 1;
short short_1 = 1;
short short_2 = 1;
short short_3 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
float_1 = v_conf_yaml_init();
short_1 = short_1 * short_2;
return short_3;
float_2 = v_conf_yaml_deinit(unsigned_int_1);
}
float v_conf_pre_validate( short parameter_1)
{
short short_1 = 1;
int int_1 = 1;
int int_2 = 1;
float float_1 = 1;
double double_1 = 1;
double double_2 = 1;
short short_2 = 1;
float float_2 = 1;
short_1 = v_conf_validate_structure(int_1);
int_2 = int_1 + int_2;
int_2 = int_1;
if(1)
{
}
float_1 = v_conf_validate_tokens();
int_2 = int_2 * int_1;
if(1)
{
}
double_1 = double_2;
if(1)
{
}
short_2 = short_2 * short_2;
return float_1;
short_2 = v_conf_validate_document(float_2);
}
void v_array_deinit( unsigned int parameter_1)
{
int int_1 = 1;
int int_2 = 1;
int_1 = int_2;
if(1)
{
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned_int_2 = unsigned_int_1 * unsigned_int_1;
}
}
void v_array_init( char parameter_1,float parameter_2,long parameter_3)
{
int int_1 = 1;
int int_2 = 1;
long long_1 = 1;
long long_2 = 1;
char char_1 = 1;
int int_3 = 1;
int_1 = int_2;
long_2 = long_1 * long_1;
if(1)
{
}
long_1 = long_1 + long_2;
char_1 = char_1 + char_1;
int_3 = int_3 + int_2;
}
float v_conf_open( char parameter_1)
{
char char_1 = 1;
float float_1 = 1;
long long_1 = 1;
long long_2 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_1 = 1;
int int_2 = 1;
double double_3 = 1;
unsigned int unsigned_int_3 = 1;
int int_3 = 1;
long long_3 = 1;
double double_4 = 1;
double double_5 = 1;
double double_6 = 1;
short short_1 = 1;
float float_2 = 1;
int int_4 = 1;
int int_5 = 1;
v_array_init(char_1,float_1,long_1);
long_2 = long_2 * long_2;
long_1 = long_2 * long_2;
double_2 = double_1 * double_2;
v_array_deinit(unsigned_int_1);
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
if(1)
{
int_2 = int_1 * int_1;
}
double_3 = double_3 * double_1;
if(1)
{
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
}
unsigned_int_3 = unsigned_int_2;
if(1)
{
unsigned int unsigned_int_4 = 1;
unsigned int unsigned_int_5 = 1;
unsigned int unsigned_int_6 = 1;
unsigned_int_2 = unsigned_int_4 + unsigned_int_1;
unsigned_int_3 = unsigned_int_5 * unsigned_int_6;
}
int_3 = int_2 + int_2;
if(1)
{
long long_4 = 1;
int_2 = int_1 + int_2;
long_4 = long_3 * long_3;
double_3 = double_3 * double_3;
}
double_5 = double_4 + double_1;
double_2 = double_6 + double_5;
double_5 = double_1 * double_4;
short_1 = short_1 * short_1;
long_1 = long_1;
long_2 = long_1 * long_1;
long_1 = long_1 + long_3;
float_2 = float_1 + float_1;
int_5 = int_2 * int_4;
int_5 = int_3 + int_2;
double_4 = double_5 * double_1;
return float_2;
}
int v_conf_create( char parameter_1)
{
short short_1 = 1;
short short_2 = 1;
long long_1 = 1;
long long_2 = 1;
short short_3 = 1;
short short_4 = 1;
char char_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
float float_1 = 1;
float float_2 = 1;
long long_3 = 1;
float float_3 = 1;
char char_2 = 1;
char char_3 = 1;
double double_1 = 1;
float float_4 = 1;
v_conf_destroy();
short_2 = short_1 * short_2;
long_2 = long_1 + long_2;
long_1 = long_2 + long_1;
if(1)
{
}
short_4 = short_2 * short_3;
if(1)
{
short_1 = v_conf_parse(char_1);
unsigned_int_1 = unsigned_int_1 + unsigned_int_2;
}
long_2 = long_2 + long_2;
if(1)
{
unsigned_int_3 = unsigned_int_1 * unsigned_int_2;
}
int_1 = int_2;
if(1)
{
int int_4 = 1;
int_4 = int_1 + int_3;
}
unsigned_int_2 = v_conf_dump(short_4);
unsigned_int_1 = unsigned_int_3 + unsigned_int_3;
float_1 = v_conf_pre_validate(short_1);
float_1 = v_conf_post_validate(float_2);
long_3 = long_1 + long_2;
int_3 = int_2 * int_3;
float_3 = v_conf_open(char_2);
char_3 = char_1 * char_3;
long_3 = long_3;
double_1 = double_1;
float_4 = float_1 * float_3;
return int_3;
}
int v_nc_test_conf( char parameter_1)
{
int int_1 = 1;
int int_2 = 1;
char char_1 = 1;
float float_1 = 1;
float float_2 = 1;
int int_3 = 1;
short short_1 = 1;
short short_2 = 1;
int_1 = int_2;
int_1 = v_conf_create(char_1);
float_1 = float_1 * float_2;
if(1)
{
double double_1 = 1;
v_conf_destroy();
double_1 = double_1 + double_1;
}
int_2 = int_2 + int_3;
short_2 = short_1 + short_1;
return int_2;
}
void v_stats_describe()
{
char char_1 = 1;
int int_1 = 1;
double double_1 = 1;
double double_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char_1 = char_1;
int_1 = int_1 + int_1;
for(int looper_1=0; looper_1<1;looper_1++)
{
char char_2 = 1;
char_2 = char_2 * char_1;
}
double_1 = double_2;
unsigned_int_1 = unsigned_int_2;
for(int looper_2=0; looper_2<1;looper_2++)
{
int int_2 = 1;
int_1 = int_2 * int_2;
}
}
int v_nc_show_usage()
{
int int_1 = 1;
int int_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
unsigned int unsigned_int_3 = 1;
short short_1 = 1;
int int_3 = 1;
int_2 = int_1 * int_1;
unsigned_int_3 = unsigned_int_1 + unsigned_int_2;
short_1 = short_1 + short_1;
return int_3;
}
short v_nc_valid_port( int parameter_1)
{
short short_1 = 1;
if(1)
{
}
return short_1;
}
int v_nc_get_options( int parameter_1,char parameter_2,int parameter_3)
{
double double_1 = 1;
short short_1 = 1;
short short_2 = 1;
int int_1 = 1;
float float_1 = 1;
float float_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
int int_2 = 1;
if(1)
{
double_1 = double_1;
}
if(1)
{
short_2 = short_1 * short_2;
}
if(1)
{
short_2 = v_nc_valid_port(int_1);
int_1 = int_1 + int_1;
}
if(1)
{
double double_2 = 1;
double_1 = double_2 + double_1;
}
if(1)
{
double double_3 = 1;
double double_4 = 1;
double_3 = double_3 + double_4;
}
if(1)
{
long long_1 = 1;
long_1 = long_1 + long_1;
}
if(1)
{
float_2 = float_1 * float_2;
}
if(1)
{
unsigned_int_1 = unsigned_int_1;
}
if(1)
{
char char_1 = 1;
char char_2 = 1;
char_2 = char_1 + char_1;
}
if(1)
{
short short_3 = 1;
short_1 = short_3;
}
if(1)
{
unsigned_int_2 = unsigned_int_2 * unsigned_int_1;
}
if(1)
{
char char_3 = 1;
char char_4 = 1;
char_3 = char_4;
}
if(1)
{
unsigned_int_1 = unsigned_int_2 + unsigned_int_2;
}
if(1)
{
float_1 = float_2 + float_2;
}
return int_2;
}
float v_nc_set_default_options()
{
int int_1 = 1;
int int_2 = 1;
int int_3 = 1;
long long_1 = 1;
long long_2 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
float float_1 = 1;
double double_1 = 1;
float float_2 = 1;
float float_3 = 1;
short short_1 = 1;
double double_2 = 1;
double double_3 = 1;
float float_4 = 1;
long long_3 = 1;
char char_1 = 1;
char char_2 = 1;
float float_5 = 1;
int_3 = int_1 * int_2;
long_2 = long_1 * long_1;
unsigned_int_1 = unsigned_int_1 * unsigned_int_2;
int_1 = int_3 * int_3;
float_1 = float_1;
double_1 = double_1;
float_2 = float_3;
int_3 = int_2 * int_2;
short_1 = short_1;
if(1)
{
double_1 = double_1 + double_1;
int_3 = int_3 * int_2;
}
double_2 = double_3;
float_4 = float_1 * float_4;
long_2 = long_3 * long_2;
int_2 = int_2;
char_2 = char_1 + char_1;
return float_5;
}
int main()
{
int uni_para =985;
long long_1 = 1;
long long_2 = 1;
float float_1 = 1;
unsigned int unsigned_int_1 = 1;
unsigned int unsigned_int_2 = 1;
char char_1 = 1;
float float_2 = 1;
int int_2 = 1;
int int_3 = 1;
short short_1 = 1;
int int_4 = 1;
int int_5 = 1;
short short_3 = 1;
long long_3 = 1;
long long_4 = 1;
long_1 = long_1 + long_2;
float_1 = float_1 + float_1;
unsigned_int_1 = unsigned_int_2;
char_1 = char_1;
if(1)
{
int int_1 = 1;
float_2 = float_1 * float_2;
int_3 = int_1 * int_2;
}
char controller4vul_2061[3];
fgets(controller4vul_2061 ,3 ,stdin);
if( strcmp( controller4vul_2061, "[-") > 0)
{
unsigned int unsigned_int_3 = 1;
float float_3 = 1;
unsigned_int_3 = unsigned_int_2 + unsigned_int_2;
char controller4vul_2062[3];
fgets(controller4vul_2062 ,3 ,stdin);
if( strcmp( controller4vul_2062, "Ft") > 0)
{
v_nc_run(short_1,uni_para);
unsigned_int_1 = unsigned_int_1 * unsigned_int_3;
}
if(1)
{
int_5 = int_4 * int_3;
}
float_3 = float_3 * float_2;
}
if(1)
{
double double_1 = 1;
double double_2 = 1;
double double_3 = 1;
if(1)
{
float float_4 = 1;
float_1 = float_4 * float_1;
}
double_3 = double_1 * double_2;
}
int_4 = int_3 * int_3;
if(1)
{
int int_6 = 1;
short short_2 = 1;
int_5 = int_2 * int_6;
short_2 = short_1 + short_1;
}
short_3 = short_1 * short_1;
int_3 = int_2;
long_4 = long_1 * long_3;
return int_3;
}
|
the_stack_data/39419.c | struct List {
struct List *next;
} *PLIST;
static void switchToNext() {
PLIST = PLIST->next;
} |
the_stack_data/1188079.c | /*
* 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.
*/
#include <arpa/inet.h>
#include <linux/if_packet.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/ether.h>
#include <unistd.h>
#include <stdint.h>
// dc:a6:32:a1:94:fe
#define DEST_MAC0 0xdc // 0x00
#define DEST_MAC1 0xa6 // 0x00
#define DEST_MAC2 0x32 // 0x00
#define DEST_MAC3 0xa1 // 0x00
#define DEST_MAC4 0x94 // 0x00
#define DEST_MAC5 0xfe // 0x00
#define ETHER_TYPE 0x0800
#define DEFAULT_IF "wlan0"
#define BUF_SIZ 1024
int main(int argc, char *argv[])
{
char sender[INET6_ADDRSTRLEN];
int sockfd, ret, i;
int sockopt;
ssize_t numbytes;
struct ifreq ifopts; /* set promiscuous mode */
struct ifreq if_ip; /* get ip addr */
struct sockaddr_storage their_addr;
uint8_t buf[BUF_SIZ];
char ifName[IFNAMSIZ];
/* Get interface name */
if (argc > 1)
strcpy(ifName, argv[1]);
else
strcpy(ifName, DEFAULT_IF);
/* Header structures */
struct ether_header *eh = (struct ether_header *) buf;
struct iphdr *iph = (struct iphdr *) (buf + sizeof(struct ether_header));
struct udphdr *udph = (struct udphdr *) (buf + sizeof(struct iphdr) + sizeof(struct ether_header));
memset(&if_ip, 0, sizeof(struct ifreq));
/* Open PF_PACKET socket, listening for EtherType ETHER_TYPE */
if ((sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETHER_TYPE))) == -1) {
perror("listener: socket");
return -1;
}
/* Set interface to promiscuous mode - do we need to do this every time? */
strncpy(ifopts.ifr_name, ifName, IFNAMSIZ-1);
ioctl(sockfd, SIOCGIFFLAGS, &ifopts);
ifopts.ifr_flags |= IFF_PROMISC;
ioctl(sockfd, SIOCSIFFLAGS, &ifopts);
/* Allow the socket to be reused - incase connection is closed prematurely */
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof sockopt) == -1) {
perror("setsockopt");
close(sockfd);
exit(EXIT_FAILURE);
}
/* Bind to device */
if (setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE, ifName, IFNAMSIZ-1) == -1) {
perror("SO_BINDTODEVICE");
close(sockfd);
exit(EXIT_FAILURE);
}
repeat: printf("listener: Waiting to recvfrom...\n");
numbytes = recvfrom(sockfd, buf, BUF_SIZ, 0, NULL, NULL);
printf("listener: got packet %lu bytes\n", numbytes);
/* Check the packet is for me */
if (eh->ether_dhost[0] == DEST_MAC0 &&
eh->ether_dhost[1] == DEST_MAC1 &&
eh->ether_dhost[2] == DEST_MAC2 &&
eh->ether_dhost[3] == DEST_MAC3 &&
eh->ether_dhost[4] == DEST_MAC4 &&
eh->ether_dhost[5] == DEST_MAC5) {
printf("Correct destination MAC address\n");
} else {
printf("Wrong destination MAC: %x:%x:%x:%x:%x:%x\n",
eh->ether_dhost[0],
eh->ether_dhost[1],
eh->ether_dhost[2],
eh->ether_dhost[3],
eh->ether_dhost[4],
eh->ether_dhost[5]);
ret = -1;
goto done;
}
/* Get source IP */
((struct sockaddr_in *)&their_addr)->sin_addr.s_addr = iph->saddr;
inet_ntop(AF_INET, &((struct sockaddr_in*)&their_addr)->sin_addr, sender, sizeof sender);
/* Look up my device IP addr if possible */
strncpy(if_ip.ifr_name, ifName, IFNAMSIZ-1);
if (ioctl(sockfd, SIOCGIFADDR, &if_ip) >= 0) { /* if we can't check then don't */
printf("Source IP: %s\n My IP: %s\n", sender,
inet_ntoa(((struct sockaddr_in *)&if_ip.ifr_addr)->sin_addr));
/* ignore if I sent it */
if (strcmp(sender, inet_ntoa(((struct sockaddr_in *)&if_ip.ifr_addr)->sin_addr)) == 0) {
printf("but I sent it :(\n");
ret = -1;
goto done;
}
}
/* UDP payload length */
ret = ntohs(udph->len) - sizeof(struct udphdr);
/* Print packet */
printf("\tData:");
for (i=0; i<numbytes; i++) printf("%02x:", buf[i]);
printf("\n");
done: goto repeat;
close(sockfd);
return ret;
}
|
the_stack_data/59511678.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void CreateInitFile(const char *libName, FILE *fout)
{
const char *prefix = "";
const char* dllexp = "VTK_ABI_EXPORT ";
fprintf(fout,"// Generated by vtkWrapPythonInit in VTK/Wrapping\n");
fprintf(fout,"#include \"vtkPython.h\"\n");
fprintf(fout,"#include \"vtkPythonCompatibility.h\"\n");
fprintf(fout,"#include \"vtkSystemIncludes.h\"\n");
fprintf(fout,"// Handle compiler warning messages, etc.\n"
"#if defined( _MSC_VER ) && !defined(VTK_DISPLAY_WIN32_WARNINGS)\n"
"#pragma warning ( disable : 4706 )\n"
"#endif // Windows Warnings\n\n");
fprintf(fout,"extern \"C\" { PyObject *real_init%s(const char *); }\n\n", libName);
fprintf(fout,"#ifdef VTK_PY3K\n");
fprintf(fout,"extern \"C\" { %sPyObject *PyInit_%s%s(); }\n\n", dllexp, prefix, libName);
fprintf(fout,"PyObject *PyInit_%s()\n", libName);
fprintf(fout,"{\n");
fprintf(fout," return real_init%s(nullptr);\n", libName);
fprintf(fout,"}\n");
fprintf(fout,"#else\n");
fprintf(fout,"extern \"C\" { %svoid init%s%s(); }\n\n", dllexp, prefix, libName);
fprintf(fout,"void init%s()\n", libName);
fprintf(fout,"{\n");
fprintf(fout," real_init%s(nullptr);\n", libName);
fprintf(fout,"}\n");
fprintf(fout,"#endif\n");
}
/* warning this code is also in getclasses.cxx under pcmaker */
/* this routine creates the init file */
static void CreateImplFile(const char *libName,
int numDepends, char **depends,
int numFiles, char **files,
FILE *fout)
{
int i;
const char* dllexp = "VTK_ABI_EXPORT ";
fprintf(fout,"// Generated by vtkWrapPythonInit in VTK/Wrapping\n");
fprintf(fout,"#include \"vtkPythonUtil.h\"\n");
fprintf(fout,"#include \"vtkSystemIncludes.h\"\n");
fprintf(fout,"#include <string.h>\n");
fprintf(fout,"// Handle compiler warning messages, etc.\n"
"#if defined( _MSC_VER ) && !defined(VTK_DISPLAY_WIN32_WARNINGS)\n"
"#pragma warning ( disable : 4706 )\n"
"#endif // Windows Warnings\n\n");
for (i = 0; i < numFiles; i++)
{
fprintf(fout,"extern \"C\" { PyObject *PyVTKAddFile_%s(PyObject *); }\n", files[i]);
}
fprintf(fout,"\nstatic PyMethodDef Py%s_Methods[] = {\n", libName);
fprintf(fout,"{nullptr, nullptr, 0, nullptr}};\n\n");
fprintf(fout,"#ifdef VTK_PY3K\n");
fprintf(fout,"static PyModuleDef Py%s_Module = {\n", libName);
fprintf(fout," PyModuleDef_HEAD_INIT,\n");
fprintf(fout," \"%s\", // m_name\n", libName);
fprintf(fout," nullptr, // m_doc\n");
fprintf(fout," 0, // m_size\n");
fprintf(fout," Py%s_Methods, //m_methods\n", libName);
fprintf(fout," nullptr, // m_reload\n");
fprintf(fout," nullptr, // m_traverse\n");
fprintf(fout," nullptr, // m_clear\n");
fprintf(fout," nullptr // m_free\n");
fprintf(fout,"};\n");
fprintf(fout,"#endif\n\n");
fprintf(fout,"extern \"C\" {%sPyObject *real_init%s(const char *); }\n\n", dllexp, libName);
fprintf(fout,"PyObject *real_init%s(const char *)\n{\n", libName);
/* module init function */
fprintf(fout,"#ifdef VTK_PY3K\n");
fprintf(fout," PyObject *m = PyModule_Create(&Py%s_Module);\n",
libName);
fprintf(fout,"#else\n");
fprintf(fout," PyObject *m = Py_InitModule(\"%s\",\n"
" Py%s_Methods);\n",
libName, libName);
fprintf(fout,"#endif\n\n");
fprintf(fout," PyObject *d = PyModule_GetDict(m);\n");
fprintf(fout," if (!d)\n");
fprintf(fout," {\n");
fprintf(fout," Py_FatalError(\"can't get dictionary for module %s\");\n",
libName);
fprintf(fout," }\n\n");
/* import all the modules that we depend on */
if (numDepends > 0)
{
fprintf(fout," const char *depends[%d] = {\n", numDepends);
for (i = 0; i < numDepends; i++)
{
fprintf(fout," \"%s\",\n", depends[i]);
}
fprintf(fout," };\n\n");
fprintf(fout," for (int i = 0; i < %d; i++)\n", numDepends);
fprintf(fout," {\n");
fprintf(fout," if (!vtkPythonUtil::ImportModule(depends[i], d))\n");
fprintf(fout," {\n");
fprintf(fout," return PyErr_Format(PyExc_ImportError,\n"
" \"Failed to load %s: No module named %%s\",\n"
" depends[i]);\n", libName);
fprintf(fout," }\n");
fprintf(fout," }\n\n");
}
for (i = 0; i < numFiles; i++)
{
fprintf(fout," PyVTKAddFile_%s(d);\n", files[i]);
}
fprintf(fout,"\n");
fprintf(fout," vtkPythonUtil::AddModule(\"%s\");\n\n", libName);
fprintf(fout," return m;\n");
fprintf(fout,"}\n\n");
}
int main(int argc,char *argv[])
{
FILE *file;
FILE *fout_init;
FILE *fout_impl;
int numFiles = 0;
int numDepends = 0;
char libName[250];
char tmpVal[250];
char *files[4000];
char *depends[400];
int doDepends = 0;
if (argc < 4)
{
fprintf(stderr,"Usage: %s input_file init_file impl_file\n",argv[0]);
return 1;
}
file = fopen(argv[1],"r");
if (!file)
{
fprintf(stderr,"Input file %s could not be opened\n",argv[1]);
return 1;
}
/* read the info from the file */
if (fscanf(file,"%s",libName) != 1)
{
fprintf(stderr,"Error getting libName\n");
fclose(file);
return 1;
}
/* read in the classes */
while (fscanf(file,"%s",tmpVal) != EOF)
{
if (strcmp(tmpVal,"DEPENDS") == 0)
{
doDepends = 1;
}
else if (doDepends)
{
depends[numDepends++] = strdup(tmpVal);
}
else
{
files[numFiles++] = strdup(tmpVal);
}
}
/* close the file */
fclose(file);
file = NULL;
fout_init = fopen(argv[2],"w");
if (!fout_init)
{
return 1;
}
fout_impl = fopen(argv[3],"w");
if (!fout_impl)
{
fclose(fout_init);
return 1;
}
/* extra functions, types, etc. for the CommonCore module */
if (strcmp(libName, "vtkCommonCorePython") == 0 ||
strcmp(libName, "vtkCommonKitPython") == 0)
{
files[numFiles] = strdup("PyVTKExtras");
numFiles++;
}
CreateInitFile(libName, fout_init);
CreateImplFile(libName, numDepends, depends, numFiles, files, fout_impl);
fclose(fout_init);
fclose(fout_impl);
return 0;
}
|
the_stack_data/23575013.c | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
typedef struct TYPE_8__ TYPE_4__ ;
typedef struct TYPE_7__ TYPE_3__ ;
typedef struct TYPE_6__ TYPE_2__ ;
typedef struct TYPE_5__ TYPE_1__ ;
/* Type definitions */
typedef int /*<<< orphan*/ u32 ;
struct wireless_dev {int iftype; struct cfg80211_internal_bss* current_bss; TYPE_1__* netdev; } ;
struct sk_buff {int dummy; } ;
struct nlattr {int dummy; } ;
struct netlink_callback {int /*<<< orphan*/ skb; } ;
struct TYPE_7__ {int signal_type; } ;
struct cfg80211_registered_device {TYPE_3__ wiphy; int /*<<< orphan*/ bss_generation; } ;
struct cfg80211_bss {int /*<<< orphan*/ signal; int /*<<< orphan*/ chain_signal; int /*<<< orphan*/ chains; int /*<<< orphan*/ scan_width; TYPE_2__* channel; scalar_t__ capability; scalar_t__ beacon_interval; int /*<<< orphan*/ beacon_ies; int /*<<< orphan*/ ies; int /*<<< orphan*/ proberesp_ies; int /*<<< orphan*/ bssid; } ;
struct cfg80211_internal_bss {struct cfg80211_bss pub; scalar_t__ ts_boottime; int /*<<< orphan*/ parent_bssid; scalar_t__ parent_tsf; scalar_t__ ts; } ;
struct cfg80211_bss_ies {int /*<<< orphan*/ data; scalar_t__ len; scalar_t__ tsf; scalar_t__ from_beacon; } ;
struct TYPE_8__ {int /*<<< orphan*/ portid; } ;
struct TYPE_6__ {int /*<<< orphan*/ center_freq; } ;
struct TYPE_5__ {int /*<<< orphan*/ ifindex; } ;
/* Variables and functions */
int /*<<< orphan*/ ASSERT_WDEV_LOCK (struct wireless_dev*) ;
#define CFG80211_SIGNAL_TYPE_MBM 132
#define CFG80211_SIGNAL_TYPE_UNSPEC 131
int EMSGSIZE ;
scalar_t__ ETH_ALEN ;
TYPE_4__ NETLINK_CB (int /*<<< orphan*/ ) ;
int /*<<< orphan*/ NL80211_ATTR_BSS ;
int /*<<< orphan*/ NL80211_ATTR_GENERATION ;
int /*<<< orphan*/ NL80211_ATTR_IFINDEX ;
int /*<<< orphan*/ NL80211_ATTR_PAD ;
int /*<<< orphan*/ NL80211_ATTR_WDEV ;
int /*<<< orphan*/ NL80211_BSS_BEACON_IES ;
int /*<<< orphan*/ NL80211_BSS_BEACON_INTERVAL ;
int /*<<< orphan*/ NL80211_BSS_BEACON_TSF ;
int /*<<< orphan*/ NL80211_BSS_BSSID ;
int /*<<< orphan*/ NL80211_BSS_CAPABILITY ;
int /*<<< orphan*/ NL80211_BSS_CHAIN_SIGNAL ;
int /*<<< orphan*/ NL80211_BSS_CHAN_WIDTH ;
int /*<<< orphan*/ NL80211_BSS_FREQUENCY ;
int /*<<< orphan*/ NL80211_BSS_INFORMATION_ELEMENTS ;
int /*<<< orphan*/ NL80211_BSS_LAST_SEEN_BOOTTIME ;
int /*<<< orphan*/ NL80211_BSS_PAD ;
int /*<<< orphan*/ NL80211_BSS_PARENT_BSSID ;
int /*<<< orphan*/ NL80211_BSS_PARENT_TSF ;
int /*<<< orphan*/ NL80211_BSS_PRESP_DATA ;
int /*<<< orphan*/ NL80211_BSS_SEEN_MS_AGO ;
int /*<<< orphan*/ NL80211_BSS_SIGNAL_MBM ;
int /*<<< orphan*/ NL80211_BSS_SIGNAL_UNSPEC ;
int /*<<< orphan*/ NL80211_BSS_STATUS ;
int /*<<< orphan*/ NL80211_BSS_STATUS_ASSOCIATED ;
int /*<<< orphan*/ NL80211_BSS_STATUS_IBSS_JOINED ;
int /*<<< orphan*/ NL80211_BSS_TSF ;
int /*<<< orphan*/ NL80211_CMD_NEW_SCAN_RESULTS ;
#define NL80211_IFTYPE_ADHOC 130
#define NL80211_IFTYPE_P2P_CLIENT 129
#define NL80211_IFTYPE_STATION 128
int /*<<< orphan*/ genl_dump_check_consistent (struct netlink_callback*,void*) ;
int /*<<< orphan*/ genlmsg_cancel (struct sk_buff*,void*) ;
int /*<<< orphan*/ genlmsg_end (struct sk_buff*,void*) ;
int /*<<< orphan*/ is_zero_ether_addr (int /*<<< orphan*/ ) ;
scalar_t__ jiffies ;
int /*<<< orphan*/ jiffies_to_msecs (scalar_t__) ;
int /*<<< orphan*/ nl80211_put_signal (struct sk_buff*,int /*<<< orphan*/ ,int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
void* nl80211hdr_put (struct sk_buff*,int /*<<< orphan*/ ,int /*<<< orphan*/ ,int,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ nla_nest_end (struct sk_buff*,struct nlattr*) ;
struct nlattr* nla_nest_start_noflag (struct sk_buff*,int /*<<< orphan*/ ) ;
scalar_t__ nla_put (struct sk_buff*,int /*<<< orphan*/ ,scalar_t__,int /*<<< orphan*/ ) ;
scalar_t__ nla_put_flag (struct sk_buff*,int /*<<< orphan*/ ) ;
scalar_t__ nla_put_u16 (struct sk_buff*,int /*<<< orphan*/ ,scalar_t__) ;
scalar_t__ nla_put_u32 (struct sk_buff*,int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
scalar_t__ nla_put_u64_64bit (struct sk_buff*,int /*<<< orphan*/ ,scalar_t__,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ nla_put_u8 (struct sk_buff*,int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
scalar_t__ rcu_access_pointer (int /*<<< orphan*/ ) ;
struct cfg80211_bss_ies* rcu_dereference (int /*<<< orphan*/ ) ;
int /*<<< orphan*/ rcu_read_lock () ;
int /*<<< orphan*/ rcu_read_unlock () ;
scalar_t__ wdev_id (struct wireless_dev*) ;
__attribute__((used)) static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
u32 seq, int flags,
struct cfg80211_registered_device *rdev,
struct wireless_dev *wdev,
struct cfg80211_internal_bss *intbss)
{
struct cfg80211_bss *res = &intbss->pub;
const struct cfg80211_bss_ies *ies;
void *hdr;
struct nlattr *bss;
ASSERT_WDEV_LOCK(wdev);
hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
NL80211_CMD_NEW_SCAN_RESULTS);
if (!hdr)
return -1;
genl_dump_check_consistent(cb, hdr);
if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
goto nla_put_failure;
if (wdev->netdev &&
nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
goto nla_put_failure;
if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
NL80211_ATTR_PAD))
goto nla_put_failure;
bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS);
if (!bss)
goto nla_put_failure;
if ((!is_zero_ether_addr(res->bssid) &&
nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
goto nla_put_failure;
rcu_read_lock();
/* indicate whether we have probe response data or not */
if (rcu_access_pointer(res->proberesp_ies) &&
nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
goto fail_unlock_rcu;
/* this pointer prefers to be pointed to probe response data
* but is always valid
*/
ies = rcu_dereference(res->ies);
if (ies) {
if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
NL80211_BSS_PAD))
goto fail_unlock_rcu;
if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
ies->len, ies->data))
goto fail_unlock_rcu;
}
/* and this pointer is always (unless driver didn't know) beacon data */
ies = rcu_dereference(res->beacon_ies);
if (ies && ies->from_beacon) {
if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
NL80211_BSS_PAD))
goto fail_unlock_rcu;
if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
ies->len, ies->data))
goto fail_unlock_rcu;
}
rcu_read_unlock();
if (res->beacon_interval &&
nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
goto nla_put_failure;
if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
jiffies_to_msecs(jiffies - intbss->ts)))
goto nla_put_failure;
if (intbss->parent_tsf &&
(nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
intbss->parent_tsf, NL80211_BSS_PAD) ||
nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
intbss->parent_bssid)))
goto nla_put_failure;
if (intbss->ts_boottime &&
nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
intbss->ts_boottime, NL80211_BSS_PAD))
goto nla_put_failure;
if (!nl80211_put_signal(msg, intbss->pub.chains,
intbss->pub.chain_signal,
NL80211_BSS_CHAIN_SIGNAL))
goto nla_put_failure;
switch (rdev->wiphy.signal_type) {
case CFG80211_SIGNAL_TYPE_MBM:
if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
goto nla_put_failure;
break;
case CFG80211_SIGNAL_TYPE_UNSPEC:
if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
goto nla_put_failure;
break;
default:
break;
}
switch (wdev->iftype) {
case NL80211_IFTYPE_P2P_CLIENT:
case NL80211_IFTYPE_STATION:
if (intbss == wdev->current_bss &&
nla_put_u32(msg, NL80211_BSS_STATUS,
NL80211_BSS_STATUS_ASSOCIATED))
goto nla_put_failure;
break;
case NL80211_IFTYPE_ADHOC:
if (intbss == wdev->current_bss &&
nla_put_u32(msg, NL80211_BSS_STATUS,
NL80211_BSS_STATUS_IBSS_JOINED))
goto nla_put_failure;
break;
default:
break;
}
nla_nest_end(msg, bss);
genlmsg_end(msg, hdr);
return 0;
fail_unlock_rcu:
rcu_read_unlock();
nla_put_failure:
genlmsg_cancel(msg, hdr);
return -EMSGSIZE;
} |
the_stack_data/132951691.c | #include <stdio.h>
#include <math.h>
#define MAX_SIZE 50
int main(int argc, char *argv[]) {
printf("%s\n\n", argv[1]);
FILE* file = fopen (argv[1], "r");
int tot;
int x[MAX_SIZE];
int y[MAX_SIZE];
int a[MAX_SIZE];
int b[MAX_SIZE];
int service[MAX_SIZE];
int tmp = 0;
fscanf (file, "%d", &tot);
printf ("tot = %d\n", tot);
for (int i = 0; i < tot; i++)
{
fscanf (file, "%d", &tmp);
fscanf (file, "%d", &x[i]);
fscanf (file, "%d", &y[i]);
fscanf (file, "%d", &tmp);
fscanf (file, "%d", &a[i]);
fscanf (file, "%d", &b[i]);
fscanf (file, "%d", &service[i]);
printf("x = %d, y = %d, a = %d, b = %d, service = %d\n", x[i], y[i], a[i], b[i], service[i]);
}
fclose (file);
printf("\n\n** DISTANCES\n\n");
int dist = 0;
int time = 0;
for (int u = 1; u < tot; u++) {
printf("*distance 0 - %d\n", u);
dist = sqrt(pow(x[0] - x[u], 2) + pow(y[0] - y[u], 2));
printf("dist = %d, time = %d\n", dist, dist + service[u]);
}
} |
the_stack_data/130220.c | #include<stdio.h>
#include<string.h>
int main()
{
char str1[100],str2[100];
gets(str1);
gets(str2);
char temp[100];
strcpy(temp,str1);
strcpy(str1,str2);
strcpy(str2,temp);
printf("%s %s",str1,str2);
} |
the_stack_data/38791.c | //
// Created by j on 19-1-16.
//
// name1.c -- 读取一个名字
#include <stdio.h>
#define MAX 81
int main(void)
{
char name[MAX];
printf("Hi, what's your name?\n");
gets(name);
printf("Nice name, %s.\n",name);
return 0;
}
|
the_stack_data/117566.c | /*
* rebind: Intercept bind calls and bind to a different port
* Copyright 2010 Joel Martin
* Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
*
* Overload (LD_PRELOAD) bind system call. If REBIND_PORT_OLD and
* REBIND_PORT_NEW environment variables are set then bind on the new
* port (of localhost) instead of the old port.
*
* This allows a proxy (such as wsproxy) to run on the old port and translate
* traffic to/from the new port.
*
* Usage:
* LD_PRELOAD=./rebind.so \
* REBIND_PORT_OLD=23 \
* REBIND_PORT_NEW=2023 \
* program
*/
//#define DO_DEBUG 1
#include <stdio.h>
#include <stdlib.h>
#define __USE_GNU 1 // Pull in RTLD_NEXT
#include <dlfcn.h>
#include <string.h>
#include <netinet/in.h>
#if defined(DO_DEBUG)
#define DEBUG(...) \
fprintf(stderr, "wswrapper: "); \
fprintf(stderr, __VA_ARGS__);
#else
#define DEBUG(...)
#endif
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
static void * (*func)();
int do_move = 0;
struct sockaddr_in * addr_in = (struct sockaddr_in *)addr;
struct sockaddr_in addr_tmp;
socklen_t addrlen_tmp;
char * PORT_OLD, * PORT_NEW, * end1, * end2;
int ret, oldport, newport, askport = htons(addr_in->sin_port);
uint32_t askaddr = htons(addr_in->sin_addr.s_addr);
if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "bind");
DEBUG(">> bind(%d, _, %d), askaddr %d, askport %d\n",
sockfd, addrlen, askaddr, askport);
/* Determine if we should move this socket */
if (addr_in->sin_family == AF_INET) {
// TODO: support IPv6
PORT_OLD = getenv("REBIND_OLD_PORT");
PORT_NEW = getenv("REBIND_NEW_PORT");
if (PORT_OLD && (*PORT_OLD != '\0') &&
PORT_NEW && (*PORT_NEW != '\0')) {
oldport = strtol(PORT_OLD, &end1, 10);
newport = strtol(PORT_NEW, &end2, 10);
if (oldport && (*end1 == '\0') &&
newport && (*end2 == '\0') &&
(oldport == askport)) {
do_move = 1;
}
}
}
if (! do_move) {
/* Just pass everything right through to the real bind */
ret = (int) func(sockfd, addr, addrlen);
DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
return ret;
}
DEBUG("binding fd %d on localhost:%d instead of 0x%x:%d\n",
sockfd, newport, ntohl(addr_in->sin_addr.s_addr), oldport);
/* Use a temporary location for the new address information */
addrlen_tmp = sizeof(addr_tmp);
memcpy(&addr_tmp, addr, addrlen_tmp);
/* Bind to other port on the loopback instead */
addr_tmp.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr_tmp.sin_port = htons(newport);
ret = (int) func(sockfd, &addr_tmp, addrlen_tmp);
DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
return ret;
}
|
the_stack_data/62636920.c | void foo()
{
int i;
switch (i)
{
case 1:
goto xxx;
case 2:
break;
// BUG: unparses as:
// default:
// xxx:
// xxx:
// break;
default:
xxx: break;
}
}
|
the_stack_data/212642134.c | #include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
/* Program ispituje da li je fajl vezan za standardni ulaz
pretraziv. */
int main(int argc, char **argv){
if (lseek(STDIN_FILENO, 0, SEEK_CUR) < 0){
perror("lseek()");
}else{
fprintf(stdout, "Moze da se pretrazuje.\n");
}
exit(EXIT_SUCCESS);
}
|
the_stack_data/150142133.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#pragma warning (disable: 4996)
void main()
{
double sidea, sideb, sidec, anga;
printf("enter the value for side b\n");
scanf("%lf", &sideb);
printf("enter the value for side c\n");
scanf("%lf", &sidec);
printf("enter the value for angle a \n");
scanf("%lf", &anga);
sidea = sqrt(pow(sideb, 2) + pow(sidec, 2) - (2 *(sideb)*(sidec)* cos(anga)));
printf("the value of side a is %f\n", sidea);
system("pause");
}
|
the_stack_data/40762759.c | #include <stdio.h>
#include <stdbool.h>
float kilogram_to_pound(int kg)
{
return kg/0.454;
}
float pound_to_kilogram(int lbs)
{
return lbs*0.454;
}
int main()
{
float kg;
float lbs;
float ans;
bool running = true;
while(running){
printf("This is a calculator that converts weights:\n\n\tMenu:\n\t1. KG -> LBS\n\t2. LBS -> KG\n\t3. quit\n\n");
int choice;
scanf("%d", &choice);
if(choice == 1) {
printf("Enter weight in KG");
scanf("%f", &kg);
ans = kilogram_to_pound(kg);
printf("%f", ans);
} else if(choice == 2) {
printf("Enter weight in LBS");
scanf("%f", &kg);
ans = pound_to_kilogram(kg);
printf("%f", ans);
} else if(choice == 3) {
printf("Later skater\n\n");
running = false;
return 0;
} else {
printf("You've to enter a valid key, this program only accepts integers");
}
}
}
|
the_stack_data/26555.c | // Test that the GCC fast-math floating point flags get lowered to the correct
// permutation of Clang frontend flags. This is non-trivial for a few reasons.
// First, the GCC flags have many different and surprising effects. Second,
// LLVM only supports three switches which is more coarse grained than GCC's
// support.
//
// Both of them use gcc driver for as.
// REQUIRES: clang-driver
//
// RUN: %clang -### -fno-honor-infinities -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-INFS %s
// infinites [sic] is a supported alternative spelling of infinities.
// RUN: %clang -### -fno-honor-infinites -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-INFS %s
// CHECK-NO-INFS: "-cc1"
// CHECK-NO-INFS: "-menable-no-infs"
//
// RUN: %clang -### -fno-fast-math -fno-honor-infinities -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH-NO-INFS %s
// CHECK-NO-FAST-MATH-NO-INFS: "-cc1"
// CHECK-NO-FAST-MATH-NO-INFS: "-menable-no-infs"
//
// RUN: %clang -### -fno-honor-infinities -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-INFS-NO-FAST-MATH %s
// CHECK-NO-INFS-NO-FAST-MATH: "-cc1"
// CHECK-NO-INFS-NO-FAST-MATH-NOT: "-menable-no-infs"
//
// RUN: %clang -### -fno-signed-zeros -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-SIGNED-ZEROS %s
// CHECK-NO-SIGNED-ZEROS: "-cc1"
// CHECK-NO-SIGNED-ZEROS: "-fno-signed-zeros"
//
// RUN: %clang -### -fno-fast-math -fno-signed-zeros -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH-NO-SIGNED-ZEROS %s
// CHECK-NO-FAST-MATH-NO-SIGNED-ZEROS: "-cc1"
// CHECK-NO-FAST-MATH-NO-SIGNED-ZEROS: "-fno-signed-zeros"
//
// RUN: %clang -### -fno-signed-zeros -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-SIGNED-ZEROS-NO-FAST-MATH %s
// CHECK-NO-SIGNED-ZEROS-NO-FAST-MATH: "-cc1"
// CHECK-NO-SIGNED-ZEROS-NO-FAST-MATH-NOT: "-fno-signed-zeros"
//
// RUN: %clang -### -freciprocal-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-RECIPROCAL-MATH %s
// CHECK-RECIPROCAL-MATH: "-cc1"
// CHECK-RECIPROCAL-MATH: "-freciprocal-math"
//
// RUN: %clang -### -fno-fast-math -freciprocal-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH-RECIPROCAL-MATH %s
// CHECK-NO-FAST-MATH-RECIPROCAL-MATH: "-cc1"
// CHECK-NO-FAST-MATH-RECIPROCAL-MATH: "-freciprocal-math"
//
// RUN: %clang -### -freciprocal-math -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-RECIPROCAL-MATH-NO-FAST-MATH %s
// CHECK-RECIPROCAL-MATH-NO-FAST-MATH: "-cc1"
// CHECK-RECIPROCAL-MATH-NO-FAST-MATH-NOT: "-freciprocal-math"
//
// RUN: %clang -### -fno-honor-nans -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NANS %s
// CHECK-NO-NANS: "-cc1"
// CHECK-NO-NANS: "-menable-no-nans"
//
// RUN: %clang -### -fno-fast-math -fno-honor-nans -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH-NO-NANS %s
// CHECK-NO-FAST-MATH-NO-NANS: "-cc1"
// CHECK-NO-FAST-MATH-NO-NANS: "-menable-no-nans"
//
// RUN: %clang -### -fno-honor-nans -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NANS-NO-FAST-MATH %s
// CHECK-NO-NANS-NO-FAST-MATH: "-cc1"
// CHECK-NO-NANS-NO-FAST-MATH-NOT: "-menable-no-nans"
//
// RUN: %clang -### -ffast-math -fno-approx-func -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH-NO-APPROX-FUNC %s
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-cc1"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-menable-no-infs"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-menable-no-nans"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-fno-signed-zeros"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-mreassociate"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-freciprocal-math"
// CHECK-FAST-MATH-NO-APPROX-FUNC: "-ffp-contract=fast"
// CHECK-FAST-MATH-NO-APPROX-FUNC-NOT: "-ffast-math"
// CHECK-FAST-MATH-NO-APPROX-FUNC-NOT: "-fapprox-func"
//
// RUN: %clang -### -fno-approx-func -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-APPROX-FUNC-FAST-MATH %s
// CHECK-NO-APPROX-FUNC-FAST-MATH: "-cc1"
// CHECK-NO-APPROX-FUNC-FAST-MATH: "-ffast-math"
//
// RUN: %clang -### -fapprox-func -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-APPROX-FUNC %s
// CHECK-APPROX-FUNC: "-cc1"
// CHECK-APPROX-FUNC: "-fapprox-func"
//
// RUN: %clang -### -fmath-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
// CHECK-MATH-ERRNO: "-cc1"
// CHECK-MATH-ERRNO: "-fmath-errno"
//
// RUN: %clang -### -fmath-errno -fno-math-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// CHECK-NO-MATH-ERRNO: "-cc1"
// CHECK-NO-MATH-ERRNO-NOT: "-fmath-errno"
//
// Target defaults for -fmath-errno (reusing the above checks).
// RUN: %clang -### -target i686-unknown-linux -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
// RUN: %clang -### -target i686-apple-darwin -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-unknown-freebsd -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-unknown-netbsd -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-unknown-openbsd -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-unknown-dragonfly -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-fuchsia -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-linux-android -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target x86_64-linux-musl -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target amdgcn-amd-amdhsa -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target amdgcn-amd-amdpal -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target amdgcn-mesa-mesa3d -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
//
// Check that -ffast-math disables -fmath-errno, and -fno-fast-math merely
// preserves the target default. Also check various flag set operations between
// the two flags. (Resuses above checks.)
// RUN: %clang -### -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -fmath-errno -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -ffast-math -fmath-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
// RUN: %clang -### -target i686-unknown-linux -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
// RUN: %clang -### -target i686-unknown-linux -fno-math-errno -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
// RUN: %clang -### -target i686-apple-darwin -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -target i686-apple-darwin -fno-math-errno -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
// RUN: %clang -### -fno-fast-math -fno-math-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
//
// RUN: %clang -### -fno-math-errno -fassociative-math -freciprocal-math \
// RUN: -fno-signed-zeros -fno-trapping-math -fapprox-func -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-UNSAFE-MATH %s
// CHECK-UNSAFE-MATH: "-cc1"
// CHECK-UNSAFE-MATH: "-menable-unsafe-fp-math"
// CHECK-UNSAFE-MATH: "-mreassociate"
//
// RUN: %clang -### -fno-fast-math -fno-math-errno -fassociative-math -freciprocal-math \
// RUN: -fno-signed-zeros -fno-trapping-math -fapprox-func -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH-UNSAFE-MATH %s
// CHECK-NO-FAST-MATH-UNSAFE-MATH: "-cc1"
// CHECK-NO-FAST-MATH-UNSAFE-MATH: "-menable-unsafe-fp-math"
// CHECK-NO-FAST-MATH-UNSAFE-MATH: "-mreassociate"
// The 2nd -fno-fast-math overrides -fassociative-math.
// RUN: %clang -### -fno-fast-math -fno-math-errno -fassociative-math -freciprocal-math \
// RUN: -fno-fast-math -fno-signed-zeros -fno-trapping-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-UNSAFE-MATH-NO-FAST-MATH %s
// CHECK-UNSAFE-MATH-NO-FAST-MATH: "-cc1"
// CHECK-UNSAFE-MATH-NO-FAST-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-UNSAFE-MATH-NO-FAST-MATH-NOT: "-mreassociate"
//
// Check that various umbrella flags also enable these frontend options.
// RUN: %clang -### -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-INFS %s
// RUN: %clang -### -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NANS %s
// RUN: %clang -### -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-UNSAFE-MATH %s
// RUN: %clang -### -ffinite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-INFS %s
// RUN: %clang -### -ffinite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NANS %s
// RUN: %clang -### -funsafe-math-optimizations -fno-math-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-UNSAFE-MATH %s
//
// One umbrella flag is *really* weird and also changes the semantics of the
// program by adding a special preprocessor macro. Check that the frontend flag
// modeling this semantic change is provided. Also check that the flag is not
// present if any of the optimizations are disabled.
// RUN: %clang -### -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// RUN: %clang -### -fno-fast-math -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -ffinite-math-only \
// RUN: -fno-math-errno -ffp-contract=fast -fno-rounding-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// RUN: %clang -### -fno-honor-infinities -fno-honor-nans -fno-math-errno \
// RUN: -fassociative-math -freciprocal-math -fno-signed-zeros -fapprox-func \
// RUN: -fno-trapping-math -ffp-contract=fast -fno-rounding-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// CHECK-FAST-MATH: "-cc1"
// CHECK-FAST-MATH: "-ffast-math"
// CHECK-FAST-MATH: "-ffinite-math-only"
//
// RUN: %clang -### -ffast-math -fno-fast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH %s
// RUN: %clang -### -ffast-math -fno-finite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH %s
// RUN: %clang -### -ffast-math -fno-unsafe-math-optimizations -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH %s
// RUN: %clang -### -ffast-math -fmath-errno -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH %s
// RUN: %clang -### -ffast-math -fno-associative-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FAST-MATH --check-prefix=CHECK-ASSOC-MATH %s
// CHECK-NO-FAST-MATH: "-cc1"
// CHECK-NO-FAST-MATH-NOT: "-ffast-math"
// CHECK-ASSOC-MATH-NOT: "-mreassociate"
//
// Check various means of disabling these flags, including disabling them after
// they've been enabled via an umbrella flag.
// RUN: %clang -### -fno-honor-infinities -fhonor-infinities -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-INFS %s
// RUN: %clang -### -ffinite-math-only -fhonor-infinities -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-INFS %s
// RUN: %clang -### -ffinite-math-only -fno-finite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-INFS %s
// RUN: %clang -### -ffast-math -fhonor-infinities -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-INFS %s
// RUN: %clang -### -ffast-math -fno-finite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-INFS %s
// CHECK-NO-NO-INFS: "-cc1"
// CHECK-NO-NO-INFS-NOT: "-menable-no-infs"
// CHECK-NO-NO-INFS-NOT: "-ffinite-math-only"
// CHECK-NO-NO-INFS: "-o"
//
// RUN: %clang -### -fno-honor-nans -fhonor-nans -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-NANS %s
// RUN: %clang -### -ffinite-math-only -fhonor-nans -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-NANS %s
// RUN: %clang -### -ffinite-math-only -fno-finite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-NANS %s
// RUN: %clang -### -ffast-math -fhonor-nans -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-NANS %s
// RUN: %clang -### -ffast-math -fno-finite-math-only -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-NO-NANS %s
// CHECK-NO-NO-NANS: "-cc1"
// CHECK-NO-NO-NANS-NOT: "-menable-no-nans"
// CHECK-NO-NO-NANS-NOT: "-ffinite-math-only"
// CHECK-NO-NO-NANS: "-o"
// A later inverted option overrides an earlier option.
// RUN: %clang -### -fassociative-math -freciprocal-math -fno-signed-zeros \
// RUN: -fno-trapping-math -fno-associative-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -fno-associative-math -c %s \
// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -fno-reciprocal-math -c %s \
// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -fsigned-zeros -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -ftrapping-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -fno-unsafe-math-optimizations \
// RUN: -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -ffast-math -fno-associative-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -ffast-math -fno-reciprocal-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -ffast-math -fsigned-zeros -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -ffast-math -ftrapping-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// RUN: %clang -### -ffast-math -fno-unsafe-math-optimizations -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-UNSAFE-MATH %s
// CHECK-NO-UNSAFE-MATH: "-cc1"
// CHECK-NO-UNSAFE-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-NO_UNSAFE-MATH-NOT: "-mreassociate"
// CHECK-NO-UNSAFE-MATH: "-o"
// Reassociate is allowed because it does not require reciprocal-math.
// RUN: %clang -### -fassociative-math -freciprocal-math -fno-signed-zeros \
// RUN: -fno-trapping-math -fno-reciprocal-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-REASSOC-NO-UNSAFE-MATH %s
// CHECK-REASSOC-NO-UNSAFE-MATH: "-cc1"
// CHECK-REASSOC-NO-UNSAFE-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-REASSOC-NO_UNSAFE-MATH: "-mreassociate"
// CHECK-REASSOC-NO-UNSAFE-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-REASSOC-NO-UNSAFE-MATH: "-o"
// In these runs, reassociate is not allowed because both no-signed-zeros and no-trapping-math are required.
// RUN: %clang -### -fassociative-math -freciprocal-math -fno-signed-zeros \
// RUN: -fno-trapping-math -fsigned-zeros -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-REASSOC-NO-UNSAFE-MATH %s
// RUN: %clang -### -fassociative-math -freciprocal-math -fno-signed-zeros \
// RUN: -fno-trapping-math -ftrapping-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-REASSOC-NO-UNSAFE-MATH %s
// CHECK-NO-REASSOC-NO-UNSAFE-MATH: "-cc1"
// CHECK-NO-REASSOC-NO-UNSAFE-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-NO-REASSOC-NO_UNSAFE-MATH-NOT: "-mreassociate"
// CHECK-NO-REASSOC-NO-UNSAFE-MATH-NOT: "-menable-unsafe-fp-math"
// CHECK-NO-REASSOC-NO-UNSAFE-MATH: "-o"
// This isn't fast-math, but the option is handled in the same place as other FP params.
// Last option wins, and strict behavior is assumed by default.
// RUN: %clang -### -fno-strict-float-cast-overflow -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FPOV-WORKAROUND %s
// CHECK-FPOV-WORKAROUND: "-cc1"
// CHECK-FPOV-WORKAROUND: "-fno-strict-float-cast-overflow"
// RUN: %clang -### -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FPOV-WORKAROUND-DEFAULT %s
// CHECK-FPOV-WORKAROUND-DEFAULT: "-cc1"
// CHECK-FPOV-WORKAROUND-DEFAULT-NOT: "strict-float-cast-overflow"
// RUN: %clang -### -fstrict-float-cast-overflow -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FPOV-WORKAROUND %s
// CHECK-NO-FPOV-WORKAROUND: "-cc1"
// CHECK-NO-FPOV-WORKAROUND-NOT: "strict-float-cast-overflow"
// RUN: %clang -### -fno-strict-float-cast-overflow -fstrict-float-cast-overflow -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NO-FPOV-WORKAROUND-OVERRIDE %s
// CHECK-NO-FPOV-WORKAROUND-OVERRIDE: "-cc1"
// CHECK-NO-FPOV-WORKAROUND-OVERRIDE-NOT: "strict-float-cast-overflow"
|
the_stack_data/69851.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
struct Node {
int value;
struct Node *previous;
};
struct Node* createNode(int value, struct Node *previous) {
struct Node *node = (struct Node*) malloc(sizeof(struct Node));
node->value = value;
if (previous) {
node->previous = previous;
}
return node;
}
void main() {
struct Node *first = createNode(2020, NULL);
struct Node *second = createNode(2021, first);
struct Node *third = createNode(2022, second);
struct Node *iterator = third;
while(iterator) {
printf("%d, ", iterator->value);
iterator = iterator->previous;
}
}
|
the_stack_data/25137647.c | /*
* Copyright (C) 2000-2006 Erik Andersen <[email protected]>
*
* Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
*/
#include <unistd.h>
int setpgrp(void)
{
return setpgid(0,0);
}
|
the_stack_data/173577086.c | //To check whether the given number is Armstrong number or not
//Armstrong number: An n -digit number equal to the sum of the nth powers of its digits.
//Example: (1^3) + (5^3) + (3^3)= 153
#include<stdio.h>
#include<math.h>
void main() {
int number, sum = 0, rem = 0, nthPower = 0, digits = 0, temp;
printf("Enter a number :");
scanf("%d", & number);
temp = number;
//to calculate the number of digits in the number
while (number != 0) {
number = number / 10;
digits++;
}
number = temp;
//to get the nth power of each digit and add it to the sum
while (number != 0) {
rem = number % 10;
nthPower = pow(rem, digits);
sum = sum + nthPower;
number = number / 10;
}
//to check if obtained sum is equal to the original number
if (sum == temp)
printf("The given number is an Armstrong number\n");
else
printf("The given number is not an Armstrong number\n");
}
//Note : when Complile in vs code use cc -o ArmstrongNumber ArmstrongNumber.c -lm
//because it is not locate math.h |
the_stack_data/729412.c | /* $OpenBSD: n_fdim.c,v 1.3 2008/12/10 01:08:24 martynas Exp $ */
/*-
* Copyright (c) 2004 David Schultz <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#include <math.h>
#define DECL(type, fn) \
type \
fn(type x, type y) \
{ \
\
if (isnan(x)) \
return (x); \
if (isnan(y)) \
return (y); \
return (x > y ? x - y : 0.0); \
}
DECL(double, fdim)
DECL(float, fdimf)
__weak_alias(fdiml, fdim);
|
the_stack_data/67325399.c | #include <stdio.h>
int main() {
int i, loan_amount, interest_rate, months;
float total_amount;
printf("Please enter the loan amount\n\t: ");
scanf("%d", &loan_amount);
printf("Please enter the interest rate\n\t: ");
scanf("%d", &interest_rate);
printf("After how many months you want to settle the loan?\n\t: ");
scanf("%d", &months);
// this is the amount before 1st month
total_amount = loan_amount + loan_amount * interest_rate / 100.0;
for (i = 1; i <= months; i++) {
total_amount = total_amount + total_amount * interest_rate / 100.0;
printf("After month %d, the total amount is %.f\n", i, total_amount);
}
return 0;
} |
the_stack_data/117328290.c | #include <stdio.h>
int _mergeSort(int arr[], int temp[], int left, int right);
int merge(int arr[], int temp[], int left, int mid, int right);
// this function sorts the input array and returns the inversions
int mergeSort(int arr[], int size) {
int *temp = (int *)malloc(sizeof(int) * size);
return _mergeSort(arr, temp, 0, size - 1);
}
// auxiallary recursive function that sorts input array and returns the
// number of inversions in the array
int _mergeSort(int arr[], int temp[], int left, int right) {
int mid, inv_count = 0;
if(right > left) {
mid = (right + left) / 2;
// Inversion count will be the sum of the inversions in the leftpart
// and the right part
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
// merge the two parts
inv_count += merge(arr, temp, left, mid +1, right);
}
return inv_count;
}
// this functions mergers the two sorted arrays and return the inversion
// counts in both the arrays
int merge(int arr[], int temp[], int left, int mid, int right) {
int i, j, k;
int inv_count = 0;
i = left; // left array index
j = mid + 1; // right array index
k = left; // is the redultant merged subarray
while((i<=mid) && (j<=right)) {
if(arr[i] <= arr[j]) {
temp[k++] = arr[i++];
}
else {
temp[k++] = arr[j++];
// tricky part below
inv_count = inv_count + (mid - 1);
}
}
// if there are elements in the left subarray
while(i<=mid-1)
temp[k++] = arr[i++];
// if there are elements in the right array
while(j<=right)
temp[k++] = arr[j++];
//copy the merged elements back to the original array
for (i = left; i <= right; i++){
arr[i] = temp[i];
}
return inv_count;
}
int main()
{
int arr[] = {1, 20, 6, 4, 5};
printf("Number of inversions are %d", mergeSort(arr, 5));
return 0;
} |
the_stack_data/896529.c | #include <unistd.h>
#include <sys/syscall.h>
void _start() { /* _exit(0); */ syscall(SYS_exit, 0); }
|
the_stack_data/524617.c | // KASAN: global-out-of-bounds Read in fb_pad_aligned_buffer
// https://syzkaller.appspot.com/bug?id=43706ff83b09eb65e3176f37346ffb7754bd6d7a
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <endian.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_link.h>
#include <linux/in6.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/veth.h>
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
};
static struct nlmsg nlmsg;
static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
const void* data, int size)
{
memset(nlmsg, 0, sizeof(*nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len)
{
if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
if (hdr->nlmsg_type == NLMSG_DONE) {
*reply_len = 0;
return 0;
}
if (n < sizeof(struct nlmsghdr))
exit(1);
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 0;
}
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static int netlink_send(struct nlmsg* nlmsg, int sock)
{
return netlink_send_ext(nlmsg, sock, 0, NULL);
}
static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset,
unsigned int total_len)
{
struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset);
if (offset == total_len || offset + hdr->nlmsg_len > total_len)
return -1;
return hdr->nlmsg_len;
}
static void netlink_device_change(struct nlmsg* nlmsg, int sock,
const char* name, bool up, const char* master,
const void* mac, int macsize,
const char* new_name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
hdr.ifi_index = if_nametoindex(name);
netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
if (new_name)
netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
const int kInitNetNsFd = 239;
#define DEVLINK_FAMILY_NAME "devlink"
#define DEVLINK_CMD_PORT_GET 5
#define DEVLINK_CMD_RELOAD 37
#define DEVLINK_ATTR_BUS_NAME 1
#define DEVLINK_ATTR_DEV_NAME 2
#define DEVLINK_ATTR_NETDEV_NAME 7
#define DEVLINK_ATTR_NETNS_FD 138
static int netlink_devlink_id_get(struct nlmsg* nlmsg, int sock)
{
struct genlmsghdr genlhdr;
struct nlattr* attr;
int err, n;
uint16_t id = 0;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, DEVLINK_FAMILY_NAME,
strlen(DEVLINK_FAMILY_NAME) + 1);
err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
if (err) {
return -1;
}
attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); /* recv ack */
return id;
}
static void netlink_devlink_netns_move(const char* bus_name,
const char* dev_name, int netns_fd)
{
struct genlmsghdr genlhdr;
int sock;
int id, err;
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_RELOAD;
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_NETNS_FD, &netns_fd, sizeof(netns_fd));
err = netlink_send(&nlmsg, sock);
if (err) {
}
error:
close(sock);
}
static struct nlmsg nlmsg2;
static void initialize_devlink_ports(const char* bus_name, const char* dev_name,
const char* netdev_prefix)
{
struct genlmsghdr genlhdr;
int len, total_len, id, err, offset;
uint16_t netdev_index;
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (rtsock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_PORT_GET;
netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
err = netlink_send_ext(&nlmsg, sock, id, &total_len);
if (err) {
goto error;
}
offset = 0;
netdev_index = 0;
while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) {
struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg.buf + offset + len;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) {
char* port_name;
char netdev_name[IFNAMSIZ];
port_name = (char*)(attr + 1);
snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix,
netdev_index);
netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0,
netdev_name);
break;
}
}
offset += len;
netdev_index++;
}
error:
close(rtsock);
close(sock);
}
static void initialize_devlink_pci(void)
{
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
exit(1);
int ret = setns(kInitNetNsFd, 0);
if (ret == -1)
exit(1);
netlink_devlink_netns_move("pci", "0000:00:10.0", netns);
ret = setns(netns, 0);
if (ret == -1)
exit(1);
close(netns);
initialize_devlink_ports("pci", "0000:00:10.0", "netpci");
}
static long syz_open_dev(volatile long a0, volatile long a1, volatile long a2)
{
if (a0 == 0xc || a0 == 0xb) {
char buf[128];
sprintf(buf, "/dev/%s/%d:%d", a0 == 0xc ? "char" : "block", (uint8_t)a1,
(uint8_t)a2);
return open(buf, O_RDWR, 0);
} else {
char buf[1024];
char* hash;
strncpy(buf, (char*)a0, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = 0;
while ((hash = strchr(buf, '#'))) {
*hash = '0' + (char)(a1 % 10);
a1 /= 10;
}
return open(buf, a2, 0);
}
}
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
int main(void)
{
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 3ul, 0x32ul, -1, 0);
intptr_t res = 0;
res = syz_open_dev(0xc, 4, 1);
if (res != -1)
r[0] = res;
*(uint32_t*)0x20000040 = 0;
*(uint32_t*)0x20000044 = 0;
*(uint32_t*)0x20000048 = 0x20;
*(uint32_t*)0x2000004c = 0x13;
*(uint32_t*)0x20000050 = 0x100;
*(uint64_t*)0x20000058 = 0x200003c0;
memcpy(
(void*)0x200003c0,
"\xcb\xb6\x2c\x7c\x7e\x12\x72\x7d\x60\xc5\xdb\x26\x5c\x1d\x8b\x3f\x75\x25"
"\x50\xd4\xea\xc7\xaf\xf1\x02\x13\x26\xe1\x5d\xfd\xad\x91\x1d\x57\xa8\x53"
"\x41\x4b\x19\x47\x02\xa4\x1a\x75\x60\x56\x8b\xe1\x11\x1d\xac\x9f\xf2\x58"
"\x6d\x67\xdc\x8e\xf3\xe9\xd3\x66\x94\xc5\xea\x96\xd8\x98\x5a\x99\x53\xe8"
"\x77\x5c\xbf\x7a\xe1\x51\xea\x1f\xd6\x08\x63\xac\xd9\xe7\x60\x31\x83\x3d"
"\xff\xb4\x47\xc4\x25\xc9\x74\x9c\x7d\xe7\xfb\xe2\xe5\x65\xb4\xa2\x5f\x7b"
"\x2a\xc0\x13\x92\xce\x04\xec\x8d\x6d\x21\x0e\x0a\x23\xae\x3a\x5f\xd8\x1c"
"\x3c\x89\xc9\x28\x74\x70\x9f\xcd\xd4\xd4\xc3\xff\xe7\xfa\x05\x2a\xc6\x8f"
"\xb6\x01\x7e\x48\x2e\x24\xbe\x6a\xc8\x19\x10\x39\xb4\x34\xaa\x0e\x9f\x97"
"\x39\xae\xdf\x30\xc0\xfa\x9c\x42\xcd\xa4\x11\x02\x5c\xa2\x0c\x42\xbf\x88"
"\x68\x56\x03\x99\x87\x3f\x4d\x1b\x28\xed\x71\x3e\x41\x1b\x34\xec\x02\x63"
"\x21\xc8\xcd\x9a\xd1\x7c\xbc\x95\x70\x4c\x14\x2d\x7c\x71\x06\x3b\x4a\x0b"
"\x52\xe2\x20\x73\xf8\x59\xd6\x32\x89\x92\x12\x6e\x5f\x50\x57\xad\x1d\x02"
"\x29\xba\xde\xc1\xe0\x88\x0f\x47\x6f\x18\xce\x68\x55\x60\x78\xa0\x06\x7d"
"\x8e\x90\x05\x7f\x56\x0b\x51\x51\xc4\x50\xe6\x55\x89\x81\x2f\x77\x9b\x50"
"\xe4\xde\xd6\x60\xee\x4a\xa6\x1e\x7f\x84\xa9\xb4\xb7\x91\x83\x71\x14\x09"
"\x55\x39\xfb\x55\x73\xe4\x7c\xce\x26\xdc\x38\x31\x19\x13\x99\x51\x81\xe7"
"\x28\xfd\x4d\x6d\x33\x4e\x62\xfd\x0a\x82\x2f\x93\x71\xbc\xdc\x43\xc8\xa6"
"\x96\x88\xa1\x1f\xc9\xf4\x3a\xfe\x64\x2c\x30\xdd\xf3\x94\x65\xb1\x3c\xf1"
"\xdd\xad\xd7\x89\x70\x77\x18\x27\xf4\x45\xf0\xd4\x56\x1e\x8e\x2b\xb6\xcf"
"\x22\x44\x63\x4b\xcd\x72\xd1\x24\xf3\xca\xa1\x52\xc6\xfd\x6d\x47\xbb\x00"
"\x4b\x97\x97\x5d\x4a\x46\xb2\xee\x12\x9b\x88\x9d\xc5\x9c\x1c\x71\x62\xff"
"\xf2\x2c\x42\x95\x54\x52\x95\xea\x72\xfe\x14\xc6\xb2\xba\xb3\x5a\xb5\x45"
"\x51\x73\x98\xb0\x03\xb6\xd3\xb8\x9c\x5c\x64\xb4\x49\xf7\xd5\x60\xdd\xe2"
"\x0f\xc1\x3b\x3e\xc8\x8d\xc0\x52\x42\xa1\x60\x07\x6c\xcb\xff\x3e\x32\xb8"
"\x78\x0b\xd1\x91\xa0\xb1\x2a\x6f\x99\x00\xa9\x37\xa1\x2d\x9f\xb5\xed\x34"
"\x88\xd5\xcd\x0a\xa3\x29\x58\x3f\x2c\x47\xc4\xfd\x47\x26\x46\x9c\x98\xe0"
"\xb6\x6d\x74\xc3\x1d\x0a\x1f\x7f\xc1\x0c\xc1\x94\x4d\x25\x26\x7e\xff\x7a"
"\x74\x0c\xc4\x13\x06\x9b\x58\x47\x9c\xa6\x96\x00\x63\x6a\x0f\x22\xa4\x70"
"\xa6\x9b\x46\xc1\xcc\x1b\x95\xcf\x32\xdd\x7b\x73\xad\x67\x41\x61\xca\x39"
"\x25\x83\xaa\x83\x4a\xaa\xde\x88\xa4\x39\x33\x89\xb7\x6d\x58\x8a\x60\x81"
"\x91\xdb\x7c\xa7\x5d\xd0\x09\x38\x2a\x45\x83\xe8\x78\x1e\xb0\x9f\x48\xa4"
"\x4d\x06\xb4\x17\x56\xeb\x3f\x1b\x7e\xea\x18\xad\xf2\x97\x83\x22\xd0\xb3"
"\x84\xdf\x03\x07\x98\x91\xe1\x0f\x09\x2c\x57\x33\x20\xfb\x94\x1f\x10\xe3"
"\xc3\xaf\x6f\x3e\x72\xb2\xaf\xcd\x95\xa3\x66\x6a\x6a\x40\xa8\x40\xe6\x3d"
"\x1c\xb9\xe2\x49\x25\xc0\x49\x7a\x04\xef\x7b\x9b\x1e\xe3\x9d\xe0\x45\x6f"
"\xec\xd6\x76\xac\xee\x23\x3f\x5b\x64\x5e\x8d\x05\xf3\xf5\x05\xa1\x2a\x0f"
"\x5b\x35\x65\x86\xf2\x2c\x2c\x2c\xeb\xef\x83\xc5\xe6\x8c\x22\x72\x34\x95"
"\xab\xa0\x64\x27\x92\x55\xde\x48\x9e\x33\xe9\x20\x9a\x63\x68\x90\xbc\xfb"
"\x2a\x52\x7e\x8d\xa8\x36\x21\xae\xf3\x74\xf5\xa1\x1d\x8a\xc7\x7f\x5d\xcd"
"\x42\x1f\x45\xe5\x2d\xdf\x9b\xc3\x5f\x64\xcf\x72\x1c\xe6\xc9\x6b\x56\x13"
"\x26\x8c\x02\x5c\xa9\x91\x0a\x8a\x23\x5e\x6a\xf3\xd6\x7a\xdd\xc6\x6e\x75"
"\xc1\x56\x4a\x7f\x86\x84\xfc\xd2\x3e\xc9\x8d\x61\xa4\xfa\x42\x2c\x55\xe6"
"\x78\x9c\xbc\x42\xb1\xd5\x32\x63\x3e\x65\x8a\x5c\x2f\xfe\x57\x67\x03\x97"
"\x62\xf1\x8c\xce\x89\xb8\x00\x0e\x37\xca\xbc\x35\x40\x9d\x3c\x7a\x02\x13"
"\xde\x87\xce\x95\xcf\xbf\xb0\xc7\x1b\xe4\xc4\xef\x44\x86\x6b\xd8\xe0\x50"
"\xe3\x36\xb3\x1a\x6e\x8f\x15\xbd\x21\x60\xef\x48\x48\xad\xa2\x56\xdf\x90"
"\x27\x58\xeb\xbc\x1e\x83\x7f\xab\x4c\xb8\xbb\x84\x67\xa7\x3d\xf7\x17\xd9"
"\x2e\x22\x04\x48\x2f\xe9\x5c\x21\x12\x11\x86\xa5\x7c\x3b\x12\xf7\x5c\x83"
"\x6a\xb7\x02\x43\x34\x18\xf3\x29\x44\x32\x3e\xaa\xad\xbc\xa3\x66\x96\x1c"
"\x25\x62\x0c\x43\x95\x1a\x7a\x3f\xd3\xe3\xcc\x85\xd6\xa3\x99\x6b\x50\xd1"
"\x2e\xa7\x6d\xf6\x58\xa6\x40\x5f\xdf\x1c\x9f\x2c\x05\x24\x8d\x95\x15\xce"
"\x96\x65\x0e\xbf\x62\x96\x64\xe6\xc1\x92\xdd\x28\xe1\x61\x72\xbe\x15\x93"
"\xe9\x4d\xbc\xa0\xe5\x54\xfc\xe9\x73\x6c\x73\x54\x03\x0c\x64\xfd\xaf\x35"
"\x03\x8e\x1f\x1e\x1d\x20\xe0\x6f\x34\x8e\xf5\xae\x75\x41\x39\xb4\xe8\x12"
"\xc6\x0f\xbc\x55\xba\xce\x83\xf2\x7b\xb8\x35\xc1\x64\xc2\x9f\x5f\x7c\x1d"
"\xbe\xeb\xfd\x98\x8a\x16\x23\x5c\x4b\xbe\xe4\xd9\xa3\xbc\x66\x6f",
1024);
syscall(__NR_ioctl, r[0], 0x4b72ul, 0x20000040ul);
res = syz_open_dev(0xc, 4, 1);
if (res != -1)
r[1] = res;
*(uint32_t*)0x20000000 = 3;
*(uint32_t*)0x20000004 = 1;
*(uint32_t*)0x20000008 = 0xfffffffe;
*(uint32_t*)0x2000000c = 5;
*(uint32_t*)0x20000010 = 0x40193;
*(uint64_t*)0x20000018 = 0;
syscall(__NR_ioctl, r[1], 0x4b72ul, 0x20000000ul);
return 0;
}
|
the_stack_data/24806.c | #include <stdio.h>
#include <string.h>
int main(){
char MASTER_PASSWORD[9]="59563376";
char userPass[9];
int i;
printf("Enter the master password:\n");
gets(userPass);
printf("\nuserPass address: '%p'",&userPass);
printf("\nuserPass contents:\n|");
for(i=0;i<9;i++){
printf("%02x|",userPass[i]);
}
printf("\n\nMASTER_PASSWORD address: '%p'",&MASTER_PASSWORD);
printf("\nMASTER_PASSWORD contents:\n|");
for(i=0;i<9;i++){
printf("%02x|",MASTER_PASSWORD[i]);
}
if(strcmp(userPass,MASTER_PASSWORD)==0){
printf("\n\nPASSWORD VERIFIED\n");
}
else{
printf("\n\nInvalid password!\n");
}
return 0;
}
|
the_stack_data/61076002.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2016 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation nor the names of its contributors may be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
END_LEGAL */
//
// Code which includes examples of all the different cmov conditions.
//
#include <stdio.h>
static int executed = 0;
static int total = 0;
#define S1(s) #s
#define STRINGIZE(s) S1(s)
// In the tool we look for fnop and toggle counting, so that it only
// counts the cmov operations in this code, not elsewhere in the runtime.
static void toggleCollection()
{
__asm__ __volatile__ ("fnop");
}
// Iterate over each CMOVcc instruction (there are more mnemonics than this,
// but they're all synonyms for one of these)
#define FOREACH_CMOV(expand) \
expand(cmovb) \
expand(cmovbe) \
expand(cmovl) \
expand(cmovle) \
expand(cmovnb) \
expand(cmovnbe) \
expand(cmovnl) \
expand(cmovnle) \
expand(cmovno) \
expand(cmovnp) \
expand(cmovns) \
expand(cmovnz) \
expand(cmovo) \
expand(cmovp) \
expand(cmovs) \
expand(cmovz)
#define DeclareCounter(movOp) \
static int movOp##_total = 0; \
static int movOp##_executed = 0;
FOREACH_CMOV(DeclareCounter)
#define CMOVFunction(res, comparison, movOp) \
{ \
int one = 1; \
res = 0; \
if (comparison) \
__asm__ __volatile__ (STRINGIZE(movOp) " %1, %0" : "+r"(res) : "r"(one)); \
else \
__asm__ __volatile__ (STRINGIZE(movOp) " %1, %0" : "+r"(res) : "r"(one)); \
\
movOp##_total++; \
movOp##_executed += res; \
}
#define DefineTest(comparison, movOp) \
toggleCollection(); \
CMOVFunction(result, comparison, movOp) \
toggleCollection(); \
total++; \
if (result) { executed++; }
#define DefineEqual(movOp) DefineTest(a==b,movOp)
#define PrintStats(movOp) \
printf ("%-7s: %4d %4d\n", STRINGIZE(movOp), movOp##_total, movOp##_executed);
int main(int argc, char **argv)
{
static int aValues[] = {-2,-1,0,1,2};
static int bValues[] = {-2,-1,0,1,2};
int aIndex;
int bIndex;
for (aIndex = 0; aIndex<sizeof(aValues)/sizeof(aValues[0]); aIndex++)
{
int a = aValues[aIndex];
for (bIndex = 0; bIndex<sizeof(bValues)/sizeof(bValues[0]); bIndex++)
{
int b = bValues[bIndex];
int result;
FOREACH_CMOV (DefineEqual);
}
}
printf ("Total : %d Executed : %d\n", total, executed);
FOREACH_CMOV(PrintStats);
return 0;
}
|
the_stack_data/117329118.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/utsname.h>
/*
* argv0switch - a very simple program to exec other programs based on
* the architecture. This comes from the need to have both 32- and 64-bit
* binaries present on the system, but where the current location and names
* of such executables can not be changed, for whatever reason. As a trivial
* example, we want /usr/bin/gdb to always be gdb, but we want it to invoke
* gdb32 if the platform is 32-bit, or gdb64 if the platform is 64-bit.
*
* The program is intentionally very very dumb. All it does is append the
* text "32" or "64" to whatever argv[0] is, and exec's that. Thus, you would
* only use this in real cases where you have 32 and 64 bit versions of a
* binary. If the path in argv[0] is absolute or explicitly relative, then
* this uses execv(). If it is neither, it uses execvp.
*/
int
main (int argc, char *argv[])
{
struct utsname sys_uname;
char *newprog;
const char *suffix = 0;
if (-1 == uname (&sys_uname)) {
perror ("uname");
exit (255);
}
/* Leave space for the 32 or 64, plus the NULL */
newprog = malloc (strlen (argv[0]) + 3);
strcpy (newprog, argv[0]);
/*
* ASSUMPTION: If the architecture contains the string 64, then we want
* to run the 64-bit version of the program. If ever a 32-bit platform
* is invented that has the string "64" in its architecture, this will
* break.
*/
suffix = "32";
if ((char *)0 != strstr (sys_uname.machine, "64"))
suffix = "64";
strcat (newprog, suffix);
/*
* If any part of argv[0] contains a '/' character, it means the invocation
* was absolute or explicitly relative. That is, it is not being exec'ed
* via the PATH. In such cases, we don't exec via the PATH either. If no
* such character exists there, then we exec via the PATH.
*/
if ((char *)0 == strchr (newprog, '/')) {
return execvp (newprog, argv);
} else {
return execv (newprog, argv);
}
}
|
the_stack_data/67324011.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.
*/
struct test {
char a;
int b;
};
struct test function() {
struct test t;
t.a = 3;
t.b = 8;
return t;
}
int main() {
struct test t;
t = function();
return t.a + t.b;
}
|
the_stack_data/1175920.c | int EXPRESSION_or(int, int);
int nondet_int();
int main()
{
int in0=nondet_int(),
in1=nondet_int();
__CPROVER_assert(EXPRESSION_or(in0, in1)==(in0 | in1), "");
}
|
the_stack_data/156393302.c | #include <stdio.h>
#include <stdlib.h>
/*
Add or remove the macro to enable/disable the DEBUG message
*/
#define DEBUG(fmt, ...) fprintf(stderr, fmt, __VA_ARGS__)
int process (int i, int j)
{
int val = 0;
DEBUG("process (%d, %d)\n", i, j);
val = i * j;
DEBUG("return %d\n", val);
return val;
}
int main(int argc, char * argv[])
{
int arg1 = 0;
int arg2 = 0;
if (argc > 1)
arg1 = atoi(argv[1]);
if (argc == 3)
arg2 = atoi(argv[2]);
DEBUG("processed %d arguments\n", argc - 1);
DEBUG("arg1 = %d, arg2 = %d\n", arg1, arg2);
printf("%i\n", process(arg1, arg2));
return 0;
}
|
the_stack_data/40761982.c | /*
SCOPE: nothing much but it calculates the sum of all numbers you specify using argv
USAGE: gcc -Wall sum.c -o sum
From there, you simply run the executable with ./sum n1 n2 n3 where ni is an integer (may be negative)
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
int64_t string_to_int(char* _param){
int64_t _returnval = 0;
bool _isnegative = false;
int i = 0;
if(_param[i] == '-'){
_isnegative = true;
++i;
}
for(; _param[i] != '\0'; ++i){
_returnval = _returnval * 10 + _param[i] - '0';
}
if(_isnegative == true)
_returnval = -_returnval;
return _returnval;
}
bool check_arguments(int _argc, char** _argv){
for(int i = 1; i < _argc; ++i){
for(int j = 0; _argv[i][j] != '\0'; ++j){
if((_argv[i][j] < 48 || _argv[i][j] > 57) && _argv[i][j] != '-'){
return false;
}
}
}
return true;
}
int main(int argc, char** argv){
if(argc < 3){
printf("Syntax: ./sum n1 n2 n3 ...\n");
return 0;
}
if(check_arguments(argc ,argv) == false){
printf("Enter numbers!\n");
return 0;
}
int64_t _sum = 0;
for(int i = 1; i < argc; ++i){
_sum = _sum + string_to_int(argv[i]);
}
printf("%" PRId64 "\n", _sum);
return 0;
}
|
the_stack_data/94108.c | #include <stdio.h>
int main()
{
int N, test, naoprimo;
while (scanf("%d", &N) && N != 0)
{
naoprimo = 1;
test = 1;
while (test < N)
{
naoprimo = 0;
if (N % test == 0 && test > 1 && test < (N / 2) + 1)
{
//printf("Não é primo, é divisivel por: %d\n", test);
naoprimo ++;
break;
}
test ++;
}
if (naoprimo > 0)
{
printf("0\n");
}
else
{
printf("1\n");
}
}
return(0);
}
|
the_stack_data/220454729.c | // 此程序打印一个月中的天数
#include <stdio.h>
int main(void)
{
enum month { January = 1, February, March, April, May, June,
July, August, September, October, November, December };
enum month aMonth;
int days;
printf("Enter month number: ");
scanf("%i", &aMonth);
switch(aMonth) {
case January:
case March:
case May:
case July:
case August:
case October:
case December:
days = 31;
break;
case April:
case June:
case September:
case November:
days = 30;
break;
case February:
days = 28;
break;
default:
printf("bad month number\n");
days = 0;
break;
}
if (days != 0)
printf("Number of days is %i\n", days);
if (aMonth == February)
printf("...or 29 if it's a leap year\n");
return 0;
} |
the_stack_data/52080.c | #include<stdio.h>
void printArray(int *ptr, int n){
for (int i = 0; i < n; i++)
{
printf("The value of element %d is %d\n",i+1, *(ptr+i));
}
}
int main()
{
int arr[]= {1,2,34543,45};
printArray(arr,4);
return 0;
}
|
the_stack_data/179831683.c | #include <stdio.h>
void condition(int);
int main(void)
{
int i=0, p_n;
while(i < 5)
{
printf("\nEnter Player Number: ");
scanf("%d", &p_n);
condition(p_n);
i++;
}
return 0;
}
void condition(int x)
{
if(x>=56 && x<=78)
{
printf("\nYOU WIN\n");
}
else
{
printf("\nYOU LOSE\n");
}
}
|
the_stack_data/170451765.c | //clang -Xclang -ast-dump -fsyntax-only main.c
#include <stdio.h>
long long c = 10;
long long d = 255;
long long *pc;
long long *pd;
long long **ppc;
long long **ppd;
int main() {
// c = *pc;
// c = **ppc;
// pc = &c;
// d = *&c;
// pc = &*&c;
// d = *&*&c;
// pd = pc;
// ppd = ppc;
pd = &*pc;
// c = *&*pc;
// c = *&**&*ppc;
printf("%lld\n", c);
printf("%lld\n", d);
return 0;
}
|
the_stack_data/68888784.c | /* { dg-do run } */
__attribute__((noinline,noclone))
void test(int *pi, long *pl, int f)
{
*pl = 0;
*pi = 1;
if (f)
*pl = 2;
}
int main()
{
void *p = __builtin_malloc(sizeof (long));
test(p, p, 0);
if (*(int *)p != 1)
__builtin_abort ();
return 0;
}
|
the_stack_data/53308.c | #include<stdio.h>
#include<stdlib.h>
struct Node{
struct Node *prev;
int data;
struct Node *next;
}*first=NULL;
void create(int A[], int n){
struct Node *t, *last;
first =(struct Node *)malloc(sizeof(struct Node));
first->prev = NULL;
first->data = A[0];
first->next = NULL;
last = first;
for(int i=1;i<n;i++){
t = (struct Node *)malloc(sizeof(struct Node));
t->prev = last;
t->data = A[i];
t->next = last->next;
last->next = t;
last = t;
}
}
void display(struct Node *p){
while(p){
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int length(struct Node *p){
int len=0;
while(p){
len++;
p = p->next;
}
return len;
}
void Insert(struct Node *p, int index, int x){
struct Node *t;
int i;
if(index<0 || index> length(p)){
return ;
}
if(index == 0){
t = (struct Node *)malloc(sizeof(struct Node));
t->prev = NULL;
t->data = x;
t->next = first;
first = t;
}else{
for(i=0;i<index-1;i++){
p =p->next;
}
t = (struct Node *)malloc(sizeof(struct Node));
t->prev = p;
t->data = x;
t->next = p->next;
if(p->next){
p->next->prev = t;
p->next = t;
}
}
}
int delete(struct Node *p, int index){
struct Node *q;
int x, i;
if(index<1 || index > length(p)){
return -1;
}
if(index == 1){
first= first->next;
if(first){
first->prev =NULL;
}
x = p->data;
free(p);
}else{
for(i=0;i<index-1;i++){
p =p->next;
}
p->prev->next = p->next;
if(p->next){
p->next->prev= p->prev;
}
x = p->data;
free(p);
}
return x;
}
void reverse(struct Node *p){
struct Node *temp;
while(p!=NULL){
temp= p->next;
p->next = p->prev;
p->prev = temp;
p = p->prev;
if(p!= NULL && p->next == NULL){
first = p;
}
}
}
int main(){
int A[] ={12,14,15,16,17,19};
create(A, 6);
printf("Doubly Linkedlist :\n");
Insert(first, 2, 100);
display(first);
printf("\nLength is :%d\n", length(first));
printf("deleted %d\n", delete(first, 3));
reverse(first);
display(first);
return 0;
} |
the_stack_data/115835.c | /****************************************************************
Copyright (C) 2014 All rights reserved.
> File Name: < daytimetcpsrv.c >
> Author: < Sean Guo >
> Mail: < [email protected] >
> Created Time: < 2014/06/05 >
> Description:
//{{{ struct sockaddr
struct sockaddr
{
unsigned short int sa_family;
char sa_data[14];
};
* sa_family 为调用socket()时的domain 参数, 即AF_xxxx 值.
* sa_data 最多使用14 个字符长度.
此sockaddr 结构会因使用不同的socket domain 而有不同结构定义,
例如使用AF_INET domain,其socketaddr 结构定义便为
struct socketaddr_in
{
unsigned short int sin_family;
uint16_t sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};
struct in_addr
{
uint32_t s_addr;
};
1、sin_family 即为sa_family
2、sin_port 为使用的port 编号
3、sin_addr. s_addr 为IP 地址 sin_zero 未使用.
参数 addrlen 为sockaddr 的结构长度.
返回值：成功则返回0, 失败返回-1, 错误原因存于errno 中.
//}}}
****************************************************************/
#include <stdio.h>
#include <stdlib.h> //exit();
#include <string.h> //bzero();
#include <sys/socket.h>
#include <netinet/in.h> //struct sockaddr_in;
#include <time.h> //time();
#include <arpa/inet.h> //inet_pton();
#include <unistd.h> //write();
#define MAXLINE 4096 /* max text line length */
#define LISTENQ 128 /* 2nd argument to listen()*/
int main(int argc, char **argv)
{
int listenfd, connfd;
struct sockaddr_in servaddr;
char buff[MAXLINE];
time_t ticks;
if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket() error");
exit(EXIT_FAILURE);
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 通配地址INADDR_ANY == 0, 表示交由内核选择;
servaddr.sin_port = htons(13); /* daytime server port */
// int bind(int sockfd, struct sockaddr * my_addr, int addrlen);
// 为sockfd指定端口(my_addr.sin_port)或IP(my_addr.sin_addr);
// 此名称由参数my_addr 指向一个sockaddr 结构, 对于不同的socket domain 定义了一个通用的数据结构
if(bind(listenfd, (const struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
{
perror("bind() error");
exit(EXIT_FAILURE);
}
// int listen(int sockfd, int backlog);
// listen()配置未连接的sockfd为被动socket, 并开始接受该socket的连接;
// listen()只设置socket 为listen 状态, 真正接收client端连接请求的是accept();
// 参数backlog 指定同时能处理的最大连接要求, 如果连接数目达此上限则client 端将收到ECONNREFUSED 的错误;
// 如果socket 为AF_INET 则参数backlog 最大值可设至128;
// listen()只适用SOCK_STREAM 或SOCK_SEQPACKET 的socket 类型, 不适合UDP(无连接);
// 成功则返回0, 失败返回-1, 错误原因存于errno.
if(listen(listenfd, LISTENQ) < 0)
{
perror("listen() error");
exit(EXIT_FAILURE);
}
for ( ; ; ) {
// int accept(int s, struct sockaddr * addr, int * addrlen);
// accept()用来接受描述符s 的socket连接请求.
// socket 必需先经bind()、listen()函数处理过,
// 当有连接请求进来时, accept()会返回一个新的socket 处理代码, 往后的数据传送与读取就是经由新的socket处理,
// 而原来参数s 的socket 能继续使用accept()来接受新的连线要求.
// 连线成功时, 参数addr 所指的结构会被系统填入远程主机的地址数据, 参数addrlen 为scokaddr 的结构长度.
// 成功则返回新的socket 处理代码, 失败返回-1, 错误原因存于errno 中.
if((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0)
{
perror("accept() error");
exit(EXIT_FAILURE);
}
//这里不关心客户端的数据, 因此传递NULL值.
ticks = time(NULL);
snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
write(connfd, buff, strlen(buff));
//调用close()只会减少对应socket描述符的引用数, 当引用数为0才会清楚对应的socket.
close(connfd);
}
}
|
the_stack_data/95280.c | #include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <netdb.h>
int main() {
//
// 1. Creating Socket
//
int s = socket(PF_INET, SOCK_RAW, 1);
//
// -> Exit the app if the socket failed to be created
//
if(s <= 0)
{
perror("Socket Error");
exit(0);
}
//
// 2. Create the ICMP Struct Header
//
typedef struct {
uint8_t type;
uint8_t code;
uint16_t chksum;
uint32_t data;
} icmp_hdr_t;
//
// 3. Use the newly created struct to make a variable.
//
icmp_hdr_t pckt;
//
// 4. Set the appropriate values to our struct, which is our ICMP header
//
pckt.type = 8; // The echo request is 8
pckt.code = 0; // No need
pckt.chksum = 0xfff7; // Fixed checksum since the data is not changing
pckt.data = 0; // We don't send anything.
//
// 5. Creating a IP Header from a struct that exists in another library
//
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.s_addr = inet_addr("8.8.8.8");
//
// 6. Send our PING
//
int actionSendResult = sendto(s, &pckt, sizeof(pckt),
0, (struct sockaddr*)&addr, sizeof(addr));
//
// -> Exit the app if the option failed to be set
//
if(actionSendResult < 0)
{
perror("Ping Error");
exit(0);
}
//
// 7. Prepare all the necessary variable to handle the response
//
unsigned int resAddressSize;
unsigned char res[30] = "";
struct sockaddr resAddress;
//
// 8. Read the response from the remote host
//
int ressponse = recvfrom(s, res, sizeof(res), 0, &resAddress,
&resAddressSize);
//
// -> Display the response in its raw form (hex)
//
if( ressponse > 0)
{
printf("Message is %d bytes long, and looks like this:\n", ressponse);
for(int i = 0; i < ressponse; i++)
{
printf("%x ", res[i]);
}
printf("\n");
exit(0);
}
else
{
perror("Response Error");
exit(0);
}
return 0;
}
|
the_stack_data/40762612.c | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from [email protected]. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: atomic_writer.c
*
* Purpose: This is the "writer" part of the standalone test to check
* atomic read-write operation on a system.
* a) atomic_writer.c--the writer (this file)
* b) atomic_reader.c--the reader
* c) atomic_data--the name of the data file used by writer and reader
*
*-------------------------------------------------------------------------
*/
/***********/
/* Headers */
/***********/
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if !defined(WIN32) && !defined(__MINGW32__)
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
/****************/
/* Local Macros */
/****************/
#define FILENAME "atomic_data"
/********************/
/* Local Prototypes */
/********************/
static void usage(void);
/*-------------------------------------------------------------------------
* Function: usage
*
* Purpose: To print information about the command line options
*
* Parameters: None
*
* Return: void
*
*-------------------------------------------------------------------------
*/
static void
usage(void)
{
printf("\n");
printf("Usage error!\n");
printf("Usage: atomic_writer -n <number of integers to write> -i <number of iterations for writer>\n");
printf(" Note**The number of integers for option n has to be positive\n");
printf(" Note**The number of integers for option i has to be positive\n");
printf("\n");
} /* usage() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: To write a series of integers to a file for the reader to verify the data.
* A write is atomic if the whole amount written in one operation is not interleaved
* with data from any other process.
* (1) Iterate with i iterations
* (2) Write a series of integers (0 to n-1) to the file with this pattern:
* offset 0: 0000000000000000000000000000000
* offset 1: 111111111111111111111111111111
* offset 2: 22222222222222222222222222222
* offset 3: 3333333333333333333333333333
* ...
* ...
* offset n-1: (n-1)
*
* At the end of the writes, the data in the file will be:
* 01234567........(n-1)
*
* Note:
* (a) The # of integers (via -n option) used by the writer and reader should be the same.
* (b) The data file used by the writer and reader should be the same.
*
* Future enhancement:
* 1) Provide default values for n and i and allow user to run with either 0 or 1 option
* 2) Use HDF library HD<system calls> instead of the system calls
* 3) Handle large sized buffer (gigabytes) if needed
*
* Return: Success: 0
* Failure: -1
*
*-------------------------------------------------------------------------
*/
int
main(int argc, char *argv[])
{
int fd = -1; /* file descriptor */
ssize_t bytes_wrote; /* the nubmer of bytes written */
unsigned int *buf = NULL; /* buffer to hold written data */
unsigned int n, u, i; /* local index variable */
int temp; /* temporary variable */
unsigned int iterations = 0; /* the input for "-i" */
unsigned int num = 0; /* the input for "-n" */
int opt = 0; /* option char */
/* Ensure the # of arguments is as expected */
if(argc != 5) {
usage();
exit(-1);
}
/* Parse command line options */
while((opt = getopt(argc, argv, "n:i:")) != -1) {
switch(opt) {
case 'n':
if((temp = atoi(optarg)) < 0) {
usage();
exit(-1);
}
num = (unsigned int)temp;
break;
case 'i':
if((temp = atoi(optarg)) < 0) {
usage();
exit(-1);
}
iterations = (unsigned int)temp;
break;
default:
printf("Invalid option encountered\n");
break;
}
}
printf("WRITER: # of integers to write = %u; # of iterations = %d\n", num, iterations);
/* Remove existing data file if needed */
if(remove(FILENAME) < 0) {
if(errno == ENOENT)
printf("WRITER: remove %s--%s\n", FILENAME, strerror(errno));
else {
printf("WRITER: error from remove: %d--%s\n", errno, strerror(errno));
goto error;
}
} else
printf("WRITER: %s is removed\n", FILENAME);
/* Create the data file */
if((fd = open(FILENAME, O_RDWR|O_TRUNC|O_CREAT, 0664)) < 0) {
printf("WRITER: error from open\n");
goto error;
}
/* Allocate buffer for holding data to be written */
if((buf = (unsigned int *)malloc(num * sizeof(unsigned int))) == NULL) {
printf("WRITER: error from malloc\n");
if(fd >= 0 && close(fd) < 0)
printf("WRITER: error from close\n");
goto error;
}
printf("\n");
for(i = 1; i <= iterations; i++) { /* iteration loop */
printf("WRITER: *****start iteration %u*****\n", i);
/* Write the series of integers to the file */
for(n = 0; n < num; n++) { /* write loop */
/* Set up data to be written */
for(u=0; u < num; u++)
buf[u] = n;
/* Position the file to the proper location */
if(lseek(fd, (off_t)(n*sizeof(unsigned int)), SEEK_SET) < 0) {
printf("WRITER: error from lseek\n");
goto error;
}
/* Write the data */
if((bytes_wrote = write(fd, buf, ((num-n) * sizeof(unsigned int)))) < 0) {
printf("WRITER: error from write\n");
goto error;
}
/* Verify the bytes written is correct */
if(bytes_wrote != (ssize_t)((num-n) * sizeof(unsigned int))) {
printf("WRITER: error from bytes written\n");
goto error;
}
} /* end for */
printf("WRITER: *****end iteration %u*****\n\n", i);
} /* end for */
/* Close the file */
if(close(fd) < 0) {
printf("WRITER: error from close\n");
goto error;
}
/* Free the buffer */
if(buf) free(buf);
return(0);
error:
return(-1);
} /* main() */
#else /* WIN32 / MINGW32 */
int
main(void)
{
printf("Non-POSIX platform. Exiting.\n");
return EXIT_FAILURE;
} /* end main() */
#endif /* WIN32 / MINGW32 */
|
the_stack_data/150142078.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conj(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimag(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__1 = 1;
/* > \brief <b> SSPEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER
matrices</b> */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download SSPEVD + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/sspevd.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/sspevd.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/sspevd.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE SSPEVD( JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, LWORK, */
/* IWORK, LIWORK, INFO ) */
/* CHARACTER JOBZ, UPLO */
/* INTEGER INFO, LDZ, LIWORK, LWORK, N */
/* INTEGER IWORK( * ) */
/* REAL AP( * ), W( * ), WORK( * ), Z( LDZ, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > SSPEVD computes all the eigenvalues and, optionally, eigenvectors */
/* > of a real symmetric matrix A in packed storage. If eigenvectors are */
/* > desired, it uses a divide and conquer algorithm. */
/* > */
/* > The divide and conquer algorithm makes very mild assumptions about */
/* > floating point arithmetic. It will work on machines with a guard */
/* > digit in add/subtract, or on those binary machines without guard */
/* > digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or */
/* > Cray-2. It could conceivably fail on hexadecimal or decimal machines */
/* > without guard digits, but we know of none. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] JOBZ */
/* > \verbatim */
/* > JOBZ is CHARACTER*1 */
/* > = 'N': Compute eigenvalues only; */
/* > = 'V': Compute eigenvalues and eigenvectors. */
/* > \endverbatim */
/* > */
/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > = 'U': Upper triangle of A is stored; */
/* > = 'L': Lower triangle of A is stored. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] AP */
/* > \verbatim */
/* > AP is REAL array, dimension (N*(N+1)/2) */
/* > On entry, the upper or lower triangle of the symmetric matrix */
/* > A, packed columnwise in a linear array. The j-th column of A */
/* > is stored in the array AP as follows: */
/* > if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; */
/* > if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n. */
/* > */
/* > On exit, AP is overwritten by values generated during the */
/* > reduction to tridiagonal form. If UPLO = 'U', the diagonal */
/* > and first superdiagonal of the tridiagonal matrix T overwrite */
/* > the corresponding elements of A, and if UPLO = 'L', the */
/* > diagonal and first subdiagonal of T overwrite the */
/* > corresponding elements of A. */
/* > \endverbatim */
/* > */
/* > \param[out] W */
/* > \verbatim */
/* > W is REAL array, dimension (N) */
/* > If INFO = 0, the eigenvalues in ascending order. */
/* > \endverbatim */
/* > */
/* > \param[out] Z */
/* > \verbatim */
/* > Z is REAL array, dimension (LDZ, N) */
/* > If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal */
/* > eigenvectors of the matrix A, with the i-th column of Z */
/* > holding the eigenvector associated with W(i). */
/* > If JOBZ = 'N', then Z is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDZ */
/* > \verbatim */
/* > LDZ is INTEGER */
/* > The leading dimension of the array Z. LDZ >= 1, and if */
/* > JOBZ = 'V', LDZ >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is REAL array, dimension (MAX(1,LWORK)) */
/* > On exit, if INFO = 0, WORK(1) returns the required LWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LWORK */
/* > \verbatim */
/* > LWORK is INTEGER */
/* > The dimension of the array WORK. */
/* > If N <= 1, LWORK must be at least 1. */
/* > If JOBZ = 'N' and N > 1, LWORK must be at least 2*N. */
/* > If JOBZ = 'V' and N > 1, LWORK must be at least */
/* > 1 + 6*N + N**2. */
/* > */
/* > If LWORK = -1, then a workspace query is assumed; the routine */
/* > only calculates the required sizes of the WORK and IWORK */
/* > arrays, returns these values as the first entries of the WORK */
/* > and IWORK arrays, and no error message related to LWORK or */
/* > LIWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] IWORK */
/* > \verbatim */
/* > IWORK is INTEGER array, dimension (MAX(1,LIWORK)) */
/* > On exit, if INFO = 0, IWORK(1) returns the required LIWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LIWORK */
/* > \verbatim */
/* > LIWORK is INTEGER */
/* > The dimension of the array IWORK. */
/* > If JOBZ = 'N' or N <= 1, LIWORK must be at least 1. */
/* > If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. */
/* > */
/* > If LIWORK = -1, then a workspace query is assumed; the */
/* > routine only calculates the required sizes of the WORK and */
/* > IWORK arrays, returns these values as the first entries of */
/* > the WORK and IWORK arrays, and no error message related to */
/* > LWORK or LIWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > > 0: if INFO = i, the algorithm failed to converge; i */
/* > off-diagonal elements of an intermediate tridiagonal */
/* > form did not converge to zero. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup realOTHEReigen */
/* ===================================================================== */
/* Subroutine */ int sspevd_(char *jobz, char *uplo, integer *n, real *ap,
real *w, real *z__, integer *ldz, real *work, integer *lwork, integer
*iwork, integer *liwork, integer *info)
{
/* System generated locals */
integer z_dim1, z_offset, i__1;
real r__1;
/* Local variables */
integer inde;
real anrm, rmin, rmax, sigma;
extern logical lsame_(char *, char *);
integer iinfo;
extern /* Subroutine */ int sscal_(integer *, real *, real *, integer *);
integer lwmin;
logical wantz;
integer iscale;
extern real slamch_(char *);
real safmin;
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
real bignum;
integer indtau;
extern /* Subroutine */ int sstedc_(char *, integer *, real *, real *,
real *, integer *, real *, integer *, integer *, integer *,
integer *);
integer indwrk, liwmin;
extern real slansp_(char *, char *, integer *, real *, real *);
extern /* Subroutine */ int ssterf_(integer *, real *, real *, integer *);
integer llwork;
real smlnum;
extern /* Subroutine */ int ssptrd_(char *, integer *, real *, real *,
real *, real *, integer *);
logical lquery;
extern /* Subroutine */ int sopmtr_(char *, char *, char *, integer *,
integer *, real *, real *, real *, integer *, real *, integer *);
real eps;
/* -- LAPACK driver routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input parameters. */
/* Parameter adjustments */
--ap;
--w;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--work;
--iwork;
/* Function Body */
wantz = lsame_(jobz, "V");
lquery = *lwork == -1 || *liwork == -1;
*info = 0;
if (! (wantz || lsame_(jobz, "N"))) {
*info = -1;
} else if (! (lsame_(uplo, "U") || lsame_(uplo,
"L"))) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*ldz < 1 || wantz && *ldz < *n) {
*info = -7;
}
if (*info == 0) {
if (*n <= 1) {
liwmin = 1;
lwmin = 1;
} else {
if (wantz) {
liwmin = *n * 5 + 3;
/* Computing 2nd power */
i__1 = *n;
lwmin = *n * 6 + 1 + i__1 * i__1;
} else {
liwmin = 1;
lwmin = *n << 1;
}
}
iwork[1] = liwmin;
work[1] = (real) lwmin;
if (*lwork < lwmin && ! lquery) {
*info = -9;
} else if (*liwork < liwmin && ! lquery) {
*info = -11;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SSPEVD", &i__1, (ftnlen)6);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
w[1] = ap[1];
if (wantz) {
z__[z_dim1 + 1] = 1.f;
}
return 0;
}
/* Get machine constants. */
safmin = slamch_("Safe minimum");
eps = slamch_("Precision");
smlnum = safmin / eps;
bignum = 1.f / smlnum;
rmin = sqrt(smlnum);
rmax = sqrt(bignum);
/* Scale matrix to allowable range, if necessary. */
anrm = slansp_("M", uplo, n, &ap[1], &work[1]);
iscale = 0;
if (anrm > 0.f && anrm < rmin) {
iscale = 1;
sigma = rmin / anrm;
} else if (anrm > rmax) {
iscale = 1;
sigma = rmax / anrm;
}
if (iscale == 1) {
i__1 = *n * (*n + 1) / 2;
sscal_(&i__1, &sigma, &ap[1], &c__1);
}
/* Call SSPTRD to reduce symmetric packed matrix to tridiagonal form. */
inde = 1;
indtau = inde + *n;
ssptrd_(uplo, n, &ap[1], &w[1], &work[inde], &work[indtau], &iinfo);
/* For eigenvalues only, call SSTERF. For eigenvectors, first call */
/* SSTEDC to generate the eigenvector matrix, WORK(INDWRK), of the */
/* tridiagonal matrix, then call SOPMTR to multiply it by the */
/* Householder transformations represented in AP. */
if (! wantz) {
ssterf_(n, &w[1], &work[inde], info);
} else {
indwrk = indtau + *n;
llwork = *lwork - indwrk + 1;
sstedc_("I", n, &w[1], &work[inde], &z__[z_offset], ldz, &work[indwrk]
, &llwork, &iwork[1], liwork, info);
sopmtr_("L", uplo, "N", n, n, &ap[1], &work[indtau], &z__[z_offset],
ldz, &work[indwrk], &iinfo);
}
/* If matrix was scaled, then rescale eigenvalues appropriately. */
if (iscale == 1) {
r__1 = 1.f / sigma;
sscal_(n, &r__1, &w[1], &c__1);
}
work[1] = (real) lwmin;
iwork[1] = liwmin;
return 0;
/* End of SSPEVD */
} /* sspevd_ */
|
the_stack_data/76856.c | #pragma line 1 "imf2.c"
#pragma line 1 "imf2.c" 1
#pragma line 1 "<built-in>" 1
#pragma line 1 "<built-in>" 3
#pragma line 147 "<built-in>" 3
#pragma line 1 "<command line>" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_op.h" 1
/* autopilot_ssdm_op.h*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 280 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
/*#define AP_SPEC_ATTR __attribute__ ((pure))*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
/****** SSDM Intrinsics: OPERATIONS ***/
// Interface operations
//typedef unsigned int __attribute__ ((bitwidth(1))) _uint1_;
void _ssdm_op_IfRead() __attribute__ ((nothrow));
void _ssdm_op_IfWrite() __attribute__ ((nothrow));
//_uint1_ _ssdm_op_IfNbRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfNbWrite() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfCanRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_op_IfCanWrite() SSDM_OP_ATTR;
#pragma empty_line
// Stream Intrinsics
void _ssdm_StreamRead() __attribute__ ((nothrow));
void _ssdm_StreamWrite() __attribute__ ((nothrow));
//_uint1_ _ssdm_StreamNbRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamNbWrite() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamCanRead() SSDM_OP_ATTR;
//_uint1_ _ssdm_StreamCanWrite() SSDM_OP_ATTR;
#pragma empty_line
// Misc
void _ssdm_op_MemShiftRead() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Wait() __attribute__ ((nothrow));
void _ssdm_op_Poll() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Return() __attribute__ ((nothrow));
#pragma empty_line
/* SSDM Intrinsics: SPECIFICATIONS */
void _ssdm_op_SpecSynModule() __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef() __attribute__ ((nothrow));
void _ssdm_op_SpecPort() __attribute__ ((nothrow));
void _ssdm_op_SpecConnection() __attribute__ ((nothrow));
void _ssdm_op_SpecChannel() __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive() __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst() __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecReset() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPlatform() __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain() __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain() __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecRegionBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopName() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopTripCount() __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecStateBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecInterface() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPipeline() __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline() __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecLatency() __attribute__ ((nothrow));
void _ssdm_op_SpecParallel() __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol() __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecResource() __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit() __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore() __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore() __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue() __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecExt() __attribute__ ((nothrow));
/*void* _ssdm_op_SpecProcess() SSDM_SPEC_ATTR;
void* _ssdm_op_SpecEdge() SSDM_SPEC_ATTR; */
#pragma empty_line
/* Presynthesis directive functions */
void _ssdm_SpecArrayDimSize() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_RegionBegin() __attribute__ ((nothrow));
void _ssdm_RegionEnd() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_Unroll() __attribute__ ((nothrow));
void _ssdm_UnrollRegion() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_InlineAll() __attribute__ ((nothrow));
void _ssdm_InlineLoop() __attribute__ ((nothrow));
void _ssdm_Inline() __attribute__ ((nothrow));
void _ssdm_InlineSelf() __attribute__ ((nothrow));
void _ssdm_InlineRegion() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecArrayMap() __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition() __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecStream() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecExpr() __attribute__ ((nothrow));
void _ssdm_SpecExprBalance() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecDependence() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecLoopMerge() __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten() __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecFuncInstantiation() __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer() __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract() __attribute__ ((nothrow));
void _ssdm_SpecConstant() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_DataPack() __attribute__ ((nothrow));
void _ssdm_SpecDataPack() __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecBitsMap() __attribute__ ((nothrow));
void _ssdm_op_SpecLicense() __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
/*#define _ssdm_op_WaitUntil(X) while (!(X)) _ssdm_op_Wait(1);
#define _ssdm_op_Delayed(X) X */
#pragma line 7 "<command line>" 2
#pragma line 1 "<built-in>" 2
#pragma line 1 "imf2.c" 2
#pragma line 1 "./duc.h" 1
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 1
/* ap_cint.h */
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 62 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 18 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* mingw.org's version macros: these make gcc to define
MINGW32_SUPPORTS_MT_EH and to use the _CRT_MT global
and the __mingwthr_key_dtor() function from the MinGW
CRT in its private gthr-win32.h header. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* MS does not prefix symbols by underscores for 64-bit. */
#pragma empty_line
/* As we have to support older gcc version, which are using underscores
as symbol prefix for x64, we have to check here for the user label
prefix defined by gcc. */
#pragma line 62 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* Use alias for msvcr80 export of get/set_output_format. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set VC specific compiler target macros. */
#pragma line 10 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
/* C/C++ specific language defines. */
#pragma line 32 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Note the extern. This is needed to work around GCC's
limitations in handling dllimport attribute. */
#pragma line 147 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Attribute `nonnull' was valid as of gcc 3.3. We don't use GCC's
variadiac macro facility, because variadic macros cause syntax
errors with --traditional-cpp. */
#pragma line 225 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* High byte is the major version, low byte is the minor. */
#pragma line 247 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/*typedef int __int128 __attribute__ ((__mode__ (TI)));*/
#pragma line 277 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 674 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_directx.h" 1 3
#pragma line 674 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_ddk.h" 1 3
#pragma line 675 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma line 13 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __builtin_va_list __gnuc_va_list;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __gnuc_va_list va_list;
#pragma line 46 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
/* Use GCC builtins */
#pragma line 102 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
#pragma pack(pop)
#pragma line 277 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 316 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* We have to define _DLL for gcc based mingw version. This define is set
by VC, when DLL-based runtime is used. So, gcc based runtime just have
DLL-base runtime, therefore this define has to be set.
As our headers are possibly used by windows compiler having a static
C-runtime, we make this definition gnu compiler specific here. */
#pragma line 370 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long size_t;
#pragma line 380 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ssize_t;
#pragma line 392 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long intptr_t;
#pragma line 405 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long uintptr_t;
#pragma line 418 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ptrdiff_t;
#pragma line 428 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned short wchar_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
#pragma line 456 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int errno_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long __time32_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long __time64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __time64_t time_t;
#pragma line 518 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* _dowildcard is an int that controls the globbing of the command line.
* The MinGW32 (mingw.org) runtime calls it _CRT_glob, so we are adding
* a compatibility definition here: you can use either of _CRT_glob or
* _dowildcard .
* If _dowildcard is non-zero, the command line will be globbed: *.*
* will be expanded to be all files in the startup directory.
* In the mingw-w64 library a _dowildcard variable is defined as being
* 0, therefore command line globbing is DISABLED by default. To turn it
* on and to leave wildcard command line processing MS's globbing code,
* include a line in one of your source modules defining _dowildcard and
* setting it to -1, like so:
* int _dowildcard = -1;
*/
#pragma line 605 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* MSVC-isms: */
#pragma empty_line
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
struct __lc_time_data;
#pragma empty_line
typedef struct localeinfo_struct {
pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct,*_locale_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct tagLC_ID {
unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID,*LPLC_ID;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct threadlocaleinfostruct {
int refcount;
unsigned int lc_codepage;
unsigned int lc_collate_cp;
unsigned long lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
int mb_cur_max;
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
const unsigned short *pctype;
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;
} threadlocinfo;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* mingw-w64 specific functions: */
const char *__mingw_get_crt_info (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 2 3
#pragma line 36 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 3
__attribute__ ((__dllimport__)) void * _memccpy(void *_Dst,const void *_Src,int _Val,size_t _MaxCount);
void * memchr(const void *_Buf ,int _Val,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _memicmp(const void *_Buf1,const void *_Buf2,size_t _Size);
__attribute__ ((__dllimport__)) int _memicmp_l(const void *_Buf1,const void *_Buf2,size_t _Size,_locale_t _Locale);
int memcmp(const void *_Buf1,const void *_Buf2,size_t _Size);
void * memcpy(void * __restrict__ _Dst,const void * __restrict__ _Src,size_t _Size) ;
void * memset(void *_Dst,int _Val,size_t _Size);
#pragma empty_line
void * memccpy(void *_Dst,const void *_Src,int _Val,size_t _Size) ;
int memicmp(const void *_Buf1,const void *_Buf2,size_t _Size) ;
#pragma empty_line
#pragma empty_line
char * _strset(char *_Str,int _Val) ;
char * _strset_l(char *_Str,int _Val,_locale_t _Locale) ;
char * strcpy(char * __restrict__ _Dest,const char * __restrict__ _Source);
char * strcat(char * __restrict__ _Dest,const char * __restrict__ _Source);
int strcmp(const char *_Str1,const char *_Str2);
size_t strlen(const char *_Str);
size_t strnlen(const char *_Str,size_t _MaxCount);
void * memmove(void *_Dst,const void *_Src,size_t _Size) ;
__attribute__ ((__dllimport__)) char * _strdup(const char *_Src);
char * strchr(const char *_Str,int _Val);
__attribute__ ((__dllimport__)) int _stricmp(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _strcmpi(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _stricmp_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
int strcoll(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _strcoll_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _stricoll(const char *_Str1,const char *_Str2);
__attribute__ ((__dllimport__)) int _stricoll_l(const char *_Str1,const char *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _strncoll (const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strncoll_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _strnicoll (const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicoll_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
size_t strcspn(const char *_Str,const char *_Control);
__attribute__ ((__dllimport__)) char * _strerror(const char *_ErrMsg) ;
char * strerror(int) ;
__attribute__ ((__dllimport__)) char * _strlwr(char *_String) ;
char *strlwr_l(char *_String,_locale_t _Locale) ;
char * strncat(char * __restrict__ _Dest,const char * __restrict__ _Source,size_t _Count) ;
int strncmp(const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicmp(const char *_Str1,const char *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _strnicmp_l(const char *_Str1,const char *_Str2,size_t _MaxCount,_locale_t _Locale);
char *strncpy(char * __restrict__ _Dest,const char * __restrict__ _Source,size_t _Count) ;
__attribute__ ((__dllimport__)) char * _strnset(char *_Str,int _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) char * _strnset_l(char *str,int c,size_t count,_locale_t _Locale) ;
char * strpbrk(const char *_Str,const char *_Control);
char * strrchr(const char *_Str,int _Ch);
__attribute__ ((__dllimport__)) char * _strrev(char *_Str);
size_t strspn(const char *_Str,const char *_Control);
char * strstr(const char *_Str,const char *_SubStr);
char * strtok(char * __restrict__ _Str,const char * __restrict__ _Delim) ;
__attribute__ ((__dllimport__)) char * _strupr(char *_String) ;
__attribute__ ((__dllimport__)) char *_strupr_l(char *_String,_locale_t _Locale) ;
size_t strxfrm(char * __restrict__ _Dst,const char * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _strxfrm_l(char * __restrict__ _Dst,const char * __restrict__ _Src,size_t _MaxCount,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
char * strdup(const char *_Src) ;
int strcmpi(const char *_Str1,const char *_Str2) ;
int stricmp(const char *_Str1,const char *_Str2) ;
char * strlwr(char *_Str) ;
int strnicmp(const char *_Str1,const char *_Str,size_t _MaxCount) ;
int strncasecmp (const char *, const char *, size_t);
int strcasecmp (const char *, const char *);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char * strnset(char *_Str,int _Val,size_t _MaxCount) ;
char * strrev(char *_Str) ;
char * strset(char *_Str,int _Val) ;
char * strupr(char *_Str) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wcsdup(const wchar_t *_Str);
wchar_t * wcscat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
wchar_t * wcschr(const wchar_t *_Str,wchar_t _Ch);
int wcscmp(const wchar_t *_Str1,const wchar_t *_Str2);
wchar_t * wcscpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
size_t wcscspn(const wchar_t *_Str,const wchar_t *_Control);
size_t wcslen(const wchar_t *_Str);
size_t wcsnlen(const wchar_t *_Src,size_t _MaxCount);
wchar_t *wcsncat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
int wcsncmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
wchar_t *wcsncpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
wchar_t * _wcsncpy_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count,_locale_t _Locale) ;
wchar_t * wcspbrk(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsrchr(const wchar_t *_Str,wchar_t _Ch);
size_t wcsspn(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsstr(const wchar_t *_Str,const wchar_t *_SubStr);
wchar_t * wcstok(wchar_t * __restrict__ _Str,const wchar_t * __restrict__ _Delim) ;
__attribute__ ((__dllimport__)) wchar_t * _wcserror(int _ErrNum) ;
__attribute__ ((__dllimport__)) wchar_t * __wcserror(const wchar_t *_Str) ;
__attribute__ ((__dllimport__)) int _wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsrev(wchar_t *_Str);
__attribute__ ((__dllimport__)) wchar_t * _wcsset(wchar_t *_Str,wchar_t _Val) ;
__attribute__ ((__dllimport__)) wchar_t * _wcslwr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcslwr_l(wchar_t *_String,_locale_t _Locale) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsupr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcsupr_l(wchar_t *_String,_locale_t _Locale) ;
size_t wcsxfrm(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _wcsxfrm_l(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount,_locale_t _Locale);
int wcscoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcscoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsncoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsncoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
wchar_t * wcsdup(const wchar_t *_Str) ;
#pragma empty_line
int wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2) ;
int wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount) ;
wchar_t * wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
wchar_t * wcsrev(wchar_t *_Str) ;
wchar_t * wcsset(wchar_t *_Str,wchar_t _Val) ;
wchar_t * wcslwr(wchar_t *_Str) ;
wchar_t * wcsupr(wchar_t *_Str) ;
int wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/string_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/string_s.h" 2 3
#pragma line 175 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\string.h" 2 3
#pragma line 63 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_push.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
/* Undefine __mingw_<printf> macros. */
#pragma line 11 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 26 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
#pragma line 84 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
typedef long _off_t;
#pragma empty_line
typedef long off_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long _off64_t;
#pragma empty_line
__extension__ typedef long long off64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * __iob_func(void);
#pragma line 120 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__extension__ typedef long long fpos_t;
#pragma line 157 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) int _filbuf(FILE *_File);
__attribute__ ((__dllimport__)) int _flsbuf(int _Ch,FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _fsopen(const char *_Filename,const char *_Mode,int _ShFlag);
#pragma empty_line
void clearerr(FILE *_File);
int fclose(FILE *_File);
__attribute__ ((__dllimport__)) int _fcloseall(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _fdopen(int _FileHandle,const char *_Mode);
#pragma empty_line
int feof(FILE *_File);
int ferror(FILE *_File);
int fflush(FILE *_File);
int fgetc(FILE *_File);
__attribute__ ((__dllimport__)) int _fgetchar(void);
int fgetpos(FILE * __restrict__ _File ,fpos_t * __restrict__ _Pos);
char * fgets(char * __restrict__ _Buf,int _MaxCount,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fileno(FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) char * _tempnam(const char *_DirName,const char *_FilePrefix);
__attribute__ ((__dllimport__)) int _flushall(void);
FILE * fopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode) ;
FILE *fopen64(const char * __restrict__ filename,const char * __restrict__ mode);
int fprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,...);
int fputc(int _Ch,FILE *_File);
__attribute__ ((__dllimport__)) int _fputchar(int _Ch);
int fputs(const char * __restrict__ _Str,FILE * __restrict__ _File);
size_t fread(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
FILE * freopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode,FILE * __restrict__ _File) ;
int fscanf(FILE * __restrict__ _File,const char * __restrict__ _Format,...) ;
int _fscanf_l(FILE * __restrict__ _File,const char * __restrict__ _Format,_locale_t locale,...) ;
int fsetpos(FILE *_File,const fpos_t *_Pos);
int fseek(FILE *_File,long _Offset,int _Origin);
int fseeko64(FILE* stream, _off64_t offset, int whence);
long ftell(FILE *_File);
_off64_t ftello64(FILE * stream);
__extension__ int _fseeki64(FILE *_File,long long _Offset,int _Origin);
__extension__ long long _ftelli64(FILE *_File);
size_t fwrite(const void * __restrict__ _Str,size_t _Size,size_t _Count,FILE * __restrict__ _File);
int getc(FILE *_File);
int getchar(void);
__attribute__ ((__dllimport__)) int _getmaxstdio(void);
char * gets(char *_Buffer) ;
int _getw(FILE *_File);
#pragma empty_line
#pragma empty_line
void perror(const char *_ErrMsg);
#pragma empty_line
__attribute__ ((__dllimport__)) int _pclose(FILE *_File);
__attribute__ ((__dllimport__)) FILE * _popen(const char *_Command,const char *_Mode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int printf(const char * __restrict__ _Format,...);
int putc(int _Ch,FILE *_File);
int putchar(int _Ch);
int puts(const char *_Str);
__attribute__ ((__dllimport__)) int _putw(int _Word,FILE *_File);
#pragma empty_line
#pragma empty_line
int remove(const char *_Filename);
int rename(const char *_OldFilename,const char *_NewFilename);
__attribute__ ((__dllimport__)) int _unlink(const char *_Filename);
#pragma empty_line
int unlink(const char *_Filename) ;
#pragma empty_line
#pragma empty_line
void rewind(FILE *_File);
__attribute__ ((__dllimport__)) int _rmtmp(void);
int scanf(const char * __restrict__ _Format,...) ;
int _scanf_l(const char * __restrict__ format,_locale_t locale,... ) ;
void setbuf(FILE * __restrict__ _File,char * __restrict__ _Buffer) ;
__attribute__ ((__dllimport__)) int _setmaxstdio(int _Max);
__attribute__ ((__dllimport__)) unsigned int _set_output_format(unsigned int _Format);
__attribute__ ((__dllimport__)) unsigned int _get_output_format(void);
unsigned int __mingw_set_output_format(unsigned int _Format);
unsigned int __mingw_get_output_format(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int setvbuf(FILE * __restrict__ _File,char * __restrict__ _Buf,int _Mode,size_t _Size);
__attribute__ ((__dllimport__)) int _scprintf(const char * __restrict__ _Format,...);
int sscanf(const char * __restrict__ _Src,const char * __restrict__ _Format,...) ;
int _sscanf_l(const char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _snscanf(const char * __restrict__ _Src,size_t _MaxCount,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snscanf_l(const char * __restrict__ input,size_t length,const char * __restrict__ format,_locale_t locale,...) ;
FILE * tmpfile(void) ;
char * tmpnam(char *_Buffer);
int ungetc(int _Ch,FILE *_File);
int vfprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,va_list _ArgList);
int vprintf(const char * __restrict__ _Format,va_list _ArgList);
#pragma empty_line
/* Make sure macros are not defined. */
extern
__attribute__((__format__ (gnu_printf, 3, 0))) __attribute__ ((__nonnull__ (3)))
int __mingw_vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,
va_list _ArgList);
extern
__attribute__((__format__ (gnu_printf, 3, 4))) __attribute__ ((__nonnull__ (3)))
int __mingw_snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
extern
__attribute__((__format__ (gnu_printf, 1, 2))) __attribute__ ((__nonnull__ (1)))
int __mingw_printf(const char * __restrict__ , ... ) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 1, 0))) __attribute__ ((__nonnull__ (1)))
int __mingw_vprintf (const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_fprintf (FILE * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vfprintf (FILE * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_sprintf (char * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vsprintf (char * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
#pragma empty_line
__attribute__ ((__dllimport__)) int _snprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _vsnprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,va_list _Args) ;
__attribute__ ((__dllimport__)) int _vsnprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,va_list argptr) ;
int sprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,...) ;
int _sprintf_l(char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
int vsprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,va_list _Args) ;
#pragma empty_line
/* this is here to deal with software defining
* vsnprintf as _vsnprintf, eg. libxml2. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,va_list _ArgList) ;
#pragma empty_line
int snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
#pragma line 312 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vscanf(const char * __restrict__ Format, va_list argp);
int vfscanf (FILE * __restrict__ fp, const char * __restrict__ Format,va_list argp);
int vsscanf (const char * __restrict__ _Str,const char * __restrict__ Format,va_list argp);
#pragma empty_line
__attribute__ ((__dllimport__)) int _vscprintf(const char * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _set_printf_count_output(int _Value);
__attribute__ ((__dllimport__)) int _get_printf_count_output(void);
#pragma line 330 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) FILE * _wfsopen(const wchar_t *_Filename,const wchar_t *_Mode,int _ShFlag);
#pragma empty_line
#pragma empty_line
wint_t fgetwc(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fgetwchar(void);
wint_t fputwc(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwchar(wchar_t _Ch);
wint_t getwc(FILE *_File);
wint_t getwchar(void);
wint_t putwc(wchar_t _Ch,FILE *_File);
wint_t putwchar(wchar_t _Ch);
wint_t ungetwc(wint_t _Ch,FILE *_File);
wchar_t * fgetws(wchar_t * __restrict__ _Dst,int _SizeInWords,FILE * __restrict__ _File);
int fputws(const wchar_t * __restrict__ _Str,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) wchar_t * _getws(wchar_t *_String) ;
__attribute__ ((__dllimport__)) int _putws(const wchar_t *_Str);
int fwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
int wprintf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _scwprintf(const wchar_t * __restrict__ _Format,...);
int vfwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
int vwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...) ;
__attribute__ ((__dllimport__)) int _swprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,... ) ;
__attribute__ ((__dllimport__)) int vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ ,va_list) ;
__attribute__ ((__dllimport__)) int _swprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _vsnwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,va_list _Args) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int snwprintf (wchar_t * __restrict__ s, size_t n, const wchar_t * __restrict__ format, ...);
int vsnwprintf (wchar_t * __restrict__ , size_t, const wchar_t * __restrict__ , va_list);
#pragma line 373 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vwscanf (const wchar_t * __restrict__ , va_list);
int vfwscanf (FILE * __restrict__ ,const wchar_t * __restrict__ ,va_list);
int vswscanf (const wchar_t * __restrict__ ,const wchar_t * __restrict__ ,va_list);
#pragma empty_line
__attribute__ ((__dllimport__)) int _fwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _wprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vfwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _wprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _wprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _fwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _fwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vfwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vfwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _swprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vswprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vswprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _scwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vsnwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList) ;
__attribute__ ((__dllimport__)) int _swprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,va_list _Args);
__attribute__ ((__dllimport__)) int __swprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,...) ;
__attribute__ ((__dllimport__)) int _vswprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,va_list argptr) ;
__attribute__ ((__dllimport__)) int __vswprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,va_list _Args) ;
#pragma line 417 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) wchar_t * _wtempnam(const wchar_t *_Directory,const wchar_t *_FilePrefix);
__attribute__ ((__dllimport__)) int _vscwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vscwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
int fwscanf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _fwscanf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
int swscanf(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _swscanf_l(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) int _snwscanf(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _snwscanf_l(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
int wscanf(const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _wscanf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) FILE * _wfdopen(int _FileHandle ,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) FILE * _wfopen(const wchar_t * __restrict__ _Filename,const wchar_t *__restrict__ _Mode) ;
__attribute__ ((__dllimport__)) FILE * _wfreopen(const wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode,FILE * __restrict__ _OldFile) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _wperror(const wchar_t *_ErrMsg);
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _wpopen(const wchar_t *_Command,const wchar_t *_Mode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wremove(const wchar_t *_Filename);
__attribute__ ((__dllimport__)) wchar_t * _wtmpnam(wchar_t *_Buffer);
__attribute__ ((__dllimport__)) wint_t _fgetwc_nolock(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwc_nolock(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _ungetwc_nolock(wint_t _Ch,FILE *_File);
#pragma line 475 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) void _lock_file(FILE *_File);
__attribute__ ((__dllimport__)) void _unlock_file(FILE *_File);
__attribute__ ((__dllimport__)) int _fclose_nolock(FILE *_File);
__attribute__ ((__dllimport__)) int _fflush_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fread_nolock(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fseek_nolock(FILE *_File,long _Offset,int _Origin);
__attribute__ ((__dllimport__)) long _ftell_nolock(FILE *_File);
__extension__ __attribute__ ((__dllimport__)) int _fseeki64_nolock(FILE *_File,long long _Offset,int _Origin);
__extension__ __attribute__ ((__dllimport__)) long long _ftelli64_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fwrite_nolock(const void * __restrict__ _DstBuf,size_t _Size,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _ungetc_nolock(int _Ch,FILE *_File);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char * tempnam(const char *_Directory,const char *_FilePrefix) ;
int fcloseall(void) ;
FILE * fdopen(int _FileHandle,const char *_Format) ;
int fgetchar(void) ;
int fileno(FILE *_File) ;
int flushall(void) ;
int fputchar(int _Ch) ;
int getw(FILE *_File) ;
int putw(int _Ch,FILE *_File) ;
int rmtmp(void) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 2 3
#pragma line 509 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_pop.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
/* Define __mingw_<printf> macros. */
#pragma line 511 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma line 64 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 77 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 1
/* autopilot_apint.h*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 1
/*-*-c++-*-*/
/* autopilot_dt.h: defines all bit-accurate data types.*/
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 97 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
typedef int __attribute__ ((bitwidth(1))) int1;
typedef int __attribute__ ((bitwidth(2))) int2;
typedef int __attribute__ ((bitwidth(3))) int3;
typedef int __attribute__ ((bitwidth(4))) int4;
typedef int __attribute__ ((bitwidth(5))) int5;
typedef int __attribute__ ((bitwidth(6))) int6;
typedef int __attribute__ ((bitwidth(7))) int7;
typedef int __attribute__ ((bitwidth(8))) int8;
typedef int __attribute__ ((bitwidth(9))) int9;
typedef int __attribute__ ((bitwidth(10))) int10;
typedef int __attribute__ ((bitwidth(11))) int11;
typedef int __attribute__ ((bitwidth(12))) int12;
typedef int __attribute__ ((bitwidth(13))) int13;
typedef int __attribute__ ((bitwidth(14))) int14;
typedef int __attribute__ ((bitwidth(15))) int15;
typedef int __attribute__ ((bitwidth(16))) int16;
typedef int __attribute__ ((bitwidth(17))) int17;
typedef int __attribute__ ((bitwidth(18))) int18;
typedef int __attribute__ ((bitwidth(19))) int19;
typedef int __attribute__ ((bitwidth(20))) int20;
typedef int __attribute__ ((bitwidth(21))) int21;
typedef int __attribute__ ((bitwidth(22))) int22;
typedef int __attribute__ ((bitwidth(23))) int23;
typedef int __attribute__ ((bitwidth(24))) int24;
typedef int __attribute__ ((bitwidth(25))) int25;
typedef int __attribute__ ((bitwidth(26))) int26;
typedef int __attribute__ ((bitwidth(27))) int27;
typedef int __attribute__ ((bitwidth(28))) int28;
typedef int __attribute__ ((bitwidth(29))) int29;
typedef int __attribute__ ((bitwidth(30))) int30;
typedef int __attribute__ ((bitwidth(31))) int31;
typedef int __attribute__ ((bitwidth(32))) int32;
typedef int __attribute__ ((bitwidth(33))) int33;
typedef int __attribute__ ((bitwidth(34))) int34;
typedef int __attribute__ ((bitwidth(35))) int35;
typedef int __attribute__ ((bitwidth(36))) int36;
typedef int __attribute__ ((bitwidth(37))) int37;
typedef int __attribute__ ((bitwidth(38))) int38;
typedef int __attribute__ ((bitwidth(39))) int39;
typedef int __attribute__ ((bitwidth(40))) int40;
typedef int __attribute__ ((bitwidth(41))) int41;
typedef int __attribute__ ((bitwidth(42))) int42;
typedef int __attribute__ ((bitwidth(43))) int43;
typedef int __attribute__ ((bitwidth(44))) int44;
typedef int __attribute__ ((bitwidth(45))) int45;
typedef int __attribute__ ((bitwidth(46))) int46;
typedef int __attribute__ ((bitwidth(47))) int47;
typedef int __attribute__ ((bitwidth(48))) int48;
typedef int __attribute__ ((bitwidth(49))) int49;
typedef int __attribute__ ((bitwidth(50))) int50;
typedef int __attribute__ ((bitwidth(51))) int51;
typedef int __attribute__ ((bitwidth(52))) int52;
typedef int __attribute__ ((bitwidth(53))) int53;
typedef int __attribute__ ((bitwidth(54))) int54;
typedef int __attribute__ ((bitwidth(55))) int55;
typedef int __attribute__ ((bitwidth(56))) int56;
typedef int __attribute__ ((bitwidth(57))) int57;
typedef int __attribute__ ((bitwidth(58))) int58;
typedef int __attribute__ ((bitwidth(59))) int59;
typedef int __attribute__ ((bitwidth(60))) int60;
typedef int __attribute__ ((bitwidth(61))) int61;
typedef int __attribute__ ((bitwidth(62))) int62;
typedef int __attribute__ ((bitwidth(63))) int63;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
typedef int __attribute__ ((bitwidth(65))) int65;
typedef int __attribute__ ((bitwidth(66))) int66;
typedef int __attribute__ ((bitwidth(67))) int67;
typedef int __attribute__ ((bitwidth(68))) int68;
typedef int __attribute__ ((bitwidth(69))) int69;
typedef int __attribute__ ((bitwidth(70))) int70;
typedef int __attribute__ ((bitwidth(71))) int71;
typedef int __attribute__ ((bitwidth(72))) int72;
typedef int __attribute__ ((bitwidth(73))) int73;
typedef int __attribute__ ((bitwidth(74))) int74;
typedef int __attribute__ ((bitwidth(75))) int75;
typedef int __attribute__ ((bitwidth(76))) int76;
typedef int __attribute__ ((bitwidth(77))) int77;
typedef int __attribute__ ((bitwidth(78))) int78;
typedef int __attribute__ ((bitwidth(79))) int79;
typedef int __attribute__ ((bitwidth(80))) int80;
typedef int __attribute__ ((bitwidth(81))) int81;
typedef int __attribute__ ((bitwidth(82))) int82;
typedef int __attribute__ ((bitwidth(83))) int83;
typedef int __attribute__ ((bitwidth(84))) int84;
typedef int __attribute__ ((bitwidth(85))) int85;
typedef int __attribute__ ((bitwidth(86))) int86;
typedef int __attribute__ ((bitwidth(87))) int87;
typedef int __attribute__ ((bitwidth(88))) int88;
typedef int __attribute__ ((bitwidth(89))) int89;
typedef int __attribute__ ((bitwidth(90))) int90;
typedef int __attribute__ ((bitwidth(91))) int91;
typedef int __attribute__ ((bitwidth(92))) int92;
typedef int __attribute__ ((bitwidth(93))) int93;
typedef int __attribute__ ((bitwidth(94))) int94;
typedef int __attribute__ ((bitwidth(95))) int95;
typedef int __attribute__ ((bitwidth(96))) int96;
typedef int __attribute__ ((bitwidth(97))) int97;
typedef int __attribute__ ((bitwidth(98))) int98;
typedef int __attribute__ ((bitwidth(99))) int99;
typedef int __attribute__ ((bitwidth(100))) int100;
typedef int __attribute__ ((bitwidth(101))) int101;
typedef int __attribute__ ((bitwidth(102))) int102;
typedef int __attribute__ ((bitwidth(103))) int103;
typedef int __attribute__ ((bitwidth(104))) int104;
typedef int __attribute__ ((bitwidth(105))) int105;
typedef int __attribute__ ((bitwidth(106))) int106;
typedef int __attribute__ ((bitwidth(107))) int107;
typedef int __attribute__ ((bitwidth(108))) int108;
typedef int __attribute__ ((bitwidth(109))) int109;
typedef int __attribute__ ((bitwidth(110))) int110;
typedef int __attribute__ ((bitwidth(111))) int111;
typedef int __attribute__ ((bitwidth(112))) int112;
typedef int __attribute__ ((bitwidth(113))) int113;
typedef int __attribute__ ((bitwidth(114))) int114;
typedef int __attribute__ ((bitwidth(115))) int115;
typedef int __attribute__ ((bitwidth(116))) int116;
typedef int __attribute__ ((bitwidth(117))) int117;
typedef int __attribute__ ((bitwidth(118))) int118;
typedef int __attribute__ ((bitwidth(119))) int119;
typedef int __attribute__ ((bitwidth(120))) int120;
typedef int __attribute__ ((bitwidth(121))) int121;
typedef int __attribute__ ((bitwidth(122))) int122;
typedef int __attribute__ ((bitwidth(123))) int123;
typedef int __attribute__ ((bitwidth(124))) int124;
typedef int __attribute__ ((bitwidth(125))) int125;
typedef int __attribute__ ((bitwidth(126))) int126;
typedef int __attribute__ ((bitwidth(127))) int127;
typedef int __attribute__ ((bitwidth(128))) int128;
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
typedef int __attribute__ ((bitwidth(129))) int129;
typedef int __attribute__ ((bitwidth(130))) int130;
typedef int __attribute__ ((bitwidth(131))) int131;
typedef int __attribute__ ((bitwidth(132))) int132;
typedef int __attribute__ ((bitwidth(133))) int133;
typedef int __attribute__ ((bitwidth(134))) int134;
typedef int __attribute__ ((bitwidth(135))) int135;
typedef int __attribute__ ((bitwidth(136))) int136;
typedef int __attribute__ ((bitwidth(137))) int137;
typedef int __attribute__ ((bitwidth(138))) int138;
typedef int __attribute__ ((bitwidth(139))) int139;
typedef int __attribute__ ((bitwidth(140))) int140;
typedef int __attribute__ ((bitwidth(141))) int141;
typedef int __attribute__ ((bitwidth(142))) int142;
typedef int __attribute__ ((bitwidth(143))) int143;
typedef int __attribute__ ((bitwidth(144))) int144;
typedef int __attribute__ ((bitwidth(145))) int145;
typedef int __attribute__ ((bitwidth(146))) int146;
typedef int __attribute__ ((bitwidth(147))) int147;
typedef int __attribute__ ((bitwidth(148))) int148;
typedef int __attribute__ ((bitwidth(149))) int149;
typedef int __attribute__ ((bitwidth(150))) int150;
typedef int __attribute__ ((bitwidth(151))) int151;
typedef int __attribute__ ((bitwidth(152))) int152;
typedef int __attribute__ ((bitwidth(153))) int153;
typedef int __attribute__ ((bitwidth(154))) int154;
typedef int __attribute__ ((bitwidth(155))) int155;
typedef int __attribute__ ((bitwidth(156))) int156;
typedef int __attribute__ ((bitwidth(157))) int157;
typedef int __attribute__ ((bitwidth(158))) int158;
typedef int __attribute__ ((bitwidth(159))) int159;
typedef int __attribute__ ((bitwidth(160))) int160;
typedef int __attribute__ ((bitwidth(161))) int161;
typedef int __attribute__ ((bitwidth(162))) int162;
typedef int __attribute__ ((bitwidth(163))) int163;
typedef int __attribute__ ((bitwidth(164))) int164;
typedef int __attribute__ ((bitwidth(165))) int165;
typedef int __attribute__ ((bitwidth(166))) int166;
typedef int __attribute__ ((bitwidth(167))) int167;
typedef int __attribute__ ((bitwidth(168))) int168;
typedef int __attribute__ ((bitwidth(169))) int169;
typedef int __attribute__ ((bitwidth(170))) int170;
typedef int __attribute__ ((bitwidth(171))) int171;
typedef int __attribute__ ((bitwidth(172))) int172;
typedef int __attribute__ ((bitwidth(173))) int173;
typedef int __attribute__ ((bitwidth(174))) int174;
typedef int __attribute__ ((bitwidth(175))) int175;
typedef int __attribute__ ((bitwidth(176))) int176;
typedef int __attribute__ ((bitwidth(177))) int177;
typedef int __attribute__ ((bitwidth(178))) int178;
typedef int __attribute__ ((bitwidth(179))) int179;
typedef int __attribute__ ((bitwidth(180))) int180;
typedef int __attribute__ ((bitwidth(181))) int181;
typedef int __attribute__ ((bitwidth(182))) int182;
typedef int __attribute__ ((bitwidth(183))) int183;
typedef int __attribute__ ((bitwidth(184))) int184;
typedef int __attribute__ ((bitwidth(185))) int185;
typedef int __attribute__ ((bitwidth(186))) int186;
typedef int __attribute__ ((bitwidth(187))) int187;
typedef int __attribute__ ((bitwidth(188))) int188;
typedef int __attribute__ ((bitwidth(189))) int189;
typedef int __attribute__ ((bitwidth(190))) int190;
typedef int __attribute__ ((bitwidth(191))) int191;
typedef int __attribute__ ((bitwidth(192))) int192;
typedef int __attribute__ ((bitwidth(193))) int193;
typedef int __attribute__ ((bitwidth(194))) int194;
typedef int __attribute__ ((bitwidth(195))) int195;
typedef int __attribute__ ((bitwidth(196))) int196;
typedef int __attribute__ ((bitwidth(197))) int197;
typedef int __attribute__ ((bitwidth(198))) int198;
typedef int __attribute__ ((bitwidth(199))) int199;
typedef int __attribute__ ((bitwidth(200))) int200;
typedef int __attribute__ ((bitwidth(201))) int201;
typedef int __attribute__ ((bitwidth(202))) int202;
typedef int __attribute__ ((bitwidth(203))) int203;
typedef int __attribute__ ((bitwidth(204))) int204;
typedef int __attribute__ ((bitwidth(205))) int205;
typedef int __attribute__ ((bitwidth(206))) int206;
typedef int __attribute__ ((bitwidth(207))) int207;
typedef int __attribute__ ((bitwidth(208))) int208;
typedef int __attribute__ ((bitwidth(209))) int209;
typedef int __attribute__ ((bitwidth(210))) int210;
typedef int __attribute__ ((bitwidth(211))) int211;
typedef int __attribute__ ((bitwidth(212))) int212;
typedef int __attribute__ ((bitwidth(213))) int213;
typedef int __attribute__ ((bitwidth(214))) int214;
typedef int __attribute__ ((bitwidth(215))) int215;
typedef int __attribute__ ((bitwidth(216))) int216;
typedef int __attribute__ ((bitwidth(217))) int217;
typedef int __attribute__ ((bitwidth(218))) int218;
typedef int __attribute__ ((bitwidth(219))) int219;
typedef int __attribute__ ((bitwidth(220))) int220;
typedef int __attribute__ ((bitwidth(221))) int221;
typedef int __attribute__ ((bitwidth(222))) int222;
typedef int __attribute__ ((bitwidth(223))) int223;
typedef int __attribute__ ((bitwidth(224))) int224;
typedef int __attribute__ ((bitwidth(225))) int225;
typedef int __attribute__ ((bitwidth(226))) int226;
typedef int __attribute__ ((bitwidth(227))) int227;
typedef int __attribute__ ((bitwidth(228))) int228;
typedef int __attribute__ ((bitwidth(229))) int229;
typedef int __attribute__ ((bitwidth(230))) int230;
typedef int __attribute__ ((bitwidth(231))) int231;
typedef int __attribute__ ((bitwidth(232))) int232;
typedef int __attribute__ ((bitwidth(233))) int233;
typedef int __attribute__ ((bitwidth(234))) int234;
typedef int __attribute__ ((bitwidth(235))) int235;
typedef int __attribute__ ((bitwidth(236))) int236;
typedef int __attribute__ ((bitwidth(237))) int237;
typedef int __attribute__ ((bitwidth(238))) int238;
typedef int __attribute__ ((bitwidth(239))) int239;
typedef int __attribute__ ((bitwidth(240))) int240;
typedef int __attribute__ ((bitwidth(241))) int241;
typedef int __attribute__ ((bitwidth(242))) int242;
typedef int __attribute__ ((bitwidth(243))) int243;
typedef int __attribute__ ((bitwidth(244))) int244;
typedef int __attribute__ ((bitwidth(245))) int245;
typedef int __attribute__ ((bitwidth(246))) int246;
typedef int __attribute__ ((bitwidth(247))) int247;
typedef int __attribute__ ((bitwidth(248))) int248;
typedef int __attribute__ ((bitwidth(249))) int249;
typedef int __attribute__ ((bitwidth(250))) int250;
typedef int __attribute__ ((bitwidth(251))) int251;
typedef int __attribute__ ((bitwidth(252))) int252;
typedef int __attribute__ ((bitwidth(253))) int253;
typedef int __attribute__ ((bitwidth(254))) int254;
typedef int __attribute__ ((bitwidth(255))) int255;
typedef int __attribute__ ((bitwidth(256))) int256;
typedef int __attribute__ ((bitwidth(257))) int257;
typedef int __attribute__ ((bitwidth(258))) int258;
typedef int __attribute__ ((bitwidth(259))) int259;
typedef int __attribute__ ((bitwidth(260))) int260;
typedef int __attribute__ ((bitwidth(261))) int261;
typedef int __attribute__ ((bitwidth(262))) int262;
typedef int __attribute__ ((bitwidth(263))) int263;
typedef int __attribute__ ((bitwidth(264))) int264;
typedef int __attribute__ ((bitwidth(265))) int265;
typedef int __attribute__ ((bitwidth(266))) int266;
typedef int __attribute__ ((bitwidth(267))) int267;
typedef int __attribute__ ((bitwidth(268))) int268;
typedef int __attribute__ ((bitwidth(269))) int269;
typedef int __attribute__ ((bitwidth(270))) int270;
typedef int __attribute__ ((bitwidth(271))) int271;
typedef int __attribute__ ((bitwidth(272))) int272;
typedef int __attribute__ ((bitwidth(273))) int273;
typedef int __attribute__ ((bitwidth(274))) int274;
typedef int __attribute__ ((bitwidth(275))) int275;
typedef int __attribute__ ((bitwidth(276))) int276;
typedef int __attribute__ ((bitwidth(277))) int277;
typedef int __attribute__ ((bitwidth(278))) int278;
typedef int __attribute__ ((bitwidth(279))) int279;
typedef int __attribute__ ((bitwidth(280))) int280;
typedef int __attribute__ ((bitwidth(281))) int281;
typedef int __attribute__ ((bitwidth(282))) int282;
typedef int __attribute__ ((bitwidth(283))) int283;
typedef int __attribute__ ((bitwidth(284))) int284;
typedef int __attribute__ ((bitwidth(285))) int285;
typedef int __attribute__ ((bitwidth(286))) int286;
typedef int __attribute__ ((bitwidth(287))) int287;
typedef int __attribute__ ((bitwidth(288))) int288;
typedef int __attribute__ ((bitwidth(289))) int289;
typedef int __attribute__ ((bitwidth(290))) int290;
typedef int __attribute__ ((bitwidth(291))) int291;
typedef int __attribute__ ((bitwidth(292))) int292;
typedef int __attribute__ ((bitwidth(293))) int293;
typedef int __attribute__ ((bitwidth(294))) int294;
typedef int __attribute__ ((bitwidth(295))) int295;
typedef int __attribute__ ((bitwidth(296))) int296;
typedef int __attribute__ ((bitwidth(297))) int297;
typedef int __attribute__ ((bitwidth(298))) int298;
typedef int __attribute__ ((bitwidth(299))) int299;
typedef int __attribute__ ((bitwidth(300))) int300;
typedef int __attribute__ ((bitwidth(301))) int301;
typedef int __attribute__ ((bitwidth(302))) int302;
typedef int __attribute__ ((bitwidth(303))) int303;
typedef int __attribute__ ((bitwidth(304))) int304;
typedef int __attribute__ ((bitwidth(305))) int305;
typedef int __attribute__ ((bitwidth(306))) int306;
typedef int __attribute__ ((bitwidth(307))) int307;
typedef int __attribute__ ((bitwidth(308))) int308;
typedef int __attribute__ ((bitwidth(309))) int309;
typedef int __attribute__ ((bitwidth(310))) int310;
typedef int __attribute__ ((bitwidth(311))) int311;
typedef int __attribute__ ((bitwidth(312))) int312;
typedef int __attribute__ ((bitwidth(313))) int313;
typedef int __attribute__ ((bitwidth(314))) int314;
typedef int __attribute__ ((bitwidth(315))) int315;
typedef int __attribute__ ((bitwidth(316))) int316;
typedef int __attribute__ ((bitwidth(317))) int317;
typedef int __attribute__ ((bitwidth(318))) int318;
typedef int __attribute__ ((bitwidth(319))) int319;
typedef int __attribute__ ((bitwidth(320))) int320;
typedef int __attribute__ ((bitwidth(321))) int321;
typedef int __attribute__ ((bitwidth(322))) int322;
typedef int __attribute__ ((bitwidth(323))) int323;
typedef int __attribute__ ((bitwidth(324))) int324;
typedef int __attribute__ ((bitwidth(325))) int325;
typedef int __attribute__ ((bitwidth(326))) int326;
typedef int __attribute__ ((bitwidth(327))) int327;
typedef int __attribute__ ((bitwidth(328))) int328;
typedef int __attribute__ ((bitwidth(329))) int329;
typedef int __attribute__ ((bitwidth(330))) int330;
typedef int __attribute__ ((bitwidth(331))) int331;
typedef int __attribute__ ((bitwidth(332))) int332;
typedef int __attribute__ ((bitwidth(333))) int333;
typedef int __attribute__ ((bitwidth(334))) int334;
typedef int __attribute__ ((bitwidth(335))) int335;
typedef int __attribute__ ((bitwidth(336))) int336;
typedef int __attribute__ ((bitwidth(337))) int337;
typedef int __attribute__ ((bitwidth(338))) int338;
typedef int __attribute__ ((bitwidth(339))) int339;
typedef int __attribute__ ((bitwidth(340))) int340;
typedef int __attribute__ ((bitwidth(341))) int341;
typedef int __attribute__ ((bitwidth(342))) int342;
typedef int __attribute__ ((bitwidth(343))) int343;
typedef int __attribute__ ((bitwidth(344))) int344;
typedef int __attribute__ ((bitwidth(345))) int345;
typedef int __attribute__ ((bitwidth(346))) int346;
typedef int __attribute__ ((bitwidth(347))) int347;
typedef int __attribute__ ((bitwidth(348))) int348;
typedef int __attribute__ ((bitwidth(349))) int349;
typedef int __attribute__ ((bitwidth(350))) int350;
typedef int __attribute__ ((bitwidth(351))) int351;
typedef int __attribute__ ((bitwidth(352))) int352;
typedef int __attribute__ ((bitwidth(353))) int353;
typedef int __attribute__ ((bitwidth(354))) int354;
typedef int __attribute__ ((bitwidth(355))) int355;
typedef int __attribute__ ((bitwidth(356))) int356;
typedef int __attribute__ ((bitwidth(357))) int357;
typedef int __attribute__ ((bitwidth(358))) int358;
typedef int __attribute__ ((bitwidth(359))) int359;
typedef int __attribute__ ((bitwidth(360))) int360;
typedef int __attribute__ ((bitwidth(361))) int361;
typedef int __attribute__ ((bitwidth(362))) int362;
typedef int __attribute__ ((bitwidth(363))) int363;
typedef int __attribute__ ((bitwidth(364))) int364;
typedef int __attribute__ ((bitwidth(365))) int365;
typedef int __attribute__ ((bitwidth(366))) int366;
typedef int __attribute__ ((bitwidth(367))) int367;
typedef int __attribute__ ((bitwidth(368))) int368;
typedef int __attribute__ ((bitwidth(369))) int369;
typedef int __attribute__ ((bitwidth(370))) int370;
typedef int __attribute__ ((bitwidth(371))) int371;
typedef int __attribute__ ((bitwidth(372))) int372;
typedef int __attribute__ ((bitwidth(373))) int373;
typedef int __attribute__ ((bitwidth(374))) int374;
typedef int __attribute__ ((bitwidth(375))) int375;
typedef int __attribute__ ((bitwidth(376))) int376;
typedef int __attribute__ ((bitwidth(377))) int377;
typedef int __attribute__ ((bitwidth(378))) int378;
typedef int __attribute__ ((bitwidth(379))) int379;
typedef int __attribute__ ((bitwidth(380))) int380;
typedef int __attribute__ ((bitwidth(381))) int381;
typedef int __attribute__ ((bitwidth(382))) int382;
typedef int __attribute__ ((bitwidth(383))) int383;
typedef int __attribute__ ((bitwidth(384))) int384;
typedef int __attribute__ ((bitwidth(385))) int385;
typedef int __attribute__ ((bitwidth(386))) int386;
typedef int __attribute__ ((bitwidth(387))) int387;
typedef int __attribute__ ((bitwidth(388))) int388;
typedef int __attribute__ ((bitwidth(389))) int389;
typedef int __attribute__ ((bitwidth(390))) int390;
typedef int __attribute__ ((bitwidth(391))) int391;
typedef int __attribute__ ((bitwidth(392))) int392;
typedef int __attribute__ ((bitwidth(393))) int393;
typedef int __attribute__ ((bitwidth(394))) int394;
typedef int __attribute__ ((bitwidth(395))) int395;
typedef int __attribute__ ((bitwidth(396))) int396;
typedef int __attribute__ ((bitwidth(397))) int397;
typedef int __attribute__ ((bitwidth(398))) int398;
typedef int __attribute__ ((bitwidth(399))) int399;
typedef int __attribute__ ((bitwidth(400))) int400;
typedef int __attribute__ ((bitwidth(401))) int401;
typedef int __attribute__ ((bitwidth(402))) int402;
typedef int __attribute__ ((bitwidth(403))) int403;
typedef int __attribute__ ((bitwidth(404))) int404;
typedef int __attribute__ ((bitwidth(405))) int405;
typedef int __attribute__ ((bitwidth(406))) int406;
typedef int __attribute__ ((bitwidth(407))) int407;
typedef int __attribute__ ((bitwidth(408))) int408;
typedef int __attribute__ ((bitwidth(409))) int409;
typedef int __attribute__ ((bitwidth(410))) int410;
typedef int __attribute__ ((bitwidth(411))) int411;
typedef int __attribute__ ((bitwidth(412))) int412;
typedef int __attribute__ ((bitwidth(413))) int413;
typedef int __attribute__ ((bitwidth(414))) int414;
typedef int __attribute__ ((bitwidth(415))) int415;
typedef int __attribute__ ((bitwidth(416))) int416;
typedef int __attribute__ ((bitwidth(417))) int417;
typedef int __attribute__ ((bitwidth(418))) int418;
typedef int __attribute__ ((bitwidth(419))) int419;
typedef int __attribute__ ((bitwidth(420))) int420;
typedef int __attribute__ ((bitwidth(421))) int421;
typedef int __attribute__ ((bitwidth(422))) int422;
typedef int __attribute__ ((bitwidth(423))) int423;
typedef int __attribute__ ((bitwidth(424))) int424;
typedef int __attribute__ ((bitwidth(425))) int425;
typedef int __attribute__ ((bitwidth(426))) int426;
typedef int __attribute__ ((bitwidth(427))) int427;
typedef int __attribute__ ((bitwidth(428))) int428;
typedef int __attribute__ ((bitwidth(429))) int429;
typedef int __attribute__ ((bitwidth(430))) int430;
typedef int __attribute__ ((bitwidth(431))) int431;
typedef int __attribute__ ((bitwidth(432))) int432;
typedef int __attribute__ ((bitwidth(433))) int433;
typedef int __attribute__ ((bitwidth(434))) int434;
typedef int __attribute__ ((bitwidth(435))) int435;
typedef int __attribute__ ((bitwidth(436))) int436;
typedef int __attribute__ ((bitwidth(437))) int437;
typedef int __attribute__ ((bitwidth(438))) int438;
typedef int __attribute__ ((bitwidth(439))) int439;
typedef int __attribute__ ((bitwidth(440))) int440;
typedef int __attribute__ ((bitwidth(441))) int441;
typedef int __attribute__ ((bitwidth(442))) int442;
typedef int __attribute__ ((bitwidth(443))) int443;
typedef int __attribute__ ((bitwidth(444))) int444;
typedef int __attribute__ ((bitwidth(445))) int445;
typedef int __attribute__ ((bitwidth(446))) int446;
typedef int __attribute__ ((bitwidth(447))) int447;
typedef int __attribute__ ((bitwidth(448))) int448;
typedef int __attribute__ ((bitwidth(449))) int449;
typedef int __attribute__ ((bitwidth(450))) int450;
typedef int __attribute__ ((bitwidth(451))) int451;
typedef int __attribute__ ((bitwidth(452))) int452;
typedef int __attribute__ ((bitwidth(453))) int453;
typedef int __attribute__ ((bitwidth(454))) int454;
typedef int __attribute__ ((bitwidth(455))) int455;
typedef int __attribute__ ((bitwidth(456))) int456;
typedef int __attribute__ ((bitwidth(457))) int457;
typedef int __attribute__ ((bitwidth(458))) int458;
typedef int __attribute__ ((bitwidth(459))) int459;
typedef int __attribute__ ((bitwidth(460))) int460;
typedef int __attribute__ ((bitwidth(461))) int461;
typedef int __attribute__ ((bitwidth(462))) int462;
typedef int __attribute__ ((bitwidth(463))) int463;
typedef int __attribute__ ((bitwidth(464))) int464;
typedef int __attribute__ ((bitwidth(465))) int465;
typedef int __attribute__ ((bitwidth(466))) int466;
typedef int __attribute__ ((bitwidth(467))) int467;
typedef int __attribute__ ((bitwidth(468))) int468;
typedef int __attribute__ ((bitwidth(469))) int469;
typedef int __attribute__ ((bitwidth(470))) int470;
typedef int __attribute__ ((bitwidth(471))) int471;
typedef int __attribute__ ((bitwidth(472))) int472;
typedef int __attribute__ ((bitwidth(473))) int473;
typedef int __attribute__ ((bitwidth(474))) int474;
typedef int __attribute__ ((bitwidth(475))) int475;
typedef int __attribute__ ((bitwidth(476))) int476;
typedef int __attribute__ ((bitwidth(477))) int477;
typedef int __attribute__ ((bitwidth(478))) int478;
typedef int __attribute__ ((bitwidth(479))) int479;
typedef int __attribute__ ((bitwidth(480))) int480;
typedef int __attribute__ ((bitwidth(481))) int481;
typedef int __attribute__ ((bitwidth(482))) int482;
typedef int __attribute__ ((bitwidth(483))) int483;
typedef int __attribute__ ((bitwidth(484))) int484;
typedef int __attribute__ ((bitwidth(485))) int485;
typedef int __attribute__ ((bitwidth(486))) int486;
typedef int __attribute__ ((bitwidth(487))) int487;
typedef int __attribute__ ((bitwidth(488))) int488;
typedef int __attribute__ ((bitwidth(489))) int489;
typedef int __attribute__ ((bitwidth(490))) int490;
typedef int __attribute__ ((bitwidth(491))) int491;
typedef int __attribute__ ((bitwidth(492))) int492;
typedef int __attribute__ ((bitwidth(493))) int493;
typedef int __attribute__ ((bitwidth(494))) int494;
typedef int __attribute__ ((bitwidth(495))) int495;
typedef int __attribute__ ((bitwidth(496))) int496;
typedef int __attribute__ ((bitwidth(497))) int497;
typedef int __attribute__ ((bitwidth(498))) int498;
typedef int __attribute__ ((bitwidth(499))) int499;
typedef int __attribute__ ((bitwidth(500))) int500;
typedef int __attribute__ ((bitwidth(501))) int501;
typedef int __attribute__ ((bitwidth(502))) int502;
typedef int __attribute__ ((bitwidth(503))) int503;
typedef int __attribute__ ((bitwidth(504))) int504;
typedef int __attribute__ ((bitwidth(505))) int505;
typedef int __attribute__ ((bitwidth(506))) int506;
typedef int __attribute__ ((bitwidth(507))) int507;
typedef int __attribute__ ((bitwidth(508))) int508;
typedef int __attribute__ ((bitwidth(509))) int509;
typedef int __attribute__ ((bitwidth(510))) int510;
typedef int __attribute__ ((bitwidth(511))) int511;
typedef int __attribute__ ((bitwidth(512))) int512;
typedef int __attribute__ ((bitwidth(513))) int513;
typedef int __attribute__ ((bitwidth(514))) int514;
typedef int __attribute__ ((bitwidth(515))) int515;
typedef int __attribute__ ((bitwidth(516))) int516;
typedef int __attribute__ ((bitwidth(517))) int517;
typedef int __attribute__ ((bitwidth(518))) int518;
typedef int __attribute__ ((bitwidth(519))) int519;
typedef int __attribute__ ((bitwidth(520))) int520;
typedef int __attribute__ ((bitwidth(521))) int521;
typedef int __attribute__ ((bitwidth(522))) int522;
typedef int __attribute__ ((bitwidth(523))) int523;
typedef int __attribute__ ((bitwidth(524))) int524;
typedef int __attribute__ ((bitwidth(525))) int525;
typedef int __attribute__ ((bitwidth(526))) int526;
typedef int __attribute__ ((bitwidth(527))) int527;
typedef int __attribute__ ((bitwidth(528))) int528;
typedef int __attribute__ ((bitwidth(529))) int529;
typedef int __attribute__ ((bitwidth(530))) int530;
typedef int __attribute__ ((bitwidth(531))) int531;
typedef int __attribute__ ((bitwidth(532))) int532;
typedef int __attribute__ ((bitwidth(533))) int533;
typedef int __attribute__ ((bitwidth(534))) int534;
typedef int __attribute__ ((bitwidth(535))) int535;
typedef int __attribute__ ((bitwidth(536))) int536;
typedef int __attribute__ ((bitwidth(537))) int537;
typedef int __attribute__ ((bitwidth(538))) int538;
typedef int __attribute__ ((bitwidth(539))) int539;
typedef int __attribute__ ((bitwidth(540))) int540;
typedef int __attribute__ ((bitwidth(541))) int541;
typedef int __attribute__ ((bitwidth(542))) int542;
typedef int __attribute__ ((bitwidth(543))) int543;
typedef int __attribute__ ((bitwidth(544))) int544;
typedef int __attribute__ ((bitwidth(545))) int545;
typedef int __attribute__ ((bitwidth(546))) int546;
typedef int __attribute__ ((bitwidth(547))) int547;
typedef int __attribute__ ((bitwidth(548))) int548;
typedef int __attribute__ ((bitwidth(549))) int549;
typedef int __attribute__ ((bitwidth(550))) int550;
typedef int __attribute__ ((bitwidth(551))) int551;
typedef int __attribute__ ((bitwidth(552))) int552;
typedef int __attribute__ ((bitwidth(553))) int553;
typedef int __attribute__ ((bitwidth(554))) int554;
typedef int __attribute__ ((bitwidth(555))) int555;
typedef int __attribute__ ((bitwidth(556))) int556;
typedef int __attribute__ ((bitwidth(557))) int557;
typedef int __attribute__ ((bitwidth(558))) int558;
typedef int __attribute__ ((bitwidth(559))) int559;
typedef int __attribute__ ((bitwidth(560))) int560;
typedef int __attribute__ ((bitwidth(561))) int561;
typedef int __attribute__ ((bitwidth(562))) int562;
typedef int __attribute__ ((bitwidth(563))) int563;
typedef int __attribute__ ((bitwidth(564))) int564;
typedef int __attribute__ ((bitwidth(565))) int565;
typedef int __attribute__ ((bitwidth(566))) int566;
typedef int __attribute__ ((bitwidth(567))) int567;
typedef int __attribute__ ((bitwidth(568))) int568;
typedef int __attribute__ ((bitwidth(569))) int569;
typedef int __attribute__ ((bitwidth(570))) int570;
typedef int __attribute__ ((bitwidth(571))) int571;
typedef int __attribute__ ((bitwidth(572))) int572;
typedef int __attribute__ ((bitwidth(573))) int573;
typedef int __attribute__ ((bitwidth(574))) int574;
typedef int __attribute__ ((bitwidth(575))) int575;
typedef int __attribute__ ((bitwidth(576))) int576;
typedef int __attribute__ ((bitwidth(577))) int577;
typedef int __attribute__ ((bitwidth(578))) int578;
typedef int __attribute__ ((bitwidth(579))) int579;
typedef int __attribute__ ((bitwidth(580))) int580;
typedef int __attribute__ ((bitwidth(581))) int581;
typedef int __attribute__ ((bitwidth(582))) int582;
typedef int __attribute__ ((bitwidth(583))) int583;
typedef int __attribute__ ((bitwidth(584))) int584;
typedef int __attribute__ ((bitwidth(585))) int585;
typedef int __attribute__ ((bitwidth(586))) int586;
typedef int __attribute__ ((bitwidth(587))) int587;
typedef int __attribute__ ((bitwidth(588))) int588;
typedef int __attribute__ ((bitwidth(589))) int589;
typedef int __attribute__ ((bitwidth(590))) int590;
typedef int __attribute__ ((bitwidth(591))) int591;
typedef int __attribute__ ((bitwidth(592))) int592;
typedef int __attribute__ ((bitwidth(593))) int593;
typedef int __attribute__ ((bitwidth(594))) int594;
typedef int __attribute__ ((bitwidth(595))) int595;
typedef int __attribute__ ((bitwidth(596))) int596;
typedef int __attribute__ ((bitwidth(597))) int597;
typedef int __attribute__ ((bitwidth(598))) int598;
typedef int __attribute__ ((bitwidth(599))) int599;
typedef int __attribute__ ((bitwidth(600))) int600;
typedef int __attribute__ ((bitwidth(601))) int601;
typedef int __attribute__ ((bitwidth(602))) int602;
typedef int __attribute__ ((bitwidth(603))) int603;
typedef int __attribute__ ((bitwidth(604))) int604;
typedef int __attribute__ ((bitwidth(605))) int605;
typedef int __attribute__ ((bitwidth(606))) int606;
typedef int __attribute__ ((bitwidth(607))) int607;
typedef int __attribute__ ((bitwidth(608))) int608;
typedef int __attribute__ ((bitwidth(609))) int609;
typedef int __attribute__ ((bitwidth(610))) int610;
typedef int __attribute__ ((bitwidth(611))) int611;
typedef int __attribute__ ((bitwidth(612))) int612;
typedef int __attribute__ ((bitwidth(613))) int613;
typedef int __attribute__ ((bitwidth(614))) int614;
typedef int __attribute__ ((bitwidth(615))) int615;
typedef int __attribute__ ((bitwidth(616))) int616;
typedef int __attribute__ ((bitwidth(617))) int617;
typedef int __attribute__ ((bitwidth(618))) int618;
typedef int __attribute__ ((bitwidth(619))) int619;
typedef int __attribute__ ((bitwidth(620))) int620;
typedef int __attribute__ ((bitwidth(621))) int621;
typedef int __attribute__ ((bitwidth(622))) int622;
typedef int __attribute__ ((bitwidth(623))) int623;
typedef int __attribute__ ((bitwidth(624))) int624;
typedef int __attribute__ ((bitwidth(625))) int625;
typedef int __attribute__ ((bitwidth(626))) int626;
typedef int __attribute__ ((bitwidth(627))) int627;
typedef int __attribute__ ((bitwidth(628))) int628;
typedef int __attribute__ ((bitwidth(629))) int629;
typedef int __attribute__ ((bitwidth(630))) int630;
typedef int __attribute__ ((bitwidth(631))) int631;
typedef int __attribute__ ((bitwidth(632))) int632;
typedef int __attribute__ ((bitwidth(633))) int633;
typedef int __attribute__ ((bitwidth(634))) int634;
typedef int __attribute__ ((bitwidth(635))) int635;
typedef int __attribute__ ((bitwidth(636))) int636;
typedef int __attribute__ ((bitwidth(637))) int637;
typedef int __attribute__ ((bitwidth(638))) int638;
typedef int __attribute__ ((bitwidth(639))) int639;
typedef int __attribute__ ((bitwidth(640))) int640;
typedef int __attribute__ ((bitwidth(641))) int641;
typedef int __attribute__ ((bitwidth(642))) int642;
typedef int __attribute__ ((bitwidth(643))) int643;
typedef int __attribute__ ((bitwidth(644))) int644;
typedef int __attribute__ ((bitwidth(645))) int645;
typedef int __attribute__ ((bitwidth(646))) int646;
typedef int __attribute__ ((bitwidth(647))) int647;
typedef int __attribute__ ((bitwidth(648))) int648;
typedef int __attribute__ ((bitwidth(649))) int649;
typedef int __attribute__ ((bitwidth(650))) int650;
typedef int __attribute__ ((bitwidth(651))) int651;
typedef int __attribute__ ((bitwidth(652))) int652;
typedef int __attribute__ ((bitwidth(653))) int653;
typedef int __attribute__ ((bitwidth(654))) int654;
typedef int __attribute__ ((bitwidth(655))) int655;
typedef int __attribute__ ((bitwidth(656))) int656;
typedef int __attribute__ ((bitwidth(657))) int657;
typedef int __attribute__ ((bitwidth(658))) int658;
typedef int __attribute__ ((bitwidth(659))) int659;
typedef int __attribute__ ((bitwidth(660))) int660;
typedef int __attribute__ ((bitwidth(661))) int661;
typedef int __attribute__ ((bitwidth(662))) int662;
typedef int __attribute__ ((bitwidth(663))) int663;
typedef int __attribute__ ((bitwidth(664))) int664;
typedef int __attribute__ ((bitwidth(665))) int665;
typedef int __attribute__ ((bitwidth(666))) int666;
typedef int __attribute__ ((bitwidth(667))) int667;
typedef int __attribute__ ((bitwidth(668))) int668;
typedef int __attribute__ ((bitwidth(669))) int669;
typedef int __attribute__ ((bitwidth(670))) int670;
typedef int __attribute__ ((bitwidth(671))) int671;
typedef int __attribute__ ((bitwidth(672))) int672;
typedef int __attribute__ ((bitwidth(673))) int673;
typedef int __attribute__ ((bitwidth(674))) int674;
typedef int __attribute__ ((bitwidth(675))) int675;
typedef int __attribute__ ((bitwidth(676))) int676;
typedef int __attribute__ ((bitwidth(677))) int677;
typedef int __attribute__ ((bitwidth(678))) int678;
typedef int __attribute__ ((bitwidth(679))) int679;
typedef int __attribute__ ((bitwidth(680))) int680;
typedef int __attribute__ ((bitwidth(681))) int681;
typedef int __attribute__ ((bitwidth(682))) int682;
typedef int __attribute__ ((bitwidth(683))) int683;
typedef int __attribute__ ((bitwidth(684))) int684;
typedef int __attribute__ ((bitwidth(685))) int685;
typedef int __attribute__ ((bitwidth(686))) int686;
typedef int __attribute__ ((bitwidth(687))) int687;
typedef int __attribute__ ((bitwidth(688))) int688;
typedef int __attribute__ ((bitwidth(689))) int689;
typedef int __attribute__ ((bitwidth(690))) int690;
typedef int __attribute__ ((bitwidth(691))) int691;
typedef int __attribute__ ((bitwidth(692))) int692;
typedef int __attribute__ ((bitwidth(693))) int693;
typedef int __attribute__ ((bitwidth(694))) int694;
typedef int __attribute__ ((bitwidth(695))) int695;
typedef int __attribute__ ((bitwidth(696))) int696;
typedef int __attribute__ ((bitwidth(697))) int697;
typedef int __attribute__ ((bitwidth(698))) int698;
typedef int __attribute__ ((bitwidth(699))) int699;
typedef int __attribute__ ((bitwidth(700))) int700;
typedef int __attribute__ ((bitwidth(701))) int701;
typedef int __attribute__ ((bitwidth(702))) int702;
typedef int __attribute__ ((bitwidth(703))) int703;
typedef int __attribute__ ((bitwidth(704))) int704;
typedef int __attribute__ ((bitwidth(705))) int705;
typedef int __attribute__ ((bitwidth(706))) int706;
typedef int __attribute__ ((bitwidth(707))) int707;
typedef int __attribute__ ((bitwidth(708))) int708;
typedef int __attribute__ ((bitwidth(709))) int709;
typedef int __attribute__ ((bitwidth(710))) int710;
typedef int __attribute__ ((bitwidth(711))) int711;
typedef int __attribute__ ((bitwidth(712))) int712;
typedef int __attribute__ ((bitwidth(713))) int713;
typedef int __attribute__ ((bitwidth(714))) int714;
typedef int __attribute__ ((bitwidth(715))) int715;
typedef int __attribute__ ((bitwidth(716))) int716;
typedef int __attribute__ ((bitwidth(717))) int717;
typedef int __attribute__ ((bitwidth(718))) int718;
typedef int __attribute__ ((bitwidth(719))) int719;
typedef int __attribute__ ((bitwidth(720))) int720;
typedef int __attribute__ ((bitwidth(721))) int721;
typedef int __attribute__ ((bitwidth(722))) int722;
typedef int __attribute__ ((bitwidth(723))) int723;
typedef int __attribute__ ((bitwidth(724))) int724;
typedef int __attribute__ ((bitwidth(725))) int725;
typedef int __attribute__ ((bitwidth(726))) int726;
typedef int __attribute__ ((bitwidth(727))) int727;
typedef int __attribute__ ((bitwidth(728))) int728;
typedef int __attribute__ ((bitwidth(729))) int729;
typedef int __attribute__ ((bitwidth(730))) int730;
typedef int __attribute__ ((bitwidth(731))) int731;
typedef int __attribute__ ((bitwidth(732))) int732;
typedef int __attribute__ ((bitwidth(733))) int733;
typedef int __attribute__ ((bitwidth(734))) int734;
typedef int __attribute__ ((bitwidth(735))) int735;
typedef int __attribute__ ((bitwidth(736))) int736;
typedef int __attribute__ ((bitwidth(737))) int737;
typedef int __attribute__ ((bitwidth(738))) int738;
typedef int __attribute__ ((bitwidth(739))) int739;
typedef int __attribute__ ((bitwidth(740))) int740;
typedef int __attribute__ ((bitwidth(741))) int741;
typedef int __attribute__ ((bitwidth(742))) int742;
typedef int __attribute__ ((bitwidth(743))) int743;
typedef int __attribute__ ((bitwidth(744))) int744;
typedef int __attribute__ ((bitwidth(745))) int745;
typedef int __attribute__ ((bitwidth(746))) int746;
typedef int __attribute__ ((bitwidth(747))) int747;
typedef int __attribute__ ((bitwidth(748))) int748;
typedef int __attribute__ ((bitwidth(749))) int749;
typedef int __attribute__ ((bitwidth(750))) int750;
typedef int __attribute__ ((bitwidth(751))) int751;
typedef int __attribute__ ((bitwidth(752))) int752;
typedef int __attribute__ ((bitwidth(753))) int753;
typedef int __attribute__ ((bitwidth(754))) int754;
typedef int __attribute__ ((bitwidth(755))) int755;
typedef int __attribute__ ((bitwidth(756))) int756;
typedef int __attribute__ ((bitwidth(757))) int757;
typedef int __attribute__ ((bitwidth(758))) int758;
typedef int __attribute__ ((bitwidth(759))) int759;
typedef int __attribute__ ((bitwidth(760))) int760;
typedef int __attribute__ ((bitwidth(761))) int761;
typedef int __attribute__ ((bitwidth(762))) int762;
typedef int __attribute__ ((bitwidth(763))) int763;
typedef int __attribute__ ((bitwidth(764))) int764;
typedef int __attribute__ ((bitwidth(765))) int765;
typedef int __attribute__ ((bitwidth(766))) int766;
typedef int __attribute__ ((bitwidth(767))) int767;
typedef int __attribute__ ((bitwidth(768))) int768;
typedef int __attribute__ ((bitwidth(769))) int769;
typedef int __attribute__ ((bitwidth(770))) int770;
typedef int __attribute__ ((bitwidth(771))) int771;
typedef int __attribute__ ((bitwidth(772))) int772;
typedef int __attribute__ ((bitwidth(773))) int773;
typedef int __attribute__ ((bitwidth(774))) int774;
typedef int __attribute__ ((bitwidth(775))) int775;
typedef int __attribute__ ((bitwidth(776))) int776;
typedef int __attribute__ ((bitwidth(777))) int777;
typedef int __attribute__ ((bitwidth(778))) int778;
typedef int __attribute__ ((bitwidth(779))) int779;
typedef int __attribute__ ((bitwidth(780))) int780;
typedef int __attribute__ ((bitwidth(781))) int781;
typedef int __attribute__ ((bitwidth(782))) int782;
typedef int __attribute__ ((bitwidth(783))) int783;
typedef int __attribute__ ((bitwidth(784))) int784;
typedef int __attribute__ ((bitwidth(785))) int785;
typedef int __attribute__ ((bitwidth(786))) int786;
typedef int __attribute__ ((bitwidth(787))) int787;
typedef int __attribute__ ((bitwidth(788))) int788;
typedef int __attribute__ ((bitwidth(789))) int789;
typedef int __attribute__ ((bitwidth(790))) int790;
typedef int __attribute__ ((bitwidth(791))) int791;
typedef int __attribute__ ((bitwidth(792))) int792;
typedef int __attribute__ ((bitwidth(793))) int793;
typedef int __attribute__ ((bitwidth(794))) int794;
typedef int __attribute__ ((bitwidth(795))) int795;
typedef int __attribute__ ((bitwidth(796))) int796;
typedef int __attribute__ ((bitwidth(797))) int797;
typedef int __attribute__ ((bitwidth(798))) int798;
typedef int __attribute__ ((bitwidth(799))) int799;
typedef int __attribute__ ((bitwidth(800))) int800;
typedef int __attribute__ ((bitwidth(801))) int801;
typedef int __attribute__ ((bitwidth(802))) int802;
typedef int __attribute__ ((bitwidth(803))) int803;
typedef int __attribute__ ((bitwidth(804))) int804;
typedef int __attribute__ ((bitwidth(805))) int805;
typedef int __attribute__ ((bitwidth(806))) int806;
typedef int __attribute__ ((bitwidth(807))) int807;
typedef int __attribute__ ((bitwidth(808))) int808;
typedef int __attribute__ ((bitwidth(809))) int809;
typedef int __attribute__ ((bitwidth(810))) int810;
typedef int __attribute__ ((bitwidth(811))) int811;
typedef int __attribute__ ((bitwidth(812))) int812;
typedef int __attribute__ ((bitwidth(813))) int813;
typedef int __attribute__ ((bitwidth(814))) int814;
typedef int __attribute__ ((bitwidth(815))) int815;
typedef int __attribute__ ((bitwidth(816))) int816;
typedef int __attribute__ ((bitwidth(817))) int817;
typedef int __attribute__ ((bitwidth(818))) int818;
typedef int __attribute__ ((bitwidth(819))) int819;
typedef int __attribute__ ((bitwidth(820))) int820;
typedef int __attribute__ ((bitwidth(821))) int821;
typedef int __attribute__ ((bitwidth(822))) int822;
typedef int __attribute__ ((bitwidth(823))) int823;
typedef int __attribute__ ((bitwidth(824))) int824;
typedef int __attribute__ ((bitwidth(825))) int825;
typedef int __attribute__ ((bitwidth(826))) int826;
typedef int __attribute__ ((bitwidth(827))) int827;
typedef int __attribute__ ((bitwidth(828))) int828;
typedef int __attribute__ ((bitwidth(829))) int829;
typedef int __attribute__ ((bitwidth(830))) int830;
typedef int __attribute__ ((bitwidth(831))) int831;
typedef int __attribute__ ((bitwidth(832))) int832;
typedef int __attribute__ ((bitwidth(833))) int833;
typedef int __attribute__ ((bitwidth(834))) int834;
typedef int __attribute__ ((bitwidth(835))) int835;
typedef int __attribute__ ((bitwidth(836))) int836;
typedef int __attribute__ ((bitwidth(837))) int837;
typedef int __attribute__ ((bitwidth(838))) int838;
typedef int __attribute__ ((bitwidth(839))) int839;
typedef int __attribute__ ((bitwidth(840))) int840;
typedef int __attribute__ ((bitwidth(841))) int841;
typedef int __attribute__ ((bitwidth(842))) int842;
typedef int __attribute__ ((bitwidth(843))) int843;
typedef int __attribute__ ((bitwidth(844))) int844;
typedef int __attribute__ ((bitwidth(845))) int845;
typedef int __attribute__ ((bitwidth(846))) int846;
typedef int __attribute__ ((bitwidth(847))) int847;
typedef int __attribute__ ((bitwidth(848))) int848;
typedef int __attribute__ ((bitwidth(849))) int849;
typedef int __attribute__ ((bitwidth(850))) int850;
typedef int __attribute__ ((bitwidth(851))) int851;
typedef int __attribute__ ((bitwidth(852))) int852;
typedef int __attribute__ ((bitwidth(853))) int853;
typedef int __attribute__ ((bitwidth(854))) int854;
typedef int __attribute__ ((bitwidth(855))) int855;
typedef int __attribute__ ((bitwidth(856))) int856;
typedef int __attribute__ ((bitwidth(857))) int857;
typedef int __attribute__ ((bitwidth(858))) int858;
typedef int __attribute__ ((bitwidth(859))) int859;
typedef int __attribute__ ((bitwidth(860))) int860;
typedef int __attribute__ ((bitwidth(861))) int861;
typedef int __attribute__ ((bitwidth(862))) int862;
typedef int __attribute__ ((bitwidth(863))) int863;
typedef int __attribute__ ((bitwidth(864))) int864;
typedef int __attribute__ ((bitwidth(865))) int865;
typedef int __attribute__ ((bitwidth(866))) int866;
typedef int __attribute__ ((bitwidth(867))) int867;
typedef int __attribute__ ((bitwidth(868))) int868;
typedef int __attribute__ ((bitwidth(869))) int869;
typedef int __attribute__ ((bitwidth(870))) int870;
typedef int __attribute__ ((bitwidth(871))) int871;
typedef int __attribute__ ((bitwidth(872))) int872;
typedef int __attribute__ ((bitwidth(873))) int873;
typedef int __attribute__ ((bitwidth(874))) int874;
typedef int __attribute__ ((bitwidth(875))) int875;
typedef int __attribute__ ((bitwidth(876))) int876;
typedef int __attribute__ ((bitwidth(877))) int877;
typedef int __attribute__ ((bitwidth(878))) int878;
typedef int __attribute__ ((bitwidth(879))) int879;
typedef int __attribute__ ((bitwidth(880))) int880;
typedef int __attribute__ ((bitwidth(881))) int881;
typedef int __attribute__ ((bitwidth(882))) int882;
typedef int __attribute__ ((bitwidth(883))) int883;
typedef int __attribute__ ((bitwidth(884))) int884;
typedef int __attribute__ ((bitwidth(885))) int885;
typedef int __attribute__ ((bitwidth(886))) int886;
typedef int __attribute__ ((bitwidth(887))) int887;
typedef int __attribute__ ((bitwidth(888))) int888;
typedef int __attribute__ ((bitwidth(889))) int889;
typedef int __attribute__ ((bitwidth(890))) int890;
typedef int __attribute__ ((bitwidth(891))) int891;
typedef int __attribute__ ((bitwidth(892))) int892;
typedef int __attribute__ ((bitwidth(893))) int893;
typedef int __attribute__ ((bitwidth(894))) int894;
typedef int __attribute__ ((bitwidth(895))) int895;
typedef int __attribute__ ((bitwidth(896))) int896;
typedef int __attribute__ ((bitwidth(897))) int897;
typedef int __attribute__ ((bitwidth(898))) int898;
typedef int __attribute__ ((bitwidth(899))) int899;
typedef int __attribute__ ((bitwidth(900))) int900;
typedef int __attribute__ ((bitwidth(901))) int901;
typedef int __attribute__ ((bitwidth(902))) int902;
typedef int __attribute__ ((bitwidth(903))) int903;
typedef int __attribute__ ((bitwidth(904))) int904;
typedef int __attribute__ ((bitwidth(905))) int905;
typedef int __attribute__ ((bitwidth(906))) int906;
typedef int __attribute__ ((bitwidth(907))) int907;
typedef int __attribute__ ((bitwidth(908))) int908;
typedef int __attribute__ ((bitwidth(909))) int909;
typedef int __attribute__ ((bitwidth(910))) int910;
typedef int __attribute__ ((bitwidth(911))) int911;
typedef int __attribute__ ((bitwidth(912))) int912;
typedef int __attribute__ ((bitwidth(913))) int913;
typedef int __attribute__ ((bitwidth(914))) int914;
typedef int __attribute__ ((bitwidth(915))) int915;
typedef int __attribute__ ((bitwidth(916))) int916;
typedef int __attribute__ ((bitwidth(917))) int917;
typedef int __attribute__ ((bitwidth(918))) int918;
typedef int __attribute__ ((bitwidth(919))) int919;
typedef int __attribute__ ((bitwidth(920))) int920;
typedef int __attribute__ ((bitwidth(921))) int921;
typedef int __attribute__ ((bitwidth(922))) int922;
typedef int __attribute__ ((bitwidth(923))) int923;
typedef int __attribute__ ((bitwidth(924))) int924;
typedef int __attribute__ ((bitwidth(925))) int925;
typedef int __attribute__ ((bitwidth(926))) int926;
typedef int __attribute__ ((bitwidth(927))) int927;
typedef int __attribute__ ((bitwidth(928))) int928;
typedef int __attribute__ ((bitwidth(929))) int929;
typedef int __attribute__ ((bitwidth(930))) int930;
typedef int __attribute__ ((bitwidth(931))) int931;
typedef int __attribute__ ((bitwidth(932))) int932;
typedef int __attribute__ ((bitwidth(933))) int933;
typedef int __attribute__ ((bitwidth(934))) int934;
typedef int __attribute__ ((bitwidth(935))) int935;
typedef int __attribute__ ((bitwidth(936))) int936;
typedef int __attribute__ ((bitwidth(937))) int937;
typedef int __attribute__ ((bitwidth(938))) int938;
typedef int __attribute__ ((bitwidth(939))) int939;
typedef int __attribute__ ((bitwidth(940))) int940;
typedef int __attribute__ ((bitwidth(941))) int941;
typedef int __attribute__ ((bitwidth(942))) int942;
typedef int __attribute__ ((bitwidth(943))) int943;
typedef int __attribute__ ((bitwidth(944))) int944;
typedef int __attribute__ ((bitwidth(945))) int945;
typedef int __attribute__ ((bitwidth(946))) int946;
typedef int __attribute__ ((bitwidth(947))) int947;
typedef int __attribute__ ((bitwidth(948))) int948;
typedef int __attribute__ ((bitwidth(949))) int949;
typedef int __attribute__ ((bitwidth(950))) int950;
typedef int __attribute__ ((bitwidth(951))) int951;
typedef int __attribute__ ((bitwidth(952))) int952;
typedef int __attribute__ ((bitwidth(953))) int953;
typedef int __attribute__ ((bitwidth(954))) int954;
typedef int __attribute__ ((bitwidth(955))) int955;
typedef int __attribute__ ((bitwidth(956))) int956;
typedef int __attribute__ ((bitwidth(957))) int957;
typedef int __attribute__ ((bitwidth(958))) int958;
typedef int __attribute__ ((bitwidth(959))) int959;
typedef int __attribute__ ((bitwidth(960))) int960;
typedef int __attribute__ ((bitwidth(961))) int961;
typedef int __attribute__ ((bitwidth(962))) int962;
typedef int __attribute__ ((bitwidth(963))) int963;
typedef int __attribute__ ((bitwidth(964))) int964;
typedef int __attribute__ ((bitwidth(965))) int965;
typedef int __attribute__ ((bitwidth(966))) int966;
typedef int __attribute__ ((bitwidth(967))) int967;
typedef int __attribute__ ((bitwidth(968))) int968;
typedef int __attribute__ ((bitwidth(969))) int969;
typedef int __attribute__ ((bitwidth(970))) int970;
typedef int __attribute__ ((bitwidth(971))) int971;
typedef int __attribute__ ((bitwidth(972))) int972;
typedef int __attribute__ ((bitwidth(973))) int973;
typedef int __attribute__ ((bitwidth(974))) int974;
typedef int __attribute__ ((bitwidth(975))) int975;
typedef int __attribute__ ((bitwidth(976))) int976;
typedef int __attribute__ ((bitwidth(977))) int977;
typedef int __attribute__ ((bitwidth(978))) int978;
typedef int __attribute__ ((bitwidth(979))) int979;
typedef int __attribute__ ((bitwidth(980))) int980;
typedef int __attribute__ ((bitwidth(981))) int981;
typedef int __attribute__ ((bitwidth(982))) int982;
typedef int __attribute__ ((bitwidth(983))) int983;
typedef int __attribute__ ((bitwidth(984))) int984;
typedef int __attribute__ ((bitwidth(985))) int985;
typedef int __attribute__ ((bitwidth(986))) int986;
typedef int __attribute__ ((bitwidth(987))) int987;
typedef int __attribute__ ((bitwidth(988))) int988;
typedef int __attribute__ ((bitwidth(989))) int989;
typedef int __attribute__ ((bitwidth(990))) int990;
typedef int __attribute__ ((bitwidth(991))) int991;
typedef int __attribute__ ((bitwidth(992))) int992;
typedef int __attribute__ ((bitwidth(993))) int993;
typedef int __attribute__ ((bitwidth(994))) int994;
typedef int __attribute__ ((bitwidth(995))) int995;
typedef int __attribute__ ((bitwidth(996))) int996;
typedef int __attribute__ ((bitwidth(997))) int997;
typedef int __attribute__ ((bitwidth(998))) int998;
typedef int __attribute__ ((bitwidth(999))) int999;
typedef int __attribute__ ((bitwidth(1000))) int1000;
typedef int __attribute__ ((bitwidth(1001))) int1001;
typedef int __attribute__ ((bitwidth(1002))) int1002;
typedef int __attribute__ ((bitwidth(1003))) int1003;
typedef int __attribute__ ((bitwidth(1004))) int1004;
typedef int __attribute__ ((bitwidth(1005))) int1005;
typedef int __attribute__ ((bitwidth(1006))) int1006;
typedef int __attribute__ ((bitwidth(1007))) int1007;
typedef int __attribute__ ((bitwidth(1008))) int1008;
typedef int __attribute__ ((bitwidth(1009))) int1009;
typedef int __attribute__ ((bitwidth(1010))) int1010;
typedef int __attribute__ ((bitwidth(1011))) int1011;
typedef int __attribute__ ((bitwidth(1012))) int1012;
typedef int __attribute__ ((bitwidth(1013))) int1013;
typedef int __attribute__ ((bitwidth(1014))) int1014;
typedef int __attribute__ ((bitwidth(1015))) int1015;
typedef int __attribute__ ((bitwidth(1016))) int1016;
typedef int __attribute__ ((bitwidth(1017))) int1017;
typedef int __attribute__ ((bitwidth(1018))) int1018;
typedef int __attribute__ ((bitwidth(1019))) int1019;
typedef int __attribute__ ((bitwidth(1020))) int1020;
typedef int __attribute__ ((bitwidth(1021))) int1021;
typedef int __attribute__ ((bitwidth(1022))) int1022;
typedef int __attribute__ ((bitwidth(1023))) int1023;
typedef int __attribute__ ((bitwidth(1024))) int1024;
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt_ext.def" 1
#pragma empty_line
#pragma empty_line
typedef int __attribute__ ((bitwidth(1025))) int1025;
typedef int __attribute__ ((bitwidth(1026))) int1026;
typedef int __attribute__ ((bitwidth(1027))) int1027;
typedef int __attribute__ ((bitwidth(1028))) int1028;
typedef int __attribute__ ((bitwidth(1029))) int1029;
typedef int __attribute__ ((bitwidth(1030))) int1030;
typedef int __attribute__ ((bitwidth(1031))) int1031;
typedef int __attribute__ ((bitwidth(1032))) int1032;
typedef int __attribute__ ((bitwidth(1033))) int1033;
typedef int __attribute__ ((bitwidth(1034))) int1034;
typedef int __attribute__ ((bitwidth(1035))) int1035;
typedef int __attribute__ ((bitwidth(1036))) int1036;
typedef int __attribute__ ((bitwidth(1037))) int1037;
typedef int __attribute__ ((bitwidth(1038))) int1038;
typedef int __attribute__ ((bitwidth(1039))) int1039;
typedef int __attribute__ ((bitwidth(1040))) int1040;
typedef int __attribute__ ((bitwidth(1041))) int1041;
typedef int __attribute__ ((bitwidth(1042))) int1042;
typedef int __attribute__ ((bitwidth(1043))) int1043;
typedef int __attribute__ ((bitwidth(1044))) int1044;
typedef int __attribute__ ((bitwidth(1045))) int1045;
typedef int __attribute__ ((bitwidth(1046))) int1046;
typedef int __attribute__ ((bitwidth(1047))) int1047;
typedef int __attribute__ ((bitwidth(1048))) int1048;
typedef int __attribute__ ((bitwidth(1049))) int1049;
typedef int __attribute__ ((bitwidth(1050))) int1050;
typedef int __attribute__ ((bitwidth(1051))) int1051;
typedef int __attribute__ ((bitwidth(1052))) int1052;
typedef int __attribute__ ((bitwidth(1053))) int1053;
typedef int __attribute__ ((bitwidth(1054))) int1054;
typedef int __attribute__ ((bitwidth(1055))) int1055;
typedef int __attribute__ ((bitwidth(1056))) int1056;
typedef int __attribute__ ((bitwidth(1057))) int1057;
typedef int __attribute__ ((bitwidth(1058))) int1058;
typedef int __attribute__ ((bitwidth(1059))) int1059;
typedef int __attribute__ ((bitwidth(1060))) int1060;
typedef int __attribute__ ((bitwidth(1061))) int1061;
typedef int __attribute__ ((bitwidth(1062))) int1062;
typedef int __attribute__ ((bitwidth(1063))) int1063;
typedef int __attribute__ ((bitwidth(1064))) int1064;
typedef int __attribute__ ((bitwidth(1065))) int1065;
typedef int __attribute__ ((bitwidth(1066))) int1066;
typedef int __attribute__ ((bitwidth(1067))) int1067;
typedef int __attribute__ ((bitwidth(1068))) int1068;
typedef int __attribute__ ((bitwidth(1069))) int1069;
typedef int __attribute__ ((bitwidth(1070))) int1070;
typedef int __attribute__ ((bitwidth(1071))) int1071;
typedef int __attribute__ ((bitwidth(1072))) int1072;
typedef int __attribute__ ((bitwidth(1073))) int1073;
typedef int __attribute__ ((bitwidth(1074))) int1074;
typedef int __attribute__ ((bitwidth(1075))) int1075;
typedef int __attribute__ ((bitwidth(1076))) int1076;
typedef int __attribute__ ((bitwidth(1077))) int1077;
typedef int __attribute__ ((bitwidth(1078))) int1078;
typedef int __attribute__ ((bitwidth(1079))) int1079;
typedef int __attribute__ ((bitwidth(1080))) int1080;
typedef int __attribute__ ((bitwidth(1081))) int1081;
typedef int __attribute__ ((bitwidth(1082))) int1082;
typedef int __attribute__ ((bitwidth(1083))) int1083;
typedef int __attribute__ ((bitwidth(1084))) int1084;
typedef int __attribute__ ((bitwidth(1085))) int1085;
typedef int __attribute__ ((bitwidth(1086))) int1086;
typedef int __attribute__ ((bitwidth(1087))) int1087;
typedef int __attribute__ ((bitwidth(1088))) int1088;
typedef int __attribute__ ((bitwidth(1089))) int1089;
typedef int __attribute__ ((bitwidth(1090))) int1090;
typedef int __attribute__ ((bitwidth(1091))) int1091;
typedef int __attribute__ ((bitwidth(1092))) int1092;
typedef int __attribute__ ((bitwidth(1093))) int1093;
typedef int __attribute__ ((bitwidth(1094))) int1094;
typedef int __attribute__ ((bitwidth(1095))) int1095;
typedef int __attribute__ ((bitwidth(1096))) int1096;
typedef int __attribute__ ((bitwidth(1097))) int1097;
typedef int __attribute__ ((bitwidth(1098))) int1098;
typedef int __attribute__ ((bitwidth(1099))) int1099;
typedef int __attribute__ ((bitwidth(1100))) int1100;
typedef int __attribute__ ((bitwidth(1101))) int1101;
typedef int __attribute__ ((bitwidth(1102))) int1102;
typedef int __attribute__ ((bitwidth(1103))) int1103;
typedef int __attribute__ ((bitwidth(1104))) int1104;
typedef int __attribute__ ((bitwidth(1105))) int1105;
typedef int __attribute__ ((bitwidth(1106))) int1106;
typedef int __attribute__ ((bitwidth(1107))) int1107;
typedef int __attribute__ ((bitwidth(1108))) int1108;
typedef int __attribute__ ((bitwidth(1109))) int1109;
typedef int __attribute__ ((bitwidth(1110))) int1110;
typedef int __attribute__ ((bitwidth(1111))) int1111;
typedef int __attribute__ ((bitwidth(1112))) int1112;
typedef int __attribute__ ((bitwidth(1113))) int1113;
typedef int __attribute__ ((bitwidth(1114))) int1114;
typedef int __attribute__ ((bitwidth(1115))) int1115;
typedef int __attribute__ ((bitwidth(1116))) int1116;
typedef int __attribute__ ((bitwidth(1117))) int1117;
typedef int __attribute__ ((bitwidth(1118))) int1118;
typedef int __attribute__ ((bitwidth(1119))) int1119;
typedef int __attribute__ ((bitwidth(1120))) int1120;
typedef int __attribute__ ((bitwidth(1121))) int1121;
typedef int __attribute__ ((bitwidth(1122))) int1122;
typedef int __attribute__ ((bitwidth(1123))) int1123;
typedef int __attribute__ ((bitwidth(1124))) int1124;
typedef int __attribute__ ((bitwidth(1125))) int1125;
typedef int __attribute__ ((bitwidth(1126))) int1126;
typedef int __attribute__ ((bitwidth(1127))) int1127;
typedef int __attribute__ ((bitwidth(1128))) int1128;
typedef int __attribute__ ((bitwidth(1129))) int1129;
typedef int __attribute__ ((bitwidth(1130))) int1130;
typedef int __attribute__ ((bitwidth(1131))) int1131;
typedef int __attribute__ ((bitwidth(1132))) int1132;
typedef int __attribute__ ((bitwidth(1133))) int1133;
typedef int __attribute__ ((bitwidth(1134))) int1134;
typedef int __attribute__ ((bitwidth(1135))) int1135;
typedef int __attribute__ ((bitwidth(1136))) int1136;
typedef int __attribute__ ((bitwidth(1137))) int1137;
typedef int __attribute__ ((bitwidth(1138))) int1138;
typedef int __attribute__ ((bitwidth(1139))) int1139;
typedef int __attribute__ ((bitwidth(1140))) int1140;
typedef int __attribute__ ((bitwidth(1141))) int1141;
typedef int __attribute__ ((bitwidth(1142))) int1142;
typedef int __attribute__ ((bitwidth(1143))) int1143;
typedef int __attribute__ ((bitwidth(1144))) int1144;
typedef int __attribute__ ((bitwidth(1145))) int1145;
typedef int __attribute__ ((bitwidth(1146))) int1146;
typedef int __attribute__ ((bitwidth(1147))) int1147;
typedef int __attribute__ ((bitwidth(1148))) int1148;
typedef int __attribute__ ((bitwidth(1149))) int1149;
typedef int __attribute__ ((bitwidth(1150))) int1150;
typedef int __attribute__ ((bitwidth(1151))) int1151;
typedef int __attribute__ ((bitwidth(1152))) int1152;
typedef int __attribute__ ((bitwidth(1153))) int1153;
typedef int __attribute__ ((bitwidth(1154))) int1154;
typedef int __attribute__ ((bitwidth(1155))) int1155;
typedef int __attribute__ ((bitwidth(1156))) int1156;
typedef int __attribute__ ((bitwidth(1157))) int1157;
typedef int __attribute__ ((bitwidth(1158))) int1158;
typedef int __attribute__ ((bitwidth(1159))) int1159;
typedef int __attribute__ ((bitwidth(1160))) int1160;
typedef int __attribute__ ((bitwidth(1161))) int1161;
typedef int __attribute__ ((bitwidth(1162))) int1162;
typedef int __attribute__ ((bitwidth(1163))) int1163;
typedef int __attribute__ ((bitwidth(1164))) int1164;
typedef int __attribute__ ((bitwidth(1165))) int1165;
typedef int __attribute__ ((bitwidth(1166))) int1166;
typedef int __attribute__ ((bitwidth(1167))) int1167;
typedef int __attribute__ ((bitwidth(1168))) int1168;
typedef int __attribute__ ((bitwidth(1169))) int1169;
typedef int __attribute__ ((bitwidth(1170))) int1170;
typedef int __attribute__ ((bitwidth(1171))) int1171;
typedef int __attribute__ ((bitwidth(1172))) int1172;
typedef int __attribute__ ((bitwidth(1173))) int1173;
typedef int __attribute__ ((bitwidth(1174))) int1174;
typedef int __attribute__ ((bitwidth(1175))) int1175;
typedef int __attribute__ ((bitwidth(1176))) int1176;
typedef int __attribute__ ((bitwidth(1177))) int1177;
typedef int __attribute__ ((bitwidth(1178))) int1178;
typedef int __attribute__ ((bitwidth(1179))) int1179;
typedef int __attribute__ ((bitwidth(1180))) int1180;
typedef int __attribute__ ((bitwidth(1181))) int1181;
typedef int __attribute__ ((bitwidth(1182))) int1182;
typedef int __attribute__ ((bitwidth(1183))) int1183;
typedef int __attribute__ ((bitwidth(1184))) int1184;
typedef int __attribute__ ((bitwidth(1185))) int1185;
typedef int __attribute__ ((bitwidth(1186))) int1186;
typedef int __attribute__ ((bitwidth(1187))) int1187;
typedef int __attribute__ ((bitwidth(1188))) int1188;
typedef int __attribute__ ((bitwidth(1189))) int1189;
typedef int __attribute__ ((bitwidth(1190))) int1190;
typedef int __attribute__ ((bitwidth(1191))) int1191;
typedef int __attribute__ ((bitwidth(1192))) int1192;
typedef int __attribute__ ((bitwidth(1193))) int1193;
typedef int __attribute__ ((bitwidth(1194))) int1194;
typedef int __attribute__ ((bitwidth(1195))) int1195;
typedef int __attribute__ ((bitwidth(1196))) int1196;
typedef int __attribute__ ((bitwidth(1197))) int1197;
typedef int __attribute__ ((bitwidth(1198))) int1198;
typedef int __attribute__ ((bitwidth(1199))) int1199;
typedef int __attribute__ ((bitwidth(1200))) int1200;
typedef int __attribute__ ((bitwidth(1201))) int1201;
typedef int __attribute__ ((bitwidth(1202))) int1202;
typedef int __attribute__ ((bitwidth(1203))) int1203;
typedef int __attribute__ ((bitwidth(1204))) int1204;
typedef int __attribute__ ((bitwidth(1205))) int1205;
typedef int __attribute__ ((bitwidth(1206))) int1206;
typedef int __attribute__ ((bitwidth(1207))) int1207;
typedef int __attribute__ ((bitwidth(1208))) int1208;
typedef int __attribute__ ((bitwidth(1209))) int1209;
typedef int __attribute__ ((bitwidth(1210))) int1210;
typedef int __attribute__ ((bitwidth(1211))) int1211;
typedef int __attribute__ ((bitwidth(1212))) int1212;
typedef int __attribute__ ((bitwidth(1213))) int1213;
typedef int __attribute__ ((bitwidth(1214))) int1214;
typedef int __attribute__ ((bitwidth(1215))) int1215;
typedef int __attribute__ ((bitwidth(1216))) int1216;
typedef int __attribute__ ((bitwidth(1217))) int1217;
typedef int __attribute__ ((bitwidth(1218))) int1218;
typedef int __attribute__ ((bitwidth(1219))) int1219;
typedef int __attribute__ ((bitwidth(1220))) int1220;
typedef int __attribute__ ((bitwidth(1221))) int1221;
typedef int __attribute__ ((bitwidth(1222))) int1222;
typedef int __attribute__ ((bitwidth(1223))) int1223;
typedef int __attribute__ ((bitwidth(1224))) int1224;
typedef int __attribute__ ((bitwidth(1225))) int1225;
typedef int __attribute__ ((bitwidth(1226))) int1226;
typedef int __attribute__ ((bitwidth(1227))) int1227;
typedef int __attribute__ ((bitwidth(1228))) int1228;
typedef int __attribute__ ((bitwidth(1229))) int1229;
typedef int __attribute__ ((bitwidth(1230))) int1230;
typedef int __attribute__ ((bitwidth(1231))) int1231;
typedef int __attribute__ ((bitwidth(1232))) int1232;
typedef int __attribute__ ((bitwidth(1233))) int1233;
typedef int __attribute__ ((bitwidth(1234))) int1234;
typedef int __attribute__ ((bitwidth(1235))) int1235;
typedef int __attribute__ ((bitwidth(1236))) int1236;
typedef int __attribute__ ((bitwidth(1237))) int1237;
typedef int __attribute__ ((bitwidth(1238))) int1238;
typedef int __attribute__ ((bitwidth(1239))) int1239;
typedef int __attribute__ ((bitwidth(1240))) int1240;
typedef int __attribute__ ((bitwidth(1241))) int1241;
typedef int __attribute__ ((bitwidth(1242))) int1242;
typedef int __attribute__ ((bitwidth(1243))) int1243;
typedef int __attribute__ ((bitwidth(1244))) int1244;
typedef int __attribute__ ((bitwidth(1245))) int1245;
typedef int __attribute__ ((bitwidth(1246))) int1246;
typedef int __attribute__ ((bitwidth(1247))) int1247;
typedef int __attribute__ ((bitwidth(1248))) int1248;
typedef int __attribute__ ((bitwidth(1249))) int1249;
typedef int __attribute__ ((bitwidth(1250))) int1250;
typedef int __attribute__ ((bitwidth(1251))) int1251;
typedef int __attribute__ ((bitwidth(1252))) int1252;
typedef int __attribute__ ((bitwidth(1253))) int1253;
typedef int __attribute__ ((bitwidth(1254))) int1254;
typedef int __attribute__ ((bitwidth(1255))) int1255;
typedef int __attribute__ ((bitwidth(1256))) int1256;
typedef int __attribute__ ((bitwidth(1257))) int1257;
typedef int __attribute__ ((bitwidth(1258))) int1258;
typedef int __attribute__ ((bitwidth(1259))) int1259;
typedef int __attribute__ ((bitwidth(1260))) int1260;
typedef int __attribute__ ((bitwidth(1261))) int1261;
typedef int __attribute__ ((bitwidth(1262))) int1262;
typedef int __attribute__ ((bitwidth(1263))) int1263;
typedef int __attribute__ ((bitwidth(1264))) int1264;
typedef int __attribute__ ((bitwidth(1265))) int1265;
typedef int __attribute__ ((bitwidth(1266))) int1266;
typedef int __attribute__ ((bitwidth(1267))) int1267;
typedef int __attribute__ ((bitwidth(1268))) int1268;
typedef int __attribute__ ((bitwidth(1269))) int1269;
typedef int __attribute__ ((bitwidth(1270))) int1270;
typedef int __attribute__ ((bitwidth(1271))) int1271;
typedef int __attribute__ ((bitwidth(1272))) int1272;
typedef int __attribute__ ((bitwidth(1273))) int1273;
typedef int __attribute__ ((bitwidth(1274))) int1274;
typedef int __attribute__ ((bitwidth(1275))) int1275;
typedef int __attribute__ ((bitwidth(1276))) int1276;
typedef int __attribute__ ((bitwidth(1277))) int1277;
typedef int __attribute__ ((bitwidth(1278))) int1278;
typedef int __attribute__ ((bitwidth(1279))) int1279;
typedef int __attribute__ ((bitwidth(1280))) int1280;
typedef int __attribute__ ((bitwidth(1281))) int1281;
typedef int __attribute__ ((bitwidth(1282))) int1282;
typedef int __attribute__ ((bitwidth(1283))) int1283;
typedef int __attribute__ ((bitwidth(1284))) int1284;
typedef int __attribute__ ((bitwidth(1285))) int1285;
typedef int __attribute__ ((bitwidth(1286))) int1286;
typedef int __attribute__ ((bitwidth(1287))) int1287;
typedef int __attribute__ ((bitwidth(1288))) int1288;
typedef int __attribute__ ((bitwidth(1289))) int1289;
typedef int __attribute__ ((bitwidth(1290))) int1290;
typedef int __attribute__ ((bitwidth(1291))) int1291;
typedef int __attribute__ ((bitwidth(1292))) int1292;
typedef int __attribute__ ((bitwidth(1293))) int1293;
typedef int __attribute__ ((bitwidth(1294))) int1294;
typedef int __attribute__ ((bitwidth(1295))) int1295;
typedef int __attribute__ ((bitwidth(1296))) int1296;
typedef int __attribute__ ((bitwidth(1297))) int1297;
typedef int __attribute__ ((bitwidth(1298))) int1298;
typedef int __attribute__ ((bitwidth(1299))) int1299;
typedef int __attribute__ ((bitwidth(1300))) int1300;
typedef int __attribute__ ((bitwidth(1301))) int1301;
typedef int __attribute__ ((bitwidth(1302))) int1302;
typedef int __attribute__ ((bitwidth(1303))) int1303;
typedef int __attribute__ ((bitwidth(1304))) int1304;
typedef int __attribute__ ((bitwidth(1305))) int1305;
typedef int __attribute__ ((bitwidth(1306))) int1306;
typedef int __attribute__ ((bitwidth(1307))) int1307;
typedef int __attribute__ ((bitwidth(1308))) int1308;
typedef int __attribute__ ((bitwidth(1309))) int1309;
typedef int __attribute__ ((bitwidth(1310))) int1310;
typedef int __attribute__ ((bitwidth(1311))) int1311;
typedef int __attribute__ ((bitwidth(1312))) int1312;
typedef int __attribute__ ((bitwidth(1313))) int1313;
typedef int __attribute__ ((bitwidth(1314))) int1314;
typedef int __attribute__ ((bitwidth(1315))) int1315;
typedef int __attribute__ ((bitwidth(1316))) int1316;
typedef int __attribute__ ((bitwidth(1317))) int1317;
typedef int __attribute__ ((bitwidth(1318))) int1318;
typedef int __attribute__ ((bitwidth(1319))) int1319;
typedef int __attribute__ ((bitwidth(1320))) int1320;
typedef int __attribute__ ((bitwidth(1321))) int1321;
typedef int __attribute__ ((bitwidth(1322))) int1322;
typedef int __attribute__ ((bitwidth(1323))) int1323;
typedef int __attribute__ ((bitwidth(1324))) int1324;
typedef int __attribute__ ((bitwidth(1325))) int1325;
typedef int __attribute__ ((bitwidth(1326))) int1326;
typedef int __attribute__ ((bitwidth(1327))) int1327;
typedef int __attribute__ ((bitwidth(1328))) int1328;
typedef int __attribute__ ((bitwidth(1329))) int1329;
typedef int __attribute__ ((bitwidth(1330))) int1330;
typedef int __attribute__ ((bitwidth(1331))) int1331;
typedef int __attribute__ ((bitwidth(1332))) int1332;
typedef int __attribute__ ((bitwidth(1333))) int1333;
typedef int __attribute__ ((bitwidth(1334))) int1334;
typedef int __attribute__ ((bitwidth(1335))) int1335;
typedef int __attribute__ ((bitwidth(1336))) int1336;
typedef int __attribute__ ((bitwidth(1337))) int1337;
typedef int __attribute__ ((bitwidth(1338))) int1338;
typedef int __attribute__ ((bitwidth(1339))) int1339;
typedef int __attribute__ ((bitwidth(1340))) int1340;
typedef int __attribute__ ((bitwidth(1341))) int1341;
typedef int __attribute__ ((bitwidth(1342))) int1342;
typedef int __attribute__ ((bitwidth(1343))) int1343;
typedef int __attribute__ ((bitwidth(1344))) int1344;
typedef int __attribute__ ((bitwidth(1345))) int1345;
typedef int __attribute__ ((bitwidth(1346))) int1346;
typedef int __attribute__ ((bitwidth(1347))) int1347;
typedef int __attribute__ ((bitwidth(1348))) int1348;
typedef int __attribute__ ((bitwidth(1349))) int1349;
typedef int __attribute__ ((bitwidth(1350))) int1350;
typedef int __attribute__ ((bitwidth(1351))) int1351;
typedef int __attribute__ ((bitwidth(1352))) int1352;
typedef int __attribute__ ((bitwidth(1353))) int1353;
typedef int __attribute__ ((bitwidth(1354))) int1354;
typedef int __attribute__ ((bitwidth(1355))) int1355;
typedef int __attribute__ ((bitwidth(1356))) int1356;
typedef int __attribute__ ((bitwidth(1357))) int1357;
typedef int __attribute__ ((bitwidth(1358))) int1358;
typedef int __attribute__ ((bitwidth(1359))) int1359;
typedef int __attribute__ ((bitwidth(1360))) int1360;
typedef int __attribute__ ((bitwidth(1361))) int1361;
typedef int __attribute__ ((bitwidth(1362))) int1362;
typedef int __attribute__ ((bitwidth(1363))) int1363;
typedef int __attribute__ ((bitwidth(1364))) int1364;
typedef int __attribute__ ((bitwidth(1365))) int1365;
typedef int __attribute__ ((bitwidth(1366))) int1366;
typedef int __attribute__ ((bitwidth(1367))) int1367;
typedef int __attribute__ ((bitwidth(1368))) int1368;
typedef int __attribute__ ((bitwidth(1369))) int1369;
typedef int __attribute__ ((bitwidth(1370))) int1370;
typedef int __attribute__ ((bitwidth(1371))) int1371;
typedef int __attribute__ ((bitwidth(1372))) int1372;
typedef int __attribute__ ((bitwidth(1373))) int1373;
typedef int __attribute__ ((bitwidth(1374))) int1374;
typedef int __attribute__ ((bitwidth(1375))) int1375;
typedef int __attribute__ ((bitwidth(1376))) int1376;
typedef int __attribute__ ((bitwidth(1377))) int1377;
typedef int __attribute__ ((bitwidth(1378))) int1378;
typedef int __attribute__ ((bitwidth(1379))) int1379;
typedef int __attribute__ ((bitwidth(1380))) int1380;
typedef int __attribute__ ((bitwidth(1381))) int1381;
typedef int __attribute__ ((bitwidth(1382))) int1382;
typedef int __attribute__ ((bitwidth(1383))) int1383;
typedef int __attribute__ ((bitwidth(1384))) int1384;
typedef int __attribute__ ((bitwidth(1385))) int1385;
typedef int __attribute__ ((bitwidth(1386))) int1386;
typedef int __attribute__ ((bitwidth(1387))) int1387;
typedef int __attribute__ ((bitwidth(1388))) int1388;
typedef int __attribute__ ((bitwidth(1389))) int1389;
typedef int __attribute__ ((bitwidth(1390))) int1390;
typedef int __attribute__ ((bitwidth(1391))) int1391;
typedef int __attribute__ ((bitwidth(1392))) int1392;
typedef int __attribute__ ((bitwidth(1393))) int1393;
typedef int __attribute__ ((bitwidth(1394))) int1394;
typedef int __attribute__ ((bitwidth(1395))) int1395;
typedef int __attribute__ ((bitwidth(1396))) int1396;
typedef int __attribute__ ((bitwidth(1397))) int1397;
typedef int __attribute__ ((bitwidth(1398))) int1398;
typedef int __attribute__ ((bitwidth(1399))) int1399;
typedef int __attribute__ ((bitwidth(1400))) int1400;
typedef int __attribute__ ((bitwidth(1401))) int1401;
typedef int __attribute__ ((bitwidth(1402))) int1402;
typedef int __attribute__ ((bitwidth(1403))) int1403;
typedef int __attribute__ ((bitwidth(1404))) int1404;
typedef int __attribute__ ((bitwidth(1405))) int1405;
typedef int __attribute__ ((bitwidth(1406))) int1406;
typedef int __attribute__ ((bitwidth(1407))) int1407;
typedef int __attribute__ ((bitwidth(1408))) int1408;
typedef int __attribute__ ((bitwidth(1409))) int1409;
typedef int __attribute__ ((bitwidth(1410))) int1410;
typedef int __attribute__ ((bitwidth(1411))) int1411;
typedef int __attribute__ ((bitwidth(1412))) int1412;
typedef int __attribute__ ((bitwidth(1413))) int1413;
typedef int __attribute__ ((bitwidth(1414))) int1414;
typedef int __attribute__ ((bitwidth(1415))) int1415;
typedef int __attribute__ ((bitwidth(1416))) int1416;
typedef int __attribute__ ((bitwidth(1417))) int1417;
typedef int __attribute__ ((bitwidth(1418))) int1418;
typedef int __attribute__ ((bitwidth(1419))) int1419;
typedef int __attribute__ ((bitwidth(1420))) int1420;
typedef int __attribute__ ((bitwidth(1421))) int1421;
typedef int __attribute__ ((bitwidth(1422))) int1422;
typedef int __attribute__ ((bitwidth(1423))) int1423;
typedef int __attribute__ ((bitwidth(1424))) int1424;
typedef int __attribute__ ((bitwidth(1425))) int1425;
typedef int __attribute__ ((bitwidth(1426))) int1426;
typedef int __attribute__ ((bitwidth(1427))) int1427;
typedef int __attribute__ ((bitwidth(1428))) int1428;
typedef int __attribute__ ((bitwidth(1429))) int1429;
typedef int __attribute__ ((bitwidth(1430))) int1430;
typedef int __attribute__ ((bitwidth(1431))) int1431;
typedef int __attribute__ ((bitwidth(1432))) int1432;
typedef int __attribute__ ((bitwidth(1433))) int1433;
typedef int __attribute__ ((bitwidth(1434))) int1434;
typedef int __attribute__ ((bitwidth(1435))) int1435;
typedef int __attribute__ ((bitwidth(1436))) int1436;
typedef int __attribute__ ((bitwidth(1437))) int1437;
typedef int __attribute__ ((bitwidth(1438))) int1438;
typedef int __attribute__ ((bitwidth(1439))) int1439;
typedef int __attribute__ ((bitwidth(1440))) int1440;
typedef int __attribute__ ((bitwidth(1441))) int1441;
typedef int __attribute__ ((bitwidth(1442))) int1442;
typedef int __attribute__ ((bitwidth(1443))) int1443;
typedef int __attribute__ ((bitwidth(1444))) int1444;
typedef int __attribute__ ((bitwidth(1445))) int1445;
typedef int __attribute__ ((bitwidth(1446))) int1446;
typedef int __attribute__ ((bitwidth(1447))) int1447;
typedef int __attribute__ ((bitwidth(1448))) int1448;
typedef int __attribute__ ((bitwidth(1449))) int1449;
typedef int __attribute__ ((bitwidth(1450))) int1450;
typedef int __attribute__ ((bitwidth(1451))) int1451;
typedef int __attribute__ ((bitwidth(1452))) int1452;
typedef int __attribute__ ((bitwidth(1453))) int1453;
typedef int __attribute__ ((bitwidth(1454))) int1454;
typedef int __attribute__ ((bitwidth(1455))) int1455;
typedef int __attribute__ ((bitwidth(1456))) int1456;
typedef int __attribute__ ((bitwidth(1457))) int1457;
typedef int __attribute__ ((bitwidth(1458))) int1458;
typedef int __attribute__ ((bitwidth(1459))) int1459;
typedef int __attribute__ ((bitwidth(1460))) int1460;
typedef int __attribute__ ((bitwidth(1461))) int1461;
typedef int __attribute__ ((bitwidth(1462))) int1462;
typedef int __attribute__ ((bitwidth(1463))) int1463;
typedef int __attribute__ ((bitwidth(1464))) int1464;
typedef int __attribute__ ((bitwidth(1465))) int1465;
typedef int __attribute__ ((bitwidth(1466))) int1466;
typedef int __attribute__ ((bitwidth(1467))) int1467;
typedef int __attribute__ ((bitwidth(1468))) int1468;
typedef int __attribute__ ((bitwidth(1469))) int1469;
typedef int __attribute__ ((bitwidth(1470))) int1470;
typedef int __attribute__ ((bitwidth(1471))) int1471;
typedef int __attribute__ ((bitwidth(1472))) int1472;
typedef int __attribute__ ((bitwidth(1473))) int1473;
typedef int __attribute__ ((bitwidth(1474))) int1474;
typedef int __attribute__ ((bitwidth(1475))) int1475;
typedef int __attribute__ ((bitwidth(1476))) int1476;
typedef int __attribute__ ((bitwidth(1477))) int1477;
typedef int __attribute__ ((bitwidth(1478))) int1478;
typedef int __attribute__ ((bitwidth(1479))) int1479;
typedef int __attribute__ ((bitwidth(1480))) int1480;
typedef int __attribute__ ((bitwidth(1481))) int1481;
typedef int __attribute__ ((bitwidth(1482))) int1482;
typedef int __attribute__ ((bitwidth(1483))) int1483;
typedef int __attribute__ ((bitwidth(1484))) int1484;
typedef int __attribute__ ((bitwidth(1485))) int1485;
typedef int __attribute__ ((bitwidth(1486))) int1486;
typedef int __attribute__ ((bitwidth(1487))) int1487;
typedef int __attribute__ ((bitwidth(1488))) int1488;
typedef int __attribute__ ((bitwidth(1489))) int1489;
typedef int __attribute__ ((bitwidth(1490))) int1490;
typedef int __attribute__ ((bitwidth(1491))) int1491;
typedef int __attribute__ ((bitwidth(1492))) int1492;
typedef int __attribute__ ((bitwidth(1493))) int1493;
typedef int __attribute__ ((bitwidth(1494))) int1494;
typedef int __attribute__ ((bitwidth(1495))) int1495;
typedef int __attribute__ ((bitwidth(1496))) int1496;
typedef int __attribute__ ((bitwidth(1497))) int1497;
typedef int __attribute__ ((bitwidth(1498))) int1498;
typedef int __attribute__ ((bitwidth(1499))) int1499;
typedef int __attribute__ ((bitwidth(1500))) int1500;
typedef int __attribute__ ((bitwidth(1501))) int1501;
typedef int __attribute__ ((bitwidth(1502))) int1502;
typedef int __attribute__ ((bitwidth(1503))) int1503;
typedef int __attribute__ ((bitwidth(1504))) int1504;
typedef int __attribute__ ((bitwidth(1505))) int1505;
typedef int __attribute__ ((bitwidth(1506))) int1506;
typedef int __attribute__ ((bitwidth(1507))) int1507;
typedef int __attribute__ ((bitwidth(1508))) int1508;
typedef int __attribute__ ((bitwidth(1509))) int1509;
typedef int __attribute__ ((bitwidth(1510))) int1510;
typedef int __attribute__ ((bitwidth(1511))) int1511;
typedef int __attribute__ ((bitwidth(1512))) int1512;
typedef int __attribute__ ((bitwidth(1513))) int1513;
typedef int __attribute__ ((bitwidth(1514))) int1514;
typedef int __attribute__ ((bitwidth(1515))) int1515;
typedef int __attribute__ ((bitwidth(1516))) int1516;
typedef int __attribute__ ((bitwidth(1517))) int1517;
typedef int __attribute__ ((bitwidth(1518))) int1518;
typedef int __attribute__ ((bitwidth(1519))) int1519;
typedef int __attribute__ ((bitwidth(1520))) int1520;
typedef int __attribute__ ((bitwidth(1521))) int1521;
typedef int __attribute__ ((bitwidth(1522))) int1522;
typedef int __attribute__ ((bitwidth(1523))) int1523;
typedef int __attribute__ ((bitwidth(1524))) int1524;
typedef int __attribute__ ((bitwidth(1525))) int1525;
typedef int __attribute__ ((bitwidth(1526))) int1526;
typedef int __attribute__ ((bitwidth(1527))) int1527;
typedef int __attribute__ ((bitwidth(1528))) int1528;
typedef int __attribute__ ((bitwidth(1529))) int1529;
typedef int __attribute__ ((bitwidth(1530))) int1530;
typedef int __attribute__ ((bitwidth(1531))) int1531;
typedef int __attribute__ ((bitwidth(1532))) int1532;
typedef int __attribute__ ((bitwidth(1533))) int1533;
typedef int __attribute__ ((bitwidth(1534))) int1534;
typedef int __attribute__ ((bitwidth(1535))) int1535;
typedef int __attribute__ ((bitwidth(1536))) int1536;
typedef int __attribute__ ((bitwidth(1537))) int1537;
typedef int __attribute__ ((bitwidth(1538))) int1538;
typedef int __attribute__ ((bitwidth(1539))) int1539;
typedef int __attribute__ ((bitwidth(1540))) int1540;
typedef int __attribute__ ((bitwidth(1541))) int1541;
typedef int __attribute__ ((bitwidth(1542))) int1542;
typedef int __attribute__ ((bitwidth(1543))) int1543;
typedef int __attribute__ ((bitwidth(1544))) int1544;
typedef int __attribute__ ((bitwidth(1545))) int1545;
typedef int __attribute__ ((bitwidth(1546))) int1546;
typedef int __attribute__ ((bitwidth(1547))) int1547;
typedef int __attribute__ ((bitwidth(1548))) int1548;
typedef int __attribute__ ((bitwidth(1549))) int1549;
typedef int __attribute__ ((bitwidth(1550))) int1550;
typedef int __attribute__ ((bitwidth(1551))) int1551;
typedef int __attribute__ ((bitwidth(1552))) int1552;
typedef int __attribute__ ((bitwidth(1553))) int1553;
typedef int __attribute__ ((bitwidth(1554))) int1554;
typedef int __attribute__ ((bitwidth(1555))) int1555;
typedef int __attribute__ ((bitwidth(1556))) int1556;
typedef int __attribute__ ((bitwidth(1557))) int1557;
typedef int __attribute__ ((bitwidth(1558))) int1558;
typedef int __attribute__ ((bitwidth(1559))) int1559;
typedef int __attribute__ ((bitwidth(1560))) int1560;
typedef int __attribute__ ((bitwidth(1561))) int1561;
typedef int __attribute__ ((bitwidth(1562))) int1562;
typedef int __attribute__ ((bitwidth(1563))) int1563;
typedef int __attribute__ ((bitwidth(1564))) int1564;
typedef int __attribute__ ((bitwidth(1565))) int1565;
typedef int __attribute__ ((bitwidth(1566))) int1566;
typedef int __attribute__ ((bitwidth(1567))) int1567;
typedef int __attribute__ ((bitwidth(1568))) int1568;
typedef int __attribute__ ((bitwidth(1569))) int1569;
typedef int __attribute__ ((bitwidth(1570))) int1570;
typedef int __attribute__ ((bitwidth(1571))) int1571;
typedef int __attribute__ ((bitwidth(1572))) int1572;
typedef int __attribute__ ((bitwidth(1573))) int1573;
typedef int __attribute__ ((bitwidth(1574))) int1574;
typedef int __attribute__ ((bitwidth(1575))) int1575;
typedef int __attribute__ ((bitwidth(1576))) int1576;
typedef int __attribute__ ((bitwidth(1577))) int1577;
typedef int __attribute__ ((bitwidth(1578))) int1578;
typedef int __attribute__ ((bitwidth(1579))) int1579;
typedef int __attribute__ ((bitwidth(1580))) int1580;
typedef int __attribute__ ((bitwidth(1581))) int1581;
typedef int __attribute__ ((bitwidth(1582))) int1582;
typedef int __attribute__ ((bitwidth(1583))) int1583;
typedef int __attribute__ ((bitwidth(1584))) int1584;
typedef int __attribute__ ((bitwidth(1585))) int1585;
typedef int __attribute__ ((bitwidth(1586))) int1586;
typedef int __attribute__ ((bitwidth(1587))) int1587;
typedef int __attribute__ ((bitwidth(1588))) int1588;
typedef int __attribute__ ((bitwidth(1589))) int1589;
typedef int __attribute__ ((bitwidth(1590))) int1590;
typedef int __attribute__ ((bitwidth(1591))) int1591;
typedef int __attribute__ ((bitwidth(1592))) int1592;
typedef int __attribute__ ((bitwidth(1593))) int1593;
typedef int __attribute__ ((bitwidth(1594))) int1594;
typedef int __attribute__ ((bitwidth(1595))) int1595;
typedef int __attribute__ ((bitwidth(1596))) int1596;
typedef int __attribute__ ((bitwidth(1597))) int1597;
typedef int __attribute__ ((bitwidth(1598))) int1598;
typedef int __attribute__ ((bitwidth(1599))) int1599;
typedef int __attribute__ ((bitwidth(1600))) int1600;
typedef int __attribute__ ((bitwidth(1601))) int1601;
typedef int __attribute__ ((bitwidth(1602))) int1602;
typedef int __attribute__ ((bitwidth(1603))) int1603;
typedef int __attribute__ ((bitwidth(1604))) int1604;
typedef int __attribute__ ((bitwidth(1605))) int1605;
typedef int __attribute__ ((bitwidth(1606))) int1606;
typedef int __attribute__ ((bitwidth(1607))) int1607;
typedef int __attribute__ ((bitwidth(1608))) int1608;
typedef int __attribute__ ((bitwidth(1609))) int1609;
typedef int __attribute__ ((bitwidth(1610))) int1610;
typedef int __attribute__ ((bitwidth(1611))) int1611;
typedef int __attribute__ ((bitwidth(1612))) int1612;
typedef int __attribute__ ((bitwidth(1613))) int1613;
typedef int __attribute__ ((bitwidth(1614))) int1614;
typedef int __attribute__ ((bitwidth(1615))) int1615;
typedef int __attribute__ ((bitwidth(1616))) int1616;
typedef int __attribute__ ((bitwidth(1617))) int1617;
typedef int __attribute__ ((bitwidth(1618))) int1618;
typedef int __attribute__ ((bitwidth(1619))) int1619;
typedef int __attribute__ ((bitwidth(1620))) int1620;
typedef int __attribute__ ((bitwidth(1621))) int1621;
typedef int __attribute__ ((bitwidth(1622))) int1622;
typedef int __attribute__ ((bitwidth(1623))) int1623;
typedef int __attribute__ ((bitwidth(1624))) int1624;
typedef int __attribute__ ((bitwidth(1625))) int1625;
typedef int __attribute__ ((bitwidth(1626))) int1626;
typedef int __attribute__ ((bitwidth(1627))) int1627;
typedef int __attribute__ ((bitwidth(1628))) int1628;
typedef int __attribute__ ((bitwidth(1629))) int1629;
typedef int __attribute__ ((bitwidth(1630))) int1630;
typedef int __attribute__ ((bitwidth(1631))) int1631;
typedef int __attribute__ ((bitwidth(1632))) int1632;
typedef int __attribute__ ((bitwidth(1633))) int1633;
typedef int __attribute__ ((bitwidth(1634))) int1634;
typedef int __attribute__ ((bitwidth(1635))) int1635;
typedef int __attribute__ ((bitwidth(1636))) int1636;
typedef int __attribute__ ((bitwidth(1637))) int1637;
typedef int __attribute__ ((bitwidth(1638))) int1638;
typedef int __attribute__ ((bitwidth(1639))) int1639;
typedef int __attribute__ ((bitwidth(1640))) int1640;
typedef int __attribute__ ((bitwidth(1641))) int1641;
typedef int __attribute__ ((bitwidth(1642))) int1642;
typedef int __attribute__ ((bitwidth(1643))) int1643;
typedef int __attribute__ ((bitwidth(1644))) int1644;
typedef int __attribute__ ((bitwidth(1645))) int1645;
typedef int __attribute__ ((bitwidth(1646))) int1646;
typedef int __attribute__ ((bitwidth(1647))) int1647;
typedef int __attribute__ ((bitwidth(1648))) int1648;
typedef int __attribute__ ((bitwidth(1649))) int1649;
typedef int __attribute__ ((bitwidth(1650))) int1650;
typedef int __attribute__ ((bitwidth(1651))) int1651;
typedef int __attribute__ ((bitwidth(1652))) int1652;
typedef int __attribute__ ((bitwidth(1653))) int1653;
typedef int __attribute__ ((bitwidth(1654))) int1654;
typedef int __attribute__ ((bitwidth(1655))) int1655;
typedef int __attribute__ ((bitwidth(1656))) int1656;
typedef int __attribute__ ((bitwidth(1657))) int1657;
typedef int __attribute__ ((bitwidth(1658))) int1658;
typedef int __attribute__ ((bitwidth(1659))) int1659;
typedef int __attribute__ ((bitwidth(1660))) int1660;
typedef int __attribute__ ((bitwidth(1661))) int1661;
typedef int __attribute__ ((bitwidth(1662))) int1662;
typedef int __attribute__ ((bitwidth(1663))) int1663;
typedef int __attribute__ ((bitwidth(1664))) int1664;
typedef int __attribute__ ((bitwidth(1665))) int1665;
typedef int __attribute__ ((bitwidth(1666))) int1666;
typedef int __attribute__ ((bitwidth(1667))) int1667;
typedef int __attribute__ ((bitwidth(1668))) int1668;
typedef int __attribute__ ((bitwidth(1669))) int1669;
typedef int __attribute__ ((bitwidth(1670))) int1670;
typedef int __attribute__ ((bitwidth(1671))) int1671;
typedef int __attribute__ ((bitwidth(1672))) int1672;
typedef int __attribute__ ((bitwidth(1673))) int1673;
typedef int __attribute__ ((bitwidth(1674))) int1674;
typedef int __attribute__ ((bitwidth(1675))) int1675;
typedef int __attribute__ ((bitwidth(1676))) int1676;
typedef int __attribute__ ((bitwidth(1677))) int1677;
typedef int __attribute__ ((bitwidth(1678))) int1678;
typedef int __attribute__ ((bitwidth(1679))) int1679;
typedef int __attribute__ ((bitwidth(1680))) int1680;
typedef int __attribute__ ((bitwidth(1681))) int1681;
typedef int __attribute__ ((bitwidth(1682))) int1682;
typedef int __attribute__ ((bitwidth(1683))) int1683;
typedef int __attribute__ ((bitwidth(1684))) int1684;
typedef int __attribute__ ((bitwidth(1685))) int1685;
typedef int __attribute__ ((bitwidth(1686))) int1686;
typedef int __attribute__ ((bitwidth(1687))) int1687;
typedef int __attribute__ ((bitwidth(1688))) int1688;
typedef int __attribute__ ((bitwidth(1689))) int1689;
typedef int __attribute__ ((bitwidth(1690))) int1690;
typedef int __attribute__ ((bitwidth(1691))) int1691;
typedef int __attribute__ ((bitwidth(1692))) int1692;
typedef int __attribute__ ((bitwidth(1693))) int1693;
typedef int __attribute__ ((bitwidth(1694))) int1694;
typedef int __attribute__ ((bitwidth(1695))) int1695;
typedef int __attribute__ ((bitwidth(1696))) int1696;
typedef int __attribute__ ((bitwidth(1697))) int1697;
typedef int __attribute__ ((bitwidth(1698))) int1698;
typedef int __attribute__ ((bitwidth(1699))) int1699;
typedef int __attribute__ ((bitwidth(1700))) int1700;
typedef int __attribute__ ((bitwidth(1701))) int1701;
typedef int __attribute__ ((bitwidth(1702))) int1702;
typedef int __attribute__ ((bitwidth(1703))) int1703;
typedef int __attribute__ ((bitwidth(1704))) int1704;
typedef int __attribute__ ((bitwidth(1705))) int1705;
typedef int __attribute__ ((bitwidth(1706))) int1706;
typedef int __attribute__ ((bitwidth(1707))) int1707;
typedef int __attribute__ ((bitwidth(1708))) int1708;
typedef int __attribute__ ((bitwidth(1709))) int1709;
typedef int __attribute__ ((bitwidth(1710))) int1710;
typedef int __attribute__ ((bitwidth(1711))) int1711;
typedef int __attribute__ ((bitwidth(1712))) int1712;
typedef int __attribute__ ((bitwidth(1713))) int1713;
typedef int __attribute__ ((bitwidth(1714))) int1714;
typedef int __attribute__ ((bitwidth(1715))) int1715;
typedef int __attribute__ ((bitwidth(1716))) int1716;
typedef int __attribute__ ((bitwidth(1717))) int1717;
typedef int __attribute__ ((bitwidth(1718))) int1718;
typedef int __attribute__ ((bitwidth(1719))) int1719;
typedef int __attribute__ ((bitwidth(1720))) int1720;
typedef int __attribute__ ((bitwidth(1721))) int1721;
typedef int __attribute__ ((bitwidth(1722))) int1722;
typedef int __attribute__ ((bitwidth(1723))) int1723;
typedef int __attribute__ ((bitwidth(1724))) int1724;
typedef int __attribute__ ((bitwidth(1725))) int1725;
typedef int __attribute__ ((bitwidth(1726))) int1726;
typedef int __attribute__ ((bitwidth(1727))) int1727;
typedef int __attribute__ ((bitwidth(1728))) int1728;
typedef int __attribute__ ((bitwidth(1729))) int1729;
typedef int __attribute__ ((bitwidth(1730))) int1730;
typedef int __attribute__ ((bitwidth(1731))) int1731;
typedef int __attribute__ ((bitwidth(1732))) int1732;
typedef int __attribute__ ((bitwidth(1733))) int1733;
typedef int __attribute__ ((bitwidth(1734))) int1734;
typedef int __attribute__ ((bitwidth(1735))) int1735;
typedef int __attribute__ ((bitwidth(1736))) int1736;
typedef int __attribute__ ((bitwidth(1737))) int1737;
typedef int __attribute__ ((bitwidth(1738))) int1738;
typedef int __attribute__ ((bitwidth(1739))) int1739;
typedef int __attribute__ ((bitwidth(1740))) int1740;
typedef int __attribute__ ((bitwidth(1741))) int1741;
typedef int __attribute__ ((bitwidth(1742))) int1742;
typedef int __attribute__ ((bitwidth(1743))) int1743;
typedef int __attribute__ ((bitwidth(1744))) int1744;
typedef int __attribute__ ((bitwidth(1745))) int1745;
typedef int __attribute__ ((bitwidth(1746))) int1746;
typedef int __attribute__ ((bitwidth(1747))) int1747;
typedef int __attribute__ ((bitwidth(1748))) int1748;
typedef int __attribute__ ((bitwidth(1749))) int1749;
typedef int __attribute__ ((bitwidth(1750))) int1750;
typedef int __attribute__ ((bitwidth(1751))) int1751;
typedef int __attribute__ ((bitwidth(1752))) int1752;
typedef int __attribute__ ((bitwidth(1753))) int1753;
typedef int __attribute__ ((bitwidth(1754))) int1754;
typedef int __attribute__ ((bitwidth(1755))) int1755;
typedef int __attribute__ ((bitwidth(1756))) int1756;
typedef int __attribute__ ((bitwidth(1757))) int1757;
typedef int __attribute__ ((bitwidth(1758))) int1758;
typedef int __attribute__ ((bitwidth(1759))) int1759;
typedef int __attribute__ ((bitwidth(1760))) int1760;
typedef int __attribute__ ((bitwidth(1761))) int1761;
typedef int __attribute__ ((bitwidth(1762))) int1762;
typedef int __attribute__ ((bitwidth(1763))) int1763;
typedef int __attribute__ ((bitwidth(1764))) int1764;
typedef int __attribute__ ((bitwidth(1765))) int1765;
typedef int __attribute__ ((bitwidth(1766))) int1766;
typedef int __attribute__ ((bitwidth(1767))) int1767;
typedef int __attribute__ ((bitwidth(1768))) int1768;
typedef int __attribute__ ((bitwidth(1769))) int1769;
typedef int __attribute__ ((bitwidth(1770))) int1770;
typedef int __attribute__ ((bitwidth(1771))) int1771;
typedef int __attribute__ ((bitwidth(1772))) int1772;
typedef int __attribute__ ((bitwidth(1773))) int1773;
typedef int __attribute__ ((bitwidth(1774))) int1774;
typedef int __attribute__ ((bitwidth(1775))) int1775;
typedef int __attribute__ ((bitwidth(1776))) int1776;
typedef int __attribute__ ((bitwidth(1777))) int1777;
typedef int __attribute__ ((bitwidth(1778))) int1778;
typedef int __attribute__ ((bitwidth(1779))) int1779;
typedef int __attribute__ ((bitwidth(1780))) int1780;
typedef int __attribute__ ((bitwidth(1781))) int1781;
typedef int __attribute__ ((bitwidth(1782))) int1782;
typedef int __attribute__ ((bitwidth(1783))) int1783;
typedef int __attribute__ ((bitwidth(1784))) int1784;
typedef int __attribute__ ((bitwidth(1785))) int1785;
typedef int __attribute__ ((bitwidth(1786))) int1786;
typedef int __attribute__ ((bitwidth(1787))) int1787;
typedef int __attribute__ ((bitwidth(1788))) int1788;
typedef int __attribute__ ((bitwidth(1789))) int1789;
typedef int __attribute__ ((bitwidth(1790))) int1790;
typedef int __attribute__ ((bitwidth(1791))) int1791;
typedef int __attribute__ ((bitwidth(1792))) int1792;
typedef int __attribute__ ((bitwidth(1793))) int1793;
typedef int __attribute__ ((bitwidth(1794))) int1794;
typedef int __attribute__ ((bitwidth(1795))) int1795;
typedef int __attribute__ ((bitwidth(1796))) int1796;
typedef int __attribute__ ((bitwidth(1797))) int1797;
typedef int __attribute__ ((bitwidth(1798))) int1798;
typedef int __attribute__ ((bitwidth(1799))) int1799;
typedef int __attribute__ ((bitwidth(1800))) int1800;
typedef int __attribute__ ((bitwidth(1801))) int1801;
typedef int __attribute__ ((bitwidth(1802))) int1802;
typedef int __attribute__ ((bitwidth(1803))) int1803;
typedef int __attribute__ ((bitwidth(1804))) int1804;
typedef int __attribute__ ((bitwidth(1805))) int1805;
typedef int __attribute__ ((bitwidth(1806))) int1806;
typedef int __attribute__ ((bitwidth(1807))) int1807;
typedef int __attribute__ ((bitwidth(1808))) int1808;
typedef int __attribute__ ((bitwidth(1809))) int1809;
typedef int __attribute__ ((bitwidth(1810))) int1810;
typedef int __attribute__ ((bitwidth(1811))) int1811;
typedef int __attribute__ ((bitwidth(1812))) int1812;
typedef int __attribute__ ((bitwidth(1813))) int1813;
typedef int __attribute__ ((bitwidth(1814))) int1814;
typedef int __attribute__ ((bitwidth(1815))) int1815;
typedef int __attribute__ ((bitwidth(1816))) int1816;
typedef int __attribute__ ((bitwidth(1817))) int1817;
typedef int __attribute__ ((bitwidth(1818))) int1818;
typedef int __attribute__ ((bitwidth(1819))) int1819;
typedef int __attribute__ ((bitwidth(1820))) int1820;
typedef int __attribute__ ((bitwidth(1821))) int1821;
typedef int __attribute__ ((bitwidth(1822))) int1822;
typedef int __attribute__ ((bitwidth(1823))) int1823;
typedef int __attribute__ ((bitwidth(1824))) int1824;
typedef int __attribute__ ((bitwidth(1825))) int1825;
typedef int __attribute__ ((bitwidth(1826))) int1826;
typedef int __attribute__ ((bitwidth(1827))) int1827;
typedef int __attribute__ ((bitwidth(1828))) int1828;
typedef int __attribute__ ((bitwidth(1829))) int1829;
typedef int __attribute__ ((bitwidth(1830))) int1830;
typedef int __attribute__ ((bitwidth(1831))) int1831;
typedef int __attribute__ ((bitwidth(1832))) int1832;
typedef int __attribute__ ((bitwidth(1833))) int1833;
typedef int __attribute__ ((bitwidth(1834))) int1834;
typedef int __attribute__ ((bitwidth(1835))) int1835;
typedef int __attribute__ ((bitwidth(1836))) int1836;
typedef int __attribute__ ((bitwidth(1837))) int1837;
typedef int __attribute__ ((bitwidth(1838))) int1838;
typedef int __attribute__ ((bitwidth(1839))) int1839;
typedef int __attribute__ ((bitwidth(1840))) int1840;
typedef int __attribute__ ((bitwidth(1841))) int1841;
typedef int __attribute__ ((bitwidth(1842))) int1842;
typedef int __attribute__ ((bitwidth(1843))) int1843;
typedef int __attribute__ ((bitwidth(1844))) int1844;
typedef int __attribute__ ((bitwidth(1845))) int1845;
typedef int __attribute__ ((bitwidth(1846))) int1846;
typedef int __attribute__ ((bitwidth(1847))) int1847;
typedef int __attribute__ ((bitwidth(1848))) int1848;
typedef int __attribute__ ((bitwidth(1849))) int1849;
typedef int __attribute__ ((bitwidth(1850))) int1850;
typedef int __attribute__ ((bitwidth(1851))) int1851;
typedef int __attribute__ ((bitwidth(1852))) int1852;
typedef int __attribute__ ((bitwidth(1853))) int1853;
typedef int __attribute__ ((bitwidth(1854))) int1854;
typedef int __attribute__ ((bitwidth(1855))) int1855;
typedef int __attribute__ ((bitwidth(1856))) int1856;
typedef int __attribute__ ((bitwidth(1857))) int1857;
typedef int __attribute__ ((bitwidth(1858))) int1858;
typedef int __attribute__ ((bitwidth(1859))) int1859;
typedef int __attribute__ ((bitwidth(1860))) int1860;
typedef int __attribute__ ((bitwidth(1861))) int1861;
typedef int __attribute__ ((bitwidth(1862))) int1862;
typedef int __attribute__ ((bitwidth(1863))) int1863;
typedef int __attribute__ ((bitwidth(1864))) int1864;
typedef int __attribute__ ((bitwidth(1865))) int1865;
typedef int __attribute__ ((bitwidth(1866))) int1866;
typedef int __attribute__ ((bitwidth(1867))) int1867;
typedef int __attribute__ ((bitwidth(1868))) int1868;
typedef int __attribute__ ((bitwidth(1869))) int1869;
typedef int __attribute__ ((bitwidth(1870))) int1870;
typedef int __attribute__ ((bitwidth(1871))) int1871;
typedef int __attribute__ ((bitwidth(1872))) int1872;
typedef int __attribute__ ((bitwidth(1873))) int1873;
typedef int __attribute__ ((bitwidth(1874))) int1874;
typedef int __attribute__ ((bitwidth(1875))) int1875;
typedef int __attribute__ ((bitwidth(1876))) int1876;
typedef int __attribute__ ((bitwidth(1877))) int1877;
typedef int __attribute__ ((bitwidth(1878))) int1878;
typedef int __attribute__ ((bitwidth(1879))) int1879;
typedef int __attribute__ ((bitwidth(1880))) int1880;
typedef int __attribute__ ((bitwidth(1881))) int1881;
typedef int __attribute__ ((bitwidth(1882))) int1882;
typedef int __attribute__ ((bitwidth(1883))) int1883;
typedef int __attribute__ ((bitwidth(1884))) int1884;
typedef int __attribute__ ((bitwidth(1885))) int1885;
typedef int __attribute__ ((bitwidth(1886))) int1886;
typedef int __attribute__ ((bitwidth(1887))) int1887;
typedef int __attribute__ ((bitwidth(1888))) int1888;
typedef int __attribute__ ((bitwidth(1889))) int1889;
typedef int __attribute__ ((bitwidth(1890))) int1890;
typedef int __attribute__ ((bitwidth(1891))) int1891;
typedef int __attribute__ ((bitwidth(1892))) int1892;
typedef int __attribute__ ((bitwidth(1893))) int1893;
typedef int __attribute__ ((bitwidth(1894))) int1894;
typedef int __attribute__ ((bitwidth(1895))) int1895;
typedef int __attribute__ ((bitwidth(1896))) int1896;
typedef int __attribute__ ((bitwidth(1897))) int1897;
typedef int __attribute__ ((bitwidth(1898))) int1898;
typedef int __attribute__ ((bitwidth(1899))) int1899;
typedef int __attribute__ ((bitwidth(1900))) int1900;
typedef int __attribute__ ((bitwidth(1901))) int1901;
typedef int __attribute__ ((bitwidth(1902))) int1902;
typedef int __attribute__ ((bitwidth(1903))) int1903;
typedef int __attribute__ ((bitwidth(1904))) int1904;
typedef int __attribute__ ((bitwidth(1905))) int1905;
typedef int __attribute__ ((bitwidth(1906))) int1906;
typedef int __attribute__ ((bitwidth(1907))) int1907;
typedef int __attribute__ ((bitwidth(1908))) int1908;
typedef int __attribute__ ((bitwidth(1909))) int1909;
typedef int __attribute__ ((bitwidth(1910))) int1910;
typedef int __attribute__ ((bitwidth(1911))) int1911;
typedef int __attribute__ ((bitwidth(1912))) int1912;
typedef int __attribute__ ((bitwidth(1913))) int1913;
typedef int __attribute__ ((bitwidth(1914))) int1914;
typedef int __attribute__ ((bitwidth(1915))) int1915;
typedef int __attribute__ ((bitwidth(1916))) int1916;
typedef int __attribute__ ((bitwidth(1917))) int1917;
typedef int __attribute__ ((bitwidth(1918))) int1918;
typedef int __attribute__ ((bitwidth(1919))) int1919;
typedef int __attribute__ ((bitwidth(1920))) int1920;
typedef int __attribute__ ((bitwidth(1921))) int1921;
typedef int __attribute__ ((bitwidth(1922))) int1922;
typedef int __attribute__ ((bitwidth(1923))) int1923;
typedef int __attribute__ ((bitwidth(1924))) int1924;
typedef int __attribute__ ((bitwidth(1925))) int1925;
typedef int __attribute__ ((bitwidth(1926))) int1926;
typedef int __attribute__ ((bitwidth(1927))) int1927;
typedef int __attribute__ ((bitwidth(1928))) int1928;
typedef int __attribute__ ((bitwidth(1929))) int1929;
typedef int __attribute__ ((bitwidth(1930))) int1930;
typedef int __attribute__ ((bitwidth(1931))) int1931;
typedef int __attribute__ ((bitwidth(1932))) int1932;
typedef int __attribute__ ((bitwidth(1933))) int1933;
typedef int __attribute__ ((bitwidth(1934))) int1934;
typedef int __attribute__ ((bitwidth(1935))) int1935;
typedef int __attribute__ ((bitwidth(1936))) int1936;
typedef int __attribute__ ((bitwidth(1937))) int1937;
typedef int __attribute__ ((bitwidth(1938))) int1938;
typedef int __attribute__ ((bitwidth(1939))) int1939;
typedef int __attribute__ ((bitwidth(1940))) int1940;
typedef int __attribute__ ((bitwidth(1941))) int1941;
typedef int __attribute__ ((bitwidth(1942))) int1942;
typedef int __attribute__ ((bitwidth(1943))) int1943;
typedef int __attribute__ ((bitwidth(1944))) int1944;
typedef int __attribute__ ((bitwidth(1945))) int1945;
typedef int __attribute__ ((bitwidth(1946))) int1946;
typedef int __attribute__ ((bitwidth(1947))) int1947;
typedef int __attribute__ ((bitwidth(1948))) int1948;
typedef int __attribute__ ((bitwidth(1949))) int1949;
typedef int __attribute__ ((bitwidth(1950))) int1950;
typedef int __attribute__ ((bitwidth(1951))) int1951;
typedef int __attribute__ ((bitwidth(1952))) int1952;
typedef int __attribute__ ((bitwidth(1953))) int1953;
typedef int __attribute__ ((bitwidth(1954))) int1954;
typedef int __attribute__ ((bitwidth(1955))) int1955;
typedef int __attribute__ ((bitwidth(1956))) int1956;
typedef int __attribute__ ((bitwidth(1957))) int1957;
typedef int __attribute__ ((bitwidth(1958))) int1958;
typedef int __attribute__ ((bitwidth(1959))) int1959;
typedef int __attribute__ ((bitwidth(1960))) int1960;
typedef int __attribute__ ((bitwidth(1961))) int1961;
typedef int __attribute__ ((bitwidth(1962))) int1962;
typedef int __attribute__ ((bitwidth(1963))) int1963;
typedef int __attribute__ ((bitwidth(1964))) int1964;
typedef int __attribute__ ((bitwidth(1965))) int1965;
typedef int __attribute__ ((bitwidth(1966))) int1966;
typedef int __attribute__ ((bitwidth(1967))) int1967;
typedef int __attribute__ ((bitwidth(1968))) int1968;
typedef int __attribute__ ((bitwidth(1969))) int1969;
typedef int __attribute__ ((bitwidth(1970))) int1970;
typedef int __attribute__ ((bitwidth(1971))) int1971;
typedef int __attribute__ ((bitwidth(1972))) int1972;
typedef int __attribute__ ((bitwidth(1973))) int1973;
typedef int __attribute__ ((bitwidth(1974))) int1974;
typedef int __attribute__ ((bitwidth(1975))) int1975;
typedef int __attribute__ ((bitwidth(1976))) int1976;
typedef int __attribute__ ((bitwidth(1977))) int1977;
typedef int __attribute__ ((bitwidth(1978))) int1978;
typedef int __attribute__ ((bitwidth(1979))) int1979;
typedef int __attribute__ ((bitwidth(1980))) int1980;
typedef int __attribute__ ((bitwidth(1981))) int1981;
typedef int __attribute__ ((bitwidth(1982))) int1982;
typedef int __attribute__ ((bitwidth(1983))) int1983;
typedef int __attribute__ ((bitwidth(1984))) int1984;
typedef int __attribute__ ((bitwidth(1985))) int1985;
typedef int __attribute__ ((bitwidth(1986))) int1986;
typedef int __attribute__ ((bitwidth(1987))) int1987;
typedef int __attribute__ ((bitwidth(1988))) int1988;
typedef int __attribute__ ((bitwidth(1989))) int1989;
typedef int __attribute__ ((bitwidth(1990))) int1990;
typedef int __attribute__ ((bitwidth(1991))) int1991;
typedef int __attribute__ ((bitwidth(1992))) int1992;
typedef int __attribute__ ((bitwidth(1993))) int1993;
typedef int __attribute__ ((bitwidth(1994))) int1994;
typedef int __attribute__ ((bitwidth(1995))) int1995;
typedef int __attribute__ ((bitwidth(1996))) int1996;
typedef int __attribute__ ((bitwidth(1997))) int1997;
typedef int __attribute__ ((bitwidth(1998))) int1998;
typedef int __attribute__ ((bitwidth(1999))) int1999;
typedef int __attribute__ ((bitwidth(2000))) int2000;
typedef int __attribute__ ((bitwidth(2001))) int2001;
typedef int __attribute__ ((bitwidth(2002))) int2002;
typedef int __attribute__ ((bitwidth(2003))) int2003;
typedef int __attribute__ ((bitwidth(2004))) int2004;
typedef int __attribute__ ((bitwidth(2005))) int2005;
typedef int __attribute__ ((bitwidth(2006))) int2006;
typedef int __attribute__ ((bitwidth(2007))) int2007;
typedef int __attribute__ ((bitwidth(2008))) int2008;
typedef int __attribute__ ((bitwidth(2009))) int2009;
typedef int __attribute__ ((bitwidth(2010))) int2010;
typedef int __attribute__ ((bitwidth(2011))) int2011;
typedef int __attribute__ ((bitwidth(2012))) int2012;
typedef int __attribute__ ((bitwidth(2013))) int2013;
typedef int __attribute__ ((bitwidth(2014))) int2014;
typedef int __attribute__ ((bitwidth(2015))) int2015;
typedef int __attribute__ ((bitwidth(2016))) int2016;
typedef int __attribute__ ((bitwidth(2017))) int2017;
typedef int __attribute__ ((bitwidth(2018))) int2018;
typedef int __attribute__ ((bitwidth(2019))) int2019;
typedef int __attribute__ ((bitwidth(2020))) int2020;
typedef int __attribute__ ((bitwidth(2021))) int2021;
typedef int __attribute__ ((bitwidth(2022))) int2022;
typedef int __attribute__ ((bitwidth(2023))) int2023;
typedef int __attribute__ ((bitwidth(2024))) int2024;
typedef int __attribute__ ((bitwidth(2025))) int2025;
typedef int __attribute__ ((bitwidth(2026))) int2026;
typedef int __attribute__ ((bitwidth(2027))) int2027;
typedef int __attribute__ ((bitwidth(2028))) int2028;
typedef int __attribute__ ((bitwidth(2029))) int2029;
typedef int __attribute__ ((bitwidth(2030))) int2030;
typedef int __attribute__ ((bitwidth(2031))) int2031;
typedef int __attribute__ ((bitwidth(2032))) int2032;
typedef int __attribute__ ((bitwidth(2033))) int2033;
typedef int __attribute__ ((bitwidth(2034))) int2034;
typedef int __attribute__ ((bitwidth(2035))) int2035;
typedef int __attribute__ ((bitwidth(2036))) int2036;
typedef int __attribute__ ((bitwidth(2037))) int2037;
typedef int __attribute__ ((bitwidth(2038))) int2038;
typedef int __attribute__ ((bitwidth(2039))) int2039;
typedef int __attribute__ ((bitwidth(2040))) int2040;
typedef int __attribute__ ((bitwidth(2041))) int2041;
typedef int __attribute__ ((bitwidth(2042))) int2042;
typedef int __attribute__ ((bitwidth(2043))) int2043;
typedef int __attribute__ ((bitwidth(2044))) int2044;
typedef int __attribute__ ((bitwidth(2045))) int2045;
typedef int __attribute__ ((bitwidth(2046))) int2046;
typedef int __attribute__ ((bitwidth(2047))) int2047;
typedef int __attribute__ ((bitwidth(2048))) int2048;
#pragma line 99 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 108 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(1))) uint1;
typedef unsigned int __attribute__ ((bitwidth(2))) uint2;
typedef unsigned int __attribute__ ((bitwidth(3))) uint3;
typedef unsigned int __attribute__ ((bitwidth(4))) uint4;
typedef unsigned int __attribute__ ((bitwidth(5))) uint5;
typedef unsigned int __attribute__ ((bitwidth(6))) uint6;
typedef unsigned int __attribute__ ((bitwidth(7))) uint7;
typedef unsigned int __attribute__ ((bitwidth(8))) uint8;
typedef unsigned int __attribute__ ((bitwidth(9))) uint9;
typedef unsigned int __attribute__ ((bitwidth(10))) uint10;
typedef unsigned int __attribute__ ((bitwidth(11))) uint11;
typedef unsigned int __attribute__ ((bitwidth(12))) uint12;
typedef unsigned int __attribute__ ((bitwidth(13))) uint13;
typedef unsigned int __attribute__ ((bitwidth(14))) uint14;
typedef unsigned int __attribute__ ((bitwidth(15))) uint15;
typedef unsigned int __attribute__ ((bitwidth(16))) uint16;
typedef unsigned int __attribute__ ((bitwidth(17))) uint17;
typedef unsigned int __attribute__ ((bitwidth(18))) uint18;
typedef unsigned int __attribute__ ((bitwidth(19))) uint19;
typedef unsigned int __attribute__ ((bitwidth(20))) uint20;
typedef unsigned int __attribute__ ((bitwidth(21))) uint21;
typedef unsigned int __attribute__ ((bitwidth(22))) uint22;
typedef unsigned int __attribute__ ((bitwidth(23))) uint23;
typedef unsigned int __attribute__ ((bitwidth(24))) uint24;
typedef unsigned int __attribute__ ((bitwidth(25))) uint25;
typedef unsigned int __attribute__ ((bitwidth(26))) uint26;
typedef unsigned int __attribute__ ((bitwidth(27))) uint27;
typedef unsigned int __attribute__ ((bitwidth(28))) uint28;
typedef unsigned int __attribute__ ((bitwidth(29))) uint29;
typedef unsigned int __attribute__ ((bitwidth(30))) uint30;
typedef unsigned int __attribute__ ((bitwidth(31))) uint31;
typedef unsigned int __attribute__ ((bitwidth(32))) uint32;
typedef unsigned int __attribute__ ((bitwidth(33))) uint33;
typedef unsigned int __attribute__ ((bitwidth(34))) uint34;
typedef unsigned int __attribute__ ((bitwidth(35))) uint35;
typedef unsigned int __attribute__ ((bitwidth(36))) uint36;
typedef unsigned int __attribute__ ((bitwidth(37))) uint37;
typedef unsigned int __attribute__ ((bitwidth(38))) uint38;
typedef unsigned int __attribute__ ((bitwidth(39))) uint39;
typedef unsigned int __attribute__ ((bitwidth(40))) uint40;
typedef unsigned int __attribute__ ((bitwidth(41))) uint41;
typedef unsigned int __attribute__ ((bitwidth(42))) uint42;
typedef unsigned int __attribute__ ((bitwidth(43))) uint43;
typedef unsigned int __attribute__ ((bitwidth(44))) uint44;
typedef unsigned int __attribute__ ((bitwidth(45))) uint45;
typedef unsigned int __attribute__ ((bitwidth(46))) uint46;
typedef unsigned int __attribute__ ((bitwidth(47))) uint47;
typedef unsigned int __attribute__ ((bitwidth(48))) uint48;
typedef unsigned int __attribute__ ((bitwidth(49))) uint49;
typedef unsigned int __attribute__ ((bitwidth(50))) uint50;
typedef unsigned int __attribute__ ((bitwidth(51))) uint51;
typedef unsigned int __attribute__ ((bitwidth(52))) uint52;
typedef unsigned int __attribute__ ((bitwidth(53))) uint53;
typedef unsigned int __attribute__ ((bitwidth(54))) uint54;
typedef unsigned int __attribute__ ((bitwidth(55))) uint55;
typedef unsigned int __attribute__ ((bitwidth(56))) uint56;
typedef unsigned int __attribute__ ((bitwidth(57))) uint57;
typedef unsigned int __attribute__ ((bitwidth(58))) uint58;
typedef unsigned int __attribute__ ((bitwidth(59))) uint59;
typedef unsigned int __attribute__ ((bitwidth(60))) uint60;
typedef unsigned int __attribute__ ((bitwidth(61))) uint61;
typedef unsigned int __attribute__ ((bitwidth(62))) uint62;
typedef unsigned int __attribute__ ((bitwidth(63))) uint63;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(65))) uint65;
typedef unsigned int __attribute__ ((bitwidth(66))) uint66;
typedef unsigned int __attribute__ ((bitwidth(67))) uint67;
typedef unsigned int __attribute__ ((bitwidth(68))) uint68;
typedef unsigned int __attribute__ ((bitwidth(69))) uint69;
typedef unsigned int __attribute__ ((bitwidth(70))) uint70;
typedef unsigned int __attribute__ ((bitwidth(71))) uint71;
typedef unsigned int __attribute__ ((bitwidth(72))) uint72;
typedef unsigned int __attribute__ ((bitwidth(73))) uint73;
typedef unsigned int __attribute__ ((bitwidth(74))) uint74;
typedef unsigned int __attribute__ ((bitwidth(75))) uint75;
typedef unsigned int __attribute__ ((bitwidth(76))) uint76;
typedef unsigned int __attribute__ ((bitwidth(77))) uint77;
typedef unsigned int __attribute__ ((bitwidth(78))) uint78;
typedef unsigned int __attribute__ ((bitwidth(79))) uint79;
typedef unsigned int __attribute__ ((bitwidth(80))) uint80;
typedef unsigned int __attribute__ ((bitwidth(81))) uint81;
typedef unsigned int __attribute__ ((bitwidth(82))) uint82;
typedef unsigned int __attribute__ ((bitwidth(83))) uint83;
typedef unsigned int __attribute__ ((bitwidth(84))) uint84;
typedef unsigned int __attribute__ ((bitwidth(85))) uint85;
typedef unsigned int __attribute__ ((bitwidth(86))) uint86;
typedef unsigned int __attribute__ ((bitwidth(87))) uint87;
typedef unsigned int __attribute__ ((bitwidth(88))) uint88;
typedef unsigned int __attribute__ ((bitwidth(89))) uint89;
typedef unsigned int __attribute__ ((bitwidth(90))) uint90;
typedef unsigned int __attribute__ ((bitwidth(91))) uint91;
typedef unsigned int __attribute__ ((bitwidth(92))) uint92;
typedef unsigned int __attribute__ ((bitwidth(93))) uint93;
typedef unsigned int __attribute__ ((bitwidth(94))) uint94;
typedef unsigned int __attribute__ ((bitwidth(95))) uint95;
typedef unsigned int __attribute__ ((bitwidth(96))) uint96;
typedef unsigned int __attribute__ ((bitwidth(97))) uint97;
typedef unsigned int __attribute__ ((bitwidth(98))) uint98;
typedef unsigned int __attribute__ ((bitwidth(99))) uint99;
typedef unsigned int __attribute__ ((bitwidth(100))) uint100;
typedef unsigned int __attribute__ ((bitwidth(101))) uint101;
typedef unsigned int __attribute__ ((bitwidth(102))) uint102;
typedef unsigned int __attribute__ ((bitwidth(103))) uint103;
typedef unsigned int __attribute__ ((bitwidth(104))) uint104;
typedef unsigned int __attribute__ ((bitwidth(105))) uint105;
typedef unsigned int __attribute__ ((bitwidth(106))) uint106;
typedef unsigned int __attribute__ ((bitwidth(107))) uint107;
typedef unsigned int __attribute__ ((bitwidth(108))) uint108;
typedef unsigned int __attribute__ ((bitwidth(109))) uint109;
typedef unsigned int __attribute__ ((bitwidth(110))) uint110;
typedef unsigned int __attribute__ ((bitwidth(111))) uint111;
typedef unsigned int __attribute__ ((bitwidth(112))) uint112;
typedef unsigned int __attribute__ ((bitwidth(113))) uint113;
typedef unsigned int __attribute__ ((bitwidth(114))) uint114;
typedef unsigned int __attribute__ ((bitwidth(115))) uint115;
typedef unsigned int __attribute__ ((bitwidth(116))) uint116;
typedef unsigned int __attribute__ ((bitwidth(117))) uint117;
typedef unsigned int __attribute__ ((bitwidth(118))) uint118;
typedef unsigned int __attribute__ ((bitwidth(119))) uint119;
typedef unsigned int __attribute__ ((bitwidth(120))) uint120;
typedef unsigned int __attribute__ ((bitwidth(121))) uint121;
typedef unsigned int __attribute__ ((bitwidth(122))) uint122;
typedef unsigned int __attribute__ ((bitwidth(123))) uint123;
typedef unsigned int __attribute__ ((bitwidth(124))) uint124;
typedef unsigned int __attribute__ ((bitwidth(125))) uint125;
typedef unsigned int __attribute__ ((bitwidth(126))) uint126;
typedef unsigned int __attribute__ ((bitwidth(127))) uint127;
typedef unsigned int __attribute__ ((bitwidth(128))) uint128;
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(129))) uint129;
typedef unsigned int __attribute__ ((bitwidth(130))) uint130;
typedef unsigned int __attribute__ ((bitwidth(131))) uint131;
typedef unsigned int __attribute__ ((bitwidth(132))) uint132;
typedef unsigned int __attribute__ ((bitwidth(133))) uint133;
typedef unsigned int __attribute__ ((bitwidth(134))) uint134;
typedef unsigned int __attribute__ ((bitwidth(135))) uint135;
typedef unsigned int __attribute__ ((bitwidth(136))) uint136;
typedef unsigned int __attribute__ ((bitwidth(137))) uint137;
typedef unsigned int __attribute__ ((bitwidth(138))) uint138;
typedef unsigned int __attribute__ ((bitwidth(139))) uint139;
typedef unsigned int __attribute__ ((bitwidth(140))) uint140;
typedef unsigned int __attribute__ ((bitwidth(141))) uint141;
typedef unsigned int __attribute__ ((bitwidth(142))) uint142;
typedef unsigned int __attribute__ ((bitwidth(143))) uint143;
typedef unsigned int __attribute__ ((bitwidth(144))) uint144;
typedef unsigned int __attribute__ ((bitwidth(145))) uint145;
typedef unsigned int __attribute__ ((bitwidth(146))) uint146;
typedef unsigned int __attribute__ ((bitwidth(147))) uint147;
typedef unsigned int __attribute__ ((bitwidth(148))) uint148;
typedef unsigned int __attribute__ ((bitwidth(149))) uint149;
typedef unsigned int __attribute__ ((bitwidth(150))) uint150;
typedef unsigned int __attribute__ ((bitwidth(151))) uint151;
typedef unsigned int __attribute__ ((bitwidth(152))) uint152;
typedef unsigned int __attribute__ ((bitwidth(153))) uint153;
typedef unsigned int __attribute__ ((bitwidth(154))) uint154;
typedef unsigned int __attribute__ ((bitwidth(155))) uint155;
typedef unsigned int __attribute__ ((bitwidth(156))) uint156;
typedef unsigned int __attribute__ ((bitwidth(157))) uint157;
typedef unsigned int __attribute__ ((bitwidth(158))) uint158;
typedef unsigned int __attribute__ ((bitwidth(159))) uint159;
typedef unsigned int __attribute__ ((bitwidth(160))) uint160;
typedef unsigned int __attribute__ ((bitwidth(161))) uint161;
typedef unsigned int __attribute__ ((bitwidth(162))) uint162;
typedef unsigned int __attribute__ ((bitwidth(163))) uint163;
typedef unsigned int __attribute__ ((bitwidth(164))) uint164;
typedef unsigned int __attribute__ ((bitwidth(165))) uint165;
typedef unsigned int __attribute__ ((bitwidth(166))) uint166;
typedef unsigned int __attribute__ ((bitwidth(167))) uint167;
typedef unsigned int __attribute__ ((bitwidth(168))) uint168;
typedef unsigned int __attribute__ ((bitwidth(169))) uint169;
typedef unsigned int __attribute__ ((bitwidth(170))) uint170;
typedef unsigned int __attribute__ ((bitwidth(171))) uint171;
typedef unsigned int __attribute__ ((bitwidth(172))) uint172;
typedef unsigned int __attribute__ ((bitwidth(173))) uint173;
typedef unsigned int __attribute__ ((bitwidth(174))) uint174;
typedef unsigned int __attribute__ ((bitwidth(175))) uint175;
typedef unsigned int __attribute__ ((bitwidth(176))) uint176;
typedef unsigned int __attribute__ ((bitwidth(177))) uint177;
typedef unsigned int __attribute__ ((bitwidth(178))) uint178;
typedef unsigned int __attribute__ ((bitwidth(179))) uint179;
typedef unsigned int __attribute__ ((bitwidth(180))) uint180;
typedef unsigned int __attribute__ ((bitwidth(181))) uint181;
typedef unsigned int __attribute__ ((bitwidth(182))) uint182;
typedef unsigned int __attribute__ ((bitwidth(183))) uint183;
typedef unsigned int __attribute__ ((bitwidth(184))) uint184;
typedef unsigned int __attribute__ ((bitwidth(185))) uint185;
typedef unsigned int __attribute__ ((bitwidth(186))) uint186;
typedef unsigned int __attribute__ ((bitwidth(187))) uint187;
typedef unsigned int __attribute__ ((bitwidth(188))) uint188;
typedef unsigned int __attribute__ ((bitwidth(189))) uint189;
typedef unsigned int __attribute__ ((bitwidth(190))) uint190;
typedef unsigned int __attribute__ ((bitwidth(191))) uint191;
typedef unsigned int __attribute__ ((bitwidth(192))) uint192;
typedef unsigned int __attribute__ ((bitwidth(193))) uint193;
typedef unsigned int __attribute__ ((bitwidth(194))) uint194;
typedef unsigned int __attribute__ ((bitwidth(195))) uint195;
typedef unsigned int __attribute__ ((bitwidth(196))) uint196;
typedef unsigned int __attribute__ ((bitwidth(197))) uint197;
typedef unsigned int __attribute__ ((bitwidth(198))) uint198;
typedef unsigned int __attribute__ ((bitwidth(199))) uint199;
typedef unsigned int __attribute__ ((bitwidth(200))) uint200;
typedef unsigned int __attribute__ ((bitwidth(201))) uint201;
typedef unsigned int __attribute__ ((bitwidth(202))) uint202;
typedef unsigned int __attribute__ ((bitwidth(203))) uint203;
typedef unsigned int __attribute__ ((bitwidth(204))) uint204;
typedef unsigned int __attribute__ ((bitwidth(205))) uint205;
typedef unsigned int __attribute__ ((bitwidth(206))) uint206;
typedef unsigned int __attribute__ ((bitwidth(207))) uint207;
typedef unsigned int __attribute__ ((bitwidth(208))) uint208;
typedef unsigned int __attribute__ ((bitwidth(209))) uint209;
typedef unsigned int __attribute__ ((bitwidth(210))) uint210;
typedef unsigned int __attribute__ ((bitwidth(211))) uint211;
typedef unsigned int __attribute__ ((bitwidth(212))) uint212;
typedef unsigned int __attribute__ ((bitwidth(213))) uint213;
typedef unsigned int __attribute__ ((bitwidth(214))) uint214;
typedef unsigned int __attribute__ ((bitwidth(215))) uint215;
typedef unsigned int __attribute__ ((bitwidth(216))) uint216;
typedef unsigned int __attribute__ ((bitwidth(217))) uint217;
typedef unsigned int __attribute__ ((bitwidth(218))) uint218;
typedef unsigned int __attribute__ ((bitwidth(219))) uint219;
typedef unsigned int __attribute__ ((bitwidth(220))) uint220;
typedef unsigned int __attribute__ ((bitwidth(221))) uint221;
typedef unsigned int __attribute__ ((bitwidth(222))) uint222;
typedef unsigned int __attribute__ ((bitwidth(223))) uint223;
typedef unsigned int __attribute__ ((bitwidth(224))) uint224;
typedef unsigned int __attribute__ ((bitwidth(225))) uint225;
typedef unsigned int __attribute__ ((bitwidth(226))) uint226;
typedef unsigned int __attribute__ ((bitwidth(227))) uint227;
typedef unsigned int __attribute__ ((bitwidth(228))) uint228;
typedef unsigned int __attribute__ ((bitwidth(229))) uint229;
typedef unsigned int __attribute__ ((bitwidth(230))) uint230;
typedef unsigned int __attribute__ ((bitwidth(231))) uint231;
typedef unsigned int __attribute__ ((bitwidth(232))) uint232;
typedef unsigned int __attribute__ ((bitwidth(233))) uint233;
typedef unsigned int __attribute__ ((bitwidth(234))) uint234;
typedef unsigned int __attribute__ ((bitwidth(235))) uint235;
typedef unsigned int __attribute__ ((bitwidth(236))) uint236;
typedef unsigned int __attribute__ ((bitwidth(237))) uint237;
typedef unsigned int __attribute__ ((bitwidth(238))) uint238;
typedef unsigned int __attribute__ ((bitwidth(239))) uint239;
typedef unsigned int __attribute__ ((bitwidth(240))) uint240;
typedef unsigned int __attribute__ ((bitwidth(241))) uint241;
typedef unsigned int __attribute__ ((bitwidth(242))) uint242;
typedef unsigned int __attribute__ ((bitwidth(243))) uint243;
typedef unsigned int __attribute__ ((bitwidth(244))) uint244;
typedef unsigned int __attribute__ ((bitwidth(245))) uint245;
typedef unsigned int __attribute__ ((bitwidth(246))) uint246;
typedef unsigned int __attribute__ ((bitwidth(247))) uint247;
typedef unsigned int __attribute__ ((bitwidth(248))) uint248;
typedef unsigned int __attribute__ ((bitwidth(249))) uint249;
typedef unsigned int __attribute__ ((bitwidth(250))) uint250;
typedef unsigned int __attribute__ ((bitwidth(251))) uint251;
typedef unsigned int __attribute__ ((bitwidth(252))) uint252;
typedef unsigned int __attribute__ ((bitwidth(253))) uint253;
typedef unsigned int __attribute__ ((bitwidth(254))) uint254;
typedef unsigned int __attribute__ ((bitwidth(255))) uint255;
typedef unsigned int __attribute__ ((bitwidth(256))) uint256;
typedef unsigned int __attribute__ ((bitwidth(257))) uint257;
typedef unsigned int __attribute__ ((bitwidth(258))) uint258;
typedef unsigned int __attribute__ ((bitwidth(259))) uint259;
typedef unsigned int __attribute__ ((bitwidth(260))) uint260;
typedef unsigned int __attribute__ ((bitwidth(261))) uint261;
typedef unsigned int __attribute__ ((bitwidth(262))) uint262;
typedef unsigned int __attribute__ ((bitwidth(263))) uint263;
typedef unsigned int __attribute__ ((bitwidth(264))) uint264;
typedef unsigned int __attribute__ ((bitwidth(265))) uint265;
typedef unsigned int __attribute__ ((bitwidth(266))) uint266;
typedef unsigned int __attribute__ ((bitwidth(267))) uint267;
typedef unsigned int __attribute__ ((bitwidth(268))) uint268;
typedef unsigned int __attribute__ ((bitwidth(269))) uint269;
typedef unsigned int __attribute__ ((bitwidth(270))) uint270;
typedef unsigned int __attribute__ ((bitwidth(271))) uint271;
typedef unsigned int __attribute__ ((bitwidth(272))) uint272;
typedef unsigned int __attribute__ ((bitwidth(273))) uint273;
typedef unsigned int __attribute__ ((bitwidth(274))) uint274;
typedef unsigned int __attribute__ ((bitwidth(275))) uint275;
typedef unsigned int __attribute__ ((bitwidth(276))) uint276;
typedef unsigned int __attribute__ ((bitwidth(277))) uint277;
typedef unsigned int __attribute__ ((bitwidth(278))) uint278;
typedef unsigned int __attribute__ ((bitwidth(279))) uint279;
typedef unsigned int __attribute__ ((bitwidth(280))) uint280;
typedef unsigned int __attribute__ ((bitwidth(281))) uint281;
typedef unsigned int __attribute__ ((bitwidth(282))) uint282;
typedef unsigned int __attribute__ ((bitwidth(283))) uint283;
typedef unsigned int __attribute__ ((bitwidth(284))) uint284;
typedef unsigned int __attribute__ ((bitwidth(285))) uint285;
typedef unsigned int __attribute__ ((bitwidth(286))) uint286;
typedef unsigned int __attribute__ ((bitwidth(287))) uint287;
typedef unsigned int __attribute__ ((bitwidth(288))) uint288;
typedef unsigned int __attribute__ ((bitwidth(289))) uint289;
typedef unsigned int __attribute__ ((bitwidth(290))) uint290;
typedef unsigned int __attribute__ ((bitwidth(291))) uint291;
typedef unsigned int __attribute__ ((bitwidth(292))) uint292;
typedef unsigned int __attribute__ ((bitwidth(293))) uint293;
typedef unsigned int __attribute__ ((bitwidth(294))) uint294;
typedef unsigned int __attribute__ ((bitwidth(295))) uint295;
typedef unsigned int __attribute__ ((bitwidth(296))) uint296;
typedef unsigned int __attribute__ ((bitwidth(297))) uint297;
typedef unsigned int __attribute__ ((bitwidth(298))) uint298;
typedef unsigned int __attribute__ ((bitwidth(299))) uint299;
typedef unsigned int __attribute__ ((bitwidth(300))) uint300;
typedef unsigned int __attribute__ ((bitwidth(301))) uint301;
typedef unsigned int __attribute__ ((bitwidth(302))) uint302;
typedef unsigned int __attribute__ ((bitwidth(303))) uint303;
typedef unsigned int __attribute__ ((bitwidth(304))) uint304;
typedef unsigned int __attribute__ ((bitwidth(305))) uint305;
typedef unsigned int __attribute__ ((bitwidth(306))) uint306;
typedef unsigned int __attribute__ ((bitwidth(307))) uint307;
typedef unsigned int __attribute__ ((bitwidth(308))) uint308;
typedef unsigned int __attribute__ ((bitwidth(309))) uint309;
typedef unsigned int __attribute__ ((bitwidth(310))) uint310;
typedef unsigned int __attribute__ ((bitwidth(311))) uint311;
typedef unsigned int __attribute__ ((bitwidth(312))) uint312;
typedef unsigned int __attribute__ ((bitwidth(313))) uint313;
typedef unsigned int __attribute__ ((bitwidth(314))) uint314;
typedef unsigned int __attribute__ ((bitwidth(315))) uint315;
typedef unsigned int __attribute__ ((bitwidth(316))) uint316;
typedef unsigned int __attribute__ ((bitwidth(317))) uint317;
typedef unsigned int __attribute__ ((bitwidth(318))) uint318;
typedef unsigned int __attribute__ ((bitwidth(319))) uint319;
typedef unsigned int __attribute__ ((bitwidth(320))) uint320;
typedef unsigned int __attribute__ ((bitwidth(321))) uint321;
typedef unsigned int __attribute__ ((bitwidth(322))) uint322;
typedef unsigned int __attribute__ ((bitwidth(323))) uint323;
typedef unsigned int __attribute__ ((bitwidth(324))) uint324;
typedef unsigned int __attribute__ ((bitwidth(325))) uint325;
typedef unsigned int __attribute__ ((bitwidth(326))) uint326;
typedef unsigned int __attribute__ ((bitwidth(327))) uint327;
typedef unsigned int __attribute__ ((bitwidth(328))) uint328;
typedef unsigned int __attribute__ ((bitwidth(329))) uint329;
typedef unsigned int __attribute__ ((bitwidth(330))) uint330;
typedef unsigned int __attribute__ ((bitwidth(331))) uint331;
typedef unsigned int __attribute__ ((bitwidth(332))) uint332;
typedef unsigned int __attribute__ ((bitwidth(333))) uint333;
typedef unsigned int __attribute__ ((bitwidth(334))) uint334;
typedef unsigned int __attribute__ ((bitwidth(335))) uint335;
typedef unsigned int __attribute__ ((bitwidth(336))) uint336;
typedef unsigned int __attribute__ ((bitwidth(337))) uint337;
typedef unsigned int __attribute__ ((bitwidth(338))) uint338;
typedef unsigned int __attribute__ ((bitwidth(339))) uint339;
typedef unsigned int __attribute__ ((bitwidth(340))) uint340;
typedef unsigned int __attribute__ ((bitwidth(341))) uint341;
typedef unsigned int __attribute__ ((bitwidth(342))) uint342;
typedef unsigned int __attribute__ ((bitwidth(343))) uint343;
typedef unsigned int __attribute__ ((bitwidth(344))) uint344;
typedef unsigned int __attribute__ ((bitwidth(345))) uint345;
typedef unsigned int __attribute__ ((bitwidth(346))) uint346;
typedef unsigned int __attribute__ ((bitwidth(347))) uint347;
typedef unsigned int __attribute__ ((bitwidth(348))) uint348;
typedef unsigned int __attribute__ ((bitwidth(349))) uint349;
typedef unsigned int __attribute__ ((bitwidth(350))) uint350;
typedef unsigned int __attribute__ ((bitwidth(351))) uint351;
typedef unsigned int __attribute__ ((bitwidth(352))) uint352;
typedef unsigned int __attribute__ ((bitwidth(353))) uint353;
typedef unsigned int __attribute__ ((bitwidth(354))) uint354;
typedef unsigned int __attribute__ ((bitwidth(355))) uint355;
typedef unsigned int __attribute__ ((bitwidth(356))) uint356;
typedef unsigned int __attribute__ ((bitwidth(357))) uint357;
typedef unsigned int __attribute__ ((bitwidth(358))) uint358;
typedef unsigned int __attribute__ ((bitwidth(359))) uint359;
typedef unsigned int __attribute__ ((bitwidth(360))) uint360;
typedef unsigned int __attribute__ ((bitwidth(361))) uint361;
typedef unsigned int __attribute__ ((bitwidth(362))) uint362;
typedef unsigned int __attribute__ ((bitwidth(363))) uint363;
typedef unsigned int __attribute__ ((bitwidth(364))) uint364;
typedef unsigned int __attribute__ ((bitwidth(365))) uint365;
typedef unsigned int __attribute__ ((bitwidth(366))) uint366;
typedef unsigned int __attribute__ ((bitwidth(367))) uint367;
typedef unsigned int __attribute__ ((bitwidth(368))) uint368;
typedef unsigned int __attribute__ ((bitwidth(369))) uint369;
typedef unsigned int __attribute__ ((bitwidth(370))) uint370;
typedef unsigned int __attribute__ ((bitwidth(371))) uint371;
typedef unsigned int __attribute__ ((bitwidth(372))) uint372;
typedef unsigned int __attribute__ ((bitwidth(373))) uint373;
typedef unsigned int __attribute__ ((bitwidth(374))) uint374;
typedef unsigned int __attribute__ ((bitwidth(375))) uint375;
typedef unsigned int __attribute__ ((bitwidth(376))) uint376;
typedef unsigned int __attribute__ ((bitwidth(377))) uint377;
typedef unsigned int __attribute__ ((bitwidth(378))) uint378;
typedef unsigned int __attribute__ ((bitwidth(379))) uint379;
typedef unsigned int __attribute__ ((bitwidth(380))) uint380;
typedef unsigned int __attribute__ ((bitwidth(381))) uint381;
typedef unsigned int __attribute__ ((bitwidth(382))) uint382;
typedef unsigned int __attribute__ ((bitwidth(383))) uint383;
typedef unsigned int __attribute__ ((bitwidth(384))) uint384;
typedef unsigned int __attribute__ ((bitwidth(385))) uint385;
typedef unsigned int __attribute__ ((bitwidth(386))) uint386;
typedef unsigned int __attribute__ ((bitwidth(387))) uint387;
typedef unsigned int __attribute__ ((bitwidth(388))) uint388;
typedef unsigned int __attribute__ ((bitwidth(389))) uint389;
typedef unsigned int __attribute__ ((bitwidth(390))) uint390;
typedef unsigned int __attribute__ ((bitwidth(391))) uint391;
typedef unsigned int __attribute__ ((bitwidth(392))) uint392;
typedef unsigned int __attribute__ ((bitwidth(393))) uint393;
typedef unsigned int __attribute__ ((bitwidth(394))) uint394;
typedef unsigned int __attribute__ ((bitwidth(395))) uint395;
typedef unsigned int __attribute__ ((bitwidth(396))) uint396;
typedef unsigned int __attribute__ ((bitwidth(397))) uint397;
typedef unsigned int __attribute__ ((bitwidth(398))) uint398;
typedef unsigned int __attribute__ ((bitwidth(399))) uint399;
typedef unsigned int __attribute__ ((bitwidth(400))) uint400;
typedef unsigned int __attribute__ ((bitwidth(401))) uint401;
typedef unsigned int __attribute__ ((bitwidth(402))) uint402;
typedef unsigned int __attribute__ ((bitwidth(403))) uint403;
typedef unsigned int __attribute__ ((bitwidth(404))) uint404;
typedef unsigned int __attribute__ ((bitwidth(405))) uint405;
typedef unsigned int __attribute__ ((bitwidth(406))) uint406;
typedef unsigned int __attribute__ ((bitwidth(407))) uint407;
typedef unsigned int __attribute__ ((bitwidth(408))) uint408;
typedef unsigned int __attribute__ ((bitwidth(409))) uint409;
typedef unsigned int __attribute__ ((bitwidth(410))) uint410;
typedef unsigned int __attribute__ ((bitwidth(411))) uint411;
typedef unsigned int __attribute__ ((bitwidth(412))) uint412;
typedef unsigned int __attribute__ ((bitwidth(413))) uint413;
typedef unsigned int __attribute__ ((bitwidth(414))) uint414;
typedef unsigned int __attribute__ ((bitwidth(415))) uint415;
typedef unsigned int __attribute__ ((bitwidth(416))) uint416;
typedef unsigned int __attribute__ ((bitwidth(417))) uint417;
typedef unsigned int __attribute__ ((bitwidth(418))) uint418;
typedef unsigned int __attribute__ ((bitwidth(419))) uint419;
typedef unsigned int __attribute__ ((bitwidth(420))) uint420;
typedef unsigned int __attribute__ ((bitwidth(421))) uint421;
typedef unsigned int __attribute__ ((bitwidth(422))) uint422;
typedef unsigned int __attribute__ ((bitwidth(423))) uint423;
typedef unsigned int __attribute__ ((bitwidth(424))) uint424;
typedef unsigned int __attribute__ ((bitwidth(425))) uint425;
typedef unsigned int __attribute__ ((bitwidth(426))) uint426;
typedef unsigned int __attribute__ ((bitwidth(427))) uint427;
typedef unsigned int __attribute__ ((bitwidth(428))) uint428;
typedef unsigned int __attribute__ ((bitwidth(429))) uint429;
typedef unsigned int __attribute__ ((bitwidth(430))) uint430;
typedef unsigned int __attribute__ ((bitwidth(431))) uint431;
typedef unsigned int __attribute__ ((bitwidth(432))) uint432;
typedef unsigned int __attribute__ ((bitwidth(433))) uint433;
typedef unsigned int __attribute__ ((bitwidth(434))) uint434;
typedef unsigned int __attribute__ ((bitwidth(435))) uint435;
typedef unsigned int __attribute__ ((bitwidth(436))) uint436;
typedef unsigned int __attribute__ ((bitwidth(437))) uint437;
typedef unsigned int __attribute__ ((bitwidth(438))) uint438;
typedef unsigned int __attribute__ ((bitwidth(439))) uint439;
typedef unsigned int __attribute__ ((bitwidth(440))) uint440;
typedef unsigned int __attribute__ ((bitwidth(441))) uint441;
typedef unsigned int __attribute__ ((bitwidth(442))) uint442;
typedef unsigned int __attribute__ ((bitwidth(443))) uint443;
typedef unsigned int __attribute__ ((bitwidth(444))) uint444;
typedef unsigned int __attribute__ ((bitwidth(445))) uint445;
typedef unsigned int __attribute__ ((bitwidth(446))) uint446;
typedef unsigned int __attribute__ ((bitwidth(447))) uint447;
typedef unsigned int __attribute__ ((bitwidth(448))) uint448;
typedef unsigned int __attribute__ ((bitwidth(449))) uint449;
typedef unsigned int __attribute__ ((bitwidth(450))) uint450;
typedef unsigned int __attribute__ ((bitwidth(451))) uint451;
typedef unsigned int __attribute__ ((bitwidth(452))) uint452;
typedef unsigned int __attribute__ ((bitwidth(453))) uint453;
typedef unsigned int __attribute__ ((bitwidth(454))) uint454;
typedef unsigned int __attribute__ ((bitwidth(455))) uint455;
typedef unsigned int __attribute__ ((bitwidth(456))) uint456;
typedef unsigned int __attribute__ ((bitwidth(457))) uint457;
typedef unsigned int __attribute__ ((bitwidth(458))) uint458;
typedef unsigned int __attribute__ ((bitwidth(459))) uint459;
typedef unsigned int __attribute__ ((bitwidth(460))) uint460;
typedef unsigned int __attribute__ ((bitwidth(461))) uint461;
typedef unsigned int __attribute__ ((bitwidth(462))) uint462;
typedef unsigned int __attribute__ ((bitwidth(463))) uint463;
typedef unsigned int __attribute__ ((bitwidth(464))) uint464;
typedef unsigned int __attribute__ ((bitwidth(465))) uint465;
typedef unsigned int __attribute__ ((bitwidth(466))) uint466;
typedef unsigned int __attribute__ ((bitwidth(467))) uint467;
typedef unsigned int __attribute__ ((bitwidth(468))) uint468;
typedef unsigned int __attribute__ ((bitwidth(469))) uint469;
typedef unsigned int __attribute__ ((bitwidth(470))) uint470;
typedef unsigned int __attribute__ ((bitwidth(471))) uint471;
typedef unsigned int __attribute__ ((bitwidth(472))) uint472;
typedef unsigned int __attribute__ ((bitwidth(473))) uint473;
typedef unsigned int __attribute__ ((bitwidth(474))) uint474;
typedef unsigned int __attribute__ ((bitwidth(475))) uint475;
typedef unsigned int __attribute__ ((bitwidth(476))) uint476;
typedef unsigned int __attribute__ ((bitwidth(477))) uint477;
typedef unsigned int __attribute__ ((bitwidth(478))) uint478;
typedef unsigned int __attribute__ ((bitwidth(479))) uint479;
typedef unsigned int __attribute__ ((bitwidth(480))) uint480;
typedef unsigned int __attribute__ ((bitwidth(481))) uint481;
typedef unsigned int __attribute__ ((bitwidth(482))) uint482;
typedef unsigned int __attribute__ ((bitwidth(483))) uint483;
typedef unsigned int __attribute__ ((bitwidth(484))) uint484;
typedef unsigned int __attribute__ ((bitwidth(485))) uint485;
typedef unsigned int __attribute__ ((bitwidth(486))) uint486;
typedef unsigned int __attribute__ ((bitwidth(487))) uint487;
typedef unsigned int __attribute__ ((bitwidth(488))) uint488;
typedef unsigned int __attribute__ ((bitwidth(489))) uint489;
typedef unsigned int __attribute__ ((bitwidth(490))) uint490;
typedef unsigned int __attribute__ ((bitwidth(491))) uint491;
typedef unsigned int __attribute__ ((bitwidth(492))) uint492;
typedef unsigned int __attribute__ ((bitwidth(493))) uint493;
typedef unsigned int __attribute__ ((bitwidth(494))) uint494;
typedef unsigned int __attribute__ ((bitwidth(495))) uint495;
typedef unsigned int __attribute__ ((bitwidth(496))) uint496;
typedef unsigned int __attribute__ ((bitwidth(497))) uint497;
typedef unsigned int __attribute__ ((bitwidth(498))) uint498;
typedef unsigned int __attribute__ ((bitwidth(499))) uint499;
typedef unsigned int __attribute__ ((bitwidth(500))) uint500;
typedef unsigned int __attribute__ ((bitwidth(501))) uint501;
typedef unsigned int __attribute__ ((bitwidth(502))) uint502;
typedef unsigned int __attribute__ ((bitwidth(503))) uint503;
typedef unsigned int __attribute__ ((bitwidth(504))) uint504;
typedef unsigned int __attribute__ ((bitwidth(505))) uint505;
typedef unsigned int __attribute__ ((bitwidth(506))) uint506;
typedef unsigned int __attribute__ ((bitwidth(507))) uint507;
typedef unsigned int __attribute__ ((bitwidth(508))) uint508;
typedef unsigned int __attribute__ ((bitwidth(509))) uint509;
typedef unsigned int __attribute__ ((bitwidth(510))) uint510;
typedef unsigned int __attribute__ ((bitwidth(511))) uint511;
typedef unsigned int __attribute__ ((bitwidth(512))) uint512;
typedef unsigned int __attribute__ ((bitwidth(513))) uint513;
typedef unsigned int __attribute__ ((bitwidth(514))) uint514;
typedef unsigned int __attribute__ ((bitwidth(515))) uint515;
typedef unsigned int __attribute__ ((bitwidth(516))) uint516;
typedef unsigned int __attribute__ ((bitwidth(517))) uint517;
typedef unsigned int __attribute__ ((bitwidth(518))) uint518;
typedef unsigned int __attribute__ ((bitwidth(519))) uint519;
typedef unsigned int __attribute__ ((bitwidth(520))) uint520;
typedef unsigned int __attribute__ ((bitwidth(521))) uint521;
typedef unsigned int __attribute__ ((bitwidth(522))) uint522;
typedef unsigned int __attribute__ ((bitwidth(523))) uint523;
typedef unsigned int __attribute__ ((bitwidth(524))) uint524;
typedef unsigned int __attribute__ ((bitwidth(525))) uint525;
typedef unsigned int __attribute__ ((bitwidth(526))) uint526;
typedef unsigned int __attribute__ ((bitwidth(527))) uint527;
typedef unsigned int __attribute__ ((bitwidth(528))) uint528;
typedef unsigned int __attribute__ ((bitwidth(529))) uint529;
typedef unsigned int __attribute__ ((bitwidth(530))) uint530;
typedef unsigned int __attribute__ ((bitwidth(531))) uint531;
typedef unsigned int __attribute__ ((bitwidth(532))) uint532;
typedef unsigned int __attribute__ ((bitwidth(533))) uint533;
typedef unsigned int __attribute__ ((bitwidth(534))) uint534;
typedef unsigned int __attribute__ ((bitwidth(535))) uint535;
typedef unsigned int __attribute__ ((bitwidth(536))) uint536;
typedef unsigned int __attribute__ ((bitwidth(537))) uint537;
typedef unsigned int __attribute__ ((bitwidth(538))) uint538;
typedef unsigned int __attribute__ ((bitwidth(539))) uint539;
typedef unsigned int __attribute__ ((bitwidth(540))) uint540;
typedef unsigned int __attribute__ ((bitwidth(541))) uint541;
typedef unsigned int __attribute__ ((bitwidth(542))) uint542;
typedef unsigned int __attribute__ ((bitwidth(543))) uint543;
typedef unsigned int __attribute__ ((bitwidth(544))) uint544;
typedef unsigned int __attribute__ ((bitwidth(545))) uint545;
typedef unsigned int __attribute__ ((bitwidth(546))) uint546;
typedef unsigned int __attribute__ ((bitwidth(547))) uint547;
typedef unsigned int __attribute__ ((bitwidth(548))) uint548;
typedef unsigned int __attribute__ ((bitwidth(549))) uint549;
typedef unsigned int __attribute__ ((bitwidth(550))) uint550;
typedef unsigned int __attribute__ ((bitwidth(551))) uint551;
typedef unsigned int __attribute__ ((bitwidth(552))) uint552;
typedef unsigned int __attribute__ ((bitwidth(553))) uint553;
typedef unsigned int __attribute__ ((bitwidth(554))) uint554;
typedef unsigned int __attribute__ ((bitwidth(555))) uint555;
typedef unsigned int __attribute__ ((bitwidth(556))) uint556;
typedef unsigned int __attribute__ ((bitwidth(557))) uint557;
typedef unsigned int __attribute__ ((bitwidth(558))) uint558;
typedef unsigned int __attribute__ ((bitwidth(559))) uint559;
typedef unsigned int __attribute__ ((bitwidth(560))) uint560;
typedef unsigned int __attribute__ ((bitwidth(561))) uint561;
typedef unsigned int __attribute__ ((bitwidth(562))) uint562;
typedef unsigned int __attribute__ ((bitwidth(563))) uint563;
typedef unsigned int __attribute__ ((bitwidth(564))) uint564;
typedef unsigned int __attribute__ ((bitwidth(565))) uint565;
typedef unsigned int __attribute__ ((bitwidth(566))) uint566;
typedef unsigned int __attribute__ ((bitwidth(567))) uint567;
typedef unsigned int __attribute__ ((bitwidth(568))) uint568;
typedef unsigned int __attribute__ ((bitwidth(569))) uint569;
typedef unsigned int __attribute__ ((bitwidth(570))) uint570;
typedef unsigned int __attribute__ ((bitwidth(571))) uint571;
typedef unsigned int __attribute__ ((bitwidth(572))) uint572;
typedef unsigned int __attribute__ ((bitwidth(573))) uint573;
typedef unsigned int __attribute__ ((bitwidth(574))) uint574;
typedef unsigned int __attribute__ ((bitwidth(575))) uint575;
typedef unsigned int __attribute__ ((bitwidth(576))) uint576;
typedef unsigned int __attribute__ ((bitwidth(577))) uint577;
typedef unsigned int __attribute__ ((bitwidth(578))) uint578;
typedef unsigned int __attribute__ ((bitwidth(579))) uint579;
typedef unsigned int __attribute__ ((bitwidth(580))) uint580;
typedef unsigned int __attribute__ ((bitwidth(581))) uint581;
typedef unsigned int __attribute__ ((bitwidth(582))) uint582;
typedef unsigned int __attribute__ ((bitwidth(583))) uint583;
typedef unsigned int __attribute__ ((bitwidth(584))) uint584;
typedef unsigned int __attribute__ ((bitwidth(585))) uint585;
typedef unsigned int __attribute__ ((bitwidth(586))) uint586;
typedef unsigned int __attribute__ ((bitwidth(587))) uint587;
typedef unsigned int __attribute__ ((bitwidth(588))) uint588;
typedef unsigned int __attribute__ ((bitwidth(589))) uint589;
typedef unsigned int __attribute__ ((bitwidth(590))) uint590;
typedef unsigned int __attribute__ ((bitwidth(591))) uint591;
typedef unsigned int __attribute__ ((bitwidth(592))) uint592;
typedef unsigned int __attribute__ ((bitwidth(593))) uint593;
typedef unsigned int __attribute__ ((bitwidth(594))) uint594;
typedef unsigned int __attribute__ ((bitwidth(595))) uint595;
typedef unsigned int __attribute__ ((bitwidth(596))) uint596;
typedef unsigned int __attribute__ ((bitwidth(597))) uint597;
typedef unsigned int __attribute__ ((bitwidth(598))) uint598;
typedef unsigned int __attribute__ ((bitwidth(599))) uint599;
typedef unsigned int __attribute__ ((bitwidth(600))) uint600;
typedef unsigned int __attribute__ ((bitwidth(601))) uint601;
typedef unsigned int __attribute__ ((bitwidth(602))) uint602;
typedef unsigned int __attribute__ ((bitwidth(603))) uint603;
typedef unsigned int __attribute__ ((bitwidth(604))) uint604;
typedef unsigned int __attribute__ ((bitwidth(605))) uint605;
typedef unsigned int __attribute__ ((bitwidth(606))) uint606;
typedef unsigned int __attribute__ ((bitwidth(607))) uint607;
typedef unsigned int __attribute__ ((bitwidth(608))) uint608;
typedef unsigned int __attribute__ ((bitwidth(609))) uint609;
typedef unsigned int __attribute__ ((bitwidth(610))) uint610;
typedef unsigned int __attribute__ ((bitwidth(611))) uint611;
typedef unsigned int __attribute__ ((bitwidth(612))) uint612;
typedef unsigned int __attribute__ ((bitwidth(613))) uint613;
typedef unsigned int __attribute__ ((bitwidth(614))) uint614;
typedef unsigned int __attribute__ ((bitwidth(615))) uint615;
typedef unsigned int __attribute__ ((bitwidth(616))) uint616;
typedef unsigned int __attribute__ ((bitwidth(617))) uint617;
typedef unsigned int __attribute__ ((bitwidth(618))) uint618;
typedef unsigned int __attribute__ ((bitwidth(619))) uint619;
typedef unsigned int __attribute__ ((bitwidth(620))) uint620;
typedef unsigned int __attribute__ ((bitwidth(621))) uint621;
typedef unsigned int __attribute__ ((bitwidth(622))) uint622;
typedef unsigned int __attribute__ ((bitwidth(623))) uint623;
typedef unsigned int __attribute__ ((bitwidth(624))) uint624;
typedef unsigned int __attribute__ ((bitwidth(625))) uint625;
typedef unsigned int __attribute__ ((bitwidth(626))) uint626;
typedef unsigned int __attribute__ ((bitwidth(627))) uint627;
typedef unsigned int __attribute__ ((bitwidth(628))) uint628;
typedef unsigned int __attribute__ ((bitwidth(629))) uint629;
typedef unsigned int __attribute__ ((bitwidth(630))) uint630;
typedef unsigned int __attribute__ ((bitwidth(631))) uint631;
typedef unsigned int __attribute__ ((bitwidth(632))) uint632;
typedef unsigned int __attribute__ ((bitwidth(633))) uint633;
typedef unsigned int __attribute__ ((bitwidth(634))) uint634;
typedef unsigned int __attribute__ ((bitwidth(635))) uint635;
typedef unsigned int __attribute__ ((bitwidth(636))) uint636;
typedef unsigned int __attribute__ ((bitwidth(637))) uint637;
typedef unsigned int __attribute__ ((bitwidth(638))) uint638;
typedef unsigned int __attribute__ ((bitwidth(639))) uint639;
typedef unsigned int __attribute__ ((bitwidth(640))) uint640;
typedef unsigned int __attribute__ ((bitwidth(641))) uint641;
typedef unsigned int __attribute__ ((bitwidth(642))) uint642;
typedef unsigned int __attribute__ ((bitwidth(643))) uint643;
typedef unsigned int __attribute__ ((bitwidth(644))) uint644;
typedef unsigned int __attribute__ ((bitwidth(645))) uint645;
typedef unsigned int __attribute__ ((bitwidth(646))) uint646;
typedef unsigned int __attribute__ ((bitwidth(647))) uint647;
typedef unsigned int __attribute__ ((bitwidth(648))) uint648;
typedef unsigned int __attribute__ ((bitwidth(649))) uint649;
typedef unsigned int __attribute__ ((bitwidth(650))) uint650;
typedef unsigned int __attribute__ ((bitwidth(651))) uint651;
typedef unsigned int __attribute__ ((bitwidth(652))) uint652;
typedef unsigned int __attribute__ ((bitwidth(653))) uint653;
typedef unsigned int __attribute__ ((bitwidth(654))) uint654;
typedef unsigned int __attribute__ ((bitwidth(655))) uint655;
typedef unsigned int __attribute__ ((bitwidth(656))) uint656;
typedef unsigned int __attribute__ ((bitwidth(657))) uint657;
typedef unsigned int __attribute__ ((bitwidth(658))) uint658;
typedef unsigned int __attribute__ ((bitwidth(659))) uint659;
typedef unsigned int __attribute__ ((bitwidth(660))) uint660;
typedef unsigned int __attribute__ ((bitwidth(661))) uint661;
typedef unsigned int __attribute__ ((bitwidth(662))) uint662;
typedef unsigned int __attribute__ ((bitwidth(663))) uint663;
typedef unsigned int __attribute__ ((bitwidth(664))) uint664;
typedef unsigned int __attribute__ ((bitwidth(665))) uint665;
typedef unsigned int __attribute__ ((bitwidth(666))) uint666;
typedef unsigned int __attribute__ ((bitwidth(667))) uint667;
typedef unsigned int __attribute__ ((bitwidth(668))) uint668;
typedef unsigned int __attribute__ ((bitwidth(669))) uint669;
typedef unsigned int __attribute__ ((bitwidth(670))) uint670;
typedef unsigned int __attribute__ ((bitwidth(671))) uint671;
typedef unsigned int __attribute__ ((bitwidth(672))) uint672;
typedef unsigned int __attribute__ ((bitwidth(673))) uint673;
typedef unsigned int __attribute__ ((bitwidth(674))) uint674;
typedef unsigned int __attribute__ ((bitwidth(675))) uint675;
typedef unsigned int __attribute__ ((bitwidth(676))) uint676;
typedef unsigned int __attribute__ ((bitwidth(677))) uint677;
typedef unsigned int __attribute__ ((bitwidth(678))) uint678;
typedef unsigned int __attribute__ ((bitwidth(679))) uint679;
typedef unsigned int __attribute__ ((bitwidth(680))) uint680;
typedef unsigned int __attribute__ ((bitwidth(681))) uint681;
typedef unsigned int __attribute__ ((bitwidth(682))) uint682;
typedef unsigned int __attribute__ ((bitwidth(683))) uint683;
typedef unsigned int __attribute__ ((bitwidth(684))) uint684;
typedef unsigned int __attribute__ ((bitwidth(685))) uint685;
typedef unsigned int __attribute__ ((bitwidth(686))) uint686;
typedef unsigned int __attribute__ ((bitwidth(687))) uint687;
typedef unsigned int __attribute__ ((bitwidth(688))) uint688;
typedef unsigned int __attribute__ ((bitwidth(689))) uint689;
typedef unsigned int __attribute__ ((bitwidth(690))) uint690;
typedef unsigned int __attribute__ ((bitwidth(691))) uint691;
typedef unsigned int __attribute__ ((bitwidth(692))) uint692;
typedef unsigned int __attribute__ ((bitwidth(693))) uint693;
typedef unsigned int __attribute__ ((bitwidth(694))) uint694;
typedef unsigned int __attribute__ ((bitwidth(695))) uint695;
typedef unsigned int __attribute__ ((bitwidth(696))) uint696;
typedef unsigned int __attribute__ ((bitwidth(697))) uint697;
typedef unsigned int __attribute__ ((bitwidth(698))) uint698;
typedef unsigned int __attribute__ ((bitwidth(699))) uint699;
typedef unsigned int __attribute__ ((bitwidth(700))) uint700;
typedef unsigned int __attribute__ ((bitwidth(701))) uint701;
typedef unsigned int __attribute__ ((bitwidth(702))) uint702;
typedef unsigned int __attribute__ ((bitwidth(703))) uint703;
typedef unsigned int __attribute__ ((bitwidth(704))) uint704;
typedef unsigned int __attribute__ ((bitwidth(705))) uint705;
typedef unsigned int __attribute__ ((bitwidth(706))) uint706;
typedef unsigned int __attribute__ ((bitwidth(707))) uint707;
typedef unsigned int __attribute__ ((bitwidth(708))) uint708;
typedef unsigned int __attribute__ ((bitwidth(709))) uint709;
typedef unsigned int __attribute__ ((bitwidth(710))) uint710;
typedef unsigned int __attribute__ ((bitwidth(711))) uint711;
typedef unsigned int __attribute__ ((bitwidth(712))) uint712;
typedef unsigned int __attribute__ ((bitwidth(713))) uint713;
typedef unsigned int __attribute__ ((bitwidth(714))) uint714;
typedef unsigned int __attribute__ ((bitwidth(715))) uint715;
typedef unsigned int __attribute__ ((bitwidth(716))) uint716;
typedef unsigned int __attribute__ ((bitwidth(717))) uint717;
typedef unsigned int __attribute__ ((bitwidth(718))) uint718;
typedef unsigned int __attribute__ ((bitwidth(719))) uint719;
typedef unsigned int __attribute__ ((bitwidth(720))) uint720;
typedef unsigned int __attribute__ ((bitwidth(721))) uint721;
typedef unsigned int __attribute__ ((bitwidth(722))) uint722;
typedef unsigned int __attribute__ ((bitwidth(723))) uint723;
typedef unsigned int __attribute__ ((bitwidth(724))) uint724;
typedef unsigned int __attribute__ ((bitwidth(725))) uint725;
typedef unsigned int __attribute__ ((bitwidth(726))) uint726;
typedef unsigned int __attribute__ ((bitwidth(727))) uint727;
typedef unsigned int __attribute__ ((bitwidth(728))) uint728;
typedef unsigned int __attribute__ ((bitwidth(729))) uint729;
typedef unsigned int __attribute__ ((bitwidth(730))) uint730;
typedef unsigned int __attribute__ ((bitwidth(731))) uint731;
typedef unsigned int __attribute__ ((bitwidth(732))) uint732;
typedef unsigned int __attribute__ ((bitwidth(733))) uint733;
typedef unsigned int __attribute__ ((bitwidth(734))) uint734;
typedef unsigned int __attribute__ ((bitwidth(735))) uint735;
typedef unsigned int __attribute__ ((bitwidth(736))) uint736;
typedef unsigned int __attribute__ ((bitwidth(737))) uint737;
typedef unsigned int __attribute__ ((bitwidth(738))) uint738;
typedef unsigned int __attribute__ ((bitwidth(739))) uint739;
typedef unsigned int __attribute__ ((bitwidth(740))) uint740;
typedef unsigned int __attribute__ ((bitwidth(741))) uint741;
typedef unsigned int __attribute__ ((bitwidth(742))) uint742;
typedef unsigned int __attribute__ ((bitwidth(743))) uint743;
typedef unsigned int __attribute__ ((bitwidth(744))) uint744;
typedef unsigned int __attribute__ ((bitwidth(745))) uint745;
typedef unsigned int __attribute__ ((bitwidth(746))) uint746;
typedef unsigned int __attribute__ ((bitwidth(747))) uint747;
typedef unsigned int __attribute__ ((bitwidth(748))) uint748;
typedef unsigned int __attribute__ ((bitwidth(749))) uint749;
typedef unsigned int __attribute__ ((bitwidth(750))) uint750;
typedef unsigned int __attribute__ ((bitwidth(751))) uint751;
typedef unsigned int __attribute__ ((bitwidth(752))) uint752;
typedef unsigned int __attribute__ ((bitwidth(753))) uint753;
typedef unsigned int __attribute__ ((bitwidth(754))) uint754;
typedef unsigned int __attribute__ ((bitwidth(755))) uint755;
typedef unsigned int __attribute__ ((bitwidth(756))) uint756;
typedef unsigned int __attribute__ ((bitwidth(757))) uint757;
typedef unsigned int __attribute__ ((bitwidth(758))) uint758;
typedef unsigned int __attribute__ ((bitwidth(759))) uint759;
typedef unsigned int __attribute__ ((bitwidth(760))) uint760;
typedef unsigned int __attribute__ ((bitwidth(761))) uint761;
typedef unsigned int __attribute__ ((bitwidth(762))) uint762;
typedef unsigned int __attribute__ ((bitwidth(763))) uint763;
typedef unsigned int __attribute__ ((bitwidth(764))) uint764;
typedef unsigned int __attribute__ ((bitwidth(765))) uint765;
typedef unsigned int __attribute__ ((bitwidth(766))) uint766;
typedef unsigned int __attribute__ ((bitwidth(767))) uint767;
typedef unsigned int __attribute__ ((bitwidth(768))) uint768;
typedef unsigned int __attribute__ ((bitwidth(769))) uint769;
typedef unsigned int __attribute__ ((bitwidth(770))) uint770;
typedef unsigned int __attribute__ ((bitwidth(771))) uint771;
typedef unsigned int __attribute__ ((bitwidth(772))) uint772;
typedef unsigned int __attribute__ ((bitwidth(773))) uint773;
typedef unsigned int __attribute__ ((bitwidth(774))) uint774;
typedef unsigned int __attribute__ ((bitwidth(775))) uint775;
typedef unsigned int __attribute__ ((bitwidth(776))) uint776;
typedef unsigned int __attribute__ ((bitwidth(777))) uint777;
typedef unsigned int __attribute__ ((bitwidth(778))) uint778;
typedef unsigned int __attribute__ ((bitwidth(779))) uint779;
typedef unsigned int __attribute__ ((bitwidth(780))) uint780;
typedef unsigned int __attribute__ ((bitwidth(781))) uint781;
typedef unsigned int __attribute__ ((bitwidth(782))) uint782;
typedef unsigned int __attribute__ ((bitwidth(783))) uint783;
typedef unsigned int __attribute__ ((bitwidth(784))) uint784;
typedef unsigned int __attribute__ ((bitwidth(785))) uint785;
typedef unsigned int __attribute__ ((bitwidth(786))) uint786;
typedef unsigned int __attribute__ ((bitwidth(787))) uint787;
typedef unsigned int __attribute__ ((bitwidth(788))) uint788;
typedef unsigned int __attribute__ ((bitwidth(789))) uint789;
typedef unsigned int __attribute__ ((bitwidth(790))) uint790;
typedef unsigned int __attribute__ ((bitwidth(791))) uint791;
typedef unsigned int __attribute__ ((bitwidth(792))) uint792;
typedef unsigned int __attribute__ ((bitwidth(793))) uint793;
typedef unsigned int __attribute__ ((bitwidth(794))) uint794;
typedef unsigned int __attribute__ ((bitwidth(795))) uint795;
typedef unsigned int __attribute__ ((bitwidth(796))) uint796;
typedef unsigned int __attribute__ ((bitwidth(797))) uint797;
typedef unsigned int __attribute__ ((bitwidth(798))) uint798;
typedef unsigned int __attribute__ ((bitwidth(799))) uint799;
typedef unsigned int __attribute__ ((bitwidth(800))) uint800;
typedef unsigned int __attribute__ ((bitwidth(801))) uint801;
typedef unsigned int __attribute__ ((bitwidth(802))) uint802;
typedef unsigned int __attribute__ ((bitwidth(803))) uint803;
typedef unsigned int __attribute__ ((bitwidth(804))) uint804;
typedef unsigned int __attribute__ ((bitwidth(805))) uint805;
typedef unsigned int __attribute__ ((bitwidth(806))) uint806;
typedef unsigned int __attribute__ ((bitwidth(807))) uint807;
typedef unsigned int __attribute__ ((bitwidth(808))) uint808;
typedef unsigned int __attribute__ ((bitwidth(809))) uint809;
typedef unsigned int __attribute__ ((bitwidth(810))) uint810;
typedef unsigned int __attribute__ ((bitwidth(811))) uint811;
typedef unsigned int __attribute__ ((bitwidth(812))) uint812;
typedef unsigned int __attribute__ ((bitwidth(813))) uint813;
typedef unsigned int __attribute__ ((bitwidth(814))) uint814;
typedef unsigned int __attribute__ ((bitwidth(815))) uint815;
typedef unsigned int __attribute__ ((bitwidth(816))) uint816;
typedef unsigned int __attribute__ ((bitwidth(817))) uint817;
typedef unsigned int __attribute__ ((bitwidth(818))) uint818;
typedef unsigned int __attribute__ ((bitwidth(819))) uint819;
typedef unsigned int __attribute__ ((bitwidth(820))) uint820;
typedef unsigned int __attribute__ ((bitwidth(821))) uint821;
typedef unsigned int __attribute__ ((bitwidth(822))) uint822;
typedef unsigned int __attribute__ ((bitwidth(823))) uint823;
typedef unsigned int __attribute__ ((bitwidth(824))) uint824;
typedef unsigned int __attribute__ ((bitwidth(825))) uint825;
typedef unsigned int __attribute__ ((bitwidth(826))) uint826;
typedef unsigned int __attribute__ ((bitwidth(827))) uint827;
typedef unsigned int __attribute__ ((bitwidth(828))) uint828;
typedef unsigned int __attribute__ ((bitwidth(829))) uint829;
typedef unsigned int __attribute__ ((bitwidth(830))) uint830;
typedef unsigned int __attribute__ ((bitwidth(831))) uint831;
typedef unsigned int __attribute__ ((bitwidth(832))) uint832;
typedef unsigned int __attribute__ ((bitwidth(833))) uint833;
typedef unsigned int __attribute__ ((bitwidth(834))) uint834;
typedef unsigned int __attribute__ ((bitwidth(835))) uint835;
typedef unsigned int __attribute__ ((bitwidth(836))) uint836;
typedef unsigned int __attribute__ ((bitwidth(837))) uint837;
typedef unsigned int __attribute__ ((bitwidth(838))) uint838;
typedef unsigned int __attribute__ ((bitwidth(839))) uint839;
typedef unsigned int __attribute__ ((bitwidth(840))) uint840;
typedef unsigned int __attribute__ ((bitwidth(841))) uint841;
typedef unsigned int __attribute__ ((bitwidth(842))) uint842;
typedef unsigned int __attribute__ ((bitwidth(843))) uint843;
typedef unsigned int __attribute__ ((bitwidth(844))) uint844;
typedef unsigned int __attribute__ ((bitwidth(845))) uint845;
typedef unsigned int __attribute__ ((bitwidth(846))) uint846;
typedef unsigned int __attribute__ ((bitwidth(847))) uint847;
typedef unsigned int __attribute__ ((bitwidth(848))) uint848;
typedef unsigned int __attribute__ ((bitwidth(849))) uint849;
typedef unsigned int __attribute__ ((bitwidth(850))) uint850;
typedef unsigned int __attribute__ ((bitwidth(851))) uint851;
typedef unsigned int __attribute__ ((bitwidth(852))) uint852;
typedef unsigned int __attribute__ ((bitwidth(853))) uint853;
typedef unsigned int __attribute__ ((bitwidth(854))) uint854;
typedef unsigned int __attribute__ ((bitwidth(855))) uint855;
typedef unsigned int __attribute__ ((bitwidth(856))) uint856;
typedef unsigned int __attribute__ ((bitwidth(857))) uint857;
typedef unsigned int __attribute__ ((bitwidth(858))) uint858;
typedef unsigned int __attribute__ ((bitwidth(859))) uint859;
typedef unsigned int __attribute__ ((bitwidth(860))) uint860;
typedef unsigned int __attribute__ ((bitwidth(861))) uint861;
typedef unsigned int __attribute__ ((bitwidth(862))) uint862;
typedef unsigned int __attribute__ ((bitwidth(863))) uint863;
typedef unsigned int __attribute__ ((bitwidth(864))) uint864;
typedef unsigned int __attribute__ ((bitwidth(865))) uint865;
typedef unsigned int __attribute__ ((bitwidth(866))) uint866;
typedef unsigned int __attribute__ ((bitwidth(867))) uint867;
typedef unsigned int __attribute__ ((bitwidth(868))) uint868;
typedef unsigned int __attribute__ ((bitwidth(869))) uint869;
typedef unsigned int __attribute__ ((bitwidth(870))) uint870;
typedef unsigned int __attribute__ ((bitwidth(871))) uint871;
typedef unsigned int __attribute__ ((bitwidth(872))) uint872;
typedef unsigned int __attribute__ ((bitwidth(873))) uint873;
typedef unsigned int __attribute__ ((bitwidth(874))) uint874;
typedef unsigned int __attribute__ ((bitwidth(875))) uint875;
typedef unsigned int __attribute__ ((bitwidth(876))) uint876;
typedef unsigned int __attribute__ ((bitwidth(877))) uint877;
typedef unsigned int __attribute__ ((bitwidth(878))) uint878;
typedef unsigned int __attribute__ ((bitwidth(879))) uint879;
typedef unsigned int __attribute__ ((bitwidth(880))) uint880;
typedef unsigned int __attribute__ ((bitwidth(881))) uint881;
typedef unsigned int __attribute__ ((bitwidth(882))) uint882;
typedef unsigned int __attribute__ ((bitwidth(883))) uint883;
typedef unsigned int __attribute__ ((bitwidth(884))) uint884;
typedef unsigned int __attribute__ ((bitwidth(885))) uint885;
typedef unsigned int __attribute__ ((bitwidth(886))) uint886;
typedef unsigned int __attribute__ ((bitwidth(887))) uint887;
typedef unsigned int __attribute__ ((bitwidth(888))) uint888;
typedef unsigned int __attribute__ ((bitwidth(889))) uint889;
typedef unsigned int __attribute__ ((bitwidth(890))) uint890;
typedef unsigned int __attribute__ ((bitwidth(891))) uint891;
typedef unsigned int __attribute__ ((bitwidth(892))) uint892;
typedef unsigned int __attribute__ ((bitwidth(893))) uint893;
typedef unsigned int __attribute__ ((bitwidth(894))) uint894;
typedef unsigned int __attribute__ ((bitwidth(895))) uint895;
typedef unsigned int __attribute__ ((bitwidth(896))) uint896;
typedef unsigned int __attribute__ ((bitwidth(897))) uint897;
typedef unsigned int __attribute__ ((bitwidth(898))) uint898;
typedef unsigned int __attribute__ ((bitwidth(899))) uint899;
typedef unsigned int __attribute__ ((bitwidth(900))) uint900;
typedef unsigned int __attribute__ ((bitwidth(901))) uint901;
typedef unsigned int __attribute__ ((bitwidth(902))) uint902;
typedef unsigned int __attribute__ ((bitwidth(903))) uint903;
typedef unsigned int __attribute__ ((bitwidth(904))) uint904;
typedef unsigned int __attribute__ ((bitwidth(905))) uint905;
typedef unsigned int __attribute__ ((bitwidth(906))) uint906;
typedef unsigned int __attribute__ ((bitwidth(907))) uint907;
typedef unsigned int __attribute__ ((bitwidth(908))) uint908;
typedef unsigned int __attribute__ ((bitwidth(909))) uint909;
typedef unsigned int __attribute__ ((bitwidth(910))) uint910;
typedef unsigned int __attribute__ ((bitwidth(911))) uint911;
typedef unsigned int __attribute__ ((bitwidth(912))) uint912;
typedef unsigned int __attribute__ ((bitwidth(913))) uint913;
typedef unsigned int __attribute__ ((bitwidth(914))) uint914;
typedef unsigned int __attribute__ ((bitwidth(915))) uint915;
typedef unsigned int __attribute__ ((bitwidth(916))) uint916;
typedef unsigned int __attribute__ ((bitwidth(917))) uint917;
typedef unsigned int __attribute__ ((bitwidth(918))) uint918;
typedef unsigned int __attribute__ ((bitwidth(919))) uint919;
typedef unsigned int __attribute__ ((bitwidth(920))) uint920;
typedef unsigned int __attribute__ ((bitwidth(921))) uint921;
typedef unsigned int __attribute__ ((bitwidth(922))) uint922;
typedef unsigned int __attribute__ ((bitwidth(923))) uint923;
typedef unsigned int __attribute__ ((bitwidth(924))) uint924;
typedef unsigned int __attribute__ ((bitwidth(925))) uint925;
typedef unsigned int __attribute__ ((bitwidth(926))) uint926;
typedef unsigned int __attribute__ ((bitwidth(927))) uint927;
typedef unsigned int __attribute__ ((bitwidth(928))) uint928;
typedef unsigned int __attribute__ ((bitwidth(929))) uint929;
typedef unsigned int __attribute__ ((bitwidth(930))) uint930;
typedef unsigned int __attribute__ ((bitwidth(931))) uint931;
typedef unsigned int __attribute__ ((bitwidth(932))) uint932;
typedef unsigned int __attribute__ ((bitwidth(933))) uint933;
typedef unsigned int __attribute__ ((bitwidth(934))) uint934;
typedef unsigned int __attribute__ ((bitwidth(935))) uint935;
typedef unsigned int __attribute__ ((bitwidth(936))) uint936;
typedef unsigned int __attribute__ ((bitwidth(937))) uint937;
typedef unsigned int __attribute__ ((bitwidth(938))) uint938;
typedef unsigned int __attribute__ ((bitwidth(939))) uint939;
typedef unsigned int __attribute__ ((bitwidth(940))) uint940;
typedef unsigned int __attribute__ ((bitwidth(941))) uint941;
typedef unsigned int __attribute__ ((bitwidth(942))) uint942;
typedef unsigned int __attribute__ ((bitwidth(943))) uint943;
typedef unsigned int __attribute__ ((bitwidth(944))) uint944;
typedef unsigned int __attribute__ ((bitwidth(945))) uint945;
typedef unsigned int __attribute__ ((bitwidth(946))) uint946;
typedef unsigned int __attribute__ ((bitwidth(947))) uint947;
typedef unsigned int __attribute__ ((bitwidth(948))) uint948;
typedef unsigned int __attribute__ ((bitwidth(949))) uint949;
typedef unsigned int __attribute__ ((bitwidth(950))) uint950;
typedef unsigned int __attribute__ ((bitwidth(951))) uint951;
typedef unsigned int __attribute__ ((bitwidth(952))) uint952;
typedef unsigned int __attribute__ ((bitwidth(953))) uint953;
typedef unsigned int __attribute__ ((bitwidth(954))) uint954;
typedef unsigned int __attribute__ ((bitwidth(955))) uint955;
typedef unsigned int __attribute__ ((bitwidth(956))) uint956;
typedef unsigned int __attribute__ ((bitwidth(957))) uint957;
typedef unsigned int __attribute__ ((bitwidth(958))) uint958;
typedef unsigned int __attribute__ ((bitwidth(959))) uint959;
typedef unsigned int __attribute__ ((bitwidth(960))) uint960;
typedef unsigned int __attribute__ ((bitwidth(961))) uint961;
typedef unsigned int __attribute__ ((bitwidth(962))) uint962;
typedef unsigned int __attribute__ ((bitwidth(963))) uint963;
typedef unsigned int __attribute__ ((bitwidth(964))) uint964;
typedef unsigned int __attribute__ ((bitwidth(965))) uint965;
typedef unsigned int __attribute__ ((bitwidth(966))) uint966;
typedef unsigned int __attribute__ ((bitwidth(967))) uint967;
typedef unsigned int __attribute__ ((bitwidth(968))) uint968;
typedef unsigned int __attribute__ ((bitwidth(969))) uint969;
typedef unsigned int __attribute__ ((bitwidth(970))) uint970;
typedef unsigned int __attribute__ ((bitwidth(971))) uint971;
typedef unsigned int __attribute__ ((bitwidth(972))) uint972;
typedef unsigned int __attribute__ ((bitwidth(973))) uint973;
typedef unsigned int __attribute__ ((bitwidth(974))) uint974;
typedef unsigned int __attribute__ ((bitwidth(975))) uint975;
typedef unsigned int __attribute__ ((bitwidth(976))) uint976;
typedef unsigned int __attribute__ ((bitwidth(977))) uint977;
typedef unsigned int __attribute__ ((bitwidth(978))) uint978;
typedef unsigned int __attribute__ ((bitwidth(979))) uint979;
typedef unsigned int __attribute__ ((bitwidth(980))) uint980;
typedef unsigned int __attribute__ ((bitwidth(981))) uint981;
typedef unsigned int __attribute__ ((bitwidth(982))) uint982;
typedef unsigned int __attribute__ ((bitwidth(983))) uint983;
typedef unsigned int __attribute__ ((bitwidth(984))) uint984;
typedef unsigned int __attribute__ ((bitwidth(985))) uint985;
typedef unsigned int __attribute__ ((bitwidth(986))) uint986;
typedef unsigned int __attribute__ ((bitwidth(987))) uint987;
typedef unsigned int __attribute__ ((bitwidth(988))) uint988;
typedef unsigned int __attribute__ ((bitwidth(989))) uint989;
typedef unsigned int __attribute__ ((bitwidth(990))) uint990;
typedef unsigned int __attribute__ ((bitwidth(991))) uint991;
typedef unsigned int __attribute__ ((bitwidth(992))) uint992;
typedef unsigned int __attribute__ ((bitwidth(993))) uint993;
typedef unsigned int __attribute__ ((bitwidth(994))) uint994;
typedef unsigned int __attribute__ ((bitwidth(995))) uint995;
typedef unsigned int __attribute__ ((bitwidth(996))) uint996;
typedef unsigned int __attribute__ ((bitwidth(997))) uint997;
typedef unsigned int __attribute__ ((bitwidth(998))) uint998;
typedef unsigned int __attribute__ ((bitwidth(999))) uint999;
typedef unsigned int __attribute__ ((bitwidth(1000))) uint1000;
typedef unsigned int __attribute__ ((bitwidth(1001))) uint1001;
typedef unsigned int __attribute__ ((bitwidth(1002))) uint1002;
typedef unsigned int __attribute__ ((bitwidth(1003))) uint1003;
typedef unsigned int __attribute__ ((bitwidth(1004))) uint1004;
typedef unsigned int __attribute__ ((bitwidth(1005))) uint1005;
typedef unsigned int __attribute__ ((bitwidth(1006))) uint1006;
typedef unsigned int __attribute__ ((bitwidth(1007))) uint1007;
typedef unsigned int __attribute__ ((bitwidth(1008))) uint1008;
typedef unsigned int __attribute__ ((bitwidth(1009))) uint1009;
typedef unsigned int __attribute__ ((bitwidth(1010))) uint1010;
typedef unsigned int __attribute__ ((bitwidth(1011))) uint1011;
typedef unsigned int __attribute__ ((bitwidth(1012))) uint1012;
typedef unsigned int __attribute__ ((bitwidth(1013))) uint1013;
typedef unsigned int __attribute__ ((bitwidth(1014))) uint1014;
typedef unsigned int __attribute__ ((bitwidth(1015))) uint1015;
typedef unsigned int __attribute__ ((bitwidth(1016))) uint1016;
typedef unsigned int __attribute__ ((bitwidth(1017))) uint1017;
typedef unsigned int __attribute__ ((bitwidth(1018))) uint1018;
typedef unsigned int __attribute__ ((bitwidth(1019))) uint1019;
typedef unsigned int __attribute__ ((bitwidth(1020))) uint1020;
typedef unsigned int __attribute__ ((bitwidth(1021))) uint1021;
typedef unsigned int __attribute__ ((bitwidth(1022))) uint1022;
typedef unsigned int __attribute__ ((bitwidth(1023))) uint1023;
typedef unsigned int __attribute__ ((bitwidth(1024))) uint1024;
#pragma line 109 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt_ext.def" 1
#pragma empty_line
#pragma empty_line
typedef unsigned int __attribute__ ((bitwidth(1025))) uint1025;
typedef unsigned int __attribute__ ((bitwidth(1026))) uint1026;
typedef unsigned int __attribute__ ((bitwidth(1027))) uint1027;
typedef unsigned int __attribute__ ((bitwidth(1028))) uint1028;
typedef unsigned int __attribute__ ((bitwidth(1029))) uint1029;
typedef unsigned int __attribute__ ((bitwidth(1030))) uint1030;
typedef unsigned int __attribute__ ((bitwidth(1031))) uint1031;
typedef unsigned int __attribute__ ((bitwidth(1032))) uint1032;
typedef unsigned int __attribute__ ((bitwidth(1033))) uint1033;
typedef unsigned int __attribute__ ((bitwidth(1034))) uint1034;
typedef unsigned int __attribute__ ((bitwidth(1035))) uint1035;
typedef unsigned int __attribute__ ((bitwidth(1036))) uint1036;
typedef unsigned int __attribute__ ((bitwidth(1037))) uint1037;
typedef unsigned int __attribute__ ((bitwidth(1038))) uint1038;
typedef unsigned int __attribute__ ((bitwidth(1039))) uint1039;
typedef unsigned int __attribute__ ((bitwidth(1040))) uint1040;
typedef unsigned int __attribute__ ((bitwidth(1041))) uint1041;
typedef unsigned int __attribute__ ((bitwidth(1042))) uint1042;
typedef unsigned int __attribute__ ((bitwidth(1043))) uint1043;
typedef unsigned int __attribute__ ((bitwidth(1044))) uint1044;
typedef unsigned int __attribute__ ((bitwidth(1045))) uint1045;
typedef unsigned int __attribute__ ((bitwidth(1046))) uint1046;
typedef unsigned int __attribute__ ((bitwidth(1047))) uint1047;
typedef unsigned int __attribute__ ((bitwidth(1048))) uint1048;
typedef unsigned int __attribute__ ((bitwidth(1049))) uint1049;
typedef unsigned int __attribute__ ((bitwidth(1050))) uint1050;
typedef unsigned int __attribute__ ((bitwidth(1051))) uint1051;
typedef unsigned int __attribute__ ((bitwidth(1052))) uint1052;
typedef unsigned int __attribute__ ((bitwidth(1053))) uint1053;
typedef unsigned int __attribute__ ((bitwidth(1054))) uint1054;
typedef unsigned int __attribute__ ((bitwidth(1055))) uint1055;
typedef unsigned int __attribute__ ((bitwidth(1056))) uint1056;
typedef unsigned int __attribute__ ((bitwidth(1057))) uint1057;
typedef unsigned int __attribute__ ((bitwidth(1058))) uint1058;
typedef unsigned int __attribute__ ((bitwidth(1059))) uint1059;
typedef unsigned int __attribute__ ((bitwidth(1060))) uint1060;
typedef unsigned int __attribute__ ((bitwidth(1061))) uint1061;
typedef unsigned int __attribute__ ((bitwidth(1062))) uint1062;
typedef unsigned int __attribute__ ((bitwidth(1063))) uint1063;
typedef unsigned int __attribute__ ((bitwidth(1064))) uint1064;
typedef unsigned int __attribute__ ((bitwidth(1065))) uint1065;
typedef unsigned int __attribute__ ((bitwidth(1066))) uint1066;
typedef unsigned int __attribute__ ((bitwidth(1067))) uint1067;
typedef unsigned int __attribute__ ((bitwidth(1068))) uint1068;
typedef unsigned int __attribute__ ((bitwidth(1069))) uint1069;
typedef unsigned int __attribute__ ((bitwidth(1070))) uint1070;
typedef unsigned int __attribute__ ((bitwidth(1071))) uint1071;
typedef unsigned int __attribute__ ((bitwidth(1072))) uint1072;
typedef unsigned int __attribute__ ((bitwidth(1073))) uint1073;
typedef unsigned int __attribute__ ((bitwidth(1074))) uint1074;
typedef unsigned int __attribute__ ((bitwidth(1075))) uint1075;
typedef unsigned int __attribute__ ((bitwidth(1076))) uint1076;
typedef unsigned int __attribute__ ((bitwidth(1077))) uint1077;
typedef unsigned int __attribute__ ((bitwidth(1078))) uint1078;
typedef unsigned int __attribute__ ((bitwidth(1079))) uint1079;
typedef unsigned int __attribute__ ((bitwidth(1080))) uint1080;
typedef unsigned int __attribute__ ((bitwidth(1081))) uint1081;
typedef unsigned int __attribute__ ((bitwidth(1082))) uint1082;
typedef unsigned int __attribute__ ((bitwidth(1083))) uint1083;
typedef unsigned int __attribute__ ((bitwidth(1084))) uint1084;
typedef unsigned int __attribute__ ((bitwidth(1085))) uint1085;
typedef unsigned int __attribute__ ((bitwidth(1086))) uint1086;
typedef unsigned int __attribute__ ((bitwidth(1087))) uint1087;
typedef unsigned int __attribute__ ((bitwidth(1088))) uint1088;
typedef unsigned int __attribute__ ((bitwidth(1089))) uint1089;
typedef unsigned int __attribute__ ((bitwidth(1090))) uint1090;
typedef unsigned int __attribute__ ((bitwidth(1091))) uint1091;
typedef unsigned int __attribute__ ((bitwidth(1092))) uint1092;
typedef unsigned int __attribute__ ((bitwidth(1093))) uint1093;
typedef unsigned int __attribute__ ((bitwidth(1094))) uint1094;
typedef unsigned int __attribute__ ((bitwidth(1095))) uint1095;
typedef unsigned int __attribute__ ((bitwidth(1096))) uint1096;
typedef unsigned int __attribute__ ((bitwidth(1097))) uint1097;
typedef unsigned int __attribute__ ((bitwidth(1098))) uint1098;
typedef unsigned int __attribute__ ((bitwidth(1099))) uint1099;
typedef unsigned int __attribute__ ((bitwidth(1100))) uint1100;
typedef unsigned int __attribute__ ((bitwidth(1101))) uint1101;
typedef unsigned int __attribute__ ((bitwidth(1102))) uint1102;
typedef unsigned int __attribute__ ((bitwidth(1103))) uint1103;
typedef unsigned int __attribute__ ((bitwidth(1104))) uint1104;
typedef unsigned int __attribute__ ((bitwidth(1105))) uint1105;
typedef unsigned int __attribute__ ((bitwidth(1106))) uint1106;
typedef unsigned int __attribute__ ((bitwidth(1107))) uint1107;
typedef unsigned int __attribute__ ((bitwidth(1108))) uint1108;
typedef unsigned int __attribute__ ((bitwidth(1109))) uint1109;
typedef unsigned int __attribute__ ((bitwidth(1110))) uint1110;
typedef unsigned int __attribute__ ((bitwidth(1111))) uint1111;
typedef unsigned int __attribute__ ((bitwidth(1112))) uint1112;
typedef unsigned int __attribute__ ((bitwidth(1113))) uint1113;
typedef unsigned int __attribute__ ((bitwidth(1114))) uint1114;
typedef unsigned int __attribute__ ((bitwidth(1115))) uint1115;
typedef unsigned int __attribute__ ((bitwidth(1116))) uint1116;
typedef unsigned int __attribute__ ((bitwidth(1117))) uint1117;
typedef unsigned int __attribute__ ((bitwidth(1118))) uint1118;
typedef unsigned int __attribute__ ((bitwidth(1119))) uint1119;
typedef unsigned int __attribute__ ((bitwidth(1120))) uint1120;
typedef unsigned int __attribute__ ((bitwidth(1121))) uint1121;
typedef unsigned int __attribute__ ((bitwidth(1122))) uint1122;
typedef unsigned int __attribute__ ((bitwidth(1123))) uint1123;
typedef unsigned int __attribute__ ((bitwidth(1124))) uint1124;
typedef unsigned int __attribute__ ((bitwidth(1125))) uint1125;
typedef unsigned int __attribute__ ((bitwidth(1126))) uint1126;
typedef unsigned int __attribute__ ((bitwidth(1127))) uint1127;
typedef unsigned int __attribute__ ((bitwidth(1128))) uint1128;
typedef unsigned int __attribute__ ((bitwidth(1129))) uint1129;
typedef unsigned int __attribute__ ((bitwidth(1130))) uint1130;
typedef unsigned int __attribute__ ((bitwidth(1131))) uint1131;
typedef unsigned int __attribute__ ((bitwidth(1132))) uint1132;
typedef unsigned int __attribute__ ((bitwidth(1133))) uint1133;
typedef unsigned int __attribute__ ((bitwidth(1134))) uint1134;
typedef unsigned int __attribute__ ((bitwidth(1135))) uint1135;
typedef unsigned int __attribute__ ((bitwidth(1136))) uint1136;
typedef unsigned int __attribute__ ((bitwidth(1137))) uint1137;
typedef unsigned int __attribute__ ((bitwidth(1138))) uint1138;
typedef unsigned int __attribute__ ((bitwidth(1139))) uint1139;
typedef unsigned int __attribute__ ((bitwidth(1140))) uint1140;
typedef unsigned int __attribute__ ((bitwidth(1141))) uint1141;
typedef unsigned int __attribute__ ((bitwidth(1142))) uint1142;
typedef unsigned int __attribute__ ((bitwidth(1143))) uint1143;
typedef unsigned int __attribute__ ((bitwidth(1144))) uint1144;
typedef unsigned int __attribute__ ((bitwidth(1145))) uint1145;
typedef unsigned int __attribute__ ((bitwidth(1146))) uint1146;
typedef unsigned int __attribute__ ((bitwidth(1147))) uint1147;
typedef unsigned int __attribute__ ((bitwidth(1148))) uint1148;
typedef unsigned int __attribute__ ((bitwidth(1149))) uint1149;
typedef unsigned int __attribute__ ((bitwidth(1150))) uint1150;
typedef unsigned int __attribute__ ((bitwidth(1151))) uint1151;
typedef unsigned int __attribute__ ((bitwidth(1152))) uint1152;
typedef unsigned int __attribute__ ((bitwidth(1153))) uint1153;
typedef unsigned int __attribute__ ((bitwidth(1154))) uint1154;
typedef unsigned int __attribute__ ((bitwidth(1155))) uint1155;
typedef unsigned int __attribute__ ((bitwidth(1156))) uint1156;
typedef unsigned int __attribute__ ((bitwidth(1157))) uint1157;
typedef unsigned int __attribute__ ((bitwidth(1158))) uint1158;
typedef unsigned int __attribute__ ((bitwidth(1159))) uint1159;
typedef unsigned int __attribute__ ((bitwidth(1160))) uint1160;
typedef unsigned int __attribute__ ((bitwidth(1161))) uint1161;
typedef unsigned int __attribute__ ((bitwidth(1162))) uint1162;
typedef unsigned int __attribute__ ((bitwidth(1163))) uint1163;
typedef unsigned int __attribute__ ((bitwidth(1164))) uint1164;
typedef unsigned int __attribute__ ((bitwidth(1165))) uint1165;
typedef unsigned int __attribute__ ((bitwidth(1166))) uint1166;
typedef unsigned int __attribute__ ((bitwidth(1167))) uint1167;
typedef unsigned int __attribute__ ((bitwidth(1168))) uint1168;
typedef unsigned int __attribute__ ((bitwidth(1169))) uint1169;
typedef unsigned int __attribute__ ((bitwidth(1170))) uint1170;
typedef unsigned int __attribute__ ((bitwidth(1171))) uint1171;
typedef unsigned int __attribute__ ((bitwidth(1172))) uint1172;
typedef unsigned int __attribute__ ((bitwidth(1173))) uint1173;
typedef unsigned int __attribute__ ((bitwidth(1174))) uint1174;
typedef unsigned int __attribute__ ((bitwidth(1175))) uint1175;
typedef unsigned int __attribute__ ((bitwidth(1176))) uint1176;
typedef unsigned int __attribute__ ((bitwidth(1177))) uint1177;
typedef unsigned int __attribute__ ((bitwidth(1178))) uint1178;
typedef unsigned int __attribute__ ((bitwidth(1179))) uint1179;
typedef unsigned int __attribute__ ((bitwidth(1180))) uint1180;
typedef unsigned int __attribute__ ((bitwidth(1181))) uint1181;
typedef unsigned int __attribute__ ((bitwidth(1182))) uint1182;
typedef unsigned int __attribute__ ((bitwidth(1183))) uint1183;
typedef unsigned int __attribute__ ((bitwidth(1184))) uint1184;
typedef unsigned int __attribute__ ((bitwidth(1185))) uint1185;
typedef unsigned int __attribute__ ((bitwidth(1186))) uint1186;
typedef unsigned int __attribute__ ((bitwidth(1187))) uint1187;
typedef unsigned int __attribute__ ((bitwidth(1188))) uint1188;
typedef unsigned int __attribute__ ((bitwidth(1189))) uint1189;
typedef unsigned int __attribute__ ((bitwidth(1190))) uint1190;
typedef unsigned int __attribute__ ((bitwidth(1191))) uint1191;
typedef unsigned int __attribute__ ((bitwidth(1192))) uint1192;
typedef unsigned int __attribute__ ((bitwidth(1193))) uint1193;
typedef unsigned int __attribute__ ((bitwidth(1194))) uint1194;
typedef unsigned int __attribute__ ((bitwidth(1195))) uint1195;
typedef unsigned int __attribute__ ((bitwidth(1196))) uint1196;
typedef unsigned int __attribute__ ((bitwidth(1197))) uint1197;
typedef unsigned int __attribute__ ((bitwidth(1198))) uint1198;
typedef unsigned int __attribute__ ((bitwidth(1199))) uint1199;
typedef unsigned int __attribute__ ((bitwidth(1200))) uint1200;
typedef unsigned int __attribute__ ((bitwidth(1201))) uint1201;
typedef unsigned int __attribute__ ((bitwidth(1202))) uint1202;
typedef unsigned int __attribute__ ((bitwidth(1203))) uint1203;
typedef unsigned int __attribute__ ((bitwidth(1204))) uint1204;
typedef unsigned int __attribute__ ((bitwidth(1205))) uint1205;
typedef unsigned int __attribute__ ((bitwidth(1206))) uint1206;
typedef unsigned int __attribute__ ((bitwidth(1207))) uint1207;
typedef unsigned int __attribute__ ((bitwidth(1208))) uint1208;
typedef unsigned int __attribute__ ((bitwidth(1209))) uint1209;
typedef unsigned int __attribute__ ((bitwidth(1210))) uint1210;
typedef unsigned int __attribute__ ((bitwidth(1211))) uint1211;
typedef unsigned int __attribute__ ((bitwidth(1212))) uint1212;
typedef unsigned int __attribute__ ((bitwidth(1213))) uint1213;
typedef unsigned int __attribute__ ((bitwidth(1214))) uint1214;
typedef unsigned int __attribute__ ((bitwidth(1215))) uint1215;
typedef unsigned int __attribute__ ((bitwidth(1216))) uint1216;
typedef unsigned int __attribute__ ((bitwidth(1217))) uint1217;
typedef unsigned int __attribute__ ((bitwidth(1218))) uint1218;
typedef unsigned int __attribute__ ((bitwidth(1219))) uint1219;
typedef unsigned int __attribute__ ((bitwidth(1220))) uint1220;
typedef unsigned int __attribute__ ((bitwidth(1221))) uint1221;
typedef unsigned int __attribute__ ((bitwidth(1222))) uint1222;
typedef unsigned int __attribute__ ((bitwidth(1223))) uint1223;
typedef unsigned int __attribute__ ((bitwidth(1224))) uint1224;
typedef unsigned int __attribute__ ((bitwidth(1225))) uint1225;
typedef unsigned int __attribute__ ((bitwidth(1226))) uint1226;
typedef unsigned int __attribute__ ((bitwidth(1227))) uint1227;
typedef unsigned int __attribute__ ((bitwidth(1228))) uint1228;
typedef unsigned int __attribute__ ((bitwidth(1229))) uint1229;
typedef unsigned int __attribute__ ((bitwidth(1230))) uint1230;
typedef unsigned int __attribute__ ((bitwidth(1231))) uint1231;
typedef unsigned int __attribute__ ((bitwidth(1232))) uint1232;
typedef unsigned int __attribute__ ((bitwidth(1233))) uint1233;
typedef unsigned int __attribute__ ((bitwidth(1234))) uint1234;
typedef unsigned int __attribute__ ((bitwidth(1235))) uint1235;
typedef unsigned int __attribute__ ((bitwidth(1236))) uint1236;
typedef unsigned int __attribute__ ((bitwidth(1237))) uint1237;
typedef unsigned int __attribute__ ((bitwidth(1238))) uint1238;
typedef unsigned int __attribute__ ((bitwidth(1239))) uint1239;
typedef unsigned int __attribute__ ((bitwidth(1240))) uint1240;
typedef unsigned int __attribute__ ((bitwidth(1241))) uint1241;
typedef unsigned int __attribute__ ((bitwidth(1242))) uint1242;
typedef unsigned int __attribute__ ((bitwidth(1243))) uint1243;
typedef unsigned int __attribute__ ((bitwidth(1244))) uint1244;
typedef unsigned int __attribute__ ((bitwidth(1245))) uint1245;
typedef unsigned int __attribute__ ((bitwidth(1246))) uint1246;
typedef unsigned int __attribute__ ((bitwidth(1247))) uint1247;
typedef unsigned int __attribute__ ((bitwidth(1248))) uint1248;
typedef unsigned int __attribute__ ((bitwidth(1249))) uint1249;
typedef unsigned int __attribute__ ((bitwidth(1250))) uint1250;
typedef unsigned int __attribute__ ((bitwidth(1251))) uint1251;
typedef unsigned int __attribute__ ((bitwidth(1252))) uint1252;
typedef unsigned int __attribute__ ((bitwidth(1253))) uint1253;
typedef unsigned int __attribute__ ((bitwidth(1254))) uint1254;
typedef unsigned int __attribute__ ((bitwidth(1255))) uint1255;
typedef unsigned int __attribute__ ((bitwidth(1256))) uint1256;
typedef unsigned int __attribute__ ((bitwidth(1257))) uint1257;
typedef unsigned int __attribute__ ((bitwidth(1258))) uint1258;
typedef unsigned int __attribute__ ((bitwidth(1259))) uint1259;
typedef unsigned int __attribute__ ((bitwidth(1260))) uint1260;
typedef unsigned int __attribute__ ((bitwidth(1261))) uint1261;
typedef unsigned int __attribute__ ((bitwidth(1262))) uint1262;
typedef unsigned int __attribute__ ((bitwidth(1263))) uint1263;
typedef unsigned int __attribute__ ((bitwidth(1264))) uint1264;
typedef unsigned int __attribute__ ((bitwidth(1265))) uint1265;
typedef unsigned int __attribute__ ((bitwidth(1266))) uint1266;
typedef unsigned int __attribute__ ((bitwidth(1267))) uint1267;
typedef unsigned int __attribute__ ((bitwidth(1268))) uint1268;
typedef unsigned int __attribute__ ((bitwidth(1269))) uint1269;
typedef unsigned int __attribute__ ((bitwidth(1270))) uint1270;
typedef unsigned int __attribute__ ((bitwidth(1271))) uint1271;
typedef unsigned int __attribute__ ((bitwidth(1272))) uint1272;
typedef unsigned int __attribute__ ((bitwidth(1273))) uint1273;
typedef unsigned int __attribute__ ((bitwidth(1274))) uint1274;
typedef unsigned int __attribute__ ((bitwidth(1275))) uint1275;
typedef unsigned int __attribute__ ((bitwidth(1276))) uint1276;
typedef unsigned int __attribute__ ((bitwidth(1277))) uint1277;
typedef unsigned int __attribute__ ((bitwidth(1278))) uint1278;
typedef unsigned int __attribute__ ((bitwidth(1279))) uint1279;
typedef unsigned int __attribute__ ((bitwidth(1280))) uint1280;
typedef unsigned int __attribute__ ((bitwidth(1281))) uint1281;
typedef unsigned int __attribute__ ((bitwidth(1282))) uint1282;
typedef unsigned int __attribute__ ((bitwidth(1283))) uint1283;
typedef unsigned int __attribute__ ((bitwidth(1284))) uint1284;
typedef unsigned int __attribute__ ((bitwidth(1285))) uint1285;
typedef unsigned int __attribute__ ((bitwidth(1286))) uint1286;
typedef unsigned int __attribute__ ((bitwidth(1287))) uint1287;
typedef unsigned int __attribute__ ((bitwidth(1288))) uint1288;
typedef unsigned int __attribute__ ((bitwidth(1289))) uint1289;
typedef unsigned int __attribute__ ((bitwidth(1290))) uint1290;
typedef unsigned int __attribute__ ((bitwidth(1291))) uint1291;
typedef unsigned int __attribute__ ((bitwidth(1292))) uint1292;
typedef unsigned int __attribute__ ((bitwidth(1293))) uint1293;
typedef unsigned int __attribute__ ((bitwidth(1294))) uint1294;
typedef unsigned int __attribute__ ((bitwidth(1295))) uint1295;
typedef unsigned int __attribute__ ((bitwidth(1296))) uint1296;
typedef unsigned int __attribute__ ((bitwidth(1297))) uint1297;
typedef unsigned int __attribute__ ((bitwidth(1298))) uint1298;
typedef unsigned int __attribute__ ((bitwidth(1299))) uint1299;
typedef unsigned int __attribute__ ((bitwidth(1300))) uint1300;
typedef unsigned int __attribute__ ((bitwidth(1301))) uint1301;
typedef unsigned int __attribute__ ((bitwidth(1302))) uint1302;
typedef unsigned int __attribute__ ((bitwidth(1303))) uint1303;
typedef unsigned int __attribute__ ((bitwidth(1304))) uint1304;
typedef unsigned int __attribute__ ((bitwidth(1305))) uint1305;
typedef unsigned int __attribute__ ((bitwidth(1306))) uint1306;
typedef unsigned int __attribute__ ((bitwidth(1307))) uint1307;
typedef unsigned int __attribute__ ((bitwidth(1308))) uint1308;
typedef unsigned int __attribute__ ((bitwidth(1309))) uint1309;
typedef unsigned int __attribute__ ((bitwidth(1310))) uint1310;
typedef unsigned int __attribute__ ((bitwidth(1311))) uint1311;
typedef unsigned int __attribute__ ((bitwidth(1312))) uint1312;
typedef unsigned int __attribute__ ((bitwidth(1313))) uint1313;
typedef unsigned int __attribute__ ((bitwidth(1314))) uint1314;
typedef unsigned int __attribute__ ((bitwidth(1315))) uint1315;
typedef unsigned int __attribute__ ((bitwidth(1316))) uint1316;
typedef unsigned int __attribute__ ((bitwidth(1317))) uint1317;
typedef unsigned int __attribute__ ((bitwidth(1318))) uint1318;
typedef unsigned int __attribute__ ((bitwidth(1319))) uint1319;
typedef unsigned int __attribute__ ((bitwidth(1320))) uint1320;
typedef unsigned int __attribute__ ((bitwidth(1321))) uint1321;
typedef unsigned int __attribute__ ((bitwidth(1322))) uint1322;
typedef unsigned int __attribute__ ((bitwidth(1323))) uint1323;
typedef unsigned int __attribute__ ((bitwidth(1324))) uint1324;
typedef unsigned int __attribute__ ((bitwidth(1325))) uint1325;
typedef unsigned int __attribute__ ((bitwidth(1326))) uint1326;
typedef unsigned int __attribute__ ((bitwidth(1327))) uint1327;
typedef unsigned int __attribute__ ((bitwidth(1328))) uint1328;
typedef unsigned int __attribute__ ((bitwidth(1329))) uint1329;
typedef unsigned int __attribute__ ((bitwidth(1330))) uint1330;
typedef unsigned int __attribute__ ((bitwidth(1331))) uint1331;
typedef unsigned int __attribute__ ((bitwidth(1332))) uint1332;
typedef unsigned int __attribute__ ((bitwidth(1333))) uint1333;
typedef unsigned int __attribute__ ((bitwidth(1334))) uint1334;
typedef unsigned int __attribute__ ((bitwidth(1335))) uint1335;
typedef unsigned int __attribute__ ((bitwidth(1336))) uint1336;
typedef unsigned int __attribute__ ((bitwidth(1337))) uint1337;
typedef unsigned int __attribute__ ((bitwidth(1338))) uint1338;
typedef unsigned int __attribute__ ((bitwidth(1339))) uint1339;
typedef unsigned int __attribute__ ((bitwidth(1340))) uint1340;
typedef unsigned int __attribute__ ((bitwidth(1341))) uint1341;
typedef unsigned int __attribute__ ((bitwidth(1342))) uint1342;
typedef unsigned int __attribute__ ((bitwidth(1343))) uint1343;
typedef unsigned int __attribute__ ((bitwidth(1344))) uint1344;
typedef unsigned int __attribute__ ((bitwidth(1345))) uint1345;
typedef unsigned int __attribute__ ((bitwidth(1346))) uint1346;
typedef unsigned int __attribute__ ((bitwidth(1347))) uint1347;
typedef unsigned int __attribute__ ((bitwidth(1348))) uint1348;
typedef unsigned int __attribute__ ((bitwidth(1349))) uint1349;
typedef unsigned int __attribute__ ((bitwidth(1350))) uint1350;
typedef unsigned int __attribute__ ((bitwidth(1351))) uint1351;
typedef unsigned int __attribute__ ((bitwidth(1352))) uint1352;
typedef unsigned int __attribute__ ((bitwidth(1353))) uint1353;
typedef unsigned int __attribute__ ((bitwidth(1354))) uint1354;
typedef unsigned int __attribute__ ((bitwidth(1355))) uint1355;
typedef unsigned int __attribute__ ((bitwidth(1356))) uint1356;
typedef unsigned int __attribute__ ((bitwidth(1357))) uint1357;
typedef unsigned int __attribute__ ((bitwidth(1358))) uint1358;
typedef unsigned int __attribute__ ((bitwidth(1359))) uint1359;
typedef unsigned int __attribute__ ((bitwidth(1360))) uint1360;
typedef unsigned int __attribute__ ((bitwidth(1361))) uint1361;
typedef unsigned int __attribute__ ((bitwidth(1362))) uint1362;
typedef unsigned int __attribute__ ((bitwidth(1363))) uint1363;
typedef unsigned int __attribute__ ((bitwidth(1364))) uint1364;
typedef unsigned int __attribute__ ((bitwidth(1365))) uint1365;
typedef unsigned int __attribute__ ((bitwidth(1366))) uint1366;
typedef unsigned int __attribute__ ((bitwidth(1367))) uint1367;
typedef unsigned int __attribute__ ((bitwidth(1368))) uint1368;
typedef unsigned int __attribute__ ((bitwidth(1369))) uint1369;
typedef unsigned int __attribute__ ((bitwidth(1370))) uint1370;
typedef unsigned int __attribute__ ((bitwidth(1371))) uint1371;
typedef unsigned int __attribute__ ((bitwidth(1372))) uint1372;
typedef unsigned int __attribute__ ((bitwidth(1373))) uint1373;
typedef unsigned int __attribute__ ((bitwidth(1374))) uint1374;
typedef unsigned int __attribute__ ((bitwidth(1375))) uint1375;
typedef unsigned int __attribute__ ((bitwidth(1376))) uint1376;
typedef unsigned int __attribute__ ((bitwidth(1377))) uint1377;
typedef unsigned int __attribute__ ((bitwidth(1378))) uint1378;
typedef unsigned int __attribute__ ((bitwidth(1379))) uint1379;
typedef unsigned int __attribute__ ((bitwidth(1380))) uint1380;
typedef unsigned int __attribute__ ((bitwidth(1381))) uint1381;
typedef unsigned int __attribute__ ((bitwidth(1382))) uint1382;
typedef unsigned int __attribute__ ((bitwidth(1383))) uint1383;
typedef unsigned int __attribute__ ((bitwidth(1384))) uint1384;
typedef unsigned int __attribute__ ((bitwidth(1385))) uint1385;
typedef unsigned int __attribute__ ((bitwidth(1386))) uint1386;
typedef unsigned int __attribute__ ((bitwidth(1387))) uint1387;
typedef unsigned int __attribute__ ((bitwidth(1388))) uint1388;
typedef unsigned int __attribute__ ((bitwidth(1389))) uint1389;
typedef unsigned int __attribute__ ((bitwidth(1390))) uint1390;
typedef unsigned int __attribute__ ((bitwidth(1391))) uint1391;
typedef unsigned int __attribute__ ((bitwidth(1392))) uint1392;
typedef unsigned int __attribute__ ((bitwidth(1393))) uint1393;
typedef unsigned int __attribute__ ((bitwidth(1394))) uint1394;
typedef unsigned int __attribute__ ((bitwidth(1395))) uint1395;
typedef unsigned int __attribute__ ((bitwidth(1396))) uint1396;
typedef unsigned int __attribute__ ((bitwidth(1397))) uint1397;
typedef unsigned int __attribute__ ((bitwidth(1398))) uint1398;
typedef unsigned int __attribute__ ((bitwidth(1399))) uint1399;
typedef unsigned int __attribute__ ((bitwidth(1400))) uint1400;
typedef unsigned int __attribute__ ((bitwidth(1401))) uint1401;
typedef unsigned int __attribute__ ((bitwidth(1402))) uint1402;
typedef unsigned int __attribute__ ((bitwidth(1403))) uint1403;
typedef unsigned int __attribute__ ((bitwidth(1404))) uint1404;
typedef unsigned int __attribute__ ((bitwidth(1405))) uint1405;
typedef unsigned int __attribute__ ((bitwidth(1406))) uint1406;
typedef unsigned int __attribute__ ((bitwidth(1407))) uint1407;
typedef unsigned int __attribute__ ((bitwidth(1408))) uint1408;
typedef unsigned int __attribute__ ((bitwidth(1409))) uint1409;
typedef unsigned int __attribute__ ((bitwidth(1410))) uint1410;
typedef unsigned int __attribute__ ((bitwidth(1411))) uint1411;
typedef unsigned int __attribute__ ((bitwidth(1412))) uint1412;
typedef unsigned int __attribute__ ((bitwidth(1413))) uint1413;
typedef unsigned int __attribute__ ((bitwidth(1414))) uint1414;
typedef unsigned int __attribute__ ((bitwidth(1415))) uint1415;
typedef unsigned int __attribute__ ((bitwidth(1416))) uint1416;
typedef unsigned int __attribute__ ((bitwidth(1417))) uint1417;
typedef unsigned int __attribute__ ((bitwidth(1418))) uint1418;
typedef unsigned int __attribute__ ((bitwidth(1419))) uint1419;
typedef unsigned int __attribute__ ((bitwidth(1420))) uint1420;
typedef unsigned int __attribute__ ((bitwidth(1421))) uint1421;
typedef unsigned int __attribute__ ((bitwidth(1422))) uint1422;
typedef unsigned int __attribute__ ((bitwidth(1423))) uint1423;
typedef unsigned int __attribute__ ((bitwidth(1424))) uint1424;
typedef unsigned int __attribute__ ((bitwidth(1425))) uint1425;
typedef unsigned int __attribute__ ((bitwidth(1426))) uint1426;
typedef unsigned int __attribute__ ((bitwidth(1427))) uint1427;
typedef unsigned int __attribute__ ((bitwidth(1428))) uint1428;
typedef unsigned int __attribute__ ((bitwidth(1429))) uint1429;
typedef unsigned int __attribute__ ((bitwidth(1430))) uint1430;
typedef unsigned int __attribute__ ((bitwidth(1431))) uint1431;
typedef unsigned int __attribute__ ((bitwidth(1432))) uint1432;
typedef unsigned int __attribute__ ((bitwidth(1433))) uint1433;
typedef unsigned int __attribute__ ((bitwidth(1434))) uint1434;
typedef unsigned int __attribute__ ((bitwidth(1435))) uint1435;
typedef unsigned int __attribute__ ((bitwidth(1436))) uint1436;
typedef unsigned int __attribute__ ((bitwidth(1437))) uint1437;
typedef unsigned int __attribute__ ((bitwidth(1438))) uint1438;
typedef unsigned int __attribute__ ((bitwidth(1439))) uint1439;
typedef unsigned int __attribute__ ((bitwidth(1440))) uint1440;
typedef unsigned int __attribute__ ((bitwidth(1441))) uint1441;
typedef unsigned int __attribute__ ((bitwidth(1442))) uint1442;
typedef unsigned int __attribute__ ((bitwidth(1443))) uint1443;
typedef unsigned int __attribute__ ((bitwidth(1444))) uint1444;
typedef unsigned int __attribute__ ((bitwidth(1445))) uint1445;
typedef unsigned int __attribute__ ((bitwidth(1446))) uint1446;
typedef unsigned int __attribute__ ((bitwidth(1447))) uint1447;
typedef unsigned int __attribute__ ((bitwidth(1448))) uint1448;
typedef unsigned int __attribute__ ((bitwidth(1449))) uint1449;
typedef unsigned int __attribute__ ((bitwidth(1450))) uint1450;
typedef unsigned int __attribute__ ((bitwidth(1451))) uint1451;
typedef unsigned int __attribute__ ((bitwidth(1452))) uint1452;
typedef unsigned int __attribute__ ((bitwidth(1453))) uint1453;
typedef unsigned int __attribute__ ((bitwidth(1454))) uint1454;
typedef unsigned int __attribute__ ((bitwidth(1455))) uint1455;
typedef unsigned int __attribute__ ((bitwidth(1456))) uint1456;
typedef unsigned int __attribute__ ((bitwidth(1457))) uint1457;
typedef unsigned int __attribute__ ((bitwidth(1458))) uint1458;
typedef unsigned int __attribute__ ((bitwidth(1459))) uint1459;
typedef unsigned int __attribute__ ((bitwidth(1460))) uint1460;
typedef unsigned int __attribute__ ((bitwidth(1461))) uint1461;
typedef unsigned int __attribute__ ((bitwidth(1462))) uint1462;
typedef unsigned int __attribute__ ((bitwidth(1463))) uint1463;
typedef unsigned int __attribute__ ((bitwidth(1464))) uint1464;
typedef unsigned int __attribute__ ((bitwidth(1465))) uint1465;
typedef unsigned int __attribute__ ((bitwidth(1466))) uint1466;
typedef unsigned int __attribute__ ((bitwidth(1467))) uint1467;
typedef unsigned int __attribute__ ((bitwidth(1468))) uint1468;
typedef unsigned int __attribute__ ((bitwidth(1469))) uint1469;
typedef unsigned int __attribute__ ((bitwidth(1470))) uint1470;
typedef unsigned int __attribute__ ((bitwidth(1471))) uint1471;
typedef unsigned int __attribute__ ((bitwidth(1472))) uint1472;
typedef unsigned int __attribute__ ((bitwidth(1473))) uint1473;
typedef unsigned int __attribute__ ((bitwidth(1474))) uint1474;
typedef unsigned int __attribute__ ((bitwidth(1475))) uint1475;
typedef unsigned int __attribute__ ((bitwidth(1476))) uint1476;
typedef unsigned int __attribute__ ((bitwidth(1477))) uint1477;
typedef unsigned int __attribute__ ((bitwidth(1478))) uint1478;
typedef unsigned int __attribute__ ((bitwidth(1479))) uint1479;
typedef unsigned int __attribute__ ((bitwidth(1480))) uint1480;
typedef unsigned int __attribute__ ((bitwidth(1481))) uint1481;
typedef unsigned int __attribute__ ((bitwidth(1482))) uint1482;
typedef unsigned int __attribute__ ((bitwidth(1483))) uint1483;
typedef unsigned int __attribute__ ((bitwidth(1484))) uint1484;
typedef unsigned int __attribute__ ((bitwidth(1485))) uint1485;
typedef unsigned int __attribute__ ((bitwidth(1486))) uint1486;
typedef unsigned int __attribute__ ((bitwidth(1487))) uint1487;
typedef unsigned int __attribute__ ((bitwidth(1488))) uint1488;
typedef unsigned int __attribute__ ((bitwidth(1489))) uint1489;
typedef unsigned int __attribute__ ((bitwidth(1490))) uint1490;
typedef unsigned int __attribute__ ((bitwidth(1491))) uint1491;
typedef unsigned int __attribute__ ((bitwidth(1492))) uint1492;
typedef unsigned int __attribute__ ((bitwidth(1493))) uint1493;
typedef unsigned int __attribute__ ((bitwidth(1494))) uint1494;
typedef unsigned int __attribute__ ((bitwidth(1495))) uint1495;
typedef unsigned int __attribute__ ((bitwidth(1496))) uint1496;
typedef unsigned int __attribute__ ((bitwidth(1497))) uint1497;
typedef unsigned int __attribute__ ((bitwidth(1498))) uint1498;
typedef unsigned int __attribute__ ((bitwidth(1499))) uint1499;
typedef unsigned int __attribute__ ((bitwidth(1500))) uint1500;
typedef unsigned int __attribute__ ((bitwidth(1501))) uint1501;
typedef unsigned int __attribute__ ((bitwidth(1502))) uint1502;
typedef unsigned int __attribute__ ((bitwidth(1503))) uint1503;
typedef unsigned int __attribute__ ((bitwidth(1504))) uint1504;
typedef unsigned int __attribute__ ((bitwidth(1505))) uint1505;
typedef unsigned int __attribute__ ((bitwidth(1506))) uint1506;
typedef unsigned int __attribute__ ((bitwidth(1507))) uint1507;
typedef unsigned int __attribute__ ((bitwidth(1508))) uint1508;
typedef unsigned int __attribute__ ((bitwidth(1509))) uint1509;
typedef unsigned int __attribute__ ((bitwidth(1510))) uint1510;
typedef unsigned int __attribute__ ((bitwidth(1511))) uint1511;
typedef unsigned int __attribute__ ((bitwidth(1512))) uint1512;
typedef unsigned int __attribute__ ((bitwidth(1513))) uint1513;
typedef unsigned int __attribute__ ((bitwidth(1514))) uint1514;
typedef unsigned int __attribute__ ((bitwidth(1515))) uint1515;
typedef unsigned int __attribute__ ((bitwidth(1516))) uint1516;
typedef unsigned int __attribute__ ((bitwidth(1517))) uint1517;
typedef unsigned int __attribute__ ((bitwidth(1518))) uint1518;
typedef unsigned int __attribute__ ((bitwidth(1519))) uint1519;
typedef unsigned int __attribute__ ((bitwidth(1520))) uint1520;
typedef unsigned int __attribute__ ((bitwidth(1521))) uint1521;
typedef unsigned int __attribute__ ((bitwidth(1522))) uint1522;
typedef unsigned int __attribute__ ((bitwidth(1523))) uint1523;
typedef unsigned int __attribute__ ((bitwidth(1524))) uint1524;
typedef unsigned int __attribute__ ((bitwidth(1525))) uint1525;
typedef unsigned int __attribute__ ((bitwidth(1526))) uint1526;
typedef unsigned int __attribute__ ((bitwidth(1527))) uint1527;
typedef unsigned int __attribute__ ((bitwidth(1528))) uint1528;
typedef unsigned int __attribute__ ((bitwidth(1529))) uint1529;
typedef unsigned int __attribute__ ((bitwidth(1530))) uint1530;
typedef unsigned int __attribute__ ((bitwidth(1531))) uint1531;
typedef unsigned int __attribute__ ((bitwidth(1532))) uint1532;
typedef unsigned int __attribute__ ((bitwidth(1533))) uint1533;
typedef unsigned int __attribute__ ((bitwidth(1534))) uint1534;
typedef unsigned int __attribute__ ((bitwidth(1535))) uint1535;
typedef unsigned int __attribute__ ((bitwidth(1536))) uint1536;
typedef unsigned int __attribute__ ((bitwidth(1537))) uint1537;
typedef unsigned int __attribute__ ((bitwidth(1538))) uint1538;
typedef unsigned int __attribute__ ((bitwidth(1539))) uint1539;
typedef unsigned int __attribute__ ((bitwidth(1540))) uint1540;
typedef unsigned int __attribute__ ((bitwidth(1541))) uint1541;
typedef unsigned int __attribute__ ((bitwidth(1542))) uint1542;
typedef unsigned int __attribute__ ((bitwidth(1543))) uint1543;
typedef unsigned int __attribute__ ((bitwidth(1544))) uint1544;
typedef unsigned int __attribute__ ((bitwidth(1545))) uint1545;
typedef unsigned int __attribute__ ((bitwidth(1546))) uint1546;
typedef unsigned int __attribute__ ((bitwidth(1547))) uint1547;
typedef unsigned int __attribute__ ((bitwidth(1548))) uint1548;
typedef unsigned int __attribute__ ((bitwidth(1549))) uint1549;
typedef unsigned int __attribute__ ((bitwidth(1550))) uint1550;
typedef unsigned int __attribute__ ((bitwidth(1551))) uint1551;
typedef unsigned int __attribute__ ((bitwidth(1552))) uint1552;
typedef unsigned int __attribute__ ((bitwidth(1553))) uint1553;
typedef unsigned int __attribute__ ((bitwidth(1554))) uint1554;
typedef unsigned int __attribute__ ((bitwidth(1555))) uint1555;
typedef unsigned int __attribute__ ((bitwidth(1556))) uint1556;
typedef unsigned int __attribute__ ((bitwidth(1557))) uint1557;
typedef unsigned int __attribute__ ((bitwidth(1558))) uint1558;
typedef unsigned int __attribute__ ((bitwidth(1559))) uint1559;
typedef unsigned int __attribute__ ((bitwidth(1560))) uint1560;
typedef unsigned int __attribute__ ((bitwidth(1561))) uint1561;
typedef unsigned int __attribute__ ((bitwidth(1562))) uint1562;
typedef unsigned int __attribute__ ((bitwidth(1563))) uint1563;
typedef unsigned int __attribute__ ((bitwidth(1564))) uint1564;
typedef unsigned int __attribute__ ((bitwidth(1565))) uint1565;
typedef unsigned int __attribute__ ((bitwidth(1566))) uint1566;
typedef unsigned int __attribute__ ((bitwidth(1567))) uint1567;
typedef unsigned int __attribute__ ((bitwidth(1568))) uint1568;
typedef unsigned int __attribute__ ((bitwidth(1569))) uint1569;
typedef unsigned int __attribute__ ((bitwidth(1570))) uint1570;
typedef unsigned int __attribute__ ((bitwidth(1571))) uint1571;
typedef unsigned int __attribute__ ((bitwidth(1572))) uint1572;
typedef unsigned int __attribute__ ((bitwidth(1573))) uint1573;
typedef unsigned int __attribute__ ((bitwidth(1574))) uint1574;
typedef unsigned int __attribute__ ((bitwidth(1575))) uint1575;
typedef unsigned int __attribute__ ((bitwidth(1576))) uint1576;
typedef unsigned int __attribute__ ((bitwidth(1577))) uint1577;
typedef unsigned int __attribute__ ((bitwidth(1578))) uint1578;
typedef unsigned int __attribute__ ((bitwidth(1579))) uint1579;
typedef unsigned int __attribute__ ((bitwidth(1580))) uint1580;
typedef unsigned int __attribute__ ((bitwidth(1581))) uint1581;
typedef unsigned int __attribute__ ((bitwidth(1582))) uint1582;
typedef unsigned int __attribute__ ((bitwidth(1583))) uint1583;
typedef unsigned int __attribute__ ((bitwidth(1584))) uint1584;
typedef unsigned int __attribute__ ((bitwidth(1585))) uint1585;
typedef unsigned int __attribute__ ((bitwidth(1586))) uint1586;
typedef unsigned int __attribute__ ((bitwidth(1587))) uint1587;
typedef unsigned int __attribute__ ((bitwidth(1588))) uint1588;
typedef unsigned int __attribute__ ((bitwidth(1589))) uint1589;
typedef unsigned int __attribute__ ((bitwidth(1590))) uint1590;
typedef unsigned int __attribute__ ((bitwidth(1591))) uint1591;
typedef unsigned int __attribute__ ((bitwidth(1592))) uint1592;
typedef unsigned int __attribute__ ((bitwidth(1593))) uint1593;
typedef unsigned int __attribute__ ((bitwidth(1594))) uint1594;
typedef unsigned int __attribute__ ((bitwidth(1595))) uint1595;
typedef unsigned int __attribute__ ((bitwidth(1596))) uint1596;
typedef unsigned int __attribute__ ((bitwidth(1597))) uint1597;
typedef unsigned int __attribute__ ((bitwidth(1598))) uint1598;
typedef unsigned int __attribute__ ((bitwidth(1599))) uint1599;
typedef unsigned int __attribute__ ((bitwidth(1600))) uint1600;
typedef unsigned int __attribute__ ((bitwidth(1601))) uint1601;
typedef unsigned int __attribute__ ((bitwidth(1602))) uint1602;
typedef unsigned int __attribute__ ((bitwidth(1603))) uint1603;
typedef unsigned int __attribute__ ((bitwidth(1604))) uint1604;
typedef unsigned int __attribute__ ((bitwidth(1605))) uint1605;
typedef unsigned int __attribute__ ((bitwidth(1606))) uint1606;
typedef unsigned int __attribute__ ((bitwidth(1607))) uint1607;
typedef unsigned int __attribute__ ((bitwidth(1608))) uint1608;
typedef unsigned int __attribute__ ((bitwidth(1609))) uint1609;
typedef unsigned int __attribute__ ((bitwidth(1610))) uint1610;
typedef unsigned int __attribute__ ((bitwidth(1611))) uint1611;
typedef unsigned int __attribute__ ((bitwidth(1612))) uint1612;
typedef unsigned int __attribute__ ((bitwidth(1613))) uint1613;
typedef unsigned int __attribute__ ((bitwidth(1614))) uint1614;
typedef unsigned int __attribute__ ((bitwidth(1615))) uint1615;
typedef unsigned int __attribute__ ((bitwidth(1616))) uint1616;
typedef unsigned int __attribute__ ((bitwidth(1617))) uint1617;
typedef unsigned int __attribute__ ((bitwidth(1618))) uint1618;
typedef unsigned int __attribute__ ((bitwidth(1619))) uint1619;
typedef unsigned int __attribute__ ((bitwidth(1620))) uint1620;
typedef unsigned int __attribute__ ((bitwidth(1621))) uint1621;
typedef unsigned int __attribute__ ((bitwidth(1622))) uint1622;
typedef unsigned int __attribute__ ((bitwidth(1623))) uint1623;
typedef unsigned int __attribute__ ((bitwidth(1624))) uint1624;
typedef unsigned int __attribute__ ((bitwidth(1625))) uint1625;
typedef unsigned int __attribute__ ((bitwidth(1626))) uint1626;
typedef unsigned int __attribute__ ((bitwidth(1627))) uint1627;
typedef unsigned int __attribute__ ((bitwidth(1628))) uint1628;
typedef unsigned int __attribute__ ((bitwidth(1629))) uint1629;
typedef unsigned int __attribute__ ((bitwidth(1630))) uint1630;
typedef unsigned int __attribute__ ((bitwidth(1631))) uint1631;
typedef unsigned int __attribute__ ((bitwidth(1632))) uint1632;
typedef unsigned int __attribute__ ((bitwidth(1633))) uint1633;
typedef unsigned int __attribute__ ((bitwidth(1634))) uint1634;
typedef unsigned int __attribute__ ((bitwidth(1635))) uint1635;
typedef unsigned int __attribute__ ((bitwidth(1636))) uint1636;
typedef unsigned int __attribute__ ((bitwidth(1637))) uint1637;
typedef unsigned int __attribute__ ((bitwidth(1638))) uint1638;
typedef unsigned int __attribute__ ((bitwidth(1639))) uint1639;
typedef unsigned int __attribute__ ((bitwidth(1640))) uint1640;
typedef unsigned int __attribute__ ((bitwidth(1641))) uint1641;
typedef unsigned int __attribute__ ((bitwidth(1642))) uint1642;
typedef unsigned int __attribute__ ((bitwidth(1643))) uint1643;
typedef unsigned int __attribute__ ((bitwidth(1644))) uint1644;
typedef unsigned int __attribute__ ((bitwidth(1645))) uint1645;
typedef unsigned int __attribute__ ((bitwidth(1646))) uint1646;
typedef unsigned int __attribute__ ((bitwidth(1647))) uint1647;
typedef unsigned int __attribute__ ((bitwidth(1648))) uint1648;
typedef unsigned int __attribute__ ((bitwidth(1649))) uint1649;
typedef unsigned int __attribute__ ((bitwidth(1650))) uint1650;
typedef unsigned int __attribute__ ((bitwidth(1651))) uint1651;
typedef unsigned int __attribute__ ((bitwidth(1652))) uint1652;
typedef unsigned int __attribute__ ((bitwidth(1653))) uint1653;
typedef unsigned int __attribute__ ((bitwidth(1654))) uint1654;
typedef unsigned int __attribute__ ((bitwidth(1655))) uint1655;
typedef unsigned int __attribute__ ((bitwidth(1656))) uint1656;
typedef unsigned int __attribute__ ((bitwidth(1657))) uint1657;
typedef unsigned int __attribute__ ((bitwidth(1658))) uint1658;
typedef unsigned int __attribute__ ((bitwidth(1659))) uint1659;
typedef unsigned int __attribute__ ((bitwidth(1660))) uint1660;
typedef unsigned int __attribute__ ((bitwidth(1661))) uint1661;
typedef unsigned int __attribute__ ((bitwidth(1662))) uint1662;
typedef unsigned int __attribute__ ((bitwidth(1663))) uint1663;
typedef unsigned int __attribute__ ((bitwidth(1664))) uint1664;
typedef unsigned int __attribute__ ((bitwidth(1665))) uint1665;
typedef unsigned int __attribute__ ((bitwidth(1666))) uint1666;
typedef unsigned int __attribute__ ((bitwidth(1667))) uint1667;
typedef unsigned int __attribute__ ((bitwidth(1668))) uint1668;
typedef unsigned int __attribute__ ((bitwidth(1669))) uint1669;
typedef unsigned int __attribute__ ((bitwidth(1670))) uint1670;
typedef unsigned int __attribute__ ((bitwidth(1671))) uint1671;
typedef unsigned int __attribute__ ((bitwidth(1672))) uint1672;
typedef unsigned int __attribute__ ((bitwidth(1673))) uint1673;
typedef unsigned int __attribute__ ((bitwidth(1674))) uint1674;
typedef unsigned int __attribute__ ((bitwidth(1675))) uint1675;
typedef unsigned int __attribute__ ((bitwidth(1676))) uint1676;
typedef unsigned int __attribute__ ((bitwidth(1677))) uint1677;
typedef unsigned int __attribute__ ((bitwidth(1678))) uint1678;
typedef unsigned int __attribute__ ((bitwidth(1679))) uint1679;
typedef unsigned int __attribute__ ((bitwidth(1680))) uint1680;
typedef unsigned int __attribute__ ((bitwidth(1681))) uint1681;
typedef unsigned int __attribute__ ((bitwidth(1682))) uint1682;
typedef unsigned int __attribute__ ((bitwidth(1683))) uint1683;
typedef unsigned int __attribute__ ((bitwidth(1684))) uint1684;
typedef unsigned int __attribute__ ((bitwidth(1685))) uint1685;
typedef unsigned int __attribute__ ((bitwidth(1686))) uint1686;
typedef unsigned int __attribute__ ((bitwidth(1687))) uint1687;
typedef unsigned int __attribute__ ((bitwidth(1688))) uint1688;
typedef unsigned int __attribute__ ((bitwidth(1689))) uint1689;
typedef unsigned int __attribute__ ((bitwidth(1690))) uint1690;
typedef unsigned int __attribute__ ((bitwidth(1691))) uint1691;
typedef unsigned int __attribute__ ((bitwidth(1692))) uint1692;
typedef unsigned int __attribute__ ((bitwidth(1693))) uint1693;
typedef unsigned int __attribute__ ((bitwidth(1694))) uint1694;
typedef unsigned int __attribute__ ((bitwidth(1695))) uint1695;
typedef unsigned int __attribute__ ((bitwidth(1696))) uint1696;
typedef unsigned int __attribute__ ((bitwidth(1697))) uint1697;
typedef unsigned int __attribute__ ((bitwidth(1698))) uint1698;
typedef unsigned int __attribute__ ((bitwidth(1699))) uint1699;
typedef unsigned int __attribute__ ((bitwidth(1700))) uint1700;
typedef unsigned int __attribute__ ((bitwidth(1701))) uint1701;
typedef unsigned int __attribute__ ((bitwidth(1702))) uint1702;
typedef unsigned int __attribute__ ((bitwidth(1703))) uint1703;
typedef unsigned int __attribute__ ((bitwidth(1704))) uint1704;
typedef unsigned int __attribute__ ((bitwidth(1705))) uint1705;
typedef unsigned int __attribute__ ((bitwidth(1706))) uint1706;
typedef unsigned int __attribute__ ((bitwidth(1707))) uint1707;
typedef unsigned int __attribute__ ((bitwidth(1708))) uint1708;
typedef unsigned int __attribute__ ((bitwidth(1709))) uint1709;
typedef unsigned int __attribute__ ((bitwidth(1710))) uint1710;
typedef unsigned int __attribute__ ((bitwidth(1711))) uint1711;
typedef unsigned int __attribute__ ((bitwidth(1712))) uint1712;
typedef unsigned int __attribute__ ((bitwidth(1713))) uint1713;
typedef unsigned int __attribute__ ((bitwidth(1714))) uint1714;
typedef unsigned int __attribute__ ((bitwidth(1715))) uint1715;
typedef unsigned int __attribute__ ((bitwidth(1716))) uint1716;
typedef unsigned int __attribute__ ((bitwidth(1717))) uint1717;
typedef unsigned int __attribute__ ((bitwidth(1718))) uint1718;
typedef unsigned int __attribute__ ((bitwidth(1719))) uint1719;
typedef unsigned int __attribute__ ((bitwidth(1720))) uint1720;
typedef unsigned int __attribute__ ((bitwidth(1721))) uint1721;
typedef unsigned int __attribute__ ((bitwidth(1722))) uint1722;
typedef unsigned int __attribute__ ((bitwidth(1723))) uint1723;
typedef unsigned int __attribute__ ((bitwidth(1724))) uint1724;
typedef unsigned int __attribute__ ((bitwidth(1725))) uint1725;
typedef unsigned int __attribute__ ((bitwidth(1726))) uint1726;
typedef unsigned int __attribute__ ((bitwidth(1727))) uint1727;
typedef unsigned int __attribute__ ((bitwidth(1728))) uint1728;
typedef unsigned int __attribute__ ((bitwidth(1729))) uint1729;
typedef unsigned int __attribute__ ((bitwidth(1730))) uint1730;
typedef unsigned int __attribute__ ((bitwidth(1731))) uint1731;
typedef unsigned int __attribute__ ((bitwidth(1732))) uint1732;
typedef unsigned int __attribute__ ((bitwidth(1733))) uint1733;
typedef unsigned int __attribute__ ((bitwidth(1734))) uint1734;
typedef unsigned int __attribute__ ((bitwidth(1735))) uint1735;
typedef unsigned int __attribute__ ((bitwidth(1736))) uint1736;
typedef unsigned int __attribute__ ((bitwidth(1737))) uint1737;
typedef unsigned int __attribute__ ((bitwidth(1738))) uint1738;
typedef unsigned int __attribute__ ((bitwidth(1739))) uint1739;
typedef unsigned int __attribute__ ((bitwidth(1740))) uint1740;
typedef unsigned int __attribute__ ((bitwidth(1741))) uint1741;
typedef unsigned int __attribute__ ((bitwidth(1742))) uint1742;
typedef unsigned int __attribute__ ((bitwidth(1743))) uint1743;
typedef unsigned int __attribute__ ((bitwidth(1744))) uint1744;
typedef unsigned int __attribute__ ((bitwidth(1745))) uint1745;
typedef unsigned int __attribute__ ((bitwidth(1746))) uint1746;
typedef unsigned int __attribute__ ((bitwidth(1747))) uint1747;
typedef unsigned int __attribute__ ((bitwidth(1748))) uint1748;
typedef unsigned int __attribute__ ((bitwidth(1749))) uint1749;
typedef unsigned int __attribute__ ((bitwidth(1750))) uint1750;
typedef unsigned int __attribute__ ((bitwidth(1751))) uint1751;
typedef unsigned int __attribute__ ((bitwidth(1752))) uint1752;
typedef unsigned int __attribute__ ((bitwidth(1753))) uint1753;
typedef unsigned int __attribute__ ((bitwidth(1754))) uint1754;
typedef unsigned int __attribute__ ((bitwidth(1755))) uint1755;
typedef unsigned int __attribute__ ((bitwidth(1756))) uint1756;
typedef unsigned int __attribute__ ((bitwidth(1757))) uint1757;
typedef unsigned int __attribute__ ((bitwidth(1758))) uint1758;
typedef unsigned int __attribute__ ((bitwidth(1759))) uint1759;
typedef unsigned int __attribute__ ((bitwidth(1760))) uint1760;
typedef unsigned int __attribute__ ((bitwidth(1761))) uint1761;
typedef unsigned int __attribute__ ((bitwidth(1762))) uint1762;
typedef unsigned int __attribute__ ((bitwidth(1763))) uint1763;
typedef unsigned int __attribute__ ((bitwidth(1764))) uint1764;
typedef unsigned int __attribute__ ((bitwidth(1765))) uint1765;
typedef unsigned int __attribute__ ((bitwidth(1766))) uint1766;
typedef unsigned int __attribute__ ((bitwidth(1767))) uint1767;
typedef unsigned int __attribute__ ((bitwidth(1768))) uint1768;
typedef unsigned int __attribute__ ((bitwidth(1769))) uint1769;
typedef unsigned int __attribute__ ((bitwidth(1770))) uint1770;
typedef unsigned int __attribute__ ((bitwidth(1771))) uint1771;
typedef unsigned int __attribute__ ((bitwidth(1772))) uint1772;
typedef unsigned int __attribute__ ((bitwidth(1773))) uint1773;
typedef unsigned int __attribute__ ((bitwidth(1774))) uint1774;
typedef unsigned int __attribute__ ((bitwidth(1775))) uint1775;
typedef unsigned int __attribute__ ((bitwidth(1776))) uint1776;
typedef unsigned int __attribute__ ((bitwidth(1777))) uint1777;
typedef unsigned int __attribute__ ((bitwidth(1778))) uint1778;
typedef unsigned int __attribute__ ((bitwidth(1779))) uint1779;
typedef unsigned int __attribute__ ((bitwidth(1780))) uint1780;
typedef unsigned int __attribute__ ((bitwidth(1781))) uint1781;
typedef unsigned int __attribute__ ((bitwidth(1782))) uint1782;
typedef unsigned int __attribute__ ((bitwidth(1783))) uint1783;
typedef unsigned int __attribute__ ((bitwidth(1784))) uint1784;
typedef unsigned int __attribute__ ((bitwidth(1785))) uint1785;
typedef unsigned int __attribute__ ((bitwidth(1786))) uint1786;
typedef unsigned int __attribute__ ((bitwidth(1787))) uint1787;
typedef unsigned int __attribute__ ((bitwidth(1788))) uint1788;
typedef unsigned int __attribute__ ((bitwidth(1789))) uint1789;
typedef unsigned int __attribute__ ((bitwidth(1790))) uint1790;
typedef unsigned int __attribute__ ((bitwidth(1791))) uint1791;
typedef unsigned int __attribute__ ((bitwidth(1792))) uint1792;
typedef unsigned int __attribute__ ((bitwidth(1793))) uint1793;
typedef unsigned int __attribute__ ((bitwidth(1794))) uint1794;
typedef unsigned int __attribute__ ((bitwidth(1795))) uint1795;
typedef unsigned int __attribute__ ((bitwidth(1796))) uint1796;
typedef unsigned int __attribute__ ((bitwidth(1797))) uint1797;
typedef unsigned int __attribute__ ((bitwidth(1798))) uint1798;
typedef unsigned int __attribute__ ((bitwidth(1799))) uint1799;
typedef unsigned int __attribute__ ((bitwidth(1800))) uint1800;
typedef unsigned int __attribute__ ((bitwidth(1801))) uint1801;
typedef unsigned int __attribute__ ((bitwidth(1802))) uint1802;
typedef unsigned int __attribute__ ((bitwidth(1803))) uint1803;
typedef unsigned int __attribute__ ((bitwidth(1804))) uint1804;
typedef unsigned int __attribute__ ((bitwidth(1805))) uint1805;
typedef unsigned int __attribute__ ((bitwidth(1806))) uint1806;
typedef unsigned int __attribute__ ((bitwidth(1807))) uint1807;
typedef unsigned int __attribute__ ((bitwidth(1808))) uint1808;
typedef unsigned int __attribute__ ((bitwidth(1809))) uint1809;
typedef unsigned int __attribute__ ((bitwidth(1810))) uint1810;
typedef unsigned int __attribute__ ((bitwidth(1811))) uint1811;
typedef unsigned int __attribute__ ((bitwidth(1812))) uint1812;
typedef unsigned int __attribute__ ((bitwidth(1813))) uint1813;
typedef unsigned int __attribute__ ((bitwidth(1814))) uint1814;
typedef unsigned int __attribute__ ((bitwidth(1815))) uint1815;
typedef unsigned int __attribute__ ((bitwidth(1816))) uint1816;
typedef unsigned int __attribute__ ((bitwidth(1817))) uint1817;
typedef unsigned int __attribute__ ((bitwidth(1818))) uint1818;
typedef unsigned int __attribute__ ((bitwidth(1819))) uint1819;
typedef unsigned int __attribute__ ((bitwidth(1820))) uint1820;
typedef unsigned int __attribute__ ((bitwidth(1821))) uint1821;
typedef unsigned int __attribute__ ((bitwidth(1822))) uint1822;
typedef unsigned int __attribute__ ((bitwidth(1823))) uint1823;
typedef unsigned int __attribute__ ((bitwidth(1824))) uint1824;
typedef unsigned int __attribute__ ((bitwidth(1825))) uint1825;
typedef unsigned int __attribute__ ((bitwidth(1826))) uint1826;
typedef unsigned int __attribute__ ((bitwidth(1827))) uint1827;
typedef unsigned int __attribute__ ((bitwidth(1828))) uint1828;
typedef unsigned int __attribute__ ((bitwidth(1829))) uint1829;
typedef unsigned int __attribute__ ((bitwidth(1830))) uint1830;
typedef unsigned int __attribute__ ((bitwidth(1831))) uint1831;
typedef unsigned int __attribute__ ((bitwidth(1832))) uint1832;
typedef unsigned int __attribute__ ((bitwidth(1833))) uint1833;
typedef unsigned int __attribute__ ((bitwidth(1834))) uint1834;
typedef unsigned int __attribute__ ((bitwidth(1835))) uint1835;
typedef unsigned int __attribute__ ((bitwidth(1836))) uint1836;
typedef unsigned int __attribute__ ((bitwidth(1837))) uint1837;
typedef unsigned int __attribute__ ((bitwidth(1838))) uint1838;
typedef unsigned int __attribute__ ((bitwidth(1839))) uint1839;
typedef unsigned int __attribute__ ((bitwidth(1840))) uint1840;
typedef unsigned int __attribute__ ((bitwidth(1841))) uint1841;
typedef unsigned int __attribute__ ((bitwidth(1842))) uint1842;
typedef unsigned int __attribute__ ((bitwidth(1843))) uint1843;
typedef unsigned int __attribute__ ((bitwidth(1844))) uint1844;
typedef unsigned int __attribute__ ((bitwidth(1845))) uint1845;
typedef unsigned int __attribute__ ((bitwidth(1846))) uint1846;
typedef unsigned int __attribute__ ((bitwidth(1847))) uint1847;
typedef unsigned int __attribute__ ((bitwidth(1848))) uint1848;
typedef unsigned int __attribute__ ((bitwidth(1849))) uint1849;
typedef unsigned int __attribute__ ((bitwidth(1850))) uint1850;
typedef unsigned int __attribute__ ((bitwidth(1851))) uint1851;
typedef unsigned int __attribute__ ((bitwidth(1852))) uint1852;
typedef unsigned int __attribute__ ((bitwidth(1853))) uint1853;
typedef unsigned int __attribute__ ((bitwidth(1854))) uint1854;
typedef unsigned int __attribute__ ((bitwidth(1855))) uint1855;
typedef unsigned int __attribute__ ((bitwidth(1856))) uint1856;
typedef unsigned int __attribute__ ((bitwidth(1857))) uint1857;
typedef unsigned int __attribute__ ((bitwidth(1858))) uint1858;
typedef unsigned int __attribute__ ((bitwidth(1859))) uint1859;
typedef unsigned int __attribute__ ((bitwidth(1860))) uint1860;
typedef unsigned int __attribute__ ((bitwidth(1861))) uint1861;
typedef unsigned int __attribute__ ((bitwidth(1862))) uint1862;
typedef unsigned int __attribute__ ((bitwidth(1863))) uint1863;
typedef unsigned int __attribute__ ((bitwidth(1864))) uint1864;
typedef unsigned int __attribute__ ((bitwidth(1865))) uint1865;
typedef unsigned int __attribute__ ((bitwidth(1866))) uint1866;
typedef unsigned int __attribute__ ((bitwidth(1867))) uint1867;
typedef unsigned int __attribute__ ((bitwidth(1868))) uint1868;
typedef unsigned int __attribute__ ((bitwidth(1869))) uint1869;
typedef unsigned int __attribute__ ((bitwidth(1870))) uint1870;
typedef unsigned int __attribute__ ((bitwidth(1871))) uint1871;
typedef unsigned int __attribute__ ((bitwidth(1872))) uint1872;
typedef unsigned int __attribute__ ((bitwidth(1873))) uint1873;
typedef unsigned int __attribute__ ((bitwidth(1874))) uint1874;
typedef unsigned int __attribute__ ((bitwidth(1875))) uint1875;
typedef unsigned int __attribute__ ((bitwidth(1876))) uint1876;
typedef unsigned int __attribute__ ((bitwidth(1877))) uint1877;
typedef unsigned int __attribute__ ((bitwidth(1878))) uint1878;
typedef unsigned int __attribute__ ((bitwidth(1879))) uint1879;
typedef unsigned int __attribute__ ((bitwidth(1880))) uint1880;
typedef unsigned int __attribute__ ((bitwidth(1881))) uint1881;
typedef unsigned int __attribute__ ((bitwidth(1882))) uint1882;
typedef unsigned int __attribute__ ((bitwidth(1883))) uint1883;
typedef unsigned int __attribute__ ((bitwidth(1884))) uint1884;
typedef unsigned int __attribute__ ((bitwidth(1885))) uint1885;
typedef unsigned int __attribute__ ((bitwidth(1886))) uint1886;
typedef unsigned int __attribute__ ((bitwidth(1887))) uint1887;
typedef unsigned int __attribute__ ((bitwidth(1888))) uint1888;
typedef unsigned int __attribute__ ((bitwidth(1889))) uint1889;
typedef unsigned int __attribute__ ((bitwidth(1890))) uint1890;
typedef unsigned int __attribute__ ((bitwidth(1891))) uint1891;
typedef unsigned int __attribute__ ((bitwidth(1892))) uint1892;
typedef unsigned int __attribute__ ((bitwidth(1893))) uint1893;
typedef unsigned int __attribute__ ((bitwidth(1894))) uint1894;
typedef unsigned int __attribute__ ((bitwidth(1895))) uint1895;
typedef unsigned int __attribute__ ((bitwidth(1896))) uint1896;
typedef unsigned int __attribute__ ((bitwidth(1897))) uint1897;
typedef unsigned int __attribute__ ((bitwidth(1898))) uint1898;
typedef unsigned int __attribute__ ((bitwidth(1899))) uint1899;
typedef unsigned int __attribute__ ((bitwidth(1900))) uint1900;
typedef unsigned int __attribute__ ((bitwidth(1901))) uint1901;
typedef unsigned int __attribute__ ((bitwidth(1902))) uint1902;
typedef unsigned int __attribute__ ((bitwidth(1903))) uint1903;
typedef unsigned int __attribute__ ((bitwidth(1904))) uint1904;
typedef unsigned int __attribute__ ((bitwidth(1905))) uint1905;
typedef unsigned int __attribute__ ((bitwidth(1906))) uint1906;
typedef unsigned int __attribute__ ((bitwidth(1907))) uint1907;
typedef unsigned int __attribute__ ((bitwidth(1908))) uint1908;
typedef unsigned int __attribute__ ((bitwidth(1909))) uint1909;
typedef unsigned int __attribute__ ((bitwidth(1910))) uint1910;
typedef unsigned int __attribute__ ((bitwidth(1911))) uint1911;
typedef unsigned int __attribute__ ((bitwidth(1912))) uint1912;
typedef unsigned int __attribute__ ((bitwidth(1913))) uint1913;
typedef unsigned int __attribute__ ((bitwidth(1914))) uint1914;
typedef unsigned int __attribute__ ((bitwidth(1915))) uint1915;
typedef unsigned int __attribute__ ((bitwidth(1916))) uint1916;
typedef unsigned int __attribute__ ((bitwidth(1917))) uint1917;
typedef unsigned int __attribute__ ((bitwidth(1918))) uint1918;
typedef unsigned int __attribute__ ((bitwidth(1919))) uint1919;
typedef unsigned int __attribute__ ((bitwidth(1920))) uint1920;
typedef unsigned int __attribute__ ((bitwidth(1921))) uint1921;
typedef unsigned int __attribute__ ((bitwidth(1922))) uint1922;
typedef unsigned int __attribute__ ((bitwidth(1923))) uint1923;
typedef unsigned int __attribute__ ((bitwidth(1924))) uint1924;
typedef unsigned int __attribute__ ((bitwidth(1925))) uint1925;
typedef unsigned int __attribute__ ((bitwidth(1926))) uint1926;
typedef unsigned int __attribute__ ((bitwidth(1927))) uint1927;
typedef unsigned int __attribute__ ((bitwidth(1928))) uint1928;
typedef unsigned int __attribute__ ((bitwidth(1929))) uint1929;
typedef unsigned int __attribute__ ((bitwidth(1930))) uint1930;
typedef unsigned int __attribute__ ((bitwidth(1931))) uint1931;
typedef unsigned int __attribute__ ((bitwidth(1932))) uint1932;
typedef unsigned int __attribute__ ((bitwidth(1933))) uint1933;
typedef unsigned int __attribute__ ((bitwidth(1934))) uint1934;
typedef unsigned int __attribute__ ((bitwidth(1935))) uint1935;
typedef unsigned int __attribute__ ((bitwidth(1936))) uint1936;
typedef unsigned int __attribute__ ((bitwidth(1937))) uint1937;
typedef unsigned int __attribute__ ((bitwidth(1938))) uint1938;
typedef unsigned int __attribute__ ((bitwidth(1939))) uint1939;
typedef unsigned int __attribute__ ((bitwidth(1940))) uint1940;
typedef unsigned int __attribute__ ((bitwidth(1941))) uint1941;
typedef unsigned int __attribute__ ((bitwidth(1942))) uint1942;
typedef unsigned int __attribute__ ((bitwidth(1943))) uint1943;
typedef unsigned int __attribute__ ((bitwidth(1944))) uint1944;
typedef unsigned int __attribute__ ((bitwidth(1945))) uint1945;
typedef unsigned int __attribute__ ((bitwidth(1946))) uint1946;
typedef unsigned int __attribute__ ((bitwidth(1947))) uint1947;
typedef unsigned int __attribute__ ((bitwidth(1948))) uint1948;
typedef unsigned int __attribute__ ((bitwidth(1949))) uint1949;
typedef unsigned int __attribute__ ((bitwidth(1950))) uint1950;
typedef unsigned int __attribute__ ((bitwidth(1951))) uint1951;
typedef unsigned int __attribute__ ((bitwidth(1952))) uint1952;
typedef unsigned int __attribute__ ((bitwidth(1953))) uint1953;
typedef unsigned int __attribute__ ((bitwidth(1954))) uint1954;
typedef unsigned int __attribute__ ((bitwidth(1955))) uint1955;
typedef unsigned int __attribute__ ((bitwidth(1956))) uint1956;
typedef unsigned int __attribute__ ((bitwidth(1957))) uint1957;
typedef unsigned int __attribute__ ((bitwidth(1958))) uint1958;
typedef unsigned int __attribute__ ((bitwidth(1959))) uint1959;
typedef unsigned int __attribute__ ((bitwidth(1960))) uint1960;
typedef unsigned int __attribute__ ((bitwidth(1961))) uint1961;
typedef unsigned int __attribute__ ((bitwidth(1962))) uint1962;
typedef unsigned int __attribute__ ((bitwidth(1963))) uint1963;
typedef unsigned int __attribute__ ((bitwidth(1964))) uint1964;
typedef unsigned int __attribute__ ((bitwidth(1965))) uint1965;
typedef unsigned int __attribute__ ((bitwidth(1966))) uint1966;
typedef unsigned int __attribute__ ((bitwidth(1967))) uint1967;
typedef unsigned int __attribute__ ((bitwidth(1968))) uint1968;
typedef unsigned int __attribute__ ((bitwidth(1969))) uint1969;
typedef unsigned int __attribute__ ((bitwidth(1970))) uint1970;
typedef unsigned int __attribute__ ((bitwidth(1971))) uint1971;
typedef unsigned int __attribute__ ((bitwidth(1972))) uint1972;
typedef unsigned int __attribute__ ((bitwidth(1973))) uint1973;
typedef unsigned int __attribute__ ((bitwidth(1974))) uint1974;
typedef unsigned int __attribute__ ((bitwidth(1975))) uint1975;
typedef unsigned int __attribute__ ((bitwidth(1976))) uint1976;
typedef unsigned int __attribute__ ((bitwidth(1977))) uint1977;
typedef unsigned int __attribute__ ((bitwidth(1978))) uint1978;
typedef unsigned int __attribute__ ((bitwidth(1979))) uint1979;
typedef unsigned int __attribute__ ((bitwidth(1980))) uint1980;
typedef unsigned int __attribute__ ((bitwidth(1981))) uint1981;
typedef unsigned int __attribute__ ((bitwidth(1982))) uint1982;
typedef unsigned int __attribute__ ((bitwidth(1983))) uint1983;
typedef unsigned int __attribute__ ((bitwidth(1984))) uint1984;
typedef unsigned int __attribute__ ((bitwidth(1985))) uint1985;
typedef unsigned int __attribute__ ((bitwidth(1986))) uint1986;
typedef unsigned int __attribute__ ((bitwidth(1987))) uint1987;
typedef unsigned int __attribute__ ((bitwidth(1988))) uint1988;
typedef unsigned int __attribute__ ((bitwidth(1989))) uint1989;
typedef unsigned int __attribute__ ((bitwidth(1990))) uint1990;
typedef unsigned int __attribute__ ((bitwidth(1991))) uint1991;
typedef unsigned int __attribute__ ((bitwidth(1992))) uint1992;
typedef unsigned int __attribute__ ((bitwidth(1993))) uint1993;
typedef unsigned int __attribute__ ((bitwidth(1994))) uint1994;
typedef unsigned int __attribute__ ((bitwidth(1995))) uint1995;
typedef unsigned int __attribute__ ((bitwidth(1996))) uint1996;
typedef unsigned int __attribute__ ((bitwidth(1997))) uint1997;
typedef unsigned int __attribute__ ((bitwidth(1998))) uint1998;
typedef unsigned int __attribute__ ((bitwidth(1999))) uint1999;
typedef unsigned int __attribute__ ((bitwidth(2000))) uint2000;
typedef unsigned int __attribute__ ((bitwidth(2001))) uint2001;
typedef unsigned int __attribute__ ((bitwidth(2002))) uint2002;
typedef unsigned int __attribute__ ((bitwidth(2003))) uint2003;
typedef unsigned int __attribute__ ((bitwidth(2004))) uint2004;
typedef unsigned int __attribute__ ((bitwidth(2005))) uint2005;
typedef unsigned int __attribute__ ((bitwidth(2006))) uint2006;
typedef unsigned int __attribute__ ((bitwidth(2007))) uint2007;
typedef unsigned int __attribute__ ((bitwidth(2008))) uint2008;
typedef unsigned int __attribute__ ((bitwidth(2009))) uint2009;
typedef unsigned int __attribute__ ((bitwidth(2010))) uint2010;
typedef unsigned int __attribute__ ((bitwidth(2011))) uint2011;
typedef unsigned int __attribute__ ((bitwidth(2012))) uint2012;
typedef unsigned int __attribute__ ((bitwidth(2013))) uint2013;
typedef unsigned int __attribute__ ((bitwidth(2014))) uint2014;
typedef unsigned int __attribute__ ((bitwidth(2015))) uint2015;
typedef unsigned int __attribute__ ((bitwidth(2016))) uint2016;
typedef unsigned int __attribute__ ((bitwidth(2017))) uint2017;
typedef unsigned int __attribute__ ((bitwidth(2018))) uint2018;
typedef unsigned int __attribute__ ((bitwidth(2019))) uint2019;
typedef unsigned int __attribute__ ((bitwidth(2020))) uint2020;
typedef unsigned int __attribute__ ((bitwidth(2021))) uint2021;
typedef unsigned int __attribute__ ((bitwidth(2022))) uint2022;
typedef unsigned int __attribute__ ((bitwidth(2023))) uint2023;
typedef unsigned int __attribute__ ((bitwidth(2024))) uint2024;
typedef unsigned int __attribute__ ((bitwidth(2025))) uint2025;
typedef unsigned int __attribute__ ((bitwidth(2026))) uint2026;
typedef unsigned int __attribute__ ((bitwidth(2027))) uint2027;
typedef unsigned int __attribute__ ((bitwidth(2028))) uint2028;
typedef unsigned int __attribute__ ((bitwidth(2029))) uint2029;
typedef unsigned int __attribute__ ((bitwidth(2030))) uint2030;
typedef unsigned int __attribute__ ((bitwidth(2031))) uint2031;
typedef unsigned int __attribute__ ((bitwidth(2032))) uint2032;
typedef unsigned int __attribute__ ((bitwidth(2033))) uint2033;
typedef unsigned int __attribute__ ((bitwidth(2034))) uint2034;
typedef unsigned int __attribute__ ((bitwidth(2035))) uint2035;
typedef unsigned int __attribute__ ((bitwidth(2036))) uint2036;
typedef unsigned int __attribute__ ((bitwidth(2037))) uint2037;
typedef unsigned int __attribute__ ((bitwidth(2038))) uint2038;
typedef unsigned int __attribute__ ((bitwidth(2039))) uint2039;
typedef unsigned int __attribute__ ((bitwidth(2040))) uint2040;
typedef unsigned int __attribute__ ((bitwidth(2041))) uint2041;
typedef unsigned int __attribute__ ((bitwidth(2042))) uint2042;
typedef unsigned int __attribute__ ((bitwidth(2043))) uint2043;
typedef unsigned int __attribute__ ((bitwidth(2044))) uint2044;
typedef unsigned int __attribute__ ((bitwidth(2045))) uint2045;
typedef unsigned int __attribute__ ((bitwidth(2046))) uint2046;
typedef unsigned int __attribute__ ((bitwidth(2047))) uint2047;
typedef unsigned int __attribute__ ((bitwidth(2048))) uint2048;
#pragma line 110 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h" 2
#pragma line 131 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_dt.h"
typedef int __attribute__ ((bitwidth(64))) int64;
typedef unsigned int __attribute__ ((bitwidth(64))) uint64;
#pragma line 58 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 2
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h" 1
/* autopilot_ssdm_bits.h */
/*
#- (c) Copyright 2011-2015 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Concatination ----------------*/
#pragma line 108 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Bit get/set ----------------*/
#pragma line 129 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Part get/set ----------------*/
#pragma empty_line
/* GetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 143 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* SetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 156 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- Reduce operations ----------------*/
#pragma line 192 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\etc/autopilot_ssdm_bits.h"
/* -- String-Integer conversions ----------------*/
#pragma line 59 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h" 2
#pragma line 85 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot/etc/autopilot_apint.h"
/************************************************/
#pragma line 78 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/common/technology/autopilot\\ap_cint.h" 2
#pragma line 3 "./duc.h" 2
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 1 3 4
/*===---- limits.h - Standard header for integer sizes --------------------===*\
*
* Copyright (c) 2009 Chris Lattner
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
\*===----------------------------------------------------------------------===*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
Avert this #include_next madness. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* System headers include a number of constants from POSIX in <limits.h>.
Include it if we're hosted. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 6 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* File system limits
*
* NOTE: Apparently the actual size of PATH_MAX is 260, but a space is
* required for the NUL. TODO: Test?
* NOTE: PATH_MAX is the POSIX equivalent for Microsoft's MAX_PATH; the two
* are semantically identical, with a limit of 259 characters for the
* path name, plus one for a terminating NUL, for a total of 260.
*/
#pragma line 38 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Many system headers try to "help us out" by defining these. No really, we
know how big each datatype is. */
#pragma line 60 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C90/99 5.2.4.2.1 */
#pragma line 90 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C99 5.2.4.2.1: Added long long. */
#pragma line 102 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* LONG_LONG_MIN/LONG_LONG_MAX/ULONG_LONG_MAX are a GNU extension. It's too bad
that we don't have something like #pragma poison that could be used to
deprecate a macro - the code should just use LLONG_MAX and friends.
*/
#pragma line 10 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 36 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef int ( *_onexit_t)(void);
#pragma line 46 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef struct _div_t {
int quot;
int rem;
} div_t;
#pragma empty_line
typedef struct _ldiv_t {
long quot;
long rem;
} ldiv_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(4)
typedef struct {
unsigned char ld[10];
} _LDOUBLE;
#pragma pack()
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
double x;
} _CRT_DOUBLE;
#pragma empty_line
typedef struct {
float f;
} _CRT_FLOAT;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
long double x;
} _LONGDOUBLE;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(4)
typedef struct {
unsigned char ld12[12];
} _LDBL12;
#pragma pack()
#pragma line 100 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern int * __imp___mb_cur_max;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int* __imp___mbcur_max;
#pragma line 132 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
typedef void ( *_purecall_handler)(void);
#pragma empty_line
__attribute__ ((__dllimport__)) _purecall_handler _set_purecall_handler(_purecall_handler _Handler);
__attribute__ ((__dllimport__)) _purecall_handler _get_purecall_handler(void);
#pragma empty_line
typedef void ( *_invalid_parameter_handler)(const wchar_t *,const wchar_t *,const wchar_t *,unsigned int,uintptr_t);
_invalid_parameter_handler _set_invalid_parameter_handler(_invalid_parameter_handler _Handler);
_invalid_parameter_handler _get_invalid_parameter_handler(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) extern int * _errno(void);
#pragma empty_line
errno_t _set_errno(int _Value);
errno_t _get_errno(int *_Value);
#pragma empty_line
__attribute__ ((__dllimport__)) unsigned long * __doserrno(void);
#pragma empty_line
errno_t _set_doserrno(unsigned long _Value);
errno_t _get_doserrno(unsigned long *_Value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __attribute__ ((__dllimport__)) char *_sys_errlist[1];
extern __attribute__ ((__dllimport__)) int _sys_nerr;
#pragma line 172 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern int * __imp___argc;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *** __imp___argv;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *** __imp___wargv;
#pragma line 200 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern char *** __imp__environ;
#pragma line 209 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern wchar_t *** __imp__wenviron;
#pragma line 218 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern char ** __imp__pgmptr;
#pragma line 227 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern wchar_t ** __imp__wpgmptr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
errno_t _get_pgmptr(char **_Value);
errno_t _get_wpgmptr(wchar_t **_Value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int * __imp__fmode;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) errno_t _set_fmode(int _Mode);
__attribute__ ((__dllimport__)) errno_t _get_fmode(int *_PMode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern unsigned int * __imp__osplatform;
#pragma line 257 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__osver;
#pragma line 266 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winver;
#pragma line 275 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winmajor;
#pragma line 284 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
extern unsigned int * __imp__winminor;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
errno_t _get_osplatform(unsigned int *_Value);
errno_t _get_osver(unsigned int *_Value);
errno_t _get_winver(unsigned int *_Value);
errno_t _get_winmajor(unsigned int *_Value);
errno_t _get_winminor(unsigned int *_Value);
#pragma line 307 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
void __attribute__ ((__nothrow__)) exit(int _Code) __attribute__ ((__noreturn__));
__attribute__ ((__dllimport__)) void __attribute__ ((__nothrow__)) _exit(int _Code) __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
/* C99 function name */
void _Exit(int) __attribute__ ((__noreturn__));
#pragma line 321 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
void __attribute__((noreturn)) abort(void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) unsigned int _set_abort_behavior(unsigned int _Flags,unsigned int _Mask);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int abs(int _X);
long labs(long _X);
#pragma empty_line
#pragma empty_line
__extension__ long long _abs64(long long);
int atexit(void ( *)(void));
#pragma empty_line
#pragma empty_line
double atof(const char *_String);
double _atof_l(const char *_String,_locale_t _Locale);
#pragma empty_line
int atoi(const char *_Str);
__attribute__ ((__dllimport__)) int _atoi_l(const char *_Str,_locale_t _Locale);
long atol(const char *_Str);
__attribute__ ((__dllimport__)) long _atol_l(const char *_Str,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
void * bsearch(const void *_Key,const void *_Base,size_t _NumOfElements,size_t _SizeOfElements,int ( *_PtFuncCompare)(const void *,const void *));
void qsort(void *_Base,size_t _NumOfElements,size_t _SizeOfElements,int ( *_PtFuncCompare)(const void *,const void *));
#pragma empty_line
unsigned short _byteswap_ushort(unsigned short _Short);
/*unsigned long __cdecl _byteswap_ulong (unsigned long _Long); */
__extension__ unsigned long long _byteswap_uint64(unsigned long long _Int64);
div_t div(int _Numerator,int _Denominator);
char * getenv(const char *_VarName) ;
__attribute__ ((__dllimport__)) char * _itoa(int _Value,char *_Dest,int _Radix);
__extension__ __attribute__ ((__dllimport__)) char * _i64toa(long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) char * _ui64toa(unsigned long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) long long _atoi64(const char *_String);
__extension__ __attribute__ ((__dllimport__)) long long _atoi64_l(const char *_String,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long _strtoi64(const char *_String,char **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _strtoi64_l(const char *_String,char **_EndPtr,int _Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _strtoui64(const char *_String,char **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _strtoui64_l(const char *_String,char **_EndPtr,int _Radix,_locale_t _Locale);
ldiv_t ldiv(long _Numerator,long _Denominator);
__attribute__ ((__dllimport__)) char * _ltoa(long _Value,char *_Dest,int _Radix) ;
int mblen(const char *_Ch,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _mblen_l(const char *_Ch,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t _mbstrlen(const char *_Str);
__attribute__ ((__dllimport__)) size_t _mbstrlen_l(const char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t _mbstrnlen(const char *_Str,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _mbstrnlen_l(const char *_Str,size_t _MaxCount,_locale_t _Locale);
int mbtowc(wchar_t * __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t _SrcSizeInBytes);
__attribute__ ((__dllimport__)) int _mbtowc_l(wchar_t * __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t _SrcSizeInBytes,_locale_t _Locale);
size_t mbstowcs(wchar_t * __restrict__ _Dest,const char * __restrict__ _Source,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _mbstowcs_l(wchar_t * __restrict__ _Dest,const char * __restrict__ _Source,size_t _MaxCount,_locale_t _Locale);
int rand(void);
__attribute__ ((__dllimport__)) int _set_error_mode(int _Mode);
void srand(unsigned int _Seed);
#pragma empty_line
#pragma empty_line
#pragma empty_line
double __attribute__ ((__nothrow__)) strtod(const char * __restrict__ _Str,char ** __restrict__ _EndPtr);
float __attribute__ ((__nothrow__)) strtof(const char * __restrict__ nptr, char ** __restrict__ endptr);
long double __attribute__ ((__nothrow__)) strtold(const char * __restrict__ , char ** __restrict__ );
#pragma empty_line
/* libmingwex.a provides a c99-compliant strtod() exported as __strtod() */
extern double __attribute__ ((__nothrow__))
__strtod (const char * __restrict__ , char ** __restrict__);
#pragma line 400 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
float __mingw_strtof (const char * __restrict__, char ** __restrict__);
long double __mingw_strtold(const char * __restrict__, char ** __restrict__);
#pragma empty_line
__attribute__ ((__dllimport__)) double _strtod_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,_locale_t _Locale);
long strtol(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long _strtol_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
unsigned long strtoul(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long _strtoul_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
int system(const char *_Command);
#pragma empty_line
__attribute__ ((__dllimport__)) char * _ultoa(unsigned long _Value,char *_Dest,int _Radix) ;
int wctomb(char *_MbCh,wchar_t _WCh) ;
__attribute__ ((__dllimport__)) int _wctomb_l(char *_MbCh,wchar_t _WCh,_locale_t _Locale) ;
size_t wcstombs(char * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) size_t _wcstombs_l(char * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _MaxCount,_locale_t _Locale) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
void * calloc(size_t _NumOfElements,size_t _SizeOfElements);
void free(void *_Memory);
void * malloc(size_t _Size);
void * realloc(void *_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) void * _recalloc(void *_Memory,size_t _Count,size_t _Size);
/* Make sure that X86intrin.h doesn't produce here collisions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _aligned_free(void *_Memory);
__attribute__ ((__dllimport__)) void * _aligned_malloc(size_t _Size,size_t _Alignment);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void * _aligned_offset_malloc(size_t _Size,size_t _Alignment,size_t _Offset);
__attribute__ ((__dllimport__)) void * _aligned_realloc(void *_Memory,size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void * _aligned_recalloc(void *_Memory,size_t _Count,size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void * _aligned_offset_realloc(void *_Memory,size_t _Size,size_t _Alignment,size_t _Offset);
__attribute__ ((__dllimport__)) void * _aligned_offset_recalloc(void *_Memory,size_t _Count,size_t _Size,size_t _Alignment,size_t _Offset);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _itow(int _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ltow(long _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ultow(unsigned long _Value,wchar_t *_Dest,int _Radix) ;
double wcstod(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr);
float wcstof(const wchar_t * __restrict__ nptr, wchar_t ** __restrict__ endptr);
#pragma empty_line
float wcstof( const wchar_t * __restrict__, wchar_t ** __restrict__);
long double wcstold(const wchar_t * __restrict__, wchar_t ** __restrict__);
#pragma empty_line
__attribute__ ((__dllimport__)) double _wcstod_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,_locale_t _Locale);
long wcstol(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long _wcstol_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
unsigned long wcstoul(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long _wcstoul_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wgetenv(const wchar_t *_VarName) ;
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wsystem(const wchar_t *_Command);
#pragma empty_line
__attribute__ ((__dllimport__)) double _wtof(const wchar_t *_Str);
__attribute__ ((__dllimport__)) double _wtof_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wtoi(const wchar_t *_Str);
__attribute__ ((__dllimport__)) int _wtoi_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) long _wtol(const wchar_t *_Str);
__attribute__ ((__dllimport__)) long _wtol_l(const wchar_t *_Str,_locale_t _Locale);
#pragma empty_line
__extension__ __attribute__ ((__dllimport__)) wchar_t * _i64tow(long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) wchar_t * _ui64tow(unsigned long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64(const wchar_t *_Str);
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64_l(const wchar_t *_Str,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64_l(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64_l(const wchar_t *_Str ,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) char * _fullpath(char *_FullPath,const char *_Path,size_t _SizeInBytes);
__attribute__ ((__dllimport__)) char * _ecvt(double _Val,int _NumOfDigits,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char * _fcvt(double _Val,int _NumOfDec,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char * _gcvt(double _Val,int _NumOfDigits,char *_DstBuf) ;
__attribute__ ((__dllimport__)) int _atodbl(_CRT_DOUBLE *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atoldbl(_LDOUBLE *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atoflt(_CRT_FLOAT *_Result,char *_Str);
__attribute__ ((__dllimport__)) int _atodbl_l(_CRT_DOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _atoldbl_l(_LDOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _atoflt_l(_CRT_FLOAT *_Result,char *_Str,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _lrotl(unsigned long long _Val,int _Shift);
__extension__ unsigned long long _lrotr(unsigned long long _Val,int _Shift);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _makepath(char *_Path,const char *_Drive,const char *_Dir,const char *_Filename,const char *_Ext);
_onexit_t _onexit(_onexit_t _Func);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _putenv(const char *_EnvString);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _rotl64(unsigned long long _Val,int _Shift);
__extension__ unsigned long long _rotr64(unsigned long long Value,int Shift);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
unsigned int _rotr(unsigned int _Val,int _Shift);
unsigned int _rotl(unsigned int _Val,int _Shift);
#pragma empty_line
#pragma empty_line
__extension__ unsigned long long _rotr64(unsigned long long _Val,int _Shift);
__attribute__ ((__dllimport__)) void _searchenv(const char *_Filename,const char *_EnvVar,char *_ResultPath) ;
__attribute__ ((__dllimport__)) void _splitpath(const char *_FullPath,char *_Drive,char *_Dir,char *_Filename,char *_Ext) ;
__attribute__ ((__dllimport__)) void _swab(char *_Buf1,char *_Buf2,int _SizeInBytes);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wfullpath(wchar_t *_FullPath,const wchar_t *_Path,size_t _SizeInWords);
__attribute__ ((__dllimport__)) void _wmakepath(wchar_t *_ResultPath,const wchar_t *_Drive,const wchar_t *_Dir,const wchar_t *_Filename,const wchar_t *_Ext);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wputenv(const wchar_t *_EnvString);
__attribute__ ((__dllimport__)) void _wsearchenv(const wchar_t *_Filename,const wchar_t *_EnvVar,wchar_t *_ResultPath) ;
__attribute__ ((__dllimport__)) void _wsplitpath(const wchar_t *_FullPath,wchar_t *_Drive,wchar_t *_Dir,wchar_t *_Filename,wchar_t *_Ext) ;
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _beep(unsigned _Frequency,unsigned _Duration) __attribute__ ((__deprecated__));
/* Not to be confused with _set_error_mode (int). */
__attribute__ ((__dllimport__)) void _seterrormode(int _Mode) __attribute__ ((__deprecated__));
__attribute__ ((__dllimport__)) void _sleep(unsigned long _Duration) __attribute__ ((__deprecated__));
#pragma line 574 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
char * ecvt(double _Val,int _NumOfDigits,int *_PtDec,int *_PtSign) ;
char * fcvt(double _Val,int _NumOfDec,int *_PtDec,int *_PtSign) ;
char * gcvt(double _Val,int _NumOfDigits,char *_DstBuf) ;
char * itoa(int _Val,char *_DstBuf,int _Radix) ;
char * ltoa(long _Val,char *_DstBuf,int _Radix) ;
int putenv(const char *_EnvString) ;
void swab(char *_Buf1,char *_Buf2,int _SizeInBytes) ;
char * ultoa(unsigned long _Val,char *_Dstbuf,int _Radix) ;
_onexit_t onexit(_onexit_t _Func);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct { __extension__ long long quot, rem; } lldiv_t;
#pragma empty_line
__extension__ lldiv_t lldiv(long long, long long);
#pragma empty_line
__extension__ long long llabs(long long);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ long long strtoll(const char * __restrict__, char ** __restrict, int);
__extension__ unsigned long long strtoull(const char * __restrict__, char ** __restrict__, int);
#pragma empty_line
/* these are stubs for MS _i64 versions */
__extension__ long long atoll (const char *);
#pragma empty_line
#pragma empty_line
__extension__ long long wtoll (const wchar_t *);
__extension__ char * lltoa (long long, char *, int);
__extension__ char * ulltoa (unsigned long long , char *, int);
__extension__ wchar_t * lltow (long long, wchar_t *, int);
__extension__ wchar_t * ulltow (unsigned long long, wchar_t *, int);
#pragma empty_line
/* __CRT_INLINE using non-ansi functions */
#pragma line 627 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 3
#pragma pack(pop)
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdlib_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdlib_s.h" 2 3
#pragma line 629 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 31 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
/* Return codes for _heapwalk() */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Values for _heapinfo.useflag */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The structure used to walk through the heap with _heapwalk. */
typedef struct _heapinfo {
int *_pentry;
size_t _size;
int _useflag;
} _HEAPINFO;
#pragma empty_line
#pragma empty_line
extern unsigned int _amblksiz;
#pragma empty_line
/* Make sure that X86intrin.h doesn't produce here collisions. */
#pragma line 98 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
/* Users should really use MS provided versions */
void * __mingw_aligned_malloc (size_t _Size, size_t _Alignment);
void __mingw_aligned_free (void *_Memory);
void * __mingw_aligned_offset_realloc (void *_Memory, size_t _Size, size_t _Alignment, size_t _Offset);
void * __mingw_aligned_realloc (void *_Memory, size_t _Size, size_t _Offset);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _resetstkoflw (void);
__attribute__ ((__dllimport__)) unsigned long _set_malloc_crt_max_wait(unsigned long _NewValue);
#pragma empty_line
__attribute__ ((__dllimport__)) void * _expand(void *_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) size_t _msize(void *_Memory);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) size_t _get_sbh_threshold(void);
__attribute__ ((__dllimport__)) int _set_sbh_threshold(size_t _NewValue);
__attribute__ ((__dllimport__)) errno_t _set_amblksiz(size_t _Value);
__attribute__ ((__dllimport__)) errno_t _get_amblksiz(size_t *_Value);
__attribute__ ((__dllimport__)) int _heapadd(void *_Memory,size_t _Size);
__attribute__ ((__dllimport__)) int _heapchk(void);
__attribute__ ((__dllimport__)) int _heapmin(void);
__attribute__ ((__dllimport__)) int _heapset(unsigned int _Fill);
__attribute__ ((__dllimport__)) int _heapwalk(_HEAPINFO *_EntryInfo);
__attribute__ ((__dllimport__)) size_t _heapused(size_t *_Used,size_t *_Commit);
__attribute__ ((__dllimport__)) intptr_t _get_heap_handle(void);
#pragma line 140 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
static __inline void *_MarkAllocaS(void *_Ptr,unsigned int _Marker) {
if(_Ptr) {
*((unsigned int*)_Ptr) = _Marker;
_Ptr = (char*)_Ptr + 16;
}
return _Ptr;
}
#pragma line 159 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
static __inline void _freea(void *_Memory) {
unsigned int _Marker;
if(_Memory) {
_Memory = (char*)_Memory - 16;
_Marker = *(unsigned int *)_Memory;
if(_Marker==0xDDDD) {
free(_Memory);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
}
#pragma line 205 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\malloc.h" 3
#pragma pack(pop)
#pragma line 630 "C:/opt/winprog/Xilinx/Vivado_HLS/2015.2/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdlib.h" 2 3
#pragma line 5 "./duc.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//#define FREQ 1657
//#define FREQ 0
/*
N Accumulator
P Phase
M Output
B N-P
Frequency
=========
Fomin = (Fs/(2^N))
Fo = (Fs/(2^N))*Dacc
Fomax = (Fs/2^(N-P))
#pragma empty_line
Phase Quantization
==================
SFDRest = 6.02P - 3.92dB
P = (SFDR+3.92)/6.02
#pragma empty_line
Amplitude Quantization
======================
SNRest = -6.02M -1.76db
Best performance (-SFDR<SNR): P = M+1
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef uint16 acc_t;
typedef uint5 phi_t;
typedef int16 dds_t;
typedef uint11 rnd_t;
#pragma empty_line
#pragma empty_line
// Largest coefficient: 69475 (0x10F63)
typedef int18 srrc_data_t;
typedef int18 srrc_coef_t;
typedef int38 srrc_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf1_data_t;
typedef int18 imf1_coef_t;
typedef int38 imf1_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf2_data_t;
typedef int18 imf2_coef_t;
typedef int38 imf2_acc_t;
#pragma empty_line
#pragma empty_line
typedef int18 imf3_data_t;
typedef int18 imf3_coef_t;
typedef int38 imf3_acc_t;
#pragma empty_line
typedef int18 mix_data_t;
#pragma empty_line
void duc (
srrc_data_t din_i,
acc_t freq,
mix_data_t *dout_i,
mix_data_t *dout_q
);
#pragma empty_line
int37 mult (
int18 c,
int19 d
);
#pragma empty_line
int37 symtap (
int18 a,
int18 b,
int18 c
);
#pragma empty_line
srrc_acc_t srrc_mac (
int18 c,
int18 d,
int40 s
);
#pragma empty_line
imf1_acc_t mac1 (
imf1_coef_t c,
imf1_data_t d,
imf1_acc_t s
);
#pragma empty_line
imf2_acc_t mac2 (
imf2_coef_t c,
imf2_data_t d,
imf2_acc_t s
);
#pragma empty_line
int48 mac (
int18 c,
int18 d,
int48 s
);
#pragma empty_line
void srrc (
srrc_data_t *y,
srrc_data_t x
);
#pragma empty_line
void imf1 (
imf1_data_t *y,
imf1_data_t x
);
#pragma empty_line
void imf2 (
imf2_data_t *y,
imf2_data_t x
);
#pragma empty_line
void imf3 (
imf2_data_t *y,
imf2_data_t x
);
#pragma empty_line
void mixer (
acc_t freq,
mix_data_t Din,
mix_data_t *Dout_I,
mix_data_t *Dout_Q
);
#pragma empty_line
void dds (
acc_t freq,
dds_t *sin,
dds_t *cosine
);
#pragma empty_line
rnd_t rnd();
#pragma line 1 "imf2.c" 2
#pragma empty_line
#pragma empty_line
void imf2 (
imf2_data_t *y,
imf2_data_t x
) {
const imf2_coef_t c[12]={
#pragma empty_line
#pragma line 1 "./imf2_coef.h" 1
2054,
-14177,
77667,
77667,
-14177,
2054,
0,
0,
131071,
0,
0,
0
#pragma line 8 "imf2.c" 2
#pragma empty_line
};
_ssdm_SpecConstant(c);
#pragma line 9 "imf2.c"
/*
Transposed form FIR poly branches
*/
static imf2_acc_t shift_reg_p[13][2];
static imf2_data_t in = 0;
imf2_acc_t acc;
#pragma empty_line
static uint1 init = 1;
static uint2 cnt = 0;
static uint1 ch = 0;
static uint4 i = 0;
#pragma empty_line
L1:
//Latch input
if (i==0) {
in = x;
}
uint4 inc = i+1;
//Calculate tap
acc = mac2(c[i], in, (init || i==5 || i==11) ? 0 : shift_reg_p[inc][ch]);
//Shift
shift_reg_p[i][ch] = acc;
if (i==11) {
if (cnt == 3) {
if (ch) init = 0;
ch = !ch;
}
cnt++;
}
//Output
if ((i==0) || (i==6))
{
*y = acc >> 17;
}
#pragma empty_line
i = (i == 11) ? 0 : inc;
}
|
the_stack_data/7949227.c | #include <stdio.h>
#include <malloc.h>
typedef struct Node {
int data;
struct Node *next;
} node;
node* head = NULL; //The first node in the list
node* temp = NULL; //The last node in the list
int count = 0; //Tracks the number of elements in the node
//Push element (add at beginning) of List
void push(int data) {
node* nPtr = (node*)malloc(sizeof(node));
nPtr->data = data;
//Checks for empty list
if (head == NULL) {
nPtr->next = NULL;
head = nPtr;
printf("First node pushed: %d\n", data);
count++;
return;
}
//Pushes new node
nPtr->next = head;
head = nPtr;
count++;
printf("Pushed: %d\n", data);
}
void pop() {
node* temp;
//Checks for empty list
if (head == NULL) {
printf("Stack Underflow\n");
return;
}
//Deletion of first element
temp = head;
printf("Popped = %d\n", head->data);
head = head->next;
free(temp);
count--;
}
void printList() {
node* nPtr = head;
printf("Stack conatins: \n");
//Checks for empty list
if (head == NULL) {
printf("\tNothing!!\n");
return;
}
//Traverses the list while printing the elements
while (nPtr != NULL) {
printf("\t\t\t%d\n", nPtr->data);
nPtr = nPtr->next;
}
//Gives node count in the list
printf("Node count in current stack: %d\n", count);
}
int main(void) {
push(28);
push(12);
push(100);
push(20);
printList();
pop();
printList();
}
|
the_stack_data/154827882.c | #include <stdio.h>
int main()
{
int n, i=0;
scanf("%d", &n);
while(n)
{
n = n/10;
i++;
}
printf("%d", i);
}
|
the_stack_data/59511733.c | #include <signal.h>
#include <memory.h>
#include <string.h>
#include <stdio.h>
#define MIN_ELEM 1
#define MAX_ELEM 3
#define NUM_ELEMS MAX_ELEM - MIN_ELEM + 1
int getElement()
{
char input[100];
int result;
int haveResult = 0; /* false */
while (! haveResult)
{
printf("Input one number: ");
fgets((char *)&input, 100, stdin); // get a string from user
if ( 1 == sscanf(input, "%d", & result) ) // parse string as decimal integer
{
haveResult = 1; /* true */
}
else
{
printf("Invalid number, please try again.\n");
}
}
return result;
}
int main(char** argv, int argc)
{
int n = getElement();
if ( (1 - (n == 1)) * (n) )
{
printf("A\n");
}
else
{
printf("B\n");
}
return 0;
}
|
the_stack_data/23575158.c | #include <ctype.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define BUF_SIZE 1024
#define COLOR_GREEN "\033[0;32m"
#define COLOR_RED "\033[0;31m"
#define COLOR_RESET "\033[0m"
#define SLOW_SLEEP (10 * 1000) /* 10ms */
int failures = 0;
void color_reset()
{
printf(COLOR_RESET);
}
void pick_color()
{
if (rand() & 1)
{
printf(COLOR_RED);
}
else
{
printf(COLOR_GREEN);
}
}
void color_print(FILE *file, bool slow)
{
pick_color();
int c;
while ((c = getc(file)) != EOF)
{
if (isspace(c))
{
pick_color();
}
putc(c, stdout);
if (slow)
{
usleep(SLOW_SLEEP);
}
}
color_reset();
}
void cleanup_and_exit()
{
color_reset();
_exit(failures);
}
int main(int argc, char *argv[])
{
bool slow = false;
int c;
while ((c = getopt (argc, argv, "s")) != -1)
{
if (c == 's')
{
slow = true;
}
}
srand(time(NULL));
signal(SIGINT, cleanup_and_exit);
setbuf(stdout, NULL);
if (argc > 1)
{
for (int i = optind; i < argc; i++)
{
FILE *file = fopen(argv[i], "r");
if (!file)
{
fprintf(stderr,
"greencat: %s: Could not open file\n",
argv[i]);
failures++;
continue;
}
color_print(file, slow);
fclose(file);
}
}
else
{
color_print(stdin, slow);
}
return failures;
}
|
the_stack_data/550289.c | /* PR optimization/15296. The delayed-branch scheduler caused code that
SEGV:d for CRIS; a register was set to -1 in a delay-slot for the
fall-through code, while that register held a pointer used in code at
the branch target. */
typedef int __attribute__ ((mode (__pointer__))) intptr_t;
typedef intptr_t W;
union u0
{
union u0 *r;
W i;
};
struct s1
{
union u0 **m0;
union u0 m1[4];
};
void f (void *, struct s1 *, const union u0 *, W, W, W)
__attribute__ ((__noinline__));
void g (void *, char *) __attribute__ ((__noinline__));
void
f (void *a, struct s1 *b, const union u0 *h, W v0, W v1, W v4)
{
union u0 *e = 0;
union u0 *k = 0;
union u0 **v5 = b->m0;
union u0 *c = b->m1;
union u0 **d = &v5[0];
l0:;
if (v0 < v1)
goto l0;
if (v0 == 0)
goto l3;
v0 = v4;
if (v0 != 0)
goto l3;
c[0].r = *d;
v1 = -1;
e = c[0].r;
if (e != 0)
g (a, "");
k = e + 3;
k->i = v1;
goto l4;
l3:;
c[0].i = v0;
e = c[1].r;
if (e != 0)
g (a, "");
e = c[0].r;
if (e == 0)
g (a, "");
k = e + 2;
k->r = c[1].r;
l4:;
}
void g (void *a, char *b) { abort (); }
int
main ()
{
union u0 uv[] = {{ .i = 111 }, { .i = 222 }, { .i = 333 }, { .i = 444 }};
struct s1 s = { 0, {{ .i = 555 }, { .i = 0 }, { .i = 999 }, { .i = 777 }}};
f (0, &s, 0, 20000, 10000, (W) uv);
if (s.m1[0].i != (W) uv || s.m1[1].i != 0 || s.m1[2].i != 999
|| s.m1[3].i != 777 || uv[0].i != 111 || uv[1].i != 222
|| uv[2].i != 0 || uv[3].i != 444)
abort ();
exit (0);
}
|
the_stack_data/944980.c | //
// main.c
// ArrayCircularQueue
//
// Created by 김희철 on 2018. 6. 17..
// Copyright © 2018년 Heekim. All rights reserved.
//
#include <stdio.h>
#include <stdlib.h>
// 큐 사이즈 4
// 사실상 들어갈 수 있는 data 는 3개만 들어갈 수 있다.
// 원형 큐는 자리 하나를 항상 비워야 하기 때문
#define QUEUE_SIZE 4
typedef int element;
typedef struct CircularQueue {
element queue[QUEUE_SIZE];
int front;
int rear;
} CircularQueue;
// 큐를 동적할당한 후 반환
CircularQueue * createQueue() {
CircularQueue * cq;
cq = (CircularQueue *)malloc(sizeof(CircularQueue));
cq->front = 0;
cq->rear = 0;
return cq;
}
// 비어있으면 1 아니면 0
int isEmpty(CircularQueue * cq) {
return cq->front == cq->rear ? 1 : 0;
}
// 가득차있으면 1 아니면 0
int isFull(CircularQueue * cq) {
return ((cq->rear) + 1) % QUEUE_SIZE == cq->front ? 1 : 0;
}
void enQueue(CircularQueue * cq, element data) {
if(isFull(cq)) {
exit(1);
}
cq->rear = (cq->rear + 1) % QUEUE_SIZE;
cq->queue[cq->rear] = data;
}
element deQueue(CircularQueue * cq) {
if(isEmpty(cq)) {
exit(1);
}
cq->front = (cq->front + 1) % QUEUE_SIZE;
return cq->queue[cq->front];
}
void del(CircularQueue * cq) {
if(isEmpty(cq)) {
exit(1);
}
cq->front = (cq->front + 1) % QUEUE_SIZE;
}
element peek(CircularQueue * cq) {
if(isEmpty(cq)) {
exit(1);
}
return cq->queue[(cq->front + 1) % QUEUE_SIZE];
}
void printQueue(CircularQueue * cq) {
printf("Circular Queue [");
int first = (cq->front + 1) % QUEUE_SIZE;
int last = (cq->rear + 1) % QUEUE_SIZE;
int i = first;
while(i != last) {
printf("%d ", cq->queue[i]);
i = (i + 1) % QUEUE_SIZE;
}
printf("]\n");
}
int main(void) {
CircularQueue *circularQueue;
circularQueue = createQueue();
element data;
printf("삽입 5 >> "); enQueue(circularQueue, 5); printQueue(circularQueue);
printf("삽입 4 >> "); enQueue(circularQueue, 4); printQueue(circularQueue);
printf("삽입 1 >> "); enQueue(circularQueue, 1); printQueue(circularQueue);
// n - 1만큼만 삽입이 되므로 4개를 삽입하려하면 프로그램 종료
// printf("삽입 1 >> "); enQueue(circularQueue, 1); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
printf("삽입 6 >> "); enQueue(circularQueue, 6); printQueue(circularQueue);
data = peek(circularQueue); printf("peek Data --> %d \n", data);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
// 선형 큐와는 달리 나머지연산자를 이용하므로 인덱스의 첫번째부터 다시 삽입된다. 정확히말해선 덮어씌워진다.
printf("삽입 1 >> "); enQueue(circularQueue, 1); printQueue(circularQueue);
printf("삽입 2 >> "); enQueue(circularQueue, 2); printQueue(circularQueue);
printf("삽입 3 >> "); enQueue(circularQueue, 3); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
printf("삭제 >> "); deQueue(circularQueue); printQueue(circularQueue);
/* 출력결과
삽입 5 >> Circular Queue [5 ]
삽입 4 >> Circular Queue [5 4 ]
삽입 1 >> Circular Queue [5 4 1 ]
삭제 >> Circular Queue [4 1 ]
삽입 6 >> Circular Queue [4 1 6 ]
peek Data --> 4
삭제 >> Circular Queue [1 6 ]
삭제 >> Circular Queue [6 ]
삭제 >> Circular Queue []
삽입 1 >> Circular Queue [1 ]
삽입 2 >> Circular Queue [1 2 ]
삽입 3 >> Circular Queue [1 2 3 ]
삭제 >> Circular Queue [2 3 ]
삭제 >> Circular Queue [3 ]
삭제 >> Circular Queue []
*/
}
|
the_stack_data/39552.c | extern void exit (int);
extern void abort (void);
typedef union
{
struct
{
int f1, f2, f3, f4, f5, f6, f7, f8;
long int f9, f10;
int f11;
} f;
char s[56];
long int a;
} T;
__attribute__((noinline))
void
test (T *t)
{
static int i = 11;
if (t->f.f1 != i++)
abort ();
if (t->f.f2 || t->f.f3 || t->f.f4 || t->f.f5 || t->f.f6
|| t->f.f7 || t->f.f8 || t->f.f9 || t->f.f10 || t->f.f11)
abort ();
if (i == 20)
exit (0);
}
__attribute__((noinline))
void
foo (int i)
{
T t;
again:
t = (T) { { ++i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
test (&t);
goto again;
}
int
main (void)
{
T *t1, *t2;
int cnt = 0;
t1 = (T *) 0;
loop:
t2 = t1;
t1 = & (T) { .f.f9 = cnt++ };
if (cnt < 3)
goto loop;
if (t1 != t2 || t1->f.f9 != 2)
abort ();
foo (10);
return 0;
}
|
the_stack_data/86075516.c | /* A Dynamic Programming based C program to find minimum
number operations to convert string1 to string2 */
#include <stdio.h>
#include <string.h>
// Utility function to find the minimum of three numbers
int minimum_count(int c1, int c2, int c3)
{
if(c1<=c2 && c1<=c3)
return c1;
if(c2<=c1 && c2<=c3)
return c2;
else
return c3;
}
int edit_DistDP(char str1[], char str2[], int Len1, int Len2)
{
// Create a table to store results of subproblems
int dp[Len1 + 1][Len2 + 1];
// Fill d[][] in bottom up manner
for (int indexstr1 = 0; indexstr1 <= Len1; indexstr1++) {
for (int indexstr2 = 0; indexstr2 <= Len2; indexstr2++) {
/* If first string is empty, only option is to
insert all characters of second string */
if (indexstr1 == 0)
// Min. operations = indexstr2
dp[indexstr1][indexstr2] = indexstr2;
/* If second string is empty, only option is to
remove all characters of second string */
else if (indexstr2 == 0)
dp[indexstr1][indexstr2] = indexstr1; // Min. operations = loop
/* If last characters are same, ignore last char
and recur for remaining string */
else if (str1[indexstr1 - 1] == str2[indexstr2 - 1])
dp[indexstr1][indexstr2] = dp[indexstr1 - 1][indexstr2 - 1];
/* If the last character is different, consider all
possibilities and find the minimum */
else
dp[indexstr1][indexstr2] = 1 + mincount(dp[indexstr1][indexstr2 - 1], // Insert
dp[indexstr1 - 1][indexstr2], // Remove
dp[indexstr1 - 1][indexstr2 - 1]); // Replace
}
}
return dp[Len1][Len2];
}
// Driver program
int main()
{
char s1[20];
char s2[20];
int n;
printf("\n Input: ");
printf("\n Enter the first string:");
scanf("%[^\n]%*c", s1);
printf("\n Enter the second string:");
scanf("%[^\n]%*c", s2);
n=edit_DistDP(s1, s2, strlen(s1), strlen(s2));
printf("\n Output:");
printf(" %d\n ", n);
return 0;
}
/*
Input:
Enter the first string: "sunday"
Enter the second string: "saturday"
Output: 3
*/ |
the_stack_data/108561.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
static uint8_t table_fetch(uint8_t inputValue);
int main(int argc, char *argv[]) {
int inputValue = 0;
if (argc > 1) {
inputValue = atoi((char const *)argv[1]);
}
return (int)table_fetch(inputValue);
}
static uint8_t table_fetch(uint8_t inputValue) {
static uint8_t const table[] = {
0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00
};
return table[inputValue&0x0F];
}
|
the_stack_data/27796.c | /*
TITLE Output in C Chapter27Drill3.c
COMMENT
Objective: Define a C function that takes a char* parameter p
and an int parameter x and prints out their values
in this format: p is "foo" and x is 7.
Call it with a few argument pairs.
Input: -
Output: -
Author: Chris B. Kirov
Date: 12.06.2017
*/
#include <stdio.h> // printf
//-------------------------------------------------------------------
void print_name_value(char* p, int x)
{
printf("p is %s and x is %d.\n", p, x);
}
//-------------------------------------------------------------------
#ifdef __cplusplus
#else // compiling in C.
int main()
{
const int size = 6;
int i = 0;
char* p[ ] = {"foo", "bar", "Ginka", "Penka", "Mitsina", "Kotsena" };
int* x[ ] = { 7, 8, 9, 10, 11, 12 };
for (i; i < size; ++i)
{
print_name_value(p[i], x[i]);
}
getchar();
}
#endif |
the_stack_data/20450860.c | /*numPass=9, numTotal=9
Verdict:ACCEPTED, Visibility:1, Input:"abcdef
2", ExpOutput:"efabcd", Output:"efabcd"
Verdict:ACCEPTED, Visibility:1, Input:"programming
11", ExpOutput:"programming", Output:"programming"
Verdict:ACCEPTED, Visibility:1, Input:"hello-@programmer
5", ExpOutput:"ammerhello-@progr", Output:"ammerhello-@progr"
Verdict:ACCEPTED, Visibility:0, Input:"hellodear
3", ExpOutput:"earhellod", Output:"earhellod"
Verdict:ACCEPTED, Visibility:0, Input:"progamming
0", ExpOutput:"progamming", Output:"progamming"
Verdict:ACCEPTED, Visibility:0, Input:"programming
10", ExpOutput:"rogrammingp", Output:"rogrammingp"
Verdict:ACCEPTED, Visibility:0, Input:"programming
13", ExpOutput:"ngprogrammi", Output:"ngprogrammi"
Verdict:ACCEPTED, Visibility:0, Input:"abcde
4", ExpOutput:"bcdea", Output:"bcdea"
Verdict:ACCEPTED, Visibility:0, Input:"abcdz
5", ExpOutput:"abcdz", Output:"abcdz"
*/
#include <stdio.h>
void rotate(char str[],int n)
{
int i,count=0,t=0;
for(i=0;str[i]!='\0';i++)
{
count++;
}
char rotated[count];
for(i=0;i<count;i++)
{ if(n>count) n=n%count;
if(i+n>=count)
{
rotated[t]=str[i];
t++;
}
else
{
rotated[i+n]=str[i];
}
}
for(i=0;i<count;i++)
{
printf("%c",rotated[i]);
}
}
int main() {
char str[100];
scanf("%s",str);
int n;
scanf("%d",&n);
rotate(str,n);
return 0;
} |
the_stack_data/248581361.c | /* Copyright 2017 IBM Corporation
*
* 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.
*/
/*
Built with:
export PATH=/opt/at12.0/bin:$PATH
gcc -mcpu=power8 -mtune=power8 -m64 -g -lpthread -o pthread_test pthread_test.c
*/
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
static pthread_mutex_t m;
static pthread_barrier_t b;
static void *
tf (void *arg)
{
int e = pthread_mutex_unlock (&m);
if (e == 0)
{
puts ("child: 1st mutex_unlock succeeded");
exit (1);
}
else if (e != EPERM)
{
puts ("child: 1st mutex_unlock error != EPERM");
exit (1);
}
e = pthread_mutex_trylock (&m);
if (e == 0)
{
puts ("child: 1st trylock suceeded");
exit (1);
}
if (e != EBUSY)
{
puts ("child: 1st trylock didn't return EBUSY");
exit (1);
}
e = pthread_barrier_wait (&b);
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("child: 1st barrier_wait failed");
exit (1);
}
e = pthread_barrier_wait (&b);
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("child: 2nd barrier_wait failed");
exit (1);
}
e = pthread_mutex_unlock (&m);
if (e == 0)
{
puts ("child: 2nd mutex_unlock succeeded");
exit (1);
}
else if (e != EPERM)
{
puts ("child: 2nd mutex_unlock error != EPERM");
exit (1);
}
if (pthread_mutex_trylock (&m) != 0)
{
puts ("child: 2nd trylock failed");
exit (1);
}
if (pthread_mutex_unlock (&m) != 0)
{
puts ("child: 3rd mutex_unlock failed");
exit (1);
}
return NULL;
}
int
main (void)
{
pthread_mutexattr_t a;
int e;
if (pthread_mutexattr_init (&a) != 0)
{
puts ("mutexattr_init failed");
return 1;
}
if (pthread_mutexattr_settype (&a, PTHREAD_MUTEX_ERRORCHECK) != 0)
{
puts ("mutexattr_settype failed");
return 1;
}
e = pthread_mutex_init (&m, &a);
if (e != 0)
{
puts ("mutex_init failed");
return 1;
}
if (pthread_barrier_init (&b, NULL, 2) != 0)
{
puts ("barrier_init failed");
return 1;
}
e = pthread_mutex_unlock (&m);
if (e == 0)
{
puts ("1st mutex_unlock succeeded");
return 1;
}
else if (e != EPERM)
{
puts ("1st mutex_unlock error != EPERM");
return 1;
}
if (pthread_mutex_lock (&m) != 0)
{
puts ("mutex_lock failed");
return 1;
}
e = pthread_mutex_lock (&m);
if (e == 0)
{
puts ("2nd mutex_lock succeeded");
return 1;
}
else if (e != EDEADLK)
{
puts ("2nd mutex_lock error != EDEADLK");
return 1;
}
pthread_t th;
if (pthread_create (&th, NULL, tf, NULL) != 0)
{
puts ("create failed");
return 1;
}
e = pthread_barrier_wait (&b);
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("1st barrier_wait failed");
return 1;
}
if (pthread_mutex_unlock (&m) != 0)
{
puts ("2nd mutex_unlock failed");
return 1;
}
e = pthread_mutex_unlock (&m);
if (e == 0)
{
puts ("3rd mutex_unlock succeeded");
return 1;
}
else if (e != EPERM)
{
puts ("3rd mutex_unlock error != EPERM");
return 1;
}
e = pthread_barrier_wait (&b);
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("2nd barrier_wait failed");
return 1;
}
if (pthread_join (th, NULL) != 0)
{
puts ("join failed");
return 1;
}
if (pthread_mutex_destroy (&m) != 0)
{
puts ("mutex_destroy failed");
return 1;
}
if (pthread_barrier_destroy (&b) != 0)
{
puts ("barrier_destroy failed");
return 1;
}
if (pthread_mutexattr_destroy (&a) != 0)
{
puts ("mutexattr_destroy failed");
return 1;
}
return 0;
}
|
the_stack_data/153268616.c | int sub(int x, int y, int z) {
return x - y - z;
}
int main() {
return sub(10, 4, 2);
}
|
the_stack_data/147865.c | #include<stdio.h>
#define PI 3.141516
int main(){ //Funcion principal
//Variables
//tipoDato identificador;
float area; //3.14, 0.10, 0.0000001 10.0
float radio; //Declaracion variables
//float PI = 3.1416;
radio = 5; //Asignacion de valores
area = PI * (radio * radio); //Operacion
//area = 3.1416 * (5 * 5);
printf("Area\n"); //Impresion
printf("%s%f\n\n", "Area de Circulo con radio 5:", area); //Impresion
return 0;
}
|
the_stack_data/25136484.c | /***********************************************************
collatz.c -- Collatz (コラッツ) の予想
***********************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define LIMIT ((ULONG_MAX - 1) / 3)
int main(void)
{
unsigned long n;
printf("n = "); scanf("%lu", &n);
while (n > 1) {
if (n & 1) { /* 奇数 */
if (n > LIMIT) {
printf("\nOverflow\n"); return 1;
} else n = 3 * n + 1;
} else n /= 2;
printf(" %lu", n);
}
printf("\n");
return 0;
}
|
the_stack_data/184517593.c | /* GIMP RGBA C-Source image dump (phase_285.c) */
static const struct {
unsigned int width;
unsigned int height;
unsigned int bytes_per_pixel; /* 2:RGB16, 3:RGB, 4:RGBA */
unsigned char pixel_data[80 * 80 * 2 + 1];
} phase_285 = {
80, 80, 2,
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\10\0\0"
"\201\20\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\242\20\2051\3069\6B\3469\12c\3059\3059\40\0\40\0\40\0\40\0\0\0"
"\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0#!\12cKk\315{\213s\250Rks\2459"
"\3469@\10D)\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\10"
"hJ\15\204o\214\320\234\213s\253{\213s*k\2051GJ\241\20\40\0@\10\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\10\214s\217\224\222\265\360"
"\244M\214-\214\354\203js\310b\210Z\207R\302\30\40\0\302\30\40\0\40\10\40"
"\10\40\10\40\0@\10\40\0\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\40\0-\214R\265\20\2551\255\257"
"\234\15\214\216\234\212{\213{\11c\250ZFJd1@\10\40\0@\10\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0@\10gR0\255\24\316q\2750\255\256\244\216\234"
"\354\203jsJs\11c\250Z&J\345A#)@\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\40\0\256\234\17\255\261\275q\275\17\255M\224-\214\354\203"
"\313{Jk)k\350b&J\250Z\345A@\10\345A\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\3059\357\2540\2650\265\17\255\256\234N\224m\224-\224\14\214"
"\313\203\313{\351b)k\207R\6B\2041C)\305A\40\0\40\0\40\10\40\10@\10\40\10"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\40\0\351b\20\255P\265\357\244\317\244M\224-\214\14\214\256"
"\234M\224m\224)kJs)k\6B\2441\2041\201\20\302\30\242\30\201\20\40\0\40\10"
"@\10@\10@\10\40\10\40\10\40\0\40\10\40\0\40\10\40\10\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\40\0\317\2440\2550\255\20\255\317\244\216"
"\234\216\234m\224\216\224\216\234\14\214\354\213\11k\253{js\345A&JD)\201"
"\20\302\30\40\0@\10\40\0\40\0@\10\40\10@\10@\10@\10\40\10\40\0\40\10@\10"
"\40\0\40\0\40\10\40\0\40\0\40\0\40\0\40\10\40\10\40\10\40\10\40\10\40\0\40"
"\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\40\0M\224q\275\20"
"\255\360\244\357\244\317\244\257\234\317\244\317\244M\214\354\203\253{ks"
"\12k\11c\250Z\6B\3059\3!@\10a\20\40\0\40\0\40\0\40\0\40\0\40\10\40\10@\10"
"@\10@\10\40\10@\10@\10@\10@\10@\10\40\10\40\10\40\0\40\0\40\10\40\0\40\10"
"\40\10\40\0\40\10\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\40\0\253{Q\265\360\254\360\254\317\244\217\234n\224n\234\316\244m\224"
"\216\234\253{ks*k\12k\310ZGJ\6BD)\241\20\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\10\40\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\10\40\0"
"\40\10\40\10\40\10\40\10\40\0\40\10\40\10\40\0\40\0\40\0\40\0\40\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0JkQ\265\21\255\360\254\317\244\217\234n\234N\224\216"
"\234m\224-\214\256\234JsJs\11c\311Z\250ZgJd)C)\241\20\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\10\40\0@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40"
"\10\40\10@\10\40\10\40\10\40\0\40\10\40\0\40\0\40\10\40\0\40\0\40\0\0\0\0"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\207Rq\2751\265\360\254\360\244\257\234\217\234N\224"
"\216\224n\224\14\214\15\214\14\214ksJk\351b\210RGR\6BC)\342\40a\10\40\0\40"
"\0\40\0\40\0\40\0\40\10\40\0@\10\40\10\40\10@\10@\10@\10@\10@\10@\10@\10"
"@\10\40\10\40\0\40\0\40\10\40\10\40\10\40\10\40\0\40\10\40\10\40\10@\10\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0#)\262\275q\265\20\255\360\254\317"
"\244\257\234\217\234N\224\216\234n\224-\214\14\204\253{ks*k\351b\210RGJ\346"
"9\2459\342\30\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\10@\10@\10@\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\10\40\0\40\10\40\0\40\0\40"
"\10@\10\40\10\40\0\40\0\40\10\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\302\30\20\255q\2651"
"\2651\255\360\254\317\244\257\234\217\234n\224n\234-\214\15\214\314{\213"
"sJs*k\11c\250ZGJ\2041\2041\241\20\40\0\40\0\40\0\40\0\40\0\40\10\40\10@\10"
"@\10\40\10\40\10@\10@\10@\10@\10\40\10\40\10\40\0\40\10\40\10@\10\40\10\40"
"\10\40\0\40\10\40\0\40\0\40\0\40\0@\10\40\10@\10\40\10\40\10\40\0\40\10\40"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\216\234\222\275q\2650\255\20\255\360\244\317\234\257\234n\234"
"N\224-\224-\214\314\203\213s\213s*k\11c\351b\250Z&J\2451D)\201\20@\10\40"
"\0\40\0\40\0\40\0\40\0\40\10@\10@\10@\10@\10\40\10@\10@\10@\10\40\0\40\0"
"\40\0\40\0\40\0\40\10\40\10\40\0\40\0\40\0@\10\40\0\40\0\40\0\40\10@\10@"
"\10@\10\40\10\40\10\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\351b\262\275q\265Q\265\20\255\20\255"
"\357\244\357\244\257\234n\224N\224\15\214\355\203\254{\253{\213{Jk\11c\310"
"Z\210R\6B\3059\342\40a\10@\10\40\0\40\0\40\0\40\0\40\0\40\0@\10\40\10@\10"
"@\10@\10\40\10@\10@\10\40\10\40\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40"
"\10@\10@\10\40\10@\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\0\40\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0A\10q\265Q\265q\275"
"0\255\360\244\360\244\360\244\360\244n\234n\224N\224\15\214\15\204\314\203"
"\213{ksJk\351b\311ZgR\6B\2041\242\30a\20\40\0\40\0\40\10\40\10\40\10\40\0"
"\40\10@\10@\10@\10@\10\40\10\40\10@\10\40\10\40\10\40\10\40\10\40\10\40\0"
"\40\0\40\10\40\0\40\0\40\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40"
"\10\40\10\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0js\363\305\262\275Q\265\20\255\360\244\20\245\357\244\257\234"
"n\234n\224-\214\355\213\15\204\354\203k{ks*k\351b\351bgR\3059#)\3!\201\20"
"\40\0\40\10\40\0\40\0\40\10@\10@\10\40\10@\10@\10@\10@\10@\10\40\10\40\0"
"\40\10\40\10\40\0\40\10\40\0\40\0\40\10\40\0\40\0\40\0\40\10@\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0@\10\363\315\363\305\262\275Q\255\20\255"
"\20\255\20\245\317\244\317\244\216\234N\224M\224\15\204\354\203\314{\213"
"{js*k\351b\311Z\210R\3059\3!\302\30a\10\40\0\40\10\40\10\40\10@\10@\10@\10"
"@\10\40\10@\10@\10@\10@\10\40\10\40\10\40\10\40\10\40\0\40\10\40\10\40\0"
"\40\10\40\0\40\0\40\0\40\0\40\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10"
"\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\12k\23\316\322\305Q\2650\255\360\2440\255\360\244\20\255\20\255\257\234"
"n\224n\224\15\214\354\203\253{\213sJs\11c\351b\310ZGJ\3059D)\40\10\241\20"
"\40\10\40\10\40\10@\10@\10@\10@\10@\10@\10\40\10\40\10@\10@\10@\10\40\10"
"\40\10\40\10\40\10\40\10\40\10\40\10\40\10\40\10\40\0\40\0\40\0\40\0@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\20\23\316\23\316\222\275Q\265\20\255"
"\320\244\20\255\20\255q\275P\265\317\244n\234.\224\15\204\354\203\253{ks"
"ks\11c\351b\250Z\306A\2041#)\242\30\242\20\40\10\40\10\40\10\40\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\0\40\10\40\10\40\10\40\10"
"\40\10\40\0\40\0\40\0\40\0\40\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10"
"\40\0\40\10\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\313{4\326\23\316\221\265Q\265\360\244\360\244\20\2550\255q\275Q\265"
"\257\234N\224-\214\354\203\354\203\253{\213sJs)k\311b\250Z\6B\2459\343\40"
"\302\30\40\10\40\0\40\0\40\0\40\0@\10@\10@\10@\10@\10@\10@\10@\10@\10\40"
"\10\40\10\40\10\40\0\40\10\40\10\40\0@\10\40\10\40\0\40\0\40\0\40\0\40\0"
"\40\10@\10@\10@\10@\10@\10\40\10\40\10\40\10\40\10\40\10\40\0\40\0\40\0\40"
"\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0""3\326\23\316\322\305\222"
"\275\20\255\360\244\20\245\20\2550\255\360\254\257\234\216\234n\224\15\214"
"\14\204\354\203\253{\213{JkJk\311b\250Z\6J\2459D)\201\20@\10\40\10\40\10"
"\40\0\40\10\40\10\40\10\40\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\10\40\10"
"\40\10\40\10\40\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0@\10@\10\40\10\40"
"\10@\10@\10\40\10@\10\40\10@\10\40\0\40\0\0\0\0\0\0\0\40\0\40\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0GJ\265\346\262\305\222\275Q\265\360\244\320\244\20"
"\245\360\244\357\244\317\244\217\234n\234n\224\15\214\14\204\314\203\253"
"{\253{Js*k\351b\250Z\6J\2041\3!\242\30a\20\40\10\40\10\40\10@\10\40\10\40"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\0@\10\40\0\40\0\40\10\40\10\40"
"\10\40\0\40\0\40\0\40\0\40\0@\10@\10\40\10\40\0\40\10@\10@\10@\10@\10@\10"
"\40\0\40\0\40\0\40\0\0\0\0\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0u\326u"
"\336\222\275\222\275\20\255\360\244\320\244\360\244\320\244\317\244\257\234"
"\216\234n\224n\224\15\214\354\203\314{\253{k{\12k\11k\351b\210Z\346Ad1\242"
"\30\241\30\40\10\40\0@\10@\10\40\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10"
"@\10\40\10\40\10@\10\40\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\10@\10\40\0\40\10\40\0\40\0@\10@\10@\10@\10\40\0\40\0\40\0\40\0\0\0\0"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\3573\316\262\275Q\265\20\255\320"
"\244\320\244\320\244\257\234\257\234\217\234n\224n\224n\224-\214\354\203"
"\314\203\213{Js\310Z\351b\11cGJ&J#)\242\30\242\30@\10\302\30@\10@\10@\10"
"@\10@\10@\10@\10@\10@\10\40\10@\10@\10@\10\40\10@\10@\10@\10@\10@\10\40\10"
"\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\10\40\0\40\0\40\0\40\10@\10"
"@\10@\10\40\10\40\0\0\0\40\0\0\0\0\0\0\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0D)\26"
"\367\363\315\222\2751\265\20\255\320\244\257\244\360\244\257\234\257\234"
"\257\234n\224\216\224N\224M\224\354\203\254{\253{jsjs\11c\310b\6J\250Zd1"
"d1\3!@\10D)@\10@\10@\10\40\10@\10@\10@\10@\10\40\10@\10\40\10@\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0@\10\40\10@\10@\10@\10\40\0\40\0\40\0\40\0\0\0\0\0\40\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\213{\366\356\363\315\222\275Q\265\20\255\320\244\257\234"
"\257\234\216\224\257\234\216\234n\224\216\234N\224n\224\354\203\254{\213"
"{\253{\313{Js\351bFJFJ\6B&J\40\0@\10\40\0@\10@\10\40\10@\10@\10@\10@\10@"
"\10@\10@\10@\10@\0@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\10"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\10@\10@\10@\10@\10\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\221\275\365\356\23\316"
"\262\275Q\265\360\254\317\244\257\244\317\244\217\234\257\234\217\234\216"
"\224n\224M\224-\214\14\214\254{ks\314{\253{\212{\250Z\351bGR\6B\302\30`\10"
"@\10@\10@\10@\10@\10@\10\40\0\40\0\40\10@\10@\10\40\10@\10\40\10\40\10\40"
"\10\40\10@\10@\10@\10@\10\40\10\40\0\40\10\40\10\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\10\40\10@\10@\10\40\10\40\0\0\0\0\0\40\0\40"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\26\3577\367T\326\222\2751\255\20\255\360"
"\244\317\244\257\234\257\234n\224N\224\216\224n\224\257\234n\224M\214\253"
"{\213{\253{\213{\213s\207R\207RGR\210Zd)\241\30@\10@\10@\10@\10@\10@\10\40"
"\10\40\10@\10@\10@\10@\10@\10\40\10\40\0@\10@\10@\10@\10@\10@\10\40\10\40"
"\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\343\30"
"\270\377V\367\224\336\222\2751\255\20\255\360\244\257\244\217\234\217\234"
"n\224N\224\216\224\256\234\317\234\216\234M\224\314\203\254\203\253{ksjs"
"\310ZJk\302\30\11ca\10\241\20@\10@\10@\10@\10@\10@\10\40\10@\10@\10@\10@"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0@\10\40\10@\10\40"
"\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\2451\371\377w\377\225\336\262"
"\275Q\265q\265\360\244\360\244\257\244\217\234n\224\216\234\216\234\317\244"
"\316\244\256\234-\214\314\203\253{js*k*k\351b\350b&J\2041#)a\20@\10@\10@"
"\10@\10\40\0@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10"
"@\10@\10@\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\10@\10\40\10\40\0\40\0\40\0\0\0\40\0\0\0\0\0\0"
"\0\0\0\250R\331\377w\377\325\346\262\3051\255Q\265\257\244\360\244\317\244"
"\257\234\256\234\257\234\216\234\257\234\256\244\216\234\354\213\354\203"
"\254{js\254{*k\310Z'J\250Zd)\302\30\201\20\40\10\40\10@\10\40\10\40\10@\10"
"\40\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40"
"\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\10\40\0\40\10\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0M\214\331\377"
"6\3676\367\23\3161\255\20\255\360\244\360\244\217\234\216\224N\224n\224n"
"\224n\224\257\234n\234\354\203\354\203\253{\314{\213{)k\310ZgJGR\346A\205"
"1#)\40\10@\10\40\10@\10@\10@\10@\10@\10@\10@\10@\10@\10`\10`\10`\10`\10`"
"\10a\10`\10@\10@\10@\10@\10@\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\10\40\0\40\0\40\0\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\40\0"
"\40\0\0\0\0\0\0\0q\265\270\377\227\377V\367\363\3151\265\360\254\320\244"
"\257\244\217\234\257\234n\224N\224\217\234-\214M\224-\214\355\203\314\203"
"\253{Ksjs*k\11k*k\2041\342\30\3!@\10@\10@\10@\10@\10@\10@\10@\10\40\10@\10"
"@\10@\10@\10`\10`\10@\10a\10a\20a\20`\10@\10@\10@\10@\10\40\10\40\10\40\0"
"\40\0\40\0\40\0\40\0\40\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\256\234\370\377W\377"
"6\367\363\305Q\265\360\244\317\244\257\244\257\234\217\234n\224.\224M\224"
"n\224n\224-\214\314\203\254{k{ksJs\351b)k\207RD)\3!\242\30\201\20@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10`\10a\10a\10a\20a\20a\10`\10"
"@\10@\10@\10\40\10\40\10\40\10\40\10\40\0\40\0\40\10\40\10@\10\40\10\40\0"
"\40\0\40\0\40\10\40\0\40\0\40\0\40\0\0\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0"
"\0\0\0\0\261\265\230\377V\377\365\356\323\305Q\265\360\244\320\244\317\244"
"\257\234n\224N\224N\224-\214-\214\15\214\15\214\314\203\213{\213{ks\11k\351"
"b\250Z\351b\345A\3059\302\30\302\30@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10@\10@\10`\10`\10a\10a\10a\20a\20a\10`\10`\10@\10@\10@\10\40\10\40\10\40"
"\10\40\10\40\10\40\0@\10@\10@\10@\10\40\0\40\10\40\0\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0q\265\227\377x\377\264\346"
"\262\305q\265\360\254\317\244\257\234\257\234n\234N\224-\214-\214\15\214"
"\15\204\14\204\354\203\254{\253sJkJs\351b\210RGR\306A\346AC)\302\30@\10@"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10`\10`\10a\10a\10`\10a\10a\10a"
"\10`\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\10@\10@\10@\10@\10@\10@\10"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0p"
"\265\26\3676\367\325\356\23\316\222\275\360\254\317\244\257\244\357\244n"
"\234n\224-\214.\214-\214\314\203\314\203\314\203\254{\213{\253{Jk\351b'J"
"\3059\2041D)#!\342\30@\10@\10@\10@\10@\10@\10`\10@\10@\10@\10@\10@\10`\10"
"a\10a\10a\10`\10`\10a\10`\10`\10`\10@\10`\10@\10@\10@\10\40\10\40\10@\10"
"@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\0\0\0\0\0\0\222\265\227\377\26\367t\336T\326\262\275\360\244"
"\317\244\360\244\20\255n\224n\224N\224N\224-\214\314\203\314{\314\203\314"
"{\213{ks*k\352b\210ZGJ\3059\2459d1@\10\302\30@\10@\10`\10@\10@\10`\10`\10"
"@\10@\10`\10`\10`\10a\10a\10a\10a\10`\10a\10a\10`\10`\10`\10a\10a\10`\10"
"@\10\40\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\40"
"\0\0\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0-\204W\367\26\357\23\316\265\346"
"\362\315q\265\320\244\317\244\360\244\257\234n\224N\224-\214\15\214\355\203"
"\354\203\354\203\314{\213{ks\213s\351b\311b\3059\2459\2459\3!\40\10\3!@\10"
"@\10@\10`\10@\10@\10`\10`\10a\10`\10`\10`\10`\10`\10`\20`\10a\10a\10`\10"
"`\10a\20a\10a\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\0\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\3059\330\377"
"7\367\23\3166\367\23\316q\275\360\244\257\234\317\244\257\234n\224N\224."
"\214-\214-\214\354\203\354\203\254{\253{\253{\253{\11c\250R&J\3059d)\245"
"9#)@\10@\10@\10@\10@\10`\10@\10`\10`\10`\10`\10`\10`\10`\10`\10a\20a\20a"
"\10a\10`\10a\10a\20a\20a\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0"
"\0\302\30\270\3776\367\265\346\365\356s\336\322\3050\255\360\244\257\234"
"\257\234\216\234N\224-\214M\214-\214\354\203\314{\314\203\253{\253{\11k\351"
"b\210ZGJ\6B\3!\342\30a\20#!@\10@\10@\10@\10@\10`\10@\10@\10@\10@\10`\10`"
"\10`\10a\10a\20a\10a\10a\10a\10`\10a\10a\10`\10`\10`\10@\10@\10@\10@\10@"
"\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\10\40\0\40"
"\0\40\0\0\0\0\0\0\0\0\0\343\30\270\3776\367\365\356\325\356\224\336\322\305"
"1\265\20\255\320\244\257\234\217\234n\224N\224M\224-\214\14\204\254{\254"
"{\253{\354\203\11c\11c\210RGR\3059\302\30d1a\10a\20\40\10\40\10@\10@\10@"
"\10`\10@\10@\10@\10@\10@\10@\10`\10a\10a\10a\10`\10a\10`\10a\10a\10a\10a"
"\10a\10a\10a\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0"
"\40\0\40\0\40\0@\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\330\3776\3676\367"
"\366\366\265\346\22\316q\2750\265P\265\317\244\317\244n\224N\224\216\234"
"-\214\355\203\254{\253{Js\213s*k\11c\210RGJ\346Ad1#)\201\20@\10@\10@\10@"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10`\10`\10a\10`\10`\10a\10a\20a"
"\10a\20a\10a\10a\10a\10`\10@\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\0\40"
"\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0""0\2556\367"
"\26\367\365\356\325\346\26\357\322\315Q\265q\265\20\255\357\244\317\244\257"
"\234\216\234n\224\15\214\314{\213{ksks*k\351bgRgR\346A\2459\302\30\201\20"
"@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10`\10`\10`\10a\10`\10"
"`\10a\10a\10a\10a\10a\10a\10a\10a\10a\10@\10@\10@\10@\10\40\10@\10@\10@\10"
"@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\250Zw\377W\377\26\367\325\346\26\3573\326\322\305\221\275\20\255Q\265"
"\20\255\317\244\256\244\256\244-\214\15\214\253{KsJk*k\351b\350b\250Z\306"
"Ad1\201\20\201\20@\10@\10\40\10@\10@\10@\10@\10@\10@\10@\10@\10`\10`\10`"
"\10`\10@\10`\10@\10a\10a\10a\10`\10a\10a\10a\10a\10a\10a\10@\10@\10@\10\40"
"\10@\10\40\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\3!\267\377\366\356\325\356\265\346\224\336\22\316\322"
"\305\322\3051\2650\2550\255\357\244\256\244\317\244-\214M\214\254{ksjsJk"
"\213{\351b\210Z\6B\2041\343\40\241\20@\10@\10\40\10@\10@\10@\10@\10@\10`"
"\10`\10@\10@\10@\10@\10@\10`\10a\10`\10`\10`\10`\10@\10a\10a\10a\10a\10a"
"\10a\10@\10@\10@\10\40\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0T\316\26\367\325\356\365\356"
"\325\3563\326\22\316\322\305\221\275P\2650\2650\265m\224\357\244N\224M\214"
"\354\203\253{\213s\12k\213s)kGR\346Ad1#)\201\20@\10\40\10\40\10@\10\40\10"
"@\10@\10@\10@\10`\10`\10`\10`\10`\10`\10a\10a\10`\10`\10`\10@\10`\10a\10"
"`\10a\10a\10a\10a\10@\10@\10@\10\40\10\40\10@\10@\10@\10@\10\40\10\40\0\40"
"\0\40\0\40\0\40\0\40\0\0\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\253{6\367V\367"
"6\3676\367t\3363\326\362\315\262\305q\275\362\305P\265n\234\256\234-\214"
"\355\203\254{\314{\254{\253{)kJkGJ\2459\2459#)\201\20\40\10\40\10\40\10@"
"\10\40\10@\10@\10`\10`\10`\10@\10@\10a\10a\10`\10@\10`\10`\10@\10@\10@\10"
"`\10`\10@\10a\10`\10a\10a\10@\10@\10\40\10\40\0\40\0@\10@\10\40\10@\10\40"
"\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\205"
"1\227\377w\377w\377w\377\224\3363\326\362\315\322\305q\275\322\305P\265n"
"\234M\214\354\203\254{\254{\213s,\214\213{)kJk\207RGJ\2041#)\242\30\40\0"
"\40\10\40\10@\10\40\10@\10@\10`\10`\10@\10@\10@\10`\10a\10@\10@\10@\10`\10"
"`\10@\10a\10`\10@\10`\10`\10a\10`\10`\10@\10@\10@\10\40\10@\10@\10@\10@\10"
"\40\10\40\0\40\0\40\0\40\10\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0""7\357\227\377\230\377\271\377\366\356\325\346S\326\362\305\221"
"\275\262\305\20\255n\224\15\214\354\203\314{\254{\213{\14\214\213{\351b\351"
"b\310ZGJ\2041#!\342\30\40\10\40\10\40\10@\10@\10@\10@\10`\10`\10@\10@\10"
"@\10@\10`\10@\10`\10`\10@\10`\10`\10`\10@\10@\10@\10`\10`\10`\10a\10@\10"
"@\10@\10@\10@\10\40\10@\10@\10\40\10\40\0\40\0\40\0@\10\40\0\40\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0kkW\377\227\377\231\377\27\347\26\357"
"t\336\224\336\322\305\23\326\357\254\216\234-\214\15\214\254{\213{\253{\254"
"{\213{\351b\250Z\250Z\346A\3059\3!\342\40@\10\40\0\40\10\40\10@\10@\10@\10"
"`\10`\10@\10`\10`\10`\10@\10@\10a\10`\10`\10a\10a\10`\10@\10@\10@\10a\10"
"a\10a\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\10\40\0\40"
"\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3!\365\346W\377x\367"
"Y\3578\357\326\346T\3262\316\321\305\357\244\257\234n\224-\214\314\203\254"
"{\253{\213{\253{*k\351b\250Z\346A\346Ad1\241\20@\10\40\10\40\0\40\10\40\10"
"@\10@\10`\10@\10@\10a\10a\10`\10@\10a\10a\10a\10a\10a\10`\10`\10@\10@\10"
"@\10a\10a\10`\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\10"
"\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0@\10n\224W\377"
"W\367\231\367\27\357\265\346T\336t\326\362\3150\265\357\254n\234M\214\354"
"\203\314\203\314\203\354\203\253{Jk\351b\311bGJ\6B\2051\302\30@\10\40\0\40"
"\10\40\10@\10@\10`\10a\10`\10a\10a\10a\10a\10`\10a\10a\10a\10a\10`\10`\10"
"@\10@\10@\10`\10a\10`\10@\10@\10`\10`\10@\10@\10\40\10@\10@\10@\10@\10@\10"
"\40\10\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\2459W\3676\3676\367\366\356t\3363\326\225\336\225\336\221\275P\265\216"
"\234n\224\15\214\354\203\314\203-\214\14\204*k*k\210R\310b&J#)\302\30\40"
"\10`\10@\10@\10@\10@\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10@\10@"
"\10@\10`\10a\10a\10`\10`\10`\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10@\10@\10@\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\40\0N\2146\367\264\346\366\356\224\3363\326\265\346\225\336\23\316"
"\221\275\17\255\357\244-\214-\214\14\214-\214\354\203Js*k\250Z\350bgR\245"
"9D)@\10@\10@\10@\10@\10a\10a\10a\10`\10a\10a\10a\10a\10a\10a\10`\10@\10@"
"\10@\10@\10`\10a\10a\10@\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10@\10@\10@\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0A\10\225\336\365\356\325\356\224\346t\336T\3263\326T\326\363"
"\305q\2750\255\216\234M\224M\224,\214\253{Js\311b\11k\351b\207R\6Bd1\40\0"
"\201\20\0\0`\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10`\10@\10@"
"\10`\10a\10`\10`\10`\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10@\10\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0*kW\367\325\356\325\346t\336\362\3153\326\362\315\363\305"
"\221\275\17\255\316\244\256\234\216\234,\214\213{jsjs\11k\11k\11kgR#!\342"
"\40\2451\3059a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10`\10@\10"
"`\10a\10a\10@\10@\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10"
"@\10@\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0Q\265\26\357\264\346\224\336s\326S\326\322\315\221\275"
"\221\275\17\255\317\244\317\244-\214M\224\354\203js\213{)k\11cJkgR\346A\305"
"9\2459\6Ba\10a\10a\10a\10a\10a\10a\10a\10a\10a\10`\10a\10`\10a\10a\10`\10"
"a\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10"
"\40\10\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\302\30\366\356t\336\265\346\224\336\224\336\362\315p\265"
"p\265\357\244\317\244n\234\14\214M\224,\214\14\214\11k\213{JkJk'J\207R\346"
"A\0\0\0\0a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10`\10a\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40"
"\10\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\14\204S\326\265\346T\326\225\336\322\305q\275P\265\17"
"\255\17\255\357\254\216\234\216\234\354\203\216\234\213{\253{JsJk\351b\210"
"RC)d1a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10@\10`\10`\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10@\10\40\10\40\0"
"\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\213{\224\336\224\336\224\336S\326\221\275P\265"
"\221\275\17\2550\265\316\244\317\244M\224,\214M\214JsIk\207ZjsGJ\2051'Ja"
"\10@\10a\10a\10a\10a\10a\10a\10a\10a\10a\10@\10`\10@\10@\10@\10@\10@\10@"
"\10`\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\40\0M\214\265\336\265\336S\326p\275\357\244p\275\317\244"
"\20\255\316\244\216\234\357\244m\224\360\244\213s\354\203\11cksGJ*k\2459"
"A\10\201\20a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10a\10@\10@\10a\10@\10@"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\0\0\40"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\40\0\256\234\325\346T\336\322\305\221\275P\265"
"\17\2550\255\256\244-\214\14\214-\224\256\234\313\203\253{ks\11kGJ*khJ@\10"
"\302\30a\10A\10A\10a\10a\10@\10a\10a\10a\10a\10a\10@\10@\10@\10@\10@\10@"
"\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\10\40\10\40\0\40\0\40\0\40\0\40"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\14\214\224\336\322\305S\326\261\305P\265"
"\20\255\256\234M\224M\224M\224\256\234\253{\253{\313\203\351b\207R\3059\210"
"R\242\20@\10@\10A\10@\10@\10@\10a\10@\10A\10@\10a\10@\10@\10@\10@\10@\10"
"@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\0\40\0\40\0\40\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\213s\362\3053\326\363\315\261\305"
"0\265n\234\216\234\216\234-\224\14\214M\224-\214\213{js\310Z\3059gJ$)@\10"
"@\10A\10@\10@\10A\10a\10@\10@\10A\10@\10@\10@\10@\10@\10@\10@\10@\10@\10"
"@\10@\10@\10@\10\40\10@\10\40\10\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\310Z\222\275\322\305\363\315\317\244"
"\357\254\256\244\256\234\354\203\253{-\214\313\203\14\214\310Z\250Z\250Z"
"ks\2051@\10@\10@\10A\10A\10A\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@"
"\10@\10@\10@\10@\10\40\10\40\10\40\0\40\0\40\0\40\0\40\0\0\0\40\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0C)P\265\261\305\221\275"
"\261\275\316\244\216\234M\224\313\203\14\214\14\214\354\203\212sjs\254{\210"
"R\3469a\20@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10"
"@\10\40\10@\10@\10\40\10\40\0\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\241\20m\224P\2650"
"\255\17\2550\255M\224\215\234n\224\14\214\314\203\314{\253{\11chR\342\40"
"\343\30@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10@\10\40"
"\10\40\10\40\10@\10\40\0\40\0\40\10\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\213s\256\234"
"\362\305\221\265Q\2650\255n\224ks\314{\15\214\210R*k\351b\6B\242\30\40\0"
"@\10@\10@\10@\10\40\10@\10@\10@\10@\10@\10@\10\40\10\40\0\40\0\40\0\40\0"
"\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\241\20\320\234"
"M\224q\265Q\2651\2451\255-\214\257\234\314{\310Z\314{\3469\6B\242\20@\10"
"@\10@\10\40\10@\10@\10@\10@\10@\10@\10@\10\40\0\40\10\40\0\40\0\40\0\40\0"
"\40\10\40\0\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2051\213s"
"1\255\21\255n\224Jk\354\203\310Z*k-\214\311Za\10GJ\40\0@\10@\10@\10@\10@"
"\10\40\10@\10@\10@\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\242\30\351bn\224n\224"
"\355{\254s\213s\214{\250ZGJD)\242\20@\10\40\0\40\0\40\0\40\10\40\0\40\0\40"
"\10\40\0\40\0\40\0\40\0\40\10\40\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\241\20\346A+k\15\214Jk\250Z"
"Jk\210RGJ\12cD)\40\0@\10\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40\0\40"
"\0\40\0\40\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\343\40#)\351b&JJkD)\2051a\10D)\40\0\40\0"
"a\10\40\0\40\0\40\0\40\0\0\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\202\20\0\0\0\0#!a\10\0\0\40\0\3059\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
};
|
the_stack_data/26700520.c | /* RUN: jlang-cc -fsyntax-only -verify -std=c90 -pedantic %s
*/
void
foo (void)
{
struct b;
struct b* x = 0;
struct b* y = &*x;
}
void foo2 (void)
{
typedef int (*arrayptr)[];
arrayptr x = 0;
arrayptr y = &*x;
}
void foo3 (void)
{
void* x = 0;
void* y = &*x; /* expected-warning{{address of an expression of type 'void'}} */
}
extern const void cv1;
const void *foo4 (void)
{
return &cv1;
}
extern void cv2;
void *foo5 (void)
{
return &cv2; /* expected-warning{{address of an expression of type 'void'}} */
}
typedef const void CVT;
extern CVT cv3;
const void *foo6 (void)
{
return &cv3;
}
|
the_stack_data/502392.c | #include <term.h>
#define erase_overstrick tigetflag("eo")
/** can erase overstrikes with a blank **/
/*
TERMINFO_NAME(eo)
TERMCAP_NAME(eo)
XOPEN(400)
*/
|
the_stack_data/1032692.c | //////////////////////////////////////////////////////////////////////////////////
/* CE1007/CZ1007 Data Structures
2016/17 S1
Author and Lab Group: HTET NAING / FSP 7
Program name: FSP7_Htet Naing
Date: November 10,2016
Purpose: Implementing the required functions for Assignment 1 (Question 1)*/
//////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
//////////////////////////////////////////////////////////////////////////////////
typedef struct _listnode {
int item;
struct _listnode *next;
} ListNode; // You should not change the definition of ListNode
typedef struct _linkedlist {
int size;
ListNode *head;
} LinkedList; // You should not change the definition of LinkedList
///////////////////////// function prototypes ////////////////////////////////////
// This is for question 1. You should not change the prototype of this function
int insertSortedLL(LinkedList *ll, int item);
// You may use the following functions or you may write your own
void printList(LinkedList *ll);
void removeAllItems(LinkedList *ll);
ListNode * findNode(LinkedList *ll, int index);
int insertNode(LinkedList *ll, int index, int value);
int removeNode(LinkedList *ll, int index);
//////////////////////////// main() //////////////////////////////////////////////
int main()
{
LinkedList ll;
int c, i, j;
c = 1;
//Initialize the linked list 1 as an empty linked list
ll.head = NULL;
ll.size = 0;
printf("1: Insert an integer to the sorted linked list:\n");
printf("2: Print the index of the most recent input value:\n");
printf("3: Print sorted linked list:\n");
printf("0: Quit:");
while (c != 0)
{
printf("\nPlease input your choice(1/2/3/0): ");
scanf("%d", &c);
switch (c)
{
case 1:
printf("Input an integer that you want to add to the linked list: ");
scanf("%d", &i);
j = insertSortedLL(&ll, i);
printf("The resulting linked list is: ");
printList(&ll);
break;
case 2:
printf("The value %d was added at index %d\n", i, j);
break;
case 3:
printf("The resulting sorted linked list is: ");
printList(&ll);
break;
case 0:
removeAllItems(&ll);
break;
default:
printf("Choice unknown;\n");
break;
}
}
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
/* The function below aims to sort the items in the linkedlist in the ascending order.
Whenever a new item is added, it will be inserted at the suitable place to maintain the ascending order.
If the insertion succeeds, the function returns the index position of the new node that is added.
Otherise it returns -1. */
int insertSortedLL(LinkedList *ll, int item)
{
//i and j are used to keep track of the current node and the index position of the new item in the linkedlist respectively.
int i, j, sameNumber;
//sameNumber is used to check if the new item has the same value as the existing item. Initially set to 0.
i = j = sameNumber = 0;
//ptr is the temporary pointer used to traverse nodes in the linkedlist.
ListNode *ptr = ll->head;
//First the program checks whether the size of the linked list is zero.
if (ll->size == 0) {
//If it is zero, the first node is inserted at index 0.
insertNode(ll, j, item);
}
else {
//Otherwise, the new item is compared against all the existing items.
//It can be done by traversing existing nodes in the linkedlist using the temporary pointer(ptr).
while (ptr != NULL) {
//If the new item is greater than current item, the current index+1 is assigned to j
//(because the bigger number should come after the current index number).
if (item > ptr->item) {
j = i + 1;
}
//If the new item is similar to one of the existing items, sameNumber is set to 1 and j to -1.
else if (item == ptr->item) {
j = -1;
sameNumber = 1;
}
ptr = ptr->next;
i++;
}
//the new item will be added only if the sameNumber is not set to 1.
if (!sameNumber) {
insertNode(ll, j, item);
}
}
//The function returns j value which represents the index position of the new node.
return j;
}
///////////////////////////////////////////////////////////////////////////////////
void printList(LinkedList *ll) {
ListNode *cur;
if (ll == NULL)
return;
cur = ll->head;
if (cur == NULL)
printf("Empty");
while (cur != NULL)
{
printf("%d ", cur->item);
cur = cur->next;
}
printf("\n");
}
void removeAllItems(LinkedList *ll)
{
ListNode *cur = ll->head;
ListNode *tmp;
while (cur != NULL) {
tmp = cur->next;
free(cur);
cur = tmp;
}
ll->head = NULL;
ll->size = 0;
}
ListNode * findNode(LinkedList *ll, int index) {
ListNode *temp;
if (ll == NULL || index < 0 || index >= ll->size)
return NULL;
temp = ll->head;
if (temp == NULL || index < 0)
return NULL;
while (index > 0) {
temp = temp->next;
if (temp == NULL)
return NULL;
index--;
}
return temp;
}
int insertNode(LinkedList *ll, int index, int value) {
ListNode *pre, *cur;
if (ll == NULL || index < 0 || index > ll->size + 1)
return -1;
// If empty list or inserting first node, need to update head pointer
if (ll->head == NULL || index == 0) {
cur = ll->head;
ll->head = malloc(sizeof(ListNode));
ll->head->item = value;
ll->head->next = cur;
ll->size++;
return 0;
}
// Find the nodes before and at the target position
// Create a new node and reconnect the links
if ((pre = findNode(ll, index - 1)) != NULL) {
cur = pre->next;
pre->next = malloc(sizeof(ListNode));
pre->next->item = value;
pre->next->next = cur;
ll->size++;
return 0;
}
return -1;
}
int removeNode(LinkedList *ll, int index) {
ListNode *pre, *cur;
// Highest index we can remove is size-1
if (ll == NULL || index < 0 || index >= ll->size)
return -1;
// If removing first node, need to update head pointer
if (index == 0) {
cur = ll->head->next;
free(ll->head);
ll->head = cur;
ll->size--;
return 0;
}
// Find the nodes before and after the target position
// Free the target node and reconnect the links
if ((pre = findNode(ll, index - 1)) != NULL) {
if (pre->next == NULL)
return -1;
cur = pre->next;
pre->next = cur->next;
free(cur);
ll->size--;
return 0;
}
return -1;
} |
the_stack_data/117329053.c | //Author Grant Mitchell
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdbool.h>
#define TRANS 1
#define NOTRANS 0
#ifndef DEBUG
#define DEBUG 0
#endif
#define ENCODE 0
#define DECODE 1
#ifndef MODE
#define MODE ENCODE
#endif
int print_buffer(char *buf, unsigned int bytes) {
/* takes in a pointer to a buffer and prints out as many
* bytes as specified */
for(int i = 0; i < bytes; ++i)
{
printf("%c", buf[i]);
}
return bytes;
}
int transpose_buffer(char *out, char *in, unsigned int dim) {
/* do a columnar encipher/decipher
* from in to out
* using box of size dim*dim
* since it's a square, enciphering and deciphering is the same
*/
//2D array to store the data to be encrypted/decrypted
char trans[dim][dim];
int iter = 0; //Interate throught the stored data
//Loading the data into the 2d array. Loading it by rows.
//print_buffer(in, 100);
for(int i = 0; i < dim; i++)
{
for(int j = 0; j < dim; j++)
{
trans[j][i] = in[iter];
++iter;
}
}
iter = 0; //Reset the iterator
//Write the date from trans into the out array by reading through columns instead of rows
for(int i = 0; i < dim; i++)
{
for(int j = 0; j < dim; j++)
{
out[iter] = trans[i][j];
iter++;
}
}
return 0;
}
int dump_buffer(char *buffer, unsigned int bufsize,
unsigned int bytes, FILE *output) {
/* prints a buffer one character at a time to a file using %c
* takes in:
* buffer -- pointer to a buffer
* bufsize -- size of 'buffer'
* bytes -- number of bytes from buffer to print
* output -- path to the file to open and output to
*/
/* open the output or quit on error */
/*if ((output = fopen(output, "w+")) == NULL)
{
printf("Problem opening output file '%s'; errno: %d\n", output, errno);
return 1;
}*/
/* print 'bytes' bytes from buffer to output file one char at a time */
for(int i = 0; i < bytes; i++)
{
int out = buffer[i];
fprintf(output, "%c", out);
}
//print_buffer(buffer, bytes);
/* optional: wipe buffer using memset */
memset(buffer, 0, bufsize);
/* close output file */
//close(output);
return bytes;
}
int pad_buffer(char *buffer, unsigned int bufsize, unsigned int rbuf_index) {
/* pad_buffer pads the empty space in a buffer
* buffer -- pointer to buffer
* bufsize -- size of 'buffer'
* rbuf_index -- first "empty" spot in buffer, i.e.,
* put the 'X' at rbuf_index and fill the
* rest with 'Y' characters.
*/
int padded = 0;
buffer[rbuf_index] = 'X';
padded++;
rbuf_index++;
for(rbuf_index; rbuf_index < bufsize; rbuf_index++)
{
buffer[rbuf_index] = 'Y';
++padded;
}
return padded;
}
int unpad_buffer(char *buffer, unsigned int bufsize) {
/* unpads a buffer of a given size
* buffer -- buffer containing padded data
* bufsize -- size of 'buffer'
*/
//Remove all of the Ys
do{
bufsize--;
}
while(buffer[bufsize] != 'X');
return bufsize;
}
void vigenereHelper(int *key, char *in, int mode);
void transferData(char *read_buf, char *write_buf);
int main(int argc, char *argv[]) {
int i = 0; /* iterator we'll reuse */
if (argc < 4) {
printf("Missing arguments!\n\n");
printf("Usage: encoder dim infile outfile ['notrans']\n\n");
printf("Note: outfile will be overwritten.\n");
printf("Optional '1' as last parameter will disable transposition.\n");
return 1;
}
/* give input and output nicer names */
//unsigned int dim = atoi(argv[1]); /* dimension of the box */
int dim = 4;
int rounds = atoi(argv[1]);
char *keypath = argv[2];
char *input = argv[3]; /* input file path */
char *output = argv[4]; /* output file path */
/* use 'transmode' to determine if we are just padding or also
* doing transposition. very helpful for debugging! */
unsigned int transmode = TRANS; /* default is TRANS */
if (argc > 4 && (atoi(argv[4]) == 1)) {
printf("Warning: Transposition disabled\n");
transmode = NOTRANS;
}
unsigned int rbuf_count = 0;
unsigned int bufsize = dim * dim;
char read_buf[bufsize]; /* buffer for reading and padding */
char write_buf[bufsize]; /* buffer for transposition */
int key[16]; /*buffer for key* /
/* open the input or quit on error. */
FILE *INPUT;
if ((INPUT = fopen(input, "r")) == NULL) {
printf("Problem opening input file '%s'; errno: %d\n", input, errno);
return 1;
}
/* get length of input file */
unsigned int filesize; /* length of file in bytes */
unsigned int bytesleft; /* counter we reduce on reading */
struct stat filestats; /* struct for file stats */
int err;
if ((err = stat(input, &filestats)) < 0) {
printf("error statting file! Error: %d\n", err);
}
filesize = filestats.st_size;
bytesleft = filesize;
if (DEBUG) printf("Size of 'input' is: %u bytes\n", filesize);
FILE *KEYPATH;
if ((KEYPATH = fopen(keypath, "r")) == NULL) {
printf("Problem truncating output file '%s'; errno: %d\n", keypath, errno);
return 1;
}
/* truncate output file if it exists */
FILE *OUTPUT;
if ((OUTPUT = fopen(output, "w+")) == NULL) {
printf("Problem truncating output file '%s'; errno: %d\n", output, errno);
return 1;
}
/* loop through the input file, reading into a buffer and
* processing the buffer when 1) the buffer is full or
* 2) the file has ended (or in the case of decoding, when
* the last block is being processed.
*/
int rbuf_index = 0; /* index into the read buffer */
int symbol; /* we will read each input byte into 'symbol' */
int count = 0;
unsigned int keylength = 0;
int temp = 0;
bool addEnd = true;
//Get key
for(i = 0; i < 16; i++)
{
symbol = (unsigned char) fgetc(KEYPATH);
key[i] = symbol;
}
fclose(KEYPATH);
//Opens the input file stream
do{
for(temp = 0; temp < bufsize; temp++)
{
if(((symbol = fgetc(INPUT)) != EOF))
{
read_buf[count] = symbol;
count++;
bytesleft--;
}
}
if(MODE == ENCODE)
{
int encSize;
if(count < bufsize)
{
addEnd = false;
encSize = count + pad_buffer(read_buf, bufsize, count);
for(i = 0; i < rounds; i++)
{
vigenereHelper(key, read_buf, MODE);
transpose_buffer(write_buf,read_buf, dim);
transferData(read_buf,write_buf);
}
}
else{
for(i = 0; i < rounds; i++)
{
vigenereHelper(key, read_buf, MODE);
transpose_buffer(write_buf, read_buf, dim);
transferData(read_buf,write_buf);
}
}
dump_buffer(write_buf, 16, 16, OUTPUT);
}
else{ //DECODING unpad only for last block.
for(i = 0; i < rounds; i++)
{
transpose_buffer(write_buf, read_buf, dim);
vigenereHelper(key, write_buf, MODE);
transferData(read_buf, write_buf);
}
if(bytesleft == 0)
{
//print_buffer(write_buf, bufsize);
int decSize = unpad_buffer(write_buf, bufsize);
dump_buffer(write_buf, bufsize, decSize, OUTPUT);
}
else{
dump_buffer(write_buf, bufsize, bufsize, OUTPUT);
}
}
count = 0;
}
while(bytesleft != 0);
//Add the padding when an entire padding block is needed
if(MODE == ENCODE)
{
if(addEnd)
{
//printf("%s", "We in addEnd");
read_buf[0] = 'X';
for(int j = 1; j < bufsize; j++)
{
read_buf[j] = 'Y';
}
for(i = 0; i < rounds; i++)
{
vigenereHelper(key, read_buf, MODE);
transpose_buffer(write_buf, read_buf, dim);
transferData(read_buf,write_buf);
}
dump_buffer(write_buf, bufsize, bufsize, OUTPUT);
}
}
fclose(INPUT);
fclose(OUTPUT);
return 0;
}
/*Helper function that copies the data in write_buf to read_buf */
void transferData(char *read_buf, char *write_buf)
{
for(int j = 0; j < 16; j++)
{
read_buf[j] = write_buf[j];
}
}
/*Helper function to executed a vigenere cipher on each block of input */
void vigenereHelper(int *key, char *in, int mode)
{
//char key[16]; /* we will only copy up to 128 bytes into the array */
unsigned int length = 16; /* length of the data */
int symbol; /* we'll read characters into this variable */
char cipher; /* we will read encrypted and decrypted chars into this var*/
unsigned int i = 0; /* iterator we'll reuse */
int k = 0; /*iterator for the key*/
/* perform a simple vigenere cipher
* -------------------------------
* accepts three arguments:
* 1. An input file of a key
* 2. An input file with content to either encrypt or decrypt
* 3. An output file to write to
*/
if (mode == 0)
{
//Read in the input file and encrypt symbol
for(i = 0; i < length; i++)
{
//printf("%s", "In v");
symbol = (unsigned char) in[i];
k = k % 16; //Keeps on looping over the key
cipher = ((symbol + key[k]) % 256);
in[i] = cipher; //Print cipher to output
k++;
}
}
else //Decoding
{
//Read in the input file and decrypt symbol
for(i = 0; i < length; i++)
{
symbol = (unsigned int) in[i];
k = k % 16;
cipher = ((symbol - key[k] + 256) % 256);
in[i] = cipher;
k++;
}
}
}
|
the_stack_data/765686.c | /* { dg-do link } */
/* { dg-options "-O2" } */
extern int link_error (int);
int tst2 (int x, int y)
{
/* VRP should be able to extract range information for
x and y out of this TRUTH_AND_EXPR. */
if ((x > 5555) && (y < 6666))
{
if (x > 5555)
if (y < 6666)
return 1111;
else
return link_error (2222);
else
if (y < 6666)
return link_error (3333);
else
return link_error (4444);
}
else
return 0;
}
int main()
{
return 0;
}
|
the_stack_data/165769564.c | /*Program to check whether the inputed character is equal to 'y'*/
void main()
{
char ch;
clrscr();
printf("Enter a character : ");
scanf("%c",&ch);
if(ch=='y'||ch=='Y')
printf("Yes,the given character is 'y'.");
else
printf("No,the given character is not 'y'.");
getch();
} |
the_stack_data/61076149.c | /* { dg-do run } */
/* { dg-options "-O2" } */
__attribute__ ((noinline))
double direct(int x, ...)
{
return x*x;
}
__attribute__ ((noinline))
double broken(double (*indirect)(int x, ...), int v)
{
return indirect(v);
}
int main ()
{
double d1, d2;
int i = 2;
d1 = broken (direct, i);
if (d1 != i*i)
{
__builtin_abort ();
}
return 0;
}
|
the_stack_data/145536.c |
/* A test program written to test robustness to decompression of
corrupted data. Usage is
unzcrash filename
and the program will read the specified file, compress it (in memory),
and then repeatedly decompress it, each time with a different bit of
the compressed data inverted, so as to test all possible one-bit errors.
This should not cause any invalid memory accesses. If it does,
I want to know about it!
PS. As you can see from the above description, the process is
incredibly slow. A file of size eg 5KB will cause it to run for
many hours.
*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <[email protected]>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include <stdio.h>
#include <assert.h>
#include "bzlib.h"
#define M_BLOCK 1000000
typedef unsigned char uchar;
#define M_BLOCK_OUT (M_BLOCK + 1000000)
uchar inbuf[M_BLOCK];
uchar outbuf[M_BLOCK_OUT];
uchar zbuf[M_BLOCK + 600 + (M_BLOCK / 100)];
int nIn, nOut, nZ;
static char *bzerrorstrings[] = {
"OK", "SEQUENCE_ERROR", "PARAM_ERROR", "MEM_ERROR", "DATA_ERROR", "DATA_ERROR_MAGIC",
"IO_ERROR", "UNEXPECTED_EOF", "OUTBUFF_FULL", "???" /* for future */
, "???" /* for future */
, "???" /* for future */
, "???" /* for future */
, "???" /* for future */
, "???" /* for future */
};
void flip_bit(int bit) {
int byteno = bit / 8;
int bitno = bit % 8;
uchar mask = 1 << bitno;
//fprintf ( stderr, "(byte %d bit %d mask %d)",
// byteno, bitno, (int)mask );
zbuf[byteno] ^= mask;
}
int main(int argc, char **argv) {
FILE *f;
int r;
int bit;
int i;
if (argc != 2) {
fprintf(stderr, "usage: unzcrash filename\n");
return 1;
}
f = fopen(argv[1], "r");
if (!f) {
fprintf(stderr, "unzcrash: can't open %s\n", argv[1]);
return 1;
}
nIn = fread(inbuf, 1, M_BLOCK, f);
fprintf(stderr, "%d bytes read\n", nIn);
nZ = M_BLOCK;
r = BZ2_bzBuffToBuffCompress(
zbuf, &nZ, inbuf, nIn, 9, 0, 30);
assert (r == BZ_OK);
fprintf(stderr, "%d after compression\n", nZ);
for (bit = 0; bit < nZ * 8; bit++) {
fprintf(stderr, "bit %d ", bit);
flip_bit(bit);
nOut = M_BLOCK_OUT;
r = BZ2_bzBuffToBuffDecompress(
outbuf, &nOut, zbuf, nZ, 0, 0);
fprintf(stderr, " %d %s ", r, bzerrorstrings[-r]);
if (r != BZ_OK) {
fprintf(stderr, "\n");
} else {
if (nOut != nIn) {
fprintf(stderr, "nIn/nOut mismatch %d %d\n", nIn, nOut);
return 1;
} else {
for (i = 0; i < nOut; i++)
if (inbuf[i] != outbuf[i]) {
fprintf(stderr, "mismatch at %d\n", i);
return 1;
}
if (i == nOut) fprintf(stderr, "really ok!\n");
}
}
flip_bit(bit);
}
#if 0
assert (nOut == nIn);
for (i = 0; i < nOut; i++) {
if (inbuf[i] != outbuf[i]) {
fprintf ( stderr, "difference at %d !\n", i );
return 1;
}
}
#endif
fprintf(stderr, "all ok\n");
return 0;
}
|
the_stack_data/225144200.c | /*
* This file is part of 'pdp', a PDP-11 simulator.
*
* For information contact:
*
* Computer Science House
* Attn: Eric Edwards
* Box 861
* 25 Andrews Memorial Drive
* Rochester, NY 14623
*
* Email: [email protected]
* FTP: ftp.csh.rit.edu:/pub/csh/mag/pdp.tar.Z
*
* Copyright 1994, Eric A. Edwards
*
* Permission to use, copy, modify, and distribute this
* software and its documentation for any purpose and without
* fee is hereby granted, provided that the above copyright
* notice appear in all copies. Eric A. Edwards makes no
* representations about the suitability of this software
* for any purpose. It is provided "as is" without expressed
* or implied warranty.
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#define RL_CYL_RL01 256
#define RL_CYL_RL02 512
#define RL_NUM_SECT 40
#define RL_NUM_HEADS 2
#define RL_WORDS_SECTOR 128
#define RL_BYTES_SECTOR (RL_WORDS_SECTOR * 2)
#define RL_SECT_RL01 (RL_CYL_RL01 * RL_NUM_HEADS * RL_NUM_SECT)
#define RL_SECT_RL02 (RL_CYL_RL02 * RL_NUM_HEADS * RL_NUM_SECT)
#define DEFAULT_NAME "./DRIVE.0"
main( argc, argv )
int argc;
char *argv[];
{
unsigned size = RL_SECT_RL01;
if ( argc == 1 ) {
make_it( DEFAULT_NAME, size );
} else {
while ( --argc ) {
argv++;
if ( **argv == '-' ) {
switch( (*argv)[1] ) {
case '1':
size = RL_SECT_RL01;
break;
case '2':
size = RL_SECT_RL02;
break;
default:
fprintf( stderr, "unknown flag -%c\n",
(*argv)[1] );
exit( 1 );
break;
}
} else {
make_it( *argv, size );
}
}
}
}
make_it( file, sectors )
char *file;
unsigned sectors;
{
char buf[RL_BYTES_SECTOR];
struct stat sbuf;
FILE *fp;
int x;
if ( stat( file, &sbuf ) == 0 ) {
fprintf( stderr, "file already exists: %s\n", file );
exit( 1 );
}
for ( x = 0; x < RL_BYTES_SECTOR; ++x )
buf[x] = x;
if (( fp = fopen( file, "w" )) == NULL ) {
fprintf( stderr, "can't open: %s\n", file );
exit( 1 );
}
for ( x = 0; x < sectors; ++x )
fwrite( buf, RL_BYTES_SECTOR, 1, fp );
fclose( fp );
}
|
the_stack_data/53243.c | #include <stdio.h>
void main() {
int num = 24, i ;
for (i=1 ; i <=num; i++ ){
if (i % 2 == 0){
printf("%d\n", i);
}
}
} |
the_stack_data/161080789.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2014-2017 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <unistd.h>
static void
after_sleep (void)
{
return; /* after sleep */
}
int
main (void)
{
sleep (3);
after_sleep ();
return 0;
}
|
the_stack_data/179830440.c | #include<stdio.h>
int main()
{
int mark;
printf("Enter marks: ");
scanf("%d",&mark);
if(mark>84 && mark<101)
printf("Grade A\n");
else if(mark>69 && mark<85)
printf("Grade B\n");
else if(mark>54 && mark<70)
printf("Grade C\n");
else if(mark>39 && mark<55)
printf("Grade D\n");
else if( mark<40)
printf("Grade F\n");
else
printf("Invalid Input");
return 0;
}
|
the_stack_data/74505.c | #include <stdio.h>
#include <string.h>
#include <sys/ptrace.h>
#include <stdlib.h>
/* Flag : dc91120{n0_one_c4n_reverse_m3} */
#define INVALID_KEY "ERRRRR Wrong KEY!"
#define CORRECT_KEY "WOOOOO Correct KEY"
int main(int, char ** ); // for some reason this was important to avoid warnings
int cstrchk(char, char);
char fake_key_[30]; // <--+
// |------ both of these strings are essentially checking for debugger
char check_key[30]; // <--+
int cstrchk(char a, char b) {
if (a != b) {
return -1;
} else {
return 1;
}
}
/* here is a function that will execute before main() */
__attribute__((__constructor__))
void func013(int argc, char ** argv) {
//code here
puts("\n\n\t\tCRACKME\n\n");
int fortune = 0;
printf("Enter Key: ");
scanf("%30s", fake_key_);
if (argc < 2) {
main(3, argv);
} else {
int xor_key = ptrace(PTRACE_TRACEME, 0, 0, 0); // if debugger is attatched then this will return 0
int forutne = 0;
for (int i = 0; i < strlen(fake_key_); i++) {
fortune += fake_key_[i];
check_key[i] = fake_key_[i];
fake_key_[i] = fake_key_[i] ^ xor_key; // a^0=a so if its not already debugged then fake_key_ and check_key will be same
}
for (int i = 0; i <= strlen(check_key); i++) {
if (cstrchk(fake_key_[i], check_key[i]) != 1) {
exit(-1);
}
if (fortune == (2745)) {
int check = main(1, argv);
if (check == 348) {
if ((argv[1][0]) - (argv[1][29]) != -25) {
main(3, argv);
} else if ((argv[1][1]) - (argv[1][28]) != 48 && argv[1][1] ^ argv[1][28] != 80) {
main(3, argv);
} else if ((argv[1][2]) - (argv[1][27]) != -52 && argv[1][2] ^ argv[1][27] != 84) {
main(3, argv);
} else if ((argv[1][3]) - (argv[1][26]) != -46 && argv[1][3] ^ argv[1][26] != 110) {
main(3, argv);
} else if ((argv[1][4]) - (argv[1][25]) != -52 && argv[1][4] ^ argv[1][25] != 84) {
main(3, argv);
} else if ((argv[1][5]) - (argv[1][24]) != -65 && argv[1][5] ^ argv[1][24] != 65) {
main(3, argv);
} else if ((argv[1][6]) - (argv[1][23]) != -66 && argv[1][6] ^ argv[1][23] != 66) {
main(3, argv);
} else if ((argv[1][7]) - (argv[1][22]) != 22) {
main(3, argv);
} else if ((argv[1][8]) - (argv[1][21]) != -8 && argv[1][8] ^ argv[1][21] != 24) {
main(3, argv);
} else if ((argv[1][9]) - (argv[1][20]) != -53 && argv[1][9] ^ argv[1][20] != 85) {
main(3, argv);
} else if ((argv[1][10]) - (argv[1][19]) != -19 && argv[1][10] ^ argv[1][19] != 45) {
main(3, argv);
} else if ((argv[1][11]) - (argv[1][18]) != 16 && argv[1][11] ^ argv[1][18] != 48) {
main(3, argv);
} else if ((argv[1][12]) - (argv[1][17]) != 0) {
main(3, argv);
} else if ((argv[1][13]) - (argv[1][16]) != 49 && argv[1][13] ^ argv[1][16] != 81) {
main(3, argv);
} else if ((argv[1][14]) - (argv[1][15]) != -4 && argv[1][14] ^ argv[1][15] != 60) {
main(3, argv);
} else if ((argv[1][15]) - (argv[1][14]) != 4) {
main(3, argv);
} else if ((argv[1][16]) - (argv[1][13]) != -49 && argv[1][16] ^ argv[1][13] != 81) {
main(3, argv);
} else if ((argv[1][17]) - (argv[1][12]) != 0 && argv[1][17] ^ argv[1][12] != 0) {
main(3, argv);
} else if ((argv[1][18]) - (argv[1][11]) != -16 && argv[1][18] ^ argv[1][11] != 48) {
main(3, argv);
} else if ((argv[1][19]) - (argv[1][10]) != 19 && argv[1][19] ^ argv[1][10] != 45) {
main(3, argv);
} else if ((argv[1][20]) - (argv[1][9]) != 53 && argv[1][20] ^ argv[1][9] != 85) {
main(3, argv);
} else if ((argv[1][21]) - (argv[1][8]) != 8) {
main(3, argv);
} else if ((argv[1][22]) - (argv[1][7]) != -22 && argv[1][22] ^ argv[1][7] != 30) {
main(3, argv);
} else if ((argv[1][23]) - (argv[1][6]) != 66 && argv[1][23] ^ argv[1][6] != 66) {
main(3, argv);
} else if ((argv[1][24]) - (argv[1][5]) != 65 && argv[1][24] ^ argv[1][5] != 65) {
main(3, argv);
} else if ((argv[1][25]) - (argv[1][4]) != 52 && argv[1][25] ^ argv[1][4] != 84) {
main(3, argv);
} else if ((argv[1][26]) - (argv[1][3]) != 46 && argv[1][26] ^ argv[1][3] != 110) {
main(3, argv);
} else if ((argv[1][27]) - (argv[1][2]) != 52 && argv[1][27] ^ argv[1][2] != 84) {
main(3, argv);
} else if ((argv[1][28]) - (argv[1][1]) != -48) {
main(3, argv);
} else if ((argv[1][29]) - (argv[1][0]) != 25) {
main(3, argv);
} else {
puts(CORRECT_KEY);
}
} else {
puts(INVALID_KEY);
}
} else {
puts(INVALID_KEY);
}
main(1, argv);
exit(0);
}
}
}
int main(int argc, char ** argv) {
if (argc != 3) {
int token = 0;
for (int i = 0; i < 5; i++) {
token += argv[1][i] ^ (i * i);
}
return token;
} else {
puts(INVALID_KEY);
exit(-1);
}
}
|
Subsets and Splits