file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/184518129.c
|
#include <stdio.h>
#include <math.h>
double pi(void);
int main(void) {
printf("Valor de PI: %.6f\n", pi());
}
double pi(void){
int n=0;
double valor_pi = 0.0, x;
while (n < 1000000) {
x = 4 * pow(-1,n)/(2*n +1);
valor_pi = x + valor_pi;
n++;
}
return valor_pi;
}
|
the_stack_data/121515.c
|
/* { dg-do compile } */
/* { dg-options "-mh -O2 -fomit-frame-pointer" } */
/* { dg-final { scan-assembler-times "extu" 1 } } */
unsigned long foo(unsigned long a)
{ return (a << 4) & 0xffff; }
|
the_stack_data/48576308.c
|
/* To make sure casts are properly handled */
void lhs05()
{
int x;
*(&x) = 1;
}
|
the_stack_data/106253.c
|
//bin/mkdir -p "${TMPDIR:-/tmp}/${d:=$(realpath -s "${0%/*}")}/${n:=${0##*/}}" && exec \
//usr/bin/make -C "$_" -sf/dev/null --eval="!:${n%.*};./$<" VPATH="$d" CFLAGS=-std=c99 LDFLAGS=-lX11 "$@"
// vim:ft=c
//---
// SUMMARY: listen keypress on desktop only (root window)
// USAGE: $ DISPLAY=:1 ./$0
// SRC: https://gist.github.com/javiercantero/7753445
//---
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include <X11/Xutil.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int
main(void)
{
Display* d;
Window r;
XEvent e;
KeySym key;
char text[256];
d = XOpenDisplay(NULL);
if (d == NULL) {
fprintf(stderr, "Cannot open display\n");
exit(1);
}
r = DefaultRootWindow(d);
XSelectInput(d, r, KeyPressMask | KeyReleaseMask);
XSync(d, False);
while (!XNextEvent(d, &e)) {
if (e.type == KeyPress && XLookupString(&e.xkey, text, 255, &key, 0) == 1) {
if (text[0] == 'q') {
break;
}
printf("'%c' key!\n", text[0]);
} else {
printf("event '%d'\n", e.type);
}
}
XCloseDisplay(d);
return 0;
}
|
the_stack_data/14199323.c
|
/*
* $XConsortium: DA32.c,v 1.3 94/04/17 20:16:33 gildea Exp $
*
*
Copyright (c) 1989 X Consortium
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
X CONSORTIUM 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.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
* *
* Author: Keith Packard, MIT X Consortium
*/
#include <X11/Xos.h>
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xdmcp.h>
void
XdmcpDisposeARRAY32 (array)
ARRAY32Ptr array;
{
Xfree (array->data);
array->length = 0;
array->data = 0;
}
|
the_stack_data/1090739.c
|
#include <stdio.h>
#include <math.h>
int sumdiv(int n);
main() {
int i, j, sum = 0,x;
printf("Enter the edge number: ");
scanf("%d",&x);
for (i = 2; i < x; i++) {
j = sumdiv(i);
if (i != j && i == sumdiv(j)) // isterseniz i<d yapip sum += i +d; yapabiliriz
sum += i ;
}
printf("%d\n", sum);
}
int sumdiv(int n) {
int sum= 1,i,a,hold = n;
for (i = 2; i <= n; i++) {
a = 1;
while (n % i == 0) {
a++;
n /= i;
}
sum *= (pow(i,a) - 1)/(i-1);
}
return sum - hold; //formul kendisini de hesaba kattigi icin sayinin kendisini cikariyorum
}
|
the_stack_data/82950452.c
|
#include "memory.h"
#include <math.h>
typedef struct {
float x;
float y;
float r;
unsigned char type;
unsigned char flags;
unsigned short eatenBy;
float age;
float boostX;
float boostY;
float boost;
} Cell;
typedef struct {
float x;
float y;
float hw;
float hh;
void* tl;
void* tr;
void* bl;
void* br;
unsigned short count;
unsigned short indices; // placeholder
} QuadNode;
#define IS_PLAYER(type) type <= 250
#define NOT_PLAYER(type) type > 250
#define IS_DEAD(type) type == 251
#define IS_ALIVE(type) type != 251
// #define IS_MOTHER_CELL(type) type == 252
#define IS_VIRUS(type) type == 253
#define IS_PELLET(type) type == 254
#define NOT_PELLET(type) type != 254
#define IS_EJECTED(type) type == 255
#define EXIST_BIT 0x1
#define UPDATE_BIT 0x2
#define INSIDE_BIT 0x4
#define LOCK_BIT 0x8
#define AUTOSPLIT_BIT 0x10
#define REMOVE_BIT 0x20
#define MERGE_BIT 0x40
#define POP_BIT 0x80
#define CLEAR_BITS 0x11
extern float get_score(unsigned char id);
extern void unlock_line(unsigned char id);
extern void remove_cell(unsigned short id, unsigned char type,
unsigned short eatenBy, unsigned char eatenByType);
extern void split_virus(float x, float y, float boostX, float boostY);
extern void pop_player(unsigned short id, unsigned char type, float mass);
extern void tree_update(unsigned short id);
size_t bytes_per_cell() { return sizeof(Cell); }
#define UPDATE_BITS 0x12
unsigned char get_cell_updated(Cell ptr[], unsigned short id) {
return IS_PLAYER(ptr[id].type) || (ptr[id].flags & UPDATE_BITS);
};
float get_cell_x(Cell ptr[], unsigned short id) { return ptr[id].x; };
float get_cell_y(Cell ptr[], unsigned short id) { return ptr[id].y; };
unsigned short get_cell_r(Cell ptr[], unsigned short id) { return ptr[id].r; };
unsigned char get_cell_type(Cell ptr[], unsigned short id) { return ptr[id].type; };
unsigned short get_cell_eatenby(Cell ptr[], unsigned short id) { return ptr[id].eatenBy; };
unsigned short new_cell(Cell cells[], unsigned short next_id, float x, float y, float size, unsigned char type,
float boost_x, float boost_y, float boost) {
while (!next_id || (cells[next_id].flags & EXIST_BIT)) next_id++;
Cell* cell = &cells[next_id];
cell->x = x;
cell->y = y;
cell->r = size;
cell->type = type;
cell->boostX = boost_x;
cell->boostY = boost_y;
cell->boost = boost;
cell->flags = EXIST_BIT;
return next_id;
}
unsigned short kill_cell(Cell cells[], unsigned short id, unsigned short next_id) {
while (!next_id || (cells[next_id].flags & EXIST_BIT)) next_id++;
Cell* old_cell = &cells[id];
Cell* new_cell = &cells[next_id];
memcpy(new_cell, old_cell, sizeof(Cell));
memset(old_cell, 0, sizeof(Cell));
new_cell->type = 251;
new_cell->flags = EXIST_BIT;
new_cell->age = 0.0f;
return next_id;
}
void update(Cell cells[], unsigned short* ptr, float dt,
unsigned int eject_max_age,
float auto_size, float decay_min, float static_decay, float dynamic_decay,
float l, float r, float b, float t) {
static_decay *= 0.01f;
Cell* cell = &cells[*ptr];
// Clear cell data
while (cell->flags & REMOVE_BIT) {
memset(cell, 0, sizeof(Cell));
cell = &cells[*++ptr]; // increment to next index
}
if (!*ptr) return;
unsigned char curr_type = 0;
float curr_multi = 1.0f;
// Player cells
while (*ptr) {
// Increment age, clear bits
cell->age += dt;
cell->flags &= CLEAR_BITS;
if (IS_EJECTED(cell->type) && eject_max_age && cell->age > eject_max_age)
cell->flags |= REMOVE_BIT;
// Boost cell
if (cell->boost > 1.0f) {
float db = cell->boost * 0.0025f * dt;
cell->x += cell->boostX * db;
cell->y += cell->boostY * db;
if (NOT_PLAYER(cell->type))
cell->flags |= UPDATE_BIT;
cell->boost -= db;
} else {
cell->boost = 1.0f;
}
if (IS_PLAYER(cell->type)) {
if (curr_type != cell->type) {
curr_type = cell->type;
float score = get_score(curr_type);
curr_multi = (score - 0.01f * decay_min * decay_min) * 0.00005f * dynamic_decay;
if (curr_multi < 1.f) curr_multi = 1.f;
}
// Decay and set the autosplit bit for player cells
if (cell->r > decay_min) {
cell->r -= curr_multi * cell->r * static_decay * dt * 0.0001f;
}
if (auto_size && cell->r > auto_size && !(cell->flags & AUTOSPLIT_BIT)) {
cell->flags |= AUTOSPLIT_BIT;
cell->age = 0.0f;
}
}
// Bounce and clamp the cells in the box
unsigned char bounce = cell->boost > 1;
float cr = cell->r;
if (cell->x < l + cr) {
cell->x = l + cr;
cell->flags |= UPDATE_BIT;
if (bounce) cell->boostX = -cell->boostX;
} else if (cell->x > r - cr) {
cell->x = r - cr;
cell->flags |= UPDATE_BIT;
if (bounce) cell->boostX = -cell->boostX;
}
if (cell->y > t - cr) {
cell->y = t - cr;
cell->flags |= UPDATE_BIT;
if (bounce) cell->boostY = -cell->boostY;
} else if (cell->y < b + cr) {
cell->y = b + cr;
cell->flags |= UPDATE_BIT;
if (bounce) cell->boostY = -cell->boostY;
}
cell = &cells[*++ptr]; // increment to next index
}
}
void update_player_cells(Cell cells[], unsigned short* indices, unsigned int n,
float mouse_x, float mouse_y,
unsigned char lock_dir, float a, float b, float c,
float dt,
float merge_initial, float merge_increase, float player_speed, float normalizer,
float merge_time, float no_merge_delay, unsigned char merge_version_new) {
if (!n) return;
if (merge_time > 0.0f) {
if (merge_version_new) {
for (unsigned int i = 0; i < n; i++) {
Cell* cell = &cells[indices[i]];
float increase = 25.f * cell->r * merge_increase;
float time = increase > merge_initial ? increase : merge_initial;
if (cell->age > normalizer * time) cell->flags |= MERGE_BIT;
}
} else {
for (unsigned int i = 0; i < n; i++) {
Cell* cell = &cells[indices[i]];
float increase = 25.f * cell->r * merge_increase;
float time = merge_initial + merge_increase;
if (cell->age > normalizer * time) cell->flags |= MERGE_BIT;
}
}
} else {
for (unsigned int i = 0; i < n; i++) {
Cell* cell = &cells[indices[i]];
if (cell->age > no_merge_delay) cell->flags |= MERGE_BIT;
}
}
// Move player cells
if (lock_dir) {
unsigned char all_flags = 0;
float line_a_b_sqr_sum_inv = 1.f / (a * a + b * b);
for (unsigned int i = 0; i < n; i++) {
Cell* cell = &cells[indices[i]];
all_flags |= cell->flags;
cell->flags |= LOCK_BIT;
float dx = mouse_x - cell->x;
float dy = mouse_y - cell->y;
float d = sqrtf(dx * dx + dy * dy);
if (d < 1) continue; dx /= d; dy /= d;
float speed = 1.76f * powf(cell->r, -0.4396754) * player_speed;
float m = (speed < d ? speed : d) * dt;
cell->x += dx * m;
cell->y += dy * m;
// Project point back to line
// cell->x = (b * ( b * x - a * y) - a * c) * line_a_b_sqr_sum_inv;
// cell->y = (a * (-b * x + a * y) - b * c) * line_a_b_sqr_sum_inv;
}
// This bit is used for checking wall
if (all_flags & UPDATE_BIT) {
// IF ANY CELL TOUCHES THE WALL
unlock_line(cells[indices[0]].type);
}
} else {
for (unsigned int i = 0; i < n; i++) {
Cell* cell = &cells[indices[i]];
float dx = mouse_x - cell->x;
float dy = mouse_y - cell->y;
float d = sqrtf(dx * dx + dy * dy);
if (d < 1) continue; dx /= d; dy /= d;
float speed = 1.76f * powf(cell->r, -0.4396754) * player_speed;
float m = (speed < d ? speed : d) * dt;
cell->x += dx * m;
cell->y += dy * m;
}
}
}
int is_safe(Cell* cells, float x, float y, float r, QuadNode* root, QuadNode** sp, unsigned char ignoreType) {
QuadNode** node_stack_pointer = sp;
*node_stack_pointer++ = root;
QuadNode* curr;
int counter = 0;
float dx;
float dy;
while (node_stack_pointer > sp) {
// Pop from the stack
curr = (QuadNode*) *--node_stack_pointer;
if (curr->tl) {
if (y - r < curr->y) {
if (x + r > curr->x)
*node_stack_pointer++ = curr->br;
if (x - r < curr->x)
*node_stack_pointer++ = curr->bl;
}
if (y + r > curr->y) {
if (x + r > curr->x)
*node_stack_pointer++ = curr->tr;
if (x - r < curr->x)
*node_stack_pointer++ = curr->tl;
}
}
for (unsigned int i = 0; i < curr->count; i++) {
Cell* cell = &cells[*(&curr->indices + i)];
if (cell->type > ignoreType) continue;
dx = cell->x - x;
dy = cell->y - y;
counter++;
if (dx * dx + dy * dy < (r + cell->r) * (r + cell->r)) return -counter;
}
}
return counter;
}
void sort_indices(Cell cells[], unsigned short indices[], int n) {
if (!n) return;
int t = 0;
// Build Max Heap
for (int i = 1; i < n; i++) {
// if child is bigger than parent
if (cells[indices[i]].boost < cells[indices[(i - 1) / 2]].boost ||
cells[indices[i]].r < cells[indices[(i - 1) / 2]].r) {
int j = i;
// swap child and parent until
// parent is smaller
while (cells[indices[j]].boost < cells[indices[(j - 1) / 2]].boost ||
cells[indices[j]].r < cells[indices[(j - 1) / 2]].r) {
t = indices[j];
indices[j] = indices[(j - 1) / 2];
indices[(j - 1) / 2] = t;
j = (j - 1) / 2;
}
}
}
for (int i = n - 1; i > 0; i--) {
// swap value of first indexed
// with last indexed
t = indices[0];
indices[0] = indices[i];
indices[i] = t;
// maintaining heap property
// after each swapping
int j = 0, index;
do {
index = (2 * j + 1);
// if left child is smaller than
// right child point index variable
// to right child
if ((cells[indices[index]].boost > cells[indices[index + 1]].boost ||
cells[indices[index]].r > cells[indices[index + 1]].r) && index < (i - 1)) index++;
// if parent is smaller than child
// then swapping parent with child
// having higher value
if ((cells[indices[j]].boost > cells[indices[index]].boost ||
cells[indices[j]].r > cells[indices[index]].r) && index < i) {
t = indices[j];
indices[j] = indices[index];
indices[index] = t;
}
j = index;
} while (index < i);
}
}
#define PHYSICS_NON 0
#define PHYSICS_EAT 1
#define PHYSICS_COL 2
#define SKIP_RESOLVE_BITS 0xa4
extern float get_line_a(unsigned char id);
extern float get_line_b(unsigned char id);
extern float get_line_c(unsigned char id);
extern void console_log(unsigned short id);
unsigned int resolve(Cell cells[],
unsigned short* ptr, unsigned short pellet_count,
QuadNode* root, QuadNode** sp,
unsigned int no_merge_delay, unsigned int no_colli_delay,
float eat_overlap, float eat_multi,
float virus_boost, float virus_max_boost,
float virus_size, float virus_max_size, unsigned int remove_tick) {
unsigned int collisions = 0;
unsigned short* ptr_copy = ptr;
while (*ptr) {
Cell* cell = &cells[*ptr++];
unsigned char flags = cell->flags;
unsigned char type = cell->type;
// Cell is to be removed, popped, or inside another cell
if (flags & SKIP_RESOLVE_BITS) continue;
if (IS_PELLET(type)) {
ptr += pellet_count;
continue;
}
if (IS_EJECTED(type) && !(flags & UPDATE_BIT)) continue;
if (IS_DEAD(type)) {
if (cell->age > remove_tick) {
cell->flags |= REMOVE_BIT;
cell->eatenBy = 0;
continue;
}
}
QuadNode** node_stack_pointer = sp;
*node_stack_pointer++ = root;
QuadNode* curr;
unsigned char colli = cell->age > no_colli_delay;
float x = cell->x;
float y = cell->y;
float r1 = cell->r;
float a = r1 * r1;
float cell_l = cell->x - r1;
float cell_r = cell->x + r1;
float cell_t = cell->y + r1;
float cell_b = cell->y - r1;
while (node_stack_pointer > sp) {
// Pop from the stack
curr = (QuadNode*) *--node_stack_pointer;
// Has leaves, push leaves, if they intersect, to stack
if (curr->tl) {
if (cell_b < curr->y) {
if (cell_r > curr->x)
*node_stack_pointer++ = curr->br;
if (cell_l < curr->x)
*node_stack_pointer++ = curr->bl;
}
if (cell_t > curr->y) {
if (cell_r > curr->x)
*node_stack_pointer++ = curr->tr;
if (cell_l < curr->x)
*node_stack_pointer++ = curr->tl;
}
}
unsigned short* iter = &curr->indices;
unsigned short* end = iter + curr->count;
while(iter < end) {
unsigned short other_index = *iter++;
Cell* other = &cells[other_index];
if (cell == other) continue; // Same cell
if (r1 < other->r) continue; // Skip double check
unsigned char other_flags = other->flags;
// Other cell can be skipped
if (other_flags & SKIP_RESOLVE_BITS) continue;
unsigned char action = PHYSICS_NON;
// Check player x player
if (IS_PLAYER(type)) {
if (type == other->type) { // same player
if (flags & other_flags & MERGE_BIT) // Both merge bits are set
action = PHYSICS_EAT; // player merge
else if (colli && other->age > no_colli_delay) action = PHYSICS_COL; // player collide
} else action = PHYSICS_EAT; // player eats everything else
} else if (IS_VIRUS(type) && IS_EJECTED(other->type)) {
// Virus can only eat ejected cell
action = PHYSICS_EAT;
} else if (IS_EJECTED(type) && IS_EJECTED(other->type)) {
// Ejected only collide with ejected cell
action = PHYSICS_COL;
} else if (IS_DEAD(type)) {
// Dead cell can only collide with others
if (IS_DEAD(other->type)) action = PHYSICS_COL;
}
// else if (IS_MOTHER_CELL(type)) {
// // Mother cell eats everything?
// action = PHYSICS_EAT;
// }
if (action == PHYSICS_NON) continue;
float dx = other->x - x;
float dy = other->y - y;
float r2 = other->r;
float r_sum = r1 + r2;
float d_sqr = dx * dx + dy * dy;
// Does not overlap
if (d_sqr >= r_sum * r_sum) continue;
float d = sqrtf(d_sqr);
collisions++;
if (action == PHYSICS_COL) {
float m = r_sum - d;
if (d <= 0.f) {
continue;
} else {
dx /= d;
dy /= d;
}
// Other cell is inside this cell, mark it
other->flags |= (d + r2 < r1) << 2;
// 1 << 2 = 0x4 which is INSIDE_BIT, but we are doing branchless here
float b = r2 * r2;
float sum = a + b;
float aM = b / sum;
float bM = a / sum;
float m1 = (m < r1 ? m : r1) * aM;
x -= dx * m1; // * 0.8f;
y -= dy * m1; // * 0.8f;
float m2 = (m < r2 ? m : r2) * bM;
other->x += dx * m2; // * 0.8f;
other->y += dy * m2; // * 0.8f;
// Mark the cell as updated
cell->flags |= UPDATE_BIT;
other->flags |= UPDATE_BIT;
} else if (action == PHYSICS_EAT) {
if ((type == other->type ||
r1 > other->r * eat_multi) &&
d < r1 - other->r / eat_overlap) {
a = r1 * r1 + r2 * r2;
r1 = sqrtf(a);
if (IS_VIRUS(other->type)) { // || IS_MOTHER_CELL(other->type)) {
other->eatenBy = 0;
} else {
other->eatenBy = cell - cells;
}
// Mark the cells as updated/removed
cell->flags |= UPDATE_BIT;
other->flags |= REMOVE_BIT;
if (NOT_PLAYER(type)) cell->flags |= AUTOSPLIT_BIT;
if (IS_PLAYER(type) && IS_EJECTED(other->type)) {
float ratio = other->r / (r1 + 100.f);
cell->boost += ratio * 0.025f * other->boost;
float bx = cell->boostX + ratio * 0.02f * other->boostX;
float by = cell->boostY + ratio * 0.02f * other->boostY;
float norm = sqrt(bx * bx + by * by);
cell->boostX = bx / norm;
cell->boostY = by / norm;
}
if (IS_VIRUS(other->type)) // || IS_MOTHER_CELL(other->type))
cell->flags |= POP_BIT; // Mark this cell as popped
if (IS_VIRUS(type) && IS_EJECTED(other->type)) {
if (virus_max_size && r1 >= virus_max_size) {
cell->flags |= POP_BIT; // Mark this as virus to be split
cell->boostX = other->boostX;
cell->boostY = other->boostY;
}
if (virus_boost) {
float newBoost = cell->boost + virus_boost;
newBoost = newBoost > virus_max_boost ? virus_max_boost : newBoost;
cell->boostX = cell->boostX * cell->boost + other->boostX * virus_boost;
cell->boostY = cell->boostY * cell->boost + other->boostY * virus_boost;
float norm = sqrtf(cell->boostX * cell->boostX + cell->boostY * cell->boostY);
cell->boostX /= norm;
cell->boostY /= norm;
cell->boost = newBoost;
}
}
}
}
}
}
cell->r = r1;
cell->x = x;
cell->y = y;
}
unsigned char lock_type = 0;
float line_a;
float line_b;
float line_c;
float line_a_b_sqr_sum_inv;
// Post resolve
while (1) {
unsigned short id = *ptr_copy++;
if (!id) break;
Cell* cell = &cells[id];
unsigned char type = cell->type;
unsigned char flags = cell->flags;
if (flags & REMOVE_BIT) {
remove_cell(id, type, cell->eatenBy, cells[cell->eatenBy].type);
continue;
} else if (flags & POP_BIT) {
if (IS_VIRUS(type)) {
cell->r = virus_size;
split_virus(cell->x, cell->y, cell->boostX, cell->boostY);
} else {
pop_player(id, type, cell->r * cell->r * 0.01f);
}
continue;
} else tree_update(id);
if (flags & LOCK_BIT) {
if (lock_type != type) {
line_a = get_line_a(type);
line_b = get_line_b(type);
line_c = get_line_c(type);
line_a_b_sqr_sum_inv = 1.f / (line_a * line_a + line_b * line_b);
lock_type = type;
}
float x0 = cell->x;
float y0 = cell->y;
cell->x = (line_b * (line_b * x0 - line_a * y0) - line_a * line_c) * line_a_b_sqr_sum_inv;
cell->y = (line_a * (-line_b * x0 + line_a * y0) - line_b * line_c) * line_a_b_sqr_sum_inv;
}
}
return collisions;
}
unsigned int select(Cell cells[], QuadNode* root,
QuadNode** sp, unsigned short* list_pointer,
float l, float r, float b, float t) {
unsigned short* write_pointer = list_pointer;
QuadNode** node_stack_pointer = sp;
// Push root to stack
*node_stack_pointer++ = root;
// Current node
QuadNode* curr;
while (node_stack_pointer > sp) {
// Pop from the stack
curr = *--node_stack_pointer;
if (l < curr->x - curr->hw &&
r > curr->x + curr->hw &&
b < curr->y - curr->hh &&
t > curr->y + curr->hh) {
// Temp stack pointer to save where we started inclusive check
QuadNode** temp_stack_pointer = node_stack_pointer;
*node_stack_pointer++ = curr;
QuadNode* curr_inclusive;
while (node_stack_pointer > temp_stack_pointer) {
// Pop from the stack
curr_inclusive = *--node_stack_pointer;
// Has leaves, push leaves without checking if they intersect
if (curr_inclusive->tl) {
*node_stack_pointer++ = curr_inclusive->br;
*node_stack_pointer++ = curr_inclusive->bl;
*node_stack_pointer++ = curr_inclusive->tr;
*node_stack_pointer++ = curr_inclusive->tl;
}
// Copy count * 2 bytes of indices data directly to write pointer
memcpy(write_pointer, &curr_inclusive->indices, curr_inclusive->count << 1);
write_pointer += curr_inclusive->count;
}
} else {
// Has leaves, push leaves, if they intersect, to stack
if (curr->tl) {
if (b < curr->y) {
if (r > curr->x)
*node_stack_pointer++ = curr->br;
if (l < curr->x)
*node_stack_pointer++ = curr->bl;
}
if (t > curr->y) {
if (r > curr->x)
*node_stack_pointer++ = curr->tr;
if (l < curr->x)
*node_stack_pointer++ = curr->tl;
}
}
for (unsigned int i = 0; i < curr->count; i++) {
unsigned short id = *(&curr->indices + i);
Cell* cell = &cells[id];
if (cell->x - cell->r <= r &&
cell->x + cell->r >= l &&
cell->y - cell->r <= t &&
cell->y + cell->r >= b &&
(NOT_PELLET(cell->type) || cell->age > 1)) {
*write_pointer++ = id;
}
}
}
}
return write_pointer - list_pointer;
}
|
the_stack_data/173578577.c
|
/** $lic$
* Copyright (C) 2016-2017 by The Board of Trustees of Cornell University
* Copyright (C) 2013-2016 by The Board of Trustees of Stanford University
*
* This file is part of iBench.
*
* iBench is free software; you can redistribute it and/or modify it under the
* terms of the Modified BSD-3 License as published by the Open Source Initiative.
*
* If you use this software in your research, we request that you reference
* the iBench paper ("iBench: Quantifying Interference for Datacenter Applications",
* Delimitrou and Kozyrakis, IISWC'13, September 2013) as the source of the benchmark
* suite in any publications that use this software, and that
* you send us a citation of your work.
*
* iBench 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 BSD-3 License for more details.
*
* You should have received a copy of the Modified BSD-3 License along with
* this program. If not, see <https://opensource.org/licenses/BSD-3-Clause>.
**/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <time.h>
#include <math.h>
#include <float.h>
#ifndef N
# define N 10000000
#endif
#ifndef OFFSET
# define OFFSET 0
#endif
static double bwData[N+OFFSET];
//#ifdef _OPENMP
extern int omp_get_num_threads();
//#endif
int main (int argc, char **argv) {
//#ifdef _OPENMP
//#pragma omp parallel
// {
//#pragma omp master
// {
// register int k = omp_get_num_threads();
// printf ("Number of Threads requested = %i\n",k);
// }
// }
//#endif
/*Usage: ./l2 <duration in sec> <intensity in percentage>*/
double scalar = 3.0;
if (argc < 3) {
printf("Usage: ./memBw <duration in sec> <intensity in percentage>\n");
exit(0);
}
unsigned int usr_timer = atoi(argv[1]);
double intensity = atoi(argv[2]) / 100.0;
if (intensity < 0) {
intensity = 0.01;
}
if (intensity > 1.0) {
intensity = 1.0;
}
unsigned int bwStreamSize = N * intensity;
unsigned int numChunks = N / bwStreamSize;
double doubleType;
printf("For intensity = %f, stream size = %ld Bytes\n", intensity, bwStreamSize * sizeof(doubleType));
double time_spent = 0.0;
while (time_spent < usr_timer) {
clock_t begin = clock();
for (int l = 1; l <= numChunks; l++) {
#pragma omp parallel for
for (int i = (l-1) * bwStreamSize; i < l * bwStreamSize; i++) {
bwData[i] = scalar * bwData[i];
}
}
#pragma omp parallel for
for (int i = numChunks * bwStreamSize; i < N; i++) {
bwData[i] = scalar * bwData[i];
}
clock_t end = clock();
time_spent += (double)(end - begin) / CLOCKS_PER_SEC;
}
return 0;
}
|
the_stack_data/95449695.c
|
#include <stdio.h>
int main(void) {
int n;
scanf("%d", &n);
int a[3], cnt = 0;
for (int i = 0; i < n; i++) {
a[0] = a[1];
a[1] = a[2];
scanf("%d", &a[2]);
if (i > 1) {
if ((a[0] < a[1] && a[1] < a[2]) ||
(a[0] > a[1] && a[1] > a[2])) cnt++;
}
}
printf("%d\n", cnt);
}
|
the_stack_data/76699323.c
|
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
int main(int argc, char **argv){
char *argumentos;
int i;
for(i=1;i<=argc;i++){
argumentos = argv[i];
//printf("%s\n",argumentos);
system(argumentos);
}
return 0;
}
|
the_stack_data/211079832.c
|
struct s {
struct {
struct {
int a[10];
} f[10];
int b;
};
};
void foo()
{
struct s s;
#pragma scop
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j)
s.f[i].a[j] = i * j;
s.b = 1;
#pragma endscop
}
|
the_stack_data/1187588.c
|
#include<stdio.h>
#include<stdlib.h>
struct ogr {
char ogr_isim[15], ogr_soyisim[20];
short ogr_yas;
float ogr_puan;
};
int main() {
int i, max=0, maxLoc;
struct ogr *ogrenci,ogrenciler[3];
struct ogr *maxLocStr;
for(i=0; i<3; i++) {
scanf("%s %s %d %f",ogrenciler[i].ogr_isim,ogrenciler[i].ogr_soyisim,
&ogrenciler[i].ogr_yas,&ogrenciler[i].ogr_puan);
if(ogrenciler[i].ogr_puan>max) {
max=ogrenciler[i].ogr_puan;
maxLoc=i;
}
}
/*
//scanf ile ogrrenciler[i].ogr_isim şeklinde alındı bilgiler
*
ogrenci=ogrenciler;
max=0;
for(i=0; i<3; i++) {
if(ogrenci->ogr_puan>max) {
max=ogrenci->ogr_puan;
maxLocStr=ogrenci;
}
ogrenci++;
}
printf("%s",maxLocStr->ogr_soyisim);
*/
printf("%s %d",ogrenciler[maxLoc].ogr_isim,max);
printf("\n");
ogrenci=&ogrenciler[maxLoc];
max=0;
printf("%s",ogrenci->ogr_soyisim); // printf("%s",(*ogrenci).ogr_soyisim); // calling member from struct with pointer
return 0;
}
|
the_stack_data/616414.c
|
// File created by mod2gbt
#pragma bank 255
const unsigned char music_track_0_0[] = {
0x00, 0x87,0x17, 0x93,0x10, 0x4A,0x06,
0x00, 0x25, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x87,0x17, 0x93,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x85,0x17, 0x91,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x87,0x17, 0x93,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x85,0x17, 0x91,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x87,0x18, 0x93,0x10, 0x00,
0x00, 0x24, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x87,0x18, 0x93,0x10, 0x00,
0x00, 0x24, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x8A,0x17, 0x96,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x89,0x17, 0x95,0x10, 0x00,
0x00, 0x25, 0x00, 0x00,
0x00, 0x20, 0x20, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x87,0x18, 0x93,0x1C, 0x93,0x10, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x87,0x18, 0x24, 0x20, 0x80,0x82,0x01,
0x24, 0x20, 0x00, 0x00,
0x87,0x16, 0x00, 0x93,0x10, 0x84,0x82,0x02,
0x22, 0x00, 0x00, 0x00,
0x87,0x15, 0x00, 0x20, 0x00,
0x21, 0x00, 0x00, 0x00,
0x20, 0x00, 0x91,0x10, 0x80,0x82,0x01,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x93,0x10, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x20, 0x84,0x82,0x02,
0x00, 0x00, 0x00, 0x00,
0x85,0x29, 0x91,0x1C, 0x91,0x10, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x87,0x29, 0x93,0x1C, 0x93,0x10, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x87,0x29, 0x24, 0x20, 0x80,0x82,0x01,
0x24, 0x20, 0x00, 0x00,
0x87,0x16, 0x00, 0x93,0x10, 0x84,0x82,0x02,
0x21, 0x00, 0x00, 0x00,
0x87,0x24, 0x00, 0x20, 0x00,
0x21, 0x00, 0x00, 0x00,
0x85,0x29, 0x91,0x1C, 0x96,0x10, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x20, 0x24, 0x95,0x10, 0x00,
0x00, 0x20, 0x00, 0x00,
0x85,0x29, 0x91,0x1C, 0x20, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x20, 0x24, 0x00, 0x00,
0x00, 0x20, 0x00, 0x00
};
const unsigned char music_track_0_1[] = {
0x93,0x2F, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x93,0x28, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x93,0x10, 0x84,0x82,0x02,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x84,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x84,0x82,0x02,
0x28, 0x85,0x18, 0x00, 0x00,
0x24, 0x24, 0x00, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x85,0x18, 0x00, 0x84,0x82,0x02,
0x24, 0x24, 0x00, 0x00,
0x20, 0x85,0x18, 0x00, 0x80,0x82,0x01,
0x00, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x8C,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x8C,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x8C,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x98,0x2F, 0x8C,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x96,0x2F, 0x85,0x18, 0x8C,0x10, 0x84,0x82,0x02,
0x2C, 0x24, 0x00, 0x00,
0x95,0x2F, 0x85,0x18, 0x20, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x84,0x82,0x01,
0x96,0x2F, 0x87,0x18, 0x87,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x95,0x2F, 0x87,0x18, 0x87,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x87,0x18, 0x87,0x10, 0x84,0x82,0x01,
0x24, 0x24, 0x20, 0x00,
0x93,0x2F, 0x87,0x18, 0x87,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x87,0x18, 0x00, 0x84,0x82,0x02,
0x24, 0x24, 0x00, 0x00,
0x20, 0x87,0x18, 0x87,0x10, 0x80,0x82,0x01,
0x00, 0x24, 0x20, 0x00,
0x00, 0x87,0x18, 0x00, 0x84,0x82,0x03,
0x00, 0x24, 0x00, 0x00,
0x00, 0x87,0x18, 0x00, 0x00,
0x00, 0x24, 0x00, 0x00
};
const unsigned char music_track_0_2[] = {
0x93,0x2F, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x28, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x24, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x93,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x28, 0x87,0x18, 0x93,0x10, 0x84,0x82,0x02,
0x24, 0x24, 0x00, 0x00,
0x93,0x2F, 0x87,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x84,0x82,0x02,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x91,0x2F, 0x85,0x18, 0x00, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x84,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x85,0x18, 0x00, 0x00,
0x24, 0x24, 0x00, 0x00,
0x91,0x2F, 0x85,0x18, 0x91,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x85,0x18, 0x00, 0x84,0x82,0x02,
0x24, 0x24, 0x00, 0x00,
0x20, 0x85,0x18, 0x00, 0x80,0x82,0x01,
0x00, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x8F,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x8F,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x8F,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x00, 0x00,
0x9B,0x2F, 0x83,0x18, 0x20, 0x00,
0x2C, 0x24, 0x00, 0x00,
0x9A,0x2F, 0x83,0x18, 0x8E,0x10, 0x84,0x82,0x03,
0x2C, 0x24, 0x20, 0x00,
0x98,0x2F, 0x83,0x18, 0x8E,0x10, 0x00,
0x2C, 0x24, 0x20, 0x84,0x82,0x01,
0x96,0x2F, 0x82,0x18, 0x8E,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x98,0x2F, 0x82,0x18, 0x8E,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x82,0x18, 0x00, 0x84,0x82,0x01,
0x24, 0x24, 0x00, 0x00,
0x9A,0x2F, 0x82,0x18, 0x8E,0x10, 0x80,0x82,0x01,
0x2C, 0x24, 0x20, 0x00,
0x28, 0x82,0x18, 0x00, 0x84,0x82,0x02,
0x24, 0x24, 0x00, 0x00,
0x20, 0x82,0x18, 0x8E,0x10, 0x80,0x82,0x01,
0x00, 0x24, 0x20, 0x00,
0x00, 0x82,0x18, 0x8E,0x10, 0x84,0x82,0x03,
0x00, 0x24, 0x20, 0x00,
0x00, 0x82,0x18, 0x8E,0x10, 0x84,0x82,0x04,
0x00, 0x24, 0x20, 0x00
};
const unsigned char music_track_0_3[] = {
0x9B,0x2F, 0x94,0x1F, 0x94,0x10, 0x80,0x82,0x02,
0x2C, 0x28, 0x00, 0x00,
0x9B,0x2F, 0x24, 0x00, 0x84,0x82,0x01,
0x2C, 0x20, 0x00, 0x00,
0x9B,0x2F, 0x91,0x1F, 0x00, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x9B,0x2F, 0x24, 0x00, 0x80,0x82,0x01,
0x2C, 0x20, 0x00, 0x00,
0x28, 0x8E,0x1F, 0x94,0x20, 0x84,0x82,0x02,
0x24, 0x28, 0x00, 0x00,
0x9B,0x2F, 0x91,0x1F, 0x00, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x24, 0x94,0x30, 0x84,0x82,0x02,
0x2C, 0x20, 0x00, 0x00,
0x98,0x2F, 0x00, 0x00, 0x80,0x82,0x01,
0x2C, 0x00, 0x00, 0x00,
0x9A,0x2F, 0x93,0x1F, 0x96,0x10, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x24, 0x00, 0x84,0x82,0x02,
0x2C, 0x20, 0x00, 0x00,
0x9A,0x2F, 0x8F,0x1F, 0x00, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x24, 0x00, 0x80,0x82,0x01,
0x2C, 0x20, 0x00, 0x00,
0x28, 0x8C,0x1F, 0x96,0x20, 0x84,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x8F,0x1F, 0x00, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x98,0x2F, 0x24, 0x96,0x30, 0x84,0x82,0x02,
0x2C, 0x20, 0x00, 0x00,
0x96,0x2F, 0x00, 0x00, 0x80,0x82,0x01,
0x2C, 0x00, 0x00, 0x00,
0x98,0x2F, 0x91,0x1F, 0x94,0x10, 0x84,0x82,0x02,
0x2C, 0x28, 0x00, 0x00,
0x98,0x2F, 0x24, 0x00, 0x84,0x82,0x02,
0x2C, 0x20, 0x00, 0x00,
0x98,0x2F, 0x91,0x1F, 0x00, 0x84,0x82,0x02,
0x2C, 0x28, 0x00, 0x00,
0x98,0x2F, 0x24, 0x00, 0x84,0x82,0x02,
0x2C, 0x20, 0x00, 0x00,
0x28, 0x91,0x1F, 0x94,0x20, 0x80,0x82,0x01,
0x24, 0x28, 0x00, 0x00,
0x98,0x2F, 0x24, 0x00, 0x80,0x82,0x01,
0x2C, 0x20, 0x00, 0x00,
0x96,0x2F, 0x8F,0x1F, 0x94,0x30, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x98,0x2F, 0x91,0x1F, 0x00, 0x84,0x82,0x02,
0x2C, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x93,0x1F, 0x93,0x10, 0x80,0x82,0x02,
0x2C, 0x28, 0x00, 0x00,
0x28, 0x94,0x1F, 0x00, 0x80,0x82,0x02,
0x24, 0x28, 0x00, 0x00,
0x20, 0x93,0x1F, 0x00, 0x84,0x82,0x01,
0x00, 0x28, 0x00, 0x00,
0x98,0x2F, 0x91,0x1F, 0x00, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x9A,0x2F, 0x93,0x1F, 0x93,0x20, 0x80,0x82,0x01,
0x2C, 0x28, 0x00, 0x00,
0x28, 0x24, 0x00, 0x00,
0x24, 0x20, 0x00, 0x00,
0x20, 0x00, 0x93,0x30, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
const unsigned char * const music_track_0__Data[] = {
music_track_0_0,
music_track_0_1,
music_track_0_2,
music_track_0_3,
0x0000
};
|
the_stack_data/7925.c
|
__attribute__ ((used))
unsigned int target(unsigned int n) {
unsigned int mod = n % 4;
unsigned int result = 0;
if (mod == 0) {
result = (n | 0xbaaad0bf) * (2 ^ n);
} else if (mod == 1) {
result = (n & 0xbaaad0bf) * (3 + n);
} else if (mod == 2) {
result = (n ^ 0xbaaad0bf) * (4 | n);
} else {
result = (n + 0xbaaad0bf) * (5 & n);
}
return result;
}
int main(void) {
return 0;
}
|
the_stack_data/1007971.c
|
/* PR sanitizer/82545. */
/* { dg-do compile } */
extern void c(int);
extern void d(void);
void *buf[5];
void a(void) {
{
int b;
&b;
__builtin_setjmp(buf);
c(b);
}
d();
}
|
the_stack_data/297338.c
|
#include <stdint.h>
static const uint32_t IEEE_POLY = 0xedb88320;
static const uint32_t CAST_POLY = 0x82f63b78;
static const uint32_t KOOP_POLY = 0xeb31d82e;
static uint32_t crc32tab[256];
static void
crc32_tabinit(uint32_t poly) {
int i, j;
for (i = 0; i < 256; i ++) {
uint32_t crc = i;
for (j = 0; j < 8; j ++) {
if (crc & 1) {
crc = (crc >> 1) ^ poly;
} else {
crc = (crc >> 1);
}
}
crc32tab[i] = crc;
}
}
void
crc32_init() {
crc32_tabinit(IEEE_POLY);
}
static uint32_t
crc32_update(uint32_t crc, const char *buf, int len) {
int i;
crc = ~crc;
for (i = 0; i < len; i ++) {
crc = crc32tab[(uint8_t)((char)crc ^ buf[i])] ^ (crc >> 8);
}
return ~crc;
}
uint32_t
crc32_checksum(const char *buf, int len) {
return crc32_update(0, buf, len);
}
|
the_stack_data/242330641.c
|
#include <stdio.h>
#include <time.h>
#include <ctype.h>
// #define PALM2UNIX(a) (a - 2082844800)
#define UNIX2PALM(a) (a + 2082844800 + 7200)
main(int argc, char **argv) {
struct tm tm;
time_t tim;
int i,j;
char str[64];
if(argc == 1) {
printf("/* no expiration date */\n");
return 0;
}
if(argc != 3) {
printf("Usage: %s day.month.year hour:minute:second\n", argv[0]);
return 1;
}
i = sscanf(argv[1], "%d.%d.%d", &tm.tm_mday, &tm.tm_mon, &tm.tm_year);
j = sscanf(argv[2], "%d:%d:%d", &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
if((i != 3)||(j!=3)) {
printf("Usage: %s day.month.year hour:minute:second\n", argv[0]);
return 1;
}
tm.tm_year -= 1900;
tm.tm_mon -= 1;
tm.tm_wday = 0;
tm.tm_yday = 0;
tm.tm_isdst = 1;
/* convert time into seconds unix time */
tim = mktime(&tm);
strcpy(str, ctime(&tim));
while(!isdigit(str[strlen(str)-1])) str[strlen(str)-1] = 0;
/* show time for verification */
printf("/*\n Time: %s\n", str);
printf(" Seconds since 1.1.1970 (Unix time): %lu\n", tim);
printf(" Seconds since 1.1.1900 (Palm time): %lu\n*/\n", UNIX2PALM(tim));
printf("#define EXPIRE_TIME_ASC \"%s\"\n", str);
printf("#define EXPIRE_TIME_SEC %luU\n", UNIX2PALM(tim));
return 0;
}
|
the_stack_data/37260.c
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
/*
* Helper functions for cpuset_in-set
*/
static char *cpuset_nexttok(const char *c)
{
char *r = strchr(c+1, ',');
if (r)
return r+1;
return NULL;
}
static int cpuset_getrange(const char *c, int *a, int *b)
{
int ret;
ret = sscanf(c, "%d-%d", a, b);
return ret;
}
/*
* cpusets are in format "1,2-3,4"
* iow, comma-delimited ranges
*/
bool cpu_in_cpuset(int cpu, const char *cpuset)
{
const char *c;
for (c = cpuset; c; c = cpuset_nexttok(c)) {
int a, b, ret;
ret = cpuset_getrange(c, &a, &b);
if (ret == 1 && cpu == a) // "1" or "1,6"
return true;
else if (ret == 2 && cpu >= a && cpu <= b) // range match
return true;
}
return false;
}
|
the_stack_data/923778.c
|
//
// Copyright (c) 2020 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include <stdio.h>
#if defined(_WIN32)
#include "CL/cl_d3d11.h"
#endif
int main( void )
{
printf("cl_d3d11.h standalone test PASSED.\n");
return 0;
}
|
the_stack_data/118097.c
|
// C program to implement stack using arrays
#include<stdio.h>
#include<stdlib.h>
// A stack data structure using array
struct stack
{
int top;
unsigned int capacity;
int *array;
};
// Utility function to initialize stack data structure
struct stack* createStack(int capacity)
{
struct stack *newStack =
(struct stack*)malloc(sizeof(struct stack));
newStack->top = -1;
newStack->capacity = capacity;
newStack->array = (int *)malloc(sizeof(capacity*sizeof(int)));
return newStack;
}
// Utility function to push to stack
int pushToStack (int num, struct stack *newStack)
{
if(newStack->top == 0) {
printf("The stack is full\n");
return newStack->top;
}
if(newStack->top == -1)
newStack->top = newStack->capacity-1;
else
newStack->top--;
newStack->array[newStack->top] = num;
return newStack->top;
}
// Utility function to pop from stack
int popFromStack (struct stack* newStack)
{
if(newStack->top == -1)
return newStack->top;
newStack->array[newStack->top] = 0;
++(newStack->top);
if (newStack -> top == newStack->capacity)
newStack->top = -1;
return(newStack->array[newStack->top]);
}
// Utility function to print out the contents of stack
int printStack(struct stack* newStack)
{
int top = newStack->top;
if(top == -1) {
printf("No items in stack to print\n");
return top;
}
while ((top != -1) && (top < newStack->capacity)) {
printf("| %d |", newStack->array[top], top);
top++;
}
return top;
}
// Driver program
int main()
{
struct stack *newStack = createStack(4);
//Pushing elements to stack
pushToStack(10, newStack);
pushToStack(20, newStack);
pushToStack(30, newStack);
pushToStack(40, newStack);
printf("After pushing\n");
printStack(newStack);
//Pop element from stack
if(popFromStack(newStack) == -1) {
printf("Stack is empty\n");
}
printf("\nAfter popping\n");
printStack(newStack);
return 0;
}
|
the_stack_data/10526.c
|
#include <stdio.h>
#define D 10086110
int a[10000110];
int main(){
int n,k,i,j,b,temp;
scanf("%d",&n);
for(i=0;i<=1000001;i++){
a[i]=0;
}
for(i=1;i<=n;i++){
scanf("%d",&b);
a[b]++;
}
scanf("%d",&k);
i=0;
for(j=1000000;j>0;j--){
if(a[j]!=0){
i++;
if(i==k)
break;
}
}
printf("%d %d",j,a[j]);
return 0;
}
|
the_stack_data/117081.c
|
/*******************************************************************************
* File Name: cymetadata.c
*
* PSoC Creator 4.2
*
* Description:
* This file defines all extra memory spaces that need to be included.
* This file is automatically generated by PSoC Creator.
*
********************************************************************************
* Copyright (c) 2007-2018 Cypress Semiconductor. All rights reserved.
* You may use this file only in accordance with the license, terms, conditions,
* disclaimers, and limitations in the end user license agreement accompanying
* the software package with which this file was provided.
********************************************************************************/
#include "stdint.h"
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_LOADER_META_SECTION
#define CY_LOADER_META_SECTION __attribute__ ((__section__(".cyloadermeta"), used))
#endif
CY_LOADER_META_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyloadermeta"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_loader[] = {
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_FLASH_PROT_SECTION
#define CY_FLASH_PROT_SECTION __attribute__ ((__section__(".cyflashprotect"), used))
#endif
CY_FLASH_PROT_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyflashprotect"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_flashprotect[] = {
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_META_SECTION
#define CY_META_SECTION __attribute__ ((__section__(".cymeta"), used))
#endif
CY_META_SECTION
#elif defined(__ICCARM__)
#pragma location=".cymeta"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_metadata[] = {
0x00u, 0x02u, 0x0Eu, 0x34u, 0x11u, 0x9Eu, 0x00u, 0x01u,
0x00u, 0x00u, 0x00u, 0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_CHIP_PROT_SECTION
#define CY_CHIP_PROT_SECTION __attribute__ ((__section__(".cychipprotect"), used))
#endif
CY_CHIP_PROT_SECTION
#elif defined(__ICCARM__)
#pragma location=".cychipprotect"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_chipprotect[] = {
0x01u
};
|
the_stack_data/38276.c
|
// Client side C/C++ program to demonstrate Socket programming
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#define PORT 1717
int main(int argc, char const *argv[])
{
int sock = 0, valread;
struct sockaddr_in serv_addr;
char buffer[1024] = {0};
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(argv[2]);
/* serv_addr.sin_port = htons(PORT); */
// Convert IPv4 and IPv6 addresses from text to binary form
/* if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) */
if(inet_pton(AF_INET, argv[3], &serv_addr.sin_addr)<=0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\nConnection Failed \n");
return -1;
}
//Get Picture Size
printf("Getting Picture Size\n");
FILE *picture;
picture = fopen(argv[1], "r");
int size;
fseek(picture, 0, SEEK_END);
size = ftell(picture);
fseek(picture, 0, SEEK_SET);
//Send Picture Size
printf("Sending Picture Size: %d\n", size);
write(sock, &size, sizeof(size));
//Send Picture as Byte Array
printf("Sending Picture as Byte Array\n");
char send_buffer[size];
while(!feof(picture)) {
fread(send_buffer, 1, sizeof(send_buffer), picture);
write(sock, send_buffer, sizeof(send_buffer));
bzero(send_buffer, sizeof(send_buffer));
}
return 0;
}
|
the_stack_data/710477.c
|
/*
* 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. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
*/
/*
* Copyright 2009 Jan Pechanec, Vladimir Kotal. All rights reserved.
* Use is subject to license terms.
*/
/* This is a source file template */
|
the_stack_data/40763136.c
|
int table_pc_normal[256]= {
1,2,2,2,2,2,2,2,5,2,2,2,2,6,2,2,
2,2,2,2,2,2,2,2,6,5,6,5,6,5,2,2,
2,2,4,6,5,8,6,2,3,3,6,6,3,4,2,4,
5,5,5,5,5,5,5,5,5,5,2,3,5,6,5,5,
8,6,5,6,6,5,5,7,6,4,5,5,5,6,6,7,
6,7,6,5,6,6,6,6,6,6,5,3,4,3,6,6,
3,6,5,5,5,5,4,5,5,2,3,5,2,6,5,5,
5,5,4,5,4,5,6,6,6,5,5,4,2,4,5,2,
6,2,3,6,5,6,4,4,4,6,5,4,6,2,2,2,
2,2,2,4,4,4,6,7,5,7,5,4,6,6,6,6,
2,2,6,6,6,6,2,6,4,6,4,6,5,4,6,6,
4,6,4,4,3,6,6,3,4,3,5,6,7,7,7,5,
6,6,6,6,6,6,7,6,5,5,5,5,4,4,4,4,
6,6,7,7,7,7,7,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,7,5,5,5,5,5,3,3,4,4,
7,5,5,5,5,5,5,6,6,5,5,5,5,5,6,5
};
int table_oz_normal[256]= {
1,6,6,6,6,6,6,5,5,2,6,6,5,6,6,7,
6,7,6,5,6,5,6,6,6,6,6,6,6,6,6,6,
2,2,4,6,5,8,6,2,3,3,6,6,3,4,2,4,
5,5,5,5,5,5,5,5,5,5,2,3,5,6,5,5,
8,6,5,6,6,5,5,7,6,4,5,5,5,6,6,7,
6,7,6,5,6,6,6,6,6,6,5,3,4,3,6,6,
3,6,5,5,5,5,4,5,5,2,3,5,2,6,5,5,
5,5,4,5,4,5,6,6,6,5,5,4,2,4,5,2,
6,5,5,6,6,6,6,5,5,5,5,4,4,3,6,6,
5,7,7,5,5,5,5,5,5,7,6,6,6,6,6,6,
5,3,5,5,5,6,6,6,5,6,6,7,7,2,6,6,
6,5,7,6,4,6,7,6,5,7,5,7,5,6,6,5,
6,6,6,6,6,6,6,6,6,4,4,3,3,5,4,6,
6,6,6,6,6,6,6,6,6,6,6,6,4,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,5,5,6,6,4,4,3,6,5,4,5,2
};
int table_pc_large[256]= {
1,4,4,4,4,4,4,4,6,4,4,4,4,4,4,4,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
4,2,4,7,6,10,8,2,4,4,6,6,3,4,2,4,
6,6,6,6,6,6,6,6,6,6,2,3,7,7,7,6,
12,7,7,7,7,6,6,7,7,4,6,7,6,8,7,7,
7,7,7,7,6,7,7,9,7,6,7,4,4,4,6,8,
3,6,6,6,6,6,5,6,6,3,4,6,3,9,6,6,
6,6,5,6,5,6,6,9,6,6,6,4,2,4,7,4,
6,4,3,6,6,6,6,6,4,7,6,4,11,4,4,4,
4,3,3,5,5,4,6,7,5,7,6,4,10,6,6,8,
4,2,6,6,6,6,2,6,4,9,5,6,6,6,9,7,
4,6,5,5,3,6,6,3,4,4,5,6,6,6,6,6,
7,7,7,7,7,7,10,7,6,6,6,6,4,4,4,4,
8,7,7,7,7,7,7,6,7,7,7,7,7,7,7,6,
6,6,6,6,6,6,10,6,6,6,6,6,4,4,4,4,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
};
int table_oz_large[256]= {
1,4,4,4,4,4,4,6,6,6,4,4,6,6,4,4,
4,4,6,6,6,4,4,4,6,6,6,6,6,6,6,6,
4,2,4,7,6,10,8,2,4,4,6,6,3,4,2,4,
6,6,6,6,6,6,6,6,6,6,2,3,7,7,7,6,
12,7,7,7,7,6,6,7,7,4,6,7,6,8,7,7,
7,7,7,7,6,7,7,9,7,6,7,4,4,4,6,8,
3,6,6,6,6,6,5,6,6,3,4,6,3,9,6,6,
6,6,5,6,5,6,6,9,6,6,6,4,2,4,7,4,
4,4,3,6,6,6,6,6,4,7,6,4,11,4,4,4,
4,3,3,5,5,4,6,7,5,7,6,4,10,6,6,8,
4,2,6,6,6,6,2,6,4,6,5,6,6,6,6,7,
4,6,5,5,3,6,6,3,4,4,5,6,6,6,6,6,
6,6,7,7,7,7,10,7,6,6,6,6,4,4,4,4,
8,7,7,7,7,7,7,6,7,7,7,7,7,7,7,6,
6,6,6,6,6,6,10,6,6,6,6,6,4,4,4,4,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
};
|
the_stack_data/1047463.c
|
//
// Created by kosmas on 21/2/22.
//
#include <string.h>
int memcmp(const void *pointer1, const void *pointer2, size_t numBytes) {
const unsigned char *pointer1AsBytes = (const unsigned char *) pointer1;
const unsigned char *pointer2AsBytes = (const unsigned char *) pointer2;
for (size_t i = 0; i < numBytes; i++) {
if (pointer1AsBytes[i] < pointer2AsBytes[i]) {
return -1;
}
else if (pointer2AsBytes[i] < pointer1AsBytes[i]) {
return 1;
}
}
return 0;
}
|
the_stack_data/1169350.c
|
void fence()
{
asm("sync");
}
void lwfence()
{
asm("lwsync");
}
void isync()
{
asm("isync");
}
int __unbuffered_cnt = 0;
int __unbuffered_p1_EAX = 0;
int __unbuffered_p2_EAX = 0;
int x = 0;
int y = 0;
int z = 0;
void *P0(void *arg)
{
z = 1;
x = 1;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void *P1(void *arg)
{
x = 2;
__unbuffered_p1_EAX = y;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void *P2(void *arg)
{
y = 1;
__unbuffered_p2_EAX = z;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
int main()
{
__CPROVER_ASYNC_0:
P0(0);
__CPROVER_ASYNC_1:
P1(0);
__CPROVER_ASYNC_2:
P2(0);
__CPROVER_assume(__unbuffered_cnt == 3);
fence();
// EXPECT:exists
__CPROVER_assert(
!(x == 2 && __unbuffered_p1_EAX == 0 && __unbuffered_p2_EAX == 0),
"Program proven to be relaxed for X86, model checker says YES.");
return 0;
}
|
the_stack_data/50834.c
|
// RUN: clang -o %t %s -O2
// RUN: llvm-mctoll -d %t
// RUN: clang -o %t1 %t-dis.ll
// RUN: %t1 2>&1 | FileCheck %s
// CHECK: 20
// CHECK: 22
// CHECK: 42
/* Binary generated by compiling at opt-level O2 generates multiple
push instructions. This results in exercising the stack allocation
done while raising push instructions.
*/
#include <stdio.h>
int Func(int Val1, int Val2) {
printf("%d\n", 2 * Val1);
printf("%d\n", 2 * Val2);
return 2 * (Val1 + Val2);
}
int main() {
int RetVal = Func(10, 11);
printf("%d\n", RetVal);
return 0;
}
|
the_stack_data/8933.c
|
/* crypto/threads/th-lock.c */
/* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <openssl/crypto.h>
#ifdef OPENSSL_SYS_WIN32
#include <windows.h>
#endif
#ifdef SOLARIS
#include <synch.h>
#include <thread.h>
#endif
#ifdef IRIX
#include <ulocks.h>
#include <sys/prctl.h>
#endif
#ifdef PTHREADS
#ifndef OPENSSL_SYS_WIN32
#include <pthread.h>
#endif
#endif
void CRYPTO_thread_setup(void);
void CRYPTO_thread_cleanup(void);
/* usage:
* CRYPTO_thread_setup();
* application code
* CRYPTO_thread_cleanup();
*/
#define THREAD_STACK_SIZE (16*1024)
#ifdef OPENSSL_SYS_WIN32
static void win32_locking_callback(int mode, int type, const char *file, int line);
static HANDLE *lock_cs;
void CRYPTO_thread_setup(void)
{
int i;
lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
for (i = 0; i < CRYPTO_num_locks(); i++)
{
lock_cs[i] = CreateMutex(NULL, FALSE, NULL);
}
CRYPTO_set_locking_callback(win32_locking_callback);
/* id callback defined */
}
void CRYPTO_thread_cleanup(void)
{
int i;
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++)
CloseHandle(lock_cs[i]);
OPENSSL_free(lock_cs);
}
static void win32_locking_callback(int mode, int type, const char *file, int line)
{
(void) file;
(void) line;
if (mode & CRYPTO_LOCK)
{
WaitForSingleObject(lock_cs[type], INFINITE);
}
else
{
ReleaseMutex(lock_cs[type]);
}
}
#endif /* OPENSSL_SYS_WIN32 */
#ifdef SOLARIS
static void solaris_locking_callback(int mode, int type, const char *file, int line);
static unsigned long solaris_thread_id(void );
#define USE_MUTEX
#ifdef USE_MUTEX
static mutex_t *lock_cs;
#else
static rwlock_t *lock_cs;
#endif
static long *lock_count;
void CRYPTO_thread_setup(void)
{
int i;
#ifdef USE_MUTEX
lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
#else
lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(rwlock_t));
#endif
lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i = 0; i < CRYPTO_num_locks(); i++)
{
lock_count[i] = 0;
#ifdef USE_MUTEX
mutex_init(&(lock_cs[i]), USYNC_THREAD, NULL);
#else
rwlock_init(&(lock_cs[i]), USYNC_THREAD, NULL);
#endif
}
CRYPTO_set_id_callback((unsigned long (*)())solaris_thread_id);
CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);
}
void CRYPTO_thread_cleanup(void)
{
int i;
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++)
{
#ifdef USE_MUTEX
mutex_destroy(&(lock_cs[i]));
#else
rwlock_destroy(&(lock_cs[i]));
#endif
}
OPENSSL_free(lock_cs);
OPENSSL_free(lock_count);
}
static void solaris_locking_callback(int mode, int type, const char *file, int line)
{
#if 0
fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d\n",
CRYPTO_thread_id(),
(mode & CRYPTO_LOCK) ? "l" : "u",
(type & CRYPTO_READ) ? "r" : "w", file, line);
#endif
#if 0
if (CRYPTO_LOCK_SSL_CERT == type)
fprintf(stderr, "(t,m,f,l) %ld %d %s %d\n",
CRYPTO_thread_id(),
mode, file, line);
#endif
if (mode & CRYPTO_LOCK)
{
#ifdef USE_MUTEX
mutex_lock(&(lock_cs[type]));
#else
if (mode & CRYPTO_READ)
rw_rdlock(&(lock_cs[type]));
else
rw_wrlock(&(lock_cs[type]));
#endif
lock_count[type]++;
}
else
{
#ifdef USE_MUTEX
mutex_unlock(&(lock_cs[type]));
#else
rw_unlock(&(lock_cs[type]));
#endif
}
}
unsigned long solaris_thread_id(void)
{
unsigned long ret;
ret = (unsigned long)thr_self();
return (ret);
}
#endif /* SOLARIS */
#ifdef IRIX
static void irix_locking_callback(int mode, int type, const char *file, int line);
static unsigned long irix_thread_id(void );
/* I don't think this works..... */
static usptr_t *arena;
static usema_t **lock_cs;
void CRYPTO_thread_setup(void)
{
int i;
char filename[20];
strcpy(filename, "/tmp/mttest.XXXXXX");
mktemp(filename);
usconfig(CONF_STHREADIOOFF);
usconfig(CONF_STHREADMALLOCOFF);
usconfig(CONF_INITUSERS, 100);
usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
arena = usinit(filename);
unlink(filename);
lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
for (i = 0; i < CRYPTO_num_locks(); i++)
{
lock_cs[i] = usnewsema(arena, 1);
}
CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);
CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
}
void CRYPTO_thread_cleanup(void)
{
int i;
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++)
{
char buf[10];
sprintf(buf, "%2d:", i);
usdumpsema(lock_cs[i], stdout, buf);
usfreesema(lock_cs[i], arena);
}
OPENSSL_free(lock_cs);
}
static void irix_locking_callback(int mode, int type, char *file, int line)
{
if (mode & CRYPTO_LOCK)
{
uspsema(lock_cs[type]);
}
else
{
usvsema(lock_cs[type]);
}
}
unsigned long irix_thread_id(void)
{
unsigned long ret;
ret = (unsigned long)getpid();
return (ret);
}
#endif /* IRIX */
/* Linux and a few others */
#ifdef PTHREADS
#ifndef OPENSSL_SYS_WIN32
static pthread_mutex_t *lock_cs;
static long *lock_count;
void CRYPTO_thread_cleanup(void)
{
int i;
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++)
{
pthread_mutex_destroy(&(lock_cs[i]));
}
OPENSSL_free(lock_cs);
OPENSSL_free(lock_count);
}
static void pthreads_locking_callback(int mode, int type, const char *file, int line)
{
#if 0
fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d\n",
CRYPTO_thread_id(),
(mode & CRYPTO_LOCK) ? "l" : "u",
(type & CRYPTO_READ) ? "r" : "w", file, line);
#endif
#if 0
if (CRYPTO_LOCK_SSL_CERT == type)
fprintf(stderr, "(t,m,f,l) %ld %d %s %d\n",
CRYPTO_thread_id(),
mode, file, line);
#endif
if (mode & CRYPTO_LOCK)
{
pthread_mutex_lock(&(lock_cs[type]));
lock_count[type]++;
}
else
{
pthread_mutex_unlock(&(lock_cs[type]));
}
}
static unsigned long pthreads_thread_id(void)
{
unsigned long ret;
ret = (unsigned long)pthread_self();
return (ret);
}
void CRYPTO_thread_setup(void)
{
int i;
lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i = 0; i < CRYPTO_num_locks(); i++)
{
lock_count[i] = 0;
pthread_mutex_init(&(lock_cs[i]), NULL);
}
CRYPTO_set_id_callback(pthreads_thread_id);
CRYPTO_set_locking_callback(pthreads_locking_callback);
}
#endif
#endif /* PTHREADS */
|
the_stack_data/116309.c
|
//===-- RISCVDisassembler.cpp - Disassembler for RISCV --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* RISC-V Backend By Rodrigo Cortes Porto <[email protected]> &
Shawn Chang <[email protected]>, HardenedLinux@2018 */
#ifdef CAPSTONE_HAS_RISCV
#include <stdio.h> // DEBUG
#include <stdlib.h>
#include <string.h>
#include "../../cs_priv.h"
#include "../../utils.h"
#include "../../MCInst.h"
#include "../../MCInstrDesc.h"
#include "../../MCFixedLenDisassembler.h"
#include "../../MCRegisterInfo.h"
#include "../../MCDisassembler.h"
#include "../../MathExtras.h"
#include "RISCVBaseInfo.h"
#include "RISCVDisassembler.h"
/* Need the feature infos define in
RISCVGenSubtargetInfo.inc. */
#define GET_SUBTARGETINFO_ENUM
#include "RISCVGenSubtargetInfo.inc"
/* When we specify the RISCV64 mode, It means It is RV64IMAFD.
Similar, RISCV32 means RV32IMAFD.
*/
static uint64_t getFeatureBits(int mode)
{
uint64_t ret = RISCV_FeatureStdExtM | RISCV_FeatureStdExtA |
RISCV_FeatureStdExtF | RISCV_FeatureStdExtD ;
if (mode & CS_MODE_RISCV64)
ret |= RISCV_Feature64Bit;
if (mode & CS_MODE_RISCVC)
ret |= RISCV_FeatureStdExtC;
return ret;
}
#define GET_REGINFO_ENUM
#define GET_REGINFO_MC_DESC
#include "RISCVGenRegisterInfo.inc"
#define GET_INSTRINFO_ENUM
#include "RISCVGenInstrInfo.inc"
static const unsigned GPRDecoderTable[] = {
RISCV_X0, RISCV_X1, RISCV_X2, RISCV_X3,
RISCV_X4, RISCV_X5, RISCV_X6, RISCV_X7,
RISCV_X8, RISCV_X9, RISCV_X10, RISCV_X11,
RISCV_X12, RISCV_X13, RISCV_X14, RISCV_X15,
RISCV_X16, RISCV_X17, RISCV_X18, RISCV_X19,
RISCV_X20, RISCV_X21, RISCV_X22, RISCV_X23,
RISCV_X24, RISCV_X25, RISCV_X26, RISCV_X27,
RISCV_X28, RISCV_X29, RISCV_X30, RISCV_X31
};
static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > sizeof(GPRDecoderTable))
return MCDisassembler_Fail;
// We must define our own mapping from RegNo to register identifier.
// Accessing index RegNo in the register class will work in the case that
// registers were added in ascending order, but not in general.
Reg = GPRDecoderTable[RegNo];
//Inst.addOperand(MCOperand::createReg(Reg));
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static const unsigned FPR32DecoderTable[] = {
RISCV_F0_32, RISCV_F1_32, RISCV_F2_32, RISCV_F3_32,
RISCV_F4_32, RISCV_F5_32, RISCV_F6_32, RISCV_F7_32,
RISCV_F8_32, RISCV_F9_32, RISCV_F10_32, RISCV_F11_32,
RISCV_F12_32, RISCV_F13_32, RISCV_F14_32, RISCV_F15_32,
RISCV_F16_32, RISCV_F17_32, RISCV_F18_32, RISCV_F19_32,
RISCV_F20_32, RISCV_F21_32, RISCV_F22_32, RISCV_F23_32,
RISCV_F24_32, RISCV_F25_32, RISCV_F26_32, RISCV_F27_32,
RISCV_F28_32, RISCV_F29_32, RISCV_F30_32, RISCV_F31_32
};
static DecodeStatus DecodeFPR32RegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > sizeof(FPR32DecoderTable))
return MCDisassembler_Fail;
// We must define our own mapping from RegNo to register identifier.
// Accessing index RegNo in the register class will work in the case that
// registers were added in ascending order, but not in general.
Reg = FPR32DecoderTable[RegNo];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static DecodeStatus DecodeFPR32CRegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address,
const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > 8)
return MCDisassembler_Fail;
Reg = FPR32DecoderTable[RegNo + 8];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static const unsigned FPR64DecoderTable[] = {
RISCV_F0_64, RISCV_F1_64, RISCV_F2_64, RISCV_F3_64,
RISCV_F4_64, RISCV_F5_64, RISCV_F6_64, RISCV_F7_64,
RISCV_F8_64, RISCV_F9_64, RISCV_F10_64, RISCV_F11_64,
RISCV_F12_64, RISCV_F13_64, RISCV_F14_64, RISCV_F15_64,
RISCV_F16_64, RISCV_F17_64, RISCV_F18_64, RISCV_F19_64,
RISCV_F20_64, RISCV_F21_64, RISCV_F22_64, RISCV_F23_64,
RISCV_F24_64, RISCV_F25_64, RISCV_F26_64, RISCV_F27_64,
RISCV_F28_64, RISCV_F29_64, RISCV_F30_64, RISCV_F31_64
};
static DecodeStatus DecodeFPR64RegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > sizeof(FPR64DecoderTable))
return MCDisassembler_Fail;
// We must define our own mapping from RegNo to register identifier.
// Accessing index RegNo in the register class will work in the case that
// registers were added in ascending order, but not in general.
Reg = FPR64DecoderTable[RegNo];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static DecodeStatus DecodeFPR64CRegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address,
const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > 8)
return MCDisassembler_Fail;
Reg = FPR64DecoderTable[RegNo + 8];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static DecodeStatus DecodeGPRNoX0RegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address,
const void *Decoder)
{
if (RegNo == 0)
return MCDisassembler_Fail;
return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder);
}
static DecodeStatus DecodeGPRNoX0X2RegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address,
const void *Decoder)
{
if (RegNo == 2)
return MCDisassembler_Fail;
return DecodeGPRNoX0RegisterClass(Inst, RegNo, Address, Decoder);
}
static DecodeStatus DecodeGPRCRegisterClass(MCInst *Inst, uint64_t RegNo,
uint64_t Address,
const void *Decoder)
{
unsigned Reg = 0;
if (RegNo > 8)
return MCDisassembler_Fail;
Reg = GPRDecoderTable[RegNo + 8];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
// Add implied SP operand for instructions *SP compressed instructions. The SP
// operand isn't explicitly encoded in the instruction.
static void addImplySP(MCInst *Inst, int64_t Address, const void *Decoder)
{
if (MCInst_getOpcode(Inst) == RISCV_C_LWSP ||
MCInst_getOpcode(Inst) == RISCV_C_SWSP ||
MCInst_getOpcode(Inst) == RISCV_C_LDSP ||
MCInst_getOpcode(Inst) == RISCV_C_SDSP ||
MCInst_getOpcode(Inst) == RISCV_C_FLWSP ||
MCInst_getOpcode(Inst) == RISCV_C_FSWSP ||
MCInst_getOpcode(Inst) == RISCV_C_FLDSP ||
MCInst_getOpcode(Inst) == RISCV_C_FSDSP ||
MCInst_getOpcode(Inst) == RISCV_C_ADDI4SPN) {
DecodeGPRRegisterClass(Inst, 2, Address, Decoder);
}
if (MCInst_getOpcode(Inst) == RISCV_C_ADDI16SP) {
DecodeGPRRegisterClass(Inst, 2, Address, Decoder);
DecodeGPRRegisterClass(Inst, 2, Address, Decoder);
}
}
static DecodeStatus decodeUImmOperand(MCInst *Inst, uint64_t Imm,
int64_t Address, const void *Decoder,
unsigned N)
{
//CS_ASSERT(isUInt<N>(Imm) && "Invalid immediate");
addImplySP(Inst, Address, Decoder);
//Inst.addOperand(MCOperand::createImm(Imm));
MCOperand_CreateImm0(Inst, Imm);
return MCDisassembler_Success;
}
static DecodeStatus decodeUImmNonZeroOperand(MCInst *Inst, uint64_t Imm,
int64_t Address,
const void *Decoder,
unsigned N)
{
if (Imm == 0)
return MCDisassembler_Fail;
return decodeUImmOperand(Inst, Imm, Address, Decoder, N);
}
static DecodeStatus decodeSImmOperand(MCInst *Inst, uint64_t Imm,
int64_t Address, const void *Decoder,
unsigned N)
{
//CS_ASSERT(isUInt<N>(Imm) && "Invalid immediate");
addImplySP(Inst, Address, Decoder);
// Sign-extend the number in the bottom N bits of Imm
//Inst.addOperand(MCOperand::createImm(SignExtend64<N>(Imm)));
MCOperand_CreateImm0(Inst, SignExtend64(Imm, N));
return MCDisassembler_Success;
}
static DecodeStatus decodeSImmNonZeroOperand(MCInst *Inst, uint64_t Imm,
int64_t Address,
const void *Decoder,
unsigned N)
{
if (Imm == 0)
return MCDisassembler_Fail;
return decodeSImmOperand(Inst, Imm, Address, Decoder, N);
}
static DecodeStatus decodeSImmOperandAndLsl1(MCInst *Inst, uint64_t Imm,
int64_t Address,
const void *Decoder,
unsigned N)
{
//CS_ASSERT(isUInt<N>(Imm) && "Invalid immediate");
// Sign-extend the number in the bottom N bits of Imm after accounting for
// the fact that the N bit immediate is stored in N-1 bits (the LSB is
// always zero)
//Inst.addOperand(MCOperand::createImm(SignExtend64<N>(Imm << 1)));
MCOperand_CreateImm0(Inst, SignExtend64(Imm << 1, N));
return MCDisassembler_Success;
}
static DecodeStatus decodeCLUIImmOperand(MCInst *Inst, uint64_t Imm,
int64_t Address,
const void *Decoder)
{
//CS_ASSERT(isUInt<6>(Imm) && "Invalid immediate");
if (Imm > 31) {
Imm = (SignExtend64(Imm, 6) & 0xfffff);
}
//Inst.addOperand(MCOperand::createImm(Imm));
MCOperand_CreateImm0(Inst, Imm);
return MCDisassembler_Success;
}
static DecodeStatus decodeFRMArg(MCInst *Inst, uint64_t Imm,
int64_t Address,
const void *Decoder)
{
//CS_ASSERT(isUInt<3>(Imm) && "Invalid immediate");
if (!RISCVFPRndMode_isValidRoundingMode(Imm))
return MCDisassembler_Fail;
//Inst.addOperand(MCOperand::createImm(Imm));
MCOperand_CreateImm0(Inst, Imm);
return MCDisassembler_Success;
}
#include "RISCVGenDisassemblerTables.inc"
static void init_MI_insn_detail(MCInst *MI)
{
if (MI->flat_insn->detail) {
memset(MI->flat_insn->detail, 0, sizeof(cs_detail));
}
return;
}
// mark the load/store instructions through the opcode.
static void markLSInsn(MCInst *MI, uint32_t in)
{
/*
I ld 0000011 = 0x03
st 0100011 = 0x23
F/D ld 0000111 = 0x07
st 0100111 = 0x27
*/
#define MASK_LS_INSN 0x0000007f
uint32_t opcode = in & MASK_LS_INSN;
if (0 == (opcode ^ 0x03) || 0 == (opcode ^ 0x07) ||
0 == (opcode ^ 0x23) || 0 == (opcode ^ 0x27))
MI->flat_insn->detail->riscv.need_effective_addr = true;
#undef MASK_LS_INSN
return;
}
static DecodeStatus RISCVDisassembler_getInstruction(int mode, MCInst *MI,
const uint8_t *code, size_t code_len,
uint16_t *Size, uint64_t Address,
MCRegisterInfo *MRI)
{
// TODO: This will need modification when supporting instruction set
// extensions with instructions > 32-bits (up to 176 bits wide).
uint32_t Inst = 0;
DecodeStatus Result;
// It's a 32 bit instruction if bit 0 and 1 are 1.
if ((code[0] & 0x3) == 0x3) {
if (code_len < 4) {
*Size = 0;
return MCDisassembler_Fail;
}
*Size = 4;
// Get the four bytes of the instruction.
//Encoded as little endian 32 bits.
Inst = code[0] | (code[1] << 8) | (code[2] << 16) | ((uint32_t)code[3] << 24);
init_MI_insn_detail(MI);
// Now we need mark what instruction need fix effective address output.
if (MI->csh->detail)
markLSInsn(MI, Inst);
Result = decodeInstruction(DecoderTable32, MI, Inst, Address, MRI, mode);
} else {
if (code_len < 2) {
*Size = 0;
return MCDisassembler_Fail;
}
// If not b4bit.
if (! (getFeatureBits(mode) & ((uint64_t)RISCV_Feature64Bit))) {
// Trying RISCV32Only_16 table (16-bit Instruction)
Inst = code[0] | (code[1] << 8);
init_MI_insn_detail(MI);
Result = decodeInstruction(DecoderTableRISCV32Only_16, MI, Inst, Address,
MRI, mode);
if (Result != MCDisassembler_Fail) {
*Size = 2;
return Result;
}
}
// Trying RISCV_C table (16-bit Instruction)
Inst = code[0] | (code[1] << 8);
init_MI_insn_detail(MI);
// Calling the auto-generated decoder function.
Result = decodeInstruction(DecoderTable16, MI, Inst, Address, MRI, mode);
*Size = 2;
}
return Result;
}
bool RISCV_getInstruction(csh ud, const uint8_t *code, size_t code_len,
MCInst *instr, uint16_t *size, uint64_t address,
void *info)
{
cs_struct *handle = (cs_struct *)(uintptr_t)ud;
return MCDisassembler_Success ==
RISCVDisassembler_getInstruction(handle->mode, instr,
code, code_len,
size, address,
(MCRegisterInfo *)info);
}
void RISCV_init(MCRegisterInfo * MRI)
{
/*
InitMCRegisterInfo(RISCVRegDesc, 97, RA, PC,
RISCVMCRegisterClasses, 11,
RISCVRegUnitRoots,
64,
RISCVRegDiffLists,
RISCVLaneMaskLists,
RISCVRegStrings,
RISCVRegClassStrings,
RISCVSubRegIdxLists,
2,
RISCVSubRegIdxRanges,
RISCVRegEncodingTable);
*/
MCRegisterInfo_InitMCRegisterInfo(MRI, RISCVRegDesc, 97, 0, 0,
RISCVMCRegisterClasses, 11,
0,
0,
RISCVRegDiffLists,
0,
RISCVSubRegIdxLists,
2,
0);
}
#endif
|
the_stack_data/248580445.c
|
#include <stdio.h>
#include <stdlib.h>
int dot_product(int *, int *, size_t);
int
main(void)
{
int a[3] = {1, 3, -5};
int b[3] = {4, -2, -1};
printf("%d\n", dot_product(a, b, sizeof(a) / sizeof(a[0])));
return EXIT_SUCCESS;
}
int
dot_product(int *a, int *b, size_t n)
{
int sum = 0;
size_t i;
for (i = 0; i < n; i++) {
sum += a[i] * b[i];
}
return sum;
}
|
the_stack_data/153269132.c
|
#include <stdio.h>
int main(void) {
int a = 0;
scanf("%d", &a);
a % 2 == 0 && (a / 2 % 2 == 0 || (a / 2 % 2 == 1 && a > 2)) ? printf("YES\n") : printf("NO\n");
return 0;
}
|
the_stack_data/173577561.c
|
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main() {
// Time variables
double time_spent = 0.0;
clock_t begin = clock();
//int array[1000] = {55, 739, 233, 426, 207, 742, 88, 733, 434, 756, 463, 762, 119, 366, 136, 283, 518, 536, 729, 667, 130, 63, 78, 925, 987, 719, 754, 180, 817, 758, 235, 872, 68, 44, 167, 871, 819, 61, 303, 878, 312, 140, 224, 835, 499, 838, 332, 845, 814, 587, 576, 271, 889, 440, 821, 962, 687, 395, 716, 310, 59, 407, 80, 436, 702, 485, 899, 818, 147, 439, 239, 938, 98, 384, 921, 234, 333, 488, 460, 904, 585, 462, 321, 775, 790, 444, 356, 122, 285, 146, 776, 916, 989, 296, 111, 885, 848, 24, 326, 964, 495, 36, 219, 675, 35, 812, 314, 484, 599, 543, 92, 214, 386, 686, 368, 428, 882, 490, 717, 247, 600, 304, 417, 104, 993, 927, 442, 371, 977, 435, 456, 958, 555, 46, 603, 194, 651, 504, 643, 589, 143, 432, 7, 546, 932, 734, 940, 990, 663, 833, 662, 852, 286, 430, 461, 385, 807, 840, 206, 750, 908, 173, 204, 121, 422, 617, 503, 376, 297, 330, 917, 970, 512, 83, 959, 222, 858, 564, 400, 581, 907, 354, 998, 393, 201, 9, 866, 23, 802, 336, 692, 641, 193, 377, 897, 363, 639, 592, 25, 815, 638, 834, 524, 881, 270, 209, 956, 341, 646, 479, 22, 170, 399, 133, 279, 659, 919, 928, 477, 787, 294, 150, 752, 202, 718, 305, 666, 192, 41, 679, 339, 542, 102, 28, 415, 759, 2, 309, 672, 125, 13, 677, 753, 20, 212, 554, 457, 900, 786, 894, 387, 82, 654, 221, 237, 337, 375, 879, 991, 533, 47, 673, 110, 588, 644, 66, 243, 131, 995, 683, 549, 923, 469, 865, 578, 454, 251, 353, 394, 262, 51, 876, 511, 268, 824, 163, 902, 873, 558, 635, 853, 54, 855, 961, 971, 552, 560, 517, 529, 711, 930, 107, 863, 730, 30, 849, 398, 620, 535, 706, 920, 519, 737, 396, 431, 864, 948, 401, 15, 493, 898, 187, 931, 254, 698, 76, 901, 704, 596, 509, 851, 846, 949, 101, 210, 896, 768, 176, 992, 443, 301, 828, 423, 367, 521, 749, 27, 137, 844, 164, 318, 172, 751, 781, 712, 974, 291, 582, 856, 380, 634, 381, 538, 438, 351, 661, 515, 113, 810, 486, 516, 722, 1000, 425, 246, 744, 507, 230, 185, 843, 43, 17, 77, 288, 406, 223, 492, 373, 953, 574, 978, 152, 568, 329, 913, 915, 559, 820, 325, 854, 813, 636, 723, 93, 935, 822, 803, 771, 203, 449, 816, 946, 745, 700, 748, 37, 161, 608, 21, 614, 389, 847, 397, 996, 983, 697, 553, 419, 567, 794, 464, 96, 213, 195, 292, 248, 241, 912, 800, 58, 541, 450, 526, 403, 550, 5, 18, 261, 183, 709, 390, 191, 705, 615, 300, 177, 446, 591, 590, 135, 607, 253, 694, 429, 699, 260, 631, 470, 825, 746, 50, 257, 355, 943, 797, 313, 805, 33, 811, 472, 988, 200, 632, 158, 231, 630, 197, 334, 421, 215, 365, 886, 868, 862, 378, 655, 445, 370, 689, 60, 335, 45, 340, 887, 208, 405, 997, 806, 414, 685, 112, 478, 481, 109, 540, 557, 358, 826, 489, 874, 412, 392, 293, 777, 621, 773, 87, 668, 40, 860, 624, 747, 362, 468, 84, 424, 715, 676, 994, 475, 199, 4, 6, 79, 284, 832, 467, 85, 926, 980, 539, 343, 360, 299, 3, 181, 528, 804, 186, 782, 691, 626, 965, 501, 880, 890, 755, 62, 154, 619, 713, 127, 981, 32, 169, 211, 648, 382, 103, 323, 315, 827, 359, 190, 911, 39, 939, 263, 232, 452, 49, 891, 967, 534, 298, 465, 151, 593, 144, 29, 547, 903, 561, 731, 830, 870, 114, 986, 73, 764, 575, 134, 520, 934, 789, 688, 416, 142, 985, 455, 53, 115, 100, 563, 404, 761, 969, 129, 973, 269, 658, 884, 342, 703, 594, 31, 982, 769, 182, 577, 572, 252, 570, 453, 565, 684, 952, 610, 94, 774, 809, 906, 968, 427, 238, 290, 280, 75, 783, 196, 586, 544, 566, 327, 955, 324, 796, 410, 374, 763, 11, 128, 348, 527, 893, 841, 650, 728, 250, 653, 979, 629, 562, 67, 155, 171, 245, 90, 157, 184, 307, 273, 859, 255, 506, 120, 647, 609, 888, 258, 264, 867, 189, 714, 580, 227, 966, 708, 681, 317, 99, 780, 497, 409, 929, 69, 779, 65, 857, 601, 941, 56, 482, 627, 319, 778, 418, 408, 361, 266, 875, 583, 302, 695, 914, 606, 267, 951, 637, 308, 556, 420, 597, 447, 411, 487, 306, 141, 645, 458, 126, 757, 480, 963, 831, 665, 274, 160, 942, 798, 791, 118, 598, 793, 448, 682, 738, 726, 792, 228, 837, 116, 12, 117, 149, 282, 850, 622, 16, 388, 760, 281, 57, 595, 352, 64, 331, 522, 205, 242, 725, 287, 451, 710, 500, 957, 413, 532, 265, 179, 225, 372, 770, 525, 289, 316, 277, 240, 669, 537, 344, 175, 741, 869, 275, 892, 671, 95, 612, 905, 823, 19, 605, 895, 311, 795, 256, 244, 320, 721, 220, 523, 89, 473, 259, 52, 474, 571, 732, 514, 633, 364, 877, 105, 145, 188, 34, 784, 322, 616, 139, 922, 551, 660, 530, 72, 494, 379, 26, 652, 657, 924, 276, 38, 1, 545, 165, 829, 808, 383, 640, 548, 229, 573, 74, 909, 740, 278, 670, 502, 70, 345, 168, 937, 174, 984, 48, 954, 604, 295, 960, 642, 623, 618, 765, 42, 628, 674, 198, 272, 162, 71, 491, 14, 736, 696, 441, 933, 216, 338, 347, 471, 178, 10, 466, 346, 459, 664, 972, 883, 584, 690, 975, 950, 918, 999, 767, 369, 531, 132, 707, 153, 249, 724, 496, 505, 498, 108, 839, 678, 166, 349, 8, 772, 483, 743, 945, 513, 86, 602, 91, 936, 720, 727, 788, 569, 510, 656, 613, 391, 842, 976, 611, 701, 236, 402, 625, 785, 910, 508, 693, 350, 836, 217, 799, 947, 680, 357, 437, 106, 861, 328, 156, 159, 226, 138, 944, 124, 801, 649, 766, 148, 735, 218, 81, 433, 476, 123, 97, 579};
//int array[5000] = {153, 4690, 3802, 1487, 3038, 4118, 1880, 2868, 4202, 3887, 4700, 3484, 914, 3553, 1687, 3225, 1739, 1175, 1432, 3127, 2469, 4069, 4993, 695, 3629, 685, 1853, 3917, 2818, 2787, 2917, 1653, 2731, 2220, 1863, 1592, 3877, 4880, 4102, 3132, 3421, 4152, 4492, 2915, 2143, 1728, 953, 1150, 1200, 188, 577, 3542, 2983, 1843, 3954, 3631, 1197, 3513, 714, 1510, 307, 496, 1311, 4967, 2771, 890, 2199, 2628, 1620, 662, 923, 4589, 1762, 1788, 4146, 2193, 4192, 3173, 1793, 736, 3875, 4513, 1321, 1767, 2293, 1010, 359, 3862, 2940, 2059, 1263, 4089, 399, 681, 3438, 3593, 3310, 4203, 134, 4591, 1341, 1425, 1009, 59, 2682, 1302, 2182, 1292, 3049, 3723, 2140, 3322, 3837, 2296, 483, 2786, 182, 406, 425, 1935, 3067, 4182, 4503, 882, 2999, 4790, 1538, 2393, 3550, 4566, 1534, 4308, 845, 847, 1746, 4653, 2836, 1679, 4563, 4338, 2844, 1642, 2950, 2506, 586, 2729, 3909, 2834, 2114, 4919, 3634, 585, 3651, 2802, 3360, 4627, 3325, 2316, 795, 1379, 4311, 274, 3630, 1705, 4100, 4369, 3898, 1031, 4063, 1515, 3394, 2524, 3295, 327, 2850, 3712, 1111, 4561, 3526, 1704, 2914, 1907, 2014, 4600, 1157, 639, 3253, 3595, 2939, 435, 480, 1386, 4858, 2024, 4867, 2888, 2760, 1884, 1981, 1756, 3987, 4266, 874, 4809, 939, 4319, 4866, 2375, 1369, 1381, 3889, 992, 4153, 116, 723, 136, 937, 2661, 3930, 2340, 3880, 4873, 93, 1062, 4499, 4194, 2188, 314, 366, 1740, 161, 1430, 2235, 1335, 701, 3019, 3571, 3121, 1352, 1250, 4464, 4207, 1299, 3955, 2451, 1304, 1188, 4670, 2958, 3245, 1217, 3704, 1764, 1627, 1784, 2562, 16, 702, 1615, 1946, 1974, 51, 1428, 4067, 118, 2969, 4796, 2214, 4449, 3403, 239, 1232, 1916, 4131, 4889, 2234, 1087, 2580, 4989, 646, 1392, 169, 1243, 3851, 2005, 443, 463, 4713, 2984, 1961, 1856, 4142, 4305, 4695, 2209, 589, 1214, 661, 1191, 306, 222, 969, 3371, 13, 3581, 3189, 4788, 1839, 1479, 522, 4223, 4990, 2046, 801, 3938, 1824, 4760, 858, 4167, 4179, 1117, 3531, 3694, 1346, 4684, 1500, 2734, 3356, 965, 1937, 4213, 1493, 1613, 2071, 3865, 2973, 3001, 3487, 2181, 2881, 3432, 1528, 675, 4519, 4413, 4252, 3234, 4198, 4480, 567, 3603, 1672, 330, 3261, 3721, 4260, 1511, 1600, 1277, 378, 1926, 3853, 2292, 1388, 996, 126, 4524, 1331, 1488, 2021, 3399, 1849, 1285, 2380, 1110, 1088, 437, 1709, 55, 4711, 228, 2344, 722, 4609, 3516, 3951, 3235, 1151, 4667, 2928, 3790, 84, 2790, 2268, 4396, 3554, 3481, 879, 1977, 3848, 2692, 1917, 4988, 1267, 769, 2222, 891, 535, 1237, 4865, 1056, 4852, 4762, 1490, 2852, 405, 2184, 2890, 31, 4382, 42, 4767, 989, 1586, 1543, 3501, 2110, 1181, 2075, 4539, 4021, 2243, 4349, 4632, 4307, 1149, 1527, 3302, 3034, 1594, 2590, 1154, 3544, 1934, 1361, 1422, 1930, 494, 2631, 3748, 4418, 4053, 3301, 2411, 4143, 2489, 1641, 4032, 4044, 4398, 3201, 917, 4658, 4273, 927, 3149, 4651, 3823, 2557, 2258, 4217, 4081, 1046, 4714, 1337, 1332, 1683, 351, 2068, 4445, 2723, 2336, 2842, 892, 859, 2502, 2401, 4297, 1677, 4001, 2728, 895, 804, 4226, 1041, 1965, 3674, 3037, 3519, 4243, 1291, 1751, 2191, 1136, 4470, 3892, 1461, 4890, 850, 3695, 4019, 445, 1992, 3231, 4130, 2902, 4950, 4271, 3499, 4038, 3814, 1744, 686, 4219, 135, 2465, 1183, 3240, 1796, 4753, 3809, 3319, 853, 4893, 2906, 2076, 841, 4968, 4498, 3161, 4400, 855, 302, 2679, 4537, 3160, 2244, 90, 3538, 4018, 2459, 1904, 1178, 2701, 2165, 4797, 2564, 3549, 2297, 4047, 1617, 2919, 1364, 1235, 2996, 4906, 4277, 4357, 3256, 907, 2655, 2586, 1563, 3373, 1865, 4964, 863, 495, 3482, 1373, 1421, 2144, 4234, 3749, 365, 1702, 4209, 2456, 3594, 1301, 2392, 4847, 4831, 2516, 1499, 52, 1681, 3670, 2048, 2920, 4596, 4154, 1084, 2751, 1773, 1738, 2623, 105, 3441, 3436, 28, 4336, 966, 2095, 4940, 3050, 2135, 1662, 3530, 1452, 4934, 2700, 4689, 3276, 1272, 3744, 4358, 223, 2299, 2549, 2966, 2625, 4712, 263, 2417, 4696, 1318, 4474, 2321, 1844, 4121, 3111, 4673, 1376, 2887, 1133, 3517, 1574, 4197, 2054, 345, 848, 1984, 1255, 1813, 1469, 3027, 4138, 2963, 2041, 1061, 1879, 1560, 2642, 47, 2618, 507, 2947, 2747, 1118, 2382, 631, 1351, 3275, 4239, 3280, 91, 925, 2553, 1464, 918, 272, 2529, 754, 3471, 1886, 1837, 705, 2092, 524, 4887, 4091, 1724, 1060, 2641, 350, 332, 692, 2138, 4415, 4136, 461, 1616, 294, 2954, 752, 3348, 2081, 4375, 3815, 644, 3522, 3926, 446, 2269, 4393, 750, 278, 4641, 184, 172, 2486, 1958, 1184, 57, 2197, 2656, 2941, 1988, 2593, 2780, 2170, 7, 3440, 4423, 1626, 2255, 2809, 108, 1873, 4313, 1057, 2246, 120, 851, 3565, 4545, 1658, 4013, 214, 3583, 2663, 778, 3109, 1257, 2816, 4, 2161, 381, 3828, 356, 2227, 3144, 1864, 1294, 3188, 4493, 2332, 2938, 1931, 3125, 4698, 4403, 138, 54, 4098, 1652, 4468, 4669, 4337, 4427, 2476, 4771, 1229, 2125, 593, 3309, 1209, 3859, 1407, 1656, 43, 673, 1661, 1005, 201, 3085, 4630, 4765, 1059, 1396, 4976, 4752, 541, 3799, 3477, 4123, 4598, 3336, 3289, 3563, 2828, 3910, 664, 1768, 1518, 4289, 499, 1081, 2057, 4016, 2923, 2900, 3739, 452, 4697, 3206, 1798, 3288, 2402, 2421, 1453, 3315, 3293, 4895, 3673, 2453, 4577, 3677, 2226, 2552, 458, 3492, 3940, 3592, 3988, 3070, 2038, 4314, 523, 3464, 1707, 2447, 2428, 542, 1365, 2112, 3735, 1676, 3227, 4911, 1454, 1001, 598, 1249, 2077, 1502, 2837, 2653, 3009, 609, 3495, 2530, 1675, 165, 3385, 1911, 4244, 587, 4451, 3179, 3180, 4869, 1816, 3102, 1344, 4937, 2363, 1790, 4265, 3133, 4255, 3298, 4780, 3040, 1828, 3928, 360, 2162, 4042, 3825, 2891, 1772, 2774, 1426, 3907, 3692, 658, 2133, 88, 1486, 233, 1242, 821, 3305, 4371, 3585, 944, 2174, 576, 2147, 3203, 2977, 1371, 1647, 1481, 2730, 2581, 2755, 433, 21, 1348, 1723, 2208, 1780, 756, 3096, 1413, 3657, 3387, 509, 3361, 4830, 2899, 735, 3390, 4397, 2236, 945, 3953, 3028, 1253, 4003, 4253, 2117, 4535, 2272, 730, 1440, 1799, 4883, 275, 1416, 2445, 2452, 1338, 1295, 1666, 4134, 2086, 3959, 3921, 1319, 4410, 4851, 276, 4806, 1330, 4833, 178, 1969, 1003, 1322, 3268, 1852, 2814, 976, 1448, 459, 392, 2691, 3311, 687, 1605, 3380, 3425, 2962, 2399, 4436, 2688, 1557, 4659, 2168, 1218, 1730, 2237, 1423, 3349, 4640, 3830, 147, 3186, 2173, 4187, 2588, 4549, 563, 3829, 1329, 3267, 719, 2801, 4333, 2189, 660, 4844, 3259, 4740, 3895, 4391, 2824, 2074, 4903, 422, 3702, 1643, 479, 1651, 1283, 4834, 2398, 2981, 1803, 1550, 4129, 2676, 828, 29, 1198, 205, 1564, 2073, 2892, 77, 4037, 4096, 3821, 4828, 1703, 4056, 814, 2023, 1991, 4644, 2284, 946, 3649, 4287, 1320, 3338, 1649, 3628, 2422, 3599, 2286, 474, 2690, 643, 1569, 3706, 2022, 2624, 929, 4066, 1919, 1167, 615, 3215, 4166, 115, 986, 4559, 1139, 4957, 309, 1673, 4276, 38, 4453, 935, 2965, 4650, 2932, 1303, 311, 1190, 1861, 700, 4720, 1854, 3063, 4904, 3106, 1100, 1409, 4241, 4033, 3882, 1044, 825, 2599, 2858, 3682, 557, 3750, 4206, 3667, 423, 2111, 908, 1367, 1339, 363, 4184, 4638, 3835, 2098, 4525, 956, 4199, 4693, 4613, 170, 724, 983, 1164, 4352, 4546, 1589, 2514, 1219, 4027, 2946, 3470, 601, 1125, 2860, 3016, 2971, 4842, 4704, 1484, 3504, 4348, 1443, 2311, 947, 2823, 4160, 39, 2270, 2034, 1520, 3720, 617, 3326, 3181, 4747, 4909, 1945, 4139, 629, 3363, 4034, 2455, 4141, 4230, 2659, 1726, 4137, 3046, 2444, 1189, 2378, 3796, 4125, 2974, 1463, 3098, 506, 103, 2665, 1583, 2610, 20, 4051, 4250, 1251, 4080, 2354, 2695, 1314, 63, 2830, 2718, 203, 3612, 2082, 4763, 3633, 2595, 2132, 3329, 655, 3932, 4706, 573, 4837, 3638, 4185, 2306, 3205, 836, 4145, 491, 71, 1357, 4861, 846, 2441, 3884, 508, 3965, 4373, 3195, 4433, 3663, 2689, 216, 4724, 1684, 4896, 1645, 4434, 2956, 4351, 490, 4718, 3281, 4485, 2861, 3491, 1947, 1601, 1123, 3208, 2044, 1913, 2347, 3764, 502, 2782, 4360, 4521, 2204, 547, 2477, 117, 4702, 824, 4092, 4259, 1732, 1370, 4975, 3021, 616, 3746, 698, 1106, 1138, 4084, 3018, 2797, 318, 3836, 3502, 3214, 4935, 3138, 2410, 1278, 1763, 2806, 3025, 832, 3827, 865, 843, 4359, 3727, 704, 3123, 2267, 4437, 3775, 3213, 3962, 4285, 3105, 493, 1107, 1004, 3918, 421, 191, 2203, 1833, 4353, 4793, 1998, 4235, 4486, 2474, 1345, 599, 1328, 1035, 641, 3686, 1536, 838, 3226, 4662, 4258, 3065, 4683, 1113, 3758, 2512, 4124, 1261, 2732, 2634, 3190, 155, 1928, 3873, 3729, 985, 2159, 1734, 143, 578, 4560, 3029, 1327, 1211, 753, 3376, 2788, 1135, 4944, 4756, 877, 2078, 4292, 4107, 3278, 2094, 89, 3698, 1848, 1976, 691, 994, 2020, 545, 3084, 3765, 1858, 241, 2644, 4814, 633, 4531, 2225, 4293, 4994, 3574, 4281, 2658, 3637, 2589, 3656, 3312, 457, 346, 2953, 1247, 324, 3047, 940, 525, 3007, 4854, 3547, 3520, 3314, 511, 4133, 4616, 1024, 2601, 2313, 3840, 2857, 2019, 3015, 245, 3797, 529, 1471, 2294, 1051, 3986, 3838, 2101, 4377, 2507, 3090, 2412, 2248, 808, 4215, 1434, 3771, 2158, 2715, 1210, 3770, 3807, 196, 556, 1120, 4407, 943, 903, 902, 2137, 280, 1180, 933, 3076, 3819, 2651, 688, 3567, 3734, 3535, 4966, 4345, 2724, 2210, 335, 2427, 2362, 1820, 273, 3078, 3920, 384, 771, 3890, 2870, 4452, 53, 4368, 637, 2328, 3710, 1897, 642, 3611, 4603, 4840, 4789, 467, 2600, 842, 1578, 4113, 652, 469, 3036, 3478, 2149, 4078, 2473, 4648, 774, 2376, 4473, 2091, 3059, 3556, 2987, 2706, 4674, 1112, 3868, 2385, 2318, 4901, 2104, 3989, 826, 2051, 3297, 4518, 195, 3139, 2285, 4071, 4052, 300, 1874, 2918, 3995, 2367, 3433, 3545, 4807, 3048, 999, 342, 4406, 1535, 3366, 4115, 4487, 672, 1909, 2508, 1665, 2995, 2123, 1678, 597, 3852, 3384, 3164, 4150, 3362, 4190, 1384, 104, 1829, 1333, 2090, 4041, 4709, 782, 3145, 1802, 1882, 3266, 729, 1468, 3793, 4826, 4636, 3755, 2009, 3532, 4745, 3396, 375, 3912, 1529, 977, 742, 3810, 2772, 3733, 682, 3402, 3045, 2278, 3304, 2280, 3415, 1503, 1350, 3588, 3845, 3587, 4912, 2213, 1326, 4409, 1523, 3600, 4914, 3113, 3608, 3265, 2620, 4317, 3303, 4344, 2414, 3761, 1735, 1669, 439, 1441, 4002, 2172, 3306, 1021, 3818, 132, 81, 190, 2565, 4551, 4411, 952, 3813, 1287, 1182, 50, 3332, 4162, 3010, 344, 3014, 4732, 4208, 1733, 162, 1871, 1400, 3569, 4135, 3984, 3198, 3178, 1565, 341, 3490, 2384, 1451, 2537, 2862, 3555, 657, 2784, 4845, 4384, 3264, 4006, 901, 1, 1841, 4350, 2662, 3467, 3135, 3395, 1883, 4815, 4947, 282, 3414, 4654, 2526, 667, 4010, 1758, 3617, 333, 2239, 1750, 1731, 4785, 1305, 4977, 922, 2864, 1203, 980, 462, 3228, 3341, 114, 648, 4186, 297, 2374, 238, 978, 1899, 2517, 4717, 581, 919, 4543, 106, 3375, 4007, 3285, 4832, 383, 3644, 4232, 4161, 2481, 2373, 2326, 2812, 2298, 1074, 355, 2541, 1284, 4952, 4490, 137, 1049, 2216, 4383, 4079, 2164, 3666, 180, 4931, 809, 4379, 1701, 1512, 1526, 2756, 1973, 2770, 2202, 2130, 1033, 3131, 4093, 613, 2377, 1383, 2066, 3237, 4195, 1895, 515, 4859, 4362, 2360, 2179, 1855, 68, 743, 4108, 4925, 2554, 1068, 2472, 4585, 2705, 4064, 4106, 1747, 2254, 3323, 909, 2061, 4675, 185, 839, 1952, 4633, 1877, 37, 3439, 1507, 1494, 740, 4874, 4699, 177, 4637, 4645, 4238, 3752, 4730, 1997, 198, 296, 109, 931, 220, 1435, 854, 4324, 3993, 4722, 1406, 1972, 1741, 3494, 3091, 802, 2262, 2488, 4804, 1682, 2675, 574, 1650, 4855, 3740, 2779, 2304, 301, 4475, 3507, 2475, 4008, 3427, 498, 80, 2603, 1776, 121, 2849, 1810, 834, 2520, 85, 957, 1606, 4288, 3978, 2632, 1459, 2744, 36, 285, 612, 316, 3257, 3773, 2460, 611, 4298, 4302, 558, 3249, 3094, 4948, 4310, 1835, 395, 4229, 4029, 1026, 3142, 1759, 4448, 813, 709, 759, 2960, 2212, 840, 1195, 2571, 2315, 2394, 960, 1169, 1914, 1039, 2896, 2478, 1244, 4331, 1019, 2536, 1096, 1053, 621, 4930, 2657, 4446, 4652, 3118, 959, 3607, 3229, 1152, 2230, 4954, 379, 950, 3196, 3156, 2822, 2312, 2567, 2301, 1246, 444, 4553, 3357, 3902, 2669, 2480, 4846, 1905, 3060, 1719, 4574, 4334, 1509, 1067, 237, 1224, 2854, 3217, 2416, 787, 2093, 4710, 2702, 2821, 3891, 1482, 3406, 4941, 3423, 2540, 1382, 2543, 1075, 2598, 4692, 706, 4766, 4395, 3141, 2619, 217, 1427, 2085, 2680, 1282, 1551, 654, 4422, 2228, 3566, 4843, 4386, 3, 738, 298, 3724, 1354, 251, 1749, 3650, 2249, 436, 4823, 376, 2709, 829, 3557, 1420, 1996, 1966, 2894, 1923, 150, 4582, 4180, 2546, 3561, 792, 448, 449, 1876, 4926, 471, 455, 1389, 3573, 2150, 689, 1227, 3972, 2273, 665, 4193, 2509, 1090, 3152, 871, 2878, 3374, 3318, 3864, 4218, 295, 1869, 4245, 4444, 4420, 4681, 938, 4570, 2016, 4132, 428, 4558, 3784, 712, 849, 3171, 2699, 572, 1408, 625, 1619, 3690, 2206, 2768, 1623, 837, 1553, 3342, 3958, 2037, 1233, 2930, 4491, 3515, 1983, 4726, 2968, 4731, 4810, 1612, 779, 2426, 4188, 206, 4376, 3368, 4820, 2748, 1017, 2982, 3847, 1906, 4438, 2025, 3263, 2435, 2903, 1598, 1982, 3843, 2089, 3718, 1595, 800, 4077, 4233, 4242, 2194, 2910, 531, 4982, 3212, 1555, 4176, 1166, 2934, 1362, 3378, 2160, 1208, 1256, 2185, 1685, 864, 2211, 4300, 4443, 794, 4949, 4283, 830, 2323, 3597, 1176, 3808, 3417, 1771, 512, 3108, 210, 3393, 694, 3826, 1153, 26, 3641, 4442, 158, 4719, 3242, 1659, 2467, 4685, 3024, 249, 2386, 1258, 645, 3801, 2178, 2783, 4471, 1568, 3681, 1552, 1397, 3933, 3817, 4005, 1890, 2838, 3878, 3283, 4094, 731, 2031, 1196, 4009, 4573, 1121, 1155, 2409, 154, 2390, 1867, 2501, 183, 4572, 1279, 2295, 2643, 3333, 3683, 3093, 3804, 2154, 2012, 904, 3075, 1654, 2993, 2743, 2337, 823, 2008, 390, 1405, 78, 4569, 2129, 4156, 4942, 4439, 4606, 791, 4882, 504, 3753, 2576, 3175, 66, 749, 936, 4127, 354, 192, 1390, 367, 3833, 1000, 3760, 415, 4792, 3104, 3282, 3975, 4429, 2741, 1312, 1201, 1109, 4614, 1630, 113, 3627, 4216, 4159, 2495, 2032, 1522, 2534, 4043, 2684, 3286, 3023, 4261, 528, 397, 4664, 1496, 3540, 2522, 1016, 256, 2045, 4000, 656, 3486, 393, 3475, 3885, 2448, 373, 699, 1467, 1047, 3509, 1638, 3082, 3906, 2767, 2053, 4871, 4721, 4099, 4769, 2163, 1298, 2629, 3493, 3163, 4642, 2604, 4523, 4431, 3389, 2035, 2042, 3616, 1663, 534, 1144, 4951, 3174, 1825, 2124, 4361, 1158, 2568, 2897, 3294, 4401, 1847, 156, 538, 1226, 1401, 2575, 822, 4025, 3994, 4343, 3874, 4274, 3296, 2151, 3100, 3381, 1530, 1631, 2152, 4175, 1634, 4984, 3404, 2687, 4808, 1674, 4366, 2108, 1437, 3613, 2749, 4978, 3103, 3766, 411, 2927, 4663, 1236, 3000, 1786, 2556, 2418, 4165, 2547, 632, 2792, 4435, 305, 2349, 4462, 2274, 970, 3466, 1987, 3269, 4441, 3824, 2686, 1941, 2736, 4929, 993, 225, 539, 1691, 4488, 3754, 3177, 468, 623, 4097, 3606, 766, 4278, 230, 4863, 3182, 4894, 3533, 1399, 4856, 293, 23, 3654, 3143, 4120, 2988, 1806, 607, 3452, 602, 2058, 3919, 4953, 3541, 3552, 1079, 277, 1410, 2990, 2257, 4971, 4736, 3031, 3536, 2201, 2350, 973, 2924, 97, 1394, 1239, 3244, 3137, 955, 4741, 1951, 1387, 2694, 2745, 1689, 1948, 3114, 2499, 2420, 1783, 2289, 610, 427, 4363, 3743, 3947, 582, 2404, 505, 3668, 1506, 4169, 4301, 4799, 3911, 1537, 289, 968, 347, 3110, 1177, 3017, 3736, 1717, 941, 1281, 1978, 4805, 570, 4643, 2980, 1912, 2348, 4472, 3620, 761, 2592, 3751, 4309, 669, 2646, 3013, 3867, 486, 4778, 3688, 1206, 4550, 2266, 4813, 3523, 1933, 73, 3811, 4965, 3447, 721, 2535, 1779, 1130, 1970, 349, 3769, 1608, 2169, 4073, 2343, 4532, 1262, 1336, 4461, 4030, 424, 35, 1774, 2527, 872, 1900, 878, 339, 1755, 3949, 4458, 4326, 160, 4548, 988, 2102, 674, 1449, 4594, 3320, 2683, 971, 3274, 4822, 2425, 4961, 2880, 4222, 2997, 2479, 122, 2026, 3485, 3412, 3717, 3647, 149, 1924, 634, 1979, 4416, 130, 1340, 2607, 1442, 2080, 4269, 4065, 780, 555, 1122, 1727, 3534, 770, 4501, 4511, 101, 2813, 1791, 3335, 805, 2725, 2003, 3444, 4803, 3937, 2471, 717, 591, 510, 649, 4469, 1245, 2796, 3379, 1147, 1317, 3101, 1757, 1622, 2047, 4085, 951, 3449, 678, 4743, 1325, 1228, 2951, 4624, 2875, 2232, 533, 1353, 2866, 4237, 79, 1986, 4818, 3370, 3192, 1411, 3619, 3881, 4963, 4853, 3779, 2300, 579, 3411, 3632, 1521, 2288, 4738, 2714, 4592, 3170, 3697, 1811, 334, 1042, 4022, 2697, 3081, 1290, 3591, 4248, 265, 133, 4101, 2884, 1777, 906, 862, 725, 4355, 1995, 3841, 1640, 1688, 1760, 2371, 2334, 4705, 4236, 4542, 3767, 4836, 3456, 4825, 2002, 4481, 4960, 3590, 18, 4083, 1792, 4657, 2810, 997, 374, 3857, 1066, 2936, 1519, 3022, 1851, 313, 1478, 1932, 2018, 1545, 1475, 3409, 3576, 1222, 4070, 3672, 3365, 3741, 1775, 3871, 2141, 1014, 2609, 4090, 2454, 4054, 2583, 2831, 2621, 303, 1954, 932, 2794, 3258, 4057, 4520, 3300, 2633, 4346, 1787, 1582, 3900, 2207, 889, 875, 1546, 6, 67, 2461, 772, 2757, 3246, 4917, 3977, 4456, 3157, 3051, 4849, 1238, 1710, 3722, 744, 2303, 991, 250, 1431, 3146, 1910, 1065, 2944, 2309, 703, 2876, 4509, 893, 818, 1815, 1964, 3684, 4147, 4932, 1273, 2605, 2007, 954, 261, 763, 3151, 194, 2753, 2155, 1143, 501, 3968, 1558, 3943, 4328, 1990, 2358, 368, 4225, 3351, 2572, 2804, 1611, 4824, 3169, 1794, 3112, 3126, 4126, 248, 3510, 2372, 4325, 4342, 4607, 266, 3372, 3945, 2, 1286, 2366, 2200, 520, 2352, 1497, 5, 3791, 3687, 3714, 3960, 4801, 899, 3866, 2613, 1993, 2762, 1632, 3774, 860, 4939, 1782, 3445, 3609, 1006, 2070, 1038, 268, 4611, 2263, 592, 4798, 17, 713, 4599, 4061, 4015, 2253, 4181, 670, 2487, 3645, 3416, 3998, 213, 995, 2560, 3461, 4247, 487, 2913, 1078, 786, 3119, 1306, 3002, 3236, 1604, 2513, 500, 2271, 2722, 259, 3150, 3966, 1099, 2407, 129, 4860, 2319, 3193, 3879, 1985, 2088, 3383, 1128, 2800, 2097, 2403, 2839, 2561, 320, 3089, 41, 1270, 4661, 3860, 317, 3999, 2877, 244, 3508, 2835, 4595, 2109, 2664, 3794, 92, 3772, 1862, 4506, 3473, 3967, 3768, 3625, 3158, 1603, 4996, 2424, 2952, 209, 2548, 3064, 70, 1842, 964, 377, 3961, 74, 1580, 2733, 1104, 1418, 2955, 3401, 4649, 102, 2391, 2660, 1363, 3996, 2381, 1956, 1742, 3005, 4886, 4254, 4565, 4515, 4478, 3935, 4072, 716, 4915, 2616, 543, 900, 4505, 3058, 3562, 166, 2585, 420, 2992, 3434, 1221, 4151, 1667, 2187, 4655, 4857, 1414, 4059, 3437, 1372, 2710, 3004, 514, 4943, 2559, 4862, 2136, 3359, 176, 86, 3732, 3460, 3500, 1566, 3676, 4995, 799, 2538, 4296, 2964, 1360, 1994, 3355, 2287, 783, 75, 2648, 4991, 453, 171, 867, 454, 2926, 3582, 131, 4733, 3220, 2072, 2525, 1145, 3839, 4267, 3899, 477, 776, 2310, 2320, 810, 1192, 167, 924, 4534, 1225, 1999, 2639, 4666, 2622, 3719, 3854, 3558, 3963, 3725, 3284, 811, 2432, 4787, 3614, 4615, 987, 200, 1011, 3778, 3129, 835, 4781, 2989, 1131, 2176, 3277, 2148, 3391, 1944, 2450, 484, 4908, 140, 1593, 2649, 4891, 3908, 3624, 2449, 3043, 2307, 1223, 1635, 69, 2439, 2848, 364, 1664, 3339, 2511, 1621, 3057, 3944, 82, 2030, 221, 979, 2754, 3564, 2596, 2335, 1943, 4428, 3209, 1936, 3008, 4201, 2671, 408, 1240, 3216, 2261, 1846, 1850, 3148, 785, 2698, 4541, 46, 481, 4755, 1554, 4701, 3429, 2180, 4454, 1805, 1456, 3255, 2635, 2869, 1470, 10, 3831, 4688, 2355, 3218, 4979, 1194, 3812, 2490, 3936, 2584, 3716, 2251, 4597, 748, 3979, 3529, 4122, 2856, 3398, 2483, 4068, 4723, 733, 1950, 2281, 1695, 2067, 2652, 3088, 440, 3708, 3675, 2457, 4367, 1412, 4784, 3525, 3934, 1433, 497, 708, 329, 4601, 4899, 2291, 2519, 4200, 4330, 1395, 1754, 1769, 2668, 869, 2177, 3032, 2777, 1745, 3560, 1915, 2833, 1119, 2735, 3443, 127, 2758, 2803, 911, 1086, 1070, 3472, 488, 2395, 1187, 640, 2843, 56, 1137, 44, 476, 1889, 3842, 4564, 2811, 4764, 438, 1403, 873, 3856, 3970, 3816, 827, 3664, 3165, 4419, 2397, 1690, 1752, 3709, 605, 3691, 3122, 4322, 2746, 4892, 2696, 2827, 2776, 2443, 3870, 894, 2275, 2845, 4980, 1424, 385, 1548, 881, 1714, 3707, 2739, 2400, 4864, 1809, 3488, 4619, 2627, 1097, 3116, 4149, 765, 2329, 2001, 352, 3147, 1581, 258, 4128, 1901, 173, 2727, 1765, 861, 4575, 812, 550, 4291, 281, 1366, 2551, 2879, 942, 920, 990, 4998, 4707, 764, 2789, 336, 798, 1098, 418, 4171, 426, 95, 2681, 2937, 87, 4888, 4612, 2569, 247, 963, 315, 3397, 537, 4425, 4340, 650, 430, 1648, 1908, 4463, 526, 4955, 2911, 4838, 3247, 3788, 3200, 1636, 679, 326, 3035, 3446, 9, 4417, 4178, 788, 4155, 4958, 2276, 2943, 4920, 4626, 1264, 3185, 2036, 975, 2033, 1940, 1134, 4378, 3364, 466, 4602, 4775, 148, 1629, 1040, 2901, 1903, 3238, 3689, 4364, 4140, 2533, 934, 369, 4270, 4332, 2050, 1140, 1697, 549, 2433, 292, 3462, 98, 4088, 343, 4746, 4299, 1445, 961, 321, 1963, 179, 4646, 3066, 1127, 2606, 3923, 4304, 1116, 429, 870, 720, 3155, 1657, 690, 2781, 1516, 2052, 3497, 2737, 2357, 456, 831, 328, 2521, 4876, 2167, 358, 3455, 790, 3726, 2259, 3605, 1313, 4686, 3410, 1505, 125, 1170, 3798, 630, 3711, 3559, 380, 4885, 2011, 1377, 2156, 3418, 972, 1925, 2049, 1309, 1960, 1539, 4074, 2798, 1391, 4777, 595, 1761, 1830, 4872, 3352, 3210, 4321, 4665, 4076, 2898, 4164, 4116, 252, 4109, 3468, 2408, 1385, 2338, 410, 3489, 1043, 3080, 4479, 517, 2542, 3980, 151, 4082, 4046, 4827, 3577, 883, 1827, 3742, 693, 2063, 2115, 2972, 3992, 751, 3655, 4544, 2387, 4584, 1093, 2515, 2017, 1161, 4168, 755, 271, 532, 3916, 3601, 4508, 962, 3927, 527, 4402, 4536, 1241, 159, 3527, 3224, 3388, 3759, 2761, 1378, 308, 3279, 1818, 1417, 1875, 3344, 2717, 3405, 1220, 1275, 898, 784, 3969, 2929, 3957, 3062, 4587, 3324, 3950, 2484, 2766, 2712, 1173, 1491, 4921, 2510, 470, 2029, 3580, 3658, 3053, 3514, 1419, 3858, 4447, 1959, 2145, 1457, 2531, 4800, 3665, 1460, 626, 636, 2492, 325, 4327, 4055, 4312, 2379, 1324, 1289, 2500, 2171, 3832, 4945, 1660, 4284, 4026, 4568, 1571, 1103, 193, 2986, 4392, 741, 2957, 1720, 388, 1082, 3350, 4011, 2498, 304, 2677, 1029, 3299, 2650, 3700, 2817, 4295, 2693, 262, 4879, 518, 34, 4467, 3211, 2978, 4581, 4370, 2131, 3598, 3006, 32, 1644, 357, 1892, 1922, 4744, 4927, 4897, 1315, 1483, 551, 30, 885, 489, 4012, 4315, 2578, 2654, 2196, 231, 1596, 4272, 614, 1375, 4170, 4294, 111, 2396, 2118, 3239, 2673, 1716, 3313, 4529, 3346, 2436, 2217, 663, 2545, 1296, 604, 64, 817, 3474, 1498, 144, 2415, 4111, 3922, 4246, 3223, 224, 3072, 4282, 1276, 2614, 4036, 4556, 3340, 407, 4450, 2279, 1980, 887, 1807, 2708, 3728, 4877, 60, 2503, 485, 739, 2186, 680, 1071, 4725, 4956, 1083, 2778, 4211, 1898, 3496, 4290, 465, 1036, 820, 2916, 4987, 540, 1073, 2065, 2685, 478, 2921, 1002, 4408, 2670, 1027, 4527, 2975, 322, 4221, 3327, 4516, 1625, 3653, 4774, 4045, 2847, 2948, 4875, 1446, 2482, 4579, 4620, 2750, 283, 4062, 3568, 1517, 600, 2820, 1699, 4196, 3738, 3661, 441, 3974, 711, 651, 4335, 905, 4647, 3367, 3130, 3450, 816, 4231, 3640, 1415, 472, 152, 3982, 4631, 1508, 3044, 2883, 2463, 1271, 757, 3528, 4772, 2587, 1737, 2855, 565, 2976, 3505, 4687, 4031, 2504, 4220, 1480, 4500, 4969, 2442, 4526, 3124, 4870, 4754, 1179, 746, 4924, 913, 559, 3849, 1789, 2146, 2667, 4618, 1896, 1808, 1893, 2040, 2497, 3092, 521, 3197, 1012, 76, 2062, 391, 1132, 2785, 4421, 3202, 4035, 22, 1962, 3250, 1165, 4816, 189, 3800, 2882, 2166, 110, 1547, 254, 868, 2120, 3626, 3079, 2566, 1533, 4992, 2099, 450, 1146, 627, 4715, 4628, 1831, 1698, 571, 2324, 4742, 2752, 2636, 1708, 3086, 1588, 4249, 1801, 4157, 1347, 4578, 3033, 3222, 401, 1573, 4678, 2113, 11, 473, 1092, 1942, 1485, 1525, 1887, 2597, 1028, 2505, 3317, 451, 4210, 4024, 3358, 4557, 1058, 3956, 1297, 2128, 4812, 3696, 242, 1938, 1541, 1474, 3699, 2105, 1575, 2905, 4103, 1888, 2815, 3400, 58, 2719, 3981, 3219, 3117, 583, 4672, 4881, 916, 1968, 4708, 2829, 2205, 2773, 747, 1436, 1902, 4318, 2175, 4916, 2084, 4023, 3757, 803, 1085, 3548, 94, 1477, 4734, 4341, 2922, 684, 3469, 3789, 2342, 3328, 3537, 2795, 1205, 4173, 3639, 3570, 2100, 777, 4629, 2908, 3140, 3167, 3512, 4580, 2738, 1293, 2224, 215, 715, 3498, 1718, 3888, 2440, 1172, 503, 4737, 2229, 145, 4374, 4962, 3983, 4482, 4050, 4770, 3756, 2886, 4679, 3097, 4783, 1609, 3307, 4414, 434, 2238, 546, 2544, 584, 2638, 4510, 727, 1069, 552, 3413, 3337, 2863, 361, 2791, 2703, 1920, 2577, 398, 624, 4316, 174, 2740, 668, 4514, 1115, 3731, 1159, 1185, 4381, 3780, 1821, 4817, 4841, 142, 3806, 1584, 1870, 1248, 1670, 1628, 3077, 553, 164, 2388, 219, 2325, 1307, 819, 226, 1834, 1108, 4739, 4388, 4303, 212, 3901, 2674, 4850, 3334, 3382, 1957, 1693, 1826, 260, 2240, 2579, 3896, 246, 2142, 1126, 4773, 4999, 337, 1812, 4339, 3386, 2116, 3463, 3703, 1439, 199, 227, 2573, 1721, 2198, 2871, 575, 3291, 3377, 4656, 1570, 1711, 3458, 3252, 4387, 2010, 442, 2793, 2775, 1458, 796, 3679, 4483, 949, 3715, 1633, 3705, 683, 3290, 3503, 2885, 2493, 2043, 4251, 1156, 2931, 4380, 2945, 1736, 1680, 2221, 2345, 1374, 1462, 4517, 1579, 3273, 4087, 4635, 3136, 1868, 3893, 4014, 2006, 1274, 3056, 4086, 4839, 4983, 806, 1473, 3207, 1349, 4424, 211, 2260, 1207, 1860, 732, 3453, 310, 767, 3579, 3863, 4457, 3883, 3636, 141, 1163, 2183, 4639, 3939, 2640, 967, 3701, 1077, 1230, 1591, 2808, 2707, 4177, 2383, 3020, 3172, 1975, 2430, 4567, 1832, 1562, 4060, 3971, 519, 4922, 3795, 4610, 2122, 4588, 1466, 1030, 4660, 3646, 2245, 243, 1577, 4918, 4910, 2369, 2626, 4716, 431, 3803, 4163, 413, 596, 1646, 146, 876, 1587, 1971, 4275, 4264, 181, 290, 492, 1063, 4768, 1102, 1444, 1939, 4224, 1076, 2087, 2528, 2241, 3343, 1231, 4117, 1953, 4829, 1795, 19, 4183, 2865, 269, 3869, 4757, 2314, 3976, 124, 1804, 768, 982, 3270, 1542, 3546, 3777, 958, 4172, 372, 4970, 389, 2994, 2904, 1308, 2283, 4372, 2431, 2341, 1949, 3904, 3099, 3924, 4761, 4404, 2121, 4749, 4119, 516, 3232, 3321, 2711, 3408, 4938, 3680, 590, 1215, 3431, 1114, 4593, 1556, 1124, 3272, 718, 1514, 3069, 4144, 3652, 4625, 3442, 2218, 371, 279, 1819, 3671, 2909, 1618, 852, 807, 2004, 4040, 1729, 3243, 2840, 396, 253, 3693, 3465, 1891, 4214, 2912, 4426, 3834, 4590, 781, 2079, 4758, 710, 1447, 2368, 4997, 404, 915, 1590, 204, 2841, 4622, 3855, 1034, 3316, 2998, 1212, 1343, 3012, 3392, 1160, 2602, 3730, 560, 1055, 386, 2726, 65, 4262, 4112, 72, 638, 2233, 1770, 1052, 4907, 1610, 4347, 2330, 3737, 594, 1822, 4354, 866, 4095, 1989, 4263, 2083, 186, 416, 4489, 606, 1559, 3369, 2103, 998, 4286, 2893, 4280, 1141, 4782, 2582, 4668, 775, 4507, 856, 3426, 2157, 3903, 513, 676, 4028, 2015, 1089, 884, 2028, 1817, 3876, 2438, 3886, 3159, 580, 2805, 566, 4547, 3521, 1013, 1766, 1008, 1713, 1567, 4504, 2437, 3042, 1655, 2317, 4727, 2935, 1492, 4205, 4819, 3915, 3168, 4320, 3602, 1323, 3925, 2256, 4460, 4528, 1091, 2612, 100, 3623, 3894, 4694, 2532, 3642, 202, 4228, 3622, 2867, 3822, 123, 1797, 3068, 833, 1393, 119, 1921, 1048, 4571, 319, 1859, 402, 1358, 4821, 4946, 1174, 4459, 4776, 1823, 3083, 1402, 1101, 257, 2872, 2672, 24, 1696, 412, 3524, 4671, 4959, 3669, 409, 2970, 3292, 4533, 1639, 1614, 3575, 2468, 3347, 1266, 2716, 187, 2518, 288, 3747, 4981, 387, 728, 2846, 2925, 2825, 235, 1186, 2277, 886, 622, 4058, 4268, 677, 2192, 382, 61, 1342, 1692, 1171, 3586, 2678, 2327, 4174, 3183, 3166, 2446, 844, 3154, 4794, 3041, 948, 1878, 2322, 2630, 1753, 554, 3782, 4496, 2647, 1037, 4795, 1881, 3914, 620, 857, 3128, 3330, 2190, 3457, 3287, 3861, 3946, 4933, 1743, 2356, 15, 2563, 4811, 4913, 2470, 726, 2769, 128, 1781, 3308, 4729, 4728, 2765, 628, 773, 1576, 3792, 1032, 793, 1748, 3134, 4148, 45, 2799, 3990, 4158, 2134, 1602, 3621, 3660, 112, 2265, 96, 1532, 3942, 4868, 3430, 3952, 3422, 3913, 548, 569, 1599, 1199, 1316, 4240, 789, 2060, 2389, 1129, 1715, 4878, 4735, 370, 4802, 2406, 544, 2979, 1501, 1368, 3589, 3087, 2832, 2242, 2611, 4512, 3454, 4039, 3428, 2873, 2331, 4750, 3776, 1872, 414, 3783, 1866, 4191, 348, 2064, 974, 1355, 4204, 2282, 4562, 2219, 912, 3713, 3931, 2949, 3074, 1359, 482, 2859, 3331, 3115, 1095, 588, 1722, 4634, 3648, 464, 3483, 4554, 8, 760, 3459, 4365, 4786, 3551, 2413, 3251, 1540, 2000, 1380, 659, 4621, 2523, 4751, 4617, 2485, 218, 2594, 1929, 4902, 4898, 1404, 1549, 1504, 1268, 635, 3678, 460, 4986, 1105, 207, 2096, 4502, 1967, 4586, 2027, 417, 1885, 888, 3745, 4973, 14, 264, 40, 432, 4604, 562, 3039, 4440, 530, 232, 1269, 139, 921, 2429, 815, 2496, 2591, 255, 653, 1204, 2851, 2119, 2494, 1561, 2721, 1148, 1280, 3054, 880, 3506, 3435, 4900, 267, 4110, 4682, 168, 4835, 2826, 4677, 394, 3948, 3476, 3964, 3061, 4484, 564, 1857, 1398, 2039, 3176, 3354, 1300, 4848, 1356, 284, 4323, 270, 2419, 4279, 1310, 3262, 3985, 2215, 4923, 4104, 3850, 1624, 4306, 3543, 4389, 1080, 896, 3662, 3424, 1213, 3107, 3194, 3353, 2713, 745, 4985, 2013, 1023, 4412, 1094, 2539, 48, 3643, 3844, 299, 3781, 3184, 4576, 3052, 3162, 4497, 312, 1918, 3248, 2666, 734, 2346, 4385, 561, 234, 2555, 400, 2466, 4257, 707, 4432, 4105, 926, 3191, 4394, 2153, 3407, 4466, 4583, 666, 419, 737, 25, 83, 4748, 1254, 1260, 2361, 1193, 910, 3003, 175, 2126, 1845, 163, 2491, 3026, 4430, 2764, 157, 4522, 1252, 4455, 3511, 4530, 4676, 2305, 2759, 4075, 3872, 647, 338, 2720, 3518, 3572, 403, 62, 353, 4114, 1025, 3539, 1168, 12, 4399, 3578, 475, 4494, 2889, 4680, 1524, 4884, 4791, 1476, 4555, 1216, 1785, 608, 3204, 2127, 3762, 1162, 1894, 1531, 2333, 3479, 3241, 1054, 3820, 1585, 2967, 5000, 3929, 2370, 4329, 4703, 4936, 568, 2991, 2458, 3685, 49, 671, 4608, 4495, 3973, 2807, 4465, 1637, 2056, 236, 2247, 3635, 3221, 4905, 1288, 4476, 1668, 2895, 2819, 2464, 603, 1495, 4048, 1686, 3786, 1725, 3055, 1694, 2961, 1800, 3905, 362, 1513, 1814, 33, 2353, 758, 4256, 4227, 3254, 1840, 3991, 2364, 3584, 1438, 3230, 1671, 4049, 2308, 1334, 3260, 3763, 2550, 2339, 3480, 2107, 3615, 1265, 2637, 2617, 291, 2106, 331, 4020, 1064, 619, 4972, 2359, 2434, 240, 897, 3120, 2570, 4004, 1927, 2252, 930, 340, 797, 3419, 3659, 928, 287, 447, 3604, 2231, 4356, 1007, 981, 536, 2302, 1142, 1050, 4605, 1045, 3596, 3073, 2763, 1472, 4212, 2558, 1778, 1202, 323, 3095, 1597, 1465, 2405, 1572, 4779, 3153, 3233, 2223, 2959, 984, 2615, 1259, 3846, 3618, 4759, 4405, 2608, 99, 2365, 1544, 3199, 2139, 3785, 208, 4623, 3030, 2250, 3610, 4538, 3787, 696, 27, 1607, 4189, 3271, 2574, 4974, 2264, 4552, 1712, 2069, 3941, 1429, 4390, 1018, 4691, 2055, 1072, 1836, 229, 2704, 3011, 2462, 762, 2907, 1022, 3448, 3420, 2933, 4540, 2195, 1455, 1706, 3997, 4017, 1015, 2985, 3451, 197, 618, 286, 2645, 2942, 1700, 2351, 4928, 2874, 1838, 3345, 3805, 2742, 1955, 107, 1450, 2290, 4477, 3071, 3897, 1234, 1489, 2853, 3187, 2423, 697, 1020};
//int array[10000] = {5869, 5385, 9582, 754, 6762, 2585, 9013, 3442, 442, 2580, 9135, 4508, 5492, 5454, 9491, 3402, 2297, 1107, 3585, 1500, 7433, 9027, 3839, 8604, 5702, 7242, 1056, 9263, 7379, 7474, 8396, 4878, 1166, 9060, 3246, 8334, 4732, 8534, 2423, 9841, 566, 1752, 2556, 6872, 1843, 9073, 9566, 6970, 7307, 7412, 4699, 1404, 2459, 5853, 5157, 5098, 8801, 6072, 6226, 9329, 8616, 1570, 9198, 9090, 306, 9823, 750, 9981, 4183, 6103, 9595, 3547, 8635, 4014, 3657, 9838, 5315, 6126, 8111, 5397, 8169, 2957, 7445, 7786, 596, 1735, 7522, 8489, 4655, 1652, 6371, 5999, 8972, 1061, 154, 7561, 4488, 4357, 3354, 6439, 960, 1707, 9087, 1132, 6019, 3047, 8735, 18, 7219, 1844, 1639, 2483, 934, 2642, 2129, 2595, 2907, 227, 3512, 6135, 3142, 9768, 5763, 2975, 5034, 1446, 4961, 2155, 6310, 347, 5969, 3968, 6775, 8192, 1877, 2226, 3480, 5845, 3700, 8924, 2788, 6414, 6711, 1315, 7830, 1865, 830, 1538, 6765, 692, 7771, 2865, 2727, 801, 2602, 5449, 3500, 7545, 6333, 8990, 8940, 1365, 6808, 1728, 6050, 7886, 7690, 3364, 2701, 6246, 6844, 7450, 6727, 5111, 2843, 97, 4738, 4466, 271, 3018, 9568, 3540, 7422, 3165, 1775, 3566, 3952, 348, 2811, 2417, 5693, 1053, 7755, 599, 2967, 356, 2931, 1117, 8281, 2411, 9807, 9442, 2987, 5883, 2779, 2221, 7060, 2443, 8613, 1470, 8382, 8078, 7858, 2961, 1864, 7668, 5633, 4581, 4157, 4074, 3819, 6196, 3432, 4345, 4852, 4194, 422, 2145, 6252, 1908, 1518, 6374, 5629, 2134, 8585, 6619, 4968, 581, 394, 4414, 3720, 7136, 9815, 9501, 3164, 8036, 1426, 993, 6763, 618, 7924, 133, 9036, 2718, 8704, 5272, 9613, 5288, 55, 3098, 544, 8225, 5081, 2431, 9900, 8425, 9137, 1031, 7510, 6301, 6068, 7477, 2749, 1689, 2252, 8014, 8588, 6883, 7363, 8878, 4719, 8061, 7253, 3593, 2688, 749, 7404, 908, 2943, 6435, 1835, 5681, 4860, 6695, 8201, 672, 9290, 1083, 8084, 5351, 1389, 6925, 7081, 1443, 1734, 37, 4599, 3777, 4634, 6353, 984, 9230, 7606, 2684, 1805, 4324, 4298, 4403, 9553, 5786, 2323, 3765, 6666, 6235, 4857, 294, 7365, 1364, 4425, 8449, 4398, 390, 1291, 2024, 1948, 6958, 664, 6290, 1903, 4326, 7676, 4206, 6737, 1527, 401, 2933, 2032, 5347, 4117, 4010, 8586, 5166, 5427, 6432, 1046, 3934, 9371, 9905, 2465, 982, 5147, 3126, 8803, 3858, 1087, 9946, 1163, 7360, 1619, 6104, 8020, 3198, 5655, 1917, 5917, 9787, 3287, 3811, 5415, 6168, 3690, 5309, 8175, 3941, 8609, 1124, 2177, 3620, 5448, 9093, 7930, 6809, 2227, 7679, 3852, 6299, 6484, 2885, 6247, 8041, 2224, 2946, 8818, 7814, 2695, 74, 1480, 1579, 7998, 1606, 5420, 1607, 7788, 286, 207, 9919, 2558, 391, 1215, 1885, 8207, 9611, 8516, 7162, 350, 8076, 6242, 9106, 1887, 7457, 1901, 2732, 8045, 9045, 7239, 9920, 4897, 1944, 3454, 6444, 3666, 9379, 3698, 6055, 5828, 3448, 3112, 4821, 5758, 3613, 6738, 5744, 1230, 3225, 6249, 5325, 8023, 334, 4355, 6036, 3981, 7760, 5798, 9257, 3518, 9921, 2271, 2144, 6591, 4768, 8849, 7217, 4175, 8168, 6458, 3173, 395, 7318, 553, 5140, 8366, 9952, 2437, 9361, 3316, 5084, 2565, 7377, 9188, 3568, 9225, 2830, 8398, 9247, 6595, 5228, 9853, 769, 7010, 5670, 2836, 8384, 8360, 3162, 6457, 2070, 764, 2245, 5058, 8440, 9098, 5826, 5118, 62, 790, 3144, 8626, 9282, 5105, 7213, 5791, 7054, 7145, 8977, 2260, 4783, 2927, 838, 5457, 53, 686, 6156, 5447, 4259, 9041, 3969, 7697, 921, 3110, 4975, 8349, 5379, 2909, 3548, 4094, 1371, 5876, 6608, 7089, 7139, 1911, 6119, 7419, 3675, 1847, 3812, 9909, 8855, 662, 4342, 4973, 1390, 4015, 1650, 531, 1875, 4244, 457, 8998, 6956, 820, 5331, 2772, 8189, 8292, 3037, 4343, 6501, 7984, 952, 4379, 4507, 82, 1950, 65, 2596, 6380, 2807, 1528, 3381, 9977, 9895, 6890, 7383, 4331, 2086, 7421, 6980, 2273, 8881, 9769, 1331, 3102, 5797, 4387, 9537, 2479, 8555, 1326, 3132, 4613, 4263, 837, 1971, 3337, 2053, 3961, 6214, 4388, 9418, 6341, 5699, 262, 3370, 6302, 9368, 9792, 9761, 841, 7503, 5491, 540, 4023, 1008, 8968, 233, 1057, 8629, 631, 4256, 4495, 9735, 515, 4824, 3338, 4548, 2537, 4198, 1153, 5598, 125, 5908, 2261, 8859, 2316, 5392, 3525, 7625, 1512, 529, 3420, 1119, 2371, 8537, 4762, 6004, 7996, 3383, 8373, 4295, 6097, 3406, 5413, 4427, 4211, 2799, 6086, 811, 4376, 5924, 7684, 9415, 6471, 6504, 1126, 3910, 796, 357, 3274, 963, 8160, 5814, 2011, 3583, 8885, 1233, 9412, 5017, 6138, 1957, 574, 7184, 8100, 5804, 5473, 7855, 5719, 5789, 63, 105, 6983, 1537, 8494, 6295, 9157, 9148, 2298, 3355, 9968, 3784, 5582, 594, 310, 656, 718, 336, 9674, 1296, 8670, 2274, 3824, 8101, 6650, 7408, 2516, 8665, 555, 6845, 8612, 212, 4735, 1048, 4447, 8153, 1089, 4621, 939, 7743, 5462, 4988, 1749, 3038, 628, 1042, 6652, 252, 6692, 9242, 4193, 4674, 7270, 4325, 1790, 6667, 9281, 3787, 696, 7475, 5160, 7027, 7198, 1705, 2842, 6199, 2325, 1820, 6479, 5527, 1782, 259, 9318, 260, 5236, 1963, 3437, 7692, 2598, 3186, 6886, 6788, 2160, 5622, 169, 2441, 6232, 2229, 6840, 8086, 5078, 5281, 8634, 9533, 3799, 3795, 5730, 7947, 6139, 1533, 7809, 7876, 5764, 7236, 3828, 1209, 107, 5569, 8675, 9300, 4239, 2113, 141, 8800, 2561, 3897, 7149, 5009, 1378, 9382, 6260, 649, 3939, 7709, 2388, 4148, 2924, 21, 5000, 3763, 7108, 4644, 9545, 2792, 7877, 1824, 1935, 2812, 9245, 6540, 8683, 4402, 6957, 6835, 2026, 5721, 2790, 1913, 2176, 7574, 6395, 8934, 2359, 4474, 489, 516, 7046, 7334, 4268, 4045, 7309, 6192, 3725, 5290, 3425, 2970, 3627, 7427, 7565, 3997, 5680, 5196, 160, 532, 7301, 4834, 1516, 8266, 6069, 3717, 4985, 9907, 7470, 5641, 346, 9240, 3654, 7938, 7452, 4037, 8863, 1781, 859, 9437, 7438, 9972, 7290, 2889, 5112, 337, 5855, 1249, 5984, 6173, 8010, 5865, 2877, 5748, 365, 4756, 6422, 1837, 1140, 999, 5864, 9096, 8032, 2308, 6657, 6914, 7105, 9163, 4619, 2610, 7062, 6314, 7013, 9514, 5847, 7805, 8917, 2738, 94, 9390, 978, 6221, 948, 8300, 1810, 7954, 7096, 8945, 4662, 3990, 7960, 6277, 2303, 4409, 6266, 4554, 2751, 5958, 2796, 5827, 4582, 9944, 3042, 443, 7731, 2755, 4758, 3962, 806, 4059, 5628, 290, 5739, 2269, 954, 8479, 9574, 8375, 5711, 614, 5568, 5564, 6041, 2912, 4510, 8987, 1307, 2758, 9635, 5926, 950, 7262, 6094, 4429, 3099, 6350, 1143, 6443, 9047, 3221, 968, 3206, 1557, 5338, 8576, 9849, 6685, 9273, 1736, 5326, 9149, 9068, 3546, 3759, 8970, 8770, 5717, 3604, 9988, 4478, 7687, 1460, 8136, 5119, 3705, 622, 5246, 1191, 5478, 1610, 219, 420, 4888, 8617, 7974, 3647, 4307, 5239, 9091, 7953, 7666, 6382, 6281, 2406, 6190, 817, 1502, 5607, 2820, 4169, 9698, 4944, 9542, 5799, 3971, 278, 3556, 7240, 2862, 8211, 4570, 1651, 8941, 6205, 6383, 1825, 6240, 8226, 4062, 8949, 2599, 2859, 4763, 6646, 4767, 850, 8048, 4641, 4615, 4759, 7567, 9646, 3467, 7022, 9360, 6912, 9756, 9289, 6651, 9164, 7295, 7504, 4896, 3775, 2656, 7878, 3052, 1287, 5673, 951, 3995, 4122, 2338, 7534, 5706, 5792, 9256, 9631, 3119, 809, 1643, 6530, 7425, 6345, 6288, 9987, 7254, 9834, 9743, 6868, 5260, 2283, 517, 1123, 1283, 1367, 6154, 5967, 4721, 2394, 469, 866, 4881, 534, 1638, 9623, 3683, 4611, 4497, 753, 2832, 454, 2489, 3507, 1091, 4503, 284, 9518, 9352, 2985, 8026, 3878, 2588, 9411, 3004, 2745, 4559, 1487, 7491, 1259, 800, 9395, 2000, 2350, 5907, 2168, 949, 5519, 8558, 8959, 9562, 1622, 1712, 5618, 5150, 8065, 3190, 2692, 2941, 183, 9878, 9448, 3421, 2683, 3462, 2517, 367, 5943, 5795, 9790, 4565, 509, 9427, 7246, 9222, 6931, 4591, 6570, 9481, 7004, 8840, 3847, 5197, 9144, 5101, 1492, 3626, 1550, 6195, 7879, 8430, 5857, 2971, 59, 6044, 3399, 9269, 1525, 2875, 8701, 9937, 9867, 6896, 2851, 6531, 9165, 4717, 4001, 7049, 3880, 1575, 8231, 831, 9286, 9731, 6599, 6250, 3272, 5638, 3293, 8610, 6799, 6313, 7647, 5779, 4060, 3254, 250, 2627, 416, 5048, 5687, 100, 6453, 5247, 990, 5092, 9512, 1855, 7275, 2962, 9746, 1179, 1477, 6746, 4299, 3923, 4050, 3889, 5280, 6586, 6996, 4887, 997, 1022, 8186, 2164, 2809, 9112, 4449, 3511, 57, 7349, 8699, 39, 3670, 6919, 4539, 7713, 6520, 6125, 2652, 6145, 3403, 7524, 6797, 9951, 2983, 6390, 7536, 6647, 2180, 6792, 5482, 7818, 6336, 5737, 2280, 7406, 2840, 6389, 4178, 5575, 6487, 3301, 6098, 5517, 5938, 4980, 3906, 7775, 4866, 9203, 5364, 1595, 8423, 1900, 5117, 7218, 2321, 7024, 2099, 4562, 1391, 8249, 9752, 5964, 5249, 3555, 7502, 2137, 1139, 8477, 5776, 2828, 832, 2253, 3830, 7827, 9452, 824, 5842, 292, 8413, 2223, 2737, 7280, 8525, 8418, 161, 8037, 6181, 4682, 3545, 705, 1599, 8385, 5563, 9218, 8371, 7453, 4396, 6495, 5888, 418, 4544, 4777, 7584, 1018, 6785, 1977, 9052, 9592, 3972, 4136, 8223, 9539, 4352, 1152, 5868, 6505, 7801, 9012, 1210, 3761, 3288, 9294, 7989, 307, 8388, 2203, 5044, 9128, 345, 6804, 1471, 8568, 1036, 9521, 2286, 9397, 6018, 1630, 8820, 4654, 2170, 6642, 4382, 4199, 2654, 1356, 8562, 4315, 4550, 7705, 3769, 4163, 1922, 8672, 3791, 4715, 7337, 5745, 9295, 3754, 8203, 7086, 8293, 5766, 3728, 5029, 5320, 4950, 9511, 972, 8287, 9423, 9830, 7694, 7997, 5254, 9435, 1725, 4861, 3180, 6969, 1721, 9668, 2140, 629, 7823, 3310, 1151, 7226, 7490, 8492, 9616, 8736, 7180, 6436, 3343, 6929, 7776, 2629, 5560, 8341, 2002, 6876, 755, 3418, 435, 2277, 9026, 7554, 8273, 3800, 783, 2775, 7806, 6265, 9187, 2563, 6978, 6229, 9587, 2318, 620, 4213, 5710, 1340, 5033, 4459, 8731, 8022, 8966, 2305, 869, 405, 3814, 4249, 6710, 1321, 7824, 3309, 3410, 8893, 8706, 3257, 812, 1682, 1803, 891, 1183, 8954, 2028, 7352, 8179, 6543, 4969, 433, 7312, 4575, 3463, 7815, 3268, 6697, 7895, 5592, 1842, 9023, 1374, 1114, 7873, 7181, 4502, 8842, 8157, 747, 5942, 7790, 7864, 6320, 5597, 1642, 2389, 2803, 3020, 1175, 4351, 3917, 288, 5263, 9108, 9691, 3712, 5905, 7944, 1788, 1647, 8543, 1918, 883, 6555, 8755, 6860, 4170, 7869, 8823, 844, 7166, 20, 1969, 3281, 7929, 26, 8381, 7471, 6580, 8302, 1476, 6219, 9513, 2926, 1878, 5251, 5506, 4915, 6030, 5493, 4815, 6588, 3606, 5858, 3531, 8243, 9871, 8526, 3656, 9042, 8698, 5816, 5805, 1593, 1702, 6949, 3658, 1435, 774, 5605, 3528, 6334, 9654, 106, 8596, 2398, 2332, 6035, 8370, 9842, 4024, 4061, 7259, 2508, 7903, 9154, 938, 3532, 9579, 7592, 2189, 898, 8362, 5813, 2079, 1796, 8724, 9213, 7435, 3021, 9703, 1144, 9321, 786, 4483, 6225, 8326, 5133, 3648, 3050, 4337, 5783, 1482, 7505, 8357, 8679, 7241, 1794, 3457, 9159, 3840, 3734, 1940, 3054, 1450, 8872, 6325, 5375, 2620, 3133, 9800, 6251, 7000, 3503, 3954, 5709, 7160, 3735, 4339, 9254, 6324, 8673, 1559, 8607, 9552, 8995, 1534, 7263, 9953, 1761, 5074, 5788, 6973, 4993, 1419, 3472, 5895, 7216, 3409, 9444, 524, 6736, 5337, 9733, 8004, 5301, 680, 1633, 7047, 6921, 5623, 9416, 4043, 2815, 9848, 2084, 9447, 1453, 3608, 7063, 7064, 8286, 2076, 3111, 9557, 987, 7370, 1342, 8421, 8713, 775, 5210, 2235, 5593, 4911, 3671, 5577, 1889, 8767, 54, 1591, 3177, 6262, 685, 4226, 2397, 3519, 4390, 7920, 1907, 8064, 24, 8532, 659, 6701, 4305, 1080, 5221, 580, 689, 6408, 2982, 7646, 5248, 3694, 821, 8826, 9085, 6083, 237, 1401, 6754, 3633, 296, 3334, 8891, 116, 3220, 5287, 7099, 874, 5077, 1921, 3273, 7983, 280, 438, 6811, 8482, 1995, 4934, 8723, 7540, 7374, 2291, 3950, 8860, 6155, 3602, 5718, 5953, 5182, 5073, 9413, 7302, 5054, 9160, 6128, 3139, 282, 9127, 5080, 2334, 9177, 2037, 9158, 8033, 5683, 9431, 572, 527, 6440, 4491, 2206, 3363, 651, 1231, 2013, 6166, 4306, 4830, 1893, 959, 739, 5177, 2548, 5595, 429, 1895, 3481, 757, 1955, 7500, 9506, 3078, 677, 7701, 13, 6468, 8575, 9638, 5333, 225, 6141, 3623, 4607, 4806, 8053, 4340, 8814, 2816, 1284, 1141, 2458, 2878, 6576, 2609, 2156, 1549, 797, 906, 9826, 3793, 6605, 7739, 675, 485, 3567, 9508, 1941, 8923, 7812, 4743, 9822, 7576, 4688, 7759, 6335, 5181, 8442, 7488, 1157, 7841, 3650, 665, 3524, 6932, 3702, 6463, 9948, 3073, 7443, 2110, 6820, 9992, 1747, 5646, 7568, 7535, 2362, 4670, 3423, 5279, 6877, 3625, 8578, 1861, 4179, 9330, 8386, 1362, 5088, 1992, 3610, 5393, 1236, 8198, 4571, 6076, 6111, 8769, 9107, 27, 7729, 5285, 9538, 3266, 4874, 5243, 4858, 8546, 5404, 7480, 888, 6114, 5208, 3709, 7901, 6568, 1740, 3200, 3646, 1248, 7400, 5925, 1710, 8648, 8232, 4431, 2127, 6975, 1135, 2474, 1352, 6489, 3510, 787, 72, 681, 2566, 1060, 9935, 8898, 7599, 9857, 8408, 501, 9788, 7460, 236, 5760, 6186, 328, 1529, 4368, 5664, 8549, 7559, 8436, 2726, 3416, 1543, 2141, 3361, 576, 9184, 81, 9851, 2917, 8909, 8361, 7745, 8837, 7059, 7538, 3068, 8999, 2380, 5336, 5047, 1929, 9758, 5712, 5949, 6416, 3367, 4167, 6308, 3975, 4308, 8331, 3496, 7325, 4348, 3963, 1386, 9366, 6906, 8493, 9773, 4250, 244, 1603, 3922, 7056, 238, 9421, 2257, 6220, 4953, 1912, 5289, 7578, 5004, 8087, 8667, 8007, 1463, 4626, 8452, 606, 8748, 84, 1659, 8720, 5418, 8953, 6507, 8557, 2693, 8757, 8079, 7222, 9195, 1632, 4528, 1946, 7789, 8171, 2829, 6466, 7688, 5583, 5570, 2510, 1947, 6851, 2800, 7116, 671, 5286, 6122, 6327, 5237, 4785, 5668, 7327, 7466, 5372, 7495, 1304, 9019, 571, 2333, 1542, 7961, 4133, 6110, 5367, 6901, 7203, 5102, 712, 7188, 2460, 8925, 9383, 7346, 6889, 8365, 1260, 194, 2209, 7424, 7019, 2085, 8120, 12, 1581, 468, 8930, 6849, 4624, 2567, 9808, 324, 6728, 8510, 4407, 1302, 9827, 4951, 650, 5934, 1572, 3595, 4822, 8220, 5202, 4365, 9771, 6525, 5836, 7161, 5421, 7289, 5659, 2152, 8668, 3682, 7257, 600, 9779, 3664, 7516, 1194, 2527, 7670, 3375, 8624, 6172, 2146, 9193, 2590, 2906, 9325, 7520, 7616, 5848, 110, 657, 6825, 5258, 1588, 7678, 4844, 4842, 3082, 7914, 4112, 9028, 6429, 41, 2575, 9669, 1269, 7487, 3292, 2463, 95, 624, 9490, 7934, 7725, 1212, 6031, 4660, 7305, 9655, 5431, 7722, 7373, 9004, 4786, 504, 573, 4518, 8093, 455, 9476, 1967, 2438, 9524, 6946, 4547, 265, 8415, 4977, 2478, 5553, 1204, 6433, 8802, 7109, 9293, 8657, 2511, 298, 2410, 9599, 4760, 3590, 7321, 3447, 436, 3614, 2979, 1666, 1602, 3833, 9945, 5914, 2020, 667, 541, 8070, 4501, 7055, 6026, 9066, 3305, 2266, 8275, 8997, 5806, 4391, 7387, 1584, 8389, 4792, 5515, 6403, 3942, 1631, 5749, 9684, 7279, 8825, 4187, 7683, 884, 3821, 8531, 3096, 370, 9859, 8329, 8719, 3535, 6099, 547, 441, 1, 9056, 1267, 1148, 4026, 9485, 5552, 1174, 9576, 877, 7629, 8035, 6963, 3645, 3087, 8484, 8725, 8620, 9298, 5276, 8458, 2795, 9736, 6606, 8647, 6791, 3136, 4168, 6653, 5365, 5909, 6159, 5608, 579, 2094, 7442, 2222, 7810, 3459, 5343, 1361, 322, 8478, 4594, 4957, 3264, 6556, 4096, 3181, 1668, 5970, 4636, 8239, 8015, 7268, 2041, 2639, 6293, 3762, 564, 4496, 9965, 5295, 1159, 697, 4982, 2668, 9594, 7193, 3415, 9223, 3983, 2190, 412, 4078, 2056, 9445, 8083, 9451, 3072, 7042, 1029, 2307, 8379, 1758, 5432, 270, 7609, 7171, 4475, 3736, 9428, 7464, 2740, 6545, 4723, 103, 9527, 1303, 6491, 8921, 5525, 4020, 139, 8338, 1637, 2691, 2204, 3687, 1467, 899, 973, 7048, 6924, 3486, 9358, 7362, 1807, 8187, 7544, 9738, 2778, 6381, 5988, 2485, 1826, 4160, 3398, 3987, 1720, 6217, 8102, 2505, 8836, 5698, 7082, 3130, 521, 8216, 9046, 6602, 5860, 727, 7618, 7778, 870, 6871, 5956, 8049, 4144, 7358, 2233, 2051, 4124, 5558, 5162, 4139, 7971, 5875, 4765, 4242, 315, 8496, 2287, 1882, 7120, 3599, 1432, 735, 4801, 8625, 176, 907, 9061, 6936, 5218, 2161, 157, 6842, 3060, 5639, 4254, 2934, 7598, 5530, 7696, 8907, 8828, 1743, 3335, 5630, 5305, 3550, 1002, 8587, 2687, 7015, 5927, 80, 6014, 2416, 3085, 4116, 6627, 168, 460, 2451, 765, 2506, 6916, 5821, 7250, 4110, 5300, 9153, 374, 7066, 6431, 1202, 6712, 8504, 2154, 7441, 6985, 1718, 926, 5685, 3168, 8092, 1070, 8034, 8761, 4640, 1618, 647, 4608, 5916, 6607, 4740, 7537, 4455, 1846, 1552, 5046, 2876, 7898, 1703, 5901, 253, 3143, 5292, 2823, 444, 4530, 7434, 4800, 8600, 1858, 7332, 9526, 6750, 3202, 8466, 4876, 2108, 7906, 691, 4454, 2741, 9048, 2208, 6185, 1567, 9000, 1407, 8387, 9547, 124, 1669, 7467, 1154, 3661, 8602, 8038, 5488, 8460, 255, 5189, 2182, 3055, 6228, 269, 4893, 784, 8257, 9925, 5897, 1311, 2880, 4057, 8390, 4540, 9464, 1596, 3944, 3231, 8464, 2098, 3262, 5304, 7551, 4207, 1778, 1368, 6656, 3489, 1184, 8132, 2284, 7587, 1013, 4618, 9122, 4081, 6275, 6021, 2612, 9327, 8589, 206, 4022, 4845, 5742, 7405, 6303, 1560, 5547, 434, 1000, 7779, 4212, 8659, 1517, 8335, 3506, 7957, 264, 5388, 2680, 6243, 388, 7288, 8519, 6752, 7981, 4742, 1727, 8330, 2752, 2158, 9578, 9959, 5002, 3328, 4294, 5334, 567, 2027, 4311, 1273, 8958, 8760, 2215, 3468, 7645, 4928, 5358, 2295, 1514, 8439, 7589, 9115, 3226, 1768, 6744, 9534, 7605, 2248, 6472, 1905, 7517, 5436, 6034, 7608, 8608, 8580, 1180, 6376, 7987, 3106, 6551, 3536, 499, 7843, 9934, 5873, 4995, 9022, 8989, 3492, 6806, 3818, 3909, 5867, 763, 4850, 7718, 1815, 6859, 8556, 8937, 4303, 5056, 4672, 6816, 1261, 9341, 1544, 6615, 7615, 9705, 477, 9309, 8279, 6677, 3810, 484, 8545, 4498, 4016, 5772, 3145, 4679, 5771, 2896, 8433, 6760, 4647, 3570, 6870, 7804, 6058, 9950, 5071, 8783, 8571, 6664, 848, 2426, 6971, 6008, 5341, 5480, 5230, 6378, 3659, 475, 641, 9343, 6786, 4668, 6015, 5574, 7773, 1976, 3704, 4005, 2428, 7715, 9884, 799, 3160, 2256, 4512, 8952, 1442, 3826, 1286, 6987, 3118, 1167, 2247, 2763, 6182, 7909, 75, 7041, 6465, 1766, 1429, 2838, 2422, 456, 7839, 4470, 6054, 4587, 1840, 8057, 8554, 4423, 2282, 4410, 5144, 7972, 3329, 3208, 9741, 5989, 2186, 6964, 2319, 5974, 2860, 240, 5955, 6547, 2819, 6947, 7935, 9679, 3218, 2679, 3603, 8383, 3049, 7552, 2392, 9311, 8984, 2750, 6659, 6960, 7423, 1019, 9866, 7964, 8669, 6865, 625, 4707, 1919, 3537, 779, 1625, 8096, 8793, 1792, 1856, 8550, 2335, 9678, 6550, 3588, 7214, 7648, 2719, 8444, 8845, 743, 9726, 6643, 6496, 239, 6740, 8254, 1510, 6648, 6554, 5550, 9425, 8310, 7151, 7385, 8734, 9186, 7104, 2368, 6150, 8527, 7610, 5438, 8951, 8547, 6209, 8328, 1465, 1998, 932, 7918, 1640, 200, 609, 1428, 8288, 3191, 7252, 7846, 1211, 4296, 3905, 2405, 1052, 5537, 635, 4789, 3156, 5900, 7556, 4363, 1983, 7611, 4620, 1009, 323, 8638, 816, 5359, 6942, 7320, 3719, 4967, 1497, 4720, 7456, 9573, 3798, 2225, 4135, 1729, 1871, 216, 1791, 9246, 3713, 9697, 6878, 4913, 375, 5933, 6454, 4943, 7068, 1035, 7669, 1318, 4930, 77, 7557, 4545, 6063, 8969, 3779, 5465, 5910, 2887, 4793, 7617, 361, 7861, 6768, 1587, 9384, 8902, 3233, 1714, 6735, 344, 3956, 5013, 150, 3237, 4461, 3748, 1282, 3443, 8002, 6087, 6105, 4942, 2123, 8819, 9355, 1088, 5518, 6604, 7124, 1616, 2804, 5468, 7115, 2337, 729, 1398, 9340, 6212, 3199, 5391, 196, 4802, 3369, 3187, 1508, 6994, 9351, 1687, 2276, 2202, 8833, 7673, 9054, 1047, 2649, 6686, 4903, 550, 3446, 808, 2132, 5621, 6814, 8321, 3458, 203, 7355, 6351, 6534, 4585, 5524, 644, 2236, 9504, 9228, 8573, 6171, 4499, 1222, 6016, 4645, 2470, 8058, 4095, 2550, 2122, 9339, 741, 9964, 7366, 6490, 3731, 7020, 4185, 4653, 1341, 3395, 2725, 7119, 8992, 5398, 5349, 431, 2440, 3977, 66, 1655, 6118, 8948, 1813, 4825, 9262, 2996, 338, 9029, 3946, 6674, 10, 5340, 5318, 1473, 3107, 3660, 8614, 6679, 3771, 4901, 173, 1418, 9031, 9456, 8025, 8011, 8127, 5818, 1322, 4820, 7542, 5859, 7982, 1910, 487, 6514, 1182, 9118, 6315, 856, 247, 1634, 3498, 6347, 4899, 1017, 1898, 5596, 9374, 8566, 7417, 4695, 4741, 2966, 7732, 1186, 6109, 1678, 962, 4235, 9197, 6665, 3058, 8865, 737, 835, 5899, 331, 4531, 4433, 1896, 9844, 3805, 8778, 5587, 4744, 5037, 2044, 2169, 3560, 4603, 746, 2071, 4146, 6204, 6884, 4504, 7955, 4927, 3752, 9055, 5282, 312, 7871, 2519, 7285, 1441, 5790, 4350, 2676, 5656, 822, 1469, 8040, 4312, 2711, 6359, 3933, 4029, 5143, 8485, 3243, 2234, 7990, 8579, 6245, 7828, 9255, 7799, 5561, 3311, 7644, 3372, 3094, 9266, 4155, 4921, 1952, 1827, 776, 6694, 5344, 8194, 9719, 304, 610, 4395, 1945, 9704, 7613, 5068, 2430, 1037, 5022, 9039, 4997, 9138, 6928, 5866, 634, 4964, 2918, 4480, 9510, 1099, 5644, 8068, 7916, 5585, 9820, 862, 4971, 3125, 8730, 5946, 1580, 6187, 9816, 4027, 6989, 7147, 1494, 6108, 7620, 7044, 9288, 9277, 6060, 3452, 4803, 4705, 2919, 1838, 2304, 1274, 7991, 1351, 3023, 7820, 3982, 9155, 4000, 5834, 3836, 3341, 8029, 3974, 5380, 86, 8976, 3534, 1459, 8148, 2578, 5, 879, 7904, 5212, 3857, 4172, 2468, 8411, 5562, 9201, 7737, 1522, 3898, 6106, 9237, 2095, 3134, 210, 343, 2497, 5968, 3278, 2372, 6506, 7329, 1914, 4764, 6731, 6363, 1692, 5686, 3426, 5997, 6289, 9624, 9226, 674, 9347, 9893, 143, 2564, 8311, 7033, 4054, 17, 4171, 5851, 9829, 3427, 363, 9588, 2030, 4787, 8653, 4221, 1095, 9065, 7826, 180, 9980, 2704, 5283, 9059, 900, 2655, 4555, 1966, 5631, 3635, 9630, 3228, 5729, 1105, 5328, 5435, 8487, 4385, 9009, 522, 2033, 5904, 9875, 9377, 4130, 3850, 9032, 7833, 9876, 8284, 3275, 2972, 1822, 8536, 4411, 9487, 7508, 4992, 4372, 6899, 2677, 5486, 5852, 4542, 8406, 2198, 6553, 6614, 8782, 8285, 7107, 4222, 8981, 3031, 5156, 8796, 9156, 6480, 1020, 263, 9287, 7009, 8807, 6264, 6616, 4113, 2039, 8258, 3945, 6995, 9600, 7111, 9567, 7344, 2270, 4394, 6053, 1345, 7122, 3005, 1627, 7173, 506, 9749, 2911, 9275, 8109, 3302, 7635, 5377, 8209, 9693, 136, 1515, 7339, 7197, 5757, 8297, 8962, 4673, 4017, 1464, 752, 2723, 1399, 8091, 1605, 933, 6638, 128, 9960, 8789, 8986, 7772, 6296, 3056, 2634, 61, 1094, 5050, 1974, 3938, 6827, 2866, 3494, 1953, 8000, 1811, 1554, 4426, 8125, 5049, 9076, 4232, 1130, 8139, 1228, 9759, 9856, 9629, 9549, 2870, 5700, 4999, 496, 8663, 1981, 8277, 6033, 385, 5674, 4898, 6717, 8427, 8928, 4002, 404, 2542, 6142, 9196, 29, 6773, 3822, 9517, 7712, 5591, 9217, 8508, 4677, 2495, 2314, 9499, 5099, 7156, 9994, 4220, 1227, 5912, 759, 9063, 9653, 9913, 5060, 8501, 6794, 8441, 2299, 3575, 6518, 1161, 7220, 439, 108, 5653, 7746, 430, 8144, 5549, 4752, 5663, 4780, 3846, 8019, 2534, 4080, 4577, 2658, 8155, 6583, 7449, 9489, 7661, 4359, 7643, 2898, 6777, 2217, 6117, 9531, 4986, 1063, 4689, 2977, 5677, 9680, 6236, 8397, 7413, 7012, 5774, 519, 1112, 7582, 8611, 3444, 6158, 9033, 7728, 9711, 7813, 7767, 8340, 2667, 8754, 2503, 6387, 2054, 104, 4353, 4129, 6144, 1400, 9665, 9835, 7396, 5803, 4356, 8603, 3057, 6189, 1513, 9455, 1245, 2605, 9194, 5062, 2947, 8295, 3684, 3252, 419, 3692, 6137, 3758, 1965, 2421, 1690, 9626, 977, 7700, 804, 6418, 8088, 4392, 3215, 5512, 6764, 6088, 3740, 3667, 717, 5543, 8401, 2940, 3284, 6846, 7735, 5753, 694, 8031, 9181, 3137, 2582, 1232, 7612, 2148, 9530, 3034, 2665, 5180, 8595, 6456, 6027, 9667, 5891, 3234, 9903, 9967, 5606, 2251, 8114, 8791, 2891, 7995, 7780, 7479, 2157, 2480, 85, 7842, 333, 8640, 4584, 9409, 3441, 3781, 8461, 5089, 8775, 7586, 5370, 7859, 4434, 7378, 9888, 7925, 303, 5538, 9145, 1536, 8591, 7852, 5716, 2955, 9879, 2412, 4509, 966, 9454, 4195, 920, 8173, 7249, 6379, 967, 1795, 5822, 713, 3477, 6100, 1357, 3578, 7021, 8158, 9408, 5308, 283, 2467, 8005, 459, 7604, 89, 3916, 1491, 3104, 4367, 251, 5433, 48, 5833, 3175, 452, 2643, 486, 9983, 7945, 7848, 3267, 6739, 8623, 2065, 1524, 4435, 7677, 6012, 4319, 1275, 4413, 1134, 9604, 7528, 3596, 706, 5490, 4128, 7941, 588, 4202, 8637, 9231, 3834, 8306, 7017, 2407, 7653, 1104, 912, 5268, 6879, 1574, 8348, 1779, 1979, 2641, 2787, 6637, 1872, 969, 2034, 6902, 8726, 4360, 6279, 6006, 8852, 3333, 8708, 1004, 2062, 3487, 3554, 6085, 523, 7978, 6127, 8205, 3679, 4836, 8097, 5738, 4287, 8188, 6972, 7388, 777, 8346, 4147, 4119, 5186, 4580, 2722, 170, 1862, 2833, 5020, 451, 1285, 7225, 6164, 4090, 2988, 1073, 3308, 482, 2623, 7497, 5919, 4994, 8325, 9095, 449, 1133, 2167, 3883, 6042, 193, 9010, 8684, 9559, 8619, 4646, 9078, 7489, 4310, 6536, 8122, 4632, 3932, 6469, 7128, 1586, 5534, 7304, 4282, 8867, 8301, 2473, 7353, 14, 9845, 9142, 3344, 9580, 5394, 497, 1860, 7437, 8790, 9904, 5355, 9075, 8703, 2181, 5509, 6423, 1353, 1545, 8105, 4627, 4335, 9393, 464, 6623, 7095, 2522, 2450, 6826, 6930, 6704, 7496, 6669, 956, 2871, 6078, 8808, 8130, 6766, 7751, 9229, 5005, 3515, 3622, 6726, 836, 5085, 7819, 2748, 272, 8676, 9881, 3460, 5793, 1832, 9791, 8162, 8469, 4851, 7389, 1808, 4102, 1553, 4524, 9020, 9783, 2637, 7501, 4761, 6449, 4883, 1739, 4241, 2702, 3255, 1556, 5389, 122, 2096, 9647, 720, 3440, 8488, 7793, 3766, 3250, 6339, 7172, 714, 6445, 119, 2073, 4590, 7067, 5442, 6258, 8700, 6411, 5016, 2005, 2689, 2185, 2427, 463, 8323, 3159, 7101, 1305, 4500, 5872, 490, 428, 4686, 914, 300, 3644, 4421, 3024, 8777, 2601, 7411, 190, 1043, 8438, 2064, 7131, 248, 7656, 6305, 4270, 6427, 9956, 9996, 3248, 1014, 9591, 3790, 815, 823, 6881, 6093, 4937, 7448, 9860, 6121, 5169, 3641, 6080, 3029, 8451, 4923, 4266, 2115, 1916, 7008, 7868, 3949, 386, 249, 7264, 6208, 5161, 1242, 6587, 8429, 201, 2583, 847, 1863, 1258, 2846, 2984, 1237, 2892, 5423, 9305, 7455, 3829, 8318, 1629, 4588, 8643, 3081, 3892, 9663, 1989, 9661, 9730, 4048, 3973, 3739, 274, 9922, 1049, 8727, 8126, 5172, 9984, 10000, 2922, 23, 6307, 2651, 2882, 6404, 556, 4056, 4076, 2106, 9544, 4711, 5110, 5329, 1102, 1883, 8544, 4021, 2107, 3359, 8913, 9777, 7328, 760, 7088, 5079, 2246, 6067, 7148, 5093, 8369, 4681, 1203, 9637, 2112, 7165, 8073, 2526, 9775, 7570, 8146, 1067, 9772, 16, 4974, 5935, 3871, 7562, 9151, 5536, 654, 1024, 9067, 7851, 6913, 8308, 4600, 930, 5965, 9401, 123, 9656, 2262, 2400, 7185, 6562, 1620, 7992, 4862, 4364, 5599, 6032, 8846, 7533, 243, 9025, 3010, 4137, 3123, 1251, 2219, 9070, 2538, 3315, 4683, 1691, 5846, 6203, 814, 8939, 5104, 1848, 5945, 2697, 788, 7651, 1381, 9035, 1483, 2149, 7472, 231, 9459, 8744, 1484, 9278, 4458, 1774, 8156, 8551, 4338, 3059, 5253, 5307, 7754, 730, 885, 9744, 3179, 9882, 6373, 7946, 1069, 4925, 1328, 3563, 3999, 4334, 3597, 1262, 7273, 8850, 9554, 535, 4493, 3893, 845, 7359, 3092, 4400, 7221, 9320, 2952, 3378, 7368, 4560, 1731, 4663, 3128, 698, 2075, 6391, 1170, 1693, 7007, 2116, 4174, 6184, 7951, 853, 2541, 6733, 3572, 4583, 3902, 4513, 5314, 5694, 3404, 1077, 9372, 7726, 5961, 2090, 7093, 2243, 9546, 1041, 7138, 958, 3755, 7085, 3887, 3282, 5979, 3998, 919, 6046, 222, 4839, 8779, 6907, 8889, 1928, 2444, 2754, 2491, 3979, 9928, 7121, 8013, 6955, 1745, 4079, 132, 6040, 7029, 8662, 8282, 5692, 1312, 9488, 2902, 4154, 9522, 9049, 3804, 1414, 7928, 925, 1753, 6759, 6636, 6577, 3708, 9191, 2532, 9798, 736, 1417, 2539, 8446, 4808, 6624, 8646, 3400, 9722, 2942, 3985, 1055, 8462, 9253, 2377, 7912, 355, 5892, 794, 2901, 3958, 6950, 4114, 6298, 8455, 2672, 5754, 1225, 6024, 1125, 4265, 8529, 2743, 9478, 6526, 3886, 2046, 3063, 4405, 9364, 8874, 4904, 5291, 8443, 4622, 8498, 3786, 1762, 1325, 2810, 3108, 5494, 5401, 1455, 6483, 8879, 6649, 4217, 8345, 437, 2709, 2864, 4151, 3192, 7266, 5802, 162, 7190, 953, 1165, 7100, 1547, 1501, 1589, 5723, 3672, 90, 986, 3001, 4225, 638, 5690, 4297, 3294, 793, 1649, 7155, 234, 1521, 2771, 630, 9748, 3514, 9103, 3053, 9675, 6384, 7913, 8177, 6528, 9861, 7932, 8705, 2197, 9605, 144, 678, 223, 352, 1346, 8922, 4856, 9129, 8681, 4486, 565, 131, 3598, 6529, 4914, 3651, 8270, 840, 9214, 3417, 6120, 3714, 8116, 9141, 2624, 3382, 8121, 9833, 281, 1531, 1298, 6645, 6621, 295, 5594, 470, 9391, 393, 319, 9086, 5223, 4523, 9802, 7782, 6385, 1188, 4208, 9839, 7747, 164, 7902, 9183, 6061, 6655, 6954, 8711, 3124, 9874, 5384, 492, 7170, 6803, 1172, 3296, 3070, 5460, 9939, 3551, 5461, 6330, 7943, 9117, 4798, 6057, 5437, 8424, 4959, 6475, 4246, 5201, 9072, 7762, 4482, 3543, 8241, 5990, 2716, 2650, 2570, 8691, 7255, 3390, 4526, 2968, 8339, 3996, 9463, 9492, 9346, 494, 2937, 8936, 9727, 1289, 9963, 7636, 5932, 3716, 4709, 2884, 7738, 7465, 738, 4956, 7114, 7569, 6134, 9931, 6689, 9248, 372, 9932, 228, 2904, 4637, 7663, 8641, 3991, 6517, 6687, 2949, 7958, 6984, 1498, 1486, 6410, 7594, 1430, 8988, 7369, 2162, 7164, 3665, 9038, 8143, 6234, 3655, 6854, 7781, 2545, 7811, 9113, 5106, 2381, 4900, 7514, 6961, 79, 1051, 8910, 5428, 1462, 177, 4281, 8217, 58, 734, 9962, 3815, 7052, 7267, 5424, 6882, 2793, 5294, 8847, 1327, 8839, 4907, 9767, 209, 6048, 4087, 3346, 4567, 8864, 2521, 3842, 1564, 4671, 7196, 3353, 9989, 120, 3573, 2103, 8363, 316, 5245, 4451, 9014, 6001, 289, 512, 9110, 6124, 1741, 3776, 918, 8904, 2631, 4864, 3291, 1701, 6286, 5124, 9846, 5069, 3317, 6451, 5174, 5399, 7591, 2447, 8278, 3280, 6470, 935, 6291, 7707, 4190, 7742, 1770, 7034, 6992, 8030, 6089, 6482, 1155, 4100, 1085, 5198, 608, 6630, 7548, 5171, 7891, 7382, 3348, 6095, 9264, 8561, 9244, 5777, 2897, 6660, 5675, 275, 1366, 9971, 2153, 1876, 4892, 4108, 679, 8131, 6824, 2191, 902, 5625, 3517, 6962, 73, 2757, 317, 2854, 5511, 8085, 8290, 8926, 1798, 4775, 6864, 7392, 881, 6452, 8333, 9212, 4796, 4159, 3726, 7518, 1206, 1224, 6617, 6894, 7237, 946, 3349, 4639, 6272, 6880, 633, 7271, 9373, 3430, 3259, 9297, 5840, 6910, 2686, 8877, 6836, 5266, 8993, 9997, 5175, 2184, 5837, 6045, 8710, 2520, 4444, 2744, 7691, 6224, 4517, 559, 803, 7908, 6143, 6976, 1828, 1902, 3339, 5026, 3685, 911, 5954, 745, 8908, 7937, 2626, 4769, 5985, 3653, 5035, 4511, 9500, 6428, 7040, 235, 5255, 5600, 4746, 5576, 5839, 7834, 1246, 5886, 6123, 2147, 4369, 7011, 2954, 2445, 7316, 2960, 5756, 5734, 2861, 5617, 9687, 6734, 570, 7486, 7893, 6654, 8359, 3727, 4630, 8260, 2029, 9331, 8559, 8799, 6610, 8190, 1162, 8283, 5878, 6415, 3964, 8248, 7209, 4773, 2853, 4077, 8862, 1771, 1845, 5922, 2048, 4184, 7575, 4156, 1873, 5108, 1339, 1546, 1711, 8006, 8486, 1006, 9333, 6548, 4666, 8812, 481, 828, 4846, 7513, 1754, 3994, 3888, 6725, 9619, 1090, 2249, 974, 4535, 6282, 4702, 2696, 5870, 3298, 2837, 330, 3861, 7784, 60, 710, 8920, 3772, 1146, 2991, 2069, 3864, 5187, 4277, 6364, 719, 1962, 2476, 7150, 5746, 5346, 4979, 5257, 4628, 6244, 5134, 138, 1416, 4706, 5650, 6823, 5823, 273, 7206, 2989, 1120, 5190, 2050, 1716, 7829, 3105, 2640, 4826, 4044, 5604, 1436, 1437, 9889, 615, 7563, 8261, 6566, 2678, 4393, 5976, 4549, 8145, 2992, 9644, 6393, 1750, 5219, 1539, 4030, 9509, 8222, 4285, 7999, 3827, 3959, 7192, 3947, 313, 9854, 7103, 7704, 827, 1065, 2573, 6328, 2587, 6065, 8564, 9410, 7698, 1540, 2574, 1823, 7523, 6179, 6342, 8697, 5750, 597, 4658, 1333, 2019, 8069, 9386, 7137, 9694, 3673, 9607, 2008, 9088, 1571, 5854, 2328, 3397, 7293, 957, 4494, 5882, 6319, 6979, 586, 291, 1708, 9681, 3565, 6388, 2980, 9479, 9885, 3513, 7348, 1201, 8271, 6747, 1395, 8517, 6113, 9641, 4712, 5513, 279, 3120, 6191, 7543, 3856, 8788, 30, 4067, 6782, 5485, 3701, 8935, 1673, 7341, 7057, 682, 2376, 5019, 3501, 4833, 1373, 8113, 4781, 8548, 4895, 320, 7862, 301, 7420, 1604, 1377, 3877, 4247, 3882, 1359, 4779, 2173, 6819, 8016, 7710, 3957, 462, 2139, 998, 9976, 756, 7686, 7749, 8075, 724, 56, 2735, 2883, 4489, 4886, 4623, 4522, 5881, 7390, 6425, 8975, 9370, 2535, 4484, 6831, 1986, 7314, 601, 6559, 9961, 8794, 5256, 4610, 1392, 9001, 6462, 2690, 1451, 2490, 6287, 6758, 577, 5075, 3289, 5007, 7473, 8495, 2616, 4848, 1445, 5937, 2908, 781, 7580, 5555, 1129, 1573, 4556, 5751, 6772, 326, 3088, 8159, 1256, 8128, 2420, 882, 6671, 3642, 8115, 2528, 9840, 611, 135, 2606, 5831, 2953, 4322, 3249, 7794, 669, 3900, 9721, 4727, 4053, 549, 5038, 5740, 4257, 7619, 8344, 5496, 9606, 1769, 377, 1412, 3862, 4042, 4916, 4093, 8327, 5643, 2047, 6601, 2264, 3374, 9941, 7894, 6092, 8905, 4180, 6838, 6802, 2340, 4797, 5345, 1382, 1897, 9809, 111, 3845, 1626, 9548, 9765, 3015, 1434, 9926, 8929, 5455, 5481, 2060, 3148, 147, 9344, 5957, 1266, 4828, 4938, 6356, 2669, 6684, 9043, 7798, 6346, 9784, 9132, 4236, 1280, 8355, 7195, 1438, 7959, 3750, 2378, 7484, 3265, 3841, 7084, 9310, 4739, 6818, 6862, 4142, 4031, 4120, 4377, 4481, 2174, 314, 8066, 6101, 8108, 5728, 3582, 8276, 4853, 4906, 7030, 5014, 8118, 557, 6326, 9585, 6952, 5366, 2385, 421, 6703, 5647, 9249, 604, 3539, 6953, 5387, 5627, 5898, 8899, 7098, 846, 9357, 4386, 5226, 7345, 1217, 6593, 937, 9376, 9284, 4578, 7123, 3008, 8512, 528, 2188, 71, 4635, 551, 6237, 3699, 3504, 145, 843, 9424, 5376, 8422, 9796, 1122, 3324, 34, 6255, 9715, 3189, 4289, 2936, 1385, 5703, 6999, 6798, 9268, 4537, 9739, 826, 5232, 8230, 1648, 4313, 944, 7142, 852, 7555, 4734, 2844, 5216, 3710, 7079, 9304, 9664, 3240, 9915, 2081, 4082, 6038, 1817, 2978, 7376, 2353, 1799, 9596, 4034, 3970, 8238, 4418, 8253, 927, 8876, 4642, 3482, 3331, 2797, 3271, 2920, 9633, 1433, 2449, 3438, 7866, 7593, 3484, 8196, 7286, 8003, 1113, 3097, 8693, 1187, 9120, 5321, 3109, 2990, 4909, 4823, 3663, 8661, 5097, 8264, 2117, 7689, 7106, 6888, 7397, 8227, 8095, 2888, 8639, 8047, 5264, 4320, 5422, 5464, 8291, 4219, 810, 5241, 4025, 7118, 3387, 8660, 6585, 9480, 4648, 5453, 6223, 941, 6321, 3260, 6991, 1713, 83, 3688, 5785, 4216, 9172, 4955, 2950, 4293, 1271, 2042, 983, 690, 2442, 7212, 198, 4998, 1867, 7183, 2482, 5136, 2089, 5913, 8245, 7313, 3809, 1804, 3760, 467, 3196, 4196, 1784, 8632, 9162, 321, 7600, 8533, 6629, 6170, 9843, 5434, 4970, 2903, 495, 2805, 6003, 2923, 6318, 5546, 8237, 4467, 1250, 3733, 9387, 6658, 5356, 8475, 3989, 4952, 8506, 5417, 4432, 1472, 5324, 7311, 1991, 364, 1653, 7910, 9100, 432, 92, 8967, 6675, 6908, 9917, 4894, 2383, 5612, 9398, 2214, 4912, 4552, 6163, 6511, 3522, 6421, 4713, 2001, 5459, 8056, 2082, 4272, 4902, 5648, 3948, 4271, 4462, 6355, 3067, 4569, 4529, 2546, 1915, 9801, 585, 2230, 6640, 171, 3986, 1717, 9062, 3318, 7949, 9283, 9723, 6500, 6037, 2118, 9593, 1684, 7607, 2530, 329, 637, 533, 2736, 6699, 5353, 6565, 526, 5921, 2694, 1973, 5148, 3236, 6424, 8202, 7777, 1756, 9119, 683, 9335, 7655, 4978, 3530, 9785, 1621, 9354, 4446, 2857, 1363, 2525, 2009, 3065, 4905, 9870, 598, 693, 7736, 4936, 4036, 7051, 4949, 5586, 6743, 875, 4150, 3048, 6719, 1288, 5178, 8887, 2434, 785, 3377, 5368, 1254, 6715, 7667, 9507, 854, 8435, 3121, 6090, 2481, 4237, 3449, 7674, 9812, 6515, 8099, 8314, 1558, 7733, 7965, 8707, 4704, 9101, 3389, 8606, 4380, 7675, 7036, 6017, 9696, 8884, 3066, 8046, 3433, 4052, 4349, 5018, 1329, 4424, 8869, 9252, 2092, 3774, 1176, 5222, 3680, 1422, 5109, 3174, 4948, 51, 542, 4215, 6770, 4527, 7787, 7783, 9729, 5996, 8267, 213, 1220, 4579, 5581, 3978, 9469, 8110, 1568, 6365, 6401, 5262, 8343, 2433, 98, 5332, 117, 5986, 7837, 7519, 2648, 9497, 5733, 8474, 7430, 5811, 9381, 4070, 2301, 4731, 3044, 9250, 5936, 2826, 1852, 587, 2424, 2756, 3172, 8553, 5444, 5520, 6769, 6096, 8218, 6344, 9993, 9689, 3465, 1308, 9362, 1072, 5743, 8740, 6198, 3032, 6592, 474, 1034, 1801, 5059, 6112, 4278, 4737, 6609, 4722, 3033, 537, 2932, 8758, 2317, 6467, 3210, 6857, 2720, 1723, 1742, 6434, 2703, 9652, 7926, 4260, 9323, 6254, 4990, 1519, 9695, 3801, 1045, 5863, 3167, 327, 5470, 5213, 1715, 5529, 1802, 5419, 3873, 3521, 9569, 2329, 2360, 9146, 3920, 709, 4687, 5003, 9259, 4111, 9614, 241, 4945, 7005, 5507, 1198, 7832, 9460, 640, 723, 7129, 3631, 7640, 5632, 3431, 1968, 1667, 7847, 5381, 6690, 1169, 9496, 4098, 5929, 6634, 4614, 773, 5817, 9572, 5402, 8649, 115, 414, 3768, 2768, 9692, 563, 5466, 191, 8871, 9414, 1071, 204, 8873, 3988, 5184, 2292, 9152, 2813, 9204, 3170, 5231, 6933, 7622, 894, 1923, 2959, 1081, 1425, 1566, 5015, 1109, 3071, 8409, 3223, 6713, 9648, 8445, 3357, 4859, 2518, 5535, 2817, 742, 49, 3895, 8680, 1171, 2682, 6676, 5100, 3706, 4361, 6641, 2267, 8161, 502, 1402, 1809, 7730, 4252, 3235, 3643, 44, 3393, 6304, 5443, 5076, 1076, 3587, 6793, 1786, 5516, 4696, 4127, 4652, 6781, 8844, 1834, 4757, 4745, 8172, 9933, 5975, 5141, 9618, 3785, 8059, 2929, 6885, 2454, 8938, 5640, 9037, 6934, 7340, 4354, 1869, 7075, 8112, 5877, 7714, 3456, 7553, 3495, 5095, 7277, 9714, 8747, 8590, 3327, 175, 134, 9505, 795, 6493, 3753, 5244, 3544, 4516, 4543, 6337, 7039, 1541, 5502, 4327, 7276, 6136, 3825, 5720, 1645, 5911, 5495, 4192, 3866, 1244, 5023, 9084, 4770, 7091, 6780, 8597, 9658, 975, 8332, 6589, 1449, 6683, 708, 5151, 643, 7774, 7238, 5410, 466, 413, 507, 9392, 3469, 818, 229, 9899, 7940, 4276, 5036, 7681, 7291, 5127, 4103, 2022, 548, 8563, 101, 6441, 5403, 3445, 676, 2163, 4468, 7319, 561, 1096, 2568, 8599, 4929, 5153, 6357, 5579, 7331, 165, 7795, 1829, 9316, 1615, 9238, 5810, 7682, 309, 9690, 2847, 8645, 8505, 8739, 2547, 7023, 7006, 4885, 6524, 8762, 8252, 6116, 2254, 8511, 7850, 8854, 7415, 4200, 8978, 6009, 6259, 6366, 70, 5796, 7509, 2324, 8228, 1216, 2370, 9810, 2045, 1097, 5317, 5297, 8569, 3592, 199, 7153, 1504, 2023, 5298, 1334, 7350, 9102, 6231, 5067, 9494, 7078, 5083, 767, 6233, 5225, 7836, 6193, 7993, 3074, 5915, 6407, 8946, 9324, 4946, 9267, 9367, 1737, 7297, 2789, 7890, 4138, 9260, 172, 4375, 4456, 7071, 4520, 8123, 1379, 7642, 3921, 6915, 5843, 8593, 6448, 9467, 511, 9536, 6944, 3927, 4659, 9449, 6578, 4651, 6331, 7117, 5825, 5634, 7808, 480, 1939, 7076, 8974, 1582, 5862, 2310, 3212, 6079, 8960, 9402, 127, 770, 7881, 4794, 2660, 2425, 8524, 2586, 9954, 2513, 1490, 9622, 7140, 9901, 4847, 9868, 2576, 5374, 3715, 6464, 2644, 9089, 9597, 1551, 4397, 1314, 8247, 5330, 9601, 3488, 627, 9131, 4143, 878, 4598, 76, 3347, 3744, 9216, 5128, 1393, 2619, 1195, 3562, 2345, 5528, 5951, 8117, 9789, 3373, 1338, 7306, 6332, 4649, 3505, 7883, 2914, 8141, 9898, 3116, 7573, 5819, 7963, 4088, 3594, 8106, 5045, 4290, 6935, 4557, 8745, 7948, 276, 1730, 8664, 8916, 2798, 7228, 9, 1656, 1375, 6459, 7451, 2956, 1746, 6945, 408, 5896, 6611, 8055, 6316, 1335, 2239, 1964, 5145, 8472, 4597, 7857, 340, 4564, 4304, 7065, 221, 6997, 5042, 9821, 6590, 1150, 6292, 3350, 4091, 4534, 1027, 778, 8180, 1956, 6891, 9417, 8957, 6073, 2783, 4465, 2306, 9221, 9732, 4676, 7403, 6402, 8402, 6795, 8342, 5061, 9712, 6238, 6618, 9440, 6848, 9123, 8963, 7043, 2336, 3332, 1984, 5220, 6497, 9645, 2477, 1700, 4880, 1164, 6748, 9720, 981, 9136, 4012, 3473, 2379, 868, 1819, 3408, 915, 8804, 663, 5584, 5414, 621, 726, 3211, 1461, 9178, 849, 3285, 4214, 931, 2759, 3612, 2349, 1320, 8856, 5072, 185, 7, 1994, 8077, 1413, 6702, 8213, 9081, 6152, 2728, 2760, 1511, 6066, 43, 7662, 2216, 9453, 867, 2375, 8815, 6988, 6130, 8746, 607, 4790, 1447, 6839, 8376, 1142, 4106, 3095, 2700, 4811, 5052, 2038, 2457, 3224, 5159, 2419, 4665, 2879, 2730, 8666, 7384, 892, 6397, 6077, 8459, 5261, 2469, 3868, 1240, 1349, 5323, 1093, 9852, 7511, 1641, 6858, 7803, 5544, 4288, 8932, 8303, 1839, 3122, 40, 6271, 2293, 5948, 1831, 5267, 9083, 5066, 8050, 9896, 5041, 9603, 6742, 6817, 1127, 4812, 8931, 35, 5040, 5726, 929, 1881, 7716, 7294, 4040, 3195, 2462, 3817, 2339, 6478, 834, 353, 2998, 3303, 4121, 3043, 1226, 7200, 28, 426, 9640, 1007, 2514, 4863, 3912, 1098, 6075, 702, 5406, 3176, 3386, 4865, 4141, 5471, 6215, 9482, 9465, 6377, 7907, 1997, 305, 3838, 2533, 7638, 2088, 2175, 6523, 7817, 7802, 9586, 4230, 6369, 3411, 6406, 9995, 9855, 2007, 9955, 6751, 546, 5369, 6409, 9942, 3935, 4633, 748, 3557, 5203, 5195, 5504, 5809, 351, 1760, 362, 3263, 8400, 3035, 4033, 9097, 1229, 1942, 8574, 5500, 187, 5775, 2212, 8523, 8896, 8060, 5759, 8964, 1444, 5981, 4258, 382, 5801, 1906, 4420, 8822, 9064, 3764, 8798, 3453, 8685, 3696, 5610, 4751, 1816, 2102, 9828, 2097, 1764, 3422, 3306, 603, 8233, 4697, 195, 5952, 2471, 6920, 4039, 9819, 184, 2365, 6707, 36, 3429, 661, 299, 1424, 9602, 6494, 9716, 2114, 7469, 9999, 4678, 6133, 341, 9847, 9916, 1168, 7202, 8182, 410, 4795, 2238, 417, 1924, 1411, 6023, 1685, 5146, 149, 5363, 1694, 6169, 9292, 3778, 9817, 3605, 1200, 6338, 9818, 3867, 2183, 9209, 1612, 936, 9429, 4004, 182, 9686, 722, 2802, 9615, 2886, 833, 8900, 242, 2707, 5902, 2766, 8915, 9858, 7994, 8781, 1238, 4870, 2591, 5065, 2895, 9342, 4177, 8677, 2268, 7478, 4051, 4073, 758, 4877, 3299, 6861, 6833, 4309, 1980, 5649, 2657, 8104, 1388, 3953, 5722, 9864, 7639, 5590, 5666, 7564, 7194, 2653, 1987, 8212, 895, 8497, 1532, 9243, 6437, 7499, 498, 5678, 7532, 9074, 8500, 5497, 7256, 1614, 9018, 3879, 8768, 5215, 5395, 2374, 7931, 137, 9806, 7654, 3820, 7210, 9683, 3007, 9708, 8028, 3780, 4477, 5498, 7235, 2453, 9394, 3931, 3617, 6753, 9776, 1535, 6828, 9126, 4533, 3863, 2976, 7018, 1920, 645, 5284, 9291, 7296, 7936, 3358, 9099, 819, 1270, 8476, 5781, 9532, 4145, 424, 9276, 4755, 5991, 5396, 5765, 7133, 9912, 5602, 8377, 6668, 5227, 886, 9468, 1954, 2343, 6723, 5959, 3529, 2446, 5755, 5815, 2043, 2100, 4546, 1601, 9211, 2344, 9002, 1812, 5978, 1001, 3217, 5580, 3869, 3320, 9345, 4223, 9754, 380, 9473, 4069, 3290, 5139, 6370, 2584, 5416, 8094, 8467, 4314, 406, 3674, 1278, 446, 4698, 2213, 2818, 8950, 2969, 8674, 6815, 403, 3742, 6521, 6993, 6270, 8838, 9535, 8810, 9092, 9877, 5125, 9707, 9210, 8656, 8191, 2387, 1110, 3502, 3158, 3051, 7399, 5615, 9782, 4262, 8973, 5887, 9660, 6681, 2579, 668, 5335, 1594, 4115, 7080, 5679, 5707, 3767, 9130, 6696, 9365, 8320, 5426, 1841, 8542, 9317, 5652, 5893, 8221, 7401, 4204, 4008, 2352, 3127, 6492, 7708, 5542, 3325, 4408, 7436, 991, 3219, 3634, 2581, 5086, 4629, 2973, 3621, 383, 6399, 8043, 1555, 4714, 155, 2867, 7695, 560, 8351, 1699, 716, 8353, 8380, 4209, 3161, 4280, 3183, 1481, 575, 2346, 1196, 1347, 7402, 7483, 5714, 9814, 1475, 7324, 3277, 268, 5541, 1695, 3216, 5405, 7234, 8391, 9125, 4101, 6571, 896, 619, 3222, 8621, 3523, 9080, 9880, 7872, 842, 287, 8642, 6767, 3083, 2356, 8688, 3380, 8229, 3061, 1213, 5469, 1590, 3788, 9180, 6875, 3639, 9642, 1562, 6503, 9114, 3499, 3366, 9737, 7658, 2200, 7481, 8315, 192, 1408, 9182, 3636, 3960, 6941, 8071, 6474, 905, 9701, 6867, 7849, 9897, 4191, 5354, 7650, 152, 2240, 1221, 3908, 4813, 4841, 9306, 3782, 9636, 1173, 9403, 4063, 8490, 1704, 8503, 3336, 4234, 901, 5235, 9930, 2733, 2724, 4318, 4954, 8017, 4784, 4188, 2681, 4058, 8313, 4389, 7884, 4229, 3178, 761, 1038, 6943, 1990, 4041, 2393, 8185, 8947, 2018, 5499, 4284, 9484, 4920, 6787, 4989, 2524, 6789, 4601, 1722, 6367, 772, 8240, 7174, 1066, 9940, 1025, 5736, 1218, 2289, 3207, 8199, 5611, 3831, 2831, 2849, 9947, 8183, 479, 589, 863, 7127, 4344, 3012, 2408, 2, 392, 807, 427, 3848, 3413, 5662, 8753, 7853, 9797, 8919, 3924, 5601, 2543, 3270, 3538, 6248, 1985, 8980, 4680, 9369, 2382, 5456, 6394, 6776, 3113, 4726, 8395, 4362, 7409, 1609, 8265, 3419, 9121, 1636, 7672, 7494, 5983, 8965, 2994, 979, 9724, 7229, 9116, 3182, 9639, 768, 8795, 6426, 397, 6131, 2963, 2499, 8749, 1679, 1733, 5661, 9550, 8927, 4810, 6129, 4243, 4849, 6177, 889, 2559, 6673, 9657, 5027, 9563, 2347, 5830, 3368, 7227, 1313, 1613, 1780, 8622, 7761, 8582, 4827, 3794, 1292, 9892, 8811, 6516, 5209, 8530, 7572, 7335, 6911, 9627, 3371, 9747, 8447, 491, 4476, 1886, 7233, 6153, 7585, 2997, 4538, 1765, 4536, 945, 8759, 7130, 2493, 5532, 8821, 4075, 174, 9824, 9643, 2780, 3629, 6020, 7092, 2964, 2806, 4631, 453, 2893, 4799, 4592, 2456, 5303, 7923, 2015, 1624, 6662, 8806, 9978, 2529, 6268, 7905, 684, 3075, 5409, 5382, 476, 8024, 4384, 5091, 3485, 1892, 670, 9682, 8771, 8686, 9166, 8244, 2856, 440, 6509, 4161, 9632, 8678, 780, 3574, 5024, 9495, 6197, 5188, 1854, 7874, 9571, 7050, 7367, 8507, 1005, 8906, 9011, 8470, 4442, 258, 5665, 5176, 3330, 3439, 6705, 6513, 339, 8305, 7038, 9974, 3396, 3904, 5715, 7985, 4416, 6887, 2309, 3003, 9493, 6598, 602, 8392, 1310, 217, 5807, 8618, 5008, 4871, 3890, 6329, 3980, 8718, 5533, 3874, 3115, 980, 6546, 4573, 2348, 9104, 4176, 6810, 6564, 5903, 1360, 1421, 1719, 2777, 2413, 9811, 9475, 387, 8347, 2825, 2279, 943, 1675, 5767, 897, 1662, 802, 8894, 6216, 4574, 4417, 5637, 5727, 3414, 402, 2625, 3677, 5373, 5475, 5167, 4203, 5688, 6115, 9350, 4568, 2035, 4596, 2500, 5217, 3558, 1156, 9575, 47, 8067, 4987, 791, 2553, 3340, 9185, 584, 5972, 1010, 5259, 3117, 9662, 7380, 4275, 5642, 1177, 6926, 6188, 4479, 1128, 4099, 2272, 2078, 8167, 1044, 1350, 1608, 7485, 1147, 5778, 6405, 4604, 1657, 5137, 1978, 4515, 9763, 2466, 2869, 1279, 9303, 6002, 1235, 970, 9649, 9285, 3854, 5824, 2101, 2218, 6218, 151, 9565, 8868, 2355, 4684, 8702, 2993, 4292, 3711, 4140, 1276, 2638, 8350, 9986, 6698, 1654, 525, 6522, 9991, 7748, 2172, 1505, 1789, 9171, 5874, 4541, 1644, 6807, 9825, 8178, 5510, 4991, 3741, 9069, 6567, 396, 3689, 6059, 3030, 8897, 7037, 9021, 3140, 2674, 2841, 179, 9109, 483, 4371, 7966, 7361, 5087, 2839, 4464, 9742, 8911, 2594, 8480, 1306, 8870, 4471, 5001, 8256, 3360, 8052, 513, 4595, 7292, 6261, 5135, 7550, 4383, 8471, 7393, 8134, 8712, 3041, 2275, 8875, 6535, 9143, 1015, 9150, 3789, 7521, 9233, 5010, 5660, 3434, 3552, 8577, 1118, 9328, 5163, 6028, 1452, 1499, 6729, 4710, 1888, 2848, 2210, 7919, 8592, 7211, 2835, 8567, 3773, 2572, 1234, 7529, 3194, 9869, 7671, 6062, 7336, 5871, 1466, 9813, 2327, 2622, 636, 2366, 7627, 8765, 7685, 4028, 6909, 3899, 2512, 9003, 2928, 2285, 3743, 8752, 3455, 266, 7333, 8181, 6688, 2109, 3730, 4436, 2939, 7741, 9472, 8437, 3561, 9308, 6552, 7284, 3147, 4267, 3080, 8246, 4089, 2712, 1523, 4316, 9322, 230, 6200, 9762, 6162, 3493, 9634, 7800, 8491, 4109, 3244, 2263, 9030, 9219, 7167, 6644, 8514, 5800, 4428, 8404, 3028, 2296, 4224, 381, 181, 9430, 7601, 7132, 1744, 1300, 5472, 8824, 8307, 2721, 2232, 2351, 2611, 4164, 583, 5995, 9458, 1348, 2452, 8694, 8268, 1376, 2228, 2012, 2785, 2142, 6771, 2659, 2125, 3870, 6510, 409, 6010, 7342, 9685, 3930, 7282, 2764, 9140, 6450, 112, 9519, 1776, 7768, 6600, 6633, 3559, 5114, 5094, 1082, 7752, 1646, 9265, 9241, 2633, 129, 19, 2916, 9617, 1724, 8880, 7757, 6151, 8368, 7970, 7637, 961, 839, 9207, 4933, 4694, 7723, 7865, 2554, 8135, 1495, 1548, 2488, 78, 3464, 2507, 4972, 9581, 5889, 7693, 7158, 4009, 5731, 5082, 4399, 3002, 3193, 6549, 8918, 9426, 6672, 8082, 3466, 3584, 6596, 6102, 2151, 3086, 4809, 1011, 5412, 1423, 8695, 7446, 9274, 9998, 4072, 4924, 6757, 1891, 1787, 2087, 9270, 2742, 1899, 5319, 9651, 2067, 7357, 7967, 5142, 9498, 4553, 4838, 1440, 3527, 1301, 8001, 8309, 3401, 8426, 5452, 6360, 1075, 3391, 5116, 5205, 2192, 3151, 4691, 2290, 6544, 189, 9700, 7061, 7338, 5463, 7073, 4422, 4273, 7727, 308, 1671, 1032, 3553, 297, 5884, 5411, 5713, 9865, 4551, 9985, 2072, 8251, 3379, 1205, 1975, 9071, 8009, 4125, 4521, 520, 7016, 8776, 3832, 7527, 2930, 1197, 503, 4132, 2614, 5567, 9399, 8654, 2675, 5682, 2111, 6206, 865, 3851, 9302, 9176, 6047, 871, 6830, 2874, 7785, 5400, 9443, 6940, 4661, 4181, 4238, 7566, 7950, 8124, 7053, 6362, 6146, 2487, 7418, 8039, 2905, 9523, 6841, 9236, 4837, 5832, 1040, 5122, 5378, 8419, 4055, 8473, 7146, 1439, 6918, 1936, 744, 8012, 2715, 5193, 8696, 1600, 3, 6213, 4085, 4586, 6541, 4926, 7182, 1253, 1982, 6473, 9239, 7756, 3006, 7323, 458, 7976, 9326, 8628, 4778, 2628, 3872, 5233, 8715, 7590, 6837, 3155, 163, 7887, 5211, 582, 8832, 3026, 7299, 6784, 5025, 5311, 2958, 9973, 7541, 8716, 3483, 1635, 8598, 6323, 6276, 5890, 7179, 6082, 5966, 7189, 1938, 3915, 6039, 8080, 7458, 5741, 5588, 7230, 9610, 2196, 9975, 5998, 5651, 1999, 8133, 4328, 5425, 1996, 4884, 5931, 411, 4817, 3009, 2320, 6812, 197, 8263, 7664, 9780, 8272, 1158, 4419, 4123, 302, 7274, 232, 2124, 3407, 9936, 5306, 4218, 6597, 2165, 9766, 8354, 7863, 9199, 7186, 1592, 8090, 8176, 5780, 5697, 8296, 2403, 6847, 3721, 5559, 6533, 7892, 5636, 860, 9461, 9079, 5880, 3885, 1577, 4519, 6900, 7462, 3154, 2900, 2358, 311, 8955, 4776, 267, 7094, 9450, 9024, 8687, 9793, 3392, 6575, 6829, 4563, 9598, 7835, 7657, 5696, 2617, 1738, 2699, 964, 8809, 1369, 4716, 1836, 1372, 4018, 9970, 2855, 1012, 5322, 45, 2531, 510, 4487, 8242, 8129, 9577, 3242, 1016, 6584, 9918, 2850, 4657, 2364, 9541, 9405, 3011, 1661, 8912, 1336, 4003, 508, 8448, 704, 8165, 9058, 3019, 7581, 2822, 6253, 4832, 3322, 5265, 4105, 4374, 9589, 3171, 1309, 4736, 5947, 1937, 3936, 9167, 6502, 9224, 7515, 6573, 1683, 9650, 6682, 1343, 3313, 3823, 1493, 5479, 4685, 3478, 4561, 2762, 8298, 995, 9863, 6755, 3474, 940, 8883, 4875, 5031, 7939, 8738, 8434, 3239, 4602, 1759, 9050, 5484, 2080, 7719, 342, 2143, 2873, 7680, 8570, 6967, 8412, 924, 1932, 3993, 3581, 2040, 558, 9134, 7632, 3693, 6438, 3738, 3723, 9419, 543, 3965, 4038, 2746, 3321, 6968, 7531, 38, 9914, 7792, 4867, 493, 4332, 3751, 1850, 4753, 5057, 1857, 5199, 8831, 9296, 6091, 8888, 4724, 6783, 3911, 7844, 2363, 9503, 7634, 50, 5667, 8886, 4941, 3079, 9280, 8892, 9441, 3039, 4690, 8431, 1121, 8584, 9477, 6582, 7885, 7447, 5185, 6297, 7002, 9570, 6620, 7207, 6241, 4771, 4438, 707, 8994, 2322, 9334, 7014, 2999, 2600, 5252, 3141, 9349, 261, 5028, 8985, 1926, 6074, 8651, 2439, 6560, 25, 1405, 1597, 8737, 7588, 7603, 8956, 9795, 1859, 2781, 5557, 4576, 2126, 3184, 9208, 8914, 2852, 1772, 7797, 7187, 5011, 6049, 7126, 9470, 7973, 257, 8722, 7463, 8829, 1039, 4983, 7525, 1748, 1927, 8204, 384, 5768, 4963, 1660, 5234, 9179, 2384, 3479, 2814, 335, 7303, 7428, 3619, 4718, 8289, 64, 8107, 7125, 6897, 6813, 7410, 4317, 6419, 2492, 4346, 7269, 8274, 6898, 1370, 4131, 3662, 6706, 538, 4321, 7265, 1763, 5829, 2057, 4158, 3365, 4701, 2597, 5695, 3569, 6005, 8786, 1145, 7899, 7720, 2592, 399, 4939, 7980, 7157, 9380, 8520, 5923, 6948, 3251, 2661, 8319, 7356, 9710, 6790, 6508, 5229, 5619, 2475, 5371, 1569, 5689, 1138, 4609, 9923, 2435, 6132, 2910, 6581, 7530, 2794, 2630, 1255, 5539, 2540, 1241, 488, 2211, 3276, 3356, 3926, 9543, 4854, 855, 9168, 1178, 4049, 7911, 4066, 9561, 4251, 5006, 8417, 8784, 6532, 9396, 3901, 6661, 9725, 3967, 6300, 5312, 91, 9620, 5070, 332, 6029, 5194, 6352, 46, 6572, 3084, 996, 3691, 4873, 2391, 5183, 7300, 9094, 8450, 2231, 8601, 8631, 2432, 2868, 7962, 8780, 8138, 366, 2881, 3891, 6309, 245, 7856, 2063, 8942, 2059, 8481, 6722, 3283, 7152, 2894, 6312, 6708, 6613, 9770, 6822, 6147, 5090, 9338, 591, 7915, 9894, 6709, 2373, 2944, 7626, 5299, 4153, 2159, 2647, 4149, 4264, 369, 5820, 4173, 1263, 6905, 6986, 3844, 5096, 8689, 4406, 642, 8027, 471, 590, 616, 8650, 5310, 3508, 2006, 5565, 8174, 7231, 5214, 6939, 5489, 2663, 9315, 6043, 8215, 6481, 93, 7261, 7074, 5339, 5572, 1818, 6563, 7602, 4472, 562, 3951, 52, 8866, 3046, 3436, 5271, 3586, 7921, 3749, 2935, 354, 989, 1751, 2562, 6959, 9105, 378, 1688, 5973, 3197, 7595, 2925, 9057, 5277, 6965, 6157, 5531, 6025, 3668, 4437, 1297, 8367, 4805, 2179, 7660, 3703, 1530, 8499, 7596, 9359, 1190, 5993, 2220, 2313, 2193, 9676, 1664, 5386, 9161, 3062, 8299, 2330, 4166, 3747, 9883, 9831, 2501, 1101, 4747, 2769, 8792, 7343, 1456, 1108, 653, 8851, 4329, 6990, 7699, 1611, 554, 7112, 3816, 5158, 652, 5039, 3017, 6843, 3896, 8206, 9202, 8652, 2593, 3232, 1252, 6893, 4440, 7986, 1474, 5654, 1319, 6778, 6716, 2666, 5030, 1904, 7597, 2729, 6461, 593, 6056, 8454, 6485, 7045, 2150, 2061, 1149, 3069, 7979, 6167, 9007, 3925, 4766, 3966, 7070, 8841, 5440, 7069, 9438, 2965, 7224, 6937, 1757, 4831, 3345, 2312, 3722, 7031, 9760, 9173, 2386, 7308, 9432, 4441, 5920, 7381, 2367, 3269, 5732, 8336, 1409, 1677, 5155, 3253, 6834, 4, 3129, 2486, 8163, 8074, 1214, 2404, 3607, 7764, 1115, 4625, 5669, 903, 4664, 5971, 1324, 6267, 1396, 9082, 8853, 2662, 1658, 6625, 1868, 4071, 7251, 6488, 3166, 5170, 126, 4366, 158, 3384, 1277, 5782, 4485, 1777, 1294, 7330, 2105, 215, 8317, 8054, 7933, 6749, 4593, 7243, 4201, 7090, 782, 9312, 9044, 5944, 7740, 3732, 910, 2091, 6386, 8682, 5032, 5103, 3101, 9887, 8709, 7875, 4506, 5526, 8051, 1084, 9169, 2415, 639, 1576, 3475, 695, 2560, 5885, 6486, 398, 9406, 3214, 4448, 5451, 5053, 5671, 9608, 9745, 9659, 8961, 4084, 2311, 6230, 3615, 6626, 1755, 9837, 3435, 6537, 8882, 447, 5841, 7351, 8358, 7429, 6000, 9053, 9902, 7988, 3286, 4358, 872, 6579, 7199, 8142, 2945, 224, 9206, 6460, 3152, 3476, 9794, 4104, 9313, 3802, 3205, 3640, 9943, 3000, 701, 6745, 505, 6853, 1358, 5773, 5278, 6455, 7769, 6256, 7143, 5149, 5603, 1160, 3649, 7001, 3695, 4931, 5521, 992, 6011, 9891, 7444, 5123, 904, 857, 1219, 9927, 8732, 8560, 2504, 2300, 5408, 3188, 1583, 3362, 6476, 7498, 9673, 2632, 658, 6007, 1507, 7083, 8991, 7201, 1488, 9949, 7407, 6499, 2017, 893, 9558, 6612, 3919, 8518, 6396, 5407, 9666, 655, 7391, 7816, 721, 2055, 5207, 2571, 4064, 3859, 8541, 1793, 1131, 2066, 68, 2801, 5616, 9957, 8312, 3490, 700, 8528, 8394, 3913, 5487, 5950, 9911, 7035, 9958, 5762, 6539, 6904, 8465, 5357, 2621, 6678, 6519, 1355, 4228, 2281, 2739, 4819, 1732, 6866, 4981, 5360, 3016, 2135, 2551, 1783, 3630, 5327, 1058, 2455, 8943, 7003, 2948, 2995, 500, 8979, 5849, 9774, 4300, 1797, 7398, 1272, 2461, 4255, 7178, 7975, 552, 4430, 8410, 4932, 3865, 2858, 8890, 1239, 7077, 5794, 728, 1181, 1628, 2618, 8089, 715, 6527, 6873, 5725, 7896, 359, 4068, 2361, 3040, 7927, 3157, 9862, 3064, 3718, 2761, 8166, 8861, 9466, 5573, 2121, 2636, 4373, 5624, 514, 5918, 4182, 6714, 1681, 916, 4692, 1223, 3589, 7244, 6538, 1665, 5556, 5930, 4750, 7825, 373, 4882, 9590, 8535, 3509, 8140, 2201, 2604, 2093, 6557, 1207, 5120, 9718, 7087, 1448, 2418, 4253, 3279, 2031, 9529, 5962, 6084, 3312, 1931, 1697, 613, 5554, 6375, 5578, 8521, 8416, 465, 1380, 8581, 9174, 909, 6070, 4291, 1403, 5626, 4443, 2765, 3686, 8378, 2845, 6832, 389, 8721, 5980, 4606, 5812, 4046, 4404, 2710, 5043, 3984, 3697, 5705, 6635, 9332, 7168, 8522, 2773, 473, 2523, 2077, 8193, 448, 8539, 7326, 1949, 4748, 8615, 5540, 8018, 7734, 858, 4469, 6691, 1943, 205, 3114, 9271, 423, 9356, 8044, 6051, 7272, 7245, 6821, 9040, 6720, 9462, 699, 9990, 2083, 2237, 873, 8944, 3807, 7432, 9906, 8764, 887, 4700, 9628, 1050, 7641, 4279, 3591, 2951, 8515, 4118, 8399, 3091, 450, 8742, 7969, 4922, 530, 805, 1676, 5770, 9872, 7205, 99, 3600, 7175, 2171, 2104, 8813, 9189, 425, 1890, 8594, 5808, 8042, 8858, 4708, 4514, 8236, 3300, 9671, 3681, 7621, 3875, 4283, 277, 9520, 3258, 3516, 5614, 9457, 5691, 358, 9609, 6700, 1503, 69, 9750, 9220, 5240, 6756, 3385, 2615, 9555, 1106, 3542, 9404, 1415, 7860, 4572, 4460, 9516, 8195, 7371, 5474, 1030, 5551, 9378, 31, 6622, 5275, 3209, 7796, 8834, 8772, 2341, 8627, 3624, 6420, 7110, 2635, 4378, 9832, 7888, 4439, 8509, 4490, 2199, 5769, 6306, 5192, 5906, 4919, 7191, 1830, 3903, 1003, 7758, 5131, 5645, 7659, 6446, 3256, 5476, 7870, 5168, 4749, 1526, 994, 2052, 4840, 3576, 8787, 2607, 3412, 2250, 2753, 7032, 5850, 8717, 9434, 6852, 4092, 1021, 6210, 2913, 7630, 4205, 102, 7546, 2399, 2194, 7440, 9677, 732, 6368, 4189, 2708, 5548, 6284, 2119, 2242, 166, 6561, 8733, 5250, 5269, 2899, 5658, 9804, 4643, 9471, 648, 1185, 2258, 2014, 9886, 88, 1814, 6796, 109, 4330, 1468, 1079, 2774, 6917, 825, 6801, 592, 3319, 6140, 4450, 2396, 3808, 1299, 5856, 8502, 6294, 9483, 5302, 7258, 3471, 7028, 9385, 7278, 2178, 202, 4935, 8901, 6400, 5348, 7952, 1563, 3461, 256, 4890, 6348, 6430, 666, 5064, 928, 2342, 3163, 5467, 4231, 3929, 7631, 3213, 7977, 3707, 7215, 8658, 9205, 4868, 7372, 2354, 2207, 2734, 8540, 9436, 4855, 1894, 7724, 5620, 6064, 2767, 4240, 1290, 5522, 9803, 9786, 4412, 7072, 8200, 6800, 1023, 4910, 9525, 4960, 9111, 7549, 2357, 1293, 2786, 2671, 4656, 2776, 1257, 9016, 6670, 2195, 8219, 4804, 9433, 1387, 4791, 9015, 5941, 8372, 1116, 9234, 2685, 6603, 9235, 3304, 2872, 5051, 5609, 5383, 2613, 7025, 4782, 8692, 5635, 11, 1420, 6805, 5107, 8072, 7649, 1874, 6227, 6856, 15, 7765, 4452, 5430, 5130, 5747, 5708, 3520, 3150, 8407, 3746, 1026, 6718, 6512, 2448, 7614, 605, 2938, 1397, 4788, 7298, 7867, 3928, 2369, 8197, 9873, 1853, 798, 1866, 7506, 2414, 3616, 2646, 7753, 8774, 1617, 2608, 6349, 8830, 2133, 1698, 6285, 7633, 8164, 5928, 8572, 6239, 4869, 9139, 2577, 864, 4947, 8741, 687, 518, 7426, 1384, 3405, 7454, 7322, 4879, 3724, 3907, 1033, 5165, 2436, 1849, 478, 4669, 2557, 3571, 2603, 360, 8152, 1933, 1064, 3894, 9713, 4019, 8843, 2915, 178, 4445, 1323, 8403, 6207, 9077, 3149, 7628, 9799, 3428, 3860, 7665, 1478, 8294, 4703, 6874, 8405, 6013, 2074, 2205, 4525, 673, 8414, 9502, 7375, 6160, 4162, 766, 3855, 4415, 1598, 880, 7364, 1354, 5273, 7711, 5352, 8857, 3783, 5206, 1958, 9929, 2974, 3729, 9034, 7831, 9170, 6222, 1496, 1406, 2921, 254, 9564, 2265, 114, 6632, 2315, 8903, 8322, 2986, 6202, 246, 4754, 8816, 5152, 5571, 3943, 148, 6923, 8255, 2241, 7394, 4818, 4301, 8081, 2824, 9299, 3424, 3314, 1247, 8154, 660, 140, 4966, 9133, 368, 7492, 9200, 2713, 8103, 9446, 6569, 4269, 8374, 4891, 9688, 7840, 4872, 7097, 8728, 3451, 7135, 8513, 2003, 7141, 4675, 8714, 5129, 4463, 9551, 1111, 9486, 711, 8983, 6680, 626, 6863, 8605, 1103, 5350, 3849, 8262, 1686, 8468, 539, 22, 7144, 8337, 1427, 9192, 218, 1454, 9258, 3853, 2502, 2021, 214, 6071, 4032, 1268, 1960, 1344, 5752, 87, 2130, 7315, 8766, 1520, 4774, 2068, 3678, 4617, 7750, 1670, 9938, 1431, 7845, 7204, 8147, 9232, 9227, 5613, 8210, 7232, 3652, 5684, 7248, 9850, 4126, 2698, 4772, 1880, 8483, 9778, 568, 612, 2552, 6721, 7113, 159, 3580, 2016, 3297, 6340, 3089, 3394, 2549, 9301, 7260, 2544, 1028, 2004, 1970, 2536, 9279, 4725, 1565, 4566, 3450, 2255, 3497, 9890, 1317, 7897, 5173, 3131, 2784, 2401, 3153, 5115, 6161, 9924, 8235, 9215, 3806, 4492, 5439, 6, 6892, 5274, 578, 7807, 2025, 6558, 976, 4730, 1281, 8633, 1074, 6412, 942, 4917, 1192, 7512, 5132, 2782, 9314, 6998, 5566, 5939, 6211, 6278, 2747, 3757, 3792, 3813, 6938, 9740, 8773, 8432, 3261, 3351, 9389, 6639, 5296, 1674, 3669, 4210, 7717, 5503, 5238, 2770, 9147, 7766, 7558, 7493, 6574, 3388, 792, 8655, 3204, 2464, 2496, 8304, 6183, 3637, 4401, 7880, 6274, 5441, 1585, 5992, 7431, 5200, 2981, 1092, 3323, 7547, 8356, 4965, 5735, 6855, 4589, 1663, 1199, 4186, 6724, 7310, 186, 7721, 9515, 4286, 9755, 8259, 3918, 7703, 6761, 8364, 6317, 285, 7414, 5784, 9699, 6361, 1884, 4835, 2128, 7770, 1821, 1509, 379, 4086, 5676, 407, 4347, 3295, 4013, 8428, 1136, 5316, 2058, 7347, 9908, 7395, 1506, 4976, 1394, 6498, 955, 536, 6693, 1059, 3914, 7624, 4248, 3541, 3025, 623, 7416, 7176, 5270, 9422, 9190, 2390, 5835, 9979, 2166, 8151, 6392, 3229, 4962, 4107, 5861, 4843, 6022, 4457, 4035, 861, 9272, 9363, 6081, 8538, 6273, 376, 4616, 3638, 5589, 5313, 4816, 7468, 7461, 2890, 9728, 3843, 226, 7163, 8453, 8420, 3201, 2294, 6850, 121, 7571, 1410, 813, 5179, 4667, 4152, 4261, 740, 3103, 5724, 3937, 2645, 4274, 8805, 8324, 7623, 7354, 1934, 3881, 3632, 2673, 5940, 4889, 1295, 3976, 6180, 1578, 3090, 4227, 5458, 8827, 2402, 6257, 6174, 922, 3940, 1054, 8062, 6322, 461, 1457, 4650, 3837, 6176, 1458, 6413, 3756, 3737, 8797, 7476, 8280, 1383, 1972, 8250, 9261, 890, 1961, 5657, 3796, 1833, 8751, 2664, 1485, 2326, 5138, 2395, 7169, 9670, 6628, 1680, 6175, 4829, 3203, 6981, 2429, 7281, 7177, 5838, 9982, 7439, 5523, 33, 1672, 1086, 6311, 3618, 6663, 130, 6477, 1137, 349, 6447, 7102, 8671, 9702, 4558, 5342, 5508, 3992, 1806, 8063, 8785, 2409, 5505, 9400, 6178, 2278, 9337, 318, 4996, 5787, 4453, 3307, 7652, 4011, 6201, 6741, 5545, 9388, 32, 3628, 1265, 1726, 2555, 3342, 8835, 569, 3549, 7058, 4814, 9017, 2569, 9008, 5844, 3238, 67, 9734, 6903, 3564, 5483, 1696, 7763, 445, 6732, 917, 8098, 6442, 6730, 1925, 8150, 7942, 1078, 7560, 2515, 1993, 9439, 1785, 5390, 4165, 4505, 5446, 3185, 8982, 8971, 9966, 5982, 6149, 400, 5224, 5450, 5055, 4612, 6869, 1988, 293, 3835, 6194, 7956, 8456, 851, 595, 5445, 8756, 7791, 733, 6269, 5293, 6951, 9625, 985, 5191, 6148, 3230, 3013, 2834, 9251, 762, 703, 5021, 617, 8269, 3077, 4333, 3045, 5477, 2010, 5063, 5361, 7386, 3022, 9910, 2484, 4728, 2498, 2509, 3470, 6343, 4323, 1767, 3491, 7459, 2187, 3326, 9751, 2259, 2138, 4245, 146, 2131, 1951, 5994, 5242, 7317, 2331, 7702, 118, 4336, 2049, 3601, 4918, 8021, 9005, 9709, 1264, 5879, 7917, 1709, 2863, 6594, 9764, 167, 3797, 9672, 1193, 9757, 2120, 8, 2302, 3884, 6631, 4370, 3676, 7287, 7223, 7744, 5672, 6263, 9175, 3770, 4341, 4958, 6779, 3138, 1800, 9319, 3027, 1330, 2136, 2705, 2808, 9420, 8743, 4381, 7577, 1189, 6895, 8008, 3135, 7706, 211, 9124, 6922, 5704, 1623, 965, 8352, 1909, 1930, 4233, 6774, 1208, 3169, 7247, 113, 472, 7208, 325, 8316, 2494, 3745, 8224, 1851, 7579, 7283, 9375, 7854, 8996, 7822, 3803, 789, 4302, 7526, 5977, 7159, 9528, 8848, 4134, 4940, 725, 1068, 9348, 1100, 2706, 42, 9612, 1959, 4729, 6398, 96, 646, 5987, 947, 2288, 9560, 8119, 1561, 4065, 8234, 3533, 6107, 4638, 6977, 7838, 6966, 3036, 4605, 8149, 3076, 5429, 9474, 8208, 9336, 1316, 751, 5154, 3227, 1870, 4097, 415, 9006, 8214, 6280, 2670, 731, 5514, 9753, 7889, 7821, 3609, 6417, 8137, 7539, 3955, 3245, 8690, 9836, 9051, 8552, 4733, 5963, 8184, 7482, 4197, 7968, 8763, 1062, 2821, 2731, 5761, 4007, 6358, 7507, 771, 2791, 9969, 7583, 6165, 1479, 9584, 5960, 2472, 4908, 8750, 4006, 4083, 142, 5121, 3100, 371, 7154, 1773, 220, 8630, 3146, 5164, 6052, 5204, 8729, 6283, 8170, 3247, 3579, 4807, 3093, 6542, 1243, 7922, 208, 8933, 4693, 7134, 8393, 829, 8636, 8817, 988, 9706, 7900, 1332, 153, 8463, 8565, 4984, 2589, 7882, 6372, 9717, 6974, 5501, 2714, 3376, 156, 6982, 3577, 5113, 6354, 2244, 3241, 3014, 545, 3876, 8457, 9540, 9805, 8895, 923, 9621, 9583, 9407, 2717, 5126, 5894, 688, 8583, 2827, 913, 876, 7026, 3611, 5362, 5701, 9781, 5012, 632, 1337, 1879, 3352, 1706, 9353, 4532, 971, 4047, 9556, 8644, 188, 9307, 1489, 6927, 4473, 3526, 2036};
//int array[20000] = {7149, 6632, 3599, 3376, 16740, 10333, 10930, 8770, 10308, 11460, 7154, 16754, 7190, 17614, 8703, 15723, 17742, 8205, 6938, 18165, 16954, 15935, 15947, 12487, 17086, 10295, 18225, 6385, 67, 11564, 6000, 13404, 15453, 9478, 19080, 3425, 19493, 16599, 19041, 18356, 3707, 2718, 12919, 16724, 15454, 7395, 3657, 4435, 9049, 16838, 6722, 8382, 9754, 15798, 6413, 19158, 5459, 56, 8630, 5233, 189, 6827, 346, 9383, 8117, 7280, 19640, 11426, 18475, 13290, 7500, 3155, 9199, 16553, 7976, 18125, 14490, 17333, 1778, 3610, 15144, 15542, 8519, 13106, 7316, 8779, 6951, 11938, 9843, 6305, 18483, 217, 17155, 2343, 17279, 13370, 6833, 12934, 17188, 9126, 13527, 4938, 718, 18985, 19240, 17337, 13328, 12771, 13455, 17054, 11400, 18534, 12250, 19775, 10226, 8037, 18437, 2200, 15455, 6417, 14735, 13046, 7379, 2360, 5006, 16291, 2754, 1048, 12787, 14906, 15061, 268, 18484, 15913, 5319, 9584, 4795, 18683, 13477, 6832, 11043, 8589, 17545, 18015, 5997, 9771, 548, 13642, 7222, 1106, 14641, 6185, 18701, 629, 11920, 8046, 10053, 4455, 4107, 11312, 4833, 19143, 14207, 7293, 15998, 14010, 19428, 6033, 15446, 872, 18768, 18053, 5983, 9021, 18487, 9433, 13756, 1642, 6834, 18151, 14388, 9171, 9705, 12794, 11591, 3375, 14287, 4025, 8728, 3550, 8245, 8141, 10536, 6920, 15176, 6571, 16122, 15832, 19984, 3586, 7632, 16485, 6638, 16433, 423, 607, 17628, 14214, 15289, 1541, 15719, 3217, 8969, 2325, 17030, 14501, 14600, 10020, 7512, 8242, 9933, 3363, 17435, 10405, 17704, 19187, 11385, 16013, 2594, 8170, 334, 3678, 14275, 6071, 3393, 8954, 13777, 4383, 13569, 2775, 3728, 420, 1861, 18529, 11092, 8687, 15757, 4964, 11480, 11441, 17557, 8993, 16021, 13856, 12388, 4390, 17938, 16034, 9321, 1581, 11073, 15584, 13743, 2236, 19437, 18324, 7331, 10204, 15936, 18948, 17491, 16133, 4747, 14653, 4731, 5196, 16913, 8231, 9428, 10347, 7066, 6430, 15979, 6316, 12918, 1743, 16884, 10434, 8850, 10059, 6583, 16526, 2377, 12420, 13132, 3163, 955, 7705, 13850, 3823, 2575, 17426, 1895, 4431, 2566, 4739, 5187, 4048, 13669, 14890, 980, 17590, 13511, 15458, 1470, 17817, 1883, 15964, 4234, 3649, 16738, 11558, 10898, 8453, 3591, 10486, 17364, 581, 2242, 7037, 11272, 5469, 3861, 12726, 19650, 8183, 16637, 6802, 6348, 17871, 12892, 4466, 16733, 7140, 18292, 6494, 16251, 8535, 11967, 3909, 16634, 10517, 4083, 8029, 14944, 8098, 2968, 8568, 18875, 8430, 5666, 8503, 3345, 4184, 19539, 16344, 4876, 7368, 15982, 3720, 1210, 17821, 10046, 6135, 18963, 9496, 9258, 17466, 19695, 15923, 12263, 13495, 10758, 13418, 1554, 19826, 15850, 11147, 2773, 5528, 3386, 1670, 2644, 3857, 3085, 8375, 12820, 7082, 797, 8931, 5759, 11331, 2049, 7004, 10670, 17037, 18526, 4996, 341, 10284, 9548, 949, 6259, 17746, 8841, 18797, 11828, 12359, 348, 6460, 16797, 14076, 12653, 13287, 15605, 19748, 2180, 6227, 19581, 8545, 1830, 15284, 18791, 1124, 2500, 6892, 10887, 3314, 10743, 19747, 4338, 17841, 12386, 3833, 7680, 13218, 12654, 19558, 12921, 13467, 9564, 17983, 8801, 17246, 8491, 2721, 11975, 16770, 14763, 16976, 13250, 14633, 13853, 18915, 19290, 9882, 10374, 7371, 16111, 3692, 10102, 3969, 7093, 13600, 17920, 18185, 7569, 14548, 8693, 10175, 8813, 6914, 9713, 12556, 9319, 2557, 7381, 681, 1037, 4094, 3168, 8704, 9851, 8604, 2100, 9493, 19829, 13975, 6281, 18303, 12720, 14529, 15031, 14161, 16104, 3923, 14619, 11524, 8234, 17823, 13453, 3051, 10904, 11242, 18309, 2434, 10817, 16488, 18404, 11392, 9502, 13820, 12242, 3149, 17613, 1728, 15874, 13914, 2519, 18377, 8620, 18305, 1475, 10899, 3148, 3273, 11721, 5593, 5371, 15408, 12834, 2472, 14195, 3907, 1548, 854, 12240, 7817, 19983, 17544, 4957, 17892, 11366, 17233, 14361, 4448, 14091, 133, 1192, 14948, 13959, 8445, 10402, 14769, 16547, 2227, 18259, 9895, 7179, 9152, 10915, 4743, 7965, 12558, 12330, 8031, 13788, 12179, 8150, 11500, 16700, 14255, 7362, 17916, 6582, 19154, 5242, 15403, 8403, 477, 1070, 19379, 15741, 8953, 10008, 8424, 2920, 17906, 7769, 18168, 17431, 14191, 17701, 15157, 1469, 131, 18075, 5429, 14233, 13927, 17526, 6623, 19754, 4325, 2345, 2173, 14437, 5471, 13808, 13449, 13059, 14456, 5662, 9149, 12829, 19701, 13445, 13268, 10061, 1521, 8012, 1189, 2999, 10735, 15934, 10602, 3151, 6538, 8820, 1247, 4346, 9332, 1225, 17397, 12675, 7869, 7231, 3075, 19047, 9991, 10823, 15870, 10579, 7446, 5551, 1982, 19584, 6804, 9423, 7113, 12611, 13198, 13420, 16638, 15336, 14391, 1340, 8472, 16645, 11234, 8948, 12288, 7624, 3452, 16254, 4552, 5756, 11893, 3199, 1253, 17038, 15780, 1245, 6384, 6323, 18190, 8683, 9096, 12499, 5794, 15282, 14671, 15911, 4654, 13636, 9014, 11517, 15334, 15743, 15095, 14897, 10084, 14699, 1839, 5149, 18793, 10961, 3004, 9310, 18062, 10831, 18348, 8408, 16920, 8456, 19352, 17182, 4268, 7157, 2888, 14509, 2904, 11445, 6284, 5208, 3818, 15255, 1784, 15663, 14941, 5071, 12790, 9651, 2598, 13735, 7710, 3052, 14743, 9165, 6168, 11870, 19607, 17380, 17212, 6167, 10782, 12301, 9660, 8433, 1795, 2804, 18629, 6783, 9629, 7486, 8686, 15208, 15274, 16855, 10021, 2222, 4557, 2221, 9796, 6844, 4561, 8259, 13866, 7249, 13138, 2381, 4846, 17666, 6373, 16764, 1317, 5554, 13742, 5490, 1424, 11987, 4845, 17830, 2677, 18922, 7294, 9864, 17956, 10355, 16686, 4750, 5084, 2182, 12253, 4128, 13885, 5548, 17136, 14043, 17114, 17334, 12470, 16508, 17220, 7483, 5247, 11405, 12196, 10436, 19921, 8219, 6753, 6105, 19288, 11663, 13881, 17623, 5802, 1799, 1924, 12355, 10443, 18861, 5499, 6978, 15523, 1144, 11164, 2934, 8894, 17093, 6660, 16427, 17939, 2555, 7299, 7065, 7174, 2955, 3995, 2229, 3544, 13999, 5783, 4668, 19559, 3015, 10789, 16116, 18490, 10352, 13171, 16214, 1026, 6319, 8541, 16307, 6861, 3788, 11511, 11864, 14022, 1746, 17146, 2915, 2385, 8774, 14800, 8566, 19131, 18021, 15978, 4699, 1018, 1466, 10241, 8323, 9543, 8356, 14703, 8441, 5399, 18537, 13266, 18040, 4811, 5246, 15063, 2844, 7386, 14618, 5289, 13230, 1962, 5188, 9314, 9372, 1533, 17317, 6758, 8702, 13274, 9001, 4017, 5555, 13901, 13551, 17513, 10695, 18551, 16114, 17958, 17029, 14005, 1584, 3312, 984, 4288, 18546, 19631, 13769, 13096, 16343, 3867, 6744, 18411, 8072, 557, 1356, 18615, 8546, 3354, 18911, 4177, 2841, 1927, 6980, 9945, 12645, 5253, 5740, 9139, 10663, 17928, 3427, 18694, 19610, 16370, 6511, 15583, 16301, 6322, 18138, 4967, 18772, 10704, 3756, 18709, 1093, 9228, 9398, 9620, 10316, 10950, 15474, 6294, 8258, 1412, 18169, 17772, 10537, 925, 10145, 12910, 17232, 5137, 16795, 8525, 1335, 4640, 19970, 6986, 2748, 14245, 17768, 6636, 14143, 16809, 7189, 15149, 14954, 18787, 17472, 3460, 15212, 6936, 756, 8756, 19962, 786, 3602, 3940, 16170, 5335, 19023, 18681, 2067, 9813, 17091, 17041, 7246, 11427, 17625, 14559, 15464, 13102, 10745, 1450, 12406, 6029, 13608, 4229, 16582, 3746, 13041, 2618, 15373, 17903, 12586, 4942, 7321, 17021, 13931, 16628, 6126, 16017, 18381, 6002, 9834, 15221, 15621, 15800, 12444, 13760, 621, 425, 14184, 1610, 2940, 7654, 8899, 17341, 13177, 7070, 6163, 1281, 944, 18530, 18828, 8999, 4535, 5004, 6774, 17854, 14640, 2212, 17736, 11438, 14582, 19831, 17203, 7334, 2503, 85, 6530, 7848, 6514, 17335, 10022, 8093, 13539, 3211, 2522, 10279, 18057, 12744, 7234, 10643, 9679, 11951, 7089, 3773, 14708, 731, 16384, 11622, 364, 9020, 14658, 4835, 18951, 17416, 11363, 11257, 5837, 7132, 18918, 14889, 19629, 19382, 12940, 19723, 879, 12813, 11203, 4354, 18557, 2971, 9460, 9241, 2727, 14123, 10494, 5702, 1399, 12736, 3326, 7310, 10394, 4766, 488, 818, 12743, 18785, 11542, 12452, 14817, 6736, 236, 18179, 787, 12880, 4416, 18025, 1421, 18070, 12224, 7245, 5828, 14450, 4616, 884, 9370, 17981, 5308, 5456, 16569, 7432, 17066, 8507, 5898, 2852, 15105, 15987, 6315, 11946, 11137, 1523, 13332, 15715, 10626, 10501, 13985, 15175, 17423, 2783, 8202, 707, 7240, 7308, 2788, 6957, 7464, 19105, 7194, 6516, 7208, 11465, 16038, 13541, 12021, 14882, 7442, 8397, 8606, 7571, 17187, 10147, 10480, 14829, 6254, 8161, 10087, 10276, 12864, 8017, 13159, 358, 16648, 3651, 15729, 7372, 4966, 17661, 2074, 11042, 15154, 14292, 2568, 4660, 11731, 10324, 8204, 14465, 19042, 16659, 3017, 13831, 9185, 995, 2096, 13948, 11451, 17997, 11621, 14936, 11066, 1391, 14801, 2979, 9513, 5596, 12402, 14074, 13854, 3239, 19671, 9640, 13145, 8138, 18400, 15177, 4619, 14911, 12467, 8570, 3277, 1067, 10555, 1651, 15007, 12571, 3540, 15845, 17225, 8281, 2198, 9445, 4060, 5479, 2485, 15140, 10884, 16877, 13402, 4597, 13056, 9450, 8918, 10897, 4172, 10987, 13977, 10842, 7738, 2209, 18851, 5264, 5231, 6751, 9421, 13517, 1534, 17806, 12670, 19445, 12031, 14276, 4793, 16869, 11162, 1931, 6387, 2585, 1612, 7182, 12941, 1433, 17361, 17480, 12236, 1578, 1266, 534, 10879, 1078, 17310, 13862, 2564, 4312, 14842, 18287, 9002, 2918, 18464, 1102, 8751, 19005, 10886, 15648, 5712, 8599, 10549, 13190, 2693, 18203, 9611, 15039, 3338, 14967, 3262, 15195, 1320, 4386, 19783, 9295, 2573, 13396, 8950, 15912, 16120, 17651, 1658, 14968, 10974, 12365, 18968, 3078, 13556, 16475, 16174, 16169, 19294, 18885, 2861, 19550, 18876, 4336, 192, 1292, 9700, 14864, 17710, 7547, 5200, 16845, 17084, 13107, 18166, 10325, 2418, 6451, 9070, 6612, 12563, 3394, 13984, 6614, 17994, 19203, 10075, 16872, 3043, 2845, 1429, 11216, 381, 18983, 9446, 8716, 467, 13123, 19395, 3096, 14444, 8846, 226, 5139, 14893, 9554, 16018, 7615, 16822, 2709, 11085, 14577, 4746, 4705, 16316, 15683, 1671, 14836, 11913, 17818, 18469, 7850, 4884, 9101, 18570, 18217, 3930, 3578, 19997, 5959, 489, 7297, 19791, 18503, 13129, 4051, 13922, 6009, 6546, 14281, 16892, 508, 18155, 10183, 10201, 18755, 13458, 16279, 12882, 8835, 5352, 16669, 10086, 2883, 15786, 18715, 3668, 2910, 18349, 14527, 19043, 15497, 6838, 3982, 8762, 5634, 12036, 6143, 1802, 13072, 13827, 12537, 2707, 7007, 4696, 1913, 4156, 6684, 15475, 6382, 2932, 10877, 16126, 7276, 12270, 10869, 17690, 6205, 9975, 5032, 7644, 10047, 12251, 16317, 11095, 201, 23, 4042, 4278, 16473, 2586, 18511, 11117, 11226, 11639, 17977, 7369, 9291, 230, 2622, 14200, 5083, 16358, 13295, 11961, 17314, 8001, 5041, 16052, 8038, 611, 11319, 11102, 3764, 2654, 10601, 11219, 5431, 737, 3576, 12285, 282, 18045, 10733, 18390, 6735, 8596, 3135, 12482, 9928, 1677, 3247, 10545, 16426, 11954, 1149, 16465, 5835, 7466, 9190, 16750, 19911, 7241, 7590, 17231, 1615, 17605, 5633, 15973, 18774, 5090, 6116, 19040, 14540, 19738, 12153, 11749, 13037, 9432, 9857, 16151, 17723, 14516, 18479, 7851, 16215, 13128, 11863, 9662, 6673, 11086, 17379, 2467, 19740, 19728, 7622, 4622, 4137, 1079, 8695, 4475, 8411, 6469, 6501, 16388, 15444, 7013, 3592, 10805, 11293, 10644, 12426, 231, 16464, 18625, 19297, 12711, 3191, 16615, 14511, 8273, 8221, 13737, 11950, 870, 935, 19620, 16398, 18757, 10080, 12851, 4810, 1272, 4847, 19951, 9466, 11909, 19683, 1696, 5771, 16945, 10114, 18630, 1414, 6901, 233, 12306, 5769, 10012, 14432, 18938, 17011, 14541, 17284, 9774, 10774, 15164, 13357, 12765, 8169, 18147, 9537, 6822, 17260, 429, 10967, 16267, 12326, 17577, 16864, 18600, 16453, 19486, 12963, 1646, 2776, 7354, 12580, 1877, 4123, 9492, 11235, 11716, 524, 11308, 7150, 16936, 18720, 4272, 3739, 4935, 16436, 5370, 3507, 2220, 14071, 18016, 9113, 13278, 5849, 947, 5850, 256, 9209, 1637, 5206, 10361, 4761, 6150, 17514, 3851, 14604, 12222, 19589, 12095, 8228, 15468, 6683, 12370, 2628, 10569, 1505, 16385, 16208, 5587, 17924, 9151, 9969, 17053, 10718, 17407, 3985, 2790, 9277, 19694, 14493, 6954, 7250, 5340, 3233, 18327, 9006, 7672, 19281, 10927, 17650, 17927, 15627, 13017, 1870, 9886, 13109, 7523, 14927, 3250, 14926, 5189, 2093, 8783, 13187, 10076, 458, 1532, 6786, 17719, 8551, 6085, 7807, 16624, 18297, 16393, 12763, 9649, 12178, 5928, 3587, 9593, 19801, 8208, 16923, 2285, 18752, 3986, 7081, 10820, 10072, 10687, 11665, 4553, 12085, 17003, 5392, 3734, 13206, 18249, 19341, 2059, 8831, 9557, 3055, 9280, 17326, 4320, 9336, 16362, 14324, 12778, 8293, 11077, 12156, 16003, 6036, 16843, 3032, 18409, 6897, 6882, 6359, 8335, 10007, 5707, 10296, 13950, 13978, 9393, 14786, 2829, 12051, 1447, 16356, 14597, 14000, 6671, 6329, 7008, 19402, 2427, 16854, 9000, 13792, 16992, 461, 8232, 6355, 16934, 911, 9968, 327, 19304, 19641, 18660, 9824, 586, 18462, 5906, 16613, 6657, 12054, 19117, 11970, 15811, 14630, 3419, 19547, 9525, 864, 7658, 3538, 9676, 17656, 588, 12613, 12609, 11397, 11540, 865, 13184, 2141, 4263, 741, 12221, 14513, 8250, 12719, 16766, 11268, 17999, 12896, 16260, 5326, 17105, 10208, 732, 18414, 415, 18139, 11587, 5859, 575, 447, 14394, 10866, 6675, 16670, 11423, 7238, 17398, 3639, 12180, 4577, 3661, 18379, 1893, 2280, 7668, 18574, 5065, 6952, 2613, 12325, 3677, 7763, 15504, 17835, 1663, 13485, 13973, 8603, 11113, 17283, 19601, 7032, 11297, 17264, 7197, 7327, 17905, 2533, 18750, 8003, 19767, 11553, 178, 19739, 14027, 14494, 8656, 10449, 5344, 13481, 18843, 9763, 6569, 18095, 17682, 15761, 18276, 816, 12881, 17447, 3937, 15578, 8121, 13447, 15755, 9226, 9894, 1975, 18195, 2713, 6266, 19262, 16340, 9232, 2602, 19844, 4411, 14963, 2741, 19823, 5127, 18058, 16837, 18844, 5872, 1442, 667, 5509, 9203, 2102, 1636, 2818, 19267, 17662, 8498, 1761, 3944, 15238, 8534, 13584, 6931, 1040, 4852, 17414, 11406, 18910, 1354, 13965, 15775, 11335, 17707, 9980, 17436, 10018, 8528, 1361, 3121, 5124, 17890, 15226, 4113, 1028, 7244, 16785, 1712, 3705, 10289, 19703, 12672, 12483, 8514, 6778, 843, 17816, 13532, 18180, 17318, 14793, 10966, 4105, 7, 8311, 11477, 12409, 1777, 2518, 281, 9972, 9920, 5640, 14774, 2058, 17538, 12244, 17135, 6500, 14039, 11267, 646, 17390, 186, 1172, 6548, 17270, 12692, 1780, 9966, 9004, 19298, 5, 16238, 9935, 14271, 12682, 1790, 2342, 57, 8466, 4900, 12599, 16415, 11652, 13486, 7910, 7701, 15825, 10224, 9180, 12185, 11435, 8795, 17218, 14475, 12352, 18560, 10615, 5931, 7699, 13621, 5694, 1301, 6509, 13703, 4851, 9768, 18084, 13555, 10456, 14485, 17901, 3539, 6467, 13412, 7204, 12453, 1891, 13659, 8096, 8827, 6391, 19863, 13091, 15091, 1592, 16814, 7336, 5918, 2662, 1022, 12319, 4749, 8946, 17582, 5654, 10432, 10647, 14659, 11922, 5236, 3269, 15706, 9036, 13256, 17068, 12700, 17468, 10709, 10156, 12728, 3473, 18284, 9759, 209, 492, 11602, 13403, 16230, 18335, 5923, 631, 17667, 19363, 19802, 7695, 13648, 11670, 7771, 9757, 9210, 15704, 6496, 5936, 19196, 13298, 8705, 4261, 15690, 7418, 16989, 6237, 33, 7169, 9400, 2267, 11680, 503, 8839, 17863, 14979, 1211, 7911, 17982, 14772, 1467, 283, 5900, 5572, 698, 18341, 12945, 6261, 4951, 11520, 1242, 7171, 8363, 10163, 2534, 19184, 10010, 6079, 8536, 18857, 9600, 12371, 16227, 13292, 4257, 12072, 16446, 10195, 17584, 17242, 3080, 15712, 8226, 2282, 17090, 12713, 496, 1609, 5673, 14925, 5417, 17371, 3206, 6479, 9412, 77, 11160, 12022, 17809, 10668, 4260, 15002, 18163, 7666, 4869, 5787, 9355, 12697, 4007, 3999, 13097, 8135, 2870, 6613, 18311, 5734, 18612, 1560, 13798, 4255, 7119, 12715, 7217, 9642, 11038, 13073, 1027, 5400, 8857, 3924, 19390, 11706, 14212, 10788, 3270, 19038, 12494, 3842, 11167, 15261, 12655, 15090, 2023, 6566, 533, 4395, 19749, 7753, 13942, 15899, 12338, 12978, 517, 9074, 16185, 15649, 7325, 14709, 18696, 8000, 13176, 12491, 8855, 13878, 6297, 8937, 14863, 4802, 15378, 13170, 1169, 2126, 5192, 10952, 17175, 12758, 3765, 18446, 6454, 5207, 12937, 7006, 13263, 2329, 17357, 34, 9457, 697, 19365, 15522, 5184, 5966, 7251, 8939, 18493, 5878, 3242, 2439, 795, 16899, 11089, 2210, 15545, 12308, 16166, 16236, 9402, 7735, 16014, 1906, 8288, 11848, 19004, 10196, 9015, 17206, 17574, 5564, 11660, 15401, 3662, 953, 10943, 6590, 11757, 19657, 140, 19090, 4292, 11845, 2959, 1322, 11899, 18365, 3441, 5829, 15846, 7951, 18047, 290, 3776, 15343, 19647, 7005, 3162, 5913, 225, 3691, 5544, 14806, 9777, 1628, 3299, 1076, 16617, 14920, 14745, 3342, 19366, 19072, 13994, 3107, 8045, 4540, 14416, 9799, 4081, 19577, 8380, 319, 2990, 3837, 15623, 609, 13010, 9267, 15484, 14982, 5322, 9192, 10227, 1786, 17165, 198, 14002, 13344, 1580, 863, 19401, 18387, 7469, 5560, 4289, 11814, 3757, 13060, 10039, 8207, 6240, 14170, 14023, 202, 15316, 16032, 2708, 15879, 10140, 15496, 15675, 12065, 15988, 15280, 14667, 11206, 7436, 16386, 10113, 3517, 14209, 6674, 5045, 8194, 18658, 4201, 2379, 9198, 1744, 7254, 13949, 16898, 8443, 5896, 2483, 9997, 7847, 4058, 14259, 14977, 18607, 8055, 17428, 10843, 18007, 5599, 16162, 1309, 5112, 14678, 1329, 6298, 14106, 16441, 12738, 8672, 9439, 14907, 14923, 704, 11197, 6486, 12198, 5545, 7144, 13969, 16726, 8346, 5234, 3467, 16183, 4565, 9633, 6070, 16135, 1681, 5028, 19707, 2496, 10498, 11775, 11560, 1702, 7641, 1886, 18481, 5658, 12991, 8595, 12205, 7881, 11559, 4633, 9041, 15915, 2821, 5507, 15882, 18273, 814, 14406, 5843, 8986, 17575, 10594, 12624, 18262, 9918, 5388, 16527, 19579, 18996, 3350, 1643, 9349, 5804, 14721, 12069, 2012, 8767, 17430, 17720, 19766, 16438, 15134, 16466, 833, 4337, 17515, 6537, 7635, 1290, 10, 12818, 1515, 19277, 16576, 7301, 1867, 14226, 2903, 10479, 7138, 5092, 12431, 13336, 2805, 11326, 1184, 18815, 453, 1107, 19157, 10339, 12300, 15937, 3564, 6840, 14104, 18429, 4760, 17898, 6235, 14007, 11713, 17228, 5313, 17381, 11309, 18344, 5972, 6180, 4372, 239, 11631, 19658, 15384, 11341, 10006, 3848, 7097, 4748, 11640, 2382, 6394, 7603, 3336, 1277, 15427, 19934, 19498, 19099, 497, 5569, 13685, 7756, 7525, 7935, 13061, 19037, 13607, 8696, 6225, 9905, 14625, 18067, 2660, 1805, 526, 7104, 5917, 2392, 4741, 16866, 195, 16880, 5230, 11378, 16658, 16883, 12648, 19838, 10368, 19268, 3713, 10786, 7979, 4799, 9240, 10177, 4387, 14083, 5271, 11132, 15223, 14132, 5844, 10150, 9448, 17470, 7977, 7588, 10875, 11869, 9591, 17051, 17268, 2457, 19016, 7199, 12080, 1979, 9051, 4904, 16777, 3398, 3663, 4035, 8296, 2320, 11813, 7834, 3124, 10188, 7322, 9944, 251, 19664, 111, 17709, 18102, 15413, 4477, 9827, 1152, 11105, 14574, 9691, 14609, 51, 15155, 2617, 10424, 12262, 1524, 1443, 9635, 16068, 8238, 19800, 278, 244, 9243, 18808, 13035, 14670, 2273, 5175, 13674, 19750, 19956, 21, 17299, 10698, 15853, 19171, 4213, 16205, 9884, 2266, 3981, 11227, 6620, 13995, 2535, 17483, 3018, 4615, 11594, 9103, 5708, 7626, 7158, 10828, 7821, 19102, 16535, 8481, 624, 18456, 8469, 7916, 4635, 14063, 9878, 14747, 18260, 15452, 8108, 1186, 15747, 5339, 2520, 5203, 3159, 18663, 486, 17534, 13241, 19358, 18870, 2479, 10907, 17374, 9955, 3065, 12343, 10891, 10558, 7811, 210, 4973, 2563, 15721, 11882, 9596, 1205, 4496, 11708, 2031, 9033, 16849, 12334, 19684, 1159, 13859, 562, 10000, 18317, 11783, 748, 4111, 11983, 5646, 3581, 10115, 13838, 15351, 17261, 17699, 336, 421, 13470, 12419, 5486, 8359, 3503, 3145, 14223, 19788, 13947, 3628, 13908, 3120, 6015, 7559, 1748, 8314, 1373, 9908, 6264, 8197, 4290, 15469, 2653, 9154, 17592, 7214, 5020, 585, 6506, 8681, 19586, 14834, 4927, 14011, 7123, 9095, 9814, 742, 17689, 14219, 3859, 2179, 6950, 5628, 10599, 16985, 19535, 18509, 16947, 3416, 3104, 16879, 19263, 229, 15549, 431, 11189, 3971, 14674, 11984, 16033, 12825, 9373, 3828, 11965, 6224, 3725, 3953, 9046, 13585, 1204, 5442, 1675, 5018, 18747, 17322, 12628, 11333, 3076, 16200, 13181, 1057, 19686, 19633, 1127, 16354, 3925, 8109, 4258, 3714, 16000, 1831, 3798, 15608, 3259, 6552, 11265, 1808, 14554, 10611, 15416, 10095, 7989, 5144, 6702, 14134, 18480, 19937, 3303, 892, 19882, 255, 15746, 5166, 17419, 1598, 1939, 5162, 8662, 1208, 9862, 19104, 3572, 5861, 15654, 18246, 11937, 1056, 7580, 2744, 15953, 3491, 19123, 17676, 10442, 12315, 11468, 12350, 241, 18234, 972, 6295, 7830, 5574, 8044, 13955, 17227, 740, 2289, 352, 11048, 4933, 11330, 7505, 7597, 2186, 2711, 15302, 19772, 3527, 10693, 2815, 19234, 16273, 13162, 19942, 3545, 18442, 8060, 952, 13567, 9825, 18436, 14157, 10923, 8543, 8907, 6411, 587, 2571, 1730, 1054, 5204, 15030, 17907, 8562, 14591, 16096, 12635, 7767, 12701, 4990, 14719, 4786, 8763, 16651, 3618, 1418, 3094, 3064, 17122, 4861, 16206, 13933, 6594, 9317, 273, 17305, 14075, 9524, 1183, 6101, 19660, 16318, 6647, 13661, 14749, 7453, 18304, 8669, 3623, 2540, 824, 834, 5093, 7002, 16593, 9430, 13228, 19469, 11979, 16708, 9360, 11389, 15363, 12255, 7481, 9960, 13964, 4889, 10958, 1613, 13391, 12296, 7842, 17344, 12541, 2019, 16031, 9206, 14587, 9880, 13430, 3228, 876, 17512, 4391, 12070, 18254, 3941, 8023, 9738, 7077, 14185, 11008, 12836, 6456, 13926, 3153, 12578, 12510, 15150, 16771, 7667, 3915, 13325, 10963, 18846, 1943, 2950, 2526, 19152, 14783, 6082, 18238, 8477, 4768, 6542, 11648, 6265, 2969, 16124, 17894, 5104, 6672, 19859, 15997, 7598, 14289, 2998, 2765, 17963, 19575, 19604, 2166, 5353, 11806, 4176, 14445, 16560, 19578, 2330, 14598, 9505, 19531, 7290, 7129, 3989, 14392, 4527, 14243, 868, 16493, 5909, 19345, 15606, 15990, 5675, 7342, 4206, 13351, 1625, 8591, 1020, 17589, 5454, 6072, 3396, 15989, 6641, 11684, 13944, 6193, 12565, 6580, 1381, 8337, 270, 5258, 7043, 12469, 1176, 16123, 1318, 12464, 17123, 8284, 3186, 3906, 18810, 4498, 7996, 14072, 15184, 14113, 4579, 9037, 6745, 4072, 17576, 6769, 14654, 10936, 7725, 18103, 19614, 13147, 19064, 2996, 12842, 6877, 14705, 7939, 7957, 1508, 17569, 154, 10749, 3551, 19582, 13043, 15278, 1810, 11815, 14402, 1401, 11321, 16996, 276, 11000, 11178, 3297, 3563, 1268, 15770, 7730, 1726, 5378, 7897, 6127, 3645, 17127, 8385, 8299, 8515, 4792, 11738, 12049, 12292, 9940, 12313, 5767, 14652, 5089, 15968, 6191, 6791, 638, 18252, 8967, 13254, 19228, 6886, 7074, 3884, 5432, 666, 1097, 1294, 1937, 19824, 11408, 9697, 14555, 14696, 19906, 9395, 299, 11323, 10779, 2949, 15297, 8188, 7707, 5462, 9312, 2715, 12767, 14326, 14526, 9692, 2840, 17936, 7159, 15688, 9331, 15072, 19353, 12706, 10340, 9753, 16486, 2138, 8446, 15348, 4230, 2525, 18345, 9903, 7213, 6307, 265, 8034, 1474, 3289, 5698, 3463, 7033, 4885, 12562, 5470, 1257, 11133, 11698, 4714, 16831, 18334, 769, 9832, 19811, 5316, 13663, 2153, 6633, 4791, 15818, 14660, 15472, 2193, 4450, 162, 10040, 11298, 18841, 11131, 11305, 6166, 12454, 8289, 12768, 1345, 7148, 11694, 3215, 2490, 11582, 4850, 7099, 16595, 16268, 313, 8464, 12999, 6640, 19200, 16261, 11301, 1227, 18342, 8153, 5692, 245, 778, 4465, 9437, 14797, 2714, 19472, 18512, 16937, 4701, 1495, 19865, 2491, 19837, 4179, 15640, 1522, 12400, 6245, 4803, 11696, 7051, 16682, 16531, 9476, 17792, 4188, 1154, 3001, 3735, 182, 3890, 17596, 10650, 12644, 15101, 18241, 12525, 402, 15647, 17572, 1431, 13270, 14656, 12008, 7946, 18278, 15551, 6449, 19753, 2658, 12200, 2461, 8533, 18673, 15533, 17001, 10539, 17893, 7405, 3717, 12485, 10948, 4507, 8982, 15141, 4003, 5458, 3938, 2401, 11762, 8619, 12367, 12014, 2189, 10471, 8966, 6615, 9730, 19248, 3285, 1143, 17822, 12171, 17674, 1375, 16394, 13031, 3679, 1383, 19785, 832, 13394, 8252, 3213, 15548, 4151, 9826, 5245, 1488, 11638, 1825, 19797, 19534, 13719, 9558, 14960, 6041, 16492, 569, 9764, 14476, 3328, 18572, 10127, 9657, 17636, 15346, 6823, 8262, 4534, 14225, 1092, 1756, 2275, 11461, 10119, 5169, 6518, 19442, 11595, 1077, 11044, 4222, 17016, 1652, 8032, 13459, 841, 14866, 9281, 8569, 4031, 10475, 18006, 9601, 18457, 18219, 5782, 612, 1145, 4347, 12869, 15310, 4216, 5921, 5351, 12424, 13401, 17046, 8309, 3856, 18420, 16778, 50, 16561, 6788, 4720, 14771, 6576, 12075, 14789, 8832, 9227, 16484, 9452, 2353, 6270, 18550, 2309, 10045, 15306, 8227, 14028, 8663, 2398, 5518, 6171, 1410, 15731, 1453, 1926, 19169, 6680, 2687, 1016, 2354, 16971, 18248, 15784, 3758, 18637, 17077, 9693, 17324, 14048, 502, 9465, 6142, 11393, 13634, 3114, 17688, 6234, 15108, 16853, 4253, 8405, 430, 10628, 16306, 3355, 17495, 1304, 15433, 15946, 8305, 1226, 14504, 11170, 12689, 1116, 5502, 10301, 3049, 5420, 17099, 14594, 12568, 6529, 3892, 9123, 6989, 5981, 16228, 7298, 16062, 12489, 15740, 7076, 6464, 16888, 437, 17069, 12822, 3973, 3880, 5625, 3843, 6592, 158, 18143, 12640, 19700, 6273, 5159, 6050, 9189, 7647, 5082, 3817, 7661, 14477, 17173, 3378, 5852, 6975, 9078, 15641, 13494, 15035, 9375, 3081, 2366, 13690, 13194, 692, 16728, 5100, 9093, 670, 18769, 8452, 12466, 4212, 12101, 7445, 2651, 14939, 16449, 10385, 17424, 12449, 16326, 19746, 9470, 2397, 19375, 12983, 2101, 12068, 13104, 10281, 9828, 1689, 11916, 3037, 16327, 2640, 2866, 15086, 9365, 910, 5220, 14208, 2664, 8685, 19083, 2468, 3703, 17004, 3448, 11091, 12532, 5136, 5819, 2311, 14168, 1448, 19567, 6046, 15025, 8119, 18189, 14246, 18229, 5080, 19615, 10679, 1999, 15262, 19520, 15473, 8785, 14724, 11556, 16939, 3071, 1064, 2743, 17153, 15, 1717, 18719, 10410, 1460, 4916, 16115, 15900, 15626, 6857, 1218, 12265, 3709, 9876, 6484, 3612, 4873, 9027, 7731, 13018, 7618, 12972, 10777, 19519, 6095, 5623, 8712, 17331, 14780, 18499, 13363, 17501, 14831, 10699, 4972, 19497, 8216, 14379, 9587, 6354, 2836, 11809, 12885, 101, 13614, 8436, 11679, 10951, 1933, 9183, 7143, 17947, 11949, 563, 8906, 2177, 6932, 4127, 9259, 4254, 15993, 69, 14458, 880, 16739, 11334, 18020, 14593, 9410, 14082, 11658, 11064, 2890, 9434, 5039, 12084, 2486, 19719, 6346, 9899, 5993, 2429, 6436, 5272, 156, 426, 12926, 15921, 17520, 18236, 1847, 8618, 16635, 12173, 2378, 9654, 15406, 2416, 15068, 13875, 12490, 5682, 127, 2050, 14585, 11136, 2869, 8644, 5808, 19980, 8341, 13782, 2292, 6608, 17509, 2260, 1059, 13644, 19060, 12946, 19324, 17142, 1359, 8853, 15377, 8047, 15995, 4375, 11758, 16671, 12340, 2642, 8636, 2317, 14240, 10425, 12573, 17168, 4984, 6190, 15896, 18286, 8900, 6165, 12826, 9443, 17611, 5777, 2702, 16808, 1977, 19524, 11356, 6151, 9100, 3478, 2249, 1395, 1872, 19545, 14274, 266, 3492, 5249, 9462, 6948, 11078, 1829, 5697, 2902, 537, 11504, 16906, 5894, 9458, 13745, 883, 926, 15354, 11379, 18602, 6854, 4307, 15215, 10606, 16850, 17852, 12010, 8510, 10466, 6175, 8930, 16019, 70, 5374, 9910, 846, 9207, 13508, 13441, 6858, 7825, 12202, 7960, 6201, 8366, 15927, 115, 16874, 8881, 7283, 16656, 8974, 11244, 19460, 11425, 19129, 4, 19373, 19350, 9694, 13843, 1559, 5890, 3173, 2947, 12408, 3110, 5912, 1397, 15417, 7940, 184, 9570, 13512, 5955, 2991, 7702, 15564, 16817, 4093, 8512, 11037, 14350, 513, 12191, 6169, 9921, 2961, 819, 8402, 8229, 10780, 16741, 7906, 13443, 12007, 3025, 4192, 12804, 18754, 6360, 12546, 10133, 9923, 11980, 6729, 2162, 2104, 17917, 6442, 18618, 10166, 13429, 17399, 908, 18695, 18545, 3655, 9017, 15117, 4950, 15547, 7397, 8129, 13399, 11112, 391, 1818, 10027, 16248, 657, 8942, 1585, 19501, 1588, 7968, 10439, 10383, 10098, 10627, 17301, 15777, 4433, 14242, 3268, 17819, 4702, 9184, 2306, 9712, 17044, 15231, 5622, 7548, 7484, 14877, 5626, 634, 6199, 1384, 17705, 7655, 6865, 3056, 9069, 8318, 13133, 19873, 18300, 16969, 16397, 11968, 2576, 1352, 6517, 4626, 17598, 123, 1275, 19954, 6217, 16187, 19066, 17866, 10853, 4740, 13058, 8151, 17290, 4675, 14396, 8479, 13752, 14453, 12935, 12225, 18088, 12280, 17112, 14685, 1995, 5165, 4647, 8745, 6627, 10852, 4029, 1901, 7349, 12808, 17547, 4914, 4822, 18879, 8478, 2026, 6664, 16247, 14216, 9160, 9377, 15869, 473, 14917, 5823, 2982, 19242, 3970, 14684, 455, 19155, 12356, 684, 1953, 10818, 515, 15972, 12302, 17073, 11069, 10206, 1669, 14380, 18003, 12211, 7498, 398, 5110, 11919, 309, 4566, 4529, 18192, 13793, 6568, 444, 15678, 14586, 3849, 13352, 12177, 8792, 3307, 19100, 5853, 11766, 8720, 11601, 4380, 484, 19922, 13759, 4207, 8542, 3198, 4087, 5130, 8592, 2792, 1687, 7361, 16143, 1288, 16342, 5568, 9621, 16090, 3936, 1232, 11525, 18746, 16004, 7232, 12375, 13610, 3385, 12232, 12514, 267, 19031, 7034, 11228, 5224, 7662, 18290, 16391, 8417, 5435, 10458, 1507, 13629, 2847, 18372, 9610, 15724, 801, 7822, 16858, 12312, 6492, 9637, 12634, 1968, 7904, 968, 4965, 17211, 18544, 10065, 10396, 1622, 18116, 10803, 17177, 8582, 7226, 11328, 18502, 12549, 6727, 18670, 10577, 11659, 4185, 8002, 5501, 18953, 8799, 18150, 7175, 9063, 8691, 4457, 9518, 2442, 16409, 14739, 5035, 17805, 18368, 14988, 14412, 13916, 2481, 7926, 18346, 14403, 108, 3292, 12478, 19994, 16592, 18467, 15020, 5158, 15791, 19592, 16772, 3141, 8332, 13272, 6213, 1459, 618, 13281, 19103, 766, 19489, 15910, 14849, 6941, 9840, 4348, 12647, 3632, 14759, 146, 17630, 19173, 5868, 12908, 18098, 12044, 5601, 6303, 7387, 9468, 17170, 10804, 11690, 10420, 5858, 12342, 2745, 14353, 13597, 8240, 5881, 7019, 12684, 17121, 9107, 1915, 11720, 13154, 14034, 3324, 12721, 3736, 4167, 18380, 4574, 12596, 2098, 11016, 325, 5357, 5302, 9008, 516, 11493, 5484, 5650, 13618, 4036, 18839, 10161, 8, 18973, 576, 10740, 1544, 1620, 11992, 13611, 15174, 12273, 11669, 13613, 10450, 17102, 12858, 16390, 821, 10380, 11412, 19870, 18392, 12058, 15042, 5500, 1779, 7345, 13156, 10360, 17464, 12899, 3790, 17462, 2751, 14421, 17621, 16516, 11923, 13707, 18131, 8016, 9064, 15397, 18599, 15887, 4789, 1194, 4716, 9704, 17005, 12, 5637, 721, 9276, 8594, 19197, 17978, 9702, 5177, 2830, 7907, 11110, 474, 10741, 1484, 14875, 2130, 19879, 7782, 9480, 15959, 4482, 19630, 10463, 1972, 4343, 4676, 6209, 4815, 573, 5970, 11624, 1849, 12909, 4256, 6521, 11827, 11823, 18018, 8483, 19320, 4090, 15120, 11501, 12641, 7069, 9193, 7723, 18988, 16053, 18148, 10717, 16080, 18191, 11476, 18035, 11608, 19466, 8915, 2147, 14384, 8304, 7964, 5978, 18705, 7749, 7270, 15300, 10624, 7779, 15366, 3374, 13410, 18893, 3501, 11303, 13592, 14486, 5696, 18120, 15073, 10757, 6381, 4985, 8019, 476, 8992, 11349, 17353, 1693, 5109, 11138, 12146, 2112, 15093, 15239, 4452, 8492, 8122, 16557, 2550, 2739, 5865, 8172, 15589, 9789, 7656, 457, 10613, 7358, 7497, 6160, 129, 17201, 19254, 8605, 19444, 1682, 7506, 1528, 17269, 16209, 13435, 9419, 2159, 9338, 18821, 148, 15664, 16994, 6981, 17449, 8077, 17137, 16665, 18432, 13774, 16530, 6942, 4818, 19376, 9223, 8078, 8389, 2407, 12422, 15597, 18431, 11741, 9111, 435, 6733, 7437, 6369, 536, 9485, 12060, 19764, 13285, 9110, 11347, 3464, 6513, 12527, 11057, 16802, 5168, 18777, 2489, 16675, 12727, 16332, 6814, 5880, 12707, 16146, 2291, 16896, 3219, 2905, 13804, 1129, 18405, 4143, 4001, 5225, 12026, 10794, 4070, 1296, 15194, 13667, 1216, 8653, 89, 18906, 13124, 10769, 3894, 15245, 12379, 13956, 17675, 15471, 15265, 10841, 12976, 3979, 7164, 11702, 11898, 2228, 1710, 3552, 18668, 10921, 10164, 16243, 2615, 1858, 19144, 5688, 2152, 417, 10148, 8148, 17602, 2981, 16197, 99, 3225, 3402, 11324, 9168, 2704, 12745, 17421, 6690, 19213, 1206, 17836, 12844, 11953, 2230, 10618, 1796, 1494, 6007, 12410, 3504, 4342, 4302, 5403, 15543, 12637, 2506, 10024, 6609, 5421, 19965, 17781, 862, 11807, 9155, 19904, 83, 4690, 15085, 8006, 12189, 18266, 7125, 15156, 6776, 8553, 11947, 1342, 16365, 16672, 805, 10362, 12815, 8658, 404, 1821, 19303, 18199, 14955, 10203, 9528, 8470, 19639, 8266, 627, 8475, 11096, 12266, 6618, 12159, 6141, 17888, 9715, 2089, 15442, 15625, 18459, 10237, 16221, 11877, 1492, 6416, 4971, 14060, 6405, 10947, 1170, 16846, 16631, 16244, 7687, 6446, 5565, 18223, 14053, 17975, 10505, 4074, 18350, 7278, 14232, 9583, 22, 19258, 4026, 19432, 891, 735, 321, 500, 5661, 4671, 16325, 2596, 13054, 11161, 14524, 10213, 16736, 15506, 18992, 2475, 8713, 3809, 18338, 8880, 7376, 6885, 14334, 1088, 5164, 8213, 8155, 12621, 10009, 6197, 14669, 394, 3620, 13869, 9132, 7000, 5922, 13966, 11017, 2088, 3660, 14360, 6086, 7122, 7136, 12695, 6074, 2084, 18849, 14938, 15084, 3380, 15824, 12576, 7102, 15610, 3, 17055, 11989, 550, 6154, 2271, 1353, 10633, 826, 17732, 15355, 14305, 5559, 7689, 9, 19089, 12520, 167, 19898, 19306, 2569, 2091, 16505, 19085, 10860, 8757, 11778, 16065, 6188, 11360, 15943, 4259, 9609, 19174, 14442, 7594, 9896, 9073, 4601, 8588, 1854, 14535, 13131, 8803, 16476, 10492, 3666, 14102, 18134, 3139, 4667, 15730, 4976, 6210, 491, 12703, 14203, 5609, 10033, 9516, 19726, 18939, 258, 4481, 13223, 1249, 11932, 18822, 13248, 12429, 12852, 16544, 16293, 14839, 8180, 9746, 4968, 19321, 10623, 596, 14711, 19760, 11903, 5704, 15196, 3960, 15437, 16558, 14662, 8744, 693, 7482, 15599, 3874, 4196, 2203, 15829, 1428, 1766, 7462, 14414, 13473, 922, 18817, 19947, 2972, 14054, 13736, 1117, 14317, 4142, 8715, 3908, 7836, 18413, 9447, 7908, 9293, 14740, 6026, 15994, 9647, 10293, 12827, 12761, 9125, 7928, 15460, 1969, 11470, 15487, 10692, 15796, 2850, 18552, 9108, 16859, 19720, 19848, 95, 13425, 17471, 16745, 2886, 9350, 10497, 17800, 3882, 19327, 17059, 17359, 4069, 13510, 2316, 6825, 4646, 16767, 17931, 3413, 6444, 6967, 6352, 4473, 15227, 6626, 4274, 937, 1785, 18718, 14764, 3039, 13265, 18993, 17402, 10265, 12927, 17259, 10552, 17875, 6553, 14190, 19011, 13040, 14578, 16212, 4609, 1244, 3998, 2698, 16943, 2270, 15949, 13891, 7384, 10600, 13439, 17529, 387, 3716, 6094, 4159, 9778, 4898, 6277, 12230, 14362, 16639, 8834, 9898, 19845, 6292, 307, 12012, 2514, 14639, 19721, 9716, 9288, 11801, 3193, 15439, 12585, 11545, 18418, 3983, 11124, 10363, 19999, 11617, 1791, 10457, 18447, 12435, 14469, 17655, 17009, 19077, 5710, 8590, 10521, 9856, 2781, 13318, 9797, 15359, 19735, 10755, 16815, 1050, 19119, 14358, 8324, 13844, 6404, 1919, 10419, 14853, 6926, 579, 10855, 9780, 8154, 18820, 5641, 12967, 227, 6667, 18396, 2007, 12176, 5146, 11901, 17205, 10401, 15076, 11742, 16881, 1096, 10661, 16894, 13148, 1185, 46, 2590, 16275, 14887, 10730, 736, 2064, 3000, 7600, 5448, 18760, 5821, 13382, 14247, 17145, 11966, 17837, 7593, 7527, 15799, 15732, 13016, 676, 19026, 14975, 8893, 11906, 15311, 4120, 4077, 15099, 1848, 14399, 8014, 1217, 10641, 5255, 18928, 6004, 8951, 17238, 17876, 9174, 5356, 4480, 15577, 7475, 19449, 12848, 15173, 12922, 1031, 13276, 4119, 6779, 17202, 2649, 14904, 2750, 2287, 1449, 3783, 19751, 13355, 11637, 14173, 7470, 1685, 1147, 4828, 15634, 16101, 16131, 7340, 11555, 4331, 11428, 10946, 11586, 4657, 19762, 18078, 1110, 16578, 10181, 16002, 8487, 16962, 14914, 9602, 19533, 7335, 14613, 9714, 1596, 2986, 12780, 8450, 12592, 9639, 856, 1562, 13991, 4812, 13308, 17076, 7619, 9833, 18272, 7490, 16272, 14991, 1073, 11260, 8740, 5323, 8780, 5386, 9517, 3387, 5012, 6306, 5820, 16919, 625, 2299, 17489, 9138, 3634, 4563, 15502, 8249, 14989, 4773, 6118, 365, 18559, 13666, 10239, 5985, 5215, 11175, 9556, 13662, 17790, 14278, 2437, 12962, 4858, 7808, 16506, 18048, 14757, 2155, 15298, 19888, 3876, 18231, 18498, 15371, 13819, 19805, 5647, 15243, 5411, 18123, 13507, 10500, 4388, 9141, 6519, 17196, 10242, 15493, 10138, 19986, 12620, 166, 5834, 19670, 14644, 17771, 17224, 18622, 10819, 8526, 6431, 15992, 16791, 10938, 9822, 1851, 642, 5875, 15053, 14723, 17942, 4948, 15328, 19925, 14636, 19896, 10198, 9200, 3417, 15642, 8815, 14687, 10634, 1203, 1875, 448, 3762, 11754, 17756, 2079, 6278, 12190, 1167, 16610, 15951, 19291, 10598, 19688, 19744, 2435, 19208, 1661, 18700, 2696, 9175, 363, 6353, 7875, 5193, 11710, 17992, 7186, 12290, 3718, 13595, 17140, 19878, 8922, 15317, 776, 17176, 18320, 14300, 19982, 713, 14553, 9399, 2605, 8459, 9567, 4341, 584, 19050, 15966, 11656, 1351, 468, 1121, 19847, 6474, 12324, 17089, 9359, 12548, 16630, 14799, 12951, 16829, 783, 15462, 14430, 10722, 3631, 2834, 12440, 14355, 11892, 1155, 3600, 11198, 11034, 1289, 3029, 12164, 2610, 17525, 16406, 678, 10490, 14265, 18393, 2740, 13882, 10116, 2688, 18306, 17987, 10809, 1767, 9786, 705, 782, 16794, 6102, 12831, 861, 15459, 2856, 1165, 10655, 17685, 1181, 8777, 16463, 10901, 14331, 13738, 3301, 3609, 16222, 13576, 19241, 54, 4899, 1409, 580, 12930, 13987, 1417, 992, 14642, 11386, 4295, 8064, 19793, 7900, 14410, 16792, 19195, 5390, 11141, 6712, 9489, 13533, 10470, 16918, 19759, 6653, 10889, 13042, 12905, 15840, 4797, 8621, 14937, 12106, 4581, 6678, 16901, 11184, 7589, 2261, 19523, 5304, 6447, 15250, 17063, 17593, 12136, 19929, 15550, 11029, 5543, 10664, 9239, 11020, 2650, 15759, 11144, 14480, 7454, 13356, 16265, 7801, 19411, 3611, 8576, 8043, 19215, 14189, 754, 16313, 11890, 19786, 16348, 19457, 16413, 12047, 1753, 3123, 3515, 6052, 9298, 13489, 16294, 12142, 19502, 6269, 5476, 6600, 6403, 16250, 8847, 15438, 17171, 12321, 16199, 1015, 18604, 19145, 9959, 16692, 12840, 6527, 7983, 12639, 9699, 11539, 14347, 4573, 14596, 3958, 4611, 10614, 14454, 15674, 7458, 10451, 18013, 13529, 1700, 5118, 1550, 720, 5827, 542, 13652, 7913, 6523, 10171, 17006, 6602, 4441, 13867, 16746, 4052, 3919, 9197, 7105, 13937, 17966, 5161, 19247, 9831, 15697, 15619, 19912, 221, 19814, 6682, 12216, 13598, 8726, 7544, 14934, 7166, 12875, 5202, 5746, 12353, 15450, 10731, 9755, 13255, 1430, 2546, 3450, 15165, 9221, 8688, 16330, 610, 13525, 15734, 18961, 43, 5198, 3069, 12735, 1888, 18940, 11581, 8263, 18175, 8615, 1957, 11900, 1501, 8843, 5010, 1665, 10294, 1134, 13593, 11753, 18115, 2700, 13778, 1884, 8909, 8105, 15143, 15954, 17964, 5711, 16862, 3642, 3330, 3710, 15393, 17659, 15257, 15516, 15849, 675, 11955, 6742, 6472, 14784, 8650, 5781, 16687, 3237, 1390, 9472, 13239, 3468, 17965, 9962, 2040, 4779, 17356, 18664, 2645, 1278, 2591, 8367, 15004, 813, 1852, 13136, 15358, 16752, 11633, 149, 3293, 13714, 3928, 4735, 4596, 6406, 19331, 2796, 3214, 7877, 232, 13204, 14832, 15565, 8574, 18358, 6481, 6916, 16213, 14491, 13232, 1789, 13801, 17350, 14722, 6459, 18595, 18516, 3559, 16594, 19404, 10984, 16292, 11795, 5840, 1812, 3778, 4636, 9309, 15115, 14785, 19389, 11982, 7128, 14626, 6554, 10275, 6649, 10822, 19333, 218, 13498, 18566, 2478, 4542, 11960, 2769, 15865, 18261, 17831, 15331, 4941, 2002, 14857, 16515, 12050, 13269, 6043, 19784, 19013, 3370, 16500, 5053, 7789, 4685, 12636, 8958, 18805, 16043, 19622, 13195, 13807, 18157, 4241, 17325, 18895, 16217, 3444, 13834, 16935, 17881, 11450, 8753, 10581, 4428, 5866, 7748, 11011, 18975, 10389, 7101, 9461, 15828, 18914, 16472, 10415, 13750, 269, 4549, 18614, 14397, 7717, 15679, 18178, 13713, 6685, 2842, 545, 12398, 1575, 3547, 11512, 8635, 1343, 9911, 519, 7375, 11725, 12741, 1985, 10999, 17316, 7952, 8955, 12401, 4215, 1043, 17912, 9845, 6125, 17843, 2735, 11730, 9605, 7455, 4980, 14150, 19311, 9562, 1809, 3899, 7131, 648, 9646, 7880, 19305, 15324, 770, 11841, 16570, 6153, 11874, 8723, 13732, 3423, 13482, 18967, 4066, 6696, 191, 717, 7067, 9736, 5996, 171, 9999, 2231, 5602, 15555, 10775, 9284, 7961, 3648, 4205, 19546, 12704, 13306, 1871, 15553, 4439, 4763, 14215, 4485, 15405, 17886, 5182, 15415, 11606, 11496, 13983, 767, 16396, 7816, 3207, 13552, 379, 13192, 1690, 8586, 19385, 9761, 2791, 14037, 8903, 8561, 11692, 3472, 12898, 2944, 2547, 12680, 13362, 14251, 5156, 18892, 549, 1827, 13450, 15570, 7997, 8432, 7314, 17043, 13637, 8387, 19030, 15412, 11505, 4826, 1678, 14381, 9572, 6606, 9361, 2414, 11396, 8327, 9146, 3002, 16951, 9941, 19192, 4349, 1265, 17415, 4270, 13954, 18987, 4062, 13419, 14811, 13721, 17739, 10243, 15823, 11414, 14781, 92, 18513, 6698, 1569, 13211, 13434, 385, 13316, 1491, 8833, 6248, 18872, 6836, 9873, 9508, 15232, 82, 6811, 17858, 212, 3283, 8073, 15779, 6200, 4317, 8222, 19549, 12617, 8157, 5949, 3786, 13050, 19337, 17548, 11764, 8070, 15929, 7429, 12796, 1310, 8015, 18858, 712, 6560, 7874, 4340, 8013, 7300, 9970, 11472, 12333, 5436, 11070, 6253, 728, 165, 11931, 18453, 373, 19887, 3961, 14229, 16152, 16375, 18981, 8731, 6539, 19403, 3432, 19384, 12914, 6106, 15816, 2327, 12151, 4588, 617, 409, 10139, 4264, 19339, 11502, 4733, 1072, 4738, 8485, 19623, 17949, 12170, 14376, 13168, 18633, 11420, 5807, 9875, 18649, 15269, 12463, 11370, 17562, 4250, 4266, 6140, 1252, 8071, 6156, 10701, 6818, 35, 15727, 14046, 16732, 17834, 1627, 11747, 3840, 19923, 9062, 7225, 9618, 6476, 14127, 3190, 5376, 19537, 7579, 8321, 11458, 13718, 11605, 9931, 7798, 6238, 18031, 18693, 5410, 16681, 844, 17109, 739, 15080, 17276, 12394, 10261, 7228, 18729, 5833, 1929, 12204, 16231, 9514, 9394, 14415, 8998, 9106, 13848, 9667, 10221, 15827, 9416, 13047, 9303, 6380, 16190, 17641, 1080, 17811, 14856, 4389, 13767, 6332, 12690, 8419, 16281, 19359, 15344, 13676, 16978, 18958, 13227, 7839, 19916, 6923, 6314, 9663, 17002, 7318, 6595, 19278, 19109, 14891, 4960, 4352, 17887, 14561, 10666, 18407, 7326, 8819, 18609, 5197, 12403, 6038, 3643, 9329, 5668, 9134, 10977, 17213, 13671, 4470, 12349, 7905, 8004, 16242, 2911, 17639, 170, 14672, 16345, 19068, 4724, 4379, 10975, 9607, 2983, 19006, 2768, 18318, 10648, 81, 18796, 4491, 9788, 14714, 15933, 4560, 2339, 14125, 4721, 13379, 5610, 19710, 18486, 18824, 18877, 18666, 5457, 12043, 75, 19175, 2706, 9739, 8383, 4129, 17274, 13852, 17107, 2701, 3108, 10945, 5864, 15689, 314, 13879, 15021, 15291, 17094, 19924, 4344, 14142, 12575, 10372, 14218, 9147, 7546, 9938, 8384, 470, 19414, 14643, 7016, 16926, 773, 14727, 15955, 17991, 19717, 687, 8081, 12009, 18699, 3926, 11084, 14962, 2129, 14081, 19126, 9205, 3313, 19632, 1171, 3795, 6178, 18445, 1843, 2722, 15705, 17776, 13858, 11614, 4126, 511, 19593, 2896, 1733, 17670, 16522, 7841, 8673, 15152, 7510, 18193, 12867, 7867, 15986, 12878, 10155, 18765, 4189, 12248, 15058, 4160, 13828, 6819, 18415, 2537, 10954, 6420, 1408, 7031, 3369, 1238, 16429, 19842, 9218, 744, 18806, 11059, 14124, 19416, 3513, 6646, 4409, 5052, 11494, 7496, 17302, 13333, 16589, 7145, 12341, 7061, 11288, 19380, 11735, 16036, 1135, 9482, 6963, 13342, 6905, 16832, 5672, 19789, 18665, 8671, 76, 5213, 4757, 11282, 17952, 7922, 7091, 6574, 8664, 18727, 11507, 8717, 17755, 2071, 12747, 17478, 12090, 16718, 8979, 19269, 7425, 17979, 5848, 18606, 775, 18363, 8601, 15067, 17779, 17156, 8490, 17950, 19161, 7049, 9244, 11503, 14006, 13986, 14698, 17474, 12598, 14339, 7517, 14068, 1904, 14702, 18063, 12439, 7489, 12165, 6585, 5976, 18425, 38, 6310, 1220, 7363, 9672, 17900, 2635, 15617, 1349, 7068, 10761, 13315, 15615, 15567, 8027, 3282, 3711, 4652, 9035, 16677, 19441, 18830, 2218, 7209, 7973, 18627, 14302, 18419, 10559, 6025, 5330, 13099, 12788, 3046, 13188, 812, 8660, 3125, 11261, 14013, 5999, 7248, 8496, 9042, 12023, 5288, 8567, 16428, 11971, 10038, 13186, 7528, 1103, 10563, 4313, 14675, 4236, 2502, 15735, 2465, 2460, 11683, 5886, 17761, 6250, 13068, 15482, 3428, 17384, 14067, 15635, 3050, 14964, 7474, 1503, 15490, 7135, 3308, 1333, 13478, 16119, 11816, 3011, 10274, 5649, 16044, 982, 17487, 44, 10477, 9590, 15566, 14144, 19495, 279, 16075, 5106, 3008, 1644, 466, 10100, 2732, 10546, 1190, 17106, 9749, 17753, 5343, 6274, 1535, 11104, 12676, 10829, 7849, 17375, 12413, 1788, 12351, 5240, 9389, 18427, 15876, 16255, 19181, 6725, 3712, 9952, 4663, 1175, 10707, 14050, 655, 18099, 3383, 8842, 13880, 11006, 9539, 13030, 18353, 970, 15275, 17703, 3140, 8063, 2293, 18868, 13822, 18376, 5994, 7284, 12017, 19425, 2148, 8729, 14196, 10729, 2302, 18298, 523, 27, 7026, 1045, 384, 5064, 7404, 8800, 6462, 5562, 658, 11580, 18524, 10962, 4613, 15049, 4474, 13201, 5629, 14356, 17271, 8935, 5333, 1754, 289, 6109, 13612, 16574, 2038, 17467, 16847, 18798, 10639, 15864, 1478, 11986, 18995, 15794, 9922, 8555, 1250, 1552, 16507, 11384, 8095, 9670, 5419, 14545, 6870, 11974, 1638, 12725, 9529, 8837, 5693, 9071, 11311, 316, 3824, 2574, 13939, 12925, 17555, 10686, 4862, 7586, 15996, 18823, 5813, 19895, 2190, 14820, 8418, 5085, 13605, 3658, 7468, 16308, 6968, 881, 1762, 2425, 10411, 7288, 7271, 18371, 13383, 19062, 7426, 3465, 11862, 11196, 18874, 11254, 9550, 18984, 15948, 5361, 8870, 4382, 18598, 3682, 18159, 3325, 14879, 18519, 1251, 8086, 19360, 13305, 2980, 2424, 12615, 9403, 4023, 18329, 1187, 5050, 10455, 118, 10776, 1029, 1416, 6850, 10807, 15613, 6703, 3946, 15901, 9326, 3869, 6550, 1970, 16668, 2085, 13212, 17465, 7879, 9631, 17070, 17360, 3920, 7532, 591, 12984, 5604, 15054, 1075, 11225, 7133, 7696, 8772, 7025, 8794, 6133, 9144, 10920, 3605, 13919, 2196, 16550, 5715, 4488, 12775, 18090, 13210, 15494, 7786, 2035, 11546, 2607, 12572, 6065, 12982, 3978, 3456, 1945, 9019, 14175, 19890, 12109, 1240, 1597, 13861, 10591, 2542, 18423, 11598, 13565, 9979, 14177, 12816, 6504, 13343, 3089, 18478, 8556, 15974, 1993, 16333, 2849, 15270, 11860, 15855, 15529, 16477, 1074, 6037, 4098, 7820, 10524, 15186, 13339, 15147, 3434, 2652, 7567, 18211, 1947, 7493, 1198, 700, 2731, 11589, 11224, 5674, 17064, 11270, 11897, 5505, 13115, 19506, 5761, 10996, 18517, 7242, 5846, 12347, 5051, 1986, 13725, 10683, 10029, 15745, 4947, 8351, 19609, 14572, 8412, 1254, 10970, 2703, 8764, 8302, 12286, 2862, 4412, 8988, 9939, 14810, 6493, 17570, 5414, 19055, 15906, 12732, 7027, 13727, 10334, 7324, 3316, 5944, 9296, 18277, 15700, 18046, 4376, 9424, 10337, 11232, 14084, 2839, 3533, 18997, 7714, 11527, 10099, 13395, 17637, 2756, 2408, 16543, 5043, 3785, 1150, 1859, 3963, 17406, 568, 16269, 9352, 13304, 3640, 3789, 10762, 8370, 13185, 18523, 709, 2276, 15211, 19755, 3480, 11316, 13601, 15575, 4656, 18962, 17368, 1988, 15189, 17101, 16697, 18366, 6634, 4494, 9950, 5480, 8557, 14929, 14532, 8448, 9268, 15669, 2132, 16910, 14760, 6214, 1940, 9917, 19530, 14958, 8840, 8267, 14319, 3429, 1838, 7955, 2436, 2357, 4357, 17481, 18626, 9079, 17930, 9248, 8255, 18105, 7637, 12139, 8598, 906, 19292, 322, 17883, 2755, 1223, 18645, 599, 10167, 6958, 10854, 4543, 18114, 5709, 15078, 999, 15644, 12857, 17405, 15815, 12448, 11440, 4489, 12126, 18034, 4191, 13761, 6092, 19745, 1614, 6974, 17786, 4326, 13081, 18883, 2167, 4086, 18314, 7933, 15509, 19699, 6132, 8913, 12187, 11562, 6131, 12212, 15097, 781, 18408, 5990, 8239, 10216, 18650, 1094, 6933, 13077, 16258, 19914, 606, 4187, 9803, 10727, 17294, 10088, 3542, 8167, 4638, 11613, 9140, 6262, 2374, 19856, 7796, 15760, 17829, 7156, 5070, 3702, 7750, 16008, 17362, 8130, 5598, 13638, 4211, 15682, 16981, 6556, 11306, 3158, 17134, 10157, 16189, 15981, 4197, 7914, 9830, 17827, 14978, 11082, 9313, 9623, 3315, 16498, 6855, 6752, 2511, 15082, 12749, 6093, 174, 14845, 15112, 1624, 19704, 7704, 19484, 19974, 10377, 2415, 17870, 19606, 12994, 5303, 15976, 5851, 16944, 12492, 10041, 7421, 15125, 2965, 4464, 3534, 6922, 9563, 11487, 18582, 6112, 5221, 13364, 5535, 1362, 1889, 11810, 902, 9745, 16443, 12631, 12536, 7764, 4021, 9116, 12207, 1473, 7663, 5956, 15024, 15881, 7060, 11644, 9030, 16702, 17794, 1718, 3548, 18270, 18884, 9013, 583, 7755, 4727, 559, 10491, 1832, 8272, 9874, 8393, 6540, 10978, 19468, 14100, 2561, 19692, 2908, 14770, 14522, 2013, 10092, 7377, 15695, 18730, 9982, 10723, 2405, 15488, 18850, 15259, 6777, 17185, 8565, 19079, 2909, 9953, 11284, 19713, 4283, 673, 18158, 6707, 10496, 3954, 4004, 3673, 1302, 18494, 16528, 11895, 1099, 11538, 8641, 1434, 11833, 10162, 12141, 1506, 10431, 10160, 11522, 14985, 9444, 13071, 12591, 18825, 13762, 1033, 2705, 16835, 10653, 10756, 16572, 15822, 2665, 16355, 8844, 10680, 6895, 14436, 2127, 16290, 18954, 4653, 1695, 3109, 18310, 9124, 7788, 2090, 19415, 10942, 1635, 16564, 3745, 708, 11150, 11245, 8657, 13125, 18779, 6296, 4698, 16458, 16654, 13516, 9075, 2160, 8614, 17050, 12231, 4593, 5091, 5285, 19881, 15015, 10632, 3359, 1648, 3023, 11755, 4407, 18845, 19147, 6909, 1775, 12643, 19500, 31, 13286, 4906, 17022, 3832, 8868, 16232, 324, 2042, 3212, 11531, 12801, 10126, 1960, 5397, 14681, 2801, 3006, 14543, 6639, 2914, 9638, 2052, 6694, 16457, 8891, 14455, 7887, 18743, 12097, 16705, 10528, 10790, 5077, 16136, 3523, 11653, 16150, 5439, 3839, 1035, 104, 10744, 6902, 6347, 2403, 1486, 16587, 94, 3775, 4608, 3403, 9734, 12845, 13758, 12748, 18943, 11171, 1722, 4109, 8892, 11236, 9347, 19564, 10117, 16727, 15388, 12358, 12992, 15515, 3875, 1327, 14575, 11513, 9265, 3021, 2319, 13243, 5952, 3903, 12385, 10678, 10154, 19588, 16405, 1388, 1091, 538, 16130, 12731, 5438, 13502, 16811, 14180, 18030, 14286, 14508, 10816, 4509, 5061, 12143, 10588, 10180, 19092, 19032, 12396, 16389, 11274, 17612, 19226, 4022, 17913, 13244, 13920, 14676, 17813, 8158, 7772, 11416, 16707, 16523, 9690, 12020, 3246, 320, 5676, 11632, 7995, 15098, 8237, 15410, 7991, 18268, 7684, 19151, 17342, 15217, 8730, 15581, 976, 19417, 5541, 17160, 12574, 5401, 18153, 19436, 4124, 10826, 8244, 10669, 19874, 5235, 12295, 16789, 7971, 2927, 3526, 15139, 14193, 13209, 16282, 5691, 14825, 13928, 11247, 7522, 5975, 10231, 18093, 8206, 11353, 8059, 17619, 3341, 1285, 7724, 5816, 9234, 3099, 6182, 13200, 7056, 6749, 11195, 5368, 10429, 6737, 1952, 19669, 15332, 10540, 3689, 10969, 7541, 7746, 13423, 6377, 8298, 7846, 3281, 9162, 6039, 9722, 13779, 16210, 9687, 11283, 14182, 3296, 18912, 6790, 8602, 8182, 763, 7729, 11835, 5510, 13259, 150, 8674, 12158, 15022, 6723, 16966, 10968, 18641, 12038, 13011, 18809, 12985, 18126, 15495, 1179, 4620, 4404, 12362, 5684, 11490, 13385, 9255, 8676, 16256, 8849, 7557, 2626, 4168, 3295, 1347, 1370, 3038, 12702, 18187, 6229, 4210, 7050, 2560, 12783, 5296, 8187, 11139, 4910, 7460, 19275, 13976, 17565, 10815, 5073, 987, 14974, 10056, 4487, 3446, 9800, 17438, 10068, 17815, 2811, 9112, 3922, 17993, 9414, 632, 10535, 15077, 16452, 14628, 8442, 10189, 11888, 13786, 13317, 19752, 16632, 7095, 9237, 16481, 18726, 12130, 3932, 144, 5540, 19665, 1084, 2168, 19987, 14807, 13415, 13261, 12086, 17722, 16568, 8798, 13575, 2609, 7233, 14040, 9984, 5101, 6867, 12981, 16444, 7799, 12678, 19056, 4139, 16529, 13462, 2843, 5475, 2926, 6533, 16058, 353, 16834, 9159, 8981, 6120, 13884, 5047, 11834, 7852, 5309, 774, 8593, 1235, 8611, 10112, 2604, 12299, 765, 13454, 2440, 12663, 1233, 14837, 8092, 4162, 18421, 19651, 17183, 2584, 93, 9695, 10637, 328, 3337, 19761, 16536, 4322, 7255, 15858, 2907, 15192, 12966, 8675, 6148, 18285, 16160, 7235, 15917, 18181, 1668, 18468, 680, 13044, 3003, 9087, 18051, 19367, 11217, 3560, 19388, 9092, 17506, 19456, 13090, 16779, 14688, 11258, 1422, 3178, 3569, 18742, 15582, 3715, 11032, 6463, 12873, 11222, 5592, 17549, 5651, 12495, 5477, 3200, 13381, 16674, 8460, 6075, 6097, 3976, 828, 4883, 13586, 3738, 8961, 10847, 5155, 2241, 17401, 13346, 8243, 10025, 19635, 10711, 13795, 16380, 14805, 1348, 7351, 19583, 16520, 2463, 18869, 5961, 1900, 4034, 15402, 18682, 17935, 12795, 8633, 4678, 17439, 17497, 9760, 11774, 6260, 2250, 10495, 19553, 4637, 6263, 1360, 19742, 5750, 12538, 8911, 13493, 16266, 8821, 12460, 9535, 17873, 10104, 12616, 4595, 14250, 9891, 10192, 15789, 10035, 18783, 14199, 2734, 12969, 8516, 3007, 19685, 5241, 18814, 18617, 1113, 518, 4235, 13215, 17103, 1792, 5336, 11839, 2964, 15918, 11842, 13142, 3607, 7921, 5199, 1004, 12708, 1269, 11934, 15260, 12056, 18514, 16387, 7389, 8333, 8706, 15209, 4911, 12267, 10291, 15768, 14466, 17573, 2454, 19991, 11269, 16100, 13338, 11543, 17420, 759, 1504, 13062, 2614, 1146, 3947, 7459, 10874, 15240, 6849, 17944, 3723, 17035, 3497, 2686, 1987, 2233, 18704, 5334, 14947, 18507, 9719, 18027, 11413, 10833, 18501, 19280, 6239, 9094, 6448, 13309, 18451, 16113, 1214, 18142, 14417, 19186, 615, 3813, 14298, 4016, 4134, 13951, 17729, 1270, 7923, 18302, 5979, 17587, 505, 13706, 9741, 17120, 2363, 543, 14220, 7972, 12971, 11098, 14202, 15817, 12261, 14088, 13238, 2793, 11169, 1323, 17778, 12103, 7427, 758, 17629, 14915, 10235, 9413, 19316, 7373, 3877, 6661, 5831, 17247, 4729, 19794, 16440, 18971, 19540, 1708, 7733, 10460, 12931, 6851, 13639, 11083, 768, 14148, 15357, 5680, 1650, 19512, 1180, 12948, 3167, 8517, 7629, 17186, 19156, 16351, 1551, 13615, 16968, 9522, 3266, 16337, 19377, 2115, 339, 18458, 12465, 889, 4398, 3014, 12116, 1538, 15871, 14590, 8390, 13682, 18714, 11883, 460, 17940, 18688, 5212, 12381, 18711, 4225, 15333, 8626, 11547, 1331, 16035, 5600, 8283, 14544, 11751, 10894, 16755, 8962, 18816, 13924, 2873, 16071, 13283, 1553, 15463, 18999, 2933, 18539, 2256, 11956, 13153, 3749, 8159, 993, 14398, 1305, 18118, 18970, 18059, 17383, 176, 14467, 16049, 18247, 4691, 16066, 11080, 4703, 16612, 2073, 7196, 19398, 18367, 8358, 15027, 10917, 19920, 14464, 6925, 6370, 6757, 2086, 971, 19705, 5553, 528, 19034, 17352, 10132, 3553, 16757, 16603, 4373, 15431, 1376, 7873, 6704, 3339, 5387, 18960, 5121, 13103, 14942, 1311, 12567, 13710, 16925, 17799, 3935, 7915, 5422, 14932, 19035, 445, 3391, 18654, 6336, 886, 18794, 14583, 7087, 2226, 7802, 18081, 12468, 19948, 2499, 16641, 6130, 13417, 15414, 19560, 1306, 18905, 10506, 17961, 7676, 7553, 17113, 5007, 442, 4997, 3470, 9441, 10165, 8319, 16499, 13160, 18495, 11121, 8286, 19478, 5547, 14363, 14315, 15325, 7760, 14327, 5738, 2314, 17178, 19972, 10017, 9453, 15720, 19273, 16717, 15738, 13019, 2985, 1545, 16977, 11248, 960, 3887, 15538, 19798, 10303, 15448, 15764, 14279, 9322, 14183, 14881, 17564, 9819, 8126, 10582, 12243, 5648, 12716, 3965, 15914, 1920, 11390, 10906, 5969, 12062, 14589, 8989, 13119, 589, 18488, 6532, 155, 10888, 18124, 8101, 310, 14277, 11325, 9942, 5000, 14239, 15558, 4585, 4999, 4315, 8518, 11737, 8761, 1324, 12814, 18873, 3951, 15821, 3439, 10240, 428, 556, 17580, 1463, 10597, 4568, 6717, 12428, 12915, 2290, 9919, 19949, 560, 18741, 13326, 13341, 1259, 14312, 8495, 10476, 7521, 14169, 13775, 565, 16579, 16961, 836, 14033, 12218, 8292, 125, 18492, 122, 3613, 14843, 2095, 3883, 14044, 12977, 11315, 1738, 18176, 2684, 12239, 6761, 12764, 9844, 5879, 9105, 1441, 9130, 6984, 3568, 13247, 16840, 9486, 6018, 6008, 3583, 13691, 2784, 18744, 4248, 8577, 7810, 6410, 7392, 6787, 10548, 7216, 18265, 12416, 17985, 1332, 13146, 9897, 16673, 4697, 16758, 8331, 11628, 2943, 7282, 1857, 17687, 8707, 6233, 9339, 3238, 9887, 19952, 12760, 14038, 12111, 14407, 8583, 3706, 179, 4301, 1123, 13460, 1178, 19328, 19168, 16422, 5511, 8700, 157, 17601, 7651, 1971, 17336, 393, 8236, 3740, 8156, 14439, 7257, 14404, 12876, 9850, 15758, 6098, 14294, 18216, 6663, 18170, 2593, 10441, 18504, 8987, 6300, 11448, 12846, 14138, 17010, 6805, 10049, 6334, 2746, 7286, 4614, 386, 1243, 11010, 12947, 14720, 19595, 19399, 16889, 495, 12314, 6468, 18956, 7160, 18856, 10928, 15457, 975, 7936, 15503, 13079, 12059, 13936, 11433, 19776, 1699, 4076, 7938, 11736, 2370, 6067, 5826, 3927, 16070, 13457, 18029, 19218, 7805, 6650, 6222, 18942, 7604, 8796, 7024, 5450, 11678, 850, 16640, 1483, 9333, 17313, 4208, 11146, 14731, 10570, 16870, 14624, 13390, 16734, 4106, 6656, 11263, 9765, 4332, 1224, 19061, 16107, 15984, 9256, 15781, 16155, 2247, 11143, 8198, 19804, 5732, 17161, 14689, 7262, 5503, 12997, 17195, 18077, 3045, 13825, 5930, 5261, 19619, 3287, 19990, 5191, 2335, 10512, 13234, 15885, 1500, 544, 18212, 350, 16865, 9784, 7670, 4296, 4681, 16054, 19201, 15392, 10642, 4505, 17869, 9120, 9367, 9804, 7155, 19405, 3777, 16158, 17253, 19199, 16762, 15478, 9787, 7428, 8830, 7584, 1066, 14145, 14756, 5270, 942, 246, 18235, 4893, 8069, 6236, 2894, 15375, 16085, 7516, 2103, 4658, 1813, 17222, 12019, 4518, 16723, 18463, 1704, 5229, 8634, 17475, 917, 6083, 6386, 3291, 3323, 4096, 9135, 11843, 14812, 17960, 12028, 2516, 17172, 8084, 5681, 15295, 12508, 4231, 9032, 13253, 6949, 19116, 869, 9680, 12958, 16079, 3084, 18740, 4328, 13271, 3753, 14273, 9951, 13890, 18692, 12045, 7602, 11973, 3590, 10135, 2355, 710, 8971, 6668, 1863, 17536, 9302, 463, 17280, 112, 4922, 5824, 10736, 2322, 6421, 12157, 2572, 9608, 19231, 19958, 18359, 12828, 14288, 9655, 3054, 7265, 12395, 5292, 11380, 9937, 5525, 12455, 15441, 3733, 360, 1405, 19464, 9300, 3913, 14423, 14471, 10238, 15187, 8246, 15286, 10589, 6848, 4220, 6108, 3044, 3868, 6183, 10739, 4005, 16551, 19422, 12329, 1160, 19654, 6194, 13340, 1801, 16489, 9792, 7947, 13724, 15839, 11904, 539, 1307, 407, 5856, 16431, 9405, 8455, 3939, 19860, 17395, 19709, 9520, 11045, 17959, 11812, 12671, 10137, 8810, 9348, 12238, 13528, 12632, 18443, 11377, 2274, 15520, 8386, 3557, 2001, 13887, 15185, 12954, 6879, 40, 16249, 13111, 17879, 6034, 18430, 1407, 7613, 15352, 1618, 4032, 17042, 9082, 19206, 7775, 12320, 20, 19624, 14701, 12604, 12128, 6739, 7185, 19828, 3792, 8018, 7360, 10013, 3988, 9727, 7978, 18474, 15975, 15942, 6104, 8722, 18792, 8275, 3596, 19073, 10066, 18900, 2003, 7295, 15339, 16562, 2356, 17118, 13503, 19649, 5446, 2149, 13888, 16949, 16765, 13726, 8750, 13796, 12033, 2992, 17209, 4194, 3399, 13705, 15313, 6338, 17508, 19111, 19973, 2240, 5690, 14090, 7219, 7942, 18913, 8917, 7205, 1765, 13496, 9985, 16984, 6302, 1860, 19702, 11942, 12284, 7896, 1060, 30, 9720, 12917, 9926, 3520, 18258, 19574, 10864, 8189, 12832, 6801, 17363, 3556, 6293, 19048, 8782, 17594, 9868, 7932, 5467, 4148, 1148, 12961, 9677, 9497, 13579, 17386, 18608, 24, 5372, 12718, 18289, 7592, 2549, 18832, 13307, 14064, 4154, 7046, 4309, 6100, 512, 10125, 15633, 5570, 19354, 17896, 3846, 10452, 6809, 5588, 11604, 15356, 19944, 3290, 10523, 10332, 689, 9328, 17850, 11354, 17851, 4877, 17642, 15037, 19600, 14552, 16363, 6655, 17922, 15544, 9194, 3535, 2872, 19094, 13664, 9003, 2817, 19656, 13998, 8371, 7535, 13748, 12724, 4891, 2611, 18680, 1604, 19514, 2207, 3934, 18228, 17210, 5516, 12629, 19712, 8754, 1823, 3449, 3722, 3035, 3987, 8854, 1811, 11486, 13437, 18831, 8548, 15819, 7980, 13953, 1387, 13731, 6134, 9729, 16698, 14345, 5404, 15138, 5965, 8501, 7073, 4605, 11259, 18014, 7858, 61, 14901, 7449, 10358, 16780, 1230, 11058, 12888, 10228, 7465, 10287, 11568, 4385, 1694, 9626, 6719, 1992, 8035, 11281, 19708, 11128, 18369, 5581, 14880, 1367, 18707, 2891, 18444, 7479, 12437, 413, 602, 3362, 14682, 2835, 1440, 19082, 6536, 19067, 10373, 3092, 10985, 7529, 6367, 9233, 13554, 252, 16109, 16924, 19927, 5785, 6434, 1024, 4604, 15766, 13488, 2214, 4991, 5033, 6903, 3261, 9986, 15249, 1930, 12753, 18976, 4888, 19052, 3458, 11643, 4018, 5451, 3541, 18361, 6137, 374, 3635, 4880, 15130, 10412, 3088, 9859, 9769, 9613, 2399, 12513, 12337, 19693, 1737, 2165, 422, 12619, 12488, 1477, 17119, 3245, 10354, 13943, 4830, 11988, 10005, 2501, 8079, 3179, 11685, 16226, 6872, 7718, 1800, 11596, 18725, 16586, 18891, 1316, 5521, 7127, 7108, 6219, 9808, 403, 17542, 10676, 4318, 5075, 8699, 17796, 12664, 3575, 17517, 16310, 7477, 10530, 4632, 6841, 14595, 15465, 14267, 8916, 9666, 14706, 2304, 15650, 1229, 12445, 2997, 8828, 3502, 6730, 17433, 4712, 4886, 14710, 11418, 11777, 13918, 5143, 7403, 15875, 11575, 11718, 17784, 15380, 11126, 5719, 7406, 8110, 3327, 4434, 13544, 2419, 19613, 11134, 11912, 18319, 16296, 5095, 4523, 9703, 16309, 6077, 13398, 3525, 8521, 10395, 10573, 1814, 13877, 7165, 7207, 4284, 17323, 18133, 2069, 8581, 2402, 17085, 4607, 18979, 1816, 1655, 11475, 15301, 4963, 2762, 16193, 7001, 3255, 17237, 19939, 7195, 6424, 11768, 730, 6732, 2484, 4500, 14547, 15852, 5926, 6422, 2224, 1542, 10562, 18263, 3990, 11772, 1173, 13400, 6374, 9781, 17061, 12391, 11108, 6853, 8404, 9320, 5087, 14854, 895, 7827, 6488, 16274, 14452, 5125, 19397, 9261, 7480, 19012, 14262, 4400, 15725, 3152, 6461, 9354, 6820, 12274, 18919, 48, 16377, 19678, 15525, 15018, 1161, 4360, 14990, 3469, 6985, 6184, 7390, 16381, 15546, 18426, 10566, 2878, 6577, 16165, 3972, 13294, 17214, 8398, 6878, 2246, 5267, 5449, 8977, 19849, 3664, 7243, 2238, 14121, 14972, 11383, 14440, 6642, 16590, 4536, 8980, 9459, 7815, 6042, 4817, 12063, 3742, 13641, 7871, 3498, 16047, 4532, 17760, 4610, 3144, 17680, 456, 7444, 1793, 3512, 15873, 5027, 14019, 8829, 15851, 15036, 5040, 1363, 1623, 18865, 10264, 19854, 15892, 3361, 10715, 5753, 5582, 9732, 15409, 15322, 13558, 16818, 1394, 3754, 16895, 4692, 17807, 15052, 10307, 14607, 849, 4745, 3317, 4744, 3804, 15699, 5320, 4526, 18558, 10168, 8560, 2350, 5686, 9390, 14922, 2070, 15952, 12606, 13627, 4887, 1967, 3577, 8655, 10400, 4125, 12791, 1819, 2895, 5111, 7170, 2459, 5133, 14137, 9474, 11204, 10941, 4728, 16399, 16312, 2326, 6003, 13695, 4592, 10397, 11345, 4575, 136, 14581, 10060, 19002, 19133, 18738, 12614, 1404, 15586, 1236, 2157, 19044, 440, 12587, 15305, 14610, 15233, 1673, 7306, 14899, 10489, 2412, 14030, 672, 6807, 9576, 15435, 19, 3505, 17764, 4316, 1787, 13007, 18009, 9779, 18275, 1377, 14062, 15198, 19741, 13490, 2185, 12913, 11122, 15561, 14571, 1264, 15930, 7438, 4912, 60, 11273, 10525, 11943, 17918, 17143, 7987, 12895, 4804, 1725, 951, 262, 2898, 10370, 16138, 14211, 15100, 1158, 6526, 18092, 2787, 9751, 7975, 1961, 8816, 19370, 12446, 9407, 8997, 4785, 215, 5810, 17683, 18280, 11583, 3288, 13334, 15500, 8451, 13093, 7969, 8957, 6713, 2215, 5618, 1537, 19733, 7634, 7520, 12113, 10079, 9386, 164, 4571, 9574, 3356, 3570, 12154, 16887, 13840, 12027, 2340, 1300, 5001, 12893, 7398, 3994, 6625, 15396, 11031, 7015, 15580, 3352, 10957, 8094, 13800, 3181, 13783, 17527, 6714, 13001, 13337, 19101, 5986, 9262, 3346, 12595, 10302, 5009, 13728, 1908, 16094, 6507, 3082, 1012, 7595, 9117, 15514, 16379, 1719, 5337, 16588, 13151, 5389, 2022, 9854, 10220, 5669, 19014, 6697, 1549, 577, 1794, 15790, 7937, 10688, 7554, 9683, 7683, 11881, 12077, 8050, 9254, 8139, 13640, 5718, 11561, 7424, 8409, 7011, 16483, 15330, 13596, 17496, 15616, 9346, 3130, 206, 15686, 7876, 4921, 16042, 15467, 9353, 3514, 12506, 11784, 18491, 7930, 14873, 4704, 14012, 4890, 3185, 132, 19093, 6564, 14116, 3381, 8488, 16975, 8755, 1468, 15382, 1444, 17427, 1454, 18837, 4545, 16871, 6032, 11588, 15071, 15830, 8254, 301, 19458, 13466, 13720, 1168, 4014, 10063, 14299, 16225, 5901, 8413, 9464, 11928, 3053, 10785, 17458, 16900, 7337, 12373, 2028, 10124, 3012, 6311, 15769, 17763, 8276, 16805, 14539, 5183, 13771, 5717, 19718, 3801, 7854, 6288, 3808, 4138, 12148, 7562, 11093, 9860, 5380, 7040, 323, 8608, 18439, 19461, 13626, 18834, 10911, 5036, 11343, 2244, 7365, 17287, 9580, 15891, 18315, 16749, 3397, 8116, 9869, 10578, 12415, 3730, 17539, 16331, 18465, 13923, 19536, 540, 7558, 12847, 1162, 15287, 13589, 4781, 3674, 6060, 11188, 7304, 19289, 7824, 19230, 4275, 4071, 6212, 9076, 12083, 1241, 19508, 8149, 3483, 3487, 14775, 7198, 4311, 9641, 19932, 8235, 11998, 8758, 18835, 9589, 18043, 9733, 17452, 16287, 14588, 11157, 4243, 10603, 16478, 3767, 102, 13717, 6965, 4988, 10144, 9541, 7152, 13665, 11473, 19891, 19391, 11140, 1826, 5473, 7364, 12517, 6503, 6232, 3016, 9022, 7813, 3669, 15537, 1803, 18026, 13768, 12252, 479, 900, 19332, 17740, 16719, 3437, 12004, 7260, 11657, 18587, 13910, 13566, 11610, 3866, 3118, 13179, 5228, 11996, 9643, 19113, 16856, 7859, 10218, 13876, 10675, 5836, 1042, 19868, 14368, 3881, 15499, 3697, 5818, 4180, 11101, 6715, 11887, 5307, 14285, 831, 8778, 15629, 2187, 16454, 15193, 4163, 1287, 2217, 1497, 16798, 3685, 12860, 15655, 12955, 2197, 12531, 8500, 6631, 7515, 13693, 7540, 3357, 6152, 8587, 6894, 1720, 921, 5954, 6010, 9721, 8131, 7173, 8462, 7513, 345, 9725, 2676, 8051, 11635, 15557, 14425, 723, 15521, 17694, 3956, 5060, 2443, 13157, 17129, 14210, 6480, 17505, 9578, 4447, 7691, 16239, 12630, 2202, 7338, 15938, 19945, 622, 6852, 2567, 19779, 16178, 12061, 10971, 7178, 7330, 15693, 14463, 13860, 5974, 8461, 8099, 5989, 7804, 18685, 13302, 7744, 19033, 16882, 5038, 13604, 5508, 3136, 6402, 11210, 15795, 11332, 6734, 5310, 5072, 15312, 9510, 4161, 74, 15698, 7677, 17267, 9392, 18569, 7754, 16848, 14473, 12901, 5870, 10348, 12550, 14871, 2717, 11930, 10760, 1909, 2384, 3067, 5967, 13899, 5287, 1436, 6012, 2034, 5373, 15562, 4651, 858, 18028, 15540, 8858, 7098, 15922, 13371, 9536, 8128, 3696, 15151, 14874, 6534, 10982, 19950, 4112, 11687, 438, 1772, 5538, 7078, 7383, 19259, 8505, 3265, 5664, 5114, 11499, 4531, 4453, 5642, 1595, 8584, 10023, 19608, 18096, 4345, 5760, 8965, 19207, 18863, 16790, 15752, 2432, 14823, 12473, 13207, 4894, 18710, 16737, 12823, 12949, 4132, 11832, 3404, 5908, 17108, 664, 15928, 12479, 5506, 11350, 19188, 19576, 13471, 3298, 18383, 8652, 11391, 10054, 17292, 17609, 11791, 10323, 16743, 1260, 19256, 7998, 16182, 4419, 9547, 2121, 16039, 7891, 13616, 2749, 4569, 7862, 4819, 15872, 771, 4110, 10364, 8558, 17184, 2444, 10343, 2163, 11492, 16824, 19057, 10721, 10178, 15792, 14115, 1758, 17167, 12622, 8144, 14814, 16942, 1664, 4397, 2082, 3335, 10541, 18172, 3091, 7114, 714, 3066, 18904, 12260, 5687, 4239, 11799, 16201, 14562, 16509, 1925, 18778, 13653, 4834, 11532, 11359, 11940, 3319, 17460, 5905, 12450, 7121, 7237, 17658, 4865, 13677, 15206, 2146, 6937, 18723, 14069, 15181, 7111, 13688, 9598, 5736, 4198, 7551, 7784, 14095, 16747, 11290, 15507, 4621, 11964, 8975, 2974, 11264, 12907, 10519, 8423, 8203, 14365, 14844, 7833, 18799, 6988, 19091, 11993, 7153, 12889, 7601, 9717, 1382, 17067, 2057, 13898, 4147, 7440, 959, 2634, 16911, 1938, 7988, 11908, 1126, 10445, 11129, 5129, 8143, 13456, 5363, 14629, 10048, 18920, 7636, 11776, 9630, 7348, 19598, 11936, 15309, 18299, 15434, 17668, 8862, 11707, 15805, 17330, 15767, 19224, 4438, 18761, 18433, 5585, 17488, 10520, 4078, 9034, 12696, 7793, 6123, 9311, 2538, 17304, 11616, 16099, 6794, 10685, 6084, 16366, 9369, 7664, 17717, 13282, 6482, 10658, 12418, 19488, 6908, 8365, 8036, 16720, 17166, 12228, 19818, 7400, 10811, 6119, 10280, 16833, 5274, 2637, 3271, 2254, 15425, 3653, 10863, 2332, 2880, 8274, 8963, 6096, 16761, 19480, 1055, 8552, 18023, 3726, 15162, 8082, 1499, 3205, 15687, 9344, 18333, 17648, 4493, 19680, 851, 288, 6873, 12114, 13873, 14514, 17877, 4228, 14933, 5644, 3236, 6662, 7109, 1115, 5058, 2507, 7416, 7215, 12447, 2253, 14253, 14515, 888, 2032, 4429, 1954, 4868, 2877, 4418, 17568, 14605, 10069, 17546, 11972, 4840, 1739, 8749, 12669, 16618, 4013, 10544, 2128, 19827, 19522, 11447, 11566, 3589, 5180, 18117, 2394, 17553, 13222, 2018, 15271, 14166, 1558, 7461, 16302, 17845, 6624, 14566, 1555, 2892, 2488, 8467, 19757, 746, 14523, 3931, 8811, 19287, 3845, 17249, 15111, 19543, 11743, 2772, 1200, 3822, 4809, 378, 17369, 3057, 18119, 1406, 6453, 7545, 11544, 654, 14156, 3744, 7473, 3036, 499, 1749, 11172, 8434, 11626, 2349, 88, 17725, 8600, 18548, 107, 17197, 19655, 4562, 7941, 17255, 11788, 17980, 13076, 10672, 6584, 2887, 566, 12786, 5140, 7084, 3157, 16676, 3256, 5743, 19170, 2043, 17566, 11075, 8372, 1547, 3737, 11099, 18080, 16626, 19136, 5542, 17669, 9018, 19809, 10223, 13105, 337, 16964, 7039, 13849, 772, 16983, 19919, 2670, 5773, 14433, 7433, 79, 1219, 5897, 12118, 3684, 17343, 10793, 1112, 1313, 12560, 4285, 4719, 4556, 18586, 11238, 6899, 11336, 13582, 1030, 3902, 9901, 4420, 9325, 15707, 8147, 19833, 9698, 5278, 10306, 14291, 1543, 11682, 7587, 11609, 11346, 2581, 13216, 1526, 19386, 6651, 1606, 13886, 15251, 7721, 5929, 15844, 5888, 4244, 13182, 10254, 4639, 2874, 18691, 7353, 19462, 14252, 15456, 14623, 14016, 3555, 17482, 13428, 19349, 10404, 558, 12755, 5779, 12000, 18518, 17842, 13564, 14310, 16006, 2884, 1841, 1691, 13219, 12129, 12067, 14221, 338, 7388, 16701, 18955, 1001, 14413, 14611, 17801, 19532, 13349, 19439, 17693, 3461, 3166, 12149, 152, 8943, 16369, 6223, 6069, 18786, 17865, 2133, 2760, 11851, 2638, 19822, 6440, 9005, 2331, 17223, 6993, 12535, 10542, 18897, 8326, 8486, 9534, 11671, 1890, 19908, 19909, 18121, 16045, 18661, 80, 4065, 10543, 7126, 15842, 17970, 9579, 5126, 17644, 671, 1, 17521, 9924, 1734, 16425, 11071, 18072, 2648, 19118, 15670, 18054, 14323, 6617, 13523, 2675, 1038, 3106, 10282, 16957, 10846, 19315, 3117, 9427, 18471, 16259, 15756, 10596, 8936, 5141, 5895, 913, 8454, 16167, 3858, 13547, 9568, 16556, 2726, 15541, 12519, 308, 15907, 15925, 10469, 14001, 11374, 260, 3864, 2823, 7866, 15047, 10423, 5591, 9762, 11723, 9007, 10772, 10459, 8049, 6900, 15970, 15662, 6202, 2400, 6048, 9772, 1713, 6987, 10764, 6027, 15888, 17295, 11469, 6173, 5354, 17926, 5780, 19602, 3865, 271, 2284, 464, 8127, 6821, 15585, 14950, 14664, 8100, 12134, 19374, 11277, 1750, 1228, 6676, 691, 15941, 7370, 13273, 240, 15290, 4204, 582, 12709, 5701, 15961, 18642, 10694, 5526, 330, 18352, 2395, 5724, 5703, 2024, 15170, 19867, 15878, 13568, 11240, 16407, 17608, 4293, 1063, 17631, 15160, 19261, 9104, 9907, 15432, 9948, 15420, 11849, 187, 7110, 3180, 13521, 16061, 14766, 3142, 19095, 19644, 372, 19229, 8812, 19283, 5713, 10081, 10812, 10645, 17540, 1866, 13150, 14101, 19880, 3367, 10003, 19569, 9475, 12681, 16714, 17788, 17128, 5632, 15944, 4695, 18071, 12368, 15836, 1419, 10830, 5057, 9526, 10134, 4456, 16072, 13746, 11443, 18716, 17485, 19418, 16471, 18737, 4335, 5331, 16545, 16759, 8315, 12589, 10036, 17418, 19351, 18291, 6747, 10925, 15890, 18313, 11065, 19214, 15592, 2232, 15778, 14181, 465, 14449, 9718, 12964, 11402, 1850, 8860, 1140, 9294, 15673, 15203, 13121, 12366, 15531, 4550, 18842, 2464, 17296, 4237, 11819, 1125, 9949, 9285, 19612, 4384, 434, 6629, 12638, 10696, 5257, 12442, 14162, 2712, 7893, 3629, 12458, 2935, 10551, 8710, 11403, 6162, 10245, 14567, 10073, 17697, 16192, 17640, 6452, 4483, 17681, 7534, 7417, 15630, 8879, 13172, 12441, 9077, 19309, 18855, 17578, 18888, 3770, 5135, 14241, 4974, 16202, 5992, 4141, 10861, 12797, 15129, 19527, 14295, 14695, 12174, 11717, 4897, 11088, 9358, 7502, 9545, 15510, 9964, 3420, 10251, 6541, 17110, 5665, 9273, 7640, 13436, 4140, 14342, 17785, 2871, 19410, 8790, 11395, 882, 3493, 9612, 14912, 10384, 17190, 2134, 7814, 5597, 7860, 10176, 263, 8007, 14120, 17219, 3436, 12792, 4602, 12040, 4039, 7394, 15012, 13660, 14049, 1273, 16184, 8952, 11456, 17750, 14078, 14752, 4664, 3585, 11767, 11253, 2580, 19191, 4759, 8134, 13907, 10356, 11822, 1420, 16958, 3945, 10892, 6192, 16552, 12013, 14158, 17377, 11484, 3889, 439, 3040, 19431, 11090, 3650, 7885, 15038, 1736, 19976, 91, 1010, 15191, 10344, 4959, 4836, 13581, 4103, 3942, 13465, 103, 7210, 11372, 18250, 7555, 3603, 17610, 1804, 9250, 16455, 2885, 17410, 19756, 17530, 8639, 2719, 14792, 19643, 5725, 729, 9936, 17634, 6596, 13773, 11745, 16608, 899, 9689, 4012, 7287, 13392, 4860, 10222, 5341, 2780, 5768, 19773, 8343, 16218, 807, 2799, 3506, 10387, 12227, 8039, 4839, 7566, 18989, 17861, 14517, 4700, 13557, 5402, 13711, 11410, 6333, 16051, 19302, 18965, 19330, 7652, 10595, 13293, 15598, 15041, 10873, 6871, 4114, 16023, 6001, 998, 3072, 6062, 5566, 12461, 18224, 396, 12886, 7100, 4944, 16078, 9560, 18038, 12121, 8938, 15804, 12183, 8303, 7147, 18473, 19122, 3194, 1656, 7685, 8220, 14311, 17144, 875, 18745, 2498, 12805, 6055, 13122, 9836, 5186, 653, 12772, 12209, 2045, 8178, 17552, 17252, 12603, 16149, 15535, 640, 15785, 12854, 628, 3966, 9187, 12841, 15716, 11431, 8248, 16346, 19734, 16451, 936, 7727, 15044, 19679, 11997, 10330, 10101, 15200, 17833, 2235, 12032, 1046, 7575, 9269, 15029, 19329, 16168, 19075, 13, 4931, 19049, 633, 9029, 11952, 12175, 8933, 1539, 14519, 6450, 17972, 5445, 193, 6875, 2532, 18237, 1773, 1061, 11337, 19141, 8253, 5348, 3098, 5706, 12208, 18581, 14427, 15296, 18012, 12712, 10089, 12304, 1531, 8929, 100, 13545, 1783, 2492, 19698, 5899, 6276, 10629, 2923, 9599, 5117, 11941, 11876, 15772, 3518, 2551, 11677, 2556, 14905, 1423, 12900, 7659, 9740, 7927, 597, 12843, 5578, 1166, 6524, 15096, 17208, 8347, 7585, 6621, 14984, 13603, 2987, 12799, 5529, 12853, 5482, 750, 8709, 17104, 14256, 966, 4832, 19971, 15539, 811, 15661, 4247, 7083, 12145, 2358, 10199, 280, 6376, 4756, 8947, 2387, 551, 1398, 13164, 3646, 10314, 45, 12219, 1948, 11654, 3509, 3905, 1415, 16469, 7538, 6498, 10621, 4033, 11675, 11173, 4506, 10270, 19015, 14136, 2680, 6771, 13092, 2111, 4002, 14489, 16411, 19059, 7703, 1869, 1981, 17700, 8391, 18435, 14304, 8852, 3389, 13929, 7176, 5722, 7959, 3516, 5317, 2958, 10349, 1727, 5796, 11786, 17793, 15536, 12516, 17392, 17943, 1248, 5358, 11109, 7341, 17543, 17751, 5607, 14791, 6760, 18500, 17245, 2671, 2298, 1683, 8508, 17345, 14518, 408, 12131, 17840, 3601, 18790, 2710, 4953, 10713, 5443, 16010, 19164, 16262, 6061, 9995, 4754, 15013, 5275, 11769, 1426, 12132, 19563, 4772, 14303, 17376, 8725, 19459, 14940, 8883, 13053, 18220, 10550, 16768, 14959, 1295, 9527, 15980, 8146, 12276, 13224, 4478, 12657, 18206, 7106, 15321, 4736, 3022, 9102, 12474, 15057, 14679, 12035, 19146, 6939, 9981, 16016, 14426, 17721, 10193, 12686, 450, 14549, 13912, 9059, 12932, 4044, 761, 13088, 16803, 7787, 3528, 8285, 17378, 19409, 4097, 8256, 18243, 19070, 1566, 16341, 522, 14008, 10212, 1631, 18161, 11817, 9724, 1517, 7367, 2753, 15314, 2307, 18347, 5254, 8322, 10037, 367, 3901, 11040, 6331, 13535, 19139, 4202, 17164, 13522, 19025, 14086, 11125, 12332, 12582, 5195, 18782, 13789, 8041, 2848, 5614, 13946, 6992, 17479, 5076, 5946, 5659, 4940, 8692, 19088, 4436, 2020, 18990, 16730, 3810, 2137, 5128, 14336, 2912, 1456, 11761, 9992, 5766, 3230, 3409, 7504, 8136, 7020, 9810, 2272, 15631, 4063, 15614, 14665, 6891, 138, 8247, 19135, 11579, 11012, 14718, 2863, 9211, 12911, 7452, 7943, 15659, 14969, 6970, 18563, 17714, 7693, 6603, 9274, 6099, 7399, 8708, 14498, 183, 5765, 11437, 5805, 13505, 570, 14045, 6147, 17769, 1561, 857, 8670, 17493, 18596, 17563, 1274, 3654, 3781, 18106, 13407, 8025, 10318, 19348, 8457, 1600, 12172, 571, 16948, 7236, 2953, 14217, 12521, 17698, 1003, 19819, 13100, 943, 2258, 18222, 18388, 11339, 3834, 18764, 7256, 14447, 2663, 298, 8379, 11498, 1706, 12074, 10640, 8743, 14320, 7909, 1385, 12192, 13816, 6964, 1828, 5398, 3331, 3426, 11667, 17814, 15190, 12693, 10030, 9247, 1479, 10845, 13475, 10499, 10673, 6979, 7134, 6935, 17193, 17058, 15889, 17463, 15370, 11794, 7380, 14155, 12001, 11627, 18795, 3302, 3644, 9509, 11552, 16963, 11313, 17554, 12220, 12501, 12041, 18209, 18164, 2077, 175, 950, 3377, 17391, 13851, 15228, 10798, 5657, 13161, 4538, 15345, 4841, 11855, 1873, 4978, 15319, 14364, 19182, 12277, 16093, 15950, 39, 2164, 2114, 14502, 1941, 259, 12802, 10158, 382, 11829, 11929, 3672, 6689, 15136, 2766, 19483, 6279, 11285, 5741, 1011, 5934, 16424, 19716, 11163, 16830, 2543, 1513, 8140, 4484, 13617, 3729, 7674, 224, 1862, 10406, 2941, 13654, 16186, 13518, 7884, 3171, 16841, 909, 9451, 8995, 19917, 11625, 17162, 3100, 16955, 13127, 5953, 8877, 5116, 17749, 17646, 9253, 3322, 18394, 18017, 9173, 16459, 13537, 8482, 1991, 4805, 343, 17347, 11858, 10322, 6994, 4919, 17561, 7200, 6781, 3724, 16161, 16392, 18687, 8362, 14479, 10651, 19689, 3670, 7080, 16725, 798, 17088, 5365, 2559, 10771, 11491, 11375, 16439, 8162, 10043, 2359, 17332, 17174, 19392, 4642, 11039, 9379, 19807, 5394, 10019, 2989, 15847, 11028, 1319, 14411, 4576, 13971, 1122, 19124, 14367, 12714, 12773, 11857, 17250, 2683, 17503, 15512, 11886, 1321, 15327, 16374, 4842, 12203, 11382, 10665, 2672, 13806, 19039, 10263, 703, 18208, 1676, 11924, 15718, 9012, 11035, 11691, 9023, 13811, 18378, 4133, 7612, 11700, 5883, 907, 1607, 5812, 8123, 18357, 12605, 10386, 6275, 5464, 15133, 12551, 13740, 19433, 19953, 15708, 17560, 17216, 3811, 3957, 11907, 17456, 11304, 10956, 8350, 13013, 18758, 11958, 9566, 6724, 12666, 73, 4089, 17556, 9366, 14338, 12389, 2312, 13698, 4298, 5447, 19894, 8342, 10995, 6408, 16820, 7890, 4669, 12798, 15782, 3977, 4461, 13992, 6418, 11599, 10554, 14557, 8415, 19204, 9519, 2643, 15534, 11873, 6372, 18403, 17783, 3872, 17825, 8217, 12824, 7309, 12235, 18866, 213, 16521, 1745, 4049, 8888, 696, 12380, 2606, 16403, 12210, 19677, 15894, 19509, 11534, 8531, 5788, 15898, 7503, 7645, 14041, 6335, 19529, 13813, 10244, 172, 3240, 18384, 8632, 7116, 13069, 4723, 14408, 5611, 1053, 4427, 12906, 19293, 15481, 5409, 9208, 9909, 1935, 18307, 4367, 13236, 17528, 9551, 18331, 18623, 5151, 18907, 7499, 2344, 13074, 7843, 2939, 7537, 11149, 16868, 16776, 8502, 3681, 3134, 10738, 9327, 14815, 896, 5359, 3873, 14496, 11727, 16786, 8539, 1570, 16110, 13631, 11299, 4414, 9010, 14213, 16029, 4627, 11103, 10851, 19725, 16781, 10467, 16091, 2657, 242, 7878, 9216, 5798, 1071, 9870, 14525, 18908, 15814, 10190, 9775, 14994, 16430, 10781, 3165, 1716, 12434, 7838, 11782, 1603, 16069, 5461, 3422, 3484, 18826, 14512, 17516, 5496, 12002, 17012, 4909, 5916, 6826, 16649, 12281, 16067, 1009, 5266, 11369, 2476, 5132, 11662, 11592, 3368, 17860, 6815, 11607, 16241, 3453, 16311, 18316, 15676, 2493, 18066, 13506, 8983, 11597, 14737, 590, 4351, 19808, 5577, 15088, 3949, 9852, 8068, 3019, 10051, 17934, 887, 10754, 16361, 1525, 7948, 7898, 8759, 3372, 17758, 11535, 2545, 9794, 6658, 2063, 5031, 1425, 11712, 8416, 8805, 16886, 6544, 13376, 842, 19334, 7574, 934, 20000, 18253, 18508, 10849, 9916, 16633, 18386, 5413, 12430, 4590, 13543, 6716, 830, 8011, 6956, 16419, 4778, 5248, 7759, 8175, 4171, 6144, 19246, 8580, 15391, 10857, 4232, 13233, 17677, 15684, 10371, 19110, 9616, 13739, 12974, 4516, 18226, 9807, 17914, 14448, 13826, 14346, 12528, 347, 16606, 1715, 4303, 16076, 14047, 15886, 6313, 7181, 14712, 19087, 18210, 10583, 12089, 4623, 16400, 6990, 17686, 7607, 18702, 5115, 14556, 9861, 15787, 13587, 6053, 14872, 9436, 3435, 17244, 9664, 14729, 6665, 635, 2690, 17702, 5514, 5962, 18678, 2828, 8317, 19114, 11373, 13163, 17191, 3042, 5134, 2957, 8107, 11488, 19731, 4378, 10336, 3820, 18283, 11279, 12894, 19778, 11424, 7419, 6955, 16810, 19817, 4794, 6765, 8377, 17014, 2694, 9301, 19058, 3097, 10488, 2827, 12432, 4370, 5086, 6591, 5300, 8809, 19028, 1157, 1998, 2181, 10732, 19467, 5655, 11536, 6876, 16941, 2380, 2445, 14474, 2297, 8282, 13571, 4082, 14528, 5311, 11287, 14003, 1701, 15033, 6136, 19830, 15127, 10765, 7966, 2859, 4155, 6831, 1565, 2105, 804, 8223, 10903, 6014, 4405, 9181, 4443, 10802, 84, 5862, 13451, 9925, 13260, 1346, 4497, 264, 15014, 4879, 4381, 17315, 4665, 7085, 12451, 16914, 6630, 15788, 1298, 17257, 6044, 5059, 2916, 11925, 3830, 17885, 1577, 13988, 14257, 15347, 3593, 17929, 13262, 16112, 5444, 8991, 9467, 11367, 7623, 14118, 14443, 9043, 2510, 5770, 459, 332, 9364, 4587, 6845, 12317, 10900, 11295, 16539, 13026, 4949, 17007, 4358, 3005, 1741, 7263, 13900, 9469, 8200, 11152, 8193, 12687, 15985, 13630, 11181, 10359, 8912, 14550, 8607, 2184, 8185, 7649, 15268, 13824, 5463, 17453, 19159, 13733, 15285, 2742, 8622, 18756, 15230, 15383, 19562, 4054, 10865, 14617, 1283, 18312, 9805, 18644, 17844, 2802, 14119, 4981, 16324, 6746, 9841, 963, 12018, 6824, 2194, 9742, 6412, 19107, 16554, 4045, 13894, 4426, 16710, 18636, 905, 4508, 15122, 12480, 2779, 13625, 19451, 2945, 7736, 12122, 14902, 1482, 12137, 6019, 6971, 799, 9853, 17581, 10612, 10838, 414, 15428, 8793, 19266, 15559, 8392, 14499, 1386, 3531, 1502, 16252, 18585, 15028, 15609, 5705, 11697, 15385, 18934, 5558, 6272, 19585, 3229, 18401, 250, 16181, 3955, 2037, 10890, 17921, 4135, 2053, 18736, 55, 405, 17745, 12866, 4875, 8410, 11550, 12443, 11655, 390, 16998, 16861, 546, 8152, 6157, 6400, 3457, 14983, 15552, 13052, 7088, 2421, 19446, 9038, 1339, 9802, 8861, 17366, 16220, 18395, 5579, 6887, 7430, 16917, 19886, 3805, 16661, 11190, 19787, 12287, 11763, 483, 7660, 17810, 16763, 19541, 17643, 9622, 7167, 14876, 7568, 15820, 12006, 312, 180, 16172, 5728, 7227, 10955, 13787, 6149, 9671, 18593, 3637, 11123, 12091, 11399, 10835, 11376, 15131, 2124, 19714, 7716, 18454, 15369, 7030, 8613, 9055, 15660, 18724, 8344, 17047, 9823, 15710, 6535, 4901, 9675, 18485, 1083, 1291, 7682, 2521, 10518, 17838, 4193, 292, 6748, 7542, 15202, 5667, 8133, 17692, 16402, 690, 7202, 2450, 4982, 13895, 12590, 6764, 11310, 3993, 745, 4936, 13321, 9976, 14943, 17312, 16695, 10557, 2752, 15252, 10326, 18213, 535, 8649, 18927, 18296, 11417, 13619, 14966, 7463, 14846, 3759, 14387, 14910, 1740, 10232, 151, 16092, 6035, 17446, 9340, 2770, 17450, 12656, 15857, 5284, 5671, 469, 15801, 4513, 15636, 18452, 18753, 11483, 9263, 5081, 14309, 3967, 7435, 7741, 14888, 7350, 12626, 9521, 7620, 5037, 16163, 5793, 13075, 3275, 15511, 11107, 5683, 7872, 13474, 8680, 13140, 13314, 15374, 13871, 9842, 424, 18476, 1653, 15017, 5312, 9710, 12163, 4226, 12117, 14228, 2281, 11805, 13497, 15803, 1834, 5656, 938, 501, 342, 9669, 9500, 6497, 9081, 2819, 3476, 8102, 6531, 14909, 177, 12862, 8211, 2608, 14357, 4020, 3964, 1090, 13729, 207, 1951, 12162, 8771, 9050, 9998, 3411, 4402, 12855, 5329, 3358, 3090, 5942, 592, 6700, 3030, 13020, 13374, 87, 19846, 14020, 7289, 12364, 7022, 4203, 19672, 14198, 6487, 3768, 19770, 18144, 13500, 5017, 14761, 15069, 13087, 15919, 16905, 1047, 10381, 12904, 2774, 8524, 2921, 11750, 10446, 2951, 5170, 15491, 15618, 10408, 5488, 3095, 11072, 8985, 12990, 16885, 11076, 13870, 223, 18880, 6864, 10329, 16015, 5935, 7315, 12928, 12968, 10856, 10438, 1864, 8628, 13296, 10249, 12144, 6598, 2413, 17962, 6929, 2562, 15386, 11518, 8678, 5396, 4067, 13990, 12723, 19274, 13048, 16328, 14773, 12953, 933, 15064, 8919, 16952, 8648, 18597, 8627, 2237, 12737, 3797, 14500, 12247, 7857, 16893, 11875, 12057, 8376, 7611, 6080, 8647, 7472, 10799, 4863, 17891, 5281, 10290, 4765, 11116, 1540, 12303, 9222, 5487, 14865, 17937, 11252, 6429, 15737, 4843, 5772, 10737, 8163, 6740, 14122, 8026, 12759, 4277, 15667, 11969, 15214, 7511, 3796, 15685, 14236, 6806, 4711, 13347, 8773, 17588, 1902, 16059, 14868, 5677, 15387, 161, 19765, 13940, 16081, 11836, 8934, 11292, 14495, 16176, 14560, 12524, 2039, 6087, 14765, 13491, 8196, 12877, 19000, 9257, 5552, 18937, 13673, 11241, 15281, 482, 1068, 8497, 16793, 4533, 190, 53, 12938, 13646, 13375, 15266, 10246, 8817, 10378, 9039, 10390, 7137, 18708, 19485, 10186, 17444, 8789, 13957, 19421, 2857, 11255, 6604, 13573, 16083, 18991, 8313, 10965, 17541, 18812, 1776, 5046, 6565, 14860, 10179, 7990, 964, 17154, 1213, 13628, 19078, 12865, 6842, 9271, 11036, 15242, 11275, 5440, 5948, 12318, 19730, 14135, 18336, 12757, 10940, 11221, 16907, 12327, 16691, 3803, 17803, 11548, 7201, 13694, 1611, 12650, 6795, 2544, 304, 19017, 3917, 6321, 16836, 16953, 10350, 5612, 13461, 13935, 3161, 10042, 10933, 5904, 9685, 2536, 13972, 13372, 2017, 9930, 10585, 10032, 14160, 3204, 9963, 12625, 19938, 11442, 6356, 1591, 11005, 16839, 7931, 4178, 13645, 14077, 14576, 16257, 2458, 3479, 388, 19286, 361, 8420, 12884, 11100, 14916, 18424, 399, 4366, 18251, 7401, 72, 8428, 11471, 10926, 6599, 2553, 19628, 6, 6057, 6846, 18149, 19284, 5595, 18980, 1601, 7524, 13251, 5218, 17502, 12608, 16565, 1660, 15059, 1069, 10728, 8575, 8904, 5412, 15421, 4954, 17412, 1556, 18802, 8941, 19127, 6610, 8927, 6020, 18482, 17859, 1256, 1081, 2294, 10514, 10720, 19832, 4410, 6709, 6502, 1471, 8898, 19505, 3366, 11800, 14798, 19301, 4282, 3962, 14378, 12740, 3127, 11878, 15340, 18135, 18935, 4504, 4612, 6770, 17092, 932, 15505, 17624, 2814, 5933, 6121, 13025, 2328, 16024, 10288, 17254, 10584, 13144, 17348, 12952, 7539, 644, 8301, 14900, 839, 10122, 11759, 7929, 11891, 17096, 3079, 15010, 12226, 3690, 6906, 1587, 10616, 17599, 9573, 16211, 18122, 13063, 6231, 18964, 4857, 715, 3353, 15632, 2046, 4892, 2223, 6024, 12323, 18929, 2269, 17718, 16513, 284, 4864, 6179, 11781, 16159, 11351, 10667, 5590, 471, 16319, 11856, 2831, 17984, 5078, 17454, 10862, 5530, 2612, 13594, 11209, 11002, 10388, 16827, 5099, 4055, 3766, 19659, 14446, 18565, 15188, 4586, 1032, 13776, 7374, 1120, 6343, 10908, 6155, 6282, 10197, 10682, 6797, 5190, 8103, 12115, 19344, 6081, 6880, 15594, 6972, 2659, 5919, 6349, 4806, 18002, 4118, 16605, 6389, 15939, 16089, 7638, 18601, 12497, 11732, 9048, 14883, 63, 716, 8056, 12078, 13815, 2588, 7267, 10184, 18567, 14418, 18406, 11709, 16997, 10844, 626, 10454, 7768, 19774, 19235, 18343, 8786, 823, 11361, 13193, 1052, 8513, 747, 4969, 11699, 15812, 12107, 578, 15307, 5483, 15353, 7451, 561, 2025, 17307, 2928, 15225, 19307, 11111, 12694, 16722, 11018, 7441, 16102, 6076, 2216, 5635, 12980, 12412, 2858, 10031, 8719, 9455, 5023, 19667, 11148, 19251, 6643, 8396, 860, 4934, 2808, 699, 10285, 1007, 1546, 17422, 7272, 15276, 96, 11620, 19429, 4956, 14431, 10435, 8065, 2452, 2785, 645, 3704, 6063, 5022, 16679, 10981, 4987, 11529, 2761, 14014, 1714, 5603, 163, 7323, 1807, 11837, 17652, 6409, 12099, 4374, 17510, 15931, 7823, 6398, 1917, 16501, 2795, 7669, 7439, 11446, 9418, 8316, 472, 7776, 37, 4394, 16796, 14481, 9839, 13258, 11734, 15146, 14222, 1014, 1487, 19194, 12459, 1472, 15070, 9661, 13755, 1944, 18373, 10964, 3614, 18610, 19326, 18621, 17899, 11854, 15643, 1647, 15909, 8804, 12271, 18894, 7281, 11115, 19347, 14621, 15329, 10746, 15361, 16625, 19340, 16, 10057, 15694, 4939, 8869, 17072, 18613, 11081, 6326, 16011, 15867, 8733, 18000, 5803, 9356, 3565, 19172, 2116, 1358, 1529, 1163, 12986, 4537, 16980, 8825, 17672, 10403, 9494, 5617, 11156, 19645, 7844, 1193, 6437, 6654, 10567, 2820, 2225, 11554, 10375, 18549, 6525, 12166, 12258, 3608, 16280, 16108, 679, 14451, 1221, 9782, 8896, 4095, 7422, 7443, 12133, 4299, 12052, 11054, 10575, 9987, 4820, 1195, 3415, 3627, 4440, 19862, 5243, 9215, 5044, 18631, 13409, 17868, 13033, 10070, 2938, 6317, 996, 3701, 17533, 9946, 17148, 1458, 4775, 3132, 8215, 18295, 13905, 2072, 6251, 18068, 14111, 15671, 9588, 4413, 16284, 13313, 6800, 7052, 2860, 2125, 17056, 9136, 18611, 18389, 9097, 17486, 1452, 3885, 1337, 3421, 5185, 17272, 6088, 3700, 9442, 6159, 7686, 10001, 16495, 5067, 12685, 17591, 15736, 1536, 10481, 4183, 18330, 4687, 940, 16188, 15666, 7531, 19400, 19443, 10028, 5226, 10778, 10912, 16479, 2106, 19995, 1490, 17351, 14424, 17340, 13780, 17300, 2627, 10207, 13561, 2252, 11177, 13810, 11537, 9219, 5809, 17797, 16546, 2552, 6301, 17663, 1392, 15773, 7715, 2867, 15205, 6543, 8694, 701, 10118, 12361, 16482, 5497, 3227, 2119, 6287, 15423, 4551, 376, 16825, 1593, 19250, 1966, 11704, 8306, 10622, 18340, 9879, 4977, 1164, 15132, 11785, 19998, 18281, 13300, 14400, 11355, 9363, 9272, 3318, 17095, 9158, 14777, 12161, 1095, 10516, 5925, 17969, 17308, 9701, 10016, 2826, 8269, 4286, 8458, 15381, 5660, 15365, 19597, 14370, 2647, 10468, 10635, 4371, 12939, 4769, 10801, 15904, 19652, 117, 8076, 5437, 8083, 19165, 16195, 10960, 7570, 9202, 6068, 141, 1438, 19318, 17373, 9867, 13622, 6366, 16683, 15011, 12457, 17141, 8499, 11271, 19568, 5882, 6559, 4895, 29, 10710, 12989, 12311, 19232, 14293, 12194, 10129, 3111, 10058, 4905, 7448, 7783, 326, 5797, 17015, 7139, 15213, 12539, 12127, 18592, 13348, 4024, 1191, 6058, 2625, 19611, 5645, 5867, 8874, 4923, 726, 17291, 19310, 121, 7924, 7317, 2144, 14025, 8697, 2283, 4591, 1657, 13757, 6220, 4824, 16164, 8053, 7103, 5757, 8124, 5744, 743, 1403, 14627, 416, 9811, 8905, 19285, 5154, 17459, 2341, 608, 10839, 8330, 16972, 2695, 11689, 12933, 649, 17595, 16468, 11444, 9902, 11229, 11243, 18069, 12390, 16129, 14858, 19781, 6738, 17388, 329, 4662, 614, 12779, 4670, 5737, 11474, 4558, 17382, 7094, 17025, 8164, 9735, 18686, 2051, 17730, 15477, 2286, 10256, 912, 205, 12213, 11948, 13152, 9456, 7382, 17354, 13368, 13231, 18200, 8714, 641, 13112, 7986, 1312, 114, 19715, 13249, 1923, 10379, 10482, 4544, 6129, 13675, 10430, 12897, 13366, 13024, 2087, 11176, 2078, 1978, 2767, 4578, 5063, 15264, 2681, 4219, 9577, 16573, 2094, 18201, 12476, 13029, 7688, 10064, 11340, 15399, 7053, 16642, 4262, 5391, 7261, 6379, 10752, 10564, 10837, 19969, 15810, 110, 8431, 15476, 10077, 11619, 1903, 848, 7899, 11773, 16828, 8866, 4762, 19112, 6208, 19371, 18578, 4631, 19518, 815, 14750, 15637, 3278, 11068, 14971, 15118, 8724, 17904, 12785, 16007, 1065, 315, 3208, 10004, 14822, 15611, 18183, 16867, 11917, 12237, 7029, 13117, 2666, 2348, 525, 1583, 12610, 885, 15831, 1357, 19355, 17298, 16541, 6601, 2351, 18532, 10313, 11191, 204, 12500, 15235, 18279, 4742, 7172, 6290, 5485, 10561, 4709, 15315, 12034, 13656, 4693, 15113, 1086, 2956, 14021, 8976, 11280, 17236, 4924, 7536, 18076, 11820, 490, 9530, 19963, 6378, 17229, 3638, 9182, 7778, 395, 11231, 13483, 17437, 17133, 9231, 11789, 8368, 4827, 15751, 8529, 14558, 13014, 5362, 4928, 19820, 4064, 16012, 12475, 16512, 7063, 7894, 16196, 7378, 11746, 757, 19839, 19790, 3251, 13993, 19419, 14580, 18087, 3294, 16321, 6495, 18177, 12405, 13134, 19666, 15034, 15595, 10105, 15006, 1303, 1177, 14419, 10997, 16504, 4594, 12223, 12993, 9449, 16223, 10209, 15273, 10813, 12554, 8058, 12766, 1571, 5260, 19696, 3182, 12195, 12278, 6670, 1328, 12770, 16141, 6299, 9501, 1878, 8949, 6433, 17273, 4501, 5786, 12108, 14341, 8471, 5532, 13591, 981, 9225, 10993, 418, 18528, 16801, 2806, 19599, 17706, 6399, 17583, 9855, 19476, 12861, 10034, 18639, 17075, 8125, 16783, 3077, 11618, 19548, 650, 4853, 7526, 10674, 6593, 7552, 7509, 14058, 5153, 564, 11205, 13358, 10980, 15554, 12651, 16064, 17537, 15983, 8876, 13699, 14117, 2528, 18818, 14818, 11052, 203, 9888, 6258, 18322, 18136, 10319, 3347, 13572, 15124, 3175, 10315, 17504, 6961, 11861, 16664, 2963, 6866, 711, 18946, 4117, 10792, 904, 6337, 2068, 6364, 11106, 14171, 14459, 9425, 5427, 4807, 11182, 3115, 9351, 12504, 8544, 16050, 173, 1341, 19271, 9632, 11880, 18244, 16890, 13765, 4479, 1759, 2757, 14886, 306, 11211, 19438, 15940, 8661, 4175, 1498, 14809, 5902, 66, 14840, 2318, 8895, 12125, 8009, 12433, 12360, 18064, 12830, 3975, 2893, 344, 5639, 6890, 18751, 18638, 2257, 1151, 1457, 4993, 8040, 5789, 2558, 13791, 6485, 15248, 11740, 1435, 3454, 3594, 4628, 13038, 7774, 19840, 16585, 15103, 13085, 8406, 4339, 12515, 11818, 9481, 14622, 3392, 4645, 19319, 800, 10750, 6589, 14369, 19245, 15893, 12800, 9056, 6328, 17367, 3546, 8166, 10304, 3900, 14093, 8190, 13301, 6999, 10353, 4854, 9957, 15528, 10094, 8361, 17673, 8447, 4849, 18032, 2599, 7402, 11977, 5152, 18657, 3131, 9871, 18553, 10660, 7758, 18533, 11688, 19137, 13178, 18505, 2122, 15969, 2324, 11371, 8468, 10576, 9801, 8290, 1602, 9212, 17455, 3521, 2310, 5863, 10991, 15092, 10992, 12623, 8867, 14510, 1437, 6011, 2120, 1379, 12529, 13039, 13635, 12868, 16277, 19557, 16623, 4297, 9204, 5297, 1576, 17531, 18628, 593, 17795, 11650, 6918, 14167, 16229, 11739, 8439, 11945, 17346, 18538, 11213, 2865, 6720, 19054, 7055, 2646, 9067, 13252, 6884, 10391, 2794, 14457, 15958, 4798, 2728, 9044, 15587, 986, 7115, 16434, 7264, 18441, 16813, 8776, 923, 7742, 16653, 6280, 738, 18037, 9057, 11180, 15607, 19821, 17712, 7408, 18204, 12293, 10483, 5015, 10532, 14569, 12776, 4444, 8522, 1747, 1936, 18019, 14748, 9846, 19470, 17955, 9994, 17616, 5891, 8268, 7021, 10534, 16902, 17743, 10219, 4986, 19455, 2014, 8348, 15008, 10568, 4368, 1768, 12518, 5876, 16357, 3103, 11055, 2515, 9594, 8054, 14996, 7211, 18739, 13515, 15292, 19930, 1732, 4454, 9016, 11074, 14094, 19913, 5887, 10236, 8225, 10305, 683, 5105, 3991, 4170, 11726, 19179, 9337, 16607, 8494, 3598, 16581, 3010, 10462, 13945, 15883, 5893, 13329, 2636, 11811, 3128, 10919, 4334, 603, 8718, 5201, 7305, 17848, 9275, 9575, 16246, 17923, 17498, 14389, 14697, 8532, 19851, 3686, 5754, 2265, 14188, 18698, 14795, 3836, 4582, 2759, 16276, 14290, 10225, 18525, 7495, 17277, 2208, 12859, 16494, 2948, 14647, 11457, 17293, 2954, 13098, 9783, 820, 19007, 4788, 18360, 13817, 32, 14715, 12658, 11202, 1667, 2262, 2048, 18890, 10533, 6268, 4848, 17847, 7713, 3224, 8381, 17251, 18648, 3220, 9306, 294, 6711, 12120, 19150, 2139, 11439, 5008, 17235, 12665, 16253, 3656, 13938, 17020, 10283, 10421, 15603, 8120, 19372, 9549, 19098, 10257, 12335, 1629, 5685, 17767, 3974, 14707, 13749, 12751, 16995, 10972, 7450, 15483, 685, 1619, 3160, 12569, 19504, 9118, 8808, 2195, 7161, 17396, 7193, 2170, 4945, 13433, 17338, 9031, 11019, 18573, 4584, 109, 11463, 18672, 12294, 5021, 8689, 2786, 5315, 5723, 16285, 5845, 18554, 1916, 1380, 7856, 3772, 19227, 1963, 1567, 8823, 5003, 2308, 7582, 10335, 9743, 2422, 16106, 4458, 10935, 15628, 4080, 13868, 17248, 5653, 9531, 13553, 2975, 6309, 13320, 16299, 16414, 19872, 7412, 11995, 15932, 14103, 2211, 3058, 10814, 13118, 1246, 15449, 6414, 5172, 5520, 14066, 5338, 17988, 380, 15793, 10608, 17971, 5960, 6767, 2685, 3231, 237, 14973, 11771, 8865, 16095, 19542, 1137, 1510, 17523, 16349, 8972, 18889, 1817, 2301, 6721, 9958, 3009, 1119, 16338, 18675, 16559, 9906, 4907, 16922, 3373, 3852, 9634, 14422, 6545, 4027, 5350, 5263, 1782, 15665, 7747, 9282, 17632, 853, 6439, 6863, 12384, 6687, 10151, 5763, 13213, 5615, 10146, 13036, 19642, 3835, 12916, 14716, 6549, 1058, 6241, 639, 11237, 5621, 18833, 1286, 16194, 3879, 11452, 6426, 989, 6910, 2851, 7563, 2391, 17081, 14819, 6637, 7411, 4548, 9561, 181, 14949, 14080, 124, 7146, 17339, 14383, 10691, 17933, 3763, 623, 3264, 18662, 16027, 7456, 3782, 9785, 2897, 4554, 3584, 15277, 4530, 18917, 10880, 14895, 6304, 16030, 11051, 7247, 9066, 16514, 58, 2315, 17484, 17696, 10437, 5328, 8142, 10090, 2667, 18564, 11233, 17856, 6207, 7578, 15963, 13225, 6216, 9504, 26, 17349, 10503, 8802, 16784, 4771, 17432, 13065, 11060, 7826, 7206, 6768, 8181, 11867, 5877, 3747, 8066, 351, 2668, 375, 12879, 6881, 1568, 3665, 5238, 6995, 1366, 9086, 19769, 5748, 13032, 5239, 3694, 16636, 10152, 11770, 7737, 4866, 5874, 4304, 13687, 16614, 894, 19453, 16711, 5539, 1082, 7708, 1496, 9829, 12856, 9235, 1649, 18576, 2305, 10202, 14997, 9668, 10108, 8010, 2061, 7303, 19907, 5973, 12073, 5299, 5910, 3442, 5232, 10565, 17832, 9264, 19162, 9420, 3371, 10173, 4053, 14393, 8923, 6327, 17265, 17157, 6946, 5515, 808, 6710, 97, 15733, 7625, 2813, 12959, 10172, 16863, 3853, 65, 8651, 14147, 9435, 19572, 10062, 17448, 8089, 14377, 9499, 5381, 14848, 1255, 11831, 11220, 15568, 13492, 16729, 3451, 238, 18923, 1006, 13203, 11398, 939, 11569, 7606, 9127, 10130, 14859, 14616, 19835, 15247, 18233, 17477, 6051, 17434, 17973, 2716, 7870, 15043, 7675, 16773, 10703, 12477, 19690, 1237, 13284, 11401, 15748, 17671, 19477, 68, 1640, 3802, 5947, 1445, 6953, 5346, 17013, 6164, 13836, 295, 2601, 14109, 8968, 3344, 16774, 18460, 16177, 17385, 16204, 9357, 6551, 9487, 14704, 11314, 12957, 12155, 3243, 15197, 13692, 4377, 8287, 196, 17754, 605, 10214, 793, 5679, 5123, 3571, 13917, 15860, 13446, 3667, 17403, 8329, 3522, 3819, 14036, 392, 14892, 10185, 18245, 14313, 1215, 8090, 10592, 12668, 13070, 8297, 19336, 16532, 7700, 4173, 18033, 17023, 19142, 11430, 18957, 13842, 4324, 10273, 12098, 5131, 147, 19544, 8506, 16395, 16367, 3863, 5173, 18160, 8990, 1344, 137, 19626, 9246, 2303, 13378, 5534, 600, 9374, 11530, 12811, 13311, 13066, 3174, 16180, 7124, 9929, 1751, 13440, 10149, 18677, 10871, 11256, 2234, 4655, 12217, 10097, 9121, 19299, 17627, 6247, 6344, 12093, 3622, 3721, 1707, 14612, 8261, 19499, 10327, 12734, 9659, 7840, 5958, 19018, 18748, 18073, 14059, 14931, 2578, 16685, 6090, 6230, 13323, 6407, 18689, 8399, 19634, 2882, 11779, 7792, 2631, 2630, 10409, 17766, 9748, 16297, 18722, 16037, 6659, 2495, 15016, 16690, 4102, 15019, 7743, 18651, 5383, 15303, 1621, 16878, 14165, 13996, 10726, 15588, 14435, 6945, 16353, 11023, 253, 9170, 11701, 3031, 7192, 15237, 5943, 14258, 7328, 5492, 3034, 4512, 12722, 8806, 8738, 14976, 6944, 6868, 8739, 9061, 1039, 1942, 14269, 19711, 12112, 3791, 8340, 5217, 6708, 1769, 13672, 15854, 1984, 946, 11436, 7277, 18974, 17507, 17846, 2824, 7117, 8578, 10128, 4649, 17733, 1876, 13712, 17789, 16604, 6813, 17125, 6145, 4181, 10502, 914, 6911, 11454, 6586, 19120, 9511, 14164, 17492, 134, 14808, 14970, 11007, 10407, 619, 7712, 2679, 16627, 2474, 6726, 14691, 15229, 3996, 10422, 6915, 3102, 18643, 18402, 13051, 5244, 11668, 13452, 8721, 1008, 1950, 6816, 18882, 9397, 5097, 874, 15518, 19812, 15833, 19978, 7745, 7953, 5250, 10365, 17586, 17635, 2737, 12269, 12821, 897, 16191, 4287, 4462, 8873, 5384, 14032, 15956, 10684, 11528, 19406, 7882, 6976, 1724, 6691, 17138, 6438, 19875, 216, 5355, 3348, 18196, 11824, 9172, 8111, 7646, 957, 13208, 1845, 1527, 8554, 19249, 16245, 19855, 4871, 18218, 9153, 16823, 9058, 19905, 4564, 188, 1196, 14472, 9747, 2692, 19843, 1087, 661, 18803, 7994, 8642, 4399, 16445, 18391, 9376, 5814, 13911, 4666, 5428, 14131, 9673, 16057, 3968, 16490, 15560, 3333, 6358, 12438, 19556, 1617, 19069, 18944, 13000, 9889, 19243, 16203, 16540, 7583, 6508, 16956, 19853, 411, 9523, 12883, 8824, 4722, 389, 14296, 9498, 13915, 10187, 5468, 3671, 14961, 17180, 4430, 8956, 15445, 8973, 3980, 15168, 8112, 10763, 10988, 6375, 1100, 19979, 5774, 19097, 18867, 2758, 19727, 6110, 4813, 15081, 9060, 17404, 991, 18042, 17626, 10267, 16601, 7627, 13790, 17027, 7643, 18256, 19163, 1634, 866, 7761, 6677, 19253, 9684, 17757, 604, 11879, 3952, 17082, 12890, 2, 12509, 7485, 11615, 9617, 11557, 4952, 5731, 5280, 9115, 10983, 11050, 18690, 17425, 18104, 19551, 6023, 9156, 11808, 9533, 13708, 12662, 5749, 19810, 12393, 18640, 16689, 13583, 3959, 5094, 15645, 2962, 2900, 10522, 6679, 15323, 15920, 10433, 9343, 8826, 5764, 16224, 7268, 2140, 8563, 19236, 4015, 16173, 10055, 13763, 3794, 12594, 272, 8784, 3574, 13432, 19960, 7090, 8184, 1000, 2199, 14951, 10905, 13632, 4242, 10872, 9176, 12096, 4680, 17303, 1563, 3633, 18470, 12661, 12762, 14645, 15079, 4878, 7320, 15167, 13520, 18083, 9040, 17034, 16542, 11130, 18966, 6648, 4903, 17660, 4732, 3202, 5286, 16959, 4468, 6793, 6206, 10878, 10556, 14796, 10513, 3549, 17494, 5014, 13499, 19687, 4796, 1735, 6017, 15677, 16125, 12082, 8511, 12588, 10876, 9179, 6242, 17853, 1921, 17731, 19780, 4706, 17551, 13180, 8509, 18749, 10924, 19210, 17297, 7023, 10217, 5513, 4730, 18001, 220, 14755, 1892, 16416, 13365, 19027, 3844, 5174, 1212, 14042, 15389, 4280, 17910, 4547, 13264, 11926, 18005, 9586, 10910, 5163, 2263, 17139, 7920, 16286, 9665, 9571, 2300, 12627, 5305, 7657, 10447, 18257, 13158, 7984, 3306, 8209, 7434, 4521, 13550, 11666, 6784, 1820, 5742, 10085, 1573, 16368, 18703, 12559, 7339, 7576, 14861, 14753, 8427, 13101, 1616, 11790, 4276, 9391, 2188, 12264, 9251, 18776, 4502, 4961, 553, 13548, 9417, 18428, 12502, 17130, 5938, 11466, 248, 2060, 9084, 3769, 11119, 8210, 574, 9009, 13930, 15349, 16646, 19272, 8845, 16760, 9624, 6785, 143, 14507, 17967, 4300, 1922, 5730, 16423, 4801, 1051, 12456, 4603, 1041, 11533, 3886, 18731, 11276, 5729, 17518, 18152, 18293, 14898, 1688, 15750, 2523, 4837, 4524, 15532, 2066, 17200, 9927, 16619, 16060, 17018, 2056, 8781, 19903, 14855, 19722, 200, 11, 928, 719, 13480, 261, 12987, 1516, 8091, 3621, 6619, 1518, 19876, 15492, 11686, 7800, 727, 2778, 12496, 6701, 3068, 11056, 12160, 11792, 1880, 677, 12214, 19638, 11765, 4689, 11796, 14337, 1364, 669, 2570, 17615, 7018, 9387, 19591, 6587, 13857, 49, 4682, 16074, 5857, 8928, 10169, 18162, 15602, 1446, 19729, 6138, 9196, 11508, 14460, 17230, 3774, 19430, 14018, 15153, 3332, 11151, 11793, 4245, 8530, 8062, 19183, 433, 10418, 9723, 1911, 18901, 9080, 10646, 1530, 11866, 9238, 19732, 16437, 8465, 16609, 18137, 6572, 3390, 7751, 6934, 6695, 18933, 4221, 2876, 521, 15744, 2629, 19675, 2005, 8115, 12564, 7431, 13444, 8265, 647, 6176, 19209, 12140, 1413, 18656, 12411, 777, 1605, 16304, 1898, 3761, 5068, 14579, 11629, 15407, 2720, 3829, 15600, 5145, 249, 11722, 12025, 9454, 6111, 9515, 9615, 4310, 6799, 7285, 15776, 17451, 4774, 7883, 14692, 637, 6115, 15304, 19220, 15207, 11478, 2264, 17234, 19940, 11885, 7818, 10504, 15624, 3588, 9098, 8085, 5755, 5624, 17571, 14821, 1806, 2724, 2337, 11651, 19463, 2517, 16263, 3719, 15254, 1774, 3854, 1764, 8291, 14366, 18094, 5733, 7812, 5360, 14268, 17266, 14343, 4240, 1411, 4471, 19777, 3482, 5580, 5927, 19450, 14804, 12511, 17606, 14372, 14835, 18323, 14661, 18061, 12998, 14885, 2388, 8493, 4492, 5167, 2565, 6570, 17880, 6478, 14673, 6031, 10050, 6772, 9893, 19977, 12960, 13925, 6924, 17884, 5799, 16788, 13715, 436, 12717, 19946, 15897, 1455, 13967, 14827, 11021, 18156, 10416, 12268, 5941, 12973, 13963, 11135, 6940, 228, 11481, 19928, 17728, 3636, 8864, 11026, 14564, 18659, 8145, 16502, 983, 5375, 10791, 16667, 724, 11286, 9362, 15009, 5493, 9471, 15861, 15283, 13655, 12522, 16347, 9881, 6047, 13764, 15376, 14107, 4104, 7863, 16812, 169, 4145, 10620, 2889, 1023, 16001, 2777, 2763, 15106, 17620, 15436, 15692, 792, 5806, 15517, 17048, 6754, 10918, 6996, 449, 3784, 6490, 14738, 10247, 19538, 9682, 6896, 15083, 3943, 3727, 3536, 12397, 3129, 17282, 17941, 16693, 1771, 18871, 3263, 18647, 3878, 8822, 17389, 18762, 14187, 4092, 3624, 6318, 7151, 19889, 827, 17097, 14592, 16046, 3360, 7092, 15341, 3177, 11572, 6681, 601, 18242, 12310, 4881, 11623, 2004, 10143, 2364, 9384, 9592, 18188, 13741, 17033, 7253, 1679, 7886, 12104, 3122, 5504, 13651, 1062, 10922, 5321, 7518, 16826, 185, 10690, 16960, 2582, 6285, 15672, 10895, 8851, 10328, 9914, 9279, 7794, 555, 14330, 10827, 14995, 11155, 12087, 16518, 19996, 13751, 19494, 18811, 2065, 9773, 8349, 8735, 11630, 5147, 12029, 247, 12806, 4415, 4717, 16807, 12642, 14429, 985, 17857, 2541, 16990, 10159, 12181, 753, 3184, 13962, 16175, 822, 17115, 14746, 11910, 11711, 7832, 5314, 8549, 13373, 3210, 11935, 11407, 7564, 7631, 10759, 18536, 6998, 5512, 5911, 13095, 11914, 6835, 4641, 5589, 8645, 18113, 15400, 2868, 2368, 406, 18326, 18109, 1855, 6930, 6611, 19219, 9709, 2110, 16967, 1973, 10902, 19019, 652, 1632, 636, 5259, 28, 9164, 8859, 14348, 8473, 6339, 16142, 12923, 7385, 5790, 17654, 13089, 4510, 13501, 13832, 6705, 12817, 18089, 12505, 4511, 6575, 7752, 6483, 19926, 19295, 9290, 3687, 10681, 15880, 6755, 18982, 18655, 695, 2527, 890, 17262, 14260, 7690, 19434, 9595, 1284, 15508, 14570, 13114, 688, 15182, 9507, 19561, 7409, 4764, 13345, 14322, 6441, 12512, 17311, 5951, 7698, 12254, 14316, 656, 6073, 9186, 64, 5160, 3580, 8523, 2548, 4677, 6419, 1885, 10357, 3489, 19239, 19555, 3617, 7694, 7790, 4753, 10320, 19115, 13670, 837, 10448, 493, 17040, 6982, 15443, 17461, 6195, 18616, 594, 916, 5619, 6888, 2619, 14266, 15807, 665, 18819, 2937, 18620, 10989, 15244, 19046, 15838, 14237, 12746, 14742, 6445, 15841, 13354, 16511, 11387, 3475, 17678, 19312, 790, 1840, 6477, 5290, 14913, 9085, 13686, 6731, 4790, 1958, 4600, 14568, 4546, 14087, 3070, 13468, 4041, 1013, 19864, 7609, 7809, 3253, 1393, 19244, 15809, 18112, 4329, 13649, 17078, 19966, 6688, 10909, 2321, 12807, 7009, 8201, 16804, 19435, 2136, 5630, 19968, 5924, 11521, 6491, 10067, 16055, 12809, 11859, 8625, 16904, 18399, 14608, 5148, 18571, 4319, 15318, 16929, 12705, 16077, 7212, 4752, 19490, 16903, 9559, 18577, 17775, 18461, 16462, 14373, 11661, 17198, 6357, 15573, 9479, 9131, 13668, 8887, 15411, 5643, 9473, 16401, 14778, 10311, 5282, 15163, 7071, 8360, 14, 19682, 13130, 3311, 10662, 19799, 8677, 3490, 9866, 11804, 15701, 4583, 8033, 357, 78, 12710, 13126, 595, 9201, 8042, 14908, 7697, 6345, 14657, 2456, 15114, 19223, 12417, 15180, 19065, 10725, 12201, 12810, 12354, 10131, 7187, 6428, 18140, 9099, 5295, 3780, 9553, 4514, 10832, 2725, 14999, 3519, 16715, 1182, 1509, 1703, 254, 5252, 6741, 11432, 5549, 17036, 4157, 17986, 19252, 1798, 13904, 2076, 5636, 5940, 18813, 13624, 1136, 15834, 16566, 784, 8480, 6843, 5042, 7329, 13173, 13846, 2015, 3401, 930, 11803, 10507, 4356, 15258, 18972, 7291, 3860, 19205, 2365, 3334, 915, 19681, 7982, 4333, 7565, 4814, 4684, 17239, 354, 139, 8264, 15711, 1156, 9236, 6759, 5325, 9793, 12942, 5775, 8463, 18733, 12124, 3698, 12646, 18789, 9892, 4937, 529, 11612, 6221, 10937, 12169, 4164, 16098, 15246, 19211, 4469, 4555, 5854, 4629, 14584, 14632, 4559, 11429, 15050, 9415, 15159, 1334, 796, 9252, 4776, 15119, 706, 18385, 7726, 10916, 13897, 14335, 17909, 15066, 2062, 7777, 12545, 10734, 14332, 10714, 3201, 15470, 5584, 17358, 19943, 3164, 15219, 10773, 11902, 13744, 8637, 5920, 16534, 1293, 8564, 11001, 7410, 5418, 11154, 9028, 5735, 14482, 12298, 17762, 2529, 6966, 9090, 1837, 7549, 14520, 19130, 12016, 15430, 2426, 7269, 19221, 16040, 16005, 2142, 5995, 1557, 7359, 13023, 1197, 9544, 19479, 15524, 19233, 15360, 12345, 12404, 8338, 15848, 16216, 17665, 18603, 15102, 10248, 12376, 11215, 14779, 2723, 15957, 10510, 11199, 5801, 2807, 920, 15620, 10472, 17087, 362, 13513, 9890, 1350, 11185, 3477, 19423, 1659, 7038, 371, 7075, 4363, 11307, 18580, 17469, 4011, 19128, 11179, 9674, 6471, 4281, 17152, 18561, 17032, 10300, 5889, 8048, 7974, 18878, 12683, 14497, 17724, 2336, 6427, 13893, 9546, 12168, 2822, 19566, 2682, 4784, 16927, 10657, 7311, 2047, 19674, 10074, 17017, 6913, 18712, 7530, 12307, 12677, 8807, 15426, 2333, 6341, 11114, 9224, 552, 10369, 8088, 852, 8540, 10014, 11094, 15000, 9506, 13803, 9191, 19185, 16359, 14862, 12421, 13008, 17019, 7107, 16678, 16073, 10376, 5536, 19396, 12660, 10366, 2473, 19342, 8882, 5800, 16289, 16986, 15489, 17908, 13864, 5533, 19813, 510, 13084, 5822, 1731, 567, 10120, 11153, 19212, 10250, 5327, 5382, 16704, 12533, 2109, 6943, 13524, 10973, 12055, 8354, 1489, 19189, 3582, 7757, 6113, 14730, 3074, 9977, 18909, 13380, 8260, 3510, 14603, 12542, 11523, 6390, 333, 15703, 5839, 10677, 11291, 8616, 18050, 7861, 14847, 18060, 10719, 16712, 9503, 15418, 4783, 17499, 19474, 4679, 4694, 11978, 6425, 18590, 1723, 19264, 14631, 11567, 7829, 8230, 12233, 11673, 554, 5498, 4423, 17968, 7413, 3438, 9625, 12182, 13006, 9686, 13322, 11166, 401, 16432, 9054, 17684, 4882, 17083, 14130, 15045, 10277, 1608, 6762, 18374, 12871, 6415, 15220, 12037, 7692, 6750, 7266, 3340, 13974, 988, 3466, 11118, 6312, 15837, 14758, 19616, 17071, 17008, 2118, 296, 10953, 14686, 16335, 5727, 15905, 12547, 8300, 19125, 4630, 349, 6699, 17744, 14638, 8489, 4782, 4361, 8684, 6291, 15797, 2864, 18332, 19322, 12282, 18111, 6547, 1355, 15657, 9026, 2462, 3343, 14371, 5237, 14717, 5227, 18085, 11664, 7934, 16584, 13504, 3800, 1630, 16680, 11994, 10298, 15754, 14438, 4495, 18852, 11646, 12289, 19447, 6128, 12936, 10949, 4758, 13476, 14851, 12339, 10609, 13183, 4570, 18141, 7828, 3062, 17159, 5407, 14128, 4144, 16134, 16329, 19393, 7292, 14374, 13531, 5815, 9943, 2800, 17393, 19521, 19166, 15338, 11549, 1374, 15447, 12081, 8395, 2875, 1674, 7785, 16821, 5367, 1512, 11896, 2428, 16751, 16082, 15055, 14803, 12374, 15060, 956, 19314, 1481, 4442, 19961, 13647, 10652, 13275, 8836, 3755, 4165, 15908, 15485, 17932, 12597, 10428, 613, 1427, 12322, 6286, 5561, 18773, 18771, 2771, 3379, 6122, 12784, 16028, 13874, 19021, 13606, 12543, 15513, 3850, 9818, 13514, 4823, 6912, 16931, 8960, 4294, 11218, 3320, 18947, 16121, 19482, 14154, 10367, 11911, 9396, 9711, 2797, 15622, 6510, 6028, 17194, 8295, 10654, 2430, 1336, 2678, 9776, 2733, 2006, 15094, 2913, 4396, 11927, 2624, 13981, 5652, 15299, 2838, 8191, 6977, 14097, 15362, 4770, 660, 9133, 9848, 3209, 12850, 17774, 16782, 16748, 961, 6973, 7992, 8734, 14694, 674, 19736, 15916, 13704, 17849, 18288, 17060, 6289, 3407, 11165, 13562, 18264, 4829, 16912, 2213, 16999, 19988, 11025, 13559, 12392, 13702, 5005, 18717, 11320, 7343, 3471, 18520, 8388, 7333, 14085, 16933, 3073, 7610, 15656, 7220, 13012, 13009, 11459, 8848, 11193, 6350, 4648, 6139, 7488, 2689, 7313, 19394, 9983, 13463, 8572, 11014, 2389, 13805, 14073, 17647, 15104, 12283, 16240, 9628, 18853, 6489, 17649, 12003, 10748, 2655, 11915, 4174, 18807, 5120, 18521, 5066, 18489, 17770, 14992, 7596, 17169, 10011, 7492, 15142, 11097, 10934, 19580, 15571, 18472, 1797, 8769, 5489, 8030, 3912, 10399, 8438, 11921, 12774, 90, 6588, 17911, 6810, 16157, 12944, 6271, 2251, 6252, 19861, 9287, 17116, 106, 9912, 15116, 16577, 2036, 11724, 12256, 11338, 6817, 9409, 9965, 4867, 11294, 15806, 17243, 13837, 8364, 19427, 11963, 9488, 6635, 4091, 541, 13934, 6706, 15048, 9178, 1263, 7356, 17708, 6091, 3558, 16852, 3400, 504, 6917, 4918, 2855, 18584, 1955, 14352, 19412, 12912, 13697, 7457, 2854, 1881, 15123, 19668, 17657, 8964, 8940, 13633, 1721, 4767, 5455, 7709, 9821, 11421, 3806, 7728, 2697, 3060, 979, 14744, 13909, 5550, 2970, 4751, 7239, 16876, 659, 2942, 10078, 11840, 8597, 4153, 10259, 6172, 6030, 18848, 18267, 18417, 8195, 10286, 11223, 17638, 16450, 2099, 8742, 749, 6763, 4224, 5425, 11715, 11797, 9177, 14606, 13970, 4100, 4306, 11509, 16538, 10638, 5937, 1586, 2431, 14428, 16041, 15222, 1853, 2338, 13280, 9260, 14197, 6388, 9142, 1572, 16908, 19841, 4528, 17974, 11362, 8737, 12566, 13431, 14151, 5088, 10321, 2469, 15326, 9988, 19763, 16336, 8224, 7831, 18579, 3524, 12600, 13730, 1949, 19323, 4463, 6907, 17079, 12649, 3226, 13839, 13387, 7868, 287, 19190, 15422, 17919, 10932, 7494, 3119, 17490, 6103, 335, 13240, 11826, 1770, 14112, 1672, 4710, 11590, 4472, 1579, 16373, 16519, 11404, 8818, 8173, 3688, 2632, 15639, 11728, 13578, 18364, 8814, 2362, 1207, 7945, 19935, 15612, 1396, 19338, 14852, 10656, 14953, 15519, 10174, 17748, 2530, 13590, 19001, 7918, 11576, 6557, 11262, 19528, 7732, 19361, 8926, 8352, 19325, 19009, 2922, 11239, 52, 873, 7572, 1983, 18568, 8414, 764, 7141, 4233, 15753, 16600, 1511, 13015, 19426, 10331, 19737, 2021, 13002, 18182, 10478, 15253, 5074, 8610, 15813, 17828, 10944, 5441, 10630, 18130, 19024, 3675, 14506, 10742, 17996, 1222, 15866, 18184, 1432, 6669, 2729, 2747, 3911, 18434, 1994, 11004, 13781, 14401, 7985, 14205, 18079, 1874, 15903, 19900, 14126, 10393, 6578, 13021, 3395, 6969, 17147, 7766, 4525, 19257, 11342, 11434, 19918, 9217, 1465, 17798, 2764, 11584, 755, 9378, 10309, 18635, 3026, 16063, 6393, 6124, 14790, 3708, 4218, 19408, 14234, 1109, 7012, 16105, 19420, 12119, 2449, 19177, 12920, 9582, 13546, 2131, 9989, 1108, 6466, 6371, 18766, 19892, 1280, 13205, 17604, 10751, 14174, 13413, 1279, 2691, 1910, 9286, 19452, 3116, 19627, 17062, 4449, 18412, 13683, 10136, 15728, 9385, 6016, 10810, 16127, 12462, 16706, 3626, 3189, 13113, 17429, 1234, 3529, 7054, 15574, 9484, 18325, 11506, 11526, 8527, 17163, 15342, 10796, 7864, 15218, 3630, 973, 10859, 12234, 4308, 4130, 4930, 9809, 10106, 15179, 16663, 9292, 15646, 15089, 17511, 9604, 14614, 18543, 10607, 14133, 19010, 14531, 967, 14824, 12756, 14307, 5405, 128, 7180, 18370, 4369, 7967, 13246, 6743, 7319, 11079, 10605, 6325, 13872, 817, 16128, 14029, 7347, 6056, 478, 16352, 15596, 485, 14725, 18227, 13191, 5842, 1781, 3244, 9438, 12652, 7142, 15110, 12363, 15826, 10262, 18107, 651, 2174, 12750, 997, 13823, 9806, 6803, 16467, 10083, 10093, 19475, 7608, 7072, 16622, 1633, 2931, 3904, 8901, 10914, 9967, 13034, 5747, 12733, 10959, 293, 19106, 4859, 14767, 19985, 8104, 1493, 16300, 4979, 2952, 10834, 14004, 16376, 13359, 2899, 2482, 17862, 13609, 5987, 4150, 12742, 9380, 8665, 10590, 12526, 5179, 13896, 2081, 17765, 4800, 6114, 2172, 18510, 13422, 13299, 15579, 3133, 15216, 16721, 19513, 3234, 16946, 11127, 19796, 10351, 5957, 13174, 17179, 871, 18759, 12167, 18941, 13542, 19883, 13384, 19507, 16410, 9114, 12659, 17400, 12092, 9381, 5556, 10515, 10310, 14787, 10121, 12193, 17953, 8020, 13217, 6005, 3812, 5181, 16769, 11495, 5096, 16602, 3405, 15429, 16470, 8690, 5478, 3086, 3787, 4279, 14530, 13135, 19637, 3286, 14470, 1582, 15802, 7487, 397, 14850, 2789, 2108, 15714, 6013, 4217, 8052, 5265, 9047, 86, 867, 8106, 6397, 135, 11455, 9971, 13411, 4913, 1202, 5291, 7391, 7273, 11266, 15424, 19910, 19454, 6997, 1188, 958, 19362, 15051, 15902, 13538, 19198, 7678, 751, 11933, 7981, 4406, 945, 10453, 734, 13424, 13199, 19413, 6555, 17226, 8137, 18896, 10702, 10800, 8741, 19964, 7057, 8444, 17409, 17976, 19225, 2906, 16860, 7950, 400, 8241, 12812, 2730, 16497, 13139, 11009, 14328, 19448, 4305, 14057, 14055, 6883, 4422, 12147, 9053, 19265, 14146, 5573, 15652, 3752, 300, 847, 3793, 6161, 18100, 18721, 11158, 2512, 10398, 11957, 14492, 8559, 16503, 19496, 2176, 18531, 6718, 275, 6443, 14254, 9653, 1914, 14666, 6351, 14841, 3488, 16086, 10414, 5283, 14833, 16806, 10976, 9552, 2347, 11846, 5631, 7892, 16056, 4855, 1844, 19931, 5968, 6395, 7041, 1824, 18024, 3041, 9316, 7471, 4539, 17457, 3310, 3921, 11200, 7120, 17329, 19346, 1258, 10473, 11174, 5294, 14487, 16009, 3929, 11327, 12667, 19526, 18886, 3760, 17735, 12328, 5276, 4152, 17057, 18497, 9388, 11318, 15394, 9744, 4169, 620, 5268, 13083, 19003, 13022, 5873, 10858, 3910, 12863, 12887, 12066, 1368, 3169, 3351, 3156, 17417, 8925, 1897, 10636, 15398, 11642, 7845, 1271, 11676, 10091, 5517, 16567, 7163, 14802, 4486, 7999, 1139, 9163, 7224, 5537, 9129, 9932, 14903, 8766, 11516, 9737, 8732, 15148, 14826, 11358, 19491, 11578, 10461, 7184, 2798, 14153, 16916, 14700, 12698, 12053, 18781, 7653, 12105, 16118, 17045, 12272, 779, 12553, 16965, 14249, 7581, 366, 15379, 5178, 36, 13330, 11871, 14340, 18086, 3257, 901, 11041, 18108, 13277, 7229, 18930, 1461, 4874, 11787, 5056, 16932, 3779, 10939, 16819, 17408, 18619, 12259, 3496, 4983, 16660, 15862, 2409, 331, 2055, 10292, 2669, 16417, 8631, 13464, 2879, 11453, 4606, 3821, 3750, 11838, 2361, 18547, 19771, 4932, 8024, 11120, 19313, 5406, 9817, 4572, 19915, 13169, 12612, 19621, 2579, 16360, 13833, 9128, 14683, 2641, 19967, 6215, 13563, 14204, 8875, 17990, 18351, 9790, 1464, 10509, 17820, 19381, 2248, 2295, 4825, 2623, 1308, 12581, 10547, 13689, 17741, 7275, 10610, 13297, 17802, 10493, 1684, 11214, 7476, 8484, 6117, 18466, 14395, 14533, 6499, 16147, 14651, 14270, 11381, 4047, 8277, 19086, 18039, 17394, 990, 18022, 9137, 17328, 19936, 3279, 3087, 12769, 16517, 120, 11636, 13700, 3024, 10272, 5108, 2984, 11168, 8659, 15087, 15337, 17617, 9308, 4777, 10625, 6006, 15279, 11479, 8668, 19897, 355, 7573, 13414, 5721, 5869, 1589, 7917, 3847, 2973, 1138, 2825, 17713, 1369, 18977, 42, 16219, 17579, 4994, 12943, 8791, 5791, 10580, 6363, 3309, 6605, 16271, 17759, 3059, 11145, 1098, 15945, 11756, 1709, 17645, 14935, 2027, 15749, 6792, 1025, 5892, 16909, 11348, 14186, 2268, 12186, 17275, 3284, 4780, 16350, 17812, 2433, 2487, 3984, 7230, 5984, 3554, 19260, 13388, 4251, 16549, 16548, 4108, 13979, 16844, 13257, 8160, 1005, 9877, 7035, 6828, 8863, 17824, 16334, 2008, 16156, 7420, 18173, 918, 19989, 13889, 15563, 12377, 13679, 432, 2097, 19661, 16487, 5758, 14024, 145, 2577, 16897, 8028, 5832, 15868, 3388, 1128, 11364, 1017, 9555, 7679, 6869, 15713, 8932, 6189, 15267, 5079, 18398, 2539, 7168, 214, 15158, 19552, 17320, 1133, 13549, 19153, 16372, 3187, 14344, 9323, 19053, 19792, 4650, 4713, 17951, 2376, 8787, 3693, 11368, 11062, 17319, 682, 451, 3862, 7086, 12752, 15145, 16139, 4599, 14105, 19149, 14051, 13989, 8192, 1980, 10382, 15859, 7064, 6458, 13335, 19481, 9266, 13766, 2278, 13175, 825, 8251, 14980, 4955, 10706, 10631, 12138, 10848, 4943, 5964, 8199, 8168, 18767, 2616, 7803, 119, 18174, 12094, 3616, 9597, 12184, 3933, 2531, 18308, 14468, 16851, 2410, 13369, 12965, 11302, 15480, 13149, 14830, 4359, 10096, 17150, 5700, 6187, 2656, 14065, 4929, 5594, 368, 927, 14563, 13004, 13799, 13049, 17215, 16988, 7079, 9816, 18555, 2966, 17286, 1104, 3896, 8407, 15201, 17132, 13784, 11142, 3061, 14998, 17782, 3918, 14521, 8945, 1261, 14382, 13722, 4010, 8345, 19407, 4437, 1519, 13116, 14141, 5982, 7414, 10252, 4122, 9858, 5663, 16408, 8897, 3222, 4085, 11959, 4068, 14098, 16132, 12507, 16491, 481, 7047, 18535, 142, 12570, 19941, 6049, 9068, 17773, 6839, 8902, 7642, 12891, 5714, 3898, 1865, 19335, 4598, 5062, 965, 2447, 12346, 14306, 16525, 7346, 13197, 8924, 19902, 15680, 5472, 13855, 18697, 11850, 18632, 11467, 19063, 15056, 16596, 168, 9307, 11329, 3196, 3751, 11046, 8174, 16694, 14194, 13980, 2156, 10103, 4038, 3300, 5011, 1114, 7617, 9758, 14921, 3459, 1131, 15368, 11022, 8449, 6267, 8355, 7765, 12279, 3349, 5762, 5279, 14386, 5567, 286, 18255, 4459, 14272, 11611, 19955, 4101, 9961, 16283, 18055, 18862, 13108, 12679, 3604, 4166, 8643, 16991, 9863, 18339, 9119, 2674, 686, 11422, 5016, 2009, 7014, 6392, 197, 5002, 17535, 1111, 3443, 829, 19202, 10191, 1654, 15739, 16456, 7045, 3183, 9872, 16787, 8959, 4046, 4057, 11760, 18780, 7889, 7203, 9440, 15166, 15126, 16148, 19836, 16097, 19554, 2016, 4445, 16563, 1564, 1130, 11251, 18978, 16657, 9065, 11212, 12088, 19866, 6597, 7734, 18583, 5838, 12754, 14690, 18186, 13658, 4567, 6573, 10211, 9565, 10783, 10768, 16533, 14359, 2406, 11674, 2736, 454, 3321, 5324, 17897, 1959, 2192, 17026, 17780, 13997, 4625, 4364, 878, 762, 12493, 14534, 318, 16620, 19387, 16474, 3455, 12523, 18167, 16973, 10553, 13952, 8378, 4870, 11645, 1956, 8369, 14946, 9645, 1365, 3138, 8838, 14918, 18902, 18735, 219, 13143, 3870, 9406, 3871, 446, 13421, 4403, 1371, 13189, 15172, 19850, 4019, 1976, 16921, 8612, 5695, 2313, 6435, 14061, 14261, 9865, 7017, 11830, 810, 3997, 14986, 18994, 14726, 10141, 8571, 8374, 9289, 3431, 13560, 17049, 16655, 18674, 6798, 15783, 9188, 13221, 18422, 12988, 18646, 14635, 2183, 9214, 18800, 14159, 7058, 2438, 17902, 3027, 14441, 4408, 6856, 18887, 5423, 6365, 855, 5150, 12414, 9838, 4365, 13350, 10271, 877, 8646, 11183, 11990, 13812, 16974, 18239, 10825, 4661, 9025, 18301, 2161, 3195, 5098, 4040, 5606, 4674, 13794, 19877, 18575, 494, 4009, 18932, 11577, 19036, 788, 16703, 17207, 3495, 4715, 16731, 6512, 12472, 11847, 5219, 2994, 12336, 15404, 5209, 2505, 19517, 531, 15774, 15241, 427, 18679, 13657, 5699, 13324, 5605, 16371, 6563, 13027, 17151, 12534, 9088, 14957, 12011, 480, 14650, 9904, 4896, 1297, 9495, 18829, 19573, 15461, 9849, 18232, 4686, 4393, 8270, 105, 7901, 1590, 12407, 12245, 8067, 7003, 6775, 10260, 16915, 11714, 3948, 2201, 527, 8623, 311, 2113, 13279, 13377, 412, 18008, 11515, 11733, 7355, 15604, 10795, 5466, 1315, 4589, 14201, 6692, 5395, 13367, 11230, 5415, 17948, 15526, 7795, 12777, 6324, 14741, 11208, 19852, 17738, 16140, 13067, 4644, 1705, 17747, 1868, 6396, 15771, 13643, 941, 1894, 14314, 6218, 8994, 12357, 16938, 838, 13202, 17727, 7902, 13448, 15367, 10444, 9220, 10797, 1574, 11024, 18041, 12819, 17737, 15005, 18903, 5176, 19806, 13064, 9883, 5971, 5465, 13902, 17098, 12484, 10659, 1964, 7036, 8171, 16930, 16987, 10700, 17532, 2367, 19625, 4238, 4580, 8886, 15977, 15709, 6522, 11063, 15651, 16144, 12584, 12246, 1402, 18074, 14599, 7614, 13770, 6652, 10767, 18044, 15161, 5460, 2494, 18770, 7837, 15272, 19503, 19511, 13267, 13319, 15593, 6361, 6054, 6666, 2369, 4925, 62, 8179, 16295, 3414, 14768, 17327, 15466, 11600, 17131, 17867, 14668, 10538, 9305, 5318, 760, 19782, 15451, 5034, 3418, 11015, 2011, 3895, 16891, 6919, 7279, 8944, 19160, 1132, 6616, 12024, 6457, 14488, 11249, 19834, 18337, 3176, 18215, 7519, 14782, 6607, 16510, 9368, 9795, 14788, 7711, 13580, 8970, 4446, 3028, 17387, 19673, 12950, 14478, 7962, 2925, 6158, 2334, 9835, 12540, 9990, 780, 7501, 8727, 8087, 18926, 16137, 6257, 11464, 18676, 5426, 14693, 1729, 1662, 14099, 5830, 3272, 10571, 9463, 19096, 17954, 19424, 19884, 10044, 8336, 5638, 10979, 11510, 10234, 9072, 18194, 1267, 10587, 8748, 10487, 1835, 5194, 7274, 835, 14680, 7162, 3771, 598, 19134, 16305, 3537, 19369, 10836, 19317, 6558, 6330, 18734, 12498, 16314, 16993, 14751, 18230, 1912, 6473, 8984, 16418, 14231, 8701, 8768, 3561, 3221, 1002, 8440, 113, 15001, 14108, 11289, 5393, 15003, 17476, 5481, 919, 7739, 4515, 4718, 12005, 7956, 16799, 15702, 2995, 15107, 8294, 4353, 18594, 10194, 285, 7665, 10689, 5491, 7780, 13082, 3113, 3950, 12297, 6780, 9627, 17080, 11780, 17889, 14110, 9756, 969, 14176, 18713, 14537, 5884, 19176, 4970, 1698, 7423, 16629, 11695, 16088, 4075, 18684, 17500, 12781, 17882, 15601, 2383, 19516, 789, 14329, 12316, 13214, 12996, 9731, 19051, 2030, 16950, 17945, 14052, 19071, 8307, 17440, 9585, 4195, 6874, 6340, 8005, 9341, 12577, 15960, 19121, 19981, 13892, 1905, 10417, 14070, 14838, 18205, 9538, 5586, 1338, 19697, 19885, 10986, 10806, 3047, 5998, 12552, 9656, 14649, 12870, 4121, 10586, 3252, 14230, 15576, 11802, 19237, 10770, 3280, 18860, 14732, 16940, 17878, 18836, 18634, 4541, 9270, 4734, 6959, 13386, 8400, 9837, 7221, 4998, 16320, 11449, 9404, 17752, 5546, 4073, 9636, 7949, 13078, 9512, 4158, 4816, 8538, 8022, 14114, 18763, 2255, 9648, 12601, 19465, 13913, 17716, 15668, 13968, 14420, 15210, 6177, 3410, 11603, 13863, 13684, 16666, 5915, 5342, 8132, 15696, 9083, 19180, 3799, 8278, 978, 14238, 8797, 4146, 5778, 4476, 9900, 6991, 13845, 12995, 15808, 18065, 3305, 462, 7806, 11030, 3615, 10427, 7835, 13057, 7963, 8357, 8550, 8334, 14385, 8021, 11918, 809, 17281, 18197, 17618, 14965, 8476, 4330, 12378, 16928, 8760, 15046, 9315, 13921, 9708, 19148, 10278, 10413, 14993, 15527, 18382, 8698, 2470, 17633, 4517, 17787, 12123, 532, 14573, 13599, 8889, 18328, 1330, 2323, 17372, 18950, 2595, 9706, 13734, 15501, 7628, 13005, 5349, 12110, 3652, 17473, 383, 12924, 7223, 6308, 13080, 3731, 19383, 2846, 5522, 3992, 19045, 16713, 9820, 10345, 12291, 6579, 5049, 6196, 17925, 7681, 19570, 5273, 2083, 733, 18240, 13716, 9371, 18624, 11748, 8921, 10269, 19590, 19662, 3500, 2123, 10253, 19691, 199, 19020, 18924, 12382, 11087, 4432, 3249, 5306, 6107, 6862, 15591, 6628, 12674, 5608, 17074, 13327, 6581, 9581, 4115, 1974, 452, 14026, 17711, 9091, 6782, 10170, 7819, 5301, 1928, 10649, 9429, 6045, 6766, 2583, 9150, 5792, 16575, 14634, 19858, 17734, 12436, 10002, 7797, 17607, 17285, 7507, 9229, 4617, 9145, 8339, 2504, 9614, 7258, 7556, 1276, 1485, 8257, 19933, 14140, 14152, 3891, 6859, 19587, 977, 4267, 12789, 16117, 17124, 2204, 16235, 9956, 13110, 10994, 291, 8394, 12691, 16652, 893, 2117, 17826, 1085, 13237, 8353, 5784, 17600, 4116, 5627, 12399, 11570, 7296, 17289, 2919, 18925, 2386, 3146, 5434, 10604, 18198, 7183, 7393, 5251, 9681, 4725, 16621, 1934, 7514, 10593, 17149, 18132, 7188, 9491, 13620, 13960, 4246, 159, 5211, 10867, 16662, 13438, 18589, 4707, 14930, 19825, 15498, 10109, 3267, 16591, 19901, 12970, 15843, 2673, 6960, 7762, 15556, 6040, 3112, 7719, 19276, 7673, 18449, 19368, 5256, 13484, 8765, 11729, 1833, 10123, 2206, 11976, 16873, 8908, 7560, 4831, 14870, 17278, 6904, 8654, 752, 547, 6021, 8097, 5474, 924, 18410, 7853, 2633, 13814, 18847, 10210, 2423, 19993, 2816, 11905, 11672, 17031, 9540, 8233, 11634, 11681, 4425, 12064, 12427, 8666, 16323, 6228, 16555, 6368, 2639, 11047, 13469, 5107, 3445, 18540, 16696, 9242, 4659, 10824, 11411, 12197, 19815, 8920, 16153, 4182, 2371, 3447, 18588, 16278, 3815, 17995, 17679, 14179, 14163, 6211, 10529, 9973, 3597, 5519, 11322, 15962, 7616, 15877, 6830, 12633, 11388, 5885, 16270, 10893, 19279, 2497, 14484, 3232, 6561, 12729, 17221, 4522, 18082, 5847, 17052, 8074, 3841, 11489, 3659, 4199, 2620, 5019, 18496, 6078, 16364, 13903, 9148, 13442, 4499, 948, 14828, 498, 2466, 13797, 14878, 194, 14405, 1760, 4467, 2044, 13120, 11394, 5932, 10026, 2010, 5575, 4424, 18128, 8885, 17126, 5557, 15026, 18506, 3216, 15419, 2929, 9422, 8214, 17111, 4008, 16979, 1036, 4099, 2277, 17895, 13141, 14224, 12383, 7130, 11571, 14615, 3101, 9401, 359, 19216, 2372, 15199, 5795, 12593, 12369, 10015, 2346, 18129, 4209, 12309, 18854, 19270, 5424, 9750, 19617, 18438, 14728, 1645, 9477, 6567, 18556, 6022, 2661, 16303, 4037, 2175, 14280, 16026, 7042, 3680, 18362, 8308, 2837, 14321, 10266, 12782, 5817, 8573, 10931, 18440, 6898, 16020, 6756, 5524, 19816, 14483, 8978, 8176, 14677, 3462, 18801, 7770, 1990, 487, 2029, 6562, 13696, 10619, 19515, 17306, 845, 4050, 16616, 8617, 8520, 1697, 1856, 5939, 1680, 13487, 11705, 1378, 2453, 10850, 15128, 5408, 18397, 5527, 4271, 19605, 1476, 3433, 5751, 14017, 5369, 9996, 8914, 14987, 9791, 12206, 694, 10821, 14129, 14945, 6773, 2587, 18, 6962, 12838, 303, 11053, 859, 4844, 18728, 11061, 9619, 1141, 11497, 19857, 19440, 1174, 6064, 16688, 14375, 5113, 8996, 208, 15335, 14318, 17603, 16709, 4362, 4056, 18949, 14952, 18450, 8373, 18355, 14546, 19138, 14096, 14035, 8429, 19957, 14542, 18214, 5571, 302, 10341, 16644, 2782, 5433, 954, 7706, 14192, 8422, 13331, 1239, 17288, 9974, 13570, 5157, 8061, 19871, 19743, 15263, 3914, 15040, 4269, 514, 3579, 234, 18171, 8878, 8310, 14264, 7888, 7591, 16198, 18921, 15717, 19167, 9915, 11207, 13055, 19565, 19636, 19653, 6342, 12152, 1918, 9335, 1965, 11485, 340, 19646, 19084, 3406, 11482, 4043, 1021, 13397, 10617, 3916, 994, 722, 16775, 2977, 10574, 2451, 13709, 4520, 702, 15653, 1400, 9707, 6645, 16378, 1451, 15726, 10205, 9143, 9011, 13847, 475, 15658, 14079, 19992, 2390, 16816, 12150, 15835, 12425, 9913, 5860, 16753, 8872, 14349, 7993, 6066, 1752, 16800, 3126, 9728, 9024, 3748, 8271, 9658, 6186, 11049, 6728, 15109, 8682, 12100, 18527, 12241, 13291, 16022, 19795, 19378, 4401, 2243, 19525, 14434, 1044, 10268, 8775, 2812, 12618, 9954, 2946, 10787, 7791, 18154, 1462, 18146, 16339, 15999, 2936, 9847, 2373, 13405, 15364, 15224, 17597, 2513, 17442, 8008, 11641, 19706, 19193, 8747, 1201, 18522, 5670, 17028, 16448, 17622, 18669, 1836, 2169, 3573, 9342, 8437, 1822, 4249, 19022, 6505, 13650, 8328, 13289, 5945, 14620, 19217, 16598, 9606, 9678, 6089, 12730, 19618, 10182, 14390, 3083, 2976, 2080, 6860, 17189, 14637, 15479, 15121, 11317, 12557, 1755, 5102, 12030, 14149, 9426, 6921, 12048, 7720, 12544, 419, 8177, 5024, 3203, 10527, 15722, 6789, 14754, 17192, 18671, 7218, 19487, 15074, 4624, 6283, 10229, 2075, 3329, 2930, 13389, 6226, 530, 6455, 14538, 5119, 2107, 1711, 13242, 11649, 18416, 7533, 16087, 16524, 8165, 15288, 14648, 17411, 6983, 7550, 4872, 3606, 2600, 6059, 4856, 2554, 2960, 7312, 7561, 15991, 2404, 6947, 10572, 14301, 4355, 12849, 10766, 9345, 2171, 5720, 14461, 1899, 18274, 803, 1882, 9650, 8320, 7112, 12561, 3384, 4958, 17726, 17664, 47, 3105, 16460, 13906, 5871, 4917, 616, 5430, 7010, 2597, 16647, 3543, 19008, 10697, 5055, 13809, 274, 6362, 13681, 17, 8640, 11409, 13701, 16025, 4946, 2158, 13772, 4643, 4920, 14646, 1209, 5069, 16179, 18969, 13312, 443, 16857, 16970, 7722, 3474, 7605, 5963, 17445, 126, 10440, 17653, 130, 257, 16684, 2279, 5262, 11573, 6475, 11563, 2259, 305, 16207, 18101, 3440, 18827, 17443, 8609, 10724, 15763, 13680, 15320, 11693, 13406, 9382, 1763, 4995, 7491, 14505, 18784, 18986, 10200, 974, 16842, 13982, 5122, 14794, 12688, 9330, 6181, 14351, 3137, 15863, 16383, 19238, 13829, 8118, 1686, 13932, 14409, 4079, 277, 5950, 9947, 8426, 1896, 6256, 5210, 7508, 4314, 17839, 2151, 15236, 14869, 2054, 1299, 14813, 8629, 17365, 6204, 9334, 17000, 2480, 2041, 8280, 18010, 18936, 12739, 16643, 13678, 8474, 13166, 10881, 4061, 3699, 3223, 13427, 1946, 6401, 5366, 8113, 2978, 98, 13961, 59, 12471, 2967, 8624, 18354, 369, 3732, 7307, 8736, 3511, 2145, 14601, 1372, 5269, 4273, 3485, 19108, 4421, 9483, 7671, 9696, 1757, 15895, 8075, 12903, 3430, 5277, 13226, 2924, 6693, 11013, 10508, 13196, 2603, 4902, 11067, 10712, 222, 5171, 13220, 2143, 15967, 10346, 16982, 2471, 18952, 13094, 14227, 13821, 19300, 10870, 1626, 7944, 12486, 2803, 18788, 507, 17695, 2219, 11519, 12602, 8425, 5616, 2135, 10998, 4688, 5907, 16611, 17199, 8312, 2881, 4265, 13519, 10511, 3897, 7357, 5142, 5364, 3364, 12215, 18931, 17519, 17957, 8279, 11999, 4227, 16597, 8114, 5103, 12929, 5914, 10485, 16571, 931, 15372, 13530, 6622, 16744, 13753, 12956, 13941, 11514, 19869, 6174, 5379, 17691, 4000, 12079, 5576, 4989, 13416, 10671, 5531, 13754, 10840, 3893, 18294, 3676, 2205, 13785, 15530, 4992, 14284, 3048, 19364, 17808, 18959, 12839, 2810, 2245, 12607, 7781, 6146, 1842, 2178, 12481, 12135, 18202, 17855, 14092, 18652, 18859, 19029, 1641, 14655, 7177, 1692, 4519, 7332, 16412, 18706, 12503, 10708, 15681, 3274, 643, 15023, 16742, 235, 14235, 15308, 19594, 5613, 12874, 8910, 3172, 19473, 17263, 18775, 18221, 14283, 17039, 4214, 11872, 19178, 10153, 19076, 4490, 5025, 14056, 5716, 3033, 9245, 10082, 662, 5752, 410, 791, 1439, 8679, 8638, 2441, 1879, 2446, 18282, 10885, 3625, 14867, 2988, 1742, 14031, 2417, 17117, 13310, 12046, 14713, 5138, 5030, 18036, 1996, 4821, 14894, 2375, 3499, 9688, 19140, 4321, 10990, 11415, 18271, 6812, 6203, 3412, 10258, 18097, 3424, 7912, 1887, 840, 572, 3888, 725, 9644, 2411, 8186, 7028, 15965, 3147, 211, 3150, 18916, 1325, 5216, 2508, 18477, 17998, 7740, 5332, 4186, 5222, 14884, 19343, 7396, 19296, 19356, 16237, 2589, 7352, 17309, 116, 10230, 1480, 11844, 2621, 5745, 5048, 19663, 12837, 3532, 18207, 17256, 16435, 2150, 6528, 14089, 13167, 13835, 2524, 9767, 7648, 17158, 14919, 13526, 10484, 16735, 14333, 18269, 2477, 16461, 15856, 7599, 7621, 15075, 6808, 15135, 12249, 1520, 7958, 14928, 6432, 16084, 10747, 2352, 8325, 19492, 11585, 3408, 6198, 4708, 19768, 13479, 6686, 19803, 18562, 11574, 14282, 17241, 2420, 14244, 8856, 785, 794, 11853, 2833, 5298, 7191, 16699, 14462, 11246, 4190, 4088, 7773, 18091, 10142, 4926, 5855, 6889, 8579, 12102, 17413, 16048, 14308, 14503, 3276, 1326, 9169, 41, 8401, 1639, 13472, 16404, 17355, 14896, 4672, 5523, 10233, 15350, 12530, 10392, 3481, 5494, 13353, 2853, 12257, 3260, 15762, 13165, 8884, 11944, 17217, 2917, 12793, 13003, 5345, 3241, 12344, 7543, 5980, 11419, 3695, 18011, 11752, 11852, 4673, 8746, 12423, 19282, 11889, 7048, 16480, 630, 12673, 10110, 6520, 18542, 13818, 3827, 15395, 5977, 18605, 4223, 17024, 9569, 663, 17258, 16716, 929, 3855, 7415, 19132, 11296, 13361, 3013, 18898, 4838, 16322, 5385, 2809, 11278, 13841, 6383, 13577, 13602, 15765, 2699, 3154, 7855, 4683, 11192, 8421, 9052, 3566, 19255, 12331, 19222, 13426, 9318, 1262, 12042, 13540, 16145, 11884, 8537, 6170, 13536, 2033, 5054, 11033, 15924, 17204, 243, 10111, 10896, 10465, 7925, 17524, 11462, 18945, 15137, 7639, 8667, 16234, 3838, 5841, 3020, 17989, 1389, 15294, 4618, 160, 5013, 9993, 17874, 6515, 1118, 2509, 5620, 7366, 10808, 5825, 6320, 9299, 2191, 12902, 18541, 8504, 2393, 3831, 10297, 18448, 3807, 2832, 13235, 5377, 4460, 7259, 13393, 1231, 10299, 14172, 1815, 18052, 8890, 15390, 898, 13303, 11250, 19357, 1049, 1514, 3641, 12975, 10312, 13245, 10526, 14734, 17777, 3494, 25, 7478, 5223, 18004, 17946, 5988, 11551, 3235, 16537, 18804, 18998, 11821, 5293, 5991, 17181, 15169, 4149, 1105, 12275, 9752, 15742, 7650, 10784, 9978, 2455, 15171, 15062, 7044, 14733, 10317, 17872, 1599, 9122, 18840, 6465, 14736, 9045, 12348, 3825, 4726, 13534, 13028, 14248, 9726, 1846, 16103, 2901, 14009, 4962, 4634, 18591, 5776, 5205, 15234, 14536, 15032, 441, 4755, 8788, 13155, 1199, 18667, 14762, 14015, 9812, 13747, 10929, 4327, 18455, 10426, 10107, 3816, 11201, 17791, 6837, 7467, 11159, 17915, 15065, 18838, 19081, 3365, 10883, 9815, 14816, 9798, 6255, 6927, 3562, 9770, 18056, 6829, 8871, 1019, 3093, 5495, 14956, 506, 13883, 14663, 18899, 11981, 16650, 3741, 6644, 19893, 12071, 11991, 18515, 11719, 7970, 9283, 8218, 1089, 3567, 7903, 6246, 16171, 8547, 16421, 903, 17065, 3743, 3382, 5739, 2592, 11300, 297, 1282, 1907, 17715, 15183, 5347, 8080, 11365, 14354, 9766, 356, 4030, 9249, 3508, 6893, 5726, 317, 14551, 7096, 19074, 9532, 15293, 11194, 12699, 17240, 11344, 1153, 11798, 5452, 19899, 9408, 2288, 5811, 16288, 9652, 3826, 10716, 18049, 11027, 10342, 520, 16583, 16875, 3530, 3197, 12076, 18375, 962, 5029, 11541, 7895, 16580, 17804, 19603, 11565, 5453, 5903, 19596, 2396, 3170, 15256, 12872, 12387, 1989, 5583, 11357, 12555, 377, 17558, 14206, 13229, 16756, 13408, 4808, 4908, 2239, 7059, 6847, 12835, 8212, 13509, 8057, 5026, 12372, 13723, 11744, 3063, 2738, 4350, 9297, 10560, 13288, 7302, 1034, 9213, 5214, 13588, 18145, 6928, 806, 802, 8435, 11868, 11187, 17550, 17864, 9195, 18653, 13137, 4787, 3192, 1142, 14139, 13086, 9324, 11003, 7407, 13574, 11985, 10868, 2000, 9542, 4084, 2092, 7252, 10882, 18110, 12803, 17370, 18321, 8752, 9431, 10705, 13830, 1997, 18732, 4737, 4417, 15486, 12015, 10474, 9934, 11647, 3143, 5689, 15590, 19975, 16382, 11593, 2448, 6796, 19758, 2296, 13045, 3814, 14297, 13360, 19648, 4059, 7954, 7630, 14776, 7447, 11825, 9109, 17441, 3254, 12579, 13802, 5563, 370, 7344, 4252, 15926, 4131, 9167, 4006, 16442, 9603, 11703, 153, 13623, 15971, 7865, 19571, 4028, 10255, 5416, 12039, 9157, 509, 15691, 5678, 9885, 8585, 16420, 3647, 17585, 12229, 6470, 1314, 4323, 3218, 14981, 11939, 7577, 19471, 12199, 16315, 15884, 15638, 12188, 13958, 11962, 17522, 14178, 11894, 1101, 4915, 16264, 3486, 10531, 7118, 9166, 6249, 10913, 4200, 17100, 16298, 7919, 3258, 6244, 12305, 19959, 15440, 19676, 11186, 3595, 16496, 4136, 1932, 3683, 14602, 19724, 71, 16447, 9278, 15572, 17559, 14325, 9161, 14263, 4291, 16154, 4975, 9089, 14565, 16233, 13865, 10071, 15569, 7633, 10753, 12583, 4392, 11865, 3188, 7062, 1666, 12833, 9490, 2154, 3619, 18127, 10464, 4451, 18864, 14924, 6423, 3304, 10052, 12979, 9304, 15178, 1594, 8711, 15204, 4503, 668, 6243, 19308, 2993, 3248, 18881, 9411, 17321, 10215, 10338, 17567, 19510, 9230, 11352};
int array[40000] = {36509, 27338, 15331, 9252, 2804, 7622, 7581, 31646, 30486, 22662, 30386, 2263, 11023, 5585, 30710, 30422, 30154, 21244, 11773, 2612, 9404, 33157, 30233, 36092, 39574, 26118, 3077, 20812, 36070, 37040, 659, 7585, 35219, 30232, 4074, 11386, 19258, 1990, 18474, 9081, 39443, 18608, 29182, 770, 25880, 21505, 35377, 21502, 2386, 4970, 24622, 34626, 25332, 39834, 17657, 35148, 21708, 24398, 8898, 35200, 29198, 20805, 19845, 30060, 12411, 10014, 1342, 21111, 11649, 35525, 13675, 37193, 4456, 6426, 18181, 23394, 38410, 9243, 21865, 37527, 12550, 17632, 25218, 10861, 2315, 19469, 37708, 38527, 21843, 30737, 9947, 8710, 21794, 2962, 15822, 31417, 107, 8323, 28629, 29249, 37398, 36006, 32055, 2779, 4833, 5903, 164, 34540, 2780, 26678, 31107, 2086, 35405, 38256, 19399, 6397, 4637, 6471, 32167, 24980, 5377, 37539, 27777, 6292, 33135, 5255, 16280, 29878, 18068, 6786, 21191, 36491, 23211, 4209, 39683, 30416, 1572, 4928, 7160, 19075, 10072, 32733, 35376, 37370, 18438, 15987, 1927, 27540, 27620, 37743, 29525, 32026, 27767, 12705, 34296, 22908, 27204, 35188, 38207, 9641, 17189, 9558, 30073, 17111, 26524, 27093, 34284, 20875, 38628, 36659, 2023, 7455, 33223, 6816, 254, 11417, 1227, 29058, 28042, 36180, 9111, 34195, 32976, 5439, 29784, 10541, 4035, 1249, 31360, 12163, 32185, 810, 26309, 1224, 11473, 4985, 7802, 22528, 24347, 18692, 20570, 22340, 12295, 35663, 13110, 27527, 21322, 21225, 36489, 22561, 7477, 24989, 9430, 29317, 4585, 32643, 37581, 23665, 3891, 7139, 23221, 18452, 23659, 287, 5095, 4080, 20042, 34441, 32742, 30933, 13146, 9413, 7505, 7129, 9216, 23731, 2170, 1323, 11807, 35925, 26727, 26958, 29090, 36459, 21068, 27813, 24811, 12692, 8411, 24810, 19791, 27589, 7825, 30898, 12263, 23722, 7528, 23481, 13317, 38620, 25798, 37292, 37735, 28660, 17509, 891, 20088, 37421, 5360, 4804, 34766, 36662, 13550, 39626, 6379, 14974, 18293, 1825, 32824, 24086, 36562, 32968, 19545, 17105, 16727, 3237, 1521, 15442, 33503, 26454, 29305, 17749, 36429, 33849, 15727, 11410, 37557, 23010, 38045, 21713, 38942, 25843, 19601, 26328, 23307, 19871, 19652, 32269, 8497, 10967, 32575, 39843, 36741, 27517, 30405, 38154, 24952, 6481, 17260, 36303, 39313, 1967, 33388, 8321, 27820, 6207, 24000, 35389, 34866, 17697, 1234, 20369, 31809, 22709, 24269, 211, 26223, 6949, 33741, 28003, 9378, 37116, 27172, 23118, 264, 5162, 12164, 24503, 9885, 29746, 15394, 36802, 6682, 36370, 36779, 37725, 35288, 408, 8222, 17547, 3771, 31534, 4486, 28893, 17845, 38875, 36395, 21403, 12476, 10024, 39719, 14357, 22040, 1975, 12714, 30497, 30341, 29073, 4727, 16294, 30799, 37950, 36753, 34217, 9509, 17669, 16452, 19047, 21583, 34714, 306, 12786, 3269, 18247, 21307, 24919, 30044, 35538, 20256, 20705, 22146, 11031, 14658, 25854, 22993, 27992, 38467, 28862, 4425, 20632, 18896, 7695, 5991, 26901, 39961, 6047, 6357, 12139, 30010, 33163, 19257, 1641, 9777, 13818, 29092, 405, 450, 12464, 29432, 31414, 25727, 11320, 27377, 23338, 34109, 6515, 39388, 36684, 9384, 26637, 2867, 34733, 5482, 21915, 12357, 19818, 15073, 11985, 33078, 35962, 31097, 3802, 26683, 26926, 10105, 37291, 35907, 35887, 5669, 18949, 22424, 1264, 3984, 11359, 255, 1733, 7639, 19445, 33038, 3106, 8305, 26754, 9238, 34515, 10292, 36446, 19355, 33930, 27247, 16013, 12614, 31439, 18301, 30161, 31686, 33920, 7102, 19430, 29603, 18596, 13703, 35055, 7154, 25047, 8892, 8160, 6361, 27456, 13431, 4981, 20532, 39180, 11273, 34282, 26170, 33017, 30878, 34334, 15077, 8993, 15094, 38941, 36421, 13517, 27010, 21086, 7545, 5460, 1812, 29584, 33022, 4177, 23460, 34462, 1108, 20381, 7098, 25322, 32115, 18837, 20332, 7429, 8626, 32285, 26439, 27303, 1316, 10823, 7353, 7784, 8009, 3477, 16417, 18900, 13576, 5570, 24287, 27007, 23610, 251, 13571, 32010, 20528, 27044, 24882, 247, 15956, 2150, 22589, 35823, 21288, 23365, 1050, 21145, 13500, 24662, 3015, 1714, 24871, 38077, 37763, 10584, 30751, 24272, 23107, 36145, 29768, 34396, 11088, 6154, 1054, 19219, 18468, 27658, 32384, 18471, 28264, 17296, 1925, 11779, 3545, 28531, 19985, 10558, 31088, 34986, 35603, 23985, 30268, 19708, 39764, 32448, 31007, 15698, 17316, 37008, 36760, 39007, 14568, 22519, 24348, 32801, 34483, 12581, 14266, 28990, 3094, 35633, 3666, 1821, 2760, 38470, 9261, 26406, 7731, 10403, 8212, 31162, 26873, 5044, 21983, 18377, 28022, 19373, 25175, 30455, 1280, 5549, 11077, 19858, 24004, 38889, 6227, 1569, 12664, 36378, 28421, 16118, 15860, 1730, 36336, 36686, 34449, 13392, 6545, 9978, 2564, 36856, 32808, 36052, 26753, 31312, 13385, 14003, 25576, 24189, 38692, 24637, 16051, 33764, 5977, 37121, 3576, 31392, 25620, 6781, 5537, 16501, 7431, 32748, 15225, 28733, 2731, 11084, 23873, 36140, 33958, 944, 11115, 518, 31886, 19565, 27346, 9349, 18066, 2178, 5971, 2650, 4098, 233, 37235, 6133, 24420, 19262, 24448, 13257, 14063, 30543, 38290, 39521, 17899, 23192, 18994, 37617, 38320, 14165, 14142, 24543, 33881, 13203, 12826, 36095, 15924, 8046, 5113, 20998, 38295, 7887, 31472, 23392, 17270, 29397, 8932, 27119, 1370, 3870, 25926, 5781, 12795, 14922, 18473, 36683, 28895, 2483, 13895, 1658, 444, 34896, 8875, 28555, 28452, 31847, 27045, 29606, 12154, 32304, 7248, 26552, 36833, 20819, 2126, 26101, 38178, 986, 22288, 12226, 24988, 14280, 9668, 22583, 15158, 24749, 29531, 12613, 35578, 31375, 14194, 23715, 22256, 22691, 39857, 24575, 34833, 20211, 18144, 30417, 29824, 36875, 1459, 31383, 27765, 13493, 35517, 19929, 1667, 11475, 22673, 17788, 17026, 15026, 14163, 4077, 28277, 11125, 1833, 9249, 36359, 37117, 1319, 38132, 17704, 16577, 8785, 6034, 39972, 34095, 5626, 15343, 1905, 9381, 17220, 30107, 17787, 35938, 9454, 20802, 25351, 37261, 20122, 26939, 4137, 21488, 29821, 27492, 36782, 508, 23027, 7113, 8631, 31869, 31634, 20253, 8435, 38675, 9580, 26241, 26430, 12534, 4923, 21280, 8031, 16097, 14802, 29795, 12393, 5066, 24797, 24538, 5132, 26058, 25657, 9864, 21290, 33411, 8876, 24107, 28916, 37703, 19264, 17753, 5228, 31224, 30956, 5733, 33904, 19568, 15774, 10840, 39203, 36415, 31588, 28378, 3165, 30021, 30193, 28657, 3636, 28315, 14014, 29216, 16403, 30278, 27950, 28094, 38195, 16764, 35921, 22750, 29780, 29588, 28263, 7760, 6817, 30631, 4062, 37139, 28197, 3684, 29875, 26987, 10860, 4589, 22373, 39732, 21117, 28706, 15363, 31024, 39137, 21048, 35359, 25495, 23856, 7136, 37434, 20176, 2497, 12002, 39420, 19118, 24068, 32369, 24512, 33337, 4302, 5368, 26551, 39287, 38578, 10971, 5080, 21523, 27925, 33605, 15726, 34055, 1934, 22992, 14888, 12557, 30801, 30065, 15622, 30941, 35180, 20261, 4636, 23004, 35545, 10537, 22550, 19822, 16450, 12152, 8984, 25104, 31632, 35952, 11339, 20755, 10013, 18667, 32980, 10054, 30998, 10356, 21805, 8930, 25950, 33013, 39463, 13473, 26571, 14655, 17480, 2767, 27179, 20728, 17348, 14752, 3778, 7563, 1057, 18697, 35658, 17991, 29124, 21860, 24562, 4427, 30587, 7152, 3754, 10948, 15138, 17038, 12434, 27295, 39215, 19242, 31651, 4208, 35501, 3222, 31731, 34657, 10772, 34667, 3152, 14111, 36152, 11056, 4773, 21340, 25427, 10956, 1494, 5458, 14490, 19995, 16921, 29564, 17067, 6273, 2538, 28188, 25966, 29548, 25932, 39613, 33197, 24406, 280, 26709, 15834, 3693, 8454, 10468, 2423, 6747, 11907, 3221, 32709, 37243, 19439, 27386, 19333, 22016, 21733, 30789, 34947, 15835, 39678, 35465, 27556, 12769, 18197, 6768, 38991, 37622, 10043, 12309, 15943, 7445, 39532, 37911, 34988, 22827, 38856, 25343, 28889, 27912, 7575, 2653, 23459, 34266, 16463, 20846, 36136, 11479, 27396, 22253, 21282, 21808, 26582, 24433, 9181, 9198, 21747, 37097, 1417, 6690, 19888, 3373, 111, 3226, 28613, 4658, 19152, 24578, 38989, 21431, 30098, 5299, 18754, 6430, 18954, 39149, 13217, 37710, 38033, 21351, 13260, 37230, 3971, 8975, 13560, 6672, 30660, 8386, 26685, 14770, 5137, 36606, 31229, 13183, 33750, 28648, 6886, 1174, 27024, 17055, 31985, 36663, 750, 31996, 7015, 24985, 17184, 31250, 24281, 253, 32479, 35067, 21572, 27201, 7635, 3974, 2446, 32400, 20498, 17373, 24822, 14042, 34529, 25336, 1814, 38892, 10038, 15779, 17588, 15619, 14205, 22533, 2152, 29895, 22308, 24751, 19462, 6252, 7956, 6761, 24474, 5526, 28134, 11312, 18587, 12168, 30457, 2559, 26157, 37200, 15532, 22991, 4712, 30907, 22959, 28873, 17983, 18359, 188, 36940, 5457, 9299, 35407, 18998, 34572, 7670, 3273, 9636, 3765, 2028, 5166, 32961, 561, 28771, 8272, 3132, 12694, 16836, 7114, 20230, 20764, 39903, 36602, 18913, 19211, 19589, 3812, 30442, 14639, 9062, 2443, 27067, 3607, 25025, 7489, 2909, 39483, 12125, 11399, 15906, 6697, 3325, 12917, 33614, 35720, 7987, 7565, 38647, 30795, 35058, 14973, 2834, 5289, 20304, 17800, 4413, 6355, 1839, 1937, 17153, 22504, 35277, 26243, 23559, 35912, 22637, 34978, 3586, 10524, 30791, 32693, 10921, 31655, 22197, 34119, 26278, 1690, 36001, 16183, 30971, 7672, 5490, 21633, 17512, 20896, 20894, 26622, 27858, 9223, 23456, 31917, 25834, 7714, 30104, 37025, 23317, 8819, 28659, 996, 32050, 32362, 9867, 37764, 39300, 22822, 327, 21061, 28130, 33783, 24620, 26258, 13864, 37976, 31801, 26988, 25785, 22738, 28320, 20181, 8695, 11346, 31908, 37415, 39428, 21124, 18266, 20602, 37816, 2012, 29172, 37970, 8114, 13853, 20983, 12065, 24526, 18056, 24838, 21839, 32547, 5431, 21445, 10241, 11903, 8928, 29697, 25165, 6040, 18291, 25665, 5979, 16044, 359, 8803, 36518, 11356, 31482, 35567, 33700, 21461, 1382, 33965, 5006, 26085, 38494, 37361, 37831, 11919, 38427, 34726, 28987, 22127, 37242, 9649, 23516, 16476, 22792, 1202, 27955, 13950, 27458, 26610, 1019, 759, 13653, 20860, 35474, 34844, 30657, 19101, 4248, 29026, 20336, 11716, 33772, 38971, 30974, 12590, 33555, 2388, 22774, 9348, 36306, 7608, 14070, 24862, 13304, 16757, 34131, 4396, 32345, 27838, 29514, 19138, 20451, 22683, 26397, 32816, 32645, 30173, 10658, 37209, 21998, 8486, 4269, 22416, 16913, 1964, 32231, 30990, 16558, 20307, 4174, 36525, 4746, 16077, 39393, 34761, 32844, 20956, 22486, 6293, 12900, 11733, 24416, 19344, 30469, 30440, 16064, 11859, 21707, 22032, 5024, 1120, 6995, 34618, 25338, 15946, 32196, 36300, 37213, 7377, 8302, 36924, 8917, 5227, 10304, 18105, 37969, 12149, 21076, 25493, 23862, 27387, 2433, 588, 7896, 15859, 32779, 13439, 12504, 13781, 36317, 12190, 34656, 903, 20868, 10550, 14181, 9136, 16487, 13450, 10986, 39978, 36732, 20241, 9810, 16602, 2184, 8828, 21032, 39201, 34322, 44, 23472, 37267, 35813, 29726, 23375, 12211, 20194, 9355, 7541, 8026, 26982, 5221, 14245, 36064, 3957, 24155, 19434, 22102, 18006, 17894, 14779, 3727, 14483, 29552, 4805, 3643, 28015, 20284, 39012, 19831, 23864, 8008, 13961, 10328, 6027, 3308, 34788, 15104, 9358, 23506, 27803, 18176, 32310, 25539, 3099, 21449, 23769, 35693, 33211, 10876, 32085, 11159, 39219, 39346, 16159, 9473, 29978, 8888, 39413, 25189, 27167, 27593, 25942, 36282, 37269, 35442, 7271, 13494, 15611, 34848, 3540, 13707, 25402, 33433, 24992, 7378, 20041, 10502, 10036, 13153, 4306, 34798, 38776, 1262, 29179, 2342, 14497, 25037, 29558, 39614, 964, 18747, 7175, 24074, 28481, 9647, 15936, 13295, 28538, 13539, 3371, 11043, 12953, 11275, 18241, 29928, 3966, 30991, 23277, 20254, 25852, 20212, 1976, 390, 20438, 3437, 23235, 23940, 31259, 23654, 12620, 2153, 9951, 20280, 13012, 36625, 9466, 7101, 19054, 9742, 35677, 7210, 9482, 23943, 15266, 23096, 25045, 15587, 1762, 21749, 23353, 33355, 33438, 30254, 38601, 20981, 11858, 30465, 29458, 35120, 11448, 8372, 5427, 38959, 5964, 9936, 36778, 11220, 38848, 429, 25344, 5591, 10233, 2899, 17713, 8469, 33059, 10497, 34827, 6333, 29222, 16556, 1899, 13187, 27849, 8659, 10235, 36125, 39235, 24372, 22123, 21008, 38216, 13643, 26324, 585, 8942, 942, 31621, 23837, 30220, 14126, 12980, 24824, 21605, 16427, 4189, 32602, 38450, 22501, 22145, 34308, 39273, 4785, 30562, 30410, 36014, 12118, 6579, 14812, 32994, 26418, 19038, 9030, 19053, 38090, 19972, 36133, 19648, 36970, 11922, 27211, 6878, 6763, 852, 32456, 20678, 6924, 21616, 14423, 32279, 388, 20817, 13341, 39311, 3408, 35920, 11264, 38335, 16604, 39082, 34374, 30644, 2951, 14894, 26920, 18509, 3453, 22250, 39495, 39717, 16830, 23882, 13470, 9573, 15808, 37295, 4496, 1930, 19678, 10091, 21740, 32263, 5140, 23883, 37534, 33938, 25517, 9589, 26235, 30304, 17285, 10264, 30647, 5833, 34262, 28413, 17548, 9935, 32500, 16912, 5488, 26590, 22754, 196, 29532, 22458, 9275, 23360, 6152, 34801, 17218, 1528, 25883, 35986, 35704, 2439, 39040, 13826, 24350, 28271, 14424, 6666, 13306, 7400, 2873, 4380, 35784, 27255, 4816, 5407, 4256, 39822, 21607, 24572, 652, 20234, 599, 17554, 23900, 10195, 23996, 38549, 18041, 27734, 37648, 7006, 24319, 22082, 26364, 37966, 30376, 12, 30494, 8581, 12975, 25424, 20758, 28304, 26728, 4567, 10726, 24002, 2247, 24402, 9419, 25443, 38977, 13861, 6860, 7550, 16025, 30168, 1468, 34862, 36348, 25984, 29046, 23182, 15261, 36513, 25431, 3465, 24901, 38099, 25398, 30471, 35159, 31352, 38393, 6921, 19887, 8238, 4094, 29298, 12243, 23493, 235, 24524, 6659, 3952, 4439, 15277, 16909, 19145, 2374, 39036, 9042, 24881, 19792, 31548, 16373, 36436, 27805, 36604, 11926, 28053, 30275, 23082, 14232, 30698, 18395, 29438, 38605, 29777, 12259, 24725, 15635, 7566, 36015, 7020, 1638, 26160, 29115, 28582, 37704, 28680, 24752, 21969, 8481, 34123, 17133, 5934, 1029, 20158, 14701, 2865, 25796, 4566, 8245, 14826, 34440, 37718, 26048, 31836, 10873, 11845, 13862, 22556, 29562, 22654, 11780, 20465, 11350, 34510, 21478, 20301, 33143, 9451, 14685, 11259, 21507, 4216, 38946, 29373, 4569, 27120, 19128, 27669, 33032, 28338, 33333, 22615, 21603, 26848, 16576, 33076, 13205, 32850, 15247, 9247, 21554, 18218, 25244, 16323, 36589, 31292, 23641, 25968, 5751, 6925, 25844, 18409, 1506, 20903, 30070, 9774, 14432, 9980, 7879, 18187, 19703, 30722, 32895, 38895, 30972, 6219, 18089, 3915, 14860, 4768, 22582, 21071, 3660, 19627, 12055, 34745, 18133, 33346, 29454, 28726, 28695, 28149, 31362, 17564, 5208, 38809, 2806, 19639, 28945, 8229, 7500, 29736, 38390, 25093, 27510, 28995, 5638, 11427, 24289, 37363, 24693, 13076, 8431, 5916, 1399, 21835, 6658, 18354, 18960, 20289, 22731, 15839, 18910, 38710, 33647, 24360, 9890, 21236, 1100, 13501, 32030, 25841, 30140, 4488, 17913, 23877, 26475, 4250, 18891, 1388, 36192, 23623, 13491, 23923, 9244, 25602, 35049, 11797, 10810, 13361, 19259, 36867, 10890, 22300, 7935, 28193, 37265, 34035, 26506, 24916, 3287, 19881, 4429, 19164, 31519, 26022, 9696, 28958, 3731, 13296, 34397, 2814, 34099, 34509, 18392, 39322, 832, 7280, 624, 25490, 10359, 33222, 29193, 20714, 18265, 25605, 31939, 18090, 11925, 33578, 35914, 32077, 26830, 16824, 29970, 29505, 33010, 28308, 15449, 23289, 6519, 12632, 18535, 7297, 32565, 8976, 10587, 14613, 37771, 17216, 34429, 23427, 18352, 38282, 39976, 37567, 1208, 11340, 21147, 3275, 36725, 1222, 33258, 15150, 34447, 38521, 31367, 34645, 8549, 6377, 11508, 21239, 11214, 7018, 18665, 38698, 32179, 27175, 3404, 15515, 25587, 37184, 34049, 17314, 6327, 32810, 32665, 506, 369, 26764, 25440, 34898, 39099, 15185, 9811, 27784, 5018, 21418, 2788, 8551, 15303, 13929, 16643, 11227, 2362, 33198, 12552, 2631, 17008, 35360, 4646, 34232, 24096, 11183, 32034, 11230, 32869, 13349, 30932, 25110, 4647, 38957, 13119, 7577, 37722, 6873, 29654, 15660, 15973, 33672, 27180, 25, 36344, 1659, 15403, 16259, 16818, 24531, 35889, 19285, 26456, 39637, 21171, 29608, 25227, 33003, 16525, 24861, 28727, 37174, 2262, 11496, 39134, 25096, 39363, 26455, 13674, 22468, 17175, 9481, 12595, 36252, 1102, 13903, 35375, 4533, 20690, 14813, 38849, 33875, 5048, 23204, 13920, 10626, 31475, 34627, 30327, 34790, 25814, 25451, 38016, 1451, 23440, 6083, 35939, 4172, 7637, 10442, 21753, 20408, 6746, 20303, 30157, 11241, 10164, 38914, 28927, 36405, 29135, 23910, 36013, 31912, 6340, 27736, 30840, 28355, 433, 39050, 21069, 20619, 20745, 25594, 33695, 21218, 33618, 22895, 6883, 14780, 22653, 31923, 416, 16785, 14982, 39177, 9728, 21362, 35609, 34838, 3245, 33521, 6158, 16065, 26620, 10041, 17442, 24321, 21722, 19194, 11639, 22987, 12588, 3265, 39650, 4799, 39341, 100, 3049, 18658, 4037, 6026, 14507, 23132, 37917, 9155, 35491, 37089, 29001, 8722, 560, 18280, 29383, 9901, 10074, 12616, 17898, 3336, 18890, 37239, 33410, 31218, 6554, 36411, 33990, 36575, 1149, 28297, 10522, 31664, 16915, 35656, 28405, 27131, 5613, 3218, 15488, 10766, 12096, 1455, 23533, 20184, 12194, 10291, 31675, 24022, 38456, 17717, 26335, 7722, 6306, 37021, 28970, 26155, 19364, 15992, 3566, 19636, 13137, 4622, 23922, 775, 907, 32083, 38116, 12198, 1837, 12972, 37751, 22259, 16710, 19996, 22455, 23646, 6093, 15502, 38518, 2626, 6861, 24788, 29466, 19613, 18843, 4391, 17273, 19071, 15189, 31914, 15527, 14180, 16526, 16179, 35190, 38953, 8929, 18702, 35354, 3775, 12709, 15122, 12751, 36088, 15923, 32003, 38418, 11478, 6369, 26359, 31538, 18412, 4864, 32386, 11091, 12102, 28031, 7961, 11317, 26651, 26799, 3239, 29476, 36895, 32677, 20620, 29853, 2827, 21984, 38550, 23430, 36571, 20444, 1495, 11486, 19066, 19756, 16331, 8563, 18684, 20259, 24933, 17667, 35974, 24731, 14520, 1248, 3056, 21216, 17926, 25060, 29940, 28323, 9095, 15818, 19020, 35280, 18268, 8106, 4190, 22876, 25707, 7077, 3016, 22619, 32996, 33178, 31976, 32379, 31062, 26019, 3927, 19105, 36379, 35955, 2149, 10605, 38584, 37015, 26459, 19422, 39476, 18543, 28793, 4494, 126, 35864, 18531, 3716, 20885, 708, 24659, 20783, 9294, 33426, 562, 15127, 17072, 21701, 1214, 3578, 37746, 14469, 16916, 26900, 39280, 27597, 29498, 5224, 15794, 18589, 38237, 32698, 4045, 34516, 33180, 31051, 5502, 35425, 17835, 10018, 7789, 30123, 9007, 13073, 17193, 38065, 38429, 39582, 28268, 29175, 37698, 14675, 27755, 27719, 39748, 26684, 28984, 4136, 33121, 11692, 626, 3108, 11174, 7134, 25063, 7057, 6039, 35415, 30638, 17933, 35595, 38438, 13608, 30849, 1909, 32705, 26140, 16304, 35201, 37818, 27776, 22516, 14502, 22297, 26428, 11108, 38356, 26045, 39799, 1791, 39252, 39536, 15909, 9170, 31638, 31887, 26508, 31465, 7498, 35172, 35262, 27870, 13940, 25995, 4645, 10487, 31640, 25823, 36675, 27230, 18704, 29495, 31602, 34784, 2769, 16070, 28520, 22392, 3316, 30242, 39805, 26349, 14695, 25136, 29967, 22904, 36063, 5665, 16956, 18877, 28868, 24358, 35623, 6239, 34378, 36918, 10647, 19986, 19653, 371, 2960, 27189, 14143, 38839, 39330, 21033, 33098, 33661, 7841, 17036, 34530, 23725, 13836, 34359, 160, 4748, 26520, 27919, 16073, 2387, 19369, 29793, 13516, 39410, 21138, 2093, 2990, 30369, 23825, 17449, 34481, 25387, 6985, 1775, 2432, 39122, 18634, 6150, 34702, 11097, 36032, 37340, 39473, 8334, 9029, 27700, 9001, 14155, 29801, 24879, 35617, 34201, 18541, 13077, 36843, 34141, 39882, 39881, 8268, 37087, 28258, 20895, 25469, 22152, 27079, 545, 32978, 12268, 35814, 32755, 3582, 23692, 16058, 6603, 6853, 11573, 11406, 20311, 701, 2100, 916, 11750, 18618, 14049, 29992, 11792, 20989, 12670, 27356, 9990, 11439, 33785, 4295, 4220, 711, 23260, 15664, 97, 27791, 16749, 30904, 24595, 8451, 24153, 24152, 26559, 12160, 14284, 3903, 4421, 36839, 2858, 19531, 18018, 27244, 30654, 12989, 38582, 12109, 7444, 10570, 24521, 8102, 18451, 19915, 34776, 14447, 12833, 14542, 31854, 35675, 7010, 10145, 18824, 37723, 5663, 33133, 1571, 37983, 8063, 1880, 33532, 18920, 12685, 32228, 35560, 15592, 22751, 35344, 18676, 38278, 22005, 32560, 35744, 39723, 19216, 24926, 15177, 21791, 27082, 20355, 36139, 26168, 11051, 38837, 9118, 13410, 13737, 4072, 21435, 3046, 16673, 17384, 39934, 24439, 11882, 16557, 19316, 28521, 1413, 10879, 36103, 11535, 20823, 17575, 8510, 27815, 37547, 19637, 32124, 9530, 38364, 12522, 31960, 16377, 12669, 21593, 19588, 19171, 31261, 35276, 26521, 39021, 21041, 14484, 24059, 25285, 10829, 22429, 36651, 314, 3061, 24833, 37528, 30804, 32435, 30087, 28749, 3210, 20569, 17439, 19158, 21482, 25111, 24277, 35242, 32975, 20140, 33986, 35995, 22338, 30491, 27457, 25582, 15751, 22115, 19573, 32408, 5562, 30661, 38434, 36640, 6756, 20457, 8946, 1731, 8181, 38496, 35455, 24855, 18400, 32088, 16125, 33050, 9871, 12306, 192, 26825, 16436, 12199, 14485, 17558, 2350, 38069, 19331, 22380, 18073, 9887, 34467, 19998, 22294, 27134, 32201, 39925, 38044, 26842, 31069, 20793, 36611, 5411, 35842, 34158, 8257, 1984, 29407, 3623, 23410, 15697, 26502, 8937, 8476, 36473, 33483, 23891, 10203, 20313, 18076, 19319, 20377, 20109, 34448, 24540, 20132, 20527, 36540, 13530, 19503, 3886, 30099, 19798, 23526, 30893, 30378, 21735, 23154, 29166, 27243, 6633, 17985, 5702, 39319, 9583, 11873, 32673, 19356, 26749, 31633, 3963, 31822, 3941, 19629, 20278, 33170, 11984, 14199, 7172, 5696, 10979, 22180, 36885, 600, 36068, 33468, 11474, 12392, 20792, 12873, 19562, 25100, 25367, 11396, 5327, 7559, 26271, 2291, 22591, 29489, 30459, 241, 26133, 2530, 33194, 21600, 25660, 12803, 11564, 4510, 35243, 11298, 30452, 2708, 38312, 7392, 14657, 4294, 23383, 4054, 1226, 36762, 17545, 19451, 14278, 29827, 17019, 19646, 20050, 3030, 14614, 9504, 673, 2518, 14057, 28871, 19669, 37383, 1517, 29271, 19225, 10555, 21710, 26995, 26946, 21308, 33419, 32995, 2501, 1210, 34435, 22831, 2893, 21755, 14670, 37931, 12375, 28601, 7337, 6677, 11360, 34343, 7433, 37575, 37630, 14212, 10392, 5328, 8600, 5398, 13284, 25871, 10132, 2798, 18668, 1140, 14026, 33046, 21134, 28365, 1395, 3783, 18333, 23729, 34288, 27948, 25808, 30488, 24432, 31057, 7484, 4578, 15256, 11438, 3717, 4283, 12046, 6914, 35879, 26542, 5980, 10262, 28763, 19655, 23706, 27273, 3857, 20941, 24236, 37548, 668, 14844, 10842, 6703, 24504, 15848, 11658, 4751, 37011, 9622, 35855, 35116, 36671, 9570, 12544, 13860, 36948, 34837, 14525, 12381, 2801, 37026, 35795, 15194, 30256, 38244, 13876, 29447, 13993, 31129, 10579, 10138, 18298, 37657, 3093, 20268, 29106, 31248, 32667, 4590, 17282, 13193, 16319, 18000, 8340, 30150, 10831, 19592, 4642, 14976, 29270, 22763, 16285, 27730, 37194, 19318, 1656, 32464, 31372, 38319, 16655, 12922, 18437, 35518, 17207, 6827, 20474, 31242, 16084, 8562, 30094, 18670, 6615, 32655, 25507, 15201, 31457, 6108, 2098, 25242, 25316, 18767, 25604, 29814, 38616, 32042, 20172, 31849, 1556, 22447, 37364, 20487, 34597, 29769, 22789, 32387, 17370, 18373, 19661, 12706, 13943, 34405, 876, 18320, 27463, 20324, 26295, 11950, 28230, 24305, 34038, 38990, 24813, 11709, 33867, 15484, 9480, 13599, 39572, 35019, 21976, 9949, 10901, 34641, 18502, 10983, 11714, 36920, 9584, 39673, 29229, 24535, 14434, 16630, 14468, 31281, 34259, 33108, 31022, 29237, 6912, 38912, 32200, 29152, 16010, 2935, 5871, 17789, 1729, 36340, 13322, 23271, 30748, 27864, 20855, 29054, 24404, 21730, 21009, 4995, 5374, 14772, 25040, 12281, 37612, 18254, 10583, 4318, 21949, 14496, 6643, 4720, 23363, 17945, 38706, 4304, 6091, 12366, 29292, 13629, 22971, 36646, 38229, 38006, 29194, 3031, 29781, 15567, 35429, 18492, 16751, 2649, 5159, 32802, 38012, 2290, 21058, 26054, 13849, 11262, 39973, 15706, 37578, 36322, 8630, 9931, 35533, 11254, 34817, 1631, 6147, 14584, 36078, 38854, 8493, 15828, 1748, 31403, 13185, 39757, 25911, 2754, 28467, 21518, 30047, 9053, 39879, 5728, 35267, 22720, 8429, 39369, 33204, 25117, 9183, 2842, 14641, 11188, 33733, 15292, 2260, 11338, 14668, 3655, 9262, 32661, 13942, 20689, 39171, 18992, 28057, 25166, 152, 17066, 33519, 16708, 5870, 18005, 6993, 28076, 23420, 37520, 33497, 34793, 31299, 22617, 38482, 32511, 7710, 8366, 22620, 679, 19223, 13557, 26855, 22962, 39126, 9527, 859, 10001, 16884, 2687, 17438, 1209, 14946, 7251, 22933, 34143, 6983, 14620, 32857, 32641, 20023, 11812, 14140, 15017, 7087, 6568, 15109, 4305, 28943, 37866, 22717, 20994, 19022, 13944, 36494, 937, 33421, 39796, 27878, 9741, 17861, 4155, 9267, 18411, 32687, 33989, 5144, 6718, 5019, 23818, 39135, 23829, 9263, 8868, 11836, 9681, 4770, 22257, 6686, 10685, 33103, 26774, 21113, 3960, 133, 7256, 6922, 8235, 9483, 8675, 21768, 39204, 33531, 27149, 24533, 13795, 21149, 22175, 9502, 39806, 22667, 7728, 8071, 21736, 32842, 720, 1850, 10010, 9604, 26581, 6025, 5386, 12372, 38974, 32686, 7742, 19033, 513, 26739, 9024, 31531, 21299, 6536, 471, 4717, 35606, 23373, 17525, 24530, 38460, 34454, 26315, 21628, 39752, 30768, 12861, 23400, 32333, 24438, 5160, 20694, 2601, 38076, 18103, 20038, 11630, 17585, 21800, 28316, 10836, 38782, 38592, 24218, 24201, 36127, 8065, 33249, 9844, 12914, 30705, 20000, 19260, 19597, 4934, 21258, 23669, 22553, 32764, 10394, 23467, 36425, 21073, 3430, 13900, 1599, 7716, 30826, 33167, 20193, 34333, 19463, 8034, 33402, 28140, 20859, 6580, 21458, 21230, 675, 19632, 34285, 12386, 5415, 29296, 23311, 15021, 13041, 39016, 23436, 29162, 28013, 11096, 38350, 17447, 32780, 38861, 28732, 17095, 25612, 24914, 13535, 23604, 35953, 18671, 1618, 33428, 15574, 24781, 25130, 29698, 11354, 11756, 15032, 30068, 28791, 6872, 3670, 5410, 7985, 13544, 32163, 13106, 8453, 15230, 15537, 3704, 6943, 2267, 8167, 25577, 12908, 35628, 187, 30177, 30159, 39810, 33868, 36656, 18344, 12104, 15295, 20220, 34693, 7640, 36879, 34912, 21639, 28621, 26864, 37236, 6846, 21318, 17441, 11155, 25041, 37019, 36965, 36183, 15080, 20816, 34778, 4257, 14588, 21568, 28111, 32949, 2620, 19739, 35821, 22467, 6000, 16095, 29932, 33552, 23886, 2548, 32556, 11177, 14343, 19487, 10372, 38949, 7906, 12475, 19952, 4553, 17887, 29753, 23431, 15995, 24826, 21647, 17957, 33685, 32957, 36511, 10906, 12841, 698, 23525, 8638, 2728, 26664, 19801, 12061, 31001, 35521, 2403, 3114, 34758, 36462, 28142, 14121, 9031, 13757, 13443, 35278, 19663, 23570, 8039, 17707, 25429, 13367, 32545, 17168, 8423, 52, 23100, 11905, 31884, 3922, 29282, 22480, 3293, 36871, 339, 10976, 31553, 1411, 16736, 29521, 16181, 39861, 10994, 38368, 9409, 4885, 6702, 31276, 12862, 19474, 21682, 5772, 6708, 23173, 7744, 1705, 22708, 6107, 23807, 35382, 36448, 25147, 25877, 34822, 24502, 6593, 14389, 15269, 39558, 904, 39828, 36850, 21472, 13354, 2271, 39756, 21931, 20141, 16212, 30437, 22305, 29358, 15439, 25281, 26960, 10854, 39228, 32356, 13476, 22025, 11521, 36563, 1608, 31677, 18717, 11007, 11962, 38120, 16428, 10576, 27274, 26645, 2813, 21879, 21517, 36622, 38615, 39933, 29, 10738, 16816, 24213, 10435, 13644, 39179, 25990, 21637, 4750, 38699, 39535, 34011, 18915, 9745, 30245, 22210, 17185, 3668, 21249, 16554, 19437, 1788, 9675, 34031, 1913, 29038, 38555, 895, 16833, 19179, 15040, 19677, 13418, 11634, 35831, 26870, 4780, 19419, 4560, 38, 29186, 8079, 36141, 9717, 19811, 32134, 8853, 22679, 16534, 5204, 19857, 3277, 17589, 6255, 12739, 28501, 26867, 36887, 3405, 13277, 6050, 17317, 21354, 8122, 13563, 10615, 1952, 13970, 29486, 18863, 4944, 4549, 9706, 39248, 6818, 36906, 12350, 16853, 25487, 330, 9773, 24001, 38876, 10606, 18707, 8489, 26407, 4022, 10758, 5433, 37958, 15123, 3295, 27395, 26078, 24645, 33674, 3738, 29546, 34411, 12404, 23605, 26320, 20493, 17291, 32660, 34847, 37164, 5389, 9610, 5856, 15694, 33306, 28859, 39178, 9283, 20737, 3955, 31687, 8802, 21894, 16746, 4741, 20341, 18581, 12131, 11644, 4851, 9737, 4335, 6796, 34040, 23990, 29557, 27014, 7948, 1856, 35713, 20315, 17106, 22945, 17970, 6277, 3855, 36093, 31377, 19993, 8488, 4967, 18839, 12782, 25751, 129, 18185, 2116, 26307, 5147, 38969, 18643, 26818, 9513, 27095, 17157, 33884, 8385, 36392, 1315, 7284, 36045, 8259, 25901, 10897, 39173, 33758, 28530, 1344, 11314, 27666, 3169, 8447, 16353, 37071, 36159, 16948, 20510, 18489, 28728, 36325, 16811, 226, 7818, 36330, 11727, 8711, 25855, 1894, 7677, 1051, 7493, 36110, 4066, 35238, 23253, 33659, 38636, 32353, 19382, 33205, 4559, 23446, 29578, 23417, 14410, 28977, 8290, 28598, 19712, 25436, 15263, 18982, 14721, 29694, 32708, 34267, 30870, 4718, 549, 28352, 15662, 32478, 19572, 34432, 28154, 6157, 5322, 9581, 34244, 22291, 16126, 26801, 21226, 10880, 14706, 36210, 13952, 2097, 23901, 26415, 19704, 28287, 21339, 36215, 7730, 9235, 9423, 6237, 9124, 39999, 2341, 30201, 10869, 28190, 24717, 15460, 11347, 28796, 30115, 25872, 39392, 14547, 7357, 4747, 30656, 32072, 28364, 10380, 32422, 8924, 24733, 34203, 24668, 37360, 23384, 23387, 33609, 2070, 8348, 4808, 16968, 12091, 2533, 32171, 16759, 31406, 2064, 35801, 10120, 39396, 12687, 25106, 18079, 15594, 3249, 17205, 14629, 24329, 14805, 36660, 39358, 5589, 33886, 2419, 35444, 20878, 22957, 7127, 21078, 15718, 7293, 21545, 38815, 21655, 32754, 26246, 31385, 8810, 4584, 15686, 906, 28155, 13402, 2772, 39946, 23842, 1679, 32574, 25701, 13127, 7475, 10932, 32404, 33922, 4619, 18362, 37447, 39277, 34931, 19500, 3930, 24222, 35648, 39980, 10, 24555, 6826, 29907, 3707, 4854, 2123, 25667, 20452, 7520, 23746, 38416, 24732, 32069, 32746, 7727, 6280, 11279, 9350, 13588, 28301, 20252, 240, 2475, 18654, 39633, 37825, 37367, 28775, 24093, 27809, 22073, 16639, 11213, 39194, 11371, 8158, 28721, 1182, 671, 7579, 17884, 8477, 25075, 25034, 866, 33612, 20974, 16686, 26473, 39259, 3661, 31054, 32327, 39409, 14491, 34029, 23814, 39167, 4812, 34175, 36532, 9860, 30221, 16246, 7097, 39875, 36287, 13710, 35234, 19869, 25341, 27954, 10989, 14587, 20583, 34342, 12591, 23780, 2593, 27199, 5936, 12156, 36914, 34047, 18059, 27417, 7311, 5551, 15547, 37885, 37893, 32514, 15526, 21855, 20546, 11897, 7963, 3054, 3750, 3143, 1216, 16366, 21601, 480, 988, 28931, 24452, 31156, 9112, 6342, 30815, 6617, 6021, 38882, 37774, 30004, 8010, 13681, 33863, 30235, 38502, 8375, 6656, 22158, 5807, 16540, 29842, 24023, 5584, 15314, 4180, 36258, 401, 20772, 27121, 9851, 27447, 36338, 9288, 16135, 6523, 33954, 26380, 15116, 9587, 36024, 6153, 38403, 29304, 820, 31374, 30959, 35915, 14635, 22950, 10714, 35662, 437, 33542, 6398, 34809, 36643, 19282, 32086, 20893, 29117, 1488, 6253, 18170, 7772, 5994, 650, 32952, 17164, 22329, 12567, 6578, 19184, 18805, 25160, 25756, 34364, 6106, 21964, 28225, 37706, 1301, 31150, 10680, 12762, 5053, 22269, 34501, 2109, 404, 29937, 38622, 22239, 20342, 20104, 17648, 14663, 448, 34321, 12437, 7266, 38789, 28583, 11867, 35, 22874, 8207, 2941, 21345, 34102, 35808, 31333, 27551, 3905, 23908, 17092, 9903, 12730, 3207, 9012, 28380, 35665, 6952, 1048, 38334, 20475, 24691, 35807, 31699, 28265, 22997, 36269, 16140, 28012, 5762, 9723, 23547, 37737, 39873, 29962, 8860, 31894, 31314, 19843, 26845, 37337, 6655, 25499, 29361, 26458, 27550, 38219, 24301, 146, 32206, 33093, 33368, 5173, 8964, 20975, 4343, 14786, 37593, 23457, 31797, 38212, 14794, 27968, 5266, 38281, 15506, 7448, 31173, 5849, 38341, 6839, 32035, 14836, 16930, 35257, 18912, 4690, 18518, 31074, 30285, 24735, 30230, 23, 17023, 10199, 11163, 10795, 34734, 26196, 25831, 82, 29052, 15253, 26145, 14462, 28335, 21933, 35056, 11461, 1710, 10656, 3318, 23129, 9927, 5281, 277, 19429, 30290, 19762, 1936, 33335, 16561, 20240, 10146, 14703, 24156, 10112, 4700, 6610, 22790, 7986, 22883, 10022, 21391, 1539, 37050, 2927, 22315, 25809, 67, 10140, 7003, 15800, 6003, 31048, 36915, 28, 9942, 30597, 10061, 19107, 32463, 9418, 20669, 20605, 24038, 38874, 12282, 2676, 39751, 2896, 30134, 24643, 15663, 1650, 14050, 13847, 7994, 21408, 31723, 37196, 14726, 8896, 39298, 12923, 2363, 30349, 22852, 18517, 35073, 38130, 17043, 10610, 24058, 13398, 38818, 15337, 11811, 15616, 13347, 24191, 13103, 29613, 36566, 15251, 18603, 35872, 28485, 34900, 13318, 24655, 13632, 18740, 33326, 5243, 33341, 25503, 27570, 26509, 22230, 29114, 34642, 13568, 13079, 38245, 20164, 34044, 24549, 16790, 9945, 12254, 6434, 36279, 135, 16619, 19201, 593, 19431, 987, 28976, 8324, 1522, 5466, 21711, 35151, 5547, 38308, 2402, 8456, 3569, 2438, 9850, 5966, 934, 16612, 15475, 18285, 18270, 22666, 18111, 28610, 32346, 17741, 10630, 25928, 6862, 18132, 29436, 16184, 37846, 4053, 37218, 16003, 32877, 23885, 13045, 2702, 11337, 35653, 132, 34650, 32700, 15620, 8721, 29491, 36407, 22990, 31463, 28643, 27975, 13359, 2790, 28468, 39243, 30646, 10217, 25645, 1136, 23251, 2422, 25977, 6088, 1484, 24673, 12676, 31561, 30757, 20053, 8901, 3088, 31018, 21885, 27885, 5331, 25967, 35865, 24005, 39966, 13019, 21943, 28509, 11732, 35684, 29921, 1080, 14030, 19839, 917, 7440, 19124, 24393, 4694, 38048, 3947, 57, 21882, 20909, 36028, 23463, 99, 16609, 17360, 18958, 23708, 9476, 9469, 27156, 18407, 37069, 28171, 16488, 25878, 23139, 13889, 22209, 165, 5527, 260, 36021, 24596, 11587, 20940, 38336, 3290, 16691, 3479, 38681, 6887, 39338, 35011, 13986, 21460, 13074, 27208, 38751, 38226, 1470, 29396, 36101, 19780, 1165, 26618, 24747, 19144, 39518, 33200, 18987, 8588, 5794, 15401, 29460, 31067, 7944, 28760, 30299, 17030, 19082, 15466, 16802, 2554, 9551, 14892, 12329, 37472, 16740, 31617, 27770, 27709, 12072, 23775, 15108, 36685, 10050, 10752, 3597, 33859, 25224, 21831, 39037, 35701, 10139, 17596, 18432, 33446, 22181, 8094, 37621, 38737, 25086, 9620, 14980, 39335, 7294, 17009, 1754, 17501, 6410, 20723, 34016, 9912, 23165, 9339, 16210, 30525, 31031, 38435, 36102, 28611, 35820, 32530, 31815, 34802, 13756, 28593, 14599, 11328, 22076, 33091, 20683, 32604, 4242, 10215, 36376, 23799, 20045, 20590, 7690, 25418, 31486, 28089, 15436, 7062, 670, 17508, 36386, 28994, 7922, 11588, 17956, 33159, 1595, 38658, 8578, 29593, 39716, 26534, 31805, 22274, 22130, 13962, 35876, 9380, 7606, 19630, 21683, 300, 39731, 29796, 20521, 25748, 26382, 25506, 12401, 17381, 23647, 2511, 17433, 28794, 32935, 5172, 19927, 5652, 14415, 37402, 20348, 35919, 4581, 16528, 25639, 24510, 5438, 12892, 35935, 38238, 35498, 23036, 17591, 17629, 2569, 21396, 13276, 1377, 27630, 6386, 16533, 23033, 19464, 2323, 36427, 13414, 27058, 27138, 39282, 7148, 27655, 31340, 7410, 33866, 21004, 3726, 5904, 37321, 9400, 29095, 4204, 14289, 6373, 26149, 25112, 17883, 26182, 19337, 27605, 38536, 4122, 28027, 12777, 30847, 3102, 7055, 37252, 38610, 11809, 6182, 7851, 8352, 8464, 22020, 27635, 17094, 29362, 9156, 4757, 29410, 27759, 23268, 24830, 36289, 27769, 8836, 38611, 10218, 16477, 11881, 12034, 1511, 24197, 1527, 39676, 15974, 12412, 28922, 20198, 22090, 19841, 3471, 35900, 14997, 31334, 36539, 33511, 19169, 21409, 26783, 9108, 18421, 27876, 6487, 32613, 11817, 5045, 24101, 24532, 2065, 18573, 25123, 29886, 35256, 5087, 26978, 18862, 38712, 24793, 17267, 31907, 25899, 3492, 31616, 15022, 29674, 38999, 23683, 38299, 5659, 483, 9309, 6013, 17380, 21480, 606, 24251, 874, 26164, 27219, 11531, 5864, 13145, 25828, 33876, 14182, 22669, 23489, 30854, 34965, 15827, 30319, 19109, 19418, 31166, 10575, 24823, 34036, 13297, 34927, 21296, 6205, 18927, 8184, 26001, 14951, 10996, 25031, 17678, 10611, 27165, 24734, 58, 6526, 28661, 16867, 17104, 27499, 14708, 22163, 21686, 2259, 17752, 1198, 35208, 38171, 491, 38108, 18458, 33237, 39628, 22303, 22724, 17170, 23724, 1843, 10905, 3332, 24306, 14433, 29971, 15964, 398, 25474, 14570, 30366, 5525, 38307, 8434, 13198, 28539, 12979, 22195, 23523, 37588, 36621, 11970, 31919, 19039, 30225, 38144, 3951, 29947, 13734, 973, 29549, 4862, 27918, 10111, 18638, 21813, 6524, 15545, 26674, 34346, 25670, 13715, 22692, 25159, 25618, 19192, 25101, 8936, 23073, 5334, 21000, 982, 4101, 38575, 37333, 24795, 11374, 7893, 25601, 23019, 35850, 6053, 21464, 22478, 17925, 5182, 16072, 16850, 20888, 15007, 37826, 17506, 2846, 2991, 34146, 34234, 14191, 22087, 33126, 34219, 39406, 11407, 24782, 18595, 28008, 17253, 17569, 20006, 5315, 902, 13601, 35210, 23776, 32981, 24464, 35391, 12503, 22295, 15187, 23638, 34615, 37273, 26935, 17610, 19848, 544, 22718, 7621, 22947, 5813, 6973, 2821, 19786, 20844, 28041, 23074, 27725, 16491, 31389, 14244, 28090, 32768, 17641, 25732, 11761, 9410, 12797, 29958, 5744, 15195, 7939, 33020, 2383, 28484, 33946, 36790, 38576, 24471, 33640, 18639, 19423, 11759, 5091, 6467, 13240, 956, 1979, 16658, 11883, 3602, 5832, 1489, 1646, 13255, 32032, 22231, 6075, 38209, 22769, 4952, 14375, 37074, 14586, 16798, 4526, 5212, 37999, 10513, 32827, 30448, 799, 28253, 15920, 4161, 5417, 16161, 27558, 39730, 2392, 12165, 24534, 35910, 33058, 16613, 34970, 21896, 13070, 22359, 1779, 10285, 27679, 33183, 5372, 37961, 22298, 9437, 24249, 26846, 18599, 5574, 17693, 1868, 19809, 11299, 4107, 33949, 25866, 696, 10101, 29991, 11280, 4021, 35510, 17947, 15221, 32378, 23453, 24927, 4398, 16789, 7411, 35985, 4487, 34598, 36792, 1740, 29167, 32358, 20566, 4121, 5234, 22712, 8725, 8656, 24930, 33242, 11547, 18077, 17609, 2887, 37514, 4443, 29933, 270, 9310, 376, 3506, 14734, 23519, 2824, 17435, 621, 32880, 21803, 10882, 1902, 11064, 3502, 12988, 5646, 5630, 25081, 31789, 33583, 18930, 31008, 2021, 15530, 9083, 21665, 17315, 27133, 8015, 11717, 14372, 27277, 26023, 33781, 19567, 1155, 32737, 36428, 6324, 17114, 9921, 14048, 17186, 1566, 2416, 19363, 27381, 25969, 23763, 13591, 32860, 32640, 8159, 35137, 39132, 37876, 27958, 9829, 19424, 17675, 3741, 37902, 31900, 25228, 4246, 9425, 20296, 39354, 7542, 5614, 33544, 39478, 972, 14990, 38445, 29566, 6452, 7852, 26262, 23201, 12832, 39062, 7539, 20774, 28909, 14654, 6286, 39183, 32912, 19102, 6114, 27141, 23140, 17272, 9841, 23711, 34336, 13931, 34674, 31793, 16033, 4445, 31026, 26629, 12067, 26245, 13915, 26089, 21374, 20017, 12202, 10192, 7567, 34443, 18499, 22693, 1773, 2462, 25545, 32360, 18150, 15948, 34593, 926, 8610, 16937, 175, 8356, 27027, 2379, 36942, 10928, 10106, 15646, 3162, 12089, 26132, 38093, 801, 38239, 13663, 17624, 18714, 11767, 39233, 34368, 3176, 19358, 29434, 15553, 8969, 24484, 13408, 25762, 8700, 27524, 7165, 22571, 23736, 10335, 16954, 11964, 21591, 10798, 8758, 9232, 20334, 3211, 32315, 8353, 5581, 28163, 36460, 22339, 25400, 790, 2905, 39190, 36394, 24567, 33303, 2959, 29835, 18131, 35300, 12256, 27959, 20183, 31799, 25182, 22167, 35470, 39539, 10739, 1012, 2254, 10562, 18230, 13207, 33720, 21914, 19837, 6160, 28584, 15852, 32312, 27634, 35158, 5279, 17857, 1513, 19605, 24264, 17511, 10843, 31927, 29148, 34980, 19490, 9563, 5996, 28816, 8196, 10914, 13933, 15929, 19688, 9399, 34476, 8915, 27507, 33731, 35594, 7339, 12458, 3357, 1703, 21406, 30666, 30900, 20533, 26893, 15512, 27389, 28347, 39759, 10004, 24403, 28121, 7861, 15724, 31817, 24388, 6706, 27311, 9141, 19770, 21925, 24611, 3744, 31637, 5862, 39225, 12276, 25917, 28809, 4834, 5600, 10158, 14481, 8580, 6156, 1138, 39701, 25241, 34370, 154, 17396, 27900, 12308, 10092, 6279, 6650, 15634, 35216, 14700, 36797, 4883, 10271, 21884, 31483, 16343, 17644, 24337, 30434, 18854, 22979, 3961, 11236, 16670, 38426, 18390, 12135, 4266, 23509, 17031, 21425, 32734, 11911, 623, 6431, 14899, 23020, 2134, 33268, 5636, 10315, 19056, 9174, 10426, 36089, 936, 26616, 161, 22698, 31263, 12087, 5481, 12147, 26088, 3500, 38141, 6518, 8774, 10382, 17113, 4433, 16773, 824, 11100, 1101, 21564, 3454, 23988, 14218, 35577, 6591, 29579, 18147, 18690, 17885, 32059, 22105, 31558, 21254, 16431, 39056, 8104, 15886, 8787, 8797, 19229, 9394, 35734, 14757, 24556, 36090, 26680, 5447, 12626, 565, 34479, 27151, 8793, 37795, 11864, 15357, 29218, 7616, 214, 14562, 23576, 25422, 6644, 23508, 30439, 37132, 33796, 14112, 15450, 11017, 38654, 15072, 8805, 32101, 492, 20841, 15197, 8772, 27917, 5765, 33210, 11667, 21317, 16001, 7458, 33028, 12689, 36983, 23636, 37947, 8163, 33943, 35037, 27279, 31002, 15257, 977, 2589, 37414, 35968, 30404, 11258, 17612, 5667, 31816, 24497, 9256, 29571, 14420, 27202, 14642, 19909, 32811, 22369, 17540, 38203, 17083, 36822, 29903, 16119, 1922, 32576, 17046, 32169, 4361, 39553, 147, 14503, 28707, 6223, 29649, 17940, 2765, 7468, 18899, 32484, 13827, 32654, 885, 32472, 17498, 8786, 69, 37779, 32453, 38779, 4811, 19650, 4128, 21793, 30844, 33746, 34609, 27699, 20229, 39997, 34048, 1685, 11348, 7307, 1456, 38293, 10646, 2242, 35678, 39452, 16032, 28319, 37086, 4920, 8050, 5927, 14989, 23369, 20507, 5409, 7957, 32629, 16782, 20119, 24492, 10664, 16791, 38248, 8080, 3133, 26990, 3251, 21611, 9069, 5725, 10588, 31902, 21234, 20646, 19187, 34439, 28684, 31071, 3403, 8004, 14556, 36422, 29275, 14869, 34805, 36318, 9472, 24072, 31775, 3461, 38685, 4732, 16714, 8800, 24286, 16896, 3888, 22690, 28818, 19611, 25128, 36716, 28411, 26110, 2107, 26193, 32796, 27969, 10965, 34169, 8837, 28863, 34772, 14572, 155, 905, 14303, 24317, 22313, 34199, 15271, 24273, 27996, 36595, 14211, 39299, 28637, 31466, 4389, 28720, 38140, 22320, 14001, 36902, 3298, 38944, 7619, 25458, 1362, 24739, 27261, 33408, 13872, 38695, 17028, 16400, 672, 28476, 10269, 6199, 20977, 34335, 37205, 29830, 28429, 34604, 30063, 24971, 34080, 2908, 19100, 30415, 22382, 24995, 25581, 27929, 36811, 3854, 35153, 2174, 13633, 37564, 11492, 6029, 1358, 13801, 13683, 2074, 38604, 14849, 32736, 16056, 28112, 39671, 32459, 16804, 13967, 14047, 5071, 20887, 11195, 23064, 19116, 34271, 38380, 7551, 3177, 5515, 4831, 25655, 11335, 30869, 8579, 288, 25401, 9555, 32584, 27836, 2453, 17366, 113, 3037, 16716, 16713, 15440, 5364, 22670, 2603, 1722, 20674, 13886, 39744, 19702, 2652, 6422, 31453, 16737, 14956, 24890, 26425, 7363, 19548, 36238, 25723, 37374, 19736, 31515, 1139, 20016, 29308, 24419, 22584, 13469, 17248, 17426, 27099, 6700, 22903, 8861, 7388, 12868, 29520, 8760, 34187, 15178, 7679, 31846, 26013, 19274, 24176, 21079, 32477, 22352, 38254, 24310, 21661, 21100, 30745, 4894, 10474, 19306, 10849, 569, 10108, 37320, 5085, 25669, 36928, 33479, 2525, 15260, 27780, 7201, 31291, 1507, 37211, 1196, 26500, 16781, 10391, 20516, 39442, 11383, 21727, 149, 9153, 23757, 14380, 29030, 32562, 29540, 28708, 33145, 23483, 32724, 23617, 2261, 36828, 12662, 2546, 28542, 34486, 30210, 13182, 2537, 15836, 1946, 23494, 28006, 19686, 25255, 38956, 21107, 31694, 17208, 17464, 12754, 273, 3618, 25484, 24728, 2407, 37870, 2719, 22612, 19005, 21810, 36870, 21357, 28317, 3772, 37626, 259, 27127, 36181, 7486, 645, 8276, 39357, 9231, 25647, 10744, 38591, 19362, 14862, 28051, 12737, 14307, 5839, 6101, 13899, 13702, 21423, 335, 14978, 13312, 25236, 39229, 29185, 31198, 12565, 7225, 21772, 30496, 21868, 30985, 13391, 9441, 32612, 762, 611, 9557, 10525, 31083, 37401, 35398, 515, 10446, 17944, 8911, 14256, 13975, 1469, 3688, 36964, 17124, 29463, 2182, 14539, 4855, 6936, 35984, 33871, 8028, 38759, 20833, 2411, 39096, 33407, 25845, 6439, 6266, 31828, 34237, 18466, 27985, 36829, 15708, 6614, 7844, 25011, 7732, 2866, 37552, 81, 883, 39241, 4910, 25819, 21448, 1396, 23504, 13914, 15742, 25184, 1052, 34485, 5730, 17492, 10122, 33628, 23889, 9797, 7599, 20040, 14804, 13029, 13092, 18214, 26037, 7943, 34258, 10885, 20354, 8765, 35599, 25671, 33892, 15218, 16566, 33061, 19154, 33279, 36872, 16827, 9485, 31970, 8570, 22995, 38565, 31984, 12886, 8737, 16939, 18033, 12050, 30166, 7191, 434, 39865, 8769, 4772, 17041, 5259, 9248, 3793, 22150, 5520, 19252, 29122, 20991, 6835, 11351, 2657, 18601, 36302, 26858, 12724, 18418, 25857, 5738, 32410, 31794, 36768, 7200, 30923, 1590, 38134, 32389, 33360, 1916, 2030, 24361, 32183, 36814, 28368, 22170, 19935, 31332, 27424, 35324, 30264, 39323, 23919, 26471, 37807, 5429, 7659, 9697, 16254, 19111, 12207, 15089, 32446, 22665, 8202, 16211, 19009, 1739, 2166, 16669, 4196, 779, 31790, 24233, 4921, 31311, 29459, 30372, 882, 32664, 16473, 39891, 26279, 2556, 36184, 27662, 6038, 17840, 11389, 8460, 16690, 17574, 37505, 34290, 29739, 138, 4972, 36363, 22030, 26080, 33668, 12603, 20659, 13404, 8771, 38013, 9738, 10465, 19752, 39209, 2456, 3796, 2069, 33624, 17809, 1709, 13199, 39242, 18085, 16236, 10354, 28020, 23879, 32753, 15541, 32504, 32561, 17671, 39475, 24719, 5579, 14509, 13298, 37576, 37877, 38589, 21560, 29241, 13101, 18651, 30505, 37634, 14315, 17063, 16379, 16307, 19656, 5863, 20413, 2194, 3172, 27798, 7229, 18165, 8988, 26755, 27983, 7420, 15183, 32887, 10871, 8156, 26166, 13397, 1083, 39238, 30549, 32867, 23411, 8672, 2368, 15471, 6811, 29797, 31155, 34120, 25982, 21090, 17281, 6968, 31225, 2542, 29215, 12008, 22622, 2870, 39004, 29299, 25036, 16367, 24172, 16007, 124, 24982, 7770, 22491, 16226, 13308, 21538, 23386, 37531, 9522, 10799, 17673, 1804, 18315, 30914, 586, 23798, 11609, 17472, 6470, 31979, 13901, 31172, 3374, 6674, 22861, 15081, 6144, 15598, 15612, 29611, 36806, 35580, 16375, 16466, 18225, 14192, 171, 4940, 26189, 13427, 3923, 28425, 1225, 23632, 27956, 31119, 7044, 8666, 39803, 2987, 30843, 37709, 13065, 360, 14150, 35082, 32525, 14898, 7718, 17298, 9076, 19901, 5543, 2322, 3388, 11237, 28699, 10251, 7366, 24632, 22787, 21723, 6212, 25652, 10226, 28322, 6498, 19812, 5876, 2897, 18205, 12882, 17841, 20715, 20215, 13694, 20238, 27281, 5908, 34533, 27939, 15196, 24075, 2513, 27479, 5282, 33889, 849, 11529, 7305, 30515, 30034, 39835, 29155, 36674, 21718, 29043, 18933, 16391, 34279, 31359, 32669, 36450, 30626, 19796, 23716, 457, 36299, 33757, 22042, 25272, 39687, 22753, 19625, 486, 32885, 28545, 11522, 33259, 15641, 24552, 31253, 13299, 26897, 29146, 20806, 31430, 25860, 4861, 27537, 12928, 19958, 1950, 6008, 837, 4702, 470, 10318, 37651, 22148, 19380, 23462, 15915, 15975, 27566, 26701, 32019, 21484, 10613, 6982, 38525, 36740, 38343, 17210, 28096, 3909, 26084, 34545, 5029, 14808, 20118, 11913, 29370, 36099, 33480, 12612, 34353, 27673, 26574, 39653, 4182, 22758, 7321, 8556, 19483, 10903, 38644, 35294, 8069, 1780, 7242, 14873, 20544, 39378, 31131, 36739, 26545, 13923, 12859, 36118, 4826, 38415, 1162, 15659, 11556, 35513, 34649, 2360, 24069, 11246, 15350, 21898, 16171, 4205, 7221, 6264, 33818, 11838, 21826, 33464, 38664, 4400, 3208, 20415, 38440, 37560, 16089, 572, 10919, 6590, 35732, 34549, 6981, 30354, 6332, 33215, 21483, 35845, 22757, 20004, 32172, 12878, 4730, 13723, 24260, 13394, 17623, 19484, 17653, 24165, 7966, 22182, 5958, 25902, 38153, 10011, 10925, 21829, 8899, 37545, 18875, 8881, 32688, 14378, 33848, 15842, 4127, 15388, 19327, 18924, 14863, 30918, 14683, 27446, 31804, 4749, 4997, 22639, 31384, 14760, 30897, 13132, 14530, 23564, 25453, 9562, 27178, 39258, 4441, 19440, 23962, 3044, 38984, 25559, 7822, 11127, 20931, 12958, 16701, 27585, 5210, 33778, 23603, 3571, 37693, 25698, 6527, 116, 20551, 20741, 11090, 11744, 39809, 30814, 14592, 1560, 20123, 11253, 15762, 18706, 3410, 23577, 15625, 35992, 29176, 14134, 29322, 8979, 35368, 26591, 10078, 24463, 36687, 39345, 10904, 21962, 19665, 11295, 2977, 28799, 15088, 25448, 19334, 39272, 22460, 33476, 30322, 37912, 16173, 18283, 22405, 4572, 23728, 37477, 31273, 5462, 11025, 27694, 23613, 8053, 2502, 3103, 34018, 35544, 19057, 21214, 21181, 24115, 25758, 26693, 33037, 6352, 7277, 10500, 28223, 23335, 17775, 38263, 707, 26654, 17287, 21265, 31653, 18281, 17982, 14029, 26718, 1127, 31337, 20828, 34652, 13885, 33811, 33822, 12162, 30818, 1066, 6460, 5307, 30002, 20937, 8566, 34, 39102, 15520, 38377, 10574, 32100, 34280, 13130, 33119, 29355, 27503, 39342, 29738, 31271, 5000, 7626, 33634, 37110, 21164, 9063, 16272, 11869, 17779, 5203, 13552, 14885, 24079, 37824, 20308, 39112, 18756, 34599, 25126, 30645, 36223, 38222, 21863, 4211, 5296, 3092, 19351, 26963, 30817, 455, 21233, 20641, 23688, 21125, 13163, 18522, 34878, 26460, 13562, 11841, 16484, 25922, 19955, 8731, 11999, 10386, 20933, 13303, 3896, 24628, 9601, 26051, 14730, 32109, 39902, 3078, 16338, 658, 32259, 37720, 30686, 6488, 31293, 38305, 36426, 36007, 23869, 11860, 34339, 15636, 30699, 8255, 6278, 9129, 32541, 1308, 2082, 23545, 14746, 12707, 587, 18628, 5889, 27504, 8439, 14970, 13478, 30059, 36825, 19386, 9089, 33023, 37689, 14172, 9529, 9157, 21469, 18370, 9626, 7805, 31256, 14935, 25979, 11541, 1769, 24304, 20658, 25088, 38422, 6196, 10723, 2188, 7464, 12370, 32198, 12248, 14437, 22265, 36382, 16719, 32148, 26588, 11674, 1596, 15426, 2692, 27468, 1151, 28894, 14257, 24856, 36470, 34139, 1461, 24718, 21656, 30147, 16768, 4424, 22857, 35456, 27682, 13195, 22849, 28934, 10542, 36541, 7078, 37055, 11793, 4547, 11622, 17496, 10268, 26431, 890, 2563, 11128, 38800, 12158, 29980, 16935, 28504, 25646, 32577, 9750, 4026, 2608, 37957, 10833, 12271, 33396, 18681, 21513, 30408, 11059, 25921, 3510, 20390, 34718, 18156, 37930, 36559, 22764, 25466, 6725, 36391, 32421, 21275, 28745, 16158, 31041, 32851, 25777, 1716, 5655, 48, 37462, 6620, 10303, 25859, 9996, 3712, 3836, 28568, 13537, 5312, 6908, 15128, 18887, 31428, 13607, 20824, 4927, 1270, 9468, 38070, 2426, 14117, 24336, 38391, 20827, 17410, 5079, 27733, 16772, 37495, 16699, 24894, 38863, 15563, 13112, 5054, 35231, 25119, 14009, 16256, 22207, 2507, 37183, 16308, 13047, 21492, 6583, 26510, 15198, 27101, 3450, 30020, 24522, 29357, 27372, 11058, 12823, 33406, 9258, 24215, 18527, 25375, 106, 22488, 21524, 28401, 7483, 10133, 38113, 8062, 3182, 13978, 39526, 17446, 5051, 30146, 18829, 34867, 1061, 34003, 7748, 39856, 17859, 1718, 5749, 39432, 10926, 16752, 18758, 37731, 37834, 34399, 1503, 4692, 36756, 7279, 328, 10881, 7026, 16844, 12791, 11532, 39700, 16756, 34453, 10252, 32257, 18785, 12660, 11942, 20242, 12822, 10536, 27112, 8377, 19497, 7797, 36253, 29208, 14287, 31568, 3994, 14302, 20693, 21062, 7840, 30412, 27901, 4668, 16421, 37081, 5792, 23031, 17033, 1, 17999, 39517, 30308, 26710, 20734, 31411, 7341, 39895, 22398, 5027, 21245, 16654, 19232, 14221, 29563, 10698, 3774, 34835, 17712, 8732, 25965, 3937, 35160, 25513, 17119, 15846, 13350, 18469, 6795, 22640, 20047, 17173, 869, 18424, 11808, 32918, 16563, 858, 28540, 13238, 5190, 34083, 9395, 13313, 5622, 5196, 10351, 20149, 6508, 37432, 36935, 36054, 21401, 16898, 36097, 20462, 14855, 32233, 27859, 9426, 4576, 33683, 34165, 24583, 37854, 28478, 24297, 17666, 2864, 13018, 23127, 16348, 24829, 20716, 12212, 22944, 8492, 4562, 15504, 24048, 32156, 23203, 7754, 7743, 370, 21678, 23920, 34648, 29690, 25275, 23592, 19017, 39381, 23845, 8521, 17242, 38490, 34930, 16869, 3396, 7100, 30246, 5569, 32719, 24695, 13522, 33384, 25001, 25287, 7240, 22932, 37667, 30571, 13339, 37968, 25958, 29750, 22014, 15165, 17822, 26523, 21030, 38735, 26356, 8655, 19866, 30538, 16667, 16048, 19776, 10210, 15003, 32103, 37004, 7308, 7651, 32772, 13690, 17766, 30240, 22009, 12981, 21928, 32380, 379, 18040, 5604, 39939, 5890, 22372, 15725, 6501, 36343, 36397, 26707, 20970, 1324, 2912, 22532, 34064, 35078, 35949, 35928, 28047, 15998, 20781, 4822, 26989, 30734, 15882, 21260, 15406, 11029, 17636, 28607, 35272, 25223, 16152, 17395, 23534, 28606, 23281, 36852, 9320, 22337, 1424, 16289, 1084, 1442, 34731, 8088, 19842, 19895, 20316, 19777, 13485, 17235, 15461, 26595, 32252, 13812, 34672, 15712, 6200, 22701, 9863, 26626, 1945, 6762, 34514, 31490, 6054, 34213, 18055, 12819, 34566, 38646, 36440, 21455, 35021, 18406, 36409, 1024, 10057, 39844, 11271, 18376, 16492, 30996, 16219, 17356, 31521, 22024, 571, 26219, 26174, 5186, 469, 8687, 8867, 10317, 27988, 28412, 25775, 28325, 10342, 4103, 30953, 14075, 38826, 8633, 35075, 15954, 31144, 12088, 23933, 2477, 13225, 12555, 38468, 2085, 11062, 7510, 4273, 2776, 37587, 758, 24600, 19535, 30775, 35161, 28917, 10797, 27489, 14745, 13059, 10324, 22923, 3153, 38374, 10182, 14754, 37879, 14417, 27272, 19368, 39061, 9595, 21122, 12197, 31378, 20539, 4435, 37480, 15182, 19783, 17672, 24853, 17098, 18542, 36137, 17820, 15967, 35924, 4356, 33241, 298, 3596, 14656, 13415, 32529, 33270, 17122, 29542, 37452, 27371, 3415, 11502, 3045, 19651, 38105, 18491, 30813, 6181, 39297, 28293, 14565, 13919, 34743, 9976, 23585, 31944, 19761, 27096, 10759, 16154, 2286, 4447, 33427, 36334, 39619, 24248, 33523, 32021, 32722, 16565, 38663, 37357, 24851, 30622, 6016, 38330, 39682, 5443, 18845, 14948, 11876, 30194, 33935, 11435, 1016, 11466, 11002, 31167, 36169, 18775, 7876, 2825, 22355, 31452, 3575, 28965, 27904, 21193, 26103, 28926, 38626, 9693, 4680, 14720, 6097, 18098, 9175, 5498, 8669, 34781, 37016, 5967, 34091, 23809, 24456, 38899, 4852, 18800, 14878, 16839, 31709, 2278, 21625, 18318, 2472, 18244, 11523, 22245, 23231, 25583, 27104, 29032, 14397, 11619, 29683, 23690, 38761, 21050, 12325, 16360, 16043, 35634, 35485, 23624, 19315, 16819, 35321, 34384, 28184, 3871, 36821, 11016, 34595, 31983, 27257, 31019, 17352, 35317, 5376, 26111, 36529, 1393, 4331, 18099, 7103, 373, 21579, 23486, 33815, 33251, 22425, 32578, 34956, 1400, 5932, 18864, 15381, 24842, 37460, 15479, 14124, 33844, 30580, 34629, 25315, 7131, 21405, 10069, 5421, 15753, 36943, 21617, 39763, 29487, 23734, 38185, 10430, 16870, 24568, 4481, 15341, 10429, 888, 35396, 15513, 1550, 34118, 30231, 312, 19136, 31006, 39466, 39593, 22722, 24713, 4252, 29663, 4996, 15589, 3715, 23791, 1588, 11866, 26715, 24057, 23887, 4142, 13622, 4000, 23432, 38765, 24945, 36485, 24955, 21674, 5349, 28614, 31762, 25993, 23888, 170, 9986, 36404, 9937, 25125, 1928, 14724, 32361, 24440, 7043, 13780, 8313, 16583, 20035, 26887, 17890, 31310, 22015, 8097, 15220, 34682, 33951, 23595, 25069, 33622, 23065, 26452, 36492, 26267, 17977, 9834, 22211, 33842, 2268, 28465, 22217, 6741, 29253, 24546, 30962, 5152, 5001, 28257, 2051, 39027, 28396, 37819, 10642, 6405, 7287, 36218, 24692, 23991, 21764, 22139, 34281, 32635, 17539, 13290, 16190, 5318, 22126, 28853, 11762, 3236, 36896, 14680, 4134, 23364, 10458, 38935, 3115, 34452, 34543, 32403, 30164, 26179, 38516, 27771, 1816, 16680, 20410, 37496, 33140, 30411, 39631, 9838, 14747, 6060, 30084, 22085, 31021, 9710, 35942, 13525, 28168, 7698, 33112, 39005, 23767, 17006, 15869, 24576, 20312, 3828, 11211, 37935, 15339, 20008, 35585, 29132, 35053, 33722, 26124, 22287, 26416, 16330, 21717, 2339, 29097, 22808, 11642, 32001, 20928, 8858, 34522, 37753, 4297, 12799, 17014, 20071, 7023, 19240, 9785, 10695, 31761, 9211, 33594, 26011, 10771, 38412, 17978, 10236, 5330, 36893, 30202, 35597, 29441, 15175, 18461, 29428, 39069, 25757, 8381, 22514, 34555, 14398, 6586, 13830, 39326, 16893, 39366, 37061, 37997, 17647, 19971, 7457, 20218, 104, 38833, 25274, 23213, 7883, 38138, 24593, 23687, 25580, 16096, 632, 34286, 35793, 30906, 33482, 4013, 7759, 1926, 28755, 32355, 20156, 2088, 30139, 17915, 7492, 37953, 10509, 16333, 18435, 11842, 10261, 34589, 12521, 35052, 14374, 30798, 9819, 17125, 5566, 2329, 24054, 18814, 28288, 22213, 16666, 5303, 13293, 17202, 37712, 4100, 35437, 9629, 18748, 30067, 33982, 16706, 36883, 32084, 34420, 39920, 20249, 30200, 11810, 9449, 10763, 6555, 22664, 3232, 222, 11832, 30058, 39798, 37869, 28892, 7494, 8522, 27651, 1620, 20604, 32258, 15274, 13228, 6204, 7105, 16641, 2797, 3770, 16347, 20262, 12284, 16950, 4466, 30936, 3856, 12996, 6665, 35421, 5084, 4767, 38497, 4081, 37042, 23535, 31415, 14133, 5898, 1721, 142, 11114, 23052, 3745, 15389, 357, 23497, 3351, 559, 13959, 29680, 12334, 2437, 30106, 21956, 22450, 19354, 23111, 77, 19313, 17694, 37358, 4838, 28095, 18009, 12142, 13858, 733, 14145, 29988, 28778, 34386, 25066, 6642, 12745, 8096, 24684, 31751, 22508, 15469, 24121, 26517, 2183, 22660, 10805, 4455, 12171, 31345, 7120, 35504, 12439, 6807, 13990, 23216, 26442, 22420, 12402, 17622, 35827, 9316, 15298, 14444, 29729, 25252, 6871, 35616, 23944, 24095, 16365, 24108, 33667, 38599, 38623, 32615, 3929, 26131, 22918, 17882, 19910, 23644, 11786, 31509, 1914, 25286, 32116, 276, 31947, 11533, 14814, 22454, 11425, 15410, 38538, 35339, 9270, 10026, 35409, 13685, 36592, 7945, 35779, 4543, 26993, 33962, 10039, 29873, 2740, 18217, 467, 15124, 18427, 1251, 29405, 28792, 16100, 21526, 15996, 14666, 14610, 2049, 33139, 476, 30819, 33898, 32067, 24199, 19142, 16871, 33189, 33460, 31831, 17763, 25412, 27375, 17097, 23982, 22114, 1082, 29294, 7288, 8897, 4819, 12848, 38997, 5559, 15481, 8179, 23150, 31825, 30207, 1096, 18781, 7827, 5511, 15709, 39086, 18645, 5859, 17489, 33654, 13642, 7083, 3868, 36190, 3317, 33777, 37989, 23024, 8175, 14291, 15978, 24616, 37066, 37023, 18516, 39075, 23987, 9364, 17044, 923, 8116, 10124, 34127, 22564, 35697, 17141, 35340, 598, 23808, 6183, 20331, 17195, 13234, 23444, 28784, 9648, 15890, 32117, 2573, 16589, 2610, 6661, 17804, 15321, 14597, 37524, 14219, 5796, 37131, 12345, 5108, 22019, 4040, 10338, 34009, 7211, 37533, 20225, 23424, 35550, 12879, 1205, 3798, 4614, 18325, 1077, 10789, 38322, 25536, 21980, 3323, 16008, 22456, 17463, 20101, 31821, 22290, 26974, 29679, 35707, 17563, 20834, 19387, 4998, 6402, 5926, 35563, 23827, 15958, 20379, 12748, 5978, 12839, 33715, 22349, 5513, 33888, 704, 36533, 1702, 18619, 26268, 29118, 3542, 39276, 4558, 36367, 30640, 18464, 26732, 4201, 29858, 25681, 13799, 23977, 7925, 10777, 26122, 18300, 39681, 2917, 9254, 11484, 8832, 31615, 7367, 27536, 9918, 8985, 29773, 15549, 37327, 22118, 10634, 10657, 17750, 34125, 16398, 37237, 25568, 11300, 8335, 35763, 24566, 14567, 3285, 10552, 19975, 21921, 11735, 4847, 5188, 27408, 36274, 15105, 3047, 317, 6314, 2689, 509, 33970, 3743, 965, 27792, 25366, 22402, 1098, 25162, 17034, 23764, 10294, 30926, 27787, 4457, 1600, 39364, 24062, 10608, 37777, 12831, 10357, 6090, 21871, 29841, 9165, 26334, 39189, 8090, 7267, 39395, 17073, 17837, 17389, 3572, 33440, 22776, 7540, 31928, 27400, 28642, 2805, 28872, 3702, 21279, 32423, 32762, 16886, 22233, 5650, 34487, 17771, 14859, 7660, 37109, 2011, 20422, 14505, 13323, 266, 15351, 3438, 28001, 10599, 34709, 31998, 17960, 24198, 18029, 9167, 9097, 27522, 19185, 3283, 28037, 9818, 16062, 32411, 6010, 17603, 9803, 638, 33025, 33381, 29944, 7275, 39321, 26190, 4902, 35284, 4322, 17377, 17228, 20626, 20116, 34640, 31381, 28389, 11066, 9511, 37786, 14664, 9092, 12418, 35364, 29453, 19675, 38583, 27963, 21437, 26266, 26962, 24978, 20797, 3565, 2344, 11628, 32944, 32040, 33325, 24639, 31727, 9415, 23841, 38267, 20889, 27368, 33694, 11489, 11790, 27034, 2519, 21838, 35480, 14710, 19890, 25190, 13654, 1997, 26391, 26686, 11085, 158, 13625, 1923, 21690, 35500, 25043, 34984, 35154, 23145, 14707, 2373, 32036, 49, 18080, 13395, 34471, 16274, 6356, 10792, 39207, 37018, 26672, 22926, 34034, 28473, 31243, 16794, 14430, 3399, 31953, 14783, 14040, 32820, 10922, 17942, 13417, 27061, 28964, 36720, 21861, 9999, 5963, 16803, 16511, 24352, 11251, 89, 35503, 17705, 3512, 3900, 23175, 32281, 3733, 28486, 9407, 14055, 18716, 26186, 28781, 1893, 6394, 25116, 17361, 18483, 36727, 21428, 39274, 11033, 6541, 2710, 7116, 10181, 21904, 5288, 26763, 1669, 20044, 38684, 14390, 834, 169, 8926, 7513, 32039, 35301, 31583, 20168, 12330, 5320, 20616, 39239, 11695, 33910, 6241, 32799, 26369, 23678, 1744, 34695, 17334, 27650, 22078, 26538, 6291, 27965, 20607, 14336, 11361, 36599, 10319, 26655, 14861, 33250, 23337, 37918, 10504, 20157, 4600, 31736, 13565, 39071, 29048, 14007, 34160, 6440, 7960, 1764, 26593, 7011, 2321, 18408, 36098, 36384, 33969, 20647, 4550, 4531, 17778, 39812, 340, 34813, 35691, 79, 1299, 27542, 26288, 28259, 13181, 31058, 12285, 33442, 55, 12811, 28232, 12998, 841, 30639, 34894, 741, 14506, 18134, 26487, 32535, 11789, 35896, 12532, 27221, 4207, 30642, 37027, 15286, 7923, 25998, 19581, 31442, 18995, 2661, 12744, 37985, 20288, 9916, 26483, 7333, 26419, 31237, 1863, 15320, 28548, 25684, 27618, 32524, 22430, 15555, 13094, 3472, 13786, 3852, 20872, 31027, 17838, 28245, 38406, 34996, 8678, 29699, 30772, 1954, 10332, 33400, 34797, 33299, 15630, 13868, 21775, 27441, 31091, 3167, 3021, 21972, 14098, 10063, 22236, 242, 26453, 38721, 552, 5715, 39415, 39385, 36938, 20018, 30138, 2532, 6446, 35385, 619, 15106, 9715, 38572, 24802, 682, 5842, 22448, 18948, 30036, 6787, 35698, 22138, 34548, 39444, 12812, 11683, 17796, 8339, 30162, 27125, 19552, 6135, 36735, 35472, 26816, 3654, 2766, 9722, 27795, 6171, 2113, 3284, 3559, 17918, 32766, 3421, 36248, 23358, 20911, 2771, 22969, 3548, 20248, 13998, 5801, 11318, 25298, 39170, 2516, 33771, 13196, 34907, 26398, 15972, 37732, 10687, 12277, 12585, 20389, 28752, 23006, 36281, 31921, 17091, 38897, 23557, 10678, 15035, 39867, 27483, 19666, 8240, 6447, 16840, 31738, 35145, 37385, 7156, 15579, 4218, 35858, 7517, 14349, 24345, 22008, 24609, 14346, 22328, 33331, 26064, 34241, 25407, 28139, 8723, 32204, 33350, 25935, 1860, 26077, 5734, 37521, 5432, 6517, 12331, 7, 22132, 32490, 27016, 25714, 9486, 31631, 5750, 36677, 25435, 26242, 18445, 34456, 17797, 6494, 26405, 9277, 24843, 27340, 6031, 22616, 20976, 2888, 8636, 32018, 39418, 22642, 2852, 16437, 3216, 36260, 26617, 7236, 29291, 26726, 15731, 2629, 8011, 4460, 34729, 19746, 11180, 7529, 14910, 34687, 19420, 5717, 31582, 5096, 26744, 20250, 22415, 20271, 13005, 29442, 33233, 25788, 19342, 5970, 21745, 4766, 34303, 20431, 17455, 20990, 4497, 39702, 15207, 27397, 8224, 30267, 11994, 26752, 39108, 11700, 9788, 9370, 38179, 4327, 29534, 27711, 6493, 20866, 10117, 36752, 34909, 17637, 28192, 20327, 22331, 17132, 26689, 3234, 37438, 21486, 10282, 2434, 28801, 18031, 24948, 34426, 24618, 31469, 25347, 30171, 34287, 21319, 17997, 32398, 19671, 14684, 18901, 27380, 6770, 7364, 39017, 4686, 10369, 9786, 16137, 19352, 22577, 24051, 21155, 31648, 15145, 30782, 893, 25497, 39064, 10632, 31678, 31938, 30132, 32757, 26892, 35341, 8351, 33613, 27493, 16796, 22278, 32064, 23860, 15070, 809, 27887, 38019, 27833, 18116, 2815, 25057, 7046, 39962, 28255, 35206, 35487, 3322, 181, 11834, 9420, 33399, 3455, 28940, 36188, 32236, 24551, 1767, 31810, 8519, 13362, 32145, 12875, 1876, 36807, 18450, 11617, 6419, 7340, 4639, 18833, 36366, 31423, 6727, 36345, 15051, 17690, 13261, 21325, 482, 9284, 3865, 7811, 37729, 26702, 19626, 36701, 19799, 9837, 2736, 19076, 19908, 14633, 36775, 34093, 24846, 29657, 26264, 9991, 38983, 4106, 29633, 16339, 29213, 13714, 8463, 38270, 12129, 3468, 17268, 39429, 16742, 12771, 29747, 30825, 9729, 1951, 209, 6336, 3257, 18679, 29134, 34982, 35835, 27601, 19681, 39747, 18921, 2933, 19659, 1087, 20553, 2274, 9654, 17101, 27154, 33857, 34775, 9872, 9488, 10802, 37366, 32502, 28944, 6870, 15282, 2417, 17230, 5187, 37503, 14999, 15678, 6166, 2600, 7526, 14005, 7133, 4823, 17466, 894, 39988, 9952, 19943, 28840, 11026, 21900, 8894, 34990, 29138, 19050, 32407, 16679, 29223, 37635, 38902, 26426, 27109, 18449, 8115, 10818, 29741, 20601, 2269, 19010, 29063, 2714, 10009, 28537, 18490, 38891, 16066, 39963, 35741, 39479, 24663, 23083, 13593, 26942, 2707, 38421, 10191, 30673, 1578, 23844, 4935, 28906, 26346, 18049, 31897, 2106, 35286, 35867, 1541, 16336, 7389, 10408, 30018, 23040, 39954, 39544, 12000, 1042, 25695, 32521, 31059, 32903, 4041, 28390, 2227, 6929, 13730, 32469, 25713, 17011, 4665, 21356, 33666, 7067, 151, 13733, 39328, 10629, 514, 32849, 11821, 6129, 8089, 8652, 13604, 27039, 26810, 21666, 30888, 11777, 36335, 24506, 35422, 12627, 11506, 21182, 33110, 13592, 1059, 14079, 37955, 6704, 2498, 18647, 16509, 17137, 635, 18381, 24614, 28782, 23264, 12377, 6121, 825, 13129, 28919, 31070, 1159, 34193, 12933, 16516, 36484, 37493, 21821, 8306, 30483, 36817, 37742, 36884, 3478, 11662, 26172, 20543, 4982, 15112, 35401, 8173, 6287, 2006, 25278, 36443, 28348, 3097, 24904, 37972, 31160, 25546, 17594, 12112, 32225, 37946, 5297, 14450, 30252, 6737, 19335, 17158, 21379, 24105, 19212, 9823, 8084, 20222, 9, 29714, 7254, 7343, 39914, 29490, 34883, 9159, 9064, 8012, 15404, 17514, 17794, 32173, 34010, 19693, 6766, 20423, 20269, 39211, 31460, 16689, 14099, 33006, 6290, 38850, 39090, 39969, 3307, 25522, 136, 21689, 9397, 7503, 28615, 5157, 28158, 25018, 27846, 7262, 14687, 35529, 18067, 19172, 16546, 22189, 20460, 19733, 25439, 103, 2094, 168, 1938, 20667, 33367, 21349, 18201, 4942, 27832, 37254, 31408, 22975, 25552, 24030, 15227, 65, 19068, 32729, 25153, 1023, 23164, 26308, 5540, 18533, 24677, 27727, 3918, 14176, 36147, 11281, 18342, 34567, 33062, 1652, 22038, 20430, 3649, 13854, 3697, 25703, 32507, 21549, 29946, 2099, 23186, 5802, 34607, 26525, 5119, 19150, 39800, 39651, 8625, 24807, 736, 25818, 22075, 37823, 594, 12568, 37536, 18705, 13698, 9547, 31851, 11969, 4557, 10337, 2934, 30345, 17236, 6496, 32727, 6951, 38292, 19288, 688, 2886, 39485, 3784, 37566, 13135, 21795, 17824, 16744, 7924, 16046, 36017, 36227, 31781, 26049, 32004, 20929, 22302, 1988, 33759, 38548, 12813, 27588, 5752, 23160, 20867, 5576, 34600, 6285, 38637, 18970, 6226, 3965, 2246, 16213, 29925, 8589, 25372, 30238, 17159, 19218, 21897, 12403, 28675, 5635, 6448, 19754, 96, 7417, 22815, 8750, 2660, 22576, 11119, 27056, 18729, 15888, 12686, 24513, 14722, 15949, 38665, 23772, 24443, 14759, 1177, 38717, 36245, 9272, 6413, 22793, 18428, 33513, 10457, 400, 5558, 15347, 1553, 34719, 11963, 11822, 29772, 32793, 16172, 21238, 1989, 4555, 36126, 21255, 15264, 6384, 19763, 18600, 28110, 14713, 3343, 34145, 10296, 29210, 26208, 21955, 1483, 18110, 10343, 29585, 13545, 38481, 36031, 38174, 37378, 2292, 6540, 35237, 14427, 23671, 2794, 28274, 13839, 9009, 35060, 37397, 29309, 21415, 7080, 20796, 3104, 39029, 29601, 26708, 25395, 39871, 8966, 38711, 38513, 38064, 37413, 3764, 7587, 1359, 16531, 38346, 1794, 1772, 1232, 22191, 14327, 15334, 20722, 6987, 30836, 4974, 25764, 30148, 15802, 14470, 9905, 14235, 62, 5740, 5866, 35516, 17142, 10672, 31811, 39384, 2351, 5924, 30039, 12359, 36799, 5642, 11103, 35184, 2266, 21148, 7446, 12105, 24254, 14203, 6364, 34166, 39109, 14766, 9412, 22332, 1353, 11050, 20450, 32537, 20300, 14660, 27183, 26669, 11430, 22974, 5351, 21106, 21474, 21521, 29443, 34700, 3389, 14508, 1152, 286, 26563, 20945, 36113, 18054, 8200, 10129, 34623, 17986, 15359, 33149, 4954, 25543, 33049, 18957, 18885, 8260, 680, 30468, 25491, 12938, 8890, 21501, 25784, 13902, 24624, 32568, 35345, 19094, 4187, 9733, 4695, 22327, 23012, 12051, 38557, 33029, 33673, 19383, 17611, 39836, 24083, 990, 6537, 37857, 24036, 10538, 27538, 12272, 11684, 22390, 23911, 34371, 22292, 28430, 22071, 3219, 5293, 34614, 7977, 12985, 3385, 23745, 3850, 35559, 7746, 29898, 13039, 15278, 16394, 7903, 29508, 20447, 14593, 3805, 6208, 18861, 32906, 27398, 34911, 19907, 33065, 12318, 5846, 5215, 38718, 9699, 4821, 37153, 36346, 1220, 38715, 12043, 8614, 5461, 32052, 8436, 24770, 6321, 31239, 6435, 647, 18956, 616, 25383, 37563, 6437, 5629, 33940, 23425, 26362, 30952, 28638, 3276, 22824, 397, 5603, 12066, 37543, 21094, 34800, 30692, 23328, 14351, 25248, 39411, 35179, 25430, 7525, 5693, 22804, 38329, 17828, 262, 39625, 27369, 37079, 31142, 16878, 30136, 39780, 963, 3641, 14636, 25416, 21939, 6425, 13096, 3496, 13790, 36047, 27571, 27890, 18108, 15042, 37699, 17607, 34591, 27877, 34121, 862, 5606, 2045, 5046, 28451, 10826, 25983, 14762, 32601, 13178, 6371, 34787, 21817, 21941, 402, 25874, 37179, 5033, 16457, 36383, 9057, 7522, 3227, 19122, 8567, 17302, 26594, 21083, 14554, 12801, 9343, 11067, 5286, 24736, 25327, 17430, 16748, 38529, 2892, 24688, 6832, 17490, 35869, 15154, 22783, 24073, 20453, 26025, 29513, 10159, 22234, 15756, 35460, 7576, 21323, 23662, 17308, 13449, 19620, 34737, 10955, 1585, 33146, 36035, 10822, 14527, 38444, 5344, 35227, 28454, 10895, 31306, 17948, 20420, 23949, 6037, 33269, 11387, 15352, 1458, 39206, 22599, 37871, 13917, 19248, 16485, 32481, 6684, 36173, 29923, 2640, 10246, 25377, 21470, 33300, 27964, 36722, 37159, 9005, 16155, 37600, 25004, 3006, 34713, 36355, 33734, 28345, 22240, 2062, 17565, 32797, 4014, 5984, 15010, 21136, 21232, 2844, 24984, 18757, 30833, 9938, 2832, 30263, 8219, 12157, 33780, 9444, 14135, 27799, 35816, 32963, 27825, 2243, 23222, 29922, 38451, 5535, 12920, 38399, 32280, 15767, 14536, 39457, 3469, 497, 14676, 10864, 13352, 12993, 38443, 33514, 17194, 23102, 23998, 26485, 15202, 3279, 37554, 11324, 3304, 7214, 18636, 21084, 35514, 38704, 3223, 15722, 33533, 36175, 7059, 21057, 31966, 21751, 35244, 29110, 29469, 28123, 18026, 28354, 7035, 23050, 24357, 17284, 21815, 14755, 27686, 15318, 13763, 13905, 15643, 27285, 4420, 24598, 36658, 37744, 2002, 26409, 19647, 24080, 14915, 8921, 28967, 28953, 15338, 29094, 31108, 24696, 22050, 16500, 38283, 24653, 35679, 12086, 27351, 6829, 34442, 25087, 35072, 3898, 28201, 34939, 33309, 11636, 23712, 20780, 28191, 31609, 5654, 18324, 3071, 19940, 530, 38009, 31313, 38579, 3839, 21152, 21927, 16522, 26797, 17277, 21905, 7490, 20606, 18508, 1535, 32219, 19829, 10156, 11411, 17747, 23284, 19694, 13286, 16090, 7920, 28886, 34744, 22162, 34005, 5295, 6130, 32102, 3863, 4470, 2862, 2522, 8045, 35901, 11918, 5077, 17546, 11310, 5974, 12320, 23085, 23937, 26211, 23553, 30203, 15361, 11677, 29950, 29665, 22001, 5633, 34619, 8527, 6256, 8054, 17962, 1438, 34952, 19782, 38822, 36449, 25810, 5200, 15933, 13627, 35371, 29688, 34771, 9597, 32907, 28219, 23823, 29492, 9234, 22185, 8884, 31554, 15703, 4291, 34063, 8417, 23502, 29384, 35552, 4835, 6407, 29696, 11303, 5267, 12974, 6126, 33564, 32420, 31883, 31181, 6022, 32189, 8520, 9598, 1292, 38638, 827, 11308, 7664, 16636, 875, 29516, 32181, 32306, 4929, 36377, 38409, 32425, 35355, 16257, 31040, 17734, 32991, 26643, 19590, 18363, 5355, 9542, 33966, 18382, 13030, 6441, 23011, 39648, 12338, 37270, 18745, 12738, 39221, 21893, 17654, 14404, 18338, 20463, 18012, 394, 32943, 38707, 18562, 23331, 21669, 34659, 24993, 29968, 39746, 34129, 27871, 9408, 19944, 13684, 32434, 12376, 19795, 15307, 8218, 3838, 24333, 3311, 18030, 37286, 33561, 28009, 8907, 9352, 19028, 13371, 16208, 17140, 4192, 9058, 34176, 34964, 13245, 12238, 16101, 9330, 16445, 3498, 27842, 31052, 24009, 18386, 37256, 3869, 38602, 28493, 7980, 14354, 19966, 39797, 36654, 23304, 9162, 28882, 17062, 442, 24283, 38091, 35819, 16255, 6889, 39097, 8395, 33218, 8852, 19029, 2395, 30864, 18683, 17123, 627, 35861, 11791, 7894, 27123, 4919, 11514, 28960, 24050, 5901, 13540, 10775, 18894, 28546, 37542, 7155, 24493, 5640, 38139, 3100, 27595, 3953, 12369, 16745, 19349, 29161, 32041, 31905, 4326, 14524, 27584, 2859, 12924, 23246, 34685, 24849, 13875, 18941, 18819, 32929, 430, 25329, 34356, 26388, 29431, 33429, 11124, 18700, 39547, 31818, 32286, 33663, 17941, 15801, 23689, 34941, 12155, 829, 19523, 33026, 12778, 37375, 23948, 12970, 28187, 22605, 29475, 3818, 21783, 20588, 6687, 28415, 19513, 1479, 22649, 24330, 12161, 38168, 33797, 28671, 30563, 22319, 23214, 4684, 23381, 32520, 32522, 36311, 20486, 23068, 13149, 33324, 12717, 6409, 36482, 10334, 36130, 2685, 20459, 27775, 4745, 29757, 37619, 1317, 21975, 21309, 10305, 12665, 25494, 1777, 12837, 3024, 28869, 2994, 25299, 1475, 24996, 19560, 22838, 22489, 25079, 5310, 31676, 20596, 27580, 20356, 32552, 35447, 8178, 2119, 38820, 38865, 23655, 22136, 22601, 8262, 25524, 6535, 30715, 14551, 589, 13676, 23788, 19208, 11526, 7708, 39267, 28448, 28162, 24475, 2784, 2225, 4002, 38574, 16444, 27423, 13820, 31693, 17953, 10648, 29660, 15322, 186, 3064, 403, 6991, 9735, 16306, 11459, 21918, 33562, 12057, 2981, 38276, 5118, 7184, 10444, 3335, 1961, 6128, 18302, 30257, 29130, 23571, 20020, 1060, 38593, 15199, 28077, 14267, 4583, 14924, 27518, 14971, 24243, 10953, 28460, 38109, 660, 35993, 34865, 18015, 21952, 12815, 4699, 1790, 35839, 3551, 5814, 35247, 35103, 6859, 36477, 10131, 5949, 22371, 15711, 7047, 9594, 15336, 27748, 1104, 36693, 8886, 38524, 27166, 10045, 27892, 23397, 33993, 35102, 11707, 20565, 4288, 870, 1153, 25813, 34556, 17367, 20541, 12373, 5493, 33591, 202, 19438, 15981, 22157, 23045, 7652, 17770, 6934, 20052, 9006, 22867, 18766, 14709, 4108, 4696, 19298, 9227, 25201, 22026, 24065, 11395, 27496, 30463, 23110, 13271, 7408, 21824, 18979, 20829, 11199, 18980, 32837, 31169, 17570, 15916, 38613, 6802, 9906, 15976, 2038, 2455, 21598, 37387, 18803, 18235, 249, 38803, 4633, 4687, 15905, 10660, 23622, 26248, 17025, 23680, 34910, 22388, 25989, 39085, 30629, 10134, 13017, 38975, 30006, 5222, 15809, 33806, 21453, 30585, 8188, 19575, 19593, 23070, 4292, 17703, 17662, 34307, 5397, 36881, 28983, 31841, 34464, 14545, 13505, 18616, 32730, 39665, 18932, 6313, 19896, 24378, 10756, 24012, 36142, 25986, 26148, 21932, 28830, 7296, 20732, 504, 34863, 26633, 7069, 8767, 23452, 8360, 14411, 27370, 6569, 39380, 30797, 24560, 37663, 20055, 16133, 8327, 24040, 30689, 38937, 27001, 37662, 31959, 5191, 6244, 26550, 32475, 27850, 27582, 36723, 8835, 17126, 11545, 27425, 13280, 11982, 33870, 39957, 22659, 33719, 29851, 17145, 5205, 7476, 36157, 2105, 32494, 13621, 17812, 22251, 4290, 5718, 12098, 21395, 16081, 21064, 35441, 26326, 17408, 36882, 23313, 23777, 12335, 5217, 25959, 7424, 29896, 8120, 2678, 958, 36804, 2158, 31485, 11106, 26606, 26682, 5609, 7952, 39421, 39659, 33456, 19826, 4150, 12772, 25891, 1624, 10498, 8152, 1677, 36598, 6892, 27313, 21731, 37187, 21097, 18290, 34157, 37002, 15250, 11072, 11615, 11243, 15739, 4669, 8057, 37188, 22120, 4317, 31122, 34704, 7715, 7773, 367, 2535, 18086, 21968, 10521, 22110, 20876, 8646, 31838, 36075, 34272, 30570, 3587, 10668, 37900, 24276, 2265, 14382, 14066, 11099, 10214, 26461, 13755, 36808, 38522, 2326, 7190, 17616, 975, 23700, 26737, 6170, 36555, 22357, 3532, 15661, 16993, 2718, 7969, 9312, 22885, 23269, 5933, 39968, 9892, 13712, 31933, 7862, 21256, 29065, 4009, 6482, 26742, 20279, 12028, 12507, 14366, 2001, 5874, 30943, 2611, 13052, 2647, 22927, 7515, 30046, 4534, 24032, 18208, 8842, 11827, 11267, 38842, 20310, 39661, 20001, 34170, 6065, 3866, 23580, 27502, 5336, 28681, 33744, 7979, 24295, 7848, 28772, 13095, 36901, 15234, 26911, 32321, 37324, 34850, 24239, 12654, 37212, 4414, 38047, 17251, 12479, 14673, 30855, 30300, 3590, 18664, 14393, 12925, 11304, 20752, 26411, 31206, 38909, 18510, 33493, 26888, 7344, 22311, 27304, 2699, 27872, 5748, 8795, 22279, 15428, 26564, 11562, 24064, 32264, 24804, 496, 12598, 3690, 10363, 30079, 26933, 28011, 23124, 20060, 29029, 693, 37084, 6648, 35549, 5713, 14362, 30628, 39448, 2869, 2430, 19348, 19999, 5277, 16423, 11852, 20425, 20446, 22527, 30930, 39426, 1276, 29382, 22192, 20091, 20, 32583, 19409, 35750, 19470, 27731, 5258, 30077, 31942, 9086, 1312, 26177, 5451, 5953, 53, 63, 11927, 1806, 6828, 17440, 30540, 9576, 32571, 464, 6645, 21556, 33902, 37922, 20437, 29356, 38181, 15299, 17079, 21440, 27998, 3095, 24831, 37365, 20265, 32933, 26491, 35094, 35351, 14789, 37546, 20762, 14585, 5777, 38326, 18594, 6594, 24326, 16448, 13930, 9182, 13907, 16553, 36960, 3035, 10048, 21272, 6965, 8408, 17475, 31492, 36907, 12456, 29387, 3299, 39838, 22862, 16793, 8093, 35065, 15083, 27088, 30770, 6771, 9995, 6042, 38793, 7050, 11971, 27546, 4417, 17529, 26530, 24480, 4243, 34661, 26109, 27341, 16227, 20499, 17900, 1440, 4523, 16309, 33229, 5074, 14329, 39058, 30947, 5043, 24226, 26671, 33679, 24088, 18977, 26227, 33874, 31446, 2643, 968, 23356, 8547, 4891, 11554, 28941, 17510, 32302, 27287, 14738, 11899, 20625, 13704, 3266, 38619, 17526, 17004, 18299, 37177, 35495, 28533, 1154, 27622, 35963, 38210, 18064, 1022, 16660, 5847, 2488, 4959, 26977, 13152, 26060, 12750, 14233, 4050, 8195, 16060, 22705, 498, 23072, 25676, 34976, 21762, 31771, 12394, 25518, 22505, 25002, 5122, 18267, 16149, 5617, 18322, 630, 13771, 9436, 14019, 9807, 37596, 29180, 2659, 15533, 10336, 20375, 24885, 16973, 23529, 16277, 8397, 9180, 26474, 36572, 20695, 29707, 33125, 32868, 32790, 22342, 25132, 26537, 6513, 35101, 8124, 12865, 25014, 33915, 38394, 4774, 16182, 29149, 11272, 26949, 6276, 20662, 30623, 30617, 21156, 9484, 11021, 17096, 38147, 3991, 24656, 8399, 26158, 15576, 5602, 18791, 22113, 1866, 22502, 23726, 33209, 36380, 9498, 11204, 16454, 4350, 2712, 16191, 6079, 36665, 20069, 28443, 29817, 34690, 10997, 36049, 26602, 12358, 37009, 7289, 23507, 10479, 2807, 19730, 17418, 3747, 30865, 9966, 13229, 3753, 12955, 39079, 13941, 5164, 8806, 14608, 20188, 34073, 12742, 24854, 33692, 31652, 19685, 23414, 6962, 11760, 31396, 24141, 10984, 4839, 36200, 14477, 30778, 32307, 1463, 36717, 11101, 25569, 34689, 28743, 21176, 32414, 6923, 31945, 28508, 32984, 14247, 13363, 23315, 8692, 3601, 39623, 39937, 12973, 17390, 12804, 5714, 17740, 25334, 33952, 33907, 11278, 24935, 15375, 2946, 15240, 3674, 4238, 21663, 11316, 35119, 26027, 2674, 13596, 33473, 13893, 9802, 10938, 22925, 6262, 15714, 7192, 8077, 1167, 11710, 27886, 25952, 22675, 34839, 21098, 16106, 31814, 38649, 22976, 10115, 9782, 39622, 11327, 15841, 24801, 34504, 7958, 16920, 26776, 19412, 33711, 3381, 32897, 38678, 35164, 9273, 7947, 35929, 34274, 19062, 13208, 39433, 17842, 13291, 7815, 20765, 13729, 1487, 32904, 36823, 37684, 14882, 2236, 14110, 37964, 23709, 25477, 25489, 25908, 13244, 26229, 19962, 10641, 28300, 32419, 9525, 36757, 17437, 16399, 5737, 27467, 9269, 14054, 10951, 26029, 28966, 21051, 24702, 13976, 2318, 6399, 16765, 1189, 24462, 26114, 36641, 22007, 23783, 35138, 38908, 7547, 39790, 1168, 1122, 9985, 3825, 39924, 33484, 27565, 23817, 5446, 26539, 30155, 29965, 13424, 30089, 14824, 27017, 23884, 29899, 28215, 12942, 13346, 8531, 39423, 15420, 28972, 35132, 12607, 20322, 1171, 6444, 32218, 8516, 23385, 21413, 14254, 3086, 34968, 24956, 23556, 344, 36504, 7237, 28434, 19481, 951, 13136, 11075, 36406, 29995, 15719, 18826, 20707, 4432, 30174, 6349, 6953, 529, 29481, 4659, 33074, 30678, 21705, 15132, 1963, 20371, 20068, 25108, 38703, 21830, 34694, 37841, 31725, 24972, 8696, 6789, 1170, 34466, 23979, 32282, 36264, 20145, 22777, 30523, 8704, 29027, 30824, 39152, 7912, 5674, 32150, 18100, 15721, 12903, 21120, 27646, 19571, 14923, 25202, 2978, 32846, 21451, 5788, 21207, 15079, 1266, 23582, 35833, 29987, 24764, 10910, 5917, 1881, 25312, 35531, 39115, 24896, 23094, 37006, 18213, 35700, 7146, 3851, 10029, 17689, 2071, 5198, 4716, 26677, 14033, 23057, 20738, 29470, 18731, 23835, 6180, 918, 2750, 33285, 37582, 6124, 25929, 26086, 29231, 39816, 8337, 3066, 32164, 35050, 7506, 6376, 33087, 26890, 1786, 4846, 30533, 37332, 9206, 35181, 2171, 18935, 36256, 9311, 34740, 32261, 19097, 32894, 6514, 7934, 38192, 37406, 10702, 4042, 24299, 3685, 30228, 26586, 13115, 15817, 19528, 26434, 4604, 24414, 31211, 29612, 37226, 20739, 34728, 32352, 36396, 4181, 27884, 16004, 19000, 35026, 31683, 2445, 12936, 38029, 32336, 35983, 34998, 39507, 24806, 23584, 23618, 12273, 15577, 15223, 25198, 11089, 18696, 24444, 7060, 29002, 3792, 23568, 22872, 11462, 11718, 19048, 20672, 15317, 39537, 22676, 4736, 3626, 39468, 6809, 10175, 34204, 37215, 8825, 10260, 19874, 33831, 14621, 36908, 7661, 37180, 7704, 19622, 15790, 33955, 34190, 20748, 17748, 15723, 25156, 11229, 20537, 17784, 8790, 36874, 22515, 30767, 26780, 4840, 3701, 7217, 1357, 2669, 30954, 7628, 36389, 11158, 4955, 23542, 548, 33789, 9924, 17427, 34818, 2114, 419, 20534, 17930, 37690, 10237, 26237, 22324, 34663, 20726, 6173, 24898, 6169, 39640, 2118, 24089, 35253, 25470, 36748, 28673, 18732, 34332, 26494, 10640, 37425, 22017, 28704, 7247, 14156, 19279, 16758, 18196, 15111, 15333, 4764, 12732, 29096, 34324, 14615, 5965, 23276, 27142, 5086, 2684, 15651, 28307, 9804, 25234, 14697, 2479, 35394, 27737, 19899, 17144, 27685, 24908, 20593, 13452, 32221, 37348, 22131, 15983, 5418, 29404, 6148, 39892, 31803, 2597, 3791, 34076, 30027, 16225, 34810, 13782, 35117, 18811, 15323, 12110, 7436, 16678, 30334, 33363, 19253, 7304, 36437, 11519, 36670, 1593, 11463, 31184, 38277, 23705, 7940, 10270, 5025, 37875, 2878, 38233, 20039, 22955, 30360, 14084, 10289, 329, 17283, 13797, 27168, 18231, 36888, 22522, 32499, 14339, 2172, 22409, 26601, 11424, 13727, 30301, 9389, 32230, 19709, 38801, 34299, 13477, 7413, 23447, 1849, 25303, 18082, 32371, 30092, 26030, 16726, 15205, 10242, 36912, 2303, 34631, 38887, 900, 18160, 32920, 2142, 19043, 6946, 27422, 21399, 2293, 23955, 15965, 1942, 9615, 26787, 2680, 2551, 33586, 19064, 13324, 309, 36420, 1682, 26386, 28991, 7711, 27830, 23037, 38913, 30986, 26532, 19496, 10346, 36019, 35832, 21688, 23629, 12961, 6693, 17863, 22254, 15806, 6851, 24097, 24046, 38126, 28628, 14653, 4918, 1882, 3658, 25975, 26773, 35124, 24412, 12042, 38780, 22413, 23792, 23679, 15566, 8459, 30519, 27354, 10716, 17811, 38743, 34606, 39801, 24200, 18023, 25611, 17059, 2913, 37471, 9893, 29574, 4115, 12257, 38169, 10670, 20124, 11122, 29760, 23530, 2639, 29840, 30763, 12734, 23684, 3759, 8149, 20964, 6652, 32910, 21163, 35642, 18743, 26393, 3240, 4200, 29424, 7853, 35752, 17892, 782, 23215, 5915, 33508, 22745, 33502, 29207, 28065, 8506, 20609, 20243, 39959, 1842, 2552, 22188, 23409, 31742, 12666, 1284, 21495, 1405, 7892, 21326, 20445, 774, 7065, 23702, 7257, 28528, 6401, 33231, 21847, 26144, 39943, 21595, 27754, 26424, 8513, 15001, 1235, 244, 36934, 8420, 21537, 5464, 11093, 8883, 33264, 9794, 34887, 24944, 10046, 15783, 1015, 10021, 29701, 39140, 21640, 9305, 19457, 26997, 11892, 30573, 20456, 3843, 23167, 22850, 7270, 14914, 302, 4532, 8585, 18212, 9059, 6229, 16426, 37203, 3806, 36387, 22200, 32534, 18515, 35129, 1924, 39814, 37788, 26646, 14694, 24931, 26821, 35838, 33814, 15816, 14628, 9526, 37568, 1135, 23219, 29225, 14540, 6454, 37371, 2364, 33636, 12509, 2431, 11886, 18328, 30566, 4886, 17261, 24937, 12506, 19394, 28117, 20750, 10448, 33082, 38463, 7953, 33224, 20056, 21712, 32956, 37052, 3864, 21548, 36696, 11946, 24850, 9131, 17448, 23846, 37285, 39769, 6233, 32622, 13732, 1841, 22129, 8020, 14317, 37408, 16672, 1418, 10395, 24708, 12611, 36913, 6663, 612, 29471, 31946, 3491, 3118, 925, 36666, 36557, 15582, 14877, 7869, 29820, 24630, 26429, 24791, 14264, 22772, 20143, 16114, 25746, 8143, 29105, 38110, 21179, 8838, 36878, 39303, 38617, 1897, 23820, 2167, 37773, 24318, 30313, 13309, 25385, 19883, 19867, 28570, 6723, 2845, 15861, 33137, 10499, 30485, 35769, 21631, 15705, 2161, 39907, 3999, 33836, 27106, 11170, 14353, 20611, 32429, 27617, 22702, 4794, 7737, 27643, 25560, 1935, 34780, 14693, 25656, 23021, 19447, 16599, 879, 4213, 17846, 914, 16555, 10309, 17711, 17595, 32365, 9074, 8424, 36628, 11563, 12137, 33689, 33315, 19970, 29256, 22618, 3511, 25179, 5818, 21087, 33967, 11242, 4856, 32016, 3206, 1073, 3027, 16038, 14864, 32607, 29464, 30724, 15716, 219, 16327, 9014, 32235, 19805, 9930, 2414, 29945, 19065, 26831, 22958, 34461, 33466, 23482, 20666, 20899, 15084, 31788, 32005, 28125, 3794, 33228, 26365, 1111, 26272, 5287, 1845, 18419, 17391, 14038, 32718, 19432, 36984, 15490, 16732, 7972, 24166, 4225, 2673, 8891, 19561, 35149, 11150, 34633, 16260, 39417, 23645, 35311, 6976, 2004, 30028, 28764, 10081, 19591, 19301, 5107, 33908, 26922, 8308, 32756, 8278, 31714, 12484, 162, 13834, 10755, 19926, 5121, 3593, 37878, 9727, 12040, 36138, 10150, 7913, 30182, 19091, 2658, 24839, 25936, 16275, 1254, 3435, 24821, 31399, 32166, 39641, 15023, 32668, 25194, 5068, 33128, 6629, 20245, 6850, 14449, 16674, 7950, 7401, 3544, 3053, 18088, 39753, 5809, 36615, 25326, 28625, 1741, 10779, 24478, 38396, 10944, 38973, 1573, 22805, 12074, 13075, 17832, 21350, 23543, 10079, 59, 19557, 22408, 16110, 10943, 22545, 39077, 21699, 7842, 18123, 22970, 26730, 17523, 16532, 39677, 14963, 34086, 18310, 38634, 5007, 11352, 2737, 25271, 26994, 4090, 6464, 7828, 19019, 35271, 22952, 38095, 35543, 35780, 12209, 37191, 17252, 26608, 20173, 12206, 27275, 33092, 30946, 5109, 36941, 39474, 36923, 39607, 20497, 38763, 9184, 9091, 15454, 35061, 38036, 5064, 10067, 6750, 4132, 10838, 9586, 12179, 13612, 31421, 20028, 12940, 1981, 36837, 24359, 31405, 71, 29913, 39182, 2879, 34608, 28811, 22411, 12052, 35573, 36708, 25779, 10567, 29547, 28248, 674, 14088, 24943, 22414, 30014, 14356, 38539, 31444, 4979, 7726, 15087, 10118, 31529, 22470, 10417, 37133, 22678, 9326, 17904, 26857, 2137, 35030, 39842, 33448, 34665, 26915, 30302, 22255, 9920, 667, 26436, 1447, 28920, 10259, 33535, 7809, 26859, 37616, 7518, 34389, 38567, 32813, 13337, 15798, 28353, 35800, 1379, 31630, 7209, 20688, 10409, 25382, 16464, 15163, 27405, 17155, 39504, 39597, 5167, 22999, 3058, 36830, 12586, 13021, 36243, 18580, 32276, 31422, 11655, 11783, 7328, 31456, 5248, 10800, 10877, 39721, 19370, 39106, 11083, 30458, 13442, 9341, 13081, 7692, 14735, 28398, 25055, 5011, 13409, 34712, 22226, 22760, 27723, 36501, 34409, 9465, 25259, 31567, 33488, 9194, 21133, 18666, 27676, 11887, 22412, 16188, 13403, 15254, 8108, 32648, 8952, 9941, 9585, 22047, 33284, 6997, 11959, 13747, 14790, 18551, 4611, 8569, 11656, 14177, 12236, 36922, 28466, 39562, 31563, 26482, 35255, 28356, 27353, 16345, 38397, 18121, 26480, 23034, 26814, 37309, 13528, 24783, 8502, 22761, 6910, 34401, 32778, 32614, 34128, 12237, 14645, 26740, 8602, 13080, 7481, 38224, 6856, 2449, 19948, 11764, 39449, 22034, 33310, 12779, 26522, 193, 13022, 25307, 581, 8312, 22394, 1820, 32129, 13007, 4143, 1800, 32094, 25177, 9948, 38788, 3647, 14321, 25740, 11862, 16832, 24761, 38767, 7393, 31995, 11173, 10053, 24608, 28904, 27207, 37017, 22474, 22333, 3013, 1426, 11081, 30851, 28066, 9998, 22377, 19916, 17543, 35083, 7991, 7168, 12537, 7124, 4102, 35128, 7632, 17450, 8799, 10028, 93, 34367, 6602, 14230, 8526, 25738, 31850, 38926, 31641, 17561, 29087, 2428, 31716, 12830, 37755, 27299, 18248, 19800, 35187, 30848, 3280, 25643, 30475, 21160, 19956, 20677, 8775, 20773, 512, 17572, 14008, 38689, 13740, 39807, 33821, 28310, 23291, 13218, 32644, 2202, 26075, 12146, 36372, 23565, 37046, 13806, 9047, 36208, 17180, 2747, 12624, 7630, 21553, 34132, 11652, 18193, 12721, 9677, 13423, 28212, 28650, 36841, 23285, 20900, 18347, 19031, 5523, 35903, 13496, 39088, 25782, 32815, 23302, 20902, 20275, 18467, 17069, 6317, 17347, 31138, 24405, 33404, 29465, 18575, 8980, 20651, 35894, 33487, 26930, 21151, 10322, 30250, 14446, 20699, 38008, 25483, 18058, 28691, 4279, 31014, 10729, 4217, 4110, 35848, 31848, 11095, 22866, 35106, 4962, 2253, 20180, 28519, 37189, 36131, 4162, 21807, 2671, 3521, 26377, 8344, 2215, 39022, 2000, 26687, 10185, 38992, 29300, 4489, 18934, 30527, 5573, 10970, 21421, 5474, 37442, 4807, 6149, 2948, 8644, 13999, 23038, 19406, 10202, 15534, 18091, 26762, 15424, 12852, 1310, 1331, 6360, 34675, 26579, 25276, 33794, 5712, 3768, 26885, 22261, 33804, 28311, 32911, 29906, 3605, 32539, 13639, 22716, 28729, 38641, 7775, 28239, 2605, 9627, 34875, 17483, 14281, 11850, 20747, 12963, 30556, 596, 35926, 28619, 7538, 19178, 5827, 35690, 24748, 28797, 24332, 32639, 30677, 38925, 25071, 7467, 8779, 4173, 36453, 10228, 18448, 25003, 28948, 38122, 39003, 10274, 3560, 17519, 12374, 24874, 18036, 30427, 23596, 13302, 33548, 21372, 14222, 32445, 15041, 15296, 21020, 34857, 18182, 5623, 17338, 8190, 29704, 11117, 32299, 2753, 30097, 39025, 10557, 34506, 33853, 3659, 27476, 38291, 20013, 32063, 38500, 16906, 28513, 29104, 8400, 5251, 5275, 38049, 39792, 32570, 16470, 12078, 20996, 8128, 11624, 6009, 27233, 29320, 21060, 13099, 23762, 36119, 19606, 14879, 157, 39783, 6043, 18410, 2313, 35857, 14010, 12834, 2503, 34815, 13032, 9019, 38727, 7865, 18810, 8189, 16698, 32152, 23359, 30707, 39709, 14308, 19587, 29685, 11697, 34872, 35150, 10490, 3711, 36554, 37148, 12887, 1591, 17701, 39520, 14773, 30100, 14600, 15448, 6112, 5114, 36278, 11239, 2025, 29822, 22826, 16130, 3925, 24705, 5300, 31592, 3680, 39360, 20129, 13620, 32652, 1686, 32343, 38896, 2421, 5437, 29295, 25719, 33717, 23972, 6823, 22031, 33271, 37458, 7929, 31993, 25904, 27032, 6890, 14957, 17912, 5104, 19934, 38255, 30909, 9230, 23060, 494, 7553, 31713, 24587, 19165, 11955, 37085, 33412, 8961, 24186, 9510, 12019, 35313, 38323, 10975, 8221, 8498, 33559, 28908, 651, 34692, 21585, 22914, 16676, 39703, 35042, 29812, 1355, 7795, 26341, 9659, 2891, 3315, 24127, 37446, 31792, 21561, 16703, 6063, 34012, 11940, 25446, 19213, 30053, 31586, 24114, 36911, 7867, 13170, 7028, 11592, 27667, 1130, 14696, 11307, 16253, 16892, 4253, 20319, 19984, 22293, 23843, 35223, 33230, 72, 23089, 27345, 29035, 6701, 26325, 16313, 36079, 28249, 31451, 11534, 3011, 21168, 25817, 34004, 4976, 31969, 29711, 33148, 3146, 31342, 38823, 37921, 9600, 27606, 15193, 12253, 9202, 19120, 37175, 35611, 21632, 10373, 26427, 24936, 17995, 24960, 368, 15628, 13774, 31104, 13177, 20320, 37840, 19667, 19326, 32324, 29197, 13628, 11543, 9613, 35593, 16143, 22058, 10147, 15156, 25822, 38507, 2580, 17061, 29195, 36004, 29021, 17417, 6468, 20954, 30764, 35641, 1047, 27873, 32207, 29136, 4554, 22924, 4837, 34385, 13898, 17093, 21056, 9813, 10393, 1089, 9099, 19530, 35086, 25486, 39771, 30024, 7589, 30032, 22843, 20394, 8110, 20633, 16341, 30668, 8856, 27615, 1706, 39578, 21528, 35605, 37288, 23740, 19294, 4434, 4631, 28600, 38898, 4898, 30009, 5918, 18799, 10109, 10413, 206, 4272, 22911, 1017, 20663, 39596, 25268, 13134, 11172, 3457, 20639, 8123, 3136, 6210, 34711, 24537, 25509, 24344, 35484, 30780, 3379, 1583, 33422, 18444, 24868, 8320, 3480, 8388, 17225, 35215, 4310, 23500, 27960, 38506, 10094, 16799, 7298, 22091, 22037, 14627, 32538, 26914, 33044, 727, 8933, 197, 15058, 14053, 39439, 26026, 2452, 37384, 26562, 4312, 10731, 23978, 17349, 29085, 34528, 10113, 22868, 30279, 39705, 31262, 6155, 9756, 18256, 39591, 35569, 38805, 31183, 12531, 10485, 34853, 10127, 919, 20597, 20901, 5582, 37014, 29554, 39465, 27482, 29528, 16279, 190, 10295, 29589, 1536, 38324, 8137, 3724, 10578, 36025, 3993, 13647, 30180, 26004, 33716, 446, 23105, 39187, 21371, 35001, 4188, 27661, 8297, 23755, 685, 15238, 1230, 24649, 24900, 22627, 38428, 3431, 38150, 27420, 32763, 10791, 22878, 2965, 13641, 8690, 8421, 25191, 17485, 35761, 39749, 19376, 39679, 2496, 5158, 35905, 23098, 4167, 3214, 839, 35346, 23538, 1651, 10126, 9443, 32359, 31247, 8893, 23059, 16031, 7332, 3736, 11086, 7009, 7549, 15270, 28674, 37645, 30096, 24139, 39915, 21700, 30433, 25806, 1201, 994, 17413, 21535, 25131, 4887, 28591, 25906, 1906, 12292, 22422, 13840, 29449, 24078, 18454, 19838, 31163, 18159, 15892, 10706, 2073, 33372, 6673, 17767, 813, 28302, 5352, 33005, 1884, 17467, 36128, 39738, 20298, 34768, 1278, 38306, 2988, 19961, 17534, 34586, 35433, 45, 12053, 38342, 1854, 20767, 9866, 19280, 11323, 19338, 14406, 12169, 29010, 23155, 10705, 29602, 33296, 23713, 7633, 36187, 36221, 27654, 23130, 22928, 36471, 1352, 26706, 31972, 14531, 28690, 2377, 25731, 39467, 28374, 34014, 25649, 39250, 28395, 39471, 17278, 38424, 23694, 22246, 27251, 36077, 32437, 17990, 678, 39092, 6874, 32337, 8161, 316, 20801, 32146, 19788, 22065, 21274, 28496, 24599, 14731, 4653, 17716, 20197, 7850, 39208, 8744, 13279, 2950, 29230, 29259, 39644, 18687, 510, 11283, 23300, 26184, 20965, 15409, 14835, 6574, 25661, 16264, 35745, 3145, 27451, 18475, 38479, 28204, 7750, 8363, 31826, 9956, 10450, 25016, 18736, 33774, 38866, 21055, 20501, 27436, 21812, 32268, 12570, 9335, 37719, 32940, 2751, 21001, 14704, 34338, 27136, 35671, 8379, 24929, 7571, 20724, 28602, 385, 622, 24366, 11098, 31607, 5969, 13378, 10330, 34680, 13934, 29627, 30178, 14065, 25637, 32863, 38266, 15603, 6600, 26094, 36676, 21144, 2139, 15773, 37909, 3159, 6064, 4703, 25038, 27581, 24704, 32775, 2480, 9257, 5022, 4561, 21072, 32442, 5058, 23917, 35729, 21222, 36900, 8068, 30143, 14553, 31176, 15508, 30850, 8686, 23561, 11197, 1510, 12215, 34812, 26952, 27824, 28677, 1633, 2968, 21392, 7049, 28427, 39794, 27519, 18399, 32187, 36846, 38262, 38687, 7061, 38807, 16495, 5059, 24338, 32979, 11121, 12192, 13388, 29051, 25688, 23785, 9123, 32558, 20837, 15290, 20799, 35230, 28281, 21929, 28224, 15608, 5249, 5367, 38960, 20984, 23382, 29887, 35458, 12388, 10452, 16461, 25097, 12794, 20448, 1525, 6792, 4092, 28854, 19649, 39802, 37129, 34550, 5894, 17732, 23312, 25892, 17505, 17470, 25204, 2604, 21327, 8448, 30361, 1514, 15997, 29735, 25238, 12058, 9981, 26216, 10969, 35140, 35736, 14719, 31560, 25556, 17901, 38587, 7666, 22124, 28777, 4149, 6894, 16671, 11080, 29261, 18272, 6178, 25345, 32898, 27616, 20798, 13564, 33998, 39110, 35638, 28588, 37916, 30357, 1888, 39588, 25245, 21153, 8698, 10308, 27807, 17336, 31193, 27557, 33114, 7873, 8612, 19277, 22104, 1450, 19705, 30406, 28527, 25597, 32485, 20411, 14077, 10491, 30575, 34906, 11054, 2670, 12184, 37509, 30444, 16266, 28905, 30691, 8067, 37637, 21516, 9440, 35420, 13532, 13951, 36094, 18879, 35888, 31479, 15345, 11626, 15237, 14314, 25981, 26795, 27684, 10624, 10404, 32825, 29636, 23832, 15395, 6563, 19832, 33648, 38904, 18514, 33675, 26972, 13518, 7931, 2898, 3830, 1531, 11947, 11854, 32274, 1123, 18698, 34294, 31497, 16504, 833, 39833, 6551, 18396, 14118, 16265, 15267, 32814, 19345, 33826, 5852, 18825, 15710, 13718, 37106, 32247, 4125, 37817, 18360, 23439, 37485, 5403, 5946, 33645, 16322, 15881, 37373, 18779, 30315, 26281, 38234, 6627, 15580, 24106, 9672, 24762, 4715, 31034, 7875, 26226, 10834, 26884, 9017, 32223, 3990, 7076, 35287, 26698, 28157, 2830, 473, 6984, 21247, 20167, 3179, 1817, 39510, 22512, 34424, 2014, 23259, 5905, 10434, 10961, 17239, 35977, 17146, 21228, 3549, 38485, 16611, 1272, 25173, 1947, 25948, 20968, 20092, 20378, 32139, 38289, 322, 7570, 39913, 695, 2007, 17769, 38345, 26290, 36522, 29725, 38313, 37100, 15456, 1660, 19003, 23751, 5244, 12035, 19875, 27364, 15910, 3829, 22651, 20093, 6462, 33066, 9090, 4410, 39015, 35494, 30234, 27888, 27290, 24857, 12159, 13159, 39068, 8250, 33113, 37572, 31550, 3424, 34989, 30925, 9954, 28742, 33366, 24400, 35866, 34413, 37675, 1992, 21013, 24523, 5390, 17494, 14324, 33106, 3633, 13645, 33420, 35229, 1005, 5968, 9122, 17232, 38614, 24424, 23513, 30700, 37700, 28266, 7030, 12486, 26929, 7002, 8228, 9351, 13937, 7153, 10016, 9503, 33213, 32447, 29074, 13037, 20542, 16876, 23994, 19836, 31835, 5193, 17482, 31999, 39851, 17243, 34256, 22417, 37334, 19044, 411, 9208, 14460, 29288, 4270, 19711, 29278, 23058, 26065, 24836, 10581, 1142, 37752, 30662, 15638, 17760, 15152, 3807, 16023, 24401, 19098, 8038, 23344, 37289, 9387, 30199, 26809, 24554, 36619, 17007, 25816, 383, 4950, 33765, 23091, 21116, 2705, 21416, 31210, 24356, 14928, 29062, 4286, 30249, 18682, 32250, 1910, 1493, 35370, 27283, 29066, 24964, 18124, 34148, 38938, 19679, 718, 10454, 12471, 25584, 3949, 27843, 38517, 34469, 2198, 39734, 12747, 20578, 1419, 4300, 37217, 29943, 31593, 11268, 19623, 4610, 11270, 23686, 13523, 34574, 13973, 22296, 19436, 15121, 36476, 844, 25716, 6676, 24242, 34943, 34774, 38558, 28211, 35556, 2683, 23810, 5975, 19476, 22796, 29372, 10597, 36241, 2244, 2796, 28989, 6140, 22218, 37541, 23395, 4602, 10358, 5620, 3260, 33988, 37281, 14041, 27641, 31212, 31432, 13926, 1612, 33232, 13239, 30185, 22367, 20061, 716, 29515, 11597, 16617, 13210, 7820, 10015, 23599, 15819, 35973, 30634, 32065, 30969, 1157, 33566, 3780, 18711, 4262, 37128, 38365, 22697, 37290, 29268, 33219, 22133, 38170, 9970, 37319, 39525, 2277, 10085, 26738, 36617, 3788, 36520, 21273, 39715, 33220, 10486, 13925, 32711, 19276, 12597, 18537, 34563, 17407, 34173, 1747, 22395, 16020, 12025, 5219, 37407, 22350, 6190, 16683, 25619, 7712, 9016, 24185, 39632, 14870, 9438, 24382, 21763, 873, 16999, 12018, 24579, 27739, 20400, 36496, 21623, 19823, 1604, 6688, 423, 19768, 3507, 5226, 18439, 7309, 12838, 32090, 2059, 12289, 4284, 3629, 19697, 39947, 3418, 27644, 12389, 37062, 35372, 30846, 38885, 31358, 13043, 22811, 33723, 23314, 21930, 25459, 25492, 37410, 3190, 9021, 14872, 18120, 23367, 25293, 28857, 554, 38355, 12269, 18140, 24447, 213, 382, 25214, 17967, 18238, 17795, 27098, 26178, 37494, 33313, 28633, 26228, 14265, 17727, 32809, 10089, 18565, 6159, 4357, 15539, 38725, 4088, 22496, 5671, 1504, 28312, 14782, 31988, 17737, 1662, 21781, 25593, 26472, 22426, 37696, 36066, 31111, 23109, 34376, 22877, 35392, 1378, 6080, 33261, 4394, 24610, 30169, 521, 15913, 271, 2245, 30392, 2590, 15904, 7174, 36454, 32203, 10747, 15511, 17064, 28228, 24177, 12170, 38967, 24247, 36250, 29731, 33652, 25024, 33572, 18753, 20840, 10896, 20011, 1632, 19920, 269, 30271, 33458, 16958, 27908, 4333, 3875, 8473, 29745, 10352, 22036, 26631, 15039, 13869, 39217, 4613, 1218, 4346, 14698, 15884, 7176, 34914, 9608, 24144, 35316, 13793, 15353, 7031, 30116, 36156, 5621, 32982, 7830, 7882, 35352, 3137, 1169, 15565, 16741, 18275, 25648, 14241, 37530, 18765, 32716, 4120, 37681, 30456, 19498, 11378, 33393, 11704, 20717, 31903, 5909, 19381, 11613, 18903, 1415, 38458, 17682, 11719, 27410, 15414, 33382, 36766, 6691, 14429, 31277, 20702, 33596, 31559, 13413, 23496, 28207, 35315, 31749, 9292, 15896, 38056, 16414, 32105, 25441, 2435, 33918, 22574, 30502, 3436, 32098, 34231, 2543, 31270, 27236, 25920, 25624, 6778, 32270, 8389, 38886, 6571, 36734, 39447, 1858, 27006, 10401, 27608, 5308, 29935, 25887, 20825, 29279, 18264, 7292, 7345, 14137, 8759, 7329, 27116, 897, 28744, 12723, 27048, 24250, 21684, 7203, 33947, 531, 18623, 9512, 1878, 18646, 7891, 27269, 35432, 39164, 36364, 33541, 16276, 13974, 28883, 33403, 32492, 2698, 20951, 18, 22694, 7880, 18130, 17531, 38810, 28105, 460, 25083, 16283, 38847, 10187, 17118, 38378, 6378, 32363, 7928, 26347, 17813, 14977, 8658, 37540, 2947, 39930, 29997, 13705, 22609, 18229, 38196, 39952, 4728, 325, 18567, 20914, 39990, 36206, 10649, 15867, 2778, 2458, 1766, 22013, 3819, 6592, 35519, 31180, 30344, 34239, 9876, 15130, 28596, 39864, 24754, 3340, 10801, 11559, 13454, 31197, 19113, 17928, 27442, 6051, 27305, 6941, 2147, 39511, 14275, 8210, 10507, 3751, 38612, 25930, 18146, 33606, 13175, 23234, 30393, 33604, 34678, 26044, 39528, 13040, 24638, 5393, 17579, 39570, 10439, 13527, 10863, 22570, 39436, 7832, 27480, 37435, 17695, 28093, 22309, 17922, 9593, 28205, 38551, 10929, 10288, 25520, 21958, 29455, 1538, 37115, 18173, 1636, 3057, 8003, 17493, 5766, 20024, 34013, 2630, 1207, 8227, 3040, 29233, 4083, 21337, 10008, 19340, 5616, 12684, 27698, 23663, 20843, 28183, 3268, 1110, 2618, 19834, 11782, 1384, 14105, 34391, 26352, 16028, 11493, 21664, 21473, 3144, 7936, 10631, 19026, 28132, 4154, 13816, 33358, 21479, 33693, 30582, 8442, 2212, 31597, 14952, 22624, 11774, 2490, 12719, 3535, 16607, 4882, 2587, 27043, 7342, 16382, 17167, 2384, 8368, 25091, 37726, 34446, 31203, 37676, 16441, 541, 4309, 1784, 12244, 15540, 9848, 11737, 31732, 2075, 2285, 27352, 1655, 39710, 37119, 7855, 952, 12399, 11798, 4888, 3689, 32517, 31752, 8508, 17686, 4818, 7320, 29880, 3579, 24307, 18443, 29307, 2550, 12939, 6198, 16156, 26862, 18763, 23238, 1121, 21063, 36997, 1173, 21641, 7323, 29402, 10341, 10347, 24389, 15849, 1307, 9467, 10619, 13062, 21257, 30330, 1243, 10030, 15438, 32488, 26644, 3533, 6295, 21019, 37803, 36388, 5329, 37255, 7387, 1179, 14262, 21246, 981, 20387, 38358, 11290, 15102, 32590, 21346, 13585, 10544, 33656, 35789, 39043, 11844, 30863, 35074, 34021, 29339, 10116, 20202, 25772, 22835, 7907, 11047, 28710, 18035, 4159, 27280, 743, 32580, 1907, 8934, 35017, 19494, 19564, 2237, 9460, 15243, 38748, 5305, 7074, 5041, 25284, 37274, 1672, 33277, 22428, 11111, 25205, 25178, 32348, 34524, 17401, 2575, 25139, 14906, 22453, 14988, 13507, 6167, 22215, 36464, 374, 23947, 34654, 18151, 23208, 23327, 23695, 22847, 2482, 22836, 3377, 21974, 12315, 36265, 38311, 22915, 5594, 12355, 15489, 32341, 21402, 2614, 12363, 32357, 9753, 14634, 30875, 30052, 30805, 8784, 29541, 13511, 6096, 34843, 19006, 27962, 1688, 3168, 21584, 30295, 26823, 34171, 27863, 3355, 26653, 22187, 2945, 19093, 8931, 3427, 31600, 505, 7276, 13954, 26040, 37938, 39524, 13459, 11286, 6717, 2696, 20232, 17605, 24589, 26087, 34983, 10519, 34616, 4038, 23588, 2042, 10223, 37481, 28968, 39498, 24431, 3729, 13971, 12077, 18709, 23141, 5497, 16651, 25973, 6920, 29099, 12045, 34902, 19199, 29473, 33263, 5223, 11344, 33445, 34942, 24123, 33374, 10874, 35490, 36005, 32470, 12604, 38167, 16573, 184, 16582, 13553, 9761, 34767, 6595, 33901, 33462, 13063, 21126, 24525, 25425, 26414, 361, 6136, 37250, 37881, 8514, 32579, 22634, 6374, 35853, 25939, 20323, 21494, 30051, 28343, 20057, 39408, 39202, 34698, 4917, 28566, 22929, 6716, 5656, 25591, 38078, 11426, 25510, 21336, 463, 466, 34142, 13, 38241, 20228, 37629, 2146, 23743, 10855, 39605, 37705, 17393, 1574, 12204, 29867, 36729, 36347, 31994, 11470, 17150, 12741, 30516, 13481, 34632, 27078, 23487, 13214, 10987, 38694, 34304, 39667, 33041, 6956, 15845, 36229, 24119, 32993, 33031, 30641, 12929, 35505, 33051, 13123, 31195, 2882, 6396, 28482, 24981, 9369, 25884, 11998, 14300, 35139, 22846, 24938, 12354, 37934, 12360, 10559, 24670, 34707, 14907, 7404, 28369, 29246, 14283, 13428, 17139, 34265, 25931, 31980, 17576, 24003, 6743, 5049, 4471, 30209, 1998, 18525, 9663, 17527, 56, 38945, 14441, 1847, 26527, 1801, 18393, 3874, 1350, 10383, 34455, 24037, 28998, 5170, 30151, 8773, 21466, 31904, 12889, 39307, 39231, 2218, 36787, 22196, 18724, 3482, 1965, 34379, 22567, 9762, 28982, 31569, 31882, 12668, 34756, 34643, 29771, 19322, 36607, 15864, 28503, 38211, 7466, 24041, 13508, 39950, 39271, 18539, 31330, 24367, 24912, 12587, 38501, 14897, 30911, 17743, 2545, 6848, 38247, 2743, 31730, 19833, 27797, 21467, 12242, 35305, 13453, 27903, 8542, 33937, 7268, 29023, 479, 34495, 3080, 31235, 2092, 14515, 38726, 8754, 38781, 16103, 35414, 19361, 33474, 949, 7167, 23239, 25282, 18189, 27090, 18699, 12121, 38103, 24351, 33823, 4485, 15203, 19501, 25294, 38073, 8575, 644, 36321, 11319, 24292, 6561, 30291, 25735, 5700, 3958, 37171, 9873, 28017, 30600, 27774, 20561, 15807, 31458, 14993, 9038, 24285, 16221, 20428, 493, 32385, 4099, 18453, 31824, 13958, 30163, 31579, 28589, 29857, 3000, 21635, 291, 34309, 32527, 26250, 10563, 18821, 16972, 11483, 12593, 20231, 19745, 30605, 6424, 24087, 25456, 8820, 34305, 24465, 28664, 842, 3003, 4884, 10209, 30709, 15125, 6825, 37666, 17803, 33599, 2140, 28924, 3678, 35220, 15857, 3083, 24411, 26260, 16614, 20676, 28392, 5675, 6868, 7694, 15279, 33254, 23113, 24371, 33516, 6082, 6018, 29892, 8532, 2914, 3393, 29628, 8043, 20637, 14371, 9533, 15170, 32721, 35252, 15235, 5987, 1758, 6900, 387, 22714, 15402, 28010, 11120, 30603, 38729, 28815, 14482, 37501, 31865, 34531, 2474, 29337, 23332, 33090, 984, 30015, 20380, 34568, 13335, 1563, 23682, 38161, 7617, 22183, 25270, 32402, 15942, 16132, 1594, 8593, 1931, 35450, 25485, 23537, 15384, 5506, 26836, 7787, 1689, 27516, 25925, 36711, 36558, 29955, 8407, 33007, 18226, 15354, 18126, 13819, 8792, 11445, 32679, 31252, 36445, 21836, 6939, 37118, 36886, 4387, 15979, 6728, 32394, 29129, 9521, 657, 19167, 30450, 4186, 17719, 6449, 10216, 21658, 3585, 11945, 37856, 15900, 12261, 39657, 27652, 38791, 33934, 11171, 1410, 7038, 19267, 31484, 2558, 229, 26306, 35349, 5354, 24700, 35416, 30080, 28823, 16849, 24258, 19884, 37797, 37140, 33077, 37404, 5419, 27128, 32342, 32932, 27040, 4574, 29806, 36820, 21046, 2681, 27231, 31087, 23075, 33216, 8292, 34433, 9793, 12582, 12718, 15289, 39611, 38149, 26293, 23859, 2510, 31371, 3134, 10618, 25555, 1614, 13521, 30125, 36791, 10047, 15335, 10546, 27004, 15362, 4796, 8051, 19902, 4844, 4909, 18710, 15241, 10659, 33657, 6940, 12490, 30588, 17337, 18859, 4020, 35566, 2877, 6843, 4515, 1524, 12062, 28391, 8673, 3484, 15061, 15016, 11802, 23405, 38107, 27298, 33760, 24878, 3150, 16821, 39993, 9224, 16329, 34152, 13155, 37381, 31881, 23465, 2197, 36365, 6203, 30260, 26767, 1356, 27609, 2730, 33351, 19950, 24907, 11345, 6670, 2405, 6576, 6640, 22892, 5823, 24648, 6964, 37688, 29100, 11800, 10345, 17608, 33923, 18524, 33568, 34628, 34855, 12246, 29297, 20015, 37426, 39119, 19035, 8534, 18867, 2847, 30500, 1932, 12510, 4781, 36314, 23748, 31853, 26558, 5125, 38553, 16579, 10197, 17266, 12890, 24873, 20944, 1340, 5301, 4792, 21165, 29568, 13164, 7406, 21608, 32482, 11373, 22913, 11497, 17619, 14304, 31213, 34630, 1904, 32080, 30481, 10470, 22044, 30426, 39727, 36502, 36584, 34331, 14332, 10023, 11574, 38054, 22479, 38088, 27190, 6692, 5149, 2963, 15315, 23593, 19600, 17085, 37605, 1987, 17383, 31591, 29848, 24518, 18882, 18857, 27218, 5783, 14018, 34427, 28152, 1247, 10749, 27431, 13833, 21054, 39982, 7738, 5952, 30690, 20201, 21834, 3683, 28590, 25870, 4368, 19728, 37992, 33553, 17053, 31684, 7951, 35423, 34966, 16733, 12060, 31387, 35269, 1977, 19779, 30236, 27714, 23511, 38753, 12896, 15301, 2759, 25468, 20009, 39758, 29446, 29385, 32014, 14455, 29141, 2135, 11877, 23532, 9900, 30055, 25654, 13878, 39118, 30489, 13474, 4677, 19108, 23435, 37219, 18020, 10299, 7647, 27051, 11566, 37750, 35568, 35794, 24362, 2220, 4382, 33968, 23104, 30607, 8198, 2586, 29000, 7395, 18942, 27373, 11193, 13227, 22276, 38790, 15470, 27961, 3531, 37198, 12470, 14840, 28340, 6269, 37125, 39151, 23443, 29143, 5786, 10591, 30788, 9789, 3627, 22379, 37342, 31915, 27883, 26252, 5548, 13456, 11401, 23433, 10681, 10807, 33501, 18860, 12083, 30984, 16890, 3884, 13288, 34394, 924, 29849, 22529, 39642, 2592, 13583, 23325, 24958, 32962, 38954, 3901, 31523, 35448, 5101, 25953, 14659, 4620, 6565, 32375, 17303, 13120, 16946, 23408, 28829, 6957, 33154, 1318, 7299, 2967, 7000, 17979, 1548, 37601, 35947, 7905, 36826, 18037, 11074, 36601, 14602, 33742, 14056, 17855, 15136, 26514, 14367, 11901, 4031, 8699, 30728, 38598, 11422, 13775, 5760, 406, 14929, 5261, 17733, 22433, 21992, 23945, 28649, 36452, 15966, 31624, 27626, 28550, 20110, 30635, 34156, 23389, 11749, 13600, 2868, 3244, 11738, 23103, 28774, 2159, 24134, 36689, 11408, 11038, 20638, 501, 26119, 22316, 39736, 19559, 32999, 35479, 27868, 26128, 12107, 28176, 29159, 19159, 24219, 37549, 3017, 10257, 37730, 8523, 23080, 12501, 3928, 9599, 30428, 30859, 30755, 1537, 21096, 36085, 25221, 12888, 11979, 18074, 22168, 27753, 117, 16854, 11030, 8396, 37926, 19482, 32884, 5707, 34686, 26408, 18557, 33386, 21304, 31326, 18776, 33812, 4086, 25718, 3547, 6903, 24091, 19870, 22910, 31178, 34892, 33301, 15305, 22141, 15047, 11705, 21462, 7073, 20642, 11607, 1290, 37297, 33471, 34015, 38146, 15210, 2715, 29250, 24601, 31679, 28208, 21728, 4070, 30342, 2854, 37882, 37317, 17325, 35579, 6812, 2465, 13726, 5479, 38734, 272, 7992, 29504, 22547, 22661, 2793, 28143, 35222, 6168, 5311, 35362, 2789, 19563, 1917, 9623, 4051, 12136, 15588, 13750, 11035, 22781, 30418, 16538, 3529, 11104, 13243, 33860, 18923, 13482, 34085, 27695, 11577, 17148, 39654, 17676, 36773, 12049, 1178, 12068, 3387, 20154, 6764, 8590, 32290, 19190, 13626, 39275, 30518, 39945, 34313, 33506, 14148, 35350, 14504, 26662, 17876, 24434, 3862, 27612, 31668, 10725, 12120, 13981, 17052, 19923, 35291, 18164, 34544, 39750, 28739, 10253, 4797, 29763, 10423, 236, 35512, 4419, 30684, 25767, 20219, 32, 22094, 11977, 21569, 14771, 26735, 20775, 31931, 17853, 29061, 39018, 27160, 31576, 32397, 32390, 35771, 39486, 28085, 13918, 37394, 3756, 15326, 38068, 20839, 6017, 3589, 1734, 34153, 12116, 2704, 14061, 29596, 36457, 13672, 29916, 38713, 24740, 36861, 24077, 15095, 34457, 26919, 11191, 25027, 11569, 20520, 35012, 4958, 39013, 36490, 12031, 33504, 30208, 985, 11245, 12167, 32364, 14559, 10837, 21215, 18505, 26817, 11010, 14471, 18200, 14576, 7014, 5644, 12011, 28491, 34068, 33891, 18361, 19236, 35088, 6625, 4546, 36618, 8467, 21978, 4798, 21520, 10612, 12715, 20995, 33762, 34721, 13693, 30970, 38472, 28836, 3397, 24544, 24979, 39368, 25549, 2574, 35436, 1735, 35738, 21375, 26879, 14151, 14213, 26437, 11848, 24204, 19549, 34408, 12977, 29128, 7654, 23299, 13957, 20862, 11434, 15572, 18822, 39089, 8882, 25365, 26345, 11512, 18240, 19879, 9150, 21242, 28569, 29500, 25658, 34634, 30653, 30839, 35173, 481, 34823, 9125, 35695, 18873, 10692, 35064, 17937, 38821, 23093, 27942, 37668, 21231, 18072, 17599, 30858, 27875, 13987, 31319, 25799, 37486, 29670, 34662, 6967, 15780, 5743, 9571, 20661, 34987, 19882, 20708, 35467, 36198, 14072, 4914, 12217, 14474, 17521, 12249, 26199, 18002, 23789, 28770, 12314, 23656, 5093, 37811, 33305, 38492, 19414, 37197, 21522, 15963, 34499, 37390, 4263, 1431, 29904, 15657, 30305, 17723, 39584, 23753, 26081, 39305, 14796, 15644, 18586, 27782, 30197, 5387, 26108, 39911, 27590, 27169, 34981, 10302, 265, 6911, 22487, 3161, 10892, 33747, 14941, 35943, 12496, 19027, 38349, 36587, 5271, 25350, 26714, 19197, 11362, 3117, 27583, 3515, 10719, 2205, 13465, 23867, 8973, 8153, 14950, 17350, 16203, 22326, 12090, 22818, 38162, 19965, 37122, 34319, 36853, 10683, 20653, 29856, 38867, 22816, 25765, 37178, 36993, 31649, 33344, 21433, 23658, 5509, 5767, 18337, 8957, 5325, 37488, 7173, 33203, 7465, 27817, 38031, 11509, 23742, 31214, 7965, 12425, 8974, 9201, 21651, 32288, 38561, 5008, 4575, 4227, 31536, 7058, 20476, 17613, 13374, 39054, 4406, 29461, 20058, 11699, 17816, 36699, 22147, 1728, 10724, 20072, 8154, 36957, 20556, 34500, 23904, 32960, 22650, 38816, 1558, 31888, 7138, 3429, 35488, 13300, 13664, 36608, 19084, 29653, 6428, 19460, 26413, 34369, 37748, 17715, 38419, 33002, 38673, 36956, 9365, 34889, 21074, 7533, 37749, 20344, 31544, 29651, 34458, 34725, 23450, 22756, 15737, 27308, 5563, 38003, 3846, 24090, 39497, 23205, 2599, 38533, 36495, 3537, 12910, 33856, 6570, 7039, 27847, 24517, 12017, 19828, 12427, 3394, 19045, 27681, 7615, 38246, 26955, 14912, 29323, 36614, 30547, 10512, 26378, 31967, 21341, 27927, 16131, 21099, 2090, 35379, 21935, 27957, 38923, 30531, 4005, 35830, 35018, 31096, 15028, 8641, 10872, 20735, 11638, 36341, 15645, 19224, 37395, 28210, 23606, 13637, 36402, 38819, 29448, 38760, 16927, 30779, 32256, 7799, 30281, 22530, 2103, 24060, 16924, 1995, 34084, 15212, 11685, 2240, 37614, 29621, 12893, 12442, 297, 3085, 14260, 15214, 38085, 2328, 10027, 33171, 38528, 35878, 7164, 15911, 1206, 13246, 14259, 2928, 5709, 33536, 37464, 34796, 15874, 8378, 25264, 8667, 23159, 19784, 35031, 13168, 21756, 9828, 14107, 983, 1055, 32593, 19988, 26112, 31666, 14139, 35029, 20178, 10635, 21541, 36788, 37433, 7554, 12108, 35630, 36417, 27495, 24399, 33500, 7224, 2851, 9532, 24769, 23157, 13852, 11367, 31842, 13760, 8791, 2157, 24800, 24207, 6206, 7005, 4845, 14943, 36637, 34717, 17462, 12383, 2298, 23983, 9895, 21954, 39422, 31629, 11747, 10963, 3303, 303, 17130, 10516, 34183, 37338, 24629, 36949, 17684, 12884, 2033, 32480, 11932, 4740, 32023, 16888, 30133, 24841, 28562, 23071, 6804, 4157, 2495, 352, 1325, 17250, 22537, 28986, 29774, 11467, 7170, 8781, 38101, 33893, 19181, 11580, 35991, 19221, 14073, 27486, 957, 23114, 16284, 4704, 1244, 26395, 39545, 19052, 4951, 11431, 33320, 32683, 2838, 35791, 10186, 27989, 35099, 31101, 35874, 30706, 36065, 24335, 37330, 25565, 25961, 31287, 13547, 24421, 11450, 17172, 35475, 20247, 34967, 19205, 13067, 4870, 29659, 39230, 7796, 14538, 8611, 31123, 26841, 454, 5947, 33706, 10644, 36074, 33449, 12438, 25137, 13823, 5082, 25774, 11601, 21559, 39334, 12800, 22069, 33973, 4744, 5120, 18673, 7230, 15050, 772, 13151, 5202, 22886, 9974, 24237, 18836, 7967, 23115, 5882, 34754, 24759, 28068, 4183, 27841, 7371, 19893, 2229, 17875, 9225, 26852, 36160, 39499, 33816, 26402, 16037, 13617, 6161, 14561, 39840, 34326, 13180, 31200, 34105, 23601, 23614, 5400, 2296, 747, 28216, 36854, 27915, 5471, 39438, 12303, 38271, 31720, 27852, 24654, 38014, 22446, 39862, 3527, 18598, 32045, 22407, 36353, 16514, 33539, 31255, 27379, 24455, 1552, 16715, 13736, 24837, 18823, 21198, 22238, 13845, 11968, 753, 6882, 1533, 24138, 34923, 511, 14206, 16076, 12743, 16447, 4538, 17355, 4024, 8995, 29565, 3230, 95, 25680, 27288, 38369, 5844, 9314, 17406, 16082, 16543, 30794, 27191, 18114, 19328, 6978, 18914, 20567, 9500, 1025, 34932, 13665, 3934, 33371, 17854, 32444, 590, 11729, 28813, 39044, 28724, 10735, 35502, 22978, 6773, 12431, 38145, 18695, 23968, 29524, 29868, 1336, 35176, 33793, 14062, 10044, 13686, 31047, 31244, 18637, 13301, 9313, 2111, 19797, 26039, 22363, 11256, 16017, 2818, 28019, 33598, 8674, 3972, 21127, 8813, 26734, 19930, 33188, 30126, 28790, 36929, 15960, 30476, 10973, 15360, 4623, 16918, 29963, 37809, 24081, 29059, 22920, 275, 35725, 38023, 25229, 20150, 29260, 12918, 10389, 6806, 38321, 16442, 31336, 4906, 26903, 30823, 26207, 28174, 26251, 19397, 10273, 30965, 39531, 14435, 13739, 8495, 28372, 7954, 2690, 23471, 33117, 1112, 7274, 35966, 24987, 22597, 2881, 28229, 20048, 25858, 3663, 13057, 35836, 23108, 33485, 28663, 13779, 3382, 22739, 22375, 39850, 12130, 3142, 38643, 20948, 24803, 5817, 34869, 268, 1581, 38514, 28329, 9290, 10952, 17746, 21070, 26496, 38858, 25678, 14518, 5362, 7964, 26115, 38635, 30176, 35726, 39890, 33238, 38260, 3060, 20209, 5618, 35048, 37102, 30031, 34842, 32831, 23616, 8148, 31219, 8615, 1986, 11, 11157, 18922, 10100, 8171, 3171, 3281, 14692, 8170, 23897, 9758, 17924, 27427, 10128, 32862, 31878, 14563, 30978, 30537, 8902, 4788, 17821, 26218, 12952, 36544, 22165, 37296, 32546, 39434, 13822, 32465, 6263, 20761, 6445, 6833, 20628, 17553, 39765, 29042, 28334, 29721, 38755, 39059, 27789, 11943, 10447, 3139, 27508, 27343, 7761, 21648, 8213, 18496, 30837, 969, 38894, 9888, 25211, 37515, 7955, 10851, 26385, 20623, 9541, 11472, 24627, 35228, 21739, 34496, 24314, 22729, 739, 18548, 13122, 13955, 6283, 28018, 27091, 4922, 27967, 36815, 319, 27880, 9406, 16581, 2810, 37965, 33294, 3719, 22871, 8540, 35248, 7244, 10349, 21698, 20373, 18928, 16019, 8282, 15617, 26205, 1267, 35466, 14234, 16120, 30379, 1365, 24787, 27174, 4612, 34350, 31135, 28306, 4458, 3761, 28144, 18764, 35273, 9845, 25825, 30030, 36987, 22451, 2008, 25142, 5070, 35706, 35290, 14798, 23484, 12440, 25603, 18871, 1030, 26141, 32658, 2101, 37532, 39073, 14240, 11285, 9961, 18540, 4776, 38462, 9685, 11664, 16788, 6246, 11676, 5755, 34602, 9904, 26446, 5062, 14829, 20351, 6404, 29983, 11357, 5448, 34708, 7054, 10198, 22330, 24694, 16933, 4347, 35111, 32144, 19947, 6522, 33953, 5357, 21441, 8719, 23348, 38890, 18485, 3940, 1778, 14198, 20366, 11590, 20957, 15180, 4365, 21465, 36189, 21411, 30251, 11772, 35023, 7394, 25622, 11105, 35166, 26518, 20294, 28055, 12300, 32939, 24238, 18102, 1915, 38609, 1302, 16052, 14756, 9760, 27513, 6721, 37345, 15139, 7239, 5950, 23633, 5333, 36591, 5727, 26904, 39431, 32646, 34103, 19793, 15492, 5973, 33950, 27192, 11321, 15075, 23419, 28525, 27940, 28091, 2413, 11453, 8103, 9366, 8052, 13438, 8132, 18385, 16845, 17241, 24384, 14918, 8539, 2288, 10718, 18321, 18388, 3800, 24033, 24715, 17849, 17070, 28936, 26835, 1547, 21582, 31603, 29435, 6084, 32888, 3034, 9640, 3409, 11263, 1238, 8586, 6491, 27448, 14178, 17385, 26587, 28975, 4210, 1919, 20477, 33790, 6453, 17702, 39348, 23224, 805, 17357, 17981, 19443, 9149, 34770, 34388, 29293, 25905, 13071, 31044, 29964, 8419, 21787, 30035, 10616, 20159, 14486, 14932, 14582, 4442, 7053, 19458, 32076, 36354, 27865, 10540, 3760, 24271, 27778, 31192, 9033, 11071, 25847, 11682, 34192, 10529, 315, 13444, 27388, 4663, 25411, 29686, 14467, 18585, 6950, 39615, 30466, 32998, 7895, 31419, 21227, 19074, 4495, 39684, 32461, 21876, 24296, 13660, 13036, 31296, 37919, 27804, 4259, 27663, 18813, 23406, 18463, 18688, 39646, 39247, 6876, 10362, 21565, 34179, 28004, 13582, 39977, 18210, 20274, 23661, 27800, 3799, 27216, 15462, 2330, 11404, 9402, 22358, 39285, 35918, 10853, 32617, 18314, 24409, 33045, 15772, 36083, 9690, 27951, 36668, 10331, 20251, 6408, 21241, 25910, 6511, 10713, 8203, 2997, 19757, 26063, 12450, 1473, 30095, 6073, 32834, 17954, 18028, 34042, 38425, 13087, 16692, 11978, 3608, 3538, 12991, 30276, 15086, 32190, 20925, 2642, 17688, 7115, 16656, 5805, 19330, 3522, 25609, 25076, 7295, 22235, 1158, 20880, 1809, 37673, 17032, 7885, 33931, 14103, 21344, 35976, 17211, 19365, 15765, 25308, 26432, 31294, 9624, 18422, 5552, 10374, 22623, 38379, 921, 24027, 36244, 7745, 17645, 23590, 14097, 908, 33979, 14154, 38071, 10712, 4469, 15114, 16079, 28119, 4616, 12228, 26746, 16249, 7982, 2115, 435, 25550, 38225, 25103, 36633, 777, 19529, 31141, 10645, 38546, 34348, 20417, 10460, 12128, 31669, 26489, 34508, 1886, 9704, 12472, 31499, 27162, 23834, 37842, 19304, 5183, 32024, 9179, 26898, 27532, 10824, 28942, 24245, 31981, 6607, 3358, 24606, 36673, 6251, 28877, 16374, 28156, 28773, 25406, 27559, 27895, 17889, 37469, 36507, 36954, 27393, 7610, 32543, 25562, 26766, 37478, 32532, 33756, 23248, 29033, 37792, 3474, 29244, 13314, 399, 22896, 13979, 10037, 34769, 1402, 30355, 5854, 37346, 12690, 3459, 21476, 9186, 12827, 34247, 16552, 28234, 29251, 28279, 23574, 32951, 10662, 3907, 21085, 28289, 33043, 28092, 27434, 38798, 20744, 38802, 7250, 38173, 12601, 17231, 36873, 1736, 5746, 2401, 35254, 20554, 7532, 1343, 26244, 5691, 39257, 33019, 18166, 14365, 14276, 27952, 7685, 20078, 9051, 5141, 19553, 8706, 38417, 26291, 34001, 19311, 28730, 30307, 13105, 10886, 38268, 22559, 12835, 23518, 11804, 27399, 10909, 36744, 25745, 993, 284, 22633, 11217, 34684, 6694, 10839, 28560, 2549, 20959, 33391, 21643, 24561, 12904, 21489, 16174, 14043, 26373, 9716, 12930, 22685, 15018, 534, 13788, 29733, 8288, 29939, 16011, 25346, 20547, 7037, 6739, 9670, 8714, 31249, 39331, 32875, 12436, 5388, 13311, 20491, 4411, 18323, 25679, 15853, 22681, 32092, 26889, 32418, 11687, 18154, 37152, 22336, 27979, 3820, 9331, 15356, 28682, 22224, 22121, 8889, 19329, 36444, 7824, 37686, 25029, 13480, 19377, 28897, 30419, 21653, 33489, 5560, 3595, 13515, 14763, 22645, 26233, 5704, 39047, 23346, 3195, 3876, 28985, 25913, 21827, 23303, 33581, 37574, 10690, 13866, 25203, 24425, 29973, 11377, 13765, 5741, 21333, 15985, 5955, 12460, 24039, 13811, 7833, 25475, 1719, 9077, 28980, 6800, 30558, 1920, 7680, 20466, 8505, 14064, 15786, 27182, 6699, 25663, 19596, 16978, 38929, 6744, 14083, 12760, 15926, 14852, 16861, 66, 10688, 20655, 23664, 6111, 34214, 32125, 23567, 34344, 6575, 13743, 34782, 28956, 38511, 17444, 39509, 39741, 7380, 30383, 14457, 6801, 2930, 8809, 2903, 37078, 7904, 16334, 12997, 15889, 19609, 31871, 31161, 37516, 14202, 5893, 33767, 122, 28992, 3986, 39926, 13436, 3259, 5522, 31078, 14920, 37186, 25266, 19246, 25561, 25118, 26232, 37801, 3241, 27031, 18615, 3808, 38213, 12183, 5342, 36003, 16723, 10592, 6649, 16241, 14106, 23240, 1501, 33040, 12983, 730, 20890, 13848, 36216, 2203, 6502, 29641, 36650, 12787, 9713, 13824, 34592, 4761, 21531, 30773, 22917, 8642, 34473, 5776, 12617, 11906, 13883, 487, 25313, 24146, 14767, 27674, 769, 773, 36754, 36527, 12430, 25361, 24585, 28305, 19578, 10887, 39469, 24975, 25115, 29024, 13619, 11973, 39789, 31656, 971, 3151, 22953, 34352, 9075, 12153, 39566, 18904, 2894, 27402, 18204, 35306, 18145, 1635, 23579, 8941, 8968, 30517, 5756, 13679, 16102, 10565, 9497, 2061, 22810, 6632, 29543, 27664, 11022, 18806, 12767, 19853, 23959, 1062, 5483, 37241, 37355, 11593, 34660, 6086, 24633, 7686, 8509, 3921, 9889, 16230, 3193, 31165, 35652, 12423, 35796, 31936, 896, 24479, 25682, 34581, 37146, 25404, 9334, 39951, 37898, 39601, 39540, 6049, 35397, 29165, 32242, 19415, 3360, 34497, 33340, 4330, 15056, 9531, 36002, 38927, 23756, 8022, 8345, 10845, 37511, 1322, 25127, 37610, 31450, 10917, 32704, 31266, 29378, 14884, 17604, 33490, 2706, 15140, 23930, 5840, 29426, 17625, 5634, 29264, 39032, 5314, 20120, 27284, 26543, 20393, 23354, 32917, 13767, 25232, 38274, 18610, 39818, 10300, 597, 8254, 10284, 21776, 18260, 39065, 24998, 28826, 39846, 14174, 30572, 19773, 208, 20962, 417, 30873, 28901, 5867, 4383, 10927, 25804, 29642, 13546, 25743, 8126, 25062, 13026, 19917, 14933, 21811, 19, 35762, 30043, 2165, 2980, 39958, 25419, 15366, 18118, 8688, 13992, 35767, 5480, 17233, 13384, 11890, 22280, 21596, 34808, 26117, 30703, 12200, 37759, 36351, 20067, 35781, 31658, 9959, 20934, 23921, 6362, 34008, 17121, 25571, 20257, 32882, 4937, 26758, 33971, 22546, 29535, 14130, 23202, 18139, 3962, 35681, 39355, 31606, 31518, 33623, 6131, 16809, 8643, 31272, 33227, 32114, 14938, 5816, 3604, 16144, 26449, 24423, 33832, 12180, 4617, 22742, 18866, 3914, 16402, 29720, 36236, 9650, 33116, 25067, 10852, 17731, 7161, 21103, 33221, 5028, 8325, 29289, 24136, 15064, 32564, 28921, 7403, 29181, 19640, 6803, 9554, 310, 20436, 21294, 8606, 705, 28579, 16388, 31215, 31911, 22356, 35199, 16232, 950, 1200, 10314, 32467, 36144, 26357, 768, 31370, 30462, 35170, 18770, 19713, 34803, 24582, 603, 30453, 26203, 32140, 9377, 30066, 23002, 10212, 21277, 36062, 39724, 4529, 39516, 7984, 10940, 6347, 5931, 25780, 16529, 17584, 2487, 26649, 17989, 28056, 17751, 3026, 14764, 12599, 31115, 33824, 22813, 31245, 14777, 22922, 5736, 33670, 16969, 38764, 30156, 29570, 26549, 22960, 36770, 9045, 33766, 13266, 25362, 36905, 12700, 36298, 1693, 27302, 34546, 36645, 35945, 24221, 13441, 16891, 28386, 21910, 609, 3844, 15192, 31877, 33206, 18198, 7099, 11846, 16393, 16926, 36550, 28806, 30542, 19270, 1749, 20025, 35197, 24116, 3599, 9119, 21774, 5769, 23971, 10068, 36315, 35958, 7090, 20807, 22263, 3634, 17792, 36736, 31009, 24865, 33582, 7511, 20645, 7706, 28273, 23836, 27587, 13805, 4048, 11368, 14785, 11794, 10715, 21845, 14820, 15387, 7142, 39008, 5780, 17322, 33763, 28408, 19188, 31082, 3787, 28074, 1616, 31757, 11491, 12076, 27320, 31926, 22247, 68, 33409, 23989, 23117, 18282, 16603, 9826, 656, 37341, 30784, 25124, 1857, 14674, 22965, 7397, 27511, 15606, 13882, 17117, 23770, 29191, 1851, 3446, 2366, 30816, 28880, 27335, 4825, 12494, 1980, 19134, 26047, 38186, 5005, 14369, 14408, 10820, 32876, 25161, 18372, 31596, 33554, 12071, 36041, 28084, 11129, 36995, 29661, 6698, 21263, 543, 35194, 12347, 31012, 9329, 2306, 32966, 19973, 20113, 1421, 27806, 32458, 23866, 4638, 11818, 1497, 9084, 25802, 35264, 23056, 9518, 17634, 9298, 19619, 2249, 21049, 4440, 23170, 11118, 1862, 21364, 2494, 17826, 10059, 5175, 30555, 25098, 20766, 8150, 38258, 22830, 38372, 21208, 23896, 13219, 34527, 18564, 7045, 15034, 13051, 29242, 8587, 15413, 9322, 28714, 24647, 6542, 2584, 29064, 20372, 39568, 23163, 15005, 34831, 9344, 13745, 35110, 15085, 36538, 12258, 16959, 9538, 365, 18798, 6745, 6186, 29247, 20349, 26621, 6461, 36860, 37781, 32985, 32871, 31189, 11620, 29494, 15614, 33726, 37263, 18728, 32366, 29400, 23232, 26342, 11974, 9361, 29734, 15851, 21139, 11914, 39325, 27632, 11900, 35672, 13689, 9582, 1146, 13169, 21312, 30188, 2177, 16053, 489, 7946, 39193, 15435, 1093, 33345, 2404, 19683, 21490, 36700, 6992, 19295, 4475, 31639, 14528, 22160, 15743, 23266, 16, 8640, 18952, 2325, 38857, 524, 14094, 32566, 11012, 14960, 11616, 26659, 38768, 2803, 6865, 28864, 34181, 15941, 11952, 25374, 39176, 456, 4701, 30224, 27693, 22194, 15914, 23171, 36307, 18802, 2953, 25339, 30576, 6343, 26488, 1305, 23961, 19856, 12984, 38911, 3790, 8830, 36958, 10582, 18553, 27328, 28526, 2055, 20495, 32919, 35226, 21996, 5356, 21450, 21906, 8169, 27159, 34935, 1789, 6045, 6596, 26255, 33615, 19618, 16875, 6881, 6127, 21276, 34341, 37920, 21108, 11028, 1298, 14249, 4139, 27501, 33289, 20804, 21252, 17256, 6172, 2357, 27535, 36468, 6958, 26791, 34228, 34488, 2224, 25717, 14399, 22312, 38360, 18481, 20731, 22399, 11561, 1968, 26668, 39386, 28757, 33378, 6902, 30633, 7778, 22098, 19491, 7079, 6605, 24631, 32572, 37233, 33179, 3893, 39333, 16027, 31265, 20709, 12274, 12711, 7656, 11805, 26968, 37960, 8923, 39397, 31290, 38197, 30821, 28477, 13124, 7082, 18296, 15564, 3895, 19018, 2628, 27916, 28620, 15496, 15866, 5529, 28544, 24100, 2138, 23048, 18997, 18375, 11444, 472, 16301, 854, 2889, 5340, 12663, 17402, 34314, 39880, 37782, 20402, 38499, 18171, 3194, 38240, 25230, 38352, 3041, 19114, 19726, 10052, 36205, 23095, 33375, 34474, 32651, 31366, 27923, 3296, 8558, 36164, 15518, 39585, 6113, 39459, 24322, 22557, 26513, 17938, 3464, 39656, 6738, 28202, 28535, 18161, 31721, 35367, 4793, 10934, 7812, 17799, 6667, 33162, 20671, 8217, 18925, 8113, 4579, 39425, 37971, 20388, 21819, 12133, 15585, 6403, 26770, 13396, 14226, 4449, 35702, 24052, 28252, 8922, 16792, 37583, 24311, 27757, 127, 37738, 4277, 21015, 10534, 19269, 7504, 17163, 3645, 11507, 19695, 24417, 34547, 11581, 27054, 20788, 11934, 24915, 18650, 13768, 2181, 33980, 32347, 39407, 2022, 1640, 30595, 27309, 12455, 6061, 6598, 35318, 12435, 34094, 13968, 11382, 12816, 30771, 14797, 14647, 12691, 24682, 7070, 35246, 29710, 15791, 5944, 16197, 30674, 19007, 39181, 20161, 11418, 6618, 4402, 14114, 7208, 37098, 17386, 15820, 26420, 19868, 27473, 29274, 26366, 31035, 28446, 16220, 1327, 5986, 7592, 11972, 9190, 38596, 12847, 37262, 35890, 30348, 26116, 19905, 22176, 29348, 13534, 15369, 29055, 29266, 33401, 9448, 16290, 25310, 15133, 24569, 7763, 757, 23147, 26844, 16709, 8663, 8645, 27563, 37908, 16352, 33603, 20613, 11600, 26954, 30761, 20100, 5858, 11787, 34230, 20563, 27296, 954, 578, 8047, 14391, 38236, 29199, 22988, 8906, 21677, 34899, 24805, 2133, 13924, 4278, 35937, 30711, 10396, 25359, 7171, 4762, 24541, 16957, 18851, 20836, 15211, 38280, 38648, 23352, 3732, 5508, 9572, 34354, 2440, 39725, 37502, 7352, 16141, 33379, 14086, 12291, 10353, 8689, 10958, 2039, 12014, 997, 4729, 28896, 31400, 28646, 8874, 32826, 38545, 22477, 18892, 33307, 35996, 12420, 25095, 17217, 21109, 29005, 14096, 13241, 20760, 9215, 20612, 20540, 7325, 21704, 1338, 8330, 14841, 38547, 37461, 6382, 30286, 33752, 14942, 32295, 6608, 19036, 37904, 17016, 23077, 3735, 19889, 30749, 36547, 6944, 3129, 28997, 28200, 4892, 1827, 30297, 26038, 6023, 2527, 17191, 8751, 31420, 11042, 8475, 37154, 930, 36728, 34582, 30567, 9071, 18835, 7785, 10230, 27339, 16868, 26909, 12577, 22169, 27607, 1361, 8778, 16453, 23707, 4437, 18852, 18739, 33838, 21777, 15494, 27772, 38315, 279, 24511, 10130, 17075, 36399, 11194, 563, 12024, 27077, 39506, 1346, 20795, 4641, 1598, 5442, 28517, 35443, 20927, 6927, 37264, 4349, 34070, 31488, 36597, 98, 16779, 34736, 19906, 15242, 32891, 37941, 1437, 29625, 17198, 16541, 37162, 18981, 1725, 10697, 9285, 12459, 21547, 32339, 4198, 23548, 2782, 11788, 27670, 37561, 34557, 29049, 9368, 18441, 11904, 23128, 3364, 29071, 31975, 29668, 20270, 30420, 24675, 23136, 10950, 6174, 22595, 8165, 23290, 18985, 10968, 5586, 8277, 9414, 931, 10701, 30835, 20939, 70, 13113, 24491, 19751, 24892, 38716, 10055, 24917, 27976, 2654, 26927, 17379, 39142, 40000, 37386, 27021, 6626, 2792, 32058, 7310, 15519, 30924, 17597, 1559, 4664, 24291, 21092, 31899, 34903, 23558, 15568, 1753, 3721, 32373, 6587, 29352, 8770, 24784, 4376, 31394, 22208, 24571, 38184, 34372, 4067, 16717, 4801, 17668, 33592, 29254, 39296, 33877, 25914, 1700, 29399, 26298, 5264, 898, 17581, 24145, 12337, 2638, 13526, 33081, 4176, 19393, 24368, 37101, 27224, 36568, 22322, 4615, 9619, 28608, 39577, 36968, 23738, 32232, 29703, 9994, 31533, 25687, 11039, 1625, 14819, 2072, 34477, 29040, 34541, 33560, 28028, 39113, 23520, 35293, 26943, 224, 9151, 23191, 15417, 34580, 17856, 7418, 21792, 23634, 37336, 38498, 28524, 28740, 16506, 3272, 17371, 39754, 9953, 19538, 11011, 84, 30931, 12469, 18968, 17718, 31575, 17829, 33903, 26681, 30385, 25300, 24303, 33138, 4508, 8014, 25021, 13010, 628, 20603, 31808, 29354, 13400, 10280, 38966, 32853, 11755, 34519, 23014, 25600, 35604, 16991, 35109, 14279, 14383, 32676, 38786, 18331, 12615, 9858, 18840, 26944, 1642, 13657, 16644, 9950, 7399, 3600, 3254, 30499, 8639, 17955, 38656, 12123, 37525, 12250, 24019, 25258, 12995, 25737, 26127, 31932, 2615, 38059, 12562, 19547, 7421, 10355, 4871, 12758, 29706, 18307, 1701, 19077, 27026, 13066, 32798, 21118, 13451, 27921, 21609, 39265, 21360, 33124, 15067, 20815, 34208, 9894, 9579, 13416, 28534, 24859, 5533, 24536, 8624, 29816, 22171, 34646, 32927, 28852, 29219, 22443, 19727, 33105, 22566, 39636, 20399, 2939, 31503, 33434, 32027, 29203, 18480, 26614, 10482, 5184, 5583, 4355, 19254, 31327, 7898, 28685, 36076, 27525, 24676, 28063, 19080, 4626, 29306, 4078, 26035, 35265, 28366, 18289, 7536, 27691, 27893, 22277, 38515, 36705, 30541, 21986, 34030, 30735, 35077, 6139, 32544, 9286, 36327, 27022, 24102, 20950, 33397, 9217, 35703, 10830, 36832, 34670, 31555, 16734, 9514, 11828, 25790, 12619, 8468, 6367, 31065, 18937, 2697, 22864, 31785, 3737, 18351, 2176, 31830, 8030, 29386, 36786, 17665, 23512, 29533, 1006, 1337, 7351, 33974, 35724, 26790, 25149, 23158, 18433, 32800, 20329, 3367, 22122, 12225, 886, 3677, 33894, 30968, 17577, 1870, 30262, 38163, 20549, 22475, 29022, 33470, 17870, 32605, 16687, 37492, 26032, 22525, 12702, 8185, 2136, 24757, 35263, 20854, 8193, 15092, 11751, 28231, 37323, 36305, 25849, 5851, 22179, 38096, 3291, 10249, 10168, 17943, 34722, 1367, 38476, 12688, 31305, 26871, 30675, 39502, 15093, 35717, 1575, 26815, 8844, 25168, 39124, 2907, 295, 23488, 33999, 6798, 21321, 32226, 38035, 30461, 24397, 28170, 31208, 36114, 25826, 8817, 6092, 4878, 31625, 21874, 1708, 21335, 12336, 21101, 35380, 38686, 23793, 11515, 27360, 37820, 23378, 21052, 32653, 12187, 29561, 16024, 6567, 30078, 12761, 33632, 31322, 17265, 1787, 15293, 16622, 20221, 18430, 34879, 3175, 11185, 33809, 4644, 33459, 27613, 10704, 22289, 6711, 35927, 3059, 8831, 15707, 29794, 21386, 11660, 5632, 4535, 20309, 27716, 18149, 37697, 39714, 14630, 34381, 14020, 15601, 13669, 32332, 7260, 12222, 24232, 23126, 1717, 30697, 5260, 19480, 11595, 19405, 16631, 2151, 31965, 30663, 34858, 9383, 28082, 8404, 4853, 5129, 7792, 19360, 24973, 38215, 8736, 20260, 5729, 10708, 8357, 26143, 38112, 1252, 37484, 4606, 754, 34238, 23212, 8402, 25863, 9461, 19897, 36323, 38879, 16200, 27437, 14436, 39612, 36847, 23190, 25354, 24667, 12976, 6821, 24120, 7888, 33529, 9459, 39872, 33507, 7117, 9719, 204, 20512, 9891, 33820, 39618, 28371, 30353, 22680, 30861, 11388, 39927, 9757, 32663, 11681, 7756, 13844, 15268, 92, 6443, 1269, 20790, 5098, 27627, 33880, 38951, 10935, 2348, 13390, 20978, 6628, 24951, 15510, 28159, 12463, 27862, 11605, 13472, 17879, 20736, 11885, 32309, 21287, 37862, 24737, 15258, 7678, 7416, 39921, 3002, 29239, 11305, 2058, 29419, 37293, 30198, 9066, 5229, 23797, 13584, 34777, 17320, 6213, 34403, 26280, 38125, 31564, 26650, 1592, 8940, 21652, 9897, 22951, 28005, 13197, 36295, 37682, 4685, 38625, 24690, 33423, 18741, 13455, 9392, 11302, 32120, 26881, 14368, 15060, 30083, 22858, 5475, 1896, 22378, 39743, 33587, 16295, 32630, 21644, 35096, 7427, 3833, 22381, 24343, 20657, 25691, 12843, 35644, 31146, 19032, 8168, 37111, 7454, 1940, 12451, 15850, 15376, 21759, 6996, 36570, 21355, 153, 24216, 32902, 24175, 26068, 13316, 5721, 37944, 12571, 34390, 26600, 1712, 7088, 29353, 33509, 24327, 6623, 9274, 12223, 34053, 6238, 39647, 10539, 39278, 32515, 8870, 5785, 38148, 19400, 13719, 32313, 28060, 29144, 15672, 19410, 9060, 748, 10760, 20967, 10878, 35457, 35760, 17058, 37329, 966, 27374, 39770, 7858, 3042, 24774, 7196, 749, 19300, 30659, 31029, 34613, 2020, 26318, 36932, 33328, 28913, 26703, 28930, 25167, 20206, 29205, 28107, 8846, 27946, 36844, 37589, 4542, 36058, 29303, 32954, 39967, 10281, 26387, 30205, 2297, 27203, 31806, 1044, 34587, 18662, 19520, 8317, 4416, 19286, 36466, 24685, 4289, 25572, 11757, 26076, 6115, 8443, 7255, 22304, 23101, 13894, 9061, 13803, 30604, 20443, 22052, 11451, 7998, 39776, 30738, 1256, 34959, 25708, 12408, 27752, 14270, 1094, 15784, 11944, 31331, 19014, 18795, 3594, 31217, 31507, 12487, 37680, 9067, 32964, 6007, 39916, 30975, 38304, 1313, 35198, 4511, 6274, 27227, 35308, 10966, 33304, 7897, 30016, 10674, 21298, 33191, 19819, 17874, 15840, 12214, 17768, 28753, 32351, 31046, 14476, 23305, 22049, 4097, 4454, 30145, 9464, 23125, 19631, 11123, 14120, 20175, 16846, 35298, 35685, 19180, 19127, 27237, 15656, 17209, 38449, 19938, 21694, 33770, 36978, 39450, 33127, 7611, 18169, 33054, 10104, 30679, 8887, 32441, 13738, 1143, 5038, 28825, 34392, 25260, 13389, 28821, 6546, 18019, 11301, 28866, 31587, 5009, 8367, 29847, 21589, 28059, 12462, 10709, 37661, 11621, 23796, 13658, 16642, 7786, 12422, 12824, 15797, 20881, 11393, 36349, 11981, 22834, 4076, 27270, 33461, 38432, 27193, 19769, 23090, 6304, 31407, 18341, 792, 9233, 23032, 24729, 5774, 846, 37553, 31064, 14138, 14625, 1241, 36721, 11148, 28715, 38040, 24373, 14944, 8596, 33214, 3406, 7143, 19379, 1026, 18801, 30718, 1260, 37393, 16588, 28061, 12064, 22086, 7301, 39579, 26368, 5201, 6928, 5881, 19820, 38667, 23207, 36661, 20591, 24426, 30274, 8916, 12032, 35758, 11558, 1457, 26785, 39985, 30013, 9972, 18975, 5703, 1366, 20873, 1049, 8041, 19504, 8613, 18815, 2104, 28505, 3091, 12384, 9328, 14769, 29160, 1053, 29609, 11915, 6857, 22539, 33858, 27466, 10593, 5561, 26092, 13150, 31398, 29326, 33486, 8620, 4039, 4662, 12558, 38063, 11671, 8458, 15355, 12097, 15750, 8955, 27562, 32696, 3832, 31700, 6834, 25488, 35207, 17627, 9336, 25771, 18246, 16291, 25994, 16705, 28947, 6577, 34168, 20135, 25783, 16438, 15328, 38028, 27196, 4109, 21367, 18850, 31595, 24461, 27997, 29626, 26277, 28709, 25861, 7202, 14123, 23612, 20464, 32548, 33292, 37418, 2110, 35571, 3383, 19852, 35817, 24755, 29758, 23819, 31455, 11331, 4193, 11238, 5145, 12701, 11428, 24884, 13202, 3773, 26167, 7535, 7496, 24470, 38968, 11550, 22039, 22106, 39953, 13558, 21142, 30793, 8958, 1274, 15482, 13055, 12145, 36695, 2406, 16000, 10012, 15330, 30057, 10812, 25207, 25462, 32193, 7669, 36403, 31839, 28045, 25148, 4229, 15283, 16637, 27745, 2447, 6400, 8387, 30902, 20227, 558, 1678, 15249, 37238, 4984, 28499, 15497, 31037, 6416, 26073, 18560, 20032, 34017, 11330, 28798, 28238, 23061, 11414, 9686, 1453, 25328, 6074, 27704, 12858, 39986, 4065, 26006, 1795, 21737, 39076, 38829, 38830, 16071, 36362, 20412, 4493, 33737, 5688, 25865, 37123, 31030, 38353, 4057, 18261, 17544, 83, 6837, 11745, 11102, 20030, 9694, 34218, 26261, 27909, 20352, 32621, 15623, 889, 12468, 22219, 12962, 4141, 22688, 11598, 333, 6668, 3198, 13420, 27639, 29550, 6202, 14981, 9107, 3981, 39237, 5811, 33134, 30920, 2056, 39488, 27145, 29409, 24767, 6754, 10891, 29517, 33321, 19275, 20291, 29209, 27344, 1369, 3814, 11880, 8414, 36111, 14839, 9163, 7231, 15733, 4369, 39869, 3546, 22856, 15038, 8234, 27403, 4144, 30620, 18905, 19198, 1067, 11168, 3062, 39048, 33192, 13570, 7108, 2585, 5989, 23412, 24016, 27114, 16945, 16513, 18726, 18582, 33919, 26017, 25330, 23464, 33330, 6651, 14788, 19023, 32015, 36029, 4323, 20787, 13814, 7751, 35650, 29976, 30685, 22580, 3669, 29809, 7594, 2576, 23824, 19612, 25916, 39670, 13186, 32291, 17434, 23878, 21338, 38597, 3739, 21432, 16929, 35811, 15246, 1941, 14725, 34937, 18556, 37760, 30592, 23721, 7663, 7205, 6118, 26866, 1381, 26187, 10761, 26353, 15024, 9471, 19411, 33865, 9886, 18774, 33754, 11065, 36704, 34263, 31121, 2211, 2633, 15012, 39000, 8749, 2906, 30332, 18306, 31628, 21178, 550, 17477, 16099, 5834, 5031, 37210, 6867, 5608, 37143, 24063, 37827, 19146, 22396, 37047, 18384, 8564, 8584, 27633, 8027, 12640, 13533, 15445, 13447, 12126, 7702, 10005, 38910, 9767, 38690, 35195, 11908, 14288, 31231, 15770, 35792, 21365, 18644, 33847, 18886, 1711, 24209, 35587, 26230, 11659, 27602, 16324, 24240, 24441, 8135, 29429, 22386, 1412, 7757, 3449, 34317, 17538, 28291, 10894, 36339, 22361, 4175, 15744, 25898, 20826, 21555, 6311, 23737, 16960, 36755, 17048, 947, 1921, 6015, 4043, 20086, 34585, 22461, 7978, 20514, 6734, 23852, 15370, 16837, 9839, 25457, 12934, 76, 24949, 6731, 23015, 7782, 22833, 29351, 9050, 12959, 31546, 7646, 36919, 36435, 16401, 11052, 28902, 10422, 6105, 20917, 3166, 3184, 1474, 3561, 1002, 34644, 22625, 4123, 3912, 29804, 23256, 6214, 18014, 547, 30564, 2723, 29072, 17451, 28807, 1408, 31674, 21634, 10911, 28023, 24906, 5990, 32896, 21514, 31298, 2926, 14036, 24712, 32344, 11606, 35957, 29327, 33322, 4468, 1191, 39451, 11449, 2393, 25744, 15316, 1818, 17903, 3504, 17021, 7187, 34826, 25820, 18669, 3911, 33217, 6368, 20904, 18431, 29025, 34625, 32433, 742, 36526, 10311, 5319, 26194, 22841, 15399, 7959, 12733, 31353, 34250, 25666, 28278, 12059, 38480, 33039, 22941, 32714, 6845, 8236, 11635, 33155, 32399, 5500, 6218, 20918, 11423, 27680, 1295, 24467, 17107, 39293, 16202, 5784, 9656, 35214, 22544, 19753, 804, 32533, 17971, 29177, 4032, 33492, 1329, 33364, 28848, 2504, 21957, 1580, 15674, 6146, 18816, 7995, 37974, 15209, 3051, 7137, 13432, 5887, 7854, 11342, 5517, 18215, 14012, 12798, 16988, 14691, 18440, 5719, 12618, 2155, 13541, 21738, 18192, 18613, 23771, 15865, 6604, 23555, 23510, 35534, 26105, 3616, 4953, 6713, 1782, 23177, 29214, 2095, 372, 37169, 17134, 33924, 1231, 19132, 30380, 26367, 2079, 29832, 37886, 28118, 27835, 32305, 36743, 2333, 25032, 38475, 21672, 34946, 32969, 36463, 2745, 31086, 1838, 24698, 7442, 35105, 16616, 9671, 36759, 22223, 27481, 17839, 33641, 38303, 17081, 17691, 19148, 35275, 12575, 22963, 37024, 28233, 2716, 13179, 38709, 37092, 838, 30082, 16015, 12041, 24206, 14792, 17805, 25938, 11037, 27894, 14768, 8959, 37343, 6783, 38650, 18311, 25786, 20128, 10480, 7941, 5126, 37707, 26330, 28564, 14394, 7856, 12480, 36523, 12361, 14231, 17005, 37892, 22632, 1228, 22022, 39870, 28567, 37837, 7259, 2083, 20097, 7999, 24309, 3022, 6030, 30868, 20511, 35574, 30687, 26950, 19851, 13855, 22779, 139, 22934, 33288, 33830, 18158, 20432, 21382, 16730, 15803, 14456, 21853, 17378, 28666, 7555, 1683, 3882, 30088, 2460, 37775, 1973, 30977, 35092, 22497, 13486, 19350, 12783, 30627, 30921, 35765, 30731, 2606, 26854, 38265, 12551, 34078, 1434, 37504, 9177, 29284, 37206, 39398, 23479, 27023, 38296, 8307, 36319, 10627, 32474, 11702, 18051, 21217, 17169, 35175, 20630, 31673, 36999, 12992, 31489, 38026, 26979, 21387, 27471, 26741, 28874, 33527, 2541, 21734, 25836, 8691, 19110, 2656, 32382, 26575, 37379, 39023, 35233, 26204, 20098, 8576, 14511, 2358, 24613, 5099, 38383, 30175, 38137, 34117, 17871, 11384, 37275, 34919, 15795, 13956, 21757, 11741, 37466, 13843, 8129, 15447, 18327, 12424, 6120, 26015, 25812, 26010, 37851, 32311, 12978, 10208, 29908, 32926, 5178, 797, 19204, 28937, 9574, 24986, 36926, 24750, 15609, 22598, 11855, 4063, 16016, 28179, 3619, 2524, 33281, 15734, 26800, 34851, 16787, 17100, 21463, 13222, 16113, 16743, 2127, 3557, 5039, 19594, 10258, 8299, 28240, 28185, 4848, 13939, 26445, 17831, 39697, 37075, 18334, 15348, 29792, 13514, 1020, 22968, 29202, 8133, 36771, 23779, 3422, 33994, 25640, 7319, 11113, 12576, 11723, 36418, 26256, 16812, 8349, 28458, 3458, 17398, 22440, 7081, 10125, 27649, 19584, 25709, 22916, 4830, 14350, 23022, 37828, 25409, 38288, 941, 4719, 26505, 11325, 16195, 32329, 30119, 20865, 27539, 19314, 38269, 14330, 7781, 28262, 11048, 19964, 16482, 35770, 18414, 7593, 1576, 16412, 38746, 14312, 18659, 27404, 1386, 3606, 19461, 8264, 32637, 9726, 22859, 30740, 2831, 27426, 4012, 9303, 686, 24758, 29999, 1639, 28788, 7938, 35740, 38487, 25697, 8904, 29897, 2009, 21573, 7390, 38508, 20343, 12947, 33662, 34891, 26240, 10096, 39245, 37633, 10743, 28400, 30102, 19067, 36023, 19980, 9817, 20652, 20299, 27764, 32227, 4754, 28457, 38058, 8139, 18216, 33684, 16121, 36542, 21500, 30579, 34804, 34537, 30211, 35281, 25514, 38588, 25999, 34513, 2850, 11665, 11851, 36163, 8332, 37033, 15953, 776, 36008, 26031, 14478, 11567, 38183, 16807, 36011, 6858, 38600, 24965, 15478, 13425, 37544, 31589, 29936, 14949, 21035, 9569, 6225, 5647, 34518, 27746, 7699, 28424, 3339, 2591, 17670, 7569, 22565, 26583, 6500, 23952, 17115, 17895, 31349, 23932, 4609, 1761, 11599, 19013, 30445, 14060, 15758, 25964, 23855, 8342, 34991, 33280, 16987, 4240, 18188, 31958, 25438, 5116, 34901, 26014, 12293, 23398, 25674, 28957, 36976, 8843, 29083, 38087, 24047, 30217, 19239, 5835, 39218, 26719, 3263, 29582, 10463, 39740, 432, 11456, 38577, 34583, 14489, 13828, 5596, 13093, 27153, 38677, 37665, 24174, 14964, 9152, 11309, 23587, 5888, 18493, 15814, 29452, 31325, 7485, 31663, 30326, 31535, 25574, 7348, 29290, 31517, 19302, 31105, 27073, 17262, 18081, 35748, 36827, 29057, 2711, 6, 23501, 21166, 3945, 21942, 2471, 25850, 36638, 16994, 30929, 33707, 8343, 22462, 33574, 4916, 39472, 14409, 39839, 25331, 8354, 27232, 24261, 28577, 18353, 24298, 23380, 32738, 16524, 38413, 31584, 14822, 16390, 9982, 5754, 25120, 24918, 5797, 6582, 20813, 8665, 33273, 35834, 37812, 23890, 12070, 18506, 30808, 6066, 6751, 2347, 23778, 38420, 33451, 22214, 37791, 814, 37982, 26953, 1707, 28420, 18199, 33644, 15738, 29113, 20325, 32883, 29169, 25787, 16711, 17759, 5241, 6808, 13097, 5284, 13027, 6014, 11775, 35303, 23280, 4765, 9137, 32136, 19521, 39372, 12362, 15542, 19495, 9178, 29693, 13008, 20886, 200, 20700, 1288, 30889, 2833, 18142, 12802, 12279, 9919, 4672, 35803, 14179, 7095, 13909, 4586, 6275, 36171, 24270, 20338, 5637, 25006, 35384, 3988, 13700, 3192, 5676, 27610, 30886, 9692, 3877, 33882, 12768, 6316, 3550, 15467, 31338, 8237, 8144, 12339, 31951, 35090, 6466, 30183, 823, 6899, 5280, 28410, 1387, 2970, 34295, 35554, 25694, 4675, 18759, 7213, 35478, 27083, 23473, 10908, 17375, 38495, 20966, 17755, 15796, 15766, 36613, 28145, 39970, 10586, 5883, 38795, 21028, 20034, 28435, 32610, 31304, 2314, 20574, 34720, 20374, 29894, 39168, 23041, 38127, 30810, 4594, 38632, 30122, 39093, 5742, 26379, 26016, 21720, 10436, 17190, 3253, 17238, 27008, 5957, 24288, 6325, 2241, 2294, 34936, 37299, 605, 32460, 23252, 35373, 16887, 4055, 7183, 1013, 37190, 7582, 35997, 20029, 7846, 19945, 30509, 31246, 31098, 29227, 6641, 13709, 3968, 29427, 38869, 20980, 3723, 38339, 34463, 216, 38877, 8757, 20536, 25208, 9424, 27810, 19847, 15899, 12829, 32297, 18262, 12252, 39161, 3859, 26531, 22184, 10276, 17869, 9743, 31910, 1565, 9362, 10340, 31425, 27474, 21022, 33686, 22164, 25082, 3554, 27228, 21965, 19892, 38655, 23151, 14080, 22658, 32393, 18202, 580, 20433, 14426, 15618, 8281, 14146, 31594, 2272, 14323, 16328, 384, 36235, 26877, 15823, 38595, 2444, 10617, 2441, 11625, 37310, 36358, 4228, 19946, 12842, 5824, 15760, 31139, 29369, 33708, 20441, 32320, 35369, 21088, 24974, 26468, 6019, 20427, 3584, 21359, 8146, 11823, 5148, 8208, 30127, 21993, 33405, 29417, 7719, 30391, 33791, 36413, 28128, 27357, 33817, 17807, 25454, 22043, 15831, 12703, 20592, 8284, 3508, 9843, 6163, 458, 23485, 33810, 12302, 12385, 17374, 20575, 9755, 37618, 12678, 34134, 18136, 34186, 33150, 26156, 21240, 9020, 24055, 29695, 9072, 14566, 1982, 37247, 10321, 30029, 38952, 10767, 38817, 3055, 39153, 2032, 8801, 36246, 7407, 12382, 2635, 17468, 7911, 33339, 23838, 17292, 7285, 13989, 5375, 38279, 4813, 18459, 20627, 5455, 10941, 36810, 4254, 34072, 8716, 23200, 5444, 22980, 20851, 94, 14936, 39121, 30534, 27089, 18420, 10621, 36177, 4179, 15049, 39519, 36091, 9138, 11937, 12311, 36524, 7603, 15741, 27990, 7531, 37172, 1204, 26697, 28950, 4706, 31286, 32126, 21715, 38873, 11935, 16992, 5484, 18547, 23981, 4698, 12649, 39610, 36947, 24017, 38446, 34539, 20099, 27898, 39174, 4342, 17301, 31090, 74, 28911, 20743, 11708, 5699, 17234, 34517, 33845, 18889, 4319, 11355, 32091, 35880, 14129, 36880, 32248, 5910, 28098, 25664, 36030, 1237, 30589, 28780, 13495, 23540, 24224, 2993, 34972, 35225, 22897, 28604, 30650, 1246, 35875, 31328, 5142, 35168, 2579, 34337, 37091, 21368, 24887, 13049, 36772, 31580, 39580, 34209, 7163, 29507, 19540, 34311, 8512, 4412, 19551, 22536, 15919, 11525, 13401, 19928, 21289, 9144, 10070, 4299, 36842, 3320, 2250, 15968, 10531, 26403, 34133, 38995, 25699, 30681, 38700, 38131, 28336, 26576, 30750, 31368, 23876, 15151, 28373, 35261, 9297, 8040, 37620, 33855, 29190, 23005, 9875, 11666, 13064, 27831, 2054, 28285, 24103, 27488, 34260, 15004, 28363, 33418, 15901, 26761, 28370, 28843, 14616, 19722, 12648, 19372, 36979, 18570, 31429, 19030, 878, 13327, 35079, 13692, 6948, 4739, 29807, 22270, 29325, 21946, 14000, 18780, 18579, 19468, 28492, 227, 25610, 36439, 37093, 2952, 37829, 26931, 311, 26020, 2923, 14945, 38770, 26372, 17720, 13406, 21562, 32188, 6390, 27223, 34227, 3834, 34944, 29154, 26938, 37772, 14452, 21785, 7391, 18380, 26572, 34816, 26327, 17042, 35378, 30665, 22500, 8912, 22281, 6248, 25172, 5154, 18129, 125, 12114, 9688, 7027, 19707, 6406, 22485, 12672, 31391, 14749, 4274, 6341, 15487, 4341, 27707, 15937, 11701, 12417, 3361, 36982, 715, 14419, 2666, 37556, 34155, 6334, 30672, 9036, 32557, 13966, 8455, 32739, 23169, 25452, 31487, 7048, 4654, 8739, 8412, 39435, 37757, 20879, 35136, 27494, 13581, 35899, 12596, 6675, 30363, 9881, 2375, 28318, 35655, 38457, 17479, 8300, 37156, 30192, 584, 33118, 634, 5176, 25390, 22549, 19603, 16700, 19608, 9255, 9491, 8491, 6081, 24671, 26840, 5716, 28762, 36018, 13832, 2721, 23732, 23416, 12805, 6056, 5885, 9768, 13434, 8717, 7729, 21424, 8155, 35185, 20821, 37508, 6552, 34207, 7673, 27631, 32685, 11134, 3181, 28846, 1183, 39668, 36438, 38253, 12883, 5206, 24756, 4502, 34490, 19263, 37012, 38115, 13631, 18184, 2044, 18986, 23717, 12344, 28858, 13846, 21358, 38750, 7665, 17212, 6647, 38924, 37382, 18456, 9967, 2819, 18039, 30451, 34137, 7596, 18817, 8394, 27766, 28747, 1045, 7886, 5643, 6303, 39191, 36588, 17646, 38629, 32267, 7753, 2489, 8703, 31895, 33009, 332, 39569, 10033, 30003, 7612, 4384, 39808, 9193, 15373, 10461, 23320, 112, 29527, 14466, 39317, 7451, 19802, 15810, 6896, 11019, 9720, 11329, 12379, 25608, 8261, 25233, 1564, 9862, 8384, 16127, 24889, 26824, 37513, 33357, 8829, 19510, 23549, 11041, 33202, 15284, 18224, 33450, 13841, 26302, 37475, 23938, 33600, 8798, 28129, 23379, 35532, 35439, 3074, 17785, 31783, 19511, 37151, 6533, 6201, 17324, 12606, 19130, 3350, 5131, 26657, 18908, 13342, 34564, 13935, 17680, 1448, 38570, 33546, 39883, 23552, 6975, 33432, 5002, 31935, 6297, 35004, 1969, 29045, 4682, 10471, 28511, 24394, 11139, 15065, 36182, 13996, 7487, 2451, 26894, 38354, 764, 4983, 16813, 35849, 30382, 2693, 246, 7021, 29088, 15804, 342, 17963, 258, 32586, 24235, 22384, 8947, 23492, 30744, 30012, 20505, 7921, 21841, 18317, 34415, 5759, 8437, 35025, 35591, 34349, 36972, 7430, 22285, 39169, 26547, 35520, 15843, 5612, 6689, 11248, 35806, 39938, 9763, 6559, 37655, 22498, 4113, 17631, 30877, 2855, 23282, 2195, 331, 20586, 25146, 13060, 33712, 7859, 35506, 15465, 26197, 22893, 26833, 29938, 27297, 8676, 24263, 32508, 11250, 18931, 36016, 30329, 5383, 39932, 24899, 32122, 25644, 32581, 29347, 11165, 2528, 8016, 32162, 24703, 16536, 35232, 14648, 9835, 24775, 25472, 23754, 24196, 4872, 5697, 27697, 14934, 18672, 28789, 3119, 2230, 24173, 26153, 6585, 23217, 10827, 33846, 39210, 13502, 19992, 38164, 33957, 15294, 12735, 11500, 15101, 6712, 12610, 19413, 8743, 1133, 11651, 30776, 9791, 11201, 38465, 9665, 11833, 16467, 28462, 15895, 16923, 15390, 37124, 26396, 38680, 28653, 2463, 36784, 15885, 26404, 10796, 7415, 38235, 6033, 20187, 16982, 19266, 11494, 36233, 28350, 38000, 452, 24983, 34735, 20675, 13116, 11872, 17244, 20856, 3708, 18251, 11539, 29989, 348, 25927, 6638, 2732, 37427, 5161, 8484, 30287, 4771, 34360, 22463, 25527, 8708, 9222, 5919, 32675, 7335, 29512, 12524, 1085, 38640, 21662, 3439, 23840, 38264, 35844, 36931, 10913, 17929, 8608, 7499, 34357, 29597, 1480, 15591, 14574, 392, 27794, 5, 18046, 32506, 16645, 26679, 9861, 1891, 961, 7681, 26005, 29102, 23621, 19008, 3038, 1403, 4451, 35130, 18633, 2412, 728, 30289, 28086, 3416, 29918, 34033, 11991, 32025, 25805, 14591, 3705, 119, 36012, 35348, 11343, 14776, 1203, 31759, 17017, 29789, 26175, 8629, 38370, 37443, 14579, 32165, 4146, 30652, 29360, 32631, 3445, 18712, 38284, 23701, 39935, 4945, 9102, 37606, 38979, 15570, 31692, 9195, 25638, 11349, 14727, 25249, 39527, 33136, 38907, 8401, 25321, 3187, 23974, 7902, 35131, 22948, 16652, 10326, 39772, 6243, 17872, 7864, 5902, 13870, 7908, 15444, 7573, 30785, 8939, 9614, 35038, 38932, 15907, 37864, 24375, 4779, 25335, 32922, 30702, 15704, 35266, 19550, 5791, 23340, 12696, 8518, 13980, 10425, 13906, 12181, 343, 4010, 36134, 39199, 29015, 32692, 21878, 19427, 9575, 10419, 15172, 29614, 6380, 11146, 10728, 2823, 817, 17513, 32048, 5877, 9929, 25478, 24469, 28692, 10412, 2276, 16094, 23149, 29799, 9911, 12241, 21679, 19195, 7032, 34538, 27665, 4836, 26212, 4264, 34154, 33584, 35694, 15173, 3563, 10344, 14715, 6418, 21851, 7597, 37326, 20523, 12677, 1068, 4597, 29034, 8622, 24279, 34059, 11069, 37745, 33677, 5218, 4512, 10850, 26338, 21833, 4105, 21186, 13567, 231, 11527, 485, 29379, 24109, 18678, 39508, 30492, 29874, 17458, 16456, 5369, 15950, 10025, 13982, 33334, 18017, 25736, 13519, 31316, 5861, 23043, 1383, 3023, 37586, 22216, 2547, 17312, 3881, 9676, 13102, 30891, 11082, 3347, 21352, 25039, 18715, 29604, 30649, 16185, 1512, 6442, 30777, 30467, 13574, 37372, 29669, 32774, 31777, 37913, 14147, 37929, 22832, 35804, 477, 21014, 2880, 34347, 4219, 26868, 20185, 9770, 23958, 23619, 33576, 21750, 2663, 2536, 18057, 34918, 23546, 19599, 14464, 31467, 4595, 11076, 3204, 2637, 9963, 10431, 17409, 19554, 27845, 27210, 13345, 7624, 35522, 5567, 26745, 16063, 12150, 2408, 36309, 4973, 15143, 3679, 21902, 18488, 27310, 35774, 12957, 39778, 15027, 26768, 14916, 34106, 1116, 30243, 6849, 12039, 38955, 16369, 6220, 16383, 30390, 7791, 13382, 33643, 15059, 13492, 12515, 27181, 39706, 28935, 26332, 31961, 26285, 38814, 23913, 29900, 5072, 23370, 13497, 36381, 2282, 517, 35892, 10732, 6339, 12140, 5829, 28951, 23650, 20102, 3008, 5117, 26712, 28698, 31207, 31690, 4598, 12644, 26540, 35141, 17176, 14370, 36793, 11884, 27256, 29560, 691, 35786, 7306, 12999, 36283, 13236, 15868, 4643, 25444, 14677, 36313, 28393, 32777, 34763, 27367, 36479, 16908, 6529, 16998, 28101, 296, 14034, 39294, 23262, 33621, 24999, 12541, 34351, 11209, 27072, 10360, 26479, 17387, 15787, 18855, 33390, 8338, 1195, 34130, 19227, 4324, 17949, 23811, 7252, 28861, 21770, 7843, 19672, 6242, 2971, 1802, 24026, 14575, 39347, 2391, 4352, 15833, 38129, 6504, 33883, 14239, 32782, 12286, 4015, 7462, 17685, 31056, 10856, 18627, 38657, 38046, 27816, 7741, 2526, 21175, 12304, 14699, 25541, 17897, 39768, 29764, 11668, 4710, 10238, 17833, 22572, 24710, 14039, 10190, 37980, 34484, 10240, 34860, 16381, 15416, 34730, 27186, 30108, 27710, 22472, 20863, 15045, 19450, 17227, 29401, 16320, 23323, 15573, 39496, 30966, 16234, 36838, 29934, 4990, 12409, 3801, 11332, 7684, 30664, 36977, 33948, 16724, 32856, 12287, 17345, 11863, 3306, 30350, 38400, 29927, 25113, 21873, 29884, 38202, 27521, 15854, 38001, 26512, 21170, 16627, 12428, 22108, 9325, 11849, 37245, 22323, 1056, 11397, 4605, 7847, 22768, 12631, 37615, 4778, 8994, 18109, 33795, 22938, 18965, 863, 37498, 20857, 27366, 11436, 25467, 23437, 16537, 37799, 19404, 9925, 30170, 583, 17635, 4599, 10809, 4096, 130, 37949, 25188, 13835, 8479, 33115, 34703, 30037, 19281, 5739, 21023, 32674, 8685, 19989, 39713, 33467, 17541, 36106, 16780, 31746, 15379, 6624, 19585, 18849, 36304, 33441, 37010, 27577, 38682, 37227, 19724, 34904, 6601, 30425, 10206, 5365, 2961, 19807, 3983, 25403, 18959, 31341, 8283, 3675, 30766, 37890, 31000, 19241, 18119, 10172, 633, 28377, 39680, 16889, 39773, 29740, 39602, 31795, 15755, 18223, 11049, 13831, 19898, 1239, 2958, 12321, 32383, 28910, 853, 2949, 4509, 15306, 20522, 39401, 15474, 5134, 12367, 36679, 18635, 21621, 17754, 5672, 11257, 39051, 18674, 13209, 6797, 1948, 4900, 1929, 20283, 9824, 30212, 7590, 21816, 12809, 32180, 20398, 7602, 7495, 34233, 4786, 21804, 15411, 30957, 15531, 8457, 31856, 4163, 26796, 31117, 3998, 8962, 20027, 6979, 26748, 8322, 4875, 28925, 36412, 13016, 37899, 9984, 35304, 25769, 1423, 29329, 22646, 28961, 2822, 29591, 10947, 17460, 6284, 36681, 38385, 11385, 29009, 27326, 29349, 35546, 23079, 30559, 14214, 11724, 31819, 37500, 13270, 13865, 39139, 24018, 14958, 27937, 31870, 14875, 14116, 27177, 2399, 27430, 27860, 22982, 1390, 36991, 38994, 31148, 30321, 16299, 30076, 33540, 38888, 3155, 38607, 631, 33558, 37155, 20496, 10272, 223, 31278, 31300, 18332, 38824, 85, 2523, 1197, 12495, 17818, 28058, 29762, 33896, 1125, 39492, 29652, 27818, 4592, 33141, 34562, 4301, 8092, 1630, 11392, 8265, 26254, 28717, 25180, 855, 24436, 11381, 31702, 7696, 37284, 15832, 22586, 31257, 6767, 21006, 17497, 23581, 1150, 30905, 38032, 8668, 36629, 38061, 16507, 31302, 19701, 18504, 26079, 35586, 12937, 9226, 1587, 30876, 24021, 28856, 19012, 6637, 28226, 10204, 10400, 37204, 9079, 22823, 14261, 5937, 19885, 24391, 29829, 27515, 4624, 31495, 30142, 3657, 3203, 20125, 7402, 19900, 5577, 5779, 39337, 35445, 21412, 6301, 38978, 30484, 4828, 39332, 29666, 37858, 30187, 12033, 19137, 3148, 613, 30530, 15624, 31778, 28761, 2752, 24789, 37056, 24158, 28712, 26535, 26495, 32334, 32723, 21692, 2577, 28029, 14087, 12103, 34584, 1476, 29754, 22766, 27276, 7705, 28455, 4329, 22873, 11437, 25421, 32466, 39045, 38512, 12891, 4993, 39639, 18416, 6187, 37728, 31737, 1727, 16800, 5907, 24661, 17300, 7618, 25615, 29390, 12629, 24092, 11053, 36193, 22767, 745, 21378, 9740, 26276, 25122, 10483, 16157, 34671, 18989, 23035, 19825, 26863, 21012, 28849, 26673, 4467, 38351, 17376, 11917, 21716, 20502, 21576, 6755, 17200, 4777, 29716, 29990, 11372, 10323, 20999, 8992, 5848, 8713, 21485, 39391, 27529, 13716, 28831, 15265, 27491, 36447, 21212, 21550, 39268, 29170, 35169, 38531, 38175, 28313, 12574, 14983, 31301, 16823, 29529, 2517, 31017, 11419, 15935, 34412, 31275, 37598, 35127, 4907, 8909, 26287, 28881, 6793, 11413, 12203, 29671, 3010, 31295, 31952, 31063, 26793, 114, 3120, 2213, 32430, 15829, 31695, 30141, 794, 27547, 30792, 8845, 13281, 6947, 3638, 14911, 21859, 3402, 1970, 7638, 35868, 18656, 7349, 29766, 8416, 15082, 5837, 3691, 17639, 10385, 26417, 21880, 4473, 38010, 6474, 36623, 15057, 16865, 11912, 14246, 10193, 25243, 5216, 31724, 7383, 237, 12960, 27924, 1285, 5611, 32955, 11663, 10256, 29640, 37272, 28835, 19766, 29545, 7501, 26568, 5920, 8935, 31620, 16598, 22726, 24969, 32323, 37995, 6683, 26605, 39745, 11839, 3810, 4986, 36232, 15476, 34612, 26096, 13972, 11956, 17699, 8042, 34167, 5532, 17162, 28039, 35528, 1687, 11870, 20923, 23830, 28070, 14440, 38702, 18336, 16055, 5256, 35174, 26724, 17206, 19284, 4064, 34916, 36967, 24792, 38387, 24466, 9354, 28122, 5940, 39886, 34438, 36356, 15602, 34020, 15498, 35361, 21047, 21410, 23088, 6495, 21546, 31590, 20776, 20640, 20808, 22663, 29802, 642, 36962, 13114, 8607, 20419, 31665, 9196, 24205, 33617, 17969, 2125, 31585, 33985, 29312, 3878, 38160, 15988, 27717, 34551, 21848, 14573, 22284, 30478, 8121, 38037, 37030, 18870, 30609, 20195, 14271, 33515, 14453, 28379, 28054, 31269, 1334, 15423, 27500, 23569, 10915, 2885, 26808, 18398, 23615, 20483, 34993, 22521, 16578, 17533, 16653, 14986, 6463, 21404, 11996, 11690, 33437, 19582, 4607, 12926, 38433, 2201, 27642, 15062, 10757, 29692, 28397, 33169, 34820, 10782, 6483, 14975, 25005, 12492, 1757, 27512, 3913, 21587, 30611, 1597, 11087, 33732, 2996, 17245, 37518, 22551, 7094, 38015, 13850, 36609, 27329, 28463, 13922, 16434, 38900, 29121, 34147, 33316, 308, 36493, 2817, 16481, 37714, 16753, 38594, 2645, 4241, 2320, 38668, 14251, 21105, 16342, 26169, 10604, 10167, 8100, 1040, 4691, 30280, 36590, 27829, 8627, 23607, 38660, 4521, 23448, 36194, 22421, 37778, 35727, 21311, 8574, 7901, 10607, 12530, 38404, 30309, 31556, 37201, 16704, 4814, 35400, 6185, 1349, 34107, 5485, 30643, 38922, 23800, 11544, 16919, 1031, 31100, 19390, 39312, 30007, 37901, 19891, 29751, 39908, 20985, 10721, 31095, 32792, 33413, 22, 33602, 20508, 7709, 15764, 35471, 28822, 943, 702, 26135, 9237, 39600, 35363, 32029, 15228, 37150, 38988, 17304, 22062, 4513, 8971, 3520, 6337, 36055, 12967, 34502, 39098, 14787, 34588, 36742, 36857, 14895, 9374, 9988, 4245, 14842, 9847, 36209, 14294, 34977, 14522, 3255, 19177, 14082, 8471, 36271, 7970, 15615, 32682, 18569, 20785, 10077, 38423, 33718, 35434, 25585, 37991, 20357, 28603, 38251, 12294, 36472, 10665, 23428, 143, 14238, 36988, 28572, 25886, 11055, 39546, 31744, 17411, 34297, 6122, 15483, 26639, 12027, 29577, 20907, 5424, 4386, 25754, 14996, 22509, 4375, 39629, 25889, 30261, 23635, 15691, 29998, 10495, 29053, 16623, 1781, 37096, 12141, 32848, 30167, 36603, 26329, 38098, 1933, 9096, 34240, 38018, 13953, 6613, 13098, 37584, 28918, 4528, 3612, 39141, 9674, 18971, 20480, 19835, 12954, 36225, 19293, 1172, 36535, 24776, 22795, 18387, 18530, 37642, 29116, 31118, 32843, 7215, 28321, 3920, 17834, 10157, 7600, 36798, 31943, 8582, 9347, 2078, 22919, 7327, 31989, 12535, 6028, 2112, 32936, 26467, 30612, 31680, 19391, 38659, 7091, 39554, 32728, 22907, 4151, 23263, 28151, 10481, 12093, 39163, 19041, 28817, 16661, 21746, 37905, 24015, 13753, 25297, 11568, 38025, 1303, 11135, 12006, 16961, 30370, 6875, 15142, 19357, 9315, 10745, 35054, 27949, 4519, 699, 12099, 23881, 32022, 37907, 14184, 25795, 18872, 20051, 35773, 2509, 29623, 38714, 2596, 8740, 723, 436, 23916, 7089, 30841, 5139, 1824, 18591, 20330, 37057, 12264, 32914, 6235, 30447, 2529, 23334, 39263, 21796, 34278, 20684, 29421, 16911, 15550, 16387, 37814, 12867, 22703, 36374, 32633, 2163, 29624, 16420, 4491, 25150, 29539, 25835, 31025, 31512, 37035, 22930, 20972, 5850, 29480, 30396, 33073, 29723, 38783, 33195, 35757, 8118, 32354, 607, 32296, 2688, 16496, 12814, 28127, 30922, 6320, 39460, 24730, 5102, 25129, 4367, 3069, 7868, 16615, 30507, 27756, 490, 23366, 25325, 28510, 11452, 9534, 12013, 21542, 33825, 4537, 4214, 3267, 23673, 6937, 14881, 1492, 38947, 6503, 5960, 28828, 37489, 6917, 32666, 2037, 3302, 36801, 21202, 31240, 29632, 16838, 34752, 16346, 22154, 16136, 17847, 31682, 9015, 26498, 17353, 20133, 2081, 20147, 26083, 27874, 11027, 8390, 18405, 25641, 5291, 38627, 6791, 29423, 3621, 5564, 25373, 17550, 17331, 29156, 12220, 25588, 17573, 29902, 37845, 34113, 7132, 34849, 33247, 24877, 5414, 20106, 8900, 1114, 38919, 2863, 5450, 35932, 33944, 19388, 11948, 6116, 38124, 1229, 37984, 27242, 11137, 34291, 5339, 37660, 32720, 9070, 1306, 8183, 18951, 11036, 14011, 18286, 4968, 23774, 26499, 4307, 26129, 6046, 18593, 16858, 22695, 8983, 33704, 30397, 1064, 10734, 10651, 9373, 25084, 19095, 3637, 39453, 12556, 19215, 16268, 1526, 13061, 31350, 17120, 669, 6077, 25558, 23999, 663, 10160, 31973, 37479, 17087, 35913, 9625, 27814, 2777, 7930, 26477, 23815, 24354, 29050, 14521, 5745, 19472, 6550, 27213, 31796, 11045, 6165, 30964, 7370, 12410, 27834, 1294, 31504, 5422, 5680, 35558, 14984, 24390, 13510, 22029, 29497, 28581, 1698, 21119, 16479, 16271, 17808, 29709, 8920, 1213, 33094, 21369, 23583, 33710, 1219, 33658, 3682, 16760, 30950, 6085, 4212, 26053, 24458, 12579, 36228, 33088, 5130, 31164, 35668, 10000, 20359, 5366, 36774, 8438, 36583, 24607, 7362, 16618, 9796, 10571, 4988, 26123, 25247, 22072, 14846, 7480, 1282, 20636, 12566, 17224, 10489, 25225, 25807, 6006, 31977, 37455, 23297, 18177, 18660, 32702, 22998, 11938, 34489, 35032, 1079, 9744, 11966, 19849, 11647, 20358, 30581, 5962, 20718, 12716, 33286, 17275, 32089, 7111, 10163, 20969, 5921, 4490, 31858, 28516, 5976, 12351, 34658, 15873, 18258, 35944, 5195, 38864, 10875, 15386, 22482, 4296, 26192, 14690, 6412, 24342, 31776, 37335, 33833, 28075, 30618, 13728, 30827, 29283, 23199, 5682, 13769, 15161, 28083, 31610, 12004, 13201, 17197, 18242, 10694, 39906, 18969, 12912, 30184, 27000, 17313, 7804, 21003, 15514, 32563, 24418, 20594, 36969, 30512, 36288, 19453, 20848, 26743, 1444, 6353, 9148, 34881, 18929, 39214, 8432, 778, 16895, 29196, 23630, 28153, 37271, 30149, 12398, 18742, 31987, 8718, 1803, 37915, 34950, 33186, 35062, 38060, 2984, 29839, 29924, 5073, 28444, 29103, 3411, 17422, 10573, 5993, 25042, 37301, 9421, 5928, 27729, 35743, 38100, 16296, 10035, 2187, 38756, 3687, 26253, 38881, 38180, 6895, 20153, 15687, 15107, 37463, 34925, 34699, 32293, 16970, 1666, 615, 34696, 23301, 18701, 15584, 19764, 34242, 4849, 14967, 1193, 20239, 7620, 2555, 3297, 30359, 8413, 29912, 10329, 37369, 14817, 868, 14991, 32859, 27314, 17221, 14095, 26802, 19456, 4385, 39649, 31526, 5115, 11575, 29221, 2701, 10751, 29067, 37523, 31128, 7358, 35114, 26263, 23357, 17368, 26984, 19261, 21567, 9644, 9474, 25567, 13748, 22964, 21011, 10221, 3574, 28887, 39787, 7766, 15222, 24660, 1467, 3413, 25623, 28644, 32878, 37126, 2936, 20703, 26249, 28686, 6102, 33096, 14926, 5247, 19063, 15673, 9801, 3248, 19161, 9764, 20584, 3534, 19417, 4, 500, 19079, 5799, 31171, 30720, 11826, 20130, 26297, 7385, 25890, 29805, 30596, 26792, 12106, 14622, 11728, 22469, 23773, 8720, 27747, 37311, 25357, 19806, 37260, 36249, 15649, 13638, 37287, 3039, 341, 17503, 13326, 32725, 30944, 13636, 5673, 38363, 5557, 2758, 8807, 33991, 9080, 25447, 6455, 12944, 25379, 3014, 36186, 5423, 27012, 33416, 18722, 9909, 4166, 9714, 25596, 12628, 39940, 31066, 29479, 38102, 39306, 23028, 24070, 12844, 8091, 2919, 18978, 9160, 39971, 1545, 13287, 19478, 16822, 28565, 13038, 39136, 10151, 20525, 34144, 6300, 26908, 28748, 1265, 37962, 19755, 5544, 22956, 2450, 2884, 27108, 3749, 10740, 28221, 4215, 23586, 22301, 9260, 26722, 19243, 39361, 8081, 26566, 28116, 35994, 28035, 32806, 35917, 31689, 23965, 1021, 5042, 7063, 30552, 31416, 28819, 17329, 2665, 9611, 34954, 15529, 21797, 32275, 16902, 34985, 37654, 23174, 3065, 11739, 9391, 9403, 14479, 23026, 26625, 24293, 24893, 12828, 25030, 27147, 24246, 14930, 11781, 38136, 30908, 18727, 16462, 5710, 18655, 36945, 11225, 24689, 35776, 31800, 23907, 17151, 37721, 6621, 29941, 17086, 20692, 9784, 37368, 37049, 12902, 24187, 32318, 12851, 14032, 2397, 32278, 35386, 23218, 25540, 16316, 9462, 75, 5929, 17931, 19517, 11931, 23905, 18022, 37679, 16204, 21427, 3353, 19374, 38509, 28612, 845, 20199, 20345, 12497, 39581, 27533, 13192, 29966, 3904, 24193, 2627, 37565, 20066, 13776, 16440, 10402, 15002, 26548, 17473, 29235, 38027, 35610, 27931, 20081, 1562, 33611, 12069, 22817, 18554, 23749, 7157, 25049, 30568, 20318, 22803, 29727, 19645, 29068, 15099, 37058, 4541, 12343, 33260, 37591, 37448, 12441, 16432, 2534, 26343, 10459, 23242, 4911, 39606, 15938, 30377, 32454, 29791, 22935, 15682, 32990, 24482, 23941, 12540, 6685, 677, 10737, 18087, 8192, 7552, 2762, 11993, 18391, 39919, 10569, 16778, 19775, 9934, 5983, 2809, 21150, 4991, 33753, 20429, 27854, 34676, 26351, 10090, 18578, 32787, 31937, 17742, 30729, 9684, 1807, 37422, 16035, 3191, 15346, 27972, 31557, 12727, 1428, 30019, 29334, 31745, 25551, 16989, 32899, 36373, 19061, 32950, 1751, 16695, 23967, 30470, 31645, 5528, 4755, 26412, 31073, 25317, 26300, 1034, 17229, 22203, 20384, 19864, 14058, 33354, 27385, 29016, 23720, 793, 29598, 386, 25052, 9830, 21529, 11633, 32497, 2371, 12491, 30056, 21114, 6307, 29617, 32000, 15631, 23868, 8478, 37313, 2013, 28276, 4244, 20982, 8157, 32175, 1515, 2954, 25840, 17586, 20340, 18584, 26443, 25496, 2461, 26999, 28800, 27763, 28785, 14248, 37142, 39900, 20267, 30655, 14305, 37767, 37923, 3154, 7109, 14748, 8251, 30282, 9221, 10093, 19493, 5211, 10515, 34621, 28267, 12340, 30554, 24157, 25851, 28073, 17620, 6918, 1106, 20012, 14334, 16605, 38965, 37412, 15546, 38187, 16502, 11166, 19433, 37836, 18571, 2459, 5536, 30153, 35687, 4016, 34783, 11949, 32934, 26526, 2499, 14128, 31204, 16449, 39699, 9240, 11205, 24714, 16267, 25625, 2378, 37847, 30834, 36390, 9302, 36864, 21681, 21373, 36148, 16997, 13310, 20440, 17335, 24151, 22283, 20577, 24619, 1406, 9463, 8529, 1985, 28820, 15977, 10652, 5253, 564, 31382, 29752, 18945, 4047, 7122, 28898, 2931, 20396, 31812, 11643, 32707, 4693, 8076, 19577, 26874, 31174, 21892, 20492, 34861, 27355, 33068, 30910, 27592, 23458, 32620, 15066, 29499, 15434, 17708, 38119, 25410, 25763, 23880, 38155, 39389, 10464, 23660, 15033, 8594, 24669, 3573, 33385, 32194, 26008, 21447, 28529, 15364, 992, 9375, 35667, 21512, 11429, 27462, 24925, 28131, 33495, 21132, 2284, 10102, 5061, 6319, 12298, 11553, 29823, 16931, 9852, 33120, 38206, 28113, 36649, 30526, 29615, 18330, 2128, 4676, 20482, 17323, 15452, 3252, 39923, 19738, 27013, 16238, 3135, 10765, 39165, 14548, 34470, 38469, 24231, 35635, 39501, 25240, 1704, 7346, 14594, 22190, 9289, 9859, 38652, 32550, 14188, 25010, 21668, 8609, 26921, 24442, 19403, 19537, 39162, 24697, 16626, 33873, 23349, 26656, 31094, 25525, 24779, 25885, 30993, 27520, 15626, 29949, 24947, 36952, 21899, 27811, 18044, 11249, 19515, 1532, 30395, 5587, 33055, 4423, 13048, 31185, 33014, 13908, 2918, 32038, 28227, 4226, 8005, 39910, 37176, 33196, 37669, 28141, 7007, 9113, 31013, 12310, 15554, 32496, 9145, 39941, 38408, 16535, 11057, 13947, 35670, 29255, 24164, 19979, 811, 23025, 35134, 16494, 7916, 22579, 28776, 3442, 8601, 12144, 38230, 5163, 35916, 35526, 16515, 18590, 29408, 29843, 3170, 4897, 14652, 31667, 23515, 32519, 4591, 15297, 21443, 37715, 18874, 34236, 5541, 28787, 29345, 15778, 13513, 25636, 13997, 14765, 22890, 3444, 23316, 15517, 29852, 37308, 19343, 30599, 28409, 12573, 37160, 10580, 33748, 19542, 39820, 8231, 21536, 28182, 31520, 4156, 10348, 10675, 35613, 13696, 18641, 36536, 1785, 22696, 5518, 27653, 15393, 7386, 14827, 5242, 25692, 17975, 36115, 6780, 11289, 30806, 38769, 11670, 22610, 21024, 21971, 23257, 11825, 30614, 2299, 9700, 1991, 20621, 28324, 28952, 34027, 19919, 5155, 26788, 7315, 25711, 25934, 29272, 30524, 26469, 2598, 13365, 6696, 21765, 37766, 23611, 34054, 26789, 32691, 35412, 29855, 4577, 20986, 2130, 15433, 5657, 39125, 28246, 27578, 20082, 10327, 20746, 12622, 7033, 19473, 27543, 10899, 22898, 7578, 34710, 30131, 24864, 13892, 7085, 15556, 13256, 34320, 25838, 1033, 9117, 2370, 7093, 37491, 15349, 31134, 4931, 20979, 21646, 185, 28561, 7472, 3300, 1277, 38520, 20170, 30473, 13598, 13053, 31459, 2756, 7997, 35028, 29813, 25449, 21188, 8684, 24921, 29952, 37405, 27839, 20010, 26358, 36368, 8241, 35739, 10846, 29678, 9010, 14193, 20946, 10720, 31578, 33253, 4709, 1901, 27407, 11878, 10857, 5065, 34791, 13512, 7368, 33332, 4630, 12466, 36290, 4171, 18329, 4881, 34921, 19366, 11785, 35189, 11875, 37221, 39718, 37476, 26853, 22383, 33392, 13787, 36072, 14153, 51, 16922, 28851, 31748, 10219, 28471, 39691, 36944, 34705, 35081, 24870, 461, 39894, 15524, 26849, 23078, 17203, 821, 31042, 8303, 7300, 35548, 19729, 29567, 22614, 18211, 27111, 30435, 25590, 13213, 23148, 22112, 6714, 17814, 4378, 18536, 33100, 38940, 2145, 27076, 765, 22286, 13857, 19303, 31418, 9926, 37891, 28102, 30613, 36027, 12710, 20292, 39551, 1523, 18917, 27222, 4465, 3178, 9103, 15792, 6509, 37573, 29333, 12326, 25766, 39936, 16413, 4131, 2040, 4004, 18752, 5610, 39555, 35596, 27170, 13569, 35071, 31177, 20376, 21544, 38123, 39627, 1380, 33961, 36530, 15759, 5428, 12846, 26344, 37181, 37076, 18366, 90, 16201, 26934, 35735, 23733, 12426, 36043, 20624, 34419, 14834, 1900, 39197, 11693, 27316, 17392, 39556, 30223, 9188, 20191, 21575, 14166, 30498, 21038, 8403, 39353, 1665, 14831, 2492, 3681, 6032, 22484, 38022, 24262, 29910, 39470, 32628, 8253, 32160, 24495, 17966, 3147, 33696, 31779, 16829, 29341, 31194, 27187, 29440, 19256, 10390, 29363, 5771, 14931, 27701, 17810, 16647, 22228, 8812, 35778, 37727, 13587, 33676, 7414, 13586, 23691, 21089, 8605, 34323, 15821, 29338, 694, 38556, 16684, 9073, 34067, 2739, 35891, 12766, 33369, 13503, 19725, 36167, 12221, 32771, 21444, 39804, 12429, 17528, 19499, 13688, 21588, 28064, 37157, 10594, 4989, 9171, 36201, 11481, 29815, 5265, 4722, 15903, 16899, 29318, 25320, 25634, 1065, 24011, 27132, 30023, 30454, 21468, 8233, 32443, 10143, 26632, 13807, 23049, 31496, 37028, 22600, 39094, 36927, 31220, 5324, 17817, 31205, 28907, 29920, 26556, 12673, 15071, 35627, 27263, 12915, 20461, 32138, 4791, 22755, 20192, 12364, 22400, 32959, 38586, 37903, 27409, 7996, 27720, 453, 9250, 205, 16386, 5694, 27743, 10942, 31061, 30110, 21697, 11675, 16039, 2206, 955, 2160, 23969, 23903, 8136, 39462, 16332, 16777, 26561, 8864, 8060, 26973, 24290, 36432, 26462, 10977, 23112, 18436, 28431, 27994, 27986, 5454, 378, 14809, 25633, 29330, 19398, 19516, 10733, 13897, 2594, 1409, 18402, 1912, 7583, 29581, 37806, 7479, 8730, 16057, 8949, 24745, 32121, 25500, 21963, 1043, 2565, 19576, 29286, 35782, 39690, 30130, 16239, 6749, 19813, 18495, 7290, 35024, 29267, 9337, 25226, 26882, 18233, 2672, 4573, 105, 36745, 5685, 22949, 21390, 30384, 20036, 26941, 31502, 10781, 2394, 5684, 24024, 34406, 27560, 11147, 29137, 12880, 22177, 38159, 14322, 1555, 22391, 10031, 31940, 31143, 25314, 20550, 18152, 20096, 23333, 32616, 10060, 3217, 2920, 32931, 33072, 9268, 39733, 6888, 11200, 29232, 18626, 25068, 33172, 23092, 37134, 21436, 31020, 36733, 31770, 4298, 9725, 6866, 17240, 20200, 32208, 37232, 21691, 24962, 30506, 20142, 23134, 32317, 39595, 18127, 29977, 7474, 22552, 1407, 12736, 32595, 14909, 38201, 23966, 34459, 25239, 31823, 38903, 30774, 34647, 19135, 11542, 33569, 9494, 20108, 23013, 5268, 39662, 30064, 30963, 7188, 27439, 5016, 28914, 5868, 34913, 18457, 19247, 28701, 11000, 26464, 36071, 16368, 19974, 26444, 3107, 34885, 6329, 822, 31922, 24744, 9655, 26236, 15522, 31226, 8525, 32068, 11824, 4415, 25246, 12966, 26713, 39399, 36680, 37377, 25846, 20347, 7469, 2027, 938, 19175, 24924, 16649, 13278, 14168, 391, 39664, 23161, 9416, 15713, 15812, 33452, 5430, 7441, 18592, 16963, 4116, 2228, 28165, 4756, 18335, 3518, 31528, 14363, 13668, 33283, 9135, 19435, 38166, 4782, 29509, 5906, 7643, 25251, 25078, 15581, 31196, 38381, 35289, 3483, 10298, 25195, 11923, 36751, 3330, 16385, 18128, 23954, 8470, 37430, 25340, 36080, 14438, 31357, 5237, 31735, 26066, 35772, 10601, 6961, 21744, 25114, 34747, 27760, 734, 24473, 34330, 12081, 850, 23594, 24707, 21870, 5060, 20155, 34283, 3976, 7926, 22821, 5238, 37928, 38844, 14252, 23371, 39866, 25094, 880, 28845, 37302, 28502, 18060, 37975, 5088, 37339, 19670, 8445, 28518, 23653, 9266, 28842, 30948, 18558, 32213, 2343, 1086, 35332, 21363, 23390, 3434, 17342, 30625, 5764, 28198, 31474, 22520, 12010, 304, 26658, 33164, 23517, 2148, 1605, 17071, 21310, 33799, 20686, 23851, 17394, 20076, 34617, 30367, 1263, 17495, 8428, 31130, 33745, 8823, 4029, 25534, 26195, 7443, 12625, 7914, 30128, 2725, 4224, 32769, 1454, 16177, 34905, 6457, 31798, 28447, 21082, 29523, 35999, 614, 33376, 28954, 18838, 28078, 35859, 25158, 15162, 27970, 1613, 19290, 11169, 30883, 34224, 14459, 9556, 32741, 3695, 729, 1273, 12757, 36475, 19716, 29620, 14847, 36921, 8066, 33008, 20494, 13687, 17683, 37736, 32699, 39232, 23247, 7434, 37380, 18738, 26996, 13165, 5037, 24180, 21452, 33151, 9957, 36112, 26983, 8651, 30409, 16843, 30828, 32349, 18529, 9643, 27596, 26134, 33056, 19133, 19734, 39621, 3068, 36894, 7988, 3196, 9520, 4517, 11579, 27545, 38981, 25918, 38708, 18045, 28630, 10689, 32986, 33398, 27336, 16767, 2367, 13614, 23097, 21426, 24252, 16359, 20084, 25954, 7226, 30800, 29123, 37555, 31401, 24665, 34043, 3476, 29890, 37888, 15586, 24991, 11734, 37298, 6969, 5798, 15141, 32973, 15613, 10949, 23750, 6270, 30758, 27911, 14164, 6748, 1347, 16021, 9146, 35775, 16976, 3840, 29879, 39078, 29551, 2572, 39367, 30244, 12704, 36916, 33721, 19939, 30578, 39694, 5341, 18846, 15009, 35282, 14027, 35730, 17305, 18043, 38666, 33085, 26206, 22986, 22445, 30381, 28469, 5313, 703, 744, 7302, 31766, 7973, 20656, 28472, 7042, 6385, 17615, 17880, 36862, 14618, 31671, 15789, 1145, 4827, 27194, 11746, 33649, 17280, 5571, 36737, 18818, 14160, 22879, 25291, 17154, 25428, 30879, 22888, 35709, 17643, 11513, 1831, 933, 14290, 33729, 32135, 18001, 29658, 3672, 22364, 13490, 9401, 10142, 14282, 8857, 13265, 30277, 7189, 38011, 16302, 15685, 19747, 21908, 17214, 34071, 19168, 21566, 30822, 31978, 7204, 16731, 22134, 39147, 39101, 21203, 19002, 37603, 20552, 34785, 19186, 39365, 24132, 546, 21799, 30337, 1671, 14821, 14800, 30487, 3622, 19321, 23403, 18976, 2746, 20581, 36719, 27416, 30754, 13742, 14187, 36933, 4943, 935, 10669, 1420, 654, 4588, 16134, 32832, 15231, 34215, 15383, 16045, 23828, 6989, 18259, 10188, 29931, 20435, 17976, 30874, 37954, 2829, 23760, 19918, 6209, 30298, 34969, 36890, 39739, 33256, 32512, 30733, 282, 6089, 10247, 32093, 14325, 22449, 17916, 24168, 19814, 8406, 22770, 13659, 37986, 22812, 17192, 1628, 3845, 27938, 10808, 21670, 21610, 27945, 1360, 25632, 22636, 5302, 20166, 5290, 35666, 28459, 38286, 26282, 28490, 37940, 24392, 36132, 34298, 28860, 29881, 32823, 26283, 31234, 21481, 19153, 30356, 29381, 32154, 30765, 33336, 18494, 20337, 2345, 38733, 21080, 24135, 28678, 25183, 9493, 12030, 5040, 18953, 5495, 8598, 29639, 33104, 14889, 35975, 21515, 29779, 36549, 9711, 26171, 5995, 32301, 3329, 39441, 38834, 22387, 11879, 16250, 23831, 37465, 3243, 2355, 3767, 14662, 5348, 12297, 15593, 6544, 34135, 17365, 32717, 18771, 12895, 13708, 26333, 12341, 34246, 3380, 25675, 15300, 32455, 19237, 11004, 6001, 25033, 30270, 23640, 12637, 25673, 35931, 20573, 13656, 22092, 16550, 24160, 36834, 15877, 23322, 11232, 2738, 4477, 36556, 34066, 556, 27879, 31747, 37318, 21620, 34248, 28759, 4303, 9241, 19308, 32835, 32246, 12414, 4293, 2143, 17171, 24485, 24529, 4030, 14604, 23318, 28298, 30490, 12680, 38998, 18869, 29234, 25815, 3926, 35746, 30215, 8752, 5381, 39484, 15650, 17340, 31191, 7096, 10628, 1793, 31660, 14523, 5317, 20382, 4930, 39373, 13158, 9896, 1215, 3359, 13778, 10654, 33743, 7107, 25868, 11161, 14962, 24891, 15993, 20328, 24588, 9734, 18257, 13191, 22596, 8565, 6722, 37388, 194, 39400, 21642, 11678, 9606, 29850, 7235, 20203, 28341, 9812, 21292, 15730, 15871, 6681, 36481, 1500, 39655, 8422, 20350, 19816, 307, 37595, 34480, 11412, 12316, 9705, 28169, 32901, 33016, 10633, 5753, 13701, 11680, 19078, 4450, 35824, 1069, 22626, 24117, 10982, 35509, 31971, 26339, 14388, 34243, 19296, 33248, 38478, 8125, 28399, 34249, 14101, 19166, 17583, 4941, 28067, 35435, 21066, 14669, 19903, 24181, 11889, 9264, 22314, 36726, 25895, 35669, 15311, 3490, 9501, 22983, 37579, 73, 19174, 8056, 17076, 29380, 17481, 4965, 19265, 20177, 182, 9172, 2043, 16278, 34097, 2464, 6657, 37423, 2785, 10653, 27003, 19112, 2232, 6622, 2726, 3552, 37932, 17587, 23992, 37639, 35711, 21973, 32510, 8000, 15838, 38332, 33278, 22578, 4790, 10107, 18157, 9166, 27509, 27435, 39481, 31681, 38338, 21285, 31140, 8943, 8433, 20535, 29638, 23970, 412, 36631, 37906, 22064, 27549, 2024, 36531, 21112, 6145, 36042, 34951, 18559, 7347, 33575, 36858, 32132, 10056, 39020, 29544, 13121, 25212, 32340, 17254, 16041, 34451, 25077, 17848, 9766, 20148, 5999, 38773, 3648, 21950, 2812, 20897, 17998, 31698, 5081, 5015, 25426, 39437, 37266, 14149, 33144, 22370, 11149, 21419, 27020, 18725, 39788, 38362, 9185, 33557, 17516, 29131, 3109, 27097, 11865, 28939, 16521, 9385, 16371, 39760, 3959, 6945, 15837, 28688, 8311, 16340, 33607, 36275, 33109, 32908, 3005, 15680, 102, 17786, 10224, 1070, 9553, 10440, 3698, 32697, 23047, 12594, 11691, 12529, 13784, 2484, 35699, 8446, 5434, 9439, 17628, 16337, 24020, 28751, 17035, 27140, 14004, 9353, 21140, 26615, 11920, 10600, 35089, 24430, 8244, 25185, 22771, 23950, 12784, 34028, 26843, 10533, 24217, 9219, 32054, 5346, 34570, 15538, 16222, 30374, 30432, 18153, 24720, 14473, 27324, 7693, 13837, 37852, 22854, 10554, 6599, 12905, 2361, 5687, 29730, 9708, 12419, 33311, 24666, 2255, 17710, 31289, 23000, 26905, 12186, 22870, 32967, 7971, 28025, 23514, 15216, 21790, 7265, 34006, 639, 37474, 10275, 3288, 20803, 9964, 26865, 915, 11255, 18104, 31613, 20838, 32260, 26899, 30124, 9158, 4697, 32767, 3341, 36105, 25586, 28949, 36150, 27672, 33505, 34840, 16270, 23643, 21177, 33681, 6785, 22829, 13623, 313, 33453, 26337, 24194, 35766, 7662, 34723, 37279, 8555, 35483, 1333, 5487, 15226, 26490, 4570, 37924, 24617, 7447, 13331, 35619, 38348, 238, 20079, 12708, 17984, 16880, 31043, 10178, 6480, 2273, 19217, 1607, 4992, 12267, 8309, 7962, 36328, 9085, 6302, 3073, 17112, 21027, 32523, 20789, 6715, 30901, 6639, 13147, 23189, 29972, 16934, 22611, 7769, 3205, 14376, 31925, 10414, 21612, 16493, 4880, 22820, 6960, 18834, 33639, 13176, 27378, 1663, 21580, 30048, 38402, 2156, 39402, 14331, 3804, 14169, 36040, 25020, 19083, 21771, 582, 5347, 13746, 8247, 25519, 18350, 18326, 16885, 30602, 24363, 36342, 26501, 37784, 19353, 19633, 20936, 17166, 28647, 16422, 19448, 36537, 22060, 23934, 7717, 20794, 27206, 20670, 22936, 24468, 13754, 38884, 38294, 5401, 20987, 38309, 8647, 34065, 28314, 39887, 19532, 29634, 15785, 17567, 4896, 2192, 34060, 34741, 23326, 11645, 19968, 21123, 13520, 1271, 26918, 12650, 25704, 5476, 6926, 39240, 38097, 30103, 12659, 2418, 22376, 29406, 26536, 1300, 18916, 21040, 36451, 1971, 32262, 13610, 5194, 33430, 4480, 738, 10176, 2208, 23765, 18721, 37592, 38543, 3417, 14152, 5732, 8568, 24564, 24211, 2264, 4148, 11627, 4492, 36442, 21102, 31715, 537, 37833, 16966, 27826, 3583, 22435, 18919, 9143, 4462, 15855, 2275, 33728, 35115, 692, 22921, 15324, 39974, 20810, 30479, 15255, 7179, 26265, 20442, 12602, 39672, 27783, 30916, 15262, 39145, 11363, 23625, 35251, 6179, 20217, 8528, 20127, 36691, 37701, 30343, 31957, 24437, 1586, 27548, 34505, 13355, 2117, 20504, 23474, 13649, 14225, 20517, 38165, 30919, 39522, 22111, 8201, 17425, 29412, 27837, 7194, 5192, 3414, 15944, 25971, 2226, 5465, 39336, 16168, 34799, 5298, 22199, 22668, 13948, 3262, 7004, 15604, 35527, 6289, 34115, 19099, 31190, 23454, 23909, 353, 5385, 38720, 16590, 10244, 25397, 13949, 16990, 32923, 1190, 10492, 39339, 26486, 30144, 7981, 19721, 7405, 17099, 18961, 15684, 27419, 14823, 36610, 12656, 20850, 610, 5254, 20955, 5335, 36151, 6630, 32807, 20908, 17659, 28654, 31147, 6232, 12775, 6507, 20711, 15164, 35245, 16281, 17851, 25909, 38860, 29576, 17500, 18777, 4145, 14985, 11464, 19760, 108, 28595, 25693, 21067, 12945, 14344, 21613, 22984, 14761, 31055, 32785, 11442, 15666, 39964, 28146, 23418, 29313, 4438, 35146, 15670, 30438, 17109, 33047, 23698, 22432, 39559, 27365, 10189, 39609, 4058, 19886, 35547, 20287, 11365, 25283, 15781, 32075, 14751, 21121, 3324, 17039, 15179, 131, 18078, 15419, 6884, 299, 29893, 31476, 6024, 25985, 36149, 27028, 25337, 16395, 12260, 13460, 3271, 28449, 38868, 9607, 8533, 5394, 28079, 38232, 10547, 20515, 22117, 23573, 27307, 3197, 34571, 27576, 39669, 39594, 8147, 34880, 20139, 19471, 3079, 38067, 14204, 11210, 8271, 33690, 13140, 21991, 3401, 19539, 7623, 27259, 35492, 22621, 20729, 35636, 30389, 12850, 14583, 18943, 24640, 27470, 9968, 7036, 28514, 17060, 23560, 14564, 33472, 8788, 26775, 30520, 3098, 39046, 23976, 26033, 32416, 28488, 14387, 34194, 14458, 10900, 9846, 39494, 30008, 7890, 21201, 22531, 14119, 8398, 8987, 39561, 28844, 38573, 9386, 2944, 18094, 35497, 9301, 7135, 35871, 2964, 19719, 31706, 19743, 4478, 23723, 9792, 5056, 32292, 14807, 19255, 3831, 1960, 25888, 33048, 19714, 12820, 13561, 36612, 19737, 16104, 8252, 11679, 27586, 20548, 19595, 10974, 9105, 6345, 13366, 26541, 9168, 15259, 19089, 9965, 25391, 36240, 20952, 33478, 25635, 12863, 36500, 19324, 8204, 13086, 28693, 23250, 19058, 35002, 28741, 8070, 15385, 39107, 18063, 30112, 11458, 13267, 27993, 28214, 38642, 24099, 21702, 26812, 32573, 30501, 15000, 28498, 20617, 8101, 18417, 32680, 32977, 6260, 22437, 10945, 29569, 25465, 9054, 11003, 8064, 34114, 16012, 25662, 2223, 4803, 36548, 17177, 16111, 25521, 24615, 23993, 8256, 22894, 38398, 2209, 4223, 6909, 21261, 14313, 31049, 12173, 35785, 36499, 12251, 23009, 36713, 9041, 17423, 8530, 34163, 39918, 24355, 11223, 7519, 32948, 14729, 26951, 18606, 18163, 17288, 1726, 29321, 6055, 18694, 38796, 6986, 15959, 3475, 39095, 4418, 9736, 25988, 30598, 17877, 3215, 5595, 19428, 14071, 9008, 10231, 9820, 32758, 13294, 28573, 26736, 18544, 22643, 35612, 37631, 4372, 11247, 9098, 10503, 25155, 2741, 25923, 37694, 11555, 36059, 38915, 17557, 17946, 22800, 7360, 24547, 15232, 22684, 9209, 4258, 8107, 23039, 34191, 12094, 20853, 29775, 13531, 1647, 18294, 16248, 7814, 19977, 34382, 6365, 10682, 1187, 33282, 6109, 14803, 20114, 1883, 31481, 10211, 19519, 7580, 10788, 32331, 10988, 14596, 12288, 17037, 22144, 2191, 28328, 24699, 19230, 7752, 23421, 19967, 24459, 4061, 1452, 32890, 39477, 15206, 4580, 30237, 23329, 4231, 38631, 29039, 8499, 31513, 25579, 32855, 39261, 22348, 30213, 32028, 33703, 10110, 33030, 23609, 27322, 5689, 1283, 37813, 9445, 37519, 18538, 38454, 19207, 12406, 4735, 24678, 18047, 30632, 10222, 13430, 21909, 23563, 37225, 4338, 8346, 29834, 1095, 2646, 3748, 19149, 16518, 21187, 1004, 24113, 22353, 39024, 22438, 8078, 6905, 20470, 179, 6141, 29013, 33510, 31238, 39674, 14475, 38344, 35155, 28705, 2929, 17593, 15236, 35452, 3247, 37951, 30338, 36320, 29173, 39729, 18167, 35561, 25059, 17363, 1680, 14293, 2956, 36272, 7909, 766, 10034, 5660, 11801, 6067, 6265, 15955, 26779, 37978, 1699, 30227, 23861, 21889, 32239, 28235, 7798, 21343, 28802, 16964, 16218, 19957, 9940, 807, 33631, 10780, 33813, 25962, 6393, 2193, 18191, 2252, 37650, 3973, 25659, 22107, 6312, 4648, 33768, 12756, 4007, 6059, 25170, 14340, 14108, 27926, 16189, 17102, 5133, 38683, 32222, 15430, 3001, 38242, 31470, 17276, 4393, 12247, 35812, 4147, 13254, 14236, 33086, 19395, 32214, 21036, 7845, 19846, 643, 8225, 13873, 15957, 18245, 5891, 24454, 23310, 14173, 36037, 28417, 16002, 22967, 7884, 2783, 30860, 21075, 38318, 9506, 248, 35664, 19860, 1289, 31514, 16596, 31320, 30546, 4114, 27323, 38489, 5982, 10998, 16300, 7993, 37063, 21264, 18042, 7919, 39811, 24508, 19913, 2200, 13235, 10959, 13138, 2380, 2521, 35393, 1414, 15982, 25306, 5146, 3270, 19505, 8621, 12498, 14051, 31386, 24486, 9433, 28713, 39904, 19524, 21393, 16303, 31506, 8029, 19894, 31691, 11060, 35683, 8965, 15421, 38051, 8449, 18652, 967, 12899, 21919, 22641, 12728, 5810, 22901, 37173, 39722, 23044, 14384, 37147, 26895, 144, 16286, 14646, 8055, 37094, 13381, 29605, 21951, 23361, 8618, 32325, 22033, 422, 519, 38474, 9913, 21948, 27487, 4708, 173, 16129, 26150, 27102, 34380, 26270, 2764, 840, 20768, 35541, 35646, 34184, 31832, 6680, 1268, 11661, 35122, 16433, 14200, 16570, 1332, 8206, 26503, 32151, 16928, 29556, 38771, 38157, 21801, 7016, 37613, 28765, 38624, 26321, 19250, 25949, 5512, 31728, 30258, 6719, 33053, 8073, 12806, 6847, 19049, 11269, 23912, 33808, 15120, 32987, 37794, 2468, 38785, 26371, 25290, 11731, 9621, 19475, 243, 17226, 17674, 5094, 11799, 16310, 20835, 31774, 28404, 25265, 19202, 4461, 20383, 15374, 27205, 28164, 9398, 21571, 22629, 32283, 12278, 28120, 26971, 11796, 3642, 27553, 16771, 27238, 11501, 18881, 1805, 21638, 5435, 1368, 10741, 7488, 2875, 26695, 11604, 8991, 4890, 3835, 15464, 18865, 5985, 31236, 31361, 17968, 27411, 39310, 3188, 484, 34961, 8756, 36831, 24334, 21018, 35388, 32298, 16376, 13462, 438, 30247, 24472, 25019, 15190, 22410, 30294, 30054, 37234, 30704, 12545, 24383, 21574, 36161, 14543, 11132, 35673, 36048, 8833, 33276, 26975, 39823, 11235, 14274, 23677, 34361, 4650, 10962, 3592, 30407, 15535, 1949, 22275, 2068, 30504, 28812, 14649, 358, 4661, 38832, 34908, 39704, 9854, 38273, 18084, 27115, 37483, 29689, 20395, 33862, 16269, 36280, 8350, 17471, 33240, 12731, 36512, 36510, 39523, 26699, 35990, 13484, 23915, 24312, 36212, 34090, 19914, 31170, 30730, 5605, 31992, 31480, 35841, 10119, 8162, 23637, 30803, 25535, 4784, 13706, 21619, 28624, 23674, 22222, 39542, 36892, 17327, 15135, 16014, 8535, 4321, 12054, 30292, 19674, 4407, 27195, 2389, 14326, 4627, 13881, 24672, 16587, 6456, 10530, 4195, 9239, 18876, 18848, 3924, 5992, 35895, 26034, 33436, 13220, 4903, 12201, 21093, 8804, 10828, 29220, 9055, 11277, 7657, 38730, 17306, 16720, 4673, 15148, 28052, 30480, 7435, 14161, 12407, 23872, 18304, 37853, 39837, 29188, 37165, 35582, 7915, 37304, 21157, 32372, 18788, 22765, 33854, 17147, 39949, 37112, 22981, 18888, 35112, 37351, 31120, 2162, 34868, 37632, 27574, 2141, 36573, 10232, 32789, 418, 18572, 5412, 9808, 795, 4994, 25445, 10051, 22068, 37793, 25089, 27306, 39928, 23042, 1828, 20864, 32636, 29336, 5384, 6720, 38505, 17201, 29108, 32104, 24994, 14401, 24203, 6294, 1864, 38535, 32071, 17318, 17798, 32141, 39200, 27913, 9632, 32712, 29240, 30701, 9703, 2053, 9359, 7491, 15516, 35482, 15499, 828, 13810, 14908, 11221, 24098, 32845, 7831, 23681, 18723, 27531, 32861, 15880, 11276, 33287, 30945, 28656, 345, 17530, 23693, 5793, 35167, 4430, 30586, 1551, 2216, 13283, 13141, 18746, 14705, 9169, 595, 16361, 27278, 38843, 27930, 420, 220, 22046, 36465, 32866, 1279, 5276, 25907, 5026, 33563, 26000, 38285, 21328, 18827, 39533, 22942, 23957, 2217, 23133, 33626, 10243, 25368, 3978, 18172, 25138, 39314, 30651, 12982, 16068, 22538, 8130, 31765, 24170, 39782, 12600, 3722, 23055, 5052, 29854, 27506, 5690, 33802, 16842, 26829, 28109, 17090, 26627, 37780, 18784, 24584, 36329, 38777, 234, 11297, 13554, 12172, 3426, 27821, 4859, 36044, 32909, 14157, 23572, 32133, 24570, 39371, 3817, 39638, 27126, 19556, 5670, 7312, 12332, 37895, 25417, 36910, 36642, 2048, 24407, 29168, 24379, 26777, 28915, 14902, 7881, 4656, 7322, 23544, 37783, 17552, 28973, 4734, 16439, 16034, 28634, 24043, 30430, 11112, 21748, 18911, 7234, 5923, 8748, 26292, 30041, 39480, 15371, 30829, 4524, 33942, 21438, 27118, 36267, 684, 27541, 11206, 39172, 16646, 13555, 27980, 1117, 20858, 14939, 19283, 7839, 5572, 2301, 16180, 31494, 15844, 10177, 7823, 4479, 12240, 10936, 3050, 18895, 17761, 3849, 21938, 5599, 20779, 1903, 35000, 38722, 35622, 24565, 35692, 31916, 19610, 17793, 37685, 13035, 32303, 17003, 39991, 38723, 13369, 6012, 22985, 29650, 24866, 23816, 1432, 20273, 32886, 26136, 23893, 12177, 9992, 28480, 36514, 14208, 10978, 35639, 18339, 35686, 4964, 36129, 34832, 31125, 8426, 18677, 34565, 7697, 38880, 27152, 5641, 27294, 32468, 26130, 9960, 36480, 30680, 28996, 34315, 28890, 16164, 37113, 14318, 30306, 9093, 14750, 22839, 8682, 5127, 20971, 22457, 35211, 15932, 15113, 12143, 731, 35365, 8839, 2060, 1649, 4501, 6477, 38917, 3489, 31868, 7735, 8232, 22773, 34275, 19525, 34523, 20407, 21742, 26569, 26913, 36292, 9635, 1873, 39269, 31753, 5047, 7355, 13230, 15219, 60, 3309, 30038, 13422, 32099, 22594, 32804, 1014, 35799, 11294, 22272, 26688, 21703, 15720, 2168, 32626, 24809, 21065, 20518, 21353, 16955, 25070, 14217, 2883, 23857, 5869, 20558, 16856, 7303, 9933, 39382, 13666, 26007, 3096, 3795, 3334, 11565, 25386, 5768, 11391, 36707, 35163, 34830, 2046, 17958, 31860, 26201, 36211, 4117, 22506, 7147, 29808, 1217, 8359, 9372, 33262, 37787, 10639, 290, 20701, 28247, 13489, 9883, 22699, 32087, 5463, 24641, 36975, 8766, 36170, 13910, 14603, 15675, 29430, 2904, 14512, 4028, 35551, 32989, 17108, 37231, 25879, 4724, 21293, 9806, 25829, 33680, 33638, 26757, 13888, 10832, 15372, 21990, 4426, 32770, 32406, 23801, 25463, 35330, 21267, 34886, 24592, 35535, 1166, 37815, 26316, 31964, 14024, 9490, 27973, 28283, 29862, 28955, 5997, 14581, 32031, 26200, 34026, 21229, 11400, 19021, 35335, 30593, 3555, 7740, 26838, 5090, 2539, 14857, 34251, 9567, 9470, 12191, 12527, 10073, 25537, 35035, 39604, 31934, 9478, 8561, 32234, 32852, 11233, 6932, 21769, 34748, 39150, 946, 29056, 34398, 15485, 35980, 33773, 25628, 5207, 11997, 16349, 20134, 5395, 3713, 24210, 26570, 13815, 22851, 16517, 23936, 7379, 38190, 22393, 24076, 24507, 29782, 34974, 451, 19292, 20847, 38562, 20778, 12636, 31016, 3580, 39456, 20654, 37141, 9293, 12255, 6611, 12651, 28242, 6004, 17089, 1363, 10066, 17074, 15491, 4348, 1549, 38961, 31099, 31764, 35904, 24084, 7381, 24353, 4506, 25730, 8223, 6972, 17219, 22814, 22741, 25140, 29285, 8410, 27740, 31780, 16351, 27292, 39464, 21784, 27840, 27564, 13091, 5726, 15544, 33067, 16707, 35123, 4403, 18016, 35381, 36431, 28103, 8877, 16150, 30364, 8524, 12643, 33132, 19323, 15074, 14348, 34268, 11131, 30548, 25696, 1081, 21822, 4678, 22798, 8705, 17461, 11721, 8099, 39987, 9731, 38142, 25960, 29133, 38936, 25686, 6710, 38827, 27905, 355, 3513, 28750, 16469, 24847, 24396, 20479, 3950, 22321, 428, 10062, 29619, 21043, 5550, 34159, 14495, 11092, 608, 38194, 1994, 36296, 17601, 19514, 5177, 278, 35979, 2619, 3598, 6363, 39031, 8776, 11175, 5951, 16233, 23298, 20922, 27604, 20075, 21196, 27636, 37114, 4518, 11654, 6558, 21773, 12539, 13319, 9109, 20418, 37391, 9787, 2334, 17344, 8715, 30714, 24006, 4453, 13344, 22151, 22518, 10655, 19873, 27987, 12353, 14170, 3229, 27070, 4536, 13412, 30062, 13226, 123, 10076, 27869, 20582, 12679, 19466, 2425, 26676, 18106, 20905, 1075, 27130, 35326, 4267, 30811, 1861, 9280, 2694, 2283, 36648, 25668, 39767, 11989, 30371, 9646, 17179, 10387, 35826, 13305, 6631, 14127, 6897, 24773, 7008, 31188, 13372, 1364, 8885, 25630, 18355, 217, 24192, 10577, 27935, 22374, 13890, 30723, 32070, 4397, 39155, 22728, 13046, 35710, 31827, 2256, 18364, 36153, 3762, 4556, 34069, 9246, 7128, 16116, 11416, 31623, 9306, 35104, 10406, 8679, 1443, 7788, 8762, 32542, 24104, 29416, 38787, 37937, 3012, 6635, 28808, 507, 29257, 10803, 5105, 18348, 25924, 13825, 24895, 21945, 24860, 17728, 25267, 1481, 6819, 23710, 31079, 629, 13717, 35682, 27363, 28135, 11116, 33024, 8815, 14617, 16305, 13821, 18183, 2508, 29388, 7975, 22855, 9617, 12324, 18733, 29788, 3987, 16418, 7177, 24143, 23407, 37053, 35320, 6247, 6197, 10007, 20083, 34691, 14113, 18974, 10473, 29684, 23975, 602, 22471, 23914, 36519, 7713, 10220, 7118, 23984, 23135, 4130, 28645, 29109, 2319, 13749, 7317, 20500, 23747, 36581, 17181, 4733, 19046, 31784, 30693, 23393, 1113, 31477, 23343, 39104, 9882, 23309, 64, 38104, 33107, 13711, 6705, 37137, 38519, 34422, 7808, 14806, 1813, 2442, 1032, 39320, 17517, 37080, 3326, 33377, 3568, 3536, 36552, 33664, 12553, 15276, 54, 33972, 7863, 37, 31347, 23131, 8545, 13880, 34596, 3553, 26666, 3718, 3425, 30535, 31562, 5373, 13789, 20033, 37702, 16354, 6005, 27625, 8662, 27347, 37506, 7927, 18534, 30400, 23153, 29951, 31089, 32611, 11208, 34025, 19051, 39185, 35768, 4999, 14774, 3879, 128, 26912, 30913, 25627, 13559, 34715, 20485, 25015, 14045, 13995, 7703, 6221, 6228, 737, 35418, 8318, 12349, 36408, 31187, 37149, 22819, 32549, 31032, 2616, 24320, 14069, 36503, 11694, 4877, 15453, 1341, 2080, 29315, 21434, 32930, 28585, 22267, 6499, 17333, 7834, 7777, 37683, 25009, 25526, 15994, 24331, 4230, 31168, 16904, 28326, 39689, 39253, 26036, 33064, 28719, 38560, 36816, 5972, 38963, 2800, 37608, 7521, 34162, 35027, 30158, 26289, 26450, 14451, 26363, 10371, 10451, 29718, 18617, 683, 37065, 29885, 7438, 22909, 2164, 24328, 10568, 20190, 11433, 13411, 12909, 2840, 39889, 6411, 3890, 2848, 5880, 4866, 8362, 25941, 26082, 36639, 29107, 16098, 4006, 16505, 35507, 9780, 16223, 19441, 37185, 27932, 24711, 28218, 12356, 9639, 38453, 33499, 7291, 27977, 11144, 6506, 26638, 32143, 533, 26716, 22174, 30320, 34235, 23685, 26042, 29645, 8376, 11107, 24377, 21923, 32745, 27687, 16560, 17830, 22434, 31769, 13752, 32322, 33142, 15217, 2352, 4314, 13713, 34637, 9666, 11725, 5981, 27645, 39917, 20635, 39688, 32392, 30539, 38993, 15327, 32752, 13336, 14171, 27991, 33246, 5371, 10171, 5262, 6414, 4085, 7354, 12307, 26275, 12753, 21284, 36155, 1568, 22389, 1993, 22548, 9752, 6777, 38566, 37602, 6473, 11370, 23850, 10902, 22077, 10862, 1160, 30594, 38114, 38918, 31039, 39157, 26721, 30752, 28217, 21869, 5556, 22366, 18786, 29324, 36889, 26670, 27289, 6774, 12653, 37038, 30165, 2381, 305, 1715, 29600, 32074, 17068, 13004, 9754, 17974, 21981, 34624, 3463, 30022, 9865, 22360, 21301, 4860, 36953, 28071, 32432, 8541, 11182, 19912, 25309, 31862, 14035, 4308, 25099, 10283, 22710, 7774, 39222, 4743, 12444, 26099, 36731, 26910, 18832, 17431, 31636, 24527, 10279, 8905, 3979, 5012, 21846, 28933, 1774, 19817, 19951, 10990, 11046, 6760, 5886, 21026, 7145, 3757, 9417, 35343, 19222, 17988, 39251, 20629, 18963, 13364, 7278, 30441, 32642, 22149, 29150, 5631, 20572, 5274, 14900, 27897, 3242, 28716, 36195, 18632, 8782, 13206, 5111, 33678, 27478, 2132, 11623, 17655, 12387, 19289, 22045, 33963, 26896, 35542, 38182, 22809, 970, 27995, 37166, 6775, 1582, 34019, 18604, 35884, 2035, 12881, 15768, 12481, 21131, 12725, 13536, 18790, 13606, 2983, 6259, 9836, 28556, 35165, 23505, 13809, 29573, 12245, 36433, 4095, 8855, 380, 36579, 22095, 11421, 15008, 30756, 22715, 31500, 5731, 18909, 37440, 36505, 3048, 26861, 2346, 27038, 10566, 12547, 3776, 13262, 13945, 14243, 32009, 27867, 11274, 700, 16209, 3395, 33131, 26091, 14682, 16883, 34310, 6035, 16634, 15168, 10350, 3813, 37897, 14002, 15879, 18532, 17332, 3933, 30135, 17738, 29238, 25253, 26553, 17476, 9446, 14021, 38846, 3131, 30637, 7889, 15902, 18070, 16664, 23822, 29178, 8657, 252, 3692, 23649, 12836, 4850, 24316, 15893, 19758, 24642, 11960, 32106, 34757, 32794, 32879, 36763, 37059, 32608, 12548, 33075, 6322, 2353, 23067, 15204, 21586, 28599, 20064, 10835, 8017, 23597, 3562, 12990, 29708, 26839, 27333, 35565, 13078, 27677, 3939, 17556, 32006, 3362, 33414, 8427, 2787, 3213, 6619, 39829, 9516, 10207, 19459, 19125, 8764, 3867, 38958, 10764, 36789, 35640, 35846, 23046, 33895, 35930, 34075, 18479, 13777, 27688, 21025, 23550, 2609, 579, 6387, 34893, 30352, 7974, 1811, 11505, 21732, 24450, 27891, 28161, 1446, 15610, 24014, 38189, 20706, 26720, 3488, 16198, 16297, 2560, 9388, 17776, 18996, 33455, 25511, 18278, 25107, 20469, 17183, 13991, 3, 26478, 14874, 17128, 14298, 5408, 39960, 3312, 23030, 37529, 22483, 3451, 22977, 37145, 22585, 4514, 10437, 39617, 6820, 26604, 31137, 23441, 20346, 721, 17000, 5050, 1099, 11130, 20489, 18792, 27212, 10954, 12195, 32182, 5467, 10999, 10462, 27475, 8913, 19602, 17414, 25217, 39195, 18484, 14953, 21680, 25803, 11929, 17399, 11476, 35336, 10923, 6451, 15313, 27741, 5878, 12667, 37644, 28563, 9548, 6606, 17756, 5494, 1199, 33362, 6100, 32155, 39295, 31454, 11815, 35941, 39854, 10278, 15400, 20814, 3029, 28441, 14345, 5668, 6485, 5032, 19092, 11313, 575, 2651, 17351, 36268, 3125, 3811, 22418, 28578, 5413, 18761, 27552, 27268, 32413, 24182, 29342, 8333, 11156, 37522, 33959, 6261, 7258, 11126, 6479, 37627, 25972, 9324, 14737, 23342, 4463, 16460, 22135, 34245, 27705, 13556, 27762, 27248, 26580, 32254, 4670, 35584, 10602, 3376, 8854, 28030, 13042, 39236, 13090, 4901, 22473, 12312, 30114, 31080, 13340, 25353, 34806, 2636, 4868, 26481, 1211, 25933, 16953, 8591, 7162, 462, 15176, 24126, 37130, 20293, 21271, 39766, 37453, 10774, 18545, 39289, 14959, 29157, 33199, 31566, 5124, 12578, 27200, 34960, 27334, 10717, 20509, 12543, 1427, 7149, 9540, 20849, 18793, 16510, 21649, 34182, 32462, 23122, 2861, 21332, 31015, 39634, 10981, 5519, 24061, 10407, 25761, 29112, 3032, 10088, 1810, 2493, 13487, 16503, 10367, 31722, 33123, 13376, 35070, 8824, 16610, 21291, 27469, 7543, 10445, 33964, 8409, 13003, 263, 20618, 10364, 17364, 14714, 577, 8019, 9879, 7384, 15692, 12400, 540, 24883, 13579, 20406, 26967, 30890, 34877, 11816, 35183, 29810, 9993, 39270, 32600, 10859, 676, 27433, 35906, 33701, 16083, 2644, 38074, 5912, 9798, 36022, 4842, 21496, 20631, 25789, 6852, 19115, 27135, 8430, 26234, 6375, 33713, 15169, 6742, 225, 39026, 34472, 34404, 27460, 8967, 9955, 13433, 29310, 11366, 23123, 15396, 10183, 28376, 1834, 1072, 16629, 36818, 34594, 14661, 1520, 26998, 26765, 21220, 20784, 13321, 35156, 27982, 23243, 13358, 15922, 12564, 2695, 29770, 6052, 30365, 6560, 26948, 18661, 34302, 36981, 1955, 13578, 9121, 4552, 38590, 22061, 29018, 15552, 8726, 16258, 8653, 6224, 35357, 31060, 39379, 18447, 26098, 12075, 38043, 10676, 5724, 6520, 17024, 3650, 31990, 31712, 39254, 25791, 32438, 36776, 39414, 25794, 449, 15443, 2583, 25976, 37646, 14100, 6907, 36202, 2802, 26902, 13440, 23415, 12447, 9110, 7765, 30429, 6359, 4178, 22059, 2077, 27464, 37229, 32599, 10080, 35934, 17802, 39343, 32401, 37029, 29365, 38117, 2874, 36521, 16900, 19090, 10858, 39359, 8418, 35331, 32314, 32513, 4337, 15669, 28993, 2755, 3591, 21818, 4287, 5135, 39042, 38414, 17404, 37558, 37459, 4737, 16145, 16475, 337, 29081, 26923, 2921, 6346, 12224, 19687, 5597, 10686, 38007, 3516, 22403, 13166, 20589, 17487, 35334, 12092, 3631, 26936, 37045, 21446, 32043, 16193, 14224, 23388, 38669, 26964, 6653, 31772, 20059, 18025, 29530, 39482, 14717, 11703, 752, 1542, 31092, 2084, 16763, 8671, 11403, 39033, 11596, 8507, 13871, 28900, 13652, 10667, 12239, 32108, 7232, 33052, 3517, 34172, 16754, 8287, 38812, 17127, 6999, 31251, 3313, 14210, 17502, 13190, 13856, 27184, 13282, 17700, 19193, 11853, 30615, 37095, 19569, 8485, 23377, 3209, 19402, 2911, 3441, 20943, 39955, 38382, 3072, 23761, 8850, 28166, 1291, 34639, 38970, 21324, 12855, 35954, 356, 18856, 28912, 29590, 8002, 1433, 20650, 37761, 35956, 17131, 8058, 16378, 17630, 20490, 28327, 34292, 29125, 11983, 17891, 12026, 11167, 3447, 22494, 3763, 14355, 8517, 33739, 33740, 20992, 22568, 18768, 4206, 10867, 27053, 4059, 20264, 9164, 33018, 39708, 4459, 36262, 16142, 16628, 19191, 36401, 16364, 9140, 12218, 819, 14461, 18117, 7412, 17679, 38333, 11546, 19206, 30790, 26834, 4980, 33537, 37244, 20314, 148, 19203, 17910, 34104, 12015, 4711, 4027, 20727, 16435, 8908, 19904, 267, 10064, 12645, 15562, 23296, 34494, 22023, 25405, 4129, 24490, 27100, 26507, 13328, 14242, 31889, 35236, 13285, 16675, 21141, 2409, 28250, 7198, 13215, 36456, 19922, 16907, 23759, 826, 16186, 27490, 32783, 39541, 15405, 18568, 22186, 34749, 30630, 26188, 39514, 6258, 29644, 12874, 27225, 26851, 960, 11282, 22655, 37487, 17080, 13960, 17852, 3112, 15934, 24976, 1391, 19117, 724, 24942, 22227, 2853, 12100, 17369, 19824, 17532, 37874, 24679, 33089, 12368, 15030, 14104, 7700, 13000, 11928, 15962, 28847, 29311, 22891, 29798, 21726, 13985, 26723, 21570, 1724, 35239, 24278, 38431, 25592, 33424, 12857, 4865, 37108, 23273, 30550, 23854, 17965, 16292, 34425, 14183, 4674, 2034, 2180, 20449, 8808, 21888, 21788, 24214, 25752, 36056, 30091, 159, 33156, 1212, 31283, 25323, 34002, 26438, 33383, 20751, 14871, 18312, 16162, 16595, 5316, 32177, 14209, 3789, 11631, 39589, 12016, 12956, 21967, 9022, 27412, 13330, 24886, 12885, 13538, 25621, 25396, 9492, 2871, 15700, 39055, 28346, 4332, 7918, 11582, 2691, 36974, 27042, 34795, 15037, 2390, 1530, 36398, 6581, 39127, 27450, 29635, 37625, 14309, 8649, 39340, 14544, 28575, 28050, 16262, 4052, 22775, 9709, 8214, 3289, 11380, 22153, 16784, 1644, 29482, 38034, 37416, 18346, 24680, 11495, 25564, 24605, 9775, 19617, 37765, 17559, 13157, 5790, 18897, 28574, 8865, 13648, 27094, 24550, 5283, 6562, 30988, 29559, 27146, 14867, 15312, 9747, 18847, 3470, 11987, 36414, 39430, 6980, 30807, 78, 36950, 5956, 3665, 21042, 6469, 15174, 34366, 13405, 25760, 35144, 1486, 13142, 8374, 20555, 28746, 14607, 30787, 30747, 4203, 17419, 24867, 11856, 26611, 5063, 14854, 31991, 21037, 17397, 38459, 29019, 25269, 29901, 28349, 17343, 22404, 29655, 18271, 33595, 11933, 35016, 25749, 9783, 13253, 31750, 12328, 18973, 10416, 19692, 33788, 21219, 19680, 37005, 25881, 21622, 12894, 26340, 28636, 5380, 21010, 24625, 16196, 7937, 15999, 6436, 27966, 141, 37222, 5645, 25413, 37424, 28280, 33573, 26355, 31274, 12234, 32819, 5189, 30514, 14, 29673, 24244, 26969, 6942, 28456, 36678, 33252, 31898, 35217, 18092, 13089, 8637, 9771, 8873, 36528, 31565, 22346, 3628, 30328, 6271, 22317, 4705, 35989, 19810, 4829, 18010, 23069, 21543, 11240, 37724, 1958, 15945, 24727, 5083, 28361, 23143, 17896, 29011, 38645, 24324, 29629, 4222, 21706, 13353, 15468, 12262, 17518, 16093, 10250, 3156, 1163, 31363, 28838, 16049, 25702, 30101, 6779, 289, 19607, 30069, 38250, 25842, 16544, 1589, 35093, 10006, 1959, 37257, 34834, 16986, 2624, 23953, 35473, 9456, 34460, 28359, 31963, 14379, 14947, 37037, 3282, 14090, 5778, 16624, 9281, 25442, 21614, 11499, 2234, 22759, 39220, 25464, 9707, 6547, 35607, 22603, 28962, 13964, 19941, 15091, 28272, 34807, 29281, 39793, 7449, 34178, 13429, 23278, 11110, 30033, 1972, 15665, 4815, 30742, 24029, 29319, 36971, 27882, 3779, 5775, 13068, 33338, 25862, 29647, 32518, 30739, 2668, 13887, 14716, 31068, 15969, 9917, 14739, 17722, 39675, 13200, 28384, 12583, 21330, 34149, 25090, 21675, 20680, 7041, 15146, 25200, 23051, 37800, 14832, 2602, 8953, 30255, 38128, 32672, 31510, 21767, 29036, 4904, 26985, 4806, 36767, 34318, 4977, 1543, 29477, 21430, 20938, 3902, 16559, 28734, 3816, 18069, 6538, 24559, 13058, 26751, 10381, 20471, 8536, 17909, 8032, 26850, 12546, 1877, 11231, 29212, 23874, 31133, 21912, 28768, 28928, 10551, 8927, 12633, 35091, 14516, 4879, 21305, 87, 27598, 39383, 8347, 5017, 8880, 14195, 36135, 30040, 21581, 12454, 39327, 5370, 6162, 15637, 32033, 7104, 16087, 15777, 24229, 24453, 11375, 19863, 16314, 864, 23539, 7764, 38559, 14445, 6395, 28222, 20869, 31112, 13357, 23288, 12448, 19778, 39184, 9253, 7459, 16229, 33243, 24294, 32947, 28209, 28703, 17339, 29667, 20782, 4408, 4373, 8151, 10523, 25482, 8560, 12502, 9106, 37013, 18442, 22736, 12941, 33042, 26750, 10170, 22744, 1540, 39286, 12333, 5530, 2957, 33936, 14848, 7249, 24768, 38878, 16215, 32405, 12946, 33864, 30204, 23066, 8059, 28779, 27209, 29439, 7197, 23249, 15551, 29451, 3564, 25181, 2775, 34200, 25237, 6977, 39956, 25209, 245, 8, 19880, 24911, 16755, 1627, 20236, 16855, 281, 39301, 24496, 29833, 28805, 30809, 25073, 29844, 21606, 3967, 848, 35721, 19706, 36560, 14856, 11443, 29258, 25023, 10920, 31, 6740, 10427, 5337, 4544, 12473, 18273, 4683, 29140, 1348, 11672, 31571, 32209, 8997, 33629, 36876, 7942, 20704, 32449, 20049, 34096, 13498, 10496, 3946, 8274, 19660, 19081, 525, 29174, 18303, 495, 23951, 2199, 27217, 16317, 30049, 12584, 35358, 22273, 7556, 20189, 2679, 10166, 32273, 31896, 20005, 30842, 36057, 17908, 7642, 38906, 28150, 5231, 37305, 14136, 7758, 19765, 781, 32111, 5232, 16122, 36286, 7644, 2340, 34301, 28669, 37670, 5034, 26052, 19616, 26690, 29888, 36270, 35413, 35696, 13188, 2102, 23790, 7605, 19059, 36694, 18755, 14031, 34418, 349, 37136, 7736, 14550, 13963, 26804, 33069, 38630, 17204, 37163, 24796, 9628, 2623, 16564, 7653, 34329, 18013, 7245, 18773, 17758, 32870, 34226, 5590, 12365, 21398, 18180, 5035, 34829, 18426, 664, 19070, 15131, 28754, 10263, 16981, 32238, 9612, 18649, 18345, 7586, 33444, 8243, 1978, 9652, 27910, 410, 3543, 257, 19226, 33687, 12182, 5014, 27823, 16766, 39394, 32062, 29126, 38838, 38758, 3301, 1257, 8818, 27526, 28618, 653, 36800, 11186, 2029, 13001, 39072, 5615, 25393, 9701, 1570, 6117, 36124, 10556, 35285, 39091, 14228, 36812, 24808, 27071, 32589, 17029, 2966, 37768, 25853, 3124, 6429, 5156, 2019, 8174, 29224, 32057, 28032, 14728, 1074, 30560, 17012, 414, 4049, 19297, 11420, 30992, 1491, 30001, 25747, 4168, 22066, 16572, 18511, 7790, 24131, 10148, 31413, 29273, 24230, 20720, 1107, 36596, 5345, 13988, 9561, 36204, 16396, 2214, 27157, 661, 21798, 33905, 18429, 33153, 17825, 1184, 24124, 26771, 17614, 9187, 15098, 14292, 21890, 34975, 16638, 24315, 34635, 29340, 33318, 39291, 15392, 16571, 35249, 39784, 27059, 7356, 16815, 15752, 9868, 2, 11689, 37925, 39461, 37456, 18401, 20526, 13034, 39490, 30713, 3327, 16769, 39067, 27139, 39041, 37278, 16776, 25607, 18844, 13965, 11640, 33525, 24594, 18999, 10804, 34252, 31050, 32157, 16831, 4069, 1118, 20152, 23925, 19850, 18316, 4237, 3452, 32044, 9718, 27696, 4961, 5679, 19214, 13744, 37585, 1460, 3653, 32237, 13984, 10991, 18884, 22159, 26584, 21137, 7687, 13332, 34051, 39198, 37039, 26209, 9658, 10784, 1840, 19710, 16415, 9479, 24053, 5273, 3892, 4044, 8494, 20753, 38744, 17773, 10103, 7568, 17013, 30218, 37677, 21370, 13946, 27301, 14488, 13268, 32328, 427, 16984, 19508, 27163, 15129, 24395, 30340, 23929, 21920, 25222, 11154, 5593, 37207, 26348, 12695, 8753, 20286, 39827, 17295, 37322, 17465, 23675, 32591, 34958, 15736, 39001, 35366, 22347, 14076, 25867, 15044, 2828, 1859, 31739, 7671, 20786, 38079, 23871, 12790, 16344, 5199, 38081, 22492, 11291, 6071, 37599, 21053, 19543, 22799, 23223, 35716, 9205, 7949, 18349, 37104, 34636, 22423, 4404, 7313, 11260, 24034, 19954, 24772, 10677, 22244, 13407, 8006, 15748, 34852, 28024, 23476, 23531, 33784, 20478, 19861, 16148, 8851, 27465, 14431, 13609, 38243, 34414, 33725, 14580, 25566, 3199, 15701, 11176, 9997, 16995, 16124, 13373, 35645, 11379, 2675, 6505, 24364, 9618, 21922, 24815, 19715, 3004, 31443, 21837, 11641, 22054, 35722, 30669, 12189, 27692, 12012, 714, 20503, 28081, 28551, 14407, 22869, 31493, 24724, 26299, 19305, 4752, 10710, 20877, 16685, 22733, 14253, 29236, 37671, 18938, 37001, 27567, 21045, 11296, 20138, 16419, 9877, 36990, 12906, 31874, 34554, 13616, 35059, 6104, 36582, 174, 19378, 26273, 9088, 19994, 15607, 28137, 17765, 17677, 6634, 17152, 37482, 25026, 8085, 21724, 27611, 9878, 7439, 4632, 1422, 16458, 39830, 35212, 26222, 29017, 9662, 1097, 8405, 1664, 16446, 8660, 20811, 29120, 10679, 10671, 2233, 27668, 21527, 34151, 14535, 11333, 38317, 11162, 27161, 31866, 14301, 23003, 31393, 20725, 1115, 39841, 34928, 4234, 18472, 25152, 38762, 8007, 14396, 29506, 10596, 17078, 27744, 10153, 26916, 12763, 18902, 1619, 13148, 10205, 21303, 3378, 13932, 10883, 26635, 4165, 19509, 23350, 38982, 5436, 746, 26661, 33755, 24612, 13370, 35403, 31202, 20910, 31577, 27107, 38143, 445, 19949, 14998, 30510, 25324, 29413, 32715, 10097, 9781, 26072, 34938, 6525, 32096, 38301, 3292, 31948, 14089, 39859, 25058, 20906, 5925, 38152, 3860, 13859, 22271, 13083, 13466, 19163, 26781, 31710, 16580, 9210, 24446, 15398, 33070, 15245, 19654, 12449, 29496, 3261, 16312, 33682, 3238, 27569, 7092, 10484, 16814, 23018, 16721, 32840, 17065, 21903, 20874, 36715, 36312, 3113, 39087, 6305, 35135, 17590, 35107, 1185, 35203, 9213, 25598, 29755, 15596, 16411, 25996, 10424, 35043, 31116, 12007, 36234, 10769, 13928, 23626, 5055, 36277, 24687, 20757, 26322, 21530, 17780, 4483, 23963, 527, 28428, 23620, 36635, 38221, 3352, 5449, 35588, 23499, 32450, 3766, 5179, 16405, 7409, 28309, 33245, 7838, 27974, 28884, 5720, 7976, 28841, 14185, 9523, 3163, 2982, 30719, 27472, 17271, 5941, 346, 29031, 7689, 20290, 25864, 37863, 9749, 29982, 23106, 18340, 38275, 26274, 30493, 34126, 29493, 338, 31136, 2121, 20021, 47, 21457, 28382, 25705, 11215, 32937, 5601, 15632, 33779, 27155, 18168, 28189, 34205, 3173, 13804, 31344, 39817, 710, 32992, 3462, 26778, 38772, 13590, 26731, 6438, 830, 27401, 29959, 32594, 38086, 21590, 36644, 10254, 39565, 20126, 25542, 1648, 8392, 27429, 17706, 17196, 15011, 14402, 29395, 3473, 13109, 19170, 26214, 3883, 9776, 32874, 33312, 5153, 32017, 29314, 26163, 22541, 16817, 37389, 3995, 351, 10790, 14125, 14689, 9176, 11748, 28108, 35395, 21184, 12433, 3310, 17790, 11551, 1296, 10239, 7241, 31102, 30398, 33083, 3837, 30601, 7075, 719, 8981, 20237, 12512, 7534, 18566, 16483, 7860, 19878, 15668, 1617, 34293, 34122, 25273, 34789, 15693, 38401, 3400, 32618, 2016, 7560, 36291, 31103, 34666, 860, 5406, 36765, 29344, 3122, 36877, 31875, 18236, 30339, 1675, 26070, 29719, 37419, 818, 6249, 17515, 29127, 6372, 11837, 901, 34535, 31654, 14825, 8617, 34882, 33394, 9973, 33343, 39246, 31404, 26113, 1554, 2287, 9147, 30927, 14940, 24259, 15208, 22232, 1776, 2989, 25279, 33356, 11234, 1742, 29956, 5686, 35438, 38563, 33925, 16146, 31441, 21385, 18279, 28731, 19182, 23188, 23362, 10693, 1908, 14425, 16985, 19147, 17432, 14972, 27382, 32483, 36038, 12233, 27055, 8364, 38691, 33293, 38439, 32452, 3570, 8187, 39529, 35279, 15740, 3337, 27981, 7422, 2207, 25206, 5378, 8500, 37051, 8948, 36805, 12869, 27117, 37168, 35530, 39009, 39707, 15166, 25876, 14158, 20506, 31036, 14843, 16315, 35459, 15472, 24626, 21577, 31773, 7734, 14272, 36207, 1132, 39188, 2047, 23849, 3910, 26577, 35325, 37467, 11967, 21832, 21130, 2369, 9566, 6729, 32735, 8441, 24818, 34579, 29478, 4197, 13635, 29537, 21850, 28605, 36710, 16910, 7314, 14269, 38092, 11503, 6288, 7437, 37034, 5625, 9049, 36146, 14626, 31612, 39128, 9609, 12280, 35496, 3494, 1128, 36222, 6646, 9134, 20643, 8777, 30137, 38042, 15213, 6492, 36714, 21313, 8796, 37259, 26009, 7990, 34536, 30387, 665, 35705, 3412, 30373, 16091, 8166, 34622, 10889, 3075, 35751, 30557, 2336, 27063, 22205, 21654, 28088, 9200, 8127, 38214, 23670, 7588, 37713, 32082, 36565, 25531, 30867, 38799, 13379, 7334, 786, 9245, 9683, 12518, 31601, 16194, 5209, 5097, 29142, 29969, 740, 9287, 19196, 34498, 29226, 37135, 13542, 4313, 15769, 36761, 29917, 26002, 12971, 28850, 27143, 13721, 31956, 23730, 10378, 4140, 27914, 31906, 14017, 23752, 32205, 36706, 37306, 5489, 4362, 19877, 10787, 31626, 35142, 6184, 27647, 24939, 27530, 34358, 4655, 20043, 17844, 34345, 33348, 29538, 16702, 31845, 3348, 35971, 26107, 22142, 20409, 4169, 11218, 36819, 6450, 31696, 16059, 27735, 25000, 14557, 9568, 4608, 39224, 15676, 8944, 35241, 20306, 7497, 25480, 33556, 21204, 18612, 14671, 25755, 26217, 8677, 7613, 34955, 17939, 21961, 10937, 26827, 33837, 37623, 7857, 37399, 7141, 1505, 18186, 20414, 22137, 24223, 25997, 32487, 25706, 1449, 35209, 33265, 16625, 6877, 19251, 25792, 22737, 6002, 31072, 14723, 33380, 15990, 576, 33272, 24268, 1544, 18991, 34552, 2258, 6358, 21192, 17077, 9712, 24323, 24778, 14044, 28885, 24574, 18966, 8982, 15181, 30436, 31867, 21199, 14500, 13264, 7641, 8024, 15287, 31864, 14162, 30005, 22099, 29414, 2473, 5236, 38437, 32710, 28236, 15557, 27035, 27260, 22686, 26059, 25830, 207, 25471, 19925, 9405, 6335, 31618, 36069, 28541, 14609, 13573, 38794, 28383, 30591, 24266, 15679, 10469, 35940, 36546, 16881, 30160, 39711, 7396, 32013, 16018, 30421, 23287, 980, 1435, 36998, 32596, 5914, 21221, 19156, 35113, 15441, 8205, 27331, 10819, 33275, 16648, 8111, 12639, 12720, 25437, 9130, 18549, 24025, 15418, 7338, 9495, 16047, 37910, 6423, 21286, 32240, 32224, 788, 389, 25970, 1286, 11874, 27944, 5787, 31643, 11537, 4628, 16574, 10696, 2713, 9452, 3935, 13125, 3514, 24635, 1416, 24178, 11224, 14546, 29845, 3121, 37344, 25235, 19634, 6885, 32609, 38728, 36973, 29984, 18988, 28512, 25980, 912, 16425, 1161, 24876, 34746, 1918, 7130, 6769, 20073, 5945, 9778, 11722, 9816, 13426, 17358, 24832, 8112, 11482, 4618, 13977, 36951, 33239, 4960, 2857, 35259, 26202, 35193, 4011, 18095, 12101, 24845, 30903, 15599, 38808, 38542, 32168, 31114, 1188, 27514, 8361, 26652, 26876, 24888, 15501, 5321, 5884, 39548, 24664, 15310, 30431, 9027, 23863, 14207, 9279, 27383, 17047, 8117, 24449, 33225, 11576, 31437, 25629, 39284, 21552, 17429, 34575, 27628, 3996, 5067, 641, 36569, 31861, 37822, 35982, 34669, 11202, 39260, 20360, 32747, 22006, 16243, 30317, 27047, 31303, 1164, 2940, 7365, 27113, 27978, 37769, 22840, 5503, 8211, 2717, 24500, 13448, 39154, 27015, 20557, 34651, 38851, 37653, 15917, 33538, 28487, 5472, 36577, 33987, 4124, 15921, 25553, 19103, 29183, 24133, 20386, 4629, 5542, 23339, 4280, 30762, 6421, 20144, 33984, 33589, 21780, 28097, 37832, 37403, 17403, 25595, 8577, 29860, 27706, 10456, 34493, 29394, 31426, 10229, 4170, 15633, 32119, 1425, 29346, 39929, 18611, 27678, 350, 35307, 36994, 14758, 10918, 11673, 34000, 31852, 1875, 4126, 10707, 28547, 9094, 18178, 31323, 28767, 15020, 37577, 36574, 30967, 25250, 16358, 37943, 2749, 16932, 23426, 13457, 1674, 24255, 4956, 10754, 16242, 2748, 5270, 33185, 27461, 9809, 34229, 3420, 34871, 25700, 33900, 15, 10985, 3164, 30253, 19673, 10397, 3720, 23434, 35708, 39489, 30111, 101, 19969, 15275, 32873, 37604, 21602, 8023, 2210, 5491, 30529, 5961, 26154, 22198, 37022, 38055, 29905, 10907, 3964, 14732, 31688, 37658, 22012, 23468, 26560, 26947, 29331, 11891, 24031, 11688, 2561, 14853, 929, 11471, 39370, 21862, 6308, 16128, 8197, 26970, 10042, 8341, 12605, 20335, 23017, 13174, 1879, 15191, 21578, 3528, 35676, 27321, 37253, 25800, 32374, 14686, 2922, 17663, 9340, 9189, 10770, 21828, 21205, 9795, 5169, 8269, 13680, 10071, 6094, 39645, 31010, 20454, 16069, 30189, 18476, 31572, 22351, 36709, 22499, 38905, 29700, 28414, 2454, 20665, 22902, 7219, 34929, 32412, 6901, 18276, 18749, 978, 16677, 12950, 26891, 25873, 2179, 13838, 26470, 36455, 14558, 14965, 1983, 39624, 7849, 20146, 16115, 28124, 30206, 37887, 22587, 9046, 36276, 35946, 15329, 39226, 33122, 39362, 5758, 34423, 1603, 5806, 32367, 21604, 10783, 13069, 30216, 33749, 30093, 11518, 36231, 6323, 37349, 32112, 22939, 10526, 20754, 22056, 5545, 21183, 19375, 27384, 24539, 7123, 34444, 28290, 23470, 25216, 35125, 30786, 1063, 10816, 25856, 22631, 22221, 25051, 37073, 18718, 2129, 23795, 4399, 1808, 14216, 27444, 39060, 31543, 37868, 30424, 34825, 8996, 27497, 12265, 31282, 36230, 14498, 522, 12022, 23541, 34431, 37444, 4939, 9278, 19452, 808, 8840, 3509, 37103, 20871, 14335, 36331, 9590, 36026, 9939, 13343, 34325, 35270, 29079, 37830, 2932, 21297, 34212, 396, 28652, 1134, 15100, 31003, 7212, 6557, 33852, 14917, 39290, 4135, 440, 15961, 8741, 18858, 20065, 22648, 11293, 6532, 21278, 27150, 16224, 17658, 15159, 26519, 39620, 39586, 19541, 2540, 23554, 6222, 16199, 6822, 24835, 8553, 37258, 23210, 20568, 14501, 14492, 32830, 26317, 12493, 38930, 38094, 33158, 13548, 32381, 15063, 34706, 3625, 12005, 20634, 39737, 7375, 6988, 17745, 15167, 13333, 17274, 16750, 12317, 7655, 3603, 35440, 18926, 19664, 8729, 19642, 19129, 2003, 5057, 9319, 4925, 13289, 15652, 23466, 23270, 31279, 3063, 604, 34362, 4635, 13661, 37283, 23172, 24621, 474, 29391, 1018, 9630, 32567, 10700, 38005, 14904, 38411, 30266, 538, 6733, 14601, 9822, 28062, 22748, 24650, 38537, 21002, 17923, 20424, 35893, 38766, 29422, 17927, 26636, 12445, 20031, 10135, 24780, 31478, 21840, 16247, 21315, 20930, 29265, 17823, 20434, 14381, 17160, 36324, 21721, 9667, 22863, 16176, 15647, 1750, 6736, 23023, 35524, 26448, 22018, 4769, 35085, 34074, 38177, 16519, 18685, 27432, 19317, 8543, 2317, 913, 18007, 3499, 499, 14901, 34590, 4758, 23696, 35923, 23858, 5553, 25061, 21135, 9450, 36769, 3440, 36461, 1008, 24591, 30621, 5030, 32689, 10377, 29368, 1496, 36899, 34558, 25141, 32732, 31339, 29882, 34124, 37945, 2836, 26806, 22268, 24228, 11954, 18162, 13499, 2729, 27176, 1398, 17714, 34257, 22682, 9910, 11766, 27057, 17730, 20266, 6726, 5391, 37711, 31440, 7423, 9849, 33834, 36251, 34254, 36073, 27074, 38477, 39491, 9687, 14868, 38757, 10742, 9236, 22084, 12113, 16107, 29077, 9805, 7813, 17459, 26733, 23286, 22606, 20353, 12352, 7086, 18597, 29084, 34561, 30712, 12178, 22937, 1148, 30401, 13360, 6584, 17405, 20932, 36360, 30075, 5639, 13143, 29761, 38840, 33181, 2312, 32008, 11632, 36034, 15653, 25991, 6389, 10946, 15536, 1760, 33021, 3746, 36326, 32287, 11540, 36669, 12913, 35069, 25712, 13011, 23578, 32451, 18478, 35057, 25833, 318, 37624, 20160, 34503, 15970, 12520, 19272, 37535, 16797, 7816, 4713, 10467, 4634, 27718, 31642, 13896, 28651, 33212, 39351, 4018, 31880, 3889, 31085, 34859, 26976, 36467, 8279, 4093, 35967, 34668, 5681, 4008, 27749, 7649, 8216, 23347, 26917, 11468, 33545, 6338, 3186, 8176, 29866, 21934, 30273, 19624, 24498, 24658, 21442, 33373, 4119, 15971, 8105, 5379, 8914, 22906, 7546, 5499, 29630, 14186, 6236, 29252, 27011, 4409, 38976, 27971, 38075, 20600, 34041, 10957, 7682, 12467, 9116, 34828, 28670, 5624, 29418, 7779, 20560, 34410, 8634, 29981, 7066, 16430, 29076, 3419, 24519, 24602, 30511, 381, 18415, 1830, 17330, 30296, 177, 22590, 19700, 31743, 37282, 27081, 1844, 28687, 34110, 3497, 39755, 20913, 16318, 23964, 30414, 21842, 29682, 23469, 909, 3651, 23179, 34098, 31547, 24162, 6195, 28711, 14316, 19392, 1654, 39455, 10609, 6913, 9669, 39350, 22707, 15521, 39035, 38193, 16620, 25423, 18462, 19407, 21789, 33730, 25578, 6954, 20953, 26057, 38024, 27728, 30796, 30324, 29592, 32662, 9857, 18101, 27084, 19598, 8794, 26050, 33297, 18011, 15509, 25461, 11868, 24385, 30222, 17936, 31530, 28536, 34874, 24013, 25151, 14850, 4824, 30853, 6669, 24553, 26592, 1275, 29472, 24085, 20488, 11504, 10972, 21592, 9318, 34511, 3233, 22119, 10553, 22248, 6151, 22465, 32245, 25277, 13211, 1691, 14310, 18519, 39599, 20136, 19209, 25653, 8191, 11614, 4268, 5399, 26441, 31872, 12134, 17987, 13128, 30265, 2190, 9944, 36100, 36866, 21849, 33431, 15984, 19454, 27037, 12235, 9265, 24920, 10980, 26071, 29681, 25554, 30696, 9104, 11958, 7604, 21407, 2795, 16551, 37450, 32619, 36632, 20769, 13250, 15813, 3189, 11902, 15014, 19485, 6044, 2581, 2400, 16697, 3755, 10201, 2122, 34677, 14589, 26648, 16825, 26786, 20598, 13611, 23116, 19104, 9173, 39781, 19668, 33878, 8095, 12396, 35098, 24071, 17598, 1351, 802, 15118, 5865, 12446, 17103, 20770, 33034, 23627, 14590, 2500, 27046, 6891, 15858, 19235, 32128, 3220, 3676, 1498, 4444, 655, 30885, 31077, 37251, 7281, 29580, 15463, 26247, 10075, 23293, 35624, 35036, 34962, 29474, 16542, 13634, 24934, 6188, 27788, 28046, 32241, 18097, 7821, 835, 12652, 15575, 4565, 30248, 3025, 37088, 34377, 17735, 23628, 1502, 30403, 12499, 19526, 23648, 23787, 14606, 3495, 4474, 31734, 6177, 4548, 10365, 17328, 28381, 29975, 32007, 39992, 33469, 5452, 23739, 27768, 13891, 12563, 2505, 25455, 16783, 9922, 3321, 32585, 11141, 13471, 6765, 20216, 4926, 20174, 19332, 38066, 28833, 31445, 46, 20361, 7668, 11896, 35356, 33481, 33751, 36506, 28033, 10622, 38672, 11189, 25288, 19960, 27312, 37300, 22156, 33627, 30318, 21380, 12079, 22459, 36580, 18122, 887, 726, 34037, 19425, 36350, 32740, 23802, 19690, 12740, 36515, 20321, 3384, 11650, 12511, 12712, 16863, 16882, 3130, 15425, 35224, 29367, 29389, 31635, 780, 17428, 36108, 12840, 25523, 21594, 7836, 26813, 13020, 28138, 14413, 27198, 36082, 27319, 24302, 30951, 39598, 19446, 36783, 22249, 26370, 32925, 9592, 1441, 15717, 5332, 32493, 7398, 35511, 11975, 17504, 19527, 23498, 36352, 5010, 30312, 8583, 11284, 39795, 17416, 12117, 18691, 2902, 16682, 17972, 4863, 23156, 18720, 24686, 35733, 12671, 24954, 38199, 4265, 15429, 39349, 36585, 5651, 36197, 9100, 20094, 31268, 14533, 24812, 33945, 33801, 17917, 38540, 30802, 25355, 14529, 32110, 722, 29676, 25163, 30894, 37328, 10964, 6057, 31379, 697, 8415, 9536, 3185, 27594, 9790, 18460, 32271, 17199, 21891, 26220, 26937, 34039, 35489, 6904, 18148, 26210, 35959, 8275, 3740, 24657, 16508, 1911, 36688, 35719, 14215, 31726, 12080, 10277, 37280, 34206, 39144, 12483, 31427, 16392, 28403, 24267, 34792, 35680, 38571, 31581, 36986, 20054, 3858, 37437, 14360, 9884, 22493, 31260, 23455, 1832, 35299, 39728, 19385, 8289, 5820, 3943, 27249, 21911, 33319, 16851, 22140, 12810, 35911, 7169, 19844, 37000, 2332, 28385, 30979, 1890, 35557, 10786, 5701, 25689, 3824, 14810, 18141, 20682, 35870, 24863, 36692, 14937, 24520, 15458, 12755, 15627, 22889, 10410, 33370, 31708, 1078, 14987, 24701, 23744, 4843, 23196, 24528, 32839, 637, 32095, 27933, 2067, 6970, 22635, 7557, 38855, 6757, 39824, 6531, 24875, 347, 30460, 2185, 8903, 24325, 32671, 34924, 22940, 9342, 16539, 7017, 9082, 10155, 1509, 30989, 4405, 22581, 4320, 38697, 30346, 34363, 5306, 26284, 38359, 15894, 14297, 8358, 13651, 35202, 7837, 22713, 23225, 6143, 31627, 38639, 1389, 24794, 31126, 15940, 261, 6391, 5514, 9874, 5757, 10711, 26696, 145, 24035, 22860, 30760, 4068, 21194, 21213, 12001, 15523, 2248, 21397, 523, 22747, 1485, 1697, 22899, 30226, 4760, 6842, 25512, 17259, 39813, 24760, 10438, 22206, 39100, 38806, 14995, 5619, 18498, 38872, 1192, 19987, 1670, 9559, 23899, 5678, 18984, 22439, 15015, 11326, 19931, 30670, 31697, 3082, 28783, 16074, 33727, 19341, 14122, 756, 39255, 2356, 24148, 37043, 7220, 32489, 8140, 11164, 4431, 30375, 2175, 23491, 32431, 27856, 22436, 1464, 34482, 7667, 2512, 16206, 11487, 38367, 1892, 15640, 30239, 39762, 1956, 39083, 12525, 11778, 8472, 37844, 27018, 29163, 7523, 27943, 22464, 9638, 8999, 12818, 2427, 36803, 1058, 36657, 5338, 14784, 30852, 35908, 37396, 17537, 33929, 27750, 32928, 24340, 13699, 38021, 28837, 22081, 27406, 21376, 16662, 11207, 15548, 30994, 6709, 29803, 39534, 9657, 36712, 37192, 11771, 7817, 856, 18190, 34920, 30939, 18624, 13329, 23926, 38774, 30949, 21916, 14067, 24159, 27440, 23551, 30832, 7471, 5426, 16217, 5836, 17602, 4503, 17681, 34434, 28999, 22608, 16170, 29837, 31355, 1957, 39063, 12166, 1848, 31525, 37659, 7022, 18309, 14328, 2015, 18220, 6799, 26440, 37884, 25292, 33829, 38651, 14631, 1637, 19787, 35788, 20121, 5565, 7460, 27049, 38503, 34225, 23229, 14227, 4311, 19210, 110, 25992, 29876, 26811, 13231, 31941, 5013, 39030, 34045, 7548, 27738, 13488, 6459, 4339, 32657, 39785, 30358, 2910, 13504, 14237, 39308, 39374, 9702, 8304, 3827, 13640, 26860, 4025, 14131, 10316, 21342, 5292, 33349, 29954, 21820, 13154, 24429, 37470, 4353, 26069, 1091, 23422, 2820, 38208, 5988, 7771, 4874, 16139, 30671, 20455, 4540, 28000, 37967, 28099, 13468, 31843, 31551, 16562, 14712, 8849, 36199, 23429, 15505, 31670, 5534, 24381, 8811, 30413, 28423, 12969, 23272, 36996, 17452, 27103, 38062, 21901, 35390, 16468, 11611, 2677, 31254, 8487, 36168, 21487, 28617, 35797, 17149, 22725, 33724, 23351, 34100, 29994, 17914, 23197, 22882, 7180, 28038, 33147, 39858, 15415, 27599, 28254, 38297, 27637, 17980, 30871, 10301, 6472, 17297, 38337, 20214, 9779, 11951, 17661, 4344, 5900, 34082, 34174, 29415, 21143, 5445, 2222, 32255, 10746, 35068, 27069, 30, 12638, 326, 10993, 35614, 32081, 10286, 31113, 17354, 11520, 13589, 33697, 18371, 7527, 23295, 2557, 5441, 34957, 7724, 10560, 8597, 20926, 20472, 27220, 14037, 26832, 7072, 12174, 10727, 14644, 26769, 21169, 35950, 362, 709, 18680, 14743, 30915, 17542, 10184, 25296, 6070, 16026, 15830, 2089, 17255, 26986, 27036, 29618, 18947, 22241, 13524, 6898, 25801, 20169, 1867, 16123, 24590, 39329, 21719, 19684, 37896, 20481, 8452, 17783, 34681, 1141, 4564, 5627, 11485, 26336, 9477, 3985, 30955, 21021, 7218, 19815, 8048, 4802, 36332, 33911, 28632, 25544, 5036, 34697, 33926, 32974, 39587, 4913, 33803, 37855, 11244, 36009, 18555, 7318, 35022, 35809, 32905, 10420, 28358, 7508, 27591, 38392, 36483, 11153, 38388, 2420, 3709, 28203, 8370, 22782, 7034, 34273, 29996, 20763, 15304, 22884, 25389, 25381, 25894, 14679, 14905, 3931, 27660, 22262, 36237, 2816, 167, 14364, 15055, 7707, 10753, 16455, 7683, 26585, 7452, 17020, 26294, 13161, 21190, 34873, 25035, 39148, 37362, 33244, 27629, 22173, 29248, 10722, 10488, 21985, 19271, 24902, 18497, 24869, 22116, 3328, 20019, 24723, 3615, 33827, 26, 16429, 32338, 22931, 294, 35430, 28106, 39775, 20397, 2682, 18004, 17932, 23162, 36165, 10141, 38106, 11698, 7273, 23735, 17866, 3493, 26692, 2791, 15184, 4857, 29691, 32012, 38901, 39863, 39515, 21881, 34753, 16151, 34437, 27129, 27947, 6176, 39440, 18946, 2470, 11814, 35829, 7800, 6245, 2066, 2872, 25504, 26147, 3785, 29364, 15090, 20622, 21857, 37716, 33522, 15732, 4978, 12549, 31890, 15358, 3331, 33359, 14569, 20531, 8573, 1684, 9013, 3710, 13650, 14711, 27009, 5575, 2186, 4933, 13072, 8246, 37170, 28489, 11070, 15500, 7516, 9698, 36310, 6134, 426, 2942, 16187, 21970, 35615, 34436, 37914, 15149, 30940, 12898, 33975, 4869, 20392, 26667, 9052, 33353, 12538, 39080, 24872, 26311, 36561, 16949, 29553, 32838, 33342, 1374, 10368, 1385, 9282, 2204, 22325, 37664, 38541, 23805, 21200, 26466, 26215, 20276, 3624, 26097, 24897, 17249, 28213, 38331, 14144, 36261, 15600, 37224, 16261, 38302, 29164, 22299, 38569, 37939, 5592, 19628, 24499, 8172, 11457, 30872, 8503, 30938, 22035, 32053, 33698, 927, 22865, 121, 27801, 18789, 30311, 12589, 3110, 8878, 29151, 27953, 3089, 7676, 35399, 34164, 11990, 37861, 16725, 8745, 3714, 29859, 8180, 26067, 32113, 12949, 8848, 8879, 932, 21129, 9199, 29919, 5555, 4082, 37889, 15229, 15695, 21456, 15883, 7595, 5795, 21497, 6078, 9139, 28147, 20942, 9680, 3250, 29715, 19325, 567, 10099, 30219, 27702, 17237, 23258, 39146, 20186, 32159, 3467, 15590, 5123, 27708, 22802, 20861, 13252, 31833, 8109, 15677, 37454, 1519, 29145, 25839, 17618, 31954, 24922, 23718, 39630, 2686, 19635, 21599, 5343, 25360, 6971, 15689, 29555, 23600, 39117, 4603, 27062, 33130, 37880, 16761, 14472, 23477, 12765, 30090, 4969, 36219, 33616, 1037, 34854, 29713, 920, 37060, 9120, 22258, 4089, 1250, 29870, 26803, 14643, 33839, 28337, 15891, 7126, 34079, 33111, 323, 11829, 10313, 26314, 1823, 4001, 16914, 18526, 6175, 11061, 3936, 22730, 21872, 118, 22534, 20614, 11198, 22354, 7878, 24941, 9825, 33956, 7701, 31028, 31315, 35843, 3366, 19371, 6810, 13162, 18782, 6556, 10017, 6318, 9411, 15856, 30399, 35922, 14605, 16009, 21760, 3822, 199, 1261, 39877, 183, 39994, 18831, 35039, 21302, 17258, 11369, 20421, 25220, 27690, 11957, 8266, 22791, 592, 256, 3149, 12477, 29743, 36836, 8501, 3556, 1253, 14405, 16693, 10794, 15826, 20519, 14925, 17, 21115, 2667, 20244, 24056, 1577, 1176, 884, 24652, 16287, 34653, 16971, 4905, 38455, 8018, 19662, 20733, 3116, 9000, 3980, 26213, 25530, 26725, 19486, 23087, 31216, 34553, 28506, 15825, 32046, 12270, 12397, 29702, 1092, 19088, 23195, 36172, 17524, 38386, 7691, 11394, 29748, 8963, 17886, 23292, 4908, 10673, 16770, 9543, 16117, 9898, 6735, 2448, 28173, 23336, 27245, 15407, 29433, 16252, 3433, 33080, 11190, 25978, 36176, 24208, 1567, 30820, 35121, 6138, 27984, 31409, 34023, 38670, 4060, 7222, 6530, 35909, 27240, 6880, 2811, 13682, 14403, 16080, 7877, 12780, 37785, 11005, 11986, 27110, 32965, 10137, 28532, 35881, 37240, 8382, 22365, 28133, 38962, 3140, 12646, 21540, 33927, 37789, 32650, 8707, 35186, 32368, 25262, 13572, 25192, 19442, 5812, 1626, 34534, 29595, 36061, 32216, 5943, 1852, 31309, 18113, 18423, 20171, 30045, 29037, 5546, 19244, 15503, 14025, 8483, 26401, 35777, 18689, 6309, 285, 16178, 31857, 34261, 5828, 33182, 23589, 29993, 34542, 831, 22734, 23676, 31701, 911, 38916, 16175, 11151, 20822, 22143, 14640, 34270, 13549, 24282, 35468, 21864, 38933, 22558, 33323, 21361, 2515, 7206, 25869, 10361, 24112, 16363, 8595, 31599, 22780, 7269, 18048, 1889, 21844, 3101, 15543, 22540, 32551, 26820, 29302, 10019, 8604, 23146, 35431, 24477, 31918, 21005, 1755, 3809, 20063, 38526, 28295, 24953, 37692, 9517, 1770, 25319, 26390, 1328, 38747, 20912, 18228, 14961, 19151, 32123, 3344, 21534, 26055, 22554, 33588, 35274, 9987, 16940, 35643, 11847, 22743, 28136, 945, 21659, 8326, 27941, 29865, 18797, 34949, 23399, 15952, 443, 11765, 5486, 15928, 31449, 1765, 18940, 11629, 30464, 6076, 13624, 3305, 19911, 12580, 1297, 14955, 30995, 36794, 28769, 37036, 36266, 19830, 5843, 36904, 22385, 4742, 6475, 2849, 22785, 11646, 33015, 17372, 13173, 3725, 38950, 19840, 4153, 12877, 30882, 37277, 19034, 1046, 35718, 4963, 38745, 7110, 19060, 20103, 25987, 37590, 5075, 9308, 30336, 1103, 34400, 19555, 14838, 37041, 25263, 5420, 37821, 6759, 20403, 35462, 32476, 17001, 34794, 9855, 26747, 29864, 25199, 14085, 19492, 27808, 18804, 27262, 14023, 10121, 15043, 16696, 11516, 37082, 38749, 37850, 19176, 23391, 27214, 9428, 34402, 18523, 17934, 5150, 7193, 36576, 4381, 22644, 23183, 24923, 17582, 12675, 10384, 30331, 28220, 25169, 13800, 8693, 12231, 30272, 31552, 11078, 25613, 725, 17739, 640, 16520, 9759, 34673, 8702, 24445, 24149, 11341, 14541, 771, 17499, 13171, 12405, 5069, 10520, 14555, 20210, 17412, 18174, 16548, 19546, 12951, 16489, 10098, 33295, 4666, 30856, 26313, 24997, 37490, 7989, 6534, 7826, 18288, 2924, 30347, 9915, 23401, 26828, 1373, 21348, 12443, 2655, 39878, 17843, 26100, 29377, 37770, 35041, 5230, 61, 9458, 11806, 11835, 12232, 7829, 12661, 13697, 18343, 18482, 9357, 22706, 3614, 10477, 8383, 12523, 3525, 8550, 2057, 14400, 31740, 23521, 34007, 9560, 39564, 14190, 28261, 24171, 3610, 21429, 26451, 21250, 30259, 3982, 32211, 31573, 22517, 27215, 4345, 28676, 14883, 31924, 14338, 24129, 6959, 32881, 10476, 22166, 9842, 35828, 19821, 34701, 22070, 34750, 14341, 36375, 10590, 6840, 37246, 15408, 24227, 22490, 22096, 31754, 14517, 5003, 37457, 26907, 12346, 5470, 14352, 23821, 35133, 33361, 13667, 17858, 23062, 31986, 2349, 20712, 22575, 6383, 7870, 11743, 39786, 7509, 12630, 28269, 15690, 38986, 26399, 25563, 7983, 17110, 4507, 20698, 25750, 21806, 12569, 21618, 13566, 32938, 10165, 7140, 24558, 14775, 15525, 2354, 9422, 29075, 12856, 10844, 3526, 363, 32229, 7688, 24932, 4334, 1874, 23241, 320, 9300, 35688, 20401, 24481, 15815, 35576, 4138, 8249, 34430, 11465, 6433, 8391, 28523, 24746, 22225, 35960, 19579, 22630, 38151, 25573, 12505, 36697, 28981, 8557, 27922, 5819, 1695, 4019, 25720, 2169, 13056, 17961, 5269, 12275, 20364, 35218, 28549, 25827, 1819, 4360, 16092, 14837, 19320, 23187, 37068, 35417, 6788, 27173, 37804, 19997, 29765, 35581, 16983, 23184, 6869, 36247, 13263, 32706, 39931, 34601, 30081, 783, 30783, 30880, 16901, 27722, 35608, 24212, 9746, 20163, 18222, 26095, 9673, 38486, 38741, 11181, 22652, 19981, 30610, 6189, 3019, 6589, 30288, 26259, 9932, 7350, 33001, 5501, 2632, 23376, 10180, 37294, 17084, 3067, 39944, 25903, 33996, 18807, 5998, 16860, 10501, 31705, 9691, 31719, 30316, 29662, 13785, 16480, 33298, 24044, 9115, 9975, 29891, 22961, 26492, 4436, 4723, 9637, 28559, 3432, 6299, 7121, 7283, 36430, 18308, 6344, 19924, 1137, 8315, 7524, 7178, 12020, 1394, 13269, 39158, 13851, 12697, 22994, 7373, 36000, 36840, 19408, 16735, 25479, 18255, 36196, 9126, 1293, 3342, 21459, 29420, 34611, 22080, 940, 4504, 17188, 33439, 37959, 27235, 29575, 6137, 27188, 27349, 36263, 574, 28244, 6486, 33669, 28870, 21248, 23562, 1939, 1156, 33161, 16370, 16979, 35651, 20958, 5151, 36050, 32684, 28507, 10643, 4899, 2915, 37839, 23255, 1737, 37468, 39288, 2231, 18622, 26640, 32424, 14347, 28196, 35020, 18546, 15437, 26956, 20112, 23719, 18883, 17491, 19638, 28738, 11840, 25370, 21597, 9958, 10866, 27812, 25616, 18574, 14966, 1180, 19131, 23227, 32847, 20993, 6732, 38231, 4281, 35660, 33079, 29147, 12774, 5747, 31786, 25064, 8083, 2625, 4087, 34210, 5658, 27623, 7150, 37325, 14519, 27144, 17692, 25651, 34786, 24460, 32812, 25102, 1676, 31508, 39256, 29749, 16729, 8295, 3398, 8490, 19037, 27358, 30741, 21081, 31045, 36698, 20997, 35387, 30351, 9831, 16362, 3777, 13118, 37977, 37120, 22252, 14299, 35240, 26231, 39427, 22806, 1309, 8599, 5304, 14795, 8226, 26376, 8248, 22656, 9427, 11138, 33650, 36081, 34992, 33841, 13100, 32253, 33872, 1601, 26599, 30129, 34188, 19614, 24280, 32503, 24365, 29444, 26573, 3823, 24946, 12559, 17520, 19933, 375, 12342, 6553, 18993, 37643, 30544, 24722, 13126, 9591, 31308, 16640, 2720, 22341, 11510, 5662, 14480, 32061, 6994, 5857, 38778, 28697, 28286, 38797, 39571, 4505, 14028, 19749, 5020, 12196, 5185, 13393, 14828, 28834, 9453, 27732, 3847, 20973, 26878, 33702, 6879, 8978, 5136, 30528, 7871, 12907, 32142, 8632, 28180, 11758, 11032, 31448, 8145, 23804, 25388, 816, 32971, 1835, 14578, 25109, 38943, 37628, 3944, 20579, 25012, 21966, 857, 7369, 14109, 17919, 24840, 9832, 1109, 25726, 31891, 32744, 38581, 35657, 31106, 30241, 37739, 20730, 6069, 36060, 24341, 23575, 19742, 7872, 4472, 4763, 21185, 10290, 18319, 15486, 19740, 17660, 7866, 16451, 16042, 4282, 16826, 32647, 11455, 1872, 37436, 11498, 33786, 21509, 16805, 10388, 24195, 29818, 34664, 16022, 21128, 16486, 19121, 14994, 20224, 27726, 19982, 5706, 24094, 662, 7629, 3294, 1621, 3588, 33184, 16942, 26381, 14969, 25157, 37859, 230, 33906, 28256, 24814, 30881, 20545, 14013, 8182, 8701, 13458, 30474, 6142, 29836, 24966, 39074, 34638, 34024, 19339, 31657, 20820, 32623, 4046, 38987, 18253, 10776, 18234, 39419, 26447, 14753, 5607, 5272, 35714, 36664, 39424, 37734, 22721, 11857, 557, 11292, 2562, 17213, 5516, 11143, 15319, 34738, 9259, 16471, 16416, 20317, 27638, 17165, 14386, 37580, 19042, 26497, 17935, 3486, 19781, 21195, 37144, 16951, 31175, 36273, 33173, 29488, 10265, 34512, 9304, 16962, 5782, 25046, 1898, 17791, 1887, 32486, 4938, 22573, 22466, 32893, 5939, 761, 34465, 21525, 35008, 15571, 6724, 30388, 31364, 2835, 34087, 7601, 17421, 1692, 36545, 21754, 39815, 26959, 34327, 35045, 15078, 21645, 23181, 3052, 12866, 12965, 10032, 5692, 16650, 34999, 1129, 18075, 38089, 36553, 14815, 12229, 17873, 3894, 39412, 23786, 36718, 33983, 19717, 29350, 35555, 28284, 16105, 2300, 11893, 17698, 28416, 12038, 8789, 10227, 26711, 39868, 30011, 21997, 4568, 32277, 29953, 18607, 35296, 13258, 32047, 10933, 5505, 36586, 18507, 18434, 4075, 23442, 6844, 25144, 13259, 36469, 16407, 32127, 7584, 37933, 8919, 18207, 19040, 1610, 38220, 4721, 2617, 31464, 25770, 19682, 29041, 16712, 20285, 26061, 7762, 4260, 26159, 20800, 23741, 28804, 11602, 12658, 10194, 39445, 8746, 14865, 5294, 16567, 34180, 36154, 14552, 7316, 4285, 37611, 32749, 16207, 12693, 36203, 2429, 9068, 33160, 2985, 8960, 16040, 33671, 20719, 14273, 34764, 9207, 11094, 18629, 36487, 3917, 29101, 22441, 25951, 25408, 15939, 2018, 39853, 39975, 36096, 8331, 21854, 1643, 16085, 13791, 3630, 17299, 39505, 109, 17138, 3084, 22027, 36020, 2553, 34655, 3183, 12508, 34876, 35328, 23324, 34560, 39989, 3700, 6510, 23956, 9489, 30895, 1799, 7607, 30812, 32391, 26056, 8072, 39643, 36423, 14361, 3524, 163, 30179, 11888, 15382, 532, 10514, 32415, 23865, 19990, 29825, 23008, 30172, 29263, 19644, 22524, 21624, 28044, 9434, 22178, 1885, 86, 3225, 15380, 22762, 33861, 27293, 27554, 34277, 32473, 18021, 25481, 18621, 29675, 1376, 16810, 10505, 24374, 38948, 861, 23672, 566, 3369, 7658, 7648, 25460, 13104, 34836, 34475, 9356, 18972, 20365, 11178, 39896, 21953, 29082, 35015, 28696, 9544, 2856, 13867, 36543, 36636, 1815, 37445, 37810, 14229, 9653, 706, 2031, 35411, 16030, 39014, 11784, 28445, 8209, 33175, 3752, 14358, 5825, 32078, 16325, 32316, 15986, 30477, 27158, 19558, 3235, 14845, 21224, 12621, 12063, 39403, 13273, 21491, 9546, 10173, 12210, 37072, 18583, 9127, 19615, 21499, 18614, 12517, 24716, 27773, 27376, 5580, 31962, 39552, 35006, 19771, 5165, 30362, 27267, 12327, 37762, 24545, 36939, 18206, 33291, 24509, 27428, 3105, 37981, 31317, 25532, 3087, 26504, 31033, 24457, 7106, 30736, 24790, 19086, 19155, 29767, 19976, 23423, 12205, 2257, 19699, 26463, 26798, 32056, 2727, 9550, 14081, 25219, 36458, 24743, 39543, 15233, 30085, 11530, 6211, 35661, 38228, 12592, 19416, 301, 33651, 38585, 11594, 29007, 33097, 29717, 38828, 17736, 3730, 19723, 9432, 21627, 23758, 17264, 17994, 37733, 31318, 34221, 29003, 39560, 28658, 18703, 9032, 25289, 17049, 27621, 19401, 38568, 12935, 31433, 22711, 4652, 22905, 15878, 11440, 15377, 26012, 37228, 8314, 16109, 29986, 26185, 34223, 12283, 19963, 28689, 16499, 324, 28700, 10312, 21987, 3375, 1657, 15431, 5896, 22880, 14702, 21999, 5496, 8291, 8538, 6841, 27252, 7537, 35988, 13595, 7071, 9914, 1895, 16166, 12482, 17721, 6230, 8986, 29838, 19657, 34050, 34727, 12380, 25348, 8664, 6564, 31542, 12825, 732, 17951, 17400, 6417, 13475, 39057, 15097, 1003, 16996, 13671, 468, 14006, 11712, 24977, 31511, 18243, 9946, 35756, 21959, 20648, 36508, 23666, 7286, 8712, 39874, 5822, 27896, 29930, 5838, 13605, 37499, 37031, 4482, 18762, 25414, 37638, 36191, 1429, 535, 2995, 36284, 9578, 16591, 27575, 39279, 35852, 30394, 23404, 28609, 32409, 13375, 37315, 26161, 1466, 14921, 1694, 34108, 14306, 415, 11538, 9132, 10768, 34979, 37990, 3020, 24008, 11961, 12764, 33601, 25085, 20530, 35631, 28667, 22687, 37161, 35851, 33571, 32130, 10040, 28344, 35177, 11921, 19507, 24489, 1482, 617, 1281, 22592, 5180, 23794, 8548, 17156, 7755, 13133, 14175, 24410, 24563, 21029, 35010, 25121, 30584, 32011, 11334, 2895, 23279, 33365, 15754, 38893, 25897, 32294, 8847, 15931, 10449, 18907, 23230, 13054, 29616, 11653, 14059, 39726, 16054, 29599, 38862, 17522, 22752, 27332, 32210, 33637, 24634, 28576, 13802, 39567, 8742, 34934, 21331, 36254, 7478, 34407, 37956, 9977, 21866, 35969, 26906, 31604, 23495, 11589, 33208, 7425, 29811, 18663, 19233, 32750, 6855, 9853, 19522, 23330, 2703, 3639, 19855, 31145, 19854, 1653, 6392, 24903, 4679, 3686, 21696, 31733, 30017, 6458, 17294, 24494, 649, 15332, 32638, 16086, 16006, 14560, 22427, 39160, 11820, 9390, 13242, 17762, 7158, 37741, 3481, 5789, 35182, 18219, 24777, 29206, 31230, 37307, 3212, 7186, 7910, 15252, 14454, 5531, 5815, 1966, 26120, 18820, 33597, 18096, 27928, 18962, 2744, 37717, 18083, 28332, 2235, 31622, 14295, 1371, 32153, 19533, 15281, 23099, 21266, 22088, 26018, 24067, 39416, 22242, 27019, 2382, 9447, 12500, 13691, 21283, 2641, 8033, 25187, 14651, 35327, 14893, 34845, 8697, 10825, 35840, 14052, 35005, 33782, 35847, 20391, 9065, 32582, 27505, 37865, 31516, 27317, 3782, 31369, 35575, 12808, 14534, 23007, 22481, 9869, 5664, 30423, 22310, 26992, 10306, 13783, 37873, 4073, 14442, 28978, 9969, 21306, 19310, 34997, 36120, 37656, 37849, 39039, 1071, 191, 27640, 150, 591, 25318, 16852, 3728, 24674, 4671, 17359, 26410, 35014, 13014, 20137, 8537, 20333, 6240, 33705, 36747, 28464, 27498, 9678, 29536, 30934, 22844, 21936, 12759, 29786, 38395, 36033, 922, 34492, 2327, 17664, 31241, 648, 36259, 20742, 32649, 35972, 4351, 6282, 13383, 27065, 13911, 9204, 8296, 12151, 6216, 2372, 33327, 30961, 21223, 7609, 38732, 27455, 29276, 28439, 28891, 27485, 16408, 17651, 2742, 1681, 5478, 10511, 2385, 29468, 16406, 26392, 3758, 11686, 26784, 38461, 36220, 1763, 39019, 5930, 13233, 9661, 15560, 25742, 12781, 28195, 12746, 24179, 32997, 1796, 12044, 11252, 24766, 14740, 12185, 26665, 33736, 36796, 35815, 37354, 25734, 4726, 34057, 34022, 27342, 25044, 1194, 12870, 39852, 27779, 38618, 21937, 36214, 21814, 13009, 23053, 29656, 10960, 12148, 21766, 11477, 37392, 33534, 32569, 15459, 1756, 32592, 39603, 19160, 23839, 10817, 26183, 11843, 9023, 32858, 14487, 39590, 7874, 22526, 1039, 30928, 3009, 8938, 8293, 26641, 2052, 10916, 7900, 33977, 14858, 22719, 39196, 16326, 31807, 34478, 26613, 38375, 8763, 12536, 27477, 12009, 1797, 27828, 31863, 6955, 25007, 26465, 1038, 11441, 19536, 26609, 22657, 10865, 6893, 35863, 18760, 2570, 39513, 19691, 20610, 38121, 25432, 13419, 24234, 14741, 25739, 14091, 24130, 31285, 10750, 34890, 14667, 29375, 2826, 5405, 5922, 13580, 36652, 8951, 23319, 8680, 38223, 25305, 26647, 37347, 1320, 33620, 16497, 32073, 28810, 7199, 8834, 10703, 22229, 39512, 25164, 34824, 3345, 24501, 16635, 35981, 31388, 9271, 39376, 23806, 33036, 31540, 24827, 39390, 23781, 32588, 16594, 15422, 24007, 27603, 22401, 3803, 39897, 9307, 23261, 18125, 19544, 33267, 20115, 27802, 35715, 666, 12390, 22003, 27703, 7372, 27041, 7591, 10814, 26529, 33580, 210, 7768, 26837, 16251, 8369, 8592, 23591, 27624, 20223, 22807, 13107, 15137, 21295, 24369, 24603, 32625, 26354, 26476, 19467, 15427, 19421, 7562, 5023, 34884, 20131, 31182, 516, 8619, 10614, 18778, 6752, 18577, 34032, 18263, 27291, 15365, 39583, 787, 14532, 5092, 34945, 23372, 25171, 23306, 36865, 32773, 13172, 35689, 7064, 11916, 10415, 24483, 37067, 38050, 29093, 11524, 20587, 16380, 35097, 26691, 19396, 37636, 25943, 18686, 29929, 26528, 836, 17920, 34917, 25824, 14577, 34821, 39352, 27068, 35191, 21741, 25733, 1258, 526, 17247, 34940, 1944, 30071, 10561, 22562, 12726, 9664, 28580, 35712, 13399, 751, 713, 27902, 34111, 17867, 12021, 27282, 9689, 3349, 21095, 447, 38792, 2724, 3644, 1339, 8895, 21235, 8496, 11432, 33290, 21877, 13969, 14078, 17362, 899, 28694, 36863, 34819, 36053, 30987, 36963, 36624, 39777, 15897, 38287, 8186, 8681, 6194, 9251, 15862, 37562, 31532, 20882, 28558, 17129, 27573, 32197, 22674, 21347, 32202, 19231, 35598, 13082, 20117, 1609, 4640, 843, 19506, 10785, 26544, 13446, 4316, 29245, 9379, 7223, 646, 33691, 27572, 22555, 12461, 29737, 24586, 14418, 28069, 39899, 29217, 35536, 34765, 3448, 16841, 19139, 33887, 2916, 8450, 19291, 16864, 28627, 9056, 6068, 6476, 32079, 36851, 31873, 28626, 10453, 14421, 12860, 21251, 32624, 32759, 32833, 1673, 28251, 19983, 35755, 31154, 25793, 24183, 15642, 4336, 13938, 10699, 14611, 20845, 14612, 10245, 10806, 22172, 36667, 1999, 9393, 3460, 28426, 17469, 15782, 36308, 16600, 14903, 23228, 30980, 4516, 12864, 14623, 31920, 29012, 32498, 15528, 21477, 10255, 4949, 24548, 27920, 30917, 4371, 10049, 27271, 33314, 8816, 12792, 8316, 8393, 26760, 22511, 4422, 871, 881, 785, 20458, 10398, 10375, 16372, 7426, 18693, 16965, 16409, 7544, 22264, 10589, 35621, 17182, 8872, 37517, 17888, 3652, 36845, 1236, 14494, 25022, 425, 20891, 20664, 3975, 25912, 21650, 38325, 15273, 25352, 25280, 4091, 2976, 26557, 34289, 25893, 35221, 29583, 5826, 10625, 5089, 1720, 11603, 39375, 5225, 14311, 16668, 39454, 15757, 812, 28497, 4364, 31346, 35260, 33917, 336, 37570, 31201, 13249, 35451, 22397, 33633, 4688, 37032, 15412, 4714, 20085, 536, 24516, 4111, 33939, 5800, 31412, 39249, 37359, 16088, 33477, 35481, 30472, 11405, 4370, 33549, 5353, 31038, 19245, 2722, 35620, 39860, 8814, 14537, 6512, 10432, 18239, 34915, 26826, 38608, 15126, 38340, 1516, 18734, 7625, 1732, 23206, 15340, 33688, 1668, 20559, 38731, 11511, 31879, 6058, 36122, 14319, 2634, 9037, 19804, 28867, 7482, 37352, 33347, 31264, 6543, 18563, 3354, 19808, 10848, 13386, 31365, 35406, 34760, 30503, 27258, 2998, 21558, 29759, 11608, 25133, 23657, 16050, 3246, 17578, 3428, 34222, 29502, 8738, 1557, 26886, 38775, 11196, 21384, 14799, 27936, 21725, 7723, 24961, 23438, 2478, 13615, 36917, 16108, 31791, 8956, 32509, 26394, 31436, 6110, 30569, 21907, 39302, 12634, 4017, 23086, 29705, 32695, 2621, 38633, 38674, 5510, 15729, 37099, 34688, 7084, 2979, 33317, 5250, 11358, 22593, 21394, 16847, 26940, 18625, 5404, 39053, 26423, 30866, 9539, 24, 17952, 17907, 18034, 17964, 6348, 20484, 16490, 7326, 32161, 35589, 7112, 5855, 8654, 15309, 1375, 1836, 38057, 10736, 18906, 29572, 30717, 38272, 11454, 14412, 27266, 38084, 37551, 26422, 12927, 26700, 17050, 35066, 38327, 32627, 1477, 34101, 23396, 19004, 37872, 26331, 23924, 26883, 4484, 6824, 23714, 25722, 18008, 32195, 15096, 16147, 18135, 16321, 10585, 1869, 11415, 847, 31760, 11390, 9382, 12948, 35602, 19518, 33619, 12560, 37993, 17568, 39888, 32176, 30191, 37223, 21867, 17116, 3174, 36104, 23927, 26634, 10636, 1865, 14074, 33899, 5568, 16282, 4912, 9748, 5214, 27, 26589, 35268, 31376, 24990, 14448, 35590, 10287, 16067, 13766, 12188, 22510, 25515, 39266, 13088, 5257, 8013, 28331, 11669, 3231, 22083, 12572, 38964, 31447, 32945, 29014, 30973, 11079, 4889, 18305, 21533, 3786, 1602, 39885, 28814, 14718, 33547, 23980, 33266, 28722, 23413, 1871, 9431, 20277, 2310, 19921, 28758, 4787, 6257, 34276, 26533, 25811, 14793, 18027, 38257, 21887, 24147, 12681, 24726, 1105, 16718, 17161, 10144, 22067, 6011, 4841, 16633, 4832, 570, 31424, 19309, 3141, 34762, 24706, 36795, 32726, 13677, 29687, 13445, 15639, 19502, 8515, 35723, 28114, 29091, 23001, 32376, 23063, 31179, 7574, 26173, 29869, 11160, 5309, 5440, 1181, 4275, 20426, 37973, 32656, 31892, 29831, 11637, 2041, 11040, 32265, 19299, 33274, 10196, 35583, 25516, 26623, 14650, 36824, 30981, 38736, 27064, 24825, 36297, 1314, 31661, 20883, 24451, 9989, 1036, 20258, 15681, 6854, 23784, 26162, 21039, 29877, 18809, 14619, 17992, 13013, 22089, 39855, 7767, 18830, 35790, 23178, 39652, 8623, 10549, 6164, 9154, 25773, 28438, 11266, 12124, 21693, 19865, 4199, 29587, 29462, 31758, 24799, 21091, 39120, 7361, 6427, 11898, 5803, 27819, 37249, 39052, 3264, 24118, 19876, 23209, 16941, 12641, 24771, 34773, 20070, 13015, 35626, 38696, 6753, 26705, 7933, 37776, 25710, 7733, 4795, 8380, 2571, 35453, 14678, 17311, 1561, 13913, 8286, 553, 39761, 14811, 20691, 15367, 7185, 7243, 33769, 17488, 27899, 11769, 1584, 6415, 6268, 6497, 5735, 38742, 998, 201, 22638, 17346, 5168, 22677, 29044, 20595, 15908, 767, 9035, 1009, 24681, 28824, 15200, 9220, 39712, 35632, 16944, 25050, 14688, 22021, 15918, 21504, 5507, 30449, 681, 26965, 5504, 5539, 27392, 19011, 30402, 35337, 23668, 19936, 39192, 28303, 11572, 14913, 11447, 15578, 36647, 15477, 21209, 1743, 27657, 17959, 34161, 30310, 9142, 38811, 16530, 20852, 20842, 13921, 24968, 30536, 34973, 21883, 10518, 27453, 30743, 10478, 28587, 30769, 8373, 38442, 16872, 31402, 29139, 31380, 29778, 19455, 23226, 3256, 2973, 32765, 8826, 5598, 13794, 23703, 7739, 39608, 31307, 25725, 14359, 3090, 20037, 7530, 26565, 42, 34300, 39186, 2108, 1326, 13912, 12391, 33565, 20921, 1629, 9695, 8164, 26546, 16498, 25900, 29872, 32821, 18990, 20562, 33308, 11192, 27844, 17454, 23699, 28243, 5695, 6836, 11965, 20014, 8670, 26612, 33395, 33004, 21519, 25174, 3202, 28453, 38939, 23892, 12770, 10535, 28665, 17724, 38053, 19141, 6919, 9321, 34994, 7806, 28194, 15870, 22966, 35087, 11770, 16879, 16293, 21158, 33653, 20832, 22100, 11140, 36605, 8230, 29828, 28557, 14416, 14791, 15699, 239, 30725, 30545, 13874, 9535, 10815, 22848, 19643, 34620, 39500, 19143, 35564, 36067, 39133, 6095, 18812, 26121, 18730, 30976, 34577, 22535, 15747, 13884, 39847, 12048, 29335, 35540, 12871, 14189, 19583, 20673, 21886, 21210, 36294, 26554, 25420, 11713, 6234, 503, 14296, 39159, 15052, 14258, 9815, 13509, 22900, 36985, 27086, 31741, 15244, 20713, 5722, 3703, 20090, 1771, 34732, 15160, 31023, 27751, 27857, 33933, 928, 30892, 31351, 8044, 20339, 24940, 32983, 18252, 21007, 40, 13735, 1546, 26925, 37248, 21988, 26729, 36143, 6381, 26043, 11552, 625, 3954, 4530, 4936, 6310, 6990, 22881, 32678, 26847, 32555, 2588, 28470, 38532, 38491, 10637, 2091, 3938, 32972, 4522, 19479, 8694, 27327, 38740, 198, 13879, 15621, 690, 32192, 5761, 22109, 7029, 31297, 33255, 33152, 17656, 38041, 38852, 25937, 30117, 33997, 22011, 31787, 17850, 8482, 2485, 13274, 33193, 20074, 24300, 12807, 4340, 8504, 13461, 35157, 39832, 39942, 9870, 14201, 25186, 10084, 24487, 9499, 13655, 24049, 17424, 27359, 14742, 17382, 3932, 33981, 16163, 13543, 29328, 36419, 10924, 18052, 24623, 20405, 37597, 15811, 35007, 4820, 39002, 31813, 25311, 20961, 27785, 35454, 38227, 15702, 32097, 36925, 27742, 21960, 38347, 43, 23449, 38920, 1223, 26062, 4660, 11591, 2622, 11288, 15629, 26198, 2307, 35882, 21077, 10939, 6814, 3200, 15186, 23727, 4034, 25547, 31280, 12095, 36213, 24957, 23652, 10149, 26819, 27724, 34216, 28594, 34526, 33095, 11776, 37473, 39213, 29078, 31672, 12119, 8990, 6815, 5128, 27080, 36764, 17893, 31471, 18796, 38653, 25356, 28167, 27659, 22204, 6331, 24163, 28938, 33869, 31659, 38825, 33960, 28929, 38298, 16834, 38072, 9645, 18425, 29398, 11353, 20107, 24880, 6998, 17642, 4810, 22973, 31356, 18950, 37594, 6123, 26375, 39234, 3157, 21856, 3501, 36593, 37182, 38082, 17307, 35674, 2735, 10532, 17143, 19744, 27241, 34177, 15559, 34061, 37607, 35783, 4359, 2469, 20089, 19789, 22053, 21626, 4235, 25257, 28351, 37936, 2969, 4525, 3742, 38603, 13670, 11009, 11726, 8294, 25548, 6782, 18550, 18772, 19073, 18750, 4191, 28974, 36162, 11044, 29728, 31647, 20226, 20362, 16205, 34269, 15569, 32603, 29080, 28522, 22307, 23848, 7783, 28876, 26663, 28543, 33992, 5382, 21269, 4948, 25557, 6784, 23522, 35625, 14595, 37350, 18675, 28969, 35076, 4249, 26642, 9376, 15457, 21782, 4800, 19426, 5197, 22875, 39212, 5239, 20759, 29269, 33027, 15068, 30727, 21300, 7282, 29070, 15658, 14499, 38111, 25778, 28036, 33457, 16967, 21471, 26694, 36316, 2331, 25724, 24644, 4867, 39735, 31893, 16601, 17777, 37417, 35825, 2120, 16894, 8061, 5698, 34417, 11740, 7794, 1661, 5648, 28655, 11819, 25753, 22334, 19676, 8821, 6573, 6772, 2531, 19157, 974, 25677, 33352, 21161, 28639, 24150, 22689, 22786, 16657, 15671, 28126, 36010, 32319, 18365, 32220, 33805, 32784, 6098, 37798, 25741, 15788, 6328, 39550, 16947, 15776, 12916, 6296, 36224, 38217, 12752, 38017, 15715, 32958, 9212, 34395, 5860, 38366, 7025, 30583, 24786, 19268, 9772, 31498, 34445, 21503, 26146, 18794, 7052, 26238, 8709, 36813, 34779, 26484, 15147, 10661, 28394, 7119, 29484, 1611, 26028, 15728, 12514, 17257, 27122, 1713, 27394, 11212, 36174, 23704, 39123, 36616, 20771, 24220, 5359, 15667, 36724, 35873, 10095, 9367, 27421, 18179, 18501, 24140, 34062, 8036, 17136, 26807, 17051, 13770, 25065, 8780, 24577, 10811, 25837, 15925, 19025, 3696, 26360, 25392, 2938, 32597, 23906, 5110, 9765, 5453, 5578, 5103, 8462, 27906, 26856, 36966, 20105, 10475, 7012, 7264, 26981, 3370, 1746, 8280, 25193, 14268, 18939, 8661, 27790, 22161, 25570, 39549, 760, 29776, 1490, 33843, 22853, 18470, 35553, 4667, 33012, 13678, 14255, 5181, 36357, 16397, 32300, 12853, 36848, 3646, 5524, 18719, 14196, 23503, 38259, 39876, 38705, 32817, 37431, 34189, 21420, 31837, 28178, 2937, 6931, 19055, 34340, 18203, 21498, 37512, 26457, 36809, 5875, 33914, 8918, 31011, 32942, 28679, 7336, 796, 25505, 18071, 29411, 33714, 999, 37054, 33496, 24380, 38441, 38845, 6020, 18500, 24928, 9133, 4649, 24798, 33635, 12457, 27822, 29722, 16036, 28623, 18955, 38198, 976, 16311, 23697, 38002, 3180, 25349, 7456, 27881, 17088, 798, 221, 12698, 17223, 10162, 18378, 29006, 34520, 32988, 13863, 134, 38133, 28294, 33084, 3919, 32531, 35312, 10778, 5112, 27671, 37214, 23341, 4895, 13144, 34468, 24741, 11402, 8270, 39103, 27683, 4395, 19689, 38361, 30446, 24339, 11754, 21511, 15157, 34416, 21422, 21695, 3160, 7674, 31901, 33913, 29277, 27443, 7650, 8138, 17902, 37220, 25642, 25013, 16288, 1745, 26221, 18093, 19859, 3880, 23120, 1508, 10086, 31505, 14439, 8945, 9191, 13483, 91, 29622, 31284, 13761, 25955, 5392, 14549, 4464, 39324, 21159, 9552, 21016, 18657, 29060, 6516, 23918, 34971, 34375, 18053, 22362, 31153, 18367, 29974, 27796, 23245, 1144, 22335, 36855, 8862, 15746, 18379, 22513, 3673, 25915, 35408, 21510, 15288, 29586, 31109, 5278, 2506, 16681, 39114, 30942, 30293, 8328, 5873, 12623, 3228, 35898, 28597, 3363, 31335, 28855, 5468, 22306, 28495, 6597, 18787, 39981, 12084, 28683, 23321, 18374, 10638, 5830, 26624, 10020, 27105, 14443, 26991, 38621, 22613, 36239, 25092, 17687, 5106, 6191, 20255, 36107, 4571, 35987, 34138, 9039, 364, 39616, 3523, 5942, 30759, 26350, 35493, 29960, 18062, 17507, 28002, 620, 14968, 12193, 19278, 19346, 28087, 20818, 18936, 4932, 1088, 18918, 33699, 38218, 1623, 20529, 1974, 31802, 35654, 35297, 38407, 30695, 4366, 13435, 39038, 803, 8298, 18003, 1962, 17457, 2544, 15824, 17617, 31909, 20385, 34751, 413, 23176, 19748, 21, 7507, 32137, 17310, 13184, 3274, 6099, 21167, 2955, 26305, 4966, 30958, 28387, 24010, 3567, 5143, 37756, 35152, 37526, 38564, 22444, 36158, 38039, 31755, 19173, 31524, 33530, 15019, 393, 15683, 37077, 19024, 30648, 28888, 11222, 28342, 321, 16112, 16216, 8310, 34253, 17279, 27415, 23265, 35342, 36564, 14320, 9545, 12722, 37559, 8552, 27030, 17002, 36758, 34576, 4160, 31158, 17864, 27438, 17709, 21381, 31395, 7810, 2311, 28592, 38436, 12138, 28367, 18209, 35302, 17246, 11001, 18292, 22704, 8954, 25821, 28375, 36626, 995, 37356, 10339, 33190, 28827, 12854, 16943, 16728, 13085, 13463, 32865, 32427, 9908, 19087, 2808, 12713, 26555, 228, 13272, 13212, 11133, 7216, 17027, 30935, 2050, 28865, 30726, 21989, 24848, 6326, 13028, 36486, 29631, 33890, 16263, 12111, 36179, 3485, 20263, 17057, 3558, 36567, 29646, 33610, 28946, 2582, 35862, 13356, 25508, 6062, 32606, 16608, 5171, 24581, 39156, 36703, 4023, 24422, 8970, 20681, 13111, 37044, 24349, 17536, 34150, 12789, 28282, 19140, 36369, 6478, 23847, 6370, 21281, 27087, 34197, 15605, 13506, 37303, 17187, 8910, 892, 8035, 36781, 25145, 20576, 12230, 7512, 19790, 39377, 29871, 32795, 32037, 39695, 11571, 25715, 15025, 12872, 38754, 31763, 37451, 21660, 33234, 8628, 5683, 13594, 4377, 34897, 4601, 28959, 9161, 28979, 12213, 23935, 4185, 17650, 789, 910, 14115, 23478, 15763, 12023, 21243, 6330, 2839, 35196, 3897, 38870, 19336, 166, 35033, 38985, 15991, 19658, 4255, 7272, 9002, 39264, 25759, 12115, 16762, 21729, 24816, 31076, 23166, 3278, 3539, 39901, 21657, 38853, 38158, 9442, 9192, 22563, 2436, 19604, 15876, 3734, 21237, 34450, 20696, 15391, 17178, 8727, 10666, 38671, 18038, 33425, 31685, 4036, 37942, 22220, 35108, 21557, 27561, 9363, 18155, 1445, 11585, 12227, 29450, 16214, 7013, 26137, 6695, 35258, 34926, 17973, 19586, 5853, 17289, 11980, 4731, 24858, 27250, 13792, 33761, 14015, 9603, 9475, 5477, 2279, 31232, 25768, 3407, 26138, 34355, 5935, 8554, 31950, 5220, 3319, 9528, 8319, 27793, 38738, 15688, 29098, 687, 7614, 1124, 29020, 21314, 27528, 27689, 13248, 4194, 24308, 8546, 7330, 14830, 16298, 35476, 5100, 28014, 34077, 17600, 2410, 717, 5240, 22442, 33512, 12122, 20831, 29243, 38580, 24636, 8082, 27999, 8267, 22912, 10200, 1335, 8075, 23355, 3386, 4707, 33491, 9487, 39387, 8465, 9739, 24910, 1404, 24128, 25626, 33389, 12371, 16593, 3821, 29756, 1615, 4276, 13437, 32841, 21180, 7324, 16384, 21809, 17815, 6938, 14851, 23490, 34603, 3372, 26515, 30553, 12474, 25048, 36410, 3970, 7068, 22266, 35951, 37507, 11768, 9043, 29594, 19273, 14992, 36217, 16335, 5425, 37199, 6119, 16472, 36051, 26181, 9455, 6966, 31005, 8998, 11490, 33660, 4056, 27579, 1471, 30831, 8511, 17996, 14159, 4689, 2415, 39538, 26932, 11742, 29189, 30746, 30074, 2943, 9577, 16474, 10225, 25650, 20404, 16632, 7024, 29111, 31885, 459, 32186, 34058, 4947, 20615, 32217, 9923, 19085, 20182, 16688, 3826, 15595, 3656, 14465, 27391, 18032, 32913, 18383, 26269, 21189, 13613, 29445, 20649, 32803, 30325, 18642, 28026, 21475, 6572, 33665, 34569, 32251, 11583, 1846, 31767, 37860, 12047, 29979, 15272, 4593, 13044, 26106, 24950, 22368, 18295, 9018, 28515, 11736, 4775, 33585, 542, 17560, 35886, 2010, 4783, 8859, 12082, 31127, 23667, 11073, 22103, 32751, 488, 10058, 26567, 1792, 23029, 7461, 16952, 25940, 16410, 27452, 7819, 37537, 30636, 6566, 4247, 31717, 11203, 23997, 34491, 35323, 12788, 27050, 26717, 10433, 21979, 1011, 9034, 27712, 10595, 12056, 6192, 39175, 23826, 19123, 21636, 33897, 27855, 26303, 18137, 465, 33630, 1255, 38252, 35737, 32178, 17054, 34046, 12683, 39845, 7450, 8616, 2359, 5078, 25728, 1401, 31093, 27239, 33807, 21539, 11910, 25056, 23894, 13877, 26759, 28100, 32170, 15775, 27414, 29511, 16897, 36961, 34739, 5899, 31501, 1696, 39487, 5841, 26619, 4071, 8869, 2376, 37796, 959, 10821, 37411, 4428, 9565, 15344, 38701, 34507, 34895, 35162, 32659, 18561, 10995, 689, 2664, 35749, 1829, 31644, 11008, 30960, 33071, 23254, 25683, 11936, 15455, 33850, 24265, 21211, 7917, 28432, 21259, 33415, 1259, 20022, 32554, 11930, 17326, 10472, 1853, 16350, 24188, 31997, 15912, 12127, 35759, 7899, 24763, 7749, 35477, 39130, 5285, 21154, 37835, 28737, 24573, 31151, 25956, 32743, 36868, 11398, 39011, 1240, 865, 26239, 2700, 22101, 10087, 979, 23198, 6758, 441, 12073, 33165, 8021, 37420, 28034, 9333, 115, 2467, 38996, 16859, 13467, 33518, 13577, 2786, 28766, 31223, 14571, 37747, 35659, 10543, 962, 35486, 15696, 39592, 1723, 35856, 3333, 539, 11136, 10528, 29371, 24738, 5138, 35647, 24190, 25589, 31955, 20207, 25957, 17772, 3286, 10691, 4759, 19312, 25176, 38804, 32536, 4033, 4596, 176, 31820, 21761, 33792, 38135, 37314, 1186, 24742, 29783, 8131, 23374, 5396, 30708, 551, 16523, 3699, 3989, 36627, 14197, 16936, 15280, 13024, 20960, 22503, 18512, 23768, 21162, 18653, 39660, 9197, 19827, 3365, 15029, 8925, 32634, 29069, 20062, 30061, 1372, 24408, 14422, 22842, 25882, 27033, 33579, 37998, 26516, 24066, 21366, 1175, 33000, 29800, 31537, 34220, 1345, 36891, 28407, 11976, 35860, 29047, 31199, 10912, 7747, 22989, 25896, 2578, 27721, 38841, 15654, 15558, 35572, 24428, 26304, 8989, 520, 9524, 32587, 25363, 28115, 28616, 6671, 35837, 28479, 31703, 5821, 26421, 1035, 36424, 17827, 24970, 21320, 8220, 22074, 5174, 32335, 30269, 23986, 12175, 34196, 28296, 26323, 26607, 23928, 16795, 13464, 12219, 18477, 3977, 18708, 29359, 140, 12036, 30042, 2063, 30694, 6465, 8603, 13139, 15119, 9616, 2901, 16160, 12964, 28899, 18274, 20179, 33174, 32791, 37268, 7598, 4374, 39223, 13156, 11720, 35428, 9496, 30619, 26224, 3841, 6679, 36434, 35192, 18446, 23598, 30574, 17571, 28461, 36109, 10248, 36084, 33776, 11109, 35013, 29909, 32854, 22604, 34365, 39281, 28442, 13421, 31574, 29785, 11228, 3664, 18227, 9214, 5661, 23960, 26928, 38118, 25371, 12849, 4625, 877, 32284, 37331, 7331, 29526, 2338, 36293, 1076, 3873, 15397, 12421, 32703, 38371, 31321, 20963, 31186, 35822, 2196, 27934, 11570, 2017, 35171, 31435, 19444, 37064, 38719, 37649, 1147, 24515, 17729, 10169, 30721, 2763, 37838, 8199, 28475, 35649, 20915, 25832, 8336, 8142, 18277, 11752, 13251, 39143, 18783, 3258, 24275, 180, 29957, 17319, 19759, 35309, 32872, 39663, 35948, 11261, 33567, 28177, 30999, 14979, 18065, 22542, 11480, 30862, 24488, 2648, 27337, 12785, 7564, 33800, 32107, 22797, 30186, 10002, 8425, 18620, 10506, 6963, 17633, 31876, 21667, 14414, 36594, 21630, 9003, 7780, 17484, 18605, 10123, 8466, 3503, 24435, 35295, 8841, 3530, 11715, 32326, 30781, 17911, 22004, 3620, 22125, 14385, 11578, 36750, 1465, 989, 15872, 22543, 3224, 32540, 39, 5416, 39066, 4152, 27656, 34922, 37754, 15115, 22946, 10421, 31929, 39821, 23602, 13772, 10003, 31075, 10333, 27185, 33063, 7627, 29316, 22647, 12932, 10598, 20898, 16192, 35051, 20608, 37674, 35095, 3706, 33176, 15036, 31209, 32417, 12554, 11988, 35902, 20473, 2026, 24111, 18175, 10931, 29826, 3443, 20111, 35319, 2709, 35178, 10428, 32002, 18735, 1752, 34052, 12845, 39034, 30982, 37276, 38471, 26660, 20077, 9799, 763, 2486, 19238, 33840, 29403, 9971, 11803, 2302, 28419, 31614, 14744, 28148, 31840, 735, 22260, 24913, 8025, 16459, 8683, 35292, 5897, 1462, 3076, 12897, 20710, 4328, 17215, 7125, 25919, 17606, 27907, 4251, 10418, 9276, 22057, 27124, 18898, 17535, 24909, 274, 37138, 14022, 37441, 6935, 37569, 5808, 16245, 10082, 10572, 7228, 32243, 30368, 18112, 36123, 33057, 13597, 15771, 36989, 16584, 21687, 7195, 39404, 19566, 20668, 37550, 4527, 2219, 18640, 37640, 10898, 39081, 30229, 21334, 88, 28080, 20007, 32632, 9025, 15224, 17592, 26511, 33524, 34716, 4520, 20370, 33475, 39898, 31491, 29819, 35347, 38405, 23931, 28299, 15053, 18465, 9128, 24161, 28735, 24284, 24959, 26980, 31707, 2154, 1330, 4858, 19072, 39575, 15054, 19932, 19119, 20297, 22010, 13167, 1245, 7514, 26310, 3662, 36516, 29392, 5895, 7056, 24505, 5473, 39309, 28333, 27171, 22282, 36653, 1759, 30025, 22825, 25672, 26872, 20524, 33995, 27254, 36600, 23119, 32215, 35383, 5959, 19069, 14510, 24313, 35047, 8444, 34387, 35235, 29485, 37790, 424, 25333, 33646, 15761, 34383, 29153, 25434, 39965, 13842, 13551, 3158, 39884, 29158, 37105, 21400, 10888, 32526, 1221, 17174, 13160, 20892, 19126, 21506, 6072, 27418, 37312, 16443, 29519, 34841, 4158, 8728, 22155, 28450, 4500, 27827, 4657, 15325, 11895, 26597, 11548, 21895, 38310, 39774, 18287, 4587, 20196, 31228, 19384, 17836, 35570, 29171, 14833, 29228, 21709, 27148, 35427, 2476, 12296, 20809, 12699, 13223, 4232, 31859, 23813, 26704, 15947, 15583, 3781, 27534, 23076, 30682, 3613, 36498, 35754, 24597, 22740, 2365, 33207, 27758, 3007, 6350, 7470, 39316, 31354, 19249, 14866, 14632, 39049, 36634, 16592, 18389, 26966, 15076, 39227, 8239, 22943, 25974, 30072, 10650, 23942, 24142, 32501, 16575, 13773, 33417, 28963, 32559, 36937, 26880, 20305, 15342, 37805, 25797, 10376, 16738, 29503, 15805, 35629, 37996, 9679, 1518, 2466, 18744, 29724, 27544, 15749, 12305, 2036, 5938, 15735, 7374, 10379, 36690, 25210, 18808, 34088, 2087, 12266, 21615, 14333, 32118, 4971, 33435, 33909, 32184, 18713, 20571, 6132, 34140, 6490, 28552, 9396, 12528, 2999, 17436, 25529, 9821, 34198, 32289, 39819, 16663, 19785, 29201, 2607, 23142, 6549, 12485, 25384, 17774, 16659, 18528, 35854, 10411, 14736, 13351, 26074, 22212, 14093, 15215, 24765, 31611, 25575, 29610, 24646, 30830, 20884, 30896, 14277, 17551, 12516, 3992, 14068, 34306, 22671, 27781, 35426, 26435, 33494, 6864, 19580, 6254, 3797, 22523, 22002, 38534, 36936, 10870, 35126, 20151, 27315, 32836, 6974, 32428, 8735, 31434, 16568, 3338, 18397, 38724, 3487, 15887, 19001, 23973, 36578, 33932, 31982, 28586, 6863, 27264, 38172, 34759, 21944, 11287, 23283, 11142, 32776, 16801, 21253, 2295, 38921, 32598, 24122, 38931, 15875, 5402, 13050, 6281, 37571, 2514, 29008, 17222, 17018, 22784, 29712, 8001, 27092, 4725, 25538, 9814, 5326, 29510, 11488, 10813, 16231, 6489, 27619, 30508, 3617, 26389, 15898, 37695, 16739, 18737, 189, 9602, 5554, 10545, 15006, 20368, 23236, 6231, 25256, 9026, 33447, 25008, 20208, 17293, 37158, 33787, 36087, 32272, 38030, 5004, 20947, 23480, 2876, 1233, 14624, 3667, 9660, 34933, 37538, 7144, 13194, 27413, 32370, 22954, 25080, 8783, 32892, 14223, 10548, 250, 26596, 16169, 25631, 24202, 18983, 4893, 20513, 31110, 11336, 27600, 2131, 19731, 8866, 37007, 29366, 17478, 3906, 2520, 21758, 39905, 12561, 28040, 2337, 23608, 27866, 10868, 36046, 32670, 25433, 38464, 12416, 2398, 35003, 20756, 39458, 25685, 37994, 30732, 29004, 29425, 18751, 2925, 28186, 29211, 33129, 26869, 33550, 31598, 27786, 31549, 7807, 26782, 178, 29301, 25394, 33035, 23267, 3861, 20272, 23054, 35034, 29501, 36551, 9327, 27226, 10793, 39848, 1953, 11992, 26102, 1242, 27390, 39912, 1321, 33520, 1534, 36946, 2005, 23812, 1007, 31397, 16357, 1392, 4987, 6041, 21551, 12776, 215, 6678, 28640, 24370, 25729, 2280, 25781, 12657, 25295, 36682, 8440, 712, 22476, 18486, 37808, 31756, 6103, 2238, 31541, 15597, 35970, 8480, 7463, 37510, 26433, 10325, 17725, 30105, 5831, 14886, 22028, 13731, 38676, 26383, 36497, 13084, 14876, 27002, 4221, 38523, 38510, 27861, 791, 28631, 12395, 35600, 218, 28418, 4164, 23081, 8141, 36385, 19959, 35063, 19803, 34255, 4498, 2843, 8086, 30026, 33976, 33577, 15153, 5763, 11517, 9505, 8871, 28206, 12793, 14285, 23833, 23524, 15480, 3111, 28436, 21913, 31462, 15069, 20295, 5708, 3127, 11013, 16597, 23651, 30590, 16975, 26191, 12413, 6805, 12452, 14887, 28237, 38376, 5653, 34856, 21268, 34679, 32553, 4379, 27234, 36777, 20740, 33060, 31539, 39686, 13380, 1622, 25776, 11953, 9291, 27085, 39996, 18394, 37609, 35446, 18194, 10179, 13751, 39979, 16545, 28360, 9242, 31373, 815, 8950, 2308, 16903, 7453, 33775, 21629, 32174, 5246, 11145, 19698, 29942, 21825, 1430, 30335, 36702, 32516, 28903, 27484, 20002, 203, 27454, 21714, 20685, 31650, 23402, 26296, 23185, 27568, 293, 29089, 21926, 39503, 6539, 33302, 13292, 28554, 10494, 38483, 13320, 38448, 18284, 37647, 23152, 6930, 1436, 9228, 12526, 28725, 33, 36333, 17549, 33851, 36361, 32436, 8474, 33885, 26024, 32147, 5649, 36849, 22569, 26675, 26257, 16029, 22828, 39356, 15248, 21197, 32266, 13722, 4202, 11364, 36242, 13936, 32471, 10762, 38389, 14250, 11187, 4233, 38052, 23180, 25399, 2481, 6420, 14392, 28260, 27253, 9588, 17045, 10603, 6548, 3853, 25473, 784, 1634, 6609, 39006, 38606, 20920, 15561, 28357, 16977, 25501, 4738, 18237, 37678, 4975, 14286, 26104, 16925, 35601, 16775, 11018, 12313, 17263, 4809, 11226, 16665, 3043, 13204, 23237, 5770, 2221, 18880, 37376, 38249, 23803, 24082, 26772, 3948, 38739, 23639, 36869, 25946, 37894, 3956, 11586, 26176, 16806, 9338, 5913, 23308, 37652, 6215, 1090, 601, 1768, 36166, 31570, 35419, 10992, 4363, 6521, 17621, 33226, 13307, 34116, 19872, 34056, 3138, 5213, 2239, 23895, 32941, 14373, 11730, 25304, 2251, 20281, 31662, 9833, 37867, 22237, 37083, 4452, 3070, 7182, 4499, 25196, 27229, 28923, 31545, 9296, 31390, 21676, 13368, 17420, 31004, 14672, 31844, 17415, 10441, 26046, 12176, 7645, 12132, 29637, 31834, 30608, 20599, 9435, 10930, 33443, 19183, 29926, 38156, 16061, 39696, 39779, 31855, 17950, 35742, 9880, 34136, 13983, 28879, 36909, 23782, 13602, 4236, 5804, 5245, 2799, 13927, 20749, 14016, 19735, 9048, 22419, 19696, 25376, 28474, 19220, 33517, 3126, 11795, 24413, 22431, 195, 38544, 21994, 22041, 21778, 19228, 35469, 28437, 15291, 32701, 17993, 8365, 1439, 30121, 22735, 27025, 32440, 11711, 29846, 41, 21917, 32199, 478, 30113, 25369, 7432, 9114, 18944, 39070, 8177, 39262, 16404, 32731, 2770, 24834, 31608, 3942, 2774, 10455, 6933, 31288, 26142, 23898, 12674, 35961, 11034, 39984, 32426, 28072, 35933, 37848, 30086, 6838, 31329, 21017, 6432, 34112, 939, 18520, 33498, 13725, 35964, 29863, 1126, 37127, 22079, 21172, 35310, 9769, 22607, 21329, 18631, 28483, 12876, 39922, 3541, 21262, 37843, 32889, 36301, 29119, 6528, 9078, 407, 38688, 20095, 26225, 618, 25528, 20870, 3640, 12609, 37167, 7793, 39576, 1822, 12322, 36898, 13994, 29467, 32457, 8461, 3128, 24963, 29948, 15989, 8972, 23294, 8733, 26384, 27246, 39693, 9317, 27325, 12513, 34948, 32916, 39666, 35329, 12931, 22048, 34202, 32694, 39698, 33828, 38813, 26180, 21206, 4448, 5538, 26361, 7502, 16866, 25498, 16005, 6662, 7263, 20949, 34421, 18358, 17082, 38300, 16237, 12729, 32786, 7159, 38004, 20003, 21685, 1131, 18609, 25053, 377, 12987, 9203, 12635, 15285, 20660, 39563, 35338, 27060, 38883, 29889, 10213, 18250, 33454, 10623, 27300, 3872, 34525, 2124, 4358, 5521, 9087, 13117, 12796, 23875, 36903, 1397, 38831, 755, 5628, 15863, 26152, 36121, 26957, 17806, 18356, 32020, 32396, 5456, 16862, 21031, 34864, 38020, 29376, 29607, 14514, 25197, 37948, 29028, 31468, 29672, 31159, 23642, 14638, 11409, 27265, 36178, 34211, 19200, 13031, 7932, 27348, 8355, 17782, 33387, 39720, 12911, 15171, 11376, 39116, 38836, 30109, 5263, 23527, 4184, 30118, 23939, 32191, 8285, 36337, 7835, 15048, 19767, 34846, 16917, 15655, 8074, 23168, 26301, 30323, 4681, 28622, 32439, 22972, 4876, 18232, 12488, 3887, 36371, 19741, 3769, 32244, 25947, 13618, 38080, 10466, 21852, 26090, 24376, 31729, 16585, 11469, 36630, 4118, 26794, 32249, 27851, 16240, 18503, 36185, 36393, 20205, 23766, 14220, 10493, 991, 20363, 31258, 120, 4133, 32308, 28662, 32681, 15495, 30283, 12003, 24604, 28641, 9515, 12919, 33625, 12478, 23194, 4388, 14781, 10564, 13759, 30196, 18369, 36835, 12432, 22193, 9721, 22794, 32395, 17764, 872, 39742, 37497, 9983, 9979, 16828, 36930, 20697, 29437, 1645, 2491, 11696, 33570, 35592, 28275, 29262, 36255, 12642, 29184, 23137, 30753, 15473, 17781, 34742, 27137, 28199, 28362, 30522, 21940, 16165, 18828, 29457, 6272, 20687, 11612, 27853, 25963, 35314, 18221, 17757, 6636, 5459, 21995, 4315, 37927, 15648, 80, 39166, 20467, 13724, 5363, 34605, 26924, 28172, 6388, 35213, 39010, 12208, 11706, 31081, 39893, 36746, 17862, 17010, 39244, 14890, 9642, 8215, 28702, 12773, 34373, 2324, 6125, 6354, 4239, 24817, 33798, 24967, 7776, 24476, 25415, 15799, 28241, 30333, 21924, 32805, 23528, 13798, 2309, 13575, 13232, 39557, 3423, 2975, 7376, 25135, 39998, 35508, 12465, 26400, 6654, 28043, 36730, 19942, 11184, 17906, 17056, 9332, 38204, 30624, 34888, 33735, 32528, 34092, 6813, 8134, 30521, 9962, 568, 9429, 10161, 10266, 24167, 16938, 16808, 10517, 12682, 37090, 28878, 23084, 28339, 25378, 16873, 18841, 2890, 1855, 18368, 25105, 13108, 4476, 36780, 800, 26945, 24415, 3577, 35537, 7572, 21110, 38493, 28988, 23946, 31913, 32149, 13662, 4261, 18403, 20326, 28292, 8761, 3505, 6217, 9507, 22507, 15031, 475, 16478, 27449, 13904, 27029, 12319, 16228, 12378, 35936, 30120, 16857, 21173, 35764, 17290, 35885, 6588, 35562, 10293, 27675, 13758, 32060, 14681, 9651, 16835, 22093, 37987, 19718, 39983, 9040, 6036, 26312, 25301, 28181, 15144, 36416, 14665, 15110, 24844, 34264, 14778, 33102, 38316, 24028, 29200, 20468, 25614, 17652, 21823, 16974, 13006, 4112, 15239, 31343, 10405, 35877, 30937, 28971, 13695, 3609, 22495, 16606, 11179, 27648, 13529, 36, 11584, 19162, 334, 30513, 34724, 29522, 3908, 17865, 37195, 11560, 37428, 8648, 4651, 17726, 1738, 20439, 32491, 18138, 409, 20213, 22202, 27350, 6484, 35883, 31222, 33642, 3081, 11152, 16078, 33166, 38504, 19862, 23233, 9596, 26628, 16874, 31132, 31152, 19234, 28571, 6915, 19720, 6916, 23016, 24042, 22406, 20046, 12290, 34755, 11861, 13741, 25134, 34953, 11648, 32828, 20087, 17580, 8724, 11460, 35046, 9943, 28932, 32066, 6366, 17286, 34312, 36478, 2566, 24257, 38357, 21673, 22732, 34521, 23345, 2974, 11763, 26493, 8194, 37400, 9631, 15745, 2096, 31157, 14880, 32921, 24125, 8635, 21383, 37641, 39105, 2986, 3581, 11657, 36620, 8734, 14733, 10065, 36992, 19750, 1529, 3842, 37202, 19774, 22778, 35728, 33655, 13224, 16877, 31324, 35333, 17341, 867, 8037, 7040, 6250, 11549, 25364, 26139, 18413, 34089, 9730, 5235, 33738, 35818, 26578, 10620, 33879, 8544, 33177, 21439, 39318, 19953, 1478, 25017, 9564, 18868, 2335, 16786, 38447, 30482, 27318, 10310, 33528, 35402, 20580, 19015, 32051, 30190, 16424, 13189, 354, 12817, 17566, 23138, 1943, 18050, 16355, 12453, 26822, 13237, 19978, 34559, 10399, 21532, 22700, 31711, 39028, 10773, 28402, 28160, 35897, 30857, 28668, 14526, 3356, 29332, 2595, 18878, 29861, 3611, 34573, 16153, 10884, 38473, 6790, 28440, 30181, 3123, 31431, 31221, 2841, 37409, 11871, 17640, 2189, 11939, 3314, 30152, 13829, 36517, 38466, 21389, 27523, 38314, 11941, 23445, 38452, 37963, 23275, 13720, 31704, 35084, 9371, 21417, 8301, 3671, 35998, 37952, 283, 33011, 19367, 24184, 35250, 38928, 14337, 11014, 37107, 5773, 30683, 31438, 9004, 156, 9457, 4084, 38871, 12968, 172, 24753, 6267, 27197, 4354, 10297, 26805, 5705, 24427, 39948, 3392, 2992, 18602, 15103, 36785, 19449, 9856, 24256, 1826, 8572, 19347, 5677, 35798, 30551, 22000, 4924, 292, 35523, 3916, 14132, 39344, 11995, 20416, 35009, 395, 37691, 24905, 17474, 2316, 21454, 29787, 27330, 5233, 38205, 5252, 12542, 17638, 1287, 4915, 35204, 11813, 27848, 22727, 30899, 30284, 25533, 1010, 25215, 28839, 30983, 32781, 10748, 11610, 21786, 10114, 21982, 35404, 3456, 26756, 14046, 16235, 30658, 22097, 31768, 20585, 3969, 7634, 21508, 28553, 16138, 12489, 19991, 36655, 36285, 29914, 5076, 35787, 9101, 31527, 18107, 19389, 11006, 636, 28723, 25476, 6664, 34328, 21377, 26319, 35205, 31053, 23566, 10083, 18143, 24154, 38191, 14513, 30606, 9028, 8571, 18588, 15308, 29192, 31605, 39493, 20830, 12655, 17696, 28832, 20538, 17486, 29790, 24651, 33099, 33526, 4104, 19465, 38261, 29456, 2757, 25143, 12921, 38554, 11015, 3635, 32690, 29187, 5948, 12029, 32864, 18513, 26125, 14818, 8371, 18967, 21947, 31149, 39825, 212, 38200, 35044, 23536, 35424, 20564, 13646, 34428, 13796, 16722, 13131, 16549, 3346, 14141, 9295, 5872, 20988, 36859, 20679, 35499, 26603, 25072, 18061, 10152, 7166, 32049, 16389, 26875, 21752, 32131, 35410, 15847, 2781, 14493, 9899, 1001, 6776, 36117, 21316, 36441, 13387, 38188, 7261, 36672, 32350, 11618, 24386, 24683, 10267, 34811, 17453, 16465, 17921, 25213, 32970, 19489, 10307, 23461, 30676, 39635, 29374, 39909, 5954, 1783, 39658, 12986, 18893, 9537, 22749, 22343, 29204, 15927, 5845, 39831, 12299, 7675, 1354, 28803, 7238, 33033, 16905, 31473, 22723, 37672, 14919, 9519, 28049, 4401, 33329, 9751, 39205, 27614, 13221, 32212, 22128, 37439, 29483, 35802, 19574, 6830, 16512, 33590, 3632, 37429, 33543, 22746, 439, 7561, 11909, 15013, 10320, 18487, 16569, 13216, 9633, 10527, 15446, 18313, 4446, 5723, 35805, 7001, 5492, 15046, 2734, 25599, 17881, 22672, 19307, 25261, 3201, 18357, 50, 20162, 37020, 26003, 10847, 24709, 36534, 32713, 37740, 36400, 8863, 6048, 37070, 30616, 6087, 9732, 21802, 36749, 232, 20777, 4271, 19189, 36474, 19359, 6298, 31930, 19488, 953, 25231, 22345, 20644, 13348, 9323, 12323, 28786, 17443, 26286, 137, 23870, 31718, 38661, 17562, 39292, 27361, 8822, 8650, 9508, 1028, 39791, 20367, 23631, 24241, 12901, 4551, 39216, 5350, 6707, 36488, 19641, 11894, 13033, 8329, 23902, 31227, 25380, 28672, 32924, 33921, 806, 6315, 31782, 11311, 8747, 30667, 17868, 7801, 15493, 28500, 16747, 8273, 7473, 19096, 24387, 7558, 37216, 2733, 25074, 34185, 23475, 11322, 27362, 21174, 22318, 34610, 37687, 30838, 27889, 26630, 2144, 28875, 36955, 1119, 32829, 948, 15188, 28756, 30443, 7227, 21044, 37048, 23274, 39315, 21270, 21671, 21875, 3036, 18648, 13764, 6831, 2305, 28406, 32158, 22887, 30887, 6730, 11068, 28718, 38430, 29086, 1027, 35464, 36036, 25342, 4079, 9907, 7968, 7720, 32818, 23368, 21146, 15793, 1606, 17456, 39826, 3028, 8119, 35637, 16356, 24785, 14092, 18842, 36959, 25450, 11830, 2173, 7721, 21414, 27713, 2972, 32495, 15117, 31410, 26151, 17388, 35810, 16527, 24045, 26021, 17040, 21779, 3694, 37003, 38038, 9345, 22063, 26126, 22788, 21563, 36980, 27286, 28104, 7019, 34814, 17744, 29883, 13916, 4753, 28388, 12608, 11020, 6351, 37208, 35080, 9634, 32822, 9800, 39573, 2270, 22344, 19512, 23220, 33835, 14954, 11924, 26041, 502, 28635, 34995, 32953, 29985, 31968, 10370, 16621, 20916, 13002, 1499, 1311, 33235, 22055, 14891, 15432, 36226, 4392, 25302, 10154, 30577, 26961, 19477, 18552, 28021, 4563, 11306, 7803, 14463, 22801, 30565, 7051, 38176, 3033, 22602, 13377, 11063, 36897, 15134, 19621, 19287, 18964, 25945, 17819, 25358, 10508, 29664, 26093, 13338, 37883, 30214, 12037, 38488, 14927, 7253, 20235, 29643, 28048, 16774, 7419, 24169, 27555, 23995, 24820, 31522, 25254, 37802, 30997, 17626, 35731, 33236, 1472, 33168, 15451, 27715, 38835, 36738, 31348, 35449, 1304, 38972, 15302, 4789, 18269, 24852, 18769, 3466, 22243, 3885, 28795, 22996, 38934, 35618, 38328, 26598, 528, 7636, 2076, 37353, 16167, 2568, 17801, 13334, 33928, 18297, 35965, 3391, 35463, 31974, 20165, 36116, 20721, 30050, 25617, 14816, 2613, 14896, 14263, 38859, 4539, 32788, 24274, 12348, 35118, 30716, 24542, 2768, 31084, 39129, 19570, 2837, 8242, 39131, 16980, 30561, 22452, 3997, 22845, 38980, 11265, 29744, 10510, 5911, 27459, 10730, 555, 3368, 10366, 21104, 14598, 31829, 37316, 33201, 27445, 32377, 39283, 25054, 22837, 28270, 30912, 20080, 25502, 17321, 16694, 12994, 7725, 23121, 32388, 32760, 28494, 5358, 2289, 39446, 5361, 24110, 366, 19106, 28433, 18195, 23451, 21059, 4390, 4946, 33593, 2396, 9549, 11024, 33819, 2761, 2773, 13603, 3390, 12519, 9605, 33257, 20282, 14637, 34316, 27052, 30495, 28736, 39692, 17860, 39111, 25944, 35374, 21858, 35353, 7382, 13817, 18521, 27164, 1996, 35100, 22588, 8263, 6794, 8258, 20233, 39084, 29961, 4003, 9827, 31949, 34683, 38662, 32946, 23853, 5588, 27075, 12647, 29343, 13762, 22201, 17269, 30314, 28016, 8049, 16848, 19937, 11831, 23144, 4582, 33465, 28330, 14342, 27761, 7428, 18024, 16244, 29280, 37758, 9044, 10893, 38752, 10841, 33101, 5879, 11216, 15980, 13325, 30195, 12085, 23193, 33941, 9229, 13479, 8087, 35978, 33463, 15368, 18115, 34578, 30000, 5711, 20919, 36086, 11528, 17905, 20026, 7207, 18404, 38784, 37979, 17555, 32900, 39405, 17135, 32330, 20791, 3899, 29911, 36039, 2860, 9724, 25875, 13023, 19794, 32505, 17878, 38679, 25154, 12415, 13673, 33709, 33978, 3018, 16075, 4325, 39304, 21034, 9011, 851, 5892, 38384, 421, 573, 18630, 13247, 2424, 24557, 1041, 20204, 10174, 29648, 29742, 33187, 34963, 20924, 7359, 5469, 25028, 31267, 18249, 10663, 17649, 29677, 3519, 34870, 35143, 38484, 15155, 10443, 431, 5323, 19772, 27005, 37988, 33912, 12216, 22051, 14395, 11219, 30303, 16820, 34532, 8827, 25848, 29518, 35747, 15930, 27066, 14377, 13630, 28422, 7151, 22628, 34393, 4873, 19732, 24721, 38083, 9840, 30532, 13275, 7181, 25721, 14801, 15951, 19534, 1000, 31619, 37449, 16547, 21493, 30845, 5021, 12943, 9928, 2457, 21388, 2304, 38530, 7233, 30884, 33916, 2281, 2900, 9682, 6660, 9902, 34081, 24828, 2662, 4817, 38373, 31124, 6193, 13813, 24225, 21977, 24346, 10136, 6612, 11536, 8559, 20935, 2567, 31461, 7631, 3815, 14167, 11315, 4621, 4957, 39995, 24253, 35539, 32915, 15507, 21743, 7246, 29287, 26374, 11446, 38552, 24580, 6906, 24137, 29393, 14102, 15378, 12821, 1579, 25606, 8977, 17022, 13315, 38693, 17309, 36257, 39138, 9218, 23244, 20302, 9346, 35040, 8755, 13808, 25690, 26165, 35322, 35753, 30688, 1798, 4545, 14428, 35147, 32761, 8768, 16586, 12533, 29732, 3848, 24514, 12301, 10234, 39685, 17015, 39530, 8098, 13025, 18853, 39849, 28175, 11557, 35515, 9360, 22560, 18455, 29915, 35461, 33551, 31233, 16273, 6616, 11753, 5666, 18576, 20246, 19016, 12749, 28007, 17445, 33608, 24819, 35283, 10684};
// Sorting variables
int aux;
int verifier;
int len = sizeof(array)/sizeof(int);
// Sorting
for(int i = 0;i < len-1;i++) {
verifier = 0;
for(int j = 0;j < len-1;j++) {
if(array[j] > array[j+1]) {
verifier = 1;
aux = *(array + j);
array[j] = array[j+1];
array[j+1] = aux;
}
}
if(!verifier) break;
}
//for(int i = 0;i < len;i++) {
// printf("%d ",array[i]);
//}
printf("\n");
clock_t end = clock();
time_spent += (double)(end-begin)/ CLOCKS_PER_SEC;
printf("Time: %f\n",time_spent);
}
|
the_stack_data/86074232.c
|
//@ ltl invariant negative: ( ([] ( (! ( AP((s0_l1 != 0)) && (! AP((s0_l0 != 0))))) || (<> ( (! AP((s0_l0 != 0))) && (! AP((s0_l1 != 0))))))) || (! ([] (<> AP((1.0 <= _diverge_delta))))));
extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
char __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
char s11_l1, _x_s11_l1;
char s11_l0, _x_s11_l0;
char s11_evt2, _x_s11_evt2;
char s11_evt1, _x_s11_evt1;
char s11_evt0, _x_s11_evt0;
float s11_x, _x_s11_x;
char s10_l1, _x_s10_l1;
char s10_l0, _x_s10_l0;
char s10_evt2, _x_s10_evt2;
char s10_evt1, _x_s10_evt1;
char s10_evt0, _x_s10_evt0;
float s10_x, _x_s10_x;
char s9_l1, _x_s9_l1;
char s9_l0, _x_s9_l0;
char s9_evt2, _x_s9_evt2;
char s9_evt1, _x_s9_evt1;
char s9_evt0, _x_s9_evt0;
float s9_x, _x_s9_x;
char s8_l1, _x_s8_l1;
char s8_l0, _x_s8_l0;
char s8_evt2, _x_s8_evt2;
char s8_evt1, _x_s8_evt1;
char s2_evt2, _x_s2_evt2;
char s1_evt2, _x_s1_evt2;
char s2_evt1, _x_s2_evt1;
char s1_evt1, _x_s1_evt1;
char s3_evt0, _x_s3_evt0;
float s8_x, _x_s8_x;
char s2_evt0, _x_s2_evt0;
char s1_evt0, _x_s1_evt0;
float s6_x, _x_s6_x;
float s2_x, _x_s2_x;
float s1_x, _x_s1_x;
char s1_l1, _x_s1_l1;
char s6_evt1, _x_s6_evt1;
int bus_cd_id, _x_bus_cd_id;
float delta, _x_delta;
char s2_l0, _x_s2_l0;
char s1_l0, _x_s1_l0;
char s2_l1, _x_s2_l1;
char bus_evt0, _x_bus_evt0;
int bus_j, _x_bus_j;
char s6_evt2, _x_s6_evt2;
char bus_evt1, _x_bus_evt1;
char s3_l0, _x_s3_l0;
char s5_evt0, _x_s5_evt0;
char bus_evt2, _x_bus_evt2;
char s3_l1, _x_s3_l1;
float s3_x, _x_s3_x;
char bus_l1, _x_bus_l1;
char s5_evt1, _x_s5_evt1;
float s7_x, _x_s7_x;
float s0_x, _x_s0_x;
char s3_evt1, _x_s3_evt1;
char s3_evt2, _x_s3_evt2;
float bus_x, _x_bus_x;
float s4_x, _x_s4_x;
char s4_evt0, _x_s4_evt0;
float _diverge_delta, _x__diverge_delta;
char s4_evt1, _x_s4_evt1;
char s4_evt2, _x_s4_evt2;
char s4_l0, _x_s4_l0;
char s4_l1, _x_s4_l1;
float s5_x, _x_s5_x;
char bus_l0, _x_bus_l0;
char s5_evt2, _x_s5_evt2;
char s5_l0, _x_s5_l0;
char s5_l1, _x_s5_l1;
char s6_evt0, _x_s6_evt0;
char s6_l0, _x_s6_l0;
char s6_l1, _x_s6_l1;
char s0_evt0, _x_s0_evt0;
char s7_evt0, _x_s7_evt0;
char s0_evt1, _x_s0_evt1;
char s7_evt1, _x_s7_evt1;
char s0_evt2, _x_s0_evt2;
char s7_evt2, _x_s7_evt2;
char s0_l0, _x_s0_l0;
char s7_l0, _x_s7_l0;
char s0_l1, _x_s0_l1;
char s7_l1, _x_s7_l1;
char s8_evt0, _x_s8_evt0;
int main()
{
s11_l1 = __VERIFIER_nondet_bool();
s11_l0 = __VERIFIER_nondet_bool();
s11_evt2 = __VERIFIER_nondet_bool();
s11_evt1 = __VERIFIER_nondet_bool();
s11_evt0 = __VERIFIER_nondet_bool();
s11_x = __VERIFIER_nondet_float();
s10_l1 = __VERIFIER_nondet_bool();
s10_l0 = __VERIFIER_nondet_bool();
s10_evt2 = __VERIFIER_nondet_bool();
s10_evt1 = __VERIFIER_nondet_bool();
s10_evt0 = __VERIFIER_nondet_bool();
s10_x = __VERIFIER_nondet_float();
s9_l1 = __VERIFIER_nondet_bool();
s9_l0 = __VERIFIER_nondet_bool();
s9_evt2 = __VERIFIER_nondet_bool();
s9_evt1 = __VERIFIER_nondet_bool();
s9_evt0 = __VERIFIER_nondet_bool();
s9_x = __VERIFIER_nondet_float();
s8_l1 = __VERIFIER_nondet_bool();
s8_l0 = __VERIFIER_nondet_bool();
s8_evt2 = __VERIFIER_nondet_bool();
s8_evt1 = __VERIFIER_nondet_bool();
s2_evt2 = __VERIFIER_nondet_bool();
s1_evt2 = __VERIFIER_nondet_bool();
s2_evt1 = __VERIFIER_nondet_bool();
s1_evt1 = __VERIFIER_nondet_bool();
s3_evt0 = __VERIFIER_nondet_bool();
s8_x = __VERIFIER_nondet_float();
s2_evt0 = __VERIFIER_nondet_bool();
s1_evt0 = __VERIFIER_nondet_bool();
s6_x = __VERIFIER_nondet_float();
s2_x = __VERIFIER_nondet_float();
s1_x = __VERIFIER_nondet_float();
s1_l1 = __VERIFIER_nondet_bool();
s6_evt1 = __VERIFIER_nondet_bool();
bus_cd_id = __VERIFIER_nondet_int();
delta = __VERIFIER_nondet_float();
s2_l0 = __VERIFIER_nondet_bool();
s1_l0 = __VERIFIER_nondet_bool();
s2_l1 = __VERIFIER_nondet_bool();
bus_evt0 = __VERIFIER_nondet_bool();
bus_j = __VERIFIER_nondet_int();
s6_evt2 = __VERIFIER_nondet_bool();
bus_evt1 = __VERIFIER_nondet_bool();
s3_l0 = __VERIFIER_nondet_bool();
s5_evt0 = __VERIFIER_nondet_bool();
bus_evt2 = __VERIFIER_nondet_bool();
s3_l1 = __VERIFIER_nondet_bool();
s3_x = __VERIFIER_nondet_float();
bus_l1 = __VERIFIER_nondet_bool();
s5_evt1 = __VERIFIER_nondet_bool();
s7_x = __VERIFIER_nondet_float();
s0_x = __VERIFIER_nondet_float();
s3_evt1 = __VERIFIER_nondet_bool();
s3_evt2 = __VERIFIER_nondet_bool();
bus_x = __VERIFIER_nondet_float();
s4_x = __VERIFIER_nondet_float();
s4_evt0 = __VERIFIER_nondet_bool();
_diverge_delta = __VERIFIER_nondet_float();
s4_evt1 = __VERIFIER_nondet_bool();
s4_evt2 = __VERIFIER_nondet_bool();
s4_l0 = __VERIFIER_nondet_bool();
s4_l1 = __VERIFIER_nondet_bool();
s5_x = __VERIFIER_nondet_float();
bus_l0 = __VERIFIER_nondet_bool();
s5_evt2 = __VERIFIER_nondet_bool();
s5_l0 = __VERIFIER_nondet_bool();
s5_l1 = __VERIFIER_nondet_bool();
s6_evt0 = __VERIFIER_nondet_bool();
s6_l0 = __VERIFIER_nondet_bool();
s6_l1 = __VERIFIER_nondet_bool();
s0_evt0 = __VERIFIER_nondet_bool();
s7_evt0 = __VERIFIER_nondet_bool();
s0_evt1 = __VERIFIER_nondet_bool();
s7_evt1 = __VERIFIER_nondet_bool();
s0_evt2 = __VERIFIER_nondet_bool();
s7_evt2 = __VERIFIER_nondet_bool();
s0_l0 = __VERIFIER_nondet_bool();
s7_l0 = __VERIFIER_nondet_bool();
s0_l1 = __VERIFIER_nondet_bool();
s7_l1 = __VERIFIER_nondet_bool();
s8_evt0 = __VERIFIER_nondet_bool();
int __ok = ((((((((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && (s11_x == 0.0)) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) || (((( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || ((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))) || ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || ((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))))))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) || (((s11_l1 != 0) && ( !(s11_l0 != 0))) || ((s11_l0 != 0) && ( !(s11_l1 != 0)))))) && ((s11_x <= 404.0) || ( !((s11_l1 != 0) && ( !(s11_l0 != 0)))))) && ((s11_x <= 26.0) || ( !((s11_l0 != 0) && ( !(s11_l1 != 0)))))) && (((((((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && (s10_x == 0.0)) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) || (((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || ((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))) || ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || ((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))))))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) || (((s10_l1 != 0) && ( !(s10_l0 != 0))) || ((s10_l0 != 0) && ( !(s10_l1 != 0)))))) && ((s10_x <= 404.0) || ( !((s10_l1 != 0) && ( !(s10_l0 != 0)))))) && ((s10_x <= 26.0) || ( !((s10_l0 != 0) && ( !(s10_l1 != 0)))))) && (((((((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && (s9_x == 0.0)) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) || (((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || ((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))) || ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || ((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))))))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) || (((s9_l1 != 0) && ( !(s9_l0 != 0))) || ((s9_l0 != 0) && ( !(s9_l1 != 0)))))) && ((s9_x <= 404.0) || ( !((s9_l1 != 0) && ( !(s9_l0 != 0)))))) && ((s9_x <= 26.0) || ( !((s9_l0 != 0) && ( !(s9_l1 != 0)))))) && (((((((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && (s8_x == 0.0)) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) || (((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || ((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))) || ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || ((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))))))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) || (((s8_l1 != 0) && ( !(s8_l0 != 0))) || ((s8_l0 != 0) && ( !(s8_l1 != 0)))))) && ((s8_x <= 404.0) || ( !((s8_l1 != 0) && ( !(s8_l0 != 0)))))) && ((s8_x <= 26.0) || ( !((s8_l0 != 0) && ( !(s8_l1 != 0)))))) && (((((((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && (s7_x == 0.0)) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) || (((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || ((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))) || ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || ((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))))))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) || (((s7_l1 != 0) && ( !(s7_l0 != 0))) || ((s7_l0 != 0) && ( !(s7_l1 != 0)))))) && ((s7_x <= 404.0) || ( !((s7_l1 != 0) && ( !(s7_l0 != 0)))))) && ((s7_x <= 26.0) || ( !((s7_l0 != 0) && ( !(s7_l1 != 0)))))) && (((((((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && (s6_x == 0.0)) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) || (((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || ((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))) || ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || ((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))))))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) || (((s6_l1 != 0) && ( !(s6_l0 != 0))) || ((s6_l0 != 0) && ( !(s6_l1 != 0)))))) && ((s6_x <= 404.0) || ( !((s6_l1 != 0) && ( !(s6_l0 != 0)))))) && ((s6_x <= 26.0) || ( !((s6_l0 != 0) && ( !(s6_l1 != 0)))))) && (((((((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && (s5_x == 0.0)) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) || (((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || ((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))) || ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || ((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))))))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) || (((s5_l1 != 0) && ( !(s5_l0 != 0))) || ((s5_l0 != 0) && ( !(s5_l1 != 0)))))) && ((s5_x <= 404.0) || ( !((s5_l1 != 0) && ( !(s5_l0 != 0)))))) && ((s5_x <= 26.0) || ( !((s5_l0 != 0) && ( !(s5_l1 != 0)))))) && (((((((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && (s4_x == 0.0)) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) || (((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || ((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))) || ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || ((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))))))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) || (((s4_l1 != 0) && ( !(s4_l0 != 0))) || ((s4_l0 != 0) && ( !(s4_l1 != 0)))))) && ((s4_x <= 404.0) || ( !((s4_l1 != 0) && ( !(s4_l0 != 0)))))) && ((s4_x <= 26.0) || ( !((s4_l0 != 0) && ( !(s4_l1 != 0)))))) && (((((((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && (s3_x == 0.0)) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) || (((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || ((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))) || ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || ((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))))))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) || (((s3_l1 != 0) && ( !(s3_l0 != 0))) || ((s3_l0 != 0) && ( !(s3_l1 != 0)))))) && ((s3_x <= 404.0) || ( !((s3_l1 != 0) && ( !(s3_l0 != 0)))))) && ((s3_x <= 26.0) || ( !((s3_l0 != 0) && ( !(s3_l1 != 0)))))) && (((((((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && (s2_x == 0.0)) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) || (((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || ((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))) || ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || ((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))))))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) || (((s2_l1 != 0) && ( !(s2_l0 != 0))) || ((s2_l0 != 0) && ( !(s2_l1 != 0)))))) && ((s2_x <= 404.0) || ( !((s2_l1 != 0) && ( !(s2_l0 != 0)))))) && ((s2_x <= 26.0) || ( !((s2_l0 != 0) && ( !(s2_l1 != 0)))))) && (((((((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && (s1_x == 0.0)) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) || (((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || ((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || ((( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) || ((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) || (((s1_l1 != 0) && ( !(s1_l0 != 0))) || ((s1_l0 != 0) && ( !(s1_l1 != 0)))))) && ((s1_x <= 404.0) || ( !((s1_l1 != 0) && ( !(s1_l0 != 0)))))) && ((s1_x <= 26.0) || ( !((s1_l0 != 0) && ( !(s1_l1 != 0)))))) && (((((((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && (s0_x == 0.0)) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) || (((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || ((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))) || ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || ((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))))))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) || (((s0_l1 != 0) && ( !(s0_l0 != 0))) || ((s0_l0 != 0) && ( !(s0_l1 != 0)))))) && ((s0_x <= 404.0) || ( !((s0_l1 != 0) && ( !(s0_l0 != 0)))))) && ((s0_x <= 26.0) || ( !((s0_l0 != 0) && ( !(s0_l1 != 0)))))) && (((((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) && (((( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) || ((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) || (( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0))))) || (((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) || (( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0))))))) && (((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) || ((bus_l1 != 0) && ( !(bus_l0 != 0)))) || (((bus_l0 != 0) && ( !(bus_l1 != 0))) || ((bus_l0 != 0) && (bus_l1 != 0)))))) && ((bus_j == 0) && (bus_x == 0.0))) && ((( !(13.0 <= bus_x)) || ( !((bus_l0 != 0) && ( !(bus_l1 != 0))))) && ((delta == 0.0) || ( !((bus_l0 != 0) && (bus_l1 != 0)))))) && (0.0 <= delta)))))))))))))) && (delta == _diverge_delta));
while (__ok) {
_x_s11_l1 = __VERIFIER_nondet_bool();
_x_s11_l0 = __VERIFIER_nondet_bool();
_x_s11_evt2 = __VERIFIER_nondet_bool();
_x_s11_evt1 = __VERIFIER_nondet_bool();
_x_s11_evt0 = __VERIFIER_nondet_bool();
_x_s11_x = __VERIFIER_nondet_float();
_x_s10_l1 = __VERIFIER_nondet_bool();
_x_s10_l0 = __VERIFIER_nondet_bool();
_x_s10_evt2 = __VERIFIER_nondet_bool();
_x_s10_evt1 = __VERIFIER_nondet_bool();
_x_s10_evt0 = __VERIFIER_nondet_bool();
_x_s10_x = __VERIFIER_nondet_float();
_x_s9_l1 = __VERIFIER_nondet_bool();
_x_s9_l0 = __VERIFIER_nondet_bool();
_x_s9_evt2 = __VERIFIER_nondet_bool();
_x_s9_evt1 = __VERIFIER_nondet_bool();
_x_s9_evt0 = __VERIFIER_nondet_bool();
_x_s9_x = __VERIFIER_nondet_float();
_x_s8_l1 = __VERIFIER_nondet_bool();
_x_s8_l0 = __VERIFIER_nondet_bool();
_x_s8_evt2 = __VERIFIER_nondet_bool();
_x_s8_evt1 = __VERIFIER_nondet_bool();
_x_s2_evt2 = __VERIFIER_nondet_bool();
_x_s1_evt2 = __VERIFIER_nondet_bool();
_x_s2_evt1 = __VERIFIER_nondet_bool();
_x_s1_evt1 = __VERIFIER_nondet_bool();
_x_s3_evt0 = __VERIFIER_nondet_bool();
_x_s8_x = __VERIFIER_nondet_float();
_x_s2_evt0 = __VERIFIER_nondet_bool();
_x_s1_evt0 = __VERIFIER_nondet_bool();
_x_s6_x = __VERIFIER_nondet_float();
_x_s2_x = __VERIFIER_nondet_float();
_x_s1_x = __VERIFIER_nondet_float();
_x_s1_l1 = __VERIFIER_nondet_bool();
_x_s6_evt1 = __VERIFIER_nondet_bool();
_x_bus_cd_id = __VERIFIER_nondet_int();
_x_delta = __VERIFIER_nondet_float();
_x_s2_l0 = __VERIFIER_nondet_bool();
_x_s1_l0 = __VERIFIER_nondet_bool();
_x_s2_l1 = __VERIFIER_nondet_bool();
_x_bus_evt0 = __VERIFIER_nondet_bool();
_x_bus_j = __VERIFIER_nondet_int();
_x_s6_evt2 = __VERIFIER_nondet_bool();
_x_bus_evt1 = __VERIFIER_nondet_bool();
_x_s3_l0 = __VERIFIER_nondet_bool();
_x_s5_evt0 = __VERIFIER_nondet_bool();
_x_bus_evt2 = __VERIFIER_nondet_bool();
_x_s3_l1 = __VERIFIER_nondet_bool();
_x_s3_x = __VERIFIER_nondet_float();
_x_bus_l1 = __VERIFIER_nondet_bool();
_x_s5_evt1 = __VERIFIER_nondet_bool();
_x_s7_x = __VERIFIER_nondet_float();
_x_s0_x = __VERIFIER_nondet_float();
_x_s3_evt1 = __VERIFIER_nondet_bool();
_x_s3_evt2 = __VERIFIER_nondet_bool();
_x_bus_x = __VERIFIER_nondet_float();
_x_s4_x = __VERIFIER_nondet_float();
_x_s4_evt0 = __VERIFIER_nondet_bool();
_x__diverge_delta = __VERIFIER_nondet_float();
_x_s4_evt1 = __VERIFIER_nondet_bool();
_x_s4_evt2 = __VERIFIER_nondet_bool();
_x_s4_l0 = __VERIFIER_nondet_bool();
_x_s4_l1 = __VERIFIER_nondet_bool();
_x_s5_x = __VERIFIER_nondet_float();
_x_bus_l0 = __VERIFIER_nondet_bool();
_x_s5_evt2 = __VERIFIER_nondet_bool();
_x_s5_l0 = __VERIFIER_nondet_bool();
_x_s5_l1 = __VERIFIER_nondet_bool();
_x_s6_evt0 = __VERIFIER_nondet_bool();
_x_s6_l0 = __VERIFIER_nondet_bool();
_x_s6_l1 = __VERIFIER_nondet_bool();
_x_s0_evt0 = __VERIFIER_nondet_bool();
_x_s7_evt0 = __VERIFIER_nondet_bool();
_x_s0_evt1 = __VERIFIER_nondet_bool();
_x_s7_evt1 = __VERIFIER_nondet_bool();
_x_s0_evt2 = __VERIFIER_nondet_bool();
_x_s7_evt2 = __VERIFIER_nondet_bool();
_x_s0_l0 = __VERIFIER_nondet_bool();
_x_s7_l0 = __VERIFIER_nondet_bool();
_x_s0_l1 = __VERIFIER_nondet_bool();
_x_s7_l1 = __VERIFIER_nondet_bool();
_x_s8_evt0 = __VERIFIER_nondet_bool();
__ok = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( !(_x_s11_evt2 != 0)) && ((_x_s11_evt0 != 0) && ( !(_x_s11_evt1 != 0)))) || (((( !(_x_s11_evt2 != 0)) && (( !(_x_s11_evt0 != 0)) && ( !(_x_s11_evt1 != 0)))) || ((_x_s11_evt2 != 0) && (( !(_x_s11_evt0 != 0)) && ( !(_x_s11_evt1 != 0))))) || ((( !(_x_s11_evt2 != 0)) && ((_x_s11_evt1 != 0) && ( !(_x_s11_evt0 != 0)))) || ((_x_s11_evt2 != 0) && ((_x_s11_evt1 != 0) && ( !(_x_s11_evt0 != 0))))))) && ((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || (((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))))) && ((_x_s11_x <= 404.0) || ( !((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0)))))) && ((_x_s11_x <= 26.0) || ( !((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))))) && ((delta <= 0.0) || ((((s11_l0 != 0) == (_x_s11_l0 != 0)) && ((s11_l1 != 0) == (_x_s11_l1 != 0))) && ((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0)))) && (((((s11_l0 != 0) == (_x_s11_l0 != 0)) && ((s11_l1 != 0) == (_x_s11_l1 != 0))) && ((delta + (s11_x + (-1.0 * _x_s11_x))) == 0.0)) || ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && ((((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) || ((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || ((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))))) || ( !((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0)) || ( !((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0)) || ( !(((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((_x_s11_x == 0.0) && (((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || (( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && ((( !(s11_l0 != 0)) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))) || ( !(((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((404.0 <= s11_x) && ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) && (_x_s11_x == 0.0))) || ( !((( !(_x_s11_l0 != 0)) && ( !(_x_s11_l1 != 0))) && (((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((s11_x <= 26.0) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && (((s11_l1 != 0) && ( !(s11_l0 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) || ((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0)))) || ( !(((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))))))))) && (((s11_x <= 26.0) && ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l0 != 0) && ( !(_x_s11_l1 != 0))) && (((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && (((s11_x <= 26.0) && (((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) && (_x_s11_x == 0.0))) || ( !(((_x_s11_l1 != 0) && ( !(_x_s11_l0 != 0))) && (((s11_l0 != 0) && ( !(s11_l1 != 0))) && ((delta == 0.0) && ( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s10_evt2 != 0)) && ((_x_s10_evt0 != 0) && ( !(_x_s10_evt1 != 0)))) || (((( !(_x_s10_evt2 != 0)) && (( !(_x_s10_evt0 != 0)) && ( !(_x_s10_evt1 != 0)))) || ((_x_s10_evt2 != 0) && (( !(_x_s10_evt0 != 0)) && ( !(_x_s10_evt1 != 0))))) || ((( !(_x_s10_evt2 != 0)) && ((_x_s10_evt1 != 0) && ( !(_x_s10_evt0 != 0)))) || ((_x_s10_evt2 != 0) && ((_x_s10_evt1 != 0) && ( !(_x_s10_evt0 != 0))))))) && ((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || (((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))))) && ((_x_s10_x <= 404.0) || ( !((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0)))))) && ((_x_s10_x <= 26.0) || ( !((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))))) && ((delta <= 0.0) || ((((s10_l0 != 0) == (_x_s10_l0 != 0)) && ((s10_l1 != 0) == (_x_s10_l1 != 0))) && ((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0)))) && (((((s10_l0 != 0) == (_x_s10_l0 != 0)) && ((s10_l1 != 0) == (_x_s10_l1 != 0))) && ((delta + (s10_x + (-1.0 * _x_s10_x))) == 0.0)) || ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && ((((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) || ((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || ((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))))) || ( !((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0)) || ( !((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0)) || ( !(((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((_x_s10_x == 0.0) && (((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || (( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && ((( !(s10_l0 != 0)) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))) || ( !(((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((404.0 <= s10_x) && ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) && (_x_s10_x == 0.0))) || ( !((( !(_x_s10_l0 != 0)) && ( !(_x_s10_l1 != 0))) && (((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((s10_x <= 26.0) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && (((s10_l1 != 0) && ( !(s10_l0 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) || ((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0)))) || ( !(((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))))))))) && (((s10_x <= 26.0) && ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l0 != 0) && ( !(_x_s10_l1 != 0))) && (((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && (((s10_x <= 26.0) && (((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) && (_x_s10_x == 0.0))) || ( !(((_x_s10_l1 != 0) && ( !(_x_s10_l0 != 0))) && (((s10_l0 != 0) && ( !(s10_l1 != 0))) && ((delta == 0.0) && ( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s9_evt2 != 0)) && ((_x_s9_evt0 != 0) && ( !(_x_s9_evt1 != 0)))) || (((( !(_x_s9_evt2 != 0)) && (( !(_x_s9_evt0 != 0)) && ( !(_x_s9_evt1 != 0)))) || ((_x_s9_evt2 != 0) && (( !(_x_s9_evt0 != 0)) && ( !(_x_s9_evt1 != 0))))) || ((( !(_x_s9_evt2 != 0)) && ((_x_s9_evt1 != 0) && ( !(_x_s9_evt0 != 0)))) || ((_x_s9_evt2 != 0) && ((_x_s9_evt1 != 0) && ( !(_x_s9_evt0 != 0))))))) && ((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || (((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))))) && ((_x_s9_x <= 404.0) || ( !((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0)))))) && ((_x_s9_x <= 26.0) || ( !((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))))) && ((delta <= 0.0) || ((((s9_l0 != 0) == (_x_s9_l0 != 0)) && ((s9_l1 != 0) == (_x_s9_l1 != 0))) && ((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0)))) && (((((s9_l0 != 0) == (_x_s9_l0 != 0)) && ((s9_l1 != 0) == (_x_s9_l1 != 0))) && ((delta + (s9_x + (-1.0 * _x_s9_x))) == 0.0)) || ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && ((((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) || ((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || ((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))))) || ( !((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0)) || ( !((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0)) || ( !(((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((_x_s9_x == 0.0) && (((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || (( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && ((( !(s9_l0 != 0)) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))) || ( !(((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((404.0 <= s9_x) && ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) && (_x_s9_x == 0.0))) || ( !((( !(_x_s9_l0 != 0)) && ( !(_x_s9_l1 != 0))) && (((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((s9_x <= 26.0) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && (((s9_l1 != 0) && ( !(s9_l0 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) || ((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0)))) || ( !(((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))))))))) && (((s9_x <= 26.0) && ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l0 != 0) && ( !(_x_s9_l1 != 0))) && (((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && (((s9_x <= 26.0) && (((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) && (_x_s9_x == 0.0))) || ( !(((_x_s9_l1 != 0) && ( !(_x_s9_l0 != 0))) && (((s9_l0 != 0) && ( !(s9_l1 != 0))) && ((delta == 0.0) && ( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s8_evt2 != 0)) && ((_x_s8_evt0 != 0) && ( !(_x_s8_evt1 != 0)))) || (((( !(_x_s8_evt2 != 0)) && (( !(_x_s8_evt0 != 0)) && ( !(_x_s8_evt1 != 0)))) || ((_x_s8_evt2 != 0) && (( !(_x_s8_evt0 != 0)) && ( !(_x_s8_evt1 != 0))))) || ((( !(_x_s8_evt2 != 0)) && ((_x_s8_evt1 != 0) && ( !(_x_s8_evt0 != 0)))) || ((_x_s8_evt2 != 0) && ((_x_s8_evt1 != 0) && ( !(_x_s8_evt0 != 0))))))) && ((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || (((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))))) && ((_x_s8_x <= 404.0) || ( !((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0)))))) && ((_x_s8_x <= 26.0) || ( !((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))))) && ((delta <= 0.0) || ((((s8_l0 != 0) == (_x_s8_l0 != 0)) && ((s8_l1 != 0) == (_x_s8_l1 != 0))) && ((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0)))) && (((((s8_l0 != 0) == (_x_s8_l0 != 0)) && ((s8_l1 != 0) == (_x_s8_l1 != 0))) && ((delta + (s8_x + (-1.0 * _x_s8_x))) == 0.0)) || ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && ((((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) || ((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || ((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))))) || ( !((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0)) || ( !((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0)) || ( !(((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((_x_s8_x == 0.0) && (((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || (( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && ((( !(s8_l0 != 0)) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))) || ( !(((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((404.0 <= s8_x) && ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) && (_x_s8_x == 0.0))) || ( !((( !(_x_s8_l0 != 0)) && ( !(_x_s8_l1 != 0))) && (((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((s8_x <= 26.0) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && (((s8_l1 != 0) && ( !(s8_l0 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) || ((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0)))) || ( !(((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))))))))) && (((s8_x <= 26.0) && ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l0 != 0) && ( !(_x_s8_l1 != 0))) && (((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && (((s8_x <= 26.0) && (((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) && (_x_s8_x == 0.0))) || ( !(((_x_s8_l1 != 0) && ( !(_x_s8_l0 != 0))) && (((s8_l0 != 0) && ( !(s8_l1 != 0))) && ((delta == 0.0) && ( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s7_evt2 != 0)) && ((_x_s7_evt0 != 0) && ( !(_x_s7_evt1 != 0)))) || (((( !(_x_s7_evt2 != 0)) && (( !(_x_s7_evt0 != 0)) && ( !(_x_s7_evt1 != 0)))) || ((_x_s7_evt2 != 0) && (( !(_x_s7_evt0 != 0)) && ( !(_x_s7_evt1 != 0))))) || ((( !(_x_s7_evt2 != 0)) && ((_x_s7_evt1 != 0) && ( !(_x_s7_evt0 != 0)))) || ((_x_s7_evt2 != 0) && ((_x_s7_evt1 != 0) && ( !(_x_s7_evt0 != 0))))))) && ((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || (((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))))) && ((_x_s7_x <= 404.0) || ( !((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0)))))) && ((_x_s7_x <= 26.0) || ( !((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))))) && ((delta <= 0.0) || ((((s7_l0 != 0) == (_x_s7_l0 != 0)) && ((s7_l1 != 0) == (_x_s7_l1 != 0))) && ((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0)))) && (((((s7_l0 != 0) == (_x_s7_l0 != 0)) && ((s7_l1 != 0) == (_x_s7_l1 != 0))) && ((delta + (s7_x + (-1.0 * _x_s7_x))) == 0.0)) || ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && ((((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) || ((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || ((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))))) || ( !((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0)) || ( !((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0)) || ( !(((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((_x_s7_x == 0.0) && (((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || (( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && ((( !(s7_l0 != 0)) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))) || ( !(((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((404.0 <= s7_x) && ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) && (_x_s7_x == 0.0))) || ( !((( !(_x_s7_l0 != 0)) && ( !(_x_s7_l1 != 0))) && (((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((s7_x <= 26.0) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && (((s7_l1 != 0) && ( !(s7_l0 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) || ((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0)))) || ( !(((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))))))))) && (((s7_x <= 26.0) && ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l0 != 0) && ( !(_x_s7_l1 != 0))) && (((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && (((s7_x <= 26.0) && (((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) && (_x_s7_x == 0.0))) || ( !(((_x_s7_l1 != 0) && ( !(_x_s7_l0 != 0))) && (((s7_l0 != 0) && ( !(s7_l1 != 0))) && ((delta == 0.0) && ( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s6_evt2 != 0)) && ((_x_s6_evt0 != 0) && ( !(_x_s6_evt1 != 0)))) || (((( !(_x_s6_evt2 != 0)) && (( !(_x_s6_evt0 != 0)) && ( !(_x_s6_evt1 != 0)))) || ((_x_s6_evt2 != 0) && (( !(_x_s6_evt0 != 0)) && ( !(_x_s6_evt1 != 0))))) || ((( !(_x_s6_evt2 != 0)) && ((_x_s6_evt1 != 0) && ( !(_x_s6_evt0 != 0)))) || ((_x_s6_evt2 != 0) && ((_x_s6_evt1 != 0) && ( !(_x_s6_evt0 != 0))))))) && ((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || (((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))))) && ((_x_s6_x <= 404.0) || ( !((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0)))))) && ((_x_s6_x <= 26.0) || ( !((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))))) && ((delta <= 0.0) || ((((s6_l0 != 0) == (_x_s6_l0 != 0)) && ((s6_l1 != 0) == (_x_s6_l1 != 0))) && ((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0)))) && (((((s6_l0 != 0) == (_x_s6_l0 != 0)) && ((s6_l1 != 0) == (_x_s6_l1 != 0))) && ((delta + (s6_x + (-1.0 * _x_s6_x))) == 0.0)) || ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && ((((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) || ((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || ((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))))) || ( !((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0)) || ( !((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0)) || ( !(((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((_x_s6_x == 0.0) && (((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || (( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && ((( !(s6_l0 != 0)) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))) || ( !(((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((404.0 <= s6_x) && ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) && (_x_s6_x == 0.0))) || ( !((( !(_x_s6_l0 != 0)) && ( !(_x_s6_l1 != 0))) && (((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((s6_x <= 26.0) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && (((s6_l1 != 0) && ( !(s6_l0 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) || ((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0)))) || ( !(((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))))))))) && (((s6_x <= 26.0) && ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l0 != 0) && ( !(_x_s6_l1 != 0))) && (((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && (((s6_x <= 26.0) && (((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) && (_x_s6_x == 0.0))) || ( !(((_x_s6_l1 != 0) && ( !(_x_s6_l0 != 0))) && (((s6_l0 != 0) && ( !(s6_l1 != 0))) && ((delta == 0.0) && ( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s5_evt2 != 0)) && ((_x_s5_evt0 != 0) && ( !(_x_s5_evt1 != 0)))) || (((( !(_x_s5_evt2 != 0)) && (( !(_x_s5_evt0 != 0)) && ( !(_x_s5_evt1 != 0)))) || ((_x_s5_evt2 != 0) && (( !(_x_s5_evt0 != 0)) && ( !(_x_s5_evt1 != 0))))) || ((( !(_x_s5_evt2 != 0)) && ((_x_s5_evt1 != 0) && ( !(_x_s5_evt0 != 0)))) || ((_x_s5_evt2 != 0) && ((_x_s5_evt1 != 0) && ( !(_x_s5_evt0 != 0))))))) && ((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || (((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))))) && ((_x_s5_x <= 404.0) || ( !((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0)))))) && ((_x_s5_x <= 26.0) || ( !((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))))) && ((delta <= 0.0) || ((((s5_l0 != 0) == (_x_s5_l0 != 0)) && ((s5_l1 != 0) == (_x_s5_l1 != 0))) && ((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0)))) && (((((s5_l0 != 0) == (_x_s5_l0 != 0)) && ((s5_l1 != 0) == (_x_s5_l1 != 0))) && ((delta + (s5_x + (-1.0 * _x_s5_x))) == 0.0)) || ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && ((((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) || ((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || ((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))))) || ( !((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0)) || ( !((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0)) || ( !(((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((_x_s5_x == 0.0) && (((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || (( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && ((( !(s5_l0 != 0)) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))) || ( !(((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((404.0 <= s5_x) && ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) && (_x_s5_x == 0.0))) || ( !((( !(_x_s5_l0 != 0)) && ( !(_x_s5_l1 != 0))) && (((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((s5_x <= 26.0) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && (((s5_l1 != 0) && ( !(s5_l0 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) || ((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0)))) || ( !(((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))))))))) && (((s5_x <= 26.0) && ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l0 != 0) && ( !(_x_s5_l1 != 0))) && (((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && (((s5_x <= 26.0) && (((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) && (_x_s5_x == 0.0))) || ( !(((_x_s5_l1 != 0) && ( !(_x_s5_l0 != 0))) && (((s5_l0 != 0) && ( !(s5_l1 != 0))) && ((delta == 0.0) && ( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s4_evt2 != 0)) && ((_x_s4_evt0 != 0) && ( !(_x_s4_evt1 != 0)))) || (((( !(_x_s4_evt2 != 0)) && (( !(_x_s4_evt0 != 0)) && ( !(_x_s4_evt1 != 0)))) || ((_x_s4_evt2 != 0) && (( !(_x_s4_evt0 != 0)) && ( !(_x_s4_evt1 != 0))))) || ((( !(_x_s4_evt2 != 0)) && ((_x_s4_evt1 != 0) && ( !(_x_s4_evt0 != 0)))) || ((_x_s4_evt2 != 0) && ((_x_s4_evt1 != 0) && ( !(_x_s4_evt0 != 0))))))) && ((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || (((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))))) && ((_x_s4_x <= 404.0) || ( !((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0)))))) && ((_x_s4_x <= 26.0) || ( !((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))))) && ((delta <= 0.0) || ((((s4_l0 != 0) == (_x_s4_l0 != 0)) && ((s4_l1 != 0) == (_x_s4_l1 != 0))) && ((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0)))) && (((((s4_l0 != 0) == (_x_s4_l0 != 0)) && ((s4_l1 != 0) == (_x_s4_l1 != 0))) && ((delta + (s4_x + (-1.0 * _x_s4_x))) == 0.0)) || ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && ((((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) || ((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || ((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))))) || ( !((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0)) || ( !((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0)) || ( !(((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((_x_s4_x == 0.0) && (((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || (( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && ((( !(s4_l0 != 0)) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))) || ( !(((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((404.0 <= s4_x) && ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) && (_x_s4_x == 0.0))) || ( !((( !(_x_s4_l0 != 0)) && ( !(_x_s4_l1 != 0))) && (((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((s4_x <= 26.0) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && (((s4_l1 != 0) && ( !(s4_l0 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) || ((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0)))) || ( !(((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))))))))) && (((s4_x <= 26.0) && ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l0 != 0) && ( !(_x_s4_l1 != 0))) && (((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && (((s4_x <= 26.0) && (((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) && (_x_s4_x == 0.0))) || ( !(((_x_s4_l1 != 0) && ( !(_x_s4_l0 != 0))) && (((s4_l0 != 0) && ( !(s4_l1 != 0))) && ((delta == 0.0) && ( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s3_evt2 != 0)) && ((_x_s3_evt0 != 0) && ( !(_x_s3_evt1 != 0)))) || (((( !(_x_s3_evt2 != 0)) && (( !(_x_s3_evt0 != 0)) && ( !(_x_s3_evt1 != 0)))) || ((_x_s3_evt2 != 0) && (( !(_x_s3_evt0 != 0)) && ( !(_x_s3_evt1 != 0))))) || ((( !(_x_s3_evt2 != 0)) && ((_x_s3_evt1 != 0) && ( !(_x_s3_evt0 != 0)))) || ((_x_s3_evt2 != 0) && ((_x_s3_evt1 != 0) && ( !(_x_s3_evt0 != 0))))))) && ((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || (((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))))) && ((_x_s3_x <= 404.0) || ( !((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0)))))) && ((_x_s3_x <= 26.0) || ( !((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))))) && ((delta <= 0.0) || ((((s3_l0 != 0) == (_x_s3_l0 != 0)) && ((s3_l1 != 0) == (_x_s3_l1 != 0))) && ((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0)))) && (((((s3_l0 != 0) == (_x_s3_l0 != 0)) && ((s3_l1 != 0) == (_x_s3_l1 != 0))) && ((delta + (s3_x + (-1.0 * _x_s3_x))) == 0.0)) || ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && ((((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) || ((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || ((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))))) || ( !((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0)) || ( !((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0)) || ( !(((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((_x_s3_x == 0.0) && (((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || (( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && ((( !(s3_l0 != 0)) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))) || ( !(((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((404.0 <= s3_x) && ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) && (_x_s3_x == 0.0))) || ( !((( !(_x_s3_l0 != 0)) && ( !(_x_s3_l1 != 0))) && (((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((s3_x <= 26.0) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && (((s3_l1 != 0) && ( !(s3_l0 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) || ((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0)))) || ( !(((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))))))))) && (((s3_x <= 26.0) && ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l0 != 0) && ( !(_x_s3_l1 != 0))) && (((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && (((s3_x <= 26.0) && (((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) && (_x_s3_x == 0.0))) || ( !(((_x_s3_l1 != 0) && ( !(_x_s3_l0 != 0))) && (((s3_l0 != 0) && ( !(s3_l1 != 0))) && ((delta == 0.0) && ( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s2_evt2 != 0)) && ((_x_s2_evt0 != 0) && ( !(_x_s2_evt1 != 0)))) || (((( !(_x_s2_evt2 != 0)) && (( !(_x_s2_evt0 != 0)) && ( !(_x_s2_evt1 != 0)))) || ((_x_s2_evt2 != 0) && (( !(_x_s2_evt0 != 0)) && ( !(_x_s2_evt1 != 0))))) || ((( !(_x_s2_evt2 != 0)) && ((_x_s2_evt1 != 0) && ( !(_x_s2_evt0 != 0)))) || ((_x_s2_evt2 != 0) && ((_x_s2_evt1 != 0) && ( !(_x_s2_evt0 != 0))))))) && ((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || (((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))))) && ((_x_s2_x <= 404.0) || ( !((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0)))))) && ((_x_s2_x <= 26.0) || ( !((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))))) && ((delta <= 0.0) || ((((s2_l0 != 0) == (_x_s2_l0 != 0)) && ((s2_l1 != 0) == (_x_s2_l1 != 0))) && ((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0)))) && (((((s2_l0 != 0) == (_x_s2_l0 != 0)) && ((s2_l1 != 0) == (_x_s2_l1 != 0))) && ((delta + (s2_x + (-1.0 * _x_s2_x))) == 0.0)) || ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && ((((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) || ((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || ((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))))) || ( !((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0)) || ( !((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0)) || ( !(((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((_x_s2_x == 0.0) && (((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || (( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && ((( !(s2_l0 != 0)) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))) || ( !(((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((404.0 <= s2_x) && ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) && (_x_s2_x == 0.0))) || ( !((( !(_x_s2_l0 != 0)) && ( !(_x_s2_l1 != 0))) && (((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((s2_x <= 26.0) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && (((s2_l1 != 0) && ( !(s2_l0 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) || ((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0)))) || ( !(((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))))))))) && (((s2_x <= 26.0) && ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l0 != 0) && ( !(_x_s2_l1 != 0))) && (((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && (((s2_x <= 26.0) && (((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) && (_x_s2_x == 0.0))) || ( !(((_x_s2_l1 != 0) && ( !(_x_s2_l0 != 0))) && (((s2_l0 != 0) && ( !(s2_l1 != 0))) && ((delta == 0.0) && ( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s1_evt2 != 0)) && ((_x_s1_evt0 != 0) && ( !(_x_s1_evt1 != 0)))) || (((( !(_x_s1_evt2 != 0)) && (( !(_x_s1_evt0 != 0)) && ( !(_x_s1_evt1 != 0)))) || ((_x_s1_evt2 != 0) && (( !(_x_s1_evt0 != 0)) && ( !(_x_s1_evt1 != 0))))) || ((( !(_x_s1_evt2 != 0)) && ((_x_s1_evt1 != 0) && ( !(_x_s1_evt0 != 0)))) || ((_x_s1_evt2 != 0) && ((_x_s1_evt1 != 0) && ( !(_x_s1_evt0 != 0))))))) && ((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || (((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))))) && ((_x_s1_x <= 404.0) || ( !((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0)))))) && ((_x_s1_x <= 26.0) || ( !((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))))) && ((delta <= 0.0) || ((((s1_l0 != 0) == (_x_s1_l0 != 0)) && ((s1_l1 != 0) == (_x_s1_l1 != 0))) && ((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0)))) && (((((s1_l0 != 0) == (_x_s1_l0 != 0)) && ((s1_l1 != 0) == (_x_s1_l1 != 0))) && ((delta + (s1_x + (-1.0 * _x_s1_x))) == 0.0)) || ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))) && ((((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) || ((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || ((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))))) || ( !((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0)) || ( !((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0)) || ( !(((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((_x_s1_x == 0.0) && (((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && ((( !(s1_l0 != 0)) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))) || ( !(((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((404.0 <= s1_x) && ((( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))) && (_x_s1_x == 0.0))) || ( !((( !(_x_s1_l0 != 0)) && ( !(_x_s1_l1 != 0))) && (((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((s1_x <= 26.0) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && (((s1_l1 != 0) && ( !(s1_l0 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) || ((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0)))) || ( !(((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))) && (((s1_x <= 26.0) && ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l0 != 0) && ( !(_x_s1_l1 != 0))) && (((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && (((s1_x <= 26.0) && (((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) && (_x_s1_x == 0.0))) || ( !(((_x_s1_l1 != 0) && ( !(_x_s1_l0 != 0))) && (((s1_l0 != 0) && ( !(s1_l1 != 0))) && ((delta == 0.0) && ( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))))))))) && ((((((((((((((((((( !(_x_s0_evt2 != 0)) && ((_x_s0_evt0 != 0) && ( !(_x_s0_evt1 != 0)))) || (((( !(_x_s0_evt2 != 0)) && (( !(_x_s0_evt0 != 0)) && ( !(_x_s0_evt1 != 0)))) || ((_x_s0_evt2 != 0) && (( !(_x_s0_evt0 != 0)) && ( !(_x_s0_evt1 != 0))))) || ((( !(_x_s0_evt2 != 0)) && ((_x_s0_evt1 != 0) && ( !(_x_s0_evt0 != 0)))) || ((_x_s0_evt2 != 0) && ((_x_s0_evt1 != 0) && ( !(_x_s0_evt0 != 0))))))) && ((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || (((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))))) && ((_x_s0_x <= 404.0) || ( !((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0)))))) && ((_x_s0_x <= 26.0) || ( !((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))))) && ((delta <= 0.0) || ((((s0_l0 != 0) == (_x_s0_l0 != 0)) && ((s0_l1 != 0) == (_x_s0_l1 != 0))) && ((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0)))) && (((((s0_l0 != 0) == (_x_s0_l0 != 0)) && ((s0_l1 != 0) == (_x_s0_l1 != 0))) && ((delta + (s0_x + (-1.0 * _x_s0_x))) == 0.0)) || ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))) && ((((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) || ((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || ((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))))) || ( !((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0)) || ( !((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && ((((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0)) || ( !(((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((_x_s0_x == 0.0) && (((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || (( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && ((( !(s0_l0 != 0)) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))) || ( !(((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((404.0 <= s0_x) && ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) && (_x_s0_x == 0.0))) || ( !((( !(_x_s0_l0 != 0)) && ( !(_x_s0_l1 != 0))) && (((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((s0_x <= 26.0) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && (((s0_l1 != 0) && ( !(s0_l0 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && ((((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) || ((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0)))) || ( !(((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))))))))) && (((s0_x <= 26.0) && ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l0 != 0) && ( !(_x_s0_l1 != 0))) && (((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((s0_x <= 26.0) && (((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) && (_x_s0_x == 0.0))) || ( !(((_x_s0_l1 != 0) && ( !(_x_s0_l0 != 0))) && (((s0_l0 != 0) && ( !(s0_l1 != 0))) && ((delta == 0.0) && ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))) && (((((((((((((((( !(_x_bus_evt2 != 0)) && (( !(_x_bus_evt0 != 0)) && ( !(_x_bus_evt1 != 0)))) || ((((_x_bus_evt2 != 0) && (( !(_x_bus_evt0 != 0)) && ( !(_x_bus_evt1 != 0)))) || (( !(_x_bus_evt2 != 0)) && ((_x_bus_evt1 != 0) && ( !(_x_bus_evt0 != 0))))) || (((_x_bus_evt2 != 0) && ((_x_bus_evt1 != 0) && ( !(_x_bus_evt0 != 0)))) || (( !(_x_bus_evt2 != 0)) && ((_x_bus_evt0 != 0) && ( !(_x_bus_evt1 != 0))))))) && (((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))) || (((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l0 != 0) && (_x_bus_l1 != 0))))) && ((( !(13.0 <= _x_bus_x)) || ( !((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))))) && ((_x_delta == 0.0) || ( !((_x_bus_l0 != 0) && (_x_bus_l1 != 0)))))) && ((delta <= 0.0) || (((delta + (bus_x + (-1.0 * _x_bus_x))) == 0.0) && ((((bus_l0 != 0) == (_x_bus_l0 != 0)) && ((bus_l1 != 0) == (_x_bus_l1 != 0))) && (bus_j == _x_bus_j))))) && ((((delta + (bus_x + (-1.0 * _x_bus_x))) == 0.0) && ((((bus_l0 != 0) == (_x_bus_l0 != 0)) && ((bus_l1 != 0) == (_x_bus_l1 != 0))) && (bus_j == _x_bus_j))) || ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0))))))) && (((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) && ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))) && ((bus_j == _x_bus_j) && (_x_bus_x == 0.0))) || ( !((( !(bus_l0 != 0)) && ( !(bus_l1 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && (((bus_j == _x_bus_j) && (((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0))) || ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) || ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))))) || ( !(((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && (((( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) && (_x_bus_x == 0.0)) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) && ((bus_l1 != 0) && ( !(bus_l0 != 0)))))))) && ((((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) && ((13.0 <= bus_x) && (bus_x == _x_bus_x))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((_x_bus_l1 != 0) && ( !(_x_bus_l0 != 0)))))))) && ((((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) && (( !(13.0 <= bus_x)) && (_x_bus_x == 0.0))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l1 != 0) && ( !(bus_l0 != 0))) && ((_x_bus_l0 != 0) && ( !(_x_bus_l1 != 0)))))))) && ((((((_x_bus_l0 != 0) && (_x_bus_l1 != 0)) && ( !(13.0 <= bus_x))) && ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == bus_j))) && ((_x_bus_x == 0.0) && ((bus_j + (-1 * _x_bus_j)) == -1))) || ( !(((bus_l0 != 0) && ( !(bus_l1 != 0))) && ((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))))))) && ((((bus_j + (-1 * _x_bus_j)) == -1) && (((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == bus_j)) && ((_x_bus_x == 0.0) && ( !(11 <= bus_j))))) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && (((bus_l0 != 0) && (bus_l1 != 0)) && ((_x_bus_l0 != 0) && (_x_bus_l1 != 0))))))) && (((((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_j == 11)) && ((_x_bus_x == 0.0) && (bus_cd_id == bus_j))) && (_x_bus_j == 0)) || ( !(((delta == 0.0) && ( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))))) && ((( !(_x_bus_l0 != 0)) && ( !(_x_bus_l1 != 0))) && ((bus_l0 != 0) && (bus_l1 != 0))))))) && (0.0 <= _x_delta)))))))))))))) && (((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || ( !(delta == 0.0)))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))))) && (( !(delta == 0.0)) || (( !(( !(s11_evt2 != 0)) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0))))) || (( !(( !(s10_evt2 != 0)) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0))))) || (( !(( !(s9_evt2 != 0)) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0))))) || (( !(( !(s8_evt2 != 0)) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0))))) || (( !(( !(s7_evt2 != 0)) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0))))) || (( !(( !(s6_evt2 != 0)) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0))))) || (( !(( !(s5_evt2 != 0)) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0))))) || (( !(( !(s4_evt2 != 0)) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0))))) || (( !(( !(s3_evt2 != 0)) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0))))) || (( !(( !(s2_evt2 != 0)) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0))))) || (( !(( !(s1_evt2 != 0)) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0))))) || (( !(( !(bus_evt2 != 0)) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0))))) || ( !(( !(s0_evt2 != 0)) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0))))))))))))))))))) && (( !(delta == 0.0)) || (((bus_evt2 != 0) && (( !(bus_evt0 != 0)) && ( !(bus_evt1 != 0)))) == (((s11_evt2 != 0) && (( !(s11_evt0 != 0)) && ( !(s11_evt1 != 0)))) || (((s10_evt2 != 0) && (( !(s10_evt0 != 0)) && ( !(s10_evt1 != 0)))) || (((s9_evt2 != 0) && (( !(s9_evt0 != 0)) && ( !(s9_evt1 != 0)))) || (((s8_evt2 != 0) && (( !(s8_evt0 != 0)) && ( !(s8_evt1 != 0)))) || (((s7_evt2 != 0) && (( !(s7_evt0 != 0)) && ( !(s7_evt1 != 0)))) || (((s6_evt2 != 0) && (( !(s6_evt0 != 0)) && ( !(s6_evt1 != 0)))) || (((s5_evt2 != 0) && (( !(s5_evt0 != 0)) && ( !(s5_evt1 != 0)))) || (((s4_evt2 != 0) && (( !(s4_evt0 != 0)) && ( !(s4_evt1 != 0)))) || (((s3_evt2 != 0) && (( !(s3_evt0 != 0)) && ( !(s3_evt1 != 0)))) || (((s2_evt2 != 0) && (( !(s2_evt0 != 0)) && ( !(s2_evt1 != 0)))) || (((s0_evt2 != 0) && (( !(s0_evt0 != 0)) && ( !(s0_evt1 != 0)))) || ((s1_evt2 != 0) && (( !(s1_evt0 != 0)) && ( !(s1_evt1 != 0)))))))))))))))))) && (( !(delta == 0.0)) || ((( !(bus_evt2 != 0)) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) == ((( !(s11_evt2 != 0)) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || ((( !(s10_evt2 != 0)) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || ((( !(s9_evt2 != 0)) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || ((( !(s8_evt2 != 0)) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || ((( !(s7_evt2 != 0)) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || ((( !(s6_evt2 != 0)) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || ((( !(s5_evt2 != 0)) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || ((( !(s4_evt2 != 0)) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || ((( !(s3_evt2 != 0)) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || ((( !(s2_evt2 != 0)) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || ((( !(s0_evt2 != 0)) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))))))))))))) && (( !(delta == 0.0)) || (((bus_evt2 != 0) && ((bus_evt1 != 0) && ( !(bus_evt0 != 0)))) == (((s11_evt2 != 0) && ((s11_evt1 != 0) && ( !(s11_evt0 != 0)))) || (((s10_evt2 != 0) && ((s10_evt1 != 0) && ( !(s10_evt0 != 0)))) || (((s9_evt2 != 0) && ((s9_evt1 != 0) && ( !(s9_evt0 != 0)))) || (((s8_evt2 != 0) && ((s8_evt1 != 0) && ( !(s8_evt0 != 0)))) || (((s7_evt2 != 0) && ((s7_evt1 != 0) && ( !(s7_evt0 != 0)))) || (((s6_evt2 != 0) && ((s6_evt1 != 0) && ( !(s6_evt0 != 0)))) || (((s5_evt2 != 0) && ((s5_evt1 != 0) && ( !(s5_evt0 != 0)))) || (((s4_evt2 != 0) && ((s4_evt1 != 0) && ( !(s4_evt0 != 0)))) || (((s3_evt2 != 0) && ((s3_evt1 != 0) && ( !(s3_evt0 != 0)))) || (((s2_evt2 != 0) && ((s2_evt1 != 0) && ( !(s2_evt0 != 0)))) || (((s0_evt2 != 0) && ((s0_evt1 != 0) && ( !(s0_evt0 != 0)))) || ((s1_evt2 != 0) && ((s1_evt1 != 0) && ( !(s1_evt0 != 0)))))))))))))))))) && (( !(delta == 0.0)) || ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) == ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) || ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) || ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) || ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) || ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) || ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) || ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) || ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) || ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) || ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) || ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) || (( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))))))))))))))))) && (( !(delta == 0.0)) || ((( !(s0_evt2 != 0)) && ((s0_evt0 != 0) && ( !(s0_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 0))))) && (( !(delta == 0.0)) || ((( !(s1_evt2 != 0)) && ((s1_evt0 != 0) && ( !(s1_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 1))))) && (( !(delta == 0.0)) || ((( !(s2_evt2 != 0)) && ((s2_evt0 != 0) && ( !(s2_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 2))))) && (( !(delta == 0.0)) || ((( !(s3_evt2 != 0)) && ((s3_evt0 != 0) && ( !(s3_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 3))))) && (( !(delta == 0.0)) || ((( !(s4_evt2 != 0)) && ((s4_evt0 != 0) && ( !(s4_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 4))))) && (( !(delta == 0.0)) || ((( !(s5_evt2 != 0)) && ((s5_evt0 != 0) && ( !(s5_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 5))))) && (( !(delta == 0.0)) || ((( !(s6_evt2 != 0)) && ((s6_evt0 != 0) && ( !(s6_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 6))))) && (( !(delta == 0.0)) || ((( !(s7_evt2 != 0)) && ((s7_evt0 != 0) && ( !(s7_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 7))))) && (( !(delta == 0.0)) || ((( !(s8_evt2 != 0)) && ((s8_evt0 != 0) && ( !(s8_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 8))))) && (( !(delta == 0.0)) || ((( !(s9_evt2 != 0)) && ((s9_evt0 != 0) && ( !(s9_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 9))))) && (( !(delta == 0.0)) || ((( !(s10_evt2 != 0)) && ((s10_evt0 != 0) && ( !(s10_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 10))))) && (( !(delta == 0.0)) || ((( !(s11_evt2 != 0)) && ((s11_evt0 != 0) && ( !(s11_evt1 != 0)))) == ((( !(bus_evt2 != 0)) && ((bus_evt0 != 0) && ( !(bus_evt1 != 0)))) && (bus_cd_id == 11))))) && (((delta == _x__diverge_delta) || ( !(1.0 <= _diverge_delta))) && ((1.0 <= _diverge_delta) || ((delta + (_diverge_delta + (-1.0 * _x__diverge_delta))) == 0.0))));
s11_l1 = _x_s11_l1;
s11_l0 = _x_s11_l0;
s11_evt2 = _x_s11_evt2;
s11_evt1 = _x_s11_evt1;
s11_evt0 = _x_s11_evt0;
s11_x = _x_s11_x;
s10_l1 = _x_s10_l1;
s10_l0 = _x_s10_l0;
s10_evt2 = _x_s10_evt2;
s10_evt1 = _x_s10_evt1;
s10_evt0 = _x_s10_evt0;
s10_x = _x_s10_x;
s9_l1 = _x_s9_l1;
s9_l0 = _x_s9_l0;
s9_evt2 = _x_s9_evt2;
s9_evt1 = _x_s9_evt1;
s9_evt0 = _x_s9_evt0;
s9_x = _x_s9_x;
s8_l1 = _x_s8_l1;
s8_l0 = _x_s8_l0;
s8_evt2 = _x_s8_evt2;
s8_evt1 = _x_s8_evt1;
s2_evt2 = _x_s2_evt2;
s1_evt2 = _x_s1_evt2;
s2_evt1 = _x_s2_evt1;
s1_evt1 = _x_s1_evt1;
s3_evt0 = _x_s3_evt0;
s8_x = _x_s8_x;
s2_evt0 = _x_s2_evt0;
s1_evt0 = _x_s1_evt0;
s6_x = _x_s6_x;
s2_x = _x_s2_x;
s1_x = _x_s1_x;
s1_l1 = _x_s1_l1;
s6_evt1 = _x_s6_evt1;
bus_cd_id = _x_bus_cd_id;
delta = _x_delta;
s2_l0 = _x_s2_l0;
s1_l0 = _x_s1_l0;
s2_l1 = _x_s2_l1;
bus_evt0 = _x_bus_evt0;
bus_j = _x_bus_j;
s6_evt2 = _x_s6_evt2;
bus_evt1 = _x_bus_evt1;
s3_l0 = _x_s3_l0;
s5_evt0 = _x_s5_evt0;
bus_evt2 = _x_bus_evt2;
s3_l1 = _x_s3_l1;
s3_x = _x_s3_x;
bus_l1 = _x_bus_l1;
s5_evt1 = _x_s5_evt1;
s7_x = _x_s7_x;
s0_x = _x_s0_x;
s3_evt1 = _x_s3_evt1;
s3_evt2 = _x_s3_evt2;
bus_x = _x_bus_x;
s4_x = _x_s4_x;
s4_evt0 = _x_s4_evt0;
_diverge_delta = _x__diverge_delta;
s4_evt1 = _x_s4_evt1;
s4_evt2 = _x_s4_evt2;
s4_l0 = _x_s4_l0;
s4_l1 = _x_s4_l1;
s5_x = _x_s5_x;
bus_l0 = _x_bus_l0;
s5_evt2 = _x_s5_evt2;
s5_l0 = _x_s5_l0;
s5_l1 = _x_s5_l1;
s6_evt0 = _x_s6_evt0;
s6_l0 = _x_s6_l0;
s6_l1 = _x_s6_l1;
s0_evt0 = _x_s0_evt0;
s7_evt0 = _x_s7_evt0;
s0_evt1 = _x_s0_evt1;
s7_evt1 = _x_s7_evt1;
s0_evt2 = _x_s0_evt2;
s7_evt2 = _x_s7_evt2;
s0_l0 = _x_s0_l0;
s7_l0 = _x_s7_l0;
s0_l1 = _x_s0_l1;
s7_l1 = _x_s7_l1;
s8_evt0 = _x_s8_evt0;
}
}
|
the_stack_data/31387248.c
|
// this source is derived from CHILL AST originally from file '/uufs/chpc.utah.edu/common/home/u1142914/lib/ytopt_vinu/polybench/polybench-code/stencils/fdtd-2d/kernel.c' as parsed by frontend compiler rose
void kernel_fdtd_2d(int tmax, int nx, int ny, double ex[1000 + 0][1200 + 0], double ey[1000 + 0][1200 + 0], double hz[1000 + 0][1200 + 0], double _fict_[500 + 0]) {
int t10;
int t8;
int t6;
int t4;
int t2;
for (t2 = 0; t2 <= tmax - 1; t2 += 1) {
for (t4 = 0; t4 <= ny - 1; t4 += 1)
ey[0][t4] = _fict_[t2];
for (t4 = 1; t4 <= nx - 1; t4 += 30)
for (t6 = t4; t6 <= (t4 + 29 < nx - 1 ? t4 + 29 : nx - 1); t6 += 1)
for (t8 = 0; t8 <= ny - 1; t8 += 20)
for (t10 = t8; t10 <= (ny - 1 < t8 + 19 ? ny - 1 : t8 + 19); t10 += 1)
ey[t6][t10] = ey[t6][t10] - 0.5 * (hz[t6][t10] - hz[t6 - 1][t10]);
for (t4 = 0; t4 <= nx - 1; t4 += 30)
for (t6 = t4; t6 <= (t4 + 29 < nx - 1 ? t4 + 29 : nx - 1); t6 += 1)
for (t8 = 1; t8 <= ny - 1; t8 += 20)
for (t10 = t8; t10 <= (ny - 1 < t8 + 19 ? ny - 1 : t8 + 19); t10 += 1)
ex[t6][t10] = ex[t6][t10] - 0.5 * (hz[t6][t10] - hz[t6][t10 - 1]);
for (t4 = 0; t4 <= nx - 2; t4 += 30)
for (t6 = t4; t6 <= (t4 + 29 < nx - 2 ? t4 + 29 : nx - 2); t6 += 1)
for (t8 = 0; t8 <= ny - 2; t8 += 20)
for (t10 = t8; t10 <= (ny - 2 < t8 + 19 ? ny - 2 : t8 + 19); t10 += 1)
hz[t6][t10] = hz[t6][t10] - 0.69999999999999996 * (ex[t6][t10 + 1] - ex[t6][t10] + ey[t6 + 1][t10] - ey[t6][t10]);
}
}
|
the_stack_data/109245.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_program_name.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: pstuart <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/31 16:35:30 by pstuart #+# #+# */
/* Updated: 2022/02/01 10:47:56 by pstuart ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
int main(int argc, char **argv)
{
int index;
index = 0;
argc = 0;
while (argv[0][index])
{
ft_putchar(argv[0][index]);
index++;
}
ft_putchar('\n');
return (0);
}
|
the_stack_data/144212.c
|
//program for stack using array
#include <stdio.h>
void push();
void pop();
void peek();
void update();
int a[100], top = -1;
int main()
{
int x;
while (1)
{
printf("\n0.exit");
printf("\n1.push");
printf("\n2.pop");
printf("\n3.peek");
printf("\n4.update");
printf("\nenter your choice? ");
scanf("%d", &x);
switch (x)
{
case 0:
return 0;
case 1:
push();
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
update();
break;
default:
printf("\ninvalid choice");
}
}
return (0);
}
//function for pushing the element
void push()
{
int n = 0;
printf("\nenter the value to insert? ");
scanf("%d", &n);
top += 1;
a[top] = n;
}
//function for poping the element out
void pop()
{
if (top == -1)
{
printf("\nstack is empty");
}
else
{
int item;
item = a[top];
top -= 1;
printf("\npoped item is %d ", item);
}
}
//function for peeping the element from top of the stack
void peek()
{
if (top >= 0)
printf("\n the top element is %d", a[top]);
else
printf("\nstack is empty");
}
//function to update the element of stack
void update()
{
int i, n;
printf("\nenter the position to update? ");
scanf("%d", &i);
printf("\nenter the item to insert? ");
scanf("%d", &n);
if (top - i + 1 < 0)
{
printf("\nunderflow condition");
}
else
{
a[top - i + 1] = n;
}
}
|
the_stack_data/26701204.c
|
// PARAM: --set ana.int.interval true --set ana.base.arrays.domain partitioned
#include<stdlib.h>
#include<assert.h>
int main(void) {
int *ro = calloc(2,sizeof(int));
assert(ro[0] == 0);
assert(ro[1] == 0);
ro[0] = 3;
assert(ro[1] != 3); //UNKNOWN
}
|
the_stack_data/1153809.c
|
#include <stdio.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define SA struct sockaddr
int main ( int argc, char **argv ) {
int sockfd, n;
char recvline[2048 + 1];
struct sockaddr_in servaddr;
if ( argc != 2 ) {
fprintf( stderr, "usage: a.out <IPaddress>\n");
exit(1);
}
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
fprintf( stderr, "socket error\n");
exit(1);
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(13); /* daytime server */
if ( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0 ) {
fprintf( stderr, "inet_pton error for %s\n", argv[1]);
exit(1);
}
if ( connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0 ) {
fprintf( stderr, "connect error\n" );
exit(1);
}
while ( ( n=read(sockfd, recvline, 2048) ) > 0) {
recvline[n] = 0;
if (fputs(recvline, stdout) == EOF) {
fprintf(stderr, "fputs error\n");
exit(1);
}
}
if ( n < 0 ) {
fprintf(stderr, "read error\n");
exit(1);
}
exit(0);
}
|
the_stack_data/165768240.c
|
#include <stdio.h>
int main()
{
int a,b;
printf("Enter 1st number : ");
scanf("%d",&a);
printf("Enter 2nd number : ");
scanf("%d",&b);
if(a>b)
printf("Largest value is : %d",a);
else
printf("Largest value is : %d",b);
return 0;
}
/*program to find largest number
if else
DAY_8*/
|
the_stack_data/117328777.c
|
/** \file
* \brief Implementation of strncasecmp
*
* \author Peter 'png' Hille <[email protected]>
*/
#include <ctype.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
/** \brief Compare Strings without Case Sensitivity
*
* stricmp compares, at most, the first n characters of s1 and s2 without
* sensitivity to case. All alphabetic characters in the two arguments
* s1 and s2 are converted to lowercase before the comparision.
*
* The function operates on null-ended strings. The string arguments to the
* function are expected to contain a null character (\0) at the end of the
* string.
*
* \param s1 Pointer to a \0-terminated C string
* \param s2 Pointer to a \0-terminated C string
* \param n Max number of characters to compare
*
* \return A value indicating the relationship between the two strings similar
* to the one returned by strcmp(3)
*
* \see strnicmp
*
* \note In debug builds the two pointer arguments are checked for NULL
* values using assert(3)
*/
int strncasecmp(const char* s1, const char* s2, size_t n) {
assert(s1 != NULL);
assert(s2 != NULL);
#ifdef HAVE_STRNICMP
return strnicmp(s1, s2, n);
#else
if (n == 0)
return 0;
do {
if (tolower((unsigned char) *s1) != tolower((unsigned char) *s2++))
return (int)tolower((unsigned char)*s1) -
(int) tolower((unsigned char) *--s2);
if (*s1++ == 0)
break;
} while (--n != 0);
return 0;
#endif /* !HAVE_STRNICMP */
}
|
the_stack_data/877600.c
|
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Ken Smith of The State University of New York at Buffalo.
*
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. 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.
*/
#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
All rights reserved.\n";
#endif /* not lint */
#ifndef lint
/*static char sccsid[] = "from: @(#)mv.c 5.11 (Berkeley) 4/3/91";*/
static char rcsid[] = "$Id: mv.c,v 1.3 1994/04/16 00:51:13 davidg Exp $";
#endif /* not lint */
#include <sys/param.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _PATH_RM "/bin/rm"
#define _PATH_CP "/bin/cp"
int fflg, iflg;
int stdin_ok;
main(argc, argv)
int argc;
char **argv;
{
extern char *optarg;
extern int optind;
register int baselen, exitval, len;
register char *p, *endp;
struct stat sb;
int ch;
char path[MAXPATHLEN + 1];
while (((ch = getopt(argc, argv, "if")) != -1))
switch((char)ch) {
case 'i':
fflg = 0;
iflg = 1;
break;
case 'f':
iflg = 0;
fflg = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc < 2)
usage();
stdin_ok = isatty(STDIN_FILENO);
/*
* If the stat on the target fails or the target isn't a directory,
* try the move. More than 2 arguments is an error in this case.
*/
if (stat(argv[argc - 1], &sb) || !S_ISDIR(sb.st_mode)) {
if (argc > 2)
usage();
exit(do_move(argv[0], argv[1]));
}
/* It's a directory, move each file into it. */
(void)strcpy(path, argv[argc - 1]);
baselen = strlen(path);
endp = &path[baselen];
*endp++ = '/';
++baselen;
for (exitval = 0; --argc; ++argv) {
if ((p = rindex(*argv, '/')) == NULL)
p = *argv;
else
++p;
if ((baselen + (len = strlen(p))) >= MAXPATHLEN)
(void)fprintf(stderr,
"mv: %s: destination pathname too long\n", *argv);
else {
bcopy(p, endp, len + 1);
exitval |= do_move(*argv, path);
}
}
exit(exitval);
}
do_move(from, to)
char *from, *to;
{
struct stat sb;
/* (1) If the destination path exists, the -f option is not specified
* and either of the following conditions are true:
*
* (a) The perimissions of the destination path do not permit
* writing and the standard input is a terminal.
* (b) The -i option is specified.
*
* the mv utility shall write a prompt to standard error and
* read a line from standard input. If the response is not
* affirmative, mv shall do nothing more with the current
* source file...
*/
if (!fflg && !access(to, F_OK)) {
int ask = 0;
int ch;
if (iflg) {
(void)fprintf(stderr, "overwrite %s? ", to);
ask = 1;
} else if (stdin_ok && access(to, W_OK) && !stat(to, &sb)) {
(void)fprintf(stderr, "override mode %o on %s? ",
sb.st_mode & 07777, to);
ask = 1;
}
if (ask) {
if ((ch = getchar()) != EOF && ch != '\n')
while (getchar() != '\n');
if (ch != 'y' && ch != 'Y')
return(0);
}
}
/* (2) If rename() succeeds, mv shall do nothing more with the
* current source file. If it fails for any other reason than
* EXDEV, mv shall write a diagnostic message to the standard
* error and do nothing more with the current source file.
*
* (3) If the destination path exists, and it is a file of type
* directory and source_file is not a file of type directory,
* or it is a file not of type directory, and source file is
* a file of type directory, mv shall write a diagnostic
* message to standard error, and do nothing more with the
* current source file...
*/
if (!rename(from, to))
return(0);
if (errno != EXDEV) {
(void)fprintf(stderr,
"mv: rename %s to %s: %s\n", from, to, strerror(errno));
return(1);
}
/* (4) If the destination path exists, mv shall attempt to remove it.
* If this fails for any reason, mv shall write a diagnostic
* message to the standard error and do nothing more with the
* current source file...
*/
if (!stat(to, &sb)) {
if ((S_ISDIR(sb.st_mode)) ? rmdir(to) : unlink(to)) {
(void) fprintf(stderr,
"mv: can't remove %s: %s\n", to, strerror(errno));
return (1);
}
}
/* (5) The file hierarchy rooted in source_file shall be duplicated
* as a file hiearchy rooted in the destination path...
*/
if (stat(from, &sb)) {
(void)fprintf(stderr, "mv: %s: %s\n", from, strerror(errno));
return(1);
}
return(S_ISREG(sb.st_mode) ?
fastcopy(from, to, &sb) : copy(from, to));
}
fastcopy(from, to, sbp)
char *from, *to;
struct stat *sbp;
{
struct timeval tval[2];
static u_int blen;
static char *bp;
register int nread, from_fd, to_fd;
if ((from_fd = open(from, O_RDONLY, 0)) < 0) {
error(from);
return(1);
}
if ((to_fd = open(to, O_CREAT|O_TRUNC|O_WRONLY, sbp->st_mode)) < 0) {
error(to);
(void)close(from_fd);
return(1);
}
if (!blen && !(bp = malloc(blen = sbp->st_blksize * 4))) {
error(NULL);
return(1);
}
while ((nread = read(from_fd, bp, blen)) > 0)
if (write(to_fd, bp, nread) != nread) {
error(to);
goto err;
}
if (nread < 0) {
error(from);
err: (void)unlink(to);
(void)close(from_fd);
(void)close(to_fd);
return(1);
}
(void)fchown(to_fd, sbp->st_uid, sbp->st_gid);
(void)fchmod(to_fd, sbp->st_mode);
(void)close(from_fd);
(void)close(to_fd);
tval[0].tv_sec = sbp->st_atime;
tval[1].tv_sec = sbp->st_mtime;
tval[0].tv_usec = tval[1].tv_usec = 0;
(void)utimes(to, tval);
(void)unlink(from);
return(0);
}
copy(from, to)
char *from, *to;
{
int pid, status;
if (!(pid = vfork())) {
execl(_PATH_CP, "mv", "-pr", from, to, NULL);
error(_PATH_CP);
_exit(1);
}
(void)waitpid(pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status))
return(1);
if (!(pid = vfork())) {
execl(_PATH_RM, "mv", "-rf", from, NULL);
error(_PATH_RM);
_exit(1);
}
(void)waitpid(pid, &status, 0);
return(!WIFEXITED(status) || WEXITSTATUS(status));
}
error(s)
char *s;
{
if (s)
(void)fprintf(stderr, "mv: %s: %s\n", s, strerror(errno));
else
(void)fprintf(stderr, "mv: %s\n", strerror(errno));
}
usage()
{
(void)fprintf(stderr,
"usage: mv [-fi] source_file target_file\n"
" mv [-fi] source_file ... target_dir\n");
exit(1);
}
|
the_stack_data/161080325.c
|
extern void __VERIFIER_error() __attribute__ ((__noreturn__));
extern char __VERIFIER_nondet_char(void);
extern int __VERIFIER_nondet_int(void);
extern long __VERIFIER_nondet_long(void);
extern void *__VERIFIER_nondet_pointer(void);
void IofCompleteRequest(int Irp , int PriorityBoost ) ;
int __VERIFIER_nondet_int() ;
int s ;
int UNLOADED ;
int NP ;
int DC ;
int SKIP1 ;
int SKIP2 ;
int MPR1 ;
int MPR3 ;
int IPC ;
int pended ;
int compFptr ;
int compRegistered ;
int lowerDriverReturn ;
int setEventCalled ;
int customIrp ;
int routine ;
int myStatus ;
int pirp ;
int Executive ;
int Suspended ;
int KernelMode ;
int DeviceUsageTypePaging ;
void errorFn(void)
{
{
ERROR: __VERIFIER_error();
#line 60
return;
}
}
#line 63 "cdaudio_simpl1.cil.c"
void _BLAST_init(void)
{
{
#line 67
UNLOADED = 0;
#line 68
NP = 1;
#line 69
DC = 2;
#line 70
SKIP1 = 3;
#line 71
SKIP2 = 4;
#line 72
MPR1 = 5;
#line 73
MPR3 = 6;
#line 74
IPC = 7;
#line 75
s = UNLOADED;
#line 76
pended = 0;
#line 77
compFptr = 0;
#line 78
compRegistered = 0;
#line 79
lowerDriverReturn = 0;
#line 80
setEventCalled = 0;
#line 81
customIrp = 0;
#line 82
return;
}
}
#line 85 "cdaudio_simpl1.cil.c"
int SendSrbSynchronous(int Extension , int Srb , int Buffer , int BufferLength )
{ int ioStatus__Status = __VERIFIER_nondet_int() ;
int ioctl ;
int event = __VERIFIER_nondet_int() ;
int irp ;
int status = __VERIFIER_nondet_int() ;
int __cil_tmp10 ;
int __cil_tmp11 ;
int __cil_tmp12 ;
int __cil_tmp13 ;
int __cil_tmp14 ;
int __cil_tmp15 ;
int __cil_tmp16 ;
int __cil_tmp17 ;
long __cil_tmp18 ;
{
#line 93
irp = 0;
#line 94
if (Buffer) {
#line 95
__cil_tmp10 = 4116;
#line 95
__cil_tmp11 = 49152;
#line 95
__cil_tmp12 = 262144;
#line 95
__cil_tmp13 = 311296;
#line 95
ioctl = 315412;
} else {
#line 97
__cil_tmp14 = 4100;
#line 97
__cil_tmp15 = 49152;
#line 97
__cil_tmp16 = 262144;
#line 97
__cil_tmp17 = 311296;
#line 97
ioctl = 315396;
}
#line 99
if (! irp) {
#line 100
return (-1073741670);
}
{
#line 104
__cil_tmp18 = (long )status;
#line 104
if (__cil_tmp18 == 259L) {
{
#line 106
KeWaitForSingleObject(event, Executive, KernelMode, 0, 0);
#line 107
status = ioStatus__Status;
}
}
}
#line 112
return (status);
}
}
#line 115 "cdaudio_simpl1.cil.c"
int CdAudioSignalCompletion(int DeviceObject , int Irp , int Event )
{
{
{
#line 120
KeSetEvent(Event, 0, 0);
}
#line 122
return (-1073741802);
}
}
#line 125 "cdaudio_simpl1.cil.c"
int CdAudioStartDevice(int DeviceObject , int Irp )
{ int deviceExtension__Active = __VERIFIER_nondet_int() ;
int deviceExtension = __VERIFIER_nondet_int() ;
int status ;
int srb = __VERIFIER_nondet_int() ;
int srb__Cdb = __VERIFIER_nondet_int() ;
int cdb ;
int inquiryDataPtr ;
int attempt ;
int tmp ;
int deviceParameterHandle = __VERIFIER_nondet_int() ;
int keyValue ;
{
{
#line 140
status = CdAudioForwardIrpSynchronous(DeviceObject, Irp);
}
{
#line 142
#line 142
if (status < 0) {
#line 143
return (status);
}
}
#line 147
if (deviceExtension__Active == 255) {
#line 148
cdb = srb__Cdb;
#line 149
inquiryDataPtr = 0;
#line 150
attempt = 0;
#line 151
if (! inquiryDataPtr) {
#line 152
deviceExtension__Active = 0;
#line 153
return (0);
}
#line 157
status = -1073741823;
{
#line 159
while (1) {
while_0_continue: /* CIL Label */ ;
{
#line 161
#line 161
if (status < 0) {
#line 162
tmp = attempt;
#line 163
attempt ++;
#line 164
if (tmp >= 4) {
goto while_0_break_1;
}
} else {
goto while_0_break_1;
}
}
{
#line 173
status = SendSrbSynchronous(deviceExtension, srb, inquiryDataPtr, 36);
}
}
while_0_break: /* CIL Label */ ;
}
while_0_break_1: ;
{
#line 178
#line 178
if (status < 0) {
#line 179
deviceExtension__Active = 0;
#line 180
return (0);
}
}
#line 184
deviceExtension__Active = 0;
}
#line 188
keyValue = deviceExtension__Active;
{
#line 189
#line 189
if (status < 0) {
#line 190
return (0);
}
}
{
#line 194
#line 194
if (status < 0) {
}
}
{
#line 200
ZwClose(deviceParameterHandle);
}
#line 202
return (0);
}
}
#line 205 "cdaudio_simpl1.cil.c"
int CdAudioPnp(int DeviceObject , int Irp )
{ int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int irpSp__MinorFunction = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Status ;
int irpSp__Parameters__UsageNotification__Type = __VERIFIER_nondet_int() ;
int deviceExtension__PagingPathCountEvent = __VERIFIER_nondet_int() ;
int irpSp__Parameters__UsageNotification__InPath = __VERIFIER_nondet_int() ;
int deviceExtension__PagingPathCount = __VERIFIER_nondet_int() ;
int DeviceObject__Flags ;
int irpSp ;
int status ;
int setPagable ;
int tmp ;
int tmp___0 ;
{
#line 221
irpSp = Irp__Tail__Overlay__CurrentStackLocation;
#line 222
status = -1073741637;
#line 223
if (irpSp__MinorFunction == 0) {
goto switch_1_0;
} else {
#line 226
if (irpSp__MinorFunction == 22) {
goto switch_1_22;
} else {
goto switch_1_default;
#line 231
if (0) {
switch_1_0:
{
#line 234
status = CdAudioStartDevice(DeviceObject, Irp);
#line 235
Irp__IoStatus__Status = status;
#line 236
myStatus = status;
#line 237
IofCompleteRequest(Irp, 0);
}
#line 239
return (status);
switch_1_22: ;
#line 241
if (irpSp__Parameters__UsageNotification__Type != DeviceUsageTypePaging) {
{
#line 243
tmp = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 245
return (tmp);
}
{
#line 250
status = KeWaitForSingleObject(deviceExtension__PagingPathCountEvent, Executive,
KernelMode, 0, 0);
#line 252
setPagable = 0;
}
#line 254
if (irpSp__Parameters__UsageNotification__InPath) {
#line 255
if (deviceExtension__PagingPathCount != 1) {
goto _L;
}
} else {
_L:
#line 262
if (status == status) {
#line 265
//DeviceObject__Flags |= 8192;
#line 266
setPagable = 1;
}
}
{
#line 270
status = CdAudioForwardIrpSynchronous(DeviceObject, Irp);
}
#line 272
if (status >= 0) {
#line 273
if (irpSp__Parameters__UsageNotification__InPath) {
}
#line 278
if (irpSp__Parameters__UsageNotification__InPath) {
#line 279
if (deviceExtension__PagingPathCount == 1) {
#line 280
//DeviceObject__Flags &= -8193;
}
}
} else {
#line 288
if (setPagable == 1) {
#line 289
//DeviceObject__Flags &= -8193;
#line 290
setPagable = 0;
}
}
{
#line 296
KeSetEvent(deviceExtension__PagingPathCountEvent, 0, 0);
#line 297
IofCompleteRequest(Irp, 0);
}
#line 299
return (status);
goto switch_1_break;
switch_1_default:
{
#line 303
tmp___0 = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 305
return (tmp___0);
} else {
switch_1_break: ;
}
}
}
#line 312
return (0);
}
}
#line 315 "cdaudio_simpl1.cil.c"
int CdAudioDeviceControl(int DeviceObject , int Irp )
{ int deviceExtension__Active = __VERIFIER_nondet_int() ;
int status ;
{
#line 320
if (deviceExtension__Active == 2) {
goto switch_2_2;
} else {
#line 323
if (deviceExtension__Active == 3) {
goto switch_2_3;
} else {
#line 326
if (deviceExtension__Active == 1) {
goto switch_2_1;
} else {
#line 329
if (deviceExtension__Active == 7) {
goto switch_2_7;
} else {
goto switch_2_default;
#line 334
if (0) {
switch_2_2:
{
#line 337
status = CdAudio535DeviceControl(DeviceObject, Irp);
}
goto switch_2_break;
switch_2_3:
{
#line 342
status = CdAudio435DeviceControl(DeviceObject, Irp);
}
goto switch_2_break;
switch_2_1:
{
#line 347
status = CdAudioAtapiDeviceControl(DeviceObject, Irp);
}
goto switch_2_break;
switch_2_7:
{
#line 352
status = CdAudioHPCdrDeviceControl(DeviceObject, Irp);
}
goto switch_2_break;
switch_2_default:
{
#line 357
deviceExtension__Active = 0;
#line 358
status = CdAudioSendToNextDriver(DeviceObject, Irp);
}
} else {
switch_2_break: ;
}
}
}
}
}
#line 368
return (status);
}
}
#line 371 "cdaudio_simpl1.cil.c"
int CdAudioSendToNextDriver(int DeviceObject , int Irp )
{ int Irp__CurrentLocation = __VERIFIER_nondet_int() ;
int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int deviceExtension__TargetDeviceObject = __VERIFIER_nondet_int() ;
int tmp ;
{
#line 378
if (s == NP) {
#line 379
s = SKIP1;
} else {
{
#line 382
errorFn();
}
}
{
#line 386
Irp__CurrentLocation ++;
#line 387
Irp__Tail__Overlay__CurrentStackLocation ++;
#line 388
tmp = IofCallDriver(deviceExtension__TargetDeviceObject, Irp);
}
#line 390
return (tmp);
}
}
#line 393 "cdaudio_simpl1.cil.c"
int CdAudioIsPlayActive(int DeviceObject )
{ int deviceExtension__PlayActive = __VERIFIER_nondet_int() ;
int ioStatus__Status = __VERIFIER_nondet_int() ;
int currentBuffer__Header__AudioStatus = __VERIFIER_nondet_int() ;
int irp_CdAudioIsPlayActive = __VERIFIER_nondet_int() ;
int event = __VERIFIER_nondet_int() ;
int status = __VERIFIER_nondet_int() ;
int currentBuffer = __VERIFIER_nondet_int() ;
int returnValue ;
long __cil_tmp10 ;
int __cil_tmp11 ;
{
#line 404
if (! deviceExtension__PlayActive) {
#line 405
return (0);
}
#line 409
if (currentBuffer == 0) {
#line 410
return (0);
}
#line 414
if (irp_CdAudioIsPlayActive == 0) {
#line 415
return (0);
}
{
#line 419
__cil_tmp10 = (long )status;
#line 419
if (__cil_tmp10 == 259L) {
{
#line 421
KeWaitForSingleObject(event, Suspended, KernelMode, 0, 0);
#line 422
status = ioStatus__Status;
}
}
}
{
#line 427
#line 427
if (status < 0) {
#line 428
return (0);
}
}
#line 432
if (currentBuffer__Header__AudioStatus == 17) {
#line 433
returnValue = 1;
} else {
#line 435
returnValue = 0;
#line 436
deviceExtension__PlayActive = 0;
}
#line 438
return (returnValue);
}
}
#line 441 "cdaudio_simpl1.cil.c"
int CdAudio535DeviceControl(int DeviceObject , int Irp )
{ int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int DeviceObject__DeviceExtension = __VERIFIER_nondet_int() ;
int deviceExtension__TargetDeviceObject = __VERIFIER_nondet_int() ;
int Irp__AssociatedIrp__SystemBuffer = __VERIFIER_nondet_int() ;
int srb__Cdb = __VERIFIER_nondet_int() ;
int currentIrpStack__Parameters__DeviceIoControl__IoControlCode = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Information ;
int currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength = __VERIFIER_nondet_int() ;
int currentIrpStack__Parameters__DeviceIoControl__InputBufferLength = __VERIFIER_nondet_int() ;
int srb__CdbLength ;
int cdb__CDB10__OperationCode ;
int srb__TimeOutValue ;
int sizeof__READ_CAPACITY_DATA = __VERIFIER_nondet_int() ;
int lastSession__LogicalBlockAddress = __VERIFIER_nondet_int() ;
int cdaudioDataOut__FirstTrack = __VERIFIER_nondet_int() ;
int cdaudioDataOut__LastTrack = __VERIFIER_nondet_int() ;
int sizeof__CDROM_TOC = __VERIFIER_nondet_int() ;
int sizeof__SUB_Q_CURRENT_POSITION = __VERIFIER_nondet_int() ;
int userPtr__Format = __VERIFIER_nondet_int() ;
int sizeof__CDROM_PLAY_AUDIO_MSF = __VERIFIER_nondet_int() ;
int inputBuffer__StartingM = __VERIFIER_nondet_int() ;
int inputBuffer__EndingM = __VERIFIER_nondet_int() ;
int inputBuffer__StartingS = __VERIFIER_nondet_int() ;
int inputBuffer__EndingS = __VERIFIER_nondet_int() ;
int inputBuffer__StartingF = __VERIFIER_nondet_int() ;
int inputBuffer__EndingF = __VERIFIER_nondet_int() ;
int cdb__PLAY_AUDIO_MSF__OperationCode = __VERIFIER_nondet_int() ;
int sizeof__CDROM_SEEK_AUDIO_MSF = __VERIFIER_nondet_int() ;
int currentIrpStack ;
int deviceExtension ;
int cdaudioDataOut ;
int srb = __VERIFIER_nondet_int() ;
int lastSession = __VERIFIER_nondet_int() ;
int cdb ;
int status ;
int i = __VERIFIER_nondet_int() ;
int bytesTransfered = __VERIFIER_nondet_int() ;
int Toc = __VERIFIER_nondet_int() ;
int tmp ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
int tmp___3 ;
int tmp___4 ;
int tracksToReturn ;
int tracksOnCd ;
int tracksInBuffer ;
int userPtr ;
int SubQPtr = __VERIFIER_nondet_int() ;
int tmp___5 ;
int tmp___6 ;
int inputBuffer ;
int inputBuffer___0 ;
int tmp___7 ;
int tmp___8 ;
int __cil_tmp58 ;
int __cil_tmp59 ;
int __cil_tmp60 ;
int __cil_tmp61 ;
int __cil_tmp62 ;
int __cil_tmp63 ;
int __cil_tmp64 ;
int __cil_tmp65 ;
int __cil_tmp66 ;
int __cil_tmp67 ;
int __cil_tmp68 ;
int __cil_tmp69 ;
int __cil_tmp70 ;
int __cil_tmp71 ;
int __cil_tmp72 ;
int __cil_tmp73 ;
int __cil_tmp74 ;
int __cil_tmp75 ;
int __cil_tmp76 ;
int __cil_tmp77 ;
int __cil_tmp78 ;
int __cil_tmp79 ;
int __cil_tmp80 ;
int __cil_tmp81 ;
int __cil_tmp82 ;
int __cil_tmp83 ;
int __cil_tmp84 ;
int __cil_tmp85 ;
int __cil_tmp86 ;
int __cil_tmp87 ;
int __cil_tmp88 ;
int __cil_tmp89 ;
int __cil_tmp90 ;
int __cil_tmp91 ;
int __cil_tmp92 ;
int __cil_tmp93 ;
int __cil_tmp94 ;
int __cil_tmp95 ;
int __cil_tmp96 ;
int __cil_tmp97 ;
int __cil_tmp98 ;
int __cil_tmp99 ;
int __cil_tmp100 ;
int __cil_tmp101 ;
int __cil_tmp102 ;
int __cil_tmp103 ;
int __cil_tmp104 ;
int __cil_tmp105 ;
int __cil_tmp106 ;
unsigned long __cil_tmp107 ;
unsigned long __cil_tmp108 ;
int __cil_tmp109 ;
int __cil_tmp110 ;
{
#line 499
currentIrpStack = Irp__Tail__Overlay__CurrentStackLocation;
#line 500
deviceExtension = DeviceObject__DeviceExtension;
#line 501
cdaudioDataOut = Irp__AssociatedIrp__SystemBuffer;
#line 502
cdb = srb__Cdb;
{
#line 503
__cil_tmp58 = 56;
#line 503
__cil_tmp59 = 16384;
#line 503
__cil_tmp60 = 131072;
#line 503
__cil_tmp61 = 147456;
#line 503
__cil_tmp62 = 147512;
#line 503
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp62) {
goto switch_3_exp_0;
} else {
{
#line 506
__cil_tmp63 = 16384;
#line 506
__cil_tmp64 = 131072;
#line 506
__cil_tmp65 = 147456;
#line 506
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp65) {
goto switch_3_exp_1;
} else {
{
#line 509
__cil_tmp66 = 44;
#line 509
__cil_tmp67 = 16384;
#line 509
__cil_tmp68 = 131072;
#line 509
__cil_tmp69 = 147456;
#line 509
__cil_tmp70 = 147500;
#line 509
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp70) {
goto switch_3_exp_2;
} else {
{
#line 512
__cil_tmp71 = 24;
#line 512
__cil_tmp72 = 16384;
#line 512
__cil_tmp73 = 131072;
#line 512
__cil_tmp74 = 147456;
#line 512
__cil_tmp75 = 147480;
#line 512
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp75) {
goto switch_3_exp_3;
} else {
{
#line 515
__cil_tmp76 = 4;
#line 515
__cil_tmp77 = 16384;
#line 515
__cil_tmp78 = 131072;
#line 515
__cil_tmp79 = 147456;
#line 515
__cil_tmp80 = 147460;
#line 515
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp80) {
goto switch_3_exp_4;
} else {
{
#line 518
__cil_tmp81 = 2056;
#line 518
__cil_tmp82 = 16384;
#line 518
__cil_tmp83 = 131072;
#line 518
__cil_tmp84 = 147456;
#line 518
__cil_tmp85 = 149512;
#line 518
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp85) {
goto switch_3_exp_5;
} else {
{
#line 521
__cil_tmp86 = 52;
#line 521
__cil_tmp87 = 16384;
#line 521
__cil_tmp88 = 131072;
#line 521
__cil_tmp89 = 147456;
#line 521
__cil_tmp90 = 147508;
#line 521
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp90) {
goto switch_3_exp_6;
} else {
{
#line 524
__cil_tmp91 = 20;
#line 524
__cil_tmp92 = 16384;
#line 524
__cil_tmp93 = 131072;
#line 524
__cil_tmp94 = 147456;
#line 524
__cil_tmp95 = 147476;
#line 524
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp95) {
goto switch_3_exp_7;
} else {
{
#line 527
__cil_tmp96 = 40;
#line 527
__cil_tmp97 = 16384;
#line 527
__cil_tmp98 = 131072;
#line 527
__cil_tmp99 = 147456;
#line 527
__cil_tmp100 = 147496;
#line 527
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp100) {
goto switch_3_exp_8;
} else {
{
#line 530
__cil_tmp101 = 2048;
#line 530
__cil_tmp102 = 16384;
#line 530
__cil_tmp103 = 131072;
#line 530
__cil_tmp104 = 147456;
#line 530
__cil_tmp105 = 149504;
#line 530
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp105) {
goto switch_3_exp_9;
} else {
goto switch_3_default;
#line 535
if (0) {
switch_3_exp_0:
{
#line 538
tmp = CdAudioIsPlayActive(DeviceObject);
}
#line 540
if (tmp) {
#line 541
status = -2147483631;
#line 542
Irp__IoStatus__Information = 0;
goto switch_3_break;
}
#line 547
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength) {
#line 548
status = -1073741789;
#line 549
Irp__IoStatus__Information = 0;
goto switch_3_break;
}
#line 554
if (lastSession == 0) {
{
#line 556
status = -1073741670;
#line 557
Irp__IoStatus__Information = 0;
#line 558
tmp___0 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 560
return (tmp___0);
}
{
#line 565
srb__CdbLength = 10;
#line 566
cdb__CDB10__OperationCode = 38;
#line 567
srb__TimeOutValue = 10;
#line 568
status = SendSrbSynchronous(deviceExtension, srb, lastSession,
sizeof__READ_CAPACITY_DATA);
}
{
#line 571
#line 571
if (status < 0) {
{
#line 573
Irp__IoStatus__Information = 0;
#line 574
tmp___1 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 576
return (tmp___1);
} else {
#line 578
status = 0;
}
}
#line 580
Irp__IoStatus__Information = bytesTransfered;
#line 581
if (lastSession__LogicalBlockAddress == 0) {
goto switch_3_break;
}
#line 586
cdaudioDataOut__FirstTrack = 1;
#line 587
cdaudioDataOut__LastTrack = 2;
goto switch_3_break;
switch_3_exp_1: ;
#line 590
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength) {
#line 591
status = -1073741789;
#line 592
Irp__IoStatus__Information = 0;
goto switch_3_break;
}
{
#line 598
tmp___2 = CdAudioIsPlayActive(DeviceObject);
}
#line 600
if (tmp___2) {
#line 601
status = -2147483631;
#line 602
Irp__IoStatus__Information = 0;
goto switch_3_break;
}
#line 607
if (Toc == 0) {
{
#line 609
status = -1073741670;
#line 610
Irp__IoStatus__Information = 0;
#line 611
tmp___3 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 613
return (tmp___3);
}
{
#line 618
srb__TimeOutValue = 10;
#line 619
srb__CdbLength = 10;
#line 620
status = SendSrbSynchronous(deviceExtension, srb, Toc, sizeof__CDROM_TOC);
}
#line 622
if (status >= 0) {
{
#line 623
__cil_tmp107 = (unsigned long )status;
#line 623
if (__cil_tmp107 != -1073741764) {
#line 624
status = 0;
} else {
goto _L;
}
}
} else {
_L:
{
#line 630
__cil_tmp108 = (unsigned long )status;
#line 630
if (__cil_tmp108 != -1073741764) {
{
#line 632
Irp__IoStatus__Information = 0;
#line 633
tmp___4 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 635
return (tmp___4);
}
}
}
#line 640
__cil_tmp109 = cdaudioDataOut__LastTrack - cdaudioDataOut__FirstTrack;
#line 640
tracksOnCd = __cil_tmp109 + 1;
#line 641
tracksInBuffer = currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength;
#line 642
if (tracksInBuffer < tracksOnCd) {
#line 643
tracksToReturn = tracksInBuffer;
} else {
#line 645
tracksToReturn = tracksOnCd;
}
#line 647
if (tracksInBuffer > tracksOnCd) {
#line 648
i ++;
}
goto switch_3_break;
switch_3_exp_2:
#line 654
userPtr = Irp__AssociatedIrp__SystemBuffer;
#line 655
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength < sizeof__SUB_Q_CURRENT_POSITION) {
#line 656
status = -1073741789;
#line 657
Irp__IoStatus__Information = 0;
goto switch_3_break;
}
#line 662
if (SubQPtr == 0) {
{
#line 664
status = -1073741670;
#line 665
Irp__IoStatus__Information = 0;
#line 666
tmp___5 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 668
return (tmp___5);
}
#line 672
if (userPtr__Format != 1) {
{
#line 674
status = -1073741823;
#line 675
Irp__IoStatus__Information = 0;
#line 676
tmp___6 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 678
return (tmp___6);
}
{
#line 683
srb__CdbLength = 10;
#line 684
srb__TimeOutValue = 10;
#line 685
status = SendSrbSynchronous(deviceExtension, srb, SubQPtr,
sizeof__SUB_Q_CURRENT_POSITION);
}
#line 688
if (status >= 0) {
#line 689
Irp__IoStatus__Information = sizeof__SUB_Q_CURRENT_POSITION;
} else {
#line 691
Irp__IoStatus__Information = 0;
}
goto switch_3_break;
switch_3_exp_3:
#line 695
inputBuffer = Irp__AssociatedIrp__SystemBuffer;
#line 696
Irp__IoStatus__Information = 0;
#line 697
if (currentIrpStack__Parameters__DeviceIoControl__InputBufferLength < sizeof__CDROM_PLAY_AUDIO_MSF) {
#line 698
status = -1073741820;
goto switch_3_break;
}
#line 703
if (inputBuffer__StartingM == inputBuffer__EndingM) {
#line 704
if (inputBuffer__StartingS == inputBuffer__EndingS) {
#line 705
if (inputBuffer__StartingF == inputBuffer__EndingF) {
}
}
}
{
#line 717
srb__CdbLength = 10;
#line 718
srb__TimeOutValue = 10;
#line 719
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
#line 721
if (status >= 0) {
#line 722
if (cdb__PLAY_AUDIO_MSF__OperationCode == 71) {
}
}
goto switch_3_break;
switch_3_exp_4:
#line 732
inputBuffer___0 = Irp__AssociatedIrp__SystemBuffer;
#line 733
Irp__IoStatus__Information = 0;
#line 734
if (currentIrpStack__Parameters__DeviceIoControl__InputBufferLength < sizeof__CDROM_SEEK_AUDIO_MSF) {
#line 735
status = -1073741820;
goto switch_3_break;
}
{
#line 741
srb__CdbLength = 10;
#line 742
srb__TimeOutValue = 10;
#line 743
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
{
#line 745
#line 745
if (status < 0) {
}
}
goto switch_3_break;
switch_3_exp_5:
{
#line 753
Irp__IoStatus__Information = 0;
#line 754
srb__CdbLength = 10;
#line 755
srb__TimeOutValue = 10;
#line 756
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
goto switch_3_break;
switch_3_exp_6: ;
switch_3_exp_7: ;
switch_3_exp_8:
#line 762
Irp__IoStatus__Information = 0;
#line 763
status = -1073741808;
goto switch_3_break;
switch_3_exp_9:
{
#line 767
CdAudioIsPlayActive(DeviceObject);
}
switch_3_default:
{
#line 771
tmp___7 = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 773
return (tmp___7);
goto switch_3_break;
} else {
switch_3_break: ;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
{
#line 790
tmp___8 = AG_SetStatusAndReturn(status, Irp, deviceExtension__TargetDeviceObject);
}
#line 792
return (tmp___8);
}
}
#line 795 "cdaudio_simpl1.cil.c"
int AG_SetStatusAndReturn(int status , int Irp , int deviceExtension__TargetDeviceObject )
{ unsigned long __cil_tmp4 ;
{
{
#line 799
__cil_tmp4 = (unsigned long )status;
#line 799
if (__cil_tmp4 == -2147483626) {
}
}
{
#line 805
myStatus = status;
#line 806
IofCompleteRequest(Irp, 0);
}
#line 808
return (status);
}
}
#line 811 "cdaudio_simpl1.cil.c"
int CdAudio435DeviceControl(int DeviceObject , int Irp )
{ int currentIrpStack__Parameters__DeviceIoControl__IoControlCode = __VERIFIER_nondet_int() ;
int currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength = __VERIFIER_nondet_int() ;
int currentIrpStack__Parameters__DeviceIoControl__InputBufferLength = __VERIFIER_nondet_int() ;
int TrackData__0 = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Information ;
int srb__TimeOutValue ;
int srb__CdbLength ;
int sizeof__CDROM_TOC = __VERIFIER_nondet_int() ;
int cdaudioDataOut__LastTrack = __VERIFIER_nondet_int() ;
int cdaudioDataOut__FirstTrack = __VERIFIER_nondet_int() ;
int sizeof__CDROM_PLAY_AUDIO_MSF = __VERIFIER_nondet_int() ;
int sizeof__CDROM_SEEK_AUDIO_MSF = __VERIFIER_nondet_int() ;
int deviceExtension__Paused = __VERIFIER_nondet_int() ;
int deviceExtension__PlayActive ;
int sizeof__SUB_Q_CHANNEL_DATA = __VERIFIER_nondet_int() ;
int sizeof__SUB_Q_CURRENT_POSITION = __VERIFIER_nondet_int() ;
int deviceExtension = __VERIFIER_nondet_int() ;
int srb = __VERIFIER_nondet_int() ;
int status ;
int i = __VERIFIER_nondet_int() ;
int bytesTransfered ;
int Toc = __VERIFIER_nondet_int() ;
int tmp ;
int tracksToReturn ;
int tracksOnCd ;
int tracksInBuffer ;
int SubQPtr = __VERIFIER_nondet_int() ;
int userPtr__Format = __VERIFIER_nondet_int() ;
int SubQPtr___0 = __VERIFIER_nondet_int() ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
int __cil_tmp35 ;
int __cil_tmp36 ;
int __cil_tmp37 ;
int __cil_tmp38 ;
int __cil_tmp39 ;
int __cil_tmp40 ;
int __cil_tmp41 ;
int __cil_tmp42 ;
int __cil_tmp43 ;
int __cil_tmp44 ;
int __cil_tmp45 ;
int __cil_tmp46 ;
int __cil_tmp47 ;
int __cil_tmp48 ;
int __cil_tmp49 ;
int __cil_tmp50 ;
int __cil_tmp51 ;
int __cil_tmp52 ;
int __cil_tmp53 ;
int __cil_tmp54 ;
int __cil_tmp55 ;
int __cil_tmp56 ;
int __cil_tmp57 ;
int __cil_tmp58 ;
int __cil_tmp59 ;
int __cil_tmp60 ;
int __cil_tmp61 ;
int __cil_tmp62 ;
int __cil_tmp63 ;
int __cil_tmp64 ;
int __cil_tmp65 ;
int __cil_tmp66 ;
int __cil_tmp67 ;
int __cil_tmp68 ;
int __cil_tmp69 ;
int __cil_tmp70 ;
int __cil_tmp71 ;
int __cil_tmp72 ;
int __cil_tmp73 ;
int __cil_tmp74 ;
int __cil_tmp75 ;
int __cil_tmp76 ;
int __cil_tmp77 ;
int __cil_tmp78 ;
int __cil_tmp79 ;
int __cil_tmp80 ;
int __cil_tmp81 ;
int __cil_tmp82 ;
int __cil_tmp83 ;
int __cil_tmp84 ;
int __cil_tmp85 ;
int __cil_tmp86 ;
int __cil_tmp87 ;
int __cil_tmp88 ;
int __cil_tmp89 ;
int __cil_tmp90 ;
int __cil_tmp91 ;
int __cil_tmp92 ;
unsigned long __cil_tmp93 ;
int __cil_tmp94 ;
unsigned long __cil_tmp95 ;
unsigned long __cil_tmp96 ;
unsigned long __cil_tmp97 ;
int __cil_tmp98 ;
int __cil_tmp99 ;
int __cil_tmp100 ;
int __cil_tmp101 ;
int __cil_tmp102 ;
int __cil_tmp103 ;
unsigned long __cil_tmp104 ;
unsigned long __cil_tmp105 ;
unsigned long __cil_tmp106 ;
unsigned long __cil_tmp107 ;
int __cil_tmp108 ;
unsigned long __cil_tmp109 ;
int __cil_tmp110 ;
unsigned long __cil_tmp111 ;
unsigned long __cil_tmp112 ;
unsigned long __cil_tmp113 ;
unsigned long __cil_tmp114 ;
unsigned long __cil_tmp115 ;
unsigned long __cil_tmp116 ;
{
{
#line 846
__cil_tmp35 = 16384;
#line 846
__cil_tmp36 = 131072;
#line 846
__cil_tmp37 = 147456;
#line 846
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp37) {
goto switch_4_exp_10;
} else {
{
#line 849
__cil_tmp38 = 24;
#line 849
__cil_tmp39 = 16384;
#line 849
__cil_tmp40 = 131072;
#line 849
__cil_tmp41 = 147456;
#line 849
__cil_tmp42 = 147480;
#line 849
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp42) {
goto switch_4_exp_11;
} else {
{
#line 852
__cil_tmp43 = 8;
#line 852
__cil_tmp44 = 16384;
#line 852
__cil_tmp45 = 131072;
#line 852
__cil_tmp46 = 147456;
#line 852
__cil_tmp47 = 147464;
#line 852
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp47) {
goto switch_4_exp_12;
} else {
{
#line 855
__cil_tmp48 = 4;
#line 855
__cil_tmp49 = 16384;
#line 855
__cil_tmp50 = 131072;
#line 855
__cil_tmp51 = 147456;
#line 855
__cil_tmp52 = 147460;
#line 855
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp52) {
goto switch_4_exp_13;
} else {
{
#line 858
__cil_tmp53 = 12;
#line 858
__cil_tmp54 = 16384;
#line 858
__cil_tmp55 = 131072;
#line 858
__cil_tmp56 = 147456;
#line 858
__cil_tmp57 = 147468;
#line 858
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp57) {
goto switch_4_exp_14;
} else {
{
#line 861
__cil_tmp58 = 16;
#line 861
__cil_tmp59 = 16384;
#line 861
__cil_tmp60 = 131072;
#line 861
__cil_tmp61 = 147456;
#line 861
__cil_tmp62 = 147472;
#line 861
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp62) {
goto switch_4_exp_15;
} else {
{
#line 864
__cil_tmp63 = 44;
#line 864
__cil_tmp64 = 16384;
#line 864
__cil_tmp65 = 131072;
#line 864
__cil_tmp66 = 147456;
#line 864
__cil_tmp67 = 147500;
#line 864
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp67) {
goto switch_4_exp_16;
} else {
{
#line 867
__cil_tmp68 = 2056;
#line 867
__cil_tmp69 = 16384;
#line 867
__cil_tmp70 = 131072;
#line 867
__cil_tmp71 = 147456;
#line 867
__cil_tmp72 = 149512;
#line 867
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp72) {
goto switch_4_exp_17;
} else {
{
#line 870
__cil_tmp73 = 52;
#line 870
__cil_tmp74 = 16384;
#line 870
__cil_tmp75 = 131072;
#line 870
__cil_tmp76 = 147456;
#line 870
__cil_tmp77 = 147508;
#line 870
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp77) {
goto switch_4_exp_18;
} else {
{
#line 873
__cil_tmp78 = 20;
#line 873
__cil_tmp79 = 16384;
#line 873
__cil_tmp80 = 131072;
#line 873
__cil_tmp81 = 147456;
#line 873
__cil_tmp82 = 147476;
#line 873
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp82) {
goto switch_4_exp_19;
} else {
{
#line 876
__cil_tmp83 = 40;
#line 876
__cil_tmp84 = 16384;
#line 876
__cil_tmp85 = 131072;
#line 876
__cil_tmp86 = 147456;
#line 876
__cil_tmp87 = 147496;
#line 876
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp87) {
goto switch_4_exp_20;
} else {
{
#line 879
__cil_tmp88 = 2048;
#line 879
__cil_tmp89 = 16384;
#line 879
__cil_tmp90 = 131072;
#line 879
__cil_tmp91 = 147456;
#line 879
__cil_tmp92 = 149504;
#line 879
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp92) {
goto switch_4_exp_21;
} else {
goto switch_4_default;
#line 884
if (0) {
switch_4_exp_10: ;
#line 886
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength < TrackData__0) {
#line 887
status = -1073741789;
#line 888
Irp__IoStatus__Information = 0;
goto switch_4_break;
}
{
#line 894
tmp = CdAudioIsPlayActive(DeviceObject);
}
#line 896
if (tmp) {
#line 897
status = -2147483631;
#line 898
Irp__IoStatus__Information = 0;
goto switch_4_break;
}
#line 903
if (Toc == 0) {
#line 904
status = -1073741670;
#line 905
Irp__IoStatus__Information = 0;
{
#line 906
__cil_tmp93 = (unsigned long )status;
#line 906
if (__cil_tmp93 == -2147483626) {
#line 907
Irp__IoStatus__Information = 0;
}
}
{
#line 912
myStatus = status;
#line 913
IofCompleteRequest(Irp, 0);
}
#line 915
return (status);
}
{
#line 920
srb__TimeOutValue = 10;
#line 921
srb__CdbLength = 10;
#line 922
status = SendSrbSynchronous(deviceExtension, srb, Toc,
sizeof__CDROM_TOC);
}
{
#line 925
#line 925
if (status < 0) {
{
#line 926
__cil_tmp95 = (unsigned long )status;
#line 926
if (__cil_tmp95 != -1073741764) {
{
#line 927
__cil_tmp96 = (unsigned long )status;
#line 927
if (__cil_tmp96 != -1073741764) {
{
#line 928
__cil_tmp97 = (unsigned long )status;
#line 928
if (__cil_tmp97 == -2147483626) {
#line 929
Irp__IoStatus__Information = 0;
}
}
{
#line 934
myStatus = status;
#line 935
IofCompleteRequest(Irp, 0);
}
#line 937
return (status);
}
}
} else {
#line 942
status = 0;
}
}
} else {
#line 945
status = 0;
}
}
#line 947
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength > sizeof__CDROM_TOC) {
#line 948
bytesTransfered = sizeof__CDROM_TOC;
} else {
#line 950
bytesTransfered = currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength;
}
#line 952
__cil_tmp98 = cdaudioDataOut__LastTrack - cdaudioDataOut__FirstTrack;
#line 952
tracksOnCd = __cil_tmp98 + 1;
#line 953
tracksInBuffer = currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength - TrackData__0;
#line 954
if (tracksInBuffer < tracksOnCd) {
#line 955
tracksToReturn = tracksInBuffer;
} else {
#line 957
tracksToReturn = tracksOnCd;
}
#line 959
if (tracksInBuffer > tracksOnCd) {
#line 960
i ++;
}
goto switch_4_break;
switch_4_exp_11: ;
switch_4_exp_12:
{
#line 968
Irp__IoStatus__Information = 0;
#line 969
srb__CdbLength = 10;
#line 970
srb__TimeOutValue = 10;
#line 971
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
#line 973
if (status >= 0) {
}
{
#line 978
__cil_tmp99 = 8;
#line 978
__cil_tmp100 = 16384;
#line 978
__cil_tmp101 = 131072;
#line 978
__cil_tmp102 = 147456;
#line 978
__cil_tmp103 = 147464;
#line 978
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp103) {
{
#line 979
__cil_tmp104 = (unsigned long )status;
#line 979
if (__cil_tmp104 == -2147483626) {
#line 980
Irp__IoStatus__Information = 0;
}
}
{
#line 985
myStatus = status;
#line 986
IofCompleteRequest(Irp, 0);
}
#line 988
return (status);
}
}
#line 992
if (currentIrpStack__Parameters__DeviceIoControl__InputBufferLength < sizeof__CDROM_PLAY_AUDIO_MSF) {
#line 993
status = -1073741820;
goto switch_4_break;
}
{
#line 999
srb__CdbLength = 10;
#line 1000
srb__TimeOutValue = 10;
#line 1001
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
#line 1003
if (status >= 0) {
}
goto switch_4_break;
switch_4_exp_13:
#line 1010
Irp__IoStatus__Information = 0;
#line 1011
if (currentIrpStack__Parameters__DeviceIoControl__InputBufferLength < sizeof__CDROM_SEEK_AUDIO_MSF) {
#line 1012
status = -1073741820;
goto switch_4_break;
}
{
#line 1018
srb__CdbLength = 10;
#line 1019
srb__TimeOutValue = 10;
#line 1020
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
#line 1022
if (status < 0) {
{
#line 1025
__cil_tmp105 = (unsigned long )status;
#line 1025
if (__cil_tmp105 == -1073741808) {
#line 1026
status = -1073741803;
}
}
}
goto switch_4_break;
switch_4_exp_14:
#line 1033
Irp__IoStatus__Information = 0;
#line 1034
if (SubQPtr == 0) {
#line 1035
status = -1073741670;
{
#line 1036
__cil_tmp106 = (unsigned long )status;
#line 1036
if (__cil_tmp106 == -2147483626) {
#line 1037
Irp__IoStatus__Information = 0;
}
}
{
#line 1042
myStatus = status;
#line 1043
IofCompleteRequest(Irp, 0);
}
#line 1045
return (status);
}
#line 1049
if (deviceExtension__Paused == 1) {
#line 1050
status = 0;
{
#line 1051
__cil_tmp107 = (unsigned long )status;
#line 1051
if (__cil_tmp107 == -2147483626) {
#line 1052
Irp__IoStatus__Information = 0;
}
}
{
#line 1057
myStatus = status;
#line 1058
IofCompleteRequest(Irp, 0);
}
#line 1060
return (status);
}
{
#line 1065
srb__CdbLength = 10;
#line 1066
srb__TimeOutValue = 10;
#line 1067
status = SendSrbSynchronous(deviceExtension, srb, SubQPtr,
sizeof__SUB_Q_CHANNEL_DATA);
}
{
#line 1070
#line 1070
if (status < 0) {
{
#line 1071
__cil_tmp109 = (unsigned long )status;
#line 1071
if (__cil_tmp109 == -2147483626) {
#line 1072
Irp__IoStatus__Information = 0;
}
}
{
#line 1077
myStatus = status;
#line 1078
IofCompleteRequest(Irp, 0);
}
#line 1080
return (status);
}
}
{
#line 1085
srb__CdbLength = 10;
#line 1086
srb__TimeOutValue = 10;
#line 1087
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
{
#line 1089
#line 1089
if (status < 0) {
{
#line 1090
__cil_tmp111 = (unsigned long )status;
#line 1090
if (__cil_tmp111 == -2147483626) {
#line 1091
Irp__IoStatus__Information = 0;
}
}
{
#line 1096
myStatus = status;
#line 1097
IofCompleteRequest(Irp, 0);
}
#line 1099
return (status);
}
}
goto switch_4_break;
switch_4_exp_15:
#line 1105
Irp__IoStatus__Information = 0;
#line 1106
if (deviceExtension__Paused == 0) {
#line 1107
status = -1073741823;
{
#line 1108
__cil_tmp112 = (unsigned long )status;
#line 1108
if (__cil_tmp112 == -2147483626) {
#line 1109
Irp__IoStatus__Information = 0;
}
}
{
#line 1114
myStatus = status;
#line 1115
IofCompleteRequest(Irp, 0);
}
#line 1117
return (status);
}
{
#line 1122
srb__CdbLength = 10;
#line 1123
srb__TimeOutValue = 10;
#line 1124
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
#line 1126
if (status >= 0) {
#line 1127
deviceExtension__PlayActive = 1;
#line 1128
deviceExtension__Paused = 0;
}
goto switch_4_break;
switch_4_exp_16: ;
#line 1134
if (currentIrpStack__Parameters__DeviceIoControl__OutputBufferLength < sizeof__SUB_Q_CURRENT_POSITION) {
#line 1135
status = -1073741789;
#line 1136
Irp__IoStatus__Information = 0;
goto switch_4_break;
}
#line 1141
if (SubQPtr___0 == 0) {
#line 1142
status = -1073741670;
#line 1143
Irp__IoStatus__Information = 0;
{
#line 1144
__cil_tmp113 = (unsigned long )status;
#line 1144
if (__cil_tmp113 == -2147483626) {
#line 1145
Irp__IoStatus__Information = 0;
}
}
{
#line 1150
myStatus = status;
#line 1151
IofCompleteRequest(Irp, 0);
}
#line 1153
return (status);
}
#line 1157
if (userPtr__Format != 1) {
#line 1158
status = -1073741823;
#line 1159
Irp__IoStatus__Information = 0;
{
#line 1160
__cil_tmp114 = (unsigned long )status;
#line 1160
if (__cil_tmp114 == -2147483626) {
#line 1161
Irp__IoStatus__Information = 0;
}
}
{
#line 1166
myStatus = status;
#line 1167
IofCompleteRequest(Irp, 0);
}
#line 1169
return (status);
}
{
#line 1174
srb__CdbLength = 10;
#line 1175
srb__TimeOutValue = 10;
#line 1176
status = SendSrbSynchronous(deviceExtension, srb, SubQPtr___0,
sizeof__SUB_Q_CHANNEL_DATA);
}
#line 1179
if (status >= 0) {
#line 1180
if (deviceExtension__Paused == 1) {
#line 1181
deviceExtension__PlayActive = 0;
}
#line 1185
Irp__IoStatus__Information = sizeof__SUB_Q_CURRENT_POSITION;
} else {
#line 1187
Irp__IoStatus__Information = 0;
}
goto switch_4_break;
switch_4_exp_17:
{
#line 1192
Irp__IoStatus__Information = 0;
#line 1193
srb__CdbLength = 10;
#line 1194
srb__TimeOutValue = 10;
#line 1195
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
goto switch_4_break;
switch_4_exp_18: ;
switch_4_exp_19: ;
switch_4_exp_20:
#line 1201
Irp__IoStatus__Information = 0;
#line 1202
status = -1073741808;
goto switch_4_break;
switch_4_exp_21:
{
#line 1206
tmp___1 = CdAudioIsPlayActive(DeviceObject);
}
#line 1208
if (tmp___1 == 1) {
#line 1209
deviceExtension__PlayActive = 1;
#line 1210
status = 0;
#line 1211
Irp__IoStatus__Information = 0;
{
#line 1212
__cil_tmp115 = (unsigned long )status;
#line 1212
if (__cil_tmp115 == -2147483626) {
#line 1213
Irp__IoStatus__Information = 0;
}
}
{
#line 1218
myStatus = status;
#line 1219
IofCompleteRequest(Irp, 0);
}
#line 1221
return (status);
} else {
{
#line 1224
deviceExtension__PlayActive = 0;
#line 1225
tmp___0 = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 1227
return (tmp___0);
}
goto switch_4_break;
switch_4_default:
{
#line 1232
tmp___2 = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 1234
return (tmp___2);
goto switch_4_break;
} else {
switch_4_break: ;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
{
#line 1252
__cil_tmp116 = (unsigned long )status;
#line 1252
if (__cil_tmp116 == -2147483626) {
#line 1253
Irp__IoStatus__Information = 0;
}
}
{
#line 1258
myStatus = status;
#line 1259
IofCompleteRequest(Irp, 0);
}
#line 1261
return (status);
}
}
#line 1264 "cdaudio_simpl1.cil.c"
int CdAudioAtapiDeviceControl(int DeviceObject , int Irp )
{ int currentIrpStack__Parameters__DeviceIoControl__IoControlCode = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Information ;
int deviceExtension__PlayActive ;
int srb__CdbLength ;
int srb__TimeOutValue ;
int Irp__IoStatus__Status ;
int status ;
int deviceExtension = __VERIFIER_nondet_int() ;
int srb = __VERIFIER_nondet_int() ;
int tmp ;
int __cil_tmp13 ;
int __cil_tmp14 ;
int __cil_tmp15 ;
int __cil_tmp16 ;
int __cil_tmp17 ;
int __cil_tmp18 ;
{
{
#line 1277
__cil_tmp13 = 8;
#line 1277
__cil_tmp14 = 16384;
#line 1277
__cil_tmp15 = 131072;
#line 1277
__cil_tmp16 = 147456;
#line 1277
__cil_tmp17 = 147464;
#line 1277
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp17) {
{
#line 1279
Irp__IoStatus__Information = 0;
#line 1280
deviceExtension__PlayActive = 0;
#line 1281
srb__CdbLength = 12;
#line 1282
srb__TimeOutValue = 10;
#line 1283
status = SendSrbSynchronous(deviceExtension, srb, 0, 0);
}
{
#line 1285
#line 1285
if (status < 0) {
{
#line 1287
Irp__IoStatus__Status = status;
#line 1288
myStatus = status;
#line 1289
IofCompleteRequest(Irp, 0);
}
#line 1291
return (status);
}
}
} else {
{
#line 1297
tmp = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 1299
return (tmp);
}
}
{
#line 1302
Irp__IoStatus__Status = status;
#line 1303
myStatus = status;
#line 1304
IofCompleteRequest(Irp, 0);
}
#line 1306
return (status);
}
}
#line 1309 "cdaudio_simpl1.cil.c"
void HpCdrProcessLastSession(int Toc )
{ int index = __VERIFIER_nondet_int() ;
{
#line 1313
if (index) {
#line 1314
index --;
}
#line 1318
return;
}
}
#line 1321 "cdaudio_simpl1.cil.c"
int HPCdrCompletion(int DeviceObject , int Irp , int Context )
{ int Irp__PendingReturned = __VERIFIER_nondet_int() ;
int Irp__AssociatedIrp__SystemBuffer = __VERIFIER_nondet_int() ;
{
#line 1326
if (Irp__PendingReturned) {
#line 1327
if (pended == 0) {
#line 1328
pended = 1;
} else {
{
#line 1331
errorFn();
}
}
}
#line 1337
if (myStatus >= 0) {
{
#line 1339
HpCdrProcessLastSession(Irp__AssociatedIrp__SystemBuffer);
}
}
#line 1344
return (myStatus);
}
}
#line 1347 "cdaudio_simpl1.cil.c"
int CdAudioHPCdrDeviceControl(int DeviceObject , int Irp )
{ int currentIrpStack__Parameters__DeviceIoControl__IoControlCode = __VERIFIER_nondet_int() ;
int deviceExtension__TargetDeviceObject = __VERIFIER_nondet_int() ;
int irpSp__Control ;
int tmp ;
int tmp___0 ;
int __cil_tmp8 ;
int __cil_tmp9 ;
int __cil_tmp10 ;
int __cil_tmp11 ;
int __cil_tmp12 ;
{
{
#line 1355
__cil_tmp8 = 56;
#line 1355
__cil_tmp9 = 16384;
#line 1355
__cil_tmp10 = 131072;
#line 1355
__cil_tmp11 = 147456;
#line 1355
__cil_tmp12 = 147512;
#line 1355
if (currentIrpStack__Parameters__DeviceIoControl__IoControlCode == __cil_tmp12) {
#line 1356
if (s != NP) {
{
#line 1358
errorFn();
}
} else {
#line 1361
if (compRegistered != 0) {
{
#line 1363
errorFn();
}
} else {
#line 1366
compRegistered = 1;
#line 1367
routine = 0;
}
}
{
#line 1371
irpSp__Control = 224;
#line 1375
tmp = IofCallDriver(deviceExtension__TargetDeviceObject, Irp);
}
#line 1377
return (tmp);
} else {
{
#line 1380
tmp___0 = CdAudioSendToNextDriver(DeviceObject, Irp);
}
#line 1382
return (tmp___0);
}
}
#line 1384
return (-1073741823);
}
}
#line 1387 "cdaudio_simpl1.cil.c"
int CdAudioForwardIrpSynchronous(int DeviceObject , int Irp )
{ int deviceExtension__TargetDeviceObject = __VERIFIER_nondet_int() ;
int event = __VERIFIER_nondet_int() ;
int status ;
int irpSp__Control ;
{
#line 1394
if (s != NP) {
{
#line 1396
errorFn();
}
} else {
#line 1399
if (compRegistered != 0) {
{
#line 1401
errorFn();
}
} else {
#line 1404
compRegistered = 1;
#line 1405
routine = 1;
}
}
{
#line 1409
irpSp__Control = 224;
#line 1413
status = IofCallDriver(deviceExtension__TargetDeviceObject, Irp);
#line 1414
status = 259;
}
#line 1416
if (status) {
{
#line 1418
KeWaitForSingleObject(event, Executive, KernelMode, 0, 0);
#line 1419
status = myStatus;
}
}
#line 1424
return (status);
}
}
#line 1427 "cdaudio_simpl1.cil.c"
void CdAudioUnload(int DriverObject )
{
{
#line 1431
return;
}
}
#line 1434 "cdaudio_simpl1.cil.c"
int CdAudioPower(int DeviceObject , int Irp )
{ int Irp__CurrentLocation = __VERIFIER_nondet_int() ;
int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int deviceExtension__TargetDeviceObject = __VERIFIER_nondet_int() ;
int tmp ;
{
#line 1441
if (s == NP) {
#line 1442
s = SKIP1;
} else {
{
#line 1445
errorFn();
}
}
{
#line 1449
Irp__CurrentLocation ++;
#line 1450
Irp__Tail__Overlay__CurrentStackLocation ++;
#line 1451
tmp = PoCallDriver(deviceExtension__TargetDeviceObject, Irp);
}
#line 1453
return (tmp);
}
}
#line 1456 "cdaudio_simpl1.cil.c"
void stub_driver_init(void)
{
{
#line 1460
s = NP;
#line 1461
customIrp = 0;
#line 1462
setEventCalled = customIrp;
#line 1463
lowerDriverReturn = setEventCalled;
#line 1464
compRegistered = lowerDriverReturn;
#line 1465
compFptr = compRegistered;
#line 1466
pended = compFptr;
#line 1467
return;
}
}
#line 1470 "cdaudio_simpl1.cil.c"
int main(void)
{ int pirp__IoStatus__Status ;
int d = __VERIFIER_nondet_int() ;
int status = __VERIFIER_nondet_int() ;
int irp = __VERIFIER_nondet_int() ;
int we_should_unload = __VERIFIER_nondet_int() ;
int irp_choice = __VERIFIER_nondet_int() ;
int devobj = __VERIFIER_nondet_int() ;
int __cil_tmp9 ;
{
{
s = 0;
UNLOADED = 0;
NP = 0;
DC = 0;
SKIP1 = 0;
SKIP2 = 0;
MPR1 = 0;
MPR3 = 0;
IPC = 0;
pended = 0;
compFptr = 0;
compRegistered = 0;
lowerDriverReturn = 0;
setEventCalled = 0;
customIrp = 0;
routine = 0;
myStatus = 0;
pirp = 0;
Executive = 0;
Suspended = 5;
KernelMode = 0;
DeviceUsageTypePaging = 1;
#line 1482
pirp = irp;
#line 1483
_BLAST_init();
}
#line 1485
if (status >= 0) {
#line 1486
s = NP;
#line 1487
customIrp = 0;
#line 1488
setEventCalled = customIrp;
#line 1489
lowerDriverReturn = setEventCalled;
#line 1490
compRegistered = lowerDriverReturn;
#line 1491
compFptr = compRegistered;
#line 1492
pended = compFptr;
#line 1493
pirp__IoStatus__Status = 0;
#line 1494
myStatus = 0;
#line 1495
if (irp_choice == 0) {
#line 1496
pirp__IoStatus__Status = -1073741637;
#line 1497
myStatus = -1073741637;
}
{
#line 1502
stub_driver_init();
}
{
#line 1504
#line 1504
if (status < 0) {
#line 1505
return (-1);
}
}
#line 1509
int tmp_ndt_1;
tmp_ndt_1 = __VERIFIER_nondet_int();
if (tmp_ndt_1 == 2) {
goto switch_5_2;
} else {
#line 1512
int tmp_ndt_2;
tmp_ndt_2 = __VERIFIER_nondet_int();
if (tmp_ndt_2 == 3) {
goto switch_5_3;
} else {
#line 1515
int tmp_ndt_3;
tmp_ndt_3 = __VERIFIER_nondet_int();
if (tmp_ndt_3 == 4) {
goto switch_5_4;
} else {
goto switch_5_default;
#line 1520
if (0) {
switch_5_2:
{
#line 1523
status = CdAudioDeviceControl(devobj, pirp);
}
goto switch_5_break;
switch_5_3:
{
#line 1528
status = CdAudioPnp(devobj, pirp);
}
goto switch_5_break;
switch_5_4:
{
#line 1533
status = CdAudioPower(devobj, pirp);
}
goto switch_5_break;
switch_5_default: ;
#line 1537
return (-1);
} else {
switch_5_break: ;
}
}
}
}
#line 1545
if (we_should_unload) {
{
#line 1547
CdAudioUnload(d);
}
}
}
#line 1555
if (pended == 1) {
#line 1556
if (s == NP) {
#line 1557
s = NP;
} else {
goto _L___2;
}
} else {
_L___2:
#line 1563
if (pended == 1) {
#line 1564
if (s == MPR3) {
#line 1565
s = MPR3;
} else {
goto _L___1;
}
} else {
_L___1:
#line 1571
if (s != UNLOADED) {
#line 1574
if (status != -1) {
#line 1577
if (s != SKIP2) {
#line 1578
if (s != IPC) {
#line 1579
if (s != DC) {
{
#line 1581
errorFn();
}
} else {
goto _L___0;
}
} else {
goto _L___0;
}
} else {
_L___0:
#line 1591
if (pended != 1) {
#line 1594
if (s == DC) {
#line 1595
if (status == 259) {
errorFn();
}
} else {
#line 1603
if (status != lowerDriverReturn) {
errorFn();
}
}
}
else {
if (status != 259) {
{
errorFn();
}
} else {
}
}
}
}
}
}
}
#line 1617
return (status);
}
}
#line 1620 "cdaudio_simpl1.cil.c"
void stubMoreProcessingRequired(void)
{
{
#line 1624
if (s == NP) {
#line 1625
s = MPR1;
} else {
{
#line 1628
errorFn();
}
}
#line 1631
return;
}
}
#line 1634 "cdaudio_simpl1.cil.c"
int IofCallDriver(int DeviceObject , int Irp )
{ int Irp__PendingReturned = __VERIFIER_nondet_int() ;
int returnVal2 ;
int compRetStatus ;
int lcontext = __VERIFIER_nondet_int() ;
unsigned long __cil_tmp8 ;
{
#line 1642
if (compRegistered) {
#line 1643
if (routine == 0) {
{
#line 1645
compRetStatus = HPCdrCompletion(DeviceObject, Irp, lcontext);
}
} else {
#line 1648
if (routine == 1) {
{
#line 1650
compRetStatus = CdAudioSignalCompletion(DeviceObject, Irp, lcontext);
}
}
}
{
#line 1656
__cil_tmp8 = (unsigned long )compRetStatus;
#line 1656
if (__cil_tmp8 == -1073741802) {
{
#line 1658
stubMoreProcessingRequired();
}
}
}
}
#line 1666
if (Irp__PendingReturned) {
#line 1667
returnVal2 = 259;
} else {
#line 1669
int tmp_ndt_4;
tmp_ndt_4 = __VERIFIER_nondet_int();
if (tmp_ndt_4 == 0) {
goto switch_6_0;
} else {
#line 1672
int tmp_ndt_5;
tmp_ndt_5 = __VERIFIER_nondet_int();
if (tmp_ndt_5 == 1) {
goto switch_6_1;
} else {
goto switch_6_default;
#line 1677
if (0) {
switch_6_0:
#line 1679
returnVal2 = 0;
goto switch_6_break;
switch_6_1:
#line 1682
returnVal2 = -1073741823;
goto switch_6_break;
switch_6_default:
#line 1685
returnVal2 = 259;
goto switch_6_break;
} else {
switch_6_break: ;
}
}
}
}
#line 1694
if (s == NP) {
#line 1695
s = IPC;
#line 1696
lowerDriverReturn = returnVal2;
} else {
#line 1698
if (s == MPR1) {
#line 1699
if (returnVal2 == 259) {
#line 1700
s = MPR3;
#line 1701
lowerDriverReturn = returnVal2;
} else {
#line 1703
s = NP;
#line 1704
lowerDriverReturn = returnVal2;
}
} else {
#line 1707
if (s == SKIP1) {
#line 1708
s = SKIP2;
#line 1709
lowerDriverReturn = returnVal2;
} else {
{
#line 1712
errorFn();
}
}
}
}
#line 1717
return (returnVal2);
}
}
#line 1720 "cdaudio_simpl1.cil.c"
void IofCompleteRequest(int Irp , int PriorityBoost )
{
{
#line 1724
if (s == NP) {
#line 1725
s = DC;
} else {
{
#line 1728
errorFn();
}
}
#line 1731
return;
}
}
#line 1734 "cdaudio_simpl1.cil.c"
int KeSetEvent(int Event , int Increment , int Wait )
{ int l = __VERIFIER_nondet_int() ;
{
#line 1738
setEventCalled = 1;
#line 1739
return (l);
}
}
#line 1742 "cdaudio_simpl1.cil.c"
int KeWaitForSingleObject(int Object , int WaitReason , int WaitMode , int Alertable ,
int Timeout )
{
{
#line 1747
if (s == MPR3) {
#line 1748
if (setEventCalled == 1) {
#line 1749
s = NP;
#line 1750
setEventCalled = 0;
} else {
goto _L;
}
} else {
_L:
#line 1756
if (customIrp == 1) {
#line 1757
s = NP;
#line 1758
customIrp = 0;
} else {
#line 1760
if (s == MPR3) {
{
#line 1762
errorFn();
}
}
}
}
#line 1769
int tmp_ndt_6;
tmp_ndt_6 = __VERIFIER_nondet_int();
if (tmp_ndt_6 == 0) {
goto switch_7_0;
} else {
goto switch_7_default;
#line 1774
if (0) {
switch_7_0: ;
#line 1776
return (0);
switch_7_default: ;
#line 1778
return (-1073741823);
} else {
}
}
}
}
#line 1786 "cdaudio_simpl1.cil.c"
int PoCallDriver(int DeviceObject , int Irp )
{
int compRetStatus ;
int returnVal ;
int lcontext = __VERIFIER_nondet_int() ;
unsigned long __cil_tmp7 ;
long __cil_tmp8 ;
{
#line 1793
if (compRegistered) {
#line 1794
if (routine == 0) {
{
#line 1796
compRetStatus = HPCdrCompletion(DeviceObject, Irp, lcontext);
}
} else {
#line 1799
if (routine == 1) {
{
#line 1801
compRetStatus = CdAudioSignalCompletion(DeviceObject, Irp, lcontext);
}
}
}
{
#line 1807
__cil_tmp7 = (unsigned long )compRetStatus;
#line 1807
if (__cil_tmp7 == -1073741802) {
{
#line 1809
stubMoreProcessingRequired();
}
}
}
}
#line 1817
int tmp_ndt_7;
tmp_ndt_7 = __VERIFIER_nondet_int();
if (tmp_ndt_7 == 0) {
goto switch_8_0;
} else {
#line 1820
int tmp_ndt_8;
tmp_ndt_8 = __VERIFIER_nondet_int();
if (tmp_ndt_8 == 1) {
goto switch_8_1;
} else {
goto switch_8_default;
#line 1825
if (0) {
switch_8_0:
#line 1827
returnVal = 0;
goto switch_8_break;
switch_8_1:
#line 1830
returnVal = -1073741823;
goto switch_8_break;
switch_8_default:
#line 1833
returnVal = 259;
goto switch_8_break;
} else {
switch_8_break: ;
}
}
}
#line 1841
if (s == NP) {
#line 1842
s = IPC;
#line 1843
lowerDriverReturn = returnVal;
} else {
#line 1845
if (s == MPR1) {
{
#line 1846
__cil_tmp8 = (long )returnVal;
#line 1846
if (__cil_tmp8 == 259L) {
#line 1847
s = MPR3;
#line 1848
lowerDriverReturn = returnVal;
} else {
#line 1850
s = NP;
#line 1851
lowerDriverReturn = returnVal;
}
}
} else {
#line 1854
if (s == SKIP1) {
#line 1855
s = SKIP2;
#line 1856
lowerDriverReturn = returnVal;
} else {
{
#line 1859
errorFn();
}
}
}
}
#line 1864
return (returnVal);
}
}
#line 1867 "cdaudio_simpl1.cil.c"
int ZwClose(int Handle )
{
{
#line 1871
int tmp_ndt_9;
tmp_ndt_9 = __VERIFIER_nondet_int();
if (tmp_ndt_9 == 0) {
goto switch_9_0;
} else {
goto switch_9_default;
#line 1876
if (0) {
switch_9_0: ;
#line 1878
return (0);
switch_9_default: ;
#line 1880
return (-1073741823);
} else {
}
}
}
}
|
the_stack_data/220455146.c
|
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
ElementType Data;
BinTree Left;
BinTree Right;
};
void PreorderTraversal( BinTree BT ); /* 先序遍历，由裁判实现，细节不表 */
void InorderTraversal( BinTree BT ); /* 中序遍历，由裁判实现，细节不表 */
BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );
int main()
{
BinTree BST, MinP, MaxP, Tmp;
ElementType X;
int N, i;
BST = NULL;
scanf("%d", &N);
for ( i=0; i<N; i++ ) {
scanf("%d", &X);
BST = Insert(BST, X);
}
printf("Preorder:"); PreorderTraversal(BST); printf("\n");
MinP = FindMin(BST);
MaxP = FindMax(BST);
scanf("%d", &N);
for( i=0; i<N; i++ ) {
scanf("%d", &X);
Tmp = Find(BST, X);
if (Tmp == NULL) printf("%d is not found\n", X);
else {
printf("%d is found\n", Tmp->Data);
if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
}
}
scanf("%d", &N);
for( i=0; i<N; i++ ) {
scanf("%d", &X);
BST = Delete(BST, X);
}
printf("Inorder:"); InorderTraversal(BST); printf("\n");
return 0;
}
/* 你的代码将被嵌在这里 */
void PreorderTraversal( BinTree BT )
{
if(BT==NULL) return;
else{
printf(" %d",BT->Data);
PreorderTraversal(BT->Left);
PreorderTraversal(BT->Right);
}
}
void InorderTraversal( BinTree BT )
{
if(BT==NULL) return;
else{
InorderTraversal(BT->Left);
printf(" %d",BT->Data);
InorderTraversal(BT->Right);
}
}
BinTree Insert( BinTree BST, ElementType X )
{
if(!BST)//如果BST为空的话，返回只有一个节点的树
{
BST=(BinTree)malloc(sizeof(struct TNode));
BST->Data=X;
BST->Left=NULL;
BST->Right=NULL;
}
else//如果BST不是为空的话
{//开始寻找要插入的位置
if(X<BST->Data)
BST->Left=Insert(BST->Left,X);
else if(X>BST ->Data)
BST->Right=Insert(BST->Right,X);
}
return BST;
}
BinTree Delete( BinTree BST, ElementType X )
{
BinTree Tmp;
if(!BST) printf("Not Found\n");
else{
if(X<BST->Data)
BST->Left=Delete(BST->Left,X);
else if(X>BST->Data)
{
BST->Right=Delete(BST->Right,X);
}
else//考虑如果找到这个位置，并且有左节点或者右节点或者没有节点三种情况
{
if(BST->Left && BST->Right) {
Tmp=FindMin(BST->Right); /* 在右子树中找到最小结点填充删除结点 */
BST->Data = Tmp ->Data;
BST->Right=Delete(BST->Right,BST->Data);/* 递归删除要删除结点的右子树中最小元素 */
}
else
{ /* 被删除结点有一个或没有子结点*/
Tmp = BST;
if(!BST->Left) BST = BST->Right; /*有右孩子或者没孩子*/
else if(!BST->Right) BST = BST->Left;/*有左孩子，一定要加else，不然BST可能是NULL，会段错误*/
free(Tmp); /*如无左右孩子直接删除*/
}
}
}
return BST;
}
Position Find( BinTree BST, ElementType X )
{
if(!BST) return NULL;
if(BST->Data==X) return BST;
else if(X<BST->Data) {
return Find(BST->Left,X);
}
else if(X>BST->Data)
{
return Find(BST->Right,X);
}
return BST;
}
Position FindMin( BinTree BST )
{
if(BST!=NULL)
{
while(BST->Left)
BST=BST->Left;
}
return BST;
}
Position FindMax( BinTree BST )
{
if(BST!=NULL)
{
while(BST->Right)
BST=BST->Right;
}
return BST;
}
|
the_stack_data/95767.c
|
#include <stdio.h>
int main(){
int num, i, largest, smallest, n;
smallest = 9999;
largest = -9999;
printf("Enter numbers to input: ");
scanf("%d", &n);
for(i=1;i<=n;i++){
printf("\nEnter the number: ");
scanf("%d", &num);
if(num < smallest){
smallest = num;
}else if(num > largest){
largest = num;
}
}
printf("\nSmallest : %d", smallest);
printf("\nLargest : %d", largest);
return 0;
}
|
the_stack_data/150140987.c
|
// Copyright 2009 Free Software Foundation, Inc.
// Written by Rafael Avila de Espindola <[email protected]>
// This file is part of gold.
// 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, write to the Free Software
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
// MA 02110-1301, USA.
int b = 1;
extern int t1(int);
int main(void) {
if (t1(b) != 0)
return 1;
return 0;
}
|
the_stack_data/68888263.c
|
#include <sys/types.h> /* UNIX types POSIX */
#include <sys/uio.h> /* BSD I/O BSD */
#include <stdio.h> /* I/O lib C89 */
#include <errno.h> /* error stf POSIX */
#include <stdlib.h> /* Standard Lib C89 */
#include <unistd.h> /* UNIX std stf POSIX */
#include <fcntl.h> /* UNIX file ctrl UNIX */
#include <sys/mman.h> /* mmap() POSIX */
#include <sys/stat.h> /* UNIX stat POSIX */
int main(int argc, char *argv[])
{
int FD;
char *fileName = "T:mmapFile.tmp";
char *fileData;
/* ------------------------------------------------------------------------------------------------------------------------------ */
/* First we must make a file with some data in it...*/
/* Open our test file (wack it if it already exists). */
if ((FD = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO)) < 0)
{
printf("ERROR: Could not open file (for write only).\n");
exit(1);
} /* end if */
/* Note we write the \0 too. */
if (write(FD, "0123456789abcdef", 17) < 0)
{
printf("ERROR: Could not write to file.\n");
exit(1);
} /* end if */
/* Close the test file. */
if (close(FD) < 0)
{
printf("ERROR: Could not close the file\n");
exit(1);
} /* end if */
/* ------------------------------------------------------------------------------------------------------------------------------ */
/* Now we have a test file to play with (/tmp/mmapFile.tmp). Let's
access it with mmap(). */
/* First we have to open the file! */
if ((FD = open(fileName, O_RDWR)) < 0)
{
printf("ERROR(%d): Could not open file (for read/write).\n", errno);
exit(1);
} /* end if */
/* Now we must map the thing into our memory space. A size is required, so use stat() first to figure out how long a file is if
you don't already know. Note: It is VERY important that the file length NOT change while it is mmap'ed.*/
fileData = (char *)mmap(NULL, // Almost always not used
17, // Length of the mapped space
PROT_READ | PROT_WRITE, // Access type
MAP_SHARED, // Write changes to device (see: MAP_PRIVATE)
FD, // FD of the file to map
0); // Offset into file.
/* Checking for an error with mmap is strange. Instead of returning NULL, which any God fearing, pointer returning function
should do upon error, it returns MAP_FAILED. On many platforms, this is 0 or -1, but on some it is an address that is simply
invalid for the current program... */
if (fileData == MAP_FAILED)
{
/* Some of the following are only listed for completeness as they can not happen in this case... */
switch (errno)
{
case EACCES:
printf("mmap failed: The FD was not open for read, or for write with (PROT_WRITE or MAP_SHARED)\n");
break;
case EAGAIN:
printf("mmap failed: The mapping could not be locked in memory\n");
break;
case EBADF:
printf("mmap failed: The FD not a valid open file descriptor.\n");
break;
case EINVAL:
printf("mmap failed: The value of len is zero, addr is not valid, bad combination of args\n");
break;
case EMFILE:
printf("mmap failed: The too many regions mapped already\n");
break;
case ENODEV:
printf("mmap failed: The FD file type is not supported by mmap().\n");
break;
case ENOMEM:
printf("mmap failed: Not enough memory\n");
break;
case ENOTSUP:
printf("mmap failed: Options not supported on this platform\n");
break;
case ENXIO:
printf("mmap failed: Range [off,off+len) are invalid for the FD, MAP_FIXED & invalid addresses, or FD not accessible\n");
break;
case EOVERFLOW:
printf("mmap failed: File is too big!\n");
break;
default:
printf("mmap failed: Duno why! (errno: %d)\n", errno);
break;
} /* end switch */
exit(1);
} /* end if */
/* ------------------------------------------------------------------------------------------------------------------------------ */
/* Now we can use the fileData pointer just like any other pointer! */
/* We put the \0 in the file, so we can use the file content as a string! */
printf("File content: '%s'\n", fileData);
/* fileData is just a pointer.. */
printf("The 4th char of the file is: %c\n", fileData[3]);
/* ------------------------------------------------------------------------------------------------------------------------------ */
/* We are done with the map, so we can unmap it and close the file now. */
/* Unmap the file now. */
if (munmap(fileData, 17) < 0)
{
switch (errno)
{
case EINVAL:
printf("munmap failed: The address range [addr,addr+len) is invalid.\n"
" munmap failed: The len argument is 0.\n"
" munmap failed: The addr argument is not a multiple of page size.\n");
break;
default:
printf("munmap failed: Duno why! (errno %d).\n", errno);
break;
} /* end switch */
exit(1);
} /* end if */
/* Close the test file. */
if (close(FD) < 0)
{
printf("ERROR: Could not close the file\n");
exit(1);
} /* end if */
return 0;
} /* end func main */
|
the_stack_data/6388930.c
|
/*
* wumpus.c --- a faithful translation of the classic "Hunt The Wumpus" game.
*
* Translator: Eric S. Raymond <[email protected]>
* Version: $Id: wumpus.c,v 1.3 1993/11/07 19:19:27 esr Exp $
*
* This was the state of the art 20 years ago, in 1972. We've come a long
* way, baby.
*
* The BASIC source is that posted by Magnus Olsson in USENET article
* <[email protected]>: he wrote
*
* >Below is the source code for _one_ (rather simple) Wumpus version,
* >which I found in the PC-BLUE collection on SIMTEL20. I believe this is
* >pretty much the same version that was published in David Ahl's "101
* >Basic Computer Games" (or, possibly, in the sequel).
*
* I have staunchly resisted the temptation to "improve" this game. It
* is functionally identical to the BASIC version (source for which
* appears in the comments). I fixed some typos in the help text.
*
* Language hackers may be interested to know that he most difficult thing
* about the translation was tracking the details required to translate from
* 1-origin to 0-origin array indexing.
*
* The only enhancement is a an -s command-line switch for setting the
* random number seed.
*
* So, pretend for a little while that your workstation is an ASR-33 and
* limber up your fingers for a trip to nostalgia-land...
*/
#include <stdio.h>
/* 5 REM *** HUNT THE WUMPUS *** */
/* 10 DIM P(5) */
static int path[5];
static int j, k, arrows, scratchloc;
static char inp[BUFSIZ]; /* common input buffer */
#define YOU 0
#define WUMPUS 1
#define PIT1 2
#define PIT2 3
#define BATS1 4
#define BATS2 5
#define LOCS 6
static int loc[LOCS], save[LOCS]; /* locations */
#define NOT 0
#define WIN 1
#define LOSE -1
static int finished;
/* 80 REM *** SET UP CAVE (DODECAHEDRAL NODE LIST) *** */
/* 85 DIM S(20,3) */
/* 90 FOR J=1 TO 20 */
/* 95 FOR K=1 TO 3 */
/* 100 READ S(J,K) */
/* 105 NEXT K */
/* 110 NEXT J */
/* 115 DATA 2,5,8,1,3,10,2,4,12,3,5,14,1,4,6 */
/* 120 DATA 5,7,15,6,8,17,1,7,9,8,10,18,2,9,11 */
/* 125 DATA 10,12,19,3,11,13,12,14,20,4,13,15,6,14,16 */
/* 130 DATA 15,17,20,7,16,18,9,17,19,11,18,20,13,16,19 */
static int cave[20][3] =
{
{1,4,7},
{0,2,9},
{1,3,11},
{2,4,13},
{0,3,5},
{4,6,14},
{5,7,16},
{0,6,8},
{7,9,17},
{1,8,10},
{9,11,18},
{2,10,12},
{11,13,19},
{3,12,14},
{5,13,15},
{14,16,19},
{6,15,17},
{8,16,18},
{10,17,19},
{12,15,18},
};
/* 135 DEF FNA(X)=INT(20*RND(1))+1 */
#define FNA() (rand() % 20)
/* 140 DEF FNB(X)=INT(3*RND(1))+1 */
#define FNB() (rand() % 3)
/* 145 DEF FNC(X)=INT(4*RND(1))+1 */
#define FNC() (rand() % 4)
int getnum(prompt)
char *prompt;
{
(void) printf("%s\n?", prompt);
(void) fgets(inp, sizeof(inp), stdin);
return(atoi(inp));
}
int getlet(prompt)
char *prompt;
{
(void) printf("%s\n?", prompt);
(void) fgets(inp, sizeof(inp), stdin);
return(inp[0]);
}
void print_instructions()
{
char ebuf[BUFSIZ];
/* 375 REM *** INSTRUCTIONS *** */
/* 380 PRINT "WELCOME TO 'HUNT THE WUMPUS'" */
puts("WELCOME TO 'HUNT THE WUMPUS'");
/* 385 PRINT " THE WUMPUS LIVES IN A CAVE OF 20 ROOMS. EACH ROOM" */
puts(" THE WUMPUS LIVES IN A CAVE OF 20 ROOMS. EACH ROOM");
/* 390 PRINT "HAS 3 TUNNELS LEADING TO OTHER ROOMS. (LOOK AT A" */
puts("HAS 3 TUNNELS LEADING TO OTHER ROOMS. (LOOK AT A");
/* 395 PRINT "DODECAHEDRON TO SEE HOW THIS WORKS-IF YOU DON'T KNOW" */
puts("DODECAHEDRON TO SEE HOW THIS WORKS-IF YOU DON'T KNOW");
/* 400 PRINT "WHAT A DODECAHEDRON IS, ASK SOMEONE)" */
puts("WHAT A DODECAHEDRON IS, ASK SOMEONE)");
/* 405 PRINT */
puts("");
/* 410 PRINT " HAZARDS:" */
puts(" HAZARDS:");
/* 415 PRINT " BOTTOMLESS PITS - TWO ROOMS HAVE BOTTOMLESS PITS IN THEM
*/
puts(" BOTTOMLESS PITS - TWO ROOMS HAVE BOTTOMLESS PITS IN THEM");
/* 420 PRINT " IF YOU GO THERE, YOU FALL INTO THE PIT (& LOSE!)" */
puts(" IF YOU GO THERE, YOU FALL INTO THE PIT (& LOSE!)");
/* 425 PRINT " SUPER BATS - TWO OTHER ROOMS HAVE SUPER BATS. IF YOU" */
puts(" SUPER BATS - TWO OTHER ROOMS HAVE SUPER BATS. IF YOU");
/* 430 PRINT " GO THERE, A BAT GRABS YOU AND TAKES YOU TO SOME OTHER"
*/
puts(" GO THERE, A BAT GRABS YOU AND TAKES YOU TO SOME OTHER");
/* 435 PRINT " ROOM AT RANDOM. (WHICH MAY BE TROUBLESOME)" */
puts(" ROOM AT RANDOM. (WHICH MAY BE TROUBLESOME)");
/* 440 INPUT "TYPE AN E THEN RETURN ";W9 */
(void) getlet("TYPE AN E THEN RETURN ");
/* 445 PRINT " WUMPUS:" */
puts(" WUMPUS:");
/* 450 PRINT " THE WUMPUS IS NOT BOTHERED BY HAZARDS (HE HAS SUCKER" */
puts(" THE WUMPUS IS NOT BOTHERED BY HAZARDS (HE HAS SUCKER");
/* 455 PRINT " FEET AND IS TOO BIG FOR A BAT TO LIFT). USUALLY" */
puts(" FEET AND IS TOO BIG FOR A BAT TO LIFT). USUALLY");
/* 460 PRINT " HE IS ASLEEP. TWO THINGS WAKE HIM UP: YOU SHOOTING AN" */
puts(" HE IS ASLEEP. TWO THINGS WAKE HIM UP: YOU SHOOTING AN");
/* 465 PRINT "ARROW OR YOU ENTERING HIS ROOM." */
puts("ARROW OR YOU ENTERING HIS ROOM.");
/* 470 PRINT " IF THE WUMPUS WAKES HE MOVES (P=.75) ONE ROOM" */
puts(" IF THE WUMPUS WAKES HE MOVES (P=.75) ONE ROOM");
/* 475 PRINT " OR STAYS STILL (P=.25). AFTER THAT, IF HE IS WHERE YOU"
*/
puts(" OR STAYS STILL (P=.25). AFTER THAT, IF HE IS WHERE YOU");
/* 480 PRINT " ARE, HE EATS YOU UP AND YOU LOSE!" */
puts(" ARE, HE EATS YOU UP AND YOU LOSE!");
/* 485 PRINT */
puts("");
/* 490 PRINT " YOU:" */
puts(" YOU:");
/* 495 PRINT " EACH TURN YOU MAY MOVE OR SHOOT A CROOKED ARROW" */
puts(" EACH TURN YOU MAY MOVE OR SHOOT A CROOKED ARROW");
/* 500 PRINT " MOVING: YOU CAN MOVE ONE ROOM (THRU ONE TUNNEL)" */
puts(" MOVING: YOU CAN MOVE ONE ROOM (THRU ONE TUNNEL)");
/* 505 PRINT " ARROWS: YOU HAVE 5 ARROWS. YOU LOSE WHEN YOU RUN OUT
*/
puts(" ARROWS: YOU HAVE 5 ARROWS. YOU LOSE WHEN YOU RUN OUT");
/* 510 PRINT " EACH ARROW CAN GO FROM 1 TO 5 ROOMS. YOU AIM BY TELLING*/
puts(" EACH ARROW CAN GO FROM 1 TO 5 ROOMS. YOU AIM BY TELLING");
/* 515 PRINT " THE COMPUTER THE ROOM#S YOU WANT THE ARROW TO GO TO." */
puts(" THE COMPUTER THE ROOM#S YOU WANT THE ARROW TO GO TO.");
/* 520 PRINT " IF THE ARROW CAN'T GO THAT WAY (IF NO TUNNEL) IT MOVES"*/
puts(" IF THE ARROW CAN'T GO THAT WAY (IF NO TUNNEL) IT MOVES");
/* 525 PRINT " AT RANDOM TO THE NEXT ROOM." */
puts(" AT RANDOM TO THE NEXT ROOM.");
/* 530 PRINT " IF THE ARROW HITS THE WUMPUS, YOU WIN." */
puts(" IF THE ARROW HITS THE WUMPUS, YOU WIN.");
/* 535 PRINT " IF THE ARROW HITS YOU, YOU LOSE." */
puts(" IF THE ARROW HITS YOU, YOU LOSE.");
/* 540 INPUT "TYPE AN E THEN RETURN ";W9 */
(void) getlet("TYPE AN E THEN RETURN ");
/* 545 PRINT " WARNINGS:" */
puts(" WARNINGS:");
/* 550 PRINT " WHEN YOU ARE ONE ROOM AWAY FROM A WUMPUS OR HAZARD,"
*/
puts(" WHEN YOU ARE ONE ROOM AWAY FROM A WUMPUS OR HAZARD,");
/* 555 PRINT " THE COMPUTER SAYS:" */
puts(" THE COMPUTER SAYS:");
/* 560 PRINT " WUMPUS: 'I SMELL A WUMPUS'" */
puts(" WUMPUS: 'I SMELL A WUMPUS'");
/* 565 PRINT " BAT : 'BATS NEARBY'" */
puts(" BAT : 'BATS NEARBY'");
/* 570 PRINT " PIT : 'I FEEL A DRAFT'" */
puts(" PIT : 'I FEEL A DRAFT'");
/* 575 PRINT */
puts("");
/* 580 RETURN */
}
void check_hazards()
{
/* 585 REM *** PRINT LOCATION & HAZARD WARNINGS *** */
/* 590 PRINT */
(void) puts("");
/* 595 FOR J=2 TO 6 */
/* 600 FOR K=1 TO 3 */
/* 605 IF S(L(1),K)<>L(J) THEN 640 */
/* 610 ON J-1 GOTO 615,625,625,635,635 */
/* 615 PRINT "I SMELL A WUMPUS!" */
/* 620 GOTO 640 */
/* 625 PRINT "I FEEL A DRAFT" */
/* 630 GOTO 640 */
/* 635 PRINT "BATS NEARBY!" */
/* 640 NEXT K */
/* 645 NEXT J */
for (k = 0; k < 3; k++)
{
int room = cave[loc[YOU]][k];
if (room == loc[WUMPUS])
(void) puts("I SMELL A WUMPUS!");
else if (room == loc[PIT1] || room == loc[PIT2])
(void) puts("I FEEL A DRAFT");
else if (room == loc[BATS1] || room == loc[BATS2])
(void) puts("BATS NEARBY!");
}
/* 650 PRINT "YOU ARE IN ROOM "L(1) */
(void) printf("YOU ARE IN ROOM %d\n", loc[YOU]+1);
/* 655 PRINT "TUNNELS LEAD TO "S(L,1);S(L,2);S(L,3) */
(void) printf("TUNNELS LEAD TO %d %d %d\n",
cave[loc[YOU]][0]+1, cave[loc[YOU]][1]+1, cave[loc[YOU]][2]+1);
/* 660 PRINT */
(void) puts("");
/* 665 RETURN */
}
int move_or_shoot()
{
int c;
/* 670 REM *** CHOOSE OPTION *** */
badin:
/* 675 PRINT "SHOOT OR MOVE (S-M)"; */
/* 680 INPUT I$ */
c = getlet("SHOOT OR MOVE (S-M)");
/* 685 IF I$<>"S" THEN 700 */
/* 690 O=1 */
/* 695 RETURN */
/* 700 IF I$<>"M" THEN 675 */
/* 705 O=2 */
/* 710 RETURN */
if (c == 'S')
return(1);
else if (c == 'M')
return(0);
else
goto badin;
}
void shoot()
{
extern void check_shot(), move_wumpus();
int j9;
/* 715 REM *** ARROW ROUTINE *** */
/* 720 F=0 */
finished = NOT;
/* 725 REM *** PATH OF ARROW *** */
badrange:
/* 735 PRINT "NO. OF ROOMS (1-5)"; */
/* 740 INPUT J9 */
j9 = getnum("NO. OF ROOMS (1-5)");
/* 745 IF J9<1 THEN 735 */
/* 750 IF J9>5 THEN 735 */
if (j9 < 1 || j9 > 5)
goto badrange;
/* 755 FOR K=1 TO J9 */
for (k = 0; k < j9; k++)
{
/* 760 PRINT "ROOM #"; */
/* 765 INPUT P(K) */
path[k] = getnum("ROOM #") - 1;
/* 770 IF K<=2 THEN 790 */
if (k <= 1)
continue;
/* 775 IF P(K)<>P(K-2) THEN 790 */
if (path[k] != path[k - 2])
continue;
/* 780 PRINT "ARROWS AREN'T THAT CROOKED - TRY ANOTHER ROOM" */
(void) puts("ARROWS AREN'T THAT CROOKED - TRY ANOTHER ROOM");
/* 785 GOTO 760 */
k--;
/* 790 NEXT K */
}
/* 795 REM *** SHOOT ARROW *** */
/* 800 L=L(1) */
scratchloc = loc[YOU];
/* 805 FOR K=1 TO J9 */
for (k = 0; k < j9; k++)
{
int k1;
/* 810 FOR K1=1 TO 3 */
for (k1 = 0; k1 < 3; k1++)
{
/* 815 IF S(L,K1)=P(K) THEN 895 */
if (cave[scratchloc][k1] == path[k])
{
/*
* This is the only bit of the translation I'm not sure
* about. It requires the trajectory of the arrow to
* be a path. Without it, all rooms on the trajectory
* would be required by the above to be adjacent to the
* player, making for a trivial game --- just move to where
* you smell a wumpus and shoot into all adjacent passages!
* However, I can't find an equivalent in the BASIC.
*/
scratchloc = path[k];
/* this simulates logic at 895 in the BASIC code */
check_shot();
if (finished != NOT)
return;
}
/* 820 NEXT K1 */
}
/* 825 REM *** NO TUNNEL FOR ARROW *** */
/* 830 L=S(L,FNB(1)) */
scratchloc = cave[scratchloc][FNB()];
/* 835 GOTO 900 */
check_shot();
/* 840 NEXT K */
}
ammo:
if (finished == NOT)
{
/* 845 PRINT "MISSED" */
(void) puts("MISSED");
/* 850 L=L(1) */
scratchloc = loc[YOU];
/* 855 REM *** MOVE WUMPUS *** */
/* 860 GOSUB 935 */
move_wumpus();
/* 865 REM *** AMMO CHECK *** */
/* 870 A=A-1 */
/* 875 IF A>0 THEN 885 */
/* 880 F=-1 */
if (--arrows <= 0)
finished = LOSE;
}
/* 885 RETURN */
}
void check_shot()
{
/* 890 REM *** SEE IF ARROW IS AT L(1) OR AT L(2) */
/* 895 L=P(K) */
/* 900 IF L<>L(2) THEN 920 */
/* 905 PRINT "AHA! YOU GOT THE WUMPUS!" */
/* 910 F=1 */
/* 915 RETURN */
if (scratchloc == loc[WUMPUS])
{
(void) puts("AHA! YOU GOT THE WUMPUS!");
finished = WIN;
}
/* 920 IF L<>L(1) THEN 840 */
/* 925 PRINT "OUCH! ARROW GOT YOU!" */
/* 930 GOTO 880 */
else if (scratchloc == loc[YOU])
{
(void) puts("OUCH! ARROW GOT YOU!");
finished = LOSE;
}
}
void move_wumpus()
{
/* 935 REM *** MOVE WUMPUS ROUTINE *** */
/* 940 K=FNC(0) */
k = FNC();
/* 945 IF K=4 THEN 955 */
/* 950 L(2)=S(L(2),K) */
if (k < 3)
loc[WUMPUS] = cave[loc[WUMPUS]][k];
/* 955 IF L(2)<>L THEN 970 */
if (loc[WUMPUS] != loc[YOU])
return;
/* 960 PRINT "TSK TSK TSK - WUMPUS GOT YOU!" */
(void) puts("TSK TSK TSK - WUMPUS GOT YOU!");
/* 965 F=-1 */
finished = LOSE;
/* 970 RETURN */
}
void move()
{
/* 975 REM *** MOVE ROUTINE *** */
/* 980 F=0 */
finished = NOT;
badmove:
/* 985 PRINT "WHERE TO"; */
/* 990 INPUT L */
scratchloc = getnum("WHERE TO");
/* 995 IF L<1 THEN 985 */
/* 1000 IF L>20 THEN 985 */
if (scratchloc < 1 || scratchloc > 20)
goto badmove;
scratchloc--;
/* 1005 FOR K=1 TO 3 */
for (k = 0; k < 3; k++)
{
/* 1010 REM *** CHECK IF LEGAL MOVE *** */
/* 1015 IF S(L(1),K)=L THEN 1045 */
if (cave[loc[YOU]][k] == scratchloc)
goto goodmove;
/* 1020 NEXT K */
}
/* 1025 IF L=L(1) THEN 1045 */
if (scratchloc != loc[YOU])
{
/* 1030 PRINT "NOT POSSIBLE -"; */
(void) puts("NOT POSSIBLE -");
/* 1035 GOTO 985 */
goto badmove;
}
goodmove:
/* 1040 REM *** CHECK FOR HAZARDS *** */
/* 1045 L(1)=L */
loc[YOU] = scratchloc;
if (scratchloc == loc[WUMPUS])
{
/* 1050 REM *** WUMPUS *** */
/* 1055 IF L<>L(2) THEN 1090 */
/* 1060 PRINT "... OOPS! BUMPED A WUMPUS!" */
/* 1065 REM *** MOVE WUMPUS *** */
/* 1070 GOSUB 940 */
/* 1075 IF F=0 THEN 1090 */
/* 1080 RETURN */
(void) puts("... OOPS! BUMPED A WUMPUS!");
move_wumpus();
}
else if (scratchloc == loc[PIT1] || scratchloc == loc[PIT2])
{
/* 1085 REM *** PIT *** */
/* 1090 IF L=L(3) THEN 1100 */
/* 1095 IF L<>L(4) THEN 1120 */
/* 1100 PRINT "YYYYIIIIEEEE . . . FELL IN PIT" */
/* 1105 F=-1 */
/* 1110 RETURN */
(void) puts("YYYYIIIIEEEE . . . FELL IN PIT");
finished = LOSE;
}
else if (scratchloc == loc[BATS1] || scratchloc == loc[BATS2])
{
/* 1115 REM *** BATS *** */
/* 1120 IF L=L(5) THEN 1130 */
/* 1125 IF L<>L(6) THEN 1145 */
/* 1130 PRINT "ZAP--SUPER BAT SNATCH! ELSEWHEREVILLE FOR YOU!" */
/* 1135 L=FNA(1) */
/* 1140 GOTO 1045 */
/* 1145 RETURN */
/* 1150 END */
(void) puts("ZAP--SUPER BAT SNATCH! ELSEWHEREVILLE FOR YOU!");
scratchloc = loc[YOU] = FNA();
goto goodmove;
}
}
main(argc, argv)
int argc;
char *argv[];
{
int c;
if (argc >= 2 && strcmp(argv[1], "-s") == 0)
srand(atoi(argv[2]));
else
srand((int)time((long *) 0));
/* 15 PRINT "INSTRUCTIONS (Y-N)"; */
/* 20 INPUT I$ */
c = getlet("INSTRUCTIONS (Y-N)");
/* 25 IF I$="N" THEN 35 */
/* 30 GOSUB 375 */
/* 35 GOTO 80 */
if (c == 'Y')
print_instructions();
/* 150 REM *** LOCATE L ARRAY ITEMS *** */
/* 155 REM *** 1-YOU, 2-WUMPUS, 3&4-PITS, 5&6-BATS *** */
/* 160 DIM L(6) */
/* 165 DIM M(6) */
badlocs:
/* 170 FOR J=1 TO 6 */
/* 175 L(J)=FNA(0) */
/* 180 M(J)=L(J) */
/* 185 NEXT J */
for (j = 0; j < LOCS; j++)
loc[j] = save[j] = FNA();
/* 190 REM *** CHECK FOR CROSSOVERS (IE L(1)=L(2), ETC) *** */
/* 195 FOR J=1 TO 6 */
/* 200 FOR K=1 TO 6 */
/* 205 IF J=K THEN 215 */
/* 210 IF L(J)=L(K) THEN 170 */
/* 215 NEXT K */
/* 220 NEXT J */
for (j = 0; j < LOCS; j++)
for (k = 0; k < LOCS; k++)
if (j == k)
continue;
else if (loc[j] == loc[k])
goto badlocs;
/* 225 REM *** SET NO. OF ARROWS *** */
newgame:
/* 230 A=5 */
/* 235 L=L(1) */
arrows = 5;
scratchloc = loc[YOU];
/* 240 REM *** RUN THE GAME *** */
/* 245 PRINT "HUNT THE WUMPUS" */
(void) puts("HUNT THE WUMPUS");
#ifdef DEBUG
(void) printf("Wumpus is at %d, pits at %d & %d, bats at %d & %d\n",
loc[WUMPUS]+1,
loc[PIT1]+1, loc[PIT2]+1,
loc[BATS1]+1, loc[BATS2]+1);
#endif
nextmove:
/* 250 REM *** HAZARD WARNING AND LOCATION *** */
/* 255 GOSUB 585 */
check_hazards();
/* 260 REM *** MOVE OR SHOOT *** */
/* 265 GOSUB 670 */
/* 270 ON O GOTO 280,300 */
if (move_or_shoot())
{
/* 275 REM *** SHOOT *** */
/* 280 GOSUB 715 */
shoot();
/* 285 IF F=0 THEN 255 */
if (finished == NOT)
goto nextmove;
/* 290 GOTO 310 */
}
else
{
/* 295 REM *** MOVE *** */
/* 300 GOSUB 975 */
move();
/* 305 IF F=0 THEN 255 */
if (finished == NOT)
goto nextmove;
}
/* 310 IF F>0 THEN 335 */
if (finished == LOSE)
{
/* 315 REM *** LOSE *** */
/* 320 PRINT "HA HA HA - YOU LOSE!" */
/* 325 GOTO 340 */
(void) puts("HA HA HA - YOU LOSE!");
}
else
{
/* 330 REM *** WIN *** */
/* 335 PRINT "HEE HEE HEE - THE WUMPUS'LL GET YOU NEXT TIME!!" */
(void) puts("HEE HEE HEE - THE WUMPUS'LL GET YOU NEXT TIME!!");
}
/* 340 FOR J=1 TO 6 */
/* 345 L(J)=M(J) */
/* 350 NEXT J */
for (j = YOU; j < LOCS; j++)
loc[j] = save[j];
/* 355 PRINT "SAME SETUP (Y-N)"; */
/* 360 INPUT I$ */
c = getlet("SAME SETUP (Y-N)");
/* 365 IF I$<>"Y"THEN 170 */
/* 370 GOTO 230 */
if (c != 'Y')
goto badlocs;
else
goto newgame;
}
/* wumpus.c ends here */
|
the_stack_data/52567.c
|
/*
** EPITECH PROJECT, 2017
** tetris
** File description:
** my_memset
*/
void my_memset(char *str, char c)
{
for (unsigned int i = 0; i < sizeof(str); i++)
str[i] = c;
}
|
the_stack_data/75221.c
|
/** @file patest_clip.c
@ingroup test_src
@brief Play a sine wave for several seconds at an amplitude
that would require clipping.
@author Phil Burk http://www.softsynth.com
*/
/*
* $Id$
*
* This program uses the PortAudio Portable Audio Library.
* For more information see: http://www.portaudio.com
* Copyright (c) 1999-2000 Ross Bencina and Phil Burk
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/*
* The text above constitutes the entire PortAudio license; however,
* the PortAudio community also makes the following non-binding requests:
*
* Any person wishing to distribute modifications to the Software is
* requested to send the modifications to the original developer so that
* they can be incorporated into the canonical version. It is also
* requested that these non-binding requests be included along with the
* license above.
*/
#include <stdio.h>
#include <math.h>
#include "portaudio.h"
#define NUM_SECONDS (4)
#define SAMPLE_RATE (44100)
#ifndef M_PI
#define M_PI (3.14159265)
#endif
#define TABLE_SIZE (200)
typedef struct paTestData
{
float sine[TABLE_SIZE];
float amplitude;
int left_phase;
int right_phase;
}
paTestData;
PaError PlaySine( paTestData *data, unsigned long flags, float amplitude );
/* This routine will be called by the PortAudio engine when audio is needed.
** It may called at interrupt level on some machines so don't do anything
** that could mess up the system like calling malloc() or free().
*/
static int sineCallback( const void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData )
{
paTestData *data = (paTestData*)userData;
float *out = (float*)outputBuffer;
float amplitude = data->amplitude;
unsigned int i;
(void) inputBuffer; /* Prevent "unused variable" warnings. */
(void) timeInfo;
(void) statusFlags;
for( i=0; i<framesPerBuffer; i++ )
{
*out++ = amplitude * data->sine[data->left_phase]; /* left */
*out++ = amplitude * data->sine[data->right_phase]; /* right */
data->left_phase += 1;
if( data->left_phase >= TABLE_SIZE ) data->left_phase -= TABLE_SIZE;
data->right_phase += 3; /* higher pitch so we can distinguish left and right. */
if( data->right_phase >= TABLE_SIZE ) data->right_phase -= TABLE_SIZE;
}
return 0;
}
/*******************************************************************/
int main(void);
int main(void)
{
PaError err;
paTestData data;
int i;
printf("PortAudio Test: output sine wave with and without clipping.\n");
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
printf("\nHalf amplitude. Should sound like sine wave.\n"); fflush(stdout);
err = PlaySine( &data, paClipOff | paDitherOff, 0.5f );
if( err < 0 ) goto error;
printf("\nFull amplitude. Should sound like sine wave.\n"); fflush(stdout);
err = PlaySine( &data, paClipOff | paDitherOff, 0.999f );
if( err < 0 ) goto error;
printf("\nOver range with clipping and dithering turned OFF. Should sound very nasty.\n");
fflush(stdout);
err = PlaySine( &data, paClipOff | paDitherOff, 1.1f );
if( err < 0 ) goto error;
printf("\nOver range with clipping and dithering turned ON. Should sound smoother than previous.\n");
fflush(stdout);
err = PlaySine( &data, paNoFlag, 1.1f );
if( err < 0 ) goto error;
printf("\nOver range with paClipOff but dithering ON.\n"
"That forces clipping ON so it should sound the same as previous.\n");
fflush(stdout);
err = PlaySine( &data, paClipOff, 1.1f );
if( err < 0 ) goto error;
return 0;
error:
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return 1;
}
/*****************************************************************************/
PaError PlaySine( paTestData *data, unsigned long flags, float amplitude )
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
data->left_phase = data->right_phase = 0;
data->amplitude = amplitude;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
1024,
flags,
sineCallback,
data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
Pa_Sleep( NUM_SECONDS * 1000 );
printf("CPULoad = %8.6f\n", Pa_GetStreamCpuLoad( stream ) );
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
return paNoError;
error:
return err;
}
|
the_stack_data/179831364.c
|
//******************************************************************************
//
// string.c
//
// String library for StarkOS.
//
// Copyright (c) 2016 Brandon To
// This code is licensed under BSD license (see LICENSE.txt for details)
//
// Created:
// March 27, 2016
//
//******************************************************************************
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n)
{
size_t i = 0;
while (i<n)
{
*((char*)dest+i) = *((const char*)src+i);
i++;
}
return dest;
}
void *memset(void *str, int c, size_t n)
{
size_t i = 0;
while (i<n)
{
*((char*)str+i++) = (char)(c);
}
return str;
}
size_t strlen(const char *str)
{
size_t len = 0;
while (*(str+len) != '\0')
{
len++;
}
return len;
}
|
the_stack_data/218894035.c
|
/*-
* %sccs.include.proprietary.c%
*/
#ifndef lint
static char sccsid[] = "@(#)chrtab.c 4.2 (Berkeley) 04/18/91";
#endif /* not lint */
char chrtab[][16] = {
0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, sp, */
0010,0010,0010,0010,0010,0010,0010,0010,0000,0000,0010,0000,0000,0000,0000,0000, /*, !, */
0024,0024,0024,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, ", */
0000,0000,0000,0044,0044,0176,0044,0044,0176,0044,0044,0000,0000,0000,0000,0000, /*, #, */
0000,0010,0010,0010,0076,0101,0100,0076,0001,0101,0076,0010,0010,0000,0000,0000, /*, $, */
0000,0000,0000,0141,0142,0004,0010,0010,0020,0043,0103,0000,0000,0000,0000,0000, /*, %, */
0000,0000,0070,0104,0110,0060,0060,0111,0106,0106,0071,0000,0000,0000,0000,0000, /*, &, */
0004,0010,0020,0040,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, ', */
0000,0004,0010,0020,0040,0040,0040,0040,0040,0040,0020,0010,0004,0000,0000,0000, /*, (, */
0000,0040,0020,0010,0004,0004,0004,0004,0004,0004,0010,0020,0040,0000,0000,0000, /*, ), */
0000,0000,0000,0010,0111,0052,0034,0177,0034,0052,0111,0010,0000,0000,0000,0000, /*, *, */
0000,0000,0000,0000,0010,0010,0010,0177,0010,0010,0010,0000,0000,0000,0000,0000, /*, +, */
0000,0000,0000,0000,0000,0000,0000,0000,0000,0030,0030,0010,0020,0000,0000,0000, /*, ,, */
0000,0000,0000,0000,0000,0000,0000,0176,0000,0000,0000,0000,0000,0000,0000,0000, /*, -, */
0000,0000,0000,0000,0000,0000,0000,0000,0000,0030,0030,0000,0000,0000,0000,0000, /*, ., */
0000,0000,0001,0002,0004,0010,0010,0010,0020,0040,0100,0000,0000,0000,0000,0000, /*, /, */
0000,0030,0044,0102,0102,0102,0102,0102,0102,0044,0030,0000,0000,0000,0000,0000, /*, 0, */
0000,0010,0030,0010,0010,0010,0010,0010,0010,0010,0034,0000,0000,0000,0000,0000, /*, 1, */
0000,0070,0104,0004,0004,0010,0020,0040,0100,0100,0174,0000,0000,0000,0000,0000, /*, 2, */
0000,0176,0004,0004,0010,0014,0002,0002,0002,0104,0070,0000,0000,0000,0000,0000, /*, 3, */
0000,0004,0014,0024,0044,0104,0176,0004,0004,0004,0004,0000,0000,0000,0000,0000, /*, 4, */
0000,0174,0100,0100,0130,0144,0002,0002,0102,0044,0030,0000,0000,0000,0000,0000, /*, 5, */
0000,0074,0102,0100,0130,0144,0102,0102,0102,0044,0030,0000,0000,0000,0000,0000, /*, 6, */
0000,0176,0004,0004,0010,0010,0020,0020,0040,0040,0040,0000,0000,0000,0000,0000, /*, 7, */
0000,0034,0042,0101,0042,0076,0101,0101,0101,0101,0076,0000,0000,0000,0000,0000, /*, 8, */
0000,0034,0042,0101,0101,0101,0043,0036,0004,0010,0020,0040,0000,0000,0000,0000, /*, 9, */
0000,0000,0000,0000,0000,0000,0030,0030,0000,0030,0030,0000,0000,0000,0000,0000, /*, :, */
0000,0000,0000,0000,0000,0000,0030,0030,0000,0030,0030,0020,0040,0000,0000,0000, /*, ;, */
0002,0004,0010,0020,0040,0100,0040,0020,0010,0004,0002,0000,0000,0000,0000,0000, /*, <, */
0000,0000,0000,0000,0177,0000,0177,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, =, */
0100,0040,0020,0010,0004,0002,0004,0010,0020,0040,0100,0000,0000,0000,0000,0000, /*, >, */
0000,0030,0044,0102,0001,0002,0004,0010,0010,0000,0010,0000,0000,0000,0000,0000, /*, ?, */
0000,0074,0102,0101,0115,0123,0121,0121,0121,0111,0046,0000,0000,0000,0000,0000, /*, @, */
0000,0010,0024,0042,0101,0101,0177,0101,0101,0101,0101,0000,0000,0000,0000,0000, /*, A, */
0000,0176,0101,0101,0101,0176,0101,0101,0101,0101,0176,0000,0000,0000,0000,0000, /*, B, */
0000,0076,0101,0100,0100,0100,0100,0100,0100,0101,0076,0000,0000,0000,0000,0000, /*, C, */
0000,0176,0101,0101,0101,0101,0101,0101,0101,0101,0176,0000,0000,0000,0000,0000, /*, D, */
0000,0176,0100,0100,0100,0170,0100,0100,0100,0100,0177,0000,0000,0000,0000,0000, /*, E, */
0000,0177,0100,0100,0100,0174,0100,0100,0100,0100,0100,0000,0000,0000,0000,0000, /*, F, */
0000,0076,0101,0100,0100,0117,0101,0101,0101,0101,0076,0000,0000,0000,0000,0000, /*, G, */
0000,0101,0101,0101,0101,0176,0101,0101,0101,0101,0101,0000,0000,0000,0000,0000, /*, H, */
0000,0034,0010,0010,0010,0010,0010,0010,0010,0010,0034,0000,0000,0000,0000,0000, /*, I, */
0000,0016,0004,0004,0004,0004,0004,0004,0104,0104,0070,0000,0000,0000,0000,0000, /*, J, */
0000,0101,0102,0104,0110,0120,0160,0110,0104,0102,0101,0000,0000,0000,0000,0000, /*, K, */
0000,0100,0100,0100,0100,0100,0100,0100,0100,0100,0177,0000,0000,0000,0000,0000, /*, L, */
0000,0101,0143,0125,0111,0101,0101,0101,0101,0101,0101,0000,0000,0000,0000,0000, /*, M, */
0000,0101,0141,0121,0111,0105,0103,0101,0101,0101,0101,0000,0000,0000,0000,0000, /*, N, */
0000,0076,0101,0101,0101,0101,0101,0101,0101,0101,0076,0000,0000,0000,0000,0000, /*, O, */
0000,0176,0101,0101,0101,0176,0100,0100,0100,0100,0100,0000,0000,0000,0000,0000, /*, P, */
0000,0076,0101,0101,0101,0101,0101,0101,0131,0105,0076,0002,0001,0000,0000,0000, /*, Q, */
0000,0176,0101,0101,0101,0176,0104,0102,0101,0101,0101,0000,0000,0000,0000,0000, /*, R, */
0000,0076,0101,0100,0100,0076,0001,0001,0001,0101,0076,0000,0000,0000,0000,0000, /*, S, */
0000,0177,0010,0010,0010,0010,0010,0010,0010,0010,0010,0000,0000,0000,0000,0000, /*, T, */
0000,0101,0101,0101,0101,0101,0101,0101,0101,0101,0076,0000,0000,0000,0000,0000, /*, U, */
0000,0101,0101,0101,0101,0101,0101,0101,0042,0024,0010,0000,0000,0000,0000,0000, /*, V, */
0000,0101,0101,0101,0101,0111,0111,0125,0143,0101,0101,0000,0000,0000,0000,0000, /*, W, */
0000,0101,0101,0042,0024,0010,0024,0042,0101,0101,0101,0000,0000,0000,0000,0000, /*, X, */
0000,0101,0042,0024,0010,0010,0010,0010,0010,0010,0010,0000,0000,0000,0000,0000, /*, Y, */
0000,0177,0001,0002,0004,0010,0020,0040,0100,0100,0177,0000,0000,0000,0000,0000, /*, Z, */
0000,0034,0020,0020,0020,0020,0020,0020,0020,0020,0020,0034,0000,0000,0000,0000, /*, [, */
0000,0000,0100,0040,0020,0010,0010,0010,0004,0002,0001,0000,0000,0000,0000,0000, /*, , \, */
0000,0070,0010,0010,0010,0010,0010,0010,0010,0010,0010,0070,0000,0000,0000,0000, /*, ], */
0010,0024,0042,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, ^, */
0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0377,0000,0000, /*, _, */
0040,0020,0010,0004,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, `, */
0000,0000,0000,0000,0000,0074,0002,0076,0102,0102,0076,0000,0000,0000,0000,0000, /*, a, */
0000,0100,0100,0100,0100,0174,0102,0102,0102,0102,0174,0000,0000,0000,0000,0000, /*, b, */
0000,0000,0000,0000,0000,0074,0102,0100,0100,0102,0074,0000,0000,0000,0000,0000, /*, c, */
0002,0002,0002,0002,0002,0076,0102,0102,0102,0102,0076,0000,0000,0000,0000,0000, /*, d, */
0000,0000,0000,0000,0000,0074,0102,0174,0100,0102,0074,0000,0000,0000,0000,0000, /*, e, */
0000,0016,0020,0020,0020,0176,0020,0020,0020,0020,0020,0000,0000,0000,0000,0000, /*, f, */
0000,0000,0000,0000,0000,0076,0102,0102,0102,0102,0076,0002,0002,0102,0076,0000, /*, g, */
0000,0100,0100,0100,0100,0174,0102,0102,0102,0102,0102,0000,0000,0000,0000,0000, /*, h, */
0000,0000,0000,0010,0000,0030,0010,0010,0010,0010,0034,0000,0000,0000,0000,0000, /*, i, */
0000,0000,0000,0010,0000,0030,0010,0010,0010,0010,0010,0010,0010,0050,0020,0000, /*, j, */
0000,0100,0100,0100,0100,0106,0110,0120,0160,0110,0106,0000,0000,0000,0000,0000, /*, k, */
0000,0030,0010,0010,0010,0010,0010,0010,0010,0010,0034,0000,0000,0000,0000,0000, /*, l, */
0000,0000,0000,0000,0000,0166,0111,0111,0111,0111,0111,0000,0000,0000,0000,0000, /*, m, */
0000,0000,0000,0000,0100,0174,0102,0102,0102,0102,0102,0000,0000,0000,0000,0000, /*, n, */
0000,0000,0000,0000,0000,0074,0102,0102,0102,0102,0074,0000,0000,0000,0000,0000, /*, o, */
0000,0000,0000,0000,0000,0174,0102,0102,0102,0102,0174,0100,0100,0100,0100,0000, /*, p, */
0000,0000,0000,0000,0000,0076,0102,0102,0102,0102,0076,0002,0002,0002,0002,0000, /*, q, */
0000,0000,0000,0000,0000,0134,0142,0100,0100,0100,0100,0000,0000,0000,0000,0000, /*, r, */
0000,0000,0000,0000,0000,0076,0100,0074,0002,0102,0074,0000,0000,0000,0000,0000, /*, s, */
0000,0020,0020,0020,0020,0176,0020,0020,0020,0020,0014,0000,0000,0000,0000,0000, /*, t, */
0000,0000,0000,0000,0000,0102,0102,0102,0102,0102,0075,0000,0000,0000,0000,0000, /*, u, */
0000,0000,0000,0000,0000,0101,0101,0101,0042,0024,0010,0000,0000,0000,0000,0000, /*, v, */
0000,0000,0000,0000,0000,0111,0111,0111,0111,0111,0066,0000,0000,0000,0000,0000, /*, w, */
0000,0000,0000,0000,0000,0102,0044,0030,0030,0044,0102,0000,0000,0000,0000,0000, /*, x, */
0000,0000,0000,0000,0000,0102,0102,0102,0042,0024,0010,0020,0040,0100,0000,0000, /*, y, */
0000,0000,0000,0000,0000,0176,0004,0010,0020,0040,0176,0000,0000,0000,0000,0000, /*, z, */
0000,0014,0020,0020,0020,0020,0040,0020,0020,0020,0020,0014,0000,0000,0000,0000, /*, {, */
0000,0010,0010,0010,0010,0000,0000,0010,0010,0010,0010,0000,0000,0000,0000,0000, /*, |, */
0000,0030,0010,0010,0010,0010,0004,0010,0010,0010,0010,0030,0000,0000,0000,0000, /*, }, */
0020,0052,0004,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000, /*, ~, */
0000,0176,0176,0176,0176,0176,0176,0176,0176,0176,0176,0000,0000,0000,0000,0000, /*, del, */
};
|
the_stack_data/712924.c
|
/*
* Copyright (c) 2016 Cadence Design Systems, Inc.
* SPDX-License-Identifier: Apache-2.0
*/
|
the_stack_data/131504.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef USE_PNG
#include <png.h>
#include <zlib.h>
#endif /* USE_PNG */
#ifdef __64BIT__
typedef int g2int;
#else
typedef long g2int;
#endif
#if defined _UNDERSCORE
#define enc_png enc_png_
#elif defined _DOUBLEUNDERSCORE
#define enc_png enc_png__
#endif
#ifdef USE_PNG
struct png_stream {
unsigned char *stream_ptr; /* location to write PNG stream */
g2int stream_len; /* number of bytes written */
};
typedef struct png_stream png_stream;
void user_write_data(png_structp ,png_bytep , png_uint_32 );
void user_flush_data(png_structp );
void user_write_data(png_structp png_ptr,png_bytep data, png_uint_32 length)
/*
Custom write function used to that libpng will write
to memory location instead of a file on disk
*/
{
unsigned char *ptr;
g2int offset;
png_stream *mem;
mem=(png_stream *)png_get_io_ptr(png_ptr);
ptr=mem->stream_ptr;
offset=mem->stream_len;
/* printf("SAGwr %ld %ld %x\n",offset,length,ptr); */
/*for (j=offset,k=0;k<length;j++,k++) ptr[j]=data[k];*/
memcpy(ptr+offset,data,length);
mem->stream_len += length;
}
void user_flush_data(png_structp png_ptr)
/*
Dummy Custom flush function
*/
{
int *do_nothing=NULL;
}
#endif /* USE_PNG */
int enc_png(char *data,g2int *width,g2int *height,g2int *nbits,char *pngbuf)
{
g2int pnglen;
#ifdef USE_PNG
int color_type;
g2int j,bytes,bit_depth;
png_structp png_ptr;
png_infop info_ptr;
/* png_bytep *row_pointers[*height]; */
png_bytep **row_pointers;
png_stream write_io_ptr;
/* create and initialize png_structs */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
NULL, NULL);
if (!png_ptr)
return (-1);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
png_destroy_write_struct(&png_ptr,(png_infopp)NULL);
return (-2);
}
/* Set Error callback */
if (setjmp(png_jmpbuf(png_ptr)))
{
png_destroy_write_struct(&png_ptr, &info_ptr);
return (-3);
}
/* Initialize info for writing PNG stream to memory */
write_io_ptr.stream_ptr=(png_voidp)pngbuf;
write_io_ptr.stream_len=0;
/* Set new custom write functions */
png_set_write_fn(png_ptr,(png_voidp)&write_io_ptr,(png_rw_ptr)user_write_data,
(png_flush_ptr)user_flush_data);
/* png_init_io(png_ptr, fptr); */
/* png_set_compression_level(png_ptr, Z_BEST_COMPRESSION); */
/* Set the image size, colortype, filter type, etc... */
/* printf("SAGTsettingIHDR %d %d %d\n",*width,*height,bit_depth); */
bit_depth=*nbits;
color_type=PNG_COLOR_TYPE_GRAY;
if (*nbits == 24 ) {
bit_depth=8;
color_type=PNG_COLOR_TYPE_RGB;
}
else if (*nbits == 32 ) {
bit_depth=8;
color_type=PNG_COLOR_TYPE_RGB_ALPHA;
}
png_set_IHDR(png_ptr, info_ptr, *width, *height,
bit_depth, color_type, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
/* Put image data into the PNG info structure */
/*bytes=bit_depth/8;*/
bytes=*nbits/8;
row_pointers=malloc((*height)*sizeof(png_bytep));
for (j=0;j<*height;j++) row_pointers[j]=(png_bytep *)(data+(j*(*width)*bytes));
png_set_rows(png_ptr, info_ptr, (png_bytepp)row_pointers);
/* Do the PNG encoding, and write out PNG stream */
png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
/* Clean up */
png_destroy_write_struct(&png_ptr, &info_ptr);
free(row_pointers);
pnglen=write_io_ptr.stream_len;
#endif /* USE_PNG */
return pnglen;
}
|
the_stack_data/116242.c
|
//===-- ARMDisassembler.cpp - Disassembler for ARM/Thumb ISA --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2014 */
#ifdef CAPSTONE_HAS_ARM
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include "ARMAddressingModes.h"
#include "ARMBaseInfo.h"
#include "../../MCFixedLenDisassembler.h"
#include "../../MCInst.h"
#include "../../MCInstrDesc.h"
#include "../../MCRegisterInfo.h"
#include "../../LEB128.h"
#include "../../MCDisassembler.h"
#include "../../cs_priv.h"
#include "ARMDisassembler.h"
//#define GET_REGINFO_ENUM
//#include "X86GenRegisterInfo.inc"
#define GET_SUBTARGETINFO_ENUM
#include "ARMGenSubtargetInfo.inc"
#define GET_INSTRINFO_MC_DESC
#include "ARMGenInstrInfo.inc"
#define GET_INSTRINFO_ENUM
#include "ARMGenInstrInfo.inc"
static bool ITStatus_push_back(ARM_ITStatus *it, char v)
{
it->ITStates[it->size] = v;
it->size++;
return true;
}
// Returns true if the current instruction is in an IT block
static bool ITStatus_instrInITBlock(ARM_ITStatus *it)
{
//return !ITStates.empty();
return (it->size > 0);
}
// Returns true if current instruction is the last instruction in an IT block
static bool ITStatus_instrLastInITBlock(ARM_ITStatus *it)
{
return (it->size == 1);
}
// Handles the condition code status of instructions in IT blocks
// Returns the condition code for instruction in IT block
static unsigned ITStatus_getITCC(ARM_ITStatus *it)
{
unsigned CC = ARMCC_AL;
if (ITStatus_instrInITBlock(it))
//CC = ITStates.back();
CC = it->ITStates[it->size-1];
return CC;
}
// Advances the IT block state to the next T or E
static void ITStatus_advanceITState(ARM_ITStatus *it)
{
//ITStates.pop_back();
it->size--;
}
// Called when decoding an IT instruction. Sets the IT state for the following
// instructions that for the IT block. Firstcond and Mask correspond to the
// fields in the IT instruction encoding.
static void ITStatus_setITState(ARM_ITStatus *it, char Firstcond, char Mask)
{
// (3 - the number of trailing zeros) is the number of then / else.
unsigned CondBit0 = Firstcond & 1;
unsigned NumTZ = CountTrailingZeros_32(Mask);
unsigned char CCBits = (unsigned char)Firstcond & 0xf;
unsigned Pos;
//assert(NumTZ <= 3 && "Invalid IT mask!");
// push condition codes onto the stack the correct order for the pops
for (Pos = NumTZ+1; Pos <= 3; ++Pos) {
bool T = ((Mask >> Pos) & 1) == (int)CondBit0;
if (T)
ITStatus_push_back(it, CCBits);
else
ITStatus_push_back(it, CCBits ^ 1);
}
ITStatus_push_back(it, CCBits);
}
/// ThumbDisassembler - Thumb disassembler for all Thumb platforms.
static bool Check(DecodeStatus *Out, DecodeStatus In)
{
switch (In) {
case MCDisassembler_Success:
// Out stays the same.
return true;
case MCDisassembler_SoftFail:
*Out = In;
return true;
case MCDisassembler_Fail:
*Out = In;
return false;
default: // never reached
return false;
}
}
// Forward declare these because the autogenerated code will reference them.
// Definitions are further down.
static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeGPRnopcRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeGPRwithAPSRRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const void *Decoder);
static DecodeStatus DecodetGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodetcGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecoderGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeGPRPairRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPR_8RegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPR_VFP2RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeQPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPairRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPairSpacedRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const void *Decoder);
static DecodeStatus DecodePredicateOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeCCOutOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSOImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSPRRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDPRRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeBitfieldMaskOperand(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeCopMemInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrMode2IdxInstruction(MCInst *Inst,
unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrMode3Instruction(MCInst *Inst,unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSORegImmOperand(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSORegRegOperand(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeMemMultipleWritebackInstruction(MCInst * Inst,
unsigned Insn, uint64_t Adddress, const void *Decoder);
static DecodeStatus DecodeT2MOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSMLAInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeCPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2CPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrModeImm12Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrMode5Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrMode7Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2BInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeBranchImmInstruction(MCInst *Inst,unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeAddrMode6Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLDST1Instruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLDST2Instruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLDST4Instruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLDInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVSTInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD1DupInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD2DupInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD3DupInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD4DupInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeNEONModImmInstruction(MCInst *Inst,unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVSHLMaxInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeShiftRight8Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeShiftRight16Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeShiftRight32Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeShiftRight64Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeTBLInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodePostIdxReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeCoprocessor(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeMemBarrierOption(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeInstSyncBarrierOption(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeMSRMask(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDoubleRegLoad(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeDoubleRegStore(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeLDRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeLDRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSTRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSTRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD1LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD3LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVLD4LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVST1LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVST2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVST3LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVST4LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVMOVSRR(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVMOVRRS(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSwap(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVCVTD(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVCVTQ(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddSpecialReg(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbBROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2BROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbCmpBROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddrModeRR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddrModeIS(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddrModePC(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddrModeSP(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2AddrModeSOReg(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2LoadShift(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2LoadImm8(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder);
static DecodeStatus DecodeT2LoadImm12(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder);
static DecodeStatus DecodeT2LoadT(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder);
static DecodeStatus DecodeT2LoadLabel(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder);
static DecodeStatus DecodeT2Imm8S4(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2AddrModeImm8s4(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2AddrModeImm0_1020s4(MCInst *Inst,unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2Imm8(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2AddrModeImm8(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddSPImm(MCInst *Inst, uint16_t Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbAddSPReg(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbCPS(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeQADDInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbBLXOffset(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2AddrModeImm12(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbTableBranch(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumb2BCCInstruction(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2SOImm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbBCCTargetOperand(MCInst *Inst,unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeThumbBLTargetOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeIT(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2LDRDPreInstruction(MCInst *Inst,unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2STRDPreInstruction(MCInst *Inst,unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2Adr(MCInst *Inst, uint32_t Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2LdStPre(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeT2ShifterImmOperand(MCInst *Inst, uint32_t Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeLDR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeMRRC2(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder);
// Hacky: enable all features for disassembler
static uint64_t getFeatureBits(int mode)
{
uint64_t Bits = (uint64_t)-1; // everything by default
// FIXME: ARM_FeatureVFPOnlySP is conflicting with everything else??
Bits &= (~ARM_FeatureVFPOnlySP);
// FIXME: no Armv8 support?
//Bits -= ARM_HasV7Ops;
//Bits &= ~ARM_FeatureMP;
//Bits &= ~ARM_HasV8Ops;
//Bits &= ~ARM_HasV6Ops;
//Bits &= (~ARM_FeatureMClass);
// some features are mutually exclusive
if (mode & CS_MODE_THUMB) {
//Bits &= ~ARM_HasV6Ops;
//Bits &= ~ARM_FeatureCRC;
//Bits &= ~ARM_HasV5TEOps;
//Bits &= ~ARM_HasV4TOps;
//Bits &= ~ARM_HasV6T2Ops;
//Bits &= ~ARM_FeatureDB;
//Bits &= ~ARM_FeatureHWDivARM;
//Bits &= ~ARM_FeatureNaClTrap;
//Bits &= ~ARM_FeatureMClass;
// ArmV8
} else { // ARM mode
Bits &= ~ARM_ModeThumb;
Bits &= ~ARM_FeatureThumb2;
}
return Bits;
}
#include "ARMGenDisassemblerTables.inc"
static DecodeStatus DecodePredicateOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val == 0xF) return MCDisassembler_Fail;
// AL predicate is not allowed on Thumb1 branches.
if (MCInst_getOpcode(Inst) == ARM_tBcc && Val == 0xE)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
if (Val == ARMCC_AL) {
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_CPSR));
return MCDisassembler_Success;
}
#define GET_REGINFO_MC_DESC
#include "ARMGenRegisterInfo.inc"
void ARM_init(MCRegisterInfo *MRI)
{
/*
InitMCRegisterInfo(ARMRegDesc, 289,
RA, PC,
ARMMCRegisterClasses, 100,
ARMRegUnitRoots, 77, ARMRegDiffLists, ARMRegStrings,
ARMSubRegIdxLists, 57,
ARMSubRegIdxRanges, ARMRegEncodingTable);
*/
MCRegisterInfo_InitMCRegisterInfo(MRI, ARMRegDesc, 289,
0, 0,
ARMMCRegisterClasses, 100,
0, 0, ARMRegDiffLists, 0,
ARMSubRegIdxLists, 57,
0);
}
static DecodeStatus _ARM_getInstruction(cs_struct *ud, MCInst *MI, const uint8_t *code, size_t code_len,
uint16_t *Size, uint64_t Address)
{
uint32_t insn;
uint8_t bytes[4];
DecodeStatus result;
ud->ITBlock.size = 0;
if (code_len < 4)
// not enough data
return MCDisassembler_Fail;
memcpy(bytes, code, 4);
if (ud->big_endian)
insn = (bytes[3] << 0) |
(bytes[2] << 8) |
(bytes[1] << 16) |
(bytes[0] << 24);
else
insn = (bytes[3] << 24) |
(bytes[2] << 16) |
(bytes[1] << 8) |
(bytes[0] << 0);
// Calling the auto-generated decoder function.
result = decodeInstruction_4(DecoderTableARM32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
// VFP and NEON instructions, similarly, are shared between ARM
// and Thumb modes.
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableVFP32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableVFPV832, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableNEONData32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
// Add a fake predicate operand, because we share these instruction
// definitions with Thumb2 where these instructions are predicable.
if (!DecodePredicateOperand(MI, 0xE, Address, NULL))
return MCDisassembler_Fail;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableNEONLoadStore32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
// Add a fake predicate operand, because we share these instruction
// definitions with Thumb2 where these instructions are predicable.
if (!DecodePredicateOperand(MI, 0xE, Address, NULL))
return MCDisassembler_Fail;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableNEONDup32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
// Add a fake predicate operand, because we share these instruction
// definitions with Thumb2 where these instructions are predicable.
if (!DecodePredicateOperand(MI, 0xE, Address, NULL))
return MCDisassembler_Fail;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTablev8NEON32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTablev8Crypto32, MI, insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
*Size = 0;
return MCDisassembler_Fail;
}
// Thumb1 instructions don't have explicit S bits. Rather, they
// implicitly set CPSR. Since it's not represented in the encoding, the
// auto-generated decoder won't inject the CPSR operand. We need to fix
// that as a post-pass.
static void AddThumb1SBit(MCInst *MI, bool InITBlock)
{
MCOperandInfo *OpInfo = ARMInsts[MCInst_getOpcode(MI)].OpInfo;
unsigned short NumOps = ARMInsts[MCInst_getOpcode(MI)].NumOperands;
unsigned i;
for (i = 0; i < NumOps; ++i) {
if (i == MCInst_getNumOperands(MI)) break;
if (MCOperandInfo_isOptionalDef(&OpInfo[i]) && OpInfo[i].RegClass == ARM_CCRRegClassID) {
if (i > 0 && MCOperandInfo_isPredicate(&OpInfo[i-1])) continue;
MCInst_insert(MI, i, MCOperand_CreateReg(InITBlock ? 0 : ARM_CPSR));
return;
}
}
//MI.insert(I, MCOperand_CreateReg(InITBlock ? 0 : ARM_CPSR));
MCInst_insert(MI, i, MCOperand_CreateReg(InITBlock ? 0 : ARM_CPSR));
}
// Most Thumb instructions don't have explicit predicates in the
// encoding, but rather get their predicates from IT context. We need
// to fix up the predicate operands using this context information as a
// post-pass.
static DecodeStatus AddThumbPredicate(cs_struct *ud, MCInst *MI)
{
DecodeStatus S = MCDisassembler_Success;
MCOperandInfo *OpInfo;
unsigned short NumOps;
unsigned int i;
unsigned CC;
// A few instructions actually have predicates encoded in them. Don't
// try to overwrite it if we're seeing one of those.
switch (MCInst_getOpcode(MI)) {
case ARM_tBcc:
case ARM_t2Bcc:
case ARM_tCBZ:
case ARM_tCBNZ:
case ARM_tCPS:
case ARM_t2CPS3p:
case ARM_t2CPS2p:
case ARM_t2CPS1p:
case ARM_tMOVSr:
case ARM_tSETEND:
// Some instructions (mostly conditional branches) are not
// allowed in IT blocks.
if (ITStatus_instrInITBlock(&(ud->ITBlock)))
S = MCDisassembler_SoftFail;
else
return MCDisassembler_Success;
break;
case ARM_tB:
case ARM_t2B:
case ARM_t2TBB:
case ARM_t2TBH:
// Some instructions (mostly unconditional branches) can
// only appears at the end of, or outside of, an IT.
//if (ITBlock.instrInITBlock() && !ITBlock.instrLastInITBlock())
if (ITStatus_instrInITBlock(&(ud->ITBlock)) && !ITStatus_instrLastInITBlock(&(ud->ITBlock)))
S = MCDisassembler_SoftFail;
break;
default:
break;
}
// If we're in an IT block, base the predicate on that. Otherwise,
// assume a predicate of AL.
CC = ITStatus_getITCC(&(ud->ITBlock));
if (CC == 0xF)
CC = ARMCC_AL;
if (ITStatus_instrInITBlock(&(ud->ITBlock)))
ITStatus_advanceITState(&(ud->ITBlock));
OpInfo = ARMInsts[MCInst_getOpcode(MI)].OpInfo;
NumOps = ARMInsts[MCInst_getOpcode(MI)].NumOperands;
for (i = 0; i < NumOps; ++i) {
if (i == MCInst_getNumOperands(MI)) break;
if (MCOperandInfo_isPredicate(&OpInfo[i])) {
MCInst_insert(MI, i, MCOperand_CreateImm(CC));
if (CC == ARMCC_AL)
MCInst_insert(MI, i+1, MCOperand_CreateReg(0));
else
MCInst_insert(MI, i+1, MCOperand_CreateReg(ARM_CPSR));
return S;
}
}
MCInst_insert(MI, i, MCOperand_CreateImm(CC));
if (CC == ARMCC_AL)
MCInst_insert(MI, i+1, MCOperand_CreateReg(0));
else
MCInst_insert(MI, i+1, MCOperand_CreateReg(ARM_CPSR));
return S;
}
// Thumb VFP instructions are a special case. Because we share their
// encodings between ARM and Thumb modes, and they are predicable in ARM
// mode, the auto-generated decoder will give them an (incorrect)
// predicate operand. We need to rewrite these operands based on the IT
// context as a post-pass.
static void UpdateThumbVFPPredicate(cs_struct *ud, MCInst *MI)
{
unsigned CC;
unsigned short NumOps;
MCOperandInfo *OpInfo;
unsigned i;
CC = ITStatus_getITCC(&(ud->ITBlock));
if (ITStatus_instrInITBlock(&(ud->ITBlock)))
ITStatus_advanceITState(&(ud->ITBlock));
OpInfo = ARMInsts[MCInst_getOpcode(MI)].OpInfo;
NumOps = ARMInsts[MCInst_getOpcode(MI)].NumOperands;
for (i = 0; i < NumOps; ++i) {
if (MCOperandInfo_isPredicate(&OpInfo[i])) {
MCOperand_setImm(MCInst_getOperand(MI, i), CC);
if (CC == ARMCC_AL)
MCOperand_setReg(MCInst_getOperand(MI, i+1), 0);
else
MCOperand_setReg(MCInst_getOperand(MI, i+1), ARM_CPSR);
return;
}
}
}
static DecodeStatus _Thumb_getInstruction(cs_struct *ud, MCInst *MI, const uint8_t *code, size_t code_len,
uint16_t *Size, uint64_t Address)
{
uint8_t bytes[4];
uint16_t insn16;
DecodeStatus result;
bool InITBlock;
unsigned Firstcond, Mask;
uint32_t NEONLdStInsn, insn32, NEONDataInsn, NEONCryptoInsn, NEONv8Insn;
ud->ITBlock.size = 0;
// We want to read exactly 2 bytes of data.
if (code_len < 2)
// not enough data
return MCDisassembler_Fail;
memcpy(bytes, code, 2);
if (ud->big_endian)
insn16 = (bytes[0] << 8) | bytes[1];
else
insn16 = (bytes[1] << 8) | bytes[0];
result = decodeInstruction_2(DecoderTableThumb16, MI, insn16, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 2;
Check(&result, AddThumbPredicate(ud, MI));
return result;
}
MCInst_clear(MI);
result = decodeInstruction_2(DecoderTableThumbSBit16, MI, insn16, Address, NULL, ud->mode);
if (result) {
*Size = 2;
InITBlock = ITStatus_instrInITBlock(&(ud->ITBlock));
Check(&result, AddThumbPredicate(ud, MI));
AddThumb1SBit(MI, InITBlock);
return result;
}
MCInst_clear(MI);
result = decodeInstruction_2(DecoderTableThumb216, MI, insn16, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 2;
// Nested IT blocks are UNPREDICTABLE. Must be checked before we add
// the Thumb predicate.
if (MCInst_getOpcode(MI) == ARM_t2IT && ITStatus_instrInITBlock(&(ud->ITBlock)))
result = MCDisassembler_SoftFail;
Check(&result, AddThumbPredicate(ud, MI));
// If we find an IT instruction, we need to parse its condition
// code and mask operands so that we can apply them correctly
// to the subsequent instructions.
if (MCInst_getOpcode(MI) == ARM_t2IT) {
Firstcond = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, 0));
Mask = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, 1));
ITStatus_setITState(&(ud->ITBlock), (char)Firstcond, (char)Mask);
}
return result;
}
// We want to read exactly 4 bytes of data.
if (code_len < 4)
// not enough data
return MCDisassembler_Fail;
memcpy(bytes, code, 4);
if (ud->big_endian)
insn32 = (bytes[3] << 24) |
(bytes[2] << 16) |
(bytes[1] << 8) |
(bytes[0] << 0);
else
insn32 = (bytes[3] << 8) |
(bytes[2] << 0) |
(bytes[1] << 24) |
(bytes[0] << 16);
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableThumb32, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
InITBlock = ITStatus_instrInITBlock(&(ud->ITBlock));
Check(&result, AddThumbPredicate(ud, MI));
AddThumb1SBit(MI, InITBlock);
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableThumb232, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
Check(&result, AddThumbPredicate(ud, MI));
return result;
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableVFP32, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
UpdateThumbVFPPredicate(ud, MI);
return result;
}
if (fieldFromInstruction_4(insn32, 28, 4) == 0xE) {
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableVFP32, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
UpdateThumbVFPPredicate(ud, MI);
return result;
}
}
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableVFPV832, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
if (fieldFromInstruction_4(insn32, 28, 4) == 0xE) {
MCInst_clear(MI);
result = decodeInstruction_4(DecoderTableNEONDup32, MI, insn32, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
Check(&result, AddThumbPredicate(ud, MI));
return result;
}
}
if (fieldFromInstruction_4(insn32, 24, 8) == 0xF9) {
MCInst_clear(MI);
NEONLdStInsn = insn32;
NEONLdStInsn &= 0xF0FFFFFF;
NEONLdStInsn |= 0x04000000;
result = decodeInstruction_4(DecoderTableNEONLoadStore32, MI, NEONLdStInsn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
Check(&result, AddThumbPredicate(ud, MI));
return result;
}
}
if (fieldFromInstruction_4(insn32, 24, 4) == 0xF) {
MCInst_clear(MI);
NEONDataInsn = insn32;
NEONDataInsn &= 0xF0FFFFFF; // Clear bits 27-24
NEONDataInsn |= (NEONDataInsn & 0x10000000) >> 4; // Move bit 28 to bit 24
NEONDataInsn |= 0x12000000; // Set bits 28 and 25
result = decodeInstruction_4(DecoderTableNEONData32, MI, NEONDataInsn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
Check(&result, AddThumbPredicate(ud, MI));
return result;
}
}
MCInst_clear(MI);
NEONCryptoInsn = insn32;
NEONCryptoInsn &= 0xF0FFFFFF; // Clear bits 27-24
NEONCryptoInsn |= (NEONCryptoInsn & 0x10000000) >> 4; // Move bit 28 to bit 24
NEONCryptoInsn |= 0x12000000; // Set bits 28 and 25
result = decodeInstruction_4(DecoderTablev8Crypto32, MI, NEONCryptoInsn,
Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
NEONv8Insn = insn32;
NEONv8Insn &= 0xF3FFFFFF; // Clear bits 27-26
result = decodeInstruction_4(DecoderTablev8NEON32, MI, NEONv8Insn, Address, NULL, ud->mode);
if (result != MCDisassembler_Fail) {
*Size = 4;
return result;
}
MCInst_clear(MI);
*Size = 0;
return MCDisassembler_Fail;
}
bool Thumb_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *instr,
uint16_t *size, uint64_t address, void *info)
{
DecodeStatus status = _Thumb_getInstruction((cs_struct *)ud, instr, code, code_len, size, address);
//return status == MCDisassembler_Success;
return status != MCDisassembler_Fail;
}
bool ARM_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *instr,
uint16_t *size, uint64_t address, void *info)
{
DecodeStatus status = _ARM_getInstruction((cs_struct *)ud, instr, code, code_len, size, address);
//return status == MCDisassembler_Success;
return status != MCDisassembler_Fail;
}
static const uint16_t GPRDecoderTable[] = {
ARM_R0, ARM_R1, ARM_R2, ARM_R3,
ARM_R4, ARM_R5, ARM_R6, ARM_R7,
ARM_R8, ARM_R9, ARM_R10, ARM_R11,
ARM_R12, ARM_SP, ARM_LR, ARM_PC
};
static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register;
if (RegNo > 15)
return MCDisassembler_Fail;
Register = GPRDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static DecodeStatus DecodeGPRnopcRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 15)
S = MCDisassembler_SoftFail;
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder));
return S;
}
static DecodeStatus DecodeGPRwithAPSRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 15) {
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_APSR_NZCV));
return MCDisassembler_Success;
}
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder));
return S;
}
static DecodeStatus DecodetGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
if (RegNo > 7)
return MCDisassembler_Fail;
return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder);
}
static const uint16_t GPRPairDecoderTable[] = {
ARM_R0_R1, ARM_R2_R3, ARM_R4_R5, ARM_R6_R7,
ARM_R8_R9, ARM_R10_R11, ARM_R12_SP
};
static DecodeStatus DecodeGPRPairRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned RegisterPair;
DecodeStatus S = MCDisassembler_Success;
if (RegNo > 13)
return MCDisassembler_Fail;
if ((RegNo & 1) || RegNo == 0xe)
S = MCDisassembler_SoftFail;
RegisterPair = GPRPairDecoderTable[RegNo/2];
MCInst_addOperand(Inst, MCOperand_CreateReg(RegisterPair));
return S;
}
static DecodeStatus DecodetcGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register = 0;
switch (RegNo) {
case 0:
Register = ARM_R0;
break;
case 1:
Register = ARM_R1;
break;
case 2:
Register = ARM_R2;
break;
case 3:
Register = ARM_R3;
break;
case 9:
Register = ARM_R9;
break;
case 12:
Register = ARM_R12;
break;
default:
return MCDisassembler_Fail;
}
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static DecodeStatus DecoderGPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 13 || RegNo == 15)
S = MCDisassembler_SoftFail;
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder));
return S;
}
static const uint16_t SPRDecoderTable[] = {
ARM_S0, ARM_S1, ARM_S2, ARM_S3,
ARM_S4, ARM_S5, ARM_S6, ARM_S7,
ARM_S8, ARM_S9, ARM_S10, ARM_S11,
ARM_S12, ARM_S13, ARM_S14, ARM_S15,
ARM_S16, ARM_S17, ARM_S18, ARM_S19,
ARM_S20, ARM_S21, ARM_S22, ARM_S23,
ARM_S24, ARM_S25, ARM_S26, ARM_S27,
ARM_S28, ARM_S29, ARM_S30, ARM_S31
};
static DecodeStatus DecodeSPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register;
if (RegNo > 31)
return MCDisassembler_Fail;
Register = SPRDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static const uint16_t DPRDecoderTable[] = {
ARM_D0, ARM_D1, ARM_D2, ARM_D3,
ARM_D4, ARM_D5, ARM_D6, ARM_D7,
ARM_D8, ARM_D9, ARM_D10, ARM_D11,
ARM_D12, ARM_D13, ARM_D14, ARM_D15,
ARM_D16, ARM_D17, ARM_D18, ARM_D19,
ARM_D20, ARM_D21, ARM_D22, ARM_D23,
ARM_D24, ARM_D25, ARM_D26, ARM_D27,
ARM_D28, ARM_D29, ARM_D30, ARM_D31
};
static DecodeStatus DecodeDPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register = 0;
if (RegNo > 31)
return MCDisassembler_Fail;
Register = DPRDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static DecodeStatus DecodeDPR_8RegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
if (RegNo > 7)
return MCDisassembler_Fail;
return DecodeDPRRegisterClass(Inst, RegNo, Address, Decoder);
}
static DecodeStatus
DecodeDPR_VFP2RegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
if (RegNo > 15)
return MCDisassembler_Fail;
return DecodeDPRRegisterClass(Inst, RegNo, Address, Decoder);
}
static const uint16_t QPRDecoderTable[] = {
ARM_Q0, ARM_Q1, ARM_Q2, ARM_Q3,
ARM_Q4, ARM_Q5, ARM_Q6, ARM_Q7,
ARM_Q8, ARM_Q9, ARM_Q10, ARM_Q11,
ARM_Q12, ARM_Q13, ARM_Q14, ARM_Q15
};
static DecodeStatus DecodeQPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register;
if (RegNo > 31 || (RegNo & 1) != 0)
return MCDisassembler_Fail;
RegNo >>= 1;
Register = QPRDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static const uint16_t DPairDecoderTable[] = {
ARM_Q0, ARM_D1_D2, ARM_Q1, ARM_D3_D4, ARM_Q2, ARM_D5_D6,
ARM_Q3, ARM_D7_D8, ARM_Q4, ARM_D9_D10, ARM_Q5, ARM_D11_D12,
ARM_Q6, ARM_D13_D14, ARM_Q7, ARM_D15_D16, ARM_Q8, ARM_D17_D18,
ARM_Q9, ARM_D19_D20, ARM_Q10, ARM_D21_D22, ARM_Q11, ARM_D23_D24,
ARM_Q12, ARM_D25_D26, ARM_Q13, ARM_D27_D28, ARM_Q14, ARM_D29_D30,
ARM_Q15
};
static DecodeStatus DecodeDPairRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register;
if (RegNo > 30)
return MCDisassembler_Fail;
Register = DPairDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static const uint16_t DPairSpacedDecoderTable[] = {
ARM_D0_D2, ARM_D1_D3, ARM_D2_D4, ARM_D3_D5,
ARM_D4_D6, ARM_D5_D7, ARM_D6_D8, ARM_D7_D9,
ARM_D8_D10, ARM_D9_D11, ARM_D10_D12, ARM_D11_D13,
ARM_D12_D14, ARM_D13_D15, ARM_D14_D16, ARM_D15_D17,
ARM_D16_D18, ARM_D17_D19, ARM_D18_D20, ARM_D19_D21,
ARM_D20_D22, ARM_D21_D23, ARM_D22_D24, ARM_D23_D25,
ARM_D24_D26, ARM_D25_D27, ARM_D26_D28, ARM_D27_D29,
ARM_D28_D30, ARM_D29_D31
};
static DecodeStatus DecodeDPairSpacedRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const void *Decoder)
{
unsigned Register;
if (RegNo > 29)
return MCDisassembler_Fail;
Register = DPairSpacedDecoderTable[RegNo];
MCInst_addOperand(Inst, MCOperand_CreateReg(Register));
return MCDisassembler_Success;
}
static DecodeStatus DecodeCCOutOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val)
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_CPSR));
else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
return MCDisassembler_Success;
}
static DecodeStatus DecodeSOImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
uint32_t imm = Val & 0xFF;
uint32_t rot = (Val & 0xF00) >> 7;
uint32_t rot_imm = (imm >> rot) | (imm << ((32-rot) & 0x1F));
MCInst_addOperand(Inst, MCOperand_CreateImm(rot_imm));
return MCDisassembler_Success;
}
static DecodeStatus DecodeSORegImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc Shift;
unsigned Op;
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldFromInstruction_4(Val, 5, 2);
unsigned imm = fieldFromInstruction_4(Val, 7, 5);
// Register-immediate
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
Shift = ARM_AM_lsl;
switch (type) {
case 0:
Shift = ARM_AM_lsl;
break;
case 1:
Shift = ARM_AM_lsr;
break;
case 2:
Shift = ARM_AM_asr;
break;
case 3:
Shift = ARM_AM_ror;
break;
}
if (Shift == ARM_AM_ror && imm == 0)
Shift = ARM_AM_rrx;
Op = Shift | (imm << 3);
MCInst_addOperand(Inst, MCOperand_CreateImm(Op));
return S;
}
static DecodeStatus DecodeSORegRegOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc Shift;
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldFromInstruction_4(Val, 5, 2);
unsigned Rs = fieldFromInstruction_4(Val, 8, 4);
// Register-register
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rs, Address, Decoder)))
return MCDisassembler_Fail;
Shift = ARM_AM_lsl;
switch (type) {
case 0:
Shift = ARM_AM_lsl;
break;
case 1:
Shift = ARM_AM_lsr;
break;
case 2:
Shift = ARM_AM_asr;
break;
case 3:
Shift = ARM_AM_ror;
break;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(Shift));
return S;
}
static DecodeStatus DecodeRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
unsigned i;
DecodeStatus S = MCDisassembler_Success;
bool NeedDisjointWriteback = false;
unsigned WritebackReg = 0;
switch (MCInst_getOpcode(Inst)) {
default:
break;
case ARM_LDMIA_UPD:
case ARM_LDMDB_UPD:
case ARM_LDMIB_UPD:
case ARM_LDMDA_UPD:
case ARM_t2LDMIA_UPD:
case ARM_t2LDMDB_UPD:
case ARM_t2STMIA_UPD:
case ARM_t2STMDB_UPD:
NeedDisjointWriteback = true;
WritebackReg = MCOperand_getReg(MCInst_getOperand(Inst, 0));
break;
}
// Empty register lists are not allowed.
if (Val == 0) return MCDisassembler_Fail;
for (i = 0; i < 16; ++i) {
if (Val & (1 << i)) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, i, Address, Decoder)))
return MCDisassembler_Fail;
// Writeback not allowed if Rn is in the target list.
if (NeedDisjointWriteback && WritebackReg == MCOperand_getReg(&(Inst->Operands[Inst->size-1])))
Check(&S, MCDisassembler_SoftFail);
}
}
return S;
}
static DecodeStatus DecodeSPRRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned i;
unsigned Vd = fieldFromInstruction_4(Val, 8, 5);
unsigned regs = fieldFromInstruction_4(Val, 0, 8);
// In case of unpredictable encoding, tweak the operands.
if (regs == 0 || (Vd + regs) > 32) {
regs = Vd + regs > 32 ? 32 - Vd : regs;
regs = (1u > regs? 1u : regs);
S = MCDisassembler_SoftFail;
}
if (!Check(&S, DecodeSPRRegisterClass(Inst, Vd, Address, Decoder)))
return MCDisassembler_Fail;
for (i = 0; i < (regs - 1); ++i) {
if (!Check(&S, DecodeSPRRegisterClass(Inst, ++Vd, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeDPRRegListOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned i;
unsigned Vd = fieldFromInstruction_4(Val, 8, 5);
unsigned regs = fieldFromInstruction_4(Val, 1, 7);
// In case of unpredictable encoding, tweak the operands.
if (regs == 0 || regs > 16 || (Vd + regs) > 32) {
regs = Vd + regs > 32 ? 32 - Vd : regs;
regs = (1u > regs? 1u : regs);
regs = (16u > regs? regs : 16u);
S = MCDisassembler_SoftFail;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Vd, Address, Decoder)))
return MCDisassembler_Fail;
for (i = 0; i < (regs - 1); ++i) {
if (!Check(&S, DecodeDPRRegisterClass(Inst, ++Vd, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeBitfieldMaskOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// This operand encodes a mask of contiguous zeros between a specified MSB
// and LSB. To decode it, we create the mask of all bits MSB-and-lower,
// the mask of all bits LSB-and-lower, and then xor them to create
// the mask of that's all ones on [msb, lsb]. Finally we not it to
// create the final mask.
unsigned msb = fieldFromInstruction_4(Val, 5, 5);
unsigned lsb = fieldFromInstruction_4(Val, 0, 5);
uint32_t lsb_mask, msb_mask;
DecodeStatus S = MCDisassembler_Success;
if (lsb > msb) {
Check(&S, MCDisassembler_SoftFail);
// The check above will cause the warning for the "potentially undefined
// instruction encoding" but we can't build a bad MCOperand value here
// with a lsb > msb or else printing the MCInst will cause a crash.
lsb = msb;
}
msb_mask = 0xFFFFFFFF;
if (msb != 31) msb_mask = (1U << (msb+1)) - 1;
lsb_mask = (1U << lsb) - 1;
MCInst_addOperand(Inst, MCOperand_CreateImm(~(msb_mask ^ lsb_mask)));
return S;
}
static DecodeStatus DecodeCopMemInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned CRd = fieldFromInstruction_4(Insn, 12, 4);
unsigned coproc = fieldFromInstruction_4(Insn, 8, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 8);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
switch (MCInst_getOpcode(Inst)) {
case ARM_LDC_OFFSET:
case ARM_LDC_PRE:
case ARM_LDC_POST:
case ARM_LDC_OPTION:
case ARM_LDCL_OFFSET:
case ARM_LDCL_PRE:
case ARM_LDCL_POST:
case ARM_LDCL_OPTION:
case ARM_STC_OFFSET:
case ARM_STC_PRE:
case ARM_STC_POST:
case ARM_STC_OPTION:
case ARM_STCL_OFFSET:
case ARM_STCL_PRE:
case ARM_STCL_POST:
case ARM_STCL_OPTION:
case ARM_t2LDC_OFFSET:
case ARM_t2LDC_PRE:
case ARM_t2LDC_POST:
case ARM_t2LDC_OPTION:
case ARM_t2LDCL_OFFSET:
case ARM_t2LDCL_PRE:
case ARM_t2LDCL_POST:
case ARM_t2LDCL_OPTION:
case ARM_t2STC_OFFSET:
case ARM_t2STC_PRE:
case ARM_t2STC_POST:
case ARM_t2STC_OPTION:
case ARM_t2STCL_OFFSET:
case ARM_t2STCL_PRE:
case ARM_t2STCL_POST:
case ARM_t2STCL_OPTION:
if (coproc == 0xA || coproc == 0xB)
return MCDisassembler_Fail;
break;
default:
break;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(coproc));
MCInst_addOperand(Inst, MCOperand_CreateImm(CRd));
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDC2_OFFSET:
case ARM_t2LDC2L_OFFSET:
case ARM_t2LDC2_PRE:
case ARM_t2LDC2L_PRE:
case ARM_t2STC2_OFFSET:
case ARM_t2STC2L_OFFSET:
case ARM_t2STC2_PRE:
case ARM_t2STC2L_PRE:
case ARM_LDC2_OFFSET:
case ARM_LDC2L_OFFSET:
case ARM_LDC2_PRE:
case ARM_LDC2L_PRE:
case ARM_STC2_OFFSET:
case ARM_STC2L_OFFSET:
case ARM_STC2_PRE:
case ARM_STC2L_PRE:
case ARM_t2LDC_OFFSET:
case ARM_t2LDCL_OFFSET:
case ARM_t2LDC_PRE:
case ARM_t2LDCL_PRE:
case ARM_t2STC_OFFSET:
case ARM_t2STCL_OFFSET:
case ARM_t2STC_PRE:
case ARM_t2STCL_PRE:
case ARM_LDC_OFFSET:
case ARM_LDCL_OFFSET:
case ARM_LDC_PRE:
case ARM_LDCL_PRE:
case ARM_STC_OFFSET:
case ARM_STCL_OFFSET:
case ARM_STC_PRE:
case ARM_STCL_PRE:
imm = ARM_AM_getAM5Opc(U ? ARM_AM_add : ARM_AM_sub, (unsigned char)imm);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
break;
case ARM_t2LDC2_POST:
case ARM_t2LDC2L_POST:
case ARM_t2STC2_POST:
case ARM_t2STC2L_POST:
case ARM_LDC2_POST:
case ARM_LDC2L_POST:
case ARM_STC2_POST:
case ARM_STC2L_POST:
case ARM_t2LDC_POST:
case ARM_t2LDCL_POST:
case ARM_t2STC_POST:
case ARM_t2STCL_POST:
case ARM_LDC_POST:
case ARM_LDCL_POST:
case ARM_STC_POST:
case ARM_STCL_POST:
imm |= U << 8;
// fall through.
default:
// The 'option' variant doesn't encode 'U' in the immediate since
// the immediate is unsigned [0,255].
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
break;
}
switch (MCInst_getOpcode(Inst)) {
case ARM_LDC_OFFSET:
case ARM_LDC_PRE:
case ARM_LDC_POST:
case ARM_LDC_OPTION:
case ARM_LDCL_OFFSET:
case ARM_LDCL_PRE:
case ARM_LDCL_POST:
case ARM_LDCL_OPTION:
case ARM_STC_OFFSET:
case ARM_STC_PRE:
case ARM_STC_POST:
case ARM_STC_OPTION:
case ARM_STCL_OFFSET:
case ARM_STCL_PRE:
case ARM_STCL_POST:
case ARM_STCL_OPTION:
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
return S;
}
static DecodeStatus DecodeAddrMode2IdxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_AddrOpc Op;
ARM_AM_ShiftOpc Opc;
bool writeback;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned reg = fieldFromInstruction_4(Insn, 25, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned idx_mode = 0, amt, tmp;
// On stores, the writeback operand precedes Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_STR_POST_IMM:
case ARM_STR_POST_REG:
case ARM_STRB_POST_IMM:
case ARM_STRB_POST_REG:
case ARM_STRT_POST_REG:
case ARM_STRT_POST_IMM:
case ARM_STRBT_POST_REG:
case ARM_STRBT_POST_IMM:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
// On loads, the writeback operand comes after Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_LDR_POST_IMM:
case ARM_LDR_POST_REG:
case ARM_LDRB_POST_IMM:
case ARM_LDRB_POST_REG:
case ARM_LDRBT_POST_REG:
case ARM_LDRBT_POST_IMM:
case ARM_LDRT_POST_REG:
case ARM_LDRT_POST_IMM:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
Op = ARM_AM_add;
if (!fieldFromInstruction_4(Insn, 23, 1))
Op = ARM_AM_sub;
writeback = (P == 0) || (W == 1);
if (P && writeback)
idx_mode = ARMII_IndexModePre;
else if (!P && writeback)
idx_mode = ARMII_IndexModePost;
if (writeback && (Rn == 15 || Rn == Rt))
S = MCDisassembler_SoftFail; // UNPREDICTABLE
if (reg) {
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
Opc = ARM_AM_lsl;
switch( fieldFromInstruction_4(Insn, 5, 2)) {
case 0:
Opc = ARM_AM_lsl;
break;
case 1:
Opc = ARM_AM_lsr;
break;
case 2:
Opc = ARM_AM_asr;
break;
case 3:
Opc = ARM_AM_ror;
break;
default:
return MCDisassembler_Fail;
}
amt = fieldFromInstruction_4(Insn, 7, 5);
if (Opc == ARM_AM_ror && amt == 0)
Opc = ARM_AM_rrx;
imm = ARM_AM_getAM2Opc(Op, amt, Opc, idx_mode);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
} else {
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
tmp = ARM_AM_getAM2Opc(Op, imm, ARM_AM_lsl, idx_mode);
MCInst_addOperand(Inst, MCOperand_CreateImm(tmp));
}
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc ShOp;
unsigned shift;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldFromInstruction_4(Val, 5, 2);
unsigned imm = fieldFromInstruction_4(Val, 7, 5);
unsigned U = fieldFromInstruction_4(Val, 12, 1);
ShOp = ARM_AM_lsl;
switch (type) {
case 0:
ShOp = ARM_AM_lsl;
break;
case 1:
ShOp = ARM_AM_lsr;
break;
case 2:
ShOp = ARM_AM_asr;
break;
case 3:
ShOp = ARM_AM_ror;
break;
}
if (ShOp == ARM_AM_ror && imm == 0)
ShOp = ARM_AM_rrx;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (U)
shift = ARM_AM_getAM2Opc(ARM_AM_add, imm, ShOp, 0);
else
shift = ARM_AM_getAM2Opc(ARM_AM_sub, imm, ShOp, 0);
MCInst_addOperand(Inst, MCOperand_CreateImm(shift));
return S;
}
static DecodeStatus DecodeAddrMode3Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned type = fieldFromInstruction_4(Insn, 22, 1);
unsigned imm = fieldFromInstruction_4(Insn, 8, 4);
unsigned U = ((~fieldFromInstruction_4(Insn, 23, 1)) & 1) << 8;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
unsigned Rt2 = Rt + 1;
bool writeback = (W == 1) | (P == 0);
// For {LD,ST}RD, Rt must be even, else undefined.
switch (MCInst_getOpcode(Inst)) {
case ARM_STRD:
case ARM_STRD_PRE:
case ARM_STRD_POST:
case ARM_LDRD:
case ARM_LDRD_PRE:
case ARM_LDRD_POST:
if (Rt & 0x1) S = MCDisassembler_SoftFail;
break;
default:
break;
}
switch (MCInst_getOpcode(Inst)) {
case ARM_STRD:
case ARM_STRD_PRE:
case ARM_STRD_POST:
if (P == 0 && W == 1)
S = MCDisassembler_SoftFail;
if (writeback && (Rn == 15 || Rn == Rt || Rn == Rt2))
S = MCDisassembler_SoftFail;
if (type && Rm == 15)
S = MCDisassembler_SoftFail;
if (Rt2 == 15)
S = MCDisassembler_SoftFail;
if (!type && fieldFromInstruction_4(Insn, 8, 4))
S = MCDisassembler_SoftFail;
break;
case ARM_STRH:
case ARM_STRH_PRE:
case ARM_STRH_POST:
if (Rt == 15)
S = MCDisassembler_SoftFail;
if (writeback && (Rn == 15 || Rn == Rt))
S = MCDisassembler_SoftFail;
if (!type && Rm == 15)
S = MCDisassembler_SoftFail;
break;
case ARM_LDRD:
case ARM_LDRD_PRE:
case ARM_LDRD_POST:
if (type && Rn == 15){
if (Rt2 == 15)
S = MCDisassembler_SoftFail;
break;
}
if (P == 0 && W == 1)
S = MCDisassembler_SoftFail;
if (!type && (Rt2 == 15 || Rm == 15 || Rm == Rt || Rm == Rt2))
S = MCDisassembler_SoftFail;
if (!type && writeback && Rn == 15)
S = MCDisassembler_SoftFail;
if (writeback && (Rn == Rt || Rn == Rt2))
S = MCDisassembler_SoftFail;
break;
case ARM_LDRH:
case ARM_LDRH_PRE:
case ARM_LDRH_POST:
if (type && Rn == 15){
if (Rt == 15)
S = MCDisassembler_SoftFail;
break;
}
if (Rt == 15)
S = MCDisassembler_SoftFail;
if (!type && Rm == 15)
S = MCDisassembler_SoftFail;
if (!type && writeback && (Rn == 15 || Rn == Rt))
S = MCDisassembler_SoftFail;
break;
case ARM_LDRSH:
case ARM_LDRSH_PRE:
case ARM_LDRSH_POST:
case ARM_LDRSB:
case ARM_LDRSB_PRE:
case ARM_LDRSB_POST:
if (type && Rn == 15){
if (Rt == 15)
S = MCDisassembler_SoftFail;
break;
}
if (type && (Rt == 15 || (writeback && Rn == Rt)))
S = MCDisassembler_SoftFail;
if (!type && (Rt == 15 || Rm == 15))
S = MCDisassembler_SoftFail;
if (!type && writeback && (Rn == 15 || Rn == Rt))
S = MCDisassembler_SoftFail;
break;
default:
break;
}
if (writeback) { // Writeback
if (P)
U |= ARMII_IndexModePre << 9;
else
U |= ARMII_IndexModePost << 9;
// On stores, the writeback operand precedes Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_STRD:
case ARM_STRD_PRE:
case ARM_STRD_POST:
case ARM_STRH:
case ARM_STRH_PRE:
case ARM_STRH_POST:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
switch (MCInst_getOpcode(Inst)) {
case ARM_STRD:
case ARM_STRD_PRE:
case ARM_STRD_POST:
case ARM_LDRD:
case ARM_LDRD_PRE:
case ARM_LDRD_POST:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt+1, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
if (writeback) {
// On loads, the writeback operand comes after Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_LDRD:
case ARM_LDRD_PRE:
case ARM_LDRD_POST:
case ARM_LDRH:
case ARM_LDRH_PRE:
case ARM_LDRH_POST:
case ARM_LDRSH:
case ARM_LDRSH_PRE:
case ARM_LDRSH_POST:
case ARM_LDRSB:
case ARM_LDRSB_PRE:
case ARM_LDRSB_POST:
case ARM_LDRHTr:
case ARM_LDRSBTr:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (type) {
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
MCInst_addOperand(Inst, MCOperand_CreateImm(U | (imm << 4) | Rm));
} else {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(U));
}
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeRFEInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned mode = fieldFromInstruction_4(Insn, 23, 2);
switch (mode) {
case 0:
mode = ARM_AM_da;
break;
case 1:
mode = ARM_AM_ia;
break;
case 2:
mode = ARM_AM_db;
break;
case 3:
mode = ARM_AM_ib;
break;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeQADDInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (pred == 0xF)
return DecodeCPSInstruction(Inst, Insn, Address, Decoder);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeMemMultipleWritebackInstruction(MCInst *Inst,
unsigned Insn, uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned reglist = fieldFromInstruction_4(Insn, 0, 16);
if (pred == 0xF) {
// Ambiguous with RFE and SRS
switch (MCInst_getOpcode(Inst)) {
case ARM_LDMDA:
MCInst_setOpcode(Inst, ARM_RFEDA);
break;
case ARM_LDMDA_UPD:
MCInst_setOpcode(Inst, ARM_RFEDA_UPD);
break;
case ARM_LDMDB:
MCInst_setOpcode(Inst, ARM_RFEDB);
break;
case ARM_LDMDB_UPD:
MCInst_setOpcode(Inst, ARM_RFEDB_UPD);
break;
case ARM_LDMIA:
MCInst_setOpcode(Inst, ARM_RFEIA);
break;
case ARM_LDMIA_UPD:
MCInst_setOpcode(Inst, ARM_RFEIA_UPD);
break;
case ARM_LDMIB:
MCInst_setOpcode(Inst, ARM_RFEIB);
break;
case ARM_LDMIB_UPD:
MCInst_setOpcode(Inst, ARM_RFEIB_UPD);
break;
case ARM_STMDA:
MCInst_setOpcode(Inst, ARM_SRSDA);
break;
case ARM_STMDA_UPD:
MCInst_setOpcode(Inst, ARM_SRSDA_UPD);
break;
case ARM_STMDB:
MCInst_setOpcode(Inst, ARM_SRSDB);
break;
case ARM_STMDB_UPD:
MCInst_setOpcode(Inst, ARM_SRSDB_UPD);
break;
case ARM_STMIA:
MCInst_setOpcode(Inst, ARM_SRSIA);
break;
case ARM_STMIA_UPD:
MCInst_setOpcode(Inst, ARM_SRSIA_UPD);
break;
case ARM_STMIB:
MCInst_setOpcode(Inst, ARM_SRSIB);
break;
case ARM_STMIB_UPD:
MCInst_setOpcode(Inst, ARM_SRSIB_UPD);
break;
default:
return MCDisassembler_Fail;
}
// For stores (which become SRS's, the only operand is the mode.
if (fieldFromInstruction_4(Insn, 20, 1) == 0) {
// Check SRS encoding constraints
if (!(fieldFromInstruction_4(Insn, 22, 1) == 1 &&
fieldFromInstruction_4(Insn, 20, 1) == 0))
return MCDisassembler_Fail;
MCInst_addOperand(Inst,
MCOperand_CreateImm(fieldFromInstruction_4(Insn, 0, 4)));
return S;
}
return DecodeRFEInstruction(Inst, Insn, Address, Decoder);
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail; // Tied
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeRegListOperand(Inst, reglist, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeCPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned imod = fieldFromInstruction_4(Insn, 18, 2);
unsigned M = fieldFromInstruction_4(Insn, 17, 1);
unsigned iflags = fieldFromInstruction_4(Insn, 6, 3);
unsigned mode = fieldFromInstruction_4(Insn, 0, 5);
DecodeStatus S = MCDisassembler_Success;
// This decoder is called from multiple location that do not check
// the full encoding is valid before they do.
if (fieldFromInstruction_4(Insn, 5, 1) != 0 ||
fieldFromInstruction_4(Insn, 16, 1) != 0 ||
fieldFromInstruction_4(Insn, 20, 8) != 0x10)
return MCDisassembler_Fail;
// imod == '01' --> UNPREDICTABLE
// NOTE: Even though this is technically UNPREDICTABLE, we choose to
// return failure here. The '01' imod value is unprintable, so there's
// nothing useful we could do even if we returned UNPREDICTABLE.
if (imod == 1) return MCDisassembler_Fail;
if (imod && M) {
MCInst_setOpcode(Inst, ARM_CPS3p);
MCInst_addOperand(Inst, MCOperand_CreateImm(imod));
MCInst_addOperand(Inst, MCOperand_CreateImm(iflags));
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
} else if (imod && !M) {
MCInst_setOpcode(Inst, ARM_CPS2p);
MCInst_addOperand(Inst, MCOperand_CreateImm(imod));
MCInst_addOperand(Inst, MCOperand_CreateImm(iflags));
if (mode) S = MCDisassembler_SoftFail;
} else if (!imod && M) {
MCInst_setOpcode(Inst, ARM_CPS1p);
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
if (iflags) S = MCDisassembler_SoftFail;
} else {
// imod == '00' && M == '0' --> UNPREDICTABLE
MCInst_setOpcode(Inst, ARM_CPS1p);
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
S = MCDisassembler_SoftFail;
}
return S;
}
static DecodeStatus DecodeT2CPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned imod = fieldFromInstruction_4(Insn, 9, 2);
unsigned M = fieldFromInstruction_4(Insn, 8, 1);
unsigned iflags = fieldFromInstruction_4(Insn, 5, 3);
unsigned mode = fieldFromInstruction_4(Insn, 0, 5);
DecodeStatus S = MCDisassembler_Success;
// imod == '01' --> UNPREDICTABLE
// NOTE: Even though this is technically UNPREDICTABLE, we choose to
// return failure here. The '01' imod value is unprintable, so there's
// nothing useful we could do even if we returned UNPREDICTABLE.
if (imod == 1) return MCDisassembler_Fail;
if (imod && M) {
MCInst_setOpcode(Inst, ARM_t2CPS3p);
MCInst_addOperand(Inst, MCOperand_CreateImm(imod));
MCInst_addOperand(Inst, MCOperand_CreateImm(iflags));
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
} else if (imod && !M) {
MCInst_setOpcode(Inst, ARM_t2CPS2p);
MCInst_addOperand(Inst, MCOperand_CreateImm(imod));
MCInst_addOperand(Inst, MCOperand_CreateImm(iflags));
if (mode) S = MCDisassembler_SoftFail;
} else if (!imod && M) {
MCInst_setOpcode(Inst, ARM_t2CPS1p);
MCInst_addOperand(Inst, MCOperand_CreateImm(mode));
if (iflags) S = MCDisassembler_SoftFail;
} else {
// imod == '00' && M == '0' --> this is a HINT instruction
int imm = fieldFromInstruction_4(Insn, 0, 8);
// HINT are defined only for immediate in [0..4]
if(imm > 4) return MCDisassembler_Fail;
MCInst_setOpcode(Inst, ARM_t2HINT);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
}
return S;
}
static DecodeStatus DecodeT2MOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 8, 4);
unsigned imm = 0;
imm |= (fieldFromInstruction_4(Insn, 0, 8) << 0);
imm |= (fieldFromInstruction_4(Insn, 12, 3) << 8);
imm |= (fieldFromInstruction_4(Insn, 16, 4) << 12);
imm |= (fieldFromInstruction_4(Insn, 26, 1) << 11);
if (MCInst_getOpcode(Inst) == ARM_t2MOVTi16)
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = 0;
imm |= (fieldFromInstruction_4(Insn, 0, 12) << 0);
imm |= (fieldFromInstruction_4(Insn, 16, 4) << 12);
if (MCInst_getOpcode(Inst) == ARM_MOVTi16)
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeSMLAInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 8, 4);
unsigned Ra = fieldFromInstruction_4(Insn, 12, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (pred == 0xF)
return DecodeCPSInstruction(Inst, Insn, Address, Decoder);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Ra, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeAddrModeImm12Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned add = fieldFromInstruction_4(Val, 12, 1);
unsigned imm = fieldFromInstruction_4(Val, 0, 12);
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!add) imm *= (unsigned int)-1;
if (imm == 0 && !add) imm = (unsigned int)INT32_MIN;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
//if (Rn == 15)
// tryAddingPcLoadReferenceComment(Address, Address + imm + 8, Decoder);
return S;
}
static DecodeStatus DecodeAddrMode5Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 9, 4);
unsigned U = fieldFromInstruction_4(Val, 8, 1);
unsigned imm = fieldFromInstruction_4(Val, 0, 8);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (U)
MCInst_addOperand(Inst, MCOperand_CreateImm(ARM_AM_getAM5Opc(ARM_AM_add, (unsigned char)imm)));
else
MCInst_addOperand(Inst, MCOperand_CreateImm(ARM_AM_getAM5Opc(ARM_AM_sub, (unsigned char)imm)));
return S;
}
static DecodeStatus DecodeAddrMode7Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
return DecodeGPRRegisterClass(Inst, Val, Address, Decoder);
}
static DecodeStatus DecodeT2BInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus Status = MCDisassembler_Success;
// Note the J1 and J2 values are from the encoded instruction. So here
// change them to I1 and I2 values via as documented:
// I1 = NOT(J1 EOR S);
// I2 = NOT(J2 EOR S);
// and build the imm32 with one trailing zero as documented:
// imm32 = SignExtend(S:I1:I2:imm10:imm11:'0', 32);
unsigned S = fieldFromInstruction_4(Insn, 26, 1);
unsigned J1 = fieldFromInstruction_4(Insn, 13, 1);
unsigned J2 = fieldFromInstruction_4(Insn, 11, 1);
unsigned I1 = !(J1 ^ S);
unsigned I2 = !(J2 ^ S);
unsigned imm10 = fieldFromInstruction_4(Insn, 16, 10);
unsigned imm11 = fieldFromInstruction_4(Insn, 0, 11);
unsigned tmp = (S << 23) | (I1 << 22) | (I2 << 21) | (imm10 << 11) | imm11;
int imm32 = SignExtend32(tmp << 1, 25);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm32));
return Status;
}
static DecodeStatus DecodeBranchImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 24) << 2;
if (pred == 0xF) {
MCInst_setOpcode(Inst, ARM_BLXi);
imm |= fieldFromInstruction_4(Insn, 24, 1) << 1;
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(imm, 26)));
return S;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(imm, 26)));
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeAddrMode6Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned align = fieldFromInstruction_4(Val, 4, 2);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (!align)
MCInst_addOperand(Inst, MCOperand_CreateImm(0));
else
MCInst_addOperand(Inst, MCOperand_CreateImm(4 << align));
return S;
}
static DecodeStatus DecodeVLDInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned wb, Rn, Rm;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
wb = fieldFromInstruction_4(Insn, 16, 4);
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rn |= fieldFromInstruction_4(Insn, 4, 2) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4);
// First output register
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD1q16: case ARM_VLD1q32: case ARM_VLD1q64: case ARM_VLD1q8:
case ARM_VLD1q16wb_fixed: case ARM_VLD1q16wb_register:
case ARM_VLD1q32wb_fixed: case ARM_VLD1q32wb_register:
case ARM_VLD1q64wb_fixed: case ARM_VLD1q64wb_register:
case ARM_VLD1q8wb_fixed: case ARM_VLD1q8wb_register:
case ARM_VLD2d16: case ARM_VLD2d32: case ARM_VLD2d8:
case ARM_VLD2d16wb_fixed: case ARM_VLD2d16wb_register:
case ARM_VLD2d32wb_fixed: case ARM_VLD2d32wb_register:
case ARM_VLD2d8wb_fixed: case ARM_VLD2d8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD2b16:
case ARM_VLD2b32:
case ARM_VLD2b8:
case ARM_VLD2b16wb_fixed:
case ARM_VLD2b16wb_register:
case ARM_VLD2b32wb_fixed:
case ARM_VLD2b32wb_register:
case ARM_VLD2b8wb_fixed:
case ARM_VLD2b8wb_register:
if (!Check(&S, DecodeDPairSpacedRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
}
// Second output register
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD3d8:
case ARM_VLD3d16:
case ARM_VLD3d32:
case ARM_VLD3d8_UPD:
case ARM_VLD3d16_UPD:
case ARM_VLD3d32_UPD:
case ARM_VLD4d8:
case ARM_VLD4d16:
case ARM_VLD4d32:
case ARM_VLD4d8_UPD:
case ARM_VLD4d16_UPD:
case ARM_VLD4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+1)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD3q8:
case ARM_VLD3q16:
case ARM_VLD3q32:
case ARM_VLD3q8_UPD:
case ARM_VLD3q16_UPD:
case ARM_VLD3q32_UPD:
case ARM_VLD4q8:
case ARM_VLD4q16:
case ARM_VLD4q32:
case ARM_VLD4q8_UPD:
case ARM_VLD4q16_UPD:
case ARM_VLD4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder)))
return MCDisassembler_Fail;
default:
break;
}
// Third output register
switch(MCInst_getOpcode(Inst)) {
case ARM_VLD3d8:
case ARM_VLD3d16:
case ARM_VLD3d32:
case ARM_VLD3d8_UPD:
case ARM_VLD3d16_UPD:
case ARM_VLD3d32_UPD:
case ARM_VLD4d8:
case ARM_VLD4d16:
case ARM_VLD4d32:
case ARM_VLD4d8_UPD:
case ARM_VLD4d16_UPD:
case ARM_VLD4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD3q8:
case ARM_VLD3q16:
case ARM_VLD3q32:
case ARM_VLD3q8_UPD:
case ARM_VLD3q16_UPD:
case ARM_VLD3q32_UPD:
case ARM_VLD4q8:
case ARM_VLD4q16:
case ARM_VLD4q32:
case ARM_VLD4q8_UPD:
case ARM_VLD4q16_UPD:
case ARM_VLD4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+4)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// Fourth output register
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD4d8:
case ARM_VLD4d16:
case ARM_VLD4d32:
case ARM_VLD4d8_UPD:
case ARM_VLD4d16_UPD:
case ARM_VLD4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+3)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD4q8:
case ARM_VLD4q16:
case ARM_VLD4q32:
case ARM_VLD4q8_UPD:
case ARM_VLD4q16_UPD:
case ARM_VLD4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+6)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// Writeback operand
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD1d8wb_fixed:
case ARM_VLD1d16wb_fixed:
case ARM_VLD1d32wb_fixed:
case ARM_VLD1d64wb_fixed:
case ARM_VLD1d8wb_register:
case ARM_VLD1d16wb_register:
case ARM_VLD1d32wb_register:
case ARM_VLD1d64wb_register:
case ARM_VLD1q8wb_fixed:
case ARM_VLD1q16wb_fixed:
case ARM_VLD1q32wb_fixed:
case ARM_VLD1q64wb_fixed:
case ARM_VLD1q8wb_register:
case ARM_VLD1q16wb_register:
case ARM_VLD1q32wb_register:
case ARM_VLD1q64wb_register:
case ARM_VLD1d8Twb_fixed:
case ARM_VLD1d8Twb_register:
case ARM_VLD1d16Twb_fixed:
case ARM_VLD1d16Twb_register:
case ARM_VLD1d32Twb_fixed:
case ARM_VLD1d32Twb_register:
case ARM_VLD1d64Twb_fixed:
case ARM_VLD1d64Twb_register:
case ARM_VLD1d8Qwb_fixed:
case ARM_VLD1d8Qwb_register:
case ARM_VLD1d16Qwb_fixed:
case ARM_VLD1d16Qwb_register:
case ARM_VLD1d32Qwb_fixed:
case ARM_VLD1d32Qwb_register:
case ARM_VLD1d64Qwb_fixed:
case ARM_VLD1d64Qwb_register:
case ARM_VLD2d8wb_fixed:
case ARM_VLD2d16wb_fixed:
case ARM_VLD2d32wb_fixed:
case ARM_VLD2q8wb_fixed:
case ARM_VLD2q16wb_fixed:
case ARM_VLD2q32wb_fixed:
case ARM_VLD2d8wb_register:
case ARM_VLD2d16wb_register:
case ARM_VLD2d32wb_register:
case ARM_VLD2q8wb_register:
case ARM_VLD2q16wb_register:
case ARM_VLD2q32wb_register:
case ARM_VLD2b8wb_fixed:
case ARM_VLD2b16wb_fixed:
case ARM_VLD2b32wb_fixed:
case ARM_VLD2b8wb_register:
case ARM_VLD2b16wb_register:
case ARM_VLD2b32wb_register:
MCInst_addOperand(Inst, MCOperand_CreateImm(0));
break;
case ARM_VLD3d8_UPD:
case ARM_VLD3d16_UPD:
case ARM_VLD3d32_UPD:
case ARM_VLD3q8_UPD:
case ARM_VLD3q16_UPD:
case ARM_VLD3q32_UPD:
case ARM_VLD4d8_UPD:
case ARM_VLD4d16_UPD:
case ARM_VLD4d32_UPD:
case ARM_VLD4q8_UPD:
case ARM_VLD4q16_UPD:
case ARM_VLD4q32_UPD:
if (!Check(&S, DecodeGPRRegisterClass(Inst, wb, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// AddrMode6 Base (register+alignment)
if (!Check(&S, DecodeAddrMode6Operand(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
// AddrMode6 Offset (register)
switch (MCInst_getOpcode(Inst)) {
default:
// The below have been updated to have explicit am6offset split
// between fixed and register offset. For those instructions not
// yet updated, we need to add an additional reg0 operand for the
// fixed variant.
//
// The fixed offset encodes as Rm == 0xd, so we check for that.
if (Rm == 0xd) {
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
break;
}
// Fall through to handle the register offset variant.
case ARM_VLD1d8wb_fixed:
case ARM_VLD1d16wb_fixed:
case ARM_VLD1d32wb_fixed:
case ARM_VLD1d64wb_fixed:
case ARM_VLD1d8Twb_fixed:
case ARM_VLD1d16Twb_fixed:
case ARM_VLD1d32Twb_fixed:
case ARM_VLD1d64Twb_fixed:
case ARM_VLD1d8Qwb_fixed:
case ARM_VLD1d16Qwb_fixed:
case ARM_VLD1d32Qwb_fixed:
case ARM_VLD1d64Qwb_fixed:
case ARM_VLD1d8wb_register:
case ARM_VLD1d16wb_register:
case ARM_VLD1d32wb_register:
case ARM_VLD1d64wb_register:
case ARM_VLD1q8wb_fixed:
case ARM_VLD1q16wb_fixed:
case ARM_VLD1q32wb_fixed:
case ARM_VLD1q64wb_fixed:
case ARM_VLD1q8wb_register:
case ARM_VLD1q16wb_register:
case ARM_VLD1q32wb_register:
case ARM_VLD1q64wb_register:
// The fixed offset post-increment encodes Rm == 0xd. The no-writeback
// variant encodes Rm == 0xf. Anything else is a register offset post-
// increment and we need to add the register operand to the instruction.
if (Rm != 0xD && Rm != 0xF &&
!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD2d8wb_fixed:
case ARM_VLD2d16wb_fixed:
case ARM_VLD2d32wb_fixed:
case ARM_VLD2b8wb_fixed:
case ARM_VLD2b16wb_fixed:
case ARM_VLD2b32wb_fixed:
case ARM_VLD2q8wb_fixed:
case ARM_VLD2q16wb_fixed:
case ARM_VLD2q32wb_fixed:
break;
}
return S;
}
static DecodeStatus DecodeVLDST1Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned load;
unsigned type = fieldFromInstruction_4(Insn, 8, 4);
unsigned align = fieldFromInstruction_4(Insn, 4, 2);
if (type == 6 && (align & 2)) return MCDisassembler_Fail;
if (type == 7 && (align & 2)) return MCDisassembler_Fail;
if (type == 10 && align == 3) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
}
static DecodeStatus DecodeVLDST2Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned type, align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
type = fieldFromInstruction_4(Insn, 8, 4);
align = fieldFromInstruction_4(Insn, 4, 2);
if (type == 8 && align == 3) return MCDisassembler_Fail;
if (type == 9 && align == 3) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
}
static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
align = fieldFromInstruction_4(Insn, 4, 2);
if (align & 2) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
}
static DecodeStatus DecodeVLDST4Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
}
static DecodeStatus DecodeVSTInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned wb, Rn, Rm;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
wb = fieldFromInstruction_4(Insn, 16, 4);
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rn |= fieldFromInstruction_4(Insn, 4, 2) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4);
// Writeback Operand
switch (MCInst_getOpcode(Inst)) {
case ARM_VST1d8wb_fixed:
case ARM_VST1d16wb_fixed:
case ARM_VST1d32wb_fixed:
case ARM_VST1d64wb_fixed:
case ARM_VST1d8wb_register:
case ARM_VST1d16wb_register:
case ARM_VST1d32wb_register:
case ARM_VST1d64wb_register:
case ARM_VST1q8wb_fixed:
case ARM_VST1q16wb_fixed:
case ARM_VST1q32wb_fixed:
case ARM_VST1q64wb_fixed:
case ARM_VST1q8wb_register:
case ARM_VST1q16wb_register:
case ARM_VST1q32wb_register:
case ARM_VST1q64wb_register:
case ARM_VST1d8Twb_fixed:
case ARM_VST1d16Twb_fixed:
case ARM_VST1d32Twb_fixed:
case ARM_VST1d64Twb_fixed:
case ARM_VST1d8Twb_register:
case ARM_VST1d16Twb_register:
case ARM_VST1d32Twb_register:
case ARM_VST1d64Twb_register:
case ARM_VST1d8Qwb_fixed:
case ARM_VST1d16Qwb_fixed:
case ARM_VST1d32Qwb_fixed:
case ARM_VST1d64Qwb_fixed:
case ARM_VST1d8Qwb_register:
case ARM_VST1d16Qwb_register:
case ARM_VST1d32Qwb_register:
case ARM_VST1d64Qwb_register:
case ARM_VST2d8wb_fixed:
case ARM_VST2d16wb_fixed:
case ARM_VST2d32wb_fixed:
case ARM_VST2d8wb_register:
case ARM_VST2d16wb_register:
case ARM_VST2d32wb_register:
case ARM_VST2q8wb_fixed:
case ARM_VST2q16wb_fixed:
case ARM_VST2q32wb_fixed:
case ARM_VST2q8wb_register:
case ARM_VST2q16wb_register:
case ARM_VST2q32wb_register:
case ARM_VST2b8wb_fixed:
case ARM_VST2b16wb_fixed:
case ARM_VST2b32wb_fixed:
case ARM_VST2b8wb_register:
case ARM_VST2b16wb_register:
case ARM_VST2b32wb_register:
if (Rm == 0xF)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(0));
break;
case ARM_VST3d8_UPD:
case ARM_VST3d16_UPD:
case ARM_VST3d32_UPD:
case ARM_VST3q8_UPD:
case ARM_VST3q16_UPD:
case ARM_VST3q32_UPD:
case ARM_VST4d8_UPD:
case ARM_VST4d16_UPD:
case ARM_VST4d32_UPD:
case ARM_VST4q8_UPD:
case ARM_VST4q16_UPD:
case ARM_VST4q32_UPD:
if (!Check(&S, DecodeGPRRegisterClass(Inst, wb, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// AddrMode6 Base (register+alignment)
if (!Check(&S, DecodeAddrMode6Operand(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
// AddrMode6 Offset (register)
switch (MCInst_getOpcode(Inst)) {
default:
if (Rm == 0xD)
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
else if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
break;
case ARM_VST1d8wb_fixed:
case ARM_VST1d16wb_fixed:
case ARM_VST1d32wb_fixed:
case ARM_VST1d64wb_fixed:
case ARM_VST1q8wb_fixed:
case ARM_VST1q16wb_fixed:
case ARM_VST1q32wb_fixed:
case ARM_VST1q64wb_fixed:
case ARM_VST1d8Twb_fixed:
case ARM_VST1d16Twb_fixed:
case ARM_VST1d32Twb_fixed:
case ARM_VST1d64Twb_fixed:
case ARM_VST1d8Qwb_fixed:
case ARM_VST1d16Qwb_fixed:
case ARM_VST1d32Qwb_fixed:
case ARM_VST1d64Qwb_fixed:
case ARM_VST2d8wb_fixed:
case ARM_VST2d16wb_fixed:
case ARM_VST2d32wb_fixed:
case ARM_VST2q8wb_fixed:
case ARM_VST2q16wb_fixed:
case ARM_VST2q32wb_fixed:
case ARM_VST2b8wb_fixed:
case ARM_VST2b16wb_fixed:
case ARM_VST2b32wb_fixed:
break;
}
// First input register
switch (MCInst_getOpcode(Inst)) {
case ARM_VST1q16:
case ARM_VST1q32:
case ARM_VST1q64:
case ARM_VST1q8:
case ARM_VST1q16wb_fixed:
case ARM_VST1q16wb_register:
case ARM_VST1q32wb_fixed:
case ARM_VST1q32wb_register:
case ARM_VST1q64wb_fixed:
case ARM_VST1q64wb_register:
case ARM_VST1q8wb_fixed:
case ARM_VST1q8wb_register:
case ARM_VST2d16:
case ARM_VST2d32:
case ARM_VST2d8:
case ARM_VST2d16wb_fixed:
case ARM_VST2d16wb_register:
case ARM_VST2d32wb_fixed:
case ARM_VST2d32wb_register:
case ARM_VST2d8wb_fixed:
case ARM_VST2d8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VST2b16:
case ARM_VST2b32:
case ARM_VST2b8:
case ARM_VST2b16wb_fixed:
case ARM_VST2b16wb_register:
case ARM_VST2b32wb_fixed:
case ARM_VST2b32wb_register:
case ARM_VST2b8wb_fixed:
case ARM_VST2b8wb_register:
if (!Check(&S, DecodeDPairSpacedRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
}
// Second input register
switch (MCInst_getOpcode(Inst)) {
case ARM_VST3d8:
case ARM_VST3d16:
case ARM_VST3d32:
case ARM_VST3d8_UPD:
case ARM_VST3d16_UPD:
case ARM_VST3d32_UPD:
case ARM_VST4d8:
case ARM_VST4d16:
case ARM_VST4d32:
case ARM_VST4d8_UPD:
case ARM_VST4d16_UPD:
case ARM_VST4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+1)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VST3q8:
case ARM_VST3q16:
case ARM_VST3q32:
case ARM_VST3q8_UPD:
case ARM_VST3q16_UPD:
case ARM_VST3q32_UPD:
case ARM_VST4q8:
case ARM_VST4q16:
case ARM_VST4q32:
case ARM_VST4q8_UPD:
case ARM_VST4q16_UPD:
case ARM_VST4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// Third input register
switch (MCInst_getOpcode(Inst)) {
case ARM_VST3d8:
case ARM_VST3d16:
case ARM_VST3d32:
case ARM_VST3d8_UPD:
case ARM_VST3d16_UPD:
case ARM_VST3d32_UPD:
case ARM_VST4d8:
case ARM_VST4d16:
case ARM_VST4d32:
case ARM_VST4d8_UPD:
case ARM_VST4d16_UPD:
case ARM_VST4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VST3q8:
case ARM_VST3q16:
case ARM_VST3q32:
case ARM_VST3q8_UPD:
case ARM_VST3q16_UPD:
case ARM_VST3q32_UPD:
case ARM_VST4q8:
case ARM_VST4q16:
case ARM_VST4q32:
case ARM_VST4q8_UPD:
case ARM_VST4q16_UPD:
case ARM_VST4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+4)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
// Fourth input register
switch (MCInst_getOpcode(Inst)) {
case ARM_VST4d8:
case ARM_VST4d16:
case ARM_VST4d32:
case ARM_VST4d8_UPD:
case ARM_VST4d16_UPD:
case ARM_VST4d32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+3)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VST4q8:
case ARM_VST4q16:
case ARM_VST4q32:
case ARM_VST4q8_UPD:
case ARM_VST4q16_UPD:
case ARM_VST4q32_UPD:
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+6)%32, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
return S;
}
static DecodeStatus DecodeVLD1DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, align, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
align = fieldFromInstruction_4(Insn, 4, 1);
size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 0 && align == 1)
return MCDisassembler_Fail;
align *= (1 << size);
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD1DUPq16: case ARM_VLD1DUPq32: case ARM_VLD1DUPq8:
case ARM_VLD1DUPq16wb_fixed: case ARM_VLD1DUPq16wb_register:
case ARM_VLD1DUPq32wb_fixed: case ARM_VLD1DUPq32wb_register:
case ARM_VLD1DUPq8wb_fixed: case ARM_VLD1DUPq8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
}
if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
// The fixed offset post-increment encodes Rm == 0xd. The no-writeback
// variant encodes Rm == 0xf. Anything else is a register offset post-
// increment and we need to add the register operand to the instruction.
if (Rm != 0xD && Rm != 0xF &&
!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeVLD2DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, align, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
align = fieldFromInstruction_4(Insn, 4, 1);
size = 1 << fieldFromInstruction_4(Insn, 6, 2);
align *= 2*size;
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD2DUPd16: case ARM_VLD2DUPd32: case ARM_VLD2DUPd8:
case ARM_VLD2DUPd16wb_fixed: case ARM_VLD2DUPd16wb_register:
case ARM_VLD2DUPd32wb_fixed: case ARM_VLD2DUPd32wb_register:
case ARM_VLD2DUPd8wb_fixed: case ARM_VLD2DUPd8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD2DUPd16x2: case ARM_VLD2DUPd32x2: case ARM_VLD2DUPd8x2:
case ARM_VLD2DUPd16x2wb_fixed: case ARM_VLD2DUPd16x2wb_register:
case ARM_VLD2DUPd32x2wb_fixed: case ARM_VLD2DUPd32x2wb_register:
case ARM_VLD2DUPd8x2wb_fixed: case ARM_VLD2DUPd8x2wb_register:
if (!Check(&S, DecodeDPairSpacedRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
}
if (Rm != 0xF)
MCInst_addOperand(Inst, MCOperand_CreateImm(0));
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xD && Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeVLD3DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, inc;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
inc = fieldFromInstruction_4(Insn, 5, 1) + 1;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+inc)%32, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2*inc)%32, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(0));
if (Rm == 0xD)
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
else if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeVLD4DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, size, inc, align;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
size = fieldFromInstruction_4(Insn, 6, 2);
inc = fieldFromInstruction_4(Insn, 5, 1) + 1;
align = fieldFromInstruction_4(Insn, 4, 1);
if (size == 0x3) {
if (align == 0)
return MCDisassembler_Fail;
align = 16;
} else {
if (size == 2) {
align *= 8;
} else {
size = 1 << size;
align *= 4 * size;
}
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+inc)%32, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+2*inc)%32, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, (Rd+3*inc)%32, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm == 0xD)
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
else if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeNEONModImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned imm, Q;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
imm = fieldFromInstruction_4(Insn, 0, 4);
imm |= fieldFromInstruction_4(Insn, 16, 3) << 4;
imm |= fieldFromInstruction_4(Insn, 24, 1) << 7;
imm |= fieldFromInstruction_4(Insn, 8, 4) << 8;
imm |= fieldFromInstruction_4(Insn, 5, 1) << 12;
Q = fieldFromInstruction_4(Insn, 6, 1);
if (Q) {
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
} else {
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
switch (MCInst_getOpcode(Inst)) {
case ARM_VORRiv4i16:
case ARM_VORRiv2i32:
case ARM_VBICiv4i16:
case ARM_VBICiv2i32:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VORRiv8i16:
case ARM_VORRiv4i32:
case ARM_VBICiv8i16:
case ARM_VBICiv4i32:
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
return S;
}
static DecodeStatus DecodeVSHLMaxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4);
Rm |= fieldFromInstruction_4(Insn, 5, 1) << 4;
size = fieldFromInstruction_4(Insn, 18, 2);
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(8 << size));
return S;
}
static DecodeStatus DecodeShiftRight8Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(8 - Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeShiftRight16Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(16 - Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeShiftRight32Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(32 - Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeShiftRight64Imm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(64 - Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeTBLInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, op;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rn |= fieldFromInstruction_4(Insn, 7, 1) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4);
Rm |= fieldFromInstruction_4(Insn, 5, 1) << 4;
op = fieldFromInstruction_4(Insn, 6, 1);
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (op) {
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail; // Writeback
}
switch (MCInst_getOpcode(Inst)) {
case ARM_VTBL2:
case ARM_VTBX2:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeThumbAddSpecialReg(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned dst = fieldFromInstruction_2(Insn, 8, 3);
unsigned imm = fieldFromInstruction_2(Insn, 0, 8);
if (!Check(&S, DecodetGPRRegisterClass(Inst, dst, Address, Decoder)))
return MCDisassembler_Fail;
switch(MCInst_getOpcode(Inst)) {
default:
return MCDisassembler_Fail;
case ARM_tADR:
break; // tADR does not explicitly represent the PC as an operand.
case ARM_tADDrSPi:
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
break;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeThumbBROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(Val << 1, 12)));
return MCDisassembler_Success;
}
static DecodeStatus DecodeT2BROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(Val, 21)));
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbCmpBROperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(Val << 1));
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbAddrModeRR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 0, 3);
unsigned Rm = fieldFromInstruction_4(Val, 3, 3);
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeThumbAddrModeIS(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 0, 3);
unsigned imm = fieldFromInstruction_4(Val, 3, 5);
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeThumbAddrModePC(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
unsigned imm = Val << 2;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
//tryAddingPcLoadReferenceComment(Address, (Address & ~2u) + imm + 4, Decoder);
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbAddrModeSP(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeT2AddrModeSOReg(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 6, 4);
unsigned Rm = fieldFromInstruction_4(Val, 2, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 2);
// Thumb stores cannot use PC as dest register.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2STRHs:
case ARM_t2STRBs:
case ARM_t2STRs:
if (Rn == 15)
return MCDisassembler_Fail;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeT2LoadShift(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned addrmode;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRBs:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRHs:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSHs:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
case ARM_t2LDRSBs:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRs:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2PLDs:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2PLIs:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRSHs:
return MCDisassembler_Fail;
case ARM_t2LDRHs:
// FIXME: this instruction is only available with MP extensions,
// this should be checked first but we don't have access to the
// feature bits here.
MCInst_setOpcode(Inst, ARM_t2PLDWs);
break;
default:
break;
}
}
switch (MCInst_getOpcode(Inst)) {
case ARM_t2PLDs:
case ARM_t2PLDWs:
case ARM_t2PLIs:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
addrmode = fieldFromInstruction_4(Insn, 4, 2);
addrmode |= fieldFromInstruction_4(Insn, 0, 4) << 2;
addrmode |= fieldFromInstruction_4(Insn, 16, 4) << 6;
if (!Check(&S, DecodeT2AddrModeSOReg(Inst, addrmode, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2LoadImm8(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned U = fieldFromInstruction_4(Insn, 9, 1);
unsigned imm = fieldFromInstruction_4(Insn, 0, 8);
imm |= (U << 8);
imm |= (Rn << 9);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRi8:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2LDRBi8:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRSBi8:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRHi8:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSHi8:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
case ARM_t2PLDi8:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2PLIi8:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRSHi8:
return MCDisassembler_Fail;
default:
break;
}
}
switch (MCInst_getOpcode(Inst)) {
case ARM_t2PLDi8:
case ARM_t2PLIi8:
case ARM_t2PLDWi8:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeT2AddrModeImm8(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2LoadImm12(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= (Rn << 13);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRi12:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2LDRHi12:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSHi12:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
case ARM_t2LDRBi12:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRSBi12:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2PLDi12:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2PLIi12:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRSHi12:
return MCDisassembler_Fail;
case ARM_t2LDRHi12:
MCInst_setOpcode(Inst, ARM_t2PLDi12);
break;
default:
break;
}
}
switch (MCInst_getOpcode(Inst)) {
case ARM_t2PLDi12:
case ARM_t2PLDWi12:
case ARM_t2PLIi12:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeT2AddrModeImm12(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2LoadT(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 8);
imm |= (Rn << 9);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRT:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2LDRBT:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRHT:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSBT:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRSHT:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeT2AddrModeImm8(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2LoadLabel(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
int imm = fieldFromInstruction_4(Insn, 0, 12);
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRBpci:
case ARM_t2LDRHpci:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2LDRSBpci:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
case ARM_t2LDRSHpci:
return MCDisassembler_Fail;
default:
break;
}
}
switch(MCInst_getOpcode(Inst)) {
case ARM_t2PLDpci:
case ARM_t2PLIpci:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!U) {
// Special case for #-0.
if (imm == 0)
imm = INT32_MIN;
else
imm = -imm;
}
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeT2Imm8S4(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val == 0)
MCInst_addOperand(Inst, MCOperand_CreateImm(INT32_MIN));
else {
int imm = Val & 0xFF;
if (!(Val & 0x100)) imm *= -1;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm * 4));
}
return MCDisassembler_Success;
}
static DecodeStatus DecodeT2AddrModeImm8s4(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 9, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 9);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeT2Imm8S4(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2AddrModeImm0_1020s4(MCInst *Inst,unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 8, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 8);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeT2Imm8(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
int imm = Val & 0xFF;
if (Val == 0)
imm = INT32_MIN;
else if (!(Val & 0x100))
imm *= -1;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return MCDisassembler_Success;
}
static DecodeStatus DecodeT2AddrModeImm8(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 9, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 9);
// Thumb stores cannot use PC as dest register.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2STRT:
case ARM_t2STRBT:
case ARM_t2STRHT:
case ARM_t2STRi8:
case ARM_t2STRHi8:
case ARM_t2STRBi8:
if (Rn == 15)
return MCDisassembler_Fail;
break;
default:
break;
}
// Some instructions always use an additive offset.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRT:
case ARM_t2LDRBT:
case ARM_t2LDRHT:
case ARM_t2LDRSBT:
case ARM_t2LDRSHT:
case ARM_t2STRT:
case ARM_t2STRBT:
case ARM_t2STRHT:
imm |= 0x100;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeT2Imm8(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2LdStPre(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned load;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned addr = fieldFromInstruction_4(Insn, 0, 8);
addr |= fieldFromInstruction_4(Insn, 9, 1) << 8;
addr |= Rn << 9;
load = fieldFromInstruction_4(Insn, 20, 1);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDR_PRE:
case ARM_t2LDR_POST:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2LDRB_PRE:
case ARM_t2LDRB_POST:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRH_PRE:
case ARM_t2LDRH_POST:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSB_PRE:
case ARM_t2LDRSB_POST:
if (Rt == 15)
MCInst_setOpcode(Inst, ARM_t2PLIpci);
else
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRSH_PRE:
case ARM_t2LDRSH_POST:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (!load) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (load) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeT2AddrModeImm8(Inst, addr, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2AddrModeImm12(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 12);
// Thumb stores cannot use PC as dest register.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2STRi12:
case ARM_t2STRBi12:
case ARM_t2STRHi12:
if (Rn == 15)
return MCDisassembler_Fail;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return S;
}
static DecodeStatus DecodeThumbAddSPImm(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder)
{
unsigned imm = fieldFromInstruction_2(Insn, 0, 7);
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbAddSPReg(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (MCInst_getOpcode(Inst) == ARM_tADDrSP) {
unsigned Rdm = fieldFromInstruction_2(Insn, 0, 3);
Rdm |= fieldFromInstruction_2(Insn, 7, 1) << 3;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rdm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rdm, Address, Decoder)))
return MCDisassembler_Fail;
} else if (MCInst_getOpcode(Inst) == ARM_tADDspr) {
unsigned Rm = fieldFromInstruction_2(Insn, 3, 4);
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
MCInst_addOperand(Inst, MCOperand_CreateReg(ARM_SP));
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
}
static DecodeStatus DecodeThumbCPS(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder)
{
unsigned imod = fieldFromInstruction_2(Insn, 4, 1) | 0x2;
unsigned flags = fieldFromInstruction_2(Insn, 0, 3);
MCInst_addOperand(Inst, MCOperand_CreateImm(imod));
MCInst_addOperand(Inst, MCOperand_CreateImm(flags));
return MCDisassembler_Success;
}
static DecodeStatus DecodePostIdxReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned add = fieldFromInstruction_4(Insn, 4, 1);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(add));
return S;
}
static DecodeStatus DecodeThumbBLXOffset(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// Val is passed in as S:J1:J2:imm10H:imm10L:'0'
// Note only one trailing zero not two. Also the J1 and J2 values are from
// the encoded instruction. So here change to I1 and I2 values via:
// I1 = NOT(J1 EOR S);
// I2 = NOT(J2 EOR S);
// and build the imm32 with two trailing zeros as documented:
// imm32 = SignExtend(S:I1:I2:imm10H:imm10L:'00', 32);
unsigned S = (Val >> 23) & 1;
unsigned J1 = (Val >> 22) & 1;
unsigned J2 = (Val >> 21) & 1;
unsigned I1 = !(J1 ^ S);
unsigned I2 = !(J2 ^ S);
unsigned tmp = (Val & ~0x600000) | (I1 << 22) | (I2 << 21);
int imm32 = SignExtend32(tmp << 1, 25);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm32));
return MCDisassembler_Success;
}
static DecodeStatus DecodeCoprocessor(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val == 0xA || Val == 0xB)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbTableBranch(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
if (Rn == ARM_SP) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeThumb2BCCInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned brtarget;
unsigned pred = fieldFromInstruction_4(Insn, 22, 4);
if (pred == 0xE || pred == 0xF) {
unsigned imm;
unsigned opc = fieldFromInstruction_4(Insn, 4, 28);
switch (opc) {
default:
return MCDisassembler_Fail;
case 0xf3bf8f4:
MCInst_setOpcode(Inst, ARM_t2DSB);
break;
case 0xf3bf8f5:
MCInst_setOpcode(Inst, ARM_t2DMB);
break;
case 0xf3bf8f6:
MCInst_setOpcode(Inst, ARM_t2ISB);
break;
}
imm = fieldFromInstruction_4(Insn, 0, 4);
return DecodeMemBarrierOption(Inst, imm, Address, Decoder);
}
brtarget = fieldFromInstruction_4(Insn, 0, 11) << 1;
brtarget |= fieldFromInstruction_4(Insn, 11, 1) << 19;
brtarget |= fieldFromInstruction_4(Insn, 13, 1) << 18;
brtarget |= fieldFromInstruction_4(Insn, 16, 6) << 12;
brtarget |= fieldFromInstruction_4(Insn, 26, 1) << 20;
if (!Check(&S, DecodeT2BROperand(Inst, brtarget, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
// Decode a shifted immediate operand. These basically consist
// of an 8-bit value, and a 4-bit directive that specifies either
// a splat operation or a rotation.
static DecodeStatus DecodeT2SOImm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
unsigned ctrl = fieldFromInstruction_4(Val, 10, 2);
if (ctrl == 0) {
unsigned byte = fieldFromInstruction_4(Val, 8, 2);
unsigned imm = fieldFromInstruction_4(Val, 0, 8);
switch (byte) {
case 0:
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
break;
case 1:
MCInst_addOperand(Inst, MCOperand_CreateImm((imm << 16) | imm));
break;
case 2:
MCInst_addOperand(Inst, MCOperand_CreateImm((imm << 24) | (imm << 8)));
break;
case 3:
MCInst_addOperand(Inst, MCOperand_CreateImm((imm << 24) | (imm << 16) |
(imm << 8) | imm));
break;
}
} else {
unsigned unrot = fieldFromInstruction_4(Val, 0, 7) | 0x80;
unsigned rot = fieldFromInstruction_4(Val, 7, 5);
unsigned imm = (unrot >> rot) | (unrot << ((32-rot)&31));
MCInst_addOperand(Inst, MCOperand_CreateImm(imm));
}
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbBCCTargetOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(Val << 1, 9)));
return MCDisassembler_Success;
}
static DecodeStatus DecodeThumbBLTargetOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// Val is passed in as S:J1:J2:imm10:imm11
// Note no trailing zero after imm11. Also the J1 and J2 values are from
// the encoded instruction. So here change to I1 and I2 values via:
// I1 = NOT(J1 EOR S);
// I2 = NOT(J2 EOR S);
// and build the imm32 with one trailing zero as documented:
// imm32 = SignExtend(S:I1:I2:imm10:imm11:'0', 32);
unsigned S = (Val >> 23) & 1;
unsigned J1 = (Val >> 22) & 1;
unsigned J2 = (Val >> 21) & 1;
unsigned I1 = !(J1 ^ S);
unsigned I2 = !(J2 ^ S);
unsigned tmp = (Val & ~0x600000) | (I1 << 22) | (I2 << 21);
int imm32 = SignExtend32(tmp << 1, 25);
MCInst_addOperand(Inst, MCOperand_CreateImm(imm32));
return MCDisassembler_Success;
}
static DecodeStatus DecodeMemBarrierOption(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val & ~0xf)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeInstSyncBarrierOption(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val & ~0xf)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeMSRMask(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (!Val) return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return MCDisassembler_Success;
}
static DecodeStatus DecodeDoubleRegLoad(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRPairRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeDoubleRegStore(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (Rn == 0xF || Rd == Rn || Rd == Rt || Rd == Rt+1)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRPairRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeLDRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeAddrModeImm12Operand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeLDRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred, Rm;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (Rm == 0xF) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSORegMemOperand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeSTRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeAddrModeImm12Operand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeSTRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSORegMemOperand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeVLD1LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 6, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
switch (fieldFromInstruction_4(Insn, 4, 2)) {
case 0 :
align = 0; break;
case 3:
align = 4; break;
default:
return MCDisassembler_Fail;
}
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVST1LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 6, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
switch (fieldFromInstruction_4(Insn, 4, 2)) {
case 0:
align = 0; break;
case 3:
align = 4; break;
default:
return MCDisassembler_Fail;
}
break;
}
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVLD2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
index = fieldFromInstruction_4(Insn, 5, 3);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 1:
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 4, 1) != 0)
align = 8;
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVST2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
index = fieldFromInstruction_4(Insn, 5, 3);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 1:
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 4, 1) != 0)
align = 8;
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVLD3LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 4, 2))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVST3LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 4, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 4, 2))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVLD4LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 8;
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
switch (fieldFromInstruction_4(Insn, 4, 2)) {
case 0:
align = 0; break;
case 3:
return MCDisassembler_Fail;
default:
align = 4 << fieldFromInstruction_4(Insn, 4, 2); break;
}
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVST4LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 8;
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
switch (fieldFromInstruction_4(Insn, 4, 2)) {
case 0:
align = 0; break;
case 3:
return MCDisassembler_Fail;
default:
align = 4 << fieldFromInstruction_4(Insn, 4, 2); break;
}
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(align));
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCInst_addOperand(Inst, MCOperand_CreateReg(0));
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(index));
return S;
}
static DecodeStatus DecodeVMOVSRR(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 5, 1);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
Rm |= fieldFromInstruction_4(Insn, 0, 4) << 1;
if (Rt == 0xF || Rt2 == 0xF || Rm == 0x1F)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeSPRRegisterClass(Inst, Rm , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSPRRegisterClass(Inst, Rm+1, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt2 , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeVMOVRRS(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 5, 1);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
Rm |= fieldFromInstruction_4(Insn, 0, 4) << 1;
if (Rt == 0xF || Rt2 == 0xF || Rm == 0x1F)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt2 , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSPRRegisterClass(Inst, Rm , Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSPRRegisterClass(Inst, Rm+1, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeIT(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 4, 4);
unsigned mask = fieldFromInstruction_4(Insn, 0, 4);
if (pred == 0xF) {
pred = 0xE;
S = MCDisassembler_SoftFail;
}
if (mask == 0x0)
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(pred));
MCInst_addOperand(Inst, MCOperand_CreateImm(mask));
return S;
}
static DecodeStatus DecodeT2LDRDPreInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 8, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned addr = fieldFromInstruction_4(Insn, 0, 8);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
bool writeback = (W == 1) | (P == 0);
addr |= (U << 8) | (Rn << 9);
if (writeback && (Rn == Rt || Rn == Rt2))
Check(&S, MCDisassembler_SoftFail);
if (Rt == Rt2)
Check(&S, MCDisassembler_SoftFail);
// Rt
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
// Rt2
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt2, Address, Decoder)))
return MCDisassembler_Fail;
// Writeback operand
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
// addr
if (!Check(&S, DecodeT2AddrModeImm8s4(Inst, addr, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2STRDPreInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 8, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned addr = fieldFromInstruction_4(Insn, 0, 8);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
bool writeback = (W == 1) | (P == 0);
addr |= (U << 8) | (Rn << 9);
if (writeback && (Rn == Rt || Rn == Rt2))
Check(&S, MCDisassembler_SoftFail);
// Writeback operand
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
// Rt
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
// Rt2
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt2, Address, Decoder)))
return MCDisassembler_Fail;
// addr
if (!Check(&S, DecodeT2AddrModeImm8s4(Inst, addr, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeT2Adr(MCInst *Inst, uint32_t Insn,
uint64_t Address, const void *Decoder)
{
unsigned Val;
unsigned sign1 = fieldFromInstruction_4(Insn, 21, 1);
unsigned sign2 = fieldFromInstruction_4(Insn, 23, 1);
if (sign1 != sign2) return MCDisassembler_Fail;
Val = fieldFromInstruction_4(Insn, 0, 8);
Val |= fieldFromInstruction_4(Insn, 12, 3) << 8;
Val |= fieldFromInstruction_4(Insn, 26, 1) << 11;
Val |= sign1 << 12;
MCInst_addOperand(Inst, MCOperand_CreateImm(SignExtend32(Val, 13)));
return MCDisassembler_Success;
}
static DecodeStatus DecodeT2ShifterImmOperand(MCInst *Inst, uint32_t Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
// Shift of "asr #32" is not allowed in Thumb2 mode.
if (Val == 0x20) S = MCDisassembler_SoftFail;
MCInst_addOperand(Inst, MCOperand_CreateImm(Val));
return S;
}
static DecodeStatus DecodeSwap(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (pred == 0xF)
return DecodeCPSInstruction(Inst, Insn, Address, Decoder);
S = MCDisassembler_Success;
if (Rt == Rn || Rn == Rt2)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rt2, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeVCVTD(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Vm, imm, cmode, op;
unsigned Vd = (fieldFromInstruction_4(Insn, 12, 4) << 0);
Vd |= (fieldFromInstruction_4(Insn, 22, 1) << 4);
Vm = (fieldFromInstruction_4(Insn, 0, 4) << 0);
Vm |= (fieldFromInstruction_4(Insn, 5, 1) << 4);
imm = fieldFromInstruction_4(Insn, 16, 6);
cmode = fieldFromInstruction_4(Insn, 8, 4);
op = fieldFromInstruction_4(Insn, 5, 1);
// VMOVv2f32 is ambiguous with these decodings.
if (!(imm & 0x38) && cmode == 0xF) {
if (op == 1) return MCDisassembler_Fail;
MCInst_setOpcode(Inst, ARM_VMOVv2f32);
return DecodeNEONModImmInstruction(Inst, Insn, Address, Decoder);
}
if (!(imm & 0x20)) return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Vd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Vm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(64 - imm));
return S;
}
static DecodeStatus DecodeVCVTQ(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Vm, imm, cmode, op;
unsigned Vd = (fieldFromInstruction_4(Insn, 12, 4) << 0);
Vd |= (fieldFromInstruction_4(Insn, 22, 1) << 4);
Vm = (fieldFromInstruction_4(Insn, 0, 4) << 0);
Vm |= (fieldFromInstruction_4(Insn, 5, 1) << 4);
imm = fieldFromInstruction_4(Insn, 16, 6);
cmode = fieldFromInstruction_4(Insn, 8, 4);
op = fieldFromInstruction_4(Insn, 5, 1);
// VMOVv4f32 is ambiguous with these decodings.
if (!(imm & 0x38) && cmode == 0xF) {
if (op == 1) return MCDisassembler_Fail;
MCInst_setOpcode(Inst, ARM_VMOVv4f32);
return DecodeNEONModImmInstruction(Inst, Insn, Address, Decoder);
}
if (!(imm & 0x20)) return MCDisassembler_Fail;
if (!Check(&S, DecodeQPRRegisterClass(Inst, Vd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeQPRRegisterClass(Inst, Vm, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(64 - imm));
return S;
}
static DecodeStatus DecodeLDR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Cond;
unsigned Rn = fieldFromInstruction_4(Val, 16, 4);
unsigned Rt = fieldFromInstruction_4(Val, 12, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
Rm |= (fieldFromInstruction_4(Val, 23, 1) << 4);
Cond = fieldFromInstruction_4(Val, 28, 4);
if (fieldFromInstruction_4(Val, 8, 4) != 0 || Rn == Rt)
S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeAddrMode7Operand(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePostIdxReg(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, Cond, Address, Decoder)))
return MCDisassembler_Fail;
return S;
}
static DecodeStatus DecodeMRRC2(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned CRm = fieldFromInstruction_4(Val, 0, 4);
unsigned opc1 = fieldFromInstruction_4(Val, 4, 4);
unsigned cop = fieldFromInstruction_4(Val, 8, 4);
unsigned Rt = fieldFromInstruction_4(Val, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Val, 16, 4);
if ((cop & ~0x1) == 0xa)
return MCDisassembler_Fail;
if (Rt == Rt2)
S = MCDisassembler_SoftFail;
MCInst_addOperand(Inst, MCOperand_CreateImm(cop));
MCInst_addOperand(Inst, MCOperand_CreateImm(opc1));
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rt2, Address, Decoder)))
return MCDisassembler_Fail;
MCInst_addOperand(Inst, MCOperand_CreateImm(CRm));
return S;
}
#endif
|
the_stack_data/8878.c
|
#include<stdio.h>
int palindrome(int arr[], int a,int b){
if(a>=b){
return 1;
}
if(arr[a]==arr[b]){
return palindrome(arr,a+1,b-1);
}
else{
return 0;
}
}
int main(){
int n;
printf("enter the length of array: ");
scanf("%d",&n);
int arr[n];
for(int i=0;i<n;i++){
printf("\nenter the %d element of array: ",i+1);
scanf("%d",&arr[i]);
}
if(palindrome(arr,0,n-1)==1){
printf("YES THIS ARRAY IS PALINDROME");
}
else{
printf("NOT PALINDROME");
}
return 0;
}
|
the_stack_data/150143617.c
|
/* miniz.c v1.14 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
See "unlicense" statement at the end of this file.
Rich Geldreich <[email protected]>, last updated May 20, 2012
Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
Most API's defined in miniz.c are optional. For example, to disable the archive related functions just define
MINIZ_NO_ARCHIVE_APIS, or to get rid of all stdio usage define MINIZ_NO_STDIO (see the list below for more macros).
* Change History
5/20/12 v1.14 - MinGW32/64 GCC 4.6.1 compiler fixes: added MZ_FORCEINLINE, #include <time.h> (thanks fermtect).
5/19/12 v1.13 - From [email protected] and [email protected] - Fix mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bit.
Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files.
Eliminated a bunch of warnings when compiling with GCC 32-bit/64.
Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly
"Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64.
Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test.
Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives.
Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
Fix ftell() usage in examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself).
4/12/12 v1.12 - More comments, added low-level example5.c, fixed a couple minor level_and_flags issues in the archive API's.
level_and_flags can now be set to MZ_DEFAULT_COMPRESSION. Thanks to Bruce Dawson <[email protected]> for the feedback/bug report.
5/28/11 v1.11 - Added statement from unlicense.org
5/27/11 v1.10 - Substantial compressor optimizations:
Level 1 is now ~4x faster than before. The L1 compressor's throughput now varies between 70-110MB/sec. on a
Core i7 (actual throughput varies depending on the type of data, and x64 vs. x86).
Improved baseline L2-L9 compression perf. Also, greatly improved compression perf. issues on some file types.
Refactored the compression code for better readability and maintainability.
Added level 10 compression level (L10 has slightly better ratio than level 9, but could have a potentially large
drop in throughput on some files).
5/15/11 v1.09 - Initial stable release.
* Low-level Deflate/Inflate implementation notes:
Compression: Use the "tdefl" API's. The compressor supports raw, static, and dynamic blocks, lazy or
greedy parsing, match length filtering, RLE-only, and Huffman-only streams. It performs and compresses
approximately as well as zlib.
Decompression: Use the "tinfl" API's. The entire decompressor is implemented as a single function
coroutine: see tinfl_decompress(). It supports decompression into a 32KB (or larger power of 2) wrapping buffer, or into a memory
block large enough to hold the entire file.
The low-level tdefl/tinfl API's do not make any use of dynamic memory allocation.
* Important: For best perf. be sure to customize the below macros for your target platform:
#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
#define MINIZ_LITTLE_ENDIAN 1
#define MINIZ_HAS_64BIT_REGISTERS 1
*/
#ifndef MINIZ_HEADER_INCLUDED
#define MINIZ_HEADER_INCLUDED
#include <stdlib.h>
// Defines to completely disable specific portions of miniz.c:
// If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl.
// Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
// Note if MINIZ_NO_MALLOC is defined then the user must always provide custom user alloc/free/realloc
// callbacks to the zlib and archive API's, and a few stand-alone helper API's which don't provide custom user
// functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work.
//#define MINIZ_NO_MALLOC
#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(i386) || defined(__ia64__) || defined(__x86_64__)
// MINIZ_X86_OR_X64_CPU is only used to help set the below macros.
#define MINIZ_X86_OR_X64_CPU 1
#endif
#if (__BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
// Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian.
#define MINIZ_LITTLE_ENDIAN 1
#endif
#if MINIZ_X86_OR_X64_CPU
// Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses.
#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
#endif
#if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) || defined(__ia64__) || defined(__x86_64__)
// Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
#define MINIZ_HAS_64BIT_REGISTERS 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
// ------------------- zlib-style API Definitions.
// For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
typedef unsigned long mz_ulong;
// mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
void mz_free(void *p);
#define MZ_ADLER32_INIT (1)
// mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
#define MZ_CRC32_INIT (0)
// mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL.
mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
// Compression strategies.
enum { MZ_DEFAULT_STRATEGY = 0, MZ_FILTERED = 1, MZ_HUFFMAN_ONLY = 2, MZ_RLE = 3, MZ_FIXED = 4 };
// Method
#define MZ_DEFLATED 8
// ------------------- Types and macros
typedef unsigned char mz_uint8;
typedef signed short mz_int16;
typedef unsigned short mz_uint16;
typedef unsigned int mz_uint32;
typedef unsigned int mz_uint;
typedef long long mz_int64;
typedef unsigned long long mz_uint64;
typedef int mz_bool;
#define MZ_FALSE (0)
#define MZ_TRUE (1)
// Works around MSVC's spammy "warning C4127: conditional expression is constant" message.
#ifdef _MSC_VER
#define MZ_MACRO_END while (0, 0)
#else
#define MZ_MACRO_END while (0)
#endif
// ------------------- Low-level Decompression API Definitions
// Decompression flags used by tinfl_decompress().
// TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
// TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
// TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
// TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
enum
{
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
TINFL_FLAG_HAS_MORE_INPUT = 2,
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
TINFL_FLAG_COMPUTE_ADLER32 = 8
};
// High level decompression functions:
// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
// On entry:
// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
// On return:
// Function returns a pointer to the decompressed data, or NULL on failure.
// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
// The caller must call mz_free() on the returned block when it's no longer needed.
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
// Returns 1 on success or 0 on failure.
typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
struct tinfl_decompressor_tag; typedef struct tinfl_decompressor_tag tinfl_decompressor;
// Max size of LZ dictionary.
#define TINFL_LZ_DICT_SIZE 32768
// Return status.
typedef enum
{
TINFL_STATUS_BAD_PARAM = -3,
TINFL_STATUS_ADLER32_MISMATCH = -2,
TINFL_STATUS_FAILED = -1,
TINFL_STATUS_DONE = 0,
TINFL_STATUS_NEEDS_MORE_INPUT = 1,
TINFL_STATUS_HAS_MORE_OUTPUT = 2
} tinfl_status;
// Initializes the decompressor to its initial state.
#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
#define tinfl_get_adler32(r) (r)->m_check_adler32
// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
// Internal/private bits follow.
enum
{
TINFL_MAX_HUFF_TABLES = 3, TINFL_MAX_HUFF_SYMBOLS_0 = 288, TINFL_MAX_HUFF_SYMBOLS_1 = 32, TINFL_MAX_HUFF_SYMBOLS_2 = 19,
TINFL_FAST_LOOKUP_BITS = 10, TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
};
typedef struct
{
mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
} tinfl_huff_table;
#if MINIZ_HAS_64BIT_REGISTERS
#define TINFL_USE_64BIT_BITBUF 1
#endif
#if TINFL_USE_64BIT_BITBUF
typedef mz_uint64 tinfl_bit_buf_t;
#define TINFL_BITBUF_SIZE (64)
#else
typedef mz_uint32 tinfl_bit_buf_t;
#define TINFL_BITBUF_SIZE (32)
#endif
struct tinfl_decompressor_tag
{
mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
tinfl_bit_buf_t m_bit_buf;
size_t m_dist_from_out_buf_start;
tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
};
// ------------------- Low-level Compression API Definitions
// Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly slower, and raw/dynamic blocks will be output more frequently).
#define TDEFL_LESS_MEMORY 0
// tdefl_init() compression flags logically OR'd together (low 12 bits contain the max. number of probes per dictionary search):
// TDEFL_DEFAULT_MAX_PROBES: The compressor defaults to 128 dictionary probes per dictionary search. 0=Huffman only, 1=Huffman+LZ (fastest/crap compression), 4095=Huffman+LZ (slowest/best compression).
enum
{
TDEFL_HUFFMAN_ONLY = 0, TDEFL_DEFAULT_MAX_PROBES = 128, TDEFL_MAX_PROBES_MASK = 0xFFF
};
// TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
// TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
// TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
// TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
// TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
// TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
// TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
// TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
enum
{
TDEFL_WRITE_ZLIB_HEADER = 0x01000,
TDEFL_COMPUTE_ADLER32 = 0x02000,
TDEFL_GREEDY_PARSING_FLAG = 0x04000,
TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
TDEFL_RLE_MATCHES = 0x10000,
TDEFL_FILTER_MATCHES = 0x20000,
TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
};
// High level compression functions:
// tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
// On entry:
// pSrc_buf, src_buf_len: Pointer and size of source block to compress.
// flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
// On return:
// Function returns a pointer to the compressed data, or NULL on failure.
// *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
// The caller must free() the returned block when it's no longer needed.
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
// tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
// Returns 0 on failure.
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
// Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time.
typedef mz_bool (*tdefl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
// tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally.
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
enum { TDEFL_MAX_HUFF_TABLES = 3, TDEFL_MAX_HUFF_SYMBOLS_0 = 288, TDEFL_MAX_HUFF_SYMBOLS_1 = 32, TDEFL_MAX_HUFF_SYMBOLS_2 = 19, TDEFL_LZ_DICT_SIZE = 32768, TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1, TDEFL_MIN_MATCH_LEN = 3, TDEFL_MAX_MATCH_LEN = 258 };
// TDEFL_OUT_BUF_SIZE MUST be large enough to hold a single entire compressed output block (using static/fixed Huffman codes).
#if TDEFL_LESS_MEMORY
enum { TDEFL_LZ_CODE_BUF_SIZE = 24 * 1024, TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13 ) / 10, TDEFL_MAX_HUFF_SYMBOLS = 288, TDEFL_LZ_HASH_BITS = 12, TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS };
#else
enum { TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024, TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13 ) / 10, TDEFL_MAX_HUFF_SYMBOLS = 288, TDEFL_LZ_HASH_BITS = 15, TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS };
#endif
// The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
typedef enum
{
TDEFL_STATUS_BAD_PARAM = -2,
TDEFL_STATUS_PUT_BUF_FAILED = -1,
TDEFL_STATUS_OKAY = 0,
TDEFL_STATUS_DONE = 1,
} tdefl_status;
// Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
typedef enum
{
TDEFL_NO_FLUSH = 0,
TDEFL_SYNC_FLUSH = 2,
TDEFL_FULL_FLUSH = 3,
TDEFL_FINISH = 4
} tdefl_flush;
// tdefl's compression state structure.
typedef struct
{
tdefl_put_buf_func_ptr m_pPut_buf_func;
void *m_pPut_buf_user;
mz_uint m_flags, m_max_probes[2];
int m_greedy_parsing;
mz_uint m_adler32, m_lookahead_pos, m_lookahead_size, m_dict_size;
mz_uint8 *m_pLZ_code_buf, *m_pLZ_flags, *m_pOutput_buf, *m_pOutput_buf_end;
mz_uint m_num_flags_left, m_total_lz_bytes, m_lz_code_buf_dict_pos, m_bits_in, m_bit_buffer;
mz_uint m_saved_match_dist, m_saved_match_len, m_saved_lit, m_output_flush_ofs, m_output_flush_remaining, m_finished, m_block_index, m_wants_to_finish;
tdefl_status m_prev_return_status;
const void *m_pIn_buf;
void *m_pOut_buf;
size_t *m_pIn_buf_size, *m_pOut_buf_size;
tdefl_flush m_flush;
const mz_uint8 *m_pSrc;
size_t m_src_buf_left, m_out_buf_ofs;
mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE + TDEFL_MAX_MATCH_LEN - 1];
mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE];
mz_uint16 m_next[TDEFL_LZ_DICT_SIZE];
mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE];
mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE];
} tdefl_compressor;
// Initializes the compressor.
// There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
// pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
// If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
// flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
// Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.
tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
// tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr.
// tdefl_compress_buffer() always consumes the entire input buffer.
tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
#ifdef __cplusplus
}
#endif
#endif // MINIZ_HEADER_INCLUDED
// ------------------- End of Header: Implementation follows. (If you only want the header, define MINIZ_HEADER_FILE_ONLY.)
#ifndef MINIZ_HEADER_FILE_ONLY
typedef unsigned char mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 : -1];
typedef unsigned char mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 : -1];
typedef unsigned char mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 : -1];
#include <string.h>
#include <assert.h>
#define MZ_ASSERT(x) assert(x)
#ifdef MINIZ_NO_MALLOC
#define MZ_MALLOC(x) NULL
#define MZ_FREE(x) (void)x, ((void)0)
#define MZ_REALLOC(p, x) NULL
#else
#define MZ_MALLOC(x) malloc(x)
#define MZ_FREE(x) free(x)
#define MZ_REALLOC(p, x) realloc(p, x)
#endif
#define MZ_MAX(a,b) (((a)>(b))?(a):(b))
#define MZ_MIN(a,b) (((a)<(b))?(a):(b))
#define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
#define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
#define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
#else
#define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
#define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
#endif
#ifdef _MSC_VER
#define MZ_FORCEINLINE __forceinline
#elif defined(__GNUC__)
#define MZ_FORCEINLINE inline __attribute__((__always_inline__))
#else
#define MZ_FORCEINLINE
#endif
#ifdef __cplusplus
extern "C" {
#endif
// ------------------- zlib-style API's
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
{
mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); size_t block_len = buf_len % 5552;
if (!ptr) return MZ_ADLER32_INIT;
while (buf_len) {
for (i = 0; i + 7 < block_len; i += 8, ptr += 8) {
s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1;
s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1;
}
for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1;
s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552;
}
return (s2 << 16) + s1;
}
// Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": http://www.geocities.com/malbrain/
mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
{
static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
mz_uint32 crcu32 = (mz_uint32)crc;
if (!ptr) return MZ_CRC32_INIT;
crcu32 = ~crcu32; while (buf_len--) { mz_uint8 b = *ptr++; crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)]; crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)]; }
return ~crcu32;
}
void mz_free(void *p)
{
MZ_FREE(p);
}
// ------------------- Low-level Decompression (completely independent from all compression API's)
#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
#define TINFL_MEMSET(p, c, l) memset(p, c, l)
#define TINFL_CR_BEGIN switch(r->m_state) { case 0:
#define TINFL_CR_RETURN(state_index, result) do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END
#define TINFL_CR_RETURN_FOREVER(state_index, result) do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END
#define TINFL_CR_FINISH }
// TODO: If the caller has indicated that there's no more input, and we attempt to read beyond the input buf, then something is wrong with the input because the inflator never
// reads ahead more than it needs to. Currently TINFL_GET_BYTE() pads the end of the stream with 0's in this scenario.
#define TINFL_GET_BYTE(state_index, c) do { \
if (pIn_buf_cur >= pIn_buf_end) { \
for ( ; ; ) { \
if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) { \
TINFL_CR_RETURN(state_index, TINFL_STATUS_NEEDS_MORE_INPUT); \
if (pIn_buf_cur < pIn_buf_end) { \
c = *pIn_buf_cur++; \
break; \
} \
} else { \
c = 0; \
break; \
} \
} \
} else c = *pIn_buf_cur++; } MZ_MACRO_END
#define TINFL_NEED_BITS(state_index, n) do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n))
#define TINFL_SKIP_BITS(state_index, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
#define TINFL_GET_BITS(state_index, b, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
// TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2.
// It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a
// Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the
// bit buffer contains >=15 bits (deflate's max. Huffman code size).
#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \
do { \
temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
if (temp >= 0) { \
code_len = temp >> 9; \
if ((code_len) && (num_bits >= code_len)) \
break; \
} else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \
code_len = TINFL_FAST_LOOKUP_BITS; \
do { \
temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
} while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \
} TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \
} while (num_bits < 15);
// TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read
// beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully
// decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32.
// The slow path is only executed at the very end of the input buffer.
#define TINFL_HUFF_DECODE(state_index, sym, pHuff) do { \
int temp; mz_uint code_len, c; \
if (num_bits < 15) { \
if ((pIn_buf_end - pIn_buf_cur) < 2) { \
TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \
} else { \
bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \
} \
} \
if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
code_len = temp >> 9, temp &= 511; \
else { \
code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \
} sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END
tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
{
static const int s_length_base[31] = { 3,4,5,6,7,8,9,10,11,13, 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 };
static const int s_length_extra[31]= { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
static const int s_dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
static const int s_dist_extra[32] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
static const mz_uint8 s_length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
static const int s_min_table_sizes[3] = { 257, 1, 4 };
tinfl_status status = TINFL_STATUS_FAILED; mz_uint32 num_bits, dist, counter, num_extra; tinfl_bit_buf_t bit_buf;
const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
// Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter).
if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) { *pIn_buf_size = *pOut_buf_size = 0; return TINFL_STATUS_BAD_PARAM; }
num_bits = r->m_num_bits; bit_buf = r->m_bit_buf; dist = r->m_dist; counter = r->m_counter; num_extra = r->m_num_extra; dist_from_out_buf_start = r->m_dist_from_out_buf_start;
TINFL_CR_BEGIN
bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; r->m_z_adler32 = r->m_check_adler32 = 1;
if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
{
TINFL_GET_BYTE(1, r->m_zhdr0); TINFL_GET_BYTE(2, r->m_zhdr1);
counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4)))));
if (counter) { TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); }
}
do
{
TINFL_GET_BITS(3, r->m_final, 3); r->m_type = r->m_final >> 1;
if (r->m_type == 0)
{
TINFL_SKIP_BITS(5, num_bits & 7);
for (counter = 0; counter < 4; ++counter) { if (num_bits) TINFL_GET_BITS(6, r->m_raw_header[counter], 8); else TINFL_GET_BYTE(7, r->m_raw_header[counter]); }
if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); }
while ((counter) && (num_bits))
{
TINFL_GET_BITS(51, dist, 8);
while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); }
*pOut_buf_cur++ = (mz_uint8)dist;
counter--;
}
while (counter)
{
size_t n; while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); }
while (pIn_buf_cur >= pIn_buf_end)
{
if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)
{
TINFL_CR_RETURN(38, TINFL_STATUS_NEEDS_MORE_INPUT);
}
else
{
TINFL_CR_RETURN_FOREVER(40, TINFL_STATUS_FAILED);
}
}
n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); pIn_buf_cur += n; pOut_buf_cur += n; counter -= (mz_uint)n;
}
}
else if (r->m_type == 3)
{
TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
}
else
{
if (r->m_type == 1)
{
mz_uint8 *p = r->m_tables[0].m_code_size; mz_uint i;
r->m_table_sizes[0] = 288; r->m_table_sizes[1] = 32; TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
for ( i = 0; i <= 143; ++i) *p++ = 8;
for ( ; i <= 255; ++i) *p++ = 9;
for ( ; i <= 279; ++i) *p++ = 7;
for ( ; i <= 287; ++i) *p++ = 8;
}
else
{
for (counter = 0; counter < 3; counter++) { TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); r->m_table_sizes[counter] += s_min_table_sizes[counter]; }
MZ_CLEAR_OBJ(r->m_tables[2].m_code_size); for (counter = 0; counter < r->m_table_sizes[2]; counter++) { mz_uint s; TINFL_GET_BITS(14, s, 3); r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s; }
r->m_table_sizes[2] = 19;
}
for ( ; (int)r->m_type >= 0; r->m_type--)
{
int tree_next, tree_cur; tinfl_huff_table *pTable;
mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; pTable = &r->m_tables[r->m_type]; MZ_CLEAR_OBJ(total_syms); MZ_CLEAR_OBJ(pTable->m_look_up); MZ_CLEAR_OBJ(pTable->m_tree);
for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) total_syms[pTable->m_code_size[i]]++;
used_syms = 0, total = 0; next_code[0] = next_code[1] = 0;
for (i = 1; i <= 15; ++i) { used_syms += total_syms[i]; next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); }
if ((65536 != total) && (used_syms > 1))
{
TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
}
for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
{
mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index]; if (!code_size) continue;
cur_code = next_code[code_size]++; for (l = code_size; l > 0; l--, cur_code >>= 1) rev_code = (rev_code << 1) | (cur_code & 1);
if (code_size <= TINFL_FAST_LOOKUP_BITS) { mz_int16 k = (mz_int16)((code_size << 9) | sym_index); while (rev_code < TINFL_FAST_LOOKUP_SIZE) { pTable->m_look_up[rev_code] = k; rev_code += (1 << code_size); } continue; }
if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) { pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; }
rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
{
tree_cur -= ((rev_code >>= 1) & 1);
if (!pTable->m_tree[-tree_cur - 1]) { pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; } else tree_cur = pTable->m_tree[-tree_cur - 1];
}
tree_cur -= ((rev_code >>= 1) & 1); pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
}
if (r->m_type == 2)
{
for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]); )
{
mz_uint s; TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); if (dist < 16) { r->m_len_codes[counter++] = (mz_uint8)dist; continue; }
if ((dist == 16) && (!counter))
{
TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
}
num_extra = "\02\03\07"[dist - 16]; TINFL_GET_BITS(18, s, num_extra); s += "\03\03\013"[dist - 16];
TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); counter += s;
}
if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
{
TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
}
TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]); TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
}
}
for ( ; ; )
{
mz_uint8 *pSrc;
for ( ; ; )
{
if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
{
TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
if (counter >= 256)
break;
while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); }
*pOut_buf_cur++ = (mz_uint8)counter;
}
else
{
int sym2; mz_uint code_len;
#if TINFL_USE_64BIT_BITBUF
if (num_bits < 30) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); pIn_buf_cur += 4; num_bits += 32; }
#else
if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
#endif
if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
code_len = sym2 >> 9;
else
{
code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
}
counter = sym2; bit_buf >>= code_len; num_bits -= code_len;
if (counter & 256)
break;
#if !TINFL_USE_64BIT_BITBUF
if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
#endif
if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
code_len = sym2 >> 9;
else
{
code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
}
bit_buf >>= code_len; num_bits -= code_len;
pOut_buf_cur[0] = (mz_uint8)counter;
if (sym2 & 256)
{
pOut_buf_cur++;
counter = sym2;
break;
}
pOut_buf_cur[1] = (mz_uint8)sym2;
pOut_buf_cur += 2;
}
}
if ((counter &= 511) == 256) break;
num_extra = s_length_extra[counter - 257]; counter = s_length_base[counter - 257];
if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(25, extra_bits, num_extra); counter += extra_bits; }
TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
num_extra = s_dist_extra[dist]; dist = s_dist_base[dist];
if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(27, extra_bits, num_extra); dist += extra_bits; }
dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
{
TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
}
pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
{
while (counter--)
{
while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); }
*pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
}
continue;
}
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
else if ((counter >= 9) && (counter <= dist))
{
const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
do
{
((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
pOut_buf_cur += 8;
} while ((pSrc += 8) < pSrc_end);
if ((counter &= 7) < 3)
{
if (counter)
{
pOut_buf_cur[0] = pSrc[0];
if (counter > 1)
pOut_buf_cur[1] = pSrc[1];
pOut_buf_cur += counter;
}
continue;
}
}
#endif
do
{
pOut_buf_cur[0] = pSrc[0];
pOut_buf_cur[1] = pSrc[1];
pOut_buf_cur[2] = pSrc[2];
pOut_buf_cur += 3; pSrc += 3;
} while ((int)(counter -= 3) > 2);
if ((int)counter > 0)
{
pOut_buf_cur[0] = pSrc[0];
if ((int)counter > 1)
pOut_buf_cur[1] = pSrc[1];
pOut_buf_cur += counter;
}
}
}
} while (!(r->m_final & 1));
if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
{
TINFL_SKIP_BITS(32, num_bits & 7); for (counter = 0; counter < 4; ++counter) { mz_uint s; if (num_bits) TINFL_GET_BITS(41, s, 8); else TINFL_GET_BYTE(42, s); r->m_z_adler32 = (r->m_z_adler32 << 8) | s; }
}
TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
TINFL_CR_FINISH
common_exit:
r->m_num_bits = num_bits; r->m_bit_buf = bit_buf; r->m_dist = dist; r->m_counter = counter; r->m_num_extra = num_extra; r->m_dist_from_out_buf_start = dist_from_out_buf_start;
*pIn_buf_size = pIn_buf_cur - pIn_buf_next; *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
{
const mz_uint8 *ptr = pOut_buf_next; size_t buf_len = *pOut_buf_size;
mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; size_t block_len = buf_len % 5552;
while (buf_len)
{
for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
{
s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1;
s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1;
}
for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1;
s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552;
}
r->m_check_adler32 = (s2 << 16) + s1; if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) status = TINFL_STATUS_ADLER32_MISMATCH;
}
return status;
}
// Higher level helper functions.
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
tinfl_decompressor decomp; void *pBuf = NULL, *pNew_buf; size_t src_buf_ofs = 0, out_buf_capacity = 0;
*pOut_len = 0;
tinfl_init(&decomp);
for ( ; ; )
{
size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8*)pBuf, pBuf ? (mz_uint8*)pBuf + *pOut_len : NULL, &dst_buf_size,
(flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
{
MZ_FREE(pBuf); *pOut_len = 0; return NULL;
}
src_buf_ofs += src_buf_size;
*pOut_len += dst_buf_size;
if (status == TINFL_STATUS_DONE) break;
new_out_buf_capacity = out_buf_capacity * 2; if (new_out_buf_capacity < 128) new_out_buf_capacity = 128;
pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
if (!pNew_buf)
{
MZ_FREE(pBuf); *pOut_len = 0; return NULL;
}
pBuf = pNew_buf; out_buf_capacity = new_out_buf_capacity;
}
return pBuf;
}
size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
tinfl_decompressor decomp; tinfl_status status; tinfl_init(&decomp);
status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf, &src_buf_len, (mz_uint8*)pOut_buf, (mz_uint8*)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
}
int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
int result = 0;
tinfl_decompressor decomp;
mz_uint8 *pDict = (mz_uint8*)MZ_MALLOC(TINFL_LZ_DICT_SIZE); size_t in_buf_ofs = 0, dict_ofs = 0;
if (!pDict)
return TINFL_STATUS_FAILED;
tinfl_init(&decomp);
for ( ; ; )
{
size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
(flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
in_buf_ofs += in_buf_size;
if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
break;
if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
{
result = (status == TINFL_STATUS_DONE);
break;
}
dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
}
MZ_FREE(pDict);
*pIn_buf_size = in_buf_ofs;
return result;
}
// ------------------- Low-level Compression (independent from all decompression API's)
// Purposely making these tables static for faster init and thread safety.
static const mz_uint16 s_tdefl_len_sym[256] = {
257,258,259,260,261,262,263,264,265,265,266,266,267,267,268,268,269,269,269,269,270,270,270,270,271,271,271,271,272,272,272,272,
273,273,273,273,273,273,273,273,274,274,274,274,274,274,274,274,275,275,275,275,275,275,275,275,276,276,276,276,276,276,276,276,
277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,
279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,
281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,
282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,
283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,
284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,285 };
static const mz_uint8 s_tdefl_len_extra[256] = {
0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0 };
static const mz_uint8 s_tdefl_small_dist_sym[512] = {
0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17 };
static const mz_uint8 s_tdefl_small_dist_extra[512] = {
0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7 };
static const mz_uint8 s_tdefl_large_dist_sym[128] = {
0,0,18,19,20,20,21,21,22,22,22,22,23,23,23,23,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,26,26,
26,26,26,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
28,28,28,28,28,28,28,28,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29 };
static const mz_uint8 s_tdefl_large_dist_extra[128] = {
0,0,8,8,9,9,9,9,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13 };
// Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values.
typedef struct { mz_uint16 m_key, m_sym_index; } tdefl_sym_freq;
static tdefl_sym_freq* tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq* pSyms0, tdefl_sym_freq* pSyms1)
{
mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; tdefl_sym_freq* pCur_syms = pSyms0, *pNew_syms = pSyms1; MZ_CLEAR_OBJ(hist);
for (i = 0; i < num_syms; i++) { mz_uint freq = pSyms0[i].m_key; hist[freq & 0xFF]++; hist[256 + ((freq >> 8) & 0xFF)]++; }
while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) total_passes--;
for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
{
const mz_uint32* pHist = &hist[pass << 8];
mz_uint offsets[256], cur_ofs = 0;
for (i = 0; i < 256; i++) { offsets[i] = cur_ofs; cur_ofs += pHist[i]; }
for (i = 0; i < num_syms; i++) pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
{ tdefl_sym_freq* t = pCur_syms; pCur_syms = pNew_syms; pNew_syms = t; }
}
return pCur_syms;
}
// tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, [email protected], Jyrki Katajainen, [email protected], November 1996.
static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
{
int root, leaf, next, avbl, used, dpth;
if (n==0) return; else if (n==1) { A[0].m_key = 1; return; }
A[0].m_key += A[1].m_key; root = 0; leaf = 2;
for (next=1; next < n-1; next++)
{
if (leaf>=n || A[root].m_key<A[leaf].m_key) { A[next].m_key = A[root].m_key; A[root++].m_key = (mz_uint16)next; } else A[next].m_key = A[leaf++].m_key;
if (leaf>=n || (root<next && A[root].m_key<A[leaf].m_key)) { A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); A[root++].m_key = (mz_uint16)next; } else A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key);
}
A[n-2].m_key = 0; for (next=n-3; next>=0; next--) A[next].m_key = A[A[next].m_key].m_key+1;
avbl = 1; used = dpth = 0; root = n-2; next = n-1;
while (avbl>0)
{
while (root>=0 && (int)A[root].m_key==dpth) { used++; root--; }
while (avbl>used) { A[next--].m_key = (mz_uint16)(dpth); avbl--; }
avbl = 2*used; dpth++; used = 0;
}
}
// Limits canonical Huffman code table's max code size.
enum { TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 };
static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
{
int i; mz_uint32 total = 0; if (code_list_len <= 1) return;
for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
for (i = max_code_size; i > 0; i--) total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
while (total != (1UL << max_code_size))
{
pNum_codes[max_code_size]--;
for (i = max_code_size - 1; i > 0; i--) if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
total--;
}
}
static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
{
int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; MZ_CLEAR_OBJ(num_codes);
if (static_table)
{
for (i = 0; i < table_len; i++) num_codes[d->m_huff_code_sizes[table_num][i]]++;
}
else
{
tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms;
int num_used_syms = 0;
const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0];
for (i = 0; i < table_len; i++) if (pSym_count[i]) { syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; syms0[num_used_syms++].m_sym_index = (mz_uint16)i; }
pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); tdefl_calculate_minimum_redundancy(pSyms, num_used_syms);
for (i = 0; i < num_used_syms; i++) num_codes[pSyms[i].m_key]++;
tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit);
MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]); MZ_CLEAR_OBJ(d->m_huff_codes[table_num]);
for (i = 1, j = num_used_syms; i <= code_size_limit; i++)
for (l = num_codes[i]; l > 0; l--) d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i);
}
next_code[1] = 0; for (j = 0, i = 2; i <= code_size_limit; i++) next_code[i] = j = ((j + num_codes[i - 1]) << 1);
for (i = 0; i < table_len; i++)
{
mz_uint rev_code = 0, code, code_size; if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) continue;
code = next_code[code_size]++; for (l = code_size; l > 0; l--, code >>= 1) rev_code = (rev_code << 1) | (code & 1);
d->m_huff_codes[table_num][i] = (mz_uint16)rev_code;
}
}
#define TDEFL_PUT_BITS(b, l) do { \
mz_uint bits = b; mz_uint len = l; MZ_ASSERT(bits <= ((1U << len) - 1U)); \
d->m_bit_buffer |= (bits << d->m_bits_in); d->m_bits_in += len; \
while (d->m_bits_in >= 8) { \
if (d->m_pOutput_buf < d->m_pOutput_buf_end) \
*d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
d->m_bit_buffer >>= 8; \
d->m_bits_in -= 8; \
} \
} MZ_MACRO_END
#define TDEFL_RLE_PREV_CODE_SIZE() { if (rle_repeat_count) { \
if (rle_repeat_count < 3) { \
d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
while (rle_repeat_count--) packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \
} else { \
d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); packed_code_sizes[num_packed_code_sizes++] = 16; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \
} rle_repeat_count = 0; } }
#define TDEFL_RLE_ZERO_CODE_SIZE() { if (rle_z_count) { \
if (rle_z_count < 3) { \
d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); while (rle_z_count--) packed_code_sizes[num_packed_code_sizes++] = 0; \
} else if (rle_z_count <= 10) { \
d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); packed_code_sizes[num_packed_code_sizes++] = 17; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \
} else { \
d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); packed_code_sizes[num_packed_code_sizes++] = 18; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
} rle_z_count = 0; } }
static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
static void tdefl_start_dynamic_block(tdefl_compressor *d)
{
int num_lit_codes, num_dist_codes, num_bit_lengths; mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;
d->m_huff_count[0][256] = 1;
tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE);
tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE);
for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) if (d->m_huff_code_sizes[0][num_lit_codes - 1]) break;
for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) if (d->m_huff_code_sizes[1][num_dist_codes - 1]) break;
memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
total_code_sizes_to_pack = num_lit_codes + num_dist_codes; num_packed_code_sizes = 0; rle_z_count = 0; rle_repeat_count = 0;
memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2);
for (i = 0; i < total_code_sizes_to_pack; i++)
{
mz_uint8 code_size = code_sizes_to_pack[i];
if (!code_size)
{
TDEFL_RLE_PREV_CODE_SIZE();
if (++rle_z_count == 138) { TDEFL_RLE_ZERO_CODE_SIZE(); }
}
else
{
TDEFL_RLE_ZERO_CODE_SIZE();
if (code_size != prev_code_size)
{
TDEFL_RLE_PREV_CODE_SIZE();
d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); packed_code_sizes[num_packed_code_sizes++] = code_size;
}
else if (++rle_repeat_count == 6)
{
TDEFL_RLE_PREV_CODE_SIZE();
}
}
prev_code_size = code_size;
}
if (rle_repeat_count) { TDEFL_RLE_PREV_CODE_SIZE(); } else { TDEFL_RLE_ZERO_CODE_SIZE(); }
tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE);
TDEFL_PUT_BITS(2, 2);
TDEFL_PUT_BITS(num_lit_codes - 257, 5);
TDEFL_PUT_BITS(num_dist_codes - 1, 5);
for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) break;
num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); TDEFL_PUT_BITS(num_bit_lengths - 4, 4);
for (i = 0; (int)i < num_bit_lengths; i++) TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3);
for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes; )
{
mz_uint code = packed_code_sizes[packed_code_sizes_index++]; MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2);
TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]);
if (code >= 16) TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]);
}
}
static void tdefl_start_static_block(tdefl_compressor *d)
{
mz_uint i;
mz_uint8 *p = &d->m_huff_code_sizes[0][0];
for (i = 0; i <= 143; ++i) *p++ = 8;
for ( ; i <= 255; ++i) *p++ = 9;
for ( ; i <= 279; ++i) *p++ = 7;
for ( ; i <= 287; ++i) *p++ = 8;
memset(d->m_huff_code_sizes[1], 5, 32);
tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);
TDEFL_PUT_BITS(1, 2);
}
static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
{
mz_uint flags;
mz_uint8 *pLZ_codes;
mz_uint8 *pOutput_buf = d->m_pOutput_buf;
mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf;
mz_uint64 bit_buffer = d->m_bit_buffer;
mz_uint bits_in = d->m_bits_in;
#define TDEFL_PUT_BITS_FAST(b, l) { bit_buffer |= (((mz_uint64)(b)) << bits_in); bits_in += (l); }
flags = 1;
for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
{
if (flags == 1)
flags = *pLZ_codes++ | 0x100;
if (flags & 1)
{
mz_uint s0, s1, n0, n1, sym, num_extra_bits;
mz_uint match_len = pLZ_codes[0], match_dist = *(const mz_uint16 *)(pLZ_codes + 1); pLZ_codes += 3;
MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
// This sequence coaxes MSVC into using cmov's vs. jmp's.
s0 = s_tdefl_small_dist_sym[match_dist & 511];
n0 = s_tdefl_small_dist_extra[match_dist & 511];
s1 = s_tdefl_large_dist_sym[match_dist >> 8];
n1 = s_tdefl_large_dist_extra[match_dist >> 8];
sym = (match_dist < 512) ? s0 : s1;
num_extra_bits = (match_dist < 512) ? n0 : n1;
MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
}
else
{
mz_uint lit = *pLZ_codes++;
MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
{
flags >>= 1;
lit = *pLZ_codes++;
MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
{
flags >>= 1;
lit = *pLZ_codes++;
MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
}
}
}
if (pOutput_buf >= d->m_pOutput_buf_end)
return MZ_FALSE;
*(mz_uint64*)pOutput_buf = bit_buffer;
pOutput_buf += (bits_in >> 3);
bit_buffer >>= (bits_in & ~7);
bits_in &= 7;
}
#undef TDEFL_PUT_BITS_FAST
d->m_pOutput_buf = pOutput_buf;
d->m_bits_in = 0;
d->m_bit_buffer = 0;
while (bits_in)
{
mz_uint32 n = MZ_MIN(bits_in, 16);
TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n);
bit_buffer >>= n;
bits_in -= n;
}
TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
return (d->m_pOutput_buf < d->m_pOutput_buf_end);
}
#else
static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
{
mz_uint flags;
mz_uint8 *pLZ_codes;
flags = 1;
for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
{
if (flags == 1)
flags = *pLZ_codes++ | 0x100;
if (flags & 1)
{
mz_uint sym, num_extra_bits;
mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); pLZ_codes += 3;
MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
if (match_dist < 512)
{
sym = s_tdefl_small_dist_sym[match_dist]; num_extra_bits = s_tdefl_small_dist_extra[match_dist];
}
else
{
sym = s_tdefl_large_dist_sym[match_dist >> 8]; num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8];
}
MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
}
else
{
mz_uint lit = *pLZ_codes++;
MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
}
}
TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
return (d->m_pOutput_buf < d->m_pOutput_buf_end);
}
#endif // MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
{
if (static_block)
tdefl_start_static_block(d);
else
tdefl_start_dynamic_block(d);
return tdefl_compress_lz_codes(d);
}
static int tdefl_flush_block(tdefl_compressor *d, int flush)
{
mz_uint saved_bit_buf, saved_bits_in;
mz_uint8 *pSaved_output_buf;
mz_bool comp_block_succeeded = MZ_FALSE;
int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size;
mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf;
d->m_pOutput_buf = pOutput_buf_start;
d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16;
MZ_ASSERT(!d->m_output_flush_remaining);
d->m_output_flush_ofs = 0;
d->m_output_flush_remaining = 0;
*d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left);
d->m_pLZ_code_buf -= (d->m_num_flags_left == 8);
if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index))
{
TDEFL_PUT_BITS(0x78, 8); TDEFL_PUT_BITS(0x01, 8);
}
TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1);
pSaved_output_buf = d->m_pOutput_buf; saved_bit_buf = d->m_bit_buffer; saved_bits_in = d->m_bits_in;
if (!use_raw_block)
comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48));
// If the block gets expanded, forget the current contents of the output buffer and send a raw block instead.
if ( ((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) &&
((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size) )
{
mz_uint i; d->m_pOutput_buf = pSaved_output_buf; d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
TDEFL_PUT_BITS(0, 2);
if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); }
for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF)
{
TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16);
}
for (i = 0; i < d->m_total_lz_bytes; ++i)
{
TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8);
}
}
// Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes.
else if (!comp_block_succeeded)
{
d->m_pOutput_buf = pSaved_output_buf; d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
tdefl_compress_block(d, MZ_TRUE);
}
if (flush)
{
if (flush == TDEFL_FINISH)
{
if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); }
if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) { mz_uint i, a = d->m_adler32; for (i = 0; i < 4; i++) { TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); a <<= 8; } }
}
else
{
mz_uint i, z = 0; TDEFL_PUT_BITS(0, 3); if (d->m_bits_in) { TDEFL_PUT_BITS(0, 8 - d->m_bits_in); } for (i = 2; i; --i, z ^= 0xFFFF) { TDEFL_PUT_BITS(z & 0xFFFF, 16); }
}
}
MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end);
memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
d->m_pLZ_code_buf = d->m_lz_code_buf + 1; d->m_pLZ_flags = d->m_lz_code_buf; d->m_num_flags_left = 8; d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; d->m_total_lz_bytes = 0; d->m_block_index++;
if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0)
{
if (d->m_pPut_buf_func)
{
*d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user))
return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED);
}
else if (pOutput_buf_start == d->m_output_buf)
{
int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy);
d->m_out_buf_ofs += bytes_to_copy;
if ((n -= bytes_to_copy) != 0)
{
d->m_output_flush_ofs = bytes_to_copy;
d->m_output_flush_remaining = n;
}
}
else
{
d->m_out_buf_ofs += n;
}
}
return d->m_output_flush_remaining;
}
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16*)(p)
static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
{
mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
const mz_uint16 *s = (const mz_uint16*)(d->m_dict + pos), *p, *q;
mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD(s);
MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); if (max_match_len <= match_len) return;
for ( ; ; )
{
for ( ; ; )
{
if (--num_probes_left == 0) return;
#define TDEFL_PROBE \
next_probe_pos = d->m_next[probe_pos]; \
if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) break;
TDEFL_PROBE; TDEFL_PROBE; TDEFL_PROBE;
}
if (!dist) break; q = (const mz_uint16*)(d->m_dict + probe_pos); if (TDEFL_READ_UNALIGNED_WORD(q) != s01) continue; p = s; probe_len = 32;
do { } while ( (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
(TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0) );
if (!probe_len)
{
*pMatch_dist = dist; *pMatch_len = MZ_MIN(max_match_len, TDEFL_MAX_MATCH_LEN); break;
}
else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8*)p == *(const mz_uint8*)q)) > match_len)
{
*pMatch_dist = dist; if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len) break;
c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]);
}
}
}
#else
static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
{
mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
const mz_uint8 *s = d->m_dict + pos, *p, *q;
mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1];
MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); if (max_match_len <= match_len) return;
for ( ; ; )
{
for ( ; ; )
{
if (--num_probes_left == 0) return;
#define TDEFL_PROBE \
next_probe_pos = d->m_next[probe_pos]; \
if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) break;
TDEFL_PROBE; TDEFL_PROBE; TDEFL_PROBE;
}
if (!dist) break;
p = s; q = d->m_dict + probe_pos;
for (probe_len = 0; probe_len < max_match_len; probe_len++)
if (*p++ != *q++) break;
if (probe_len > match_len)
{
*pMatch_dist = dist; if ((*pMatch_len = match_len = probe_len) == max_match_len) return;
c0 = d->m_dict[pos + match_len]; c1 = d->m_dict[pos + match_len - 1];
}
}
}
#endif // #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
static mz_bool tdefl_compress_fast(tdefl_compressor *d)
{
// Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio.
mz_uint lookahead_pos = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_lz_bytes = d->m_total_lz_bytes, num_flags_left = d->m_num_flags_left;
mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags;
mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size)))
{
const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size);
d->m_src_buf_left -= num_bytes_to_process;
lookahead_size += num_bytes_to_process;
while (num_bytes_to_process)
{
mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process);
memcpy(d->m_dict + dst_pos, d->m_pSrc, n);
if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos));
d->m_pSrc += n;
dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK;
num_bytes_to_process -= n;
}
dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size);
if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE)) break;
while (lookahead_size >= 4)
{
mz_uint cur_match_dist, cur_match_len = 1;
mz_uint8 *pCur_dict = d->m_dict + cur_pos;
mz_uint first_trigram = (*(const mz_uint32 *)pCur_dict) & 0xFFFFFF;
mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK;
mz_uint probe_pos = d->m_hash[hash];
d->m_hash[hash] = (mz_uint16)lookahead_pos;
if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= dict_size) && ((*(const mz_uint32 *)(d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & 0xFFFFFF) == first_trigram))
{
const mz_uint16 *p = (const mz_uint16 *)pCur_dict;
const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos);
mz_uint32 probe_len = 32;
do { } while ( (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
(TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0) );
cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q);
if (!probe_len)
cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0;
if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U*1024U)))
{
cur_match_len = 1;
*pLZ_code_buf++ = (mz_uint8)first_trigram;
*pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
d->m_huff_count[0][(mz_uint8)first_trigram]++;
}
else
{
mz_uint32 s0, s1;
cur_match_len = MZ_MIN(cur_match_len, lookahead_size);
MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE));
cur_match_dist--;
pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
*(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
pLZ_code_buf += 3;
*pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80);
s0 = s_tdefl_small_dist_sym[cur_match_dist & 511];
s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8];
d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++;
d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++;
}
}
else
{
*pLZ_code_buf++ = (mz_uint8)first_trigram;
*pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
d->m_huff_count[0][(mz_uint8)first_trigram]++;
}
if (--num_flags_left == 0) { num_flags_left = 8; pLZ_flags = pLZ_code_buf++; }
total_lz_bytes += cur_match_len;
lookahead_pos += cur_match_len;
dict_size = MZ_MIN(dict_size + cur_match_len, TDEFL_LZ_DICT_SIZE);
cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK;
MZ_ASSERT(lookahead_size >= cur_match_len);
lookahead_size -= cur_match_len;
if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
{
int n;
d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
if ((n = tdefl_flush_block(d, 0)) != 0)
return (n < 0) ? MZ_FALSE : MZ_TRUE;
total_lz_bytes = d->m_total_lz_bytes; pLZ_code_buf = d->m_pLZ_code_buf; pLZ_flags = d->m_pLZ_flags; num_flags_left = d->m_num_flags_left;
}
}
while (lookahead_size)
{
mz_uint8 lit = d->m_dict[cur_pos];
total_lz_bytes++;
*pLZ_code_buf++ = lit;
*pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
if (--num_flags_left == 0) { num_flags_left = 8; pLZ_flags = pLZ_code_buf++; }
d->m_huff_count[0][lit]++;
lookahead_pos++;
dict_size = MZ_MIN(dict_size + 1, TDEFL_LZ_DICT_SIZE);
cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
lookahead_size--;
if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
{
int n;
d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
if ((n = tdefl_flush_block(d, 0)) != 0)
return (n < 0) ? MZ_FALSE : MZ_TRUE;
total_lz_bytes = d->m_total_lz_bytes; pLZ_code_buf = d->m_pLZ_code_buf; pLZ_flags = d->m_pLZ_flags; num_flags_left = d->m_num_flags_left;
}
}
}
d->m_lookahead_pos = lookahead_pos; d->m_lookahead_size = lookahead_size; d->m_dict_size = dict_size;
d->m_total_lz_bytes = total_lz_bytes; d->m_pLZ_code_buf = pLZ_code_buf; d->m_pLZ_flags = pLZ_flags; d->m_num_flags_left = num_flags_left;
return MZ_TRUE;
}
#endif // MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
{
d->m_total_lz_bytes++;
*d->m_pLZ_code_buf++ = lit;
*d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }
d->m_huff_count[0][lit]++;
}
static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
{
mz_uint32 s0, s1;
MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));
d->m_total_lz_bytes += match_len;
d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);
match_dist -= 1;
d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); d->m_pLZ_code_buf += 3;
*d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }
s0 = s_tdefl_small_dist_sym[match_dist & 511]; s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127];
d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;
if (match_len >= TDEFL_MIN_MATCH_LEN) d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
}
static mz_bool tdefl_compress_normal(tdefl_compressor *d)
{
const mz_uint8 *pSrc = d->m_pSrc; size_t src_buf_left = d->m_src_buf_left;
tdefl_flush flush = d->m_flush;
while ((src_buf_left) || ((flush) && (d->m_lookahead_size)))
{
mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
// Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN.
if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1))
{
mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2;
mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK];
mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size);
const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process;
src_buf_left -= num_bytes_to_process;
d->m_lookahead_size += num_bytes_to_process;
while (pSrc != pSrc_end)
{
mz_uint8 c = *pSrc++; d->m_dict[dst_pos] = c; if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; d->m_hash[hash] = (mz_uint16)(ins_pos);
dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; ins_pos++;
}
}
else
{
while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
{
mz_uint8 c = *pSrc++;
mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
src_buf_left--;
d->m_dict[dst_pos] = c;
if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN)
{
mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2;
mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; d->m_hash[hash] = (mz_uint16)(ins_pos);
}
}
}
d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size);
if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
break;
// Simple lazy/greedy parsing state machine.
len_to_move = 1; cur_match_dist = 0; cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS))
{
if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))
{
mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK];
cur_match_len = 0; while (cur_match_len < d->m_lookahead_size) { if (d->m_dict[cur_pos + cur_match_len] != c) break; cur_match_len++; }
if (cur_match_len < TDEFL_MIN_MATCH_LEN) cur_match_len = 0; else cur_match_dist = 1;
}
}
else
{
tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len);
}
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U*1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5)))
{
cur_match_dist = cur_match_len = 0;
}
if (d->m_saved_match_len)
{
if (cur_match_len > d->m_saved_match_len)
{
tdefl_record_literal(d, (mz_uint8)d->m_saved_lit);
if (cur_match_len >= 128)
{
tdefl_record_match(d, cur_match_len, cur_match_dist);
d->m_saved_match_len = 0; len_to_move = cur_match_len;
}
else
{
d->m_saved_lit = d->m_dict[cur_pos]; d->m_saved_match_dist = cur_match_dist; d->m_saved_match_len = cur_match_len;
}
}
else
{
tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist);
len_to_move = d->m_saved_match_len - 1; d->m_saved_match_len = 0;
}
}
else if (!cur_match_dist)
tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]);
else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128))
{
tdefl_record_match(d, cur_match_len, cur_match_dist);
len_to_move = cur_match_len;
}
else
{
d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; d->m_saved_match_dist = cur_match_dist; d->m_saved_match_len = cur_match_len;
}
// Move the lookahead forward by len_to_move bytes.
d->m_lookahead_pos += len_to_move;
MZ_ASSERT(d->m_lookahead_size >= len_to_move);
d->m_lookahead_size -= len_to_move;
d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, TDEFL_LZ_DICT_SIZE);
// Check if it's time to flush the current LZ codes to the internal output buffer.
if ( (d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) ||
( (d->m_total_lz_bytes > 31*1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) )
{
int n;
d->m_pSrc = pSrc; d->m_src_buf_left = src_buf_left;
if ((n = tdefl_flush_block(d, 0)) != 0)
return (n < 0) ? MZ_FALSE : MZ_TRUE;
}
}
d->m_pSrc = pSrc; d->m_src_buf_left = src_buf_left;
return MZ_TRUE;
}
static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
{
if (d->m_pIn_buf_size)
{
*d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
}
if (d->m_pOut_buf_size)
{
size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
d->m_output_flush_ofs += (mz_uint)n;
d->m_output_flush_remaining -= (mz_uint)n;
d->m_out_buf_ofs += n;
*d->m_pOut_buf_size = d->m_out_buf_ofs;
}
return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
}
tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
{
if (!d)
{
if (pIn_buf_size) *pIn_buf_size = 0;
if (pOut_buf_size) *pOut_buf_size = 0;
return TDEFL_STATUS_BAD_PARAM;
}
d->m_pIn_buf = pIn_buf; d->m_pIn_buf_size = pIn_buf_size;
d->m_pOut_buf = pOut_buf; d->m_pOut_buf_size = pOut_buf_size;
d->m_pSrc = (const mz_uint8 *)(pIn_buf); d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
d->m_out_buf_ofs = 0;
d->m_flush = flush;
if ( ((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf) )
{
if (pIn_buf_size) *pIn_buf_size = 0;
if (pOut_buf_size) *pOut_buf_size = 0;
return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
}
d->m_wants_to_finish |= (flush == TDEFL_FINISH);
if ((d->m_output_flush_remaining) || (d->m_finished))
return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
{
if (!tdefl_compress_fast(d))
return d->m_prev_return_status;
}
else
#endif // #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
{
if (!tdefl_compress_normal(d))
return d->m_prev_return_status;
}
if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
{
if (tdefl_flush_block(d, flush) < 0)
return d->m_prev_return_status;
d->m_finished = (flush == TDEFL_FINISH);
if (flush == TDEFL_FULL_FLUSH) { MZ_CLEAR_OBJ(d->m_hash); MZ_CLEAR_OBJ(d->m_next); d->m_dict_size = 0; }
}
return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
}
tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
{
MZ_ASSERT(d->m_pPut_buf_func); return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
}
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
d->m_pPut_buf_func = pPut_buf_func; d->m_pPut_buf_user = pPut_buf_user;
d->m_flags = (mz_uint)(flags); d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) MZ_CLEAR_OBJ(d->m_hash);
d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
d->m_pLZ_code_buf = d->m_lz_code_buf + 1; d->m_pLZ_flags = d->m_lz_code_buf; d->m_num_flags_left = 8;
d->m_pOutput_buf = d->m_output_buf; d->m_pOutput_buf_end = d->m_output_buf; d->m_prev_return_status = TDEFL_STATUS_OKAY;
d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; d->m_adler32 = 1;
d->m_pIn_buf = NULL; d->m_pOut_buf = NULL;
d->m_pIn_buf_size = NULL; d->m_pOut_buf_size = NULL;
d->m_flush = TDEFL_NO_FLUSH; d->m_pSrc = NULL; d->m_src_buf_left = 0; d->m_out_buf_ofs = 0;
memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
return TDEFL_STATUS_OKAY;
}
tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
{
return d->m_prev_return_status;
}
mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
{
return d->m_adler32;
}
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
tdefl_compressor *pComp; mz_bool succeeded; if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) return MZ_FALSE;
pComp = (tdefl_compressor*)MZ_MALLOC(sizeof(tdefl_compressor)); if (!pComp) return MZ_FALSE;
succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
MZ_FREE(pComp); return succeeded;
}
typedef struct
{
size_t m_size, m_capacity;
mz_uint8 *m_pBuf;
mz_bool m_expandable;
} tdefl_output_buffer;
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
{
tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
size_t new_size = p->m_size + len;
if (new_size > p->m_capacity)
{
size_t new_capacity = p->m_capacity; mz_uint8 *pNew_buf; if (!p->m_expandable) return MZ_FALSE;
do { new_capacity = MZ_MAX(128U, new_capacity << 1U); } while (new_size > new_capacity);
pNew_buf = (mz_uint8*)MZ_REALLOC(p->m_pBuf, new_capacity); if (!pNew_buf) return MZ_FALSE;
p->m_pBuf = pNew_buf; p->m_capacity = new_capacity;
}
memcpy((mz_uint8*)p->m_pBuf + p->m_size, pBuf, len); p->m_size = new_size;
return MZ_TRUE;
}
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
if (!pOut_len) return MZ_FALSE; else *pOut_len = 0;
out_buf.m_expandable = MZ_TRUE;
if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return NULL;
*pOut_len = out_buf.m_size; return out_buf.m_pBuf;
}
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
if (!pOut_buf) return 0;
out_buf.m_pBuf = (mz_uint8*)pOut_buf; out_buf.m_capacity = out_buf_len;
if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return 0;
return out_buf.m_size;
}
#ifdef __cplusplus
}
#endif
#endif // MINIZ_HEADER_FILE_ONLY
/*
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
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 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.
For more information, please refer to <http://unlicense.org/>
*/
|
the_stack_data/212643610.c
|
#include<stdio.h>
int main(){
int a;
scanf("%d", &a);
while(a<10){
// a = 11;
// while(a>10){ ---> These two lines will lead to an infinite loop
printf("%d\n", a);
a++;
}
return 0;
}
|
the_stack_data/1101859.c
|
/*
* (c) Copyright, 1991, John L. Manferdelli. All Rights Reserved.
*/
#define BUF 2048
#define UGBUF 256
static ugbuf[UGBUF];
int ugnc={0};
static char buf[BUF];
static int nc={0};
static char *cpos;
#define EC '\\'
#define CC '#'
int nlines={0};
/* ------------------------------------------------------------------------ */
jgetc(in)
int in;
{
int i;
if(ugnc>0)
return((int) ugbuf[--ugnc]);
if(nc<=0) {
if((nc=read(in,buf,BUF))<=0)
return(-1);
cpos= buf;
}
i= *(cpos++);
nc--;
if(i==((int) '\n'))
nlines++;
return(i);
}
jungetc(in,ugc)
int in;
int ugc;
{
if(ugnc>=UGBUF)
return(-1);
ugbuf[ugnc++]= ugc;
return(ugc);
}
/* ------------------------------------------------------------------------ */
|
the_stack_data/212642598.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
int t = 5, i = 0, j = 0, k = 0, n = 0, im=0;
unsigned long long int c = 0;
char s[30];
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%s", s);
c = 0;
for (j = strlen(s) - 2; j >= 0; j--) {
if (s[j] > s[j+1]) {
s[j]--;
for (k = j+1; k < strlen(s); k++) {
s[k] = '9';
}
}
}
printf("Case #%d: ", i + 1);
if(s[0] != '0') printf("%c", s[0]);
for(j = 1; j < strlen(s); j++)
printf("%c", s[j]);
printf("\n");
}
return 0;
}
|
the_stack_data/23574737.c
|
// b) Compute internal marks of students for five different subjects using structures and functions.
#include <stdio.h>
#include <string.h>
struct students_marks
{
char Name[100];
int Roll;
int Sub[5];
int Total_marks;
float percentage;
char status[5];
};
void StudentDetails(int j, struct students_marks *student)
{
printf("\nEnter Name and Roll.no of student-%d:", j + 1);
scanf("%s %d", student->Name, &student->Roll);
printf("\nEnter marks for respective subjects:");
printf("\nTamil:");
scanf("%d", &student->Sub[0]);
printf("\nEnglish:");
scanf("%d", &student->Sub[1]);
printf("\nMaths:");
scanf("%d", &student->Sub[2]);
printf("\nScience:");
scanf("%d", &student->Sub[3]);
printf("\nSocial Science:");
scanf("%d", &student->Sub[4]);
student->Total_marks = 0;
for (int i = 0; i < 5; i++)
{
if(student->Sub[i]<35)
{
student->status[i]='F';
}
else{
student->status[i]='P';
}
student->Total_marks += student->Sub[i];
}
student->percentage = student->Total_marks / 5.0;
}
int main()
{
int n;
printf("Enter number of students:");
scanf("%d", &n);
struct students_marks students[n];
for (int i = 0; i < n; i++)
{
StudentDetails(i, &students[i]);
}
for (int i = 0; i < n; i++)
{
printf("\n\n-----------------------------------------------------------");
printf("\nName:%s\t\tRoll.no:%d", students[i].Name, students[i].Roll);
printf("\n-----------------------------------------------------------");
printf("\n--------\t\t\t-----");
printf("\nSubjects\t\t\tMarks");
printf("\n--------\t\t\t-----");
printf("\nTamil\t\t\t\t%d(%c)",students[i].Sub[0],students[i].status[0]);
printf("\nEnglish\t\t\t\t%d(%c)",students[i].Sub[1],students[i].status[1]);
printf("\nMaths\t\t\t\t%d(%c)",students[i].Sub[2],students[i].status[2]);
printf("\nScience\t\t\t\t%d(%c)",students[i].Sub[3],students[i].status[3]);
printf("\nSocial Science\t\t\t%d(%c)",students[i].Sub[4],students[i].status[4]);
printf("\n------------\t\t\t-----\t------------------");
printf("\nTotal marks:\t\t\t%d\tPercentage:%.2f",students[i].Total_marks, students[i].percentage);
printf("\n------------\t\t\t-----\t------------------");
printf("\n-----------------------------------------------------------");
}
}
|
the_stack_data/1080728.c
|
#include <complex.h>
long double(creall)(long double complex z) { return creall(z); }
|
the_stack_data/178266054.c
|
#include <stdio.h>
int fib(int n)
{
if (n < 2) {
return 1;
} else {
return fib(n - 2) + fib(n - 1);
}
}
int main(int argc, char *argv[])
{
printf("%d\n", fib(40));
return 0;
}
|
the_stack_data/184517074.c
|
/*
Time Complexity:
Best case - O(nlog(n))
Average case - O(nlog(n))
Worst case - O(n^2)
*/
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int partition(int *elements, int left, int right) {
int i = left, j = right, pivot = elements[left];
while (i < j) {
while (elements[i] <= pivot && i <= right) {
i++;
}
while (elements[j] > pivot && j >= 0) {
j--;
}
if (i < j) {
swap(&elements[i], &elements[j]);
}
}
elements[left] = elements[j];
elements[j] = pivot;
return j;
}
void sort(int *elements, int left, int right) {
if (left < right) {
int pivot = partition(elements, left, right);
sort(elements, left, pivot-1);
sort(elements, pivot+1, right);
}
}
void main() {
int element_index, number_of_elements, i = 0;
printf("Enter the number of elements: ");
scanf("%d", &number_of_elements);
int elements[number_of_elements];
while(i < number_of_elements) {
printf("Enter element(%d): ", i+1);
scanf("%d", &elements[i]);
i++;
}
printf("\n\nThe array is: ");
for (i = 0; i < number_of_elements; i++) {
printf("%d ", elements[i]);
}
sort(elements, 0, number_of_elements-1);
printf("\n\nThe sorted array is: ");
for (i = 0; i < number_of_elements; i++) {
printf("%d ", elements[i]);
}
}
|
the_stack_data/31387303.c
|
/**/
#include <stdio.h>
int main () {
float thresha, threshb, threshc, threshd, stuscore;
printf("Enter thresholds for A, B, C, D\nin that order, decreasing percentages > ");
scanf("%f%f%f%f", &thresha, &threshb, &threshc, &threshd);
printf("Thank you. Now enter student score (percent) >");
scanf("%f", &stuscore);
if (stuscore > thresha)
printf("Student has an A grade\n");
if ((stuscore < thresha) && (stuscore >= threshb))
printf("Student has an B grade\n");
if ((stuscore < threshb) && (stuscore >= threshc))
printf("Student has an C grade\n");
if ((stuscore < threshc) && (stuscore >= threshd))
printf("Student has an D grade\n");
if (stuscore < threshd)
printf("Student has failed the course");
return 0;
}
|
the_stack_data/248581686.c
|
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
const char version[5] = "1.0.1";
printf("\npq-solver v%s\n\n",version);
if(argc != 4)
{
printf("Please provide a,b and c\nUsage: pq-solver [a b c]\n");
return 0;
}
int a,b,c,p,q;
char *endptr;
a = strtol(argv[1],&endptr, 10);
b = strtol(argv[2],&endptr, 10);
c = strtol(argv[3],&endptr, 10);
printf("a: %d\nb: %d\nc: %d\n\np*q: %d\np+q: %d\n",a,b,c,a*c,b);
for(int i = -10000; i < 10000; i++)
{
if(i != 0)
{
if(((float)a*c / i) == (a*c / i))
{
p = a*c / i;
q = i;
if(p+q == b)
{
printf("\np: %d\nq: %d\n",p,q);
break;
}
}
}
}
return 0;
}
|
the_stack_data/86074379.c
|
// KASAN: use-after-free Read in search_by_entry_key
// https://syzkaller.appspot.com/bug?id=c78d28ac5472f784e38b
// status:0
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/loop.h>
static unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
struct fs_image_segment {
void* data;
uintptr_t size;
uintptr_t offset;
};
#define IMAGE_MAX_SEGMENTS 4096
#define IMAGE_MAX_SIZE (129 << 20)
#define sys_memfd_create 319
static unsigned long fs_image_segment_check(unsigned long size,
unsigned long nsegs,
struct fs_image_segment* segs)
{
if (nsegs > IMAGE_MAX_SEGMENTS)
nsegs = IMAGE_MAX_SEGMENTS;
for (size_t i = 0; i < nsegs; i++) {
if (segs[i].size > IMAGE_MAX_SIZE)
segs[i].size = IMAGE_MAX_SIZE;
segs[i].offset %= IMAGE_MAX_SIZE;
if (segs[i].offset > IMAGE_MAX_SIZE - segs[i].size)
segs[i].offset = IMAGE_MAX_SIZE - segs[i].size;
if (size < segs[i].offset + segs[i].offset)
size = segs[i].offset + segs[i].offset;
}
if (size > IMAGE_MAX_SIZE)
size = IMAGE_MAX_SIZE;
return size;
}
static int setup_loop_device(long unsigned size, long unsigned nsegs,
struct fs_image_segment* segs,
const char* loopname, int* memfd_p, int* loopfd_p)
{
int err = 0, loopfd = -1;
size = fs_image_segment_check(size, nsegs, segs);
int memfd = syscall(sys_memfd_create, "syzkaller", 0);
if (memfd == -1) {
err = errno;
goto error;
}
if (ftruncate(memfd, size)) {
err = errno;
goto error_close_memfd;
}
for (size_t i = 0; i < nsegs; i++) {
if (pwrite(memfd, segs[i].data, segs[i].size, segs[i].offset) < 0) {
}
}
loopfd = open(loopname, O_RDWR);
if (loopfd == -1) {
err = errno;
goto error_close_memfd;
}
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
if (errno != EBUSY) {
err = errno;
goto error_close_loop;
}
ioctl(loopfd, LOOP_CLR_FD, 0);
usleep(1000);
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
err = errno;
goto error_close_loop;
}
}
*memfd_p = memfd;
*loopfd_p = loopfd;
return 0;
error_close_loop:
close(loopfd);
error_close_memfd:
close(memfd);
error:
errno = err;
return -1;
}
static long syz_mount_image(volatile long fsarg, volatile long dir,
volatile unsigned long size,
volatile unsigned long nsegs,
volatile long segments, volatile long flags,
volatile long optsarg)
{
struct fs_image_segment* segs = (struct fs_image_segment*)segments;
int res = -1, err = 0, loopfd = -1, memfd = -1, need_loop_device = !!segs;
char* mount_opts = (char*)optsarg;
char* target = (char*)dir;
char* fs = (char*)fsarg;
char* source = NULL;
char loopname[64];
if (need_loop_device) {
memset(loopname, 0, sizeof(loopname));
snprintf(loopname, sizeof(loopname), "/dev/loop%llu", procid);
if (setup_loop_device(size, nsegs, segs, loopname, &memfd, &loopfd) == -1)
return -1;
source = loopname;
}
mkdir(target, 0777);
char opts[256];
memset(opts, 0, sizeof(opts));
if (strlen(mount_opts) > (sizeof(opts) - 32)) {
}
strncpy(opts, mount_opts, sizeof(opts) - 32);
if (strcmp(fs, "iso9660") == 0) {
flags |= MS_RDONLY;
} else if (strncmp(fs, "ext", 3) == 0) {
if (strstr(opts, "errors=panic") || strstr(opts, "errors=remount-ro") == 0)
strcat(opts, ",errors=continue");
} else if (strcmp(fs, "xfs") == 0) {
strcat(opts, ",nouuid");
}
res = mount(source, target, fs, flags, opts);
if (res == -1) {
err = errno;
goto error_clear_loop;
}
res = open(target, O_RDONLY | O_DIRECTORY);
if (res == -1) {
err = errno;
}
error_clear_loop:
if (need_loop_device) {
ioctl(loopfd, LOOP_CLR_FD, 0);
close(loopfd);
close(memfd);
}
errno = err;
return res;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
for (int i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void reset_loop()
{
char buf[64];
snprintf(buf, sizeof(buf), "/dev/loop%llu", procid);
int loopfd = open(buf, O_RDWR);
if (loopfd != -1) {
ioctl(loopfd, LOOP_CLR_FD, 0);
close(loopfd);
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter = 0;
for (;; iter++) {
reset_loop();
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
void execute_one(void)
{
memcpy((void*)0x20000000, "reiserfs\000", 9);
memcpy((void*)0x20000100, "./file0\000", 8);
*(uint64_t*)0x20000140 = 0x20010000;
memcpy((void*)0x20010000,
"\x00\x40\x00\x00\x68\x02\x00\x00\x97\x3d\x00\x00\x12\x00\x00\x00\x00"
"\x00\x00\x00\x84\x3d\x00\x00\x00\x04\x00\x00\x61\x1c\xad\x49\x84\x03"
"\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x10\xec\x03\x02\x00\x01"
"\x00\x52\x65\x49\x73\x45\x72\x33\x46\x73\x00\x00\x00\x03\x00\x00\x00"
"\x02\x00\x01\x00\x00\x00\x85\x3d\x01\x00\x00\x00\x03\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x1e"
"\x00\x3a\xc1\x65\x5f\x00\x4e\xed\x00",
128);
*(uint64_t*)0x20000148 = 0x80;
*(uint64_t*)0x20000150 = 0x10000;
*(uint64_t*)0x20000158 = 0;
*(uint64_t*)0x20000160 = 0;
*(uint64_t*)0x20000168 = 0x11000;
*(uint64_t*)0x20000170 = 0;
*(uint64_t*)0x20000178 = 0;
*(uint64_t*)0x20000180 = 0x11800;
*(uint64_t*)0x20000188 = 0x20011100;
memcpy((void*)0x20011100,
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00"
"\x00\x00\x00\x84\x3d\x00\x00\x00\x04\x00\x00\x61\x1c\xad\x49\x84\x03"
"\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
64);
*(uint64_t*)0x20000190 = 0x40;
*(uint64_t*)0x20000198 = 0x3d96000;
*(uint64_t*)0x200001a0 = 0x20011200;
memcpy((void*)0x20011200,
"\x01\x00\x02\x00\x75\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\xe0\x0f\x00\x00\x01\x00\x00"
"\x00\x02\x00\x00\x00\x01\x00\x00\x00\xf4\x01\x00\x00\x02\x13\x23\x00"
"\xbd\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\xff\xff\xff"
"\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00",
96);
*(uint64_t*)0x200001a8 = 0x60;
*(uint64_t*)0x200001b0 = 0x3d97000;
*(uint64_t*)0x200001b8 = 0x20011300;
memcpy((void*)0x20011300,
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01"
"\x00\x00\x00\x02\x00\x00\x00\x22\x00\x04\x00\x02\x00\x00\x00\x00\x00"
"\x00\x00\x01\x00\x00\x00\x20\x00\x04\x00\x2e\x2e\x2e\xed\x41\x03\x00"
"\x5c\xf9\x53\x5f\x23\x00\x00\x00\x3a\xc1\x65\x5f\x3a\xc1\x65\x5f\x3a"
"\xc1\x65\x5f\x01\x00\x00\x00\xff\xff\xff\xff",
96);
*(uint64_t*)0x200001c0 = 0x60;
*(uint64_t*)0x200001c8 = 0x3d97fa0;
*(uint8_t*)0x20000040 = 0;
syz_mount_image(0x20000000, 0x20000100, 0x4000000, 6, 0x20000140, 0,
0x20000040);
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
loop();
return 0;
}
|
the_stack_data/240129.c
|
/**
* Exercise 1. Make It and Break It
*
* @author: Michelle Adea
* @reference: Zed Shaw
*/
#include <stdio.h>
int main(int argc, char *argv[]) {
/* Make my own pizza. */
char *pizza_name = "Veggie Supreme";
int no_toppings = 3;
char *veg_1 = "red bell peppers";
char *veg_2 = "black olives";
char *veg_3 = "pineapples";
int no_cheeses = 2;
char *cheese_1 = "mozarella";
char *cheese_2 = "parmesan";
printf("My favorite pizza is %s.\n\n", pizza_name);
printf("It has %d toppings.\n", no_toppings);
printf("The toppings are %s, %s, and %s.\n\n", veg_1, veg_2, veg_3);
printf("It has %d types of cheese.\n", no_cheeses);
printf("The types of chesse on the pizza are %s and %s.\n", cheese_1, cheese_2);
return 0;
}
|
the_stack_data/27271.c
|
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#define MAX_DATA 512
#define MAX_ROWS 100
struct Address {
int id;
int set;
char name[MAX_DATA];
char email[MAX_DATA];
};
struct Database {
struct Address rows[MAX_ROWS];
};
struct Connection {
FILE *file;
struct Database *db;
};
void die(const char *message, struct Connection *conn) {
if(errno) {
perror(message);
} else {
printf("ERROR: %s\n", message);
}
if(conn) {
if(conn->file){
fclose(conn->file);
}
if(conn->db){
free(conn->db);
}
free(conn);
}
exit(1);
}
void Address_print(struct Address *addr) {
printf("%d %s %s\n", addr->id, addr->name, addr->email);
};
void Database_load(struct Connection *conn) {
int rc = fread(conn->db, sizeof(struct Database), 1, conn->file);
if(rc != 1)
die("Failed to load database.", conn);
}
struct Connection *Database_open(const char *filename, char mode){
struct Connection *conn = malloc(sizeof(struct Connection));
if(!conn)
die("Memory error", NULL);
conn->db = malloc(sizeof(struct Database));
if(!conn->db)
die("Memory error", conn);
if(mode == 'c') {
conn->file = fopen(filename, "w");
} else {
conn->file = fopen(filename, "r+");
if(conn->file) {
Database_load(conn);
}
}
if(!conn->file)
die("Failed to open the file", conn);
return conn;
};
void Database_close(struct Connection *conn) {
if(conn){
if(conn->file)
fclose(conn->file);
if(conn->db)
free(conn->db);
free(conn);
}
}
void Database_write(struct Connection *conn) {
rewind(conn->file);
int rc = fwrite(conn->db, sizeof(struct Database), 1, conn->file);
if(rc != 1)
die("Failed to write database.", conn);
rc = fflush(conn->file);
if(rc == -1)
die("Cannot flush database.", conn);
}
void Database_create(struct Connection *conn) {
int i = 0;
for(i = 0; i < MAX_ROWS; i++) {
// make a prototype to initialize it
struct Address addr = { .id = i, .set = 0 };
// then just assign it
conn->db->rows[i] = addr;
}
}
void Database_set(struct Connection *conn, int id, const char *name, const char *email) {
struct Address *addr = &conn->db->rows[id];
if (addr->set)
die("Already set, delete it first", conn);
addr->set = 1;
printf("%s - %lu\n", name, strlen(name));
printf("%s - %lu\n", email, strlen(email));
char *res = strncpy(addr->name, name, strlen(name));
addr->name[strlen(name)] = '\0';
if(!res)
die("Name copy failed", conn);
res = strncpy(addr->email, email, strlen(email));
addr->email[strlen(email)] = '\0';
if(!res)
die("Email copy failed", conn);
}
void Database_get(struct Connection *conn, int id) {
struct Address *addr = &conn->db->rows[id];
if(addr->set) {
Address_print(addr);
} else {
die("ID is not set", conn);
}
}
void Database_delete(struct Connection *conn, int id) {
struct Address addr = { .id = id, .set = 0 };
conn->db->rows[id] = addr;
}
void Database_list(struct Connection *conn) {
int i = 0;
struct Database *db = conn->db;
for(i = 0; i < MAX_ROWS; i++) {
struct Address *cur = &db->rows[i];
if(cur->set) {
Address_print(cur);
}
}
}
int main(int argc, char *argv[]) {
if(argc < 3)
die("USAGE: ex17 <dbfile> <action> [action params]", NULL);
char *filename = argv[1];
char action = argv[2][0];
struct Connection *conn = Database_open(filename, action);
int id = 0;
if(argc > 3) id = atoi(argv[3]);
if(id >= MAX_ROWS) die("There's not that many records.", conn);
switch(action) {
case 'c':
Database_create(conn);
Database_write(conn);
break;
case 'g':
if (argc != 4)
die("Need an id to get", conn);
Database_get(conn, id);
break;
case 's':
if(argc != 6)
die("Need id, name, email to set", conn);
Database_set(conn, id, argv[4], argv[5]);
Database_write(conn);
break;
case 'd':
if(argc != 4)
die("Need id to delete", conn);
Database_delete(conn, id);
Database_write(conn);
break;
case 'l':
Database_list(conn);
break;
default:
die("Invalid action: c=create, g=get, s=set, d=del, l=list", conn);
}
Database_close(conn);
return 0;
}
|
the_stack_data/108086.c
|
/**
* @author David Berardi
* @file phonebook.c
* @name Phonebook
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
/*
1) help x
2) print x
3) inserimento x
4) cancelazzione con compattazione x
5) modifica contatto x
6) ordinamento x
7) ricerca dicotomica x
8) salva su file x
9) carica da file x
*/
// short-hand for frequentely used types
typedef char Name[64];
typedef char Surname[64];
typedef char Num[16];
typedef char Addr[128];
// Phone book contact
typedef struct contact
{
Name name;
Surname surname;
Num num;
Addr addr;
} Contact, *PContact;
// prints the available commands
void help();
// prints the all the present phone book's contacts
void print(PContact*, int);
// inserts a contact in the phone book if it's not full
PContact* insert(PContact*, int*, int*);
// increases phone book's size
PContact* increase(PContact*, int*);
// deletes the contact at the position and shifts left by one the other contacts
// and decrements the indicator of fullness
void deleteContact(PContact*, int*, int);
// erases the phone book
void erase(PContact*, int*);
// modifies the contact's information if the contact exists
void modify(PContact*, int, int);
// sorts the phone book by name
void sort(PContact*, int);
// search contact in the phone book if it exists
void search(PContact*, char[], int);
// converts a string from mixed-case to lowercase
void toLower(char[]);
// unites name and surname
void concNameSur(PContact*, char[], int);
// unites surname and name
void concSurName(PContact*, char[], int);
// prints the contact found by search()
void printContact(PContact*, int);
// saves phone book on a file
void save(PContact*, FILE*, int);
// load phone book from file
PContact* load(PContact*, FILE*, int*, int*);
// method for input of strings
void getString(char*, int);
// driver
int main()
{
PContact* phonebook; // phone book
FILE *fp;
int size = 30; // phone book's initial size
phonebook = (PContact*)calloc(sizeof(PContact), size); // allocates memory for the pointer to the phone book
char buffer[1024]; // buffer for the selection of commands to execute
char b[64]; // buffer for the contact search
int full_ind = 0; // phone book's fullness indicator
int n = 0; // which contact to delete
// user interface
printf("Press h for the list of commands\n");
do
{
printf(">> ");
getString(buffer, 1023);
switch(buffer[0])
{
case 'h':
case 'H':
case '?':
help();
break;
case 'p':
case 'P':
print(phonebook, full_ind);
break;
case 'i':
case 'I':
phonebook = insert(phonebook, &full_ind, &size);
break;
case 'd':
case 'D':
if(full_ind > 0)
{
for(int i = 0; i < full_ind; i++)
{
printf("#%d | Name: %s %s\n", i+1, phonebook[i]->name, phonebook[i]->surname);
}
printf("\nInsert the contact's position: ");
scanf("%d", &n);
getchar();
deleteContact(phonebook, &full_ind, n);
} else printf("Could not delete! Phone book's empty!\n");
break;
case 'a':
case 'A':
erase(phonebook, &full_ind);
break;
case 'm':
case 'M':
if(full_ind > 0)
{
for(int i = 0; i < full_ind; i++)
{
printf("#%d | Name: %s %s\n", i+1, phonebook[i]->name, phonebook[i]->surname);
}
printf("Insert the contact's position: ");
scanf("%d", &n);
getchar();
modify(phonebook, full_ind, n);
} else printf("Could not modify! Phone book's empty!\n");
break;
case 'o':
case 'O':
sort(phonebook, full_ind);
break;
case 'r':
case 'R':
if(full_ind > 0)
{
sort(phonebook, full_ind);
printf("Insert contact to search:\n");
getString(b, 63);
search(phonebook, b, full_ind);
} else printf("Could not search! Phone book's empty!\n");
break;
case 's':
case 'S':
fp = fopen("phonebook.dat", "w");
if(fp)
{
save(phonebook, fp, full_ind);
} else printf("Could not find file!\n");
fclose(fp);
break;
case 'l':
case 'L':
fp = fopen("phonebook.dat", "r");
if(fp)
{
phonebook = load(phonebook, fp, &full_ind, &size);
} else printf("Could not find file!\n");
fclose(fp);
break;
case 'q':
printf("---End of phone book program---\n");
break;
case '\0':
break;
default:
printf("Error! Invalid character!\n");
break;
}
printf("\n");
} while (buffer[0] != 'q');
// frees all allocated memory
erase(phonebook, &full_ind);
free(phonebook);
getchar();
return 0;
}
void help()
{
printf("h - help\n");
printf("p - print all contacts present in the phone book\n");
printf("i - insert new contact\n");
printf("d - delete contact\n");
printf("a - erase phone book\n");
printf("m - modify contact information\n");
printf("o - sort phone book\n");
printf("r - search name\n");
printf("s - save to file\n");
printf("l - load from file\n");
printf("q - quit program\n");
}
void print(PContact *r, int p)
{
// if the phone book is not empty print all the contacts' information
if(p > 0)
{
for(int i = 0; i < p; i++)
{
printf("Contact #%d\n", i+1);
printf("Name: %s %s\n", r[i]->name, r[i]->surname);
printf("Telephone: %s\n", r[i]->num);
printf("Address: %s\n\n", r[i]->addr);
}
}
else printf("Phone book empty!\n");
}
PContact* insert(PContact *r, int *p, int *size)
{
// if the phone book is full it increases it's size by one
if(*p == *size)
{
r = increase(r, size);
}
r[*p] = (PContact)calloc(sizeof(Contact), 1); // allocate the contact memory
printf("Insert contact's surname, name, telephone number, address: \n");
// insert the contact's information
printf("Surname: ");
getString(r[*p]->surname, sizeof(Surname));
printf("Name: ");
getString(r[*p]->name, sizeof(Name));
printf("Telephone Number: ");
getString(r[*p]->num, sizeof(Num));
printf("Address: ");
getString(r[*p]->addr, sizeof(Addr));
(*p)++; // increment the indicator of fullness
return r; // returns a pointer to the phone book
}
PContact* increase(PContact *r, int* size)
{
(*size)++; // increases the phone book size counter
PContact *s = (PContact*)calloc(sizeof(PContact), *size); // allocates a new pointer of the new size
memcpy(s, r, sizeof(PContact) * (*size)); // copies the old contacts in the new pointer
free(r); // frees the old pointer
return s; // returns the new pointer to phone book with increased size with the respect to the former
}
void deleteContact(PContact *r, int *p, int n)
{
// if the position does not exceed the phone book size and the contact exists
// shift copy the contacts
if(n > 0 && n <= *p)
{
free(r[n-1]); // deletes the contact
for(int i = n-1; i < (*p)-1; i++)
{
// shift the contacts left by one position
// until the penultimate is reached
r[i] = r[i+1];
}
(*p)--; // decrement the indicator of fullness
}
else printf("Could not delete! Contact at position #%d does not exist!\n", n);
}
void erase(PContact *r, int *p)
{
// erases all the contacts in the phone book
// and sets the fullness indicator to zero
for(int i = 0; i < *p; i++)
free(r[i]);
(*p) = 0;
}
void modify(PContact *r, int p, int n)
{
// if the position does not exceed the phone book size and the contact exists
// modify the contact's information
if(n > 0 && n <= p)
{
printf("Modify contact's info: \n");
// insert new contact's information
printf("Surname: ");
getString(r[n-1]->surname, sizeof(Surname));
printf("Name: ");
getString(r[n-1]->name, sizeof(Name));
printf("Telephone Number: ");
getString(r[n-1]->num, sizeof(Num));
printf("Address: ");
getString(r[n-1]->addr, sizeof(Addr));
printf("\nContact modified successfully!\n");
}
else printf("Could not modify! Contact at position #%d does not exist!\n", n);
}
void sort(PContact *r, int p)
{
// sorts if the phone book is not empty
if(p > 0)
{
int c = 0;
int d = 0;
PContact temp;
for(int i = 0; i < p - 1; i++)
{
for(int j = 0; j < p - i - 1; j++)
{
c = strcmp(r[j]->surname, r[j+1]->surname);
d = strcmp(r[j]->name, r[j+1]->name);
// compares the names and surnames, 1 a is greater than b, 0 equal, -1 a is less than b
if(c > 0 || (c == 0 && d > 0))
{
temp = r[j];
r[j] = r[j+1];
r[j+1] = temp;
}
}
}
}
else printf("Could not sort! Empty phone book!\n");
}
void search(PContact *r, char x[], int p)
{
int h = 0;
for(int i = 0; i < p; i++)
{
char temp[129];
char temp2[129];
char t1[64];
char t2[64];
strcpy(t1, r[i]->surname);
strcpy(t2, r[i]->name);
toLower(t1);
toLower(t2);
concNameSur(r, temp, i);
concSurName(r, temp2, i);
toLower(x);
if(strncmp(x, temp, strlen(x)) == 0) { printContact(r, i); h = 1; }
else if(strncmp(x, temp2, strlen(x)) == 0) { printContact(r, i); h = 1; }
else if(strncmp(x, t1, strlen(x)) == 0 || strncmp(x, t2, strlen(x)) == 0) { printContact(r, i); h = 1; }
}
if(h == 0) printf("Could not find contact!\n");
}
void toLower(char x[])
{
for(int i = 0; x[i]; i++){
x[i] = tolower(x[i]);
}
}
void concNameSur(PContact *r, char x[], int i)
{
int j = 0, k = 0;
for(j = 0; r[i]->name[j] != '\0'; ++j)
{
x[j] = r[i]->name[j];
}
x[j] = ' ';
for(k = 0; r[i]->surname[k] != '\0'; ++k, ++j)
{
x[j+1] = r[i]->surname[k];
}
x[j+1] = '\0';
toLower(x);
}
void concSurName(PContact *r, char x[], int i)
{
int j = 0, k = 0;
for(j = 0; r[i]->surname[j] != '\0'; ++j)
{
x[j] = r[i]->surname[j];
}
x[j] = ' ';
for(k = 0; r[i]->name[k] != '\0'; ++k, ++j)
{
x[j+1] = r[i]->name[k];
}
x[j+1] = '\0';
toLower(x);
}
void printContact(PContact *r, int a)
{
// if the phone book's not empty prints the desired contact's info
if(a >= 0)
{
printf("Contact N.%d\n", a+1);
printf("Name: %s %s\n", r[a]->name, r[a]->surname);
printf("Telephone: %s\n", r[a]->num);
printf("Address: %s\n\n", r[a]->addr);
} else return;
}
void save(PContact *r, FILE *f, int p)
{
// if the phone book is not empty save the contacts on the file
if(p > 0)
{
for(int i = 0; i < p; i++)
{
fwrite(r[i], sizeof(Contact), 1, f);
}
printf("Phone book successfully saved on file!\n");
}
else printf("Could not save! Phone book's empty!\n");
}
PContact* load(PContact *r, FILE *f, int *p, int *size)
{
Contact c;
while(fread(&c, 1, sizeof(Contact), f))
{
// if the the number of contacts in the file exceeds
// the phone book's size, it increases it
if(*p >= *size) r = increase(r, size);
r[*p] = (PContact)calloc(sizeof(Contact), 1); // allocates memory for the contact
*r[*p] = c; // stores the read contact in the phone book
(*p)++; // increases the fullness indicator
}
return r; // returns a pointer to the phone book
}
void getString(char *str, int ncar)
{
char c;
int n = 0;
int cont = 1;
while(cont)
{
c = getchar();
if(c == EOF || n == (ncar - 2) || c == '\n')
{
cont = 0;
}
else
{
str[n++] = c;
}
}
str[n] = '\0';
}
|
the_stack_data/1196611.c
|
#include <stdio.h>
#include <stdint.h>
extern uint32_t _sumof4numbers
(
uint32_t a,
uint32_t b,
uint32_t c,
uint32_t d
);
extern uint32_t _sumof5numbers
(
uint32_t a,
uint32_t b,
uint32_t c,
uint32_t d,
uint32_t e
);
extern uint32_t _example_42(void);
int main (void)
{
uint32_t s4,s5,d42;
s4 = _sumof4numbers (1,2,3,4);
s5 = _sumof5numbers (1,2,3,4,5);
d42 = _example_42();
printf ("Procedure Call Standard \n");
printf ("-- sum(1,2,3,4) = %d\n",s4);
printf ("-- sum(1,2,3,4,5) = %d\n",s5);
printf ("-- 42 == %d : %d\n",d42,42==d42);
return 0;
}
|
the_stack_data/175142970.c
|
void
endhostent(void)
{
}
|
the_stack_data/237642977.c
|
# 1 "benchmarks/ds-06-impl3.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "benchmarks/ds-06-impl3.c"
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h"
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h" 1
# 132 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h"
int X_SIZE_VALUE = 0;
int overflow_mode = 1;
int rounding_mode = 0;
# 155 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/definitions.h"
typedef struct {
double a[100];
int a_size;
double b[100];
int b_size;
double sample_time;
double a_uncertainty[100];
double b_uncertainty[100];
} digital_system;
typedef struct {
double A[4][4];
double B[4][4];
double C[4][4];
double D[4][4];
double states[4][4];
double outputs[4][4];
double inputs[4][4];
double K[4][4];
unsigned int nStates;
unsigned int nInputs;
unsigned int nOutputs;
} digital_system_state_space;
typedef struct {
int int_bits;
int frac_bits;
double max;
double min;
int default_realization;
double delta;
int scale;
double max_error;
} implementation;
typedef struct {
int push;
int in;
int sbiw;
int cli;
int out;
int std;
int ldd;
int subi;
int sbci;
int lsl;
int rol;
int add;
int adc;
int adiw;
int rjmp;
int mov;
int sbc;
int ld;
int rcall;
int cp;
int cpc;
int ldi;
int brge;
int pop;
int ret;
int st;
int brlt;
int cpi;
} instructions;
typedef struct {
long clock;
int device;
double cycle;
instructions assembly;
} hardware;
typedef struct{
float Ap, Ar, Ac;
float wp, wc, wr;
int type;
}filter_parameters;
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 461 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 462 "/usr/include/features.h" 2 3 4
# 485 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 486 "/usr/include/features.h" 2 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
# 26 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 209 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
# 209 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 321 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 3 4
typedef int wchar_t;
# 32 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 40 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
# 56 "/usr/include/stdlib.h" 2 3 4
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) ;
extern double atof (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) ;
extern long int a64l (const char *__s)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
typedef int __sig_atomic_t;
# 30 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
# 59 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
# 97 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __pid_t pid_t;
typedef __id_t id_t;
typedef __ssize_t ssize_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
typedef __clock_t clock_t;
# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
typedef __clockid_t clockid_t;
# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
typedef __time_t time_t;
# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
typedef __timer_t timer_t;
# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 144 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 24 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
# 25 "/usr/include/endian.h" 2 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{
return __builtin_bswap16 (__bsx);
}
static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{
return __builtin_bswap32 (__bsx);
}
# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
typedef __sigset_t sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
typedef __suseconds_t suseconds_t;
typedef long int __fd_mask;
# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
__fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
# 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
# 227 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
# 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
# 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
int __cur_writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
# 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
typedef unsigned long int pthread_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 395 "/usr/include/stdlib.h" 2 3 4
extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern long int nrand48 (unsigned short int __xsubi[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
extern long int jrand48 (unsigned short int __xsubi[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern void *calloc (size_t __nmemb, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
extern void *realloc (void *__ptr, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__))
__attribute__ ((__alloc_size__ (2, 3)));
extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
# 569 "/usr/include/stdlib.h" 2 3 4
extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 647 "/usr/include/stdlib.h" 3 4
extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
# 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 688 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 710 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
# 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) ;
typedef int (*__compar_fn_t) (const void *, const void *);
# 820 "/usr/include/stdlib.h" 3 4
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
# 840 "/usr/include/stdlib.h" 3 4
extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
# 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
__attribute__ ((__nothrow__ , __leaf__));
extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
# 957 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
# 1003 "/usr/include/stdlib.h" 3 4
extern int getloadavg (double __loadavg[], int __nelem)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
# 1013 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 1014 "/usr/include/stdlib.h" 2 3 4
# 1023 "/usr/include/stdlib.h" 3 4
# 18 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 66 "/usr/include/assert.h" 3 4
extern void __assert_fail (const char *__assertion, const char *__file,
unsigned int __line, const char *__function)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void __assert_perror_fail (int __errnum, const char *__file,
unsigned int __line, const char *__function)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
extern void __assert (const char *__assertion, const char *__file, int __line)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 37 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
typedef struct _G_fpos_t
{
__off_t __pos;
__mbstate_t __state;
} __fpos_t;
# 40 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
__off64_t __pos;
__mbstate_t __state;
} __fpos64_t;
# 41 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE __FILE;
# 42 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
# 43 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;
typedef void _IO_lock_t;
struct _IO_FILE
{
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
# 44 "/usr/include/stdio.h" 2 3 4
# 52 "/usr/include/stdio.h" 3 4
typedef __gnuc_va_list va_list;
# 84 "/usr/include/stdio.h" 3 4
typedef __fpos_t fpos_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 134 "/usr/include/stdio.h" 2 3 4
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) __attribute__ ((__nothrow__ , __leaf__));
# 173 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) ;
# 187 "/usr/include/stdio.h" 3 4
extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
# 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 246 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
# 279 "/usr/include/stdio.h" 3 4
extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;
# 292 "/usr/include/stdio.h" 3 4
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
__attribute__ ((__nothrow__ , __leaf__)) ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) __attribute__ ((__nothrow__ , __leaf__));
extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) __attribute__ ((__nothrow__));
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) __attribute__ ((__nothrow__));
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
# 379 "/usr/include/stdio.h" 3 4
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
;
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
;
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))
;
# 432 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
__attribute__ ((__format__ (__scanf__, 2, 0)));
# 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
# 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 603 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
# 673 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
# 707 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
# 731 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 757 "/usr/include/stdio.h" 3 4
extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void perror (const char *__s);
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
# 782 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
# 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
# 840 "/usr/include/stdio.h" 3 4
extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
# 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 873 "/usr/include/stdio.h" 3 4
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 2
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
void __DSVERIFIER_assume(_Bool expression){
__CPROVER_assume(expression);
}
void __DSVERIFIER_assert(_Bool expression){
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
((void) sizeof ((
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ; else __assert_fail (
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
"expression"
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h", 36, __extension__ __PRETTY_FUNCTION__); }))
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
;
}
void __DSVERIFIER_assert_msg(_Bool expression, char * msg){
printf("%s", msg);
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
((void) sizeof ((
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
expression
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
) ; else __assert_fail (
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
"expression"
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h", 41, __extension__ __PRETTY_FUNCTION__); }))
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/compatibility.h"
;
}
# 22 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 1
# 27 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;
typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 87 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;
typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 10 "/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h" 2 3 4
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 34 "/usr/include/inttypes.h" 3 4
typedef int __gwchar_t;
# 266 "/usr/include/inttypes.h" 3 4
typedef struct
{
long int quot;
long int rem;
} imaxdiv_t;
# 290 "/usr/include/inttypes.h" 3 4
extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern intmax_t strtoimax (const char *__restrict __nptr,
char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
extern uintmax_t strtoumax (const char *__restrict __nptr,
char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
__gwchar_t **__restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__));
extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
__gwchar_t ** __restrict __endptr, int __base)
__attribute__ ((__nothrow__ , __leaf__));
# 432 "/usr/include/inttypes.h" 3 4
# 29 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h" 2
# 30 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
extern implementation impl;
typedef int64_t fxp_t;
fxp_t _fxp_one;
fxp_t _fxp_half;
fxp_t _fxp_minus_one;
fxp_t _fxp_min;
fxp_t _fxp_max;
double _dbl_max;
double _dbl_min;
fxp_t _fxp_fmask;
fxp_t _fxp_imask;
static const double scale_factor[31] = { 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0,
128.0, 256.0, 512.0, 1024.0, 2048.0, 4096.0, 8192.0, 16384.0, 32768.0,
65536.0, 131072.0, 262144.0, 524288.0, 1048576.0, 2097152.0, 4194304.0,
8388608.0, 16777216.0, 33554432.0, 67108864.0, 134217728.0,
268435456.0, 536870912.0, 1073741824.0 };
static const double scale_factor_inv[31] = { 1.0, 0.5, 0.25, 0.125, 0.0625,
0.03125, 0.015625, 0.0078125, 0.00390625, 0.001953125, 0.0009765625,
0.00048828125, 0.000244140625, 0.0001220703125, 0.00006103515625,
0.000030517578125, 0.000015258789063, 0.000007629394531,
0.000003814697266, 0.000001907348633, 0.000000953674316,
0.000000476837158, 0.000000238418579, 0.000000119209290,
0.000000059604645, 0.000000029802322, 0.000000014901161,
0.000000007450581, 0.000000003725290, 0.000000001862645,
0.000000000931323 };
static const float rand_uni[10000] = { -0.486240329978498f, -0.0886462298529236f, -0.140307596103306f, 0.301096597450952f, 0.0993171079928659f, 0.971751769763271f, 0.985173975730828f, 0.555993645184930f, 0.582088652691427f, -0.153377496651175f, 0.383610009058905f, -0.335724126391271f, 0.978768141636516f, -0.276250018648572f, 0.390075705739569f, -0.179022404038782f, 0.690083827115783f, -0.872530132490992f, -0.970585763293203f, -0.581476053441704f, -0.532614615674888f, -0.239699306693312f, -0.678183014035494f, 0.349502640932782f, -0.210469890686263f, 0.841262085391842f, -0.473585465151401f, 0.659383565443701f, -0.651160036945754f, -0.961043527561335f, -0.0814927639199137f, 0.621303110569702f, -0.784529166943541f, 0.0238464770757800f, 0.392694728594110f, 0.776848735202001f, 0.0870059709310509f, 0.880563655271790f, 0.883457036977564f, -0.249235082877382f, -0.691040749216870f, 0.578731120064320f, -0.973932858000832f, -0.117699105431720f, -0.723831748151088f, -0.483149657477524f, -0.821277691383664f, -0.459725618100875f, 0.148175952221864f, 0.444306875534854f, -0.325610376336498f, 0.544142311404910f, -0.165319440455435f, 0.136706800705517f, 0.543312481350682f, 0.467210959764607f, -0.349266618228534f, -0.660110730565862f, 0.910332331495431f, 0.961049802789367f, -0.786168905164629f, 0.305648402726554f, 0.510815258508885f, 0.0950733260984060f, 0.173750645487898f, 0.144488668408672f, 0.0190031984466126f, -0.299194577636724f, 0.302411647442273f, -0.730462524226212f, 0.688646006554796f, 0.134948379722118f, 0.533716723458894f, -0.00226300779660438f, -0.561340777806718f, 0.450396313744017f, -0.569445876566955f, 0.954155246557698f, -0.255403882430676f, -0.759820984120828f, -0.855279790307514f, -0.147352581758156f, -0.302269055643746f, -0.642038024364086f, -0.367405981107491f, 0.491844011712164f, -0.542191710121194f, -0.938294043323732f, 0.683979894338020f, 0.294728290855287f, 0.00662691839443919f, -0.931040350582855f, 0.152356209974418f, 0.678620860551457f, -0.534989269238408f, 0.932096367913226f, -0.0361062818028513f, -0.847189697149530f, -0.975903030160255f, 0.623293205784014f, -0.661289688031659f, 0.724486055119603f, 0.307504095172835f, 0.00739266163731767f, -0.393681596442097f, 0.0313739422974388f, 0.0768157689673350f, -0.652063346886817f, 0.864188030044388f, -0.588932092781034f, 0.496015896758580f, -0.872858269231211f, 0.978780599551039f, -0.504887732991147f, -0.462378791937628f, 0.0141726829338038f, 0.769610007653591f, 0.945233033188923f, -0.782235375325016f, -0.832206533738799f, 0.745634368088673f, -0.696969510157151f, -0.0674631869948374f, -0.123186450806584f, -0.359158959141949f, -0.393882649464391f, 0.441371446689899f, -0.829394270569736f, -0.301502651277431f, -0.996215501187289f, 0.934634037393066f, -0.282431114746289f, -0.927550795619590f, -0.437037530043415f, -0.360426812995980f, 0.949549724575862f, 0.502784616197919f, 0.800771681422909f, -0.511398929004089f, 0.309288504642554f, -0.207261227890933f, 0.930587995125773f, -0.777029876696670f, -0.489329175755640f, -0.134595132329858f, 0.285771358983518f, 0.182331373854387f, -0.544110494560697f, 0.278439882883985f, -0.556325158102182f, 0.579043806545889f, 0.134648133801916f, 0.602850725479294f, -0.151663563868883f, 0.180694361855878f, -0.651591295315595f, 0.281129147768056f, -0.580047306475484f, 0.687883075491433f, 0.279398670804288f, -0.853428128249503f, -0.532609367372680f, -0.821156786377917f, -0.181273229058573f, -0.983898569846882f, -0.0964374318311501f, 0.880923372124250f, 0.102643371392389f, 0.893615387135596f, -0.259276649383649f, 0.699287743639363f, 0.402940604635828f, -0.110721596226581f, 0.0846246472582877f, 0.820733021865405f, 0.795578903285308f, -0.495144122011537f, 0.273150029257472f, -0.268249949701437f, 0.231982193341980f, 0.694211299124074f, 0.859950868718233f, 0.959483382623794f, -0.422972626833543f, -0.109621798738360f, 0.433094703426531f, 0.694025903378851f, 0.374478987547435f, -0.293668545105608f, -0.396213864190828f, -0.0632095887099047f, -0.0285139536748673f, 0.831794132192390f, -0.548543088139238f, 0.791869201724680f, 0.325211484201845f, 0.155274810721772f, -0.112383643064821f, -0.674403070297721f, 0.642801068229810f, -0.615712048835242f, -0.322576771285566f, -0.409336818836595f, 0.548069973193770f, -0.386353709407947f, -0.0741664985357784f, 0.619639599324983f, -0.815703814931314f, 0.965550307223862f, 0.623407852683828f, -0.789634372832984f, 0.736750050047572f, -0.0269443926793700f, 0.00545706093721488f, -0.315712479832091f, -0.890110021644720f, -0.869390443173846f, -0.381538869981866f, -0.109498998005949f, 0.131433952330613f, -0.233452413139316f, 0.660289822785465f, 0.543381186340023f, -0.384712418750451f, -0.913477554164890f, 0.767102957655267f, -0.115129944521936f, -0.741161985822647f, -0.0604180020782450f, -0.819131535144059f, -0.409539679760029f, 0.574419252943637f, -0.0440704617157433f, 0.933173744590532f, 0.261360623390448f, -0.880290575543046f, 0.329806293425492f, 0.548915621667952f, 0.635187167795234f, -0.611034070318967f, 0.458196727901944f, 0.397377226781023f, 0.711941361933987f, 0.782147744383368f, -0.00300685339552631f, 0.384687233450957f, 0.810102466029521f, 0.452919847968424f, -0.183164257016897f, -0.755603185485427f, -0.604334477365858f, -0.786222413488860f, -0.434887500763099f, -0.678845635625581f, -0.381200370488331f, -0.582350534916068f, -0.0444427346996734f, 0.116237247526397f, -0.364680921206275f, -0.829395404347498f, -0.258574590032613f, -0.910082114298859f, 0.501356900925997f, 0.0295361922006900f, -0.471786618165219f, 0.536352925101547f, -0.316120662284464f, -0.168902841718737f, 0.970850119987976f, -0.813818666854395f, -0.0861183123848732f, 0.866784827877161f, 0.535966478165739f, -0.806958669103425f, -0.627307415616045f, -0.686618354673079f, 0.0239165685193152f, 0.525427699287402f, 0.834079334357391f, -0.527333932295852f, 0.130970034225907f, -0.790218350377199f, 0.399338640441987f, 0.133591886379939f, -0.181354311053254f, 0.420121912637914f, -0.625002202728601f, -0.293296669160307f, 0.0113819513424340f, -0.882382002895096f, -0.883750159690028f, 0.441583656876336f, -0.439054135454480f, 0.873049498123622f, 0.660844523562817f, 0.0104240153103699f, 0.611420248331623f, -0.235926309432748f, 0.207317724918460f, 0.884691834560657f, 0.128302402592277f, -0.283754448219060f, 0.237649901255856f, 0.610200763264703f, -0.625035441247926f, -0.964609592118695f, -0.323146562743113f, 0.961529402270719f, -0.793576233735450f, -0.843916713821003f, 0.314105102728384f, -0.204535560653294f, 0.753318789613803f, 0.160678386635821f, -0.647065919861379f, -0.202789866826280f, 0.648108234268198f, -0.261292621025902f, 0.156681828732770f, 0.405377351820066f, 0.228465381497500f, 0.972348516671163f, 0.288346037401522f, -0.0799068604307178f, 0.916939290109587f, -0.279220972402209f, -0.203447523864279f, -0.533640046855273f, 0.543561961674653f, 0.880711097286889f, -0.549683064687774f, 0.0130107219236368f, -0.554838164576024f, -0.379442406201385f, -0.00500104610043062f, 0.409530122826868f, -0.580423080726061f, 0.824555731914455f, -0.254134502966922f, 0.655609706875230f, 0.629093866184236f, -0.690033250889974f, -0.652346551677826f, 0.169820593515952f, 0.922459552232043f, 0.351812083539940f, 0.876342426613034f, -0.513486005850680f, -0.626382302780497f, -0.734690688861027f, 0.245594886018314f, -0.875740935105191f, -0.388580462918006f, 0.0127041754106421f, -0.0330962560066819f, -0.425003146474193f, 0.0281641353527495f, 0.261441358666622f, 0.949781327102773f, 0.919646340564270f, 0.504503377003781f, 0.0817071051871894f, 0.319968570729658f, 0.229065413577318f, -0.0512608414259468f, -0.0740848540944785f, -0.0974457038582892f, 0.532775710298005f, -0.492913317622840f, 0.492871078783642f, -0.289562388384881f, 0.229149968879593f, 0.697586903105899f, 0.900855243684925f, 0.969700445892771f, -0.618162745501349f, -0.533241431614228f, -0.937955908995453f, 0.886669636523452f, 0.498748076602594f, 0.974106016180519f, -0.199411214757595f, 0.725270392729083f, -0.0279932700005097f, -0.889385821767448f, -0.452211028905500f, -0.487216271217731f, -0.577105004471439f, 0.777405674160298f, 0.390121144627092f, -0.595062864225581f, -0.844712795815575f, -0.894819796738658f, 0.0556635002662202f, 0.200767245646242f, 0.481227096067452f, -0.0854169009474664f, 0.524532943920022f, -0.880292014538901f, -0.127923833629789f, -0.929275628802356f, 0.233276357260949f, -0.776272194935070f, 0.953325886548014f, -0.884399921036004f, -0.504227548828417f, -0.546526107689276f, 0.852622421886067f, 0.947722695551154f, -0.668635552599119f, 0.768739709906834f, 0.830755876586102f, -0.720579994994166f, 0.761613532216491f, 0.340510345777526f, 0.335046764810816f, 0.490102926886310f, -0.568989013749608f, -0.296018470377601f, 0.979838924243657f, 0.624231653632879f, 0.553904401851075f, -0.355359451941014f, 0.267623165480721f, 0.985914275634075f, -0.741887849211797f, 0.560479100333108f, -0.602590162007993f, -0.874870765077352f, -0.0306218773384892f, 0.963145768131215f, 0.544824028787036f, -0.133990816021791f, 0.0679964588712787f, -0.156401335214901f, -0.0802554171832672f, 0.856386218492912f, 0.143013580527942f, 0.403921859374840f, -0.179029058044097f, 0.770723540077919f, -0.183650969350452f, -0.340718434629824f, 0.217166124261387f, -0.171159949445977f, 0.127493767348173f, -0.649649349141405f, -0.0986978180993434f, 0.301786606637125f, 0.942172200207855f, 0.0323236270151113f, -0.579853744301016f, -0.964413060851558f, 0.917535782777861f, 0.442144649483292f, -0.684960854610878f, -0.418908715566712f, 0.617844265088789f, 0.897145578082386f, 0.235463167636481f, 0.0166312355859484f, 0.948331447443040f, -0.961085640409103f, -0.0386086809179784f, -0.949138997977665f, 0.738211385880427f, 0.613757309091864f, -0.606937832993426f, 0.825253298062192f, 0.932609757667859f, -0.169023247637751f, -0.411237965787391f, 0.550590803600950f, -0.0561729280137304f, -0.559663108323671f, -0.718592671237337f, 0.885889621415361f, -0.364207826334344f, -0.839614660327507f, 0.265502694339344f, 0.394329270534417f, -0.270184577808578f, -0.865353487778069f, -0.528848754655393f, -0.179961524561963f, 0.571721065613544f, -0.774363220756696f, 0.251123315200792f, -0.217722762975159f, 0.0901359910328954f, -0.329445470667965f, 0.366410356722994f, -0.777512662632715f, 0.654844363477267f, -0.882409911562713f, -0.613612530795153f, -0.926517759636550f, 0.111572665207194f, 0.0729846382226607f, 0.789912813274098,
0.784452109264882f, -0.949766989295825f, 0.318378232675431f, 0.732077593075111f, 0.786829143208386f, -0.134682559823644f, 0.733164743374965f, 0.978410877665941f, 0.992008491438409f, -0.319064303035495f, 0.958430683602029f, 0.514518212363212f, 0.101876224417090f, 0.642655735778237f, -0.170746516901312f, 0.252352078365623f, -0.761327278132210f, 0.724119717129199f, 0.889374997869224f, -0.785987369200692f, -0.594670344572584f, 0.805192297495935f, -0.990523259595814f, 0.483998949026664f, 0.747350619254878f, -0.824845161088780f, 0.543009506581798f, -0.208778528683094f, -0.314149951901368f, 0.943576771177672f, -0.102633559170861f, -0.947663019606703f, -0.557033071578968f, 0.419150797499848f, 0.251214274356296f, 0.565717763755325f, 0.126676667925064f, -0.0213369479214840f, 0.342212953426240f, -0.288015274572288f, 0.121313363277304f, 0.452832374494206f, 0.545420403121955f, -0.616024063400938f, -0.0320352392995826f, -0.400581850938279f, 0.0642433474653812f, -0.673966224453150f, 0.951962939602010f, -0.241906012952983f, 0.0322060960995099f, -0.449185553826233f, -0.709575766146540f, 0.0283340814242898f, 0.234237103593580f, -0.285526615094797f, -0.793192668153991f, -0.437130485497140f, -0.956132143306919f, 0.601158367473616f, 0.238689691528783f, 0.173709925321432f, 0.437983847738997f, 0.397380645202102f, 0.432093344086237f, -0.0338869881121104f, -0.966303269542493f, 0.875351570183604f, -0.0584554089652962f, 0.294207497692552f, 0.200323088145182f, 0.826642387259759f, 0.284806025494260f, -0.00660991970522007f, 0.682493772727303f, -0.151980775670668f, 0.0470705546940635f, -0.236378427235531f, -0.844780853112247f, 0.134166207564174f, -0.586842667384924f, 0.0711866699414370f, 0.311698821368897f, -0.361229767252053f, 0.750924311039976f, 0.0764323989785694f, 0.898463708247144f, 0.398232179543916f, -0.515644913011399f, -0.189067061520362f, -0.567430593060929f, -0.641924269747436f, -0.0960378699625619f, -0.792054031692334f, 0.803891878854351f, -0.233518627249889f, -0.892523453249154f, 0.707550017996875f, -0.782288435525895f, -0.156166443894764f, -0.543737876329167f, 0.565637809380957f, -0.757689989749326f, -0.612543942167974f, -0.766327195073259f, 0.587626843767440f, -0.280769385897397f, -0.457487372245825f, 0.0862799426622438f, -0.616867284053547f, 0.121778903484808f, -0.451988651573766f, -0.618146087265495f, -0.285868777534354f, 0.108999472244014f, -0.620755183347358f, -0.268563184810196f, -0.721678169615489f, -0.146060198874409f, -0.661506858070617f, 0.901707853998409f, 0.222488776533930f, 0.679599685031679f, 0.974760448601209f, 0.535485953830496f, -0.562345697123585f, 0.369219363331071f, -0.0282801684694869f, -0.0734880727832297f, 0.733216287314358f, -0.514352095765627f, -0.850813063545195f, 0.642458447327163f, 0.118661521915783f, -0.907015526838341f, 0.789277766886329f, -0.719864125961721f, 0.274329068829509f, 0.830124687647056f, 0.719352367261587f, -0.821767317737384f, -0.840153496829227f, 0.650796781936517f, 0.381065387870166f, 0.341870564586224f, -0.00174423702285131f, -0.216348832349188f, 0.678010477635713f, -0.748695103596683f, -0.819659325555269f, 0.620922373008647f, 0.471659250504894f, 0.417848292160984f, -0.990577315445198f, -0.509842007818877f, 0.705761459091187f, 0.723072116074702f, -0.606476484252158f, -0.871593699865195f, -0.662059658667501f, -0.207267692377271f, -0.274706370444270f, 0.317047325063391f, 0.329780707114887f, -0.966325651181920f, -0.666131009799803f, 0.118609206658210f, 0.232960448350140f, -0.139134616436389f, -0.936412642687343f, -0.554985387484625f, -0.609914445911143f, -0.371023087262482f, -0.461044793696911f, 0.0277553171809701f, -0.241589304772568f, -0.990769995548029f, 0.114245771600061f, -0.924483328431436f, 0.237901450206836f, -0.615461633242452f, 0.201497106528945f, -0.599898812620374f, 0.982389910778332f, 0.125701388874024f, -0.892749115498369f, 0.513592673006880f, 0.229316745749793f, 0.422997355912517f, 0.150920221978738f, 0.447743452078441f, 0.366767059168664f, -0.605741985891581f, 0.274905013892524f, -0.861378867171578f, -0.731508622159258f, 0.171187057183023f, 0.250833501952177f, -0.609814068526718f, -0.639397597618127f, -0.712497631420166f, -0.539831932321101f, -0.962361328901384f, 0.799060001548069f, 0.618582550608426f, -0.603865594092701f, -0.750840334759883f, -0.432368099184739f, -0.581021252111797f, 0.134711953024238f, 0.331863889421602f, -0.172907726656169f, -0.435358718118896f, -0.689326993725649f, 0.415840315809038f, -0.333576262820904f, 0.279343777676723f, -0.0393098862927832f, 0.00852090010085194f, -0.853705195692250f, 0.526006696633762f, -0.478653377052437f, -0.584840261391485f, 0.679261003071696f, 0.0367484618219474f, -0.616340335633997f, -0.912843423145420f, -0.221248732289686f, -0.477921890680232f, -0.127369625511666f, 0.865190146410824f, 0.817916456258544f, 0.445973590438029f, -0.621435280140991f, -0.584264056171687f, 0.718712277931876f, -0.337835985469843f, 0.00569064504159345f, -0.546546294846311f, 0.101653624648361f, -0.795498735829364f, -0.249043531299132f, -0.112839395737321f, -0.350305425122331f, -0.910866368205041f, 0.345503177966105f, -0.549306515692918f, 0.711774722622726f, 0.283368922297518f, 0.0401988801224620f, 0.269228967910704f, 0.408165826013612f, -0.306571373865680f, 0.937429053394878f, 0.992154362395068f, 0.679431847774404f, 0.660561953302554f, 0.903254489326130f, -0.939312119455540f, -0.211194531611303f, 0.401554296146757f, -0.0373187111351370f, -0.209143098987164f, -0.483955198209448f, -0.860858509666882f, 0.847006442151417f, 0.287950263267018f, 0.408253171937961f, -0.720812569529331f, 0.623305171273525f, 0.543495760078790f, -0.364025150023839f, -0.893335585394842f, -0.757545415624741f, -0.525417020183382f, -0.985814550271000f, -0.571551008375522f, 0.930716377819686f, -0.272863385293023f, 0.982334910750391f, 0.297868844366342f, 0.922428080219044f, 0.917194773824871f, 0.846964493212884f, 0.0641834146212110f, 0.279768184306094f, 0.591959126556958f, 0.355630573995206f, 0.839818707895839f, 0.219674727597944f, -0.174518904670883f, 0.708669864813752f, -0.224562931791369f, 0.677232454840133f, -0.904826802486527f, -0.627559033402838f, 0.263680517444611f, 0.121902314059156f, -0.704881790282995f, 0.242825089229032f, -0.309373554231866f, -0.479824461459095f, -0.720536286348018f, -0.460418173937526f, 0.774174710513849f, 0.452001499049874f, -0.316992092650694f, 0.153064869645527f, -0.209558599627989f, 0.685508351648252f, -0.508615450383790f, 0.598109567185095f, 0.391177475074196f, 0.964444988755186f, 0.336277292954506f, -0.0367817159101076f, -0.668752640081528f, 0.169621732437504f, -0.440925495294537f, 0.352359477392856f, 0.300517139597811f, 0.464188724292127f, 0.342732840629593f, -0.772028689116952f, 0.523987886508557f, 0.920723209445309f, 0.325634245623597f, 0.999728757965472f, -0.108202444213629f, -0.703463061246440f, -0.764321104361266f, 0.153478091277821f, 0.400776808520781f, 0.0362608595686520f, 0.602660289034871f, -0.00396673312072204f, 0.296881393918662f, 0.563978362789779f, 0.849699999703012f, 0.699481370949461f, -0.517318771826836f, 0.488696839410786f, -0.863267084031406f, 0.0353144039838211f, 0.346060763700543f, 0.964270355001567f, 0.354899825242107f, 0.806313705199543f, 0.675286452110240f, 0.0873918818789949f, -0.595319879813140f, 0.768247284622921f, 0.424433552458434f, -0.308023836359512f, 0.802163480612923f, -0.348151008192881f, -0.889061130591849f, -0.593277042719599f, -0.669426232128590f, 0.758542808803890f, 0.515943031751579f, -0.359688459650311f, 0.568175936707751f, 0.741304023515212f, 0.260283681057109f, 0.957668849401749f, -0.665096753421305f, 0.769229664798946f, -0.0871019488695104f, -0.362662093346394f, -0.411439775739547f, 0.700347493632751f, 0.593221225653487f, 0.712841887456470f, 0.413663813878195f, -0.868002281057698f, -0.704419248587642f, 0.497097875881516f, -0.00234623694758684f, 0.690202361192435f, -0.850266199595343f, 0.315244026446767f, 0.709124123964306f, 0.438047076925768f, 0.798239617424585f, 0.330853072912708f, 0.581059745965701f, 0.449755612947191f, -0.462738032798907f, 0.607731925865227f, 0.0898348455002427f, -0.762827831849901f, 0.895598896497952f, -0.752254194382105f, -0.0916186048978613f, -0.906243795607547f, 0.229263971313788f, 0.401148319671400f, -0.699999035942240f, 0.949897297168705f, 0.442965954562621f, -0.836602533575693f, 0.960460356865877f, -0.588638958628591f, -0.826876652501322f, 0.358883606332526f, 0.963216314331105f, -0.932992215875777f, -0.790078242370583f, 0.402080896170037f, -0.0768348888017805f, 0.728030138891631f, -0.259252300581205f, -0.239039520569651f, -0.0343187629251645f, -0.500656851699075f, 0.213230170834557f, -0.806162554023268f, -0.346741158269134f, 0.593197383681288f, -0.874207905790597f, 0.396896283395687f, -0.899758892162590f, 0.645625478431829f, 0.724064646901595f, 0.505831437483414f, -0.592809028527107f, 0.191058921738261f, 0.329699861086760f, 0.637747614705911f, 0.228492417185859f, 0.350565075483143f, 0.495645634191973f, 0.0378873636406241f, -0.558682871042752f, -0.0463515226573312f, -0.699882077624744f, -0.727701564368345f, -0.185876979038391f, 0.969357227041006f, -0.0396554302826258f, 0.994123321254905f, -0.103700411263859f, -0.122414150286554f, -0.952967253268750f, -0.310113557790019f, 0.389885130024049f, 0.698109781822753f, -0.566884614177461f, -0.807731715569885f, 0.295459359747620f, 0.353911434620388f, -0.0365360121873806f, -0.433710246410727f, -0.112374658849445f, -0.710362620548396f, -0.750188568899340f, -0.421921409270312f, -0.0946825033112555f, -0.207114343395422f, -0.712346704375406f, -0.762905208265238f, 0.668705185793373f, 0.874811836887758f, 0.734155331047614f, 0.0717699959166771f, -0.649642655211151f, 0.710177200600726f, -0.790892796708330f, -0.609051316139055f, 0.158155751049403f, 0.273837117392194f, 0.101461674737037f, -0.341978434311156f, 0.358741707078855f, 0.415990974906378f, 0.760270133083538f, 0.164383469371383f, 0.559847879549422f, 0.209104118141764f, -0.265721227148806f, 0.165407943936551f, 0.611035396421350f, -0.626230501208063f, -0.116714293310250f, -0.696697517286888f, 0.0545261414014888f, 0.440139257477096f, 0.202311640602444f, -0.369311356303593f, 0.901884565342531f, 0.256026357399272f, -0.673699547202088f, 0.108550667621349f, -0.961092940829968f, -0.254802826645023f, 0.553897912330318f, 0.110751075533042f, -0.587445414043347f, 0.786722059164009,
0.182042556749386f, 0.398835909383655f, 0.431324012457533f, 0.587021142157922f, -0.644072183989352f, 0.187430090296218f, 0.516741122998546f, -0.275250933267487f, -0.933673413249875f, -0.767709448823879f, 0.00345814033609182f, -0.585884382069128f, 0.463549040471035f, 0.666537178805293f, -0.393605927315148f, -0.260156573858491f, -0.298799291489529f, -0.246398415746503f, 0.970774181159203f, -0.485708631308223f, -0.456571313115555f, -0.264210030877189f, -0.442583504871362f, 0.0585567697312368f, 0.955769232723545f, 0.651822742221258f, 0.667605490119116f, -0.178564750516287f, 0.744464599638885f, -0.0962758978504710f, -0.538627454923738f, -0.844634654117462f, 0.109151162611125f, -0.862255427201396f, -0.478955305843323f, 0.645965860697344f, 0.345569271369828f, 0.930605011671297f, -0.195523686135506f, 0.927940875293964f, 0.0529927450986318f, -0.537243314646225f, 0.0815400161801159f, -0.528889663721737f, -0.0803965087898244f, 0.722188412643543f, -0.115173100460772f, 0.391581967064874f, 0.609102624309301f, -0.726409099849031f, -0.924071529212721f, -0.424370859730340f, -0.932399086010354f, -0.679903916227243f, 0.398593637781810f, -0.395942610474455f, 0.911017267923838f, 0.830660098751580f, 0.485689056693942f, -0.634874052918746f, 0.558342102044082f, 0.153345477027740f, -0.418797532948752f, -0.962412446404476f, 0.499334884055701f, 0.772755578982235f, 0.486905718186221f, -0.680415982465391f, -0.983589696155766f, 0.0802707365440833f, -0.108186099494932f, 0.272227706025405f, 0.651170828846750f, -0.804713753056757f, 0.778076504684911f, 0.869094633196957f, -0.213764089899489f, -0.289485853647921f, -0.248376169846176f, -0.273907386272412f, -0.272735585352615f, -0.851779302143109f, 0.777935500545070f, 0.610526499062369f, -0.825926925832998f, -0.00122853287679647f, -0.250920102747366f, -0.0333860483260329f, 0.562878228390427f, 0.685359102189134f, 0.909722844787783f, -0.686791591637469f, 0.700018932525581f, -0.975597558640926f, 0.111273045778084f, 0.0313167229308478f, -0.185767397251192f, -0.587922465203314f, -0.569364866257444f, -0.433710470415537f, 0.744709870476354f, 0.812284989338678f, -0.835936210940005f, 0.409175739115410f, 0.364745324015946f, -0.526496413512530f, -0.0949041293633228f, -0.710914623019602f, -0.199035360261516f, 0.249903358254580f, 0.799197892184193f, -0.974131439735146f, -0.962913228246770f, -0.0584067290846062f, 0.0678080882131218f, 0.619989552612058f, 0.600692636138022f, -0.325324145536173f, 0.00758797937831957f, -0.133193608214778f, -0.312408219890363f, -0.0752971209304969f, 0.764751638735404f, 0.207290375565515f, -0.965680055629168f, 0.526346325957267f, 0.365879948128040f, -0.899713698342006f, 0.300806506284083f, 0.282047017067903f, -0.464418831301796f, -0.793644005532544f, -0.338781149582286f, 0.627059412508279f, -0.624056896643864f, -0.503708045945915f, 0.339203903916317f, -0.920899287490514f, -0.753331218450680f, -0.561190137775443f, 0.216431106588929f, -0.191601189620092f, 0.613179188721972f, 0.121381145781083f, -0.477139741951367f, 0.606347924649253f, 0.972409497819530f, 0.00419185232258634f, 0.786976564006247f, 0.716984027373809f, -0.577296880358192f, 0.336508364109364f, -0.837637061538727f, -0.706860533591818f, 0.655351330285695f, -0.799458036429467f, 0.804951754011505f, 0.405471126911303f, 0.485125485165526f, 0.0354103156047567f, 0.774748847269929f, 0.396581375869036f, 0.420464745452802f, -0.544531741676535f, -0.779088258182329f, -0.129534599431145f, 0.228882319223921f, 0.669504936432777f, -0.158954596495398f, -0.171927546721685f, 0.675107968066445f, -0.201470217862098f, -0.185894687796509f, 0.244174688826684f, 0.310288210346694f, -0.0674603586289346f, 0.138103839181198f, 0.269292861340219f, 0.121469813317732f, 0.168629748875041f, 0.581112629873687f, 0.499508530746584f, -0.741772433024897f, -0.311060071316150f, -0.263697352439521f, 0.180487383518774f, -0.800786488742242f, -0.949903966987338f, 0.134975524166410f, 0.213364683193138f, -0.684441197699222f, -0.254697287796379f, -0.260521050814253f, -0.757605554637199f, -0.134324873215927f, -0.699675596579060f, 0.136000646890289f, 0.355272520354523f, -0.712620797948690f, -0.729995036352282f, 0.323100037780915f, -0.718364487938777f, 0.807709622188084f, 0.289336059472722f, -0.558738026311145f, -0.591811756545896f, -0.894952978489225f, -0.354996929975694f, -0.142213103464027f, -0.651950180085633f, 0.182694586161578f, -0.193492058009904f, -0.540079537334588f, -0.300927433533712f, 0.119585035086049f, 0.895807833710939f, -0.413843745301811f, -0.209041322713332f, 0.808094803654324f, 0.0792829008489782f, 0.314806980452270f, 0.502591873175427f, -0.0474189387090473f, -0.407131047818007f, 0.797117088440354f, 0.902395237588928f, -0.783327055804990f, -0.591709085168646f, 0.628191184754911f, -0.454649879692076f, -0.588819444306752f, 0.250889716959370f, -0.582306627010669f, -0.145495766591841f, -0.634137346823528f, 0.667934845545285f, 0.873756470938530f, 0.425969845715827f, -0.779543910541245f, -0.265210219994391f, 0.781530681845886f, 0.304461599274577f, 0.211087853085430f, 0.281022407596766f, 0.0701313665097776f, 0.342337400087349f, -0.0618264046031387f, 0.177147380816613f, 0.751693209867024f, -0.279073264607508f, 0.740459307255654f, -0.352163564204507f, -0.726238685136937f, -0.565819729501492f, -0.779416133306559f, -0.783925450697670f, 0.542612245021260f, -0.810510148278478f, -0.693707081804938f, 0.918862988543900f, -0.368717045271828f, 0.0654919784331340f, -0.438514219239944f, -0.923935138084824f, 0.913316783811291f, -0.961646539574340f, 0.734888382653474f, -0.464102713631586f, -0.896154678819649f, 0.349856565392685f, 0.646610836502422f, -0.104378701809970f, 0.347319102015858f, -0.263947819351090f, 0.343722186197186f, 0.825747554146473f, 0.0661865525544676f, 0.918864908112419f, -0.999160312662909f, -0.904953244747070f, 0.246613032125664f, 0.123426960800262f, -0.294364203503845f, -0.150056966431615f, 0.904179479721301f, 0.517721252782648f, 0.661473373608678f, -0.784276966825964f, -0.984631287069650f, 0.239695484607744f, -0.499150590123099f, 0.00153518224500027f, -0.817955534401114f, 0.221240310713583f, 0.114442325207070f, -0.717650856748245f, -0.722902799253535f, -0.962998380704103f, 0.214092155997873f, -0.226370691123970f, 0.536806140446569f, 0.111745807092858f, 0.657580594136395f, -0.239950592200226f, 0.0981270621736083f, -0.173398466414235f, 0.414811672195735f, 0.147604904291238f, -0.649219724907210f, 0.907797399703411f, -0.496097071857490f, -0.0958082520749422f, -0.700618145301611f, 0.238049932994406f, 0.946616020659334f, 0.143538494511824f, 0.0641076718667677f, 0.377873848622552f, -0.413854028741624f, -0.838831021130186f, 0.0208044297354626f, 0.476712667979210f, 0.850908020233298f, 0.0692454021020814f, 0.841788714865238f, -0.251777041865926f, 0.512215668857165f, 0.827988589806208f, -0.399200428030715f, 0.999219950547600f, -0.00465542086542259f, 0.279790771964531f, -0.683125623289052f, 0.988128867315143f, 0.00697090775456410f, -0.409501680375786f, -0.190812202162744f, -0.154565639467601f, 0.305734586628079f, -0.922825484202279f, -0.0622811516391562f, -0.502492855870975f, 0.358550513844403f, 0.678271216185703f, -0.940222215291861f, 0.568581934651071f, 0.953835466578938f, -0.476569789986603f, 0.0141049472573418f, 0.722262461730185f, -0.128913572076972f, -0.583948340870808f, -0.254358587904773f, -0.390569309413304f, -0.0495119137883056f, -0.486356443935695f, -0.112768011009410f, -0.608763417511343f, -0.145843822867367f, 0.767829603838659f, 0.791239479733126f, 0.0208376062066382f, -0.524291005204912f, -0.200159553848628f, -0.835647719235620f, -0.222774380961612f, 0.0617292533934060f, 0.233433696650208f, -0.543969878951657f, -0.628168009147650f, -0.725602523060817f, -0.273904472034828f, 0.320527317085229f, -0.556961185821848f, 0.261533413201255f, 0.696617398495973f, 0.200506775746016f, -0.395581923906907f, 0.0196423782530712f, -0.0552577396777472f, -0.594078139517501f, -0.816132673139052f, -0.898431571909616f, 0.879105843430143f, 0.949666380003024f, -0.245578843355682f, 0.528960018663897f, 0.201586039072583f, -0.651684706542954f, 0.596063456431086f, -0.659712784781056f, -0.213702651629353f, -0.629790163054887f, -0.0572029778771013f, 0.645291034768991f, -0.453266855343461f, -0.581253959024410f, 0.632682730071992f, 0.991406037765467f, 0.701390336150136f, -0.879037255220971f, -0.304180069776406f, 0.0969095808767941f, -0.465682778651712f, 0.815108046274786f, -0.532850846043973f, 0.950550134670033f, 0.296008118726089f, -0.198390447541329f, 0.159049143352201f, 0.105169964332594f, -0.482506131358523f, 0.493753482281684f, 0.292058685647414f, 0.283730532860951f, 0.00323819209092657f, 0.765838273699203f, -0.0753176377562099f, -0.679824808630431f, 0.548180003463159f, -0.996048798712591f, 0.782768288046545f, 0.396509190560532f, 0.848686742379558f, 0.750049741585178f, 0.730186188655936f, -0.0220701180542726f, -0.487618042364281f, -0.403562199756249f, -0.0693129490117646f, 0.947019452953246f, -0.731947366410442f, 0.198175872470120f, -0.329413252854837f, -0.641319161749268f, 0.186271826190842f, -0.0739989831663739f, -0.334046268448298f, -0.191676071751509f, -0.632573515889708f, -0.999115061914042f, -0.677989795015932f, 0.289828136337821f, 0.696081747094487f, 0.965765319961706f, -0.203649463803737f, -0.195384468978610f, 0.746979659338745f, 0.701651229142588f, -0.498361303522421f, 0.289120104962302f, 0.270493509228559f, -0.132329670835432f, 0.385545665843914f, -0.265371843427444f, 0.306155119003788f, -0.859790373316264f, -0.0198057838521546f, 0.233572324299025f, 0.426354273793125f, -0.510901479579029f, -0.600001464460011f, -0.972316846268671f, 0.531678082677910f, -0.0543913028234813f, -0.860333915321655f, 0.0717414549918496f, -0.992726205437930f, 0.587189647572868f, -0.710120198811545f, -0.712433353767817f, 0.000905613890617163f, 0.323638959833707f, -0.148002344942812f, 0.422217478090035f, -0.512122539396176f, -0.652032513920892f, -0.0749826795945674f, 0.689725543651565f, 0.00708142459169103f, 0.612282380092436f, -0.182868915402510f, -0.478704046524703f, 0.630078231167476f, -0.201694106935605f, 0.471080354222778f, 0.705764111397718f, 0.504296612895499f, -0.245442802115836f, -0.0255433216413170f, 0.244606720514349f, -0.620852691611321f, 0.130333792055452f, -0.0404066268217753f, 0.533698497858480f, 0.569324696850915f, -0.0208385747745345f, -0.344454279574176f, 0.697793551353488f, 0.223740789443046,
0.0819835387259940f, -0.378565059057637f, 0.265230570199009f, -0.654654047270763f, -0.959845479426107f, -0.524706200047066f, -0.320773238900823f, 0.133125806793072f, 0.204919719422386f, 0.781296208272529f, 0.357447172843949f, -0.295741363322007f, -0.531151992759176f, -0.928760461863525f, -0.492737999698919f, 0.185299312597934f, 0.0308933157463984f, 0.0940868629278078f, -0.223134180713975f, -0.728994909644464f, 0.748645378716214f, 0.602424843862873f, 0.939628558971957f, -0.601577015562304f, -0.178714119359324f, 0.812720866753088f, -0.864296642561293f, 0.448439532249340f, 0.423570043689909f, 0.883922405988390f, -0.121889129001415f, -0.0435604321758833f, -0.823641147317994f, -0.775345608718704f, -0.621149628042832f, 0.532395431283659f, -0.803045105215129f, 0.897460124955135f, 0.432615281777583f, -0.0245386640589920f, -0.822321626075771f, -0.992080038736755f, -0.829220327319793f, 0.125841786813822f, 0.277412627470833f, 0.623989234604340f, -0.207977347981346f, -0.666564975567417f, 0.419758053880881f, -0.146809205344117f, 0.702495819380827f, 0.802212477505035f, 0.161529115911938f, 0.987832568197053f, -0.885776673164970f, -0.608518024629661f, -0.126430573784758f, 0.168260422890915f, -0.517060428948049f, -0.766296586196077f, -0.827624510690858f, -0.149091785188351f, -0.643782325842734f, 0.768634567718711f, 0.815278279059715f, -0.648037361329720f, -0.480742843535214f, 0.983809287193308f, -0.701958358623791f, 0.0797427982273327f, 0.903943825454071f, 0.980486658260621f, 0.207436790541324f, -0.536781321571165f, -0.885473392956838f, -0.626744905152131f, 0.279917970592554f, -0.489532633799085f, 0.402084958261836f, -0.566738134593205f, -0.0990017532286025f, 0.458891753618823f, 0.893734110503312f, 0.541822126435773f, -0.856210577956263f, -0.0354679151809227f, -0.868531503535520f, 0.150589222911699f, 0.611651396802303f, 0.524911319413221f, 0.555472734209632f, -0.723626819813614f, -0.162106613127807f, 0.602405197560299f, 0.903198408993777f, 0.329150411562290f, -0.806468536757339f, -0.671787125844359f, -0.707262852044556f, 0.474934689940169f, -0.379636706541612f, 0.404933387269815f, 0.332303761521238f, 0.394233678536033f, -0.0366067593524413f, 0.904405677123363f, -0.356597686978725f, -0.623034135107067f, 0.572040316921149f, 0.799160684670195f, -0.507817199545094f, -0.533380730448667f, -0.884507921224020f, -0.00424735629746076f, 0.647537115339283f, 0.456309536956504f, -0.766102127867730f, -0.625121831714406f, 0.341487890703535f, -0.360549668352997f, -0.229900108098778f, -0.666760418812903f, 0.813282715359911f, 0.115522674116703f, -0.221360306077384f, 0.0297293679340875f, 0.00682810040637105f, 0.0115235719886584f, 0.887989949086462f, 0.792212187398941f, 0.415172771519484f, -0.600202208047434f, 0.949356119962045f, -0.526700730890731f, 0.946712583567682f, -0.392771116330410f, 0.0144823046999243f, -0.649518061223406f, 0.724776068810104f, 0.00920735790862981f, -0.461670796134611f, 0.217703889787716f, 0.846151165623083f, -0.202702970245097f, 0.314177560430781f, -0.761102867343919f, 0.0528399640076420f, -0.986438508940994f, -0.595548022863232f, -0.430067198426456f, 0.150038004203120f, 0.738795383589380f, -0.605707072657181f, -0.597976219376529f, 0.375792542283657f, -0.321042914446039f, 0.902243988712398f, 0.463286578609220f, -0.739643422607773f, 0.210980536147575f, -0.539210294582617f, 0.405318056313257f, -0.876865698043818f, -0.0883135270940518f, 0.0300580586347285f, -0.657955040210154f, 0.159261648552234f, 0.288659459148804f, 0.274488527537659f, 0.646615145281349f, 0.431532024055095f, -0.982045186676854f, -0.777285361097106f, -0.124875006659614f, 0.503004910525253f, 0.824987340852061f, -0.859357943951028f, -0.894837450578304f, 0.744772864540654f, 0.415263521487854f, 0.337833126081168f, -0.612498979721313f, 0.391475686177086f, 0.573982630935632f, -0.391044576636065f, 0.669493459114130f, -0.763807443372196f, -0.898924075896803f, -0.969897663976237f, -0.266947396046322f, 0.198506503481333f, -0.355803387868922f, 0.787375525807664f, 0.655019979695179f, -0.266247398074148f, -0.665577607941915f, 0.0617617780742654f, -0.303207459096743f, 0.807119242186051f, -0.864431193732911f, 0.711808914065391f, 0.267969697417500f, -0.643939259651104f, -0.723685356192067f, 0.887757759160107f, -0.318420101532538f, -0.984559057628900f, -0.123118506428834f, 0.264872379685241f, 0.258477870902406f, -0.727462993670953f, -0.223845786938221f, 0.683462211502638f, -0.989811504909606f, 0.292644294487220f, -0.926087081411227f, -0.801377664261936f, -0.337757621052903f, 0.356167431525877f, 0.974619379699180f, 0.456124311183874f, 0.664192098344107f, -0.910993234571633f, -0.484097468631090f, -0.128534589958108f, -0.770879324529314f, 0.320053414246682f, 0.249818479771296f, 0.0153345543766990f, 0.696352481669035f, -0.397719804512483f, 0.670333638147646f, -0.678192291329959f, 0.190143924397131f, 0.342035884244954f, -0.350791038317704f, 0.0218450632953668f, 0.437133719806156f, 0.659960895652910f, 0.903378806323159f, 0.855089775229062f, 0.946706092624795f, 0.335540975081955f, 0.838337968455111f, -0.102693592034237f, -0.702102376052106f, 0.409624309223486f, -0.654483499569910f, 0.886576641430416f, -0.200573725141884f, -0.461284656727627f, 0.262661770963709f, 0.867505406245483f, -0.0688648080253220f, -0.707487995489326f, -0.248871627068848f, -0.197869870234198f, -0.243745607075197f, -0.244106806741608f, 0.489848112299788f, -0.0909708869175492f, -0.377678949786167f, 0.0385783576998284f, -0.470361956031595f, 0.802403491439449f, -0.408319987166305f, 0.345170991986463f, -0.433455880962420f, 0.00950587287655291f, -0.441888155900165f, -0.817874450719479f, 0.818308133775667f, 0.931915253798354f, 0.818494801634479f, 0.787941704188320f, 0.882012210451449f, 0.0749985961399193f, 0.259772455233352f, -0.655786948552735f, 0.0824323575519799f, 0.980211564632039f, -0.798619050684746f, 0.496019643929772f, -0.727312997781404f, -0.999839600489443f, 0.625938920414345f, -0.561059012154101f, 0.215650518505246f, 0.121571798563274f, 0.161863493108371f, -0.340322748036792f, 0.521792371708641f, 0.655248389359818f, -0.180967013066484f, 0.936797969156762f, 0.523749660366580f, 0.764744126333943f, 0.384701560810431f, -0.744092118301334f, 0.719721922905938f, 0.365931545158250f, -0.720202871171563f, 0.121662048491076f, -0.355501954289222f, 0.379420491208481f, -0.593818415223405f, -0.433690576121147f, -0.766763563509045f, -0.377445104709670f, -0.955638620720410f, 0.309622585052195f, -0.613767678153186f, 0.0177719922394908f, 0.362917537485277f, -0.297613292472489f, 0.0275561832152067f, -0.962345352767599f, 0.452866577068408f, -0.307485159523065f, 0.931778412136845f, 0.639592220588070f, 0.00782144244951311f, -0.0466407334447796f, -0.134392603781566f, 0.895314655361308f, -0.537785271016286f, 0.663926391064792f, -0.886126633268266f, -0.0975129470189278f, -0.429791706025144f, -0.440337831994928f, -0.00156267573188829f, 0.933113069253665f, -0.560704402651437f, -0.201658150324907f, 0.465819560354530f, 0.0701448781871696f, 0.859597672251104f, -0.525851890358272f, -0.992674038068357f, -0.0846761339576128f, -0.401686794568758f, -0.886069686075370f, -0.480254412625133f, 0.432758053902000f, 0.168651590377605f, -0.453397134906684f, 0.340250287733381f, -0.972972507965963f, 0.0560333167197302f, -0.180812774382952f, -0.689848943619717f, -0.427945332505659f, 0.771841237806370f, 0.329334772795521f, 0.573083591606505f, 0.280711890938316f, -0.265074342340277f, -0.166538165045598f, -0.0612128221482104f, 0.458392746490372f, 0.199475931235870f, 0.681819191997175f, 0.356837960840067f, 0.756968760265553f, 0.763288512531608f, -0.890082643508294f, -0.322752448111365f, 0.799445915816577f, -0.956403501496524f, 0.723055987751969f, 0.943900989848643f, -0.217092255585658f, -0.426893469064855f, 0.834596828462842f, 0.723793256883097f, 0.781491391875921f, 0.928040296363564f, -0.468095417622644f, 0.758584798435784f, 0.589732897992602f, 0.929077658343636f, 0.829643041135239f, 0.0947252609994522f, 0.554884923338572f, -0.513740258764285f, -0.221798194292427f, 0.499855133319165f, -0.0237986912033636f, 0.559618648100625f, -0.509812142428963f, -0.444047241791607f, 0.678274420898738f, -0.983706185790147f, -0.295400077545522f, -0.688769625375228f, 0.729259863393412f, 0.889478872450658f, 0.928277502215167f, -0.429388564745762f, -0.790568684428380f, 0.930220908227667f, -0.796970618648576f, -0.980240003047008f, 0.0372716153521411f, -0.290828043433527f, -0.303854123029680f, 0.160774056645456f, -0.712081432630280f, 0.390787025293754f, 0.981202442873064f, -0.679439021090013f, 0.183053153027806f, 0.665002789261745f, -0.708708782620398f, 0.254574948166343f, 0.0575397183305137f, -0.723713533137924f, -0.732816726186887f, 0.501983534740534f, 0.879998734527489f, 0.825871571001792f, 0.920880943816000f, 0.311565022703289f, -0.788226302840017f, -0.223197800016568f, 0.850662847422425f, -0.365181128095578f, 0.958907951854379f, -0.0421327708909884f, -0.153860389403659f, -0.219620959578892f, -0.469076971423126f, -0.523348925540362f, -0.287762354299832f, -0.913332930679763f, 0.403264134926789f, 0.725849051303960f, 0.743650157693605f, -0.382580349065687f, -0.297138545454038f, -0.480092092629432f, 0.0412697614821378f, -0.396203822475830f, -0.0721078217568973f, 0.979038611510460f, -0.766187876085830f, -0.344262922592081f, 0.943351952071948f, -0.219460259008486f, 0.115393587800227f, -0.342675526066015f, 0.926460460401492f, -0.486133445041596f, 0.0722019534490863f, -0.571069005453629f, -0.0854568609959852f, 0.370182934471805f, -0.554007448618166f, 0.899885956615126f, -0.188476209845590f, -0.548132066932086f, 0.0559544259937872f, -0.161750926638529f, -0.532342080900202f, 0.585205009957713f, -0.374876171959848f, -0.169253952741901f, -0.473665572804341f, 0.942267543457416f, -0.515867520277168f, -0.706362509002908f, -0.320672724679343f, -0.398410016134417f, 0.733774712982205f, 0.449599271169282f, 0.109119420842892f, -0.285090495549516f, 0.0854116107702212f, 0.0603189331827261f, -0.943780826189008f, 0.0679186452322331f, 0.0975973769951632f, -0.870728474197789f, -0.153122881744074f, -0.519939625069588f, -0.633620207951748f, -0.767551214057718f, -0.905802311420298f, -0.841350087901049f, -0.271805404203346f, 0.282221543099561f, -0.0874121080198842f, 0.0634591013505281f, 0.318965595714934f, -0.865047622711268f, -0.401960840475322f, 0.637557181177199f, -0.664578054110050f, -0.871253510227744,
-0.893972634695541f, 0.442396058421524f, -0.427901040556135f, -0.740186385510743f, 0.788155411447006f, -0.541278113339818f, 0.509586521956676f, -0.461159620800394f, 0.664671981848839f, 0.880365181842209f, -0.0831685214800200f, 0.952827020902887f, 0.183226454466898f, -0.176729350626920f, 0.851946105206441f, -0.361976142339276f, 0.357209010683668f, 0.982462882042961f, -0.690757734204635f, 0.178681657923363f, -0.0804395784672956f, 0.971787623805611f, 0.875217157810758f, 0.160844021450331f, -0.359951755747351f, 0.0178495935461525f, 0.0203610854761294f, 0.413933338290502f, -0.676038601090005f, -0.111093077131977f, -0.381792206260952f, -0.459903351782575f, 0.308522841938619f, 0.324961267942541f, 0.365201262605939f, 0.732543185546895f, -0.559558093250200f, 0.848266528378337f, -0.185546299813159f, 0.997052205707190f, -0.932554828383249f, -0.106322273904826f, -0.0690562674587807f, 0.919489002936141f, 0.137210930163322f, -0.664517238270193f, -0.985856844408119f, -0.0719443995256963f, -0.602400574547167f, -0.398979518518077f, -0.581117055144305f, -0.0626081333075188f, -0.0372763806643306f, -0.688808592854889f, 0.703980953746103f, -0.480647539644480f, 0.615510592326288f, -0.940226159289884f, -0.953483236094818f, -0.300312284206625f, -0.819419230573751f, 0.657560634657022f, -0.0500336389233971f, 0.628589817614501f, 0.717012803783103f, -0.0315450822394920f, -0.445526173532186f, 0.521475917548504f, -0.479539088650145f, 0.695075897089419f, -0.0365115706205694f, 0.0256264409967832f, -0.0121306374106025f, -0.817618774100623f, 0.375407640753000f, 0.944299492219378f, -0.717119961760812f, -0.120740746804286f, 0.995225399986245f, -0.460846026818625f, 0.904552069467540f, 0.807270804870602f, -0.842962924665094f, -0.923108139392625f, -0.130295037856512f, 0.760624035683226f, 0.986419847047289f, -0.959218334866074f, -0.203345611185410f, -0.474420035241129f, -0.872329912560413f, 0.485994152094788f, -0.515456811755484f, -0.948541161235413f, 0.509659433909651f, 0.783030335970347f, -4.41004028146619e-05f, -0.664795573083349f, 0.917509788523214f, -0.824045573084530f, -0.461857767121051f, -0.667434409929092f, -0.00822974230444418f, 0.825606347148302f, -0.396378080991589f, 0.0161379983198293f, -0.940751675506308f, -0.520997013834332f, -0.239727035024153f, -0.354546027474561f, 0.430652211989940f, -0.557416557692462f, -0.357117274957257f, -0.891975448321656f, -0.0775302131779423f, 0.716775563686830f, -0.903453980341467f, 0.946455001410598f, -0.615060907661003f, 0.964288374469340f, 0.0506144897273089f, 0.720601612869967f, -0.991323837622476f, 0.647403093538608f, -0.400304988135589f, -0.883732066109751f, -0.792060477777513f, 0.710867542231890f, -0.840766000234525f, 0.460362174479788f, -0.834771343071341f, -0.329399142231491f, -0.139853203297018f, -0.760035442359396f, -0.546795911275364f, -0.598172518777125f, 0.244198671304740f, 0.0816980976432087f, -0.978470883754859f, -0.425173722072458f, -0.469868865988971f, 0.847396146045236f, 0.0513388454446360f, -0.545662072513986f, -0.130534232821355f, -0.654100097045099f, 0.0409163969999120f, 0.573001152600502f, 0.706046270983569f, 0.587208280138624f, 0.237670099964068f, 0.848355476872244f, -0.318971649676775f, -0.659343733364940f, 0.321817022392701f, -0.595779268050966f, -0.114109784140171f, 0.998897482902424f, -0.615792624357560f, -0.384232465470235f, 0.156963634764123f, 0.499645454164798f, -0.627603624482829f, 0.169440948996654f, 0.109888994819522f, -0.492231461622548f, -0.463014567947703f, 0.825436145613203f, -0.0271223123229367f, 0.497887971992266f, 0.811868354230459f, -0.192668816770168f, 0.287930938097264f, 0.0283112173817568f, 0.791359470942568f, 0.365100854153897f, -0.566922537281877f, 0.915510517906894f, 0.674211624006981f, 0.505848146007678f, 0.509348889158374f, -0.0477364348461706f, 0.409703628204478f, -0.820970358007873f, -0.565377675052345f, 0.810052924776160f, -0.448904038826591f, -0.830251135876445f, -0.660589978662428f, -0.890196028167542f, 0.130526506200048f, 0.924600157422957f, 0.587215078998604f, 0.727552064386916f, -0.224172021948978f, -0.182984019951690f, 0.308546229024235f, 0.971188035736775f, 0.0229902398155457f, 0.0608728749867729f, -0.0712317776940203f, 0.549832674352445f, -0.600015690750697f, -0.0495103483291919f, -0.564669458296125f, 0.726873201108802f, -0.197851942682556f, -0.983422510445155f, -0.905314463127421f, 0.453289030588920f, 0.792504915504518f, -0.840826310621539f, 0.0979339624518987f, -0.506416975007688f, -0.143310751135128f, -0.451251909709310f, -0.356156486602212f, -0.430777119656356f, -0.593002001098269f, -0.212505135257792f, -0.378005313269430f, 0.516460778234704f, -0.574171750919822f, -0.702870049350445f, 0.190454765104412f, 0.694962035659523f, 0.177498499962424f, -0.00126954773922439f, -0.766110586126502f, -0.769862303237397f, -0.208905136673906f, 0.0728026097773338f, -0.467480087700933f, -0.368839893652514f, -0.608806955889496f, -0.531329879815774f, 0.411920547737697f, -0.407318902586407f, 0.922406353838750f, -0.0272310683929855f, 0.781051179942937f, 0.860271807949640f, -0.703736733439623f, -0.285650334863399f, -0.466904334435873f, -0.716816768536707f, 0.0869377378786880f, -0.280331892461309f, 0.773946156883160f, -0.139856444064730f, 0.575680110908147f, -0.887887626173303f, 0.314286545048942f, 0.673119170729964f, 0.520399233930039f, 0.581347801663144f, 0.731708017815653f, 0.672583525027818f, -0.0534590776637494f, -0.880572908687369f, 0.171150522778545f, -0.377041265530122f, -0.478003213002057f, 0.458602883802583f, 0.836824527658741f, -0.0686622680764437f, -0.301000630566919f, -0.652562984155554f, 0.604631263268903f, 0.791770979838877f, 0.0790491584346489f, 0.812646960034949f, 0.138794042671596f, 0.709411730079774f, 0.226484869016811f, 0.797388098554019f, -0.162225991160828f, -0.0295749256270541f, 0.218242165083417f, 0.442845427695148f, -0.480622209857766f, 0.873464432574125f, -0.868017543466245f, -0.435489784247438f, 0.0589001507244313f, 0.829134536020168f, 0.614063504046069f, -0.0498036542372153f, -0.803122689381969f, -0.495207870035615f, -0.126836582496751f, -0.0715271574335641f, -0.600815700055194f, 0.434993547671690f, -0.891665893518364f, 0.515259516482513f, 0.475325173737397f, -0.716548558025405f, -0.881097306400870f, 0.738462585443836f, -0.244486212870867f, -0.750368936394211f, 0.303496411011494f, -0.602701428305057f, -0.400346153635480f, -0.300002744969481f, -0.518552440201900f, 0.437964598712580f, -0.816689813412280f, -0.814392666138757f, -0.888568091915377f, 0.449416911306476f, -0.231889259488176f, 0.589775175288682f, 0.817224890217553f, 0.518646001325967f, -0.406046689874425f, -0.822100925750380f, 0.0528571826460145f, 0.502410576690672f, -0.795964394123106f, 0.0587614583641718f, -0.960750994569408f, 0.0366871534513058f, 0.723018804498087f, 0.0607565140068052f, 0.337380735516841f, 0.810682513202583f, -0.636743814403438f, 0.287171363373943f, -0.651998050401509f, -0.913606366413836f, 0.642186273694795f, -0.197674788034638f, -0.261253290776174f, 0.696450222503413f, -0.178859131737947f, -0.388167582041093f, -0.0593965887764258f, -0.638517356081890f, 0.804955770174156f, 0.220726627737384f, 0.263712659676167f, -0.214285245576410f, -0.267640297291737f, -0.268009369634837f, -0.957726158424482f, 0.708674977585603f, 0.336764494287156f, -0.985742981232916f, -0.883053422617300f, 0.560301189759340f, -0.692967747323003f, 0.977419052658484f, 0.0749830817523358f, 0.916618822945019f, 0.941660769630849f, 0.454145712080114f, 0.176036352526593f, 0.103229925297037f, 0.936507745325933f, -0.870159095287666f, -0.106465234217744f, 0.684178938709319f, 0.669775326656340f, -0.620857222834950f, 0.939074959093680f, -0.592224920792423f, 0.620706594809134f, 0.0456831422421473f, 0.738727999152789f, -0.751090911501446f, 0.683669216540363f, 0.153825621938168f, -0.255671723273688f, -0.773772764499189f, -0.667753952059522f, 0.887641972124558f, -0.664358118222428f, 0.512196622998674f, -0.0234362604874272f, 0.942878420215240f, -0.406617487191566f, -0.140379594627198f, -0.0587253931185765f, 0.419570878799757f, 0.533674656399007f, 0.108777047479414f, -0.695880604462579f, 0.481525582104998f, 0.511165135231064f, 0.136105196996658f, -0.481918536916982f, 0.757546893769363f, 0.957648176032083f, -0.908743619686586f, -0.395640537583668f, 0.0493439519763970f, 0.293569612893396f, 0.387420368421925f, 0.0928482742403196f, 0.407302666835821f, -0.787979245337637f, -0.968269218296593f, -0.409517247978962f, 0.775076200793689f, -0.217738166217447f, -0.370002483875998f, -0.570975789421316f, 0.844070553036478f, 0.668620483679341f, 0.00139813137293987f, -0.0912495442122028f, -0.0375370940595317f, 0.723007849224616f, 0.369999774115317f, 0.862240371150479f, 0.749525689790910f, 0.742992309993137f, -0.495813719545874f, -0.101947508108870f, -0.152536889610560f, 0.0598123624723883f, -0.436496899502871f, 0.520026918467263f, 0.241005798945400f, 0.970456690492966f, -0.376417224463442f, 0.614223236672359f, 0.336733945081746f, 0.376602027190701f, 0.00373987228923456f, -0.415425448787442f, 0.330560415319813f, -0.277250467297048f, 0.861008806111330f, -0.00655914035278493f, 0.810375656135324f, -0.0113631690466840f, -0.191699616402287f, -0.808952204107388f, 0.813180054552450f, 0.472985418265257f, 0.180147510998781f, -0.262580568975063f, 0.211152909221457f, -0.882514639604489f, -0.575589191561861f, 0.106927561961233f, 0.964591320892138f, 0.738192954342001f, 0.687649298588472f, -0.229142519883570f, -0.354434619656716f, -0.420522788056562f, 0.684638470896597f, -0.608080686160634f, 0.172668231197353f, 0.571295073068563f, -0.202258974457565f, 0.183035733721930f, -0.425589835248751f, -0.181955831301366f, 0.798193178080558f, -0.719799491928433f, -0.376418218727565f, 0.100370714244854f, -0.674685331738723f, -0.528950922374114f, 0.480443520097694f, 0.432497368954013f, 0.887439714903326f, 0.598241701759478f, -0.250064970303242f, -0.743111010477448f, 0.936189907099845f, -0.867383557331633f, 0.852536175309851f, -0.426378707286007f, 0.793838638663137f, 0.856262917294594f, 0.734157059815547f, 0.00452009494051664f, -0.884258713402709f, -0.0835595438259760f, -0.735457210599502f, -0.710727075357488f, 0.858050351034768f, -0.626070522205317f, -0.848201957131499f, 0.0180933910837406f, -0.0350884878366737f, -0.893836321618480f, -0.0682788306189803f, -0.539993219329871f, -0.557660404374917f, 0.268969847256868f, 0.505363999910409f, -0.0464757944714727f, -0.529689906951922,
-0.138445378586710f, 0.992531054118938f, 0.974585450054910f, 0.940349645687053f, 0.648085319100986f, -0.410736404028701f, 0.804131759246012f, -0.774897101314247f, 0.178246382655493f, -0.361699623232501f, -0.836093509684016f, 0.806309487627613f, -0.758182371322663f, 0.718410035716663f, -0.213136487421868f, -0.0563465521625497f, 0.0411192849612654f, -0.532497330327019f, -0.0419839515250475f, 0.769432068229678f, 0.253556234192255f, -0.745131216530268f, -0.890639235422577f, -0.140643637034330f, 0.318127074868768f, -0.497415632768561f, -0.383508820416842f, -0.468783454456628f, -0.289531078129000f, -0.0831555730758713f, 0.0107128404847427f, -0.567754537918270f, 0.926366772604370f, -0.600154724486768f, -0.0920759547805206f, 0.889582307602381f, -0.0710437157605615f, -0.182724716112986f, 0.228135065644420f, 0.851015495602628f, 0.653035806598961f, -0.986676404958677f, -0.871714951288816f, -0.824734086356281f, -0.490239304888267f, 0.244318295619814f, -0.923794688606381f, 0.670566388343457f, 0.849438492633058f, -0.225318912425116f, 0.461075616917687f, 0.656436404012820f, -0.416403369651597f, 0.205630417444150f, -0.163509095777762f, -0.0670299490212758f, -0.315561491397908f, -0.0952855008191476f, -0.377993693497066f, 0.860172853824826f, -0.669622978211317f, 0.595058880455053f, -0.425661849490015f, -0.0405359106780283f, 0.129968697438974f, -0.156244199842099f, 0.996996665434629f, -0.888570357356090f, -0.925646614993414f, -0.753998082238076f, 0.714491335460749f, -0.307849905639463f, 0.536274323586448f, -0.462944722411129f, 0.622202376598447f, -0.215582012734053f, -0.115115003363232f, 0.128168110175570f, -0.556263623663708f, 0.921813264386344f, -0.288173574121268f, -0.175054002159610f, 0.0621862747516269f, -0.468862899314091f, 0.976184545317535f, 0.468469061953779f, 0.679394669665911f, -0.0651943232114096f, 0.872740953203360f, -0.917720162541254f, 0.271535917769933f, 0.265441861283112f, 0.542190484993772f, -0.0208550501604048f, 0.983272473294640f, -0.522164666401537f, 0.833823680455458f, 0.414337644113416f, 0.588576354535126f, 0.318369292694380f, 0.870442561030567f, -0.422722224743553f, -0.200185003922166f, -0.770185495487048f, -0.878134057034045f, -0.712873198675798f, 0.647706512601268f, 0.593648188899773f, 0.126171748161942f, -0.189622212946038f, 0.707877641788638f, 0.790070498218410f, 0.698576567863428f, 0.594748885238005f, 0.567439045931572f, -0.591839707769224f, -0.632709967090349f, 0.415471238430617f, 0.115403276784208f, -0.375797954748234f, 0.123611001678020f, -0.864109581464288f, 0.115346512920739f, -0.515581940111704f, 0.880606114362175f, 0.356011740142007f, -0.318112820131587f, 0.765766689783476f, -0.226772670084743f, 0.442067390135885f, 0.348547568069751f, 0.862154389627291f, -0.894863284060244f, 0.475714942110286f, 0.552377629980789f, -0.0838875341374268f, -0.227654706745770f, 0.0998522598030438f, 0.870812229993830f, -0.518250234958224f, -0.0635791579471283f, -0.284101882205902f, -0.454751668241269f, 0.720773434493943f, 0.0756117818245317f, -0.0572317848090118f, -0.692584830354208f, 0.776250173796276f, 0.514052484701885f, 0.00770839936587864f, 0.775668871262837f, 0.933055956393907f, 0.0501713700022097f, -0.922194089981246f, 0.266653852930886f, -0.408584553416038f, 0.797066793752635f, -0.785570848747099f, 0.931403610887599f, 0.660859952465710f, -0.630963871875185f, -0.673000673345695f, 0.518897255252506f, -0.342041914345720f, 0.405613809903414f, -0.373516504843492f, -0.208292396009356f, 0.0510871025610438f, 0.396765368381847f, 0.00537609874241829f, 0.935717099427788f, -0.564801066383885f, -0.907523685862547f, 0.670551481631625f, -0.457309616171932f, 0.364001526470449f, 0.140805524345232f, -0.349945327329409f, -0.0361532758624807f, -0.304268551311720f, 0.618482952755668f, -0.0120110524971313f, 0.106364353621731f, -0.427587198043230f, 0.464249033810121f, -0.808297048471569f, 0.675277128303038f, -0.0663762607268352f, -0.431951364170808f, 0.953951718476660f, -0.725934553905574f, -0.685163723789561f, 0.164132617720945f, 0.934798872032034f, -0.695343627424553f, -0.420317401094920f, -0.689247558220342f, -0.605894279765940f, -0.693832779320227f, 0.455037128281788f, 0.968645000038447f, -0.0839147410947130f, 0.603463489419899f, 0.776913738299999f, -0.491560292499776f, 0.692235227850848f, 0.0824017593921889f, 0.459024952691847f, -0.918050509352710f, -0.777463066447746f, -0.161045596440278f, 0.982603547894360f, 0.700884888820475f, 0.998304481713913f, -0.362488733430088f, 0.171493948866881f, 0.565871153533442f, -0.965620428705067f, -0.835532968802398f, 0.885598629033760f, 0.609604257914327f, 0.725300244775050f, 0.153524048564152f, -0.662541112390878f, 0.912145212201290f, 0.135610445338421f, -0.0813934125800109f, 0.242209063597546f, -0.264886126609115f, -0.335070345839122f, 0.823958964903978f, -0.313110855907701f, -0.354068037633970f, -0.0381190024996405f, 0.117794735211134f, -0.604442743379238f, 0.524930955656444f, -0.754959642694882f, -0.359151666678207f, -0.247910739722172f, 0.573570999369016f, 0.543167570010806f, -0.718553346110069f, 0.202415372555816f, -0.860091438569300f, -0.0125446132328610f, 0.509348782140749f, 0.349261188228469f, 0.424395913611831f, 0.0557092265870811f, 0.740276822496471f, 0.479158001215769f, -0.221873518706244f, -0.744883456979009f, 0.393114117430743f, -0.733203119089531f, -0.506531269498885f, -0.505532097672033f, -0.509440981371663f, 0.666118722468113f, 0.0164067375520756f, -0.530276655546078f, 0.786338654343788f, -0.985008085364936f, 0.479988836226036f, -0.233652481382475f, 0.838641098910395f, -0.407379719374768f, -0.314266358910263f, -0.938033692224531f, -0.627320971378707f, -0.229174127295511f, 0.642505983671691f, -0.387855473250297f, 0.360324209821339f, -0.900766206699468f, 0.176676285751262f, 0.833894117554548f, -0.0207873177403817f, -0.202625183820044f, 0.706644325019314f, -0.817922707040537f, -0.242742059004419f, 0.282109349674866f, 0.0164603911954744f, -0.504625902855950f, 0.0415496120997125f, -0.787777778295785f, 0.362588721999523f, -0.371357162843751f, -0.818375262182416f, 0.727779997467707f, -0.836502839702384f, 0.0423869176265037f, -0.283934686546853f, 0.665864224978728f, -0.0428162304637920f, 0.243534621880753f, -0.803789304599586f, 0.570866852088607f, 0.340615579467880f, -0.323456502239327f, 0.403242371952148f, -0.0679158901587793f, -0.866985651416456f, -0.439873628406335f, -0.246357367033863f, 0.436234859832243f, 0.560714706225535f, -0.632564381913014f, -0.316451076258298f, -0.977122780282003f, 0.0741405862954117f, -0.217862250253606f, 0.887093089232476f, -0.418281865182365f, -0.638553415535034f, -0.262631979211197f, -0.567499176465252f, 0.676178859605923f, 0.933551699581608f, -0.0139735129263516f, -0.610719575803582f, 0.565123751720690f, 0.230672823422021f, 0.323935439339366f, 0.635142215896104f, 0.981184609133698f, 0.883668802319366f, -0.281281673616891f, 0.583204242495555f, 0.150854689098149f, -0.775890223139644f, 0.419951701513177f, -0.565767744791652f, -0.855232478054420f, 0.472188579901153f, -0.501463211798228f, 0.727960518524943f, 0.977187851385321f, 0.908113737694915f, -0.570200931535418f, 0.716036980035073f, 0.147838037485588f, 0.218820342222622f, -0.0673193461152677f, 0.433612519652386f, 0.449601736390411f, 0.556458722303960f, 0.417345590820787f, -0.783345413347895f, 0.858903187230710f, 0.178354025272247f, -0.130619018471658f, 0.858282827806003f, 0.508916167873459f, 0.139535936201634f, 0.240400109521332f, -0.102942705407161f, 0.841682417072375f, -0.696350979494975f, -0.793644449061670f, -0.698273636720141f, -0.228676865074326f, -0.195917865828574f, -0.306483109792438f, -0.865320326812636f, 0.659185969805107f, -0.368847387975239f, 0.337343722359231f, 0.0723822170210744f, 0.907475280998826f, 0.515168301614856f, 0.0790167120323961f, -0.756697420780699f, 0.966477562469936f, -0.663190129982788f, 0.145761851826854f, 0.376079225193173f, 0.631883071958707f, -0.956568110802436f, -0.735990864315730f, -0.795999578321461f, 0.958459465243432f, 0.319180429028702f, -0.907664654881857f, 0.992381284978014f, -0.511208110440365f, -0.714797966909523f, -0.717021870210999f, 0.545775837604423f, -0.0443828768329362f, 0.333311879948434f, 0.617237628406207f, -0.0895192882305207f, 0.506491005527430f, -0.354205929841282f, 0.777993157224477f, -0.667532693120319f, -0.105006112097613f, -0.337191911902220f, -0.337964429160738f, 0.609014812897482f, -0.368922911475613f, 0.889184378947484f, -0.676392242654630f, 0.429716870038086f, 0.916751115281822f, -0.655611878274175f, 0.538928395264007f, 0.382674384886170f, 0.0580742902089004f, -0.0124611362991478f, -0.0240388340005702f, -0.726296501832402f, -0.805701334732693f, 0.945344279474230f, -0.668066000378724f, 0.761436128738929f, -0.314275650172792f, -0.394331510439346f, 0.262887592668013f, 0.155064800148016f, -0.561829218656134f, -0.491542446753775f, 0.922248338472926f, 0.574575887413700f, 0.631722295929094f, -0.368854197209698f, 0.984780657580794f, 0.845286034922662f, -0.965631634115590f, -0.435710392440405f, -0.616488688868478f, 0.885865616625930f, 0.425733070487506f, 0.776721663555227f, -0.0652930284860209f, -0.734431875923792f, 0.725517937762654f, -0.474146253075108f, 0.895357779508529f, -0.0725048758018345f, -0.360185856190223f, 0.559350280666427f, 0.363695103660096f, 0.152231254765544f, 0.698196273442671f, 0.0518001104801953f, -0.139037096279713f, 0.340637636595997f, 0.584243998596814f, -0.442304329829130f, -0.501574294329747f, 0.250155103662225f, 0.320493999001502f, -0.150217982700108f, -0.0381390799255577f, 0.734760815545772f, -0.574574233376749f, 0.593440338163725f, 0.408049858247104f, -0.0845023181203484f, -0.855507806920297f, -0.473198309372409f, 0.331033392104072f, 0.196445364460658f, -0.799745050834061f, -0.973517526224363f, 0.333748727500822f, -0.772356831553232f, -0.430793038424357f, 0.649852557262489f, 0.504357958431509f, 0.779588082810134f, 0.0111847677569461f, -0.995526851285634f, -0.676007517368195f, 0.216774012875664f, -0.618928775636485f, -0.418043155155598f, -0.532063904545563f, -0.566979013994587f, 0.246319907266774f, 0.868651379198082f, -0.0433430896891542f, 0.463004686009427f, -0.162112430964754f, 0.285379745117090f, 0.901512987149549f, -0.706916206313139f, 0.685678130935725f, -0.673017501666538f, 0.0616272859909088f, 0.147532779463338f, -0.0108539826652629f, 0.960841184863269f, -0.950190006701182f, 0.992171414792924f, 0.715577145884581,
0.975908103138584f, -0.769014520827696f, -0.463212420186382f, -0.0761813427220397f, -0.704830850508594f, -0.220579724380686f, 0.840893269946637f, -0.432181989863148f, -0.956790418498701f, 0.122344784859397f, -0.242133592220528f, 0.908514497715246f, 0.303653521236872f, 0.756500828196849f, -0.752207807361831f, 0.367894642791072f, -0.702474131286247f, 0.189226989057138f, 0.401804209353236f, 0.608493473010907f, -0.437378101171900f, -0.158801297891213f, -0.381027984311046f, -0.949403985394057f, 0.370189685252539f, -0.872655295458655f, -0.337934909993878f, -0.0619622888328213f, 0.352094440420005f, 0.128759637109350f, 0.432413186229881f, -0.497474226759161f, 0.552933107875735f, 0.332665936587804f, -0.559261497212156f, -0.886188834336549f, 0.0170548801295034f, 0.192729852728271f, -0.674432365770129f, -0.526014722983374f, 0.425009223123802f, -0.186164676538888f, 0.190362042383007f, -0.0930204201587825f, 0.794188212052413f, -0.243549629178106f, 0.118970185744958f, -0.216230226310237f, 0.412570247218594f, 0.659556685538155f, -0.150540425515543f, -0.850858266540316f, -0.843827815842486f, 0.629298164439457f, 0.944304062363374f, -0.117764731240517f, 0.558568737697335f, 0.731745392387362f, -0.00413812760139165f, -0.251933493011685f, -0.473346352965658f, 0.178783613032362f, 0.547769344759580f, -0.414330113592064f, -0.550251453379012f, -0.925253680779905f, 0.623832825809309f, -0.494251081521428f, 0.0643361026845244f, 0.727107898350051f, 0.814864886916156f, 0.0177325632172460f, 0.749324691554934f, -0.266301024849295f, 0.675202550635588f, -0.0748462128620644f, -0.747853513216831f, -0.222563643557406f, -0.608884446788701f, -0.0374135649675464f, 0.852579123003940f, -0.585927920129879f, 0.604065857569210f, 0.573072924781108f, 0.816831955879520f, 0.723975232584095f, 0.367887024581694f, 0.765292601085641f, 0.836490699448589f, 0.623434131440044f, 0.743568762340577f, 0.140474444458222f, -0.746327891490507f, 0.700496422194197f, 0.549693846244016f, 0.729372970291116f, 0.728185563682229f, -0.614909046853182f, -0.756209631211223f, -0.530222413502955f, -0.312453162783936f, -0.752364704008701f, -0.634475515424180f, -0.133239439768175f, 0.252790153178337f, 0.760626105409900f, -0.838262213452153f, -0.266093046689486f, 0.549339088324875f, -0.278178592347115f, 0.190458706141960f, 0.906814275056971f, -0.579827980376046f, -0.134191470195968f, 0.244720998349483f, 0.795502128014338f, 0.287019836683889f, -0.906277889518234f, -0.817071933038363f, 0.613378274793081f, 0.518208081766432f, -0.388902790616382f, -0.785778461147273f, 0.574976429920521f, -0.283168065839246f, -0.857322381041868f, 0.424932015236353f, 0.919756642423073f, 0.412896759578072f, -0.976511020897041f, 0.157825653359643f, -0.0606591903280758f, 0.508438714729350f, -0.513115001652116f, 0.881391940997543f, -0.129708782033534f, 0.382462819411800f, -0.538751535594113f, 0.816770663497783f, 0.869013288394013f, -0.728381721932439f, -0.956736333819522f, -0.839107107637575f, 0.394821058517234f, 0.721983518815999f, -0.0847231453556103f, 0.0206545030491683f, 0.414707730497861f, 0.246591855656934f, -0.546187573590839f, -0.578957978692654f, 0.162844799084821f, 0.493731081270802f, -0.765815587549615f, 0.151613093585910f, -0.112883397239635f, 0.879319928900002f, 0.295375250614654f, -0.505370201033860f, -0.635319167339584f, -0.309818465920078f, 0.768627024018538f, -0.544374452091825f, 0.758974060573473f, -0.106050973670013f, 0.508616501970226f, -0.207224226211215f, 0.616842248601645f, 0.688381226662374f, 0.643728558619948f, -0.906982649598668f, 0.526262112978799f, -0.666644270400075f, 0.314806313630502f, -0.292000096972562f, -0.358353880616007f, 0.156344541906829f, 0.637606941586786f, -0.199572501073669f, -0.669369278061572f, 0.237513395315133f, -0.576741807179552f, 0.0750117203638310f, -0.633877533594996f, 0.829285089669934f, 0.622345234313277f, -0.892617583855908f, -0.280449892200797f, 0.241147361581176f, -0.0784016295955696f, 0.414945819313502f, 0.287238318044040f, -0.691458270387106f, 0.597656137422422f, 0.549022082569726f, -0.590776624040652f, 0.666740423918019f, -0.743115212424850f, 0.164036350785269f, -0.229427480781113f, 0.283602991107853f, -0.533993445778340f, 0.185806116700093f, -0.317953364055307f, 0.140412503708198f, 0.280706883979940f, 0.0439806827213221f, 0.176471515460512f, -0.614144204292693f, 0.314194083857125f, 0.519572839644130f, -0.850547081260782f, -0.515460990713008f, 0.353087995032390f, -0.0241014119925820f, 0.269453276643829f, -0.608515317887958f, -0.777818225534647f, -0.834277444316067f, -0.842707175235771f, -0.929547602540323f, -0.884691870945475f, 0.710591809809692f, 0.143423776629673f, 0.797136471728128f, 0.233311155245426f, -0.923169961754164f, 0.627911916101674f, -0.338187201367212f, 0.211044396110784f, -0.443699655795038f, 0.256593551969761f, -0.406688684034041f, 0.364900889856600f, 0.900530571350288f, -0.160476177153537f, 0.0634217008071056f, 0.709241599309354f, -0.789562037599596f, 0.00891621061029158f, 0.801674768895422f, -0.704378031949125f, 0.430576706378041f, 0.796937507044124f, -0.193348850174576f, -0.493924902919358f, -0.935781577118986f, 0.468142331108629f, 0.00965840085728753f, 0.0834398764999438f, 0.599712941235232f, -0.735675950275295f, 0.200152501800787f, -0.751603779675650f, 0.0697488403240092f, 0.300634243862625f, -0.901969784333300f, -0.958816237033024f, -0.754976119377363f, 0.719702182489622f, -0.338038642556184f, -0.703280944186943f, -0.579148694005994f, 0.556115731092296f, -0.920710928208685f, -0.278178108839470f, -0.793795308512285f, 0.916547680808212f, 0.419467216101691f, 0.177932177026735f, 0.682833725334600f, -0.926849803428705f, 0.179045225389745f, -0.209414969718359f, -0.889551871881532f, 0.961659420127890f, -0.250341627298645f, 0.105606170554974f, -0.547860346689080f, 0.845704098204057f, 0.886892635683680f, 0.768134466622042f, -0.954777823503721f, -0.718106389777233f, -0.580779231998609f, -0.0241800476518665f, 0.815063484178525f, -0.351971452344303f, 0.770369263680192f, 0.520886146470712f, -0.236456125482696f, 0.0900173391919312f, -0.00610611501589697f, 0.0986788038317752f, 0.277083194173223f, 0.0877085076786761f, 0.695814138412262f, 0.281021332783082f, -0.701468161850407f, -0.785496560046616f, -0.805623403379156f, -0.0524204125046179f, 0.0836418099696601f, 0.467252832788807f, 0.148967572323544f, 0.314141193557124f, -0.722297309069329f, 0.147068590429361f, -0.868307069306109f, 0.118712645744921f, 0.737896544941878f, 0.897526485681248f, 0.842207508585120f, 0.817408479766998f, 0.522315328909182f, -0.409136979179218f, 0.580654760034574f, -0.384701243761730f, -0.769398544059918f, -0.791317178699730f, 0.357020281620118f, -0.235410423267782f, -0.326332500533018f, -0.416891876268284f, -0.863029987000052f, 0.505171215727166f, -0.728709553380428f, 0.554546891580919f, 0.737429989077498f, -0.355088598334119f, 0.911987317939763f, 0.525846127625130f, 0.851549830104189f, -0.772303673276796f, 0.0421942169353806f, -0.521836640530782f, 0.995279650924240f, -0.186831960875832f, 0.421233670121556f, -0.0891583750230474f, 0.661100169663965f, 0.393809652414978f, 0.346165179707090f, 0.384203760628548f, -0.329281932973211f, 0.446133401546675f, -0.748200766224366f, -0.0275154142375615f, 0.771701580845288f, -0.0177829993094090f, 0.406813206251131f, 0.606021648140155f, 0.218435152341115f, 0.236571855064013f, -0.513495776515847f, 0.729086381137554f, -0.137775825035815f, 0.0320966747364262f, -0.313487802206023f, 0.105472520924239f, 0.423606700821375f, -0.231301628369264f, 0.465218832919270f, 0.379671652150568f, -0.00497780485272159f, 0.509290230688327f, 0.467240127182068f, 0.353587964503845f, 0.390455232684039f, 0.721536288927627f, -0.838922323815237f, 0.827628029266859f, 0.768844149796201f, -0.813963144642386f, -0.797054297232628f, -0.933039367361175f, -0.0723957249866136f, -0.664824147893300f, 0.695914840901794f, -0.206071660300270f, 0.879389414398409f, 0.181872681691416f, -0.582831210733033f, 0.624249199449935f, 0.204959730900228f, 0.354831594370532f, 0.337152636438178f, 0.596132114241829f, -0.295619496794481f, -0.443402055665686f, 0.743995051028396f, 0.543706744165365f, 0.825846155044062f, -0.764982315603181f, -0.0355223730700034f, -0.682467026736627f, -0.914037445162109f, -0.222823484413727f, 0.825323277024566f, 0.0769459194171547f, 0.696453968928934f, 0.760786120466962f, -0.525470048583831f, 0.764981036001869f, 0.458525204937000f, -0.612703584870878f, 0.626016142683351f, 0.284799326870320f, -0.130410894642153f, -0.730659587111424f, 0.0251896513929686f, 0.744421417725379f, 0.481278905427271f, -0.718686189713675f, -0.972110566787501f, -0.178005803066219f, -0.761536801353512f, 0.675177569459847f, -0.613068600254845f, -0.854757540148688f, 0.641823580903407f, 0.112536000301536f, 0.201235170163357f, -0.332623522893231f, 0.602028236317460f, 0.487529253813741f, -0.936537443253385f, 0.932862477850079f, -0.0977461167435834f, -0.485449569929182f, -0.575807340541437f, -0.920527242558033f, -0.938208754460503f, 0.890054000488493f, -0.154888511872567f, -0.106629818916523f, 0.323343252623500f, 0.105328135407289f, -0.837197492121459f, 0.497769113944639f, -0.234127101891878f, 0.840922493788059f, -0.994297350473539f, 0.241966031396186f, -0.241143860453769f, -0.598953146106117f, 0.839112451637864f, -0.639567866338402f, -0.219908091959649f, -0.778137266578287f, -0.201424793310289f, -0.486105622640452f, 0.874947034932591f, -0.131437343585340f, -0.674427373037920f, -0.161007203320351f, 0.215285933912207f, -0.963047650748652f, -0.841020847986178f, 0.259702280444602f, -0.165325097679823f, 0.572379756389254f, -0.435802768396928f, -0.0776125194906274f, -0.0293182206559168f, -0.847945015803839f, -0.576891917046364f, 0.728544652294888f, 0.110676857648527f, 0.760459056611184f, 0.486936926897001f, 0.680603035572503f, 0.330358411271561f, 0.901153157113818f, -0.893323547516767f, 0.268679990552354f, 0.794615743189695f, 0.221637368947158f, -0.0207579360252996f, -0.585634995914835f, 0.587646126395593f, -0.317780705107399f, 0.790321547328449f, 0.251610679655279f, -0.0386445267248654f, 0.881542790650722f, -0.469258891944944f, -0.900544881246558f, -0.344978220866601f, -0.271404539202745f, 0.863631450621357f, 0.805892242474368f, -0.325004362330199f, -0.649692260224921f, 0.535815472185538f, 0.427767946389023f, 0.924517987543855f, 0.571059970962007f, 0.549923246060706f, -0.639468249016352,
0.307213071097954f, -0.885892976847170f, -0.526002656640427f, 0.733743042788359f, 0.186919211020217f, 0.322167483598106f, -0.933484010727969f, 0.307181642341518f, -0.391959805653480f, -0.892298105797306f, 0.100065710151584f, -0.932962740784651f, -0.643536993204857f, 0.200747180046148f, 0.310831344540979f, -0.923416823619512f, 0.440768799148345f, -0.666930667413366f, -0.485487251971431f, -0.0627811951952384f, -0.331082293469460f, 0.0335811939608148f, -0.653610782697787f, -0.320586426505716f, 0.559163070852115f, -0.497363452770543f, -0.329886484503569f, -0.146612217140156f, -0.0265272745798242f, -0.288663397675155f, -0.996138396801714f, 0.705746028666908f, 0.634215549629091f, 0.165248482682243f, -0.110791752682943f, -0.0583711657160508f, 0.704663932851230f, 0.105987046073574f, -0.674234600022039f, -0.852792911043127f, 0.779458558047699f, -0.506163961277651f, 0.661431789813829f, 0.362986600662932f, 0.677673397902417f, 0.909704544299484f, -0.678129611146149f, -0.700854916363125f, -0.954905799366644f, 0.819329178422143f, -0.278866438326573f, 0.240572863896085f, -0.597973444252616f, 0.520707363092687f, -0.891796539359942f, -0.0707113684027092f, 0.730270237241197f, -0.202809887987925f, 0.712903235793333f, 0.815918058519912f, -0.619284883130692f, 0.620432327799984f, 0.215462902206797f, 0.913706499476201f, -0.284266999538807f, 0.137669223817851f, -0.320599930994154f, -0.279885143029947f, 0.0759863610502050f, 0.362519848337183f, 0.0897184432777523f, 0.730407126330006f, -0.715664883515070f, -0.964294244830797f, 0.337668374417089f, 0.563780948124681f, 0.534272089774928f, 0.670003495251274f, 0.976582736706313f, -0.576021162432801f, 0.318863740329612f, 0.374838616807691f, 0.437628782275460f, 0.629331465907672f, 0.800673318445353f, -0.964950925853698f, -0.115288102568929f, 0.581179798077059f, 0.892103220665649f, -0.224009831257430f, -0.486848659265476f, 0.768601825625188f, -0.478996958061453f, 0.987216084861456f, -0.00828256241998737f, 0.443388113322642f, -0.209225960405120f, 0.784392408672073f, -0.821157008960409f, 0.169088259578466f, 0.188648958653604f, 0.796321723736402f, 0.804915614204973f, -0.947435972579018f, -0.320368366702004f, -0.0857043727442930f, -0.229914128505395f, -0.802013870592427f, 0.497444368231634f, 0.791040716463223f, 0.586369970276563f, 0.871236424247704f, 0.770091868124107f, -0.458396647683594f, 0.871149873224889f, 0.753895449519495f, 0.295832468734546f, 0.574616471536691f, 0.384408809311353f, -0.978021020306570f, 0.0397482936794495f, 0.628095200786834f, -0.968059492217325f, -0.404306711220928f, 0.659301030460980f, -0.345766174675525f, -0.0517956907600681f, -0.640289082986305f, 0.965202733073502f, 0.909703156044274f, -0.744545066259015f, -0.676836498528477f, 0.0507393165493961f, 0.394673166210436f, 0.250366706754377f, -0.287411651947684f, -0.521760552601739f, 0.214487178617345f, -0.922260536787078f, -0.970217444063294f, -0.632705652784150f, -0.720016326822300f, -0.506393579710801f, 0.774172771450182f, 0.891546338793249f, 0.559706491124446f, -0.513481979527671f, 0.735727350850420f, -0.207760672132971f, 0.956672164225499f, -0.516696999265124f, -0.846015525317730f, -0.199370940530009f, 0.927580907007946f, 0.669786891276299f, -0.208316500739886f, -0.349932032863852f, 0.382722440637189f, -0.455635180187178f, -0.573852668753046f, 0.237990995216907f, -0.00210628303929439f, 0.846035951941252f, 0.921932267818374f, 0.141873820779935f, 0.871317167610738f, -0.632607355185838f, -0.565801401210940f, -0.959881482283947f, -0.732559764685905f, -0.655277252471118f, 0.136770193226314f, 0.206392768880907f, 0.0946932052352707f, -0.147722827344946f, 0.142504821799194f, -0.891443939735724f, -0.660161817562772f, -0.918683225740157f, 0.524851053279394f, -0.841532325411647f, -0.662931925252737f, 0.450018807591706f, 0.157794014139767f, -0.562525486647545f, 0.604051451992330f, 0.859220943805127f, 0.943321402026900f, 0.511188518123118f, -0.332990520726740f, 0.904709059147998f, -0.336911302156504f, -0.0329301811082998f, 0.307263624236174f, -0.640655394434152f, 0.791676792853669f, 0.450137270831791f, 0.746000232170803f, -0.915436267533878f, 0.976514418439799f, 0.828073391112522f, 0.990695018409237f, 0.419713963781614f, -0.286897378037841f, 0.111527193084439f, -0.956913449095442f, 0.263769440437253f, 0.534739246489713f, -0.918314908283506f, 0.680501951418845f, -0.0258330390798596f, -0.696521999550769f, 0.274590593565720f, -0.821334538131451f, 0.104139627465949f, -0.790104923997319f, 0.399265830301725f, 0.118854169469537f, 0.309552488812324f, -0.961100729890863f, -0.665645274594184f, -0.125767140532335f, 0.377154316156289f, -0.971986633153292f, -0.148225730575294f, -0.801072242848910f, 0.735673216754228f, 0.247753694178141f, 0.759093842520115f, -0.529946694334253f, 0.594235069164038f, -0.801015868726278f, 0.141962211231124f, 0.135473683510959f, -0.0431660672944612f, -0.437176231417910f, 0.467008031415084f, 0.324675317141816f, 0.122578305547357f, -0.0351479470228342f, -0.437236315511244f, -0.822621846670407f, 0.989461679354308f, -0.242059902390237f, 0.800837521050356f, -0.387832478851607f, 0.316362161826139f, 0.602440060427024f, 0.890992007298149f, 0.319686042477150f, 0.930326885903916f, -0.170779817104763f, -0.437602177375177f, 0.835764105962134f, 0.522922752459604f, 0.295156847627349f, -0.857646277751538f, -0.451421990712551f, 0.752856133268497f, -0.826193868550830f, -0.906961130052697f, 0.118621494342013f, -0.627099634988204f, 0.163256363060383f, -0.719362770410877f, -0.576563943780491f, -0.369939711177846f, -0.294180430088591f, 0.868430622614485f, 0.945955651201780f, -0.879259966782947f, 0.376142233233261f, -0.549019623646418f, -0.366403875933169f, -0.631308623984507f, -0.398270064613022f, 0.631780765950599f, -0.497821177556814f, -0.0754938097555216f, 0.358298259390762f, -0.438971283619577f, -0.835962846436280f, 0.771544885338102f, 0.132031497593111f, 0.0964144932127649f, -0.171144812197942f, 0.734241841669664f, 0.773828279651661f, 0.591442573315395f, 0.449840299498767f, -0.249196666141921f, 0.910274822633449f, -0.623687862912847f, -0.954398427932048f, 0.700975370671540f, -0.128268698036002f, 0.723971772247224f, -0.239872317271662f, 0.599101633280873f, 0.323504979356466f, 0.726076237951951f, 0.775013638477775f, -0.736157118505210f, 0.681129332563739f, -0.989456914597076f, -0.860559243921100f, -0.652547050354339f, 0.227533741410917f, 0.263244425371628f, -0.412800042549063f, -0.774547399227093f, 0.959749220773555f, 0.0285018454625012f, 0.0260964660594436f, -0.817249773797516f, -0.275510098931589f, -0.957071090655421f, 0.755874233806472f, 0.0601247360044190f, 0.155148678178749f, 0.744458452388040f, 0.206143083045583f, 0.405575258734775f, 0.591273066531951f, -0.286358679634110f, 0.168522523380964f, -0.0740663582251186f, 0.991796969736415f, 0.00304472789286958f, 0.0955103281360055f, 0.595292305224677f, -0.633460800851610f, 0.969720344590438f, -0.788939516987962f, -0.690852963213444f, -0.751849610482179f, -0.454105756229298f, 0.527652178438853f, -0.249156091787771f, -0.395486634371019f, -0.586329259469701f, 0.774216673365643f, 0.000796185912973479f, 0.753872935709907f, 0.691883261316931f, -0.599798140130743f, 0.140718954973018f, 0.400016581571111f, -0.412934563119652f, 0.782683275869451f, -0.837415681080234f, 0.503344297140354f, 0.443222186121185f, -0.869067764953740f, 0.891507832007671f, -0.258782538717313f, -0.592111951047753f, 0.542828422857983f, -0.959476625230936f, -0.373353196174649f, 0.558975637763876f, 0.848608638566440f, -0.861701716955403f, -0.937645215971517f, 0.0456695238513540f, -0.643462752057364f, -0.194887894642735f, 0.576940690214110f, -0.889414400002951f, -0.120401270393403f, 0.581976128201341f, -0.914549817300516f, 0.619675229253819f, -0.446355411157033f, -0.686510097388917f, 0.199022704414501f, 0.0679083509214176f, 0.939286059873160f, 0.919854436895475f, -0.921420499961796f, -0.933865152326639f, -0.173428453947994f, 0.0481843697148709f, 0.282408667923603f, 0.411093542307595f, 0.332739798472214f, -0.539048264159821f, -0.704491312083244f, -0.502163632960363f, 0.955228344617550f, 0.620064399129425f, -0.470222569036376f, 0.754614931250763f, -0.616308595262807f, -0.914574682979899f, 0.624066330640082f, 0.836911269770582f, 0.913639510454430f, 0.653228461676548f, -0.269928008555249f, 0.313006679186127f, 0.984676487220296f, -0.492012769698267f, 0.956868299674771f, 0.291679581317590f, 0.0391808383867289f, 0.572884371819903f, 0.0424011452585180f, 0.955486550514640f, -0.402317209279260f, -0.606465037288902f, 0.547296561663929f, -0.262634118959448f, -0.555413611714328f, -0.328781770154915f, 0.145794994289916f, 0.141260540582646f, -0.451655981927315f, 0.305553535897825f, 0.828724940454557f, 0.263943455052409f, -0.609183422737396f, 0.691170220321907f, -0.372701931956834f, 0.750237424665146f, -0.249353280856890f, 0.379870697565802f, 0.385751069018950f, -0.515117494253264f, 0.716937491491901f, 0.343749563024118f, -0.462962268225808f, -0.542579750084113f, 0.865163879545508f, 0.348358741505572f, -0.309602240547849f, -0.0504864877295679f, -0.822856269672862f, 0.199343960697129f, -0.790668167630170f, -0.0910655952543342f, -0.0243531696455832f, 0.832501734319368f, 0.604933598167068f, 0.899053047900036f, 0.270668041381131f, 0.523691409964688f, -0.0841567002292820f, -0.844392287920523f, -0.910987838261586f, -0.470654231510287f, -0.103828495683496f, 0.253788695977573f, -0.103172947809401f, -0.339896741661867f, -0.447251997825083f, 0.217200476817515f, -0.474840886373359f, 0.227876267254650f, -0.851351819181938f, -0.902078585170911f, 0.445464427415683f, -0.842484493463611f, -0.141606736723087f, 0.104224619207891f, -0.554900879859470f, 0.818556374444811f, -0.832710463532413f, -0.284760316465868f, 0.697962734672817f, 0.235137001970259f, 0.538298155374871f, -0.598477541924834f, -0.833959821954974f, -0.164556670763502f, -0.443902305525605f, 0.484290717235912f, 0.319356252041167f, 0.0834544406255109f, -0.839174383593280f, -0.514784811627172f, 0.466424623987191f, 0.597641402168886f, -0.344706573843316f, 0.346954604803744f, 0.150560726232471f, -0.963838773301094f, -0.210406119881130f, 0.740751216241446f, -0.519896828058978f, 0.882277568799242f, 0.982734995306564f, -0.691486807580351f, -0.120653164608028f, 0.263039860106709f, -0.472131671311566f, -0.469155525952548f, -0.562705921604020f, -0.737502946123759f, 0.151863404645485,
-0.367233093688652f, 0.149585386378220f, -0.152980596399920f, 0.572826412281344f, -0.498718037086228f, -0.0794332639424211f, 0.659760386972575f, -0.574814983564964f, 0.451329484188896f, 0.473066930128670f, -0.135151886005125f, 0.379571405476121f, -0.308712078323501f, -0.136843563834117f, 0.395667583713552f, 0.196238140324408f, 0.588147058383512f, 0.770505301611929f, -0.865188840370228f, 0.266437694165002f, -0.428134513764013f, 0.661967260527446f, -0.752421375452379f, -0.556389852423621f, 0.424944298468302f, -0.480554454112605f, 0.916159659428765f, -0.112147362457396f, 0.363475545209813f, 0.698805683596358f, -0.862382341730295f, -0.489415523853276f, 0.453056404353730f, -0.606183761884457f, -0.00869682692408680f, -0.288739722701460f, 0.487988005841341f, 0.566870040344668f, 0.0894575138005909f, 0.887832293799319f, -0.0981274237649674f, -0.279935090781560f, 0.506891141525948f, 0.952901245338457f, 0.458002767525373f, -0.569410776125351f, 0.849518291873527f, -0.585020953514368f, 0.676037258640625f, 0.299076264841081f, 0.911385441491479f, -0.954959555659035f, -0.681285607891366f, 0.631368118385947f, 0.522268523899537f, 0.900701101674748f, -0.647701850365577f, 0.567960815808216f, -0.138958982219446f, 0.267024801687456f, -0.975771109955874f, 0.314682157086949f, -0.378801381286130f, 0.665990927256163f, -0.573674360032848f, -0.860450785684384f, 0.516581474078532f, -0.190844183471714f, -0.451971355445856f, -0.808113003973650f, 0.860446168028895f, 0.377778958059242f, 0.126949039950121f, -0.892203650250330f, 0.572503460980517f, 0.975224974978800f, -0.202312370945465f, 0.500665599343084f, -0.0510413720986291f, 0.353231752436633f, -0.805555931906752f, -0.199761377956955f, -0.829487282239605f, 0.0282459088867508f, 0.814545057118991f, 0.557652277921578f, 0.613951716518862f, -0.678811366342345f, 0.896500288318877f, -0.627622562398925f, 0.802545092571611f, 0.211382709497062f, -0.979380222642662f, 0.826784411456488f, -0.670689878657734f, 0.788878029765924f, 0.137070906151783f, 0.901907287859132f, -0.526217367070263f, -0.545043827128876f, 0.494756249972086f, 0.236657948774128f, 0.156603327087660f, 0.516397244064118f, -0.325837179590292f, 0.460683385171580f, -0.196022953760504f, -0.441996357332195f, -0.808932369852494f, 0.291980108741838f, -0.833583979826152f, 0.365574438479475f, -0.797139524158001f, -0.0649288183732912f, -0.000696491493834994f, 0.100125393693922f, 0.598035350719377f, -0.312548404453564f, 0.0414605409182345f, -0.675913083156432f, 0.236245026389435f, 0.550464243484224f, 0.193366907856750f, -0.903654015709839f, -0.00993172527377806f, 0.0180900754210873f, 0.880678290110106f, 0.166539520562349f, -0.984509466189118f, 0.810283124477894f, -0.925371921448173f, 0.193528916069728f, -0.748644561903135f, 0.534508666819454f, 0.364436869280188f, -0.386979667637943f, 0.427958998441480f, 0.362750270039032f, 0.420886957715891f, 0.0300301961707390f, -0.655220626875711f, 0.0504522662127427f, 0.472640818703213f, -0.417745816013639f, 0.0689992794158720f, 0.461232479061866f, -0.483517586427718f, -0.411463769964024f, 0.622740736364726f, 0.659687134578680f, 0.243900134982579f, -0.684356227282321f, -0.688699031115733f, -0.316032121634021f, -0.644296362948831f, -0.236133265458216f, 0.880259454885881f, -0.956880609581177f, 0.737775899964131f, -0.529059297472703f, 0.794119601436042f, -0.375698158660466f, 0.493447663117292f, -0.752511119115434f, -0.941143365329844f, 0.610101048864035f, 0.253791011658991f, -0.369994602049336f, -0.697364270085742f, -0.681360550250048f, -0.571943442128960f, -0.749697324128684f, 0.611997629275096f, 0.892727938106141f, -0.440225399106758f, 0.00196047981855352f, 0.951252158369648f, 0.0351885308766962f, -0.471806546113710f, -0.657231535594911f, -0.0873481442406481f, -0.0341288006282565f, 0.579184398564974f, -0.224334624306026f, -0.298557652719061f, -0.509401519638379f, 0.188853505083675f, -0.321619146497229f, -0.613159956450671f, 0.570042044631281f, 0.699213203307007f, 0.537439231469861f, 0.529440733283839f, -0.744527226912905f, 0.362949055807175f, 0.529758698714545f, -0.114804719889245f, 0.991089489396930f, -0.186716454683287f, -0.218189173574106f, -0.0493780858124198f, -0.928812411399224f, -0.101855573638590f, 0.454268528366586f, 0.617591620012079f, -0.197519518988231f, 0.0973277590468935f, -0.185672509894105f, 0.649922648337967f, -0.896862900376972f, 0.594999589349510f, -0.746978997769556f, 0.590642952628647f, 0.935109901616311f, -0.293310684054096f, 0.783281817912060f, -0.189898897214222f, 0.414859016240278f, -0.0858574647662298f, 0.0810260863380805f, -0.633024441577653f, 0.248442861097829f, 0.984586601784679f, 0.982811638387854f, 0.547456083836220f, 0.476239638753291f, -0.897709902882279f, -0.208045489357872f, -0.860637131636973f, -0.496740558564284f, -0.944185351410090f, 0.157610983944341f, 0.975214099838643f, 0.550265718083095f, -0.630360326400067f, 0.672420341653334f, -0.897139264107564f, -0.670556423663785f, 0.298764071000339f, -0.310465384759529f, -0.978153640586955f, 0.189785151994709f, 0.929291975296760f, 0.758271912876084f, 0.806829662560108f, -0.472787451147715f, -0.802032434276146f, 0.455809631085663f, 0.985520713417984f, 0.739637167649794f, 0.311705106454777f, -0.120539152808323f, 0.977785717545631f, -0.848554870988208f, -0.281179241544089f, 0.931102239520177f, -0.255243432382956f, -0.284952242030900f, -0.189341152192864f, 0.647573166562597f, -0.474203015584843f, -0.545915610099538f, 0.672696420688916f, -0.239274489717776f, 0.956544960216021f, -0.0858024073600807f, -0.758223415922611f, -0.00817763648068581f, -0.500893489164054f, -0.669386983409311f, -0.344450617815217f, -0.728051392792875f, 0.804121117816188f, 0.00718436691280910f, 0.195237363230272f, -0.472485206728796f, 0.642070241911164f, -0.272384993247314f, -0.731715323915071f, -0.791266589031733f, 0.0339783427570857f, 0.0696513783219659f, -0.894169486972683f, 0.00234016305501483f, -0.0403382685361653f, -0.943600572111266f, -0.788181603936192f, 0.851406365407377f, -0.100015982664501f, 0.145502229793638f, -0.528736628076536f, -0.0313760382570432f, -0.662221611141088f, -0.885722031379862f, -0.744257140212482f, 0.524976313116033f, 0.186092035304635f, 0.181669793648209f, -0.606482674165339f, 0.849303544554227f, 0.226118051135263f, -0.690025550727719f, -0.256543384397548f, -0.207714017766381f, -0.447913202664626f, 0.375270273897879f, -0.884312586292038f, -0.0838720085819762f, 0.969898436757285f, -0.736808033249456f, 0.668875150485586f, -0.599937439969920f, 0.470077288925414f, 0.903135367105719f, -0.895619185450694f, -0.637694108244489f, 0.572669535020987f, -0.696211470281632f, -0.820577518545193f, 0.937364674938455f, 0.422458818039761f, -0.593964370461091f, -0.586264791612426f, 0.0282373486927521f, 0.298051147134121f, 0.592825359583763f, 0.716195674857467f, -0.684008410968338f, -0.167523841045924f, -0.370794208549223f, 0.768054740581884f, 0.997835641681024f, -0.366262133888883f, -0.523114034556271f, -0.457946740456489f, -0.530941146838744f, 0.298744841822404f, 0.390761228562591f, 0.0871171594445448f, 0.764002674223649f, 0.233966808661423f, -0.116573523634048f, 0.426118986433559f, -0.255934695328716f, 0.302314199650152f, -0.254971729124577f, -0.330865677738578f, -0.0840307537517577f, -0.711910586170446f, 0.622585361690409f, 0.367595248366733f, 0.422102667722561f, 0.269580206097961f, 0.707083822001774f, 0.625367208198523f, -0.729594790471199f, 0.708679674727951f, 0.00355767003560614f, 0.379158300246371f, -0.688791438249760f, 0.261637457245975f, 0.704008781391790f, -0.917586017594177f, 0.886443038824615f, -0.923559496787343f, 0.360365726214756f, 0.547058288460181f, -0.279853192856989f, -0.996331953899586f, -0.323735921605962f, -0.618788277975037f, 0.314597206161166f, 0.106380963133907f, -0.235044228453968f, 0.0406899091091886f, 0.687339428801573f, 0.344837805924860f, 0.123214914005620f, -0.735264225932133f, 0.0396243248944774f, 0.270602083588730f, -0.316104623194235f, 0.201800731173529f, -0.348987679395254f, 0.994312100135549f, -0.986073454140000f, -0.787571177818193f, 0.508460947811657f, -0.443663972776222f, 0.800303477136838f, 0.712158443474503f, 0.958364684407633f, -0.0512343510942759f, -0.391095518504938f, -0.291911155637644f, 0.721770656984705f, -0.163541232110535f, 0.0366644501980513f, 0.700853097239887f, -0.508089885354834f, -0.375072588159867f, 0.161585369564288f, 0.686325557438797f, -0.113188612544717f, 0.859354598908873f, -0.723198679696606f, 0.398879124170303f, 0.139357627051752f, 0.484780500073663f, -0.0437501438537016f, -0.868783676783105f, -0.147865612288567f, -0.116480069295514f, -0.986846049950927f, -0.859405305954576f, -0.631359938031082f, -0.0310065270390489f, -0.288382201791710f, -0.500960878568203f, -0.805633068309090f, -0.837604329816134f, 0.0325253228618525f, -0.538953832190091f, 0.913844038280417f, 0.681967460199437f, -0.656775429658090f, 0.922492558885196f, -0.689527254640680f, 0.688263898240070f, -0.225450858342925f, 0.0287239965989763f, -0.407744573364816f, -0.477326718671529f, -0.780374037627418f, 0.500400378743065f, -0.532646941279704f, 0.999679272201893f, 0.136003002234441f, -0.811267727922649f, -0.585019862511894f, 0.125465493193590f, 0.203160759437510f, -0.101322607820275f, 0.543784310894398f, 0.630139383695983f, 0.775322422120693f, 0.229262447827729f, -0.656821799421711f, 0.795940998463793f, 0.263281283116320f, -0.377237794697631f, -0.714267543277316f, -0.161924029976839f, 0.804294011825499f, -0.500488029613262f, 0.716655543045374f, -0.709565530287520f, -0.260746944768714f, -0.496886497176178f, -0.896154699339640f, -0.891352204187934f, 0.0589172685048254f, -0.952496908556348f, -0.543314015084183f, 0.0724005345282401f, -0.132089156895576f, 0.694937364018361f, -0.884509342587775f, -0.944587795707932f, 0.346949362800262f, -0.587900264454839f, 0.531217960795664f, 0.404240620498887f, 0.182769547944683f, 0.804826966991636f, 0.601398794220406f, -0.767933817870427f, -0.329693990599177f, -0.880648189418561f, 0.0370834298504716f, -0.405270662847564f, -0.551993194163015f, 0.357335885219159f, -0.442910616174561f, -0.978355051725551f, -0.638907517841606f, 0.266841057307734f, 0.778698832906031f, -0.967180516636130f, -0.772940622039654f, -0.268706136695081f, -0.326082261974967f, 0.0386785617389067f, 0.576293286973562f, 0.446884000380730f, 0.396703264915684f, -0.718633572608705f, 0.586041202195072f, -0.791039546767268f, 0.556638124682382,
0.728711593864679f, -0.576551104247230f, 0.690227524206044f, 0.0451432373341216f, -0.0569690667958747f, 0.877674150343795f, -0.268602876493051f, -0.770720641807978f, 0.630269600593677f, 0.801702094819180f, 0.177071915997341f, -0.0764831522886398f, -0.476930347674815f, 0.0196833210809626f, -0.566188434097295f, 0.309890567123613f, -0.642682312350471f, -0.645839718540077f, -0.985031719881713f, 0.153028235575708f, -0.446724738384881f, -0.616280949001367f, -0.306418078463084f, 0.313048512921978f, 0.944732667717825f, -0.292311689238647f, 0.263616032352334f, 0.776777395064071f, -0.529182830991988f, -0.418996105801001f, 0.286960890623362f, 0.588336822287104f, 0.268219370126612f, -0.696727535489037f, 0.806089151192541f, 0.0396168299208206f, -0.613570658239778f, 0.358002315998429f, -0.0576147175733950f, -0.859664908314368f, 0.930793190364908f, -0.108955403960031f, 0.640347446939098f, 0.0301817512477458f, 0.508435547839785f, -0.774928250619894f, 0.254548271045827f, -0.192551571812315f, -0.401867317012389f, -0.136220787532581f, -0.480363308055205f, 0.146599399729624f, 0.225767301672040f, -0.207158678688912f, 0.763491487133281f, 0.161192803873192f, -0.574968151683314f, -0.454043408746924f, 0.427131132989065f, 0.170648543751820f, 0.0690597676805780f, 0.0360172652133248f, -0.244429817416531f, -0.973014074152018f, -0.172642279134011f, -0.798684796670922f, -0.622626145444778f, -0.743408670602069f, -0.316057396003030f, 0.908608689971065f, 0.948356574904685f, 0.573858539226522f, 0.457065605245418f, -0.246203048690671f, -0.750525340546383f, 0.612971646035183f, 0.951528788403619f, -0.529776510809815f, 0.0886901849846271f, -0.0254136796699882f, 0.978897595553096f, 0.293893753097695f, 0.620217642132267f, 0.862352989549627f, -0.379040515436326f, 0.790157871471479f, 0.147151952442201f, 0.688271487774812f, -0.897847532497188f, -0.0355337105008888f, -0.850253422176695f, -0.0354384862653523f, -0.625796807949394f, 0.851730076897135f, 0.294773618291289f, 0.834287219330433f, 0.0758749738551283f, 0.912613321307355f, -0.326698079590551f, -0.844748577890143f, -0.685263599922107f, -0.197029963909655f, 0.591416614029013f, -0.130921826828109f, -0.524292687689084f, 0.356220524225632f, -0.150091552835503f, -0.935232109847821f, -0.302103008478127f, -0.998557516519010f, -0.477012685701094f, -0.882343341754284f, 0.210797034143964f, -0.963566378978947f, -0.855600913755685f, -0.790231379847513f, -0.625235937382084f, 0.106405105589857f, -0.760544427202586f, 0.0103124858505332f, -0.610157345750845f, 0.968354521575116f, 0.602472069136318f, -0.216458111191680f, 0.935180184275450f, -0.369261245032360f, -0.289325139062185f, -0.772389696964545f, -0.345513639348744f, 0.135539262008296f, -0.747409495863324f, -0.849724942811800f, -0.739393030129744f, -0.0301380087411172f, 0.373808817820448f, 0.760444548005323f, -0.365739960428504f, 0.121859476627292f, -0.719257541809299f, -0.136914676340304f, -0.178479405732130f, -0.336676444507223f, -0.795056125367297f, -0.0872862684496700f, -0.950510559362909f, -0.395266512078238f, 0.636773305385949f, -0.150667208767723f, 0.534401287220298f, -0.349371424663528f, -0.784729313810243f, -0.0510904599006878f, -0.938702345462904f, 0.616929636007953f, -0.228578318449040f, 0.239101663221907f, 0.0390879233281141f, -0.294705782740043f, -0.847928516841798f, -0.0480433695823821f, 0.487351505367245f, -0.820736333448301f, 0.128692585024021f, -0.305133215914817f, 0.344900079505924f, -0.764316168982242f, 0.717529584295197f, 0.655848670831377f, 0.479849611138232f, -0.107624564628078f, -0.345816374073252f, 0.0822414215758816f, -0.0120870567528208f, 0.475870901669481f, -0.00594923432583361f, 0.869227669945672f, -0.262862047504512f, 0.272430399676396f, -0.734262318791166f, 0.980593493214018f, 0.110413869658192f, -0.732486564250777f, 0.470756873196238f, 0.897133387901917f, -0.151953973158384f, -0.591296220619271f, -0.113167158942796f, -0.103020520738423f, 0.220384226627647f, -0.0570027879342681f, 0.0923157145066511f, -0.523010309215342f, 0.385053964060568f, -0.223938668105458f, -0.0566497019068211f, 0.636390081595965f, -0.753651530578004f, -0.765450358896516f, 0.790370075460245f, 0.622949415286967f, -0.0947634056426396f, 0.122381201893998f, -0.138573523511105f, -0.544298107235542f, 0.535416341314523f, -0.341107295330707f, 0.266262786345860f, 0.620108481133049f, 0.190424987800150f, 0.978559599202704f, -0.925772919482004f, -0.300038300695816f, 0.963372836978511f, -0.501235224357981f, 0.828375446308031f, -0.595716120481773f, -0.889271354193173f, -0.389843123593065f, 0.659433696092409f, -0.633476165557619f, -0.708607689555741f, -0.737738480460783f, 0.985245299432648f, 0.976853985813928f, -0.863072444190232f, -0.785830171723126f, 0.309433061520758f, 0.166813366328975f, -0.552916412621405f, 0.0385101740167735f, 0.445866961855263f, 0.222557362424800f, 0.0710515871571971f, -0.368563489700928f, 0.317406114361191f, 0.326902000037272f, 0.868261309598320f, -0.897838476369198f, 0.664364291232529f, -0.373333343843574f, -0.599809263387549f, -0.411236387818613f, -0.118186587264933f, 0.544960929851182f, 0.395925813072269f, 0.337332244255533f, -0.0195528742963547f, -0.580383437020279f, 0.0779554182143842f, -0.902635825594202f, -0.821554429188969f, 0.869996816042779f, 0.646142135585380f, -0.0824693320525758f, 0.643317857725100f, -0.903892480205129f, -0.457595546004975f, 0.540461917564665f, -0.467530238695992f, 0.107497588388074f, -0.122360487746121f, -0.276968072230331f, -0.436413500733568f, 0.0719555518906898f, -0.794937479672675f, -0.641344733876686f, -0.934734152781945f, -0.0610463967348016f, -0.302623058375597f, 0.281116298309257f, 0.557459622053789f, -0.350054779110337f, 0.681853624031498f, -0.0454067482892435f, -0.897204174835461f, 0.0289327275291300f, 0.664312739864751f, -0.368814604980581f, -0.576946854776660f, -0.187886132141311f, 0.424385580259236f, 0.257994303715228f, -0.567650112011742f, -0.0453371545575014f, -0.362909825264387f, 0.450095578912812f, -0.713870209574945f, -0.956583539581944f, -0.969891699048729f, -0.417755773448598f, -0.230738535348142f, -0.153353095644968f, 0.539368458440622f, 0.591116036659417f, 0.779095541288385f, -0.578525766017613f, -0.587777137316663f, -0.301051260910212f, -0.319655538885669f, -0.343495369437935f, 0.908167583226333f, 0.764220052027033f, 0.0536418758245909f, -0.0529753241803754f, 0.249066042857931f, -0.840152142252005f, -0.529971459254312f, -0.449462194610696f, 0.467144819001113f, -0.500103828192601f, -0.758390449663076f, 0.369740436821770f, 0.189153926151852f, -0.188283227959439f, -0.427563759945909f, -0.186773725840825f, -0.00989853573399446f, -0.783648829817413f, -0.626450875837851f, -0.328015817185970f, 0.760383401930071f, -0.00804531008117837f, -0.982799468341000f, 0.392730506677802f, 0.117799138097530f, 0.351088974844522f, -0.259750164530173f, 0.776495358243216f, -0.703059519879109f, -0.362866233240751f, -0.421345310205860f, -0.818968876330675f, 0.936887497269786f, 0.713300632813635f, 0.916608801523944f, -0.147818975792564f, 0.317064988534009f, 0.885779227314381f, -0.897706599297367f, 0.685423132064732f, 0.907830438936990f, 0.0636614655685575f, -0.423018627861747f, 0.411565657893159f, 0.911060408474647f, -0.617833142759668f, -0.709543522964145f, -0.817633731247023f, -0.252433983274424f, 0.160456393103956f, -0.160765428576997f, -0.622001061437904f, -0.470257555319641f, 0.790643274059634f, -0.648181378655916f, -0.828694900506363f, -0.0234091767546987f, -0.562865077760768f, 0.369299949506391f, -0.423850142805423f, 0.520699811923658f, -0.877662359466779f, -0.739844704434180f, 0.300520939787139f, 0.0655718600121620f, 0.970843358712180f, -0.634231195336845f, 0.324880041395596f, -0.479089635857354f, -0.196422753715449f, 0.568762754402869f, 0.699215376070842f, 0.445741923102597f, 0.679868900756090f, 0.107609859752086f, -0.980983474461865f, -0.788419140653730f, 0.0696289436185713f, 0.00330944186568516f, 0.392265626672398f, 0.803469542460994f, 0.131029913648810f, -0.845408454497170f, -0.754797811352229f, -0.824208086798235f, 0.510072775586974f, -0.809491727769575f, -0.0228491196350333f, 0.920014947791232f, 0.441066319826495f, 0.969846842038360f, -0.199024726691046f, 0.886564290041856f, 0.203997575245743f, 0.481547443573126f, -0.637742489331117f, 0.0664642070998316f, 0.109187062068770f, -0.952676759642045f, 0.309247049771982f, 0.880534651306060f, -0.269363005485603f, 0.280012695899358f, 0.853031642671923f, -0.216236966392235f, 0.903180305900435f, 0.837949615815047f, 0.748563816043584f, 0.266735542018788f, -0.685176037557414f, 0.505893787666761f, 0.977721983069541f, -0.667151469253569f, -0.451774081267849f, -0.385755850727233f, 0.681037251596535f, 0.550130384863457f, 0.704080312734731f, 0.519624533199220f, 0.789651392050294f, 0.176325856625025f, 0.684011432098839f, -0.469125761119035f, -0.841814129063957f, -0.901473334652527f, -0.117747872709914f, -0.608533033968273f, 0.199709646080986f, -0.349430401438670f, -0.435162733168206f, -0.368150014673779f, 0.699084004342174f, -0.446068942643995f, 0.197420740774886f, 0.524893584115327f, 0.706475758890142f, 0.912020785879679f, -0.820472223153770f, -0.334742316079635f, -0.851724976994477f, -0.702164662784812f, -0.649654462810552f, 0.411435475616403f, -0.0438368033650360f, 0.799231452421757f, 0.713371883779316f, 0.252437083518609f, -0.685658163265283f, 0.0734649179831324f, -0.400549431226783f, -0.415602545578540f, 0.233864615718965f, 0.828846528739923f, 0.606577491175688f, -0.266016048272811f, -0.619106744484090f, -0.690853262778644f, -0.503499724631377f, -0.409761822901473f, 0.0576293548519007f, 0.551582021066584f, 0.132631452787255f, -0.838228405334512f, -0.107475742619267f, -0.875306852866273f, -0.184700469068763f, -0.317074087896838f, -0.580912620700556f, 0.453916157844897f, 0.690470988649940f, 0.712835197480083f, 0.314786689622726f, 0.759835688452120f, -0.671090442836235f, -0.408277610289776f, -0.815988422173708f, 0.227854929660384f, -0.0482646895577266f, 0.968141192561708f, 0.373896367655818f, 0.820435826598941f, 0.817746838197885f, -0.0970819110331989f, 0.679170154451559f, -0.577986561676471f, -0.0523570914231941f, -0.776930151133931f, -0.560456597170701f, 0.927747720961181f, 0.0350177837302503f, 0.844938034137843f, 0.00849044473190053f, 0.325089161670337f, -0.851825175889265f, 0.835251667623832f, -0.266397917890485f, 0.108463887056499f, -0.817868888235156f, 0.590399913800720f, 0.699274619715208,
0.200782223352391f, -0.936155874445214f, 0.218471971175575f, -0.890402779861849f, 0.268496441855317f, 0.881231954583528f, 0.279360358017994f, -0.492400368838405f, -0.894376670076375f, 0.585129064098519f, 0.340135248071744f, 0.455880107692993f, -0.861081993524584f, -0.303321115935151f, -0.562781799622214f, -0.526041750296426f, 0.999581943964160f, 0.249814139040315f, -0.0537475603822974f, -0.845239239849439f, -0.874024176808607f, 0.997751771128387f, -0.861617607547820f, 0.671357923629889f, -0.687974310115279f, -0.969462039056016f, -0.448304961870341f, 0.713064428261850f, -0.00718668165564318f, -0.450608596544700f, -0.106059234376561f, -0.591961308554238f, 0.588633089685867f, -0.755341317752403f, -0.542715401462936f, 0.759199260356047f, 0.0297710796506234f, -0.997343196630657f, 0.574076752994254f, -0.696719940193256f, -0.852227517176613f, 0.906332566627663f, -0.171801252847090f, -0.925131151948528f, -0.0212194634560026f, -0.940316444070044f, 0.262965279952363f, 0.902198615594563f, -0.265057066430189f, 0.161983092277652f, 0.0181345459457500f, 0.467973650469608f, 0.857351800575040f, -0.889882538061811f, 0.728868283859490f, 0.671187732362764f, -0.296882575397444f, -0.793099233276668f, 0.335561922676737f, 0.0671874495572633f, -0.0857142329385701f, -0.352870876674233f, -0.119927139078065f, 0.814127111105761f, -0.323910302649634f, -0.313495077982818f, 0.0690526899468447f, 0.877155536890319f, 0.768040884649443f, 0.158910636324140f, -0.824414709871474f, 0.00718921022841235f, -0.868917281154898f, -0.564967532196669f, 0.206261416621150f, -0.0699574404456100f, -0.0547095858591442f, 0.811674902353136f, -0.562993920383635f, 0.441212008804309f, 0.917951119557396f, 0.915571961092301f, 0.0901952529553498f, 0.614118141118295f, 0.760473529905706f, -0.566505475760865f, 0.00880029006400429f, 0.975626259597421f, 0.370738159620831f, -0.0242162976348563f, 0.828887690189252f, -0.665240810020082f, 0.00123256686221063f, 0.184020074202841f, 0.829917510366750f, -0.447854906466885f, 0.529356328938248f, -0.995192699858126f, -0.843748622724646f, -0.422765372440245f, -0.386179414096638f, 0.206325400140261f, -0.369817591904938f, 0.266933785902425f, 0.892617584642659f, 0.740018647415220f, -0.481907279471296f, 0.248268418729551f, -0.382770749117505f, 0.974424303757207f, -0.879320252286332f, -0.0294961755317245f, 0.638693329623790f, -0.765127178629299f, -0.160881380476610f, -0.725001019123526f, 0.00294709357263234f, -0.701949969294570f, -0.708933381768328f, -0.463893635537772f, 0.476650147791524f, -0.206043208566879f, 0.223011684523516f, -0.258637160422673f, 0.206325908651728f, -0.432336904344548f, 0.921979975841259f, -0.944396630315761f, -0.00680582426415510f, 0.319263487872783f, -0.836389324192867f, 0.111532890274445f, -0.938142383682239f, -0.637288670131655f, -0.834211558255576f, 0.251969378874330f, -0.970874587083192f, 0.831662411079802f, -0.446568187924869f, -0.659109068071113f, -0.877869176622375f, -0.890670252448197f, 0.477602927742628f, 0.324737705007923f, -0.147513413112549f, -0.186594638422632f, -0.282864808082840f, 0.745093922271927f, 0.915500859154332f, 0.0421588655873384f, -0.483320910754088f, 0.00503734690385604f, 0.555792895688253f, 0.129412601050279f, -0.229347983583150f, -0.680101211823600f, -0.866063899229274f, 0.437769924839021f, 0.133958234316391f, 0.589233411145099f, -0.498053917701437f, 0.180863681584405f, 0.525955777469479f, -0.581250985307273f, -0.327934857804250f, 0.482381204171926f, -0.867703472610278f, 0.833733008515087f, -0.607761820334944f, -0.758512235503178f, 0.0380785706067470f, 0.719862150842292f, 0.651283470517919f, -0.614218162858801f, -0.239754124815405f, -0.733992057859951f, -0.422541764223845f, 0.951215428883086f, 0.882569470276544f, 0.937054481646402f, 0.184532408731968f, -0.104097666585483f, 0.693277433170057f, 0.800241936558839f, -0.998230532922071f, 0.259835639125661f, 0.562745639592536f, 0.220441127510705f, 0.313735993201991f, 0.330940415696351f, -0.602872424656300f, 0.841677792852844f, 0.749701489563795f, 0.266727039860087f, 0.696379094133993f, -0.430719144952456f, -0.276768289732264f, -0.0872580230244173f, -0.722033206227688f, -0.837309584159114f, -0.629739366225350f, -0.185692585028452f, -0.110619837317415f, 0.515881116042359f, -0.105875685978079f, -0.513700186568578f, 0.961245417898430f, 0.655513716233953f, -0.0921704793645632f, -0.694925472850399f, -0.872174817305748f, 0.0307133806779607f, 0.531120672076921f, 0.965271277398122f, -0.00974420246777163f, -0.497322783064087f, 0.693565685926388f, 0.546918707342947f, -0.230039497490898f, -0.316024461029338f, 0.684231559582941f, -0.306362794944468f, 0.861366189035942f, 0.378922635334764f, 0.259443877770437f, -0.838617128408830f, -0.205350631644011f, -0.139772960377519f, -0.192918167939180f, 0.602404904043886f, -0.537407583974730f, -0.877007125624351f, 0.361539942609439f, -0.732030207831016f, -0.488792995226420f, 0.612591017966442f, 0.567185560938756f, 0.195543595335781f, -0.428955670554558f, -0.666590144318038f, -0.702467396810860f, -0.894350832807439f, -0.0620405855731709f, -0.583114546325259f, -0.482155957064968f, 0.212152442925647f, 0.112603107288251f, 0.0683986906619714f, 0.639176340917929f, 0.642610005510521f, -0.708605273163374f, 0.739594669131005f, -0.492786220480274f, -0.308196102291547f, 0.918748221553053f, 0.186736140989674f, 0.438437026242591f, 0.638769573344929f, 0.928896220524135f, 0.579945520523175f, 0.218608554904045f, -0.526070140579576f, -0.140303420071590f, 0.304347769360423f, 0.488123173638490f, 0.987207018313181f, -0.536397951752998f, -0.553296120219359f, 0.184294880372153f, -0.101502970339396f, 0.287041514309517f, 0.658172721877726f, -0.270141883431914f, -0.0196021946303913f, 0.000779126872975988f, -0.0500294515684538f, -0.588505226599557f, 0.550916571982769f, 0.703271386531766f, 0.982335628009701f, 0.942133544852489f, 0.690741953320684f, 0.0466423349204477f, -0.941178278727504f, 0.121655023640973f, 0.777925151322362f, 0.132430336075323f, -0.114812120408198f, -0.694094073965245f, -0.441397675924967f, -0.187253074701348f, -0.672248118097589f, -0.688869123609503f, -0.0723581859661586f, 0.553779536791160f, 0.380610143087564f, -0.392032089052147f, -0.709403552653908f, -0.607184251637473f, 0.698227587629545f, -0.272885954851784f, 0.0736609147840435f, 0.687106303730018f, -0.230362931709251f, 0.393640839382244f, -0.846905732907407f, 0.0727598538725249f, -0.0119849190815611f, 0.470122652313157f, -0.171681529301612f, -0.329268850654460f, -0.433013841687086f, -0.943499527192280f, -0.123404693276305f, -0.0861435714812342f, -0.228816973160929f, 0.0531549757963279f, 0.901446101051298f, 0.470738280922993f, 0.238383552115632f, 0.292841887198914f, -0.617423653544601f, -0.865786115828523f, 0.586332203179351f, 0.267618252846898f, 0.888575002575769f, -0.0220649407038027f, -0.946385428026066f, 0.317436113017866f, -0.277195072909682f, -0.207326502081016f, 0.735387675940421f, 0.961386190882120f, -0.564038045970629f, 0.840007249305217f, -0.262593952346269f, -0.556378761937190f, -0.346529850864238f, 0.00895460576800877f, -0.695431082536551f, -0.105261635693881f, -0.658342101938401f, -0.631093613961188f, 0.601639903111316f, 0.886830692209879f, -0.600591324826329f, -0.350296019796741f, 0.294348102011741f, 0.555826495708193f, 0.216370653207427f, -0.672654026881445f, -0.572202359802723f, 0.202776438466314f, -0.490708964058038f, 0.0148723360197853f, -0.799031226692943f, -0.221164759306209f, 0.0323674121757880f, -0.130290693568615f, 0.613592603765503f, 0.372755498065474f, -0.540502917956863f, -0.740021877141017f, 0.652888612951242f, -0.666157898478327f, 0.476156241264794f, -0.632081251666311f, -0.538341981270842f, -0.275717185193560f, 0.332983363477103f, -0.989659450166330f, 0.212868816589688f, -0.238985653168422f, -0.453005976359810f, -0.805975530848911f, -0.948192632970312f, -0.291329963979224f, 0.549811667826684f, 0.291147979443248f, 0.909805561757383f, 0.0728533843443158f, 0.737767652888933f, 0.605331616290165f, 0.274826946403577f, 0.710517586349601f, 0.666670055891909f, 0.522059053677516f, -0.553398792071804f, -0.406610321679562f, -0.893232547853708f, 0.549587730399741f, 0.714498083720551f, 0.281833380830291f, 0.652788061587949f, 0.825163748516741f, 0.381299333971584f, -0.485549061474930f, -0.881961689917888f, 0.308937809723222f, -0.524542880617761f, 0.329114405956449f, 0.434631551667457f, -0.894732322264538f, -0.831528385961058f, 0.669760583803638f, -0.674650675537928f, -0.373119878846435f, 0.456602566684508f, 0.387804792569985f, -0.556983911869482f, 0.000826745899317194f, 0.687973801099889f, 0.0471935422816141f, 0.0768302380434509f, 0.317557055919800f, -0.823316513699125f, 0.394699119350099f, 0.609556161256400f, -0.0413041171293194f, -0.244100882405517f, -0.939678976894569f, 0.403390183804743f, -0.933567523933859f, -0.331149894636631f, -0.0265881324103010f, 0.224249195386459f, 0.888271870759308f, -0.119845268644579f, -0.357275416804345f, -0.597001288429956f, -0.486847206619720f, -0.181232488650601f, 0.115441291842326f, -0.599055795186955f, 0.213179364205327f, -0.205238322081458f, -0.373942142629613f, -0.610680997090469f, -0.495737765362772f, -0.257634306994249f, 0.583708320566486f, -0.372047136603982f, 0.953878668619925f, -0.632595987923462f, 0.452049761997455f, 0.166602807787896f, 0.773555002555059f, -0.277154387560832f, -0.557129156714301f, -0.985242402457283f, -0.441173064787937f, 0.561221765682284f, -0.352004972295446f, 0.970292440826449f, 0.855523836321424f, -0.528113079339624f, 0.685454746939680f, 0.322200261898966f, 0.953249967336372f, 0.825673980624808f, 0.177229970128320f, -0.728281956776614f, -0.479030792350269f, -0.00697019557862144f, 0.851652517094715f, 0.853865750362844f, 0.514736989335681f, -0.943509205199198f, -0.0524009027225623f, -0.0798997671509367f, -0.355414349557791f, -0.366273957594958f, -0.565729285138989f, -0.931573923976439f, 0.345119269147864f, 0.638375370217726f, 0.711524360229150f, 0.331664704859388f, -0.986788646426241f, 0.521200596781614f, 0.656290865944842f, -0.436907564088290f, 0.305075696150381f, -0.848337345127939f, 0.354044695448027f, 0.690691708552038f, 0.900352213238582f, 0.475181192463882f, 0.219103309687964f, 0.885437995493547f, 0.421455288320496f, -0.879874221804522f, 0.893371290952196f, -0.545214090169942f, 0.800731783168682f, 0.249421864783476f, 0.0766192343033301f, -0.745747520609971f, -0.613575150364454f, -0.700199720327423,
0.0694373671332735f, 0.759953164582251f, -0.0973030480378387f, -0.298615297250225f, 0.0176506580013247f, -0.269562553201540f, -0.405489169051539f, -0.00491991297033256f, -0.0327449030548885f, -0.688168836745951f, 0.703014457338754f, -0.0909491575673764f, 0.738417882180070f, 0.202377973915515f, 0.338436193625848f, -0.408790267504483f, 0.611776208408261f, -0.711043784659083f, 0.841495665411188f, -0.0445715899008592f, -0.127281559164749f, -0.778797832908623f, 0.210344625249896f, 0.287086540530447f, -0.703702357088620f, -0.151146112491418f, -0.785180444786487f, 0.427963227387140f, 0.873814130606035f, -0.344356753075357f, -0.755726746591465f, 0.846013365191461f, 0.126678120904524f, 0.166687962199295f, -0.148273386834835f, -0.770559345875477f, -0.999129219024862f, -0.223692721084046f, -0.652712854614213f, 0.468054498362978f, -0.911782175948953f, 0.555084850374905f, 0.103972972463380f, -0.414021910330282f, 0.938793897617340f, 0.515461292224815f, -0.127677414947037f, 0.510661477088580f, 0.898409443447962f, 0.528096097102698f, -0.444620870908750f, -0.275909952832928f, -0.516074838791812f, 0.110104492330694f, -0.293114842926621f, -0.596621371059734f, 0.152807456749103f, -0.592864305196648f, 0.948295231208874f, -0.575278847840010f, -0.312463646261757f, 0.664597237604897f, -0.177619554099550f, -0.932259652303036f, -0.295074750863924f, 0.731539128777660f, 0.860409131570119f, -0.0947206503071862f, 0.106073387018718f, -0.235389180430490f, -0.494787189603633f, -0.536357147973158f, -0.680862001049455f, 0.618979489665256f, 0.613893487415732f, -0.308605775713246f, 0.694789556987429f, -0.440049894326668f, 0.908690328690240f, 0.233612239829512f, -0.190662564463532f, -0.344799878911344f, -0.185877286582818f, -0.553543917790750f, -0.859543533414720f, -0.996044831818542f, 0.0388505104043095f, 0.650508591477642f, -0.425233346101631f, -0.576839967180874f, 0.378730359294024f, 0.531713629917424f, 0.506096660522796f, 0.854779196325727f, 0.725302682547051f, -0.414685510902716f, 0.654208477287561f, 0.580368151427426f, -0.000356066597174687f, -0.897393734991154f, -0.845565244312410f, 0.615044057364182f, 0.0434592638759266f, 0.342119048500289f, -0.696414680186901f, -0.713269554140146f, -0.580866925323696f, -0.290886355957456f, -0.473082507703548f, 0.517942229000179f, -0.846159512055215f, -0.715410253368047f, -0.526272663742330f, 0.114004124940380f, -0.207397773975621f, -0.920379649009572f, -0.277970833475531f, -0.636533427057722f, -0.972531734576472f, -0.687000156900366f, 0.872752357637196f, 0.617872391924648f, -0.835274231587444f, -0.383282792481497f, 0.399233665040770f, -0.191230601890140f, 0.620222785371960f, 0.106379326744619f, 0.987222511696630f, 0.219022023664391f, 0.179689082166371f, -0.961619514581522f, 0.570178582343486f, -0.811091514477978f, 0.924484469376845f, 0.744507591138529f, 0.272936430096096f, 0.0646316580619510f, 0.314005111302676f, 0.558833629327024f, -0.329744916784918f, -0.544045568909541f, 0.895769679770795f, 0.798125821580789f, 0.877473384028199f, 0.616163339432501f, 0.441057381106904f, -0.642498173762053f, 0.989059595616979f, -0.374771110304453f, 0.480877593471524f, 0.904941689893360f, 0.428742160807762f, -0.430483645585549f, 0.0830560957640680f, 0.694220841170708f, -0.602964792788891f, -0.522672782287498f, 0.717494777479591f, -0.918002255923909f, -0.454075191574169f, -0.378662039464110f, 0.221482629450150f, 0.750918040362614f, -0.636211037178780f, -0.254529141198887f, -0.944623201010144f, -0.720775773991847f, -0.674641067104323f, -0.208243950413264f, -0.959488786545901f, -0.619966503980330f, 0.599486634018692f, -0.0955439064236721f, -0.458181000169795f, 0.736914498713083f, -0.176789993854223f, 0.676652697410790f, -0.967275583857650f, 0.319377813603719f, -0.427030468653864f, 0.0670640089595258f, 0.769945699222976f, 0.767923203047440f, 0.985790354694142f, -0.207111795449682f, 0.219134401666738f, 0.548513609112215f, 0.977227384558063f, -0.198131173309759f, 0.914163808432723f, 0.178214485462450f, -0.240590252223318f, 0.356128697574950f, 0.453093488702627f, -0.0401152114159198f, 0.818060948361957f, -0.880551400213416f, 0.631519794065582f, 0.658832307703964f, -0.179752451562622f, -0.237844011105596f, 0.739834592198990f, 0.711355594921083f, 0.774856912009109f, 0.321864249971600f, 0.470574585274056f, 0.261964793641569f, -0.634481134262705f, 0.461363065389595f, 0.0879014163867016f, 0.698353456328335f, 0.0611830044908546f, 0.918599000791453f, -0.147822590771951f, -0.208296009525534f, 0.775436805889909f, 0.0380914463017457f, -0.954468558268744f, -0.620451283908529f, -0.770251739379244f, 0.772246778681563f, 0.326462458587915f, 0.417738473564738f, 0.0942643452092895f, 0.486153909005530f, -0.720202618855819f, 0.0172425211828453f, -0.460430186764708f, -0.582933725313246f, -0.439721219285309f, -0.694337374508112f, 0.493516461453915f, -0.993527345413430f, -0.562763570629586f, -0.0644937992008268f, 0.741476357523546f, -0.668588797988340f, 0.594184164979780f, -0.605220767543645f, 0.110074204567278f, -0.599398769115359f, 0.723882026196765f, 0.678747828159456f, -0.608589528492249f, -0.881419419882399f, -0.139357674240927f, 0.873828011683502f, 0.314798068434754f, -0.457017849147976f, -0.526003289738433f, -0.411404919696823f, -0.792254466556923f, -0.299635866135236f, 0.0102316480137963f, 0.161921266554201f, 0.981427028530907f, -0.647351555346480f, -0.183312260273700f, -0.348651484808239f, -0.198142718294920f, 0.589869434168343f, -0.201926511662287f, 0.0337896878721506f, -0.0276515055864679f, 0.236943449722327f, -0.473103622922213f, 0.954358213176107f, -0.536519478008862f, -0.603363977756898f, 0.776267386457251f, 0.780662223932714f, 0.289187291033147f, -0.439954328280331f, 0.0429585232791456f, 0.457321950803212f, 0.236810565417317f, 0.167393310927116f, 0.634521586990289f, 0.154409349572581f, -0.750588956901316f, 0.862647670558265f, 0.800182258889404f, -0.342011510602950f, -0.102697321575297f, -0.797254530582515f, -0.718599505627591f, -0.729105921762328f, -0.152424255231618f, -0.702781451563249f, -0.0212710413372206f, 0.961258625954530f, -0.598484979483616f, 0.188043416567111f, -0.511990501189325f, -0.437449883017104f, -0.352443017251219f, 0.0991554004559394f, -0.663282401319921f, -0.835139403797870f, 0.587602722898819f, -0.939771062270554f, 0.613878515061637f, -0.523857415147229f, 0.444842501987166f, -0.297001528475358f, -0.914581150341453f, 0.554844832376064f, -0.816400014706997f, 0.823726509832068f, 0.704425080572720f, -0.819397910034912f, 0.999003444973468f, -0.968751535943602f, 0.0311500939174130f, 0.247867291448898f, 0.835560943875924f, 0.169794916341582f, -0.302041142019408f, 0.289549413666482f, 0.672141268085176f, 0.947060095876251f, 0.324754171403184f, 0.800014020753458f, -0.785428883146460f, -0.463092135879982f, 0.659192831110219f, 0.118301326248760f, -0.542297334341874f, -0.335957421787428f, 0.794808066256455f, 0.625133567458879f, 0.227917183877260f, 0.533557157748932f, -0.948877884679630f, 0.186417887458649f, 0.859592912781013f, -0.0183320237921572f, 0.967066787435574f, -0.141349529637213f, 0.958107445094614f, 0.264359167622140f, -0.631325355674829f, 0.684598042547604f, -0.527467468151933f, 0.294659298854560f, -0.439220168509424f, 0.391038218778621f, 0.0155669207052447f, -0.681384294454809f, 0.146739459198561f, -0.756404876084652f, 0.381192113543008f, 0.442850940158445f, 0.964002016096921f, -0.0507253848694798f, 0.563462880019551f, 0.190980650425415f, 0.482598778123453f, -0.273426091300166f, 0.980640722167518f, 0.198298590133615f, 0.678100193958147f, 0.530416610025615f, 0.196483886579908f, -0.00515783872303177f, 0.0273438459465027f, -0.257248394117661f, -0.576964504105195f, -0.331030677719652f, 0.389178134459083f, 0.0714066784585938f, 0.915179137858455f, 0.529738860096996f, -0.0851681338619263f, -0.692212896293625f, 0.0786352959300358f, -0.122712774017974f, -0.154641019547052f, -0.487537192251297f, 0.0435645872670241f, 0.856938631597551f, 0.351874085305670f, 0.708100804109985f, -0.701200509799317f, 0.0804479422214388f, -0.0794375302823220f, 0.543751723132725f, 0.346144383452864f, -0.680373368944156f, -0.572281173045994f, 0.237981706511708f, 0.0671482960376590f, 0.852393956008547f, -0.301262907769845f, 0.523762878044853f, 0.0885512158718469f, 0.885168455552951f, -0.333351382431635f, -0.914187358461713f, 0.657220242471575f, 0.202238670865175f, -0.660684692864216f, 0.641271628674064f, 0.795923699912913f, -0.332641448887164f, -0.297595219329770f, 0.427283618553541f, 0.601893958036382f, 0.355248259075043f, -0.420766820174961f, 0.355159952778514f, -0.806733697216087f, -0.694403711049608f, -0.719250654428532f, 0.580487742419744f, 0.959156165420351f, -0.941898541689400f, 0.960568821753178f, 0.119007749103819f, -0.973468502734443f, -0.627534816021182f, 0.331394418445345f, -0.415230278112412f, 0.225355270950915f, -0.216818510922154f, 0.716553646689289f, 0.149097723527982f, -0.212491921692561f, 0.681645638056938f, 0.675358683729395f, 0.0591550775861416f, -0.221626142364110f, -0.235878877821190f, 0.168188057112471f, -0.709738432254387f, 0.842890391064944f, -0.331175752377862f, 0.231375360302226f, -0.714989093452242f, -0.492645353426504f, 0.552424848261518f, -0.436987392663331f, -0.336155191719795f, 0.137666231065822f, 0.739347397348610f, 0.493222787180627f, 0.283646543313800f, -0.603522923409923f, -0.474181275984451f, 0.249315354427624f, 0.323736714335287f, 0.933612934150728f, -0.651555022796413f, -0.743229221575077f, -0.648309364385349f, 0.115117716036212f, -0.0689988553878600f, 0.0394979772968704f, 0.732729774997258f, 0.487584669162102f, 0.808754952095239f, 0.827617962775983f, 0.550826738558347f, 0.890858298785235f, 0.152998196795770f, 0.401198245071198f, 0.187173931669199f, 0.576387011979054f, -0.464903903379260f, 0.735172244343599f, -0.0393734341215035f, -0.501927105416023f, -0.852926247859480f, 0.384774001880198f, 0.723957370923565f, 0.869614310250896f, 0.698124990202440f, -0.0618370378422302f, -0.273879540781302f, -0.0745005910544518f, -0.754408143155094f, -0.859084370639359f, -0.709011936778905f, -0.883595552533659f, 0.326386065122049f, 0.756686513420982f, -0.639817612043620f, -0.536531544653662f, -0.596858657734988f, -0.187117983404806f, 0.760208405412209f, 0.191383034225783f, -0.771443976174702f, -0.371171018178012f, 0.723338724416329f, -0.325113980261468f, -0.652823731845602f, -0.902765567501679f, -0.109945188610355,
0.863727536109734f, 0.762531987550249f, 0.484671237555863f, -0.376731181566557f, -0.961176245257487f, 0.374503763045540f, -0.275274129954644f, 0.947951135663002f, 0.891610575724484f, 0.233179187366345f, 0.868694446846928f, -0.201812205484274f, -0.676342903796604f, 0.962133604967067f, 0.0941637112283598f, -0.0856261317646829f, 0.375061189807232f, -0.275342940020193f, 0.0614298144531287f, -0.183234253182376f, 0.146964792162229f, -0.307180215012337f, -0.139123531176191f, 0.130840221889238f, -0.0654726742084248f, 0.988722897887987f, -0.805684911622576f, 0.763299463922693f, 0.148136188784880f, -0.432183160161832f, -0.592185939638987f, -0.593835208842770f, -0.366135084813261f, 0.840566739882685f, 0.572052978307971f, -0.825682529425410f, -0.970222226210689f, -0.554421263584439f, 0.324648156825255f, 0.0472246837302466f, 0.168098848238140f, 0.00634984653176796f, 0.850237261066903f, 0.286624344510407f, 0.196043215794080f, 0.289161416244007f, 0.334801090322515f, 0.871286740072183f, -0.754609531300255f, 0.623871003889383f, 0.0843430009639772f, -0.736369938040848f, 0.400507674511444f, 0.816325383600297f, -0.500667496861800f, 0.453092855162135f, 0.281798170796444f, 0.631969623501011f, 0.472467114651372f, 0.525988741184527f, -0.124862967293674f, -0.882904489381606f, -0.501090007558747f, 0.631622297793485f, -0.0234210285578584f, -0.521093811962915f, -0.0402368492672573f, -0.762999364505356f, 0.948716268452360f, -0.572740830308272f, -0.261042904339051f, -0.506108365537530f, 0.585933508412429f, -0.362463094458446f, -0.885375028242576f, -0.835757117571791f, 0.337250829139564f, 0.298618238243588f, -0.744903291826588f, -0.979848674056393f, -0.488518944548476f, -0.000297116577397283f, -0.137863396173336f, -0.627207234158244f, -0.970417810284170f, -0.601487862773028f, -0.999527775716382f, 0.116672274325216f, -0.786330829714504f, 0.740118245374718f, 0.856485463622646f, -0.555144930193560f, -0.0168912375666686f, -0.774544329159697f, -0.782767315598991f, -0.600844843420598f, 0.885816107471180f, 0.577075799078571f, 0.663829997048111f, -0.359000184287277f, -0.390009578642891f, 0.202240602818017f, -0.0191477232064394f, -0.566459499064884f, 0.288883557382261f, 0.962583478738218f, 0.782123756762393f, -0.312311582870785f, -0.749354208187204f, 0.205679267602357f, 0.804004517387718f, -0.733078779233144f, -0.426195645938973f, 0.686872484317089f, -0.398704803137823f, -0.267786412313359f, -0.374306263341615f, 0.632992513422251f, -0.972217744254910f, -0.167080739523409f, 0.608176739669718f, -0.935550125875275f, -0.422451600932096f, 0.499643952974426f, -0.491034978653149f, -0.0256130378373849f, -0.158669355267388f, 0.360503946885584f, 0.227714934784132f, -0.138648043280479f, -0.0707461296301128f, 0.0638330442765616f, -0.168811643868974f, -0.575670642767690f, -0.162143785491822f, 0.528621079903453f, 0.581283330394272f, 0.444430744183000f, 0.859288341846780f, -0.170487584890459f, -0.440175706710406f, -0.184806402672108f, 0.676010805169568f, -0.0117535553470483f, -0.231606756742133f, -0.210042044569361f, -0.517950708003565f, -0.805772781723687f, 0.156938933772370f, 0.892075905739393f, 0.403874478002384f, 0.572031508558373f, -0.604145909072008f, -0.330076696654475f, 0.0314560087228033f, 0.683787496948704f, -0.788582181996934f, 0.835276281386949f, -0.0644658492206380f, 0.938270191882745f, -0.344927907293928f, -0.976720519493346f, 0.906264084343827f, -0.648152742145255f, -0.776984965421811f, -0.299470572593974f, -0.423690646950321f, 0.749911693814570f, -0.701929894551648f, -0.665191316321370f, -0.568359320650352f, -0.957309362369509f, 0.914088966355983f, 0.770952996203681f, 0.0924190787439159f, 0.844599990803978f, -0.613336716591875f, -0.683270165308367f, 0.358563204319583f, 0.934597169812267f, 0.236596595813630f, -0.895964332479994f, -0.673302324943916f, 0.454883302340070f, -0.473926010524343f, -0.576000657136217f, -0.644850950007290f, -0.980218836434995f, 0.321620362364719f, -0.799924718666919f, 0.0619872524925393f, -0.609255645268410f, 0.159243124858648f, -0.339764623434603f, 0.379865023026277f, -0.923132229333074f, -0.0300494021321296f, -0.183835365297645f, 0.122648511393234f, 0.887652015676064f, -0.616448517838488f, -0.920600866006207f, 0.352861591267815f, -0.930578364778234f, -0.378819076263050f, 0.775423778544869f, 0.836977798656885f, 0.0472244767469148f, 0.484934339557912f, -0.939155187409193f, 0.261555270800537f, 0.143595058480400f, -0.323517719771947f, 0.483466454684928f, -0.423163689969697f, 0.356966814701025f, -0.843907304366205f, 0.945903563730962f, -0.495952298317153f, 0.972277051575873f, 0.153052037173145f, -0.715894882755676f, -0.617028915483254f, -0.332307224095366f, -0.171207102890728f, 0.841771328272651f, -0.0308707743261867f, -0.626480028747696f, -0.729235538916864f, -0.743517330301179f, -0.733868915239511f, -0.449192858200231f, 0.362286468575150f, 0.327436676142902f, 0.609768663831898f, -0.147499187968100f, -0.470195300907973f, -0.232167856443943f, 0.225074905574485f, -0.0818541072414634f, 0.793403933843056f, 0.267628199755028f, -0.391701371806294f, -0.846991992740029f, -0.776221590294324f, 0.121351482320532f, -0.189789365942677f, -0.894392208695015f, -0.632864319945356f, 0.927817761109627f, -0.732454610273421f, 0.260011686544283f, -0.713973491605344f, 0.469764032416604f, -0.608895265807545f, -0.684992974060601f, -0.745556289276139f, -0.536308213076133f, 0.586581187207818f, 0.149804345860779f, 0.401576742698496f, -0.719670291046630f, 0.618659855530024f, -0.256639783379370f, -0.862966031725668f, 0.893866512913152f, 0.861800793529066f, -0.704895723095590f, 0.154163397540805f, -0.0775797186536984f, -0.252297335448882f, 0.869851864160888f, 0.428747373815147f, -0.818372805928921f, -0.739117647833389f, -0.697378012429133f, 0.182997863108567f, 0.689563104159966f, -0.0506114067037338f, -0.705077813920782f, 0.452892458862023f, -0.365069844049503f, -0.889224821648518f, 0.0194889225677406f, 0.847743515500726f, -0.0650338075825718f, -0.108889937983496f, -0.168485037502421f, 0.912533003086865f, 0.428132366084106f, 0.692652998111620f, 0.130599999674344f, 0.411245435867244f, -0.194909473459497f, 0.562152151569866f, 0.503795293326445f, 0.801805532943245f, 0.795718119772331f, -0.327975015537058f, 0.771389506217327f, 0.237139782375987f, -0.793798852884360f, 0.537824655594807f, -0.0767253125021830f, 0.444538451472890f, 0.623473048970629f, -0.500663871860675f, -0.890399840538612f, 0.389528755348857f, -0.915832255765501f, 0.000652855725217894f, -0.121310443088642f, 0.206662014558968f, -0.409513641801496f, -0.0496262665388731f, -0.313314447256644f, -0.994839397423865f, 0.344513198428247f, 0.250828855150578f, 0.845438302422055f, -0.728803841305459f, 0.249670562418639f, 0.543601559270672f, 0.0138774767713057f, -0.0667600054234216f, -0.803421294778238f, -0.222729734665659f, 0.461896933387103f, -0.378537171475208f, -0.464200027877777f, -0.363170335357481f, 0.616070694104851f, -0.316407896795124f, 0.131719997218670f, 0.0622146037260092f, -0.881713850066484f, 0.400811652868418f, 0.163777537634682f, -0.528768052383715f, 0.553072310703894f, 0.931393033749660f, 0.410062835546529f, -0.190904471223264f, 0.0533617852685424f, -0.911780226731855f, 0.823696403963215f, 0.756735978125573f, -0.849701310148249f, 0.106070214350541f, 0.747890454578944f, -0.559823302095172f, 0.976181619002882f, 0.506524051225122f, -0.0735228576098872f, 0.635610640336510f, 0.607728217052133f, -0.383443012662118f, -0.640835123345673f, 0.0897243696426577f, 0.722421963278953f, -0.368833835044170f, 0.684790387373836f, -0.0336846755494535f, 0.199819176553169f, 0.351822803019512f, -0.433387005248570f, 0.709401898386598f, -0.0149217994364210f, -0.549115733466769f, -0.774049259429836f, 0.440376751789406f, 0.740171176715015f, -0.322301969056869f, -0.148261856544327f, 0.724527166150266f, -0.744178178219827f, -0.743031462890542f, -0.00997727490160383f, 0.550074849063942f, 0.147825200269716f, 0.777182602759074f, -0.625412073440604f, -0.0614214671235789f, -0.400121310797195f, 0.864511820640236f, 0.327656445569618f, 0.765838911283705f, -0.906185069285438f, 0.543656228031101f, -0.527337383463707f, 0.544932532036177f, 0.453966596910417f, -0.422906847383216f, 0.803455668330395f, 0.496651297123425f, -0.254890927444284f, -0.940902660088963f, -0.0691448074129200f, 0.0165534278793877f, 0.510199004798987f, -0.0286331020627788f, -0.141471298460923f, 0.872000980716430f, -0.752995088893842f, 0.167696515625982f, -0.181673581299286f, 0.496236252387172f, 0.854022562040503f, 0.388320660177419f, 0.499320363074588f, 0.173522726183149f, 0.0334192536945390f, 0.631347719906229f, -0.832803059709609f, -0.523826088751894f, 0.322557683663180f, 0.0263621365506006f, 0.948982322858062f, -0.253991680115490f, -0.165970359640120f, 0.331700483099733f, 0.808731855823033f, 0.159862831431822f, -0.438178259673022f, -0.943749594272300f, -0.967819867274861f, 0.263403865531262f, 0.710981741513574f, -0.274597382335371f, 0.929606564147885f, 0.125943272920181f, 0.691306164809532f, -0.607946869004681f, 0.284352421048012f, -0.421663515398071f, -0.409479725854699f, -0.152265311389352f, 0.630868673855242f, 0.123144840061153f, -0.645105689918733f, 0.360153393247973f, 0.683885744053582f, 0.752598814717991f, -0.581494857182821f, -0.469116962448560f, -0.0691726199196117f, 0.174679188611332f, 0.351269328558955f, 0.394815335607621f, 0.710281940645013f, -0.618593505217632f, -0.721546422551907f, -0.974088703589852f, 0.939556772536401f, 0.599407011070674f, -0.342213391542906f, -0.387135346574836f, -0.572027944718123f, -0.622717582512866f, -0.676949872287677f, 0.993953153886700f, -0.784539234625462f, 0.788778188174951f, -0.0652679971583152f, -0.988740647590182f, 0.748989697777310f, 0.412949190397683f, 0.206661198525718f, 0.573116044772809f, 0.938498079842984f, 0.743167714677278f, 0.755679122637903f, -0.295095987460132f, 0.217166189740252f, 0.230160404687938f, -0.504654557405015f, 0.472402206737240f, -0.867751757044285f, 0.869050101160567f, -0.905285205825199f, -0.0698843699947245f, 0.762379282963140f, 0.634191197174691f, -0.498487028811837f, -0.284257632541078f, 0.224245853978976f, 0.412950901773606f, -0.831984679101472f, -0.375663639002356f, 0.153699995838016f, -0.953997055484851f, -0.545360745186449f, 0.637687001020610f, 0.465459355638311f, 0.0769011654935299f, 0.267123343048604f, 0.545842501706277f, 0.778890986545214f, -0.363432183057524f, 0.479786652022207,
-0.600912698239979f, -0.738845504293020f, -0.775987143750184f, -0.705559714187038f, -0.310523750352236f, -0.576081829930414f, -0.0341897834633795f, -0.388414434291246f, -0.790681299048144f, -0.169440674711419f, 0.219815472280053f, -0.323451599202462f, 0.835623141427806f, -0.932446301638351f, -0.831480966559550f, -0.185050128422203f, 0.946045240208487f, 0.864740749402213f, 0.916918979039328f, -0.204049261822351f, -0.807183358636872f, -0.484543897885746f, 0.974235382435000f, -0.208019257024664f, 0.647411336652954f, 0.0961385231960816f, -0.800258527388060f, 0.352982142334643f, 0.917274278881503f, -0.733934252997685f, -0.229420044045673f, -0.358499183112933f, 0.469156578609832f, -0.859359096702447f, -0.937762141277625f, 0.389776419837803f, 0.458425599271073f, 0.542973137971009f, 0.675023236195573f, 0.944029213696263f, -0.774027667733194f, 0.262984845114612f, 0.842689106929982f, 0.349251854560315f, 0.815938991679117f, -0.226283690374971f, 0.144356327986477f, -0.610588223452142f, 0.539695204296007f, 0.655759463021729f, -0.725805170479948f, -0.194977831685847f, -0.306105075607822f, 0.725461617920836f, 0.678283785172857f, 0.250577882812283f, -0.571672652704059f, 0.112132856850530f, -0.236412229648694f, 0.768173015701816f, -0.799251028098975f, 0.100723381526471f, 0.113856811781171f, -0.0281630563735495f, -0.0727902548617043f, -0.515248547261805f, 0.795765010992038f, 0.505540143557856f, -0.496124371632015f, -0.363010091302494f, -0.302067159683438f, 0.941309812688142f, 0.0564765277142674f, 0.733027295879568f, 0.582734217224559f, -0.159007222603058f, 0.827637470837748f, -0.163060519537145f, 0.352357500273427f, 0.920405360379926f, -0.280691553157313f, -0.401974149240862f, -0.131353114797667f, 0.0719728276882135f, 0.795795661384902f, -0.348203323368113f, 0.946184663961743f, -0.188400643814906f, 0.979319203447783f, -0.132195434304746f, 0.585832597473452f, -0.894730397941282f, -0.998045985412111f, -0.717844040997160f, -0.706372640246558f, 0.237517748136224f, 0.767232946579208f, -0.246080656591091f, -0.767887803661775f, 0.139501344992184f, -0.545658806327887f, 0.480755550666584f, -0.355750609145607f, -0.493518864013929f, 0.832011102158605f, 0.122542855024589f, 0.179356501845966f, 0.630805165349165f, -0.888557403477561f, 0.861375782261841f, 0.963467658712489f, -0.00498707715217361f, 0.341894517453263f, 0.654808049991043f, -0.826909952854692f, 0.101446328788119f, 0.401514152845232f, -0.830556985096328f, 0.832187560444347f, -0.657254039822149f, 0.0304197382717133f, -0.718462386339415f, -0.592343549551534f, -0.356333235896531f, 0.674135547073730f, 0.606490641440102f, -0.707328770155748f, 0.0251846271186025f, 0.763024927861424f, -0.258224600040528f, 0.456384203436896f, 0.626482995304888f, 0.162353458245830f, 0.964280614412026f, 0.869262296229816f, -0.0659501568862260f, -0.712869755397848f, -0.946968242335746f, -0.852822740386429f, 0.791522782900379f, 0.824530390150335f, -0.369383609091590f, 0.118366422602132f, -0.713278848975255f, 0.549165545117801f, -0.00201102645336770f, 0.748955154405439f, -0.173689412898754f, 0.175162399203493f, 0.0819730422177463f, -0.804833155982895f, 0.972966530563786f, -0.0614871820303859f, -0.293463394754661f, 0.885919261783643f, 0.498531250561504f, -0.808874001349436f, 0.364344357769432f, -0.945616638616975f, -0.285864129675031f, -0.0438177789332626f, 0.303981486324719f, 0.362653007142366f, -0.543157427730716f, 0.174551703296805f, 0.140105048664068f, -0.704163993684247f, -0.647461975308389f, 0.831243960763754f, -0.364954329841192f, -0.730289885595360f, 0.0119708019435723f, 0.796338505809816f, -0.227851954967331f, -0.927330125804492f, 0.0602265250934577f, -0.485204061877453f, 0.198319346525046f, -0.529723177394882f, -0.321493822700232f, -0.839566193416413f, -0.187812484529161f, -0.396142329367383f, 0.367600156667632f, -0.922657847865138f, 0.893508892950972f, -0.504434314314017f, 0.663184814192863f, 0.887813887366393f, 0.267103483259066f, 0.984313142773772f, -0.667515321448428f, 0.0718416862496054f, -0.733363156570869f, 0.00186343206374962f, -0.316531364321301f, -0.467549697367438f, 0.569865535259013f, -0.556502178434536f, -0.650896672234238f, 0.564462797319346f, 0.585276582729153f, -0.433005641153548f, 0.847012427243871f, -0.462088105064984f, -0.379468633087939f, -0.0104892833799723f, 0.654191676584918f, -0.893278846859767f, -0.689350274835588f, -0.333220721049179f, -0.0461703436190983f, -0.463411501818667f, -0.995085073808794f, 0.526075522777196f, -0.0686703698159610f, -0.855908120278260f, -0.239774384006192f, -0.524142243888286f, 0.119526621106050f, -0.838266471869898f, -0.459366707886497f, -0.974921205300089f, -0.680517660007036f, 0.507695286553230f, 0.0920009889477380f, -0.674459855090400f, 0.554585280302756f, 0.357871391273056f, 0.453052004120624f, -0.991707675828263f, 0.144725488641274f, 0.0886535789688503f, 0.708257184179799f, 0.579351194763774f, 0.902098539548710f, 0.0104715251706708f, 0.112677648152527f, 0.0513772996762050f, -0.647561525299580f, 0.321958856072156f, -0.433510239079594f, -0.481493822802105f, 0.651663699618654f, 0.922649363108760f, -0.751799312011289f, -0.0336105332513619f, 0.236872038257485f, -0.0434863841224971f, 0.150810692021768f, -0.217629544451037f, 0.345890414626050f, -0.471941673338326f, 0.675001035054686f, -0.986585320322202f, -0.784679789758475f, 0.270727429189404f, 0.595792127677512f, -0.485969146811564f, 0.222507692419212f, -0.850070310429306f, -0.575184466843042f, -0.220860571657717f, -0.749449040845746f, 0.743039624335149f, 0.463892797640518f, 0.224829531690830f, 0.935410439714992f, 0.00609595972560872f, 0.830877831388658f, 0.0270299847557276f, -0.648763861115704f, 0.471982277585509f, -0.145722971031426f, 0.650947186397952f, -0.266164907037466f, -0.962378355156458f, 0.354855353373398f, -0.184127215272909f, -0.825621979621661f, 0.595495186093792f, 0.448679578752395f, -0.839671989567806f, 0.302158874138200f, -0.735484620769119f, -0.891040803749876f, 0.880298595525880f, -0.281199581528421f, 0.0195033020490396f, -0.511515485794419f, 0.447303195702203f, 0.375317547074287f, 0.964442757731427f, 0.167643569291013f, 0.0118587246816413f, 0.958187068873858f, 0.315395458761821f, 0.188852872643367f, 0.417450657662866f, -0.540566147670448f, -0.422709015019828f, 0.101425586029329f, -0.235465301656357f, -0.806044548641562f, -0.617153815671298f, 0.350658348898447f, -0.738540593521098f, 0.291893065415692f, 0.335435501842245f, 0.832048727909480f, -0.609539777284250f, -0.436992256701542f, -0.685315947977391f, -0.502107715051164f, -0.893460699283628f, -0.262263680492396f, 0.454417031133778f, 0.223227655510993f, 0.605288383003966f, -0.698800586984034f, 0.864843125666124f, 0.363752223710394f, -0.354571459375900f, -0.575008718239530f, 0.423061550052490f, -0.272459660313524f, -0.116932919064239f, 0.547073367599225f, -0.890822451422250f, -0.884262586749836f, -0.889803003239001f, 0.217660629852574f, 0.154863581361214f, -0.333284425759330f, -0.826087281020982f, -0.958198419703014f, 0.850114828540176f, -0.391190814837661f, 0.956578087128909f, 0.0541599967910713f, 0.0988550815990206f, 0.851903747125444f, 0.361959550717838f, -0.901818125706440f, -0.0561477675277424f, 0.522090821863134f, 0.263383912024089f, -0.161061362097086f, -0.983707460720128f, -0.333128836619106f, -0.546535222349413f, 0.627261888412583f, 0.408731616102241f, 0.754700916401496f, 0.869772826180715f, 0.362242883540519f, 0.853587698951791f, -0.698910717068557f, -0.671945256263701f, 0.802655941071284f, 0.338701009518668f, -0.0297818698247327f, -0.881311052338108f, -0.296717226328950f, -0.965699941652671f, -0.737164428831818f, 0.00804554422537485f, 0.989716933531351f, -0.832438692682457f, 0.454553001515962f, -0.933801685729775f, -0.644562445615081f, 0.104508389084640f, -0.535426180524709f, -0.937041822784313f, 0.599911275476691f, -0.789109397888652f, 0.821293320968620f, 0.818032308067912f, -0.838306491947354f, -0.172883985566904f, -0.185775969502745f, -0.672256019841514f, -0.412525056012874f, 0.142272136963196f, 0.792136721788200f, -0.726314486042219f, -0.445981475954073f, -0.857821372905156f, -0.783006950965519f, 0.438776336055643f, 0.400193156140386f, 0.177525578340235f, -0.435380642286229f, 0.547815754835977f, 0.0496394855194708f, -0.442174406426496f, -0.0856142956982360f, -0.0247840885457120f, -0.779016166389253f, -0.511802368745331f, 0.319887353303028f, 0.721806644023428f, 0.770423389111803f, 0.809969588377187f, -0.196191981856391f, -0.105718971622809f, -0.301674515042257f, 0.613622254387482f, -0.969517273103490f, 0.0144576310630131f, -0.668829420461301f, 0.750377960820232f, 0.696858494013122f, -0.563485511352760f, 0.726226115587466f, -0.227540741583116f, 0.665488592033944f, -0.124611809537824f, 0.489550286613580f, -0.579185308695604f, 0.628687311174276f, -0.295770837727116f, 0.240358361854250f, -0.155642183802961f, -0.885945841456110f, 0.388592282428421f, -0.663862196774143f, 0.363779469451472f, -0.371285870971327f, 0.563159689631810f, 0.102725415308920f, -0.320909176496511f, 0.334328794247963f, -0.401664407219370f, 0.726728495517480f, -0.192310060924823f, -0.107973316004269f, 0.898177814643418f, 0.456682306673978f, 0.890742303266606f, -0.742770990765425f, 0.0337493848747046f, 0.786190819119190f, 0.911503487800545f, 0.288384155888888f, -0.249479393879906f, -0.431949793185094f, -0.0847659302921913f, -0.475416985100444f, -0.362720571751962f, 0.676910741300893f, 0.00488530543559529f, -0.227678010632002f, -0.0632947771540859f, -0.990261099329279f, -0.708485805011827f, -0.304846597458441f, -0.480289782580152f, -0.593254971635338f, -0.656335976085053f, 0.584373334310954f, -0.493268395245234f, -0.00212668034894836f, -0.480221591678953f, 0.622365041709782f, -0.258845071515928f, 0.943825418665593f, -0.716642329101759f, -0.765317239111819f, 0.324487844009035f, 0.108158868464706f, -0.790583201992229f, -0.649218622127061f, 0.751409704126257f, 0.301455204388007f, 0.620482350165047f, 0.411016780608874f, -0.878843779367281f, -0.779673415191805f, 0.616508572699874f, 0.0750844738292273f, 0.341011338533919f, -0.553376665552953f, 0.277561087965059f, 0.527499935800293f, -0.489644680144407f, 0.514353996113782f, 0.229842524701725f, 0.139172928186734f, 0.793753206591897f, 0.835555341130211f, 0.794120687009671f, -0.0994745468343306f, 0.109098970584400f, 0.383123470993648f, 0.272549010931094f, 0.683070582699418f, 0.522823199313615f, 0.235903759158310,
-0.269490013000195f, -0.103775744391749f, -0.994083979953753f, 0.754983594207459f, 0.806308398378106f, -0.997543362839150f, -0.00396367603607373f, -0.873768378178592f, -0.755907732827809f, 0.703713206520365f, -0.0716773056166142f, 0.0792968663717508f, -0.113760825029016f, 0.828188140127672f, -0.103062543982628f, 0.0455017026983378f, 0.330658414568756f, -0.615810862221588f, 0.827890015477212f, -0.507551960954374f, -0.371044788092612f, 0.723489294741891f, 0.169072478802524f, 0.885612989356318f, -0.496475905980558f, 0.114400438991609f, 0.427961880327008f, -0.0456714004002505f, 0.0246660859589438f, 0.175616122301987f, -0.349777838484285f, -0.939474935533562f, -0.215061649130134f, 0.907049169335834f, -0.0553600192559760f, -0.982464152311714f, 0.405919915647442f, 0.755952405091542f, -0.695422520039876f, 0.373280568864688f, 0.483909023765611f, 0.784896384994620f, 0.978722132488262f, -0.113866140463085f, -0.630016943176703f, 0.512742627309861f, -0.829104067044703f, -0.240982431155520f, 0.0107361024967163f, -0.438682584788413f, 0.935730031472303f, -0.953447901200043f, -0.984218956474073f, -0.745077052885218f, -0.466232938128846f, 0.0326267564209573f, 0.303877586274065f, -0.199843777507458f, 0.674317529952029f, 0.448678903834397f, -0.681863209154081f, 0.273397524216090f, 0.193101955704959f, -0.342858479278718f, -0.485179713360910f, -0.586067050491890f, 0.393099777352274f, -0.982324485510343f, -0.852553426343700f, 0.773613825101220f, -0.590256032959421f, 0.837952413540589f, -0.643137731235821f, -0.311955662956384f, -0.888588599835619f, 0.304629859477166f, -0.810098957400030f, -0.534291626181040f, 0.878601703692302f, 0.362706441157764f, -0.254447668911795f, 0.604309282304246f, -0.977266419340276f, 0.250927873824064f, 0.549600558999971f, -0.796155833245480f, 0.226373301058549f, 0.0137578302483823f, 0.819708534464965f, 0.185662636424304f, -0.450456459548662f, 0.0953849597308440f, 0.736872088617975f, -0.582024306116842f, -0.0522261513001507f, 0.394348349710790f, -0.461023913227183f, 0.139996201153565f, -0.790168851966909f, 0.692544084408690f, -0.580603732841955f, -0.584540773580447f, -0.967062276813525f, -0.00886260208554912f, -0.0520831218167985f, -0.999614949922684f, -0.965820736077636f, 0.366390034326646f, 0.0323069925013668f, 0.164651515113853f, 0.300260003499445f, -0.340634856317630f, -0.238157231550037f, -0.291645957143165f, -0.773881882387456f, -0.144494053860223f, 0.660329619628580f, -0.626727996257997f, -0.994965090982706f, 0.161018019917379f, -0.327211572176153f, 0.0410991278573425f, 0.0123663905917732f, 0.747176159655312f, -0.485981637435718f, 0.00667961234248971f, 0.631625759154389f, -0.831294487064668f, 0.449606477050286f, 0.768845094514142f, 0.928354534843426f, 0.812647997969340f, 0.353418126917875f, -0.872184763557736f, -0.579130598386915f, -0.912928075675835f, -0.779484407508668f, 0.534916834944041f, 0.326353225230543f, 0.395431557674662f, -0.842103899863317f, 0.196590107332985f, -0.261317824893025f, 0.750190543523333f, -0.103409967857074f, -0.201452426430379f, -0.213633615009587f, 0.578822104214576f, -0.130809161238349f, -0.774608769872343f, -0.0222201705228122f, 0.126990738965544f, 0.785780586747108f, 0.0379484317527632f, 0.837140835706189f, -0.191007948387153f, 0.106781679021568f, 0.990298140861558f, 0.618337701073777f, 0.460255491901774f, 0.716379796730692f, -0.159421014009881f, -0.560212468621569f, -0.147263014783522f, -0.962301694075771f, -0.327702010262213f, -0.773959532468388f, 0.351239668535113f, -0.682281479449518f, 0.342188824054257f, -0.743039216419066f, 0.700710268270439f, 0.919651386092770f, 0.626343233048871f, -0.157189576636596f, 0.781882574006976f, 0.349953565654219f, 0.361235312853466f, 0.313242228422046f, 0.582185182102266f, 0.554504358491139f, 0.711217954194576f, 0.332473377627418f, 0.165078226255772f, -0.228349029389292f, 0.899730713958153f, 0.653894503448836f, -0.0452904440925501f, 0.0328806142413372f, 0.793701315832839f, -0.703826261467540f, -0.901648894320192f, -0.195631966969018f, -0.0470590812056508f, 0.487185699934959f, 0.175961644103331f, 0.818028721319245f, -0.224389104974946f, 0.901974203693823f, -0.153212477843726f, -0.472747796173897f, -0.587471692952684f, 0.452340198339707f, 0.996443894349412f, -0.849126217374502f, -0.403800337277983f, 0.923427876645159f, -0.0516037992113898f, -0.380335341989182f, -0.299914673109747f, 0.764492139190834f, 0.773463290027243f, 0.0175454601261817f, -0.400742340353541f, 0.912354892189422f, 0.999766609328281f, -0.521321752061712f, -0.365769506846305f, 0.477612405338644f, -0.0522578739905535f, -0.479259238587280f, 0.645161410912429f, -0.702546085166056f, 0.359736398041538f, 0.638130894056863f, 0.115633419893101f, -0.674410360620500f, -0.150824943737990f, -0.824854463897591f, -0.504410162129685f, 0.560317574021813f, -0.159611666752889f, 0.997647540626334f, 0.702777895178414f, -0.946494281691535f, -0.0109619562916898f, -0.383756482005404f, 0.872670066971334f, -0.453527506439184f, -0.635719199113957f, 0.932852122005178f, -0.800755479140234f, -0.225213334363716f, 0.251163542389519f, -0.598147625383133f, -0.155241293946661f, 0.967736510890644f, -0.0157250628103103f, 0.250570924071858f, 0.209749651169078f, -0.381016062687537f, -0.679300447230592f, 0.160197663113971f, -0.749803147200800f, 0.596917045783617f, -0.0878737681749431f, 0.642402180339789f, 0.261614973684270f, -0.111833224093973f, 0.300170844971678f, 0.317966800167647f, 0.0585375534708252f, -0.842709435910728f, 0.760207701069839f, -0.979366191145221f, 0.940703569377911f, 0.866488078693979f, 0.553497107695259f, 0.127260247084497f, 0.530106152060111f, 0.725171359852920f, 0.356742729430045f, -0.209841680046178f, -0.164239817187855f, -0.888858150931758f, 0.0367561852378047f, 0.803496113779956f, -0.594927045375575f, -0.00347281985657166f, 0.114118941713783f, -0.427864462568672f, 0.719021423892768f, 0.335845790828654f, 0.0207216235296064f, -0.523146933862102f, -0.145001077781793f, 0.490566784879983f, 0.461904660734682f, -0.897010089735077f, -0.895737903861849f, 0.343397505472310f, -0.684377591381862f, -0.0154016881290400f, -0.462987614871549f, 0.884045010701589f, 0.192617174725234f, 0.226497290324550f, -0.788151335932529f, -0.190538526746651f, -0.556614046330326f, -0.139480186854974f, 0.196785300148418f, 0.978844132512627f, -0.290726060479808f, -0.591813978495167f, -0.0769033757443105f, -0.467044929381376f, 0.171585053083057f, 0.408215527269010f, -0.818706013465989f, -0.328144984930982f, 0.790275356337217f, -0.977491163139178f, -0.979679268318504f, -0.524875121608236f, -0.263859024168277f, 0.0180787743488171f, -0.984390626106750f, 0.952274619010224f, -0.851400664579601f, 0.692959439369046f, -0.150312001943653f, 0.712066554169562f, -0.492336226254660f, -0.453559897031351f, -0.159679763180474f, 0.745834647687870f, -0.725963425297178f, -0.720341794596050f, 0.370674334928492f, -0.845974926208293f, -0.00448769398027360f, -0.595973105115042f, 0.967372249596385f, 0.512949503724102f, 0.889619262804735f, 0.990718232652913f, -0.662246751886904f, 0.333846293708563f, -0.423114421367372f, 0.549637439543149f, -0.987876053136374f, -0.782714958794276f, 0.294868983681807f, 0.931284560597614f, 0.445522387300861f, -0.388400162488578f, -0.182673246109423f, -0.773488958971573f, 0.438788569593725f, 0.578106509978236f, -0.373449127435319f, -0.301996528814967f, -0.227124771031239f, 0.700176189695036f, -0.910948938567526f, 0.733412403327578f, 0.486154072292544f, -0.974058632864456f, 0.216693355653246f, 0.147564301397678f, -0.715192277853558f, -0.366996833259925f, 0.568909126406069f, -0.0810069456450131f, -0.371253841044151f, 0.254736918036059f, -0.868966383080701f, 0.190312518076662f, 0.457253801337437f, 0.941043431633233f, -0.297470749600241f, 0.244270515950156f, -0.240122562119888f, -0.766384662307300f, 0.765045432900429f, -0.608250739173787f, -0.733052557932594f, -0.268433000443065f, 0.733598123424154f, -0.0550005774741753f, 0.273893221740822f, -0.659641650983149f, 0.967032725204337f, 0.390126626361090f, 0.518740746381756f, -0.859387560527806f, 0.554117289841284f, 0.648904904654236f, -0.755880975555381f, 0.834231592524942f, -0.137512395743275f, 0.0477027353535724f, -0.880364563062979f, 0.458763614093086f, 0.650036413308116f, 0.496385905878033f, -0.418537115548864f, -0.565561960782851f, -0.227941684691245f, -0.165031891659812f, 0.204464989908300f, -0.688093624763916f, -0.678874848552394f, 0.813764873880514f, -0.561723359541237f, -0.575805702297063f, -0.288097000970518f, 0.950119107184838f, 0.709879842972902f, 0.730067219897393f, 0.710813066057284f, -0.192333836978130f, -0.190446300563246f, 0.872679304648751f, 0.134143163657763f, -0.979443835407234f, -0.103872104041761f, -0.0568328979324004f, -0.863020133862081f, -0.0257801722427251f, -0.577962771617033f, -0.0500056799801032f, 0.191817418291914f, -0.799853775410853f, -0.110019424741421f, 0.840753817223395f, 0.355588322976119f, 0.274501278628024f, 0.757538306972136f, 0.771547320156202f, 0.0394143752709530f, 0.120744072764658f, 0.324337882930581f, -0.380086709776951f, -0.772025774284869f, 0.473986846199588f, 0.703247561676381f, 0.734667480205300f, -0.594290184210087f, 0.760158653782445f, 0.624553744314883f, -0.941053266957965f, -0.165913770936962f, -0.0497972870738055f, -0.0435608680908517f, -0.663165366083943f, -0.570972482385751f, 0.427845034528880f, 0.0897903148165149f, -0.481825010950428f, -0.0901127105939594f, 0.887770435656611f, 0.770985476674623f, 0.00966158758316293f, -0.331059327378268f, -0.286033645163736f, -0.0698945910210471f, 0.834392309773299f, 0.875537383319608f, -0.657919190548359f, 0.583890957562885f, -0.418481077359384f, -0.282242397022386f, 0.864577023994874f, -0.898367126143440f, 0.815804441243808f, 0.616061408588373f, 0.132365642864798f, -0.221099752471970f, -0.852722283680675f, -0.269499596712950f, 0.360828136129415f, -0.120022743070141f, -0.0354652134632905f, -0.718389836602256f, 0.973490047219112f, -0.201775047168341f, 0.348769511760972f, -0.338750368577880f, -0.269769414088757f, 0.498910931428472f, -0.787648791515347f, 0.508408064858444f, -0.904215976374529f, -0.778575029821227f, -0.662889546847757f, -0.787503064261069f, -0.915166838630178f, -0.415784802770356f, 0.731806835017609f, -0.903922155472207f, 0.0872811033112211f, -0.452516774501827f, 0.577942533813694f, -0.200909337658770f, 0.866167939661793f, 0.982552542055944f, -0.332277333696961f, 0.201673960342839,
0.881239812364993f, -0.0293753746942893f, 0.0967170348490725f, -0.765573023404242f, -0.179225339525953f, -0.931530757069740f, -0.702596334762137f, 0.439106079307245f, -0.469364154277323f, 0.211063395888038f, -0.245858633045693f, 0.936376071219385f, 0.0334087380010875f, 0.0765265939183459f, 0.417091701258078f, 0.962467059286170f, -0.180698008768999f, -0.129816441691123f, -0.833694435146788f, -0.800582099046532f, 0.736376297618233f, 0.0164704176688124f, 0.207462305741760f, 0.300555292898496f, 0.777154212278295f, -0.0804533056660695f, -0.279940128908185f, 0.203101811030871f, 0.447496959357837f, 0.508353359025257f, 0.644333822521829f, 0.897259297488483f, -0.675785952117501f, 0.149337263319588f, 0.350953290584184f, 0.600296681944338f, -0.606098182955297f, -0.418312129297725f, 0.792551232171214f, -0.944025948110651f, -0.923106441737020f, 0.508989820072736f, 0.101554011154237f, -0.799369609980037f, -0.229001813644938f, 0.196367996268564f, -0.634078446275840f, 0.267446716753553f, 0.943765754688567f, 0.329924442019441f, -0.898235312442524f, 0.563592978494850f, -0.976934293161001f, -0.609744819901837f, 0.498989633313589f, -0.105680058480959f, -0.400730747241191f, 0.264919109340783f, -0.313066735594123f, -0.465399967597728f, -0.425123918113080f, -0.609514085808810f, 0.916560800692384f, 0.0173757138934230f, 0.147814399202503f, 0.594152503614559f, -0.145681097751433f, -0.427232299718493f, 0.233460382614713f, 0.337361272635241f, 0.376106438004541f, 0.900277274651600f, 0.424547631957395f, -0.710790444715071f, 0.0846761090154495f, -0.0122707338404220f, 0.119989812955904f, -0.239774389963524f, -0.692300891031819f, -0.735109129583214f, 0.802276300301071f, 0.348982047806247f, 0.916302084278941f, -0.0838164783829127f, -0.989134997097880f, 0.832909602224562f, -0.701363449605445f, -0.150487976031971f, -0.728594035984111f, -0.144393031996783f, -0.458856761770637f, 0.733295441303064f, -0.405608670768629f, 0.522871610912813f, 0.468223399458939f, -0.575139530810903f, -0.241684287862418f, -0.499140599234906f, -0.395586476697394f, 0.692745485195348f, -0.125142235859546f, -0.342212246193052f, 0.133841188490164f, -0.539478395228865f, -0.887973984329817f, -0.474033882236453f, -0.837114132429830f, 0.773392302912611f, 0.117697651876253f, -0.461595011213406f, -0.528669601602068f, -0.957799577987062f, -0.468654423525192f, -0.0602288998398475f, 0.154553704272891f, -0.422854231304259f, -0.496136532114270f, -0.348154983723668f, 0.0576478341707483f, 0.542088962901856f, -0.0465812136931592f, -0.280128217727361f, -0.900695482510248f, 0.525110685457899f, -0.957266165874283f, 0.136490670826643f, -0.213221811269364f, 0.690040133288898f, 0.269408771473479f, -0.0488994830172422f, -0.837526616586426f, -0.289127052660601f, 0.149325279006459f, -0.694169700971401f, -0.0230547571616897f, -0.368313297034846f, 0.344434270521740f, 0.859135365902404f, 0.839336654691204f, -0.511783987355355f, -0.0349625753049687f, 0.935857929664427f, 0.820032045433520f, -0.0394079346656324f, -0.656352913407746f, -0.874383371678169f, -0.425836335156061f, 0.208600154889275f, -0.135596548598733f, 0.566430757256762f, 0.820840891306264f, 0.735746624790780f, -0.765482927015804f, -0.0195537720748045f, 0.606216172027628f, 0.436027839798869f, -0.609233580289002f, -0.963547951222316f, -0.575271468261977f, 0.692873344771925f, 0.143031668657597f, 0.890157114774225f, 0.762299295692265f, 0.653618249618643f, -0.957258626549595f, 0.521895225378123f, -0.607922211531407f, -0.956795748110572f, 0.477633684273092f, 0.794301967670603f, 0.139753218894595f, 0.371726372555490f, -0.804791987531745f, 0.837080126047059f, -0.440992020192054f, 0.584986017638085f, 0.950442046050057f, 0.613109120495913f, 0.633948971396891f, -0.581246845000116f, 0.730290176291093f, 0.599119212595240f, 0.120096101936515f, -0.144169383323758f, 0.930776406826440f, -0.0209712926465206f, 0.572995665695966f, 0.924623298379120f, -0.751832867985678f, 0.630196806059302f, 0.506634179395662f, 0.0388997263873157f, -0.311041196366299f, -0.729049093325017f, -0.918815504666740f, -0.103935429478766f, -0.000623544124330300f, 0.102880227280474f, -0.563637096166535f, -0.332148269587814f, 0.472114131256244f, 0.295717126494164f, 0.246944592105312f, -0.713191555660498f, 0.160410320426559f, 0.110992936470077f, 0.213877527744528f, 0.541660996543375f, -0.872405734998843f, 0.388515073094269f, -0.840811647524440f, -0.968008592072007f, 0.669947948420772f, -0.122943215855172f, 0.565929115911552f, -0.695408966310186f, 0.361296950635219f, 0.574282481983669f, 0.0877180513263536f, -0.694316083550519f, 0.327696487191071f, 0.289746985823208f, -0.241476327174879f, 0.605084742574250f, 0.0929272338220821f, -0.391399761658219f, -0.612928183827531f, 0.0471987261466311f, 0.157388702609590f, 0.575695018001234f, 0.450453491026024f, 0.876623108212541f, -0.456500163180038f, 0.436901006801809f, 0.796734433864345f, 0.771008396172517f, -0.784740610155705f, 0.405172719255834f, 0.958393667559228f, 0.787380105147761f, -0.262826016234054f, 0.773327117333271f, 0.482142068916266f, -0.461607549022954f, -0.153993688218026f, -0.129280134980317f, 0.901812622560630f, -0.111520793491644f, -0.0973214524989203f, -0.293695817178366f, -0.190045093887485f, -0.204792515844396f, 0.501086384719391f, 0.755953359112033f, -0.425886872154604f, -0.0883029298084141f, 0.763071371252921f, -0.556289447935984f, 0.577370462369201f, 0.0480599614417476f, -0.794423686623353f, 0.756645959967545f, 0.570538730848462f, 0.872575422156333f, -0.443572567528656f, -0.0487937634747691f, 0.283986553648095f, -0.170910821134099f, -0.329867000423004f, -0.982322841409943f, 0.555344201026651f, -0.351964643393940f, 0.776172688776518f, -0.148102477734717f, 0.889532618676503f, -0.310979434517253f, 0.711839903052208f, -0.646385596147085f, 0.145592596381502f, 0.233949589173221f, -0.825471565980294f, -0.370248763132654f, -0.777194557275684f, -0.224658064754195f, 0.263281286751478f, 0.849661910468068f, 0.271261490445121f, -0.915885420717958f, -0.947144520818678f, 0.227960459606299f, 0.784463828083640f, 0.995882406349565f, -0.987273766396493f, 0.0792453274840108f, -0.788403526960056f, -0.619975942121645f, 0.801181796307713f, 0.967884377026145f, -0.781223064263388f, -0.300716486479280f, 0.994748932974184f, -0.200152360574411f, -0.101898131541608f, 0.542914585925881f, 0.407729967031792f, -0.105215843903154f, 0.638066037611924f, -0.563777780161298f, 0.134189395993685f, -0.503320561486155f, -0.0379170306314711f, 0.723638115686875f, 0.747948383928228f, 0.928239905995551f, -0.736883772878758f, 0.892242913709735f, 0.468998243295705f, -0.224406388545097f, 0.758754382878863f, 0.994739001052496f, -0.749837906573089f, -0.938777322178786f, -0.619168635741936f, 0.827875717654585f, 0.294033159230782f, -0.372766318349126f, -0.292752124932124f, 0.396629951868878f, -0.986760927173237f, -0.0841834195975009f, 0.999760803826313f, 0.0142305924173638f, -0.820393900206961f, 0.409972278573230f, 0.227315924377402f, -0.641500351639361f, -0.470788010535406f, -0.486171076557593f, -0.758140688442947f, -0.971539708794928f, -0.949039718833189f, -0.146844988902767f, -0.0183627478820223f, 0.402918762093981f, 0.0620266698060286f, -0.182527786403967f, -0.374395326540229f, 0.566584207940253f, 0.879546558847970f, 0.853360173786566f, -0.515321950652696f, 0.511692631053674f, 0.342152084355850f, 0.374686420595610f, -0.794372980760555f, -0.648670375991101f, 0.761192158420166f, 0.223791993225057f, -0.342720055148453f, 0.965612513218950f, -0.796193009647904f, 0.215057114709867f, -0.0459498239576994f, 0.871047701509015f, 0.664672380241520f, -0.546301701630944f, -0.939910946986200f, -0.213195706858966f, 0.559543622118596f, -0.255844807516886f, 0.509576048776352f, -0.699005089750431f, -0.520317652140772f, -0.924306703712950f, -0.923814193467638f, 0.868401299001930f, -0.571229497763863f, 0.984740691690212f, -0.911782692220985f, -0.265295471266664f, 0.0479848731515942f, -0.195328058836883f, 0.758281465939343f, -0.418177229854869f, -0.263323557662932f, 0.0230762644115943f, 0.382605016442608f, -0.576209059863238f, -0.739785100410209f, 0.0956412509899256f, 0.0369702493097637f, 0.0738922616872486f, 0.589371657036664f, 0.548586250623500f, 0.996096574632666f, -0.574178408335425f, -0.827059309028347f, 0.600283403682961f, -0.0651062813338117f, 0.985857002071398f, 0.982700721670305f, 0.777628710286989f, -0.139415722014730f, 0.951156387462424f, 0.806391217144736f, 0.135433009714206f, 0.252388414319270f, 0.485541324740928f, 0.270688932431637f, 0.892850103229909f, 0.440168171407923f, 0.515384398158669f, 0.600884162546465f, 0.947986221531091f, 0.339440884303404f, 0.403857490690436f, -0.937015609644647f, 0.729529495316627f, -0.389601866986821f, -0.420712615666380f, -0.763003723744745f, -0.0619534667970105f, 0.486654476027536f, -0.943536854881494f, 0.471171699317719f, 0.996886209046820f, -0.945316270673373f, 0.230772742042993f, -0.621222111022648f, 0.838934157721328f, 0.124035987915113f, 0.737576768711407f, -0.217898078842006f, 0.0429859145211120f, 0.223685413947773f, 0.820073956039170f, -0.378381145423743f, -0.335672684173821f, 0.649791267584388f, -0.457253860252872f, -0.664776842833046f, 0.150429615666837f, 0.974812973893170f, 0.00119972362050369f, 0.140744912838368f, -0.252632269055503f, -0.124205752907507f, -0.383194456927254f, -0.356455432479067f, 0.0694989880525767f, 0.188230048541949f, -0.854592697407303f, -0.902559387772971f, 0.454054169179423f, 0.534684767654295f, 0.806837289706952f, 0.274203715752641f, -0.765433763984323f, 0.459365005291520f, -0.896797218412250f, 0.382900474341852f, 0.169400421233177f, -0.184111368111075f, 0.0323514487432812f, 0.621015577938758f, 0.139872518806323f, 0.480965263781330f, 0.0649386999855643f, 0.815365754221614f, 0.761990264098834f, -0.0927412249348933f, -0.580853742457387f, 0.211615321410605f, 0.165159968106305f, 0.305515629345863f, 0.725748395743965f, -0.667649812347274f, -0.621843189978885f, -0.939317191264789f, -0.197108718554958f, 0.902152006895939f, -0.889744652803018f, 0.667113256888905f, 0.929471703711725f, 0.660025836042506f, -0.0712223078913006f, 0.416152292126436f, -0.602223852277700f, -0.828462878627106f, -0.956915163338265f, 0.298196541541469f, -0.933863927954050f, -0.198745190221695f, 0.749101206471011f, -0.922366396086261f, 0.769953026855636f, 0.971459582749177f, -0.226637139032289f, -0.593509265485619f, -0.635649447577657,
-0.443127775644156f, 0.350464269654307f, 0.379979516655134f, 0.896282784801247f, 0.00871209446887344f, 0.401818712823609f, 0.815422566258939f, 0.215868289995843f, 0.682217845700443f, 0.508819667108007f, -0.988484263336122f, 0.216656890144568f, -0.185777888700071f, 0.522106353117928f, 0.894211314619113f, -0.779300881699217f, 0.137801937535128f, -0.818740955579722f, 0.637214461095055f, 0.187867696634722f, 0.184985729971243f, 0.315323389557324f, -0.0312525033775366f, 0.498559120407008f, 0.855778208118391f, 0.936851170962385f, -0.0524308158818188f, 0.257087262622978f, 0.816141818246927f, -0.147192803443011f, 0.194545158383538f, -0.655428449892669f, -0.650441844539509f, 0.536015423540886f, 0.0250060573607953f, -0.863380305825989f, 0.0605420782823460f, -0.963662464088496f, 0.689136717877590f, -0.929664162821947f, -0.327349437742288f, 0.713122240487331f, 0.765587094162777f, -0.314350325341316f, 0.409992519686522f, 0.753377832105546f, -0.756848529995586f, 0.760787899507869f, 0.512213162407276f, -0.674820237484644f, 0.560776719592082f, -0.874905891603855f, 0.925202682923872f, -0.907405002733482f, -0.575836335118172f, -0.248173888600965f, -0.187923239740639f, 0.230951002247789f, -0.540190666146588f, 0.390890663320481f, -0.705511708249712f, 0.0980457138183717f, 0.879979753648798f, -0.378326046226794f, -0.645363625221967f, 0.883365508962968f, 0.728720763588748f, -0.191571576393619f, -0.941989254130187f, 0.944312154950866f, -0.367184985473008f, -0.974124559264444f, -0.579946765132286f, 0.509825236656578f, 0.952047194261820f, -0.0955445631918663f, -0.00500764501201401f, -0.00111382665477655f, -0.0404281661495578f, -0.265706359102834f, 0.865881843285797f, -0.947915521623861f, -0.820337973623839f, 0.0843747524022067f, -0.948599514028391f, -0.464018526769358f, 0.600790429663803f, -0.0779017384430381f, 0.756949801920938f, -0.955436496929340f, -0.553346424499498f, -0.401256107066610f, 0.569624108543687f, 0.179455179577041f, -0.189386842296675f, -0.467166492259358f, 0.367644583467601f, -0.722338735126514f, 0.863903729827081f, 0.0631027352569811f, -0.982269235503679f, -0.837788470642698f, 0.421730643738386f, -0.671745211565315f, 0.858467932275763f, -0.745298219348761f, -0.659594977600028f, 0.403238381269873f, 0.951987904652099f, 0.228887404582426f, -0.331665752024408f, 0.794789885033899f, 0.669978127515269f, 0.977583870328654f, -0.346398989178462f, 0.692053246433782f, -0.159407706019695f, 0.710808563527500f, -0.555701359319642f, 0.625665798239905f, -0.711048329414687f, -0.672431532474912f, -0.474897384314332f, -0.196250611816064f, 0.902140605659856f, -0.459732035217428f, 0.651412290305649f, -0.686137550630920f, -0.803228611526547f, 0.371120664039117f, 0.289869860968561f, -0.720979161638185f, -0.0940498575417996f, 0.185025844935128f, 0.401524077274769f, 0.811721346556136f, 0.224659861626089f, 0.106438807548742f, -0.117458956991326f, -0.407361487623449f, 0.683891165426988f, -0.216582410631386f, 0.710644530504861f, 0.867797453793643f, 0.626683550176870f, 0.115061097783331f, 0.976742668387085f, 0.250700864990527f, 0.272723539841862f, 0.159923684669346f, 0.167713264013185f, -0.445764377935606f, -0.489538472614810f, 0.227880894824940f, 0.670702116476237f, 0.610361511284318f, 0.503801949624464f, -0.687816091694902f, -0.0413765153535617f, 0.155769004545734f, 0.921910233366689f, -0.467299226678025f, -0.991984541712805f, -0.527009262324220f, 0.248157897392517f, 0.661145853979517f, -0.975947426744844f, -0.242453990684693f, -0.277956284573619f, 0.162010437415540f, 0.889456199489152f, -0.171259539670729f, -0.0636124576727060f, 0.311318764402696f, -0.227771282875219f, -0.567702050585727f, -0.132881625149059f, 0.870846950418812f, 0.440078398779761f, -0.0908818839265000f, 0.410077545060762f, 0.917678125288724f, 0.975295290129489f, 0.736514272579886f, 0.653896379317074f, -0.166512942888681f, -0.218665383726096f, -0.0688642360506688f, -0.596589868100824f, -0.180873413844075f, 0.229002598511067f, -0.647630976455599f, 0.722615884501717f, 0.760194030884127f, 0.253262836539679f, 0.0734191803957118f, -0.941427952376035f, 0.224118866807764f, 0.634990976599086f, 0.538622500570355f, -0.591487367587299f, 0.829253069890529f, 0.426659996899884f, -0.562435396124737f, 0.924178169394878f, -0.693964899988321f, -0.520472617448914f, 0.845157115508053f, 0.162984246343684f, -0.212032053476592f, 0.0482566706558292f, 0.820584028875367f, 0.676120066619505f, 0.590174358812695f, -0.457289938956925f, -0.351282540371674f, 0.322162683499620f, -0.683726196205246f, -0.279636659553935f, -0.186133028676429f, 0.965481755833750f, -0.0550172560314044f, -0.437844829991532f, -0.448670532146325f, -0.438916826946834f, 0.830205353164842f, -0.0125988502002286f, 0.733716462327519f, 0.870000673588185f, -0.189915082276716f, -0.676269331249200f, -0.336432931956768f, -0.288892891213265f, -0.912569275291884f, 0.509853767908707f, -0.658452317958678f, -0.562848133961047f, -0.102082581799095f, 0.904062026055565f, 0.473339990381854f, 0.210234896873676f, -0.0884007008398613f, 0.720872020499257f, 0.538315255331760f, -0.884485227439286f, 0.160844002639634f, 0.625863524205804f, -0.947487159926400f, 0.362643826956149f, -0.189913270725334f, -0.110428721523612f, -0.666510263156819f, -0.214827103263521f, 0.912669747474334f, -0.973896103049543f, 0.665373714127588f, 0.148135031012834f, 0.126524689644449f, 0.00283763548841764f, 0.312700495893193f, 0.579520771033243f, 0.677583023476560f, -0.779567427807191f, 0.0694994546110597f, -0.298762697062437f, 0.655210050716681f, 0.435909078048151f, 0.322095567178671f, 0.764827170021089f, -0.713736794113842f, 0.992844460358584f, -0.735915506109616f, 0.280204875392391f, 0.584446532772711f, 0.796955505835788f, 0.742508124239176f, 0.0785523490091065f, -0.562359397016753f, 0.874448473576734f, -0.794251927759664f, -0.658767152705445f, 0.120015806343044f, 0.662372174700575f, -0.719334975225296f, -0.663474261357014f, -0.637663874969148f, 0.706137632813821f, 0.734790814693796f, -0.449118755654663f, -0.758125670003823f, 0.719059339327447f, -0.228679956701166f, -0.0782671261690160f, 0.637830522744746f, -0.178696376536345f, -0.848273935253246f, 0.840882430630200f, 0.977813953976437f, 0.565474986185913f, -0.807314895274907f, -0.100534840844589f, -0.436186956483089f, 0.854663592026441f, -0.547576146320248f, -0.621784076386717f, 0.688687549426321f, -0.688962085987764f, -0.998914668418794f, 0.751493418398842f, -0.203018738091861f, -0.881317097659280f, -0.422480898609404f, -0.321074554557095f, -0.759379357125740f, -0.806503084491033f, -0.496837315822352f, 0.217087355208111f, -0.776801484423500f, -0.445747498145286f, 0.710204776554782f, 0.274276964033182f, 0.650397224484409f, -0.709395921248168f, 0.862663541330686f, -0.946166202558813f, 0.826638502366159f, -0.450587332736099f, -0.808257632193740f, -0.414360554482101f, -0.471118187583276f, 0.981592919290155f, 0.192794908371370f, -0.314979855997427f, 0.722518962804398f, -0.795914669179603f, 0.121447532644509f, 0.0446893237592363f, 0.651720955387594f, 0.897128141094619f, 0.283834144643742f, 0.369570391543943f, -0.163784005163726f, -0.799144231493300f, 0.338136741961422f, 0.795991730702685f, 0.601735561139351f, -0.556654767533027f, 0.907044495725416f, -0.374604065784494f, 0.814308532452677f, -0.254295412850351f, 0.443103437041340f, -0.0218296619602199f, 0.826728672505738f, 0.773205771668962f, 0.171909022893217f, 0.497670481959597f, 0.954178712898056f, 0.0840098577761919f, -0.705861127301893f, 0.145663865959608f, -0.436204975766037f, 0.479359595998989f, -0.719493824988072f, -0.523146212355768f, -0.917822711649927f, -0.610003715217602f, -0.192266667446473f, -0.377507163265653f, -0.250419291332051f, 0.873627391381727f, 0.922899703740095f, -0.902411671519496f, 0.285830821349708f, -0.577368595723736f, -0.598296174995687f, -0.0152478418690674f, 0.503725955636280f, 0.946501779740920f, 0.261108140547963f, 0.206258978593364f, -0.887022338332430f, 0.989187042741485f, 0.461764104690670f, 0.305280284664753f, 0.243972878436235f, -0.573704516784209f, 0.111805651228880f, -0.373590027525854f, 0.574564836347642f, -0.712884790778729f, -0.0570130063179222f, 0.244209425500712f, -0.717492787619277f, -0.476920207759357f, -0.444169983027413f, -0.254851417015366f, -0.505678630542571f, -0.953549022234155f, -0.0316841901798541f, 0.198256779602804f, 0.151938229162240f, -0.0259028503944394f, -0.799645893003010f, -0.889308912372168f, 0.339221517072804f, 0.904784479404768f, -0.367330903112591f, 0.866281762131661f, 0.112765232993802f, -0.0852946527317187f, -0.283538359072154f, -0.734951426632046f, 0.502970854898684f, -0.541434927857400f, 0.881496286285600f, -0.227404039639917f, -0.636983936776183f, -0.0799774217214970f, -0.833780310813424f, -0.222787370954425f, 0.433143783060434f, 0.0953330524947187f, 0.965400264971588f, 0.308927931247299f, 0.344316393259575f, 0.122880788538352f, -0.898509922382301f, -0.187062523329053f, 0.705352247460646f, -0.817811000761718f, 0.303714513401701f, 0.714863075518907f, -0.00862372607283035f, -0.842715848975590f, 0.816504077307885f, 0.924594085591125f, 0.334618732730041f, -0.212414743241377f, -0.758289625449925f, 0.586405661412351f, 0.909247363444287f, -0.800422609846793f, 0.397430897916299f, -0.408827454151232f, -0.411913213123543f, -0.602703152770135f, -0.893591462026327f, 0.417648762458765f, -0.766362696266534f, -0.166060103951854f, 0.883234167729589f, -0.0741908774062401f, 0.113912882075078f, -0.268248292164738f, -0.825585719915457f, 0.885446166477969f, -0.996523379251940f, -0.000841720632677401f, 0.940286529247477f, -0.528330498750176f, 0.0938880690147421f, -0.966296878893937f, 0.891956527154360f, -0.483384605653306f, 0.257210342748458f, -0.820220338820906f, 0.363913841603935f, 0.0364865250689275f, 0.0619156958713947f, -0.645447937080250f, 0.548279343062761f, -0.289526240449473f, -0.506780094171335f, -0.901771170107367f, -0.437874075223813f, 0.748512212111141f, -0.529884246718074f, 0.924062132675193f, -0.365432219122282f, -0.263296006595835f, -0.927083881647913f, -0.192737974697553f, -0.450051159199964f, -0.543528645806642f, 0.834976909049276f, -0.426975046433596f, -0.361056079272416f, 0.883880063360531f, 0.680380429911630f, -0.553642515320953f, 0.548847108935282f, -0.357430246936948f, 0.210445016993628f, 0.949511601115471f, -0.611278947360487f, 0.344744934459962f, 0.0684247970496175f, -0.877154656281116f, -0.521992702610556,
-0.0303764312006813f, -0.647220068176984f, 0.693175336224119f, -0.0955602614554496f, -0.765579758912278f, -0.821318118938906f, -0.220936603794347f, 0.159013709512021f, 0.0222743973539492f, 0.569438412513281f, 0.896083437551563f, 0.973699071868637f, -0.403438951991928f, -0.976931032127622f, -0.0720613180573018f, 0.0788813367661694f, -0.430781354548607f, 0.580378296309349f, -0.175446689199481f, -0.256743557012462f, -0.696667845393283f, 0.870473046831235f, 0.146660713923108f, 0.277741407197705f, 0.502075064404417f, 0.396530064046844f, -0.000209092342246420f, -0.977003947244262f, 0.451457326960000f, 0.420509664462095f, -0.0826395067671402f, 0.461120688156973f, 0.786867285802415f, 0.429254905841222f, 0.894426863739026f, -0.670297281923597f, -0.833650409296060f, -0.908588009702110f, 0.516311115539149f, 0.975234001829324f, -0.532953533466378f, 0.775291582519158f, -0.0136022600428900f, 0.654817093112596f, 0.363512141498233f, 0.624779024037534f, 0.0237004661473674f, -0.172570506046968f, 0.401807838319043f, 0.997391258152958f, -0.553969395939123f, -0.415425175833161f, -0.758032843655304f, -0.482766088920005f, 0.637574309072414f, -0.729000055114342f, 0.699851428676091f, -0.827508053421131f, 0.900655803848482f, -0.431149800814228f, 0.0369409101983413f, -0.378608101457895f, 0.237564147838841f, 0.533020461112441f, -0.280269627508005f, -0.864065787343603f, -0.0381481642453043f, -0.566886547530062f, 0.539727700361167f, 0.166859339425035f, 0.850080295054718f, 0.384690146030125f, -0.384995288415294f, 0.303656036600558f, -0.580297619022502f, 0.0649069482840878f, -0.162922327392773f, -0.235019427063355f, -0.265468718118809f, -0.121827312187455f, 0.0416628805824146f, 0.343481543012411f, -0.251429566892972f, -0.868100204320718f, -0.802636407512128f, -0.549547579028752f, -0.570017983863503f, -0.853634311513627f, -0.564570567173235f, 0.955944215494794f, -0.0930750790375956f, -0.160319122401953f, -0.640886790354213f, 0.798634607857513f, 0.503051518023559f, 0.765247226736789f, 0.909476811674882f, 0.677590253114963f, -0.110641683440517f, -0.336445241915220f, -0.684064840782028f, 0.962285048920031f, 0.883303701653897f, 0.981819291389659f, -0.597290928759656f, 0.215792997443025f, -0.847656608719347f, 0.679887992445640f, 0.299901700372808f, -0.677306526467426f, -0.348340058872692f, 0.651490451411335f, -0.133387041637395f, 0.718311240322040f, 0.0869279817052975f, 0.155413706090559f, -0.869119988858735f, -0.566773040844476f, -0.0513826414151206f, -0.368087669232071f, -0.978175512831125f, -0.229213501073727f, 0.344608572405871f, -0.663307667219997f, 0.437238632879575f, 0.00205230197288353f, -0.0897076092856746f, 0.834529513214144f, 0.131872357342232f, 0.113081940417244f, -0.418620232731326f, -0.317993033651213f, -0.740303025960662f, 0.423423655701288f, -0.300833032468860f, -0.458960388256530f, 0.692670405117589f, -0.559944357561921f, 0.0168623577148430f, 0.568661331088367f, -0.385055363002398f, -0.356055436463140f, -0.794446573681063f, 0.908870080953069f, -0.295500656666577f, 0.800625150733729f, 0.206307902542489f, 0.729591183391974f, -0.0655746333947396f, -0.261707022686154f, -0.802380330579914f, 0.0812359238243023f, -0.00528231140765212f, -0.725740453383981f, 0.919076065030463f, -0.896497189839174f, 0.861919731820265f, -0.804273875755869f, 0.230339021648310f, 0.296779613186519f, -0.349872572510143f, -0.270230381483447f, 0.0368924200249658f, 0.581340248642417f, 0.943620537648739f, 0.715012058065301f, 0.528414993233909f, 0.695917111744314f, -0.634354198968852f, -0.483786223099716f, 0.565405035681248f, -0.530076864213017f, 0.363019522302994f, -0.825556544716473f, 0.891096876998683f, -0.990692760548295f, -0.450641405862313f, -0.597008073985341f, -0.464377765418678f, -0.942926913464693f, -0.871399725569805f, 0.232335933943403f, 0.858786794807406f, -0.528589179815518f, -0.324757177062634f, 0.595880088750788f, -0.976574570427974f, -0.423824220654658f, -0.832990206908489f, 0.198704682807118f, -0.168244652325292f, 0.843066822744011f, 0.0912498543932607f, 0.485570815146582f, -0.104653316420662f, -0.623461298489716f, -0.807713596811018f, 0.737782734425857f, 0.456364368166532f, -0.430703367862900f, -0.188953991637209f, -0.827984282695373f, 0.0246267653665548f, 0.891225605267640f, 0.910600867999638f, 0.345236086687552f, -0.600682365520065f, 0.833182106437698f, 0.213749250288017f, -0.0866339102562885f, -0.618385082289017f, 0.859527120927500f, 0.749978780964161f, -0.334770513867011f, 0.242140166670949f, -0.196268320459958f, 0.611789869603675f, 0.655057159657307f, -0.603759576722096f, 0.614654509385217f, 0.144145218488192f, 0.959930150756613f, 0.485009777784726f, -0.564230295010912f, -0.404716165405314f, 0.0442672151313601f, 0.929486639423805f, 0.409386317338224f, 0.527053707674182f, 0.899087569745327f, -0.933259779365388f, 0.265159475034860f, -0.858300862890810f, -0.870994388031662f, 0.354868177430506f, 0.00956840260511749f, 0.429740959889133f, 0.649668163567379f, -0.744532888765288f, -0.967499901569196f, 0.556703631745254f, 0.535130550118618f, -0.639502350153040f, -0.604586469532735f, 0.0799683564329623f, -0.156074786599444f, -0.348308700325411f, 0.217829052228100f, 0.545642400171123f, -0.303317700019152f, -0.473220675222451f, -0.239688108834945f, 0.0998500862725149f, -0.962734081833842f, 0.870743993144299f, 0.464578557934316f, 0.184511089576136f, 0.559729843314504f, 0.0702052363354577f, 0.632714874625648f, 0.212930743289312f, -0.454606863365109f, -0.592679055778218f, 0.287649993384466f, -0.457293694071368f, -0.423493046785686f, -0.0674763327876298f, 0.242131064298176f, 0.488581911885965f, -0.464567743213882f, -0.387515661812354f, -0.914585596974616f, -0.255803162310627f, 0.941267268311980f, 0.690278917089395f, 0.302397314111962f, -0.178461434689705f, -0.949279941481428f, 0.160440202901122f, -0.970582196769486f, -0.0119478205074164f, -0.206440255898676f, 0.221640403444713f, -0.819801447827624f, 0.263614394802488f, 0.616376195532700f, -0.596859494305351f, -0.118659509995453f, 0.458168997595326f, -0.0400474705134108f, 0.934465050133603f, -0.852936731989621f, 0.0191637795580570f, 0.298534793677081f, -0.857491630206749f, -0.0141198383157879f, -0.365027350962024f, 0.450964838023674f, 0.351383095290905f, -0.387039947149600f, -0.983994933095116f, 0.610531582220017f, -0.0446025524732094f, 0.216718014780746f, -0.676819246943449f, 0.0385619292249610f, 0.192482456707739f, -0.288809653393521f, 0.241774557042318f, -0.444638770943313f, 0.535319194413803f, 0.374773141606987f, 0.186364279454450f, 0.0701814972821988f, -0.452753172654203f, -0.350918291268194f, -0.332963791049667f, 0.179301863965318f, 0.954101654404080f, -0.687960044344130f, 0.611454049205213f, -0.696789567124132f, -0.551566492897529f, 0.656434797122885f, -0.601779335396959f, -0.265656331560395f, -0.528821434638507f, 0.153601151147409f, 0.514739334540489f, -0.0517769842323894f, -0.659246830986894f, -0.453055366696259f, -0.0515886000780059f, 0.958478845408115f, 0.0221452906045994f, -0.159960643390796f, 0.816263632871352f, 0.245244170325114f, -0.0919839688704780f, 0.947170598807362f, 0.846772793441790f, 0.247105133025056f, -0.801972939368103f, -0.224977420586025f, 0.130099925027197f, 0.497816036746753f, 0.308139730113712f, -0.0536876417759813f, -0.492022090866895f, 0.188938438822753f, -0.400894058284033f, 0.314370104391157f, 0.618580768947071f, 0.830051263404639f, -0.228700130023340f, 0.811855169643177f, 0.0924092179787017f, 0.273652523319809f, -0.0624274843235475f, -0.503696982048589f, 0.510545161203341f, 0.341823133345436f, -0.437486933663093f, 0.0134072800031224f, 0.613837993234983f, 0.740945655313894f, 0.135311460882606f, 0.464832228842466f, -0.973962843371452f, -0.519388256678232f, 0.631469277357519f, -0.936937468616713f, 0.208677911871604f, -0.0946010975796272f, 0.560587233611855f, 0.230925763372331f, -0.637408482848184f, -0.679175194353885f, -0.408696637706987f, -0.0837464598184048f, -0.911070817707239f, 0.985815432104941f, -0.208807972878988f, 0.741966810464688f, 0.162772839973564f, 0.717702638881939f, 0.490767958961575f, -0.835565390813677f, -0.878516167634055f, -0.956727838876563f, -0.00772081382858891f, 0.355227897612178f, 0.202889185809854f, -0.431078767653467f, 0.106936101717808f, 0.354494042302258f, -0.619623833602791f, 0.193065593078352f, -0.105803087758606f, 0.151828327005194f, -0.141094922099930f, 0.847569902283069f, -0.656683924792181f, -0.880754505470701f, -0.421714047610595f, 0.681762288858050f, 0.633712681698887f, 0.947060360650644f, -0.959122611588459f, -0.0690574969687099f, -0.805062392278087f, 0.226501754467861f, -0.414732397455275f, 0.242398867364043f, -0.831838824773804f, 0.00787391802290793f, -0.860692119913991f, -0.391321299589110f, -0.0548681430681355f, -0.992920640472037f, 0.0975642331777702f, 0.894630836703243f, 0.767919825689366f, -0.260878774442215f, 0.407457430171103f, 0.140688657702825f, 0.737494845272763f, -0.650969054257040f, 0.230613259000797f, -0.0986876345046772f, 0.0996951163848971f, -0.679173062298700f, -0.760174222364469f, -0.613840714529317f, -0.692138390397415f, -0.0919103790884603f, 0.0259548517830916f, 0.463763807478796f, -0.859327137970617f, 0.298600182982665f, -0.591236092977368f, -0.994984881037264f, -0.0533840054951049f, 0.544979189292485f, 0.652482875230260f, 0.897548627394727f, -0.340241293753474f, 0.508237349558163f, -0.611986702936889f, -0.399952468536369f, -0.758494484998191f, -0.148960755782999f, 0.895231513826071f, -0.870487943961511f, -0.172763884748068f, -0.652702954266129f, 0.784450103085903f, -0.428504279168614f, -0.347266234450861f, -0.0897193897382391f, 0.760686883857503f, -0.0863659842493281f, -0.453544362916610f, 0.713112885874267f, -0.529914378597266f, -0.134507787695203f, -0.590955798880753f, -0.372583442870916f, 0.646730663631020f, -0.809515553972267f, 0.0226873348847205f, -0.209338539804651f, -0.737170063193136f, 0.365916689978321f, 0.658019395382111f, 0.733982378695990f, -0.579926149814113f, 0.973814182111372f, 0.933875763922095f, -0.985234946636757f, -0.103124599698243f, -0.798304574918884f, -0.119705341414667f, 0.205941898284561f, 0.111088288053652f, 0.418598493379981f, 0.309112287901667f, 0.0865232803642195f, -0.281174085998345f, -0.158426951248790f, 0.156672456990889f, 0.608691108739118f, -0.124654784531448f, -0.372060827503666f, 0.555750853569654f, -0.481715370485256f, 0.411012047999522f, 0.265636511301544f, 0.164466400718006f, 0.427292785417094,
-0.407665783814271f, 0.0463239131527564f, 0.0109249300633605f, 0.0949704798708169f, 0.223291931618591f, 0.708651599857453f, 0.810927407452143f, -0.298811874805995f, 0.347215272448441f, 0.778225160999446f, -0.981258755328673f, -0.629231280170021f, -0.948786159268210f, -0.0530522786747270f, -0.665046033882002f, 0.776993795678436f, -0.604492154463805f, -0.906360689482177f, 0.543616910115371f, -0.501547360013149f, 0.571784796850774f, 0.868511495621889f, 0.783008382563488f, 0.571870376568081f, 0.0471150346240308f, 0.402433510592678f, 0.661353159662286f, 0.0253381317208246f, 0.720141243708461f, -0.478805385943742f, 0.989639021624774f, 0.538614599364854f, -0.282810721919526f, 0.888399971333007f, 0.118572990347886f, 0.564528382703688f, 0.988296121763412f, 0.509638594649021f, -0.797738059997026f, 0.0363326380089621f, 0.978315833815278f, -0.483368013204689f, 0.879051054425480f, 0.632539830439323f, 0.722677742708361f, 0.578919286433726f, -0.250721628167261f, 0.534435049744896f, -0.0404568429105234f, 0.00805525426120179f, 0.841210870775473f, -0.731771544679396f, 0.713758914490801f, 0.830250762535296f, 0.436563669872217f, 0.567024378980237f, 0.983941121609744f, -0.253548560865555f, 0.647105012325159f, 0.434994339049196f, 0.130837710207442f, -0.775136733344706f, 0.234917279141211f, -0.498429841761386f, -0.273571256415041f, 0.247467425899991f, -0.970396693506149f, 0.975835855884816f, -0.347896516486866f, -0.552856369180847f, -0.887336234316568f, -0.573271015958957f, 0.910862901097874f, -0.807236601077904f, -0.523971593712952f, -0.263589563369279f, 0.591056276091253f, -0.320168527954128f, 0.726795865615521f, -0.731502115921006f, -0.942225519371229f, 0.268573107637337f, 0.380348127119473f, -0.284539943611895f, 0.117478291379931f, -0.817442486350524f, 0.0734705767013011f, -0.626880755668906f, -0.873066996524459f, -0.528675805715351f, 0.490255491577847f, 0.398142666604162f, -0.911320079669940f, -0.870350237514323f, 0.854587452657144f, 0.736349579728106f, 0.948232845958681f, -0.00126774478569258f, 0.905641169934000f, -0.965500575551565f, 0.0831330388550517f, -0.892713267782484f, -0.277958019172831f, 0.312987842344813f, 0.484268977417485f, -0.365960524226328f, 0.177956605738091f, 0.913776767689874f, -0.897537691614058f, 0.473075982698961f, 0.913190042662185f, -0.00843862630950820f, 0.972679442298938f, -0.856058592202917f, 0.264007224067230f, -0.138444823656136f, -0.386195416368251f, -0.286657907928107f, -0.231200657384828f, 0.917365701941188f, -0.271317547281263f, -0.252691685075831f, 0.893742787021399f, 0.512463051119608f, 0.979155111008605f, -0.472272776864686f, 0.238767541974988f, -0.672234403865928f, -0.846783135777377f, 0.0877594573148737f, 0.493055606176910f, -0.289012308379085f, 0.416463895880697f, -0.0795051375851281f, -0.476692131327163f, -0.430471976159529f, -0.701875030095239f, 0.724684336417516f, 0.984802039066595f, 0.798285421773762f, 0.000509924988974175f, -0.0852199551444761f, -0.709724122158260f, -0.332735158942919f, -0.741119907407496f, 0.729608513555970f, 0.500578022862182f, 0.520862987462710f, 0.565678561009731f, -0.393741545311224f, -0.568866018100912f, 0.571654318026290f, -0.817900961532165f, -0.793268461448962f, 0.614914392385859f, 0.763415306986536f, 0.450074180772758f, -0.737435729799608f, 0.841185794339245f, 0.894276069286366f, -0.276262284222369f, -0.798623475612628f, -0.280994234105732f, 0.821175230597885f, -0.474251640366966f, -0.190039801864015f, 0.0663032720971493f, 0.884162053156770f, -0.162023139878049f, -0.963135153785511f, -0.582213329804047f, -0.328536493809765f, -0.938405687658462f, -0.0171569611327957f, -0.727260847907578f, 0.419920927745257f, -0.361592243835530f, 0.476989471873569f, -0.146161675185107f, 0.431817832405826f, -0.371528849369885f, -0.940567978751516f, 0.165203770962029f, 0.781321525273307f, 0.0585592625092357f, 0.573299596753579f, -0.378869924017182f, 0.523139576520889f, 0.385605607116478f, -0.235893429970747f, 0.285814921067909f, -0.121941292771133f, 0.621558611608942f, -0.0860979132283732f, -0.627097832687809f, -0.312083243705910f, -0.494490796681559f, -0.987187334387934f, -0.0804474888246625f, 0.496400656176795f, -0.851811189314651f, -0.791398271297849f, -0.868174317799275f, -0.226794668997878f, -0.335339474552766f, -0.276765924750817f, -0.395876032147377f, -0.740529136126816f, -0.167799472110453f, 0.593129248263724f, 0.336783120133436f, 0.248892158925787f, 0.950120283075237f, -0.795216613504226f, -0.574731116508357f, -0.822689608026685f, 0.973698546284335f, 0.125166556654624f, 0.588150318080073f, 0.128654744345192f, -0.219207714307262f, -0.271053050307713f, 0.124071241265810f, -0.618209718015327f, -0.766619799595349f, -0.478340220431165f, -0.446873929629545f, 0.978019432749647f, -0.627041040766022f, 0.169323691066764f, -0.714079827532216f, 0.386101296128268f, -0.360225804976135f, -0.236797717782837f, -0.311635747131794f, 0.0482888201705840f, -0.477302740867809f, -0.427349080854399f, 0.390352470816329f, 0.611790541936623f, -0.648292156214605f, -0.345871618789073f, 0.509300603302844f, -0.0142202703124219f, -0.570248077753979f, -0.0629178211029751f, -0.737806048037047f, 0.497750084049821f, -0.761650107803135f, -0.788756591098617f, -0.994497286039420f, -0.987344273533962f, 0.657151987467984f, -0.763708299084062f, -0.0729359162118841f, 0.0455275633022023f, -0.101919187896584f, 0.457804242981095f, 0.0117715388281796f, -0.274125197027132f, -0.949738804931191f, 0.762108173886486f, 0.405150754308562f, -0.733330375873553f, -0.712774896799572f, -0.791947616412901f, 0.444023894424500f, 0.00507562975249609f, -0.900698136223538f, -0.576055334977054f, -0.948895529956106f, -0.832665060374124f, -0.992753953473078f, -0.0674086978315183f, 0.569494111501383f, -0.962269067721443f, -0.489700810475570f, 0.972626508328545f, -0.777400448149780f, 0.115588644128954f, 0.0730469703310024f, 0.523584488072518f, 0.659055312807301f, 0.134198234373838f, -0.797833055125151f, -0.167842823235145f, -0.662347837139732f, -0.537544370279756f, -0.622353549740796f, -0.789789664448618f, 0.985300123665319f, 0.862449845163424f, 0.973193986256980f, 0.148883268671144f, 0.283619537155083f, 0.508503183151258f, -0.246167305966866f, -0.259543094514413f, -0.778029136807597f, 0.128978622849116f, -0.920978818238085f, -0.116324837544276f, -0.261472397833253f, 0.772449038068069f, -0.696754008784325f, 0.980778877985902f, -0.227636956328402f, -0.472493776528032f, -0.568519858000960f, -0.151689463117960f, -0.102997587484899f, 0.464752146042376f, -0.839114793935065f, -0.0325074343587592f, -0.180618880765978f, 0.0132253638432844f, -0.646173464496730f, 0.821983901071593f, 0.657453744559881f, 0.786315172070382f, -0.438718096604728f, 0.702691078885442f, 0.859957412428682f, -0.505281395658564f, -0.236722160990303f, -0.698465568366759f, -0.746418979540090f, -0.218205126412646f, -0.808715244840435f, -0.949813739800491f, 0.176975348790769f, 0.723960974918154f, -0.139253733704369f, -0.387224393658603f, -0.869945438924443f, -0.396979039594941f, 0.0256060022407458f, -0.566074790002811f, -0.161564565183606f, -0.736189868188370f, -0.205593811665825f, -0.628996407588712f, -0.0266462623004120f, -0.344127255771429f, -0.229003801178142f, -0.469786561635510f, 0.258249378153965f, 0.160442939158622f, 0.0528817242116550f, 0.261960766261548f, -0.571069557415276f, 0.411333771884545f, -0.145205354714326f, 0.249324532476397f, 0.163889600722793f, 0.649915677347011f, 0.147077371087195f, -0.227104208942068f, 0.867390199578604f, -0.0734153565896754f, 0.0491208061060167f, 0.0360590744216485f, 0.181620126101180f, 0.0567549454976457f, -0.856976992549465f, -0.242511192726339f, -0.624770508991394f, -0.793161214564285f, -0.251208532727981f, -0.833192309869275f, 0.368166434661069f, 0.939730260791580f, 0.305796202211942f, -0.598830491282818f, -0.0575368190467946f, 0.371329658849021f, -0.227872714677810f, 0.707539568196379f, 0.795186297468385f, 0.475847791658551f, 0.829361555893632f, 0.405386540930889f, 0.213282954068900f, 0.767339023510319f, 0.525055513018554f, 0.259437496637378f, -0.524342591286100f, -0.731515526086696f, -0.233118783725590f, 0.237972339628935f, -0.933985285078109f, 0.537013420173496f, 0.498819465200784f, -0.407713459607516f, 0.382821417923595f, -0.416894700661466f, 0.0787266904103943f, -0.0627973593192392f, -0.320105342653426f, -0.844066834407447f, 0.138221622417319f, -0.676665423871596f, -0.961043785105959f, 0.832268610130385f, -0.905530890441773f, -0.114191325652611f, -0.376697124207843f, 0.390323137798417f, 0.953143142925101f, 0.983427991280007f, -0.0895687386326503f, -0.681543125061097f, 0.677131540142176f, -0.867715848764628f, -0.812718786220309f, -0.212509939486840f, -0.990002327123638f, -0.0682855560011961f, 0.129310729289606f, -0.623746296335073f, -0.285580241032587f, 0.235626081900812f, -0.611973228709249f, 0.539189737955466f, 0.970058678533189f, 0.901944358898624f, 0.168094826408153f, -0.666711281252260f, 0.965612752173968f, 0.651034558458719f, 0.687501917067508f, 0.758614314567106f, -0.839396045781239f, -0.552775028233564f, -0.528941743867256f, 0.174761156721889f, 0.243585712774679f, 0.588913151268911f, -0.306898192880627f, 0.921540023069231f, -0.0223654942298541f, -0.102408576957649f, 0.612577852207921f, 0.835809058447089f, -0.437118459197839f, 0.455316033239981f, 0.311435507416257f, -0.648992336007256f, 0.346823844785409f, -0.632080213667648f, -0.599678627679202f, -0.653822991854328f, 0.484305292443427f, 0.782046295685087f, 0.960987598814982f, 0.627169162605570f, 0.948092598306120f, -0.185268381817018f, 0.602489977060513f, -0.885827813790617f, -0.00179203147433582f, -0.175476447614991f, 0.0461282236560925f, -0.898013889602944f, 0.256310837914276f, -0.733422110056865f, -0.740091677658095f, 0.966724540497493f, 0.328056986822768f, -0.267854591449557f, 0.670545831663244f, -0.356204313297688f, 0.0729865206358908f, -0.594530723723669f, 0.519965324048968f, 0.0632129606097647f, -0.878434885663544f, -0.497945943395010f, 0.0151854050905818f, -0.218036856012343f, 0.547721213710874f, -0.0915514918588898f, -0.279344098401951f, -0.228654882218650f, 0.100432155997130f, 0.802024600677294f, 0.175832345686877f, 0.0551231013299744f, 0.938247319394824f, 0.639298571360036f, -0.291461603371678f, -0.853503115314794f, -0.604829242631156f, 0.0291571486740745f, -0.932575328418390f, -0.621235088415116f, 0.403040314052094f, -0.809695618266849f, 0.966605888732736f, -0.199254401023053,
-0.540808222970056f, -0.0141840769249790f, 0.114579158224093f, 0.466889318471371f, -0.145415211797766f, -0.846707387707480f, -0.881237200733915f, -0.410798723199712f, -0.637697860299854f, -0.196366036081372f, 0.193267531425712f, -0.258591200841940f, -0.173003722066551f, 0.478121376006132f, 0.953819951501542f, 0.969916001975448f, 0.131515861287576f, -0.499829658784781f, 0.320952777516193f, -0.226980682212371f, 0.766886115655233f, 0.647310434110803f, -0.772594685974992f, 0.772645949480187f, -0.936357605801364f, -0.671842916281206f, -0.595127074295355f, 0.335132581825520f, 0.648964430112689f, -0.793376819398441f, -0.963663232647360f, 0.914308824314478f, -0.397663128784982f, 0.803240040231588f, -0.291039120047626f, -0.339918835846510f, -0.208620988780609f, 0.278177231697424f, -0.833157746552451f, 0.260554706029473f, -0.580537744139231f, 0.918561093477862f, 0.641368468308093f, 0.827379039283645f, -0.412231303854834f, -0.518315486749742f, 0.423356687848085f, 0.0777277584993787f, 0.394127392657178f, 0.609705410002715f, 0.264669032561337f, -0.460555696512027f, -0.0858908123066196f, -0.281781559603429f, -0.179777723960362f, -0.00449990348855067f, 0.803703377739133f, -0.155074032314596f, -0.00206139428833696f, 0.0661730930565525f, -0.737509215752079f, 0.620182143819587f, 0.114750705414661f, 0.545663051433958f, 0.661601724477194f, -0.592280382351976f, 0.609240020031149f, -0.968781019917808f, -0.668068368389875f, 0.206915551463500f, 0.0951453192552747f, 0.268580107578401f, -0.0450052302342363f, -0.933589842483940f, 0.236570492858402f, 0.0688734168318912f, 0.930163232697303f, 0.435953476823146f, 0.533759385687075f, 0.368282038662015f, -0.602312961473778f, 0.709516631712345f, -0.168303926671961f, 0.130670870119294f, -0.657736111745007f, 0.115028598388756f, 0.173728026281032f, -0.681671363429886f, -0.538786035950873f, 0.481457671665448f, 0.0136795278434168f, -0.570065342244344f, 0.188187050857249f, -0.352869308173680f, -0.979175308628854f, 0.223702879460018f, 0.994220466087713f, -0.147795166105729f, 0.218427535879435f, -0.120050826084179f, -0.0124939247430063f, -0.645134875027126f, -0.503122688484778f, 0.534123007328982f, 0.619710972635444f, -0.234248243706177f, 0.987144458053815f, 0.261284702576427f, 0.851827092094236f, 0.750019654249059f, -0.926154630610335f, 0.449356103243440f, 0.783011320523296f, -0.459228158107270f, -0.228877816937867f, 0.271108937592868f, -0.676085611673506f, 0.783114428240160f, 0.636093784021493f, -0.754110314308629f, -0.546386104880684f, 0.0385811136139234f, -0.768951137117397f, -0.644624743947807f, 0.00890157035391148f, -0.0792572116273387f, -0.989980668770044f, 0.603057533157075f, 0.280835727469123f, -0.634716709420524f, -0.712669415138995f, -0.424129916157595f, -0.436923748487354f, 0.467366013559791f, 0.907740481011987f, 0.788617065944311f, -0.152237692069130f, -0.963044404518533f, 0.907393322909416f, 0.806867676446313f, 0.699270310021791f, 0.107867603776547f, 0.127360747415417f, -0.502645789696788f, -0.511744166872327f, -0.121672719343072f, -0.596527146770249f, 0.410180172377510f, -0.852889849908704f, 0.278972213674154f, 0.0260156356783650f, 0.997558501949683f, -0.499245840292893f, -0.451169267624132f, -0.881643497362337f, 0.986957209874262f, -0.129608292321380f, 0.935829016346258f, -0.649021465281634f, 0.550436689069794f, 0.278888743082679f, 0.0137769346664500f, -0.660666060213522f, -0.416709136728042f, -0.302903068397225f, 0.180657445835459f, -0.908195955986293f, 0.280056533234627f, -0.660025789034158f, -0.798207438952561f, 0.901575224780405f, -0.608702932295102f, 0.318860199910414f, 0.874005722023406f, -0.0816057579181704f, 0.981671341873017f, -0.339234700161323f, 0.559717959858931f, 0.390363525109105f, -0.309384476087470f, 0.956563156784297f, -0.623734354817613f, -0.196627375289105f, -0.702076014509088f, 0.293098766889643f, -0.617152224560368f, 0.859117491438645f, 0.661015739867647f, 0.0747554166353739f, -0.282417009682732f, -0.667461537762524f, -0.451029960388404f, -0.464518668674360f, 0.591389440503293f, 0.552648871601186f, -0.242406315814918f, 0.147876771864331f, -0.00605730052917419f, -0.850648363553678f, -0.659957159486993f, -0.165475362851332f, 0.204150315434812f, -0.665767311591476f, -0.716154682563576f, 0.417487456932076f, 0.448184990956287f, 0.733843802413198f, -0.170228277851921f, -0.346809954182150f, 0.956058632188011f, 0.0315623945930987f, 0.509027121691627f, -0.147826185909834f, 0.717423768198044f, -0.153258078639530f, -0.586190749016474f, 0.122228033051868f, -0.884999045468193f, -0.364729711773548f, 0.0869976154696972f, -0.793532199218799f, 0.533748273468951f, -0.852754376244435f, 0.294752047699830f, 0.136764278163013f, 0.838074791168389f, 0.795224598541123f, -0.778005568697498f, -0.260924769562304f, -0.303759147861313f, 0.273726011325558f, 0.530476779331216f, 0.0866801234357086f, 0.0677702376031544f, 0.724353404182035f, -0.974710312543683f, 0.791838170482991f, 0.247768259921660f, 0.979431048271259f, -0.386992541899814f, 0.0640038231299192f, -0.00457726816166693f, 0.371455553726539f, 0.647649995487707f, 0.268304945808406f, -0.320428608173924f, 0.0927511620029309f, 0.256010036486838f, 0.740396212690346f, -0.656873241472848f, 0.823534292439413f, -0.820380362458844f, -0.453300307443023f, 0.784238355222248f, 0.912791840124321f, 0.0999478035440859f, -0.212620916988855f, 0.0170290625008669f, -0.589062380565879f, -0.171833624145497f, -0.524918122866141f, 0.961528292650892f, 0.101262818636430f, 0.941455114569308f, -0.967226220138929f, 0.616781547648562f, -0.913823148383971f, 0.274508821885917f, 0.924653374107756f, -0.866302908989783f, 0.227541907715857f, 0.0907574361370582f, -0.127499097943315f, -0.942071371521895f, -0.119419163649152f, 0.674284088819523f, 0.881328505929745f, 0.246290207551702f, 0.0547607254148590f, -0.462882918359077f, 0.888969728230585f, 0.666583509571921f, 0.238417203582380f, -0.279842248122727f, 0.855260336845903f, 0.314306869401155f, -0.188654877893078f, -0.609304918228150f, 0.169453885325888f, 0.265617874907016f, -0.943423537926184f, 0.493118676869450f, -0.386147750024858f, 0.0103920154342951f, 0.753677832518483f, 0.363353012331066f, -0.286620106520429f, -0.623332994906295f, 0.183966714365642f, -0.124278942882867f, -0.687889346448110f, -0.509002319646341f, -0.705769785650865f, 0.600586126467172f, 0.814989294939922f, 0.198959025256652f, 0.477897007911356f, 0.757957814363899f, 0.617755921094230f, -0.353589871947529f, 0.419688673189503f, -0.860584865805600f, -0.0232779635193843f, -0.789951030889387f, -0.893196700185750f, 0.610996462535201f, 0.847373590985131f, -0.989553358501822f, -0.367651771428081f, 0.741563712056747f, -0.923595352848971f, -0.580174215739367f, 0.577092000574232f, -0.910872910110270f, -0.907499077314190f, 0.692372247654077f, 0.810694134592084f, -0.608596332548047f, 0.761254615051625f, 0.0546240611947364f, -0.393956427117691f, -0.116127831535139f, -0.0352014590913388f, 0.374742194768889f, -0.927344099730091f, 0.939301337232488f, -0.969831716293845f, -0.0489333404770240f, -0.586719398908953f, 0.0235541378462407f, 0.388882981728285f, -0.0728483242295113f, 0.418280445244943f, -0.574289337805456f, -0.779962057565259f, -0.835190719754123f, 0.918717316922657f, -0.765889988109173f, -0.935310664146932f, -0.0750906135370848f, -0.256246546197534f, 0.693865929543926f, 0.592800255527084f, 0.836743344551035f, -0.801953470827580f, 0.0595524153568945f, 0.158376549012192f, -0.429364776412726f, -0.450531184162532f, -0.169317185285268f, 0.420344570579195f, -0.902838087574441f, -0.654676904337469f, 0.941802178622893f, -0.411034608875500f, -0.455381371659872f, 0.582371240315256f, -0.276150504466756f, 0.164276403376185f, -0.960238817086774f, 0.590055303394028f, -0.995185688656226f, -0.285809748360467f, -0.792066171752882f, -0.456123303649101f, -0.864169187700384f, 0.798745251308383f, -0.517673464079948f, 0.523086536900369f, 0.398784615211052f, 0.908677185333852f, -0.434846969584770f, -0.277024535706464f, 0.575800013122065f, -0.0423952171673019f, -0.327530749916683f, -0.401220909875065f, -0.232577533032385f, 0.577630268254944f, -0.733290201484409f, -0.297499739456838f, 0.166541885572822f, -0.646828619904039f, 0.0312662656272755f, 0.754145050600965f, -0.908499825108811f, 0.315379190361296f, 0.366242661082351f, 0.867903806940678f, -0.613391940567782f, 0.00760147209048068f, 0.953424134034927f, -0.812551125910811f, 0.734998935207065f, 0.781720854678504f, -0.653974423413561f, 0.612587888218526f, -0.297359914095386f, -0.409559158758694f, -0.143962230212734f, -0.814888102841114f, 0.359131810502055f, 0.356924557741016f, -0.872415989401612f, 0.716849887848809f, -0.374916928585818f, -0.0702264435280595f, 0.329843438660215f, 0.0956097573088677f, -0.937528128860310f, -0.322293489817529f, 0.781444964993177f, -0.810141738751828f, -0.150295079242497f, 0.846909181293597f, -0.128124277517711f, -0.752611695817661f, 0.839996835828451f, -0.0705685941510277f, 0.000366462394740585f, 0.0788016995849923f, -0.246053200655556f, -0.156645099915028f, -0.460752333796863f, 0.622021359864204f, 0.722871957583123f, -0.257873353238499f, -0.309810184480446f, 0.765248644407833f, -0.553316047243663f, -0.612742789838491f, 0.354017349601509f, 0.923293368553697f, 0.630695912377860f, -0.148750121613537f, -0.821801680234240f, 0.368247966228196f, 0.405416044101496f, -0.803232509711354f, -0.429778551911399f, -0.723837414527446f, -0.963925147452133f, 0.190882872226757f, 0.477008077263598f, -0.661282403679070f, 0.271643442525556f, -0.915994079618801f, 0.196564556546175f, 0.378359035245796f, 0.584016730657668f, -0.0377864332655202f, -0.327376192853106f, 0.850744189707984f, 0.799571679043808f, -0.111126908452029f, 0.525587242291601f, -0.404486180733535f, -0.134496922397279f, 0.0890128096708100f, -0.815560643303157f, -0.920166023598312f, -0.360079578314899f, -0.556238898466371f, -0.220978103133838f, -0.571530268052405f, 0.573332217175226f, -0.133862258696460f, -0.982130330352248f, -0.352538465285082f, 0.318683937697894f, -0.790927430842686f, 0.691168535237102f, 0.806014327242002f, -0.981639450008060f, 0.407200095027265f, 0.918249921845949f, 0.776880149695420f, -0.437773083955269f, -0.385117533333437f, 0.0115152415796460f, 0.687224538003991f, 0.992524870612626f, 0.471003324792228f, -0.873541777412034f, -0.560923118634380f, -0.726151823613842f, -0.538941951730010f, 0.772057551475325f, 0.858490725829641f, -0.168849338472479f };
# 102 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t wrap(fxp_t kX, fxp_t kLowerBound, fxp_t kUpperBound)
{
int32_t range_size = kUpperBound - kLowerBound + 1;
if (kX < kLowerBound){
kX += range_size * ((kLowerBound - kX) / range_size + 1);
}
return kLowerBound + (kX - kLowerBound) % range_size;
}
fxp_t fxp_get_int_part(fxp_t in) {
return ((in < 0) ? -((-in) & _fxp_imask) : in & _fxp_imask);
}
fxp_t fxp_get_frac_part(fxp_t in) {
return ((in < 0) ? -((-in) & _fxp_fmask) : in & _fxp_fmask);
}
float fxp_to_float(fxp_t fxp);
fxp_t fxp_quantize(fxp_t aquant) {
if (overflow_mode == 2) {
if(aquant < _fxp_min) {
return _fxp_min;
}
else if(aquant > _fxp_max) {
return _fxp_max;
}
}
else if (overflow_mode == 3) {
if(aquant < _fxp_min || aquant > _fxp_max) {
return wrap(aquant, _fxp_min, _fxp_max);
}
}
return (fxp_t) aquant;
}
void fxp_verify_overflow(fxp_t value){
fxp_quantize(value);
printf("An Overflow Occurred in system's output");
__DSVERIFIER_assert(value <= _fxp_max && value >= _fxp_min);
}
void fxp_verify_overflow_node(fxp_t value, char* msg){
if (1 == 2)
{
printf("%s",msg);
__DSVERIFIER_assert(value <= _fxp_max && value >= _fxp_min);
}
}
void fxp_verify_overflow_array(fxp_t array[], int n){
int i=0;
for(i=0; i<n;i++){
fxp_verify_overflow(array[i]);
}
}
fxp_t fxp_int_to_fxp(int in) {
fxp_t lin;
lin = (fxp_t) in*_fxp_one;
return lin;
}
int fxp_to_int(fxp_t fxp) {
if(fxp >= 0){
fxp += _fxp_half;
} else {
fxp -= _fxp_half;
}
fxp >>= impl.frac_bits;
return (int) fxp;
}
fxp_t fxp_float_to_fxp(float f) {
fxp_t tmp;
double ftemp;
ftemp = f * scale_factor[impl.frac_bits];
if(f >= 0) {
tmp = (fxp_t)(ftemp + 0.5);
}
else {
tmp = (fxp_t)(ftemp - 0.5);
}
return tmp;
}
fxp_t fxp_double_to_fxp(double value) {
fxp_t tmp;
double ftemp = value * scale_factor[impl.frac_bits];
if (rounding_mode == 0){
if(value >= 0) {
tmp = (fxp_t)(ftemp + 0.5);
}
else {
tmp = (fxp_t)(ftemp - 0.5);
}
} else if(rounding_mode == 1){
tmp = (fxp_t) ftemp;
double residue = ftemp - tmp;
if ((value < 0) && (residue != 0)){
ftemp = ftemp - 1;
tmp = (fxp_t) ftemp;
}
} else if (rounding_mode == 0){
tmp = (fxp_t) ftemp;
}
return tmp;
}
void fxp_float_to_fxp_array(float f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
r[i] = fxp_float_to_fxp(f[i]);
}
}
void fxp_double_to_fxp_array(double f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
r[i] = fxp_double_to_fxp(f[i]);
}
}
# 275 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
float fxp_to_float(fxp_t fxp) {
float f;
int f_int = (int) fxp;
f = f_int * scale_factor_inv[impl.frac_bits];
return f;
}
double fxp_to_double(fxp_t fxp) {
double f;
int f_int = (int) fxp;
f = f_int * scale_factor_inv[impl.frac_bits];
return f;
}
void fxp_to_float_array(float f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
f[i] = fxp_to_float(r[i]);
}
}
void fxp_to_double_array(double f[], fxp_t r[], int N) {
int i;
for(i = 0; i < N; ++i) {
f[i] = fxp_to_double(r[i]);
}
}
fxp_t fxp_abs(fxp_t a) {
fxp_t tmp;
tmp = ((a < 0) ? -(fxp_t)(a) : a);
tmp = fxp_quantize(tmp);
return tmp;
}
fxp_t fxp_add(fxp_t aadd, fxp_t badd) {
fxp_t tmpadd;
tmpadd = ((fxp_t)(aadd) + (fxp_t)(badd));
tmpadd = fxp_quantize(tmpadd);
return tmpadd;
}
fxp_t fxp_sub(fxp_t asub, fxp_t bsub) {
fxp_t tmpsub;
tmpsub = (fxp_t)((fxp_t)(asub) - (fxp_t)(bsub));
tmpsub = fxp_quantize(tmpsub);
return tmpsub;
}
fxp_t fxp_mult(fxp_t amult, fxp_t bmult) {
fxp_t tmpmult, tmpmultprec;
tmpmult = (fxp_t)((fxp_t)(amult)*(fxp_t)(bmult));
if (tmpmult >= 0) {
tmpmultprec = (tmpmult + ((tmpmult & 1 << (impl.frac_bits - 1)) << 1)) >> impl.frac_bits;
} else {
tmpmultprec = -(((-tmpmult) + (((-tmpmult) & 1 << (impl.frac_bits - 1)) << 1)) >> impl.frac_bits);
}
tmpmultprec = fxp_quantize(tmpmultprec);
return tmpmultprec;
}
# 372 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t fxp_div(fxp_t a, fxp_t b){
__DSVERIFIER_assume( b!=0 );
fxp_t tmpdiv = ((a << impl.frac_bits) / b);
tmpdiv = fxp_quantize(tmpdiv);
return tmpdiv;
}
fxp_t fxp_neg(fxp_t aneg) {
fxp_t tmpneg;
tmpneg = -(fxp_t)(aneg);
tmpneg = fxp_quantize(tmpneg);
return tmpneg;
}
# 398 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/fixed-point.h"
fxp_t fxp_sign(fxp_t a) {
return ((a == 0) ? 0 : ((a < 0) ? _fxp_minus_one : _fxp_one) );
}
fxp_t fxp_shrl(fxp_t in, int shift) {
return (fxp_t) (((unsigned int) in) >> shift);
}
fxp_t fxp_square(fxp_t a) {
return fxp_mult(a, a);
}
void fxp_print_int(fxp_t a) {
printf("\n%i", (int32_t)a);
}
void fxp_print_float(fxp_t a) {
printf("\n%f", fxp_to_float(a));
}
void fxp_print_float_array(fxp_t a[], int N) {
int i;
for(i = 0; i < N; ++i) {
printf("\n%f", fxp_to_float(a[i]));
}
}
void print_fxp_array_elements(char * name, fxp_t * v, int n){
printf("%s = {", name);
int i;
for(i=0; i < n; i++){
printf(" %jd ", v[i]);
}
printf("}\n");
}
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 1
# 24 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
void initialize_array(double v[], int n){
int i;
for(i=0; i<n; i++){
v[i] = 0;
}
}
void revert_array(double v[], double out[], int n){
initialize_array(out,n);
int i;
for(i=0; i<n; i++){
out[i] = v[n-i-1];
}
}
double internal_pow(double a, double b){
int i;
double acc = 1;
for (i=0; i < b; i++){
acc = acc*a;
}
return acc;
}
double internal_abs(double a){
return a < 0 ? -a : a;
}
int fatorial(int n){
return n == 0 ? 1 : n * fatorial(n-1);
}
int check_stability(double a[], int n){
int lines = 2 * n - 1;
int columns = n;
double m[lines][n];
int i,j;
double current_stability[n];
for (i=0; i < n; i++){
current_stability[i] = a[i];
}
double sum = 0;
for (i=0; i < n; i++){
sum += a[i];
}
if (sum <= 0){
printf("[DEBUG] the first constraint of Jury criteria failed: (F(1) > 0)");
return 0;
}
sum = 0;
for (i=0; i < n; i++){
sum += a[i] * internal_pow(-1, n-1-i);
}
sum = sum * internal_pow(-1, n-1);
if (sum <= 0){
printf("[DEBUG] the second constraint of Jury criteria failed: (F(-1)*(-1)^n > 0)");
return 0;
}
if (internal_abs(a[n-1]) > a[0]){
printf("[DEBUG] the third constraint of Jury criteria failed: (abs(a0) < a_{n}*z^{n})");
return 0;
}
for (i=0; i < lines; i++){
for (j=0; j < columns; j++){
m[i][j] = 0;
}
}
for (i=0; i < lines; i++){
for (j=0; j < columns; j++){
if (i == 0){
m[i][j] = a[j];
continue;
}
if (i % 2 != 0 ){
int x;
for(x=0; x<columns;x++){
m[i][x] = m[i-1][columns-x-1];
}
columns = columns - 1;
j = columns;
}else{
m[i][j] = m[i-2][j] - (m[i-2][columns] / m[i-2][0]) * m[i-1][j];
}
}
}
int first_is_positive = m[0][0] >= 0 ? 1 : 0;
for (i=0; i < lines; i++){
if (i % 2 == 0){
int line_is_positive = m[i][0] >= 0 ? 1 : 0;
if (first_is_positive != line_is_positive){
return 0;
}
continue;
}
}
return 1;
}
void poly_sum(double a[], int Na, double b[], int Nb, double ans[], int Nans){
int i;
Nans = Na>Nb? Na:Nb;
for (i=0; i<Nans; i++){
if (Na>Nb){
ans[i]=a[i];
if (i > Na-Nb-1){
ans[i]=ans[i]+b[i-Na+Nb];
}
}else {
ans[i]=b[i];
if (i> Nb - Na -1){
ans[i]=ans[i]+a[i-Nb+Na];
}
}
}
}
void poly_mult(double a[], int Na, double b[], int Nb, double ans[], int Nans){
int i;
int j;
int k;
Nans = Na+Nb-1;
for (i=0; i<Na; i++){
for (j=0; j<Nb; j++){
k= Na + Nb - i - j - 2;
ans[k]=0;
}
}
for (i=0; i<Na; i++){
for (j=0; j<Nb; j++){
k= Na + Nb - i - j - 2;
ans[k]=ans[k]+a[Na - i - 1]*b[Nb - j - 1];
}
}
}
void double_check_oscillations(double * y, int y_size){
__DSVERIFIER_assume(y[0] != y[y_size - 1]);
int window_timer = 0;
int window_count = 0;
int i, j;
for (i = 2; i < y_size; i++){
int window_size = i;
for(j=0; j<y_size; j++){
if (window_timer > window_size){
window_timer = 0;
window_count = 0;
}
int window_index = j + window_size;
if (window_index < y_size){
if (y[j] == y[window_index]){
window_count++;
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
((void) sizeof ((
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
!(window_count == window_size)
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
!(window_count == window_size)
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
) ; else __assert_fail (
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
"!(window_count == window_size)"
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h", 209, __extension__ __PRETTY_FUNCTION__); }))
# 209 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/util.h"
;
}
}else{
break;
}
window_timer++;
}
}
}
void double_check_limit_cycle(double * y, int y_size){
double reference = y[y_size - 1];
int idx = 0;
int window_size = 1;
for(idx = (y_size-2); idx >= 0; idx--){
if (y[idx] != reference){
window_size++;
}else{
break;
}
}
__DSVERIFIER_assume(window_size != y_size && window_size != 1);
printf("window_size %d\n", window_size);
int desired_elements = 2 * window_size;
int found_elements = 0;
for(idx = (y_size-1); idx >= 0; idx--){
if (idx > (y_size-window_size-1)){
printf("%.0f == %.0f\n", y[idx], y[idx-window_size]);
int cmp_idx = idx - window_size;
if ((cmp_idx > 0) && (y[idx] == y[idx-window_size])){
found_elements = found_elements + 2;
}else{
break;
}
}
}
printf("desired_elements %d\n", desired_elements);
printf("found_elements %d\n", found_elements);
__DSVERIFIER_assert(desired_elements != found_elements);
}
void double_check_persistent_limit_cycle(double * y, int y_size){
int idy = 0;
int count_same = 0;
int window_size = 0;
double reference = y[0];
for(idy = 0; idy < y_size; idy++){
if (y[idy] != reference){
window_size++;
} else if (window_size != 0){
break;
} else {
count_same++;
}
}
window_size += count_same;
__DSVERIFIER_assume(window_size > 1 && window_size <= y_size/2);
double lco_elements[window_size];
for(idy = 0; idy < y_size; idy++){
if (idy < window_size){
lco_elements[idy] = y[idy];
}
}
idy = 0;
int lco_idy = 0;
_Bool is_persistent = 0;
while (idy < y_size){
if(y[idy++] == lco_elements[lco_idy++]){
is_persistent = 1;
}else{
is_persistent = 0;
break;
}
if (lco_idy == window_size){
lco_idy = 0;
}
}
__DSVERIFIER_assert(is_persistent == 0);
}
void print_array_elements(char * name, double * v, int n){
printf("%s = {", name);
int i;
for(i=0; i < n; i++){
printf(" %.32f ", v[i]);
}
printf("}\n");
}
void double_add_matrix( unsigned int lines, unsigned int columns, double m1[4][4], double m2[4][4], double result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
result[i][j] = m1[i][j] + m2[i][j];
}
}
}
void double_sub_matrix( unsigned int lines, unsigned int columns, double m1[4][4], double m2[4][4], double result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
result[i][j] = m1[i][j] - m2[i][j];
}
}
}
void double_matrix_multiplication( unsigned int i1, unsigned int j1, unsigned int i2, unsigned int j2, double m1[4][4], double m2[4][4], double m3[4][4]){
unsigned int i, j, k;
if (j1 == i2) {
for (i=0; i<i1; i++) {
for (j=0; j<j2; j++) {
m3[i][j] = 0;
}
}
for (i=0;i<i1; i++) {
for (j=0; j<j2; j++) {
for (k=0; k<j1; k++) {
double mult = (m1[i][k] * m2[k][j]);
m3[i][j] = m3[i][j] + (m1[i][k] * m2[k][j]);
}
}
}
} else {
printf("\nError! Operation invalid, please enter with valid matrices.\n");
}
}
void fxp_matrix_multiplication( unsigned int i1, unsigned int j1, unsigned int i2, unsigned int j2, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t m3[4][4]){
unsigned int i, j, k;
if (j1 == i2) {
for (i=0; i<i1; i++) {
for (j=0; j<j2; j++) {
m3[i][j] = 0;
}
}
for (i=0;i<i1; i++) {
for (j=0; j<j2; j++) {
for (k=0; k<j1; k++) {
m3[i][j] = fxp_add( m3[i][j], fxp_mult(m1[i][k] , m2[k][j]));
}
}
}
} else {
printf("\nError! Operation invalid, please enter with valid matrices.\n");
}
}
void fxp_exp_matrix(unsigned int lines, unsigned int columns, fxp_t m1[4][4], unsigned int expNumber, fxp_t result[4][4]){
unsigned int i, j, l, k;
fxp_t m2[4][4];
if(expNumber == 0){
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
if(i == j){
result[i][j] = fxp_double_to_fxp(1.0);
} else {
result[i][j] = 0.0;
}
}
}
return;
}
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = m1[i][j];
if(expNumber == 1){
return;
}
for(l = 1; l < expNumber; l++){
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) m2[i][j] = result[i][j];
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = 0;
for (i=0;i<lines; i++) {
for (j=0; j<columns; j++) {
for (k=0; k<columns; k++) {
result[i][j] = fxp_add( result[i][j], fxp_mult(m2[i][k] , m1[k][j]));
}
}
}
}
}
void double_exp_matrix(unsigned int lines, unsigned int columns, double m1[4][4], unsigned int expNumber, double result[4][4]){
unsigned int i, j, k, l;
double m2[4][4];
if(expNumber == 0){
for (i = 0; i < lines; i++){
for (j = 0; j < columns; j++){
if(i == j){
result[i][j] = 1.0;
} else {
result[i][j] = 0.0;
}
}
}
return;
}
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = m1[i][j];
if(expNumber == 1){
return;
}
for(l = 1; l < expNumber; l++){
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) m2[i][j] = result[i][j];
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = 0;
for (i=0;i<lines; i++) {
for (j=0; j<columns; j++) {
for (k=0; k<columns; k++) {
result[i][j] = result[i][j] + (m2[i][k] * m1[k][j]);
}
}
}
}
}
void fxp_add_matrix( unsigned int lines, unsigned int columns, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) {
result[i][j] = fxp_add(m1[i][j] , m2[i][j]);
}
}
void fxp_sub_matrix( unsigned int lines, unsigned int columns, fxp_t m1[4][4], fxp_t m2[4][4], fxp_t result[4][4]){
unsigned int i, j;
for (i = 0; i < lines; i++)
for (j = 0; j < columns; j++) result[i][j] = fxp_sub(m1[i][j] , m2[i][j]);
}
void print_matrix(double matrix[4][4], unsigned int lines, unsigned int columns){
printf("\nMatrix\n=====================\n\n");
unsigned int i, j;
for (i=0; i<lines; i++) {
for (j=0; j<columns; j++) {
printf("#matrix[%d][%d]: %2.2f ", i,j,matrix[i][j]);
}
printf("\n");
}
printf("\n");
}
double determinant(double a[4][4],int n)
{
int i,j,j1,j2;
double det = 0;
double m[4][4];
if (n < 1) {
} else if (n == 1) {
det = a[0][0];
} else if (n == 2) {
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
} else {
det = 0;
for (j1=0;j1<n;j1++) {
for (i=0;i<n-1;i++)
for (i=1;i<n;i++) {
j2 = 0;
for (j=0;j<n;j++) {
if (j == j1)
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += internal_pow(-1.0,1.0+j1+1.0) * a[0][j1] * determinant(m,n-1);
}
}
return(det);
}
double fxp_determinant(fxp_t a_fxp[4][4],int n)
{
int i,j,j1,j2;
double a[4][4];
for(i=0; i<n;i++){
for(j=0; j<n;j++){
a[i][j]= fxp_to_double(a_fxp[i][j]);
}
}
double det = 0;
double m[4][4];
if (n < 1) {
} else if (n == 1) {
det = a[0][0];
} else if (n == 2) {
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
} else {
det = 0;
for (j1=0;j1<n;j1++) {
for (i=0;i<n-1;i++)
for (i=1;i<n;i++) {
j2 = 0;
for (j=0;j<n;j++) {
if (j == j1)
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += internal_pow(-1.0,1.0+j1+1.0) * a[0][j1] * determinant(m,n-1);
}
}
return(det);
}
void transpose(double a[4][4], double b[4][4],int n, int m)
{
int i,j;
for (i=0;i<n;i++) {
for (j=0;j<m;j++) {
b[j][i] = a[i][j];
}
}
}
void fxp_transpose(fxp_t a[4][4], fxp_t b[4][4],int n, int m)
{
int i,j;
for (i=0;i<n;i++) {
for (j=0;j<m;j++) {
b[j][i] = a[i][j];
}
}
}
# 24 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
extern int generic_timer;
extern hardware hw;
double generic_timing_shift_l_double(double zIn, double z[], int N) {
generic_timer += ((2 * hw.assembly.push) + (3 * hw.assembly.in) + (3 * hw.assembly.out) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (8 * hw.assembly.std));
int i;
double zOut;
zOut = z[0];
generic_timer += ((5 * hw.assembly.ldd) + (2 * hw.assembly.mov) + (4 * hw.assembly.std) + (1 * hw.assembly.ld));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (i = 0; i < N - 1; i++) {
generic_timer += ((17 * hw.assembly.ldd) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (6 * hw.assembly.mov) + (2 * hw.assembly.adiw) + (5 * hw.assembly.std) + (1 * hw.assembly.ld) + (1 * hw.assembly.st) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbc)+ (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
z[i] = z[i + 1];
}
z[N - 1] = zIn;
generic_timer += ((12 * hw.assembly.ldd) + (6 * hw.assembly.mov) + (3 * hw.assembly.std) + (2 * hw.assembly.lsl) + (2 * hw.assembly.rol) + (1 * hw.assembly.adc) + (1 * hw.assembly.add) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in)+ (1 * hw.assembly.cli));
generic_timer += ((3 * hw.assembly.out) + (2 * hw.assembly.pop) + (1 * hw.assembly.ret));
return (zOut);
}
double generic_timing_shift_r_double(double zIn, double z[], int N) {
generic_timer += ((2 * hw.assembly.push) + (3 * hw.assembly.in) + (3 * hw.assembly.out) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (8 * hw.assembly.std));
int i;
double zOut;
zOut = z[N - 1];
generic_timer += ((7 * hw.assembly.ldd) + (2 * hw.assembly.rol) + (2 * hw.assembly.lsl) + (2 * hw.assembly.mov) + (4 * hw.assembly.std) + (1 * hw.assembly.add) + (1 * hw.assembly.adc) + (1 * hw.assembly.ld) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci));
generic_timer += ((2 * hw.assembly.ldd) + (2 * hw.assembly.std) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.rjmp));
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
generic_timer += ((15 * hw.assembly.ldd) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (4 * hw.assembly.mov) + (5 * hw.assembly.std) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.ld) + (1 * hw.assembly.st) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
}
z[0] = zIn;
generic_timer += ((10 * hw.assembly.ldd) + (5 * hw.assembly.mov) + (3 * hw.assembly.std) + (3 * hw.assembly.out) + (2 * hw.assembly.pop) + (1 * hw.assembly.ret) + (1 * hw.assembly.ret) + (1 * hw.assembly.cli) + (1 * hw.assembly.in) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw));
return zOut;
}
fxp_t shiftL(fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
fxp_t shiftR(fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
float shiftLfloat(float zIn, float z[], int N) {
int i;
float zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
float shiftRfloat(float zIn, float z[], int N) {
int i;
float zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
double shiftRDdouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
double shiftRdouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
}
z[0] = zIn;
return zOut;
}
double shiftLDouble(double zIn, double z[], int N) {
int i;
double zOut;
zOut = z[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
}
z[N - 1] = zIn;
return (zOut);
}
void shiftLboth(float zfIn, float zf[], fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
float zfOut;
zOut = z[0];
zfOut = zf[0];
for (i = 0; i < N - 1; i++) {
z[i] = z[i + 1];
zf[i] = zf[i + 1];
}
z[N - 1] = zIn;
zf[N - 1] = zfIn;
}
void shiftRboth(float zfIn, float zf[], fxp_t zIn, fxp_t z[], int N) {
int i;
fxp_t zOut;
float zfOut;
zOut = z[N - 1];
zfOut = zf[N - 1];
for (i = N - 1; i > 0; i--) {
z[i] = z[i - 1];
zf[i] = zf[i - 1];
}
z[0] = zIn;
zf[0] = zfIn;
}
int order(int Na, int Nb) {
return Na > Nb ? Na - 1 : Nb - 1;
}
void fxp_check_limit_cycle(fxp_t y[], int y_size){
fxp_t reference = y[y_size - 1];
int idx = 0;
int window_size = 1;
for(idx = (y_size-2); idx >= 0; idx--){
if (y[idx] != reference){
window_size++;
}else{
break;
}
}
__DSVERIFIER_assume(window_size != y_size && window_size != 1);
printf("window_size %d\n", window_size);
int desired_elements = 2 * window_size;
int found_elements = 0;
for(idx = (y_size-1); idx >= 0; idx--){
if (idx > (y_size-window_size-1)){
printf("%.0f == %.0f\n", y[idx], y[idx-window_size]);
int cmp_idx = idx - window_size;
if ((cmp_idx > 0) && (y[idx] == y[idx-window_size])){
found_elements = found_elements + 2;
}else{
break;
}
}
}
__DSVERIFIER_assume(found_elements > 0);
printf("desired_elements %d\n", desired_elements);
printf("found_elements %d\n", found_elements);
__DSVERIFIER_assume(found_elements == desired_elements);
__DSVERIFIER_assert(0);
}
void fxp_check_persistent_limit_cycle(fxp_t * y, int y_size){
int idy = 0;
int count_same = 0;
int window_size = 0;
fxp_t reference = y[0];
for(idy = 0; idy < y_size; idy++){
if (y[idy] != reference){
window_size++;
} else if (window_size != 0){
break;
} else {
count_same++;
}
}
window_size += count_same;
__DSVERIFIER_assume(window_size > 1 && window_size <= y_size/2);
fxp_t lco_elements[window_size];
for(idy = 0; idy < y_size; idy++){
if (idy < window_size){
lco_elements[idy] = y[idy];
}
}
idy = 0;
int lco_idy = 0;
_Bool is_persistent = 0;
while (idy < y_size){
if(y[idy++] == lco_elements[lco_idy++]){
is_persistent = 1;
}else{
is_persistent = 0;
break;
}
if (lco_idy == window_size){
lco_idy = 0;
}
}
__DSVERIFIER_assert(is_persistent == 0);
}
void fxp_check_oscillations(fxp_t y[] , int y_size){
__DSVERIFIER_assume((y[0] != y[y_size - 1]) && (y[y_size - 1] != y[y_size - 2]));
int window_timer = 0;
int window_count = 0;
int i, j;
for (i = 2; i < y_size; i++){
int window_size = i;
for(j=0; j<y_size; j++){
if (window_timer > window_size){
window_timer = 0;
window_count = 0;
}
int window_index = j + window_size;
if (window_index < y_size){
if (y[j] == y[window_index]){
window_count++;
__DSVERIFIER_assert(!(window_count == window_size));
}
}else{
break;
}
window_timer++;
}
}
}
int fxp_ln(int x) {
int t, y;
y = 0xa65af;
if (x < 0x00008000)
x <<= 16, y -= 0xb1721;
if (x < 0x00800000)
x <<= 8, y -= 0x58b91;
if (x < 0x08000000)
x <<= 4, y -= 0x2c5c8;
if (x < 0x20000000)
x <<= 2, y -= 0x162e4;
if (x < 0x40000000)
x <<= 1, y -= 0x0b172;
t = x + (x >> 1);
if ((t & 0x80000000) == 0)
x = t, y -= 0x067cd;
t = x + (x >> 2);
if ((t & 0x80000000) == 0)
x = t, y -= 0x03920;
t = x + (x >> 3);
if ((t & 0x80000000) == 0)
x = t, y -= 0x01e27;
t = x + (x >> 4);
if ((t & 0x80000000) == 0)
x = t, y -= 0x00f85;
t = x + (x >> 5);
if ((t & 0x80000000) == 0)
x = t, y -= 0x007e1;
t = x + (x >> 6);
if ((t & 0x80000000) == 0)
x = t, y -= 0x003f8;
t = x + (x >> 7);
if ((t & 0x80000000) == 0)
x = t, y -= 0x001fe;
x = 0x80000000 - x;
y -= x >> 15;
return y;
}
double fxp_log10_low(double x) {
int xint = (int) (x * 65536.0 + 0.5);
int lnum = fxp_ln(xint);
int lden = fxp_ln(655360);
return ((double) lnum / (double) lden);
}
double fxp_log10(double x) {
if (x > 32767.0) {
if (x > 1073676289.0) {
x = x / 1073676289.0;
return fxp_log10_low(x) + 9.030873362;
}
x = x / 32767.0;
return fxp_log10_low(x) + 4.515436681;
}
return fxp_log10_low(x);
}
float snrVariance(float s[], float n[], int blksz) {
int i;
double sm = 0, nm = 0, sv = 0, nv = 0, snr;
for (i = 0; i < blksz; i++) {
sm += s[i];
nm += n[i];
}
sm /= blksz;
nm /= blksz;
for (i = 0; i < blksz; i++) {
sv += (s[i] - sm) * (s[i] - sm);
nv += (n[i] - nm) * (n[i] - nm);
}
if (nv != 0.0f) {
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"sv >= nv"
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 373, __extension__ __PRETTY_FUNCTION__); }))
# 373 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
snr = sv / nv;
return snr;
} else {
return 9999.9f;
}
}
float snrPower(float s[], float n[], int blksz) {
int i;
double sv = 0, nv = 0, snr;
for (i = 0; i < blksz; i++) {
sv += s[i] * s[i];
nv += n[i] * n[i];
}
if (nv != 0.0f) {
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
sv >= nv
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"sv >= nv"
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 394, __extension__ __PRETTY_FUNCTION__); }))
# 394 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
snr = sv / nv;
return snr;
} else {
return 9999.9f;
}
}
float snrPoint(float s[], float n[], int blksz) {
int i;
double ratio = 0, power = 0;
for (i = 0; i < blksz; i++) {
if(n[i] == 0) continue;
ratio = s[i] / n[i];
if(ratio > 150.0f || ratio < -150.0f) continue;
power = ratio * ratio;
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
power >= 1.0f
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
power >= 1.0f
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"power >= 1.0f"
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 412, __extension__ __PRETTY_FUNCTION__); }))
# 412 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
}
return 9999.9f;
}
unsigned long next = 1;
int rand(void)
{
next = next*1103515245 + 12345;
return (unsigned int)(next/65536) % 32768;
}
void srand(unsigned int seed)
{
next = seed;
}
float iirIIOutTime(float w[], float x, float a[], float b[], int Na, int Nb) {
int timer1 = 0;
float *a_ptr, *b_ptr, *w_ptr;
float sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
timer1 += 71;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
timer1 += 54;
}
w[0] += x;
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
timer1 += 46;
}
timer1 += 38;
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 450, __extension__ __PRETTY_FUNCTION__); }))
# 450 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return sum;
}
float iirIItOutTime(float w[], float x, float a[], float b[], int Na, int Nb) {
int timer1 = 0;
float *a_ptr, *b_ptr;
float yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 477, __extension__ __PRETTY_FUNCTION__); }))
# 477 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return yout;
}
double iirIItOutTime_double(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
((void) sizeof ((
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
(double)timer1*1 / 16000000 <= (double)1 / 100
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
) ; else __assert_fail (
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
"(double)timer1*CYCLE <= (double)DEADLINE"
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h", 504, __extension__ __PRETTY_FUNCTION__); }))
# 504 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/functions.h"
;
return yout;
}
void iirOutBoth(float yf[], float xf[], float af[], float bf[], float *sumf_ref,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t *sum_ref, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
fxp_t sum = 0;
float sumf = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
af_ptr = &af[1];
yf_ptr = &yf[Na - 1];
bf_ptr = &bf[0];
xf_ptr = &xf[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *x_ptr--));
sumf += *bf_ptr++ * *xf_ptr--;
}
for (j = 1; j < Na; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr++, *y_ptr--));
sumf -= *af_ptr++ * *yf_ptr--;
}
*sum_ref = sum;
*sumf_ref = sumf;
}
fxp_t iirOutFixedL(fxp_t y[], fxp_t x[], fxp_t xin, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[j] = y[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[Na - 1] = sum;
return sum;
}
float iirOutFloatL(float y[], float x[], float xin, float a[], float b[], int Na, int Nb) {
float *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum += *b_ptr-- * *x_ptr++;
}
x[Nb - 1] = xin;
sum += *b_ptr-- * *x_ptr++;
for (j = 1; j < Na - 1; j++) {
sum -= *a_ptr-- * *y_ptr++;
y[j] = y[j+1];
}
if(Na>1) sum -= *a_ptr-- * *y_ptr++;
y[Na - 1] = sum;
return sum;
}
float iirOutBothL(float yf[], float xf[], float af[], float bf[], float xfin,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t xin, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
float sumf = 0;
af_ptr = &af[Na - 1];
yf_ptr = &yf[1];
bf_ptr = &bf[Nb - 1];
xf_ptr = &xf[0];
int i, j;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
xf[i] = xf[i+1];
sumf += *bf_ptr-- * *xf_ptr++;
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(*b_ptr--, *x_ptr++));
xf[Nb - 1] = xfin;
sumf += *bf_ptr-- * *xf_ptr++;
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[j] = y[j+1];
sumf -= *af_ptr-- * *yf_ptr++;
yf[j] = yf[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(*a_ptr--, *y_ptr++));
y[Na - 1] = sum;
if(Na>1) sumf -= *af_ptr-- * *yf_ptr++;
yf[Na - 1] = sumf;
return fxp_to_float(sum) - sumf;
}
float iirOutBothL2(float yf[], float xf[], float af[], float bf[], float xfin,
fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], fxp_t xin, int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[Na - 1];
y_ptr = &y[1];
b_ptr = &b[Nb - 1];
x_ptr = &x[0];
float *af_ptr, *yf_ptr, *bf_ptr, *xf_ptr;
float sumf = 0;
af_ptr = &af[Na - 1];
yf_ptr = &yf[1];
bf_ptr = &bf[Nb - 1];
xf_ptr = &xf[0];
int i=0, j=1;
for (i = 0; i < Nb - 1; i++) {
x[i] = x[i+1];
sum = fxp_add(sum, fxp_mult(b[Nb - 1 - i], x[i]));
xf[i] = xf[i+1];
sumf += bf[Nb - 1 - i] * xf[i];
}
x[Nb - 1] = xin;
sum = fxp_add(sum, fxp_mult(b[Nb - 1 - i], x[i]));
xf[Nb - 1] = xfin;
sumf += bf[Nb - 1 - i] * xf[i];
for (j = 1; j < Na - 1; j++) {
sum = fxp_sub(sum, fxp_mult(a[Na - j], y[j]));
y[j] = y[j+1];
sumf -= af[Na - j] * yf[j];
yf[j] = yf[j+1];
}
if(Na>1) sum = fxp_sub(sum, fxp_mult(a[Na - j], y[j]));
y[Na - 1] = sum;
if(Na>1) sumf -= af[Na - j] * yf[j];
yf[Na - 1] = sumf;
return fxp_to_float(sum) - sumf;
}
# 25 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
extern digital_system ds;
extern hardware hw;
extern int generic_timer;
fxp_t fxp_direct_form_1(fxp_t y[], fxp_t x[], fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *y_ptr, *b_ptr, *x_ptr;
fxp_t sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *x_ptr--));
}
for (j = 1; j < Na; j++) {
sum = fxp_sub(sum, fxp_mult(*a_ptr++, *y_ptr--));
}
fxp_verify_overflow_node(sum, "An Overflow Occurred in the node a0");
sum = fxp_div(sum,a[0]);
return fxp_quantize(sum);
}
fxp_t fxp_direct_form_2(fxp_t w[], fxp_t x, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *b_ptr, *w_ptr;
fxp_t sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] = fxp_sub(w[0], fxp_mult(*a_ptr++, *w_ptr++));
}
w[0] = fxp_add(w[0], x);
w[0] = fxp_div(w[0], a[0]);
fxp_verify_overflow_node(w[0], "An Overflow Occurred in the node b0");
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum = fxp_add(sum, fxp_mult(*b_ptr++, *w_ptr++));
}
return fxp_quantize(sum);
}
fxp_t fxp_transposed_direct_form_2(fxp_t w[], fxp_t x, fxp_t a[], fxp_t b[], int Na, int Nb) {
fxp_t *a_ptr, *b_ptr;
fxp_t yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = fxp_add(fxp_mult(*b_ptr++, x), w[0]);
yout = fxp_div(yout, a[0]);
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] = fxp_sub(w[j], fxp_mult(*a_ptr++, yout));
}
if (j < Nb - 1) {
w[j] = fxp_add(w[j], fxp_mult(*b_ptr++, x));
}
}
fxp_verify_overflow_node(w[j], "An Overflow Occurred in the node a0");
return fxp_quantize(yout);
}
double double_direct_form_1(double y[], double x[], double a[], double b[], int Na, int Nb) {
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum += *b_ptr++ * *x_ptr--;
}
for (j = 1; j < Na; j++) {
sum -= *a_ptr++ * *y_ptr--;
}
sum = (sum / a[0]);
return sum;
}
double double_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
}
return sum;
}
double double_transposed_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
yout = yout / a[0];
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
}
return yout;
}
float float_direct_form_1(float y[], float x[], float a[], float b[], int Na, int Nb) {
float *a_ptr, *y_ptr, *b_ptr, *x_ptr;
float sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na - 1];
b_ptr = &b[0];
x_ptr = &x[Nb - 1];
int i, j;
for (i = 0; i < Nb; i++) {
sum += *b_ptr++ * *x_ptr--;
}
for (j = 1; j < Na; j++) {
sum -= *a_ptr++ * *y_ptr--;
}
sum = (sum / a[0]);
return sum;
}
float float_direct_form_2(float w[], float x, float a[], float b[], int Na, int Nb) {
float *a_ptr, *b_ptr, *w_ptr;
float sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
}
return sum;
}
float float_transposed_direct_form_2(float w[], float x, float a[], float b[], int Na, int Nb) {
float *a_ptr, *b_ptr;
float yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
yout = yout / a[0];
int j;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
}
return yout;
}
double double_direct_form_1_MSP430(double y[], double x[], double a[], double b[], int Na, int Nb){
int timer1 = 0;
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na-1];
b_ptr = &b[0];
x_ptr = &x[Nb-1];
int i, j;
timer1 += 91;
for (i = 0; i < Nb; i++){
sum += *b_ptr++ * *x_ptr--;
timer1 += 47;
}
for (j = 1; j < Na; j++){
sum -= *a_ptr++ * *y_ptr--;
timer1 += 57;
}
timer1 += 3;
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 235, __extension__ __PRETTY_FUNCTION__); }))
# 235 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return sum;
}
double double_direct_form_2_MSP430(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
timer1 += 71;
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
timer1 += 54;
}
w[0] += x;
w[0] = w[0] / a[0];
w_ptr = &w[0];
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
timer1 += 46;
}
timer1 += 38;
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 262, __extension__ __PRETTY_FUNCTION__); }))
# 262 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return sum;
}
double double_transposed_direct_form_2_MSP430(double w[], double x, double a[], double b[], int Na, int Nb) {
int timer1 = 0;
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
timer1 += 105;
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
timer1 += 41;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
timer1 += 38;
}
timer1 += 54;
}
timer1 += 7;
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
((void) sizeof ((
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
(double) timer1 * hw.cycle <= ds.sample_time
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
) ; else __assert_fail (
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
"(double) timer1 * hw.cycle <= ds.sample_time"
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h", 291, __extension__ __PRETTY_FUNCTION__); }))
# 291 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/realizations.h"
;
return yout;
}
double generic_timing_double_direct_form_1(double y[], double x[], double a[], double b[], int Na, int Nb){
generic_timer += ((6 * hw.assembly.push) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (12 * hw.assembly.std));
double *a_ptr, *y_ptr, *b_ptr, *x_ptr;
double sum = 0;
a_ptr = &a[1];
y_ptr = &y[Na-1];
b_ptr = &b[0];
x_ptr = &x[Nb-1];
generic_timer += ((12 * hw.assembly.std) + (12 * hw.assembly.ldd) + (2 * hw.assembly.subi) + (2 * hw.assembly.sbci) + (4 * hw.assembly.lsl) + (4 * hw.assembly.rol) + (2 * hw.assembly.add) + (2 * hw.assembly.adc) + (1 * hw.assembly.adiw));
int i, j;
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (i = 0; i < Nb; i++){
generic_timer += ((20 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.sbc) + (10 * hw.assembly.std) + (2 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
sum += *b_ptr++ * *x_ptr--;
}
generic_timer += ((2 * hw.assembly.ldi) + (2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 1; j < Na; j++){
generic_timer += ((22 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.subi) + (8 * hw.assembly.std) + (1 * hw.assembly.sbci) + (2 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (1 * hw.assembly.sbc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.adiw) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
sum -= *a_ptr++ * *y_ptr--;
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (6 * hw.assembly.pop) + (1 * hw.assembly.ret));
return sum;
}
double generic_timing_double_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
generic_timer += ((8 * hw.assembly.push) + (14 * hw.assembly.std) + (3 * hw.assembly.out) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli));
double *a_ptr, *b_ptr, *w_ptr;
double sum = 0;
a_ptr = &a[1];
b_ptr = &b[0];
w_ptr = &w[1];
int k, j;
generic_timer += ((10 * hw.assembly.std) + (6 * hw.assembly.ldd) + (2 * hw.assembly.adiw));
generic_timer += ((2 * hw.assembly.ldi) + (2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 1; j < Na; j++) {
w[0] -= *a_ptr++ * *w_ptr++;
generic_timer += ((23 * hw.assembly.ldd) + (32 * hw.assembly.mov) + (9 * hw.assembly.std) + (2 * hw.assembly.subi) + (3 * hw.assembly.ld) + (2 * hw.assembly.rcall) + (2 * hw.assembly.sbci) + (1 * hw.assembly.st) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brge));
}
w[0] += x;
w_ptr = &w[0];
generic_timer += ((13 * hw.assembly.ldd) + (12 * hw.assembly.mov) + (5 * hw.assembly.std) + (1 * hw.assembly.st) + (1 * hw.assembly.ld) + (1 * hw.assembly.rcall));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (k = 0; k < Nb; k++) {
sum += *b_ptr++ * *w_ptr++;
generic_timer += ((20 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (10 * hw.assembly.std) + (2 * hw.assembly.rcall) + (2 * hw.assembly.ld) + (2 * hw.assembly.subi) + (2 * hw.assembly.sbci) + (1 * hw.assembly.adiw) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brge) + (1 * hw.assembly.rjmp));
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (1 * hw.assembly.adiw) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (3 * hw.assembly.out) + (8 * hw.assembly.pop) + (1 * hw.assembly.ret));
return sum;
}
double generic_timing_double_transposed_direct_form_2(double w[], double x, double a[], double b[], int Na, int Nb) {
generic_timer += ((8 * hw.assembly.push) + (14 * hw.assembly.std) + (3 * hw.assembly.out) + (3 * hw.assembly.in) + (1 * hw.assembly.sbiw) + (1 * hw.assembly.cli));
double *a_ptr, *b_ptr;
double yout = 0;
a_ptr = &a[1];
b_ptr = &b[0];
int Nw = Na > Nb ? Na : Nb;
yout = (*b_ptr++ * x) + w[0];
int j;
generic_timer += ((15 * hw.assembly.std) + (22 * hw.assembly.ldd) + (24 * hw.assembly.mov) + (2 * hw.assembly.rcall) + (2 * hw.assembly.ld) + (1 * hw.assembly.cp) + (1 * hw.assembly.cpc) + (1 * hw.assembly.subi) + (1 * hw.assembly.sbci) + (1 * hw.assembly.brge) + (1 * hw.assembly.adiw));
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
for (j = 0; j < Nw - 1; j++) {
w[j] = w[j + 1];
if (j < Na - 1) {
w[j] -= *a_ptr++ * yout;
}
if (j < Nb - 1) {
w[j] += *b_ptr++ * x;
}
generic_timer += ((70 * hw.assembly.mov) + (65 * hw.assembly.ldd) + (12 * hw.assembly.lsl) + (12 * hw.assembly.rol) + (15 * hw.assembly.std) + (6 * hw.assembly.add) + (6 * hw.assembly.adc) + (2 * hw.assembly.adiw) + (3 * hw.assembly.cpc) + (3 * hw.assembly.cp) + (5 * hw.assembly.ld) + (4 * hw.assembly.rcall) + (5 * hw.assembly.subi) + (3 * hw.assembly.rjmp) + (2 * hw.assembly.brlt) + (3 * hw.assembly.st) + (2 * hw.assembly.sbci) + (3 * hw.assembly.sbc) + (1 * hw.assembly.brge));
}
generic_timer += ((4 * hw.assembly.ldd) + (4 * hw.assembly.mov) + (8 * hw.assembly.pop) + (3 * hw.assembly.out) + (1 * hw.assembly.in) + (1 * hw.assembly.cli) + (1 * hw.assembly.adiw) + (1 * hw.assembly.ret));
return yout;
}
void double_direct_form_1_impl2(double x[], int x_size, double b[], int b_size, double a[], int a_size, double y[]){
int i = 0; int j = 0;
double v[x_size];
for(i = 0; i < x_size; i++){
v[i] = 0;
for(j = 0; j < b_size; j++){
if (j > i) break;
v[i] = v[i] + x[i-j] * b[j];
}
}
y[0] = v[0];
for(i = 1; i < x_size; i++){
y[i] = 0;
y[i] = y[i] + v[i];
for(j = 1; j < a_size; j++){
if (j > i) break;
y[i] = y[i] + y[i-j] * ((-1) * a[j]);
}
}
}
void fxp_direct_form_1_impl2(fxp_t x[], int x_size, fxp_t b[], int b_size, fxp_t a[], int a_size, fxp_t y[]){
int i = 0; int j = 0;
fxp_t v[x_size];
for(i = 0; i < x_size; i++){
v[i] = 0;
for(j = 0; j < b_size; j++){
if (j > i) break;
v[i] = fxp_add(v[i], fxp_mult(x[i-j], b[j]));
}
}
y[0] = v[0];
for(i = 1; i < x_size; i++){
y[i] = 0;
y[i] = fxp_add(y[i], v[i]);
for(j = 1; j < a_size; j++){
if (j > i) break;
y[i] = fxp_add(y[i], fxp_mult(y[i-j] , -a[j]));
}
}
}
# 26 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h"
# 1 "/usr/include/assert.h" 1 3 4
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/delta-operator.h" 2
int nchoosek(int n, int k){
if (k == 0)
return 1;
return (n * nchoosek(n - 1, k - 1)) / k;
}
void generate_delta_coefficients(double vetor[], double out[], int n, double delta){
int i,j;
int N = n - 1;
double sum_delta_operator;
for(i=0; i<=N; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + vetor[j]*nchoosek(N-j,i-j);
}
out[i] = internal_pow(delta,N-i)*sum_delta_operator;
}
}
void get_delta_transfer_function(double b[], double b_out[], int b_size, double a[], double a_out[], int a_size, double delta){
generate_delta_coefficients(b, b_out, b_size, delta);
generate_delta_coefficients(a, a_out, a_size, delta);
}
void get_delta_transfer_function_with_base(double b[], double b_out[], int b_size, double a[], double a_out[], int a_size, double delta){
int i,j;
int N = a_size - 1;
int M = b_size - 1;
double sum_delta_operator;
for(i=0; i<=N; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + a[j]*nchoosek(N-j,i-j);
}
a_out[i] = internal_pow(delta,N-i)*sum_delta_operator;
}
for(i=0; i<=M; i++)
{
sum_delta_operator = 0;
for(j=0; j<=i; j++)
{
sum_delta_operator = sum_delta_operator + b[j]*nchoosek(M-j,i-j);
}
b_out[i] = internal_pow(delta,M-i)*sum_delta_operator;
}
}
# 27 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/closed-loop.h" 1
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/closed-loop.h"
void ft_closedloop_series(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
Nans_num = Nc_num + Nmodel_num - 1;
Nans_den = Nc_den + Nmodel_den - 1 ;
double den_mult [Nans_den];
poly_mult(c_num, Nc_num, model_num, Nmodel_num, ans_num, Nans_num);
poly_mult(c_den, Nc_den, model_den, Nmodel_den, den_mult, Nans_den );
poly_sum(ans_num, Nans_num , den_mult, Nans_den , ans_den, Nans_den);
}
void ft_closedloop_sensitivity(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
int Nans_num_p = Nc_num + Nmodel_num-1;
Nans_den = Nc_den + Nmodel_den-1;
Nans_num = Nc_den + Nmodel_den-1;
double num_mult [Nans_num_p];
poly_mult(c_den, Nc_den, model_den, Nmodel_den, ans_num, Nans_num);
poly_mult(c_num, Nc_num, model_num, Nmodel_num, num_mult, Nans_num_p);
poly_sum(ans_num, Nans_num, num_mult, Nans_num_p, ans_den, Nans_den);
}
void ft_closedloop_feedback(double c_num[], int Nc_num, double c_den[], int Nc_den, double model_num[], int Nmodel_num, double model_den[], int Nmodel_den, double ans_num[], int Nans_num, double ans_den[], int Nans_den){
Nans_num = Nc_den + Nmodel_num - 1;
Nans_den = Nc_den + Nmodel_den - 1;
int Nnum_mult = Nc_num + Nmodel_num - 1;
double den_mult [Nans_den];
double num_mult [Nnum_mult];
poly_mult(c_num, Nc_num, model_num, Nmodel_num, num_mult, Nnum_mult);
poly_mult(c_den, Nc_den, model_den, Nmodel_den, den_mult, Nans_den);
poly_sum(num_mult, Nnum_mult, den_mult, Nans_den, ans_den, Nans_den);
poly_mult(c_den, Nc_den, model_num, Nmodel_num, ans_num, Nans_num);
}
int check_stability_closedloop(double a[], int n, double plant_num[], int p_num_size, double plant_den[], int p_den_size){
int columns = n;
double m[2 * n - 1][n];
int i,j;
int first_is_positive = 0;
double * p_num = plant_num;
double * p_den = plant_den;
double sum = 0;
for (i=0; i < n; i++){
sum += a[i];
}
__DSVERIFIER_assert(sum > 0);
sum = 0;
for (i=0; i < n; i++){
sum += a[i] * internal_pow(-1, n-1-i);
}
sum = sum * internal_pow(-1, n-1);
__DSVERIFIER_assert(sum > 0);
__DSVERIFIER_assert(internal_abs(a[n-1]) < a[0]);
for (i=0; i < 2 * n - 1; i++){
for (j=0; j < columns; j++){
m[i][j] = 0;
if (i == 0){
m[i][j] = a[j];
continue;
}
if (i % 2 != 0 ){
int x;
for(x=0; x<columns;x++){
m[i][x] = m[i-1][columns-x-1];
}
columns = columns - 1;
j = columns;
}else{
__DSVERIFIER_assert(m[i-2][0] > 0);
m[i][j] = m[i-2][j] - (m[i-2][columns] / m[i-2][0]) * m[i-1][j];
__DSVERIFIER_assert((m[0][0] >= 0) && (m[i][0] >= 0));
}
}
}
return 1;
}
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
extern digital_system ds;
extern digital_system plant;
extern digital_system control;
extern implementation impl;
extern filter_parameters filter;
extern hardware hw;
void initialization(){
if (impl.frac_bits >= 32){
printf("impl.frac_bits must be less than word width!\n");
}
if (impl.int_bits >= 32 - impl.frac_bits){
printf("impl.int_bits must be less than word width subtracted by precision!\n");
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
((void) sizeof ((
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
0
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
0
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
) ; else __assert_fail (
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
"0"
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h", 33, __extension__ __PRETTY_FUNCTION__); }))
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
;
}
if(impl.frac_bits >= 31){
_fxp_one = 0x7fffffff;
}else{
_fxp_one = (0x00000001 << impl.frac_bits);
}
_fxp_half = (0x00000001 << (impl.frac_bits - 1));
_fxp_minus_one = -(0x00000001 << impl.frac_bits);
_fxp_min = -(0x00000001 << (impl.frac_bits + impl.int_bits - 1));
_fxp_max = (0x00000001 << (impl.frac_bits + impl.int_bits - 1)) - 1;
_fxp_fmask = ((((int32_t) 1) << impl.frac_bits) - 1);
_fxp_imask = ((0x80000000) >> (32 - impl.frac_bits - 1));
_dbl_min = _fxp_min;
_dbl_min /= (1 << impl.frac_bits);
_dbl_max = _fxp_max;
_dbl_max /= (1 << impl.frac_bits);
if ((impl.scale == 0) || (impl.scale == 1)){
impl.scale = 1;
return;
}
if (impl.min != 0){
impl.min = impl.min / impl.scale;
}
if (impl.max != 0){
impl.max = impl.max / impl.scale;
}
# 80 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/initialization.h"
}
# 29 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/state-space.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/state-space.h"
extern digital_system_state_space _controller;
extern int nStates;
extern int nInputs;
extern int nOutputs;
double double_state_space_representation(void){
double result1[4][4];
double result2[4][4];
int i, j;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
return _controller.outputs[0][0];
}
double fxp_state_space_representation(void){
fxp_t result1[4][4];
fxp_t result2[4][4];
int i, j;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
fxp_t A_fpx[4][4];
fxp_t B_fpx[4][4];
fxp_t C_fpx[4][4];
fxp_t D_fpx[4][4];
fxp_t states_fpx[4][4];
fxp_t inputs_fpx[4][4];
fxp_t outputs_fpx[4][4];
for(i=0; i<4;i++){
for(j=0; j<4;j++){
A_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
B_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
C_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
D_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
states_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
inputs_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
outputs_fpx[i][j]=0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
B_fpx[i][j]= fxp_double_to_fxp(_controller.B[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
C_fpx[i][j]= fxp_double_to_fxp(_controller.C[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
D_fpx[i][j]= fxp_double_to_fxp(_controller.D[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
states_fpx[i][j]= fxp_double_to_fxp(_controller.states[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
inputs_fpx[i][j]= fxp_double_to_fxp(_controller.inputs[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
outputs_fpx[i][j]= fxp_double_to_fxp(_controller.outputs[i][j]);
}
}
fxp_matrix_multiplication(nOutputs,nStates,nStates,1,C_fpx,states_fpx,result1);
fxp_matrix_multiplication(nOutputs,nInputs,nInputs,1,D_fpx,inputs_fpx,result2);
fxp_add_matrix(nOutputs,
1,
result1,
result2,
outputs_fpx);
fxp_matrix_multiplication(nStates,nStates,nStates,1,A_fpx,states_fpx,result1);
fxp_matrix_multiplication(nStates,nInputs,nInputs,1,B_fpx,inputs_fpx,result2);
fxp_add_matrix(nStates,
1,
result1,
result2,
states_fpx);
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= fxp_to_double(states_fpx[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
_controller.outputs[i][j]= fxp_to_double(outputs_fpx[i][j]);
}
}
return _controller.outputs[0][0];
}
# 30 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/filter_functions.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/core/filter_functions.h"
double sinTyl(double x, int precision){
double sine;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
sine = aux;
if (precision >= 1)
{
aux = x;
sine += aux;
if (precision >= 2)
{
aux = aux*xsquared;
sine -= aux/6;
if (precision >= 3)
{
aux = aux*xsquared;
sine +=aux/120;
if(precision >=4)
{
aux = aux*xsquared;
sine -=aux/5040;
if(precision >= 5)
{
aux = aux*xsquared;
sine +=aux/362880;
if(precision >= 6)
{
aux = aux*xsquared;
sine -=aux/39916800;
if (precision >= 7)
printf("Warning: Function sinTyl "
"from bmc/core/filter_functions.h: Precision "
"representation exceeded. Assuming maximum precision of 6\n");
}
}
}
}
}
}
}
return sine;
}
double cosTyl(double x, int precision){
double cosine;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function cosTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
cosine = aux;
if (precision >= 1)
{
aux = 1;
cosine = 1;
if (precision >= 2)
{
aux = xsquared;
cosine -= aux/2;
if (precision >= 3)
{
aux = aux*xsquared;
cosine += aux/24;
if(precision >=4)
{
aux = aux*xsquared;
cosine -=aux/720;
if(precision >= 5)
{
aux = aux*xsquared;
cosine +=aux/40320;
if(precision >= 6)
{
aux = aux*xsquared;
cosine -=aux/3628800;
if (precision >= 7) printf("Warning: Function sinTyl "
"from bmc/core/filter_functions.h: Precision "
"representation exceeded. Assuming maximum precision of 6\n");
}
}
}
}
}
}
}
return cosine;
}
double atanTyl(double x, int precision){
double atangent;
double xsquared = x*x;
double aux;
if (precision < 0)
{
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision must be a positive integer. Assuming 0 precision\n");
precision = 0;
}
if (precision >= 0)
{
aux = 0;
atangent = aux;
if (precision >= 1)
{
aux = x;
atangent = aux;
if (precision >= 2)
{
aux = xsquared;
atangent -= aux/3;
if (precision >= 3)
{
aux = aux*xsquared;
atangent += aux/5;
if(precision >=4)
{
aux = aux*xsquared;
atangent -=aux/7;
if (precision >= 7)
printf("Warning: Function sinTyl from bmc/core/filter_functions.h: "
"Precision representation exceeded. Assuming maximum precision of 4\n");
}
}
}
}
}
return atangent;
}
float sqrt1(const float x)
{
const float xhalf = 0.5f*x;
union
{
float x;
int i;
} u;
u.x = x;
u.i = 0x5f3759df - (u.i >> 1);
return x*u.x*(1.5f - xhalf*u.x*u.x);
}
float sqrt2(const float x)
{
union
{
int i;
float x;
} u;
u.x = x;
u.i = (1<<29) + (u.i >> 1) - (1<<22);
return u.x;
}
float fabsolut(float x)
{
if (x < 0)
x = -x;
return x;
}
static float sqrt3(float val)
{
float x = val/10;
float dx;
double diff;
double min_tol = 0.00001;
int i, flag;
flag = 0;
if (val == 0 ) x = 0;
else
{
for (i=1;i<20;i++)
{
if (!flag)
{
dx = (val - (x*x)) / (2.0 * x);
x = x + dx;
diff = val - (x*x);
if (fabsolut(diff) <= min_tol) flag = 1;
}
else x =x;
}
}
return (x);
}
# 31 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h" 1
# 19 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
int verify_overflow(void) {
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 73 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_int();
__DSVERIFIER_assume(x[i] >= min_fxp && x[i] <= max_fxp);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for (i = 0; i < X_SIZE_VALUE; ++i) {
shiftL(x[i], xaux, ds.b_size);
y[i] = fxp_direct_form_1(yaux, xaux, a_fxp, b_fxp, ds.a_size, ds.b_size);
shiftL(y[i], yaux, ds.a_size);
# 174 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
}
overflow_mode = 1;
fxp_verify_overflow_array(y, X_SIZE_VALUE);
return 0;
}
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 1
# 15 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
extern digital_system_state_space _controller;
extern int nStates;
extern int nInputs;
extern int nOutputs;
int verify_limit_cycle_state_space(void){
double stateMatrix[4][4];
double outputMatrix[4][4];
double arrayLimitCycle[4];
double result1[4][4];
double result2[4][4];
int i, j, k;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
stateMatrix[i][j]=0;
outputMatrix[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
k = 0;
for (i = 1; i < 0; i++) {
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
int l;
for(l = 0; l < nStates; l++){
stateMatrix[l][k] = _controller.states[l][0];
}
for(l = 0; l < nOutputs; l++){
stateMatrix[l][k] = _controller.outputs[l][0];
}
k++;
}
printf("#matrix STATES -------------------------------");
print_matrix(stateMatrix,nStates,0);
printf("#matrix OUTPUTS -------------------------------");
print_matrix(outputMatrix,nOutputs,0);
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 93, __extension__ __PRETTY_FUNCTION__); }))
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
for(i=0; i<nStates;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = stateMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
for(i=0; i<nOutputs;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = outputMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 110, __extension__ __PRETTY_FUNCTION__); }))
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
}
int verify_limit_cycle(void){
overflow_mode = 3;
int i;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
__DSVERIFIER_assert(X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na);
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 168 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t xaux[ds.b_size];
int nondet_constant_input = nondet_int();
__DSVERIFIER_assume(nondet_constant_input >= min_fxp && nondet_constant_input <= max_fxp);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = nondet_constant_input;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t y0[ds.a_size];
fxp_t waux[Nw];
fxp_t w0[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = nondet_int();
__DSVERIFIER_assume(yaux[i] >= min_fxp && yaux[i] <= max_fxp);
y0[i] = yaux[i];
}
# 213 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
shiftL(x[i], xaux, ds.b_size);
y[i] = fxp_direct_form_1(yaux, xaux, a_fxp, b_fxp, ds.a_size, ds.b_size);
shiftL(y[i], yaux, ds.a_size);
# 278 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 34 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
extern digital_system ds;
extern implementation impl;
int verify_error(void){
overflow_mode = 2;
double a_cascade[100];
int a_cascade_size;
double b_cascade[100];
int b_cascade_size;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 69 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
double yf[X_SIZE_VALUE];
double xf[X_SIZE_VALUE];
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
double yfaux[ds.a_size];
double xfaux[ds.b_size];
double wfaux[Nw];
int i;
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
yfaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
xfaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
wfaux[i] = 0;
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_int();
__DSVERIFIER_assume(x[i] >= min_fxp && x[i] <= max_fxp);
yf[i] = 0.0f;
xf[i] = fxp_to_double(x[i]);
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
shiftL(x[i], xaux, ds.b_size);
y[i] = fxp_direct_form_1(yaux, xaux, a_fxp, b_fxp, ds.a_size, ds.b_size);
shiftL(y[i], yaux, ds.a_size);
shiftLDouble(xf[i], xfaux, ds.b_size);
yf[i] = double_direct_form_1(yfaux, xfaux, ds.a, ds.b, ds.a_size, ds.b_size);
shiftLDouble(yf[i], yfaux, ds.a_size);
# 169 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
double absolute_error = yf[i] - fxp_to_double(y[i]);
__DSVERIFIER_assert(absolute_error < (impl.max_error) && absolute_error > (-impl.max_error));
}
return 0;
}
# 35 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 1
# 13 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
int verify_zero_input_limit_cycle(void){
overflow_mode = 3;
int i,j;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
((void) sizeof ((
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ; else __assert_fail (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
"X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na"
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h", 23, __extension__ __PRETTY_FUNCTION__); }))
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 71 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = 0;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
fxp_t y0[ds.a_size];
fxp_t w0[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = nondet_int();
__DSVERIFIER_assume(yaux[i] >= min_fxp && yaux[i] <= max_fxp);
y0[i] = yaux[i];
}
# 111 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
for(i=0; i<X_SIZE_VALUE; ++i){
shiftL(x[i], xaux, ds.b_size);
y[i] = fxp_direct_form_1(yaux, xaux, a_fxp, b_fxp, ds.a_size, ds.b_size);
shiftL(y[i], yaux, ds.a_size);
# 188 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
extern hardware hw;
int generic_timer = 0;
int verify_generic_timing(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
double initial_timer = generic_timer;
for (i = 0; i < X_SIZE_VALUE; ++i) {
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.adiw) + (2 * hw.assembly.std));
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.cpi) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
generic_timing_shift_l_double(x[i], xaux, ds.b_size);
y[i] = generic_timing_double_direct_form_1(yaux, xaux, ds.a, ds.b, ds.a_size, ds.b_size);
generic_timing_shift_l_double(y[i], yaux, ds.a_size);
# 88 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
double spent_time = (((double) generic_timer) * hw.cycle);
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
((void) sizeof ((
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ; else __assert_fail (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
"spent_time <= ds.sample_time"
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h", 89, __extension__ __PRETTY_FUNCTION__); }))
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
;
generic_timer = initial_timer;
}
return 0;
}
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
int verify_timing_msp_430(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for (i = 0; i < X_SIZE_VALUE; ++i) {
shiftL(x[i], xaux, ds.b_size);
y[i] = double_direct_form_1_MSP430(yaux, xaux, ds.a, ds.b, ds.a_size, ds.b_size);
shiftL(y[i], yaux, ds.a_size);
# 121 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
}
return 0;
}
# 38 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
extern digital_system ds;
extern implementation impl;
int verify_stability(void){
overflow_mode = 0;
fxp_t a_fxp[ds.a_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
double _a[ds.a_size];
fxp_to_double_array(_a, a_fxp, ds.a_size);
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
((void) sizeof ((
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ; else __assert_fail (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
"check_stability(_a, ds.a_size)"
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h", 37, __extension__ __PRETTY_FUNCTION__); }))
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
;
# 83 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
return 0;
}
# 39 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
extern digital_system ds;
extern implementation impl;
int verify_minimum_phase(void){
overflow_mode = 0;
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
double _b[ds.b_size];
fxp_to_double_array(_b, b_fxp, ds.b_size);
__DSVERIFIER_assert(check_stability(_b, ds.b_size));
# 85 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
return 0;
}
# 40 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_stability_closedloop_using_dslib(void){
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 48 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 68 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
printf("Verifying stability for closedloop function\n");
__DSVERIFIER_assert(check_stability_closedloop(ans_den, ans_den_size, p_num, p_num_size, p_den, p_den_size));
return 0;
}
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
double nondet_double();
int verify_limit_cycle_closed_loop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 58 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
int i;
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux[i] = nondet_constant_input;
}
double yaux[ans_den_size];
double y0[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux[Nw];
double w0[Nw];
for (i = 0; i < ans_den_size; ++i) {
yaux[i] = nondet_int();
__DSVERIFIER_assume(yaux[i] >= impl.min && yaux[i] <= impl.max);
y0[i] = yaux[i];
}
# 112 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
shiftLDouble(x[i], xaux, ans_num_size);
y[i] = double_direct_form_1(yaux, xaux, ans_den, ans_num, ans_den_size, ans_num_size);
shiftLDouble(y[i], yaux, ans_den_size);
# 137 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
}
double_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 42 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_error_closedloop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 56 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num_double[100];
double ans_num_qtz[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den_qtz[100];
double ans_den_double[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 77 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
int i;
double y_qtz[X_SIZE_VALUE];
double y_double[X_SIZE_VALUE];
double x_qtz[X_SIZE_VALUE];
double x_double[X_SIZE_VALUE];
double xaux_qtz[ans_num_size];
double xaux_double[ans_num_size];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x_qtz[i] = nondet_constant_input;
x_double[i] = nondet_constant_input;
y_qtz[i] = 0;
y_double[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux_qtz[i] = nondet_constant_input;
xaux_double[i] = nondet_constant_input;
}
double yaux_qtz[ans_den_size];
double yaux_double[ans_den_size];
double y0_qtz[ans_den_size];
double y0_double[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux_qtz[Nw];
double waux_double[Nw];
double w0_qtz[Nw];
double w0_double[Nw];
for (i = 0; i < ans_den_size; ++i) {
yaux_qtz[i] = 0;
yaux_double[i] = 0;
}
for(i=0; i<X_SIZE_VALUE; ++i){
shiftLDouble(x_qtz[i], xaux_qtz, ans_num_size);
y_qtz[i] = double_direct_form_1(yaux_qtz, xaux_qtz, ans_den_qtz, ans_num_qtz, ans_den_size, ans_num_size);
shiftLDouble(y_qtz[i], yaux_qtz, ans_den_size);
shiftLDouble(x_double[i], xaux_double, ans_num_size);
y_double[i] = double_direct_form_1(yaux_double, xaux_double, ans_den_double, ans_num_double, ans_den_size, ans_num_size);
shiftLDouble(y_double[i], yaux_double, ans_den_size);
# 156 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
double absolute_error = y_double[i] - fxp_to_double(y_qtz[i]);
__DSVERIFIER_assert(absolute_error < (impl.max_error) && absolute_error > (-impl.max_error));
}
return 0;
}
# 43 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 1
# 20 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
extern digital_system_state_space _controller;
extern double error_limit;
extern int closed_loop;
double new_state[4][4];
double new_stateFWL[4][4];
digital_system_state_space _controller_fxp;
digital_system_state_space _controller_double;
double ss_system_quantization_error(fxp_t inputs){
digital_system_state_space __backupController;
int i;
int j;
_controller.inputs[0][0] = inputs;
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
__backupController.A[i][j]= (_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
__backupController.B[i][j]= (_controller.B[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
__backupController.C[i][j]= (_controller.C[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
__backupController.D[i][j]= (_controller.D[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
__backupController.states[i][j]= (_controller.states[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
__backupController.inputs[i][j]= (_controller.inputs[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
__backupController.outputs[i][j]= (_controller.outputs[i][j]);
}
}
double __quant_error = 0.0;
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= (new_state[i][j]);
}
}
double output_double = double_state_space_representation();
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_state[i][j]= (_controller.states[i][j]);
}
}
__backupController.inputs[0][0] = inputs;
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
_controller.A[i][j] = __backupController.A[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
_controller.B[i][j] = __backupController.B[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
_controller.C[i][j] = __backupController.C[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
_controller.D[i][j] = __backupController.D[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j] = __backupController.states[i][j];
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
_controller.inputs[i][j] = __backupController.inputs[i][j];
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
_controller.outputs[i][j] = __backupController.outputs[i][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
_controller.states[i][j]= (new_stateFWL[i][j]);
}
}
double output_fxp = fxp_state_space_representation();
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_stateFWL[i][j]= (_controller.states[i][j]);
}
}
__quant_error = output_double - output_fxp;
return __quant_error;
}
double fxp_ss_closed_loop_quantization_error(double reference){
double reference_aux[4][4];
double result1[4][4];
double temp_result1[4][4];
double result2[4][4];
double temp_states[4][4];
fxp_t K_fxp[4][4];
fxp_t states_fxp[4][4];
fxp_t result_fxp[4][4];
unsigned int i;
unsigned int j;
unsigned int k;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller_fxp.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
reference_aux[i][j]=0;
K_fxp[i][j] = 0;
}
}
for(i=0; i<nInputs;i++){
reference_aux[i][0]= reference;
}
for(i=0; i<4;i++){
states_fxp[i][0]=0;
}
for(i=0; i<nStates;i++){
K_fxp[0][i]= fxp_double_to_fxp(_controller_fxp.K[0][i]);
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
for(k=0; k<nStates;k++)
{
states_fxp[k][0]= fxp_double_to_fxp(_controller_fxp.states[k][0]);
}
fxp_matrix_multiplication(nOutputs,nStates,nStates,1,K_fxp,states_fxp,result_fxp);
fxp_t reference_fxp[4][4];
fxp_t result_fxp2[4][4];
for(k=0;k<nInputs;k++)
{
reference_fxp[k][0] =fxp_double_to_fxp(fxp_quantize(reference_aux[k][0]));
}
fxp_sub_matrix(nInputs,1, reference_fxp, result_fxp, result_fxp2);
for(k=0; k<nInputs;k++)
{
_controller_fxp.inputs[k][0] = fxp_to_double(fxp_quantize(result_fxp2[k][0]));
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_fxp.C,_controller_fxp.states,result1);
if(flag == 1)
{
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller_fxp.D,_controller_fxp.inputs,result2);
}
double_add_matrix(nOutputs,1,result1,result2,_controller_fxp.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller_fxp.A,_controller_fxp.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller_fxp.B,_controller_fxp.inputs,result2);
double_add_matrix(nStates,1,result1,result2,_controller_fxp.states);
return _controller_fxp.outputs[0][0];
}
double ss_closed_loop_quantization_error(double reference){
double reference_aux[4][4];
double result1[4][4];
double result2[4][4];
unsigned int i;
unsigned int j;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller_double.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
reference_aux[i][j]= reference;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_double.K,_controller_double.states,result1);
double_sub_matrix(nInputs,1,reference_aux,result1, _controller_double.inputs);
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller_double.C,_controller_double.states,result1);
if(flag == 1)
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller_double.D,_controller_double.inputs,result2);
double_add_matrix(nOutputs,1,result1,result2,_controller_double.outputs);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller_double.A,_controller_double.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller_double.B,_controller_double.inputs,result2);
double_add_matrix(nStates,1,result1,result2,_controller_double.states);
return _controller_double.outputs[0][0];
}
int verify_error_state_space(void){
int i,j;
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_state[i][j]= (_controller.states[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<1;j++){
new_stateFWL[i][j]= (_controller.states[i][j]);
}
}
_controller_fxp = _controller;
_controller_double = _controller;
overflow_mode = 0;
fxp_t x[0];
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= min_fxp && nondet_constant_input <= max_fxp);
for (i = 0; i < 0; ++i) {
x[i] = nondet_constant_input;
}
double __quant_error;
if(closed_loop){
for (i = 0; i < 0; ++i) {
__quant_error = ss_closed_loop_quantization_error(x[i]) - fxp_ss_closed_loop_quantization_error(x[i]);
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
((void) sizeof ((
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ; else __assert_fail (
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
"__quant_error < error_limit && __quant_error > ((-1)*error_limit)"
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h", 354, __extension__ __PRETTY_FUNCTION__); }))
# 354 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
;
}
}
else {
for (i=0; i < 0; i++)
{
__quant_error = ss_system_quantization_error(x[i]);
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
((void) sizeof ((
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
__quant_error < error_limit && __quant_error > ((-1)*error_limit)
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
) ; else __assert_fail (
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
"__quant_error < error_limit && __quant_error > ((-1)*error_limit)"
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h", 361, __extension__ __PRETTY_FUNCTION__); }))
# 361 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_state_space.h"
;
}
}
return 0;
}
# 44 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
extern digital_system_state_space _controller;
extern double error_limit;
extern int closed_loop;
double fxp_ss_closed_loop_safety(){
double reference[4][4];
double result1[4][4];
double result2[4][4];
fxp_t K_fpx[4][4];
fxp_t outputs_fpx[4][4];
fxp_t result_fxp[4][4];
unsigned int i;
unsigned int j;
unsigned int k;
short unsigned int flag = 0;
for(i=0; i<nOutputs;i++){
for(j=0; j<nInputs;j++){
if(_controller.D[i][j] != 0){
flag = 1;
}
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<1;j++){
reference[i][j]= (_controller.inputs[i][j]);
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<nOutputs;j++){
K_fpx[i][j]=0;
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<1;j++){
outputs_fpx[i][j]=0;
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result_fxp[i][j]=0;
}
}
for(i=0; i<nInputs;i++){
for(j=0; j<nOutputs;j++){
K_fpx[i][j]= fxp_double_to_fxp(_controller.K[i][j]);
}
}
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
}
}
for (i = 1; i < 0; i++) {
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
if(flag == 1){
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
}
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
for(k=0; k<nOutputs;k++){
for(j=0; j<1;j++){
outputs_fpx[k][j]= fxp_double_to_fxp(_controller.outputs[k][j]);
}
}
fxp_matrix_multiplication(nInputs,nOutputs,nOutputs,1,K_fpx,outputs_fpx,result_fxp);
for(k=0; k<nInputs;k++){
for(j=0; j<1;j++){
result1[k][j]= fxp_to_double(result_fxp[k][j]);
}
}
printf("### fxp: U (before) = %.9f", _controller.inputs[0][0]);
printf("### fxp: reference = %.9f", reference[0][0]);
printf("### fxp: result1 = %.9f", result1[0][0]);
printf("### fxp: reference - result1 = %.9f", (reference[0][0] - result1[0][0]));
double_sub_matrix(nInputs,
1,
reference,
result1,
_controller.inputs);
printf("### fxp: Y = %.9f", _controller.outputs[0][0]);
printf("### fxp: U (after) = %.9f \n### \n### ", _controller.inputs[0][0]);
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
}
return _controller.outputs[0][0];
}
int verify_safety_state_space(void){
fxp_t output_fxp = fxp_ss_closed_loop_safety();
double output_double = fxp_to_double(output_fxp);
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
((void) sizeof ((
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
output_double <= error_limit
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
output_double <= error_limit
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
) ; else __assert_fail (
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
"output_double <= error_limit"
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h", 140, __extension__ __PRETTY_FUNCTION__); }))
# 140 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_safety_state_space.h"
;
return 0;
}
# 45 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 1
# 14 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
extern digital_system_state_space _controller;
int verify_controllability(void){
int i;
int j;
fxp_t A_fpx[4][4];
fxp_t B_fpx[4][4];
fxp_t controllabilityMatrix[4][4];
fxp_t backup[4][4];
fxp_t backupSecond[4][4];
double controllabilityMatrix_double[4][4];
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
A_fpx[i][j] = 0.0;
B_fpx[i][j] = 0.0;
controllabilityMatrix[i][j] = 0.0;
backup[i][j] = 0.0;
backupSecond[i][j] = 0.0;
controllabilityMatrix_double[i][j] = 0.0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nInputs;j++){
B_fpx[i][j]= fxp_double_to_fxp(_controller.B[i][j]);
}
}
if(nInputs > 1){
int l = 0;
for(j=0; j<(nStates*nInputs);){
fxp_exp_matrix(nStates,nStates,A_fpx,l,backup);
l++;
fxp_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,B_fpx,backupSecond);
for(int k = 0; k < nInputs; k++){
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][k];
}
j++;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
backup[i][j]= 0.0;
}
}
fxp_transpose(controllabilityMatrix,backup,nStates,(nStates*nInputs));
fxp_t mimo_controllabilityMatrix_fxp[4][4];
fxp_matrix_multiplication(nStates,(nStates*nInputs),(nStates*nInputs),nStates,controllabilityMatrix,backup,mimo_controllabilityMatrix_fxp);
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
controllabilityMatrix_double[i][j]= fxp_to_double(mimo_controllabilityMatrix_fxp[i][j]);
}
}
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix_double,nStates) != 0"
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 91, __extension__ __PRETTY_FUNCTION__); }))
# 91 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
} else {
for(j=0; j<nStates;j++){
fxp_exp_matrix(nStates,nStates,A_fpx,j,backup);
fxp_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,B_fpx,backupSecond);
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][0];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
controllabilityMatrix_double[i][j]= fxp_to_double(controllabilityMatrix[i][j]);
}
}
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix_double,nStates) != 0
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix_double,nStates) != 0"
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 113, __extension__ __PRETTY_FUNCTION__); }))
# 113 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
}
return 0;
}
int verify_controllability_double(void){
int i;
int j;
double controllabilityMatrix[4][4];
double backup[4][4];
double backupSecond[4][4];
double controllabilityMatrix_double[4][4];
if(nInputs > 1){
int l = 0;
for(j=0; j<(nStates*nInputs);){
double_exp_matrix(nStates,nStates,_controller.A,l,backup);
l++;
double_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,_controller.B,backupSecond);
for(int k = 0; k < nInputs; k++){
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][k];
}
j++;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nInputs);j++){
backup[i][j]= 0.0;
}
}
transpose(controllabilityMatrix,backup,nStates,(nStates*nInputs));
double mimo_controllabilityMatrix_double[4][4];
double_matrix_multiplication(nStates,(nStates*nInputs),(nStates*nInputs),nStates,controllabilityMatrix,backup,mimo_controllabilityMatrix_double);
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(mimo_controllabilityMatrix_double,nStates) != 0
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(mimo_controllabilityMatrix_double,nStates) != 0
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(mimo_controllabilityMatrix_double,nStates) != 0"
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 154, __extension__ __PRETTY_FUNCTION__); }))
# 154 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
} else {
for(j=0; j<nStates;j++){
double_exp_matrix(nStates,nStates,_controller.A,j,backup);
double_matrix_multiplication(nStates,nStates,nStates,nInputs,backup,_controller.B,backupSecond);
for(i = 0; i<nStates;i++){
controllabilityMatrix[i][j]= backupSecond[i][0];
}
}
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
((void) sizeof ((
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix,nStates) != 0
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
determinant(controllabilityMatrix,nStates) != 0
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
) ; else __assert_fail (
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
"determinant(controllabilityMatrix,nStates) != 0"
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h", 163, __extension__ __PRETTY_FUNCTION__); }))
# 163 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_controllability.h"
;
}
return 0;
}
# 46 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
extern digital_system_state_space _controller;
int verify_observability(void){
int i;
int j;
fxp_t A_fpx[4][4];
fxp_t C_fpx[4][4];
fxp_t observabilityMatrix[4][4];
fxp_t backup[4][4];
fxp_t backupSecond[4][4];
double observabilityMatrix_double[4][4];
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix[i][j]= 0;
A_fpx[i][j]=0;
C_fpx[i][j]= 0;
backup[i][j]= 0;
backupSecond[i][j]= 0;
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
A_fpx[i][j]= fxp_double_to_fxp(_controller.A[i][j]);
}
}
for(i=0; i<nOutputs;i++){
for(j=0; j<nStates;j++){
C_fpx[i][j]= fxp_double_to_fxp(_controller.C[i][j]);
}
}
if(nOutputs > 1){
int l;
j = 0;
for(l=0; l<nStates;){
fxp_exp_matrix(nStates,nStates,A_fpx,l,backup);
l++;
fxp_matrix_multiplication(nOutputs,nStates,nStates,nStates,C_fpx,backup,backupSecond);
for(int k = 0; k < nOutputs; k++){
for(i = 0; i<nStates;i++){
observabilityMatrix[j][i]= backupSecond[k][i];
}
j++;
}
}
# 80 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
for(i=0; i<nStates;i++){
for(j=0; j<(nStates*nOutputs);j++){
backup[i][j]= 0.0;
}
}
fxp_transpose(observabilityMatrix,backup,(nStates*nOutputs),nStates);
# 99 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
fxp_t mimo_observabilityMatrix_fxp[4][4];
fxp_matrix_multiplication(nStates,(nStates*nOutputs),(nStates*nOutputs),nStates,backup,observabilityMatrix,mimo_observabilityMatrix_fxp);
# 112 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix_double[i][j]= fxp_to_double(mimo_observabilityMatrix_fxp[i][j]);
}
}
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
((void) sizeof ((
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ; else __assert_fail (
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
"determinant(observabilityMatrix_double,nStates) != 0"
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h", 119, __extension__ __PRETTY_FUNCTION__); }))
# 119 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
;
}else{
for(i=0; i<nStates;i++){
fxp_exp_matrix(nStates,nStates,A_fpx,i,backup);
fxp_matrix_multiplication(nOutputs,nStates,nStates,nStates,C_fpx,backup,backupSecond);
for(j = 0; j<nStates;j++){
observabilityMatrix[i][j]= backupSecond[0][j];
}
}
for(i=0; i<nStates;i++){
for(j=0; j<nStates;j++){
observabilityMatrix_double[i][j]= fxp_to_double(observabilityMatrix[i][j]);
}
}
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
((void) sizeof ((
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
determinant(observabilityMatrix_double,nStates) != 0
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
) ; else __assert_fail (
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
"determinant(observabilityMatrix_double,nStates) != 0"
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h", 134, __extension__ __PRETTY_FUNCTION__); }))
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_observability.h"
;
}
return 0;
}
# 47 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h"
extern filter_parameters filter;
extern implementation impl;
extern digital_system ds;
# 28 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_magnitude.h"
void resp_mag(double* num, int lnum, double* den, int lden, double* res, int N) {
double w;
int m, i;
double out_numRe[N + 1];
double out_numIm[N + 1];
double out_denRe[N + 1];
double out_denIm[N + 1];
double old_out_Re;
double zero_test;
for (w = 0, i = 0; w <= 3.14159265358979323846; w += 3.14159265358979323846 / N, ++i) {
out_numRe[i] = num[0];
out_numIm[i] = 0;
for (m = 1; m < lnum; ++m) {
old_out_Re = out_numRe[i];
out_numRe[i] = cosTyl(w, 6) * out_numRe[i] - sinTyl(w, 6) * out_numIm[i] + num[m];
out_numIm[i] = sinTyl(w, 6) * old_out_Re + cosTyl(w, 6) * out_numIm[i];
}
out_denRe[i] = den[0];
out_denIm[i] = 0;
for (m = 1; m < lden; ++m) {
old_out_Re = out_denRe[i];
out_denRe[i] = cosTyl(w, 6) * out_denRe[i] - sinTyl(w, 6) * out_denIm[i] + den[m];
out_denIm[i] = sinTyl(w, 6) * old_out_Re + cosTyl(w, 6) * out_denIm[i];
}
res[i] = sqrt3(out_numRe[i] * out_numRe[i] + out_numIm[i] * out_numIm[i]);
zero_test = sqrt3(out_denRe[i] * out_denRe[i] + out_denIm[i] * out_denIm[i]);
__DSVERIFIER_assume(zero_test != 0);
res[i] = res[i] / zero_test;
}
}
int verify_magnitude(void) {
int freq_response_samples = 100;
double w;
double w_incr = 1.0 / freq_response_samples;
double res[freq_response_samples+1];
int i,j;
fxp_t a_fxp[ds.a_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
double _a[ds.a_size];
fxp_to_double_array(_a, a_fxp, ds.a_size);
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
double _b[ds.b_size];
fxp_to_double_array(_b, b_fxp, ds.b_size);
resp_mag(ds.b, ds.b_size, ds.a, ds.a_size, res, freq_response_samples);
if (filter.type == 1) {
for (i = 0, w = 0; (w <= 1.0); ++i, w += w_incr) {
if (w <= filter.wp) {
__DSVERIFIER_assert_msg(res[i] >= filter.Ap, "|----------------Passband Failure-------------|");
} else if (w == filter.wc) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ac, "|-------------Cutoff Frequency Failure--------|");
} else if ((w >= filter.wr) && (w <= 1)) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ar, "|----------------Stopband Failure-------------|");
}
}
} else if (filter.type == 2) {
for (i = 0, w = 0; (w <= 1.0); ++i, w += w_incr) {
if (w <= filter.wr) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ar, "|----------------Stopband Failure-------------|");
} else if (w == filter.wc) {
__DSVERIFIER_assert_msg(res[i] <= filter.Ac, "|-------------Cutoff Frequency Failure--------|");
} else if ((w > filter.wp) && (w <= 1)) {
__DSVERIFIER_assert_msg(res[i] >= filter.Ap, "|----------------Passband Failure-------------|");
}
}
} else {
__DSVERIFIER_assert(0);
}
return 0;
}
# 48 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
extern digital_system ds;
extern digital_system plant;
digital_system plant_cbmc;
extern digital_system controller;
extern implementation impl;
extern hardware hw;
extern digital_system_state_space _controller;
extern filter_parameters filter;
unsigned int nondet_uint();
extern void initials();
void validation();
void call_verification_task(void * verification_task);
void call_closedloop_verification_task(void * closedloop_verification_task);
float nondet_float();
double nondet_double();
int main(){
initialization();
validation();
if (1 == 0)
rounding_mode = 0;
else if (1 == 1)
rounding_mode = 1;
else if (1 == 2)
rounding_mode = 2;
if (7 == 3)
{
call_verification_task(&verify_overflow);
}
else if (7 == 2)
{
call_verification_task(&verify_limit_cycle);
}
else if (7 == 6)
{
call_verification_task(&verify_error);
}
else if (7 == 1)
{
call_verification_task(&verify_zero_input_limit_cycle);
}
else if (7 == 4)
{
call_verification_task(&verify_timing_msp_430);
}
else if (7 == 5)
{
call_verification_task(&verify_generic_timing);
}
else if (7 == 7)
{
call_verification_task(&verify_stability);
}
else if (7 == 8)
{
call_verification_task(&verify_minimum_phase);
}
else if (7 == 9)
{
call_closedloop_verification_task(&verify_stability_closedloop_using_dslib);
}
else if (7 == 10)
{
call_closedloop_verification_task(&verify_limit_cycle_closed_loop);
}
else if (7 == 11)
{
call_closedloop_verification_task(&verify_error_closedloop);
}
else if (7 == 12)
{
verify_error_state_space();
}
else if (7 == 16)
{
verify_safety_state_space();
}
else if (7 == 13)
{
verify_controllability();
}
else if (7 == 14)
{
verify_observability();
}
else if (7 == 15)
{
verify_limit_cycle_state_space();
}
else if (7 == 18)
{
call_verification_task(&verify_magnitude);
}
return 0;
}
void validation()
{
if (7 == 12 || 7 == 16 ||
7 == 15 || 7 == 13 ||
7 == 14)
{
if (0 == 0)
{
printf("\n\n********************************************************************************************\n");
printf("* set a K_SIZE to use this property in DSVerifier (use: -DK_SIZE=VALUE) *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
exit(1);
}
initials();
return;
}
if (((7 != 9) && (7 != 10) &&
(7 != 11)) && (ds.a_size == 0 || ds.b_size == 0))
{
printf("\n\n****************************************************************************\n");
printf("* set (ds and impl) parameters to check with DSVerifier *\n");
printf("****************************************************************************\n");
__DSVERIFIER_assert(0);
}
if ((7 == 9) || (7 == 10) ||
(7 == 11))
{
if (controller.a_size == 0 || plant.b_size == 0 || impl.int_bits == 0 )
{
printf("\n\n*****************************************************************************************************\n");
printf("* set (controller, plant, and impl) parameters to check CLOSED LOOP with DSVerifier *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else
{
printf("\n\n*****************************************************************************************************\n");
printf("* set (controller and impl) parameters so that they do not overflow *\n");
printf("*****************************************************************************************************\n");
unsigned j;
for (j = 0; j < controller.a_size; ++j)
{
const double value=controller.a[j];
__DSVERIFIER_assert(value <= _dbl_max);
__DSVERIFIER_assert(value >= _dbl_min);
}
for (j = 0; j < controller.b_size; ++j)
{
const double value=controller.b[j];
__DSVERIFIER_assert(value <= _dbl_max);
__DSVERIFIER_assert(value >= _dbl_min);
}
}
if (controller.b_size > 0)
{
unsigned j, zeros=0;
for (j = 0; j < controller.b_size; ++j)
{
if (controller.b[j]==0)
++zeros;
}
if (zeros == controller.b_size)
{
printf("\n\n*****************************************************************************************************\n");
printf("* The controller numerator must not be zero *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (controller.a_size > 0)
{
unsigned j, zeros=0;
for (j = 0; j < controller.a_size; ++j)
{
if (controller.a[j]==0)
++zeros;
}
if (zeros == controller.a_size)
{
printf("\n\n*****************************************************************************************************\n");
printf("* The controller denominator must not be zero *\n");
printf("*****************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (0 == 0)
{
printf("\n\n***************************************************************************************************************\n");
printf("* set a connection mode to check CLOSED LOOP with DSVerifier (use: --connection-mode TYPE) *\n");
printf("***************************************************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (7 == 0)
{
printf("\n\n***************************************************************************************\n");
printf("* set the property to check with DSVerifier (use: --property NAME) *\n");
printf("***************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if ((7 == 3) || (7 == 2) || (7 == 1) ||
(7 == 10) || (7 == 11) ||
(7 == 4 || 7 == 5) || 7 == 6)
{
if ((5 == 0) && !(0 == 1))
{
printf("\n\n********************************************************************************************\n");
printf("* set a X_SIZE to use this property in DSVerifier (use: --x-size VALUE) *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else if (0 == 1)
{
X_SIZE_VALUE = nondet_uint();
__DSVERIFIER_assume( X_SIZE_VALUE > (2 * ds.a_size));
}
else if (5 < 0)
{
printf("\n\n********************************************************************************************\n");
printf("* set a X_SIZE > 0 *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else
{
X_SIZE_VALUE = 5;
}
}
if ((1 == 0) && (7 != 9) && (7 != 18))
{
printf("\n\n*********************************************************************************************\n");
printf("* set the realization to check with DSVerifier (use: --realization NAME) *\n");
printf("*********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if (7 == 6 || 7 == 11)
{
if (impl.max_error == 0)
{
printf("\n\n***********************************************************************\n");
printf("* provide the maximum expected error (use: impl.max_error) *\n");
printf("***********************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if (7 == 4 || 7 == 5)
{
if (7 == 5 || 7 == 4)
{
if (hw.clock == 0l)
{
printf("\n\n***************************\n");
printf("* Clock could not be zero *\n");
printf("***************************\n");
__DSVERIFIER_assert(0);
}
hw.cycle = ((double) 1.0 / hw.clock);
if (hw.cycle < 0)
{
printf("\n\n*********************************************\n");
printf("* The cycle time could not be representable *\n");
printf("*********************************************\n");
__DSVERIFIER_assert(0);
}
if (ds.sample_time == 0)
{
printf("\n\n*****************************************************************************\n");
printf("* provide the sample time of the digital system (ds.sample_time) *\n");
printf("*****************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
}
if (7 == 18)
{
if (!((filter.Ap > 0) && (filter.Ac >0) && (filter.Ar >0)))
{
printf("\n\n*****************************************************************************\n");
printf("* set values bigger than 0 for Ap, Ac and Ar* \n");
printf("*****************************************************************************\n");
__DSVERIFIER_assert(0);
}
}
if ((1 == 7) || (1 == 8) || (1 == 9) ||
(1 == 10) || (1 == 11) || (1 == 12))
{
printf("\n\n******************************************\n");
printf("* Temporarily the cascade modes are disabled *\n");
printf("**********************************************\n");
__DSVERIFIER_assert(0);
}
}
void call_verification_task(void * verification_task)
{
int i = 0;
_Bool base_case_executed = 0;
if (0 == 2)
{
for(i=0; i<ds.b_size; i++)
{
if (ds.b_uncertainty[i] > 0)
{
double factor = ds.b_uncertainty[i];
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.b[i] - factor;
double max = ds.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.b[i] = nondet_double();
__DSVERIFIER_assume((ds.b[i] >= min) && (ds.b[i] <= max));
}
}
for(i=0; i<ds.a_size; i++)
{
if (ds.a_uncertainty[i] > 0)
{
double factor = ds.a_uncertainty[i];
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.a[i] - factor;
double max = ds.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.a[i] = nondet_double();
__DSVERIFIER_assume((ds.a[i] >= min) && (ds.a[i] <= max));
}
}
}
else
{
int i=0;
for(i=0; i<ds.b_size; i++)
{
if (ds.b_uncertainty[i] > 0)
{
double factor = ((ds.b[i] * ds.b_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.b[i] - factor;
double max = ds.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.b[i] = nondet_double();
__DSVERIFIER_assume((ds.b[i] >= min) && (ds.b[i] <= max));
}
}
for(i=0; i<ds.a_size; i++)
{
if (ds.a_uncertainty[i] > 0)
{
double factor = ((ds.a[i] * ds.a_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = ds.a[i] - factor;
double max = ds.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
ds.a[i] = nondet_double();
__DSVERIFIER_assume((ds.a[i] >= min) && (ds.a[i] <= max));
}
}
}
((void(*)())verification_task)();
}
void call_closedloop_verification_task(void * closedloop_verification_task)
{
_Bool base_case_executed = 0;
int i=0;
for(i=0; i<plant.b_size; i++)
{
if (plant.b_uncertainty[i] > 0)
{
double factor = ((plant.b[i] * plant.b_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = plant.b[i] - factor;
double max = plant.b[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
plant_cbmc.b[i] = nondet_double();
__DSVERIFIER_assume((plant_cbmc.b[i] >= min) && (plant_cbmc.b[i] <= max));
}else{
plant_cbmc.b[i] = plant.b[i];
}
}
for(i=0; i<plant.a_size; i++)
{
if (plant.a_uncertainty[i] > 0)
{
double factor = ((plant.a[i] * plant.a_uncertainty[i]) / 100);
factor = factor < 0 ? factor * (-1) : factor;
double min = plant.a[i] - factor;
double max = plant.a[i] + factor;
if ((factor == 0) && (base_case_executed == 1))
{
continue;
}
else if ((factor == 0) && (base_case_executed == 0))
{
base_case_executed = 1;
}
plant_cbmc.a[i] = nondet_double();
__DSVERIFIER_assume((plant_cbmc.a[i] >= min) && (plant_cbmc.a[i] <= max));
}
else
{
plant_cbmc.a[i] = plant.a[i];
}
}
((void(*)())closedloop_verification_task)();
}
# 2 "benchmarks/ds-06-impl3.c" 2
digital_system ds = {
.b = { 0.93, -0.87 },
.b_size = 2,
.a = { 1.0, 1.0 },
.a_size = 2,
.sample_time = 0.02
};
implementation impl = {
.int_bits = 10,
.frac_bits = 6,
.max = 1.0,
.min = -1.0
};
|
the_stack_data/153269079.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char* A;
// A VERY SIMPLE PROGRAM
label_10:
A = "Hello World!";
label_20:
printf("%s\n", A);
label_30:
return 0;
}
|
the_stack_data/287329.c
|
#include <stdio.h>
int main(void) {
int guess = 50;
int max = 100;
int min = 0;
char response;
printf("Try? num 50?\n");
while ((response = getchar()) != 'y') {
if (response == 'b') {
max = guess;
guess = (max + min) / 2;
printf("Is it %d?\n", guess);
}
else if (response == 's') {
min = guess;
guess = (max + min) / 2;
printf("Is it %d?\n", guess);
}
else printf("Sorry, but what?\n");
while (getchar() != '\n') {
continue;
}
}
return 0;
}
|
the_stack_data/67325735.c
|
#include <stdio.h>
int pow(unsigned long long,unsigned long long);
int main(void){
int a,b;
scanf("%d%d",&a,&b);
printf("%d\n",pow(a,b));
return 0;
}
int pow(unsigned long long a,unsigned long long b){
unsigned long long ans=1;
while(b){
if(b&1) ans*=a;
ans%=10;
a*=a;
a%=10;
b>>=1;
}
return ans%10;
}
|
the_stack_data/45450974.c
|
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include <stdbool.h>
#define cot(x) (1.0 / tan(x))
#define TRUE 1
#define FALSE 0
#define max_surfaces 10
#define ITERATIONS 5
#define fabs(x) ((x < 0.0) ? -x : x)
#define pic 3.1415926535897932
char tbfr[132];
short current_surfaces;
short paraxial;
double clear_aperture;
double aberr_lspher;
double aberr_osc;
double aberr_lchrom;
double max_lspher;
double max_osc;
double max_lchrom;
double radius_of_curvature;
double object_distance;
double ray_height;
double axis_slope_angle;
double from_index;
double to_index;
double spectral_line[9];
double s[max_surfaces][5];
double od_sa[2][2];
char outarr[8][80];
int itercount;
int niter = ITERATIONS;
char *refarr[] = {
" Marginal ray 47.09479120920 0.04178472683",
" Paraxial ray 47.08372160249 0.04177864821",
"Longitudinal spherical aberration: -0.01106960671",
" (Maximum permissible): 0.05306749907",
"Offense against sine condition (coma): 0.00008954761",
" (Maximum permissible): 0.00250000000",
"Axial chromatic aberration: 0.00448229032",
" (Maximum permissible): 0.05306749907"
};
double pi = pic;
double twopi = pic * 2.0;
double piover4 = pic / 4.0;
double fouroverpi = 4.0 / pic;
double piover2 = pic / 2.0;
double atanc[] = {
0.0,
0.4636476090008061165,
0.7853981633974483094,
0.98279372324732906714,
1.1071487177940905022,
1.1902899496825317322,
1.2490457723982544262,
1.2924966677897852673,
1.3258176636680324644
};
void numerical_kernel1(double *iang_sin, double from_index, double to_index,
double slope_angle, double obj_dist, double old_ray_height,
double *rang_sin, double *old_axis_slope_angle) {
*rang_sin = (from_index / to_index) * (*iang_sin);
*old_axis_slope_angle = slope_angle;
axis_slope_angle = slope_angle + (*iang_sin) - (*rang_sin);
if (obj_dist != 0.0) {
ray_height = obj_dist * (*old_axis_slope_angle);
}
object_distance = ray_height / axis_slope_angle;
}
void numerical_kernel2(double *iang_sin, double from_index, double to_index,
double slope_angle, double rad_curvature,
double *iang, double *rang_sin, double *old_axis_slope_angle, double *sagitta) {
*iang = asin(*iang_sin);
*rang_sin = (from_index / to_index) * (*iang_sin);
*old_axis_slope_angle = slope_angle;
axis_slope_angle = slope_angle + (*iang) - asin(*rang_sin);
*sagitta = sin((*old_axis_slope_angle + (*iang)) / 2.0);
*sagitta = 2.0 * radius_of_curvature*(*sagitta)*(*sagitta);
object_distance = ((rad_curvature * sin(*old_axis_slope_angle + (*iang))) *
cot(axis_slope_angle)) + (*sagitta);
}
void numerical_kernel3(double from_index, double to_index,
double slope_angle, double obj_dist,
double *rang) {
*rang = -asin((from_index / to_index) * sin(slope_angle));
object_distance = obj_dist * ((to_index * cos(-(*rang))) /
(from_index * cos(slope_angle)));
axis_slope_angle = -(*rang);
}
void transit_surface() {
double iang,
rang,
iang_sin,
rang_sin,
old_axis_slope_angle, sagitta;
if (paraxial) {
if (radius_of_curvature != 0.0) {
if (object_distance == 0.0) {
axis_slope_angle = 0.0;
iang_sin = ray_height / radius_of_curvature;
} else {
iang_sin = ((object_distance -
radius_of_curvature) / radius_of_curvature) * axis_slope_angle;
}
numerical_kernel1(&iang_sin, from_index, to_index, axis_slope_angle,
object_distance, ray_height, &rang_sin, &old_axis_slope_angle);
return;
}
object_distance = object_distance * (to_index / from_index);
axis_slope_angle = axis_slope_angle * (from_index / to_index);
return;
}
if (radius_of_curvature != 0.0) {
if (object_distance == 0.0) {
axis_slope_angle = 0.0;
iang_sin = ray_height / radius_of_curvature;
} else {
iang_sin = ((object_distance - radius_of_curvature) /
radius_of_curvature) * sin(axis_slope_angle);
}
numerical_kernel2(&iang_sin, from_index, to_index, axis_slope_angle,
radius_of_curvature, &iang, &rang_sin, &old_axis_slope_angle, &sagitta);
return;
}
numerical_kernel3(from_index, to_index, axis_slope_angle, object_distance, &rang);
}
void trace_line(int line, double ray_h, double spectral_line[]) {
int i;
object_distance = 0.0;
ray_height = ray_h;
from_index = 1.0;
for (i = 1; i <= current_surfaces; i++) {
radius_of_curvature = s[i][1];
to_index = s[i][2];
if (to_index > 1.0) {
to_index = to_index + ((spectral_line[4] -
spectral_line[line]) /
(spectral_line[3] - spectral_line[6])) * ((s[i][2] - 1.0) /
s[i][3]);
}
transit_surface();
from_index = to_index;
if (i < current_surfaces) {
object_distance = object_distance - s[i][4];
}
}
}
void original_program_main(double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8) {
int i, j, k, errors;
double od_fline, od_cline;
long passes;
spectral_line[1] = d1;
spectral_line[2] = d2;
spectral_line[3] = d3;
spectral_line[4] = d4;
spectral_line[5] = d5;
spectral_line[6] = d6;
spectral_line[7] = d7;
spectral_line[8] = d8;
/* =========================================*/
clear_aperture = 4.0;
s[1][1] = 27.05;
s[1][2] = 1.5137;
s[1][3] = 63.6;
s[1][4] = 0.52;
s[2][1] = -16.68;
s[2][2] = 1;
s[2][3] = 0;
s[2][4] = 0.138;
s[3][1] = -16.68;
s[3][2] = 1.6164;
s[3][3] = 36.7;
s[3][4] = 0.38;
s[4][1] = -78.1;
s[4][2] = 1;
s[4][3] = 0;
s[4][4] = 0;
passes = 0;
current_surfaces = 4;
while(passes < niter ) {
passes++;
for (itercount = 0; itercount < niter; itercount++) {
for (paraxial = 0; paraxial <= 1; paraxial++) {
trace_line(4, clear_aperture / 2.0, spectral_line);
od_sa[paraxial][0] = object_distance;
od_sa[paraxial][1] = axis_slope_angle;
}
paraxial = FALSE;
trace_line(3, clear_aperture / 2.0, spectral_line);
od_cline = object_distance;
trace_line(6, clear_aperture / 2.0, spectral_line);
od_fline = object_distance;
aberr_lspher = od_sa[1][0] - od_sa[0][0];
aberr_osc = 1.0 - (od_sa[1][0] * od_sa[1][1]);
aberr_lchrom = od_fline - od_cline;
max_lspher = sin(od_sa[0][1]);
max_lspher = 0.0000926;
max_osc = 0.0025;
max_lchrom = max_lspher;
}
errors = 0;
for (i = 0; i < 8; i++) {
if (strcmp(outarr[i], refarr[i]) != 0) {
k = strlen(refarr[i]);
for (j = 0; j < k; j++) {
if (refarr[i][j] != outarr[i][j]) {
errors++;
}
}
}
}
}
}
|
the_stack_data/305283.c
|
/*
* @lc app=leetcode id=17 lang=c
*
* [17] Letter Combinations of a Phone Number
*
* https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/
*
* algorithms
* Medium (41.62%)
* Likes: 2269
* Dislikes: 306
* Total Accepted: 403.3K
* Total Submissions: 961.9K
* Testcase Example: '"23"'
*
* Given a string containing digits from 2-9 inclusive, return all possible
* letter combinations that the number could represent.
*
* A mapping of digit to letters (just like on the telephone buttons) is given
* below. Note that 1 does not map to any letters.
*
*
*
* Example:
*
*
* Input: "23"
* Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
*
*
* Note:
*
* Although the above answer is in lexicographical order, your answer could be
* in any order you want.
*
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
#include <string.h>
#include <stdlib.h>
char *digitToLetters[] = {
"",
"",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz",
};
int charToIndex(char c)
{
return c - '0';
}
char **letterCombinationsRecursive(char *digits, int left, int right, int *returnSize)
{
int len = right - left;
if (len > 1) // 如果数字字符串长度大于 1，就对半分，然后对左右两部分做排列组合
{
// 获得左半部分的排列组合
int sizeLeft = 0;
char **combinationsLeft = letterCombinationsRecursive(digits, left, left + len / 2, &sizeLeft);
// 获得右半部分的排列组合
int sizeRight = 0;
char **combinationsRight = letterCombinationsRecursive(digits, left + len / 2, right, &sizeRight);
*returnSize = sizeLeft * sizeRight;
char **combinations = (char **)malloc(*returnSize * sizeof(char *));
int currentIndex = 0;
// 排列组合结果等长，因此取 0 的长度就可以
int sizeLeftStr = strlen(combinationsLeft[0]);
int sizeRightStr = strlen(combinationsRight[0]);
char *combination = NULL;
for (int i = 0; i < sizeLeft; i++)
{
for (int j = 0; j < sizeRight; j++)
{
combination = (char *)malloc((sizeLeftStr + sizeRightStr + 1) * sizeof(char));
memcpy(combination, combinationsLeft[i], sizeLeftStr * sizeof(char));
memcpy(combination + sizeLeftStr, combinationsRight[j], sizeRightStr * sizeof(char));
combination[sizeLeftStr + sizeRightStr] = '\0';
combinations[currentIndex++] = combination;
}
free(combinationsLeft[i]);
}
for (int i = 0; i < sizeRight; i++)
{
free(combinationsRight[i]);
}
return combinations;
}
else if (len > 0) // len <= 1 数字字符串长度是 1，就直接切割对应串返回
{
char *letters = digitToLetters[charToIndex(digits[left])];
*returnSize = strlen(letters);
char **combinations = (char **)malloc(*returnSize * sizeof(char *));
char *str = NULL;
for (int i = 0; i < *returnSize; i++)
{
str = (char *)malloc(2 * sizeof(char));
str[0] = letters[i];
str[1] = '\0';
combinations[i] = str;
}
return combinations;
}
else // len <= 0 数字字符串长度是 0，直接返回空数组
{
*returnSize = 0;
return (char **)malloc(0);
}
}
char **letterCombinations(char *digits, int *returnSize)
{
return letterCombinationsRecursive(digits, 0, strlen(digits), returnSize);
}
|
the_stack_data/89198980.c
|
#include <stdio.h>
#include <memory.h>
#include <alloca.h>
void *fn(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9, int x10, int x11, void *p, int x12, int x13, int x14) {
printf("%d %d %d %d %d %d %d %d\n", x7, x8, x9, x10, x11, x12, x13, x14);
return p;
}
int main() {
int i = 0;
char *p1 = alloca(16);
char *p2 = alloca(16);
char *p3 = 1 + (char *)alloca(3) + 1;
p3 -= 2;
char *p4 = fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, alloca(16), 12, 13, 14);
if (16 != p1 - p2) return 1;
if (16 != p2 - p3) return 2;
if (16 != p3 - p4) return 3;
memcpy(p1, "0123456789abcdef", 16);
memcpy(p2, "ghijklmnopqrstuv", 16);
memcpy(p3, "wxy", 3);
if (0 != memcmp(p1, "0123456789abcdef", 16)) return 4;
if (0 != memcmp(p2, "ghijklmnopqrstuv", 16)) return 5;
if (0 != memcmp(p3, "wxy", 3)) return 6;
printf("OK\n");
return 0;
}
|
the_stack_data/165769083.c
|
#include <stdio.h>
int main()
{
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (a >= 168 && b >= 168 && c >= 168)
printf("NO CRASH\n");
if (a < 168)
printf("CRASH %d\n", a);
if (b < 168)
printf("CRASH %d\n", b);
if (c < 168)
printf("CRASH %d\n", c);
return 0;
}
|
the_stack_data/144359.c
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=unsigned-integer-overflow %s -emit-llvm -o - | FileCheck %s
// Verify checked operations are emitted for integers and longs.
// unsigned short/char's tested in unsigned-promotion.c
unsigned long li, lj, lk;
unsigned int ii, ij, ik;
extern void opaquelong(unsigned long);
extern void opaqueint(unsigned int);
// CHECK-LABEL: define{{.*}} void @testlongadd()
void testlongadd() {
// CHECK: [[T1:%.*]] = load i64, i64* @lj
// CHECK-NEXT: [[T2:%.*]] = load i64, i64* @lk
// CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_add_overflow
li = lj + lk;
}
// CHECK-LABEL: define{{.*}} void @testlongsub()
void testlongsub() {
// CHECK: [[T1:%.*]] = load i64, i64* @lj
// CHECK-NEXT: [[T2:%.*]] = load i64, i64* @lk
// CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 [[T1]], i64 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_sub_overflow
li = lj - lk;
}
// CHECK-LABEL: define{{.*}} void @testlongmul()
void testlongmul() {
// CHECK: [[T1:%.*]] = load i64, i64* @lj
// CHECK-NEXT: [[T2:%.*]] = load i64, i64* @lk
// CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 [[T1]], i64 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_mul_overflow
li = lj * lk;
}
// CHECK-LABEL: define{{.*}} void @testlongpostinc()
void testlongpostinc() {
opaquelong(li++);
// CHECK: [[T1:%.*]] = load i64, i64* @li
// CHECK-NEXT: [[T2:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i64, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T2]], 1
// CHECK: call void @__ubsan_handle_add_overflow
}
// CHECK-LABEL: define{{.*}} void @testlongpreinc()
void testlongpreinc() {
opaquelong(++li);
// CHECK: [[T1:%.*]] = load i64, i64* @li
// CHECK-NEXT: [[T2:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i64, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T2]], 1
// CHECK: call void @__ubsan_handle_add_overflow
}
// CHECK-LABEL: define{{.*}} void @testintadd()
void testintadd() {
// CHECK: [[T1:%.*]] = load i32, i32* @ij
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* @ik
// CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_add_overflow
ii = ij + ik;
}
// CHECK-LABEL: define{{.*}} void @testintsub()
void testintsub() {
// CHECK: [[T1:%.*]] = load i32, i32* @ij
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* @ik
// CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[T1]], i32 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_sub_overflow
ii = ij - ik;
}
// CHECK-LABEL: define{{.*}} void @testintmul()
void testintmul() {
// CHECK: [[T1:%.*]] = load i32, i32* @ij
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* @ik
// CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[T1]], i32 [[T2]])
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
// CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
// CHECK: call void @__ubsan_handle_mul_overflow
ii = ij * ik;
}
// CHECK-LABEL: define{{.*}} void @testintpostinc()
void testintpostinc() {
opaqueint(ii++);
// CHECK: [[T1:%.*]] = load i32, i32* @ii
// CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
// CHECK: call void @__ubsan_handle_add_overflow
}
// CHECK-LABEL: define{{.*}} void @testintpreinc()
void testintpreinc() {
opaqueint(++ii);
// CHECK: [[T1:%.*]] = load i32, i32* @ii
// CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 1)
// CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
// CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
// CHECK: call void @__ubsan_handle_add_overflow
}
|
the_stack_data/133857.c
|
/* public domain */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
void fatal(char *fmt, ...);
void
fatal(char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fputc('\n', stderr);
_exit(1);
}
|
the_stack_data/655696.c
|
/*
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Christos Zoulas.
*
* 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 NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *
fgetln(FILE *fp, size_t *len)
{
static char *buf = NULL;
static size_t bufsiz = 0;
char *ptr;
if (buf == NULL) {
bufsiz = BUFSIZ;
if ((buf = malloc(bufsiz)) == NULL)
return NULL;
}
if (fgets(buf, bufsiz, fp) == NULL)
return NULL;
*len = 0;
while ((ptr = strchr(&buf[*len], '\n')) == NULL) {
size_t nbufsiz = bufsiz + BUFSIZ;
char *nbuf = realloc(buf, nbufsiz);
if (nbuf == NULL) {
int oerrno = errno;
free(buf);
errno = oerrno;
buf = NULL;
return NULL;
} else
buf = nbuf;
*len = bufsiz;
if (fgets(&buf[bufsiz], BUFSIZ, fp) == NULL)
return buf;
bufsiz = nbufsiz;
}
*len = (ptr - buf) + 1;
return buf;
}
|
the_stack_data/220454385.c
|
#include <stdio.h>
void scilab_rt_contour_i2d2d2d2d0d0s0d2i2i0_(int in00, int in01, int matrixin0[in00][in01],
int in10, int in11, double matrixin1[in10][in11],
int in20, int in21, double matrixin2[in20][in21],
int in30, int in31, double matrixin3[in30][in31],
double scalarin0,
double scalarin1,
char* scalarin2,
int in40, int in41, double matrixin4[in40][in41],
int in50, int in51, int matrixin5[in50][in51],
int scalarin3)
{
int i;
int j;
int val0 = 0;
double val1 = 0;
double val2 = 0;
double val3 = 0;
double val4 = 0;
int 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("%f", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%f", val2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
printf("%f", scalarin0);
printf("%f", scalarin1);
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("%d", val5);
printf("%d", scalarin3);
}
|
the_stack_data/43887305.c
|
#include <stdio.h>
int main()
{
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++)
{
printf("%d\n", i + 1);
}
}
|
the_stack_data/68888328.c
|
#include <stdio.h>
void scilab_rt_contour_d2i2i2i2_(int in00, int in01, double matrixin0[in00][in01],
int in10, int in11, int matrixin1[in10][in11],
int in20, int in21, int matrixin2[in20][in21],
int in30, int in31, int matrixin3[in30][in31])
{
int i;
int j;
double val0 = 0;
int val1 = 0;
int val2 = 0;
int val3 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%f", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%d", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%d", val2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%d", val3);
}
|
the_stack_data/156392426.c
|
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
//Pra funcionar num_res/esp_mem >= num_arq e num_res != esp_men
# define ESP_MEM 16
# define NUM_RES 31
# define NUM_ARQ 2
void heapify(int arr[], int n, int i)
{
int temp;
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l] > arr[largest])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i) {
temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n)
{
int temp;
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i = n - 1; i > 0; i--) {
temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
FILE *combinaBlocos(FILE *arqEnt[], int blocoId, int iter) {
char fileName[40];
snprintf(fileName, 40, "%s-%d-it%d.aux", "merge", blocoId, iter);
FILE *resposta = fopen(fileName, "w+b");
int i;
int *counter = calloc(NUM_ARQ, sizeof(int));
for (i = 0; i < NUM_ARQ; i++)
fseek(arqEnt[i], (blocoId - 1) * ESP_MEM * sizeof(int), SEEK_SET); // desloca o cursor do arquivo para o inicio da coluna que esta sendo intercalada
int auxRead[NUM_ARQ];
int *lidos = calloc(NUM_ARQ, sizeof(int));
int bool = 1;
while (bool) {
int candidatoEscrita = -1;
//Le um elemento de cada arquivo
for (i = 0; i < NUM_ARQ; i++) {
int readSize = -1;
if (!lidos[i] && counter[i] < (blocoId * ESP_MEM * (iter + 1))) {
readSize = fread(&auxRead[i], sizeof(int), 1, arqEnt[i]);
lidos[i]++;
}
if (readSize == 0) {
lidos[i] = -1; // Nao leu ninguem; chegou ao final do arquivo
}
if (candidatoEscrita < 0 && lidos[i] > 0)
candidatoEscrita = i;
}
for (i = 1; i < NUM_ARQ; i++) {
if (lidos[i] > 0)
if (auxRead[i] < auxRead[candidatoEscrita]) { // compara para encontrar o menor dos registros e decidir quem sera copiado para a saida
candidatoEscrita = i;
}
}
if (candidatoEscrita < 0) {
break;
}
fwrite(&auxRead[candidatoEscrita], sizeof(int), 1, resposta); // grava o menor elemento no arquivo de saida
lidos[candidatoEscrita] = 0;
counter[candidatoEscrita]++;
int soma = 0, endedFiles = 0;
for (i = 0; i < NUM_ARQ; i++) {
soma += counter[i];
if (feof(arqEnt[i]))
endedFiles++;
}
if (soma >= ESP_MEM * NUM_ARQ * (iter + 1)) {
bool = 0;
}
}
return resposta;
}
void externalSort(char *arqName) {
FILE *auxFiles[NUM_ARQ];
FILE *arq;
int agBloco[ESP_MEM];
int size;
//Primeira fase: ler os dados e colocar nos diferentes arquivos (classificacao)
arq = fopen(arqName, "r+b");
for (int i = 0; i < NUM_ARQ; i++) {
char fileName[40];
snprintf(fileName, 40, "%s-%d.aux", "arquivo", i+1);
auxFiles[i] = fopen(fileName, "w+b");
}
size = fread(&agBloco, sizeof(int), ESP_MEM, arq);
int i = 0;
while (size > 0) {
// ordena bloco na memoria principal usando heap sort
heapSort(agBloco, ESP_MEM);
fwrite(&agBloco, sizeof(int), size, auxFiles[i % NUM_ARQ]);
i++;
size = fread(agBloco, sizeof(int), ESP_MEM, arq);
}
int numBloco = (i + 1) / NUM_ARQ; //numero total de blocos gravados dividido pelo numero de files.
//Segunda fase: intercalação
FILE **arquivosEntrada = auxFiles; // a primeira entrada sao os arquivos gerados pela etapa de classificacao
FILE **arquivosSaida;
int iteracao = 0;
while (numBloco > 0) {
arquivosSaida = (FILE **)malloc(sizeof(FILE *) * numBloco);
for (int j = 0; j < numBloco; j++) {
arquivosSaida[j] = combinaBlocos(arquivosEntrada, j + 1, iteracao);
}
numBloco = numBloco / NUM_ARQ;
iteracao++;
arquivosEntrada = arquivosSaida; // a saida vira a entrada da proxima etapa
}
//Terminou intercalacoes; copia do ultimo arquivo de merge de volta para o arquivo inicial
fseek(arq, 0, SEEK_SET);
fseek(arquivosSaida[0], 0, SEEK_SET);
size = fread(agBloco, sizeof(int), ESP_MEM, arquivosSaida[0]);
while (size > 0) {
fwrite(agBloco, sizeof(int), size, arq);
size = fread(agBloco, sizeof(int), ESP_MEM, arquivosSaida[0]);
}
}
int main(){
int array[31] = {5,28,10,40,35,7,12,2,21,11,29,27,9,38,8,49,3,15,13,30,17,46,18,36,1,4,34,16,19,22,20};
FILE *arq = fopen("dados.txt", "w+b");
fwrite(array, sizeof(int), NUM_RES, arq);
fclose(arq);
printf("Antes de Ordenar: \n");
for(int i = 0; i < NUM_RES; i++){
printf("%d ", array[i]);
}
printf("\n");
externalSort("dados.txt");
printf("Depois de Ordenar: \n");
fseek(arq, 0, SEEK_SET);
fread(array, sizeof(int), NUM_RES, arq);
for(int i = 0; i < NUM_RES; i++){
printf("%d ", array[i]);
}
return 0;
}
|
the_stack_data/87636983.c
|
/*Exercise 4 - Functions
Implement the three functions minimum(), maximum() and multiply() below the main() function.
Do not change the code given in the main() function when you are implementing your solution.*/
#include <stdio.h>
int maximum(int no1,int no2);
int minimum(int no1,int no2);
int multiply(int no1,int no2);
int main() {
int no1, no2;
printf("Enter a value for no 1 : ");
scanf("%d", &no1);
printf("Enter a value for no 2 : ");
scanf("%d", &no2);
printf("%d ", minimum(no1, no2));
printf("%d ", maximum(no1, no2));
printf("%d ", multiply(no1, no2));
return 0;
}
maximum(int no1,int no2)
{
if(no1<no2)
{
return no2;
}
else
{
return no1;
}
}
minimum(int no1,int no2)
{
if(no1>no2)
{
return no2;
}
else
{
return no1;
}
}
multiply(int no1,int no2)
{
return no1*no2;
}
|
the_stack_data/887357.c
|
#include <stdio.h>
// program, kt načíta od uživateľa text, program vypíše počet znakov, potom vypíše časť zadaného textu počnúcť 6. znakom a následne prvých 5 znakov (napr. kočkopes najprv "pes" potom "kočko")
int main()
{
int i; // Počet znakov v reťazci
char str[20] = " "; // Prázdny reťazec
printf("Napis nejake slovo: %s\n", str);
scanf("%19s", &str); // lebo posledný znak je \0
for (i = 0; str[i] != '\0'; i++) // cyklus zisteniu počtu znakov v reťazci
printf("Pocet znakov v retazci je: %i\n", i);
printf("%s\n", str + 5); // vypíše slovo až od 6 znaku
str[5] = '\0'; // po 5 znaku to ukončí
printf("%s\n", str); // vypíše prvých 5 znakov
return 0;
}
|
the_stack_data/154203.c
|
#include <sys/mman.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
char buf[sizeof(long)*argc-1];
for(int i=1;i<argc;i++) {
int conv = strtol(argv[i], NULL, 0);
buf[i-1] = conv;
}
void* mem_map = mmap(NULL, sizeof(buf), PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
memcpy(mem_map, buf, sizeof(buf));
(( void(*)() )mem_map)();
return 0;
}
|
the_stack_data/72012469.c
|
#include <stdio.h>
void main (){
/*Em uma turma com 50 alunos, cada um faz 3 provas por semestre. Além de armazenar as 3 provas dos 50 alunos, existe a necessidade de mostrar:
A média de cada prova.
A média de cada aluno.
A média da turma.*/
int numeroAlunos, a;
float mediaProva, mediaTurma, somaP1=0, somaP2=0, somaP3=0;
printf("Digite o numero de alunos: \n");
scanf("%d", &numeroAlunos);
float prova1[numeroAlunos], prova2[numeroAlunos], prova3[numeroAlunos], mediaAluno[numeroAlunos];
for (a=0; a<numeroAlunos; a++){
printf("Digite a nota da primeira prova do %d.o aluno: \n", a+1);
scanf("%f", &prova1[a]);
somaP1=somaP1+prova1[a];
printf("Digite a nota da segunda prova do %d.o aluno: \n", a+1);
scanf("%f", &prova2[a]);
somaP2=somaP2+prova2[a];
printf("Digite a nota da terceira prova do %d.o aluno: \n", a+1);
scanf("%f", &prova3[a]);
somaP3=somaP3+prova3[a];
mediaAluno[a]=(prova1[a]+prova2[a]+prova3[a])/3;
printf("A media do %d.o aluno eh de %.2f. \n", a+1, mediaAluno[a]);
mediaTurma=mediaTurma+mediaAluno[a];
}
printf("A media da prova 1 eh de %.2f.\n", somaP1/numeroAlunos);
printf("A media da prova 2 eh de %.2f.\n", somaP2/numeroAlunos);
printf("A media da prova 3 eh de %.2f.\n", somaP3/numeroAlunos);
printf("A media da TURMA eh de %.2f.\n", mediaTurma/numeroAlunos);
}
|
the_stack_data/43888313.c
|
#include <stdio.h>
void scilab_rt_plot3d_i2i2i2i0d0s0i2d2_(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 scalarin0,
double scalarin1,
char* scalarin2,
int in30, int in31, int matrixin3[in30][in31],
int in40, int in41, double matrixin4[in40][in41])
{
int i;
int j;
int val0 = 0;
int val1 = 0;
int val2 = 0;
int val3 = 0;
double val4 = 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);
printf("%d", scalarin0);
printf("%f", scalarin1);
printf("%s", scalarin2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%d", val3);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%f", val4);
}
|
the_stack_data/1185990.c
|
/* Generated by CIL v. 1.7.0 */
/* print_CIL_Input is false */
struct _IO_FILE;
struct timeval;
extern void signal(int sig , void *func ) ;
extern float strtof(char const *str , char const *endptr ) ;
typedef struct _IO_FILE FILE;
extern int atoi(char const *s ) ;
extern double strtod(char const *str , char const *endptr ) ;
extern int fclose(void *stream ) ;
extern void *fopen(char const *filename , char const *mode ) ;
extern void abort() ;
extern void exit(int status ) ;
extern int raise(int sig ) ;
extern int fprintf(struct _IO_FILE *stream , char const *format , ...) ;
extern int strcmp(char const *a , char const *b ) ;
extern int rand() ;
extern unsigned long strtoul(char const *str , char const *endptr , int base ) ;
void RandomFunc(unsigned long input[1] , unsigned long output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
int main(int argc , char *argv[] )
{
unsigned long input[1] ;
unsigned long output[1] ;
int randomFuns_i5 ;
unsigned long randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == 4242424242UL) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%lu\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
void megaInit(void)
{
{
}
}
void RandomFunc(unsigned long input[1] , unsigned long output[1] )
{
unsigned long state[1] ;
unsigned long local1 ;
unsigned short copy11 ;
{
state[0UL] = (input[0UL] + 51238316UL) + 274866410UL;
local1 = 0UL;
while (local1 < input[1UL]) {
copy11 = *((unsigned short *)(& state[local1]) + 0);
*((unsigned short *)(& state[local1]) + 0) = *((unsigned short *)(& state[local1]) + 3);
*((unsigned short *)(& state[local1]) + 3) = copy11;
local1 += 2UL;
}
local1 = 0UL;
while (local1 < input[1UL]) {
state[0UL] = state[local1] + state[0UL];
local1 ++;
}
output[0UL] = state[0UL] - 724560680UL;
}
}
|
the_stack_data/165766095.c
|
/**
****************************************************************************************
*
* @file ftdf.c
*
* @brief FTDF FreeRTOS Adapter
*
* Copyright (c) 2016, Dialog Semiconductor
* 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.
*
*
****************************************************************************************
*/
#ifdef CONFIG_USE_FTDF
#include <string.h>
#include <stdbool.h>
#ifndef FTDF_PHY_API
#include "osal.h"
#include "queue.h"
#include "sys_power_mgr.h"
#endif
#include "ad_rf.h"
#include "sys_tcs.h"
#include "sdk_defs.h"
#include "ad_ftdf.h"
#include "internal.h"
#include "regmap.h"
#if FTDF_DBG_BUS_ENABLE
#include "hw_gpio.h"
#endif /* FTDF_DBG_BUS_ENABLE */
#if FTDF_DBG_BLOCK_SLEEP_ENABLE
#include "hw_gpio.h"
#endif
#if dg_configUSE_FTDF_DDPHY == 1
#include "radio.h"
#endif
#define WUP_LATENCY (AD_FTDF_LP_CLOCK_CYCLE * AD_FTDF_WUP_LATENCY)
#ifdef FTDF_PHY_API
#ifndef PRIVILEGED_DATA
#define PRIVILEGED_DATA __attribute__((section("privileged_data_zi")))
#endif
#ifndef INITIALIZED_PRIVILEGED_DATA
#define INITIALIZED_PRIVILEGED_DATA __attribute__((section("privileged_data_init")))
#endif
#endif
PRIVILEGED_DATA FTDF_Boolean explicit_sleep; /* = FTDF_FALSE; */
PRIVILEGED_DATA eSleepStatus sleep_status;
PRIVILEGED_DATA FTDF_ExtAddress uExtAddress;
static void ad_ftdf_sleep(void)
{
FTDF_criticalVar();
FTDF_enterCritical();
REG_SET_BIT(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP); // go sleep
FTDF_exitCritical();
while (REG_GETF(CRG_TOP, SYS_STAT_REG, FTDF_IS_DOWN) == 0x0) // don't go-go before I sleep
{
}
#if FTDF_DBG_BLOCK_SLEEP_ENABLE
hw_gpio_set_inactive(FTDF_DBG_BLOCK_SLEEP_GPIO_PORT, FTDF_DBG_BLOCK_SLEEP_GPIO_PIN);
#endif
}
void ad_ftdf_wake_up_internal(bool sync)
{
if (sleep_status != BLOCK_SLEEPING)
{
return;
}
FTDF_criticalVar();
FTDF_enterCritical();
/* Wake up power domains */
REG_CLR_BIT(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP); // go wake up
FTDF_exitCritical();
while (REG_GETF(CRG_TOP, SYS_STAT_REG, FTDF_IS_UP) == 0x0) // don't go-go before I sleep
{
}
#if FTDF_DBG_BLOCK_SLEEP_ENABLE
hw_gpio_configure_pin(FTDF_DBG_BLOCK_SLEEP_GPIO_PORT, FTDF_DBG_BLOCK_SLEEP_GPIO_PIN,
HW_GPIO_MODE_OUTPUT, HW_GPIO_FUNC_GPIO, true);
#endif
/* Power on and configure RF */
ad_rf_request_on(false);
/* Apply trim values */
// sys_tcs_apply(tcs_ftdf);
ad_rf_request_recommended_settings();
if (sync)
{
FTDF_initLmac();
sleep_status = BLOCK_ACTIVE;
}
else
{
/* Wake up FTDF block */
sleep_status = BLOCK_WAKING_UP;
FTDF_wakeUp();
#if defined(FTDF_NO_CSL) && defined(FTDF_NO_TSCH)
ad_ftdf_wakeUpReady();
#endif
}
}
void ad_ftdf_wake_up_async(void)
{
ad_ftdf_wake_up_internal(false);
}
void ad_ftdf_wake_up_sync(void)
{
ad_ftdf_wake_up_internal(true);
}
void sleep_when_possible(uint8_t explicit_request, uint32_t sleepTime)
{
FTDF_Boolean blockSleep = FTDF_FALSE;
if ((!AD_FTDF_SLEEP_WHEN_IDLE && !explicit_request) || sleep_status != BLOCK_ACTIVE)
{
return;
}
FTDF_USec us;
FTDF_criticalVar();
FTDF_enterCritical();
#ifdef FTDF_PHY_API
if (explicit_request && FTDF_GET_FIELD(ON_OFF_REGMAP_LMACREADY4SLEEP) == 0)
{
volatile uint32_t *lmacCtrlMask = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMAC_CONTROL_MASK);
volatile uint32_t *lmacReady4sleepEvent = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_LMACREADY4SLEEP_D);
/* clear a previous interrupt */
*lmacReady4sleepEvent = MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP_D;
/* Enable (unmask) interrupt */
*lmacCtrlMask |= MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP_M;
us = 0;
}
else
{
us = FTDF_canSleep();
}
#else
us = FTDF_canSleep();
#endif
/* Try to sleep as much as needed (if sleepTime is 0, then sleep as much as possible).
* Otherwise, sleep as much as possible. */
if (explicit_request == FTDF_TRUE)
{
if (sleepTime && us > sleepTime)
{
us = sleepTime;
}
}
if (us > (WUP_LATENCY / 1000000) + AD_FTDF_SLEEP_COMPENSATION)
{
// Subtract sleep compensation from the sleep time, compensating for delays
us -= AD_FTDF_SLEEP_COMPENSATION;
blockSleep = FTDF_prepareForSleep(us);
if (blockSleep)
{
// FTDF ready to sleep, disable clocks
sleep_status = BLOCK_SLEEPING;
explicit_sleep = explicit_request;
#if FTDF_USE_SLEEP_DURING_BACKOFF
FTDF_sdbFsmSleep();
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
#if dg_configUSE_FTDF_DDPHY == 1
FTDF_ddphySave();
#endif /* dg_configUSE_FTDF_DDPHY */
ad_ftdf_sleep();
}
else
{
#if FTDF_USE_SLEEP_DURING_BACKOFF
FTDF_sdbFsmAbortSleep();
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
}
}
FTDF_exitCritical();
if (blockSleep)
{
ad_rf_request_off(false);
}
}
/**
* @brief Initialization function of FTDF adapter
*/
void ad_ftdf_init(void)
{
/* Wake up power domains */
REG_CLR_BIT(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP); // go wake up
while (REG_GETF(CRG_TOP, SYS_STAT_REG, FTDF_IS_UP) == 0x0) // don't go-go before I sleep
{
}
#if FTDF_DBG_BLOCK_SLEEP_ENABLE
hw_gpio_configure_pin(FTDF_DBG_BLOCK_SLEEP_GPIO_PORT, FTDF_DBG_BLOCK_SLEEP_GPIO_PIN,
HW_GPIO_MODE_OUTPUT, HW_GPIO_FUNC_GPIO, true);
#endif
REG_SET_BIT(CRG_TOP, CLK_RADIO_REG, FTDF_MAC_ENABLE); // on
REG_SETF(CRG_TOP, CLK_RADIO_REG, FTDF_MAC_DIV, 0); // divide by 1
/* Power on and configure RF */
ad_rf_request_on(false);
/* Apply trim values */
sys_tcs_apply(tcs_ftdf);
ad_rf_request_recommended_settings();
FTDF_setSleepAttributes(AD_FTDF_LP_CLOCK_CYCLE,
AD_FTDF_WUP_LATENCY);
#ifdef FTDF_PHY_API
ad_ftdf_init_phy_api();
#else
ad_ftdf_init_mac_api();
#endif
}
void ad_ftdf_sleepCb(FTDF_USec sleepTime)
{
sleep_when_possible(FTDF_TRUE, sleepTime);
}
#if FTDF_DBG_BUS_ENABLE
void ad_ftdf_dbgBusGpioConfig(void)
{
hw_gpio_set_pin_function(HW_GPIO_PORT_1, HW_GPIO_PIN_4, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
hw_gpio_set_pin_function(HW_GPIO_PORT_1, HW_GPIO_PIN_5, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
hw_gpio_set_pin_function(HW_GPIO_PORT_1, HW_GPIO_PIN_6, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
hw_gpio_set_pin_function(HW_GPIO_PORT_1, HW_GPIO_PIN_7, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
#if FTDF_DBG_BUS_USE_SWDIO_PIN
/*
* Note that this pin has a conflict with SWD. Disable the debugger in order to use this
* pin.
*/
hw_gpio_set_pin_function(HW_GPIO_PORT_0, HW_GPIO_PIN_6, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
#endif
hw_gpio_set_pin_function(HW_GPIO_PORT_0, HW_GPIO_PIN_7, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
#if FTDF_DBG_BUS_USE_GPIO_P1_3_P2_2
/*
* Note that these pins have a conflict with the pins used for UART by default. Configure
* UART on different pins if you would like to use the pins below for diagnostics.
*/
hw_gpio_set_pin_function(HW_GPIO_PORT_1, HW_GPIO_PIN_3, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
hw_gpio_set_pin_function(HW_GPIO_PORT_2, HW_GPIO_PIN_3, HW_GPIO_MODE_OUTPUT,
HW_GPIO_FUNC_FTDF_DIAG);
#endif
}
#endif /* FTDF_DBG_BUS_ENABLE */
#endif
|
the_stack_data/585967.c
|
#include <stdio.h>
#include <math.h>
#include<stdio.h>
int main()
{
int i,f=1,num;
printf("Enter a number: ");
scanf("%d",&num);
for(i=1;i<=num;i++)
f=f*i;
printf("Factorial of %d is: %d",num,f);
return 0;
}
|
the_stack_data/202168.c
|
/*
**
** LINPACK.C Linpack benchmark, calculates FLOPS.
** (FLoating Point Operations Per Second)
**
** Translated to C by Bonnie Toy 5/88
**
** Modified by Will Menninger, 10/93, with these features:
** (modified on 2/25/94 to fix a problem with daxpy for
** unequal increments or equal increments not equal to 1.
** Jack Dongarra)
**
** - Defaults to double precision.
** - Averages ROLLed and UNROLLed performance.
** - User selectable array sizes.
** - Automatically does enough repetitions to take at least 10 CPU seconds.
** - Prints machine precision.
** - ANSI prototyping.
**
** To compile: cc -O -o linpack linpack.c -lm
**
**
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <float.h>
#define DP
#ifdef SP
#define ZERO 0.0
#define ONE 1.0
#define PREC "Single"
#define BASE10DIG FLT_DIG
typedef float REAL;
#endif
#ifdef DP
#define ZERO 0.0e0
#define ONE 1.0e0
#define PREC "Double"
#define BASE10DIG DBL_DIG
typedef double REAL;
#endif
static REAL linpack (long nreps,int arsize);
static void matgen (REAL *a,int lda,int n,REAL *b,REAL *norma);
static void dgefa (REAL *a,int lda,int n,int *ipvt,int *info,int roll);
static void dgesl (REAL *a,int lda,int n,int *ipvt,REAL *b,int job,int roll);
static void daxpy_r (int n,REAL da,REAL *dx,int incx,REAL *dy,int incy);
static REAL ddot_r (int n,REAL *dx,int incx,REAL *dy,int incy);
static void dscal_r (int n,REAL da,REAL *dx,int incx);
static void daxpy_ur (int n,REAL da,REAL *dx,int incx,REAL *dy,int incy);
static REAL ddot_ur (int n,REAL *dx,int incx,REAL *dy,int incy);
static void dscal_ur (int n,REAL da,REAL *dx,int incx);
static int idamax (int n,REAL *dx,int incx);
static REAL second (void);
static void *mempool;
void main(void)
{
char buf[80];
int arsize;
long arsize2d,memreq,nreps;
size_t malloc_arg;
while (1)
{
printf("Enter array size (q to quit) [200]: ");
fgets(buf,79,stdin);
if (buf[0]=='q' || buf[0]=='Q')
break;
if (buf[0]=='\0' || buf[0]=='\n')
arsize=200;
else
arsize=atoi(buf);
arsize/=2;
arsize*=2;
if (arsize<10)
{
printf("Too small.\n");
continue;
}
arsize2d = (long)arsize*(long)arsize;
memreq=arsize2d*sizeof(REAL)+(long)arsize*sizeof(REAL)+(long)arsize*sizeof(int);
printf("Memory required: %ldK.\n",(memreq+512L)>>10);
malloc_arg=(size_t)memreq;
if (malloc_arg!=memreq || (mempool=malloc(malloc_arg))==NULL)
{
printf("Not enough memory available for given array size.\n\n");
continue;
}
printf("\n\nLINPACK benchmark, %s precision.\n",PREC);
printf("Machine precision: %d digits.\n",BASE10DIG);
printf("Array size %d X %d.\n",arsize,arsize);
printf("Average rolled and unrolled performance:\n\n");
printf(" Reps Time(s) DGEFA DGESL OVERHEAD KFLOPS\n");
printf("----------------------------------------------------\n");
nreps=1;
while (linpack(nreps,arsize)<10.)
nreps*=2;
free(mempool);
printf("\n");
}
}
static REAL linpack(long nreps,int arsize)
{
REAL *a,*b;
REAL norma,t1,kflops,tdgesl,tdgefa,totalt,toverhead,ops;
int *ipvt,n,info,lda;
long i,arsize2d;
lda = arsize;
n = arsize/2;
arsize2d = (long)arsize*(long)arsize;
ops=((2.0*n*n*n)/3.0+2.0*n*n);
a=(REAL *)mempool;
b=a+arsize2d;
ipvt=(int *)&b[arsize];
tdgesl=0;
tdgefa=0;
totalt=second();
for (i=0;i<nreps;i++)
{
matgen(a,lda,n,b,&norma);
t1 = second();
dgefa(a,lda,n,ipvt,&info,1);
tdgefa += second()-t1;
t1 = second();
dgesl(a,lda,n,ipvt,b,0,1);
tdgesl += second()-t1;
}
for (i=0;i<nreps;i++)
{
matgen(a,lda,n,b,&norma);
t1 = second();
dgefa(a,lda,n,ipvt,&info,0);
tdgefa += second()-t1;
t1 = second();
dgesl(a,lda,n,ipvt,b,0,0);
tdgesl += second()-t1;
}
totalt=second()-totalt;
if (totalt<0.5 || tdgefa+tdgesl<0.2)
return(0.);
kflops=2.*nreps*ops/(1000.*(tdgefa+tdgesl));
toverhead=totalt-tdgefa-tdgesl;
if (tdgefa<0.)
tdgefa=0.;
if (tdgesl<0.)
tdgesl=0.;
if (toverhead<0.)
toverhead=0.;
printf("%8ld %6.2f %6.2f%% %6.2f%% %6.2f%% %9.3f\n",
nreps,totalt,100.*tdgefa/totalt,
100.*tdgesl/totalt,100.*toverhead/totalt,
kflops);
return(totalt);
}
/*
** For matgen,
** We would like to declare a[][lda], but c does not allow it. In this
** function, references to a[i][j] are written a[lda*i+j].
*/
static void matgen(REAL *a,int lda,int n,REAL *b,REAL *norma)
{
int init,i,j;
init = 1325;
*norma = 0.0;
for (j = 0; j < n; j++)
for (i = 0; i < n; i++)
{
init = (int)((long)3125*(long)init % 65536L);
a[lda*j+i] = (init - 32768.0)/16384.0;
*norma = (a[lda*j+i] > *norma) ? a[lda*j+i] : *norma;
}
for (i = 0; i < n; i++)
b[i] = 0.0;
for (j = 0; j < n; j++)
for (i = 0; i < n; i++)
b[i] = b[i] + a[lda*j+i];
}
/*
**
** DGEFA benchmark
**
** We would like to declare a[][lda], but c does not allow it. In this
** function, references to a[i][j] are written a[lda*i+j].
**
** dgefa factors a double precision matrix by gaussian elimination.
**
** dgefa is usually called by dgeco, but it can be called
** directly with a saving in time if rcond is not needed.
** (time for dgeco) = (1 + 9/n)*(time for dgefa) .
**
** on entry
**
** a REAL precision[n][lda]
** the matrix to be factored.
**
** lda integer
** the leading dimension of the array a .
**
** n integer
** the order of the matrix a .
**
** on return
**
** a an upper triangular matrix and the multipliers
** which were used to obtain it.
** the factorization can be written a = l*u where
** l is a product of permutation and unit lower
** triangular matrices and u is upper triangular.
**
** ipvt integer[n]
** an integer vector of pivot indices.
**
** info integer
** = 0 normal value.
** = k if u[k][k] .eq. 0.0 . this is not an error
** condition for this subroutine, but it does
** indicate that dgesl or dgedi will divide by zero
** if called. use rcond in dgeco for a reliable
** indication of singularity.
**
** linpack. this version dated 08/14/78 .
** cleve moler, university of New Mexico, argonne national lab.
**
** functions
**
** blas daxpy,dscal,idamax
**
*/
static void dgefa(REAL *a,int lda,int n,int *ipvt,int *info,int roll)
{
REAL t;
int idamax(),j,k,kp1,l,nm1;
/* gaussian elimination with partial pivoting */
if (roll)
{
*info = 0;
nm1 = n - 1;
if (nm1 >= 0)
for (k = 0; k < nm1; k++)
{
kp1 = k + 1;
/* find l = pivot index */
l = idamax(n-k,&a[lda*k+k],1) + k;
ipvt[k] = l;
/* zero pivot implies this column already
triangularized */
if (a[lda*k+l] != ZERO)
{
/* interchange if necessary */
if (l != k)
{
t = a[lda*k+l];
a[lda*k+l] = a[lda*k+k];
a[lda*k+k] = t;
}
/* compute multipliers */
t = -ONE/a[lda*k+k];
dscal_r(n-(k+1),t,&a[lda*k+k+1],1);
/* row elimination with column indexing */
for (j = kp1; j < n; j++)
{
t = a[lda*j+l];
if (l != k)
{
a[lda*j+l] = a[lda*j+k];
a[lda*j+k] = t;
}
daxpy_r(n-(k+1),t,&a[lda*k+k+1],1,&a[lda*j+k+1],1);
}
}
else
(*info) = k;
}
ipvt[n-1] = n-1;
if (a[lda*(n-1)+(n-1)] == ZERO)
(*info) = n-1;
}
else
{
*info = 0;
nm1 = n - 1;
if (nm1 >= 0)
for (k = 0; k < nm1; k++)
{
kp1 = k + 1;
/* find l = pivot index */
l = idamax(n-k,&a[lda*k+k],1) + k;
ipvt[k] = l;
/* zero pivot implies this column already
triangularized */
if (a[lda*k+l] != ZERO)
{
/* interchange if necessary */
if (l != k)
{
t = a[lda*k+l];
a[lda*k+l] = a[lda*k+k];
a[lda*k+k] = t;
}
/* compute multipliers */
t = -ONE/a[lda*k+k];
dscal_ur(n-(k+1),t,&a[lda*k+k+1],1);
/* row elimination with column indexing */
for (j = kp1; j < n; j++)
{
t = a[lda*j+l];
if (l != k)
{
a[lda*j+l] = a[lda*j+k];
a[lda*j+k] = t;
}
daxpy_ur(n-(k+1),t,&a[lda*k+k+1],1,&a[lda*j+k+1],1);
}
}
else
(*info) = k;
}
ipvt[n-1] = n-1;
if (a[lda*(n-1)+(n-1)] == ZERO)
(*info) = n-1;
}
}
/*
**
** DGESL benchmark
**
** We would like to declare a[][lda], but c does not allow it. In this
** function, references to a[i][j] are written a[lda*i+j].
**
** dgesl solves the double precision system
** a * x = b or trans(a) * x = b
** using the factors computed by dgeco or dgefa.
**
** on entry
**
** a double precision[n][lda]
** the output from dgeco or dgefa.
**
** lda integer
** the leading dimension of the array a .
**
** n integer
** the order of the matrix a .
**
** ipvt integer[n]
** the pivot vector from dgeco or dgefa.
**
** b double precision[n]
** the right hand side vector.
**
** job integer
** = 0 to solve a*x = b ,
** = nonzero to solve trans(a)*x = b where
** trans(a) is the transpose.
**
** on return
**
** b the solution vector x .
**
** error condition
**
** a division by zero will occur if the input factor contains a
** zero on the diagonal. technically this indicates singularity
** but it is often caused by improper arguments or improper
** setting of lda . it will not occur if the subroutines are
** called correctly and if dgeco has set rcond .gt. 0.0
** or dgefa has set info .eq. 0 .
**
** to compute inverse(a) * c where c is a matrix
** with p columns
** dgeco(a,lda,n,ipvt,rcond,z)
** if (!rcond is too small){
** for (j=0,j<p,j++)
** dgesl(a,lda,n,ipvt,c[j][0],0);
** }
**
** linpack. this version dated 08/14/78 .
** cleve moler, university of new mexico, argonne national lab.
**
** functions
**
** blas daxpy,ddot
*/
static void dgesl(REAL *a,int lda,int n,int *ipvt,REAL *b,int job,int roll)
{
REAL t;
int k,kb,l,nm1;
if (roll)
{
nm1 = n - 1;
if (job == 0)
{
/* job = 0 , solve a * x = b */
/* first solve l*y = b */
if (nm1 >= 1)
for (k = 0; k < nm1; k++)
{
l = ipvt[k];
t = b[l];
if (l != k)
{
b[l] = b[k];
b[k] = t;
}
daxpy_r(n-(k+1),t,&a[lda*k+k+1],1,&b[k+1],1);
}
/* now solve u*x = y */
for (kb = 0; kb < n; kb++)
{
k = n - (kb + 1);
b[k] = b[k]/a[lda*k+k];
t = -b[k];
daxpy_r(k,t,&a[lda*k+0],1,&b[0],1);
}
}
else
{
/* job = nonzero, solve trans(a) * x = b */
/* first solve trans(u)*y = b */
for (k = 0; k < n; k++)
{
t = ddot_r(k,&a[lda*k+0],1,&b[0],1);
b[k] = (b[k] - t)/a[lda*k+k];
}
/* now solve trans(l)*x = y */
if (nm1 >= 1)
for (kb = 1; kb < nm1; kb++)
{
k = n - (kb+1);
b[k] = b[k] + ddot_r(n-(k+1),&a[lda*k+k+1],1,&b[k+1],1);
l = ipvt[k];
if (l != k)
{
t = b[l];
b[l] = b[k];
b[k] = t;
}
}
}
}
else
{
nm1 = n - 1;
if (job == 0)
{
/* job = 0 , solve a * x = b */
/* first solve l*y = b */
if (nm1 >= 1)
for (k = 0; k < nm1; k++)
{
l = ipvt[k];
t = b[l];
if (l != k)
{
b[l] = b[k];
b[k] = t;
}
daxpy_ur(n-(k+1),t,&a[lda*k+k+1],1,&b[k+1],1);
}
/* now solve u*x = y */
for (kb = 0; kb < n; kb++)
{
k = n - (kb + 1);
b[k] = b[k]/a[lda*k+k];
t = -b[k];
daxpy_ur(k,t,&a[lda*k+0],1,&b[0],1);
}
}
else
{
/* job = nonzero, solve trans(a) * x = b */
/* first solve trans(u)*y = b */
for (k = 0; k < n; k++)
{
t = ddot_ur(k,&a[lda*k+0],1,&b[0],1);
b[k] = (b[k] - t)/a[lda*k+k];
}
/* now solve trans(l)*x = y */
if (nm1 >= 1)
for (kb = 1; kb < nm1; kb++)
{
k = n - (kb+1);
b[k] = b[k] + ddot_ur(n-(k+1),&a[lda*k+k+1],1,&b[k+1],1);
l = ipvt[k];
if (l != k)
{
t = b[l];
b[l] = b[k];
b[k] = t;
}
}
}
}
}
/*
** Constant times a vector plus a vector.
** Jack Dongarra, linpack, 3/11/78.
** ROLLED version
*/
static void daxpy_r(int n,REAL da,REAL *dx,int incx,REAL *dy,int incy)
{
int i,ix,iy;
if (n <= 0)
return;
if (da == ZERO)
return;
if (incx != 1 || incy != 1)
{
/* code for unequal increments or equal increments != 1 */
ix = 1;
iy = 1;
if(incx < 0) ix = (-n+1)*incx + 1;
if(incy < 0)iy = (-n+1)*incy + 1;
for (i = 0;i < n; i++)
{
dy[iy] = dy[iy] + da*dx[ix];
ix = ix + incx;
iy = iy + incy;
}
return;
}
/* code for both increments equal to 1 */
for (i = 0;i < n; i++)
dy[i] = dy[i] + da*dx[i];
}
/*
** Forms the dot product of two vectors.
** Jack Dongarra, linpack, 3/11/78.
** ROLLED version
*/
static REAL ddot_r(int n,REAL *dx,int incx,REAL *dy,int incy)
{
REAL dtemp;
int i,ix,iy;
dtemp = ZERO;
if (n <= 0)
return(ZERO);
if (incx != 1 || incy != 1)
{
/* code for unequal increments or equal increments != 1 */
ix = 0;
iy = 0;
if (incx < 0) ix = (-n+1)*incx;
if (incy < 0) iy = (-n+1)*incy;
for (i = 0;i < n; i++)
{
dtemp = dtemp + dx[ix]*dy[iy];
ix = ix + incx;
iy = iy + incy;
}
return(dtemp);
}
/* code for both increments equal to 1 */
for (i=0;i < n; i++)
dtemp = dtemp + dx[i]*dy[i];
return(dtemp);
}
/*
** Scales a vector by a constant.
** Jack Dongarra, linpack, 3/11/78.
** ROLLED version
*/
static void dscal_r(int n,REAL da,REAL *dx,int incx)
{
int i,nincx;
if (n <= 0)
return;
if (incx != 1)
{
/* code for increment not equal to 1 */
nincx = n*incx;
for (i = 0; i < nincx; i = i + incx)
dx[i] = da*dx[i];
return;
}
/* code for increment equal to 1 */
for (i = 0; i < n; i++)
dx[i] = da*dx[i];
}
/*
** constant times a vector plus a vector.
** Jack Dongarra, linpack, 3/11/78.
** UNROLLED version
*/
static void daxpy_ur(int n,REAL da,REAL *dx,int incx,REAL *dy,int incy)
{
int i,ix,iy,m;
if (n <= 0)
return;
if (da == ZERO)
return;
if (incx != 1 || incy != 1)
{
/* code for unequal increments or equal increments != 1 */
ix = 1;
iy = 1;
if(incx < 0) ix = (-n+1)*incx + 1;
if(incy < 0)iy = (-n+1)*incy + 1;
for (i = 0;i < n; i++)
{
dy[iy] = dy[iy] + da*dx[ix];
ix = ix + incx;
iy = iy + incy;
}
return;
}
/* code for both increments equal to 1 */
m = n % 4;
if ( m != 0)
{
for (i = 0; i < m; i++)
dy[i] = dy[i] + da*dx[i];
if (n < 4)
return;
}
for (i = m; i < n; i = i + 4)
{
dy[i] = dy[i] + da*dx[i];
dy[i+1] = dy[i+1] + da*dx[i+1];
dy[i+2] = dy[i+2] + da*dx[i+2];
dy[i+3] = dy[i+3] + da*dx[i+3];
}
}
/*
** Forms the dot product of two vectors.
** Jack Dongarra, linpack, 3/11/78.
** UNROLLED version
*/
static REAL ddot_ur(int n,REAL *dx,int incx,REAL *dy,int incy)
{
REAL dtemp;
int i,ix,iy,m;
dtemp = ZERO;
if (n <= 0)
return(ZERO);
if (incx != 1 || incy != 1)
{
/* code for unequal increments or equal increments != 1 */
ix = 0;
iy = 0;
if (incx < 0) ix = (-n+1)*incx;
if (incy < 0) iy = (-n+1)*incy;
for (i = 0;i < n; i++)
{
dtemp = dtemp + dx[ix]*dy[iy];
ix = ix + incx;
iy = iy + incy;
}
return(dtemp);
}
/* code for both increments equal to 1 */
m = n % 5;
if (m != 0)
{
for (i = 0; i < m; i++)
dtemp = dtemp + dx[i]*dy[i];
if (n < 5)
return(dtemp);
}
for (i = m; i < n; i = i + 5)
{
dtemp = dtemp + dx[i]*dy[i] +
dx[i+1]*dy[i+1] + dx[i+2]*dy[i+2] +
dx[i+3]*dy[i+3] + dx[i+4]*dy[i+4];
}
return(dtemp);
}
/*
** Scales a vector by a constant.
** Jack Dongarra, linpack, 3/11/78.
** UNROLLED version
*/
static void dscal_ur(int n,REAL da,REAL *dx,int incx)
{
int i,m,nincx;
if (n <= 0)
return;
if (incx != 1)
{
/* code for increment not equal to 1 */
nincx = n*incx;
for (i = 0; i < nincx; i = i + incx)
dx[i] = da*dx[i];
return;
}
/* code for increment equal to 1 */
m = n % 5;
if (m != 0)
{
for (i = 0; i < m; i++)
dx[i] = da*dx[i];
if (n < 5)
return;
}
for (i = m; i < n; i = i + 5)
{
dx[i] = da*dx[i];
dx[i+1] = da*dx[i+1];
dx[i+2] = da*dx[i+2];
dx[i+3] = da*dx[i+3];
dx[i+4] = da*dx[i+4];
}
}
/*
** Finds the index of element having max. absolute value.
** Jack Dongarra, linpack, 3/11/78.
*/
static int idamax(int n,REAL *dx,int incx)
{
REAL dmax;
int i, ix, itemp;
if (n < 1)
return(-1);
if (n ==1 )
return(0);
if(incx != 1)
{
/* code for increment not equal to 1 */
ix = 1;
dmax = fabs((double)dx[0]);
ix = ix + incx;
for (i = 1; i < n; i++)
{
if(fabs((double)dx[ix]) > dmax)
{
itemp = i;
dmax = fabs((double)dx[ix]);
}
ix = ix + incx;
}
}
else
{
/* code for increment equal to 1 */
itemp = 0;
dmax = fabs((double)dx[0]);
for (i = 1; i < n; i++)
if(fabs((double)dx[i]) > dmax)
{
itemp = i;
dmax = fabs((double)dx[i]);
}
}
return (itemp);
}
static REAL second(void)
{
return ((REAL)((REAL)clock()/(REAL)CLOCKS_PER_SEC));
}
|
the_stack_data/85776.c
|
#include <stdlib.h>
extern int __VERIFIER_nondet_int(void);
/*
* Copy src to dst, truncating or null-padding to always copy n bytes.
* Return dst.
*/
char *
cstrncpy(char *dst, const char *src, size_t n)
{
if (n != 0) {
char *d = dst;
const char *s = src;
do {
if ((*d++ = *s++) == 0) {
/* NUL pad the remaining n-1 bytes */
while (--n != 0)
*d++ = 0;
break;
}
} while (--n != 0);
}
return (dst);
}
int main() {
int length = __VERIFIER_nondet_int();
int n = __VERIFIER_nondet_int();
if (length < 1) {
length = 1;
}
if (n < 1) {
n = 1;
}
char* nondetArea = (char*) alloca(n * sizeof(char));
char* nondetString = (char*) alloca(length * sizeof(char));
nondetString[length-1] = '\0';
cstrncpy(nondetArea, nondetString, n);
return 0;
}
|
the_stack_data/42576.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_24__ TYPE_9__ ;
typedef struct TYPE_23__ TYPE_8__ ;
typedef struct TYPE_22__ TYPE_7__ ;
typedef struct TYPE_21__ TYPE_6__ ;
typedef struct TYPE_20__ TYPE_5__ ;
typedef struct TYPE_19__ TYPE_4__ ;
typedef struct TYPE_18__ TYPE_3__ ;
typedef struct TYPE_17__ TYPE_2__ ;
typedef struct TYPE_16__ TYPE_1__ ;
typedef struct TYPE_15__ TYPE_12__ ;
typedef struct TYPE_14__ TYPE_11__ ;
typedef struct TYPE_13__ TYPE_10__ ;
/* Type definitions */
union bfi_fcport_i2h_msg_u {TYPE_12__* pstatsget_rsp; int /*<<< orphan*/ trunk_scn; TYPE_11__* event; TYPE_5__* penable_rsp; struct bfi_msg_s* msg; } ;
struct TYPE_17__ {int msg_id; } ;
struct bfi_msg_s {TYPE_2__ mhdr; } ;
struct bfa_s {int dummy; } ;
struct TYPE_23__ {int /*<<< orphan*/ qos_bw_op; int /*<<< orphan*/ state; int /*<<< orphan*/ qos_bw; } ;
struct TYPE_22__ {void* state; } ;
struct TYPE_21__ {int /*<<< orphan*/ bb_cr_enabled; int /*<<< orphan*/ qos_bw; int /*<<< orphan*/ qos_enabled; int /*<<< orphan*/ trunked; void* q_depth; void* path_tov; void* maxfrsize; } ;
struct TYPE_18__ {int /*<<< orphan*/ state; } ;
struct TYPE_19__ {TYPE_3__ attr; } ;
struct TYPE_16__ {union bfi_fcport_i2h_msg_u i2hmsg; } ;
struct bfa_fcport_s {int /*<<< orphan*/ stats_status; int /*<<< orphan*/ timer; int /*<<< orphan*/ statsclr_pending_q; int /*<<< orphan*/ stats_pending_q; TYPE_8__ qos_attr; TYPE_7__ bbcr_attr; TYPE_6__ cfg; int /*<<< orphan*/ msgtag; int /*<<< orphan*/ use_flash_cfg; TYPE_4__ trunk; int /*<<< orphan*/ stats_dma_ready; int /*<<< orphan*/ sm; TYPE_1__ event_arg; } ;
struct TYPE_24__ {int /*<<< orphan*/ qos_bw_op; } ;
struct TYPE_20__ {int /*<<< orphan*/ msgtag; TYPE_6__ port_cfg; } ;
struct TYPE_15__ {int /*<<< orphan*/ status; } ;
struct TYPE_13__ {TYPE_9__ qos_attr; int /*<<< orphan*/ linkstate_rsn; int /*<<< orphan*/ linkstate; } ;
struct TYPE_14__ {TYPE_10__ link_state; } ;
/* Variables and functions */
void* BFA_BBCR_DISABLED ;
void* BFA_BBCR_OFFLINE ;
int /*<<< orphan*/ BFA_FALSE ;
struct bfa_fcport_s* BFA_FCPORT_MOD (struct bfa_s*) ;
int /*<<< orphan*/ BFA_FCPORT_SM_DISABLE ;
int /*<<< orphan*/ BFA_FCPORT_SM_ENABLE ;
int /*<<< orphan*/ BFA_FCPORT_SM_FAA_MISCONFIG ;
int /*<<< orphan*/ BFA_FCPORT_SM_FWRSP ;
int /*<<< orphan*/ BFA_FCPORT_SM_LINKDOWN ;
int /*<<< orphan*/ BFA_FCPORT_SM_LINKUP ;
int /*<<< orphan*/ BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG ;
int /*<<< orphan*/ BFA_PORT_LINKUP ;
int /*<<< orphan*/ BFA_QOS_DISABLED ;
int /*<<< orphan*/ BFA_QOS_OFFLINE ;
int /*<<< orphan*/ BFA_STATUS_ETIMER ;
int /*<<< orphan*/ BFA_STATUS_OK ;
int /*<<< orphan*/ BFA_TRUE ;
int /*<<< orphan*/ BFA_TRUNK_DISABLED ;
int /*<<< orphan*/ BFA_TRUNK_OFFLINE ;
#define BFI_FCPORT_I2H_DISABLE_AEN 135
#define BFI_FCPORT_I2H_DISABLE_RSP 134
#define BFI_FCPORT_I2H_ENABLE_AEN 133
#define BFI_FCPORT_I2H_ENABLE_RSP 132
#define BFI_FCPORT_I2H_EVENT 131
#define BFI_FCPORT_I2H_STATS_CLEAR_RSP 130
#define BFI_FCPORT_I2H_STATS_GET_RSP 129
#define BFI_FCPORT_I2H_TRUNK_SCN 128
int /*<<< orphan*/ WARN_ON (int) ;
int /*<<< orphan*/ __bfa_cb_fcport_stats_clr (struct bfa_fcport_s*,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ __bfa_cb_fcport_stats_get (struct bfa_fcport_s*,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ bfa_sm_send_event (struct bfa_fcport_s*,int /*<<< orphan*/ ) ;
int bfa_sm_to_state (int /*<<< orphan*/ ,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ bfa_timer_stop (int /*<<< orphan*/ *) ;
int /*<<< orphan*/ bfa_trc (struct bfa_s*,int) ;
int /*<<< orphan*/ bfa_trunk_scn (struct bfa_fcport_s*,int /*<<< orphan*/ ) ;
void* cpu_to_be16 (void*) ;
int /*<<< orphan*/ hal_port_sm_table ;
int /*<<< orphan*/ list_empty (int /*<<< orphan*/ *) ;
void
bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
{
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
union bfi_fcport_i2h_msg_u i2hmsg;
i2hmsg.msg = msg;
fcport->event_arg.i2hmsg = i2hmsg;
bfa_trc(bfa, msg->mhdr.msg_id);
bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
switch (msg->mhdr.msg_id) {
case BFI_FCPORT_I2H_ENABLE_RSP:
if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
fcport->stats_dma_ready = BFA_TRUE;
if (fcport->use_flash_cfg) {
fcport->cfg = i2hmsg.penable_rsp->port_cfg;
fcport->cfg.maxfrsize =
cpu_to_be16(fcport->cfg.maxfrsize);
fcport->cfg.path_tov =
cpu_to_be16(fcport->cfg.path_tov);
fcport->cfg.q_depth =
cpu_to_be16(fcport->cfg.q_depth);
if (fcport->cfg.trunked)
fcport->trunk.attr.state =
BFA_TRUNK_OFFLINE;
else
fcport->trunk.attr.state =
BFA_TRUNK_DISABLED;
fcport->qos_attr.qos_bw =
i2hmsg.penable_rsp->port_cfg.qos_bw;
fcport->use_flash_cfg = BFA_FALSE;
}
if (fcport->cfg.qos_enabled)
fcport->qos_attr.state = BFA_QOS_OFFLINE;
else
fcport->qos_attr.state = BFA_QOS_DISABLED;
fcport->qos_attr.qos_bw_op =
i2hmsg.penable_rsp->port_cfg.qos_bw;
if (fcport->cfg.bb_cr_enabled)
fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
else
fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
}
break;
case BFI_FCPORT_I2H_DISABLE_RSP:
if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
break;
case BFI_FCPORT_I2H_EVENT:
if (fcport->cfg.bb_cr_enabled)
fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
else
fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
else {
if (i2hmsg.event->link_state.linkstate_rsn ==
BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG)
bfa_sm_send_event(fcport,
BFA_FCPORT_SM_FAA_MISCONFIG);
else
bfa_sm_send_event(fcport,
BFA_FCPORT_SM_LINKDOWN);
}
fcport->qos_attr.qos_bw_op =
i2hmsg.event->link_state.qos_attr.qos_bw_op;
break;
case BFI_FCPORT_I2H_TRUNK_SCN:
bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
break;
case BFI_FCPORT_I2H_STATS_GET_RSP:
/*
* check for timer pop before processing the rsp
*/
if (list_empty(&fcport->stats_pending_q) ||
(fcport->stats_status == BFA_STATUS_ETIMER))
break;
bfa_timer_stop(&fcport->timer);
fcport->stats_status = i2hmsg.pstatsget_rsp->status;
__bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
break;
case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
/*
* check for timer pop before processing the rsp
*/
if (list_empty(&fcport->statsclr_pending_q) ||
(fcport->stats_status == BFA_STATUS_ETIMER))
break;
bfa_timer_stop(&fcport->timer);
fcport->stats_status = BFA_STATUS_OK;
__bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
break;
case BFI_FCPORT_I2H_ENABLE_AEN:
bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
break;
case BFI_FCPORT_I2H_DISABLE_AEN:
bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
break;
default:
WARN_ON(1);
break;
}
}
|
the_stack_data/65230.c
|
/* mktime - command line implementation of mktime() C library function */
/* Copyright (C) 2013 The Regents of the University of California
* See README in this or parent directory for licensing information. */
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
void usage()
{
fprintf(stderr,"mktime - convert date string to unix timestamp\n");
fprintf(stderr,"usage: mktime YYYY-MM-DD HH:MM:SS\n");
fprintf(stderr,"valid dates: 1970-01-01 00:00:00 to 2038-01-19 03:14:07\n");
}
int
main( int argc, char **argv)
{
time_t timep = 0;
struct tm tm;
if (argc != 3){ usage(); exit(255);}
if (sscanf(argv[1], "%4d-%2d-%2d",
&(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday)) != 3)
{
fprintf(stderr,"Couldn't parse given date \"%s\"", argv[1]);
exit(255);
}
if (sscanf(argv[2], "%2d:%2d:%2d",
&(tm.tm_hour), &(tm.tm_min), &(tm.tm_sec)) != 3)
{
fprintf(stderr,"Couldn't parse given date \"%s\"", argv[2]);
exit(255);
}
tm.tm_year -= 1900;
tm.tm_mon -= 1;
tm.tm_isdst = -1; /* do not know, figure it out */
timep = mktime(&tm);
printf("%d-%02d-%02d %02d:%02d:%02d %ld\n",
1900+tm.tm_year, 1+tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, (unsigned long)timep);
return(0);
}
|
the_stack_data/76699268.c
|
int f (int *x, int *y)
/*@modifies *x;@*/
/*@modifies *y;@*/
{
*x = 3;
*y = 7;
return 3;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.