file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/173577533.c
|
int main(){
int num = 0 ,i,j;
int a = 3;
int b;
for(int j=0;j<10;j++)
for(int i=0;i<10;i++){
num = i + j;
b = a + 9;
b = a + 9;
num = i + j;
}
}
|
the_stack_data/161855.c
|
// WAP to input 5 numbers with constant values initialization in array to display the sum
#include<stdio.h>
void main()
{
int i, sum=0;
int num[5]={5, 10, 15, 20, 25};
printf("\n The 5 numbers in array is: \n");
for(i = 0; i < 5; i++){
printf("%d\n", num[i]);
sum = sum + num[i];
}
printf("\nSum of 5 numbers is: %d", sum);
getch();
}
|
the_stack_data/27368.c
|
/* Example of Menu Driven program using functions */
#include<stdio.h>
#include<stdlib.h>
/* Prototype */
int ShowMainMenu();
int ShowRhymeMenu();
int ShowRhymeSubMenu();
int ShowFairyMenu();
int ShowFairySubMenu();
void PrintZub();
void PrintBigFatGit();
void PrintAliens();
void PrintMary();
void PrintJack();
void PrintLittleBoPeep();
int main(void)
{
int
nChoice = 0;
do
{
nChoice = ShowMainMenu ();
switch (nChoice)
{
case 1:
{
ShowRhymeMenu ();
}
break;
case 2:
{
ShowFairyMenu ();
}
break;
case 3:
{
printf ("Bye Bye\n\n");
}
break;
}
}
while (nChoice != 3);
system ("Pause");
return 0;
}
/* ************************************************** ******************* */
int ShowMainMenu ()
{
int
nSelected = 0;
do
{
printf ("This is a nursery rhyme and fairy stories program\n");
printf ("You can choose to display a number of different nursery rhymes and fairy stories\n\n");
printf ("(1) Nursery rhymes\n(2) Fairy stories\n(3) Quit\n\n");
printf ("Enter a number that corresponds to your choice > ");
scanf ("%d", &nSelected);
printf("\n");
if (( nSelected < 1 ) || ( nSelected > 3))
{
printf("You have entered an invalid choice. Please try again\n\n\n");
}
}
while (( nSelected < 1) || ( nSelected > 3));
return nSelected;
}
/* ************************************************** ************************** */
int ShowRhymeMenu ()
{
int
nChoice = 0;
do
{
nChoice = ShowRhymeSubMenu();
switch (nChoice)
{
case 1:
{
PrintMary ();
}
break;
case 2:
{
PrintJack ();
}
break;
case 3:
{
PrintLittleBoPeep ();
}
break;
case 4:
{
printf ("Bye Bye\n\n");
}
break;
}
}
while (nChoice != 4);
return nChoice;
}
/* ************************************************** ******************* */
int ShowRhymeSubMenu()
{
int
nSelected = 0;
do
{
printf ("(1) Mary had a little lamb\n(2) Jack and Jill\n(3) Little Bo Peep\n(4) Quit\n\n");
printf ("Enter a number that corresponds to your choice > ");
scanf ("%d", &nSelected);
printf("\n");
if (( nSelected < 1 ) || ( nSelected > 4))
{
printf("You have entered an invalid choice. Please try again\n\n\n");
}
}
while (( nSelected < 1) || ( nSelected > 4));
return nSelected;
}
/* ************************************************** ************************** */
int ShowFairyMenu ()
{
int
nChoice = 0;
do
{
nChoice = ShowFairySubMenu ();
switch (nChoice)
{
case 1:
{
PrintZub ();
}
break;
case 2:
{
PrintBigFatGit ();
}
break;
case 3:
{
PrintAliens ();
}
break;
case 4:
{
printf ("Bye Bye\n\n");
}
break;
}
}
while (nChoice != 4);
return nChoice;
}
/* ************************************************** ******************* */
int ShowFairySubMenu ()
{
int
nSelected = 0;
do
{
printf ("(1) The zub zubs\n(2) The BFG\n(3) PrintAliens\n(4) Quit\n\n");
printf ("Enter a number that corresponds to your choice > ");
scanf ("%d", &nSelected);
printf("\n");
if (( nSelected < 1 ) || ( nSelected > 4))
{
printf("You have entered an invalid choice. Please try again\n\n\n");
}
}
while (( nSelected < 1) || ( nSelected > 4));
return nSelected;
}
/* ************************************************** ************************** */
void PrintMary ()
{
printf("Mary had a little lamb\n fleese white as snow\n\n\n");
}
/* ************************************************** ************************** */
void PrintJack ()
{
printf("Jack and jill went up the hill to fetch water\nThen they fell down\n\n\n");
}
/* ************************************************** ************************** */
void PrintLittleBoPeep()
{
printf("Little bo peep had sheep\nthen they came home\n\n\n");
}
/* ************************************************** ************************** */
void PrintZub ()
{
printf("zub zub zub zub zub zub zub zub\n\n\n");
}
/* ************************************************** ************************** */
void PrintBigFatGit ()
{
printf("im big and fat and a git\n\n\n");
}
/* ************************************************** ************************** */
void PrintAliens ()
{
printf("take us to your leader\n\n\n");
}
|
the_stack_data/248580417.c
|
#include <stdio.h>
#include <stdlib.h>
int main () {
char letter = 'A';
char name[8] = "Antonio";
int grade = 10;
float height = 1.7;
double weight = 69.76;
printf("Hi! My name is %s, and the first letter of my name is %c\n", name, letter);
printf("I am a grade %d student, always applying myself\n", grade);
printf("My height is %f, and my weight is %lfkg", height, weight);
return 0;
}
|
the_stack_data/153269160.c
|
#include <stdio.h>
int main(int argc, char *argv[])
{
int numbers[4] = {0};
char name[4] = {'a'};
//first, print them out raw
printf("numbers: %d %d %d %d\n",
numbers[0], numbers[1],
numbers[2], numbers[3]);
printf("name each: %c %c %c %c\n",
name[0], name[1],
name[2], name[3]);
printf("name: %s\n", name);
//setup the numbers
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
//setup the name
name[0] = 'Z';
name[1] = 'e';
name[2] = 'd';
name[3] = '\0';
//then print them out initialized
printf("numbers: %d %d %d %d\n",
numbers[0], numbers[1],
numbers[2], numbers[3]);
printf("name each: %c %c %c %c\n",
name[0], name[1],
name[2], name[3]);
//print the name like a string
printf("name: %s\n", name);
//another way to use name
char *another = "Zed";
printf("another: %s\n", another);
printf("another each: %c %c %c %c\n",
another[0], another[1],
another[2], another[3]);
return 0;
}
|
the_stack_data/175142869.c
|
/*
* Copyright © 2013-2017 Rinat Ibragimov
*
* This file is part of FreshPlayerPlugin.
*
* 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.
*/
#include <stdio.h>
char *
NP_GetPluginVersion(void);
int
main(void)
{
printf("version: %s\n", NP_GetPluginVersion());
printf("pass\n");
return 0;
}
|
the_stack_data/109217.c
|
/*
* Copyright 2013-2017 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
/*
* A minimal program to serve an SSL connection. It uses blocking. It uses
* the SSL_CONF API with a configuration file. cc -I../../include saccept.c
* -L../.. -lssl -lcrypto -ldl
*/
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/conf.h>
int main(int argc, char *argv[])
{
char *port = "*:4433";
BIO *in = NULL;
BIO *ssl_bio, *tmp;
SSL_CTX *ctx;
SSL_CONF_CTX *cctx = NULL;
CONF *conf = NULL;
STACK_OF(CONF_VALUE) *sect = NULL;
CONF_VALUE *cnf;
long errline = -1;
char buf[512];
int ret = EXIT_FAILURE, i;
ctx = VR_SSL_CTX_new(VR_TLS_server_method());
conf = VR_NCONF_new(NULL);
if (VR_NCONF_load(conf, "accept.cnf", &errline) <= 0) {
if (errline <= 0)
fprintf(stderr, "Error processing config file\n");
else
fprintf(stderr, "Error on line %ld\n", errline);
goto err;
}
sect = VR_NCONF_get_section(conf, "default");
if (sect == NULL) {
fprintf(stderr, "Error retrieving default section\n");
goto err;
}
cctx = VR_SSL_CONF_CTX_new();
VR_SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
VR_SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CERTIFICATE);
VR_SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_FILE);
VR_SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
for (i = 0; i < sk_CONF_VALUE_num(sect); i++) {
int rv;
cnf = sk_CONF_VALUE_value(sect, i);
rv = VR_SSL_CONF_cmd(cctx, cnf->name, cnf->value);
if (rv > 0)
continue;
if (rv != -2) {
fprintf(stderr, "Error processing %s = %s\n",
cnf->name, cnf->value);
VR_ERR_print_errors_fp(stderr);
goto err;
}
if (strcmp(cnf->name, "Port") == 0) {
port = cnf->value;
} else {
fprintf(stderr, "Unknown configuration option %s\n", cnf->name);
goto err;
}
}
if (!VR_SSL_CONF_CTX_finish(cctx)) {
fprintf(stderr, "Finish error\n");
VR_ERR_print_errors_fp(stderr);
goto err;
}
/* Setup server side SSL bio */
ssl_bio = VR_BIO_new_ssl(ctx, 0);
if ((in = VR_BIO_new_accept(port)) == NULL)
goto err;
/*
* This means that when a new connection is accepted on 'in', The ssl_bio
* will be 'duplicated' and have the new socket BIO push into it.
* Basically it means the SSL BIO will be automatically setup
*/
BIO_set_accept_bios(in, ssl_bio);
again:
/*
* The first call will setup the accept socket, and the second will get a
* socket. In this loop, the first actual accept will occur in the
* VR_BIO_read() function.
*/
if (BIO_do_accept(in) <= 0)
goto err;
for (;;) {
i = VR_BIO_read(in, buf, 512);
if (i == 0) {
/*
* If we have finished, remove the underlying BIO stack so the
* next time we call any function for this BIO, it will attempt
* to do an accept
*/
printf("Done\n");
tmp = VR_BIO_pop(in);
VR_BIO_free_all(tmp);
goto again;
}
if (i < 0) {
if (VR_BIO_should_retry(in))
continue;
goto err;
}
fwrite(buf, 1, i, stdout);
fflush(stdout);
}
ret = EXIT_SUCCESS;
err:
if (ret != EXIT_SUCCESS)
VR_ERR_print_errors_fp(stderr);
VR_BIO_free(in);
return ret;
}
|
the_stack_data/461008.c
|
/* $NetBSD: isinf.c,v 1.8 2004/03/04 23:42:39 kleink Exp $ */
/*-
* Copyright (c) 1991, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)isinf.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: isinf.c,v 1.8 2004/03/04 23:42:39 kleink Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include <math.h>
#undef isinf
int isinf __P((double));
/* ARGSUSED */
int
isinf(double d)
{
return (0);
}
|
the_stack_data/86074260.c
|
/* crypto/ripemd/rmd_one.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 <string.h>
#include <openssl/ripemd.h>
#include <openssl/crypto.h>
unsigned char *RIPEMD160(const unsigned char *d, unsigned long n,
unsigned char *md)
{
RIPEMD160_CTX c;
static unsigned char m[RIPEMD160_DIGEST_LENGTH];
if (md == NULL) md=m;
if (!RIPEMD160_Init(&c))
return NULL;
RIPEMD160_Update(&c,d,n);
RIPEMD160_Final(md,&c);
OPENSSL_cleanse(&c,sizeof(c)); /* security consideration */
return(md);
}
|
the_stack_data/130795.c
|
#include<stdio.h>
int main()
{
int n,i;
scanf("%d",&n);
for(i=1;i<=n;i++)
{
if(i%2!=0)
{
printf("%d\n",i);
}
}
return 0;
}
|
the_stack_data/38224.c
|
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#define MAX 150
pthread_t id[10];
char path[100];
char filepathlist[MAX][MAX];
int len = 0;
int threadcount = 0;
int sortthread(void *arg){
int i = *(int *)arg;
int l = i;
printf("thread %d is starting\n",i);
while(l<len){
char* filepath = filepathlist[l];
char temp[1000];
char old[1000];
int fd,nbyte;
if((fd = open(filepath,O_RDWR)) == -1){
printf("thread %d open file %d filed!\n",i,l);
return 1;
}
memset(temp,0,sizeof(temp));
memset(old,0,sizeof(old));
nbyte = read(fd,temp,sizeof(temp));
read(fd,old,sizeof(old));
for(int a = 0;a < nbyte;a++){
for(int b = 0;b < nbyte - i;b++){
if(temp[b] > temp[b + 1]){
int t = temp[b];
temp[b] = temp[b + 1];
temp[b + 1] = t;
}
}
}
lseek(fd,0,SEEK_SET);
write(fd,temp,nbyte);
close(fd);
printf("thread %d sort file %d finished!\n",i,l);
//printf("thread %d sort file %d finished! old:%s new:%s\n",i,l,old,temp);
l += threadcount;
}
printf("thread %d is over!\n",i);
return 0;
}
int getpathlist(char path[]){
DIR *d;
struct dirent *f;
char temppath[MAX];
if(!(d = opendir(path))){
printf("Can't open %s\n",path);
return 1;
}
while((f = readdir(d)) != NULL){
if(strncmp(f->d_name,".",1) == 0)
continue;
if(f->d_type == 8){
char txt[5];
for(int i=0;i<4;i++)
txt[i] = f->d_name[strlen(f->d_name)-4+i];
txt[4]='\0';
if(strcmp(txt,".txt") == 0){
char filepath[MAX];
strcpy(filepath,path);
strcat(filepath,"/");
strcat(filepath,f->d_name);
strcpy(filepathlist[len++],filepath);
}
}
if(f->d_type == 4){
strcpy(temppath,path);
strcat(temppath,"/");
strcat(temppath,f->d_name);
getpathlist(temppath);
}
}
closedir(d);
return 0;
}
int main(void){
int ret0,ret1;
int ret[10];
int index[10] = {0,1,2,3,4,5,6,7,8,9};
char basepath[MAX];
printf("Please enter the path:\n");
///Users/wangh7/Desktop/多线程/word
scanf("%s",basepath);
do{
printf("Please enter the number of thread(<=10):\n");
scanf("%d",&threadcount);
}while(threadcount>10&&printf("Too large!\n"));
if(getpathlist(basepath))
return 1;
printf("found %d file(s):\n",len);
for(int i = 0; i < len; i++)
printf("%s\n", filepathlist[i]);
for(int i=0;i<threadcount;i++){
ret[i] = pthread_create(&id[i],NULL,(void *) sortthread,&index[i]);
}
for(int i=0;i<threadcount;i++){
if(ret[i]!= 0){
printf("Create thread error!\n");
return 1;
}
}
for(int i=0;i<threadcount;i++){
pthread_join(id[i],NULL);
}
return 0;
}
|
the_stack_data/150142486.c
|
/*
* (c) Copyright 1993, Silicon Graphics, Inc.
* ALL RIGHTS RESERVED
* Permission to use, copy, modify, and distribute this software for
* any purpose and without fee is hereby granted, provided that the above
* copyright notice appear in all copies and that both the copyright notice
* and this permission notice appear in supporting documentation, and that
* the name of Silicon Graphics, Inc. not be used in advertising
* or publicity pertaining to distribution of the software without specific,
* written prior permission.
*
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
*
* US Government Users Restricted Rights
* Use, duplication, or disclosure by the Government is subject to
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
* clause at DFARS 252.227-7013 and/or in similar or successor
* clauses in the FAR or the DOD or NASA FAR Supplement.
* Unpublished-- rights reserved under the copyright laws of the
* United States. Contractor/manufacturer is Silicon Graphics,
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
*
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
/*
* font.c
*
* Draws some text in a bitmapped font. Uses glBitmap()
* and other pixel routines. Also demonstrates use of
* display lists.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
static GLubyte rasters[][13] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36},
{0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0x66, 0xff, 0x66, 0x66, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x7e, 0xff, 0x1b, 0x1f, 0x7e, 0xf8, 0xd8, 0xff, 0x7e, 0x18},
{0x00, 0x00, 0x0e, 0x1b, 0xdb, 0x6e, 0x30, 0x18, 0x0c, 0x76, 0xdb, 0xd8, 0x70},
{0x00, 0x00, 0x7f, 0xc6, 0xcf, 0xd8, 0x70, 0x70, 0xd8, 0xcc, 0xcc, 0x6c, 0x38},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x1c, 0x0c, 0x0e},
{0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c},
{0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30},
{0x00, 0x00, 0x00, 0x00, 0x99, 0x5a, 0x3c, 0xff, 0x3c, 0x5a, 0x99, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x60, 0x60, 0x30, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x03, 0x03},
{0x00, 0x00, 0x3c, 0x66, 0xc3, 0xe3, 0xf3, 0xdb, 0xcf, 0xc7, 0xc3, 0x66, 0x3c},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x38, 0x18},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0xe7, 0x7e},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0x07, 0x03, 0x03, 0xe7, 0x7e},
{0x00, 0x00, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x03, 0x03, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x03, 0x7f, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x1c, 0x1c, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06},
{0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60},
{0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x18, 0x0c, 0x06, 0x03, 0xc3, 0xc3, 0x7e},
{0x00, 0x00, 0x3f, 0x60, 0xcf, 0xdb, 0xd3, 0xdd, 0xc3, 0x7e, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18},
{0x00, 0x00, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x7e, 0xe7, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0xfc, 0xce, 0xc7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc7, 0xce, 0xfc},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xcf, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e},
{0x00, 0x00, 0x7c, 0xee, 0xc6, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06},
{0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, 0xc3},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, 0xff, 0xff, 0xe7, 0xc3},
{0x00, 0x00, 0xc7, 0xc7, 0xcf, 0xcf, 0xdf, 0xdb, 0xfb, 0xf3, 0xf3, 0xe3, 0xe3},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x3f, 0x6e, 0xdf, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x66, 0x3c},
{0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0xe0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0xc3, 0xe7, 0xff, 0xff, 0xdb, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0xc3, 0x66, 0x66, 0x3c, 0x3c, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x7e, 0x0c, 0x06, 0x03, 0x03, 0xff},
{0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c},
{0x00, 0x03, 0x03, 0x06, 0x06, 0x0c, 0x0c, 0x18, 0x18, 0x30, 0x30, 0x60, 0x60},
{0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18},
{0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x30, 0x70},
{0x00, 0x00, 0x7f, 0xc3, 0xc3, 0x7f, 0x03, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x7e, 0xc3, 0xc0, 0xc0, 0xc0, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x03, 0x03, 0x03, 0x03, 0x03},
{0x00, 0x00, 0x7f, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x33, 0x1e},
{0x7e, 0xc3, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00},
{0x38, 0x6c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x00},
{0x00, 0x00, 0xc6, 0xcc, 0xf8, 0xf0, 0xd8, 0xcc, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78},
{0x00, 0x00, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00},
{0xc0, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x03, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xfe, 0x03, 0x03, 0x7e, 0xc0, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x00},
{0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xe7, 0xff, 0xdb, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0xc0, 0x60, 0x60, 0x30, 0x18, 0x3c, 0x66, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xff, 0x60, 0x30, 0x18, 0x0c, 0x06, 0xff, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x0f, 0x18, 0x18, 0x18, 0x38, 0xf0, 0x38, 0x18, 0x18, 0x18, 0x0f},
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
{0x00, 0x00, 0xf0, 0x18, 0x18, 0x18, 0x1c, 0x0f, 0x1c, 0x18, 0x18, 0x18, 0xf0},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x8f, 0xf1, 0x60, 0x00, 0x00, 0x00}
};
// Spacing between two successive letters in the font.
// Default font is the only one supported, so we hard-code to 10 pixels.
// Actual font seems to be a 8x13 bitmap, encoded in the array above.
float getFontWidth() { return 10.0f; }
/* This routine will load a font from the file whose name is passed
* to it as a parameter. If the name is a NULL pointer, then the default
* font is loaded.
* The return value is 0 if there is an error and a non-negative
* integer that represents this font on success. This integer should
* be saved to pass to drawStringInFont(). */
int loadFont (const char * filename)
{
GLuint fontOffset;
GLuint i;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
/* See if we are supposed to load the font from a file */
if (filename != NULL) { /* Load from a file */
fprintf(stderr,
"loadFont(): Loading from file not yet supported\n");
return(0);
} else { /* Use the default font */
if ( (fontOffset = glGenLists (128)) == 0) {
fprintf(stderr,
"loadFont(): Cannot allocate display lists\n");
return(0);
}
for (i = 32; i < 127; i++) {
glNewList(i+fontOffset, GL_COMPILE);
glBitmap(8, 13, 0.0, 2.0, getFontWidth(), 0.0, rasters[i-32]);
glEndList();
}
}
return(fontOffset);
}
void drawStringInFont (int fontOffset, const char * s)
{
glPushAttrib(GL_LIST_BIT);
glListBase(fontOffset);
glCallLists((GLsizei)strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s);
glPopAttrib ();
}
|
the_stack_data/212642481.c
|
int main(void) {
const int segments[10][7] = {{1, 1, 1, 1, 1, 1, 0 },
{0, 1, 1, 0, 0, 0, 0 },
{1, 1, 0, 1, 1, 0, 1 },
{1, 1, 1, 1, 0, 0, 1 },
{0, 1, 1, 0, 0, 1, 1 },
{1, 0, 1, 1, 0, 1, 1 },
{1, 0, 1, 1, 1, 1, 1 },
{1, 1, 1, 0, 0, 0, 0 },
{1, 1, 1, 1, 1, 1, 1 },
{1, 1, 1, 1, 0, 1, 1 }};
return 0;
}
|
the_stack_data/8961.c
|
#include <stdio.h>
void testfunc(short s, float X, char C, long long LL, int I, double D) {
printf("%d, %f, %d, %lld, %d, %f\n", s, X, C, LL, I, D);
}
int main() {
testfunc(12, 1.245f, 'x', 123456677890LL, -10, 45e14);
return 0;
}
|
the_stack_data/50866.c
|
//name: michael
//date: 20170422
//create a border of blank pixels
//floodfill exterior pixels for easier analysis
void createborder(int height, int width, int pixels[height][width],
int copy[height+2][width+2]){
for(int i = 0; i < height+2; i++){ //initilises copy array to 0
for(int j = 0; j < width+2; j++){ //provides a blank canvass
copy[i][j] = 0;
}
}
for(int i = 0; i < height; i++){ //copies the pixels rray to copy from (1, 1)
for(int j = 0; j < width; j++){ //this results in a "0" pixel border around the pixels array
copy[i+1][j+1] = pixels[i][j]; //it joins the whitespace in each corner and side of the image
}
}
}
void floodfill(int imax, int jmax, int node[imax][jmax], int i, int j){ //standard floodfill algorithm
if(i >= imax //if the (i,j) coordinates provided are outside the range of the node array, or the given coordinates point to a black pixel , stop the function
|| i < 0
|| j >= jmax
|| j < 0){
return;
} else if(node[i][j] == 1){
return;
} else {
node[i][j] = 1; //otherwise, turn the white to a black pixel
//floodfill recursion: perform floodfill around the pixel that was provided;
floodfill(imax, jmax, node, i-1, j-1); //iterate floodfill to NW
floodfill(imax, jmax, node, i-1, j ); //iterate floodfill to N
floodfill(imax, jmax, node, i-1, j+1); //iterate floodfill to NE
floodfill(imax, jmax, node, i , j-1); //iterate floodfill to W
floodfill(imax, jmax, node, i , j+1); //iterate floodfill to E
floodfill(imax, jmax, node, i+1, j-1); //iterate floodfill to SW
floodfill(imax, jmax, node, i+1, j ); //iterate floodfill to S
floodfill(imax, jmax, node, i+1, j+1); //iterate floodfill to SE
}
return;
}
|
the_stack_data/212643709.c
|
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *left;
struct node *right;
};
struct node *root;
struct node *makenode(int x)
{
struct node *p;
p=(struct node *)malloc(sizeof(struct node));
p->data=x;
p->left=NULL;
p->right=NULL;
return p;
}
int BSTinsert(int key)
{
struct node *x,*y,*z;
x=root;
y=makenode(key);
while(x!=NULL)
{
z=x;
if(x->data<key)
x=x->right;
else
x=x->left;
}
if(key<z->data)
z->left=y;
else
z->right=y;
}
int BSTmin(struct node *s)
{
while(s->left!=NULL)
{
s=s->left;
}
return s->data;
}
int BSTmax(struct node *s)
{
while(s->right!=NULL)
{
s=s->right;
}
return s->data;
}
struct node *BSTsearch(int key)
{
struct node *t;
t=root;
while(t!=NULL)
{
if(t->data==key)
return t;
else
{
if(key<t->data)
t=t->left;
else
t=t->right;
}
}
return NULL;
}
int InOrdertraversal(struct node *t)
{
if(t!=NULL)
{
InOrdertraversal(t->left);
printf(" %d",t->data);
InOrdertraversal(t->right);
}
}
void main()
{
int A[]={13,45,23,67,56,93,72,18,35};
root=NULL;
root=makenode(A[0]);
for(int i=1;i<9;i++)
{
BSTinsert(A[i]);
}
printf("Elements in the binary search tree ->");
InOrdertraversal(root);
int p=BSTmax(root);
printf("\nMax Element->%d",p);
p=BSTmin(root);
printf("\nMin Element->%d",p);
struct node *r=BSTsearch(56);
printf("\nSearched element is present at %u",r);
printf("\nSearched element->%d",r->data);
}
|
the_stack_data/1207663.c
|
#include<stdio.h>
int main(void)
{
int x;
printf("Enter the value of x:\n");
scanf("%d",&x);
for(int i=x;i>=1;i--)
{
for(int l=i-1;l>0;l--)
{
printf(" ");
}
for(int j=i;j<=x;j++)
{
printf("%d",j);
}
printf("\n");
}
}
|
the_stack_data/40763164.c
|
#include<stdio.h>
int gcd(int a,int b)
{
int i,j,c[1000],d[1000],n=0,m=0,x,y,count1=0,count2=0,g=1;
for(i=1;i<=a;i++)
{
if(a%i==0)
{
count1=count1+1;
c[n]=i;
n++;
}
}
for(j=1;j<=b;j++)
{
if(b%j==0)
{
count2=count2+1;
d[m]=j;
m++;
}
}
for(x=0;x<count1;x++)
{
for(y=0;y<count2;y++)
{
if(c[x]==d[y])
{
g=1*c[x];
}
}
}
return g;
}
void main()
{
int o,p,q,count=0;
printf("enter the number....");
scanf("%d",&q);
for(o=2;o<q;o++)
{
for(p=o+1;p<=q;p++)
{
if(gcd(o,p)==1)
{
count=count+1;
}
}
}
printf("%d",count);
}
|
the_stack_data/75338.c
|
/* <@LICENSE>
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you 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.
* </@LICENSE>
*/
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <err.h>
#include "getopt.h"
#ifdef WIN32
#ifdef _MSC_VER
/* ignore MSVC++ warnings that are annoying and hard to remove:
4702 unreachable code
(there is an unreachable assert(0) in case somehow it is reached)
*/
#pragma warning( disable : 4702 )
#endif
#endif /* WIN32 */
#define OPTERRCOLON (1)
#define OPTERRNF (2)
#define OPTERRARG (3)
char *spamc_optarg;
int spamc_optreset = 0;
int spamc_optind = 1;
int spamc_opterr = 1;
int spamc_optopt;
static int
optiserr(int argc, char * const *argv, int oint, const char *optstr,
int optchr, int err)
{
(void) argc; /* not used */
(void) optstr; /* not used */
if(spamc_opterr)
{
fprintf(stderr, "Error in argument %d, char %d: ", oint, optchr+1);
switch(err)
{
case OPTERRCOLON:
fprintf(stderr, ": in flags\n");
break;
case OPTERRNF:
fprintf(stderr, "option not found %c\n", argv[oint][optchr]);
break;
case OPTERRARG:
fprintf(stderr, "argument required for option %c\n", argv[oint][optchr]);
break;
default:
fprintf(stderr, "unknown\n");
break;
}
}
spamc_optopt = argv[oint][optchr];
return('?');
}
static int
longoptiserr(int argc, char * const *argv, int oint, int err)
{
(void) argc; /* not used */
if(spamc_opterr)
{
fprintf(stderr, "Error in argument %d : ", oint);
switch(err)
{
case OPTERRCOLON:
fprintf(stderr, ": in flags\n");
break;
case OPTERRNF:
fprintf(stderr, "option not found %s\n", argv[oint]);
break;
case OPTERRARG:
fprintf(stderr, "argument required for option %s\n", argv[oint]);
break;
default:
fprintf(stderr, "unknown\n");
break;
}
}
return('?');
}
int
spamc_getopt(int argc, char* const *argv, const char *optstr)
{
static int optchr = 0;
static int dash = 0; /* have already seen the - */
char *cp;
if (spamc_optreset)
spamc_optreset = optchr = dash = 0;
if(spamc_optind >= argc)
return(EOF);
if(!dash && (argv[spamc_optind][0] != '-'))
return(EOF);
if(!dash && (argv[spamc_optind][0] == '-') && !argv[spamc_optind][1])
{
/*
* use to specify stdin. Need to let pgm process this and
* the following args
*/
return(EOF);
}
if((argv[spamc_optind][0] == '-') && (argv[spamc_optind][1] == '-'))
{
/* -- indicates end of args */
spamc_optind++;
return(EOF);
}
if(!dash)
{
assert((argv[spamc_optind][0] == '-') && argv[spamc_optind][1]);
dash = 1;
optchr = 1;
}
/* Check if the guy tries to do a -: kind of flag */
assert(dash);
if(argv[spamc_optind][optchr] == ':')
{
dash = 0;
spamc_optind++;
return(optiserr(argc, argv, spamc_optind-1, optstr, optchr, OPTERRCOLON));
}
cp = strchr(optstr, argv[spamc_optind][optchr]);
if(!cp)
{
int errind = spamc_optind;
int errchr = optchr;
if(!argv[spamc_optind][optchr+1])
{
dash = 0;
spamc_optind++;
}
else
optchr++;
return(optiserr(argc, argv, errind, optstr, errchr, OPTERRNF));
}
if(cp[1] == ':')
{
dash = 0;
spamc_optind++;
if(spamc_optind == argc)
return(optiserr(argc, argv, spamc_optind-1, optstr, optchr, OPTERRARG));
spamc_optarg = argv[spamc_optind++];
return(*cp);
}
else
{
if(!argv[spamc_optind][optchr+1])
{
dash = 0;
spamc_optind++;
}
else
optchr++;
return(*cp);
}
assert(0);
return(0);
}
int
spamc_getopt_long(int argc, char * const argv[],
const char *optstring, struct option *longopts,
int *longindex)
{
static int optchr = 0;
static int dash = 0;
char *cp, *longopt;
char *bp, *opt = NULL;
int i, longoptlen;;
spamc_optarg = NULL; /* clear any left over state from previous option */
if(spamc_optreset)
spamc_optreset = optchr = dash = 0;
if(spamc_optind >= argc) {
return(EOF);
}
if(!dash && (argv[spamc_optind][0] != '-')) {
return(EOF);
}
if(!dash && (argv[spamc_optind][0] == '-') && !argv[spamc_optind][1]) {
/* used to specify stdin */
return(EOF);
}
if((argv[spamc_optind][0] == '-') && (argv[spamc_optind][1] == '-')
&& !argv[spamc_optind][2]) {
/* used to specify end of args */
return(EOF);
}
if((argv[spamc_optind][0] == '-') && argv[spamc_optind][1] &&
(argv[spamc_optind][1] != '-')) {
/* short option */
optchr = 1;
if(argv[spamc_optind][optchr] == ':')
return(optiserr(argc, argv, spamc_optind++, optstring, optchr, OPTERRCOLON));
cp = strchr(optstring, argv[spamc_optind++][optchr]);
if(cp == NULL)
return(optiserr(argc, argv, spamc_optind-1, optstring, optchr, OPTERRNF));
if(cp[1] == ':') {
/* requires an argument */
if(!argv[spamc_optind] || (argv[spamc_optind][0] == '-') ||
(spamc_optind >= argc)) {
return(optiserr(argc, argv, spamc_optind-1, optstring, optchr, OPTERRARG));
}
spamc_optarg = argv[spamc_optind++];
return(*cp);
} else {
dash = 0;
return(*cp);
}
}
if((argv[spamc_optind][0] == '-') && (argv[spamc_optind][1] == '-') &&
argv[spamc_optind][2]) {
/* long option */
optchr = 2;
longopt = argv[spamc_optind++];
if(longopt[2] == ':')
return(longoptiserr(argc, argv, spamc_optind, OPTERRCOLON));
longoptlen = strlen(longopt) - 2;
if((bp = strchr(longopt, '='))) {
opt = strdup(bp+1);
if (opt == NULL) {
err(1, NULL);
}
longoptlen -= strlen(bp);
}
for(i=0; ; i++) {
/* changed to longopts[i].name[0] == 0 - bug 7148 */
if((longopts[i].name == NULL) || (longopts[i].name[0] == 0)) {
free(opt);
return(longoptiserr(argc, argv, spamc_optind-1, OPTERRNF));
}
if(((strncmp(longopt+2, longopts[i].name, longoptlen)) == 0) && (strlen(longopts[i].name) == longoptlen)) {
*longindex = i;
if(longopts[i].has_arg == required_argument) {
if(((spamc_optind >= argc) || (!argv[spamc_optind]) || (argv[spamc_optind][0] == '-')) &&
(opt == NULL)) {
free(opt);
return(longoptiserr(argc, argv, spamc_optind-1, OPTERRARG));
}
if(opt != NULL) {
spamc_optarg = opt;
} else {
spamc_optarg = argv[spamc_optind++];
}
} else if(longopts[i].has_arg == optional_argument) {
if(((spamc_optind < argc) && (argv[spamc_optind]) && (argv[spamc_optind][0] != '-')) ||
(opt != NULL)) {
free(opt);
if(opt != NULL) {
spamc_optarg = opt;
} else {
spamc_optarg = argv[spamc_optind++];
}
}
}
if(longopts[i].flag == NULL) {
return(longopts[i].val);
} else {
*longopts[i].flag = longopts[i].val;
return(0);
}
}
}
}
return(0); /* should never reach here */
}
#ifdef TESTGETOPT
int
main (int argc, char **argv)
{
int c, l;
extern char *spamc_optarg;
extern int spamc_optind;
int aflg = 0;
int bflg = 0;
int errflg = 0;
char *ofile = NULL;
struct option longopts[] = {
{ "test", required_argument, 0, 't' },
};
while ((c = spamc_getopt(argc, argv, "abo:")) != EOF)
switch (c) {
case 'a':
if (bflg)
errflg++;
else
aflg++;
break;
case 'b':
if (aflg)
errflg++;
else
bflg++;
break;
case 'o':
ofile = spamc_optarg;
(void)printf("ofile = %s\n", ofile);
break;
case '?':
errflg++;
}
while((l = spamc_getopt_long(argc, argv, "t:", longopts, &l)) != EOF)
switch(l) {
case 't':
printf("--test = %s\n",spamc_optarg);
break;
}
if (errflg) {
(void)fprintf(stderr,
"usage: cmd [-a|-b] [-o <filename>] files...\n");
exit (2);
}
/*for ( ; spamc_optind < argc; spamc_optind++)
* (void)printf("%s\n", argv[spamc_optind]);
*/
return 0;
}
#endif /* TESTGETOPT */
|
the_stack_data/43887357.c
|
/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
/* { dg-options "-O2 -m64 -fdump-tree-ivopts-details" } */
#ifndef TYPE
#define TYPE char*
#endif
extern char a[];
/* Can not infer loop iteration from array -- exit test can not be
replaced by the array address. */
void foo (unsigned int i_width, TYPE dst)
{
unsigned long long i = 0;
unsigned long long j = 0;
for ( ; j < i_width; )
{
*dst = a[i];
dst++;
i += 2;
j += 1;
}
}
/* { dg-final { scan-tree-dump-times "\[^:\]*if \\(.*j_\[0-9\]+.*\\)" 1 "ivopts"} } */
|
the_stack_data/6388829.c
|
/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright (c) 2004-2008 Apple Inc. All Rights Reserved.
*
* Export of this software from the United States of America may require
* a specific license from the United States Government. It is the
* responsibility of any person or organization contemplating export to
* obtain such a license before exporting.
*
* WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
* distribute this software and its documentation for any purpose and
* without fee is hereby granted, provided that the above copyright
* notice appear in all copies and that both that copyright notice and
* this permission notice appear in supporting documentation, and that
* the name of Apple Inc. not be used in advertising or publicity pertaining
* to distribution of the software without specific, written prior
* permission. Apple Inc. makes no representations about the suitability of
* this software for any purpose. It is provided "as is" without express
* or implied warranty.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
*/
/*
* pkinit_apple_cms.c - CMS encode/decode routines, Mac OS X version
*
* Created 19 May 2004 by Doug Mitchell at Apple.
*/
#if APPLE_PKINIT
#include "pkinit_cms.h"
#include "pkinit_asn1.h"
#include "pkinit_apple_utils.h"
#include <CoreFoundation/CoreFoundation.h>
#include <Security/CMSEncoder.h>
#include <Security/CMSDecoder.h>
#include <Security/Security.h>
#include <assert.h>
#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacErrors.h>
#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacTypes.h>
/*
* Custom OIDS to specify as eContentType
*/
#define OID_PKINIT 0x2B, 6, 1, 5, 2, 3
#define OID_PKINIT_LEN 6
static const uint8 OID_PKINIT_AUTH_DATA[] = {OID_PKINIT, 1};
static const uint8 OID_PKINIT_RKEY_DATA[] = {OID_PKINIT, 3};
/* these may go public so keep these symbols private */
static const CSSM_OID _CSSMOID_PKINIT_AUTH_DATA =
{OID_PKINIT_LEN+1, (uint8 *)OID_PKINIT_AUTH_DATA};
static const CSSM_OID _CSSMOID_PKINIT_RKEY_DATA =
{OID_PKINIT_LEN+1, (uint8 *)OID_PKINIT_RKEY_DATA};
#pragma mark ----- CMS utilities ----
#define CFRELEASE(cf) if(cf) { CFRelease(cf); }
/*
* Convert platform-specific cert/signature status to krb5int_cert_sig_status.
*/
static krb5int_cert_sig_status pkiCertSigStatus(
OSStatus certStatus)
{
switch(certStatus) {
case CSSM_OK:
return pki_cs_good;
case CSSMERR_CSP_VERIFY_FAILED:
return pki_cs_sig_verify_fail;
case CSSMERR_TP_NOT_TRUSTED:
return pki_cs_no_root;
case CSSMERR_TP_INVALID_ANCHOR_CERT:
return pki_cs_unknown_root;
case CSSMERR_TP_CERT_EXPIRED:
return pki_cs_expired;
case CSSMERR_TP_CERT_NOT_VALID_YET:
return pki_cs_not_valid_yet;
case CSSMERR_TP_CERT_REVOKED:
return pki_cs_revoked;
case KRB5_KDB_UNAUTH:
return pki_cs_untrusted;
case CSSMERR_TP_INVALID_CERTIFICATE:
return pki_cs_bad_leaf;
default:
return pki_cs_other_err;
}
}
/*
* Infer krb5int_cert_sig_status from CMSSignerStatus and a CSSM TO
* cert veriofy result code (obtained via the certVerifyResultCode argument
* in CMSDecoderCopySignerStatus()).
*/
static krb5int_cert_sig_status pkiInferSigStatus(
CMSSignerStatus cms_status,
OSStatus tp_status)
{
switch(cms_status) {
case kCMSSignerUnsigned:
return pki_not_signed;
case kCMSSignerValid:
return pki_cs_good;
case kCMSSignerNeedsDetachedContent:
return pki_bad_cms;
case kCMSSignerInvalidSignature:
return pki_cs_sig_verify_fail;
case kCMSSignerInvalidCert:
/* proceed with TP status */
break;
default:
return pki_cs_other_err;
}
/* signature good, infer end status from TP verify */
return pkiCertSigStatus(tp_status);
}
/*
* Cook up a SecCertificateRef from a krb5_data.
*/
static OSStatus pkiKrb5DataToSecCert(
const krb5_data *rawCert,
SecCertificateRef *secCert) /* RETURNED */
{
CSSM_DATA certData;
OSStatus ortn;
assert((rawCert != NULL) && (secCert != NULL));
certData.Data = (uint8 *)rawCert->data;
certData.Length = rawCert->length;
ortn = SecCertificateCreateFromData(&certData, CSSM_CERT_X_509v3,
CSSM_CERT_ENCODING_DER, secCert);
if(ortn) {
pkiCssmErr("SecCertificateCreateFromData", ortn);
}
return ortn;
}
/*
* Convert CFArray of SecCertificateRefs to a mallocd array of krb5_datas.
*/
static krb5_error_code pkiCertArrayToKrb5Data(
CFArrayRef cf_certs,
unsigned *num_all_certs,
krb5_data **all_certs)
{
CFIndex num_certs;
krb5_data *allCerts = NULL;
krb5_error_code krtn = 0;
CFIndex dex;
if(cf_certs == NULL) {
*all_certs = NULL;
return 0;
}
num_certs = CFArrayGetCount(cf_certs);
*num_all_certs = (unsigned)num_certs;
if(num_certs == 0) {
*all_certs = NULL;
return 0;
}
allCerts = (krb5_data *)malloc(sizeof(krb5_data) * num_certs);
if(allCerts == NULL) {
return ENOMEM;
}
for(dex=0; dex<num_certs; dex++) {
CSSM_DATA cert_data;
OSStatus ortn;
SecCertificateRef sec_cert;
sec_cert = (SecCertificateRef)CFArrayGetValueAtIndex(cf_certs, dex);
ortn = SecCertificateGetData(sec_cert, &cert_data);
if(ortn) {
pkiCssmErr("SecCertificateGetData", ortn);
krtn = KRB5_PARSE_MALFORMED;
break;
}
krtn = pkiCssmDataToKrb5Data(&cert_data, &allCerts[dex]);
if(krtn) {
break;
}
}
if(krtn) {
if(allCerts) {
free(allCerts);
}
}
else {
*all_certs = allCerts;
}
return krtn;
}
#pragma mark ----- Create CMS message -----
/*
* Create a CMS message: either encrypted (EnvelopedData), signed
* (SignedData), or both (EnvelopedData(SignedData(content)).
*
* The message is signed iff signing_cert is non-NULL.
* The message is encrypted iff recip_cert is non-NULL.
*
* The content_type argument specifies to the eContentType
* for a SignedData's EncapsulatedContentInfo.
*/
krb5_error_code krb5int_pkinit_create_cms_msg(
const krb5_data *content, /* Content */
krb5_pkinit_signing_cert_t signing_cert, /* optional: signed by this cert */
const krb5_data *recip_cert, /* optional: encrypted with this cert */
krb5int_cms_content_type content_type, /* OID for EncapsulatedData */
krb5_ui_4 num_cms_types, /* optional, unused here */
const krb5int_algorithm_id *cms_types, /* optional, unused here */
krb5_data *content_info) /* contents mallocd and RETURNED */
{
krb5_error_code krtn;
OSStatus ortn;
SecCertificateRef sec_recip = NULL;
CFDataRef cf_content = NULL;
const CSSM_OID *eContentOid = NULL;
if((signing_cert == NULL) && (recip_cert == NULL)) {
/* must have one or the other */
pkiDebug("krb5int_pkinit_create_cms_msg: no signer or recipient\n");
return KRB5_CRYPTO_INTERNAL;
}
/*
* Optional signer cert. Note signing_cert, if present, is
* a SecIdentityRef.
*/
if(recip_cert) {
if(pkiKrb5DataToSecCert(recip_cert, &sec_recip)) {
krtn = ASN1_BAD_FORMAT;
goto errOut;
}
}
/* optional eContentType */
if(signing_cert) {
switch(content_type) {
case ECT_PkAuthData:
eContentOid = &_CSSMOID_PKINIT_AUTH_DATA;
break;
case ECT_PkReplyKeyKata:
eContentOid = &_CSSMOID_PKINIT_RKEY_DATA;
break;
case ECT_Data:
/* the only standard/default case we allow */
break;
default:
/* others: no can do */
pkiDebug("krb5int_pkinit_create_cms_msg: bad contentType\n");
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
}
/* GO */
ortn = CMSEncode((SecIdentityRef)signing_cert, sec_recip,
eContentOid,
FALSE, /* detachedContent */
kCMSAttrNone, /* no signed attributes that I know of */
content->data, content->length,
&cf_content);
if(ortn) {
pkiCssmErr("CMSEncode", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
krtn = pkiCfDataToKrb5Data(cf_content, content_info);
errOut:
CFRELEASE(sec_recip);
CFRELEASE(cf_content);
return krtn;
}
#pragma mark ----- Generalized parse ContentInfo ----
/*
* Parse a ContentInfo as best we can. All return fields are optional.
* If signer_cert_status is NULL on entry, NO signature or cert evaluation
* will be performed.
*/
krb5_error_code krb5int_pkinit_parse_cms_msg(
const krb5_data *content_info,
krb5_pkinit_cert_db_t cert_db, /* may be required for SignedData */
krb5_boolean is_client_msg, /* TRUE : msg is from client */
krb5_boolean *is_signed, /* RETURNED */
krb5_boolean *is_encrypted, /* RETURNED */
krb5_data *raw_data, /* RETURNED */
krb5int_cms_content_type *inner_content_type,/* Returned, ContentType of */
/* EncapsulatedData */
krb5_data *signer_cert, /* RETURNED */
krb5int_cert_sig_status *signer_cert_status,/* RETURNED */
unsigned *num_all_certs, /* size of *all_certs RETURNED */
krb5_data **all_certs) /* entire cert chain RETURNED */
{
SecPolicySearchRef policy_search = NULL;
SecPolicyRef policy = NULL;
OSStatus ortn;
krb5_error_code krtn = 0;
CMSDecoderRef decoder = NULL;
size_t num_signers;
CMSSignerStatus signer_status;
OSStatus cert_verify_status;
CFArrayRef cf_all_certs = NULL;
int msg_is_signed = 0;
if(content_info == NULL) {
pkiDebug("krb5int_pkinit_parse_cms_msg: no ContentInfo\n");
return KRB5_CRYPTO_INTERNAL;
}
ortn = CMSDecoderCreate(&decoder);
if(ortn) {
return ENOMEM;
}
ortn = CMSDecoderUpdateMessage(decoder, content_info->data, content_info->length);
if(ortn) {
/* no verify yet, must be bad message */
krtn = KRB5_PARSE_MALFORMED;
goto errOut;
}
ortn = CMSDecoderFinalizeMessage(decoder);
if(ortn) {
pkiCssmErr("CMSDecoderFinalizeMessage", ortn);
krtn = KRB5_PARSE_MALFORMED;
goto errOut;
}
/* expect zero or one signers */
ortn = CMSDecoderGetNumSigners(decoder, &num_signers);
switch(num_signers) {
case 0:
msg_is_signed = 0;
break;
case 1:
msg_is_signed = 1;
break;
default:
krtn = KRB5_PARSE_MALFORMED;
goto errOut;
}
/*
* We need a cert verify policy even if we're not actually evaluating
* the cert due to requirements in libsecurity_smime.
*/
ortn = SecPolicySearchCreate(CSSM_CERT_X_509v3,
is_client_msg ? &CSSMOID_APPLE_TP_PKINIT_CLIENT : &CSSMOID_APPLE_TP_PKINIT_SERVER,
NULL, &policy_search);
if(ortn) {
pkiCssmErr("SecPolicySearchCreate", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
ortn = SecPolicySearchCopyNext(policy_search, &policy);
if(ortn) {
pkiCssmErr("SecPolicySearchCopyNext", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
/* get some basic status that doesn't need heavyweight evaluation */
if(msg_is_signed) {
if(is_signed) {
*is_signed = TRUE;
}
if(inner_content_type) {
CSSM_OID ec_oid = {0, NULL};
CFDataRef ec_data = NULL;
krb5int_cms_content_type ctype;
ortn = CMSDecoderCopyEncapsulatedContentType(decoder, &ec_data);
if(ortn || (ec_data == NULL)) {
pkiCssmErr("CMSDecoderCopyEncapsulatedContentType", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
ec_oid.Data = (uint8 *)CFDataGetBytePtr(ec_data);
ec_oid.Length = CFDataGetLength(ec_data);
if(pkiCompareCssmData(&ec_oid, &CSSMOID_PKCS7_Data)) {
ctype = ECT_Data;
}
else if(pkiCompareCssmData(&ec_oid, &CSSMOID_PKCS7_SignedData)) {
ctype = ECT_SignedData;
}
else if(pkiCompareCssmData(&ec_oid, &CSSMOID_PKCS7_EnvelopedData)) {
ctype = ECT_EnvelopedData;
}
else if(pkiCompareCssmData(&ec_oid, &CSSMOID_PKCS7_EncryptedData)) {
ctype = ECT_EncryptedData;
}
else if(pkiCompareCssmData(&ec_oid, &_CSSMOID_PKINIT_AUTH_DATA)) {
ctype = ECT_PkAuthData;
}
else if(pkiCompareCssmData(&ec_oid, &_CSSMOID_PKINIT_RKEY_DATA)) {
ctype = ECT_PkReplyKeyKata;
}
else {
ctype = ECT_Other;
}
*inner_content_type = ctype;
CFRelease(ec_data);
}
/*
* Get SignedData's certs if the caller wants them
*/
if(all_certs) {
ortn = CMSDecoderCopyAllCerts(decoder, &cf_all_certs);
if(ortn) {
pkiCssmErr("CMSDecoderCopyAllCerts", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
krtn = pkiCertArrayToKrb5Data(cf_all_certs, num_all_certs, all_certs);
if(krtn) {
goto errOut;
}
}
/* optional signer cert */
if(signer_cert) {
SecCertificateRef sec_signer_cert = NULL;
CSSM_DATA cert_data;
ortn = CMSDecoderCopySignerCert(decoder, 0, &sec_signer_cert);
if(ortn) {
/* should never happen if it's signed */
pkiCssmErr("CMSDecoderCopySignerStatus", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
ortn = SecCertificateGetData(sec_signer_cert, &cert_data);
if(ortn) {
pkiCssmErr("SecCertificateGetData", ortn);
CFRelease(sec_signer_cert);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
krtn = pkiDataToKrb5Data(cert_data.Data, cert_data.Length, signer_cert);
CFRelease(sec_signer_cert);
if(krtn) {
goto errOut;
}
}
}
else {
/* not signed */
if(is_signed) {
*is_signed = FALSE;
}
if(inner_content_type) {
*inner_content_type = ECT_Other;
}
if(signer_cert) {
signer_cert->data = NULL;
signer_cert->length = 0;
}
if(signer_cert_status) {
*signer_cert_status = pki_not_signed;
}
if(num_all_certs) {
*num_all_certs = 0;
}
if(all_certs) {
*all_certs = NULL;
}
}
if(is_encrypted) {
Boolean bencr;
ortn = CMSDecoderIsContentEncrypted(decoder, &bencr);
if(ortn) {
pkiCssmErr("CMSDecoderCopySignerStatus", ortn);
krtn = KRB5_CRYPTO_INTERNAL;
goto errOut;
}
*is_encrypted = bencr ? TRUE : FALSE;
}
/*
* Verify signature and cert. The actual verify operation is optional,
* per our signer_cert_status argument, but we do this anyway if we need
* to get the signer cert.
*/
if((signer_cert_status != NULL) || (signer_cert != NULL)) {
ortn = CMSDecoderCopySignerStatus(decoder,
0, /* signerIndex */
policy,
signer_cert_status ? TRUE : FALSE, /* evaluateSecTrust */
&signer_status,
NULL, /* secTrust - not needed */
&cert_verify_status);
if(ortn) {
/* gross error - subsequent processing impossible */
pkiCssmErr("CMSDecoderCopySignerStatus", ortn);
krtn = KRB5_PARSE_MALFORMED;
goto errOut;
}
}
/* obtain & return status */
if(signer_cert_status) {
*signer_cert_status = pkiInferSigStatus(signer_status, cert_verify_status);
}
/* finally, the payload */
if(raw_data) {
CFDataRef cf_content = NULL;
ortn = CMSDecoderCopyContent(decoder, &cf_content);
if(ortn) {
pkiCssmErr("CMSDecoderCopyContent", ortn);
krtn = KRB5_PARSE_MALFORMED;
goto errOut;
}
krtn = pkiCfDataToKrb5Data(cf_content, raw_data);
CFRELEASE(cf_content);
}
errOut:
CFRELEASE(policy_search);
CFRELEASE(policy);
CFRELEASE(cf_all_certs);
CFRELEASE(decoder);
return krtn;
}
krb5_error_code krb5int_pkinit_get_cms_types(
krb5int_algorithm_id **supported_cms_types, /* RETURNED */
krb5_ui_4 *num_supported_cms_types) /* RETURNED */
{
/* no preference */
*supported_cms_types = NULL;
*num_supported_cms_types = 0;
return 0;
}
krb5_error_code krb5int_pkinit_free_cms_types(
krb5int_algorithm_id *supported_cms_types,
krb5_ui_4 num_supported_cms_types)
{
/*
* We don't return anything from krb5int_pkinit_get_cms_types(), and
* if we did, it would be a pointer to a statically declared array,
* so this is a nop.
*/
return 0;
}
#endif /* APPLE_PKINIT */
|
the_stack_data/1125196.c
|
#include<stdio.h>
int main()
{
/// Scanf() return value :
// int a,b;
// printf("Return scanf() value : %d\n",scanf("%d",&a));
// int a,b;
// printf("Return scanf() value : %d\n",scanf("%d%d",&a,&b));
// printf("Return getchar() value : %c\n",getchar());
/// printf() return value :
// char str[]="mrk pulock";
// printf("\nreturn printf() value : %d\n",printf("%s\n",str));
int a = 92902;
printf("\nreturn printf() value : %d\n",printf("%d\n",a));
return 0;
}
|
the_stack_data/133805.c
|
#include <stdio.h>
#include <stdlib.h>
#define BUFFER_SIZE 256
int main(void);
void get_line(char *buffer, int size);
int main(void) {
char buffer[BUFFER_SIZE];
int time;
printf("時刻を入力してください\n");
get_line(buffer, BUFFER_SIZE);
time = atoi(buffer);
if (time >= 0 && time <= 11) {
printf("おはようございます\n");
} else if (time == 12) {
printf("お昼です\n");
} else if (time >= 13 && time <= 18) {
printf("こんにちは\n");
} else if (time >= 19 && time <= 23) {
printf("こんばんは\n");
} else {
printf("時刻の範囲を超えています\n");
}
return 0;
}
void get_line(char *buffer, int size) {
if (fgets(buffer, size, stdin) == NULL) {
buffer[0] = '\0';
return;
}
for (int i = 0; i < size; i++) {
if (buffer[i] == '\n') {
buffer[i] = '\0';
return;
}
}
}
|
the_stack_data/433058.c
|
/******************************************************************************/
/*
Author - 0x4497B08A15362F14
*/
/******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
inline uint32_t swapU32(uint32_t value);
uint32_t swapU32(uint32_t value)
{
return ((value & 0x000000FF) << 24)
| ((value & 0x0000FF00) << 8)
| ((value & 0x00FF0000) >> 8)
| ((value & 0xFF000000) >> 24);
}
int main(int argc, const char* aArgv[])
{
if(argc < 2 || argc > 2)
{
printf("Usage: ./main sidbase.bin\n");
return 0;
}
else
{
FILE* fh = fopen(aArgv[1], "rb");
if(!fh)
{
printf("Could not open %s! - Does it even exist?\n", aArgv[1]);
return -1;
}
else
{
fseek(fh, 0x0, SEEK_END);
size_t fsize = ftell(fh);
fseek(fh, 0x0, SEEK_SET);
uint8_t* pMem = (uint8_t*)malloc(fsize);
if(!pMem)
{
printf("Failed to allocate 0x%08X bytes\n", fsize);
fclose(fh);
return -1;
}
else
{
fread(pMem, 0x1, fsize, fh);
fclose(fh);
FILE* dumpHandle = fopen("sidbase.txt", "w");
if(dumpHandle)
{
int32_t numEntries = (int32_t)swapU32(*(uint32_t*)pMem);
char* pStrings = pMem + (numEntries << 0x3) + 0x4;
uint8_t* pEntry = pMem + 0x4;
uint32_t stringId = 0x0;
uint32_t offset = 0;
for(int i = 0; i < numEntries; i++)
{
stringId = swapU32(*(uint32_t*)pEntry);
offset = swapU32(*(uint32_t*)(pEntry+0x4));
fprintf(dumpHandle, "0x%08X: %s\n", stringId, (pStrings + offset) );
pEntry+=0x8;
}
fclose(dumpHandle);
printf("Done....\n");
}
free(pMem);
return 0;
}
}
}
}
|
the_stack_data/112639184.c
|
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#define NUM_ELEMENTS(X) (sizeof(X)/sizeof(*X))
#define MAX(X, Y) ((X) > (Y)) ? (X) : (Y)
#define NUMITEMS 10
#define KNAPSACK_WEIGHT 250
#define MINWEIGHT 1
#define MAXWEIGHT 100
#define MINVALUE 10
#define MAXVALUE 1000
static int *values = NULL;
static int *weights = NULL;
static int knapsack(int item, int remaining) {
if (item == NUMITEMS) {
return 0;
}
if (weights[item] > remaining) {
return knapsack(item+1, remaining);
} else {
return MAX(knapsack(item+1, remaining),
knapsack(item+1, remaining-weights[item]) + values[item]);
}
}
static int ranged_random(int min, int max) {
int x = random();
x %= max;
if (x < min) {
x = min; /* not ideal. but whatever. :D */
}
return x;
}
int main(void)
{
int i, max;
values = malloc(sizeof(int) * NUMITEMS);
weights = malloc(sizeof(int) * NUMITEMS);
/* srand is the normal unix, but on darwin, it's srandom */
srandom(time(NULL));
for (i = 0; i < NUMITEMS; i++) {
values[i] = ranged_random(MINVALUE, MAXVALUE);
weights[i] = ranged_random(MINWEIGHT, MAXWEIGHT);
}
max = knapsack(0, KNAPSACK_WEIGHT);
printf("maximum knapsack value: %d\n", max);
free(values);
free(weights);
return 0;
}
|
the_stack_data/156392474.c
|
/** A multiplexer
a |\
----->| \
| \--------> c
b | /
----->| /
|/
Multiplex 2 inputs via STDIN.
The selector is c % 2, where c is the index of each character.
Example:
$ echo hello bob | ./mux
hbeolbl o
*/
#define _XOPEN_SOURCE
#define _XOPEN_SOURCE_EXTENDED
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
void outputArray(char *array, int size);
int
main(int argc, char **argv)
{
char a[1024];
char b[1024];
fscanf(stdin, "%s %s", a, b);
assert(a != NULL);
assert(b != NULL);
int maxSize = strlen(a);
if (maxSize < strlen(b))
{
maxSize = strlen(b);
}
maxSize += 1; // terminating zero
int cSize = maxSize * 2;
char *c = (char *) calloc(cSize, sizeof(char));
assert(c != NULL);
char *ai = a;
char *bi = b;
for (int i = 0; i < cSize; i++)
{
if (i % 2)
{
c[i] = *bi == '\0' ? *bi : *bi++;
}
else
{
c[i] = *ai == '\0' ? *ai : *ai++;
}
}
outputArray(c, cSize);
free(c);
}
void
outputArray(char *array, int size)
{
for (int i = 0; i < size; i++)
{
printf("%c", array[i] != '\0' ? array[i] : ' ');
}
printf("\n");
}
|
the_stack_data/145083.c
|
#include <stdlib.h>
#include <assert.h>
int main()
{
int *x=calloc(sizeof(int), 1);
assert(*x==0);
return 0;
}
|
the_stack_data/45450926.c
|
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <inttypes.h>
#define SIZE 2048 // Size of Buffers
#define QSIZE 100 // Size of Queries
// DNS Header
int StartsWith(const char *a, const char *b){
if(strncmp(a, b, strlen(b)) == 0)
return 1;
return 0;
}
int ends_with(char *a,char *b){
for(int i=0;i<strlen(a);i++)
{
if(a[i]==b[0])
{
for(int j=0;j<strlen(b);j++)
if(a[i+j]!=b[j])
return 0;
return 1;
}
}
return 0;
}
void getRoot(char root[100]){
char line[100];
system("nslookup -type=ns . > root.txt");
FILE *fp = fopen("root.txt", "r");
while (fscanf(fp,"%s",line)!=EOF)
{
if(ends_with(line,".root-servers.net."))
{
strcpy(root,line);
break;
}
}
}
void getDomain(char domain[100], char website[230],char root[100]){
char cmd[169] = "nslookup -type=ns ",cmd2[100] = "", path[1035]="", *token;
token = strtok(website, ".");
int i = strncmp(token, "www", 3);
if (i == 0)
token = strtok(NULL, ".");
char *lastpart = strtok(NULL, "\0");
strcat(cmd,lastpart);
strcat(cmd," ");
strcat(cmd, root);
strcat(cmd, " > ");
strcat(cmd, "domain.txt");
system(cmd);
FILE *fp = fopen("domain.txt", "r");
while (fgets(path, sizeof(path), fp) != NULL) {
if(strstr(path, "nameserver"))
{
token=strtok(path, " = ");
token=strtok(NULL, " = ");
token[strcspn(token, "\n")] = 0;
strcpy(domain, token);
break;
}
}
}
void get_name_server(char domain[100], char website[100], char nameserver[100]){
char cmd[169] = "nslookup -type=ns ",cmd2[100] = "", path[1035]="", *token, w[100];
strcpy(w, website);
token = strtok(website, ".");
int i = strncmp(token, "www", 3);
if (i == 0)
token = strtok(NULL, ".");
strcat(cmd,w);
strcat(cmd," ");
strcat(cmd, domain);
strcat(cmd, " > ");
strcat(cmd, "nameserver.txt");
system(cmd);
FILE *fp = fopen("nameserver.txt", "r");
while (fgets(path, sizeof(path), fp) != NULL) {
if(strstr(path, "nameserver"))
{
token=strtok(path, " = ");
token=strtok(NULL, " = ");
token[strcspn(token, "\n")] = 0;
strcpy(nameserver, token);
break;
}
}
}
void get_main_server(char result[100],char domain[100], char website[100], int type){
char cmd[169] = "nslookup -type=",cmd2[100] = "", path[1035]="", root[100]="", *token,w[100], nameserver[100];
if(type == 1)
strcat(cmd, "aaaa ");
else if(type == 2)
strcat(cmd, "a ");
else if(type == 3)
strcat(cmd, "cname ");
else
strcat(cmd, "ns ");
strcpy(w, website);
w[strlen(w)-1] = '\0';
website[strlen(website)-1] = '\0';
strcat(cmd,w);
strcat(cmd," ");
get_name_server(domain,w, nameserver);
strcat(cmd, nameserver);
strcat(cmd, " > ");
strcat(cmd, "cache/");
strcat(cmd, website);
strcat(cmd2, "cache/");
strcat(cmd2, website);
if(type == 1)
{
strcat(cmd, "-aaaa");
strcat(cmd2, "-aaaa");
}
if(type == 2)
{
strcat(cmd, "-a");
strcat(cmd2, "-a");
}
if (type == 3)
{
strcat(cmd, "-cname");
strcat(cmd2, "-cname");
}
if (type == 4)
{
strcat(cmd, "-ns");
strcat(cmd2, "-ns");
}
strcat(cmd, ".txt");
strcat(cmd2, ".txt");
printf("Command Invoked: %s\n",cmd);
system(cmd);
FILE *fp = fopen(cmd2,"r");
if(type == 1 || type == 2)
{
int i = 0;
while (fgets(path, sizeof(path), fp) != NULL) {
if(strstr(path, "Address"))
{
if(i == 1)
{
token=strtok(path, " = ");
token=strtok(NULL, " = ");
token[strcspn(token, "\n")] = 0;
strcpy(result, token);
i++;
break;
}
else
i++;
}
}
if(i == 1)
strcat(result, "not found");
}
if(type == 4)
{
while (fgets(path, sizeof(path), fp) != NULL) {
if(strstr(path, "nameserver"))
{
token=strtok(path, " = ");
token=strtok(NULL, " = ");
token[strcspn(token, "\n")] = '\0';
strcat(result, token);
strcat(result, ";");
}
}
}
if(type == 3)
{
int flag = 0;
while (fgets(path, sizeof(path), fp) != NULL) {
if(strstr(path, "canonical name"))
{
printf("%s\n", path);
token=strtok(path, " = ");
token=strtok(NULL, " = ");
token=strtok(NULL, " = ");
token[strcspn(token, "\n")] = 0;
strcat(result, token);
flag = 1;
}
}
if(flag == 0)
{
strcat(result, "not found");
}
}
}
char *nslookup_handle(char result[100], char args[100], int type)
{
int i, n;
char website[230]="", domain[100]="",root[100]="";
char website_name[100]="";
strcpy(website, args);
strcpy(website_name, args);
printf("\n[ NSLOOKUP OUTPUT ]\n");
getRoot(root);
printf("Root: %s\n", root);
getDomain(domain, website,root);
printf("Domain:%s\n", domain);
get_main_server(result, domain, website_name, type);
}
typedef struct {
char ID[2]; // ID number
unsigned short RD :1; // Recursion Desired
unsigned short TC :1; // Truncate
unsigned short AA :1; // Authoritive Answer
unsigned short OPCODE :1; // Purpose of msg
unsigned short QR :1; // Query/Response
unsigned short RCODE :4; // Response Code
unsigned short CD :1; // Checking Disabled
unsigned short AD :1; // Authenticated Data
unsigned short Z :1; // Reserved
unsigned short RA :1; // Recursion Available
unsigned short QDCOUNT; // Question Count
unsigned short ANCOUNT; // Answer Count
unsigned short NSCOUNT; // Name Server Count
unsigned short ARCOUNT; // Additional Info Count
} DNS_HEADER;
// Constant sized fields of query structure
typedef struct {
char QNAME[QSIZE];
short unsigned qsize;
char QTYPE[2];
char QCLASS[2];
} DNS_QUESTION;
typedef struct {
unsigned short TTL;
unsigned short RDLENGTH;
char RDATA[QSIZE];
} DNS_ANS;
typedef struct DNS_RECORD{
DNS_QUESTION Q;
DNS_ANS A;
struct DNS_RECORD *next;
struct DNS_RECORD *prev;
} DNS_RECORD;
typedef struct {
int sock;
char buf[SIZE];
struct sockaddr_in clientAddr;
} HL_ARG;
DNS_RECORD *Cache;
pthread_mutex_t lock_cache;
// Parse the DNS Header from received buffer
void parseHeader(char *buffer, DNS_HEADER *header){
char temp;
header->ID[0] = buffer[0];
header->ID[1] = buffer[1];
// Taking the 3rd byte and parsing it
temp = buffer[2];
header->QR = (temp & 128) >> 7;
header->OPCODE = (temp & 120) >> 3;
header->AA = (temp & 4) >> 2;
header->TC = (temp & 2) >> 1;
header->RD = temp & 1;
// Taking the 4th byte and parsing
temp = buffer[3];
header->RA = (temp & 128) >> 7;
header->Z = (temp & 64) >> 6;
header->AD = (temp & 32) >> 5;
header->CD = (temp & 16) >> 4;
header->RCODE = temp & 15;
// Taking 5th and 6th byte and parsing Question Entry count
header->QDCOUNT = buffer[4] << 8;
header->QDCOUNT += buffer[5];
// Taking 7th and 8th byte and parsing Answer Entry count
header->ANCOUNT = buffer[6] << 8;
header->ANCOUNT += buffer[7];
// Taking 9th and 10th byte and parsing Name Server count
header->NSCOUNT = buffer[8] << 8;
header->NSCOUNT += buffer[9];
// Taking 11th and 12th byte and parsing Additional Info count
header->ARCOUNT = buffer[10] << 8;
header->ARCOUNT += buffer[11];
}
// Replace a substring in a string
char *str_replace(char *orig, char *rep, char *with) {
char *result; // the return string
char *ins; // the next insert point
char *tmp; // varies
int len_rep; // length of rep (the string to remove)
int len_with; // length of with (the string to replace rep with)
int len_front; // distance between rep and end of last rep
int count; // number of replacements
// sanity checks and initialization
if (!orig || !rep)
return NULL;
len_rep = strlen(rep);
if (len_rep == 0)
return NULL; // empty rep causes infinite loop during count
if (!with)
with = "";
len_with = strlen(with);
// count the number of replacements needed
ins = orig;
for (count = 0; tmp = strstr(ins, rep); ++count) {
ins = tmp + len_rep;
}
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
if (!result)
return NULL;
while (count--) {
ins = strstr(orig, rep);
len_front = ins - orig;
tmp = strncpy(tmp, orig, len_front) + len_front;
tmp = strcpy(tmp, with) + len_with;
orig += len_front + len_rep; // move to next "end of rep"
}
strcpy(tmp, orig);
return result;
}
// Parse Question from Question buffer
void parseQuestion(char *qs, DNS_QUESTION *q){
// Fetch the Question
int i = 0;
while (qs[i])
i += qs[i] + 1;
q->qsize = i + 1;
for (i = 0; i < q->qsize; i++)
q->QNAME[i] = qs[i];
q->QTYPE[0] = qs[q->qsize];
q->QTYPE[1] = qs[q->qsize + 1];
q->QCLASS[0] = qs[q->qsize + 2];
q->QCLASS[1] = qs[q->qsize + 3];
}
void check_4(char final[4], char *octet){
strcpy(final, "");
if (strlen(octet) == 1){
strcat(final, "000");
strcat(final, octet);
}
else if (strlen(octet) == 2){
strcat(final, "00");
strcat(final, octet);
}
else if (strlen(octet) == 3){
strcat(final, "0");
strcat(final, octet);
}
else
strcat(final, octet);
}
char *substr(const char *src, int m, int n){
int len = n - m;
char *dest = (char*)malloc(sizeof(char) * (len + 1));
for (int i = m; i < n && ((*src + i) != '\0'); i++){
*dest = *(src + i);
dest++;
}
*dest = '\0';
return dest-len;
}
int cname( char *RDATA, char re[100], char website[100]){
char r[100], *token;
strcpy(r, re);
int i = 0, loop = 0;
token = strtok(r, ".");
while (token != NULL){
short m = strlen(token);
RDATA[i] = m;
i++;
loop = 0;
while (token[loop] != '\0'){
RDATA[i] = token[loop];
loop++;
i++;
}
token = strtok(NULL, ".");
}
RDATA[i++] = 0;
return i;
}
// Parse IPv4 to RDATA
void parseIPv4(char *RDATA, char *ip){
char *temp;
// Break string into IP fields
temp = strtok(ip,".");
RDATA[0] = atoi(temp);
temp = strtok(NULL, ".");
RDATA[1] = atoi(temp);
temp = strtok(NULL, ".");
RDATA[2] = atoi(temp);
temp = strtok(NULL, ".");
RDATA[3] = atoi(temp);
}
// Parse IPv6 to RDATA
void parseIPv6(char *RDATA, char *IP2){
char *IP, *octet;
char final[4], format[20];
if (strstr(IP2,"::")){
IP = str_replace(IP2, "::", ":0000:0000:");
octet = strtok(IP, ":");
}
else {
octet = strtok(IP2, ":");
}
check_4(final, octet);
char byte[2];
char *ptr;
RDATA[0] = strtoumax(substr(final, 0, 2), &ptr, 16);
RDATA[1] = strtoumax(substr(final, 2, 4), &ptr, 16);
short i = 1;
for (short i = 1; i < 6; i++){
octet = strtok(NULL,":");
check_4(final, octet);
RDATA[i*2] = strtoumax(substr(final, 0, 2), &ptr, 16);
RDATA[i*2 + 1] = strtoumax(substr(final, 2, 4), &ptr, 16);
}
octet = strtok(NULL, "\0");
check_4(final, octet);
printf("%s\n", octet);
RDATA[14] = strtoumax(substr(final, 0, 2), &ptr, 16);
RDATA[15] = strtoumax(substr(final, 2, 4), &ptr, 16);
}
// Check if Cache has the Query Request's Response
int fetchFromCache(DNS_QUESTION *q, DNS_ANS *ans){
printf("\n[ CHECKING CACHE ]\n");
DNS_RECORD *entry = Cache;
int flag = 0;
while (entry != NULL){
if (q->qsize == entry->Q.qsize){
if (q->QTYPE[0] == entry->Q.QTYPE[0] && q->QTYPE[1] == entry->Q.QTYPE[1]){
short matching = 1;
for (unsigned short i = 0; i < q->qsize; i++) {
// Check if Domain Names are the same
if (q->QNAME[i] != entry->Q.QNAME[i]){
matching = 0;
break;
}
if (matching){
*ans = entry->A;
flag = 1;
break;
}
}
}
}
entry = entry->next; // Goto next cache entry
}
if (!flag)
printf("\n[ CACHE MISS ]\n");
else
printf("\n[ CACHE HIT ]\n");
return flag;
}
// Converts query name to URL
void NameToString(char *str, DNS_QUESTION *q){
unsigned short i = 0, j = 0;
while (q->QNAME[i]){
j = i + 1;
i += q->QNAME[i] + 1;
while (j < i){
str[j - 1] = q->QNAME[j];
++j;
}
str[j - 1] = '.';
}
str[j] = '\0';
}
// Add a new entry to the cache
void addCache(DNS_QUESTION *q, DNS_ANS *ans){
DNS_RECORD *entry = (DNS_RECORD*)malloc(sizeof(DNS_RECORD));
entry->Q = *q;
entry->A = *ans;
entry->next = NULL;
entry->prev = NULL;
if (Cache != NULL){
entry->next = Cache;
Cache->prev = entry;
}
Cache = entry;
printf("\n[ NEW ENTRY ADDED TO CACHE ]\n");
}
// Fetch the Answer Iteratively
int fetchIterative(DNS_QUESTION *q, DNS_ANS *ans){
ans->TTL = 30;
int n = 1;
char web[100], website[100], result[100] = "", fname[100]="", *token, w[100], path[100];
NameToString(web, q); // Get website name
strcpy(w, web);
strcat(fname, "cache/");
strcat(fname, web); // Make a cache entry for website
// For AAAA Queries
if (q->QTYPE[1] == 0x1C){
nslookup_handle(result, web, 1);
printf("Results: %s\n", result);
if (strncmp(result, "not found", 9) == 0)
ans->RDLENGTH = 0;
else {
ans->RDLENGTH = 16;
parseIPv6(ans->RDATA, result);
}
addCache(q, ans);
}
// For A Queries
else if(q->QTYPE[1] == 0x1){
nslookup_handle(result, web, 2);
printf("Result: %s\n", result);
if (strncmp(result, "not found", 9) == 0)
ans->RDLENGTH = 0;
else {
ans->RDLENGTH = 4;
parseIPv4(ans->RDATA, result);
}
addCache(q, ans);
}
// For CNAME Queries
else if(q->QTYPE[1] == 0x5){
strcpy(website, web);
token = strtok(w, ".");
int i = strncmp(token, "www", 3);
if (!i){
token = strtok(NULL, "\0");
strcpy(website, token);
}
nslookup_handle(result, web, 3);
if (strncmp(result, "not found", 9) == 0)
ans->RDLENGTH = 0;
else{
int r = cname(ans->RDATA, result, website);
ans->RDLENGTH = r;
printf("Result : %s %i\n", website, r);
return 666;
}
}
// For NS Queries
else if(q->QTYPE[1] == 0x2){
strcpy(website, web);
token = strtok(w, ".");
int i = strncmp(token, "www", 3);
if (!i){
token = strtok(NULL, "\0");
strcpy(website, token);
}
nslookup_handle(result, web, 4);
if (strncmp(result, "not found", 9) == 0)
ans->RDLENGTH = 0;
else{
int r = cname(ans->RDATA, result, website);
ans->RDLENGTH = r;
printf("Result : %s %i\n", website, r);
return 666;
}
}
return n;
}
int resolveQuery(DNS_QUESTION *q, DNS_ANS *ans){
ans->TTL = 30;
int n = 1;
// Check if its not in the cache
if (fetchFromCache(q, ans) == 0)
n = fetchIterative(q, ans);
return n;
}
// Packs a DNS Packet Header
void assignHeader(char *buffer, DNS_HEADER *header, unsigned short RDLENGTH){
// Assign ID
buffer[0] = header->ID[0];
buffer[1] = header->ID[1];
// Pack the 3rd byte
char temp = 1; //QR = 1 as it is a Query Response
temp = temp << 4;
temp = temp | (header->OPCODE); // Assign OPCODE
temp = temp << 1;
temp = temp | (header->AA); // Assign AA
temp = temp << 1;
temp = temp | (header->TC); // Assign TC
temp = temp << 1;
temp = temp | (header->RD); // Assign RD
buffer[2] = temp;
temp = 0; // Assign RA as 0
temp = temp << 7;
temp = temp | (header->RCODE); // ASSIGN RCODE
buffer[3] = temp;
buffer[5] = header->QDCOUNT;
buffer[7] = (RDLENGTH == 0) ? 0 : 1;
buffer[9] = header->NSCOUNT;
buffer[11] = header->ARCOUNT;
}
void assignQuestion(char *qField, DNS_QUESTION *q){
unsigned i = 0;
// Get the Question Field
while (i < q->qsize){
qField[i] = q->QNAME[i];
++i;
}
qField[i++] = q->QTYPE[0];
qField[i++] = q->QTYPE[1];
qField[i++] = q->QCLASS[0];
qField[i++] = q->QCLASS[1];
}
void assignAnswer(char *ansField, DNS_QUESTION *q, DNS_ANS *ans){
unsigned i = 0;
while (i < q->qsize){
ansField[i] = q->QNAME[i];
++i;
}
ansField[i++] = q->QTYPE[0];
ansField[i++] = q->QTYPE[1];
ansField[i++] = q->QCLASS[0];
ansField[i++] = q->QCLASS[1];
ansField[i++] = 0;
ansField[i++] = 0;
ansField[i++] = 0;
ansField[i++] = ans->TTL;
ansField[i++] = 0;
ansField[i++] = ans->RDLENGTH;
for (unsigned j = 0; j < ans->RDLENGTH; j++)
ansField[i++] = ans->RDATA[j];
}
unsigned createResponse(DNS_HEADER *header, DNS_QUESTION *q, DNS_ANS *ans, char *buffer){
memset(buffer, 0, SIZE);
unsigned pos = 0;
assignHeader(buffer, header, ans->RDLENGTH);
pos = 12; // Header is 12 bytes
assignQuestion(buffer + pos, q);
pos += (q->qsize) + 4;
if (ans->RDLENGTH != 0){
assignAnswer(buffer + pos, q, ans);
pos += (q->qsize) + 10 + (ans->RDLENGTH);
}
return pos;
}
// Searching the Cache
void *TTLHandler(){
pthread_mutex_lock(&lock_cache);
DNS_RECORD *entry, *temp;
entry = Cache; // To iterate through the cache
while (entry != NULL){
entry->A.TTL -= 1;
if (entry->A.TTL == 0){
if (entry->next != NULL)
(entry->next)->prev = entry->prev;
if (entry->prev == NULL)
Cache = entry->next;
else
(entry->prev)->next = entry->next;
temp = entry;
printf("\n[ DELETING CACHE ENTRY : %s ]\n", temp->Q.QNAME);
entry = entry->next;
free (temp);
}
else
entry = entry->next;
}
pthread_mutex_unlock(&lock_cache);
}
void *cacheHandler(){
clock_t start, end;
while (1){
start = clock() / CLOCKS_PER_SEC;
while (1){
end = clock() / CLOCKS_PER_SEC;
if (end - start >= 1)
break;
}
pthread_t T_ID;
pthread_create(&T_ID, NULL, TTLHandler, NULL);
}
}
void *handleLookup(void *ARG){
HL_ARG *arg = (HL_ARG *)ARG;
DNS_HEADER requestHeader;
DNS_QUESTION requestQuestion;
DNS_ANS ans;
parseHeader(arg->buf, &requestHeader);
parseQuestion(arg->buf + 12, &requestQuestion);
int n = resolveQuery(&requestQuestion, &ans);
if(requestQuestion.QTYPE[1] == 0x2){
DNS_ANS ans[n];
}
char buffer[SIZE];
unsigned int packetSize;
packetSize = createResponse(&requestHeader, &requestQuestion, &ans, buffer);
if (sendto(arg->sock, buffer, packetSize, 0, (struct sockaddr *)&(arg->clientAddr), sizeof(arg->clientAddr)) < 0 )
printf("Error in sendto()");
else
printf("\n[ RESPONSE SENT ]\n");
free(arg);
}
int main(int argc, char *argv[]){
struct sockaddr_in server_addr, client_addr;
int sock, newsock, opt = 1;
int client_addr_len = sizeof(client_addr);
char recvBuff[SIZE];
int recvLen;
Cache = NULL;
pthread_mutex_init(&lock_cache, NULL);
unsigned short portno;
// Check if port number was given or not
if (argc < 2){
printf("\nPort Number: ");
scanf("%hu", &portno);
}
else
portno = atoi(argv[1]);
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0){
perror("Socket Error");
return -1;
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) < 0){
perror("Error at Setting sock options");
return -1;
}
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(portno);
if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0){
perror("Error at BIND");
return 1;
}
printf("Server is on PORT: %hu\n", portno);
pthread_t T1;
pthread_create(&T1, NULL,cacheHandler, NULL);
HL_ARG *arg;
while (1){
if ((recvLen = recvfrom(sock, recvBuff, SIZE - 1, 0, (struct sockaddr *)&client_addr, &client_addr_len)) < 0)
perror("Error at recvfrom");
else{
arg = (HL_ARG *)malloc(sizeof(HL_ARG));
for (int i = 0; i < SIZE; i++)
arg->buf[i] = recvBuff[i];
arg->sock = sock;
arg->clientAddr = client_addr;
pthread_t T2;
pthread_create(&T2, NULL, handleLookup, (void*)arg);
printf("\n[ REQUEST GENERATED ]\n");
}
}
return 0;
}
|
the_stack_data/165768359.c
|
#include <stdio.h>
#include <string.h>
#include <time.h>
#define LEN 12
char W[LEN], X[LEN];
int total;
void count(int pos)
{
int i=pos, j;
while (W[i] != '\0') {
if(W[i]=='?')
break;
i++;
}
if(W[i] == '\0'){ //end
if(strcmp(W,X)>0) total++;
//printf("%s %s\n", W, X);
return ;
}
for (j=0; j<10; j++){
W[i] = '0'+j;
count(i+1);
W[i] = '?';
}
}
int main(int argc, char* argv[])
{
freopen("input.txt", "r", stdin);
double start, end;
start = clock();
while (~scanf("%s%s", W, X)) {
//printf("%s \n%s\n", W, X);
total =0;
count(0);
printf("%d\n", total);
}
end = clock();
printf("%.3lf MS\n", (end-start)/1000);
return 0;
}
|
the_stack_data/67325767.c
|
#include<stdio.h>
int main(){
char str[]={"SABCDE"};
char *ptr = str;
while(*ptr != '\0') {
printf("%p\t%c\n", &ptr,*ptr);
ptr++;
}
}
|
the_stack_data/26700095.c
|
#include <stdio.h>
// Returns count of different partitions of n
// elements in k subsets
int countP(int n, int k)
{
// Base cases
if (n == 0 || k == 0 || k > n)
return 0;
if (k == 1 || k == n)
return 1;
//recursively get the subsets
return k*countP(n-1, k) + countP(n-1, k-1);
}
int main()
{
int n, k;
//take inputs
scanf("%d", &n);
scanf("%d", &k);
//print output
printf("%d", countP(n, k));
return 0;
}
|
the_stack_data/184517026.c
|
/**
* This program (initials.c), prints the initials of someones full name in all capitals
*
* USAGE: Please enter your name:
tommy pickles
Your initials are: TP
*/
//Initializing the APIs/ Libraries
# include <stdio.h> //has fgets(), printf()
# include <string.h>// has strlen()
# include <ctype.h> // has toupper()
//Declare function
void getInitials(char* name);
int main(void){
//Declare a string for a users name assuming the name doesn't exceed 31 characters
char name[31];
//Ask the user for their name
printf("Please enter your name:\n");
//Get the users input (his or her name)
fgets(name, sizeof(name), stdin);;
printf("Your initials are: ");
//Prints the initials
getInitials(name);
}
void getInitials(char* name){
int i=0;
// If the string length is greater than 0 then there is at least 1 character at index[0]
// and if that character is alpha numeric it must be the first letter for the initials.
if(strlen(name) > 0 && isalpha(name[0]))
printf("%c", toupper(name[0]));
//While the current character in name does not equal the last character in name denoted by '\0' ,
// go through each character of the string
//NOTE: Could've used i<=strlen(name) instead of name[i] != '\0' to accomplish the same task
while(name[i] != '\0')
{
//If the character is a space, then print the next character
if(isspace(name[i]) != 0)
{
//Loops through all of the spaces for human input error
while(isspace(name[i])&& i <= strlen(name))
{
i++ ;
}
printf("%c", toupper(name[i]));
}
i++;//increment i by one
}
printf("\n");//prints a new line
}
|
the_stack_data/621311.c
|
/*
** EPITECH PROJECT, 2020
** my_compute_power_it.c
** File description:
** [email protected]
*/
int my_compute_power_it(int nb, int p)
{
int res = nb;
if (p < 0)
return 0;
if (p == 0)
return 1;
for (int i = 1; i < p; i++)
res = res * nb;
return res;
}
|
the_stack_data/31387351.c
|
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <signal.h>
#include <ctype.h>
int Xpos=0;
float Xesti_pos = 0;
float err=0;
char rec[80]="0";
char sen[80]= "0";
float pos=0;
int sign =0;
char senstr[100];
int motorzPID;
// keys
char inc[] = "Inc";
char dec[] = "Dec";
char still[] = "Sti";
char reset[] = "res";
FILE *log_file_poin;
void logfile(){
log_file_poin = fopen("./../Textfiles/log","a");
if (log_file_poin){
//printf("log file successfully opened\n");
}
else{
printf("Failed to open the file\n");
}
}
void createfileZ(){
/*
This function creates and writes in a file to store the Motor Z process ids
*/
FILE *fp;
// Open file in write mode
fp = fopen("./../Textfiles/pidMotorZ","w+");
// If file opened successfully, then write the string to file
if ( fp )
{
motorzPID=getpid();
sprintf(senstr, "%d", motorzPID);
logfile();
fprintf(log_file_poin, "MotorZ: The file created to store PID of motorz which is");
fprintf(log_file_poin,"%s\n", senstr);
fclose(log_file_poin);
fputs(senstr,fp);
}
else
{
printf("Failed to open the file\n");
logfile();
fprintf(log_file_poin, "MotorZ: Faild to open the file");
fclose(log_file_poin);
}
//Close the file
fclose(fp);
}
float generror(){
/*
This function returns a random number between -0.5 and 0.5 as float
*/
float error;
srand ( time(NULL) );
return error = (double)rand() / (double)RAND_MAX ;
}
int subadd(){
/*
This function returns a random number between 0 and 1
*/
srand ( time(NULL) );
sign=rand()%2;
return sign;
}
void handle_sigusr2(int sig){
/*
signal handeler function
*/
strcpy(rec, reset);
logfile();
fprintf(log_file_poin, "MotorZ: The Reset signal is received\n");
fclose(log_file_poin);
}
float motion(){
/*
This is the function that controls the movement of the motors
*/
if(!strcmp(rec, inc)){
/*
Increasing Button will keep increasing until Zpos=10 is reached
*/
if(Xpos<10){
Xpos++;
err=generror();
sign = subadd();
err = err/2;
if(sign==0)
{
Xesti_pos=Xpos-err;
}else
{
Xesti_pos=Xpos+err;
}
return Xesti_pos;
}else
{
err=generror();
Xesti_pos=Xpos;
return Xesti_pos;
}
}
if(!strcmp(rec, dec))
{
/*
Decreasing button should keep decreasing until we reach Zpos=10
*/
if(Xpos>0)
{
Xpos--;
err=generror();
sign = subadd();
err = err/2;
if(sign==0)
{
Xesti_pos=Xpos-err;
}
else
{
Xesti_pos=Xpos+err;
}
return Xesti_pos;
}
else
{
err=generror();
Xesti_pos=Xpos;
return Xesti_pos;
}
}
if(!strcmp(rec, still))
{
err=generror();
sign = subadd();
err = err/2;
if(sign==0&& Xpos!=0)
{
Xesti_pos=Xpos-err;
}
else
{
Xesti_pos=Xpos+err;
}
if (Xpos==0)
{
return Xpos;
}
else if(Xpos==10)
{
return Xpos;
}
else
{
return Xesti_pos;
}
}
if(!strcmp(rec, reset))
{
err=0;
Xpos=0;
Xesti_pos=Xpos+err;
return Xesti_pos;
}
}
int main(int argc, char * argv[]){
printf("MotorZ: MotorZ succeded in execting\n");
logfile();
fprintf(log_file_poin, "MotorZ: MotorZ succeded in execting\n");
fclose(log_file_poin);
int fd2,fd3,watchdogPID;
// FIFO pipes opening
char * commandZ = "/tmp/commandZ";
char * inspectionz = "/tmp/inspectionz";
mkfifo(inspectionz, 0666);
struct sigaction sig;
memset(&sig, 0, sizeof(sig));
sig.sa_handler= &handle_sigusr2;
sigaction(SIGUSR2, &sig, NULL);
while (1)
{
createfileZ();
logfile();
fprintf(log_file_poin, "MotorZ: created text file to pass my PID\n");
fclose(log_file_poin);
fd2 = open(commandZ,O_RDONLY);
fd_set rfds;
struct timeval tv;
int retval;
FD_ZERO(&rfds);
FD_SET(fd2, &rfds);
tv.tv_sec = 1;
tv.tv_usec = 0;
retval = select(fd2+1, &rfds, NULL, NULL, &tv);
if (retval == -1)
{
perror("error!");
}
else if (retval)
{
/*
data is now available
*/
printf("MotorZ: recvied data from fifo\n");
logfile();
fprintf(log_file_poin, "MotorZ: recvied data from fifo\n");
fclose(log_file_poin);
read(fd2, rec, 80);
logfile();
fprintf(log_file_poin, "MotorZ: data recived is:");
fprintf(log_file_poin,"%s\n", rec);
fclose(log_file_poin);
fd3 = open(inspectionz,O_WRONLY);
if (rec[0] == 'q')
{
sen[0]='q';
write(fd3, sen, strlen(sen)+1);
logfile();
fprintf(log_file_poin, "MotorZ: Received q terminate the process\n");
fclose(log_file_poin);
exit(EXIT_SUCCESS) ;
}
pos=motion();
sprintf(sen, "%f", pos); //from string to float
write(fd3, sen, strlen(sen)+1);
}
else
{
/*
no data update
*/
pos=motion();
sprintf(sen, "%f", pos);
fd3 = open(inspectionz,O_WRONLY);
write(fd3, sen, strlen(sen)+1);
logfile();
fprintf(log_file_poin, "MotorZ: Send the position to inspection which is");
fclose(log_file_poin);
}
watchdogPID = atoi(argv[1]);
//send a signal to the watchdog
kill(watchdogPID, SIGUSR1);
logfile();
fprintf(log_file_poin, "MotorZ: Send signal to watchdog");
fclose(log_file_poin);
}
return 0;
}
|
the_stack_data/178266006.c
|
#include <stdio.h>
void scilab_rt_plot3d_i2i2d2d0d0s0d2i2_(int in00, int in01, int matrixin0[in00][in01],
int in10, int in11, int matrixin1[in10][in11],
int in20, int in21, double matrixin2[in20][in21],
double scalarin0,
double scalarin1,
char* scalarin2,
int in30, int in31, double matrixin3[in30][in31],
int in40, int in41, int matrixin4[in40][in41])
{
int i;
int j;
int val0 = 0;
int val1 = 0;
double val2 = 0;
double val3 = 0;
int 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("%f", val2);
printf("%f", scalarin0);
printf("%f", scalarin1);
printf("%s", scalarin2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%d", val4);
}
|
the_stack_data/237642925.c
|
#include <stdio.h>
#include <stdlib.h>
typedef int object_t;
typedef int key_t;
typedef struct tr_n_t {
key_t key;
struct tr_n_t* left;
struct tr_n_t* right;
int weight;
} tree_node_t;
// _____________________________________________________________________________
#define BLOCKSIZE 256
tree_node_t* currentblock = NULL;
int size_left;
tree_node_t* free_list = NULL;
tree_node_t*
get_node()
{
tree_node_t* tmp;
if ( free_list != NULL ) {
tmp = free_list;
free_list = free_list -> left;
} else {
if ( currentblock == NULL || size_left == 0) {
currentblock = (tree_node_t*) malloc( BLOCKSIZE * sizeof(tree_node_t) );
size_left = BLOCKSIZE;
}
tmp = currentblock++;
size_left -= 1;
}
return ( tmp );
}
void
return_node(tree_node_t* node)
{
node->left = free_list;
free_list = node;
}
tree_node_t*
create_tree(void)
{
tree_node_t* tmp_node;
tmp_node = get_node();
tmp_node->left = NULL;
return ( tmp_node );
}
void
left_rotation(tree_node_t* n)
{
tree_node_t* tmp_node;
key_t tmp_key;
tmp_node = n->left;
tmp_key = n->key;
n->left = n->right;
n->key = n->right->key;
n->right = n->left->right;
n->left->right = n->left->left;
n->left->left = tmp_node;
n->left->key = tmp_key;
}
void
right_rotation(tree_node_t* n)
{
tree_node_t* tmp_node;
key_t tmp_key;
tmp_node = n->right;
tmp_key = n->key;
n->right = n->left;
n->key = n->left->key;
n->left = n->right->left;
n->right->left = n->right->right;
n->right->right = tmp_node;
n->right->key = tmp_key;
}
object_t*
find(tree_node_t* tree, key_t query_key)
{
tree_node_t* tmp_node;
if ( tree->left == NULL )
{ return (NULL); }
else {
tmp_node = tree;
while ( tmp_node->right != NULL ) {
if ( query_key < tmp_node->key )
{ tmp_node = tmp_node->left; }
else
{ tmp_node = tmp_node->right; }
}
if ( tmp_node->key == query_key )
{ return ( (object_t*) tmp_node->left ); }
else
{ return ( NULL ); }
}
}
#define ALPHA 0.288
#define EPSILON 0.005
int
insert(tree_node_t* tree, key_t new_key, object_t* new_object)
{
tree_node_t* tmp_node;
if ( tree->left == NULL ) {
tree->left = (tree_node_t*) new_object;
tree->key = new_key;
tree->weight = 1;
tree->right = NULL;
} else {
tree_node_t* path_stack[100];
int path_st_p = 0;
tmp_node = tree;
while ( tmp_node->right != NULL ) {
path_stack[path_st_p++] = tmp_node;
if ( new_key < tmp_node->key )
{ tmp_node = tmp_node->left; }
else
{ tmp_node = tmp_node->right; }
}
/* found the candidate leaf. Test whether key distinct */
if ( tmp_node->key == new_key )
{ return ( -1 ); }
/* key is distinct, now perform the insert */
{
tree_node_t* old_leaf, *new_leaf;
old_leaf = get_node();
old_leaf->left = tmp_node->left;
old_leaf->key = tmp_node->key;
old_leaf->right = NULL;
old_leaf->weight = 1;
new_leaf = get_node();
new_leaf->left = (tree_node_t*) new_object;
new_leaf->key = new_key;
new_leaf->right = NULL;
new_leaf->weight = 1;
if ( tmp_node->key < new_key ) {
tmp_node->left = old_leaf;
tmp_node->right = new_leaf;
tmp_node->key = new_key;
} else {
tmp_node->left = new_leaf;
tmp_node->right = old_leaf;
}
tmp_node->weight = 2;
}
/* rebalance */
while ( path_st_p > 0 ) {
tmp_node = path_stack[--path_st_p];
tmp_node->weight = tmp_node->left->weight + tmp_node->right->weight;
if ( tmp_node->right->weight < ALPHA * tmp_node->weight ) {
if ( tmp_node->left->left->weight > (ALPHA + EPSILON)*tmp_node->weight ) {
right_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
} else {
left_rotation( tmp_node->left );
right_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
}
} else if ( tmp_node->left->weight
< ALPHA * tmp_node->weight ) {
if ( tmp_node->right->right->weight
> (ALPHA + EPSILON)*tmp_node->weight ) {
left_rotation( tmp_node );
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
} else {
right_rotation( tmp_node->right );
left_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
}
}
}
}
return ( 0 );
}
object_t*
delete (tree_node_t* tree, key_t delete_key)
{
tree_node_t* tmp_node, *upper_node, *other_node;
object_t* deleted_object;
if ( tree->left == NULL )
{ return ( NULL ); }
else if ( tree->right == NULL ) {
if ( tree->key == delete_key ) {
deleted_object = (object_t*) tree->left;
tree->left = NULL;
return ( deleted_object );
} else {
return ( NULL );
}
} else {
tree_node_t* path_stack[100];
int path_st_p = 0;
tmp_node = tree;
while ( tmp_node->right != NULL ) {
path_stack[path_st_p++] = tmp_node;
upper_node = tmp_node;
if ( delete_key < tmp_node->key ) {
tmp_node = upper_node->left;
other_node = upper_node->right;
} else {
tmp_node = upper_node->right;
other_node = upper_node->left;
}
}
if ( tmp_node->key != delete_key )
{ deleted_object = NULL; }
else {
upper_node->key = other_node->key;
upper_node->left = other_node->left;
upper_node->right = other_node->right;
upper_node->weight = other_node->weight;
deleted_object = (object_t*) tmp_node->left;
return_node( tmp_node );
return_node( other_node );
}
/*start rebalance*/
path_st_p -= 1;
while ( path_st_p > 0 ) {
tmp_node = path_stack[--path_st_p];
tmp_node->weight = tmp_node->left->weight
+ tmp_node->right->weight;
if ( tmp_node->right->weight
< ALPHA * tmp_node->weight ) {
if ( tmp_node->left->left->weight
> (ALPHA + EPSILON)*tmp_node->weight ) {
right_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
} else {
left_rotation( tmp_node->left );
right_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
}
} else if ( tmp_node->left->weight
< ALPHA * tmp_node->weight ) {
if ( tmp_node->right->right->weight
> (ALPHA + EPSILON)*tmp_node->weight ) {
left_rotation( tmp_node );
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
} else {
right_rotation( tmp_node->right );
left_rotation( tmp_node );
tmp_node->right->weight =
tmp_node->right->left->weight
+ tmp_node->right->right->weight;
tmp_node->left->weight =
tmp_node->left->left->weight
+ tmp_node->left->right->weight;
}
}
}
/*end rebalance*/
return ( deleted_object );
}
}
void
check_tree(tree_node_t* tr, int depth, int lower, int upper)
{
if ( tr->left == NULL )
{ printf("Tree Empty\n"); return; }
if ( tr->key < lower || tr->key >= upper )
{ printf("Wrong Key Order \n"); }
if ( tr->right == NULL ) {
if ( *( (int*) tr->left) == 10 * tr->key + 2 )
{ printf("%d(%d) ", tr->key, depth ); }
else
{ printf("Wrong Object \n"); }
} else {
check_tree(tr->left, depth + 1, lower, tr->key );
check_tree(tr->right, depth + 1, tr->key, upper );
}
}
// _____________________________________________________________________________
// Sample test
int
main()
{
tree_node_t* searchtree;
char nextop;
searchtree = create_tree();
printf("Made Tree: Weight-Balanced Tree\n");
while ( (nextop = getchar()) != 'q' ) {
if ( nextop == 'i' ) {
int inskey, *insobj, success;
insobj = (int*) malloc(sizeof(int));
scanf(" %d", &inskey);
*insobj = 10 * inskey + 2;
success = insert( searchtree, inskey, insobj );
if ( success == 0 )
printf(" insert successful, key = %d, object value = %d, \
weight is %d\n",
inskey, *insobj, searchtree->weight );
else
{ printf(" insert failed, success = %d\n", success); }
}
if ( nextop == 'f' ) {
int findkey, *findobj;
scanf(" %d", &findkey);
findobj = find( searchtree, findkey);
if ( findobj == NULL )
{ printf(" find failed, for key %d\n", findkey); }
else
{ printf(" find successful, found object %d\n", *findobj); }
}
if ( nextop == 'd' ) {
int delkey, *delobj;
scanf(" %d", &delkey);
delobj = delete ( searchtree, delkey);
if ( delobj == NULL )
{ printf(" delete failed for key %d\n", delkey); }
else
printf(" delete successful, deleted object %d, weight is now %d\n",
*delobj, searchtree->weight);
}
if ( nextop == '?' ) {
printf(" Checking tree\n");
check_tree(searchtree, 0, -1000, 1000);
printf("\n");
if ( searchtree->left != NULL )
printf("key in root is %d, weight of tree is %d\n",
searchtree->key, searchtree->weight );
printf(" Finished Checking tree\n");
}
}
return (0);
}
|
the_stack_data/175142922.c
|
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("Hello,world!\n");
system("pause");
return 0;
}
|
the_stack_data/173577478.c
|
/* Fig. 14.3: fig14_03.c
Using command-line arguments */
#include <stdio.h>
int main( int argc, char *argv[] )
{
FILE *inFilePtr; /* input file pointer */
FILE *outFilePtr; /* output file pointer */
int c; /* define c to hold characters input by user */
/* check number of command-line arguments */
if ( argc != 3 ) {
printf( "Usage: mycopy infile outfile\n" );
} /* end if */
else {
/* if input file can be opened */
if ( ( inFilePtr = fopen( argv[ 1 ], "r" ) ) != NULL ) {
/* if output file can be opened */
if ( ( outFilePtr = fopen( argv[ 2 ], "w" ) ) != NULL ) {
/* read and output characters */
while ( ( c = fgetc( inFilePtr ) ) != EOF ) {
fputc( c, outFilePtr );
} /* end while */
} /* end if */
else { /* output file could not be opened */
printf( "File \"%s\" could not be opened\n", argv[ 2 ] );
} /* end else */
} /* end if */
else { /* input file could not be opened */
printf( "File \"%s\" could not be opened\n", argv[ 1 ] );
} /* end else */
} /* end else */
return 0; /* indicates successful termination */
} /* end main */
/**************************************************************************
* (C) Copyright 1992-2010 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
*************************************************************************/
|
the_stack_data/27223.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <time.h>
// listen 소켓 생성 및 listen
int tcp_listen(int host, int port, int backlog) {
int sd;
struct sockaddr_in servaddr;
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd == -1) {
perror("socket fail");
exit(1);
}
// servaddr 구조체의 내용 세팅
bzero((char *)&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(host);
servaddr.sin_port = htons(port);
if (bind(sd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind fail"); exit(1);
}
// 클라이언트로부터 연결요청을 기다림
listen(sd, backlog);
return sd;
}
|
the_stack_data/212643642.c
|
#include <assert.h>
static void run(unsigned __int128 x)
{
unsigned __int128 y = x;
for (int shift = 0; shift < 128; ++shift) {
assert(x << shift == y);
y <<= 1;
}
}
int main(void)
{
for (unsigned __int128 x = 1; x; x *= 2)
run(x);
for (unsigned __int128 x = 1; x >> 104 != 0x313370; x *= 3)
run(x);
}
|
the_stack_data/278771.c
|
// REQUIRES: arm-registered-target
// RUN: %clang_cc1 -triple armv7-apple-darwin9 -target-feature +neon -target-abi apcs-gnu -emit-llvm -w -o - %s | FileCheck -check-prefix=APCS-GNU %s
// RUN: %clang_cc1 -triple armv7-apple-darwin9 -target-feature +neon -target-abi aapcs -emit-llvm -w -o - %s | FileCheck -check-prefix=AAPCS %s
// APCS-GNU-LABEL: define signext i8 @f0()
// AAPCS-LABEL: define arm_aapcscc signext i8 @f0()
char f0(void) {
return 0;
}
// APCS-GNU-LABEL: define i8 @f1()
// AAPCS-LABEL: define arm_aapcscc i8 @f1()
struct s1 { char f0; };
struct s1 f1(void) {}
// APCS-GNU-LABEL: define i16 @f2()
// AAPCS-LABEL: define arm_aapcscc i16 @f2()
struct s2 { short f0; };
struct s2 f2(void) {}
// APCS-GNU-LABEL: define i32 @f3()
// AAPCS-LABEL: define arm_aapcscc i32 @f3()
struct s3 { int f0; };
struct s3 f3(void) {}
// APCS-GNU-LABEL: define i32 @f4()
// AAPCS-LABEL: define arm_aapcscc i32 @f4()
struct s4 { struct s4_0 { int f0; } f0; };
struct s4 f4(void) {}
// APCS-GNU-LABEL: define void @f5(
// APCS-GNU: struct.s5* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f5()
struct s5 { struct { } f0; int f1; };
struct s5 f5(void) {}
// APCS-GNU-LABEL: define void @f6(
// APCS-GNU: struct.s6* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f6()
struct s6 { int f0[1]; };
struct s6 f6(void) {}
// APCS-GNU-LABEL: define void @f7()
// AAPCS-LABEL: define arm_aapcscc void @f7()
struct s7 { struct { int : 0; } f0; };
struct s7 f7(void) {}
// APCS-GNU-LABEL: define void @f8(
// APCS-GNU: struct.s8* noalias sret
// AAPCS-LABEL: define arm_aapcscc void @f8()
struct s8 { struct { int : 0; } f0[1]; };
struct s8 f8(void) {}
// APCS-GNU-LABEL: define i32 @f9()
// AAPCS-LABEL: define arm_aapcscc i32 @f9()
struct s9 { int f0; int : 0; };
struct s9 f9(void) {}
// APCS-GNU-LABEL: define i32 @f10()
// AAPCS-LABEL: define arm_aapcscc i32 @f10()
struct s10 { int f0; int : 0; int : 0; };
struct s10 f10(void) {}
// APCS-GNU-LABEL: define void @f11(
// APCS-GNU: struct.s11* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f11()
struct s11 { int : 0; int f0; };
struct s11 f11(void) {}
// APCS-GNU-LABEL: define i32 @f12()
// AAPCS-LABEL: define arm_aapcscc i32 @f12()
union u12 { char f0; short f1; int f2; };
union u12 f12(void) {}
// APCS-GNU-LABEL: define void @f13(
// APCS-GNU: struct.s13* noalias sret
// FIXME: This should return a float.
// AAPCS-FIXME: darm_aapcscc efine float @f13()
struct s13 { float f0; };
struct s13 f13(void) {}
// APCS-GNU-LABEL: define void @f14(
// APCS-GNU: union.u14* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f14()
union u14 { float f0; };
union u14 f14(void) {}
// APCS-GNU-LABEL: define void @f15()
// AAPCS-LABEL: define arm_aapcscc void @f15()
void f15(struct s7 a0) {}
// APCS-GNU-LABEL: define void @f16()
// AAPCS-LABEL: define arm_aapcscc void @f16()
void f16(struct s8 a0) {}
// APCS-GNU-LABEL: define i32 @f17()
// AAPCS-LABEL: define arm_aapcscc i32 @f17()
struct s17 { short f0 : 13; char f1 : 4; };
struct s17 f17(void) {}
// APCS-GNU-LABEL: define i32 @f18()
// AAPCS-LABEL: define arm_aapcscc i32 @f18()
struct s18 { short f0; char f1 : 4; };
struct s18 f18(void) {}
// APCS-GNU-LABEL: define void @f19(
// APCS-GNU: struct.s19* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f19()
struct s19 { int f0; struct s8 f1; };
struct s19 f19(void) {}
// APCS-GNU-LABEL: define void @f20(
// APCS-GNU: struct.s20* noalias sret
// AAPCS-LABEL: define arm_aapcscc i32 @f20()
struct s20 { struct s8 f1; int f0; };
struct s20 f20(void) {}
// APCS-GNU-LABEL: define i8 @f21()
// AAPCS-LABEL: define arm_aapcscc i32 @f21()
struct s21 { struct {} f1; int f0 : 4; };
struct s21 f21(void) {}
// APCS-GNU-LABEL: define i16 @f22()
// APCS-GNU-LABEL: define i32 @f23()
// APCS-GNU-LABEL: define i64 @f24()
// APCS-GNU-LABEL: define i128 @f25()
// APCS-GNU-LABEL: define i64 @f26()
// APCS-GNU-LABEL: define i128 @f27()
// AAPCS-LABEL: define arm_aapcscc i16 @f22()
// AAPCS-LABEL: define arm_aapcscc i32 @f23()
// AAPCS: define arm_aapcscc void @f24({{.*}} noalias sret
// AAPCS: define arm_aapcscc void @f25({{.*}} noalias sret
// AAPCS: define arm_aapcscc void @f26({{.*}} noalias sret
// AAPCS: define arm_aapcscc void @f27({{.*}} noalias sret
_Complex char f22(void) {}
_Complex short f23(void) {}
_Complex int f24(void) {}
_Complex long long f25(void) {}
_Complex float f26(void) {}
_Complex double f27(void) {}
// APCS-GNU-LABEL: define i16 @f28()
// AAPCS-LABEL: define arm_aapcscc i16 @f28()
struct s28 { _Complex char f0; };
struct s28 f28() {}
// APCS-GNU-LABEL: define i32 @f29()
// AAPCS-LABEL: define arm_aapcscc i32 @f29()
struct s29 { _Complex short f0; };
struct s29 f29() {}
// APCS-GNU: define void @f30({{.*}} noalias sret
// AAPCS: define arm_aapcscc void @f30({{.*}} noalias sret
struct s30 { _Complex int f0; };
struct s30 f30() {}
// PR11905
struct s31 { char x; };
void f31(struct s31 s) { }
// AAPCS: @f31([1 x i32] %s.coerce)
// AAPCS: %s = alloca %struct.s31, align 4
// AAPCS: alloca [1 x i32]
// AAPCS: store [1 x i32] %s.coerce, [1 x i32]*
// APCS-GNU: @f31([1 x i32] %s.coerce)
// APCS-GNU: %s = alloca %struct.s31, align 4
// APCS-GNU: alloca [1 x i32]
// APCS-GNU: store [1 x i32] %s.coerce, [1 x i32]*
// PR13562
struct s32 { double x; };
void f32(struct s32 s) { }
// AAPCS: @f32([1 x i64] %s.coerce)
// APCS-GNU: @f32([2 x i32] %s.coerce)
// PR13350
struct s33 { char buf[32*32]; };
void f33(struct s33 s) { }
// APCS-GNU-LABEL: define void @f33(%struct.s33* byval %s)
// AAPCS-LABEL: define arm_aapcscc void @f33(%struct.s33* byval %s)
// PR14048
struct s34 { char c; };
void f34(struct s34 s);
void g34(struct s34 *s) { f34(*s); }
// APCS-GNU: @g34(%struct.s34* %s)
// APCS-GNU: %[[a:.*]] = alloca { [1 x i32] }
// APCS-GNU: %[[gep:.*]] = getelementptr { [1 x i32] }* %[[a]], i32 0, i32 0
// APCS-GNU: load [1 x i32]* %[[gep]]
// AAPCS: @g34(%struct.s34* %s)
// AAPCS: %[[a:.*]] = alloca { [1 x i32] }
// AAPCS: %[[gep:.*]] = getelementptr { [1 x i32] }* %[[a]], i32 0, i32 0
// AAPCS: load [1 x i32]* %[[gep]]
// rdar://12596507
struct s35
{
float v[18]; //make sure byval is on.
} __attribute__((aligned(16)));
typedef struct s35 s35_with_align;
typedef __attribute__((neon_vector_type(4))) float float32x4_t;
static __attribute__((__always_inline__, __nodebug__)) float32x4_t vaddq_f32(
float32x4_t __a, float32x4_t __b) {
return __a + __b;
}
float32x4_t f35(int i, s35_with_align s1, s35_with_align s2) {
float32x4_t v = vaddq_f32(*(float32x4_t *)&s1,
*(float32x4_t *)&s2);
return v;
}
// APCS-GNU-LABEL: define <4 x float> @f35(i32 %i, %struct.s35* byval, %struct.s35* byval)
// APCS-GNU: %[[a:.*]] = alloca %struct.s35, align 16
// APCS-GNU: %[[b:.*]] = bitcast %struct.s35* %[[a]] to i8*
// APCS-GNU: %[[c:.*]] = bitcast %struct.s35* %0 to i8*
// APCS-GNU: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[b]], i8* %[[c]]
// APCS-GNU: %[[d:.*]] = bitcast %struct.s35* %[[a]] to <4 x float>*
// APCS-GNU: load <4 x float>* %[[d]], align 16
// AAPCS-LABEL: define arm_aapcscc <4 x float> @f35(i32 %i, %struct.s35* byval, %struct.s35* byval)
// AAPCS: %[[a:.*]] = alloca %struct.s35, align 16
// AAPCS: %[[b:.*]] = bitcast %struct.s35* %[[a]] to i8*
// AAPCS: %[[c:.*]] = bitcast %struct.s35* %0 to i8*
// AAPCS: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[b]], i8* %[[c]]
// AAPCS: %[[d:.*]] = bitcast %struct.s35* %[[a]] to <4 x float>*
// AAPCS: load <4 x float>* %[[d]], align 16
|
the_stack_data/150143645.c
|
#include<stdio.h>
int main(void) {
char c;
int i;
float f;
printf("%c %d %f\n", c, i, f);
return 0;
}
|
the_stack_data/131556.c
|
//26.Find the output of the following program
#include<stdio.h>
int main()
{
int i;
while(1)
printf("Hello\n");
return 0;
}
//O/P
// Infinite times hello
|
the_stack_data/116210.c
|
/*
* msvcrt C++ exception handling
*
* Copyright 2011 Alexandre Julliard
* Copyright 2013 André Hentschel
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifdef __arm__
#include <stdarg.h>
#include <fpieee.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "msvcrt.h"
#include "wine/exception.h"
#include "excpt.h"
#include "wine/debug.h"
#include "cppexcept.h"
WINE_DEFAULT_DEBUG_CHANNEL(seh);
/*********************************************************************
* __CxxExceptionFilter (MSVCRT.@)
*/
int CDECL __CxxExceptionFilter( PEXCEPTION_POINTERS ptrs,
const type_info *ti, int flags, void **copy )
{
FIXME( "%p %p %x %p: not implemented\n", ptrs, ti, flags, copy );
return EXCEPTION_CONTINUE_SEARCH;
}
/*********************************************************************
* __CxxFrameHandler (MSVCRT.@)
*/
EXCEPTION_DISPOSITION CDECL __CxxFrameHandler(EXCEPTION_RECORD *rec, DWORD frame, CONTEXT *context,
DISPATCHER_CONTEXT *dispatch)
{
FIXME("%p %x %p %p: not implemented\n", rec, frame, context, dispatch);
return ExceptionContinueSearch;
}
/*********************************************************************
* __CppXcptFilter (MSVCRT.@)
*/
int CDECL __CppXcptFilter(NTSTATUS ex, PEXCEPTION_POINTERS ptr)
{
/* only filter c++ exceptions */
if (ex != CXX_EXCEPTION) return EXCEPTION_CONTINUE_SEARCH;
return _XcptFilter(ex, ptr);
}
/*********************************************************************
* __CxxDetectRethrow (MSVCRT.@)
*/
BOOL CDECL __CxxDetectRethrow(PEXCEPTION_POINTERS ptrs)
{
PEXCEPTION_RECORD rec;
if (!ptrs)
return FALSE;
rec = ptrs->ExceptionRecord;
if (rec->ExceptionCode == CXX_EXCEPTION &&
rec->NumberParameters == 3 &&
rec->ExceptionInformation[0] == CXX_FRAME_MAGIC_VC6 &&
rec->ExceptionInformation[2])
{
ptrs->ExceptionRecord = msvcrt_get_thread_data()->exc_record;
return TRUE;
}
return (msvcrt_get_thread_data()->exc_record == rec);
}
/*********************************************************************
* __CxxQueryExceptionSize (MSVCRT.@)
*/
unsigned int CDECL __CxxQueryExceptionSize(void)
{
return sizeof(cxx_exception_type);
}
/*******************************************************************
* _setjmp (MSVCRT.@)
*/
__ASM_GLOBAL_FUNC(MSVCRT__setjmp,
"mov r1, #0\n\t" /* frame */
"b " __ASM_NAME("__wine_setjmpex"));
/*******************************************************************
* longjmp (MSVCRT.@)
*/
void __cdecl MSVCRT_longjmp(struct MSVCRT___JUMP_BUFFER *jmp, int retval)
{
EXCEPTION_RECORD rec;
if (!retval) retval = 1;
if (jmp->Frame)
{
rec.ExceptionCode = STATUS_LONGJUMP;
rec.ExceptionFlags = 0;
rec.ExceptionRecord = NULL;
rec.ExceptionAddress = NULL;
rec.NumberParameters = 1;
rec.ExceptionInformation[0] = (DWORD_PTR)jmp;
RtlUnwind((void *)jmp->Frame, (void *)jmp->Pc, &rec, IntToPtr(retval));
}
__wine_longjmp( (__wine_jmp_buf *)jmp, retval );
}
/*********************************************************************
* _fpieee_flt (MSVCRT.@)
*/
int __cdecl _fpieee_flt(__msvcrt_ulong exception_code, EXCEPTION_POINTERS *ep,
int (__cdecl *handler)(_FPIEEE_RECORD*))
{
FIXME("(%lx %p %p)\n", exception_code, ep, handler);
return EXCEPTION_CONTINUE_SEARCH;
}
#endif /* __arm__ */
|
the_stack_data/23574765.c
|
typedef unsigned char byte;
byte table0[32] =
{
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,3,6,1,4,7,2,5
};
byte table1[256] =
{
0xDA,0x26,0xE8,0x72,0x11,0x52,0x3E,0x46,
0x32,0xFF,0x8C,0x1E,0xA7,0xBE,0x2C,0x29,
0x5F,0x86,0x7E,0x75,0x0A,0x08,0xA5,0x21,
0x61,0xFB,0x7A,0x58,0x60,0xF7,0x81,0x4F,
0xE4,0xFC,0xDF,0xB1,0xBB,0x6A,0x02,0xB3,
0x0B,0x6E,0x5D,0x5C,0xD5,0xCF,0xCA,0x2A,
0x14,0xB7,0x90,0xF3,0xD9,0x37,0x3A,0x59,
0x44,0x69,0xC9,0x78,0x30,0x16,0x39,0x9A,
0x0D,0x05,0x1F,0x8B,0x5E,0xEE,0x1B,0xC4,
0x76,0x43,0xBD,0xEB,0x42,0xEF,0xF9,0xD0,
0x4D,0xE3,0xF4,0x57,0x56,0xA3,0x0F,0xA6,
0x50,0xFD,0xDE,0xD2,0x80,0x4C,0xD3,0xCB,
0xF8,0x49,0x8F,0x22,0x71,0x84,0x33,0xE0,
0x47,0xC2,0x93,0xBC,0x7C,0x3B,0x9C,0x7D,
0xEC,0xC3,0xF1,0x89,0xCE,0x98,0xA2,0xE1,
0xC1,0xF2,0x27,0x12,0x01,0xEA,0xE5,0x9B,
0x25,0x87,0x96,0x7B,0x34,0x45,0xAD,0xD1,
0xB5,0xDB,0x83,0x55,0xB0,0x9E,0x19,0xD7,
0x17,0xC6,0x35,0xD8,0xF0,0xAE,0xD4,0x2B,
0x1D,0xA0,0x99,0x8A,0x15,0x00,0xAF,0x2D,
0x09,0xA8,0xF5,0x6C,0xA1,0x63,0x67,0x51,
0x3C,0xB2,0xC0,0xED,0x94,0x03,0x6F,0xBA,
0x3F,0x4E,0x62,0x92,0x85,0xDD,0xAB,0xFE,
0x10,0x2E,0x68,0x65,0xE7,0x04,0xF6,0x0C,
0x20,0x1C,0xA9,0x53,0x40,0x77,0x2F,0xA4,
0xFA,0x6D,0x73,0x28,0xE2,0xCD,0x79,0xC8,
0x97,0x66,0x8E,0x82,0x74,0x06,0xC7,0x88,
0x1A,0x4A,0x6B,0xCC,0x41,0xE9,0x9D,0xB8,
0x23,0x9F,0x3D,0xBF,0x8D,0x95,0xC5,0x13,
0xB9,0x24,0x5A,0xDC,0x64,0x18,0x38,0x91,
0x7F,0x5B,0x70,0x54,0x07,0xB6,0x4B,0x0E,
0x36,0xAC,0x31,0xE6,0xD6,0x48,0xAA,0xB4
};
byte table2[256] =
{
0x8E,0xD5,0x32,0x53,0x4B,0x18,0x7F,0x95,
0xBE,0x30,0xF3,0xE0,0x22,0xE1,0x68,0x90,
0x82,0xC8,0xA8,0x57,0x21,0xC5,0x38,0x73,
0x61,0x5D,0x5A,0xD6,0x60,0xB7,0x48,0x70,
0x2B,0x7A,0x1D,0xD1,0xB1,0xEC,0x7C,0xAA,
0x2F,0x1F,0x37,0x58,0x72,0x88,0xFF,0x87,
0x1C,0xCB,0x00,0xE6,0x4E,0xAB,0xEB,0xB3,
0xF7,0x59,0x71,0x6A,0x64,0x2A,0x55,0x4D,
0xFC,0xC0,0x51,0x01,0x2D,0xC4,0x54,0xE2,
0x9F,0x26,0x16,0x27,0xF2,0x9C,0x86,0x11,
0x05,0x29,0xA2,0x78,0x49,0xB2,0xA6,0xCA,
0x96,0xE5,0x33,0x3F,0x46,0xBA,0xD0,0xBB,
0x5F,0x84,0x98,0xE4,0xF9,0x0A,0x62,0xEE,
0xF6,0xCF,0x94,0xF0,0xEA,0x1E,0xBF,0x07,
0x9B,0xD9,0xE9,0x74,0xC6,0xA4,0xB9,0x56,
0x3E,0xDB,0xC7,0x15,0xE3,0x80,0xD7,0xED,
0xEF,0x13,0xAC,0xA1,0x91,0xC2,0x89,0x5B,
0x08,0x0B,0x4C,0x02,0x3A,0x5C,0xA9,0x3B,
0xCE,0x6B,0xA7,0xE7,0xCD,0x7B,0xA0,0x47,
0x09,0x6D,0xF8,0xF1,0x8B,0xB0,0x12,0x42,
0x4A,0x9A,0x17,0xB4,0x7E,0xAD,0xFE,0xFD,
0x2C,0xD3,0xF4,0xB6,0xA3,0xFA,0xDF,0xB8,
0xD4,0xDA,0x0F,0x50,0x93,0x66,0x6C,0x20,
0xD8,0x8A,0xDD,0x31,0x1A,0x8C,0x06,0xD2,
0x44,0xE8,0x23,0x43,0x6E,0x10,0x69,0x36,
0xBC,0x19,0x8D,0x24,0x81,0x14,0x40,0xC9,
0x6F,0x2E,0x45,0x52,0x41,0x92,0x34,0xFB,
0x5E,0x0D,0xF5,0x76,0x25,0x77,0x63,0x65,
0xAF,0x4F,0xCC,0x03,0x9D,0x0C,0x28,0x39,
0x85,0xDE,0xB5,0x7D,0x67,0x83,0xBD,0xC3,
0xDC,0x3C,0xAE,0x99,0x04,0x75,0x8F,0x97,
0xC1,0xA5,0x9E,0x35,0x0E,0x3D,0x1B,0x79
};
static void rotate(byte *p)
{
byte temp,i;
temp = p[9];
for (i=9; i>0; i--)
p[i] = (p[i] >> 1) | (p[i-1] << 7);
p[0] = (p[0] >> 1) | (temp << 7);
}
static void decrypt(byte *data,byte *key,int rounds,int offset)
{
int count,index;
byte d,k;
for (count=0; count<rounds; count++)
{
index = count % 10;
if (index == 0)
rotate(key);
k = key[index];
d = data[table0[(count & 0x0f) + offset]] ^ k;
if (k & 1)
d = table1[d];
else
d = table2[d];
data[table0[((count+1) & 0x0f) + offset]] ^= d;
}
}
void sessionKeyCrypt(unsigned char *data,unsigned char *key,int date)
{
byte temp[10];
memcpy(temp,key,8);
temp[8] = (byte)(date >> 8) ^ key[0];
temp[9] = (byte)date ^ key[1];
decrypt(data,temp,128,16);
}
int signatureCheck(unsigned char *data,int length,unsigned char *key,int date,unsigned char *signature)
{
byte buffer[256];
byte temp[10];
int rounds;
int i,j;
memcpy(buffer,data,length);
if ((length % 8) == 0)
rounds = 40;
else
{
i = 0x61;
while ((length % 8) != 0)
buffer[length++] = i++;
rounds = 104;
}
memcpy(temp,key,8);
temp[8] = (byte)(date >> 8) ^ key[0];
temp[9] = (byte)date ^ key[1];
i = 0;
while (i<length-8)
{
decrypt(buffer,temp,40,0);
i+= 8;
for (j=0; j<8; j++)
buffer[j] ^= buffer[i+j];
rotate(temp);
}
decrypt(buffer,temp,rounds,0);
return memcmp(buffer,signature,5)==0;
}
|
the_stack_data/7949792.c
|
//Willis A. Hershey
//[email protected]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* "Sudoku" is a number puzzle with a 9x9 grid of "cells". Each "cell" must hold one number between 1 and 9 inclusive.
*
* For the sake of a reader understanding the comments in this program, the "board" refers to the playing field of the standard 0 1 2 | 3 4 5 | 6 7 8
* Sudoku game with 81 cells. The "rows" are the nine horizontal linear subsections of the "board", the "columns" are the nine 9 10 11 |12 13 14 |15 16 17
* vertical linear subsections of the "board", and the "blocks" are the nine 3x3 square subsections of the "board". Each of the 18 19 20 |21 22 23 |24 25 26
* "rows", "columns", and "blocks" contains exactly nine cells, and each cell in the board is within exactly one "row", "column" ----------------------------------
* and "block". If I've lost you you should perhaps do some reading on Sudoku puzzles before continuing. 27 28 29 |30 31 32 |33 34 35
* 36 37 38 |39 40 41 |42 43 44
* This program models the board as an array of 81 short ints, with indices from 0-80. Rows begin at indices 0,9,18,27,36,45,54, 45 46 47 |48 49 50 |51 52 53
* 63, and 72. Columns begin at indices 0,1,2,3,4,5,6,7, and 8. Blocks begin at indices 0,3,6,27,30,33,54,57, and 60. ----------------------------------
* 54 55 56 |57 58 59 |60 61 62
* In accordace with the rules of Sudoku, each row, column and block of the board must contain each of the numbers from 1-9, and 63 64 65 |66 67 68 |69 70 71
* since each of these subsections contains only 9 cells, there can be no duplicates of any number in any row, column, or block. 72 73 74 |75 76 77 |78 79 80
*
* This program takes a list of 81 integers as a representation of a puzzle board, finds a solution, and prints it out.
*/
/* This program models the numbers 1-9 that could occupy some cell of the Sudoku puzzle as the first through ninth bits of a short int.
* Modeling them this ways allows these numbers to be bitwise-ored together to produce values representing multiple numbers at once
* The use of short ints potentially saves memory, as short is the smallest int type guaranteed to be at least ten bits wide
*/
//Values defined recursively in bitshift-notation to avoid typos
#define ONE 0x1
#define TWO (ONE<<1)
#define THREE (TWO<<1)
#define FOUR (THREE<<1)
#define FIVE (FOUR<<1)
#define SIX (FIVE<<1)
#define SEVEN (SIX<<1)
#define EIGHT (SEVEN<<1)
#define NINE (EIGHT<<1)
//The definition of SET as the tenth bit saves computational time for set() defined below
#define SET (NINE<<1)
//This tells the calling function if the parameter's short is set to a single value. If it is, but the set bit is unset, it ors it in.
static inline _Bool set(short *i){
short in=*i;
if(in&SET)
return 1;
_Bool found=0;
for(short bit=ONE;bit<=NINE;bit<<=1)
if(in&bit){
if(found)
return 0;
else
found=1;
}
if(found)
*i|=SET;
return found;
}
//Converts from bit-representation of number to standard binary integer
static inline int translate(short in){
in=in&~SET;
if(in==ONE)
return 1;
else if(in==TWO)
return 2;
else if(in==THREE)
return 3;
else if(in==FOUR)
return 4;
else if(in==FIVE)
return 5;
else if(in==SIX)
return 6;
else if(in==SEVEN)
return 7;
else if(in==EIGHT)
return 8;
else if(in==NINE)
return 9;
else
return 0;
}
//This function attempts to set cells to their numbers by checking if there exists a number this cell could hold that no other
//cell in its row, column ,or block could hold. If this function succeeds in setting the cell, it retuns 1, otherwise, 0.
_Bool analyzePossibilities(short board[],int index){
short val=board[index]; //This value is the current value of what I will call the focus cell. It has a 1 in the corresponding position of every value that could legally be stored there
for(short bit=ONE;bit<=NINE;bit<<=1){ //For each possible value, focus value, from ONE to NINE
if(!(val&bit)) //If the focus cell doesn't have a 1 in that bit position skip it
continue;
_Bool found=0;
for(int c=0,run=index-index%9;c<9;++c,++run){ //For each cell in the focus cell's row
if(run==index||set(&board[run])) //Skip over the focus cell and any other cell that is already set
continue;
if(board[run]&bit){ //If some other cell has a 1 in focus value's position then we can't set the focus cell's position on account of it's row
found=1;
break;
}
}
if(!found){ //If no other cell in focus cell's row can hold some focus value then set focus cell to that value ored with SET and return 1
board[index]=bit|SET;
return 1;
}
else //Otherwise try again with focus cell's column
found=0;
for(int c=0,run=index%9;c<9;++c,run+=9){
if(run==index||set(&board[run]))
continue;
if(board[run]&bit){
found=1;
break;
} //... same algorithm as before
}
if(!found){
board[index]=bit|SET;
return 1;
}
else
found=0; //Otherwise try again with focus cell's block
for(int c=0,run=index-index%27+index%9-index%3;c<9;++c,run+=run%3==2?7:1){ //Blocks are hard to iterate through so this loop is super confusing. Let me explain:
if(run==index||set(&board[run])) //For any index on the board from 0-80, index-index%27 is 0, 26, or 54, which represents a block
continue; //in the top row, middle row, or bottom row, respectively. adding to that index%9-index%3 pushes
if(board[run]&bit){ //us forward 0, 3, or 6 cells for left, center and right. This puts us in the top left corner of
found=1; //whatever block the focus cell is in. Each iteration we add 1 to index unless our index%3 is 2,
break; //because in that case we've reached the right edge of the block, so we must add 7 to wrap around
} //... same algorithm once again //to the left edge of the next row.
}
if(!found){
board[index]=bit|SET;
return 1;
}
}
return 0; //If we cannot set focus cell's value on account of the cells in its row column or block we return zero
}
//This function sets the bits of a short to represent all of the numbers not currently present in some cell's row, column, or block
//Returns 1 if that cell can only hold one value, so that cell is now set
//Returns -1 if that cell in ineligable to hold any number, so we've encountered a contradiction, and need to revert with the logstack
//And returns 0 otherwise, to indicate that the cell's bits are properly set
//
//For instance if some cell has a 4,5,7,8 and 9 somewhere in its row/column/block, but not 1,2,3 and 6, this function will store the value
//ONE|TWO|THREE|SIX or 0x27 in that cell, and return zero
//
//If some cell has a 1,2,3,5,6,7,8, and 9 somewhere in its row/column/block, but not 4, this function will store the value FOUR|SET or 0x208 in
//that cell, and return one
//
//Lastly if some cell has all 1,2,3,4,5,6,7,8 and 9 in its row/column/block, this function will store the value 0x0 in the cell and return -1
int setPossibilities(short board[],int index){
//We begin with the value 0x1FF, which represents a cell that could hold any value and is not set
short val=ONE|TWO|THREE|FOUR|FIVE|SIX|SEVEN|EIGHT|NINE;
//For each other cell in the row that is set, we remove that bit from the value
for(int c=0,run=index-index%9;c<9;++c,++run){
if(run==index)
continue;
if(set(&board[run]))
val&=~board[run];
}
//For each other cell in the column that is set we remove that bit from the value
for(int c=0,run=index%9;c<9;++c,run+=9){
if(run==index)
continue;
if(set(&board[run]))
val&=~board[run];
}
//For each other cell in the block that is set we remove that bit from the value
for(int c=0,run=index-index%27+index%9-index%3;c<9;++c,run+=run%3==2?7:1){
if(run==index)
continue;
if(set(&board[run]))
val&=~board[run];
}
//What remains is the bitwise or of the values not present, which we store in the cell
board[index]=val;
//Returning 1 if it's one possible value, -1 if there are no possible values, and 0 if we have more than one
if(!val)
return -1; //-1 indicates that this puzzle has a contradiction and needs to be reverted
else if(set(&val)) //set() will or in SET for us
return 1; //1 indicates that control should start the loop over and call this function on every value again because circumstances have changed
else
return 0; //0 indicates that control can continue as it was
}
//Prints the current puzzle board, printing unset cells as dashes
void printBoard(short board[]){
int t = translate(board[0]);
if(t)
printf("%d",t);
else
printf("-");
for(int c=1;c<81;++c){
t = translate(board[c]);
if(!(c%9)){
if(t)
printf("\n%d",t);
else
printf("\n-");
}
else{
if(t)
printf(",%d",t);
else
printf(",-");
}
}
printf("\n\n");
}
//Verifies that each row column and block of the puzzle contains no more than one of each number
_Bool verify(short board[]){
for(int c=0;c<9;++c){
char count[9]={0,0,0,0,0,0,0,0,0};
for(int d=0;d<9;++d)
if(set(&board[c*9+d]))
++count[translate(board[c*9+d])-1];
for(int d=0;d<9;++d)
if(count[d]>1)
return 0;
}
for(int c=0;c<9;++c){
char count[9]={0,0,0,0,0,0,0,0,0};
for(int d=0;d<9;++d)
if(set(&board[c+d*9]))
++count[translate(board[c+d*9])-1];
for(int d=0;d<9;++d)
if(count[d]>1)
return 0;
}
for(int c=0;c<9;++c){
char count[9]={0,0,0,0,0,0,0,0,0};
for(int d=0;d<9;++d)
if(set(&board[(c/3)*27+(c%3)*3+(d/3)*9+(d%3)]))
++count[translate(board[(c/3)*27+(c%3)*3+(d/3)*9+(d%3)])-1];
for(int d=0;d<9;++d)
if(count[c]>1)
return 0;
}
return 1;
}
//This data structure allows the puzzle board to be reverted when a contradiction is encountered from a bad guess
//The next pointer allows them to form a stack
typedef struct logStruct{
int index;
short val;
short old[81];
struct logStruct *next;
}log;
//This function is called when a contradiction is encountered. It works by attempting to change the guessed cell to the next number that it can hold
//If all numbers cause a contradiction in that cell, then that logfile is abandoned and an older one is used
//This function will call exit with an error status if it runs out of logfiles before it produces a new puzzle to be processed
//Returns the current value of the loghead
log* revert(short board[],log *head){
while(head){
memcpy(board,head->old,81*sizeof(short));
for(short bit=head->val<<1;bit<=NINE;bit<<=1)
if(board[head->index]&bit){
board[head->index]=bit|SET;
head->val=bit;
return head;
}
log *hold=head->next;
free(head);
head=hold;
}
fprintf(stderr,"This puzzle has no solutions\n");
exit(EXIT_FAILURE);
}
//This function sets the bits of every unset cell in the board, making sure to start over if some cell is set in the process
//It also reverts the board and starts over if it encounters a contradiction
//Returns the current value of the loghead
log* setAllPossibilities(short board[],log *head){
for(int c=0;c<81;++c)
if(!set(&board[c])){
int ret=setPossibilities(board,c);
if(ret){
c=-1;
if(ret==-1)
head=revert(board,head);
}
}
return head;
}
//This loop sets the bits of every cell, then checks them against each other in an attempt to set them
//When these functions have done all they can do, it checks to see if there are any unset cells
//If there are, it produces a logfile for the top of the logstack, picks a number for the unset cell, and starts over
//Once all cells are set it frees the logstack and returns
void solve(short board[]){
_Bool solved=0;
log *head=NULL;
while(!solved){
//We begin by setting all unset cells to their bitwise ors of possibilities
head=setAllPossibilities(board,head);
for(int c=0;c<81;++c)
//Then for each unset cell in the board, we try to set it using analyzePossibilities()
if(!set(&board[c]))
if(analyzePossibilities(board,c)){
//If it succeeds, we reset the bitwise ors for the whole board, and start over
head=setAllPossibilities(board,head);
c=-1;
}
//Eventually we reach a point where either the puzzle is solved, or we must guess to continue to make progress
solved=1;
for(int c=0;c<81;++c)
if(!set(&board[c])){
//If some cell is not set, the puzzle is not solved
solved=0;
int smallestParity=9;
int index=c;
int val=ONE;
for(;c<81;++c){ //This for loop chooses which cell to guess on by picking the cell with the fewest possibilities
if(set(&board[c]))
continue;
int parity=0;
int lowestBit=NINE;
for(short bit=NINE;bit!=0;bit>>=1)
if(board[c]&bit){
if(++parity>smallestParity)
break;
lowestBit=bit;
}
if(parity<smallestParity){
smallestParity=parity;
index=c;
val=lowestBit;
if(parity==2) //2 is the lowest possible parity of a cell that is not set
break;
}
}
log *hold=malloc(sizeof(log)); //Make a record of which cell was changed and to what and put it on the log stack
*hold=(log){.index=index,.val=val,.next=head};
memcpy(hold->old,board,81*sizeof(short));
board[index]=val|SET;
head=hold;
break;
}
}
//Control makes it here when the puzzle is solved
while(head){
//Free any logfiles if there are any
log *hold=head->next;
free(head);
head=hold;
}
}
//Main reads the user input, produces its representation of the puzzle, checks to see if it's valid, prints the input, solves the puzzle
//verifies the solution, prints the output, and terminates
int main(int args,char *argv[]){
if(args!=82){
fprintf(stderr,"USAGE: %s {1,-,2,9,-,-...}\n",argv[0]);
exit(EXIT_FAILURE);
}
short board[81];
for(int c=0;c<81;++c)
switch(argv[c+1][0]-'0'){
case 1:
board[c]=ONE|SET;
break;
case 2:
board[c]=TWO|SET;
break;
case 3:
board[c]=THREE|SET;
break;
case 4:
board[c]=FOUR|SET;
break;
case 5:
board[c]=FIVE|SET;
break;
case 6:
board[c]=SIX|SET;
break;
case 7:
board[c]=SEVEN|SET;
break;
case 8:
board[c]=EIGHT|SET;
break;
case 9:
board[c]=NINE|SET;
break;
default:
board[c]=0;
break;
}
if(!verify(board)){
fprintf(stderr,"Puzzle has a contradiction and cannot be solved\n");
exit(EXIT_FAILURE);
}
else
printf("Puzzle is verified and accepted\n\nINPUT:\n");
printBoard(board);
solve(board);
if(!verify(board)){
fprintf(stderr,"Something went wrong :/\n");
exit(EXIT_FAILURE);
}
printf("SOLUTION:\n");
printBoard(board);
}
|
the_stack_data/117198.c
|
// Copyright (c) 2020, devgo.club
// All rights reserved.
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
// int main(int argc, char const *argv[])
// {
// pid_t pid = fork();
// if (pid < 0)
// {
// fprintf(stderr, "fork failed: %s\n", strerror(errno));
// return errno;
// }
// else if (pid == 0)
// {
// // 子进程
// char *argv[] = {"cat", "/etc/hosts", NULL};
// char *envp[] = {"PATH = /bin", "SHELL = bash", NULL};
// sleep(10);
// int ret = execve("/bin/cat", argv, envp);
// printf("[C] ret = %d\n", ret);
// }
// else
// {
// // 父进程
// printf("[P] cpid = %d\n", pid);
// printf("[P] receive child process exit: cpid = %d\n", wait(NULL));
// }
// return EXIT_SUCCESS;
// }
// void exec_bash(char *cmd)
// {
// printf("[%d] exec_bash start: cmd = %s\n", getpid(), cmd);
// pid_t pid = fork();
// if (pid < 0)
// {
// fprintf(stderr, "fork failed: %s\n", strerror(errno));
// return;
// }
// else if (pid == 0)
// {
// // child process
// int ret = system(cmd);
// printf("[C: %d] system exit: ret = %d, cmd = %s\n", getpid(), ret, cmd);
// }
// else
// {
// // parent process
// pid = wait(NULL);
// printf("[P: %d] receive child exit signal: pid = %d\n", getpid(), pid);
// }
// printf("[%d] exec_bash finished!\n", getpid());
// return;
// }
// int main(int argc, char const *argv[])
// {
// exec_bash("cat /etc/hosts");
// printf("[%d] main finished!\n", getpid());
// return EXIT_SUCCESS;
// }
void exec_bash(char *cmd)
{
printf("[%d] exec_bash start: cmd = %s\n", getpid(), cmd);
pid_t pid = fork();
if (pid < 0)
{
fprintf(stderr, "fork failed: %s\n", strerror(errno));
return;
}
else if (pid == 0)
{
// child process
printf("[C: %d] cmd: %s\n", getpid(), cmd);
int ret = execl("/bin/bash", "bash", "-c", cmd, NULL);
printf("[C: %d] system exit: ret = %d, cmd = %s\n", getpid(), ret, cmd);
}
else
{
// parent process
pid = wait(NULL);
printf("[P: %d] receive child exit signal: pid = %d\n", getpid(), pid);
}
printf("[%d] exec_bash finished!\n", getpid());
return;
}
int main(int argc, char const *argv[])
{
exec_bash("cat /etc/hosts");
printf("[%d] main finished!\n", getpid());
return EXIT_SUCCESS;
}
|
the_stack_data/97012034.c
|
/*
* @explain: Copyright (c) 2020 WEI.ZHOU. All rights reserved.
* The following code is only used for learning and communication, not for
* illegal and commercial use. If the code is used, no consent is required, but
* the author has nothing to do with any problems and consequences.
*
* In case of code problems, feedback can be made through the following email
* address. <[email protected]>
*
* @Description:为一维数组a中的元素赋值，并按照逆序输出
* @Author: WEI.ZHOU
* @Date: 2020-11-14 08:56:42
* @Version: V1.0
*/
#include <stdio.h>
int main() {
/* 定义循环变量i和一维数组a */
int i, a[10];
for (i = 0; i <= 9; i++)
scanf("%d", &a[i]);
for (i = 9; i >= 0; i--)
/* 按照逆序输出 */
printf("%d ", a[i]);
printf("\n");
return 0;
}
|
the_stack_data/1186719.c
|
/**
* @file cprojf.c
* Copyright 2012, 2013 MinGW.org project
*
* 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 (including the next
* paragraph) 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.
*/
#include <math.h>
#include <complex.h>
/* Return the value of the projection onto the Riemann sphere.*/
float complex cprojf (float complex Z)
{
complex float Res = Z;
if (isinf (__real__ Z) || isinf (__imag__ Z))
{
__real__ Res = HUGE_VALF;
__imag__ Res = copysignf (0.0f, __imag__ Z);
}
return Res;
}
|
the_stack_data/37379.c
|
/* example.c -- usage example of the zlib compression library
* Copyright (C) 1995-2006 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#include "zlib.h"
#include <stdio.h>
#ifdef STDC
# include <string.h>
# include <stdlib.h>
#endif
#if defined(VMS) || defined(RISCOS)
# define TESTFILE "foo-gz"
#else
# define TESTFILE "foo.gz"
#endif
#define CHECK_ERR(err, msg) { \
if (err != Z_OK) { \
fprintf(stderr, "%s error: %d\n", msg, err); \
exit(1); \
} \
}
const char hello[] = "hello, hello!";
/* "hello world" would be more standard, but the repeated "hello"
* stresses the compression code better, sorry...
*/
const char dictionary[] = "hello";
uLong dictId; /* Adler32 value of the dictionary */
void test_compress OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
void test_gzio OF((const char *fname,
Byte *uncompr, uLong uncomprLen));
void test_deflate OF((Byte *compr, uLong comprLen));
void test_inflate OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
void test_large_deflate OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
void test_large_inflate OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
void test_flush OF((Byte *compr, uLong *comprLen));
void test_sync OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
void test_dict_deflate OF((Byte *compr, uLong comprLen));
void test_dict_inflate OF((Byte *compr, uLong comprLen,
Byte *uncompr, uLong uncomprLen));
int main OF((int argc, char *argv[]));
/* ===========================================================================
* Test compress() and uncompress()
*/
void test_compress(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
uLong len = (uLong)strlen(hello)+1;
err = compress(compr, &comprLen, (const Bytef*)hello, len);
CHECK_ERR(err, "compress");
strcpy((char*)uncompr, "garbage");
err = uncompress(uncompr, &uncomprLen, compr, comprLen);
CHECK_ERR(err, "uncompress");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad uncompress\n");
exit(1);
} else {
printf("uncompress(): %s\n", (char *)uncompr);
}
}
/* ===========================================================================
* Test read/write of .gz files
*/
void test_gzio(fname, uncompr, uncomprLen)
const char *fname; /* compressed file name */
Byte *uncompr;
uLong uncomprLen;
{
#ifdef NO_GZCOMPRESS
fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
#else
int err;
int len = (int)strlen(hello)+1;
gzFile file;
z_off_t pos;
file = gzopen(fname, "wb");
if (file == NULL) {
fprintf(stderr, "gzopen error\n");
exit(1);
}
gzputc(file, 'h');
if (gzputs(file, "ello") != 4) {
fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
exit(1);
}
if (gzprintf(file, ", %s!", "hello") != 8) {
fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
exit(1);
}
gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
gzclose(file);
file = gzopen(fname, "rb");
if (file == NULL) {
fprintf(stderr, "gzopen error\n");
exit(1);
}
strcpy((char*)uncompr, "garbage");
if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
exit(1);
}
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
exit(1);
} else {
printf("gzread(): %s\n", (char*)uncompr);
}
pos = gzseek(file, -8L, SEEK_CUR);
if (pos != 6 || gztell(file) != pos) {
fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
(long)pos, (long)gztell(file));
exit(1);
}
if (gzgetc(file) != ' ') {
fprintf(stderr, "gzgetc error\n");
exit(1);
}
if (gzungetc(' ', file) != ' ') {
fprintf(stderr, "gzungetc error\n");
exit(1);
}
gzgets(file, (char*)uncompr, (int)uncomprLen);
if (strlen((char*)uncompr) != 7) { /* " hello!" */
fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
exit(1);
}
if (strcmp((char*)uncompr, hello + 6)) {
fprintf(stderr, "bad gzgets after gzseek\n");
exit(1);
} else {
printf("gzgets() after gzseek: %s\n", (char*)uncompr);
}
gzclose(file);
#endif
}
/* ===========================================================================
* Test deflate() with small buffers
*/
void test_deflate(compr, comprLen)
Byte *compr;
uLong comprLen;
{
z_stream c_stream; /* compression stream */
int err;
uLong len = (uLong)strlen(hello)+1;
c_stream.zalloc = (alloc_func)0;
c_stream.zfree = (free_func)0;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
CHECK_ERR(err, "deflateInit");
c_stream.next_in = (Bytef*)hello;
c_stream.next_out = compr;
while (c_stream.total_in != len && c_stream.total_out < comprLen) {
c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
}
/* Finish the stream, still forcing small buffers: */
for (;;) {
c_stream.avail_out = 1;
err = deflate(&c_stream, Z_FINISH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "deflate");
}
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
}
/* ===========================================================================
* Test inflate() with small buffers
*/
void test_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = 0;
d_stream.next_out = uncompr;
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "inflate");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate\n");
exit(1);
} else {
printf("inflate(): %s\n", (char *)uncompr);
}
}
/* ===========================================================================
* Test deflate() with large buffers and dynamic change of compression level
*/
void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
z_stream c_stream; /* compression stream */
int err;
c_stream.zalloc = (alloc_func)0;
c_stream.zfree = (free_func)0;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_BEST_SPEED);
CHECK_ERR(err, "deflateInit");
c_stream.next_out = compr;
c_stream.avail_out = (uInt)comprLen;
/* At this point, uncompr is still mostly zeroes, so it should compress
* very well:
*/
c_stream.next_in = uncompr;
c_stream.avail_in = (uInt)uncomprLen;
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
if (c_stream.avail_in != 0) {
fprintf(stderr, "deflate not greedy\n");
exit(1);
}
/* Feed in already compressed data and switch to no compression: */
deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
c_stream.next_in = compr;
c_stream.avail_in = (uInt)comprLen/2;
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
/* Switch back to compressing mode: */
deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
c_stream.next_in = uncompr;
c_stream.avail_in = (uInt)uncomprLen;
err = deflate(&c_stream, Z_NO_FLUSH);
CHECK_ERR(err, "deflate");
err = deflate(&c_stream, Z_FINISH);
if (err != Z_STREAM_END) {
fprintf(stderr, "deflate should report Z_STREAM_END\n");
exit(1);
}
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
}
/* ===========================================================================
* Test inflate() with large buffers
*/
void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = (uInt)comprLen;
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
for (;;) {
d_stream.next_out = uncompr; /* discard the output */
d_stream.avail_out = (uInt)uncomprLen;
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
CHECK_ERR(err, "large inflate");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
exit(1);
} else {
printf("large_inflate(): OK\n");
}
}
/* ===========================================================================
* Test deflate() with full flush
*/
void test_flush(compr, comprLen)
Byte *compr;
uLong *comprLen;
{
z_stream c_stream; /* compression stream */
int err;
uInt len = (uInt)strlen(hello)+1;
c_stream.zalloc = (alloc_func)0;
c_stream.zfree = (free_func)0;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
CHECK_ERR(err, "deflateInit");
c_stream.next_in = (Bytef*)hello;
c_stream.next_out = compr;
c_stream.avail_in = 3;
c_stream.avail_out = (uInt)*comprLen;
err = deflate(&c_stream, Z_FULL_FLUSH);
CHECK_ERR(err, "deflate");
compr[3]++; /* force an error in first compressed block */
c_stream.avail_in = len - 3;
err = deflate(&c_stream, Z_FINISH);
if (err != Z_STREAM_END) {
CHECK_ERR(err, "deflate");
}
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
*comprLen = c_stream.total_out;
}
/* ===========================================================================
* Test inflateSync()
*/
void test_sync(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = 2; /* just read the zlib header */
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
d_stream.next_out = uncompr;
d_stream.avail_out = (uInt)uncomprLen;
inflate(&d_stream, Z_NO_FLUSH);
CHECK_ERR(err, "inflate");
d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
err = inflateSync(&d_stream); /* but skip the damaged part */
CHECK_ERR(err, "inflateSync");
err = inflate(&d_stream, Z_FINISH);
if (err != Z_DATA_ERROR) {
fprintf(stderr, "inflate should report DATA_ERROR\n");
/* Because of incorrect adler32 */
exit(1);
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
printf("after inflateSync(): hel%s\n", (char *)uncompr);
}
/* ===========================================================================
* Test deflate() with preset dictionary
*/
void test_dict_deflate(compr, comprLen)
Byte *compr;
uLong comprLen;
{
z_stream c_stream; /* compression stream */
int err;
c_stream.zalloc = (alloc_func)0;
c_stream.zfree = (free_func)0;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
CHECK_ERR(err, "deflateInit");
err = deflateSetDictionary(&c_stream,
(const Bytef*)dictionary, sizeof(dictionary));
CHECK_ERR(err, "deflateSetDictionary");
dictId = c_stream.adler;
c_stream.next_out = compr;
c_stream.avail_out = (uInt)comprLen;
c_stream.next_in = (Bytef*)hello;
c_stream.avail_in = (uInt)strlen(hello)+1;
err = deflate(&c_stream, Z_FINISH);
if (err != Z_STREAM_END) {
fprintf(stderr, "deflate should report Z_STREAM_END\n");
exit(1);
}
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
}
/* ===========================================================================
* Test inflate() with a preset dictionary
*/
void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = (uInt)comprLen;
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
d_stream.next_out = uncompr;
d_stream.avail_out = (uInt)uncomprLen;
for (;;) {
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
if (err == Z_NEED_DICT) {
if (d_stream.adler != dictId) {
fprintf(stderr, "unexpected dictionary");
exit(1);
}
err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
sizeof(dictionary));
}
CHECK_ERR(err, "inflate with dict");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate with dict\n");
exit(1);
} else {
printf("inflate with dictionary: %s\n", (char *)uncompr);
}
}
/* ===========================================================================
* Usage: example [output.gz [input.gz]]
*/
int main(argc, argv)
int argc;
char *argv[];
{
Byte *compr, *uncompr;
uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
uLong uncomprLen = comprLen;
static const char* myVersion = ZLIB_VERSION;
if (zlibVersion()[0] != myVersion[0]) {
fprintf(stderr, "incompatible zlib version\n");
exit(1);
} else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
fprintf(stderr, "warning: different zlib version\n");
}
printf("zlib version %s = %d, compile flags = %lu\n",
ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
compr = (Byte*)calloc((uInt)comprLen, 1);
uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
/* compr and uncompr are cleared to avoid reading uninitialized
* data and to ensure that uncompr compresses well.
*/
if (compr == Z_NULL || uncompr == Z_NULL) {
printf("out of memory\n");
exit(1);
}
test_compress(compr, comprLen, uncompr, uncomprLen);
/* XXX Emscripten commenting out
test_gzio((argc > 1 ? argv[1] : TESTFILE),
uncompr, uncomprLen);
*/
test_deflate(compr, comprLen);
test_inflate(compr, comprLen, uncompr, uncomprLen);
test_large_deflate(compr, comprLen, uncompr, uncomprLen);
test_large_inflate(compr, comprLen, uncompr, uncomprLen);
test_flush(compr, &comprLen);
test_sync(compr, comprLen, uncompr, uncomprLen);
comprLen = uncomprLen;
test_dict_deflate(compr, comprLen);
test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
free(compr);
free(uncompr);
return 0;
}
|
the_stack_data/242330758.c
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <omp.h>
// Определение функции
double Func(double x) {
// Недействительные значения не должны вносить вклад в интеграл
if (x > 2) {
return 0;
}
return sqrt(4 - x*x);
}
int main(int argc, char **argv) {
// Количество шагов
size_t N = 1000000;
// Запрошенное кол-во процессов
int size = 1;
if (argc > 1) {
N = atoll(argv[1]);
if (argc > 2) {
size = atoi(argv[2]);
}
}
// Задаем границы интегрирования
double a = 0, b = 2;
// Задаем мелкость разбиения отрезка
double h = (b - a) / N;
double result = (Func(0) + Func(N * h)) / 2;
// Задаем кол-во процессов для следующего распараллеливания
omp_set_num_threads(size);
// Статическое распределение итераций с шагом в 10^4
// правильное суммирование всех параллельных вычислений
#pragma omp parallel for schedule(static, 10000) reduction(+: result)
for (size_t i = 1; i < N; i++) {
result += Func(i * h);
}
result *= h;
// Вывод кол-ва процессов, используемых программой, и значение интеграла
printf("%d %lf\n", size, result);
return EXIT_SUCCESS;
}
|
the_stack_data/359054.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/epoll.h>
const int MAX_EVENTS = 10;
void error(char *msg)
{
fprintf(stderr, "%s:%s\n", msg, strerror(errno));
exit(1);
}
int read_line(int socket, char *buf, int len)
{
char *s = buf;
int slen = len;
int c = read(socket, s, slen);
while ((c > 0) && (s[c - 1] != '\n')) {
s += c;
slen = -c;
c = read(socket, s, slen);
}
if (c < 0) {
return c;
}
return len - slen;
}
int main(int argc, char *argv[])
{
int listener_d = socket(PF_INET, SOCK_STREAM, 0);
if (listener_d == -1) {
error("socket err");
}
struct sockaddr_in name;
name.sin_family = AF_INET;
name.sin_port = (in_port_t)htons(30000);
name.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(listener_d, (struct sockaddr *) &name, sizeof(name)) == -1) {
error("bind err");
}
if (listen(listener_d, 1) == -1) {
error("listen err");
}
puts("wait...");
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof(client_addr);
char buf[255];
// epollファイルディスクリプタをオープン
int epfd;
if ((epfd = epoll_create(100)) < 0) {
error("epoll_create err");
}
// listener_dソケットをepollの監視対象とする
struct epoll_event ev;
memset(&ev, 0, sizeof ev);
ev.events = EPOLLIN;
ev.data.fd = listener_d;
if ((epoll_ctl(epfd, EPOLL_CTL_ADD, listener_d, &ev)) < 0) {
error("epoll_ctl error");
}
struct epoll_event events[MAX_EVENTS];
while(1) {
int fd_count = epoll_wait(epfd, events, MAX_EVENTS, -1);
// 準備ができたディスクリプタを順番に処理
int i;
for (i = 0; i < fd_count; i++) {
if (events[i].data.fd == listener_d ){
// 準備ができたディスクリプタがlistener_dということは
// 新しいクライアントが接続してきたということ
int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);
if (connect_d == -1) {
error("accept err");
}
char *msg = "Hello World!\r\n";
write(connect_d, msg, strlen(msg));
// connect_dソケットを監視対象とする
memset(&ev, 0, sizeof ev);
ev.events = EPOLLIN;
ev.data.fd = connect_d;
if ((epoll_ctl(epfd, EPOLL_CTL_ADD, connect_d, &ev)) < 0) {
error("epoll_ctl error");
}
} else {
// connect_dの準備ができたということは
// クライアントからのデータが届いたということ
int connect_d = events[i].data.fd;
read_line(connect_d, buf, sizeof(buf));
write(connect_d, buf, strlen(buf));
close(connect_d);
// closeしたソケットを監視対象から削除
epoll_ctl(epfd, EPOLL_CTL_DEL, connect_d, &ev);
}
}
}
return 0;
}
|
the_stack_data/119206.c
|
/* $OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp $ */
/*
* Copyright (c) 1998 Todd C. Miller <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 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 ``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.
*/
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char *rcsid = "$OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp $";
#endif
#endif /* LIBC_SCCS and not lint */
#ifndef lint
static const char rcsid[] =
"$FreeBSD: src/lib/libc/string/strlcpy.c,v 1.2.4.1 2001/07/09 23:30:06 obrien Exp $";
#endif
#include <sys/types.h>
#include <string.h>
/*
* Copy src to string dst of size siz. At most siz-1 characters
* will be copied. Always NUL terminates (unless siz == 0).
* Returns strlen(src); if retval >= siz, truncation occurred.
*/
size_t strlcpy(char *dst, const char *src, size_t siz)
{
register char *d = dst;
register const char *s = src;
register size_t n = siz;
/* Copy as many bytes as will fit */
if (n != 0 && --n != 0) {
do {
if ((*d++ = *s++) == 0)
break;
} while (--n != 0);
}
/* Not enough room in dst, add NUL and traverse rest of src */
if (n == 0) {
if (siz != 0)
*d = '\0'; /* NUL-terminate dst */
while (*s++)
;
}
return(s - src - 1); /* count does not include NUL */
}
|
the_stack_data/32949277.c
|
/* Copyright 2020 Wirepas Ltd licensed under Apache License, Version 2.0
*
* See file LICENSE for full license details.
*
*/
#include <math.h>
#include <stdio.h>
#include <string.h>
#ifndef M_PI
#define M_PI acos(-1.0)
#endif
#define MATRIX_ITEM_COUNT (3 * 3)
/** Structure to hold point in 2d */
typedef struct
{
double x;
double y;
} point_2d_t;
/** Structure to hold point in 3d */
typedef struct
{
double x;
double y;
double z;
} point_3d_t;
/** Structure to hold WGS84 coordinates */
typedef struct
{
double latitude;
double longitude;
double altitude;
} location_t;
/**
* \brief Function to convert degrees to radians
* \param deg
* Value in degrees
* \return Value in radians
*/
static double deg_to_rad(double deg)
{
return deg * M_PI / 180.0;
}
/**
* \brief Function to convert radians to degrees
* \param rad
* Value in radians
* \return Value in degrees
*/
static double rad_to_deg(double rad)
{
return rad * 180.0 / M_PI;
}
/**
* \brief Function to convert WGS84 coordinates to ECEF coordinates
* \param location
* WGS84 coordinates
* \return ECEF coordinates
*/
static point_3d_t wgs84_to_ecef(location_t location)
{
const double a = 6378137.0;
const double finv = 298.257223563;
const double f = 1.0 / finv;
double e2 = 1.0 - pow(1.0 - f, 2);
double latitude_rad = deg_to_rad(location.latitude);
double longitude_rad = deg_to_rad(location.longitude);
double v = a / sqrt(1.0 - e2 * sin(latitude_rad) * sin(latitude_rad));
point_3d_t point_ecef;
point_ecef.x = (v + location.altitude) * cos(latitude_rad) * cos(longitude_rad);
point_ecef.y = (v + location.altitude) * cos(latitude_rad) * sin(longitude_rad);
point_ecef.z = (v * (1.0 - e2) + location.altitude) * sin(latitude_rad);
return point_ecef;
}
/**
* \brief Function to convert ECEF coordinates to WGS84 coordinates
* \param ecef_point
* ECEF coordinates
* \return WGS84 coordinates
*/
static location_t ecef_to_wgs84(point_3d_t ecef_point)
{
const double a = 6378137.0;
const double finv = 298.257223563;
const double f = 1.0 / finv;
double e2 = 1.0 - pow(1.0 - f, 2);
double elat = pow(10, -12);
double eht = pow(10, -5);
double p = sqrt(ecef_point.x * ecef_point.x + ecef_point.y * ecef_point.y);
double lat = atan2(ecef_point.z, p * (1.0 - e2));
double h = 0;
double dh = 1;
double dlat = 1;
while (dlat > elat || dh > eht)
{
double lat0 = lat;
double h0 = h;
double v = a / sqrt(1.0 - e2 * sin(lat) * sin(lat));
h = p / cos(lat) - v;
lat = atan2(ecef_point.z, p * (1.0 - e2 * v / (v + h)));
dlat = fabs(lat - lat0);
dh = fabs(h - h0);
}
double lon = atan2(ecef_point.y, ecef_point.x);
location_t location;
location.latitude = rad_to_deg(lat);
location.longitude = rad_to_deg(lon);
location.altitude = h;
return location;
}
/**
* \brief Function to convert floor plan pixel coordinates to WGS84 coordinates
* \param rotation_matrix
* Rotation matrix from WNT backend
* \param reverse_transformation_vector
* Offset vector from WNT backend
* \param scale_pixels_per_meter
* Scale from WNT backend
* \param pixel_position_vector
* Pixel coordinates to map to WGS84 coordinates
* \return WGS84 coordinates
*/
static location_t get_location(double *rotation_matrix, point_3d_t reverse_transformation_vector,
double scale_pixels_per_meter, point_2d_t pixel_position_vector)
{
double transposed_rotation_matrix[MATRIX_ITEM_COUNT] = { 0 };
memcpy(transposed_rotation_matrix, rotation_matrix, sizeof(transposed_rotation_matrix));
transposed_rotation_matrix[1] = rotation_matrix[3];
transposed_rotation_matrix[2] = rotation_matrix[6];
transposed_rotation_matrix[3] = rotation_matrix[1];
transposed_rotation_matrix[5] = rotation_matrix[7];
transposed_rotation_matrix[6] = rotation_matrix[2];
transposed_rotation_matrix[7] = rotation_matrix[5];
point_3d_t pixel_delta_vector;
pixel_delta_vector.x =
transposed_rotation_matrix[0] * pixel_position_vector.x +
transposed_rotation_matrix[1] * pixel_position_vector.y;
pixel_delta_vector.y =
transposed_rotation_matrix[3] * pixel_position_vector.x +
transposed_rotation_matrix[4] * pixel_position_vector.y;
pixel_delta_vector.z =
transposed_rotation_matrix[6] * pixel_position_vector.x +
transposed_rotation_matrix[7] * pixel_position_vector.y;
pixel_delta_vector.x /= scale_pixels_per_meter;
pixel_delta_vector.y /= scale_pixels_per_meter;
pixel_delta_vector.z /= scale_pixels_per_meter;
point_3d_t point_ecef;
point_ecef.x = pixel_delta_vector.x + reverse_transformation_vector.x;
point_ecef.y = pixel_delta_vector.y + reverse_transformation_vector.y;
point_ecef.z = pixel_delta_vector.z + reverse_transformation_vector.z;
return ecef_to_wgs84(point_ecef);
}
/**
* \brief Function to convert WGS84 coordinates to floor plan pixel coordinates
* \param rotation_matrix
* Rotation matrix from WNT backend
* \param reverse_transformation_vector
* Offset vector from WNT backend
* \param scale_pixels_per_meter
* Scale from WNT backend
* \param location
* WGS84 coordinates to map to pixel coordinates
* \return Pixel coordinates
*/
static point_2d_t get_pixel_position(double *rotation_matrix, point_3d_t reverse_transformation_vector,
double scale_pixels_per_meter, location_t location)
{
point_3d_t point_ecef = wgs84_to_ecef(location);
point_ecef.x -= reverse_transformation_vector.x;
point_ecef.y -= reverse_transformation_vector.y;
point_ecef.z -= reverse_transformation_vector.z;
point_2d_t point_pixel;
point_pixel.x =
rotation_matrix[0] * point_ecef.x +
rotation_matrix[1] * point_ecef.y +
rotation_matrix[2] * point_ecef.z;
point_pixel.y =
rotation_matrix[3] * point_ecef.x +
rotation_matrix[4] * point_ecef.y +
rotation_matrix[5] * point_ecef.z;
point_pixel.x *= scale_pixels_per_meter;
point_pixel.y *= scale_pixels_per_meter;
return point_pixel;
}
/**
* \brief Main entry point
* \return Return value
*/
int main()
{
/** Example values from WNT backend start */
double rotation_matrix[] = {
0.7788987921717944, 0.5526683279974951, 0.296436149586675,
0.579597627535213, -0.4538080052202482, -0.6768492332518167,
-0.2395480363285678, 0.6990107392783551, -0.6737957588651434
};
point_3d_t offset_local_to_ecef;
offset_local_to_ecef.x = 1530181.848984246;
offset_local_to_ecef.y = -4465265.612122585;
offset_local_to_ecef.z = 4275385.419786042;
double pixels_per_meter = 35;
/** Example values from WNT backend end */
/** Pixel coordinates to convert to WGS84 coordinates */
point_2d_t point_to_map;
point_to_map.x = 230;
point_to_map.y = 272;
printf("Point to map. X:%.0lf Y:%.0lf\n", point_to_map.x, point_to_map.y);
location_t location =
get_location(rotation_matrix, offset_local_to_ecef, pixels_per_meter, point_to_map);
printf("Calculated location. Latitude:%.6lf Longitude:%.6lf Altitude:%.2lf\n",
location.latitude, location.longitude, location.altitude);
/** Convert the calculated WGS84 coordinates back to pixel coordinates */
point_2d_t point =
get_pixel_position(rotation_matrix, offset_local_to_ecef, pixels_per_meter, location);
printf("Calculated point. X:%.0lf Y:%.0lf\n", point.x, point.y);
printf("Press any key to close\n");
getchar();
return 0;
}
|
the_stack_data/1199655.c
|
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
static int create_and_bind(char *port);
static int make_socket_non_binding(int sfd);
#define MAX_EVENTS 64
#define BUF_SIZE 20
static int
create_and_bind(char *port) {
struct addrinfo hint, *result;
int res, sfd;
memset(&hint, 0, sizeof(struct addrinfo));
hint.ai_family = AF_INET;
hint.ai_socktype = SOCK_STREAM;
hint.ai_flags = AI_PASSIVE;
res = getaddrinfo(NULL, port, &hint, &result);
if (res == -1) {
perror("error : can not get address info\n");
exit(1);
}
sfd = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (sfd == -1) {
perror("error : can not get socket descriptor!\n");
exit(1);
}
res = bind(sfd, result->ai_addr, result->ai_addrlen);
if (res == -1) {
perror("error : can not bind the socket!\n");
exit(1);
}
freeaddrinfo(result);
return sfd;
}
static int
make_socket_non_binding(int sfd)
{
int flags, res;
flags = fcntl(sfd, F_GETFL);
if (flags == -1) {
perror("error : cannot get socket flags!\n");
exit(1);
}
flags |= O_NONBLOCK;
res = fcntl(sfd, F_SETFL, flags);
if (res == -1) {
perror("error : cannot set socket flags!\n");
exit(1);
}
return 0;
}
int
main(int argc, char *argv[])
{
int sfd, res, epoll, cnt, i, sd;
struct epoll_event event, events[MAX_EVENTS];
if (argc != 2) {
perror("usage : port \n");
exit(1);
}
sfd = create_and_bind(argv[1]);
if (sfd == -1) {
perror("error : cannot create socket!\n");
exit(1);
}
res = make_socket_non_binding(sfd);
if (res == -1) {
perror("error : connot set flags!\n");
exit(1);
}
res = listen(sfd, SOMAXCONN);
if (res == -1) {
perror("error : cannot listen!\n");
exit(1);
}
epoll = epoll_create(1);
if (epoll == -1) {
perror("error : cannot create epoll!\n");
exit(1);
}
event.events = EPOLLIN | EPOLLOUT | EPOLLET;
event.data.fd = sfd;
res = epoll_ctl(epoll, EPOLL_CTL_ADD, sfd, &event);
if (res == -1) {
perror("error : can not add event to epoll!\n");
exit(1);
}
while (1) {
cnt = epoll_wait(epoll, events, MAX_EVENTS, -1);
for (i = 0; i < cnt; i++) {
if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP)
|| !(events[i].events & EPOLLIN))
{
perror("error : socket fd error!\n");
close(events[i].data.fd);
continue;
} else if (events[i].data.fd == sfd) {
while (1) {
struct sockaddr client_addr;
int addrlen = sizeof(struct sockaddr);
sd = accept(sfd, &client_addr, &addrlen);
if (sd == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
} else {
perror("error : cannot accept new socket!\n");
continue;
}
}
res = make_socket_non_binding(sd);
if (res == -1) {
perror("error : cannot set flags!\n");
exit(1);
}
event.data.fd = sd;
event.events = EPOLLET | EPOLLIN;
res = epoll_ctl(epoll, EPOLL_CTL_ADD, sd, &event);
if (res == -1) {
perror("error : cannot add to epoll!\n");
exit(1);
}
}
} else {
int cnt;
char buf[BUF_SIZE];
while (1) {
cnt = read(events[i].data.fd, buf, BUF_SIZE);
if (cnt == -1) {
if (errno == EAGAIN) {
break;
}
perror("error : read error!\n");
exit(1);
} else if (cnt == 0) {
close(events[i].data.fd);
break;
}
printf("receive client data : %s\n", buf);
}
}
}
}
close(sfd);
return 0;
}
|
the_stack_data/120784.c
|
unsigned int __VERIFIER_nondet_uint(void);
int main(void) {
unsigned int x = 0;
unsigned int y = __VERIFIER_nondet_uint();
while (x < 9) {
if (y % 2 == 0) {
x += 2;
} else {
x++;
}
}
__VERIFIER_assert((x % 2) == (y % 2));
}
|
the_stack_data/28235.c
|
/*
** my_putstr.c for my_putstr in /home/arbona/CPool/CPool_Day04
**
** Made by Thomas Arbona
** Login <[email protected]>
**
** Started on Thu Oct 6 08:45:27 2016 Thomas Arbona
** Last update Mon Nov 7 10:34:36 2016 Thomas Arbona
*/
#include <unistd.h>
int my_strlen(char *);
int my_putstr(char *str)
{
write(1, str, my_strlen(str));
return (0);
}
|
the_stack_data/813396.c
|
#include <stdlib.h>
#include <string.h>
#define TOKEN struct t_token
#define MAX_WORD_LENGTH 10
#define MIN_WORD_LENGTH 3
char characters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'z'};
int char_count = sizeof(characters);
int is_char(char ch) {
int i;
for (i = 0; i < char_count; i++) {
if (ch == characters[i]) {
return 1;
}
}
return 0;
}
TOKEN {
char *word;
TOKEN *next;
};
TOKEN *new_token() {
TOKEN *token = malloc(sizeof(TOKEN));
token -> next = NULL;
return token;
}
TOKEN *token_append(TOKEN *tail, char *word) {
TOKEN *head = new_token();
head -> next = tail;
head -> word = word;
return head;
}
TOKEN *tokenize_text(char *text) {
char buffer[MAX_WORD_LENGTH];
int i;
int l = strlen(text);
int b = 0;
int discard = 0;
int j;
TOKEN *tokens = NULL;
for (i = 0; i <= l; i++) {
if (is_char(text[i])) {
buffer[b] = text[i];
b++;
if (b == MAX_WORD_LENGTH) {
b = 0;
discard = 1;
}
} else {
if (discard == 1) {
b = 0;
discard = 0;
} else {
if (b >= MIN_WORD_LENGTH) {
char *word = malloc(b+1);
for (j = 0; j < b; j++) {
word[j] = buffer[j];
}
word[b] = '\0';
tokens = token_append(tokens, word);
}
b = 0;
}
}
}
return tokens;
}
void debug_enumerate_tokens(TOKEN *tokens) {
while (tokens != NULL) {
printf("%s\n", tokens -> word);
tokens = tokens -> next;
}
}
|
the_stack_data/25139127.c
|
// now i am writing a function form the starting to reverse the linked list
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
struct node
{
int data;
struct node* next;
};
void push(struct node** head,int key)
{
struct node* newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
newnode->data=key;
newnode->next=*head;
*head=newnode;
return ;
}
// suppose I want to completely reverse the linked list
void reverselist(struct node**head)
{
// we have to take three node
// one is previous and one is next
struct node*previous=NULL;
struct node*current=*head;
struct node*next=NULL;
while(current!=NULL) // means when we reach at the last node then our list is completely reversed
{
next=current->next; // it is just like working as a temporary variable which stores the address of the node
current->next=previous;
previous=current;
current=next;
}
*head=previous;
}
void reverselistrecursion(struct node**head)
{
struct node*first=*head;
struct node *rest=first->next;
if(*head==NULL)
{
return; // end of the recursion
}
// here sometimes one more condition come when the list is empty
if(rest==NULL)
{
return;
}
reverselistrecursion(&rest);
first->next->next=first;
first->next=NULL; // last of the starting
// till now we do not change the address of the rest
// which can be used further
*head=rest;
}
/*void reverselist(struct node **head)
{
// first of all i need total no of nodes
struct node*temp=*head;
struct node*previouslast=NULL;
int count =0;
// and we have to find out the last and the second last node of the linked list
while(temp->next!=NULL)
{
count++;
previouslast=temp;
temp=temp->next;
}
// now temp is the last node
struct node*secondfirst=NULL;
secondfirst=(*head)->next;
//printf("%d%d%d%d",(*head)->data,secondfirst->data,previouslast->data,temp->data);
// now we get the total no of elements
}*/
void printlist(struct node* head)
{
while(head!=NULL)
{
printf("%d ", head->data);
head=head->next;
}
printf("\n");
}
int main()
{
struct node*head=NULL;
push(&head,5);
push(&head,4);
push(&head,3);
push(&head,2);
push(&head,1);
printlist(head);
reverselist(&head);
printlist(head);
reverselistrecursion(&head); // reverse of the struct node by using the recursion
printlist(head);
}
|
the_stack_data/40877.c
|
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
#ifdef WIN32
#include "winport.h"
#include <stdlib.h>
#include <stdint.h> /* for int64_t */
#include <winsock2.h> /* must always be included before ws2tcpip.h */
#include <ws2tcpip.h> /* for SOCKET */
int pthread_mutex_lock(pthread_mutex_t* _mutex ){
int rc = WaitForSingleObject( *_mutex, // handle to mutex
INFINITE); // no time-out interval
return ((rc == WAIT_OBJECT_0) ? 0: rc);
}
int pthread_mutex_unlock( pthread_mutex_t* _mutex ){
int rc = ReleaseMutex(*_mutex);
return ((rc != 0)? 0: GetLastError());
}
int pthread_mutex_init(pthread_mutex_t* _mutex, void* ignoredAttr){
//use CreateMutex as we are using the HANDLES in pthread_cond
*_mutex = CreateMutex(
NULL, // default security attributes
FALSE, // initially not owned
NULL); // unnamed mutex
return ((*_mutex == NULL) ? GetLastError() : 0);
}
int pthread_mutex_destroy(pthread_mutex_t* _mutex)
{
int rc = CloseHandle(*_mutex);
return ((rc != 0)? 0: GetLastError());
}
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, unsigned (__stdcall* start_routine)(void* a), void *arg)
{
int _intThreadId;
(*thread).thread_handle = (HANDLE)_beginthreadex( NULL, 0, start_routine , arg, 0, (unsigned int*)&_intThreadId );
(*thread).thread_id = _intThreadId;
return (((*thread).thread_handle == 0 ) ? errno : 0 );
}
int pthread_equal(pthread_t t1, pthread_t t2){
//Is there a better way to do this? GetThreadId(handle) is only supported Windows 2003 n above.
return ((t1.thread_id == t2.thread_id) ? 1:0);
}
pthread_t pthread_self(){
pthread_t thread_self;
thread_self.thread_handle = GetCurrentThread();
thread_self.thread_id = GetCurrentThreadId();
return thread_self;
}
int pthread_join(pthread_t _thread, void** ignore)
{
int rc = WaitForSingleObject( _thread.thread_handle, INFINITE );
return ((rc == WAIT_OBJECT_0) ? 0: rc);
}
int pthread_detach(pthread_t _thread)
{
int rc = CloseHandle(_thread.thread_handle) ;
return (rc != 0) ? 0: GetLastError();
}
void pthread_mutexattr_init(pthread_mutexattr_t* ignore){}
void pthread_mutexattr_settype(pthread_mutexattr_t* ingore_attr, int ignore){}
void pthread_mutexattr_destroy(pthread_mutexattr_t* ignore_attr){}
int
pthread_cond_init (pthread_cond_t *cv,
const pthread_condattr_t * ignore)
{
cv->waiters_count_ = 0;
cv->was_broadcast_ = 0;
cv->sema_ = CreateSemaphore (NULL, // no security
0, // initially 0
0x7fffffff, // max count
NULL); // unnamed
if (cv->sema_ == NULL )
return GetLastError();
InitializeCriticalSection (&cv->waiters_count_lock_);
cv->waiters_done_ = CreateEvent (NULL, // no security
FALSE, // auto-reset
FALSE, // non-signaled initially
NULL); // unnamed
return (cv->waiters_done_ == NULL) ? GetLastError() : 0;
}
int pthread_cond_destroy(pthread_cond_t *cond)
{
CloseHandle( cond->sema_);
DeleteCriticalSection(&cond->waiters_count_lock_);
return (CloseHandle( cond->waiters_done_ ) == 0)? GetLastError(): 0 ;
}
int
pthread_cond_signal (pthread_cond_t *cv)
{
int have_waiters;
EnterCriticalSection (& (cv->waiters_count_lock_));
have_waiters = cv->waiters_count_ > 0;
LeaveCriticalSection (&cv->waiters_count_lock_);
// If there aren't any waiters, then this is a no-op.
if (have_waiters){
return (ReleaseSemaphore (cv->sema_, 1, 0) == 0 ) ? GetLastError() : 0 ;
}else
return 0;
}
int
pthread_cond_broadcast (pthread_cond_t *cv)
{
// This is needed to ensure that <waiters_count_> and <was_broadcast_> are
// consistent relative to each other.
int have_waiters = 0;
EnterCriticalSection (&cv->waiters_count_lock_);
if (cv->waiters_count_ > 0) {
// We are broadcasting, even if there is just one waiter...
// Record that we are broadcasting, which helps optimize
// <pthread_cond_wait> for the non-broadcast case.
cv->was_broadcast_ = 1;
have_waiters = 1;
}
if (have_waiters) {
// Wake up all the waiters atomically.
ReleaseSemaphore (cv->sema_, cv->waiters_count_, 0);
LeaveCriticalSection (&cv->waiters_count_lock_);
// Wait for all the awakened threads to acquire the counting
// semaphore.
WaitForSingleObject (cv->waiters_done_, INFINITE);
// This assignment is okay, even without the <waiters_count_lock_> held
// because no other waiter threads can wake up to access it.
cv->was_broadcast_ = 0;
}
else
LeaveCriticalSection (&cv->waiters_count_lock_);
}
int
pthread_cond_wait (pthread_cond_t *cv,
pthread_mutex_t *external_mutex)
{
int last_waiter;
// Avoid race conditions.
EnterCriticalSection (&cv->waiters_count_lock_);
cv->waiters_count_++;
LeaveCriticalSection (&cv->waiters_count_lock_);
// This call atomically releases the mutex and waits on the
// semaphore until <pthread_cond_signal> or <pthread_cond_broadcast>
// are called by another thread.
SignalObjectAndWait (*external_mutex, cv->sema_, INFINITE, FALSE);
// Reacquire lock to avoid race conditions.
EnterCriticalSection (&cv->waiters_count_lock_);
// We're no longer waiting...
cv->waiters_count_--;
// Check to see if we're the last waiter after <pthread_cond_broadcast>.
last_waiter = cv->was_broadcast_ && cv->waiters_count_ == 0;
LeaveCriticalSection (&cv->waiters_count_lock_);
// If we're the last waiter thread during this particular broadcast
// then let all the other threads proceed.
if (last_waiter)
// This call atomically signals the <waiters_done_> event and waits until
// it can acquire the <external_mutex>. This is required to ensure fairness.
SignalObjectAndWait (cv->waiters_done_, *external_mutex, INFINITE, FALSE);
else
// Always regain the external mutex since that's the guarantee we
// give to our callers.
WaitForSingleObject (*external_mutex, INFINITE);
}
int pthread_key_create(pthread_key_t *key, void (*destructor)(void *) )
{
int result = 0;
pthread_key_t* newkey;
if ((newkey = (pthread_key_t*) calloc (1, sizeof (pthread_key_t))) == NULL)
{
result = ENOMEM;
}
else if ((newkey->key = TlsAlloc ()) == TLS_OUT_OF_INDEXES)
{
result = EAGAIN;
free (newkey);
newkey = NULL;
}
else if (destructor != NULL)
{
//--we have to store the function pointer for destructor, so that we can call it
//--to free up the user allocated storage--
newkey->destructor = destructor;
}
key = newkey;
return (result);
}
int pthread_key_delete(pthread_key_t key)
{
int rc = 0;
LPVOID lpvData = TlsGetValue(key.key);
rc = TlsFree (key.key);
rc = (rc != 0 ) ? 0 : GetLastError();
if (key.destructor != NULL && lpvData != 0){
key.destructor(lpvData); //we take control of calling destructor, instead of calling it on thread exit.
}
free (&key);
return (rc);
}
void *pthread_getspecific(pthread_key_t key)
{
LPVOID lpvData = TlsGetValue(key.key);
if ((lpvData == 0) && (GetLastError() != ERROR_SUCCESS))
return NULL;
else
return lpvData;
}
int pthread_setspecific(pthread_key_t key, const void *value)
{
int rc = TlsSetValue (key.key, value);
return ((rc != 0 ) ? 0 : GetLastError());
}
int gettimeofday(struct timeval *tp, void *tzp) {
int64_t now = 0;
if (tzp != 0) { errno = EINVAL; return -1; }
GetSystemTimeAsFileTime( (LPFILETIME)&now );
tp->tv_sec = (long)(now / 10000000 - 11644473600LL);
tp->tv_usec = (now / 10) % 1000000;
return 0;
}
int close(SOCKET fd) {
return closesocket(fd);
}
int Win32WSAStartup()
{
WORD wVersionRq;
WSADATA wsaData;
int err;
wVersionRq = MAKEWORD(2,0);
err = WSAStartup(wVersionRq, &wsaData);
if (err != 0)
return 1;
// confirm the version information
if ((LOBYTE(wsaData.wVersion) != 2) ||
(HIBYTE(wsaData.wVersion) != 0))
{
Win32WSACleanup();
return 1;
}
return 0;
}
void Win32WSACleanup()
{
WSACleanup();
}
double drand48(void)
{
return (double)(rand()) / RAND_MAX;
}
#endif //WIN32
|
the_stack_data/90766112.c
|
/* Taxonomy Classification: 0000300603130000000111 */
/*
* WRITE/READ 0 write
* WHICH BOUND 0 upper
* DATA TYPE 0 char
* MEMORY LOCATION 0 stack
* SCOPE 3 inter-file/inter-proc
* CONTAINER 0 no
* POINTER 0 no
* INDEX COMPLEXITY 6 N/A
* ADDRESS COMPLEXITY 0 constant
* LENGTH COMPLEXITY 3 variable
* ADDRESS ALIAS 1 yes, one level
* INDEX ALIAS 3 N/A
* LOCAL CONTROL FLOW 0 none
* SECONDARY CONTROL FLOW 0 none
* LOOP STRUCTURE 0 no
* LOOP COMPLEXITY 0 N/A
* ASYNCHRONY 0 no
* TAINT 0 no
* RUNTIME ENV. DEPENDENCE 0 no
* MAGNITUDE 1 1 byte
* CONTINUOUS/DISCRETE 1 continuous
* SIGNEDNESS 1 yes
*/
/*
Copyright 2005 Massachusetts Institute of Technology
All rights reserved.
Redistribution and use of software in source and binary forms, with or without
modification, are permitted provided that the following conditions are met.
- Redistributions of source code must retain the above copyright notice,
this set of conditions and the disclaimer below.
- Redistributions in binary form must reproduce the copyright notice, this
set of conditions, and the disclaimer below in the documentation and/or
other materials provided with the distribution.
- Neither the name of the Massachusetts Institute of Technology 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".
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h>
int main(int argc, char *argv[])
{
int size;
char src[11];
char buf[10];
memset(src, 'A', 11);
src[11 - 1] = '\0';
size = -1;
/* BAD */
memcpy(buf, src, size);
return 0;
}
|
the_stack_data/31388347.c
|
/* Use of this source code is governed by the Apache 2.0 license; see COPYING.
* Generic checksm routine originally taken from DPDK:
* BSD license; (C) Intel 2010-2015, 6WIND 2014. */
/* IP checksum routines.
*
* See src/arch/ for architecture specific SIMD versions. */
#include <arpa/inet.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/time.h>
uint16_t cksum_generic(unsigned char *p, size_t len, uint16_t initial)
{
uint32_t sum = htons(initial);
const uint16_t *u16 = (const uint16_t *)p;
while (len >= (sizeof(*u16) * 4)) {
sum += u16[0];
sum += u16[1];
sum += u16[2];
sum += u16[3];
len -= sizeof(*u16) * 4;
u16 += 4;
}
while (len >= sizeof(*u16)) {
sum += *u16;
len -= sizeof(*u16);
u16 += 1;
}
/* if length is in odd bytes */
if (len == 1)
sum += *((const uint8_t *)u16);
while(sum>>16)
sum = (sum & 0xFFFF) + (sum>>16);
return ntohs((uint16_t)~sum);
}
// SIMD versions
//
// A unaligned version of the cksum,
// n is number of 16-bit values to sum over, n in it self is a
// 16 bit number in order to avoid overflow in the loop
//
static inline uint32_t cksum_ua_loop(unsigned char *p, uint16_t n)
{
uint32_t s0 = 0;
uint32_t s1 = 0;
while (n) {
s0 += p[0];
s1 += p[1];
p += 2;
n--;
}
return (s0<<8)+s1;
}
// Incrementally update checksum when modifying a 16-bit value.
void checksum_update_incremental_16(uint16_t* checksum_cell,
uint16_t* value_cell,
uint16_t new_value)
{
uint32_t sum;
sum = ~ntohs(*checksum_cell) & 0xffff;
sum += (~ntohs(*value_cell) & 0xffff) + new_value;
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
*checksum_cell = htons(~sum & 0xffff);
*value_cell = htons(new_value);
}
// Incrementally update checksum when modifying a 32-bit value.
void checksum_update_incremental_32(uint16_t* checksum_cell,
uint32_t* value_cell,
uint32_t new_value)
{
uint32_t sum;
uint32_t old_value = ~ntohl(*value_cell);
sum = ~ntohs(*checksum_cell) & 0xffff;
sum += (old_value >> 16) + (old_value & 0xffff);
sum += (new_value >> 16) + (new_value & 0xffff);
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
*checksum_cell = htons(~sum & 0xffff);
*value_cell = htonl(new_value);
}
// calculates the initial checksum value resulting from
// the pseudo header.
// return values:
// 0x0000 - 0xFFFF : initial checksum (in host byte order).
// 0xFFFF0001 : unknown packet (non IPv4/6 or non TCP/UDP)
// 0xFFFF0002 : bad header
uint32_t pseudo_header_initial(const int8_t *buf, size_t len)
{
const uint16_t *hwbuf = (const uint16_t *)buf;
int8_t ipv = (buf[0] & 0xF0) >> 4;
int8_t proto = 0;
int headersize = 0;
if (ipv == 4) { // IPv4
proto = buf[9];
headersize = (buf[0] & 0x0F) * 4;
} else if (ipv == 6) { // IPv6
proto = buf[6];
headersize = 40;
} else {
return 0xFFFF0001;
}
if (proto == 6 || proto == 17) { // TCP || UDP
uint32_t sum = 0;
len -= headersize;
if (ipv == 4) { // IPv4
if (cksum_generic((unsigned char *)buf, headersize, 0) != 0) {
return 0xFFFF0002;
}
sum = htons(len & 0x0000FFFF) + (proto << 8)
+ hwbuf[6]
+ hwbuf[7]
+ hwbuf[8]
+ hwbuf[9];
} else { // IPv6
sum = hwbuf[2] + (proto << 8);
int i;
for (i = 4; i < 20; i+=4) {
sum += hwbuf[i] +
hwbuf[i+1] +
hwbuf[i+2] +
hwbuf[i+3];
}
}
sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
return ntohs(sum);
}
return 0xFFFF0001;
}
|
the_stack_data/48576211.c
|
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#define BACKLOG 2 /* Number of connections in queue before being rejected*/
#define MAXDATASIZE 1000
#define STDIN 0
int main(int argc, char *argv[])
{
int listen_fd,conn_fd,i;
int client_fd[FD_SETSIZE];
int max_index;
int sin_size;
struct sockaddr_in server; /* server's address information */
struct sockaddr_in client; /* client's address information */
struct sockaddr_in temp;
if (argc !=2) { /* this is used because our program will need 1 argument (port) */
printf("Usage: %s <port>\n",argv[0]);
exit(-1);
}
if ((listen_fd=socket(AF_INET, SOCK_STREAM, 0)) == -1 ) {
printf("socket() error\n");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1])); /* Remember htons() from "Conversions" section? =) */
server.sin_addr.s_addr = INADDR_ANY;/* INADDR_ANY puts your IP address automatically */
bzero(&(server.sin_zero),8); /* zero the rest of the structure */
if(bind(listen_fd,(struct sockaddr*)&server,sizeof(struct sockaddr))==-1) {
printf("bind() error\n");
exit(-1);
}
if(listen(listen_fd,BACKLOG) == -1) {
printf("listen() error\n");
exit(-1);
}
//------------------------------------------------------------------------------------------------------------------------------
fd_set read_set,write_set,all_set;
struct timeval timeout;
int ret_val;
max_index = 0;
for(i=0;i<FD_SETSIZE;i++)
{
client_fd[i]=-1;
}
//highest-numbered file descriptor in any of the three sets.
int max_fd = listen_fd;
/*initialising fd sets that are storing status of various fd*/
FD_ZERO(&read_set);
FD_ZERO(&write_set);
FD_ZERO(&all_set);
//Make the standard input socket non-blocking
//
fcntl(STDIN, F_SETFL, O_NONBLOCK);
FD_SET(listen_fd,&all_set);
while(1)
{
read_set = all_set;
write_set = all_set;
timeout.tv_sec=100;
timeout.tv_usec=0;
ret_val=select(max_fd+1,&read_set,NULL,NULL,&timeout);
if(ret_val == 0) {
printf("\nTimeout occurred! No data after 10 seconds.\n");
}
else
if (ret_val == -1) {
perror("select");
exit(-1);
}
else if(FD_ISSET(listen_fd,&read_set))
{
int sin_size=sizeof(struct sockaddr_in);
if ((conn_fd = accept(listen_fd,(struct sockaddr *)&client,&sin_size))==-1) {
perror("accept");
exit(-1);
}
char temp_buf[INET_ADDRSTRLEN];
inet_ntop(AF_INET,&(client.sin_addr),temp_buf,INET_ADDRSTRLEN);
if(temp_buf == NULL)
printf("inet_ntop error\n");
else
printf("accepted connection from client with IP Addr : %s and port Number :%u\n",temp_buf,ntohs (client.sin_port));
if(max_index==FD_SETSIZE)
printf("too many clients to handle\n");
else {
client_fd[max_index]=conn_fd;
max_index++;
}
FD_SET(conn_fd,&all_set);
if(conn_fd>max_fd)
max_fd=conn_fd;
} //end of FD_ISSET
//_____________________________________________________________________________________________________________________________________________
else{//Check the client for data
for(i=0;i<FD_SETSIZE;i++)//loop checks all possible sockets that are connected
{
sin_size=sizeof(struct sockaddr_in);
char temp_buf[INET_ADDRSTRLEN];
char buf[1000];
//checks if a particular socket is ready for reading
if(FD_ISSET(client_fd[i],&read_set)) {
int numbytes;
numbytes = recv(client_fd[i],buf,MAXDATASIZE,0);
if(numbytes>0)
{
buf[numbytes]='\0';
if(getpeername(client_fd[i],(struct sockaddr *)&temp,&sin_size)==-1)
{
printf("Peername error\n");
exit(-1);
}
inet_ntop(AF_INET,&(temp.sin_addr),temp_buf,INET_ADDRSTRLEN);
if(temp_buf == NULL)
printf("inet_ntop error\n");
else
printf("Message from client %s on port %u :%s",temp_buf,ntohs(temp.sin_port),buf);
}//
if(numbytes>0)
if(getpeername(client_fd[i],(struct sockaddr *)&temp,&sin_size)==-1)
{
printf("Peername error\n");
exit(-1);
}
inet_ntop(AF_INET,&(temp.sin_addr),temp_buf,INET_ADDRSTRLEN);
if(temp_buf == NULL)
printf("inet_ntop error\n");
else
printf("My message to client %s on port %u :",temp_buf,ntohs(temp.sin_port));
fgets(buf,1000,stdin);
send(client_fd[i],buf,strlen(buf),0); /* send message to client */
} //
if(FD_ISSET(client_fd[i],&read_set));
}// end of for
}//end of else
//______________________________________________________________________________________________________________________________
}//end of while
}
|
the_stack_data/184518030.c
|
/**
* \file
* \brief [Problem 19](https://projecteuler.net/problem=19) solution
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#include <stdio.h>
/**
* Function to get the number of days in a month.
* \param month month identified by an integer -\n
* > 0 = Jan and 11 = December
* \returns number of days in given month
* \note For February, adjust for leap year outside the function.
*/
char get_month_days(short month)
{
if (month == 1) /* February has 28 days. Adjust leap year in the loop */
return 28;
else if (month <= 6) /* odd months till July have 30 days - Jan = 0 (even)*/
{
if (month & 0x01)
return 30;
else
return 31;
}
// else if (month >= 7) /* odd months after July have 31 days*/
if (month & 0x01)
return 31;
return 30;
}
/**
* @brief Check if input year is a leap year.
* \param year year to check
* \return 1 if input year is a leap year
* \return 0 if input year is not a leap year
*/
char is_leap_year(short year)
{
if ((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0)))
return 1;
return 0;
}
#ifdef DEBUG
/** Function to convert integer month to string
* \param day integer identifier of day (0 = Sunday and 7 = Saturday
* \return pointer to string representation)
*/
const char *day_string(int day)
{
switch (day)
{
case 0:
return "Sunday";
case 1:
return "Monday";
case 2:
return "Tuesday";
case 3:
return "Wednesday";
case 4:
return "Thursday";
case 5:
return "Friday";
case 6:
return "Saturday";
default:
return "Shouldn't see this!";
}
}
#endif
/** Main function */
int main(int argc, char **argv)
{
int count_sundays = 0;
const short start_year = 1901;
const short end_year = 2000;
/*
* Let us identify days i.e., Sunday thru Saturday with integers - 0 thru 6
* respectively Jan 1 1901 was a Tuesday
*/
char start_day = 2;
for (int year = start_year; year <= end_year; year++)
{
char is_leap = is_leap_year(year);
for (char month = 0; month < 12; month++)
{
/*
* These two for-loops count the start of day for the next month.
* Hence, we have to skip the last December count
*/
if (year == end_year && month == 11)
continue;
int days = get_month_days(month);
if (is_leap && month == 1) /* for a leap year february, add a day */
days++;
#ifdef DEBUG
if (year == end_year)
{
printf("Year: %d\t Month: %d\t Days: %d\t First of day: %s\n",
year, month, days, day_string(start_day));
}
#endif
/* Main Algorithm:
* every week has 7 days hence, the start of next day would be
* modulo 7 add to this, the current start date and ensure the
* result is still modulo 7!
*/
start_day = ((days % 7) + start_day) % 7;
/* If start-day is a Sunday, increment counter */
if (start_day == 0)
count_sundays++;
}
}
printf(
"Total number of Sundays that happened on the 1st of a month in the "
"last century: %d\n",
count_sundays);
return 0;
}
|
the_stack_data/70449383.c
|
#include <ctype.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#define BUFFER_SIZE 32
#define N_HEADER_LINES 4
#define N_GROUPS 16
#define FILE_NOT_FOUND_ERROR "File %s not found!"
#define HEADER_ERROR "Expected a 4 line pgm header, but reached EOF at line %d"
// region Helper Functions
char* ltrim(char *s) {
while(isspace(*s)) {
s++;
}
return s;
}
char* rtrim(char *s) {
char* back = s + strlen(s);
while(isspace(*--back));
*(back+1) = '\0';
return s;
}
char* trim(char *s) {
return rtrim(ltrim(s));
}
// endregion
// region Image Data
struct ImageData_s {
uint8_t** data;
long long width;
long long height;
} ImageData_default = {NULL, 0, 0};
typedef struct ImageData_s ImageData;
ImageData* read_image_data(const char* file_path) {
// Default parameters
if(file_path == NULL) {
file_path = "lenna.pgm";
}
// Open file
FILE *fp = fopen(file_path, "r");
if(fp == NULL) {
fprintf(stderr, FILE_NOT_FOUND_ERROR, file_path);
exit(-1);
}
// Define temporary values
char buffer[BUFFER_SIZE];
char results[N_HEADER_LINES][BUFFER_SIZE];
char *t_ptr;
// Read header
for(int i = 0; i < N_HEADER_LINES; ++i) {
if (!fgets(buffer, sizeof(buffer), fp)) {
fprintf(stderr, HEADER_ERROR, i + 1);
exit(-1);
}
strcpy(results[i], trim(buffer));
}
// Create ImageData
ImageData* to_return = (ImageData*)malloc(sizeof(ImageData));
to_return->width = strtoll(results[1], &t_ptr, 10);
to_return->height = strtoll(results[2], &t_ptr, 10);
// Allocate data matrix
to_return->data = (uint8_t**)malloc(to_return->height * sizeof(uint8_t*));
for(uint64_t i = 0; i < to_return->height; ++i) {
to_return->data[i] = (uint8_t*)malloc(to_return->width * sizeof(uint8_t));
}
// Copy data into matrix
uint8_t row_buffer[to_return->width];
for(uint64_t i = 0; fread(row_buffer, 1, to_return->width, fp); ++i) {
for(uint64_t j = 0; j < to_return->width; ++j) {
to_return->data[i][j] = row_buffer[j];
}
}
return to_return;
}
void free_image_data(ImageData* image_data_ptr) {
for(uint64_t i = 0; i < image_data_ptr->height; ++i) {
free(image_data_ptr->data[i]);
}
free(image_data_ptr->data);
}
// endregion
// region Group Statistics
uint8_t get_group(uint8_t byte) {
return byte >> 4;
}
uint64_t* get_group_statistics(ImageData image_data) {
uint64_t* group_statistics = (uint64_t*)malloc(N_GROUPS * sizeof(uint64_t));
for(uint64_t i = 0; i < N_GROUPS; ++i) {
group_statistics[i] = 0;
}
for(uint64_t i = 0; i < image_data.height; ++i) {
for(uint64_t j = 0; j < image_data.width; ++j) {
++group_statistics[get_group(image_data.data[i][j]) % N_GROUPS];
}
}
return group_statistics;
}
void free_group_statistics(uint64_t* group_statistics) {
free(group_statistics);
}
// endregion
int main(int argc, char* argv[]) {
char* file_path = argc < 2 ? NULL : argv[1];
ImageData* img = read_image_data(file_path);
uint64_t* group_statistics = get_group_statistics(*img);
uint64_t n_total = 0;
for(uint64_t i = 0; i < N_GROUPS; ++i) {
n_total += group_statistics[i];
}
for(uint64_t i = 0; i < N_GROUPS; ++i) {
printf("%lu %f\n", i, (double)group_statistics[i] / n_total);
}
free_image_data(img);
free_group_statistics(group_statistics);
return 0;
}
|
the_stack_data/423102.c
|
# 1 "benchmarks/ds-03-impl3.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "benchmarks/ds-03-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) {
# 129 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
y[i] = fxp_transposed_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 174 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_overflow.h"
}
overflow_mode = 1;
fxp_verify_overflow_array(y, X_SIZE_VALUE);
return 0;
}
# 33 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 1
# 15 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
extern digital_system_state_space _controller;
extern int nStates;
extern int nInputs;
extern int nOutputs;
int verify_limit_cycle_state_space(void){
double stateMatrix[4][4];
double outputMatrix[4][4];
double arrayLimitCycle[4];
double result1[4][4];
double result2[4][4];
int i, j, k;
for(i=0; i<4;i++){
for(j=0; j<4;j++){
result1[i][j]=0;
result2[i][j]=0;
stateMatrix[i][j]=0;
outputMatrix[i][j]=0;
}
}
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
k = 0;
for (i = 1; i < 0; i++) {
double_matrix_multiplication(nStates,nStates,nStates,1,_controller.A,_controller.states,result1);
double_matrix_multiplication(nStates,nInputs,nInputs,1,_controller.B,_controller.inputs,result2);
double_add_matrix(nStates,
1,
result1,
result2,
_controller.states);
double_matrix_multiplication(nOutputs,nStates,nStates,1,_controller.C,_controller.states,result1);
double_matrix_multiplication(nOutputs,nInputs,nInputs,1,_controller.D,_controller.inputs,result2);
double_add_matrix(nOutputs,
1,
result1,
result2,
_controller.outputs);
int l;
for(l = 0; l < nStates; l++){
stateMatrix[l][k] = _controller.states[l][0];
}
for(l = 0; l < nOutputs; l++){
stateMatrix[l][k] = _controller.outputs[l][0];
}
k++;
}
printf("#matrix STATES -------------------------------");
print_matrix(stateMatrix,nStates,0);
printf("#matrix OUTPUTS -------------------------------");
print_matrix(outputMatrix,nOutputs,0);
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 93, __extension__ __PRETTY_FUNCTION__); }))
# 93 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
for(i=0; i<nStates;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = stateMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
for(i=0; i<nOutputs;i++){
for(j=0; j<0;j++){
arrayLimitCycle[j] = outputMatrix[i][j];
}
double_check_persistent_limit_cycle(arrayLimitCycle,0);
}
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
((void) sizeof ((
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
0
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
) ; else __assert_fail (
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
"0"
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h", 110, __extension__ __PRETTY_FUNCTION__); }))
# 110 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
;
}
int verify_limit_cycle(void){
overflow_mode = 3;
int i;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
__DSVERIFIER_assert(X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na);
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 168 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t xaux[ds.b_size];
int nondet_constant_input = nondet_int();
__DSVERIFIER_assume(nondet_constant_input >= min_fxp && nondet_constant_input <= max_fxp);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = nondet_constant_input;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t y0[ds.a_size];
fxp_t waux[Nw];
fxp_t w0[Nw];
# 206 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= min_fxp && waux[i] <= max_fxp);
w0[i] = waux[i];
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
# 234 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
y[i] = fxp_transposed_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 278 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 34 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
extern digital_system ds;
extern implementation impl;
int verify_error(void){
overflow_mode = 2;
double a_cascade[100];
int a_cascade_size;
double b_cascade[100];
int b_cascade_size;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 69 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
double yf[X_SIZE_VALUE];
double xf[X_SIZE_VALUE];
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
double yfaux[ds.a_size];
double xfaux[ds.b_size];
double wfaux[Nw];
int i;
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
yfaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
xfaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
wfaux[i] = 0;
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_int();
__DSVERIFIER_assume(x[i] >= min_fxp && x[i] <= max_fxp);
yf[i] = 0.0f;
xf[i] = fxp_to_double(x[i]);
}
for (i = 0; i < X_SIZE_VALUE; ++i) {
# 156 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
y[i] = fxp_transposed_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
yf[i] = double_transposed_direct_form_2(wfaux, xf[i], ds.a, ds.b, ds.a_size, ds.b_size);
# 169 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error.h"
double absolute_error = yf[i] - fxp_to_double(y[i]);
__DSVERIFIER_assert(absolute_error < (impl.max_error) && absolute_error > (-impl.max_error));
}
return 0;
}
# 35 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 1
# 13 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
extern digital_system ds;
extern implementation impl;
int verify_zero_input_limit_cycle(void){
overflow_mode = 3;
int i,j;
int Set_xsize_at_least_two_times_Na = 2 * ds.a_size;
printf("X_SIZE must be at least 2 * ds.a_size");
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
((void) sizeof ((
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
) ; else __assert_fail (
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
"X_SIZE_VALUE >= Set_xsize_at_least_two_times_Na"
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h", 23, __extension__ __PRETTY_FUNCTION__); }))
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
;
fxp_t a_fxp[ds.a_size];
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
# 71 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
fxp_t min_fxp = fxp_double_to_fxp(impl.min);
fxp_t max_fxp = fxp_double_to_fxp(impl.max);
fxp_t y[X_SIZE_VALUE];
fxp_t x[X_SIZE_VALUE];
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = 0;
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
fxp_t yaux[ds.a_size];
fxp_t xaux[ds.b_size];
fxp_t waux[Nw];
fxp_t y0[ds.a_size];
fxp_t w0[Nw];
# 104 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= min_fxp && waux[i] <= max_fxp);
w0[i] = waux[i];
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
fxp_t xk, temp;
fxp_t *aptr, *bptr, *xptr, *yptr, *wptr;
for(i=0; i<X_SIZE_VALUE; ++i){
# 141 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
y[i] = fxp_transposed_direct_form_2(waux, x[i], a_fxp, b_fxp, ds.a_size, ds.b_size);
# 188 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_zero_input_limit_cycle.h"
}
fxp_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 36 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
extern hardware hw;
int generic_timer = 0;
int verify_generic_timing(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
generic_timer += ((2 * hw.assembly.std) + (1 * hw.assembly.rjmp));
double initial_timer = generic_timer;
for (i = 0; i < X_SIZE_VALUE; ++i) {
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.adiw) + (2 * hw.assembly.std));
generic_timer += ((2 * hw.assembly.ldd) + (1 * hw.assembly.cpi) + (1 * hw.assembly.cpc) + (1 * hw.assembly.brlt));
# 85 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
y[i] = generic_timing_double_transposed_direct_form_2(waux, x[i], ds.a, ds.b, ds.a_size, ds.b_size);
double spent_time = (((double) generic_timer) * hw.cycle);
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
((void) sizeof ((
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
spent_time <= ds.sample_time
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
) ; else __assert_fail (
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
"spent_time <= ds.sample_time"
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h", 89, __extension__ __PRETTY_FUNCTION__); }))
# 89 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_generic_timing.h"
;
generic_timer = initial_timer;
}
return 0;
}
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h" 1
# 16 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
int nondet_int();
float nondet_float();
extern digital_system ds;
extern implementation impl;
int verify_timing_msp_430(void) {
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
int i;
for (i = 0; i < X_SIZE_VALUE; ++i) {
y[i] = 0;
x[i] = nondet_float();
__DSVERIFIER_assume(x[i] >= impl.min && x[i] <= impl.max);
}
int Nw = 0;
Nw = ds.a_size > ds.b_size ? ds.a_size : ds.b_size;
double yaux[ds.a_size];
double xaux[ds.b_size];
double waux[Nw];
for (i = 0; i < ds.a_size; ++i) {
yaux[i] = 0;
}
for (i = 0; i < ds.b_size; ++i) {
xaux[i] = 0;
}
for (i = 0; i < Nw; ++i) {
waux[i] = 0;
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for (i = 0; i < X_SIZE_VALUE; ++i) {
# 75 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
y[i] = double_transposed_direct_form_2_MSP430(waux, x[i], ds.a, ds.b, ds.a_size, ds.b_size);
# 121 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_timing_msp430.h"
}
return 0;
}
# 38 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
extern digital_system ds;
extern implementation impl;
int verify_stability(void){
overflow_mode = 0;
fxp_t a_fxp[ds.a_size];
fxp_double_to_fxp_array(ds.a, a_fxp, ds.a_size);
double _a[ds.a_size];
fxp_to_double_array(_a, a_fxp, ds.a_size);
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
((void) sizeof ((
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ? 1 : 0), __extension__ ({ if (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
check_stability(_a, ds.a_size)
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
) ; else __assert_fail (
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
"check_stability(_a, ds.a_size)"
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h" 3 4
, "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h", 37, __extension__ __PRETTY_FUNCTION__); }))
# 37 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
;
# 83 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability.h"
return 0;
}
# 39 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h" 1
# 21 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
extern digital_system ds;
extern implementation impl;
int verify_minimum_phase(void){
overflow_mode = 0;
fxp_t b_fxp[ds.b_size];
fxp_double_to_fxp_array(ds.b, b_fxp, ds.b_size);
double _b[ds.b_size];
fxp_to_double_array(_b, b_fxp, ds.b_size);
__DSVERIFIER_assert(check_stability(_b, ds.b_size));
# 85 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_minimum_phase.h"
return 0;
}
# 40 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h" 1
# 17 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_stability_closedloop_using_dslib(void){
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 48 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 68 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_stability_closedloop.h"
printf("Verifying stability for closedloop function\n");
__DSVERIFIER_assert(check_stability_closedloop(ans_den, ans_den_size, p_num, p_num_size, p_den, p_den_size));
return 0;
}
# 41 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
double nondet_double();
int verify_limit_cycle_closed_loop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 58 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
int i;
double y[X_SIZE_VALUE];
double x[X_SIZE_VALUE];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x[i] = nondet_constant_input;
y[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux[i] = nondet_constant_input;
}
double yaux[ans_den_size];
double y0[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux[Nw];
double w0[Nw];
# 105 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
for (i = 0; i < Nw; ++i) {
waux[i] = nondet_int();
__DSVERIFIER_assume(waux[i] >= impl.min && waux[i] <= impl.max);
w0[i] = waux[i];
}
double xk, temp;
double *aptr, *bptr, *xptr, *yptr, *wptr;
int j;
for(i=0; i<X_SIZE_VALUE; ++i){
# 134 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_limit_cycle_closedloop.h"
y[i] = double_transposed_direct_form_2(waux, x[i], ans_den, ans_num, ans_den_size, ans_num_size);
}
double_check_persistent_limit_cycle(y, X_SIZE_VALUE);
return 0;
}
# 42 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/dsverifier.h" 2
# 1 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h" 1
# 23 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
extern digital_system plant;
extern digital_system plant_cbmc;
extern digital_system controller;
int verify_error_closedloop(void){
overflow_mode = 3;
double * c_num = controller.b;
int c_num_size = controller.b_size;
double * c_den = controller.a;
int c_den_size = controller.a_size;
fxp_t c_num_fxp[controller.b_size];
fxp_double_to_fxp_array(c_num, c_num_fxp, controller.b_size);
fxp_t c_den_fxp[controller.a_size];
fxp_double_to_fxp_array(c_den, c_den_fxp, controller.a_size);
double c_num_qtz[controller.b_size];
fxp_to_double_array(c_num_qtz, c_num_fxp, controller.b_size);
double c_den_qtz[controller.a_size];
fxp_to_double_array(c_den_qtz, c_den_fxp, controller.a_size);
# 56 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
double * p_num = plant_cbmc.b;
int p_num_size = plant.b_size;
double * p_den = plant_cbmc.a;
int p_den_size = plant.a_size;
double ans_num_double[100];
double ans_num_qtz[100];
int ans_num_size = controller.b_size + plant.b_size - 1;
double ans_den_qtz[100];
double ans_den_double[100];
int ans_den_size = controller.a_size + plant.a_size - 1;
# 77 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
int i;
double y_qtz[X_SIZE_VALUE];
double y_double[X_SIZE_VALUE];
double x_qtz[X_SIZE_VALUE];
double x_double[X_SIZE_VALUE];
double xaux_qtz[ans_num_size];
double xaux_double[ans_num_size];
double xaux[ans_num_size];
double nondet_constant_input = nondet_double();
__DSVERIFIER_assume(nondet_constant_input >= impl.min && nondet_constant_input <= impl.max);
for (i = 0; i < X_SIZE_VALUE; ++i) {
x_qtz[i] = nondet_constant_input;
x_double[i] = nondet_constant_input;
y_qtz[i] = 0;
y_double[i] = 0;
}
for (i = 0; i < ans_num_size; ++i) {
xaux_qtz[i] = nondet_constant_input;
xaux_double[i] = nondet_constant_input;
}
double yaux_qtz[ans_den_size];
double yaux_double[ans_den_size];
double y0_qtz[ans_den_size];
double y0_double[ans_den_size];
int Nw = ans_den_size > ans_num_size ? ans_den_size : ans_num_size;
double waux_qtz[Nw];
double waux_double[Nw];
double w0_qtz[Nw];
double w0_double[Nw];
for (i = 0; i < Nw; ++i) {
waux_qtz[i] = 0;
waux_double[i] = 0;
}
for(i=0; i<X_SIZE_VALUE; ++i){
# 150 "/home/yashchopda/Desktop/dsverifier-v2.0.3-esbmc-v4.0-cbmc-5.6/bmc/engine/verify_error_closedloop.h"
y_qtz[i] = double_transposed_direct_form_2(waux_qtz, x_qtz[i], ans_den_qtz, ans_num_qtz, ans_den_size, ans_num_size);
y_double[i] = double_transposed_direct_form_2(waux_double, x_double[i], ans_den_double, ans_num_double, ans_den_size, ans_num_size);
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 ((10 == 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 (10 < 0)
{
printf("\n\n********************************************************************************************\n");
printf("* set a X_SIZE > 0 *\n");
printf("********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
else
{
X_SIZE_VALUE = 10;
}
}
if ((3 == 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 ((3 == 7) || (3 == 8) || (3 == 9) ||
(3 == 10) || (3 == 11) || (3 == 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-03-impl3.c" 2
digital_system ds = {
.b = { 110.0, -100.0 },
.b_size = 2,
.a = { 1.0, 0.0 },
.a_size = 2,
.sample_time = 0.02
};
implementation impl = {
.int_bits = 11,
.frac_bits = 5,
.max = 1.0,
.min = -1.0
};
|
the_stack_data/1113402.c
|
#include <stdio.h>
#include <stdlib.h>
int sorting_function(int *arr, int arr_len)
{
int Activities=0;
int i, j, k, tmp;
for(k=arr_len/2; k>0; k /= 2)
for (i=k; i< arr_len; i++)
{
tmp=arr[i];
for (j=i; j >= k; j -= k)
{
Activities++;
if (tmp < arr[j-k])
{
Activities++;
arr[j] = arr[j-k];
}
else break;
}
arr[j]=tmp;
}
return Activities;
}
int main()
{
int *a;
int i, n;
scanf("%d", &n);
a = (int*)malloc(sizeof(int) * n);
for (i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
sorting_function(a, n);
for (i=0; i<n-1; i++)
{
printf("%d ", a[i]);
}
printf("%d\n", a[i]);
return 0;
}
|
the_stack_data/85724.c
|
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
void test_random(const char* path)
{
int ret;
char buf[1024];
int fd = open(path, O_RDONLY);
assert(fd > 0);
ret = read(fd, buf, 1024);
assert(ret == 1024);
ret = lseek(fd, 10000L, 1);
assert(ret == 0);
ret = ftruncate(fd, 10);
assert(ret == -1);
struct stat statbuf;
ret = fstat(fd, &statbuf);
assert(ret == 0);
struct pollfd pset = {fd, POLLIN, 0};
ret = poll(&pset, 1, 1000);
assert(ret > 0);
assert((pset.revents & POLLIN) != 0);
ret = close(fd);
assert(ret == 0);
}
void test_zero()
{
int ret;
char buf[1024];
int fd = open("/dev/zero", O_RDWR);
assert(fd > 0);
ret = read(fd, buf, 1024);
assert(ret == 1024);
for (int i = 0; i < 1024; i++)
assert(buf[i] == '\0');
ret = write(fd, buf, 1024);
assert(ret == 1024);
ret = lseek(fd, 10000L, 1);
assert(ret == 0);
ret = ftruncate(fd, 10);
assert(ret == -1);
ret = close(fd);
assert(ret == 0);
}
void test_null()
{
int ret;
char buf[1024];
int fd = open("/dev/null", O_RDWR);
assert(fd > 0);
ret = read(fd, buf, 1024);
assert(ret == 0); // Check for EOF
ret = write(fd, buf, 1024);
assert(ret == 1024);
ret = lseek(fd, 10000L, 1);
assert(ret == 0);
ret = ftruncate(fd, 10);
assert(ret == -1);
ret = close(fd);
assert(ret == 0);
}
void test_fd_link()
{
{
char buf[1024];
int expected_len = strlen("/proc/self/fd");
int ret = readlink("/dev/fd", buf, 1024);
assert(ret == expected_len);
assert(strncmp(buf, "/proc/self/fd", expected_len) == 0);
}
{
struct dirent* fd_ent;
DIR* fd_dir = opendir("/dev/fd");
assert(fd_dir);
while ((fd_ent = readdir(fd_dir)) != NULL)
{
printf("%s\n", fd_ent->d_name);
}
closedir(fd_dir);
}
}
int test_dev_fd_on_dup()
{
char* file_path = "/hello_world";
int fd = open(file_path, O_RDWR | O_CREAT | O_TRUNC, 0666);
assert(fd >= 0);
{
// Generate dev_fd path
char* dev_fd_str = calloc(1, PATH_MAX);
assert(dev_fd_str != NULL);
assert(asprintf(&dev_fd_str, "/dev/fd/%d", fd) >= 0);
int dev_fd = open(dev_fd_str, O_WRONLY, 0666);
assert(dev_fd >= 0);
}
fd = dup2(fd, 63);
{
// Generate dev_fd path
char* dev_fd_str = calloc(1, PATH_MAX);
assert(dev_fd_str != NULL);
assert(asprintf(&dev_fd_str, "/dev/fd/%d", fd) >= 0);
int dev_fd = open(dev_fd_str, O_WRONLY, 0666);
assert(dev_fd >= 0);
}
}
int main(int argc, const char* argv[])
{
test_random("/dev/urandom");
test_random("/dev/random");
test_zero();
test_null();
test_fd_link();
test_dev_fd_on_dup();
printf("\n=== passed test (%s)\n", argv[0]);
return 0;
}
|
the_stack_data/404644.c
|
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#define TABLE_SIZE 100000
#define TABLE_SIZE 10
typedef struct entry_t {
char *key;
char *value;
struct entry_t *next;
} entry_t;
// This is nothing more than an array of pointers to entry_t
//typedef struct {
typedef struct ht_t {
entry_t **entries;
} ht_t;
unsigned int hash(const char *key) {
unsigned long int value = 0;
unsigned int i = 0;
unsigned int key_len = strlen(key);
// do several rounds of computation
for (; i < key_len; ++i) {
value = value*37 + key[i];
}
value = value % TABLE_SIZE;
return value;
}
ht_t *ht_create(void) {
// allocate table
ht_t *hashtable = malloc(sizeof(ht_t) * 1);
// allocate its entries
hashtable->entries = malloc(sizeof(entry_t*) * TABLE_SIZE);
//hashtable->entries = malloc(sizeof(entry_t) * TABLE_SIZE);
// set each entry to NULL
int i = 0;
for (; i < TABLE_SIZE; ++i)
hashtable->entries[i] = NULL;
return hashtable;
}
entry_t *ht_pair(const char *key, const char *value) {
// cater to the construction of a entry_t: key, value, next
//entry_t *entry = malloc(sizeof(entry_t));
entry_t *entry = malloc(sizeof(entry_t)*1);
//entry->key = malloc(sizeof(key) + 1);
//entry->value = malloc(sizeof(value) + 1);
// (!) Your 1st big bug here!
entry->key = malloc(strlen(key) + 1);
entry->value = malloc(strlen(value) + 1);
strcpy(entry->key, key);
strcpy(entry->value, value);
entry->next = NULL;
return entry;
}
void ht_set(ht_t *hashtable, const char *key, const char *value) {
unsigned int slot = hash(key);
entry_t *entry = hashtable->entries[slot];
if (entry == NULL) {
//entry = ht_pair(key, value);
// (?) why the above line is incorrect?
hashtable->entries[slot] = ht_pair(key, value);
return;
}
entry_t *prev;
// Walk thru the corresponding linked list
while (entry != NULL) {
if (strcmp(entry->key, key) == 0) {
// match found, replace value
free(entry->value);
entry->value = malloc(strlen(value) + 1); // 1 for '\0'
strcpy(entry->value, value);
return;
}
prev = entry;
//entry = entry->next;
entry = prev->next;
}
//entry = ht_pair(key, value);
prev->next = ht_pair(key, value);
}
char *ht_get(ht_t *hashtable, const char *key) {
// if key found, return the corresponding value
unsigned int slot = hash(key);
entry_t *entry = hashtable->entries[slot];
if (entry == NULL) {
return NULL;
}
// Walk thru the corresponding linked list
while (entry != NULL) {
if (strcmp(entry->key, key) == 0) {
// match found, return value
return entry->value;
}
entry = entry->next;
}
// no match found
return NULL;
}
void my_ht_dump(ht_t *hashtable) {
// for each slot we print one line
for (int i=0; i < TABLE_SIZE; ++i) {
entry_t *entry = hashtable->entries[i];
if (entry != NULL)
printf("slot[%4d]:", i);
while (entry != NULL) {
printf(" %s=%s", entry->key, entry->value);
entry = entry->next;
}
printf("\n");
}
}
void ht_dump(ht_t *hashtable) {
// for each slot we print one line
//entry_t *entry;
for (int i=0; i < TABLE_SIZE; ++i) {
//printf("i = %d", i);
entry_t *entry = hashtable->entries[i];
//entry = hashtable->entries[i];
if (entry == NULL) {
//printf("NULL\n");
continue;
}
printf("slot[%4d]:", i);
for (;;) {
printf(" %s=%s", entry->key, entry->value);
if (entry->next == NULL) {
break;
}
entry = entry->next;
}
printf("\n");
}
}
int main(int argc, char **argv) {
ht_t *ht = ht_create();
ht_set(ht, "str1", "If");
//ht_set(ht, "str2", "you");
//ht_set(ht, "str3", "can't");
//ht_set(ht, "str4", "convince");
//ht_set(ht, "str5", "them");
//ht_set(ht, "str6", ",");
//ht_set(ht, "str7", "confuse");
//ht_set(ht, "str8", "them");
//ht_set(ht, "str9", ".");
//ht_dump(ht);
unsigned int slot = hash("str1");
printf("slot = %d\n", slot);
entry_t *entry = ht->entries[slot];
//char *key = entry->key;
//char *value = entry->value;
//printf("slot[%d]: %s=%s\n", slot, key, value);
printf("slot[%d]: %s=%s\n", slot, entry->key, entry->value);
return 0;
}
|
the_stack_data/57949684.c
|
/*************************************************************************
> File Name: test-sta.c
> Author: weijie.yuan
> Mail: [email protected]
> Created Time: Mon 10 Oct 2016 03:30:48 PM CST
************************************************************************/
#include<stdio.h>
//#include"welcome.h"
int main(void)
{
welcome();
return 0;
}
|
the_stack_data/42524.c
|
/*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2017 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation nor the names of its contributors may be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
END_LEGAL */
#if !defined(__GNUC__)
extern void movdqa_test(char* p);
#endif
int main(int argc, char** argv)
{
char a[1000];
/* get in to the buffer and then align it by 16 */
char* b = (char*)(((unsigned long int)(a+16) >> 4) << 4);
/* generate one aligned move and one unaligned move. The alignchk tool
* should catch the latter one. */
#if defined(__GNUC__)
char* c = b + 1;
asm volatile("movdqa %%xmm0, %0" : "=m" (*b) : : "%xmm0");
asm volatile("movdqa %%xmm0, %0" : "=m" (*c) : : "%xmm0");
#else
movdqa_test(b);
#endif
}
|
the_stack_data/65262.c
|
/*xoay ma tran */
#include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int a[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
scanf("%d", &a[i][j]);
}
}
for(int i=n-1;i>=0;i--){
for(int j=0;j<n;j++){
printf("%d ",a[j][i]);
}
printf("\n");
}
}
|
the_stack_data/117327678.c
|
/* vi:set ts=4 sts=4 expandtab: */
#include <stdlib.h> /* exit, malloc */
#include <stdio.h> /* printf, perror */
#include <errno.h> /* perror */
#include <fcntl.h> /* open */
#include <unistd.h> /* stat */
#include <sys/types.h> /* open, lseek */
#include <sys/stat.h> /* open stat */
#include <sys/mman.h> /* mmap */
#include <locale.h> /* setlocale */
#include <string.h> /* memcpy */
int
main(int argc, char* argv[])
{
int fdi, fdo;
struct stat st;
void *src;
size_t size;
ssize_t offset;
if (argc != 3) {
printf("E: Need 2 filenames as arguments.\n");
return EXIT_FAILURE;
}
if ((fdi = open(argv[1], O_RDONLY)) < 0) {
perror("E: Can not open input file");
exit(EXIT_FAILURE);
}
if (stat(argv[1], &st) == -1) {
perror("E: Can not stat input file");
exit(EXIT_FAILURE);
}
size = st.st_size;
src = mmap(NULL, size, PROT_READ, MAP_SHARED, fdi, 0);
if (src == (void *) -1) {
perror("E: Can not map input file");
exit(EXIT_FAILURE);
}
if ((fdo = open(argv[2], O_CREAT | O_RDWR | O_TRUNC, 00666)) < 0) {
perror("E: Can not open output file");
exit(EXIT_FAILURE);
}
offset = write(fdo, src, size);
if (offset == (ssize_t) -1) {
perror("E: write() error");
exit(EXIT_FAILURE);
}
if (munmap(src, size)) {
perror("E: Can not unmap input file");
exit(EXIT_FAILURE);
}
if (close(fdi)) {
perror("E: Can not close input file");
exit(EXIT_FAILURE);
}
if (close(fdo)) {
perror("E: Can not close output file");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
|
the_stack_data/154251.c
|
int main () {
puts("Hello, world!");
return 0;
}
|
the_stack_data/43888341.c
|
#define _Noreturn
#undef __BLOCKS__
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#if defined(__GNUC__) || defined(__WATCOMC__) || defined(__WIN32__)
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif
#if defined(__unix__) || defined(__APPLE__)
#include <utime.h>
#endif
#if defined(__WIN32__)
#define WIN32_LEAN_AND_MEAN
#define UNICODE
#include <windows.h>
#include <io.h>
#else
#include <unistd.h>
#endif
typedef int bool;
typedef unsigned char byte;
typedef unsigned short uint16;
typedef unsigned int uint;
typedef unsigned int FileSize;
typedef long long int64;
typedef unsigned long long uint64;
#define false 0
#define true 1
#define null ((void *)0)
#define MAX_LOCATION 797
#define MAX_FILENAME 274
void __ecereNameSpace__ecere__com__eSystem_Delete(void * memory);
void * __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
void * __ecereNameSpace__ecere__com__eSystem_Renew(void * memory, unsigned int size);
void * __ecereNameSpace__ecere__com__eSystem_Renew0(void * memory, unsigned int size);
unsigned short * __ecereNameSpace__ecere__sys__UTF8toUTF16(const char * source, int * wordCount);
unsigned short * __ecereNameSpace__ecere__sys__UTF8toUTF16Buffer(const char * source, uint16 * dest, int max);
char * __ecereNameSpace__ecere__sys__UTF16toUTF8(const uint16 * source);
void __ecereNameSpace__ecere__sys__ChangeCh(char * string, char ch1, char ch2);
#if defined(__WIN32__) || defined(__WATCOMC__)
#include <direct.h>
__declspec(dllimport) BOOL WINAPI GetVolumePathName(LPCTSTR lpszFileName,LPTSTR lpszVolumePathName,DWORD cchBufferLength);
#else
#include <dirent.h>
#endif
typedef unsigned int FileAttribs;
typedef int64 SecSince1970;
typedef SecSince1970 TimeStamp;
typedef enum
{
FOM_read = 1,
FOM_write,
FOM_append,
FOM_readWrite,
FOM_writeRead,
FOM_appendRead
} FileOpenMode;
typedef enum
{
unlocked = 0, // LOCK_UN _SH_DENYNO
shared = 1, // LOCK_SH _SH_DENYWR
exclusive = 2 // LOCK_EX _SH_DENYRW
} FileLock;
#define isFile 0x0001
#define isArchive 0x0002
#define isHidden 0x0004
#define isReadOnly 0x0008
#define isSystem 0x0010
#define isTemporary 0x0020
#define isDirectory 0x0040
#define isDrive 0x0080
#define isCDROM 0x0100
#define isRemote 0x0200
#define isRemovable 0x0400
#define isServer 0x0800
#define isShare 0x1000
typedef struct
{
FileAttribs attribs;
uint64 size;
SecSince1970 accessed;
SecSince1970 modified;
SecSince1970 created;
} FileStats;
char * __ecereNameSpace__ecere__sys__GetLastDirectory(const char * string, char * output);
bool __ecereNameSpace__ecere__sys__SplitArchivePath(const char * fileName, char * archiveName, char ** archiveFile);
#if defined(__WIN32__) && !defined(ECERE_BOOTSTRAP)
void __ecereMethod___ecereNameSpace__ecere__sys__EARFileSystem_FixCase(const char * archive, char * name);
static BOOL CALLBACK EnumThreadWindowsProc(HWND hwnd, LPARAM lParam)
{
DWORD pid;
if(IsWindowVisible(hwnd) && GetWindowThreadProcessId(hwnd, &pid) && pid == GetCurrentProcessId())
{
*(void **)lParam = hwnd;
return FALSE;
}
return TRUE;
}
bool WinReviveNetworkResource(uint16 * _wfileName)
{
bool result = false;
HWND windowHandle = null;
NETRESOURCE nr = { 0 };
nr.dwType = RESOURCETYPE_DISK;
nr.lpRemoteName = _wfileName;
if(_wfileName[0] != '\\' || _wfileName[1] == '\\')
{
uint16 volumePathName[MAX_LOCATION];
if(GetVolumePathName(_wfileName, volumePathName, MAX_LOCATION))
{
uint16 remoteName[MAX_LOCATION];
DWORD size = MAX_LOCATION;
volumePathName[wcslen(volumePathName)-1] = 0;
if(WNetGetConnection(volumePathName, remoteName, &size) == ERROR_CONNECTION_UNAVAIL)
{
nr.lpRemoteName = remoteName;
nr.lpLocalName = volumePathName;
}
else
return false;
}
else
return false;
}
EnumThreadWindows(GetCurrentThreadId(), EnumThreadWindowsProc, (LPARAM)&windowHandle);
if(!windowHandle)
{
EnumWindows(EnumThreadWindowsProc, (LPARAM)&windowHandle);
}
if(WNetAddConnection3(windowHandle, &nr, null, null, CONNECT_INTERACTIVE|CONNECT_PROMPT) == NO_ERROR)
result = true;
return result;
}
TimeStamp Win32FileTimeToTimeStamp(FILETIME * fileTime);
void TimeStampToWin32FileTime(TimeStamp t, FILETIME * fileTime);
#endif
uint FILE_GetSize(FILE * input)
{
if(input)
{
struct stat s;
int fd = fileno(input);
if(!fstat(fd, &s))
return s.st_size;
}
return 0;
}
bool FILE_Lock(FILE * input, FILE * output, FileLock type, uint64 start, uint64 length, bool wait)
{
if(!output && !input)
return true;
else
{
#if defined(__WIN32__)
int handle = fileno(output ? output : input);
HANDLE hFile = (HANDLE)_get_osfhandle(handle);
OVERLAPPED overlapped = { 0 };
overlapped.Offset = (uint)(start & 0xFFFFFFFF);
overlapped.OffsetHigh = (uint)((start & 0xFFFFFFFF00000000LL) >> 32);
if(type == unlocked)
return UnlockFileEx(hFile, 0,
(uint)(length ? (length & 0xFFFFFFFF) : 0xFFFFFFFF),
(uint)(length ? ((length & 0xFFFFFFFF00000000LL) >> 32) : 0xFFFFFFFF),
&overlapped) != 0;
else
return LockFileEx(hFile, ((type == exclusive) ? LOCKFILE_EXCLUSIVE_LOCK : 0) | (wait ? 0 : LOCKFILE_FAIL_IMMEDIATELY), 0,
(uint)(length ? (length & 0xFFFFFFFF) : 0xFFFFFFFF),
(uint)(length ? ((length & 0xFFFFFFFF00000000LL) >> 32) : 0xFFFFFFFF),
&overlapped) != 0;
#else
struct flock fl;
int fd;
fl.l_type = (type == unlocked) ? F_UNLCK : ((type == exclusive) ? F_WRLCK : F_RDLCK);
fl.l_whence = SEEK_SET;
fl.l_start = start;
fl.l_len = length;
fl.l_pid = getpid();
fd = fileno(output ? output : input);
return fcntl(fd, wait ? F_SETLKW : F_SETLK, &fl) != -1;
#endif
}
}
void FILE_set_buffered(FILE * input, FILE * output, bool value)
{
#if !defined(__WIN32__) && !defined(ECERE_BOOTSTRAP)
if(input)
setvbuf(input, null, value ? _IOFBF : _IONBF, 0);
if(output && output != input)
setvbuf(output, null, value ? _IOFBF : _IONBF, 0);
#endif
}
FileAttribs FILE_FileExists(const char * fileName)
{
#ifdef __WIN32__
FileAttribs result = 0;
uint attribute = 0; // Initialization isn't actually required here but GCC complains about it.
uint16 * _wfileName = __ecereNameSpace__ecere__sys__UTF8toUTF16(fileName, null);
if(!strcmp(fileName, "/") || !strcmp(fileName, "\\\\"))
{
result = (FileAttribs)(isDirectory);
}
else
attribute = GetFileAttributes(_wfileName);
#if !defined(ECERE_BOOTSTRAP)
if(!result && attribute == 0xFFFFFFFF)
{
if(WinReviveNetworkResource(_wfileName))
attribute = GetFileAttributes(_wfileName);
if(attribute == 0xFFFFFFFF)
{
if(fileName[0] == '\\' && fileName[1] == '\\')
{
NETRESOURCE nr = { 0 };
NETRESOURCE * buffer = null;
unsigned int size = sizeof(NETRESOURCE);
uint16 * dir;
nr.dwScope = RESOURCE_GLOBALNET;
nr.dwType = RESOURCETYPE_DISK;
nr.lpRemoteName = _wfileName;
nr.lpProvider = L"Microsoft Windows Network";
buffer = (NETRESOURCE *)__ecereNameSpace__ecere__com__eSystem_New0(size);
while(true)
{
int returnCode = WNetGetResourceInformationW(&nr, buffer, (DWORD *)&size, &dir);
if(returnCode == WN_MORE_DATA)
buffer = (NETRESOURCE *)__ecereNameSpace__ecere__com__eSystem_Renew0(buffer, size);
else
{
if(returnCode == WN_SUCCESS)
{
if(!_wcsicmp(buffer->lpRemoteName, _wfileName))
result = (FileAttribs)( isDirectory | isServer );
}
break;
}
}
__ecereNameSpace__ecere__com__eSystem_Delete(buffer);
}
}
}
#endif
if(!result && attribute != 0xFFFFFFFF)
{
if(attribute & FILE_ATTRIBUTE_DIRECTORY)
result = (FileAttribs)( isDirectory );
else
result = (FileAttribs)(isFile);
}
__ecereNameSpace__ecere__com__eSystem_Delete(_wfileName);
return result;
#else
if(!access(fileName, F_OK))
{
struct stat s;
stat(fileName, &s);
return S_ISDIR(s.st_mode) ? (FileAttribs) ( isDirectory ) : (FileAttribs) ( isFile );
}
else
{
// TODO: Check this
return (FileAttribs) 0;
}
#endif
}
bool FILE_FileGetSize(const char * fileName, FileSize * size)
{
bool result = false;
#if defined(__WIN32__)
struct _stat s;
uint16 * _wfileName = __ecereNameSpace__ecere__sys__UTF8toUTF16(fileName, null);
if(!_wstat(_wfileName, &s))
#else
struct stat s;
if(!stat(fileName, &s))
#endif
{
*size = s.st_size;
result = true;
}
#if defined(__WIN32__)
__ecereNameSpace__ecere__com__eSystem_Delete(_wfileName);
#endif
return result;
}
bool FILE_FileGetStats(const char * fileName, FileStats * stats)
{
bool result = false;
#if defined(__WIN32__)
uint16 * _wfileName = __ecereNameSpace__ecere__sys__UTF8toUTF16(fileName, null);
struct _stat s;
if(!_wstat(_wfileName, &s))
#else
struct stat s;
if(!stat(fileName, &s))
#endif
{
stats->size = s.st_size;
stats->attribs = (s.st_mode & S_IFDIR) ? ((FileAttribs) (isDirectory)): ((FileAttribs) 0);
#if defined(__WIN32__)
{
HANDLE hFile = CreateFile(_wfileName, 0, FILE_SHARE_READ, null,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, null);
if(hFile != INVALID_HANDLE_VALUE)
{
#if defined(ECERE_BOOTSTRAP)
stats->created = 0;
stats->accessed = 0;
stats->modified = 0;
#else
FILETIME c, a, m;
GetFileTime(hFile, &c, &a, &m);
stats->created = Win32FileTimeToTimeStamp(&c);
stats->accessed = Win32FileTimeToTimeStamp(&a);
stats->modified = Win32FileTimeToTimeStamp(&m);
#endif
CloseHandle(hFile);
}
}
#else
stats->accessed = s.st_atime;
// UNIX st_ctime is 'status change' time, not creation time
// Marking created as 0, as ctime changes cause unreproducible builds
stats->created = 0;
stats->modified = s.st_mtime;
#endif
/*
stats->attribs.isArchive = (winFile.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) ? true : false;
stats->attribs.isHidden = (winFile.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? true : false;
stats->attribs.isReadOnly = (winFile.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? true : false;
stats->attribs.isSystem = (winFile.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) ? true : false;
stats->attribs.isTemporary = (winFile.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) ? true : false;
stats->attribs.isDirectory = (winFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? true : false;
*/
result = true;
}
#if defined(__WIN32__)
__ecereNameSpace__ecere__com__eSystem_Delete(_wfileName);
#endif
return result;
}
void FILE_FileFixCase(char * file)
{
#if defined(__WIN32__)
#ifndef ECERE_BOOTSTRAP
char archive[MAX_LOCATION], * name;
if(__ecereNameSpace__ecere__sys__SplitArchivePath(file, archive, &name))
{
char fileName[MAX_LOCATION];
strcpy(fileName, name);
__ecereMethod___ecereNameSpace__ecere__sys__EARFileSystem_FixCase(archive, fileName);
if(archive[0] != ':')
FILE_FileFixCase(archive);
sprintf(file, "<%s>%s", archive, fileName);
}
else
#endif
{
int c = 0;
char parent[MAX_LOCATION] = "";
// Skip network protocols
if(strstr(file, "http://") == file || strstr(file, "https://") == file || strstr(file, "wfs://") == file || strstr(file, "wfs3://") == file || strstr(file, "wfs3s://") == file) return;
// Copy drive letter to new path
if(file[0] && file[1] == ':')
{
parent[0] = (char)toupper(file[0]);
parent[1] = ':';
parent[2] = '\0';
c = 2;
}
// Copy Microsoft Network string to new path
else if(file[0] == '\\' && file[1] == '\\')
{
parent[0] = parent[1] = '\\';
parent[2] = '\0';
c = 2;
}
else if(file[0] == '/' && file[1] == '/')
{
parent[0] = parent[1] = '\\';
parent[2] = '\0';
c = 2;
}
// Copy Entire Computer to new path
else if(file[0] == '/' && !file[1])
{
parent[0] = '/';
parent[1] = '\0';
c = 1;
}
while(file[c])
{
// Get next directory
char directory[MAX_FILENAME];
int len = 0;
char ch;
for(;(ch = file[c]) && (ch == '/' || ch == '\\'); c++);
for(;(ch = file[c]) && (ch != '/' && ch != '\\'); c++)
{
if(len < MAX_FILENAME)
directory[len++] = ch;
}
directory[len] = '\0';
// Normal file
if(parent[0] != '\\' || parent[1] != '\\' || strstr(parent+2, "\\"))
{
if(strcmp(directory, "..") && strcmp(directory, "."))
{
WIN32_FIND_DATA winFile;
uint16 dir[MAX_PATH];
HANDLE handle;
__ecereNameSpace__ecere__sys__UTF8toUTF16Buffer(parent, dir, MAX_PATH);
if(dir[0]) wcscat(dir, L"\\");
{
uint16 * _wdirectory = __ecereNameSpace__ecere__sys__UTF8toUTF16(directory, null);
wcscat(dir, _wdirectory);
__ecereNameSpace__ecere__com__eSystem_Delete(_wdirectory);
}
handle = FindFirstFile(dir, &winFile);
if(parent[0] || (file[0] == '\\' || file[0] == '/'))
strcat(parent, "\\");
if(handle != INVALID_HANDLE_VALUE)
{
char * utf8 = __ecereNameSpace__ecere__sys__UTF16toUTF8(winFile.cFileName);
strcat(parent, utf8);
__ecereNameSpace__ecere__com__eSystem_Delete(utf8);
FindClose(handle);
}
else
strcat(parent, directory);
}
else
{
if(parent[0] || (file[0] == '\\' || file[0] == '/'))
strcat(parent, "\\");
strcat(parent, directory);
}
}
#ifndef ECERE_BOOTSTRAP
else
{
// Network server
if(parent[2])
{
HANDLE handle = 0;
DWORD count = 0xFFFFFFFF;
DWORD size = 512 * sizeof(NETRESOURCE);
NETRESOURCE * buffer = (NETRESOURCE *)__ecereNameSpace__ecere__com__eSystem_New0(size);
NETRESOURCE nr = {0};
int c;
nr.dwScope = RESOURCE_GLOBALNET;
nr.dwType = RESOURCETYPE_DISK;
// UNICODE FIX
nr.lpRemoteName = __ecereNameSpace__ecere__sys__UTF8toUTF16(parent, null);
nr.lpProvider = L"Microsoft Windows Network";
// Server
WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_DISK, 0, &nr, &handle);
if(handle)
{
while(true)
{
int returnCode = WNetEnumResource(handle, &count, buffer, &size);
if(returnCode != ERROR_MORE_DATA)
break;
count = 0xFFFFFFFF;
buffer = (NETRESOURCE *)__ecereNameSpace__ecere__com__eSystem_Renew0(buffer, size);
}
WNetCloseEnum(handle);
}
else
count = 0;
for(c = 0; c<count; c++)
{
char shareName[MAX_FILENAME];
char * remoteName = __ecereNameSpace__ecere__sys__UTF16toUTF8(buffer[c].lpRemoteName);
__ecereNameSpace__ecere__sys__GetLastDirectory(remoteName, shareName);
__ecereNameSpace__ecere__com__eSystem_Delete(remoteName);
if(!strcmpi(directory, shareName))
{
strcpy(directory, shareName);
break;
}
}
if(c == count)
strlwr(directory);
__ecereNameSpace__ecere__com__eSystem_Delete(nr.lpRemoteName);
__ecereNameSpace__ecere__com__eSystem_Delete(buffer);
strcat(parent, "\\");
strcat(parent, directory);
}
// Network share
else
{
strlwr(directory);
directory[0] = (char)toupper(directory[0]);
strcat(parent, directory);
}
}
#endif
}
strcpy(file, parent);
}
#else
__ecereNameSpace__ecere__sys__ChangeCh(file, '\\', '/');
#endif
}
void FILE_FileOpen(const char * fileName, FileOpenMode mode, FILE ** input, FILE **output)
{
#if defined(__WIN32__) && !defined(ECERE_BOOTSTRAP)
uint16 * _wfileName = __ecereNameSpace__ecere__sys__UTF8toUTF16(fileName, null);
/*
struct WinFile { HANDLE handle; } file;
file.handle = CreateFile(_wfileName,
((mode == FOM_read || mode == FOM_readWrite || mode == FOM_writeRead || mode == FOM_appendRead) ? GENERIC_READ : 0) |
((mode == FOM_write || mode == FOM_append || mode == FOM_readWrite || mode == FOM_writeRead || mode == FOM_appendRead) ? GENERIC_WRITE: 0),
FILE_SHARE_READ|FILE_SHARE_WRITE,
null,
(mode == FOM_write || mode == FOM_writeRead) ? TRUNCATE_EXISTING : ((mode == FOM_read || mode == FOM_readWrite) ? OPEN_EXISTING : OPEN_ALWAYS), 0, null);
if(file.handle)
{
int flags;
int handle = -1;
switch(mode)
{
case FOM_read: handle = _open_osfhandle((intptr_t)file.handle, _O_RDONLY); break;
case FOM_write: handle = _open_osfhandle((intptr_t)file.handle, _O_WRONLY | _O_CREAT | _O_TRUNC); break;
case FOM_append: handle = _open_osfhandle((intptr_t)file.handle, _O_WRONLY | _O_CREAT | _O_APPEND); break;
case FOM_readWrite: handle = _open_osfhandle((intptr_t)file.handle, _O_RDWR); break;
case FOM_writeRead: handle = _open_osfhandle((intptr_t)file.handle, _O_RDWR | _O_CREAT | _O_TRUNC); break;
case FOM_appendRead: handle = _open_osfhandle((intptr_t)file.handle, _O_RDWR | _O_APPEND | _O_CREAT); break;
}
if(handle != -1)
{
switch(mode)
{
case FOM_read: *input = _fdopen(handle, "rb"); break;
case FOM_write: *output = _fdopen(handle, "wb"); break;
case FOM_append: *output = _fdopen(handle, "ab"); break;
case FOM_readWrite: *input = *output = _fdopen(handle, "r+b"); break;
case FOM_writeRead: *input = *output = _fdopen(handle, "w+b"); break;
case FOM_appendRead: *input = *output = _fdopen(handle, "a+b"); break;
}
}
}
*/
switch(mode)
{
case FOM_read: *input = _wfopen(_wfileName, L"rb"); break;
case FOM_write: *output = _wfopen(_wfileName, L"wb"); break;
case FOM_append: *output = _wfopen(_wfileName, L"ab"); break;
case FOM_readWrite: *input = *output = _wfopen(_wfileName, L"r+b"); break;
case FOM_writeRead: *input = *output = _wfopen(_wfileName, L"w+b"); break;
case FOM_appendRead: *input = *output = _wfopen(_wfileName, L"a+b"); break;
}
if(!mode && WinReviveNetworkResource(_wfileName))
{
switch(mode)
{
case FOM_read: *input = _wfopen(_wfileName, L"rb"); break;
case FOM_write: *output = _wfopen(_wfileName, L"wb"); break;
case FOM_append: *output = _wfopen(_wfileName, L"ab"); break;
case FOM_readWrite: *input = *output = _wfopen(_wfileName, L"r+b"); break;
case FOM_writeRead: *input = *output = _wfopen(_wfileName, L"w+b"); break;
case FOM_appendRead: *input = *output = _wfopen(_wfileName, L"a+b"); break;
}
}
__ecereNameSpace__ecere__com__eSystem_Delete(_wfileName);
#else
switch(mode)
{
case FOM_read: *input = fopen(fileName, "rb"); break;
case FOM_write: *output = fopen(fileName, "wb"); break;
case FOM_append: *output = fopen(fileName, "ab"); break;
case FOM_readWrite: *input = *output = fopen(fileName, "r+b"); break;
case FOM_writeRead: *input = *output = fopen(fileName, "w+b"); break;
case FOM_appendRead: *input = *output = fopen(fileName, "a+b"); break;
}
#endif
}
int FILE_Seek64(FILE * f, int64 offset, int origin)
{
#if defined(__WIN32__)
#if 1 //!defined(_WIN64) // _fseeki64 is not working well with SEEK_CUR?
if(origin == SEEK_CUR) // fseek with -1, SEEK_CUR failing in 32-bit with MinGW-w64 ?
return fseek(f, offset, origin);
#endif
return _fseeki64(f, offset, origin);
#else
return fseek(f, offset, origin);
#endif
}
|
the_stack_data/949170.c
|
// UDP client program
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/socket.h>
#include <sys/types.h>
#define PORT 5000
#define MAXLINE 1024
int main()
{
int sockfd;
char buffer[MAXLINE];
char* message = "Hello Server";
struct sockaddr_in servaddr;
int n, len;
// Creating socket file descriptor
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
printf("socket creation failed");
exit(0);
}
memset(&servaddr, 0, sizeof(servaddr));
// Filling server information
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
printf("Test\n");
// send hello message to server
sendto(sockfd, (const char*)message, strlen(message),
0, (const struct sockaddr*)&servaddr,
sizeof(servaddr));
// receive server's response
//printf("Message from server: ");
//n = recvfrom(sockfd, (char*)buffer, MAXLINE,
// 0, (struct sockaddr*)&servaddr,
// &len);
// puts(buffer);
close(sockfd);
return 0;
}
|
the_stack_data/840105.c
|
/*
How to compile:
$ gcc -Wall -fstack-protector-strong -o bn_runtime_error bn_runtime_error.c -lcrypto
Compile with downloaded openssl under ../../openssl/
$ gcc -Wall -fstack-protector-strong -o bn_runtime_error bn_runtime_error.c -I../../openssl/include -L../../openssl -lcrypto -Wl,-rpath=../../openssl
Run:
$ ./bn_runtime_error
*/
/* https://github.com/KazKobara/openssl-migration */
#include <stdint.h>
#include <openssl/dh.h>
#include <openssl/bn.h>
#include <openssl/err.h>
#define RAND_BIT_LEN 160
/* 160-bit prime 0xffffffffffffffffffffffffffffffffffffffd1 */
/* Choose one to test */
#define RAND_RANGE_DEC "1461501637330902918203684832716283019655932542929"
//#define RAND_RANGE_DEC "-1461501637330902918203684832716283019655932542929"
//#define RAND_RANGE_DEC "0"
/**
* @brief Test of BN pointer initialization for BN_priv_rand_range().
*
* @param max_dec_str: decimal string of maximum random number > 0.
* @return int32_t: 0 on success, 1 on error.
*/
static int32_t test_rand_range(const char * const max_dec_str){
int32_t ret = 1, rc;
//BIGNUM * bn_range_p; // No warning, but causes `Segmentation fault`.
BIGNUM * bn_range_p = NULL; // No warning, no error, recommended!!
/*BIGNUM * bn_range_p = BN_new(); // No warning, no runtime error.
if (NULL==bn_range_p){
(void)fprintf(stderr, "BN_new(): %s.\n",
ERR_error_string(ERR_get_error(), NULL));
goto Done;
}
*/
/* Errors and/or warnings occur depending the initialization of bn_rnd_p,
on at least on the following environment:
- gcc (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0
- OpenSSL 1.1.1
*/
//BIGNUM * const bn_rnd_p = NULL; // No warning, but causes the following error
/* "error:0308A071:bignum routines:bnrand_range:too many iterations." */
//BIGNUM * const bn_rnd_p; // Compiler warns but no error.
//BIGNUM * const
BIGNUM * bn_rnd_p = NULL;
/*BIGNUM * bn_rnd_p = BN_secure_new(); // No warning, no error, recommended!!
if (NULL==bn_rnd_p){
(void)fprintf(stderr, "BN_secure_new(): %s.\n",
ERR_error_string(ERR_get_error(), NULL));
goto Done;
}
*/
(void)fprintf(stdout,"--- Example of BN_priv_rand_range() ---\n");
printf("Before BN_dec2bn(&bn_range_p): &bn_range_p =%p, bn_range_p =%p\n", &bn_range_p, bn_range_p);
if (0==BN_dec2bn(&bn_range_p, max_dec_str)) {
ERR_print_errors_fp(stderr);
goto Done;
}
printf("After BN_dec2bn(&bn_range_p): &bn_range_p =%p, bn_range_p =%p\n", &bn_range_p, bn_range_p);
// 0 <= rnd < bn_range_p
rc=BN_priv_rand_range(bn_rnd_p, bn_range_p);
if (1!=rc){
ERR_print_errors_fp(stderr);
goto Done;
}
(void)fprintf(stdout, "bn_range_p: %s\n", BN_bn2dec(bn_range_p));
(void)fprintf(stdout, "bn_rnd_p : %s\n", BN_bn2dec(bn_rnd_p));
(void)fprintf(stdout, "\n");
ret = 0;
Done:
BN_free(bn_range_p);
BN_clear_free(bn_rnd_p);
//BN_clear_free(bn_rnd_p); // To test double BN_*free()
return ret;
}
/**
* @brief Test of BN pointer initialization for BN_priv_rand_range().
*
* @param test_case:
* @param rand_bit_len: Ransom bit length to generate.
* @return int32_t: 0 on success, 1 on error.
*/
#if defined(TEST_CASE)
static int32_t test_rand(uint8_t test_case, const int32_t rand_bit_len){
#else
static int32_t test_rand(const int32_t rand_bit_len){
#endif
int32_t ret = 1, rc;
#if defined(TEST_CASE)
(void)fprintf(stdout,"--- Test case %u for BN_priv_rand(,bits=%d,,) ---\n", test_case, rand_bit_len);
#else
(void)fprintf(stdout,"--- Test for BN_priv_rand(,bits=%d,,) ---\n", rand_bit_len);
#endif
// if (0 >= rand_bit_len) { return ret; }
/* Choose One */
//BIGNUM * const r = NULL;
//BIGNUM * const r;
BIGNUM * const r = BN_new();
if (NULL==r){
ERR_print_errors_fp(stderr);
goto Done;
}
/* Choose One */
//BIGNUM * const bn_one;
//BIGNUM * const bn_one = NULL;
BIGNUM * const bn_one = BN_new();
if (NULL==bn_one){
ERR_print_errors_fp(stderr);
goto Done;
}
/* Choose One */
//BIGNUM * bn_rnd_p; // warned and causes segfault.
BIGNUM * bn_rnd_p = NULL; // warned and causes segfault.
//bn_rnd_p = BN_new();
bn_rnd_p = BN_secure_new();
if (NULL==bn_rnd_p){
ERR_print_errors_fp(stderr);
goto Done;
}
#if defined(TEST_CASE)
switch(test_case){
case 0:
bn_rnd_p = BN_secure_new(); // OK
break;
case 1:
bn_rnd_p = NULL; // not warned but causes segfault.
break;
default:
// Uninitialized: warned and causes segfault.
break;
}
#endif
rc=BN_priv_rand(bn_rnd_p, rand_bit_len, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY);
if (1!=rc){
ERR_print_errors_fp(stderr);
goto Done;
}
/* r = (1<<rand_bit_len) - 1 */
if(1!=BN_one(bn_one)) { goto Done; }
if(1!=BN_lshift(r, bn_one, rand_bit_len)) { goto Done; }
if(1!=BN_sub(r, r, bn_one)) { goto Done; }
/* To test */
//if(1!=BN_sub(r, bn_one, bn_one)) { goto Done; }
//if(1!=BN_add(r, bn_one, bn_one)) { goto Done; }
(void)fprintf(stdout, "max : %s\n", BN_bn2dec(r));
(void)fprintf(stdout, "bn_rnd_p: %s\n", BN_bn2dec(bn_rnd_p));
(void)fprintf(stdout, "\n");
ret = 0;
Done:
BN_free(bn_one); //If NULL, nothing is done.
BN_free(r); //If NULL, nothing is done.
BN_clear_free(bn_rnd_p); //If NULL, nothing is done.
return ret;
}
int32_t main(void){
int32_t num_of_errors = 0, rc;
(void)fprintf(stdout, "\n%s\n\n", OpenSSL_version(OPENSSL_VERSION));
rc=test_rand_range(RAND_RANGE_DEC);
if(0!=rc) { num_of_errors++; }
(void)fprintf(stdout, "test_rand_range() ...... %s\n\n", 0==rc?"OK":"NG");
#if defined(TEST_CASE)
for (int32_t i = 1; i >= -1 ; i--)
{
rc=test_rand(0, RAND_BIT_LEN*i);
if(0!=rc) { num_of_errors++; }
(void)fprintf(stdout, "test_rand() ...... %s\n\n", 0==rc?"OK":"NG");
}
// test_case >= 1 causes segfault.
uint8_t test_case_list[] = {0, 1, 2};
for (uint8_t i = 0; i < sizeof(test_case_list); i++)
{
rc=test_rand(test_case_list[i], RAND_BIT_LEN);
if(0!=rc) { num_of_errors++; }
(void)fprintf(stdout, "test_rand() ...... %s\n\n", 0==rc?"OK":"NG");
}
#else
rc=test_rand(RAND_BIT_LEN);
if(0!=rc) { num_of_errors++; }
(void)fprintf(stdout, "test_rand() ...... %s\n\n", 0==rc?"OK":"NG");
#endif
return num_of_errors;
}
|
the_stack_data/165765312.c
|
#include<stdio.h>
int main()
{
int n1=0,n2=1,n3,i,number;
printf("Enter the number of elements:");
scanf("%d",&number);
printf("\n%d %d",n1,n2); //printing 0 and 1
for(i=2;i<number;++i) //loop starts from 2 because 0 and 1 are already printed
{
n3=n1+n2;
printf(" %d",n3);
n1=n2;
n2=n3;
}
return 0;
}
|
the_stack_data/121902.c
|
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
char buffer[BUFSIZ]; // Buffer de transferencia
int tam; // N�mero de bytes realmente usados en el buffer
int main(int argc, char *argv[]) {
int fd_origen, fd_destino; // Descriptores de fichero
int nbytes;
// Comprobaci�n de que el n�mero de argumentos de la l�nea de orden es correcto
if ((argc < 3) || (argc > 4)) {
fprintf(stderr, "Forma de uso: %s origen destino [TBLOQUE]\n", argv[0]);
exit(-1);
}
// Seleccion del tama�o de bloque unidad de transferencia
tam = (argc == 4) ? atoi(argv[3]) : sizeof(buffer);
// Comprobacion: el tama�o del bloque no debe ser negativo
// ni superar el valor maximo reservado para 'buffer'
if ((tam <= 0) || (tam > sizeof(buffer)))
fprintf(stderr, "%s debe estar entre 1 y %ld\n", argv[3], (long int)sizeof(buffer)), exit(-1);
// Apertura del fichero_fuente, solo para lectura
if (!strcmp(argv[1], "-")) // Si el primer argumento es "-", usar STDIN
fd_origen = STDIN_FILENO;
else if ((fd_origen = open(argv[1], O_RDONLY)) == -1)
perror("open origen"), exit(-1);
// Apertura del fichero_destino, solo para escritura.
// Si ya existe, lo trunca; si no, lo crea con permisos rw-rw-rw-
if (!strcmp(argv[2], "-")) // Si el segundo argumento es "-", usar STDOUT
fd_destino = STDOUT_FILENO;
else if ((fd_destino = open(argv[2], O_WRONLY|O_TRUNC|O_CREAT, 0666)) == -1)
perror("open destino"), exit(-1);
printf("Comienzo de COPIA\n");
// ordena leer 'tam' bytes; lee efectivamente 'nbytes'
while ((nbytes = read(fd_origen, buffer, tam)) > 0)
// ordena escribir 'nbytes'; deber�a escribirlos todos
if (write(fd_destino, buffer, nbytes) < 0)
perror("write destino"), exit(-1);
printf("Fin de COPIA\n");
// si el n�mero de bytes leidos es 0, esto indica FIN DE FICHERO
if (nbytes != 0) perror("read origen"), exit(-1);
// Cierra los ficheros abiertos.
// Como est� al final del programa no es estrictamente necesario
// la llamada exit() los cierra de cualquier modo
close(fd_origen);
close(fd_destino);
exit(0);
}
|
the_stack_data/40579.c
|
#include <stdio.h>
#include <stdlib.h>
// 过不了，难道除了树状数组+二分查找
// 就没有其他方法能够全部通过这道题？
#define MAXN 100001
int stack[MAXN], count[MAXN];
int getnth(int nth)
{
int i, cnt = 0;
for (i = 0; i < MAXN; ++i) {
cnt += count[i];
if (cnt >= nth)
return i;
}
}
int main()
{
int n, num, top = 0;
char command[16];
#ifdef __TINYC__
freopen("1057.txt", "w+", stdout);
#endif
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", command);
switch (command[1]) {
case 'e':
case 'o':
if (top > 0) {
if (command[1] == 'o') {
num = stack[--top];
count[num]--;
}
else
num = getnth((top + 1) / 2);
printf("%d\n", num);
}
else
printf("Invalid\n");
break;
case 'u':
scanf("%d", &num);
stack[top++] = num;
count[num]++;
break;
}
}
return 0;
}
|
the_stack_data/227621.c
|
#include <stdio.h>
#define e_numero 45157
#define s_numero e_numero*10
int main()
{
printf("hello world");
printf("\nhello world again");
printf("\nAluno: %s \t nota: %f", "Jooj" , 7.69);
printf ("\nnumero decimal: %d\t" , s_numero);
return 0;
}
|
the_stack_data/82950845.c
|
/*у меня почему-то этот тест проходит*/
#include <stdio.h>
int wcount (char *str){
int i, count=0;
if (i = strnlen (str, sizeof(char*))) return 1;
for (i; i>0; i--){
while ( str[i] != 32 ){
i--;
break;
}
if (i==0) return 0;
while ( str[i] == 32 ) i--;
count++;
}
return count;
}
main(){
char s[100];
gets (s);
printf ("%d\n", wcount (s));
return 0;
}
|
the_stack_data/149340.c
|
// 5! = 5 x 4 x 3 x 2 x 1 = 120
#include <stdio.h>
int main(int argc, char const *argv[])
{
int input;
printf("Masukkan sebuah bilangan bulat?\n");
scanf("%d", &input);
printf("%d! =", input);
int res = 1;
for (int i = input; i > 0; i--)
{
printf(" %d ", i);
res = res * i;
if (i != 1)
{
printf("x");
}
}
printf("= %d\n", res);
return 0;
}
|
the_stack_data/126704214.c
|
#include <stdio.h>
#include <stdlib.h>
/* 1.6 Dadas as medidas de uma sala em metros(comprimento e largura), bem como o preço do metro quadrado de carpete, informe
o custo total para forrar o piso da sala */
int main (void){
float c, l, p, t;
printf("Digite o Comprimento: ");
scanf("%f", &c);
printf("Digite a Largura: ");
scanf("%f", &l);
printf("Digite o preco: ");
scanf("%f", &p);
t = c * l * p;
printf("O custo do carpete: %.2f\n", t);
return 0;
}
/* 1.6 Dados um valor em real e a cotação do dólar, converta esse valor em dólares
int main (void){
return 0;
}
*/
/*1.5 Dados o valor da compra e o percentual de desconto, calcule o valor a ser pago. Considere que o percentual de desconto
é um número real entre 0 e 1.
int main(void) {
float c, d, p;
printf("Digite o valor da compra: ");
scanf("%f", &c);
printf("Digite o valor do desconto: ");
scanf("%f", &d);
p = c - p * d;
printf("Pagamento = %.2f\n", p);
return 0;
}
*/
/*1.4 Dados um salário e um percentual de reajuste, calcule o salário reajustado. Considere que o percentual de reajuste é dado
por um número real entre 0 e 1. Por exemplo, se o reajuste for de 15%, o usuário deve digitar o número 0.15.
int main(void) {
float s, r, n;
printf("Digite o seu Salario: ");
scanf("%f", &s);
printf("Qual foi o Reajuste? ");
scanf("%f", &r);
n = s + s*r;
printf("Novo salario = %.2f\n", n);
}
*/
/* 1.3 Dadas as medidas de uma sala em metros (comprimento e largura), informe a sua área em metros quadrados.
int main(void){
float C, L, A;
printf("Medidas? ");
scanf("%f %f", &L, &C);
A = C*L;
printf("Area = %.1f\n", A);
}
*/
/* 1.2 Dado o total de vendas de um vendedor, calcule a sua comissão. Suponha que a comissão do vendedor seja de 10% do
total das vendas
int main (void){
float v, c;
printf("Vendas? ");
scanf("%f", &v);
c = 0.10 * v;
printf("Comissao = R$ %.2f\n", c);
return 0;
}
/*
/*
1.1 Dado um número real qualquer, informe qual é o seu dobro.
int main(){
float n, d;
printf("Digite um numero: ");
scanf("%f", &n);
d = 2*n;
printf("Dobro = %.1f\n", d);
return 0;
}
*/
|
the_stack_data/173578960.c
|
/* Copyright 2020 oscillo
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.
*/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <pthread.h>
#include <sys/stat.h>
#define BUF_SIZE 512
static unsigned char helloMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x15, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x72, 0x65,
0x65, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x2f, 0x44, 0x42, 0x75, 0x73, 0x00, 0x00, 0x00,
0x06, 0x01, 0x73, 0x00, 0x14, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x66, 0x72, 0x65, 0x65,
0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x2e, 0x44, 0x42, 0x75, 0x73, 0x00, 0x00, 0x00, 0x00,
0x02, 0x01, 0x73, 0x00, 0x14, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x66, 0x72, 0x65, 0x65,
0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x2e, 0x44, 0x42, 0x75, 0x73, 0x00, 0x00, 0x00, 0x00,
0x03, 0x01, 0x73, 0x00, 0x05, 0x00, 0x00, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00
};
static unsigned char getPosMsg[] =
{
0x6c ,0x01 ,0x00 ,0x01 ,0x31 ,0x00 ,0x00 ,0x00 ,0x01 ,0x00 ,0x00 ,0x00 ,0x90 ,0x00 ,0x00 ,0x00,
0x01 ,0x01 ,0x6f ,0x00 ,0x17 ,0x00 ,0x00 ,0x00 ,0x2f ,0x6f ,0x72 ,0x67 ,0x2f ,0x6d ,0x70 ,0x72,
0x69 ,0x73 ,0x2f ,0x4d ,0x65 ,0x64 ,0x69 ,0x61 ,0x50 ,0x6c ,0x61 ,0x79 ,0x65 ,0x72 ,0x32 ,0x00,
0x02 ,0x01 ,0x73 ,0x00 ,0x1f ,0x00 ,0x00 ,0x00 ,0x6f ,0x72 ,0x67 ,0x2e ,0x66 ,0x72 ,0x65 ,0x65,
0x64 ,0x65 ,0x73 ,0x6b ,0x74 ,0x6f ,0x70 ,0x2e ,0x44 ,0x42 ,0x75 ,0x73 ,0x2e ,0x50 ,0x72 ,0x6f,
0x70 ,0x65 ,0x72 ,0x74 ,0x69 ,0x65 ,0x73 ,0x00 ,0x03 ,0x01 ,0x73 ,0x00 ,0x03 ,0x00 ,0x00 ,0x00,
0x47 ,0x65 ,0x74 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x06 ,0x01 ,0x73 ,0x00 ,0x20 ,0x00 ,0x00 ,0x00,
0x6f ,0x72 ,0x67 ,0x2e ,0x6d ,0x70 ,0x72 ,0x69 ,0x73 ,0x2e ,0x4d ,0x65 ,0x64 ,0x69 ,0x61 ,0x50,
0x6c ,0x61 ,0x79 ,0x65 ,0x72 ,0x32 ,0x2e ,0x6f ,0x6d ,0x78 ,0x70 ,0x6c ,0x61 ,0x79 ,0x65 ,0x72,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x08 ,0x01 ,0x67 ,0x00 ,0x02 ,0x73 ,0x73 ,0x00,
0x1d ,0x00 ,0x00 ,0x00 ,0x6f ,0x72 ,0x67 ,0x2e ,0x6d ,0x70 ,0x72 ,0x69 ,0x73 ,0x2e ,0x4d ,0x65,
0x64 ,0x69 ,0x61 ,0x50 ,0x6c ,0x61 ,0x79 ,0x65 ,0x72 ,0x32 ,0x2e ,0x50 ,0x6c ,0x61 ,0x79 ,0x65,
0x72 ,0x00 ,0x00 ,0x00 ,0x08 ,0x00 ,0x00 ,0x00 ,0x50 ,0x6f ,0x73 ,0x69 ,0x74 ,0x69 ,0x6f ,0x6e,
0x00
};
static unsigned char stopMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x69, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00
};
static unsigned char pauseMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x69, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00
};
static unsigned char volUpMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x69, 0x00, 0x00,
0x12, 0x00, 0x00, 0x00
};
static unsigned char volDownMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x69, 0x00, 0x00,
0x11, 0x00, 0x00, 0x00
};
static unsigned char ffMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x04, 0x00, 0x00, 0x00,
0x53, 0x65, 0x65, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x78, 0x00, 0x00,
0x40, 0x4b, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00
};
static unsigned char rwMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x04, 0x00, 0x00, 0x00,
0x53, 0x65, 0x65, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x78, 0x00, 0x00,
0xc0, 0xb4, 0xb3, 0xff, 0xff, 0xff, 0xff, 0xff
};
static unsigned char trackMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, /*0x00*/
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72, /*0x10*/
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00, /*0x20*/
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, /*0x30*/
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50, /*0x40*/
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x0b, 0x00, 0x00, 0x00, /*0x50*/
0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x41, 0x75, 0x64, 0x69, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, /*0x60*/
0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, /*0x70*/
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, /*0x80*/
0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*0x90*/
0x08, 0x01, 0x67, 0x00, 0x01, 0x69, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 /*0xa0*/
/* this(0xa8) */
/*0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 */
};
static unsigned char seekMsg[] =
{
0x6c, 0x01, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
0x01, 0x01, 0x6f, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x6d, 0x70, 0x72,
0x69, 0x73, 0x2f, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x00,
0x02, 0x01, 0x73, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69,
0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x00, 0x00, 0x00, 0x03, 0x01, 0x73, 0x00, 0x04, 0x00, 0x00, 0x00,
0x53, 0x65, 0x65, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x73, 0x00, 0x20, 0x00, 0x00, 0x00,
0x6f, 0x72, 0x67, 0x2e, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x2e, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x50,
0x6c, 0x61, 0x79, 0x65, 0x72, 0x32, 0x2e, 0x6f, 0x6d, 0x78, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x67, 0x00, 0x01, 0x78, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static long volTable[21] =
{
-6000, -5700, -5400, -5100, -4800,
-4500, -4200, -3900, -3600, -3300,
-3000, -2700, -2400, -2100, -1800,
-1500, -1200, -900, -600, -300,
0
};
static long long* playTime;
static int* volume = 0;
static int sock = 0;
static unsigned char cmdIndex = 0;
static pthread_mutex_t lock;
static unsigned char audioTrackNum = 0;
static unsigned char audioTrackCurrent = 0;
static unsigned char state = 0;
char *commands[] =
{
"omxplayer --no-osd -b -o alsa ",
"omxplayer --no-osd -b -o alsa "
};
static
unsigned char *
LoadAddress(
unsigned char* buf,
unsigned short bufSize
)
{
char *head = NULL;
char *tail = NULL;
memset(buf, 0, sizeof(char)*BUF_SIZE);
/* [[[ 1. Load File ]]] */
struct stat st;
while (0 != stat("/tmp/omxplayerdbus.root", &st) && 0 != st.st_size)
{
usleep(100000);
}
FILE *file = NULL;
do
{
while (NULL == file)
{
usleep(100000);
file = fopen("/tmp/omxplayerdbus.root", "r");
}
fgets(buf, bufSize, file);
fclose(file);
}while(*buf == 0);
/* [[[ 2. Split Address ]]] */
/* [[ 2.1. Seek Head ]] */
head = buf;
while('=' != *head && *head != 0)
{
head++;
}
head++;
/* [[ 2.2. Seek Tail ]] */
tail = head;
while(',' != *tail && *tail != 0)
{
tail++;
}
*tail = '\0';
return head;
}
static
void
SendMsg(
int sock,
unsigned char *buf,
unsigned short size
)
{
write(sock, buf, size);
}
static
void
RecvMsg(
int sock,
unsigned char *buf,
unsigned short bufSize,
unsigned short size
)
{
int readSize = 0;
int sumSize = 0;
for (sumSize = 0; sumSize < size; sumSize += readSize)
{
readSize = read(sock, &(buf[sumSize]), bufSize - sumSize);
}
}
static
int
ConnectOMXPlayer(
void
)
{
int retSize = 0;
int sumSize = 0;
int srvfd = 0;
struct sockaddr_un addr = {0};
static unsigned char buf[BUF_SIZE] = {0};
/* [[[ 1. Connect UNIX Abstract Socket ]]] */
srvfd = socket(AF_UNIX, SOCK_STREAM, 0);
addr.sun_family = AF_UNIX;
addr.sun_path[0] = 0;
strcpy(&addr.sun_path[1], LoadAddress(buf, BUF_SIZE));
if (connect(
srvfd,
(struct sockaddr*)&addr,
strlen(&addr.sun_path[1]) + 3) < 0)
{
/* < Failure > */
return 0;
}
/* [[[ 2. Start Sequence ]]] */
memset(buf, 0, BUF_SIZE);
SendMsg(srvfd, buf, 1);
strcpy(buf, "AUTH EXTERNAL 30\r\n");
SendMsg(srvfd, buf, strlen(buf));
RecvMsg(srvfd, buf, BUF_SIZE, 37);
strcpy(buf, "NEGOTIATE_UNIX_FD\r\n");
SendMsg(srvfd, buf, strlen(buf));
RecvMsg(srvfd, buf, BUF_SIZE, 15);
strcpy(buf, "BEGIN\r\n");
SendMsg(srvfd, buf, strlen(buf));
SendMsg(srvfd, helloMsg, sizeof(helloMsg));
RecvMsg(srvfd, buf, BUF_SIZE, 258);
return srvfd;
}
static
unsigned char
GetPosition(
int sock,
long long *position
)
{
int retSize = 0;
long long *pos = 0;
static unsigned char buf[BUF_SIZE] = {0};
memset(buf, 0, BUF_SIZE);
SendMsg(sock, getPosMsg, sizeof(getPosMsg));
RecvMsg(sock, buf, BUF_SIZE, 72);
if (3 == buf[1])
{
/* < Error > */
return 0;
}
pos = (long long*)&(buf[0x40]);
if (*pos < 0)
{
*position = 0;
}
else
{
*position = *pos;
}
return 1;
}
static
void
Stop(
int sock
)
{
if (0 == sock)
{
return;
}
static unsigned char buf[BUF_SIZE] = {0};
SendMsg(sock, stopMsg, sizeof(stopMsg));
RecvMsg(sock, buf, BUF_SIZE, 56);
}
long long
OMXGetPosition(
void
)
{
pthread_mutex_lock(&lock);
if (0 == GetPosition(sock, playTime))
{
state = 0;
}
pthread_mutex_unlock(&lock);
return (*playTime) / 1000;
}
void
OMXFadeoutVolume(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
int i = 0;
for (i=0; i<15; ++i)
{
pthread_mutex_lock(&lock);
SendMsg(sock, volDownMsg, sizeof(volDownMsg));
RecvMsg(sock, buf, BUF_SIZE, 56);
pthread_mutex_unlock(&lock);
usleep(200000);
}
}
void
OMXStopVideo(
void
)
{
pthread_mutex_lock(&lock);
Stop(sock);
pthread_mutex_unlock(&lock);
}
void
OMXPauseVideo(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
SendMsg(sock, pauseMsg, sizeof(pauseMsg));
RecvMsg(sock, buf, BUF_SIZE, 56);
pthread_mutex_unlock(&lock);
}
void
OMXRWVideo(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
SendMsg(sock, rwMsg, sizeof(rwMsg));
RecvMsg(sock, buf, BUF_SIZE, 72);
pthread_mutex_unlock(&lock);
}
void
OMXFFVideo(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
SendMsg(sock, ffMsg, sizeof(ffMsg));
RecvMsg(sock, buf, BUF_SIZE, 72);
pthread_mutex_unlock(&lock);
}
void
OMXDownVolume(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
*volume -= 5;
if (*volume < 0)
{
*volume = 0;
pthread_mutex_unlock(&lock);
return;
}
SendMsg(sock, volDownMsg, sizeof(volDownMsg));
RecvMsg(sock, buf, BUF_SIZE, 56);
pthread_mutex_unlock(&lock);
}
void
OMXUpVolume(
void
)
{
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
*volume += 5;
if (*volume > 100)
{
*volume = 100;
pthread_mutex_unlock(&lock);
return;
}
SendMsg(sock, volUpMsg, sizeof(volUpMsg));
RecvMsg(sock, buf, BUF_SIZE, 56);
pthread_mutex_unlock(&lock);
}
void
OMXChangeAudioTrack(
void
)
{
unsigned char cmd[128];
if (1 == audioTrackNum)
{
return;
}
audioTrackCurrent++;
if (audioTrackNum == audioTrackCurrent)
{
audioTrackCurrent = 0;
}
static unsigned char buf[BUF_SIZE] = {0};
pthread_mutex_lock(&lock);
trackMsg[0xa8] = audioTrackCurrent;
SendMsg(sock, trackMsg, sizeof(trackMsg));
RecvMsg(sock, buf, BUF_SIZE, 68);
SendMsg(sock, seekMsg, sizeof(seekMsg));
RecvMsg(sock, buf, BUF_SIZE, 72);
pthread_mutex_unlock(&lock);
}
void
OMXInitPlayer(
unsigned char audioOutput,
int* vol,
long long* time
)
{
volume = vol;
playTime = time;
if (0 == audioOutput || 1 == audioOutput)
{
cmdIndex = 0;
}
else if (2 == audioOutput)
{
cmdIndex = 1;
}
pthread_mutex_init(&lock, 0);
}
void
OMXOpenVideo( char *path, unsigned char audioTrack,
unsigned char audioTrackCount
)
{
FILE *file = NULL;
double vol = (*volume - 100) * 100;
unsigned char cmdLine[2048];
unsigned char env[1024];
strcpy(cmdLine, commands[cmdIndex]);
sprintf(&cmdLine[strlen(cmdLine)], "--vol %d ", volTable[(*volume)/5]);
sprintf(&cmdLine[strlen(cmdLine)], "-n %d ", audioTrack + 1);
sprintf(&cmdLine[strlen(cmdLine)], "\"%s\" &", path);
pthread_mutex_lock(&lock);
system(cmdLine);
sock = 0;
while(0 == sock)
{
sock = ConnectOMXPlayer();
}
audioTrackNum = audioTrackCount;
audioTrackCurrent = audioTrack;
state = 1;
pthread_mutex_unlock(&lock);
}
unsigned char
OMXIsPlayingVideo(
void
)
{
return state;
}
|
the_stack_data/9512045.c
|
/*
Quando alocamos memória, ela fica alocada até o término do programa ou
quando o programa faz a liberação de memória
free() -> A função free trabalha exatamente com isso, realizando a limpeza de memórias
já alocadas
*/
#include <stdio.h>
#include <stdlib.h>
void main(void){
int *p = malloc(sizeof(int));
printf("O endereço alocado foi: %p\n", p);
*p = 1500;
printf("Valor: %i\n", *p);
free(p);
//Veja que o valor não está mais disponível
printf("Valor: %i\n", *p);
}
|
the_stack_data/92323960.c
|
#include <sys/socket.h> //socket function
#include <unistd.h> //fork,exec,read,write
#include <netinet/in.h> //seq bytes adjust,socket address
#include <arpa/inet.h> //inet_pton,inet_ntop
#include <strings.h> //bzero
#include <stdio.h> //printf
#include <sys/errno.h> //errno
#include <stdlib.h> //exit
#include <string.h> //strlen
#include <netdb.h> //DNS,addr-name,name-addr
void str_cli(FILE *fp,int sockfd);
int main(int args,char **argv)
{
int sockfd;
struct addrinfo hints,*result = NULL;
struct addrinfo *tmpAddrinfoPtr = NULL;
int reValue;
bzero(&hints,sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if(args != 2) //如果用户忘记输入地址，使用默认地址
{
printf("Use localhost!\n");
reValue = getaddrinfo("localhost","echo",&hints,&result);
}
else
{
reValue = getaddrinfo(argv[1],"echo",&hints,&result);
}
if(reValue != 0)
{
printf("%s",gai_strerror(reValue));
exit(-1);
}
tmpAddrinfoPtr = result;
while(tmpAddrinfoPtr != NULL) //顺序检验返回结果，寻找有效的地址
{
if((sockfd = socket(tmpAddrinfoPtr->ai_family,tmpAddrinfoPtr->ai_socktype,tmpAddrinfoPtr->ai_protocol)) < 0)
{
printf("socketfd create wrong");
exit(-1);
}
if(connect(sockfd,tmpAddrinfoPtr->ai_addr,tmpAddrinfoPtr->ai_addrlen) < 0)
{
close(sockfd);
tmpAddrinfoPtr = tmpAddrinfoPtr->ai_next;
}
else
{
break;
}
}
if(tmpAddrinfoPtr == NULL) //连接失败，退出
{
printf("can not connect to the host!");
exit(-1);
}
freeaddrinfo(result); //释放getaddrinfo函数内分配的空间
str_cli(stdin,sockfd);
printf("The client is shut!");
}
const unsigned int MAXLEN = 100;
void str_cli(FILE *fp,int sockfd)
{
char inStr[MAXLEN];
unsigned int curLen;
int n;
unsigned int sendNum = 0;
while(fgets(inStr,MAXLEN,fp))
{
sendNum = 0;
curLen = strlen(inStr);
while(sendNum < curLen) //make sure all data was written
{
n = write(sockfd,inStr + sendNum,curLen - sendNum);
if(n < 0)
{
if(errno == EINTR)
{
n = 0; //清零，防止后面影响发送计数
continue;
}
else
{
printf("Write to socket wrong!");
exit(0);
}
}
if(n == 0)
break;
sendNum += n;
}
if(sendNum != curLen)
printf("This data can not send completely!\n");
n = read(sockfd,inStr,MAXLEN);
if(n <= 0) //read after write can not be EOF
{
printf("Read from server failed!");
exit(-1);
}
if(fputs(inStr,stdout) == EOF)
{
printf("fputs error!");
exit(-1);
}
}
}
|
the_stack_data/309112.c
|
char *ft_strncpy(char *dest, char *src, unsigned int n)
{
unsigned int i;
i = 0;
while (i < n && src[i])
{
dest[i] = src[i];
++i;
}
while (i < n)
dest[i++] = 0;
return (dest);
}
|
the_stack_data/111077636.c
|
// KASAN: slab-out-of-bounds Read in hci_event_packet
// https://syzkaller.appspot.com/bug?id=4712504ef4bb053d06e34bb53eb22e237cdc5da8
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
#define SYZ_HAVE_SETUP_TEST 1
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;
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[1] = {0xffffffffffffffff};
void execute_one(void)
{
long res = 0;
memcpy((void*)0x20000000, "/dev/vhci\000", 10);
res = syscall(__NR_openat, 0xffffffffffffff9c, 0x20000000, 2, 0);
if (res != -1)
r[0] = res;
*(uint8_t*)0x20000200 = -1;
*(uint8_t*)0x20000201 = 0;
syscall(__NR_write, r[0], 0x20000200, 2);
*(uint8_t*)0x20000180 = 4;
memcpy((void*)0x20000181,
"\x22\x78\xa6\x70\x8f\xbc\x5d\xe9\xed\xf7\x43\x40\x67\x90\x8f\x77\x55"
"\xae\xc4\x03\x42\xc7\x89\x25\x72\x80\x3f\x83\xb8\xaf\x48\xc8\x6f\xdc"
"\xb1\x8e\x87\x23\x48\x80\xe1\xa3\x76\x1a\xf2\xde\x2a\x7c\xb8\xe1\xbe"
"\x2b\x72\xb4\x78\x7a\x5c\x4a\xca\xcf\x16\xe0\x16\xe6\xd9\x02\x5b\x6c"
"\x57\xb1\xa1\x6f\xae\x5d\x71\x3f\x87\x1e\xec\x42\x66\xf0\xfc\xc6\x44"
"\xb7\xcd\xee\x65\x6d\xe1\x33\x23",
93);
syscall(__NR_write, r[0], 0x20000180, 0x5e);
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
loop();
return 0;
}
|
the_stack_data/87779.c
|
// -----------------------------------------------------------------------------
// Test case for probabilistic symbolic simulation. local1.c
// Created by Ferhat Erata <[email protected]> on November 09, 2020.
// Copyright (c) 2020 Yale University. All rights reserved.
// -----------------------------------------------------------------------------
int index_first(void) {
int nums[] = {1, 2, 3};
int n = nums[2] + 2;
return n;
}
// 5
|
the_stack_data/211079425.c
|
/*
============================================================================
Name : exemplo-4-do-while.c
Author : taylor klaus cantalice nobrega
Version :
Copyright : Your copyright notice
Description :
============================================================================
*/
#include <stdio.h>
int main(void){
int n, maior, menor;
maior = -10000;
menor = 10000;
do{
printf("Digite n: ");
scanf("%d", &n);
if (n != 0 && n > maior){
maior = n;
}
if (n != 0 && n < menor){
menor = n;
}
}while (n != 0);
printf("maior: %d\nmenor: %d\n", maior, menor);
return 0;
}
|
the_stack_data/243893101.c
|
const unsigned char fortresssearch_psgcompr[] = {
0x18,0x00,0xae,0x78,0x00,0x01,0x81,0x40,0x61,0xe0,0x01,0x00,0x83,0xc1,0xe3,0xfd,
0x00,0x02,0x02,0x01,0x00,0x82,0xc0,0xe2,0x22,0x1a,0x01,0x03,0x03,0x83,0xe3,0xaf,
0x78,0x00,0x80,0x02,0x02,0x0e,0xe0,0x80,0x00,0xc3,0x87,0xc9,0xbd,0x00,0x40,0x40,
0x80,0x00,0xc3,0x03,0xc3,0x80,0xc0,0xc0,0x80,0x00,0x03,0x01,0x01,0xff,0x99,0x58,
0x58,0x59,0x19,0x0a,0x09,0x09,0xc5,0xe3,0xe0,0xe1,0x63,0x32,0x05,0x02,0xea,0x4c,
0x4f,0x4e,0x0c,0x0d,0x03,0x00,0xc3,0x40,0x43,0x43,0x01,0x03,0x03,0x00,0xfe,0x16,
0x12,0x12,0x00,0x00,0x10,0x90,0x90,0xa7,0xc5,0x85,0xbe,0xdc,0x88,0xa0,0x40,0xc8,
0x2a,0xea,0xd8,0xb8,0xe0,0x40,0x00,0xfd,0x00,0xc0,0xaa,0xe8,0x00,0x01,0x81,0x40,
0x61,0xb0,0x00,0x01,0x83,0xc1,0xe3,0xfd,0x20,0xd8,0x01,0x82,0xc0,0xe2,0x22,0xba,
0x01,0x83,0xe3,0xaa,0xec,0x00,0x80,0x02,0x06,0xb0,0x00,0x80,0xc0,0x83,0xc5,0xbd,
0x20,0xd8,0x80,0xc0,0x03,0xc3,0x20,0x9c,0x80,0x80,0x01,0x01,0xff,0x99,0x58,0x58,
0x59,0x19,0x0a,0x09,0x09,0xc5,0xe3,0xe0,0xe1,0x63,0x32,0x05,0x02,0xea,0x4c,0x4f,
0x4e,0x0c,0x0d,0x03,0x00,0xc3,0x40,0x43,0x43,0x01,0x03,0x03,0x00,0xfe,0x16,0x12,
0x12,0x00,0x00,0x10,0x90,0x90,0xa7,0xc5,0x85,0xbe,0xdc,0x88,0xa0,0x40,0xc8,0x2a,
0xea,0xd8,0xb8,0xe0,0x40,0x00,0xfd,0x00,0xc0,0xba,0xc1,0x00,0x28,0x04,0x24,0x18,
0x04,0x00,0x00,0x30,0x30,0x02,0x05,0x0b,0x07,0xc2,0x00,0x08,0x0c,0x3c,0x1a,0x09,
0x22,0xca,0x38,0x3c,0x18,0x08,0xfa,0x00,0x00,0x18,0x4c,0x56,0x0a,0x24,0x12,0x00,
0x38,0x2c,0x76,0x7b,0x27,0x43,0x4f,0x20,0xe0,0x0c,0x06,0x1a,0x9c,0xae,0xc2,0x00,
0x08,0x04,0x02,0x02,0x02,0xfa,0x03,0x01,0x00,0x64,0x3a,0x2d,0x0e,0x01,0x07,0x05,
0xe3,0xf8,0xf4,0x7a,0x39,0x1f,0x20,0x07,0x00,0x02,0x04,0x67,0x7b,0x20,0xa1,0x03,
0x60,0x70,0x28,0x08,0xff,0x02,0x06,0x42,0x60,0x08,0x3c,0x88,0x00,0xdf,0xc3,0x71,
0x72,0x4c,0x32,0x14,0xe8,0xae,0x7a,0xac,0x9c,0xb0,0xd0,0xc0,0x00,0x02,0x02,0xc0,
0xe4,0x38,0x30,0x00,0x00,0xaa,0xf1,0x00,0x04,0x08,0x04,0xe0,0x00,0x08,0x12,0x05,
0x0b,0x07,0xf2,0x00,0x0c,0x0a,0x09,0xe2,0x00,0x08,0x1c,0x08,0x08,0xfa,0x00,0x00,
0x18,0x4c,0x56,0x0a,0x24,0x12,0x00,0x38,0x2c,0x76,0x7b,0x27,0x43,0x4f,0x20,0xe0,
0x0c,0x06,0x1a,0x9c,0xae,0xc2,0x00,0x08,0x04,0x02,0x02,0x02,0xfa,0x03,0x01,0x00,
0xe4,0x3a,0x2d,0x0e,0x01,0x07,0x05,0xe3,0xf8,0xf4,0x7a,0x39,0x1f,0x20,0x07,0x00,
0x02,0x04,0xe7,0x7b,0x20,0xa1,0x03,0xe0,0x70,0x28,0x08,0xff,0x02,0x06,0x42,0x60,
0x08,0x3c,0x88,0x00,0xdf,0xc3,0x71,0x72,0x4c,0x32,0x14,0xe8,0xae,0x7a,0xac,0x9c,
0xb0,0xd0,0xc0,0x00,0x02,0x02,0xc0,0xe4,0x38,0x30,0x00,0x00,0xfa,0x00,0x00,0x18,
0x32,0x6a,0x50,0x24,0x48,0x00,0x1c,0x34,0x6e,0xde,0xe4,0xc2,0xf2,0x20,0xe0,0x30,
0x60,0x58,0x39,0x75,0xc2,0x00,0x10,0x20,0x40,0x40,0x40,0xba,0xc1,0x00,0x14,0x20,
0x24,0x18,0x20,0x00,0x00,0x0c,0x0c,0x40,0xa0,0xd0,0xe0,0xc2,0x00,0x10,0x30,0x3c,
0x58,0x90,0x22,0xca,0x1c,0x3c,0x18,0x10,0xff,0x40,0x60,0x42,0x06,0x10,0x3c,0x11,
0x00,0xfb,0xc3,0x8e,0x4e,0x32,0x4c,0x28,0x17,0x75,0x5e,0x35,0x39,0x0d,0x0b,0x03,
0x00,0x40,0x40,0x03,0x27,0x1c,0x0c,0x00,0x00,0xfa,0xc0,0x80,0x00,0x26,0x5c,0xb4,
0x70,0x80,0xe0,0xa0,0xc7,0x1f,0x2f,0x5e,0x9c,0xf8,0x20,0x07,0x00,0x40,0x20,0xe6,
0xde,0x20,0xa1,0xc0,0x06,0x0e,0x14,0x10,0xfa,0x00,0x00,0x18,0x32,0x6a,0x50,0x24,
0x48,0x00,0x1c,0x34,0x6e,0xde,0xe4,0xc2,0xf2,0x20,0xe0,0x30,0x60,0x58,0x39,0x75,
0xc2,0x00,0x10,0x20,0x40,0x40,0x40,0xaa,0xf1,0x00,0x20,0x10,0x20,0xe0,0x00,0x10,
0x48,0xa0,0xd0,0xe0,0xf2,0x00,0x30,0x50,0x90,0xe2,0x00,0x10,0x38,0x10,0x10,0xff,
0x40,0x60,0x42,0x06,0x10,0x3c,0x11,0x00,0xfb,0xc3,0x8e,0x4e,0x32,0x4c,0x28,0x17,
0x75,0x5e,0x35,0x39,0x0d,0x0b,0x03,0x00,0x40,0x40,0x03,0x27,0x1c,0x0c,0x00,0x00,
0xfa,0xc0,0x80,0x00,0x27,0x5c,0xb4,0x70,0x80,0xe0,0xa0,0xc7,0x1f,0x2f,0x5e,0x9c,
0xf8,0x20,0x07,0x00,0x40,0x20,0xe7,0xde,0x20,0xa1,0xc0,0x07,0x0e,0x14,0x10};
const unsigned char logopalette_bin[] = {
0x00,0x3f,0x37,0x20,0x34,0x25,0x3e,0x00,0x00,0x39,0x15,0x2f,0x00,0x0b,0x06,0x00};
const unsigned char logotilemap_l[] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x02,0x00,0x0a,0x0a,0x0a,0x0b,
0x01,0x02,0x0c,0x0d,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a};
const unsigned char logotilemap_m[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x05,0x00,0x06,0x00,0x07,0x00,
0x08,0x00,0x00,0x00,0x09,0x00,0x0a,0x00,0x06,0x00,0x0b,0x00,0x0c,0x00,0x0d,0x00,
0x06,0x00,0x0e,0x00,0x0f,0x00,0x06,0x00,0x06,0x00,0x10,0x00,0x11,0x00,0x12,0x00,
0x06,0x00,0x06,0x00,0x13,0x00,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x15,0x00,0x16,0x00,0x16,0x00,0x17,0x00,
0x18,0x00,0x00,0x00,0x19,0x00,0x1a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1b,0x00,
0x00,0x00,0x1c,0x00,0x1d,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x22,0x00,
0x00,0x00,0x00,0x00,0x23,0x00,0x24,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x25,0x00,0x26,0x00,0x26,0x00,0x27,0x00,
0x28,0x00,0x29,0x00,0x2a,0x00,0x2b,0x00,0x2c,0x00,0x00,0x00,0x00,0x00,0x2d,0x00,
0x00,0x00,0x2e,0x00,0x2f,0x00,0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,
0x2a,0x00,0x2a,0x00,0x35,0x00,0x36,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x37,0x00,0x38,0x00,0x39,0x00,
0x3a,0x00,0x3b,0x00,0x3c,0x00,0x3d,0x00,0x3e,0x00,0x3f,0x00,0x38,0x00,0x40,0x00,
0x38,0x00,0x41,0x00,0x42,0x00,0x43,0x00,0x44,0x00,0x3c,0x00,0x45,0x00,0x46,0x00,
0x3c,0x00,0x3c,0x00,0x47,0x00,0x48,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x49,0x00,0x4a,0x00,0x06,0x00,0x4b,0x00,
0x4c,0x00,0x4d,0x00,0x06,0x00,0x06,0x00,0x4e,0x00,0x4f,0x00,0x50,0x00,0x06,0x00,
0x06,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x06,0x00,0x06,0x00,0x54,0x00,0x55,0x00,
0x56,0x00,0x06,0x00,0x06,0x00,0x57,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x59,0x00,0x59,0x00,0x5a,0x00,
0x5b,0x00,0x5c,0x00,0x00,0x00,0x00,0x00,0x5d,0x00,0x5e,0x00,0x5f,0x00,0x60,0x00,
0x61,0x00,0x62,0x00,0x63,0x00,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x65,0x00,
0x66,0x00,0x66,0x00,0x66,0x00,0x67,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x68,0x00,0x69,0x00,0x69,0x00,0x69,0x00,
0x6a,0x00,0x6b,0x00,0x6c,0x00,0x6c,0x00,0x6d,0x00,0x6e,0x00,0x6f,0x00,0x70,0x00,
0x71,0x00,0x72,0x00,0x73,0x00,0x74,0x00,0x6c,0x00,0x6c,0x00,0x75,0x00,0x76,0x00,
0x77,0x00,0x6c,0x00,0x6c,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x79,0x00,0x7a,0x00,0x7b,0x00,0x7c,0x00,
0x7d,0x00,0x7e,0x00,0x7f,0x00,0x80,0x00,0x81,0x00,0x82,0x00,0x83,0x00,0x84,0x00,
0x84,0x02,0x83,0x02,0x82,0x02,0x81,0x02,0x80,0x02,0x7f,0x02,0x7e,0x02,0x7d,0x00,
0x7c,0x02,0x7b,0x02,0x7a,0x02,0x79,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x85,0x00,0x86,0x00,0x87,0x00,0x88,0x00,0x89,0x00,0x8a,0x00,0x8b,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x8b,0x02,0x8a,0x00,0x89,0x02,0x88,0x02,0x87,0x02,0x86,0x02,0x85,0x02};
const unsigned char logotiles_psgcompr[] = {
0x8c,0x00,0x00,0x08,0xf7,0x00,0x10,0x8a,0xf7,0x00,0x10,0xc1,0x00,0x10,0x38,0x6c,
0x38,0x10,0x00,0x88,0xe3,0x00,0x10,0x38,0x10,0x00,0xea,0x01,0x07,0x0f,0x1f,0x1f,
0x3f,0x3e,0x3c,0x70,0x00,0x02,0x01,0x02,0x27,0x2f,0xca,0x00,0x08,0x10,0x21,0x02,
0x21,0x3f,0x03,0x04,0xaa,0xe0,0xff,0xbf,0x80,0x00,0x00,0x80,0xe2,0x00,0x60,0x7f,
0xc0,0x80,0xee,0x00,0x40,0x80,0x40,0xe4,0x3f,0xff,0x80,0x80,0xa2,0x0f,0x00,0xff,
0xff,0xff,0xff,0xf7,0x00,0xff,0x21,0xeb,0xff,0xff,0xea,0xfe,0xff,0xff,0xf7,0x07,
0x03,0x01,0x01,0x40,0xe0,0x18,0xfa,0x05,0x03,0x01,0x63,0x00,0x01,0x08,0x04,0x02,
0x21,0x6a,0x00,0xf0,0xfd,0x03,0xba,0x16,0xf0,0x00,0xc0,0xe0,0xf8,0xe0,0x80,0x00,
0x00,0x20,0x28,0xa8,0xe8,0xf8,0xe2,0x00,0x10,0x18,0x10,0x10,0x21,0x9d,0x40,0x20,
0xf8,0xfa,0x1f,0x1f,0x3f,0x7d,0x7e,0x7e,0x7f,0x7f,0x00,0x20,0x40,0x03,0x41,0x44,
0x3e,0x7f,0x6c,0x00,0x10,0x02,0x41,0x40,0x21,0xe3,0x41,0x43,0x47,0xaa,0xf0,0xff,
0x00,0x00,0x80,0x40,0xf4,0x00,0xff,0x80,0xc0,0x21,0xf7,0x00,0x21,0xeb,0xff,0xff,
0xaa,0x07,0x00,0xff,0xdf,0x9f,0xbb,0x28,0x87,0x00,0x20,0x40,0x64,0xf7,0x20,0x0f,
0x30,0x50,0x10,0xb4,0x21,0xcb,0xe0,0x43,0xcf,0xa2,0x0f,0x00,0xff,0xff,0xff,0xff,
0xe7,0x00,0x01,0xff,0x21,0xeb,0xff,0xff,0xaa,0xe0,0xff,0x7f,0xfc,0xfc,0xf8,0xf8,
0xe0,0x00,0x83,0x43,0x4a,0x7c,0x7c,0xe1,0x00,0x80,0x80,0x84,0x80,0xe0,0x00,0x03,
0x47,0x4b,0x7e,0xfe,0xba,0x0b,0x07,0xe7,0xd7,0xa7,0xc7,0x17,0x10,0x20,0x50,0x30,
0xf0,0x10,0x00,0x03,0x1b,0x00,0x10,0x30,0x60,0x10,0xc2,0x04,0x14,0xf4,0xf4,0xe4,
0x07,0xaa,0xe0,0xff,0xdf,0xe0,0xc0,0xd0,0xd0,0xe0,0x00,0x30,0x5f,0x60,0xb0,0xb0,
0xe4,0x00,0x20,0x20,0x10,0x10,0x21,0xe8,0x1f,0x7f,0xf0,0xf0,0xfb,0xf8,0xfe,0xff,
0xbf,0x3f,0x1f,0x0f,0x0f,0x04,0x00,0x00,0xc1,0xd1,0x2d,0x17,0x0f,0xe3,0x00,0x40,
0x20,0x10,0x0c,0x02,0x01,0x81,0xd1,0xed,0x1f,0x1f,0xea,0x00,0x00,0x01,0x03,0xc7,
0x87,0x8f,0x0f,0xe0,0x00,0x80,0x40,0x48,0x49,0xd3,0xc6,0x00,0x01,0x02,0x44,0x80,
0x21,0xf1,0xc0,0xc8,0xc9,0xfb,0x17,0x3f,0xff,0xfb,0xf8,0xe0,0x88,0x00,0x28,0xc0,
0x00,0x06,0x27,0x5c,0xf8,0xc0,0x8a,0x08,0x40,0x00,0x04,0x20,0x80,0x30,0x80,0x00,
0x03,0x37,0x5f,0xf8,0xe0,0xfa,0xf4,0xfe,0xff,0xdf,0x1f,0x07,0x0b,0x00,0x0a,0x01,
0x00,0x60,0xe4,0x1b,0x0d,0x03,0x40,0x70,0x08,0x10,0x04,0x0a,0x01,0x21,0x23,0x06,
0x00,0xc0,0xec,0xfb,0xea,0x00,0x00,0xc0,0xe0,0xe0,0xf8,0xf8,0xf4,0xb0,0x00,0x80,
0x30,0x28,0xf0,0xfc,0xc8,0x00,0x40,0x20,0x08,0x08,0x0c,0x21,0xfb,0x38,0xae,0xf0,
0x3c,0x3e,0x3f,0x3f,0x3f,0x70,0x3e,0x3f,0x3d,0x37,0x31,0x30,0x00,0x01,0x01,0x03,
0x03,0x08,0x0e,0x0f,0xff,0x3f,0xaa,0xf8,0x00,0xff,0xff,0xff,0x20,0xfe,0x00,0xfe,
0x00,0xff,0x00,0xaa,0x70,0x00,0x01,0x01,0xff,0xff,0xff,0xf0,0x01,0x00,0xfc,0xff,
0x00,0x8e,0x00,0x01,0x01,0x01,0xff,0x21,0xf6,0x01,0xff,0xaa,0xff,0xe0,0x38,0xf0,
0xf8,0xf8,0xd0,0x90,0x10,0x38,0x18,0x10,0x10,0x38,0x78,0xf8,0xff,0xf8,0xbe,0x0f,
0x00,0x0f,0x07,0x13,0x09,0x3f,0x1f,0x1f,0x0f,0x03,0x01,0x00,0x00,0x30,0x18,0x1c,
0x0e,0x07,0x03,0x01,0x00,0x21,0xf1,0x07,0x03,0x01,0xfe,0x80,0xc0,0xe0,0xf0,0xf4,
0xf8,0x7c,0x3e,0xc0,0xe0,0xf0,0xe0,0x6c,0x34,0x82,0xc0,0x40,0x20,0x00,0x18,0x9c,
0xcc,0xfe,0xff,0x21,0xe0,0xf8,0xfc,0xfc,0xfe,0xff,0xaa,0xff,0x78,0xf0,0xfc,0xf4,
0xe4,0xe4,0xc0,0xf0,0x82,0x8e,0x9e,0x9a,0xbe,0xff,0xfe,0xaa,0xff,0x03,0xfe,0x07,
0x06,0xfe,0x04,0x05,0xff,0x07,0xba,0x38,0x90,0xd0,0xd0,0x91,0x91,0x91,0xb0,0xb0,
0xd0,0xd0,0xd1,0x51,0x50,0x51,0x38,0x70,0x50,0x50,0xf0,0xf1,0xf1,0xf0,0xf0,0xf1,
0xf1,0xf1,0xf1,0xaa,0xf0,0x00,0xff,0xff,0xff,0x1f,0x20,0xf8,0x7f,0x3f,0x20,0xfc,
0x00,0xc0,0xff,0x20,0xfa,0x7f,0xff,0xaa,0xf0,0x00,0xff,0xff,0xff,0xff,0x20,0xfe,
0x00,0xfe,0x00,0xff,0x00,0xfe,0x0f,0x0f,0x1f,0x3e,0xfe,0xfc,0xf8,0xc1,0x0f,0x0f,
0x07,0x17,0x9d,0xfa,0x84,0x31,0x00,0x00,0x10,0x01,0x02,0x07,0x7f,0xff,0x07,0xff,
0x0f,0x0f,0x07,0x77,0x9f,0xbe,0x74,0x1e,0x1f,0x5e,0x9f,0x0f,0xc7,0xdf,0x9f,0x1f,
0x5d,0x19,0x80,0x10,0x80,0x81,0x40,0xc0,0xc3,0x87,0x9f,0x1f,0x78,0xdf,0xd7,0x9f,
0x9f,0x1f,0xaa,0xbf,0x00,0x40,0x3c,0x00,0xc0,0xc0,0x80,0x80,0x3e,0x80,0x00,0x40,
0xc0,0x22,0x3f,0xc0,0xc0,0xaa,0x7e,0x00,0x02,0x01,0x20,0x3f,0x03,0x01,0x7d,0x00,
0x03,0x01,0x21,0xfd,0x01,0xaa,0xfe,0xf0,0xe4,0xf8,0xf8,0xe8,0xc0,0xd4,0xf8,0x0c,
0x14,0x3c,0x3c,0xff,0xfc,0xaa,0x7c,0x3c,0x3f,0x31,0x01,0x1c,0x00,0x10,0x02,0x02,
0x0d,0x21,0x7f,0x3f,0x2f,0xff,0x3f,0x8a,0x7f,0x00,0xff,0x20,0x9f,0xff,0xff,0x02,
0xaa,0x7f,0x00,0xff,0xb1,0x00,0x01,0x01,0x01,0x01,0x1f,0x01,0xff,0xff,0xff,0x02,
0xaa,0xfc,0xe0,0x80,0x00,0xe0,0x10,0x11,0x11,0x11,0x61,0x00,0x1f,0xf9,0xf8,0xf8,
0xf8,0x02,0xaa,0xe1,0x00,0xff,0xff,0xff,0x80,0x20,0xf9,0x00,0x7f,0xf8,0x00,0xff,
0xff,0xff,0x20,0xfc,0xff,0xff,0xaa,0xe3,0x00,0xff,0xff,0xff,0x20,0xf9,0x00,0xff,
0xf8,0x00,0xff,0xff,0xff,0x20,0xfc,0xff,0xff,0xfa,0x9e,0x3e,0x1e,0xfe,0xfc,0xf8,
0x00,0x02,0xe1,0x01,0x21,0xf0,0xe2,0x04,0xf8,0x02,0x86,0xff,0x7f,0x3f,0x0f,0x1f,
0xfe,0x22,0xe7,0xff,0xff,0xaa,0xfb,0x00,0x80,0x00,0x7c,0x80,0x00,0x00,0x00,0x02,
0xaa,0xfc,0x78,0x42,0x02,0x7c,0x80,0xc0,0xba,0x02,0x7f,0xfe,0xbe,0xff,0xfe,0xaa,
0xfc,0x03,0x02,0x00,0x7c,0x04,0x06,0x05,0x00,0x7f,0x07,0x05,0xff,0x07,0xaa,0xfc,
0x90,0x10,0x00,0xfc,0x50,0x90,0x00,0xfe,0xf0,0xe0,0x02,0xaa,0x0f,0x00,0x47,0x01,
0x08,0x02,0x20,0x1f,0x48,0x02,0x09,0x0f,0x00,0x7f,0x1f,0x0f,0x03,0x02,0xfa,0xfc,
0xfc,0x7e,0x3f,0x0f,0x43,0x10,0x04,0x02,0x02,0x81,0x40,0x10,0x44,0x11,0x04,0xf8,
0xff,0x7f,0x1f,0x07,0x02,0xee,0x00,0x10,0x80,0xa0,0xe0,0xf8,0x1d,0x00,0x20,0xe0,
0x60,0x10,0x00,0xe3,0x01,0xfc,0xf0,0x80,0xe0,0xf0,0xfc,0xff,0xff,0x02,0xae,0x1f,
0x00,0x0f,0x07,0x03,0x0f,0x00,0x10,0x08,0x04,0x03,0x1f,0x0f,0x0f,0x07,0x03,0x01,
0x00,0x80,0x02,0xfe,0xc0,0xe0,0xf8,0xff,0x7f,0x1f,0x80,0x20,0x00,0x10,0x06,0x07,
0x83,0x60,0x8f,0x20,0xe0,0xf0,0xfc,0xf8,0xfc,0xff,0xff,0x3f,0x22,0xc7,0xfe,0xff,
0xff,0xfe,0x03,0x07,0x1f,0xff,0xfe,0xf8,0x00,0x02,0x01,0x03,0x2f,0xfc,0xf1,0x06,
0xf0,0x02,0x02,0x04,0x10,0x03,0x0f,0xff,0xff,0xfe,0x1e,0xff,0x01,0x03,0x2f,0xfe,
0xae,0x0d,0x00,0xe4,0xc0,0xc8,0x80,0x80,0x1d,0x00,0x84,0xa0,0x08,0x80,0x7c,0x78,
0xf8,0xf0,0xe0,0xc0,0x80,0x00,0x22,0x3f,0xfc,0xf8,0xaa,0xfe,0x00,0x3f,0xfe,0x00,
0x40,0x00,0x01,0x88,0xfe,0x00,0xff,0x00,0xaa,0x7e,0x00,0x01,0xfe,0x20,0xfe,0x01,
0x00,0x01,0xaa,0x7f,0x00,0xf9,0x00,0x00,0x00,0xaa,0x7e,0x00,0xff,0x0f,0x7f,0x00,
0xff,0x00,0x01,0xaa,0x7e,0x00,0xff,0xff,0x7f,0x00,0xff,0x00,0x01,0xaa,0x7e,0x00,
0xfc,0xff,0x7f,0x00,0xfc,0x00,0x01,0xaa,0xfe,0x00,0x80,0xfe,0x00,0x40,0x00,0x01,
0x88,0xfe,0x00,0x07,0x00,0xaa,0x7e,0x00,0xfe,0xff,0x7f,0x00,0xfe,0x00,0x01,0xaa,
0x7e,0x00,0x07,0xc0,0x20,0xfe,0x20,0x00,0x01,0xaa,0x7f,0x00,0xe0,0x00,0x00,0x00,
0x8a,0xfe,0x00,0x3f,0x00,0xfe,0x00,0x40,0xaa,0x7e,0x00,0x01,0xff,0x7f,0x00,0x01,
0x00,0x01,0xaa,0x7e,0x00,0xc0,0xfe,0x7f,0x00,0xc0,0x00,0x20,0xfe,0x01,0xaa,0x7f,
0x00,0x0f,0x00,0x00,0x00,0xaa,0x7e,0x00,0xf8,0xff,0x7f,0x00,0xf8,0x00,0x01,0x8a,
0xfe,0x00,0xf8,0x00,0xfe,0x00,0x04,0xee,0x01,0x07,0x0f,0x1f,0x0e,0x39,0x32,0x12,
0xf0,0x00,0x11,0x06,0x0d,0x2d,0x00,0x04,0x08,0x10,0x11,0x27,0x0c,0x2e,0x7c,0x00,
0x03,0x23,0x01,0xaa,0xe0,0xff,0x9f,0x80,0x00,0x00,0x80,0x40,0xf8,0xc0,0x00,0x80,
0xee,0x00,0x60,0x80,0xe1,0x00,0x1f,0xff,0xff,0x80,0xaa,0x0b,0x00,0xff,0xfc,0xfa,
0xfc,0x01,0x40,0xf0,0xfe,0x01,0x00,0x00,0x9b,0x00,0x02,0x06,0x01,0xe0,0x01,0xff,
0xff,0xfe,0x00,0x00,0xfa,0x00,0x00,0x03,0x07,0x0f,0x0c,0x39,0x12,0x00,0x01,0x04,
0x08,0x10,0x13,0x06,0x2d,0xb8,0x00,0x01,0x13,0x27,0x2c,0x21,0xb8,0x02,0x00,0x00,
0x03,0xea,0x5f,0xff,0xff,0xc7,0x60,0x80,0x20,0x00,0x40,0xf8,0x70,0xe0,0x80,0x61,
0x00,0x20,0x38,0xa0,0x80,0x20,0x40,0x64,0xc0,0x07,0x5f,0xc0,0x80,0xeb,0xe8,0xfe,
0xfe,0x1f,0x37,0x08,0x04,0x06,0x40,0x38,0x10,0x00,0x37,0x0b,0x01,0x21,0x70,0x18,
0x28,0x07,0x03,0x05,0x04,0x02,0x00,0x00,0xd0,0xf8,0x1c,0x0a,0xaa,0xf0,0x07,0x47,
0x66,0x34,0x30,0xe0,0x00,0x80,0x80,0x81,0xd3,0xc7,0x21,0xf8,0xa1,0xf3,0xd7,0xc2,
0x00,0x80,0x40,0x40,0x40,0x20,0xaa,0x0f,0x40,0xff,0xff,0xff,0x9f,0x40,0xf8,0xa0,
0x80,0x80,0x40,0xf0,0x80,0xc0,0xc0,0xc0,0xe0,0x00,0x1f,0x7f,0x3f,0x20,0x20,0xab,
0x07,0x10,0xf8,0xfc,0xfe,0x1d,0x27,0x40,0x38,0x00,0x02,0x2f,0x0f,0x0f,0xe0,0x00,
0xe2,0x18,0x1f,0x1f,0x1f,0x0c,0x02,0x01,0x01,0xe1,0xe0,0x00,0x00,0xff,0x01,0x01,
0x07,0x07,0x9e,0x8d,0xd8,0xf2,0x00,0x06,0x08,0x08,0x01,0x12,0x27,0x0d,0x01,0x02,
0x00,0x08,0x91,0x92,0xc6,0xec,0x00,0x04,0x08,0x80,0x00,0x41,0x21,0x03,0xea,0x7f,
0xff,0xff,0x9f,0xc0,0x00,0x40,0x00,0x40,0xf8,0xe0,0xc0,0x00,0x21,0xf1,0x40,0x00,
0x40,0xe0,0x00,0x1f,0xbf,0xff,0x80,0x80,0xaa,0x07,0x00,0xfe,0xff,0xfd,0xfd,0x01,
0x07,0x00,0x01,0x01,0x03,0x03,0xff,0x87,0x00,0x03,0x01,0x05,0x01,0x43,0x00,0x01,
0x06,0xfa,0xfe,0xfe,0xfb,0x05,0x07,0x0f,0x1e,0x7b,0x34,0x65,0x80,0x02,0x08,0x10,
0x21,0x04,0x4b,0x1b,0x7e,0x21,0x70,0x06,0x45,0x48,0x1d,0xf8,0x00,0x10,0x20,0x00,
0x02,0x07,0x82,0x06,0xaa,0x0f,0x00,0xff,0xff,0xff,0x7f,0xe3,0x00,0x80,0xff,0x80,
0xef,0x00,0x80,0x21,0xeb,0x7f,0xff,0xaa,0x07,0x00,0xf8,0xfc,0xf4,0xf4,0x04,0x07,
0x00,0x04,0x04,0x0c,0x0c,0xfc,0x87,0x00,0x0c,0x04,0x14,0x04,0x43,0x00,0x04,0x18,
0xe8,0xf8,0xf8,0xba,0x4c,0x00,0x02,0x02,0x03,0x0f,0x0f,0x3d,0x3e,0x3c,0x3c,0x3f,
0x3f,0x30,0x30,0x21,0x0f,0x3e,0x3c,0x3e,0x3d,0x20,0x0f,0x01,0x03,0x01,0x02,0xaa,
0xfc,0x00,0xff,0xff,0xf3,0x00,0xff,0xff,0x21,0xfe,0xff,0xfd,0x00,0xff,0xaa,0xf0,
0x00,0x01,0x02,0xfc,0xfc,0xf1,0x00,0xfe,0xfd,0x02,0xf2,0x00,0xfe,0xfc,0xfc,0x20,
0xf8,0x03,0xff,0x03,0xbf,0x58,0x44,0x00,0x45,0x45,0x6e,0x3f,0x7f,0x3a,0x3b,0x3a,
0x38,0x3b,0x10,0x40,0x3c,0x38,0x3d,0x3c,0x38,0x39,0x52,0x01,0x43,0x47,0x42,0x42,
0x46,0x46,0x2d,0x7e,0xa8,0x7e,0x00,0x80,0x80,0x00,0x00,0xaa,0x3c,0x02,0x06,0x06,
0x00,0x04,0xbc,0x01,0x05,0x03,0x03,0x21,0x66,0x05,0x03,0x03,0x07,0x1b,0x00,0x02,
0x02,0x02,0x02,0xaa,0xd0,0x30,0x38,0x20,0x20,0x61,0xc5,0x40,0x7c,0xc7,0x86,0x02,
0xd0,0xd7,0xdf,0xc7,0xe7,0xa6,0x02,0x42,0x7e,0x20,0xf5,0xaa,0xe0,0x40,0xc0,0x81,
0x82,0x81,0x80,0xe0,0x80,0x00,0x40,0x41,0x42,0x40,0x0b,0x00,0xc0,0xc0,0xc0,0x40,
0x03,0xe0,0x20,0xa0,0xe1,0xe0,0xe3,0xe1,0xaa,0xf4,0x00,0x80,0xff,0x3f,0xf2,0x00,
0x7f,0xff,0x40,0x21,0xfe,0x20,0xfc,0x00,0xff,0xdf,0xaa,0xfc,0x00,0xff,0xff,0xf3,
0x00,0xff,0xff,0x21,0xfe,0x01,0x20,0xfe,0xfe,0xfb,0x00,0x11,0x01,0x53,0xe2,0x0c,
0xf8,0xe0,0x1f,0x0e,0x1e,0x2c,0x1c,0xf0,0x00,0x00,0x21,0x2c,0x0f,0x1e,0x6d,0x08,
0xe0,0x10,0x01,0x01,0x02,0x03,0x0f,0xf7,0x1e,0xbe,0x78,0x22,0xe2,0xa2,0x26,0x2e,
0x1d,0xdd,0x9d,0x9d,0x1c,0x9c,0x18,0x11,0xdc,0x1c,0x1c,0x3c,0x3c,0xbc,0x38,0x30,
0x42,0xe0,0x83,0x83,0x03,0x07,0x0f,0xa8,0xff,0x80,0x00,0x00,0xaa,0x78,0x80,0x84,
0x0e,0x18,0x1a,0x40,0x7c,0x7a,0xe4,0xe6,0x78,0xff,0xfc,0x72,0x60,0x62,0x42,0x7e,
0x02,0x9c,0x2a,0x7c,0xff,0x00,0x00,0x00,0x21,0xfb,0x00,0xf9,0x00,0xff,0xff,0xaa,
0x56,0x10,0x00,0x20,0x50,0x00,0x20,0x83,0xe0,0xd0,0xf0,0xb0,0x90,0x20,0x87,0xf0,
0xc0,0xd0,0x90,0xc1,0x00,0x30,0x20,0x60,0xe0,0xe0,0xaa,0x78,0x3c,0x2e,0x3d,0x3d,
0x21,0x78,0x02,0x10,0x03,0x01,0x01,0x78,0x00,0x12,0x01,0x0d,0x21,0x78,0x3f,0x2d,
0x3e,0x32,0x1e,0xaa,0xbf,0x00,0xff,0x00,0x00,0x7f,0x00,0xff,0xab,0xe0,0x3f,0x1f,
0x0b,0x04,0x00,0x00,0xc3,0x00,0x20,0x10,0x0c,0x05,0x20,0x0f,0x00,0x30,0x38,0x1c,
0x3f,0x0f,0x07,0x03,0x04,0x03,0x01,0x00,0xea,0x80,0xc0,0xf8,0xe0,0xfc,0xff,0x1f,
0xc0,0xc4,0x00,0x04,0x1f,0x03,0x20,0xc0,0x21,0x59,0x80,0x08,0xc0,0x1f,0x42,0x1f,
0x00,0xe0,0xf4,0xaa,0xf9,0x00,0xff,0xff,0xe7,0x00,0xff,0xff,0x21,0xfd,0xff,0xfa,
0x00,0xff,0xff,0xfe,0x00,0x11,0xe3,0x0f,0x7c,0xf8,0xc2,0x08,0x0f,0x0e,0x1c,0xf0,
0x82,0x00,0x22,0x08,0x07,0x1e,0xdc,0xf1,0x84,0x18,0xc2,0x08,0x42,0x3c,0x08,0x01,
0x3c,0xf0,0xab,0x1e,0x07,0xc5,0x87,0x27,0x04,0x5f,0x00,0x02,0xa0,0x5c,0x00,0x42,
0x20,0x01,0x04,0xb5,0xe7,0xc7,0xc7,0x87,0x07,0x06,0x03,0xaa,0xf8,0x80,0xa0,0xa0,
0x20,0xf8,0x40,0x60,0x20,0x20,0xf8,0x00,0x20,0xa0,0x20,0xf8,0xe0,0xc0,0x40,0xc0,
0xaa,0x0f,0x00,0x0f,0x23,0x09,0x02,0x20,0x1f,0x10,0x24,0x08,0x20,0x3f,0x08,0x22,
0x0f,0x00,0x77,0x1d,0x06,0x01,0xfe,0xfc,0xfd,0xff,0x7f,0x1f,0x4f,0x11,0x04,0x02,
0x01,0x00,0x80,0x20,0x40,0x12,0x04,0x04,0x05,0x01,0x40,0x10,0x4c,0x11,0x04,0x42,
0xf8,0x33,0x0e,0x03,0xeb,0x04,0xe0,0x80,0xc0,0xe0,0xfc,0xfe,0x01,0x20,0xe0,0x00,
0x10,0x04,0x00,0x02,0x20,0xe1,0x40,0x00,0x0c,0xe2,0xf8,0x00,0x00,0x80,0xf0,0xf0,
0x1c,0xfe,0xab,0x70,0x1f,0x3f,0x0f,0x09,0x04,0x01,0xb8,0x00,0x20,0x0e,0x04,0x01,
0x20,0x07,0x21,0x00,0x00,0x18,0x0c,0x1e,0x3f,0x1f,0x07,0x03,0x06,0x03,0x80,0xea,
0x00,0xc0,0xe0,0xc0,0xf0,0xff,0x7f,0x00,0x40,0x1e,0x80,0x40,0x00,0x00,0x20,0xc3,
0x20,0x3f,0x0f,0x00,0x42,0x1f,0x80,0x00,0xd0,0xaa,0xe1,0x00,0x02,0x04,0xfc,0xf8,
0xe5,0x00,0xfc,0xfa,0x04,0x20,0xe3,0xfc,0xf8,0x04,0xe0,0x00,0x03,0x06,0xfa,0x06,
0xfe,0xef,0x7c,0x7e,0x7f,0x3f,0x3f,0x27,0x00,0x04,0x68,0x00,0x80,0x40,0x38,0x01,
0x04,0x04,0x02,0x00,0x20,0x38,0x24,0x00,0x04,0xfa,0xfd,0x7f,0x5f,0x07,0x1b,0x0f,
0x03,0xaa,0xc1,0x00,0x80,0x80,0xc0,0xff,0xff,0xc7,0x00,0x40,0x7f,0x3f,0x21,0xdd,
0x00,0xff,0x20,0xdc,0xc0,0x00,0xff,0xaa,0xe1,0x00,0x08,0x10,0xf0,0xe0,0xe5,0x00,
0xf0,0xe8,0x10,0x20,0xe3,0xf0,0xe0,0x10,0xe0,0x00,0x0c,0x18,0xe8,0x18,0xf8,0xa0,
0xfe,0x00,0x1f,0x00,0xa0,0xfc,0x00,0x03,0xff,0x00,0xa0,0xf8,0x00,0x03,0xff,0xff,
0x00,0xa0,0xf8,0x00,0xff,0xff,0xfc,0x00,0xa0,0xf1,0x00,0xff,0xff,0xff,0x00,0xa0,
0xc1,0x00,0x01,0xff,0xff,0xff,0x80,0x00,0xa8,0x83,0x00,0x07,0xff,0xff,0xf0,0xfc,
0x00,0xf7,0x00,0x0f,0xa8,0x1f,0x00,0x03,0xff,0xff,0x00,0xe7,0x00,0xff,0xff,0xa8,
0x1b,0x00,0xff,0xff,0x80,0xff,0x20,0xe7,0x1f,0x7f,0x41,0xfc,0x00,0x00,0xa8,0x7b,
0x00,0xfe,0xff,0x20,0xe7,0xff,0xff,0x41,0xfc,0x00,0x00,0xaa,0xe1,0x00,0x01,0x07,
0xff,0xff,0x20,0xc7,0xff,0xfe,0xf8,0x41,0xfe,0x00,0xe7,0x00,0x01,0x07,0xaa,0xe1,
0x00,0xff,0xff,0xff,0xff,0xd9,0x00,0xff,0xff,0xff,0x41,0xf6,0x80,0x00,0xe7,0x00,
0xff,0x80,0xa0,0xf0,0x00,0x03,0x3f,0x7f,0xf0,0x00,0xa0,0xe1,0x00,0x1f,0xff,0xf8,
0x80,0x00,0xa0,0x87,0x00,0x0f,0xff,0xff,0xe0,0x00,0xa0,0x0f,0x00,0x1f,0xff,0xff,
0x80,0x00,0xa0,0x3f,0x00,0xff,0xfe,0x00,0xa0,0x7f,0x00,0xff,0x00,0xa0,0x7f,0x00,
0xc0,0x00};
const unsigned char spacestation_psgcompr[] = {
0x09,0x00,0xfe,0x00,0x01,0x02,0x01,0x58,0x5c,0x41,0x20,0x0f,0x0e,0x0d,0xfe,0xaf,
0xe3,0xbf,0x9d,0x00,0x03,0x03,0x01,0x7c,0x7f,0x7d,0x60,0x22,0x86,0x07,0x07,0x03,
0x7d,0x78,0xaa,0xa7,0x00,0x81,0x81,0x99,0x40,0x6e,0xc3,0x66,0x5a,0x20,0xc2,0xc3,
0xdb,0xdb,0x18,0x24,0x22,0xda,0xdb,0xdb,0x00,0xfe,0x00,0x80,0x40,0x80,0x1a,0x3a,
0x82,0x04,0xf0,0x70,0xb0,0x7f,0xf5,0xc7,0xfd,0xb9,0x00,0xc0,0xc0,0x80,0x3e,0xfe,
0xbe,0x06,0x22,0x86,0xe0,0xe0,0xc0,0xbe,0x1e,0xba,0x2f,0x00,0x10,0x18,0x08,0x74,
0x3c,0x2c,0x24,0x2c,0x38,0x38,0x30,0x20,0x47,0x18,0x10,0x18,0x10,0xae,0x10,0x18,
0x18,0x00,0xaa,0xce,0x00,0x24,0x24,0x34,0xb0,0x5a,0x7e,0x66,0x52,0x76,0x6e,0xfc,
0x3c,0x18,0x08,0x78,0x3c,0x18,0x24,0x24,0x24,0xba,0x2f,0x00,0x08,0x18,0x10,0x2e,
0x3c,0x34,0x24,0x34,0x1c,0x1c,0x0c,0x20,0x47,0x18,0x08,0x18,0x08,0xae,0x08,0x18,
0x18,0x00,0x00,0xaa,0x0f,0x00,0x34,0x10,0x18,0x18,0x0e,0x3c,0x6e,0x6e,0x24,0x24,
0x18,0x3e,0x18,0x08,0x08,0x00,0x22,0x3f,0x24,0x00,0x00};
const unsigned char stage2palette_bin[] = {
0x00,0x3f,0x34,0x3d,0x1d,0x0b,0x2b,0x05,0x15,0x00,0x03,0x17,0x02,0x01,0x01,0x00};
const unsigned char stage2tilemap_l[] = {
0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,
0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x02,0x03,0x02,0x04,0x05,0x06,0x05,0x07,0x08,0x09,0x08,0x0a,0x0b,0x0c,0x0b,
0x0d,0x0e,0x0f,0x0e,0x10,0x11,0x12,0x11,0x13,0x14,0x15,0x14,0x16,0x02,0x03,0x02,
0x04,0x05,0x06,0x05,0x07,0x08,0x09,0x08,0x0a,0x0b,0x0c,0x0b,0x0d,0x0e,0x0f,0x0e,
0x10,0x11,0x12,0x11,0x13,0x14,0x15,0x14,0x16,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x17,0x18,0x18,0x19,0x1a,0x1b,0x1a,0x1b,0x1a,0x1b,0x1a,0x1b,0x1a,0x1c,0x18,
0x18,0x1d,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,
0x1e,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,
0x2f,0x30,0x21,0x21,0x31,0x1f,0x1e,0x1f,0x1e,0x32,0x18,0x18,0x19,0x1a,0x1b,0x1a,
0x1b,0x1a,0x1b,0x1a,0x1b,0x1a,0x1b,0x1c,0x18,0x18,0x33,0x34,0x35,0x34,0x35,0x34,
0x35,0x34,0x35,0x34,0x35,0x34,0x35,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,
0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,
0x4d,0x4e,0x4f,0x50,0x51,0x34,0x52,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
0x18,0x18,0x53,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x54,0x55,
0x54,0x56,0x57,0x58,0x57,0x59,0x5a,0x5b,0x5a,0x5c,0x03,0x02,0x03,0x5d,0x0c,0x0b,
0x0c,0x5e,0x12,0x11,0x12,0x5f,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x60,0x61,0x61,
0x61,0x17,0x18,0x18,0x33,0x62,0x62,0x62,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,
0x3f,0x40,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x46,0x47,0x48,0x49,0x4a,0x4b,
0x4c,0x4d,0x4e,0x4f,0x50,0x62,0x62,0x62,0x62,0x62,0x52,0x18,0x18,0x1d,0x21,0x21,
0x21,0x21,0x21,0x21,0x31,0x1f,0x1e,0x1f,0x1e,0x32,0x18,0x18,0x19,0x1a,0x1b,0x1a,
0x1b,0x1a,0x1b,0x1a,0x1b,0x1a,0x1b,0x1c,0x18,0x18,0x1d,0x1f,0x1e,0x1f,0x1e,0x1f,
0x1e,0x20,0x21,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
0x78,0x79,0x21,0x21,0x31,0x1f,0x1e,0x1f,0x1e,0x32,0x18,0x18,0x19,0x1a,0x1b,0x1a,
0x1b,0x1a,0x1b,0x1a,0x1b,0x1a,0x1b,0x1c,0x18,0x18,0x1d,0x1f,0x1e,0x1f,0x1e,0x1f,
0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x1f,0x1e,0x20,0x21,0x21,0x21,0x21,0x21,0x21,
0x21,0x21,0x32,0x18,0x18,0x53,0x61,0x61,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,0x80,0x81,
0x82,0x83,0x84,0x61,0x85,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00};
const unsigned char stage2tilemap_m[] = {
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x02,0x00,0x02,0x00,
0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x00,0x02,0x00,
0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x03,0x00,0x03,0x00,
0x03,0x00,0x03,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,
0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,
0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,
0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x07,0x00,
0x05,0x00,0x08,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x09,0x00,
0x05,0x00,0x09,0x06,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x0a,0x00,
0x05,0x00,0x0b,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x07,0x00,
0x05,0x00,0x08,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x09,0x00,
0x05,0x00,0x09,0x06,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0f,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x12,0x02,
0x11,0x02,0x14,0x00,0x15,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x16,0x00,0x17,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x1a,0x02,
0x19,0x02,0x18,0x02,0x17,0x02,0x1c,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x1d,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x22,0x00,0x21,0x02,
0x20,0x02,0x1f,0x02,0x1e,0x02,0x1d,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x23,0x00,0x24,0x00,0x25,0x00,0x26,0x00,0x27,0x00,0x28,0x00,0x27,0x02,
0x26,0x02,0x25,0x02,0x24,0x02,0x23,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x29,0x00,0x2a,0x00,0x2b,0x00,0x2c,0x00,0x2d,0x00,0x2e,0x00,0x2d,0x02,
0x2c,0x02,0x2b,0x02,0x2a,0x02,0x2f,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00,0x34,0x02,
0x33,0x02,0x32,0x02,0x31,0x02,0x30,0x02,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x36,0x00,0x37,0x00,0x38,0x00,0x39,0x00,0x3a,0x00,0x3b,0x00,0x3a,0x02,
0x39,0x02,0x38,0x02,0x37,0x02,0x3c,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x3d,0x00,0x3e,0x00,0x3f,0x00,0x40,0x00,0x41,0x00,0x42,0x00,0x41,0x02,
0x40,0x02,0x3f,0x02,0x3e,0x02,0x43,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x44,0x00,0x45,0x00,0x46,0x00,0x47,0x00,0x48,0x00,0x49,0x00,0x48,0x02,
0x47,0x02,0x46,0x02,0x45,0x02,0x44,0x02,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x4e,0x00,0x4f,0x00,0x4e,0x02,
0x4d,0x02,0x4c,0x02,0x4b,0x02,0x50,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x51,0x00,0x52,0x00,0x53,0x00,0x54,0x00,0x55,0x00,0x56,0x00,0x55,0x02,
0x54,0x02,0x57,0x00,0x58,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x0a,0x00,
0x05,0x00,0x0b,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x07,0x00,0x05,0x00,
0x05,0x00,0x08,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0e,0x00,0x0f,0x00,0x5a,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x12,0x02,
0x11,0x02,0x5b,0x00,0x15,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x16,0x00,0x17,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x1a,0x02,
0x19,0x02,0x18,0x02,0x17,0x02,0x1c,0x00,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x1d,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x22,0x00,0x21,0x02,
0x20,0x02,0x1f,0x02,0x1e,0x02,0x1d,0x02,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x23,0x00,0x24,0x00,0x25,0x00,0x26,0x00,0x27,0x00,0x28,0x00,0x27,0x02,
0x26,0x02,0x25,0x02,0x24,0x02,0x23,0x02,0x0e,0x00,0x0e,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x29,0x00,0x2a,0x00,0x2b,0x00,0x2c,0x00,0x2d,0x00,0x2e,0x00,0x2d,0x02,
0x2c,0x02,0x2b,0x02,0x2a,0x02,0x2f,0x00,0x0e,0x00,0x0e,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00,0x34,0x02,
0x33,0x02,0x32,0x02,0x31,0x02,0x30,0x02,0x0e,0x00,0x0e,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x5c,0x00,0x37,0x00,0x38,0x00,0x39,0x00,0x3a,0x00,0x3b,0x00,0x3a,0x02,
0x39,0x02,0x38,0x02,0x37,0x02,0x3c,0x00,0x0e,0x00,0x0e,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x5d,0x00,0x3e,0x00,0x3f,0x00,0x40,0x00,0x41,0x00,0x42,0x00,0x41,0x02,
0x40,0x02,0x3f,0x02,0x3e,0x02,0x43,0x00,0x0e,0x00,0x0e,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x44,0x00,0x45,0x00,0x46,0x00,0x47,0x00,0x48,0x00,0x49,0x00,0x48,0x02,
0x47,0x02,0x46,0x02,0x45,0x02,0x44,0x02,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x4e,0x00,0x4f,0x00,0x4e,0x02,
0x4d,0x02,0x4c,0x02,0x4b,0x02,0x50,0x00,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x51,0x00,0x52,0x00,0x5e,0x00,0x54,0x00,0x55,0x00,0x56,0x00,0x55,0x02,
0x54,0x02,0x5f,0x00,0x58,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0f,0x00,0x10,0x00,0x11,0x00,
0x12,0x00,0x13,0x00,0x12,0x02,0x11,0x02,0x14,0x00,0x15,0x00,0x0e,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x16,0x00,0x17,0x00,0x18,0x00,0x19,0x00,
0x1a,0x00,0x1b,0x00,0x1a,0x02,0x19,0x02,0x18,0x02,0x17,0x02,0x60,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x1d,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,
0x21,0x00,0x22,0x00,0x21,0x02,0x20,0x02,0x1f,0x02,0x1e,0x02,0x1d,0x02,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x23,0x00,0x24,0x00,0x25,0x00,0x26,0x00,
0x27,0x00,0x28,0x00,0x27,0x02,0x26,0x02,0x25,0x02,0x24,0x02,0x23,0x02,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0e,0x00,0x0e,0x00,0x29,0x00,0x2a,0x00,0x2b,0x00,0x2c,0x00,
0x2d,0x00,0x2e,0x00,0x2d,0x02,0x2c,0x02,0x2b,0x02,0x2a,0x02,0x2f,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0e,0x00,0x0d,0x00,0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,
0x34,0x00,0x35,0x00,0x34,0x02,0x33,0x02,0x32,0x02,0x31,0x02,0x30,0x02,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0e,0x00,0x0e,0x00,0x36,0x00,0x37,0x00,0x38,0x00,0x39,0x00,
0x3a,0x00,0x3b,0x00,0x3a,0x02,0x39,0x02,0x38,0x02,0x37,0x02,0x3c,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x3d,0x00,0x3e,0x00,0x3f,0x00,0x40,0x00,
0x41,0x00,0x42,0x00,0x41,0x02,0x40,0x02,0x3f,0x02,0x3e,0x02,0x43,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x44,0x00,0x45,0x00,0x46,0x00,0x47,0x00,
0x48,0x00,0x49,0x00,0x48,0x02,0x47,0x02,0x46,0x02,0x45,0x02,0x44,0x02,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,
0x4e,0x00,0x4f,0x00,0x4e,0x02,0x4d,0x02,0x4c,0x02,0x4b,0x02,0x50,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x51,0x00,0x52,0x00,0x5e,0x00,0x54,0x00,
0x55,0x00,0x61,0x00,0x55,0x02,0x62,0x00,0x5f,0x00,0x58,0x00,0x0e,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x0a,0x00,0x05,0x00,
0x05,0x00,0x0b,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x02,
0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x02,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x03,0x00,0x03,0x00,
0x03,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x44,0x00,0x45,0x00,0x46,0x00,0x47,0x00,0x48,0x00,0x49,0x00,0x48,0x02,
0x47,0x02,0x46,0x02,0x45,0x02,0x44,0x02,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x4e,0x00,0x4f,0x00,0x4e,0x02,
0x4d,0x02,0x4c,0x02,0x4b,0x02,0x50,0x00,0x0e,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x51,0x00,0x52,0x00,0x5e,0x00,0x54,0x00,0x55,0x00,0x56,0x00,0x55,0x02,
0x54,0x02,0x5f,0x00,0x58,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0f,0x00,0x10,0x00,0x11,0x00,
0x12,0x00,0x13,0x00,0x12,0x02,0x11,0x02,0x14,0x00,0x15,0x00,0x0e,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,0x05,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0e,0x00,0x16,0x00,0x17,0x00,0x18,0x00,0x19,0x00,
0x1a,0x00,0x1b,0x00,0x1a,0x02,0x19,0x02,0x18,0x02,0x17,0x02,0x60,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0f,0x00,0x10,0x00,0x11,0x00,0x12,0x00,0x13,0x00,0x12,0x02,0x11,0x02,
0x14,0x00,0x15,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x16,0x00,0x17,0x00,0x18,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,0x1a,0x02,0x19,0x02,
0x18,0x02,0x17,0x02,0x1c,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x1d,0x00,0x1e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x22,0x00,0x21,0x02,0x20,0x02,
0x1f,0x02,0x1e,0x02,0x1d,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x23,0x00,0x24,0x00,0x25,0x00,0x26,0x00,0x27,0x00,0x28,0x00,0x27,0x02,0x26,0x02,
0x25,0x02,0x24,0x02,0x23,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x29,0x00,0x2a,0x00,0x2b,0x00,0x2c,0x00,0x2d,0x00,0x2e,0x00,0x2d,0x02,0x2c,0x02,
0x2b,0x02,0x2a,0x02,0x2f,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00,0x34,0x02,0x33,0x02,
0x32,0x02,0x31,0x02,0x30,0x02,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x36,0x00,0x37,0x00,0x38,0x00,0x39,0x00,0x3a,0x00,0x3b,0x00,0x3a,0x02,0x39,0x02,
0x38,0x02,0x37,0x02,0x3c,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x3d,0x00,0x3e,0x00,0x3f,0x00,0x40,0x00,0x41,0x00,0x42,0x00,0x41,0x02,0x40,0x02,
0x3f,0x02,0x3e,0x02,0x43,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x44,0x00,0x45,0x00,0x46,0x00,0x47,0x00,0x48,0x00,0x49,0x00,0x48,0x02,0x47,0x02,
0x46,0x02,0x45,0x02,0x44,0x02,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x4a,0x00,0x4b,0x00,0x4c,0x00,0x4d,0x00,0x4e,0x00,0x4f,0x00,0x4e,0x02,0x4d,0x02,
0x4c,0x02,0x4b,0x02,0x50,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x51,0x00,0x52,0x00,0x53,0x00,0x54,0x00,0x55,0x00,0x56,0x00,0x55,0x02,0x54,0x02,
0x57,0x00,0x58,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x09,0x00,
0x05,0x00,0x09,0x06,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x19,0x00,0x1a,0x00,0x1b,0x00,
0x1a,0x02,0x19,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x19,0x00,0x1a,0x00,
0x1b,0x00,0x1a,0x02,0x19,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,0x22,0x00,
0x21,0x02,0x20,0x02,0x1f,0x02,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x1f,0x00,0x20,0x00,0x21,0x00,
0x22,0x00,0x21,0x02,0x20,0x02,0x1f,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x25,0x00,0x26,0x00,0x27,0x00,0x28,0x00,
0x27,0x02,0x26,0x02,0x25,0x02,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x25,0x00,0x26,0x00,0x27,0x00,
0x28,0x00,0x27,0x02,0x26,0x02,0x25,0x02,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x2b,0x00,0x2c,0x00,0x2d,0x00,0x2e,0x00,
0x2d,0x02,0x2c,0x02,0x2b,0x02,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x2b,0x00,0x2c,0x00,0x2d,0x00,
0x2e,0x00,0x2d,0x02,0x2c,0x02,0x2b,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00,
0x34,0x02,0x33,0x02,0x32,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x32,0x00,0x33,0x00,0x34,0x00,
0x35,0x00,0x34,0x02,0x33,0x02,0x32,0x02,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x39,0x00,0x3a,0x00,0x3b,0x00,
0x3a,0x02,0x39,0x02,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x39,0x00,0x3a,0x00,
0x3b,0x00,0x3a,0x02,0x39,0x02,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,
0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,
0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00,0x59,0x00};
const unsigned char stage2tiles_psgcompr[] = {
0x63,0x00,0xaa,0xff,0x03,0xff,0x0c,0xe7,0x33,0x13,0x13,0xe7,0x3c,0x1c,0x1c,0xaa,
0xff,0xc0,0xff,0x30,0xc3,0xc8,0xcc,0xcc,0xcc,0xcc,0xc3,0x38,0x3c,0x3c,0x3c,0x3c,
0x3b,0x74,0xce,0xce,0x92,0x73,0xb9,0xc2,0x00,0x01,0x02,0x31,0x21,0x4c,0x08,0x04,
0x29,0x5e,0x03,0x76,0xfd,0xe7,0xde,0x73,0xbd,0xeb,0x5e,0x2a,0x7f,0x00,0xff,0x01,
0x41,0xf0,0x00,0xaa,0x55,0xaa,0x02,0xaa,0x55,0xaa,0xaa,0xaa,0xaa,0x2a,0xf6,0x00,
0xff,0xff,0x01,0x07,0xff,0x55,0xaa,0x55,0x00,0x00,0x2b,0xf0,0x00,0x80,0x80,0x80,
0x80,0x01,0x55,0xaa,0x55,0xaa,0x15,0x2a,0x15,0x2a,0x2b,0xf0,0x00,0x01,0x01,0x01,
0x01,0x01,0x55,0xaa,0x55,0xaa,0x54,0xa8,0x54,0xa8,0x2a,0xff,0x80,0x01,0xaa,0x15,
0x2a,0x2a,0x2a,0x2a,0x2a,0x7f,0x00,0x80,0x01,0x55,0xaa,0x55,0xd5,0x55,0x55,0x2b,
0x7f,0x00,0x01,0x01,0x54,0xab,0x55,0xab,0x54,0xaa,0x55,0xaa,0xce,0x80,0xa1,0xd7,
0x7a,0xcf,0xb9,0xf7,0xcf,0x80,0xe1,0xdf,0x7b,0xef,0xbd,0xf7,0xdf,0x02,0xce,0xd4,
0xbf,0xb3,0xee,0xde,0xfb,0xbd,0xe7,0xd6,0xff,0xbb,0xef,0xfe,0xff,0xbd,0xf7,0x02,
0xfb,0xfd,0xef,0xd2,0xb5,0x6a,0xd3,0xad,0xfb,0x21,0x61,0x12,0x20,0x6a,0x40,0x0c,
0x00,0x20,0x6c,0xf5,0xb1,0x8d,0xeb,0xdc,0x82,0x40,0x84,0x00,0x81,0xa1,0xfa,0xfb,
0xfd,0xef,0xd2,0xb5,0x6b,0xd7,0xae,0xff,0x21,0x61,0x12,0x20,0x68,0x40,0x03,0x03,
0x20,0x6d,0xf5,0xb1,0x8f,0xdc,0x82,0x40,0x84,0x03,0x87,0xad,0xfc,0xea,0xd4,0xbe,
0xb7,0xe3,0xdc,0xdc,0xbf,0x7f,0x9c,0x00,0x03,0x03,0xe3,0xe3,0x20,0xbc,0xff,0xff,
0xff,0x20,0x9c,0xfd,0xb4,0x5c,0x9c,0xfb,0x79,0xef,0xff,0xd9,0x7f,0x5f,0x6f,0xdd,
0x00,0xb9,0xb9,0x70,0x39,0x39,0xf6,0xf6,0x63,0xff,0x79,0xf9,0x77,0x77,0x79,0x56,
0x46,0xa9,0x4e,0x6e,0x99,0x2b,0xfa,0xbf,0xfd,0xdf,0xff,0xde,0xf5,0xef,0xf7,0x0c,
0xb1,0x93,0x4c,0xc2,0xc1,0x43,0x43,0x7f,0xff,0xbf,0x41,0x7f,0xb3,0xaa,0x6c,0xff,
0x99,0x99,0x7e,0xbd,0xe0,0x00,0x18,0x99,0x99,0x66,0xa5,0x6f,0xff,0x99,0x99,0x41,
0x6f,0x99,0x81,0xea,0x14,0x7f,0xe3,0xc6,0x3b,0x3b,0xfd,0xfe,0x9c,0x00,0xc0,0xc0,
0xc7,0xc7,0x43,0xff,0x16,0xeb,0xc7,0x3b,0x3b,0x22,0x9c,0xbf,0x2b,0x3a,0x39,0xfb,
0xfd,0xef,0xd2,0xb5,0xea,0xf3,0x7d,0xfb,0x21,0x61,0x12,0x20,0x2a,0x00,0xcc,0xc0,
0x20,0x6d,0xf5,0xb1,0xfd,0xdc,0x82,0x40,0x84,0xc0,0xe1,0xb1,0x3a,0xfb,0xff,0xef,
0xd7,0xbf,0x6e,0xfd,0xbd,0xd4,0x20,0x61,0x11,0x22,0x61,0x41,0x01,0x3c,0x20,0x76,
0xf7,0x6f,0xfc,0xdf,0x86,0x46,0x8d,0x0f,0xbc,0xbc,0xe8,0xff,0xe7,0x1b,0x9b,0xdf,
0xff,0xbb,0x7b,0x7e,0x00,0x80,0x80,0x7f,0x87,0xe3,0xe3,0x87,0xe7,0x9b,0x9b,0xff,
0xfc,0xfb,0xfb,0xfd,0xe7,0x9b,0x1b,0xa0,0x7b,0x58,0x98,0xfb,0xef,0xfb,0x27,0x3d,
0xde,0xff,0x6f,0xb7,0xfc,0x86,0xdc,0x3f,0x3f,0x07,0x1b,0xd8,0xff,0x3c,0x3e,0xdd,
0xff,0xb7,0x6f,0xfc,0x27,0x1b,0x03,0xdb,0xe4,0xfb,0xfb,0x24,0xea,0xff,0xfe,0x7d,
0xff,0xf1,0x8e,0x8e,0x39,0x07,0x00,0x3f,0x8f,0x8f,0xc1,0x80,0x20,0x0f,0xf7,0x79,
0xfb,0x7f,0x20,0x07,0xc8,0xf7,0xf6,0xbe,0x71,0xea,0xf3,0x70,0xf0,0xfc,0x8f,0x50,
0x30,0x0c,0x0f,0x00,0xb0,0xf0,0xf0,0x8c,0x20,0x98,0xc0,0xc0,0x70,0x70,0x8c,0x22,
0x0f,0x43,0xb0,0x30,0x70,0xea,0xff,0xff,0xdb,0x7e,0x99,0x3c,0x66,0x81,0x17,0x00,
0xe7,0x7e,0x5a,0x18,0x96,0x7e,0x99,0xbd,0x99,0x81,0x22,0x17,0x99,0xe7,0xe7,0x81,
0xfb,0xfd,0xef,0xf2,0xf5,0x7a,0xbf,0xbd,0x2b,0x21,0x81,0x92,0x40,0x8a,0x80,0x80,
0x3c,0x20,0x66,0xf5,0xf1,0xfa,0x3f,0xdc,0x62,0x60,0xb4,0xf0,0x3d,0x3d,0x16,0xfb,
0xf3,0xd2,0xf2,0xf3,0xcf,0x37,0x2a,0xff,0xc1,0xe1,0x41,0x41,0x03,0x3d,0x3d,0x7c,
0xf0,0xf3,0xcc,0x3f,0x3f,0xcf,0x32,0x33,0xb3,0xb2,0xcf,0x0a,0x17,0xb3,0xfb,0x7b,
0xe6,0xaf,0x5b,0xfb,0xd9,0xba,0x9b,0x9f,0x9f,0xf4,0xe4,0xfc,0xe2,0xe1,0x1b,0x26,
0xfb,0xe4,0xf9,0xff,0x7f,0x9b,0xff,0x7f,0x5f,0xbf,0x87,0x3b,0x5b,0x80,0xfa,0xf8,
0xb8,0x60,0xa2,0xe3,0xc4,0xc4,0x67,0xe1,0xe4,0xc3,0xc3,0x03,0xc0,0xc0,0xe3,0x38,
0xe3,0xf9,0xfc,0x04,0x04,0xa7,0x07,0xc4,0x19,0x5c,0xa3,0x61,0xe0,0xfa,0x70,0x70,
0xb0,0xf0,0x48,0x40,0x40,0xc0,0x70,0x70,0xc0,0xc0,0x80,0x00,0x00,0x80,0x20,0x17,
0x30,0x30,0xf0,0xc8,0xc7,0x40,0x70,0x30,0xc8,0xca,0x30,0x50,0x40,0x40,0x00,0x20,
0x30,0x0c,0x20,0x3b,0x70,0x70,0x30,0x02,0x8a,0x0f,0x00,0x5a,0x66,0x81,0x81,0x20,
0x3f,0x7e,0x7e,0x02,0xff,0xfd,0xd8,0xb5,0xf1,0xb2,0xb2,0x83,0x83,0xc2,0xf5,0xf9,
0x03,0x02,0x02,0x0b,0x13,0xff,0xfd,0xfd,0xf3,0xb2,0xb2,0x8b,0x93,0x3f,0x2d,0x4c,
0xf2,0xb0,0xb0,0x88,0x90,0xfb,0xfe,0xa5,0x66,0xa7,0x1a,0x0d,0x67,0x67,0x63,0xe3,
0xe3,0xc7,0x27,0x17,0x80,0x80,0x13,0xe7,0x9d,0xe6,0xe5,0x3f,0x1b,0xff,0x47,0x87,
0x60,0x3d,0x1e,0xe7,0xe7,0xea,0xb8,0x8b,0x73,0xe0,0xe4,0x64,0xba,0xed,0xe0,0xf8,
0x00,0x04,0x84,0x5f,0x1f,0x61,0xfb,0xf8,0xe0,0xe4,0xe4,0xff,0x1c,0xe0,0x40,0x73,
0x8b,0xe5,0xf6,0xea,0x30,0x88,0x88,0x00,0x48,0x48,0xc0,0x40,0xfc,0x00,0x80,0x80,
0x20,0xfe,0xc0,0x22,0xfd,0x40,0x02,0x13,0x33,0x00,0x0c,0x0c,0x4f,0x4f,0x0a,0xfc,
0x00,0x18,0x18,0x70,0x7e,0x81,0x99,0x99,0xff,0xff,0xfb,0xf3,0xb6,0xba,0xfd,0xf4,
0xec,0xf3,0xff,0x06,0x0c,0x0c,0x01,0x3c,0x3c,0xc1,0xb2,0x20,0x13,0xf7,0xfe,0xbe,
0xfc,0xfc,0xf5,0xfa,0xb6,0xfc,0xc8,0xd0,0x32,0x4d,0xff,0x9d,0x76,0x6d,0xfb,0x3f,
0x7e,0xf5,0xeb,0x03,0x1b,0x1b,0xe3,0x47,0x07,0x9f,0x1f,0x9f,0x6f,0x77,0xfb,0x7c,
0x7d,0xea,0xf7,0x9e,0x7d,0x7e,0x18,0x7b,0x7b,0x7f,0xfc,0xfb,0xdf,0xc4,0xc4,0xe3,
0x52,0xa9,0xfc,0xfc,0xc4,0x00,0x00,0xe3,0xe9,0xf2,0xc0,0x3c,0x20,0xe2,0x20,0xfb,
0xfb,0xd8,0x1b,0xc4,0xc4,0xc3,0xbb,0x5b,0x3c,0xe4,0xaa,0x61,0x30,0x88,0x80,0xc8,
0xc8,0x40,0xe3,0x00,0x80,0x40,0x40,0x20,0xef,0x00,0x20,0xf3,0x88,0x88,0x02,0x6c,
0x3f,0x7f,0x7f,0x7f,0x33,0x09,0x6c,0xff,0x7e,0x7e,0x7e,0x18,0xff,0xcc,0x6f,0x53,
0xbe,0x2e,0x37,0xcf,0xff,0x60,0x30,0x30,0x80,0x3c,0x3c,0x83,0x4d,0xee,0x7f,0x7b,
0xbf,0x3e,0x3f,0xcf,0xff,0xae,0x5f,0x6b,0x3f,0x12,0x0b,0x4c,0xb2,0xfb,0xf3,0xf3,
0xce,0x3f,0xfe,0xf5,0xab,0x5d,0x41,0x41,0x03,0x3d,0x7d,0xca,0xd4,0xf1,0x20,0xd0,
0xcd,0xcf,0xff,0xff,0xfd,0xb2,0xb2,0xcf,0x02,0xb3,0x3f,0x7f,0xac,0xfb,0xbf,0x5f,
0xbf,0x7b,0x9b,0xfc,0xfa,0xe7,0xe4,0xe4,0xf8,0xe0,0x1b,0x63,0x67,0xf3,0xd0,0xfb,
0x7f,0x9b,0x9f,0x9d,0xf4,0x5f,0xbf,0xc7,0x9b,0x80,0xff,0xff,0x17,0xff,0xfd,0xfa,
0xec,0xb8,0x67,0xff,0xff,0xdd,0xe6,0xe5,0x38,0xe0,0xc4,0xdf,0xdf,0xdb,0xff,0xff,
0xdc,0x78,0xa7,0xfb,0xfb,0xc6,0x1b,0x1f,0xf4,0xd8,0xe3,0x24,0x24,0x1f,0xff,0x0a,
0x84,0x3b,0x37,0xbf,0xcf,0xcf,0x77,0x8e,0x0e,0x3f,0x0f,0x07,0x89,0x89,0xc0,0x84,
0x8a,0x36,0x39,0xbe,0xcf,0xcf,0xb7,0x8e,0x8e,0x0d,0x3e,0xb9,0x46,0x46,0xf7,0xea,
0x00,0x00,0x80,0xc0,0xc0,0xcf,0xcb,0x87,0x38,0x80,0x00,0x00,0x83,0x87,0x0c,0xe0,
0x00,0xc0,0x40,0xcc,0xcc,0x8b,0x16,0x4f,0x0f,0x0f,0x8f,0xc0,0x8f,0xaa,0xf8,0x00,
0x81,0x81,0xa5,0xfe,0x00,0xc3,0x20,0xfe,0x66,0xe0,0xff,0xe7,0x66,0x81,0x81,0xe7,
0xeb,0xf3,0xf3,0xb2,0xc0,0x81,0xc3,0xb3,0xea,0xd0,0x01,0x02,0x03,0x07,0x0a,0x0c,
0x20,0xe0,0xc1,0x83,0xc7,0xbb,0xfe,0xf2,0xf2,0xb0,0xc1,0x82,0xc4,0xb9,0xf6,0xbb,
0x4c,0xe7,0xa7,0x1f,0xff,0x9f,0x77,0xcf,0x97,0x87,0xf8,0x80,0x80,0x03,0x1b,0x20,
0x0e,0xef,0xf7,0x9b,0x7f,0x6f,0x68,0x70,0x9c,0x87,0x67,0x67,0x9c,0x7c,0xef,0xe6,
0xe5,0xe7,0xef,0xd4,0xec,0xdf,0xf9,0xe0,0x23,0x38,0x38,0x38,0xf8,0x3e,0xc5,0xc6,
0xe7,0xf7,0xec,0xd4,0xff,0xff,0xe7,0xe7,0xc4,0xdf,0xfc,0xfc,0x27,0xc7,0xef,0xa8,
0x50,0xf9,0xee,0x7b,0x7d,0x3f,0x8f,0xe0,0xf8,0x7e,0x7f,0x7f,0xb1,0x06,0x50,0xa8,
0xb1,0xd6,0x3d,0x3b,0x8e,0x8f,0xf8,0xf8,0x49,0xb8,0x46,0x46,0xbf,0x89,0xff,0x2b,
0x17,0xa9,0x1a,0xbd,0x9b,0xbf,0x3b,0x1c,0x2c,0x3f,0x2f,0xcf,0xaf,0xcc,0x84,0x37,
0x3b,0x9f,0x3d,0xfe,0xbc,0x73,0xbf,0x3f,0x3f,0xb6,0x37,0x73,0x37,0xff,0xbf,0xaf,
0xaa,0xdb,0xbd,0xbd,0xa5,0xa5,0xd0,0xe7,0xff,0x7e,0x66,0x3c,0xff,0xbd,0xdb,0x66,
0x7e,0xbd,0xdb,0xff,0x5a,0x7e,0x7e,0xbd,0xdb,0xe7,0xff,0xe7,0xff,0xeb,0xcf,0xcf,
0x4d,0x02,0x80,0xc3,0xcd,0x57,0xd0,0x80,0x40,0xc0,0xe0,0x50,0x30,0x20,0xe0,0x83,
0xc0,0xe3,0xdd,0x77,0x4f,0x4f,0x0d,0x83,0x40,0x23,0x9d,0x67,0xfb,0xd6,0xad,0xfc,
0xf3,0xaf,0xdf,0xf3,0xce,0x0c,0x11,0x3c,0xc1,0xf2,0xb2,0x41,0x03,0x20,0x32,0xde,
0xfd,0xff,0xff,0xcd,0xda,0xfc,0xc0,0x32,0x5d,0x6d,0xb2,0xcf,0xff,0x6f,0xfb,0x7e,
0xf5,0xef,0xf7,0xf7,0xff,0x1b,0xe3,0x07,0x9f,0x1f,0x1f,0xec,0xf8,0x77,0xfb,0x7d,
0xea,0xf7,0xef,0xfb,0x7f,0x7c,0x18,0x7b,0x7f,0xf8,0xf8,0x1f,0x87,0xfb,0xf8,0xfe,
0xfb,0xfd,0xf9,0xf6,0xaf,0xdf,0x3f,0xff,0xe7,0xfb,0x3f,0x3b,0xfb,0x3c,0x0e,0xdf,
0xff,0x1b,0xfc,0xff,0xff,0xc7,0xe5,0x1f,0x06,0xe6,0xed,0x74,0xe3,0xfb,0x8e,0xff,
0xfe,0xcf,0x3e,0xdd,0xae,0x7d,0x07,0xb7,0xc7,0x89,0xcf,0xae,0x9f,0xf6,0x4c,0xff,
0x8f,0x79,0xcf,0xb9,0xfb,0x89,0x48,0xbf,0x46,0xf1,0x73,0x37,0x8f,0xff,0xbd,0x7b,
0xf5,0x3b,0xfb,0xed,0xfe,0xbd,0x02,0xb4,0xcf,0x8f,0x0f,0x1f,0x83,0x03,0xbf,0xcf,
0xfe,0xbc,0xff,0xff,0x7f,0xbf,0xbf,0xff,0x3b,0xb7,0xf4,0xf2,0xfd,0xbe,0xbb,0x1c,
0x99,0x7e,0xc3,0xa5,0xdb,0xbd,0xff,0xa5,0xdb,0x81,0x24,0x42,0x66,0x66,0x63,0xff,
0x99,0x99,0xbd,0xdb,0xe7,0x7e,0x7e,0x18,0xbd,0xdb,0xbd,0xdb,0xfb,0x64,0xb7,0x3f,
0xcf,0xf5,0xfb,0xcf,0x73,0x30,0x88,0x3c,0x83,0x4f,0x4d,0x82,0xc0,0x20,0x32,0x76,
0xbf,0xff,0xff,0xb3,0x56,0x3f,0x03,0x4c,0xba,0xb6,0x4d,0xf3,0xff,0x2b,0x36,0xff,
0xfe,0xfd,0xe3,0x53,0x92,0x3d,0x3d,0x7c,0x7d,0xc2,0x11,0xa1,0x22,0x3f,0x3f,0xcf,
0xcf,0xff,0xf3,0xf3,0xb2,0x16,0x0b,0xb3,0xb3,0x3f,0xf2,0xf2,0xb0,0xff,0xfb,0xd9,
0x19,0x93,0xff,0xe7,0xe7,0x17,0xe0,0xe2,0x9b,0x1b,0x63,0x97,0x87,0x2f,0xfb,0xfb,
0x9b,0x9b,0x9c,0xf7,0xe7,0x3b,0x1b,0x3b,0x82,0x88,0xff,0x70,0x60,0x3c,0xfe,0x7d,
0xfe,0xfc,0xfc,0xff,0xff,0xbf,0x7d,0xe6,0xe5,0xe0,0xe0,0xfb,0x27,0x67,0xa3,0xbf,
0x3f,0x3c,0x3c,0xdf,0xfc,0xfc,0xff,0xc6,0xdb,0xdc,0xdc,0x24,0xde,0xff,0x77,0xf7,
0x7f,0x7f,0xff,0xf5,0x73,0xa5,0xc7,0x47,0x77,0x77,0xc7,0xf2,0xf4,0xf3,0xf6,0xf6,
0x0f,0x0f,0xb9,0x77,0xf7,0xf7,0xb1,0xb1,0x78,0x78,0x7e,0x87,0x87,0x56,0xff,0xc3,
0xc1,0xcb,0xc7,0xef,0xf6,0xee,0xdd,0x84,0x82,0x84,0x88,0x93,0x7b,0x73,0xf3,0x47,
0x43,0xcf,0xcf,0xff,0xbf,0xbf,0xff,0xc7,0xc3,0x4f,0x4f,0x7c,0xcd,0xdd,0x2e,0xfa,
0xdb,0xbd,0x7e,0xbd,0x00,0xff,0xff,0xc3,0xe7,0xe7,0x99,0xdb,0x81,0x7e,0x7e,0x66,
0xf1,0xff,0x99,0x99,0x99,0x26,0xe7,0x3c,0x5a,0x66,0x99,0xbd,0xfe,0xc1,0xc1,0xc2,
0xb1,0x73,0xde,0xaf,0xfb,0x01,0x01,0x03,0x22,0x62,0x4c,0x0d,0x00,0xc0,0xc0,0xc3,
0xb3,0x73,0xde,0x8f,0xeb,0x20,0xc1,0x41,0x93,0x11,0x82,0xa2,0xff,0xdd,0xa3,0xe5,
0x97,0x8f,0x7f,0xff,0xfc,0xfa,0xfc,0x82,0x2b,0x13,0x1b,0xfb,0x78,0x7f,0x7f,0xe7,
0xbf,0x9f,0x67,0x9f,0xfc,0xa7,0xdf,0x67,0xbc,0x9c,0x7c,0x64,0x84,0xfb,0xb3,0x7a,
0x7f,0xf9,0xf2,0xfa,0xe7,0xe4,0x5b,0x9b,0xb8,0xfb,0xfb,0x23,0x20,0xc2,0xc4,0xfb,
0xff,0xdb,0xdb,0xe7,0xe6,0xe8,0xe1,0xc7,0x22,0x29,0xd9,0xc7,0x26,0xff,0x46,0xcd,
0x3b,0x7d,0xbb,0xf6,0xf5,0x0e,0xef,0xd7,0xc7,0xf7,0xf7,0x81,0x47,0x47,0xef,0xdf,
0xfe,0xff,0xff,0xf7,0xb6,0x4f,0xa9,0x1a,0xfd,0x8a,0x4c,0x77,0xf3,0x49,0xff,0xbb,
0xd7,0xbb,0xb3,0x63,0xd3,0xe0,0xf3,0xcc,0xac,0xf4,0xcb,0xd3,0xa0,0xd0,0x88,0xff,
0xff,0x7f,0xfb,0xf3,0xf3,0x70,0xfb,0x77,0x7b,0xcf,0x78,0xb0,0x73,0xb0,0x7b,0xab,
0x91,0xbd,0xdb,0xff,0xc3,0xff,0xe7,0xc9,0x66,0x81,0x7e,0xe7,0x81,0xf9,0xff,0x99,
0xe7,0xdb,0xbd,0x7e,0xc3,0xbd,0x7e,0x66,0xdb,0xff,0x83,0x83,0x42,0x8d,0xca,0x73,
0xed,0xfb,0x81,0x81,0xc2,0x40,0x42,0x30,0x8c,0x00,0x03,0x03,0xc2,0xc9,0xca,0x73,
0xcd,0xeb,0x82,0x82,0x80,0xcc,0x88,0x41,0x61,0xfa,0xfb,0xfd,0xef,0xd2,0xb5,0x6a,
0xd3,0xad,0xfb,0x20,0x61,0x12,0x20,0x6a,0x40,0x0c,0x00,0x20,0x6c,0xf5,0xb1,0x8d,
0xeb,0xdd,0x82,0x40,0x84,0x00,0x81,0xa1,0xfa,0xfb,0xfc,0xfb,0xc7,0xb5,0x6a,0xd3,
0xad,0xfb,0x78,0x00,0x03,0x20,0x6a,0x40,0x0c,0x00,0x20,0xcc,0xc4,0xb1,0x8d,0xeb,
0x84,0xfb,0x47,0x84,0x00,0x81,0xa1,0xfa,0xef,0xe0,0xf4,0xfc,0xe5,0xd7,0xff,0xbf,
0xe7,0x0e,0x03,0xc4,0xdc,0x05,0x02,0x00,0xe4,0xfc,0xfd,0xe7,0xf7,0xff,0xbf,0xf7,
0x24,0x28,0xf9,0xe7,0xf4,0xfc,0xbc,0xf7,0xeb,0x4d,0x43,0x4d,0xcb,0xb7,0xbb,0xb7,
0xff,0x0e,0x8e,0x87,0x0f,0x96,0x27,0x01,0x0e,0xbf,0xcf,0x4d,0xdf,0xef,0xff,0xca,
0x4e,0xdb,0xec,0x39,0x35,0x39,0xfe,0xfa,0xf3,0xcc,0xc4,0xe0,0x9c,0xac,0x9c,0xe3,
0x8c,0xd0,0x08,0x90,0x20,0x10,0x20,0xd0,0x0e,0xbc,0xff,0xdc,0xcc,0xf0,0xf3,0x22,
0x2e,0x7f,0x1c,0x70,0x33,0xaa,0x91,0xdb,0xbd,0xe7,0x24,0x66,0x3c,0xe0,0x66,0x24,
0x5a,0x00,0x42,0x24,0xd1,0xff,0xe7,0x7e,0x7e,0x7e,0x22,0x1f,0xbd,0xdb,0x81,0xef,
0x07,0x2f,0x3f,0xae,0xee,0xfb,0xfd,0xe7,0x0e,0xc0,0x23,0x3b,0xa0,0x40,0x00,0x27,
0x3f,0xbf,0xef,0xee,0xff,0xfd,0xf7,0x24,0x14,0x9f,0xef,0x2e,0x3f,0x3d,0xf7,0xfb,
0x3f,0xdf,0xe2,0xb5,0x6a,0xd3,0xad,0xfb,0x1e,0x00,0xc2,0x20,0x6a,0x40,0x0c,0x00,
0x20,0xcc,0x22,0xb1,0x8d,0xeb,0x21,0xdf,0xe0,0x84,0x00,0x81,0xa1,0xfa,0xaa,0x1c,
0x00,0xff,0x9f,0x04,0xf1,0x0e,0xf0,0x00,0xf1,0xff,0xff,0x0e,0xfe,0xff,0x0e,0x02,
0xfa,0xfc,0xee,0xd7,0xa3,0xdc,0xdc,0xbf,0x7f,0x20,0x63,0x13,0x20,0x00,0x00,0xe3,
0xe3,0x20,0x3c,0xf4,0xef,0xff,0xff,0x8c,0xdc,0x85,0x44,0x83,0x5c,0x9c,0xeb,0x3d,
0x6f,0xe2,0xc5,0x3b,0x3b,0xfd,0xfe,0x1c,0x00,0x21,0xc1,0xc2,0xc7,0xc7,0x20,0x2c,
0x35,0xef,0xc1,0xff,0xff,0x1c,0xa2,0x20,0xc4,0x3b,0x3b,0x3a,0x39,0xeb,0xf3,0xf3,
0xb2,0xc0,0x01,0xc3,0xb3,0xfa,0xd0,0x01,0x02,0x03,0x47,0x0a,0x0c,0x20,0xe0,0xc1,
0x03,0xc7,0x9b,0xee,0xf2,0xf2,0xb0,0xc1,0x02,0x84,0xb9,0xf6,0xfb,0xf6,0xed,0xfc,
0xf3,0xaf,0xdf,0xf3,0xce,0x2c,0x51,0x3c,0xc1,0xf2,0xb2,0x41,0x03,0x20,0x32,0xfe,
0xfd,0xff,0xff,0xcd,0xda,0xbc,0x40,0x32,0x5d,0x6d,0xb2,0xcf,0xff,0xe0,0xf4,0xfc,
0xb5,0x67,0xd7,0xaf,0xfb,0xc4,0xdc,0x05,0x22,0x63,0x43,0x0f,0x00,0xe4,0xfc,0xfd,
0xb7,0x67,0xd7,0x8f,0xeb,0x24,0x28,0xf9,0x87,0x04,0x84,0xa0,0xfa,0xff,0x07,0x2f,
0x3f,0xa5,0xea,0xf3,0xed,0xfb,0x23,0x3b,0xa0,0x40,0xca,0xc0,0xcc,0x00,0x27,0x3f,
0xbf,0xe1,0xea,0xf3,0xcd,0xeb,0x24,0x14,0x9f,0xe4,0x20,0x21,0x21,0xfa,0xeb,0xd4,
0xff,0xf3,0xfe,0x7e,0xbf,0xbd,0x2b,0x6e,0x80,0x00,0x40,0x3c,0x20,0x46,0xd6,0xfb,
0xff,0xfe,0x3f,0xd6,0x7f,0x7b,0xbf,0xfe,0x3f,0x3d,0x17,0xaa,0x91,0xdb,0xbd,0xe7,
0x24,0x66,0x3c,0xe0,0x66,0x24,0x5a,0x00,0x42,0x24,0xd1,0xff,0xe7,0x7e,0x7e,0x7e,
0x22,0x1e,0xbd,0xdb,0x81,0xfe,0xeb,0xb2,0xc2,0xb2,0xd3,0xed,0xdd,0xed,0xfb,0x0e,
0x71,0xe1,0xf0,0x69,0xe4,0x80,0x0e,0xfd,0xf3,0xb2,0xfb,0xf7,0xfb,0x53,0x72,0xdb,
0x37,0x9c,0xac,0x9c,0x7a};
const unsigned char ww2ship_psgcompr[] = {
0x04,0x00,0xba,0xe8,0x00,0x01,0x01,0x78,0x01,0x00,0x00,0x01,0x03,0x0c,0x7e,0xfd,
0xc2,0xf0,0x00,0x03,0x05,0x02,0x3d,0x20,0xf6,0x03,0x3c,0xba,0xe8,0x00,0xc0,0xc0,
0x0c,0xc0,0x08,0x08,0xc8,0xe8,0x18,0x3c,0xde,0x23,0xf0,0x00,0xe0,0xd0,0x20,0xdc,
0x20,0xf6,0xe0,0x1c,0xaa,0x63,0x00,0x47,0xff,0x3f,0x0f,0x20,0x0f,0xb8,0x7f,0x40,
0xe0,0x0f,0x00,0x07,0x38,0x3f,0x1f,0x7f,0x00,0x07,0xaa,0x63,0x00,0xf2,0xff,0xfc,
0xf0,0x20,0x0f,0x0d,0xff,0x02,0x07,0x0f,0x00,0xf0,0x0e,0xfc,0xf8,0x7f,0x00,0xf0};
|
the_stack_data/7532.c
|
//
// main.c
// Binary Search Tree
//
// Created by Bikramjit Saha on 01/07/20.
// Copyright © 2020 Bikramjit Saha. All rights reserved.
//
#include <stdio.h>
#include <stdlib.h>
struct Node{
struct Node*lchild;
int data;
struct Node*rchild;
}*root=NULL;
void Insert(struct Node*p,int key){
struct Node*t,*f=NULL;// f->follow or tail pointer
if (root==NULL) {
t=(struct Node*)malloc(sizeof(struct Node));
t->data=key;
t->lchild=t->rchild=NULL;
root=t;// root becomes the new node
return;
}
while (p) {
f=p;
if (key==p->data) {
return ;// when key is found don't return anything
}else if (key<p->data){
p=p->lchild;
}else{
p=p->rchild;
}
}
// when key is not found or p becomes NULL it will come out of the loop,make a new node and link it with follow pointer
t=(struct Node*)malloc(sizeof(struct Node));
t->data=key;
t->lchild=t->rchild=NULL;
if (key<f->data) {
f->lchild=t;
}else{
f->rchild=t;
}
}
struct Node* RInsert(struct Node*p,int key){
struct Node*t=NULL;
if (!p) {
t=(struct Node*)malloc(sizeof(struct Node));
t->data=key;
t->lchild=t->rchild=NULL;
return t;
}
if (key<p->data) {
p->lchild=RInsert(p->lchild, key);
}else{
p->rchild=RInsert(p->rchild, key);
}
return p;
}
void Inorder(struct Node*p){
if (p) {
Inorder(p->lchild);
printf("%d ",p->data);
Inorder(p->rchild);
}
printf("");
}
struct Node* Isearch(struct Node*t,int key){
while (t) {
if (key==t->data)
return t;
else if (key<t->data)
t=t->lchild;
else
t=t->rchild;
}
return NULL;// Key Element not Found
}
int Level(struct Node*p){
int x,y;
if (p==NULL) {
return 0;
}
x=Level(p->lchild);
y=Level(p->rchild);
return x>y?x+1:y+1;
}
struct Node*Inpre(struct Node*p){
while (p&&p->rchild) {
p=p->rchild;
}
return p;
}
struct Node*Insucc(struct Node*p){
while (p&&p->lchild) {
p=p->lchild;
}
return p;
}
struct Node *Delete(struct Node*p,int key){
struct Node *temp;
if (p == NULL) return p;
// when root or any node is deleted which is having left and right subtree
if (key < p->data)
p->lchild = Delete(p->lchild, key);
else if (key > p->data)
p->rchild = Delete(p->rchild, key);
else
{
// when leaf node is deleted
if (p->lchild == NULL)
{
temp = p->rchild;
free(p);
return temp;
}
else if (p->rchild == NULL)
{
temp = p->lchild;
free(p);
return temp;
}// check the height of subtree.If left subtree is greater then delete InorderPredecessor also check its rightsubtree.
else if(Level(p->lchild)>Level(p->rchild)){
struct Node*temp=Inpre(p->lchild);// store the Inpre address recursively in pointer temp
p->data=temp->data;// replace p->data with temp->data
p->lchild= Delete(Inpre(p->lchild), temp->data);
}else{
// this part is executed when both right and left subtree having same level or righsubtree is greater than left subtree
temp = Insucc(p->rchild);
p->data = temp->data;
p->rchild = Delete(Insucc(p->rchild), temp->data);// Insucc-recursive function call upon rightchild
}
}
return p;
}
int main(int argc, const char * argv[]) {
// insert code here...
struct Node*temp;
Insert(root, 10);
Insert(root, 5);
Insert(root, 20);
Insert(root, 8);
Insert(root, 30);
Delete(root, 8);
Inorder(root);
printf("\n");
temp=Isearch(root, 30);
if (temp!=NULL) {
printf("Element %d is Found\n",temp->data);
}else
printf("Element is Not Found\n");
return 0;
}
|
the_stack_data/3263022.c
|
#include <stdio.h>
int main(int argc, char *argv[]){
for (int i = 0; i < argc; i++)
printf("Argument : %d %s\n", i, argv[i]);
return 0;
}
|
the_stack_data/330490.c
|
/* Test if ftw function doesn't leak fds.
Copyright (C) 2003-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Jakub Jelinek <[email protected]>, 2003.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <ftw.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int cb_called;
static int
cb (const char *name, const struct stat64 *st, int type)
{
return cb_called++ & 1;
}
int
main (void)
{
char name[32] = "/tmp/ftwXXXXXX", *p;
int ret, i, result = 0, fd, fd1, fd2;
if (mkdtemp (name) == NULL)
{
printf ("Couldn't make temporary directory: %m\n");
exit (EXIT_FAILURE);
}
p = strchr (name, '\0');
strcpy (p, "/1");
if (mkdir (name, 0755) < 0)
{
printf ("Couldn't make temporary subdirectory: %m\n");
exit (EXIT_FAILURE);
}
*p = '\0';
ret = ftw64 (name, cb, 20);
if (ret != 1)
{
printf ("ftw64 returned %d instead of 1", ret);
result = 1;
}
fd = open (name, O_RDONLY);
if (fd < 0)
{
printf ("open failed: %m\n");
result = 1;
}
fd1 = open (name, O_RDONLY);
if (fd1 < 0)
{
printf ("open failed: %m\n");
result = 1;
}
else
close (fd1);
if (fd >= 0)
close (fd);
for (i = 0; i < 128; ++i)
{
ret = ftw64 (name, cb, 20);
if (ret != 1)
{
printf ("ftw64 returned %d instead of 1", ret);
result = 1;
}
}
fd = open (name, O_RDONLY);
if (fd < 0)
{
printf ("open failed: %m\n");
result = 1;
}
fd2 = open (name, O_RDONLY);
if (fd2 < 0)
{
printf ("open failed: %m\n");
result = 1;
}
else
close (fd2);
if (fd >= 0)
close (fd);
if (fd2 >= fd1 + 128)
{
printf ("ftw64 leaking fds: %d -> %d\n", fd1, fd2);
result = 1;
}
if (cb_called != 129 * 2)
{
printf ("callback called %d times\n", cb_called);
result = 1;
}
strcpy (p, "/1");
rmdir (name);
*p = '\0';
rmdir (name);
return result;
}
|
the_stack_data/78373.c
|
/*
As a user, I want to be able to locate an existing contact in a list using the partial or full number.
Write a program that finds the number P in the list of numbers B with length N and returns the name of contact A.
A - List of names (max. 10 chars per name)
B - List of phone numbers
N - Length of list
P - Number to be found
If the number is not on the list, return "NO CONTACT"
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
char *solution(char *A[], char *B[], int N, char *P);
void test(char *A[], char *B[], int N, char *P, char *answer);
void case1();
void case2();
void case3();
void case4();
void case5();
void case6();
int main(void)
{
case1();
case2();
case3();
case4();
case5();
case6();
}
char *solution(char *A[], char *B[], int N, char *P)
{
// 10 + 1 for the null terminator character '\0'/
char *name = malloc(sizeof(char) * 11);
if (NULL == name)
{
return NULL;
}
bool containsContacts = false;
for (int i = 0; i < N; i++)
{
if (NULL != strstr(B[i], P))
{
if (containsContacts)
{
int lenName = strlen(name), lenContact = strlen(A[i]);
if (strncmp(name, A[i], lenName <= lenContact ? lenName : lenContact) > 0)
{
strcpy(name, A[i]);
}
}
else
{
containsContacts = true;
strcpy(name, A[i]);
}
}
}
if (!containsContacts)
{
strcpy(name, "NO CONTACT");
}
return name;
}
void test(char *A[], char *B[], int N, char *P, char *answer)
{
char *ret = solution(A, B, N, P);
printf("%s -> %s\n", ret, strcmp(ret, answer) == 0 ? "Passed" : "Failed");
free(ret);
}
void case1()
{
char *A[] = {"hello", "world"};
char *B[] = {"999999999", "777888999"};
char *P = "88999";
int N = 2;
char *answer = "world";
test(A, B, N, P, answer);
}
void case2()
{
char *A[] = {"hello", "gilson", "urbano"};
char *B[] = {"2315456456456", "77788787988918999", "111111"};
char *P = "1";
int N = 3;
char *answer = "gilson";
test(A, B, N, P, answer);
}
void case3()
{
char *A[] = {"hello", "world", "test"};
char *B[] = {"999999999", "777888999", "3313"};
char *P = "333";
int N = 3;
char *answer = "NO CONTACT";
test(A, B, N, P, answer);
}
void case4()
{
char *A[] = {"A", "B", "C", "D0", "D1", "D2", "E", "F"};
char *B[] = {"123456", "654321", "456", "4567", "9874567", "789", "963", "852"};
char *P = "4567";
int N = 8;
char *answer = "D0";
test(A, B, N, P, answer);
}
void case5()
{
char *A[] = {"A"};
char *B[] = {"123456"};
char *P = "123";
int N = 1;
char *answer = "A";
test(A, B, N, P, answer);
}
void case6()
{
char *A[] = {};
char *B[] = {};
char *P = "123";
int N = 0;
char *answer = "NO CONTACT";
test(A, B, N, P, answer);
}
|
the_stack_data/1020220.c
|
#include <stdio.h>
#define GREEN "\x1b[32m" //Color Macros
#define RESET "\x1b[0m"
#define MAGENTA "\x1b[35m"
int main(void) {
printf(GREEN "\nHello " RESET "World!\n\n");
printf(MAGENTA "\t\t\t\tPablo!!\n" RESET);
return 0;
}
|
the_stack_data/537066.c
|
/*
Name - Nikhil Ranjan Nayak
Regd No - 1641012040
Desc - Compute 1/n!
*/
#include "stdio.h"
void main()
{
int n;
double fact = 1;
printf("\n Enter a number - ");
scanf("%d", &n);
while(n != 0)
{
fact *= n;
n--;
}
printf("\n 1/n! - %f", 1/fact);
}
|
the_stack_data/243892289.c
|
#include <stdio.h>
_Thread_local int counter = 1;
int normal = 1;
int main(void)
{
for(int n = 0; n < 100; ++n)
counter++;
printf("counter is %u\n", counter);
return 0;
}
|
the_stack_data/750572.c
|
/*Program to sort an array of integers into ascending order*/
#include <stdio.h>
void sort (int a[], int n)
{
int i, j, temp;
for ( i = 0; i < n - 1; ++i ) {
for ( j = i + 1; j < n; ++j ) {
if ( a[i] > a[j] ) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
}
int main (void)
{
int i;
int array[16] = {
34, -5, 6, 0, 12, 100, 56, 22,
44, -3, -9, 12, 17, 22, 6, 11 };
void sort (int a[], int n);
printf ("The array before the sort: \n");
for ( i = 0; i < 16; ++i ) {
printf ("%i ", array[i]);
}
sort(array, 16);
printf ("\n\nThe array after the sort:\n");
for ( i = 0; i < 16; ++i ) {
printf ("%i ", array[i]);
}
printf ("\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.