file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/1181756.c | /*
* Fixes for broken IEEE floating point on the Alpha/G++ platform
*/
#ifdef __alpha
#include <math.h>
/*
double
log10(double x)
{
return log(x)/M_LN10;
}
*/
int
is_minus_infinity(float x)
{
return x == (-1.0/0);
}
#endif
|
the_stack_data/903168.c | /*
simple calculator
by Francesco
on Feb 2022
MIT license
c89 compiler
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
//variable declaration
int n1,n2,total;
printf("Enter the prices: \n");
scanf("%d%d", &n1, &n2);
total = n1 + n2;
printf("the total: %d", total);
return 0;
}
/*
#include <stdio.h>
#include <stdlib.h>
int main()
{
//variable declaration
int n1,n2,sum,diff,product;
char name[100];
float quot;
printf("simple calculator!\n");
//capture input
printf("Enter your name: ");
gets(name);
printf("Enter two integers: ");
scanf("%d%d", &n1,&n2);
//computations
sum= n1+ n2;
diff= n1- n2;
product=n1* n2;
quot=(float)n1/n2;
//outputs
printf("Hey %s, here is your results: \n", name);
printf("%d + %d = %d\n",n1,n2,sum);
printf("%d - %d = %d\n",n1,n2,diff);
printf("%d * %d = %d\n",n1,n2,product);
printf("%d / %d = %f\n",n1,n2,quot);
return 0;
}
*/
|
the_stack_data/30336.c | #include <stdio.h>
#include <stdlib.h>
//Thiago da Silva Ferreira
//Calcular fatorial
int main(void) {
int num,cont=1, fat=1;
printf("Digite um numero para calcular o fatorial:");
scanf("%d", &num);
for(cont=1; cont<=num; cont++){
fat=fat*cont;
}
printf("Fatorial de %d e %d", num , fat);
return 0;
}
|
the_stack_data/101305.c | #include <stdio.h>
#include <stdlib.h>
#define LIM 10
/*
Dado um conjunto de N elementos (numeros inteiros) entrados pelo usuario
mostre ao final, quantos são pares, impares e nulos. (10 valores)
*/
int main()
{
int vet[LIM];
int par=0, impar=0, nulo=0;
//alimentar o vetor
for(int i=0; i<LIM; i++){
printf("Digite um dado: \n");
scanf("%d", &vet[i]);
}
//percorrendo e aplicando a logica
for(int i=0; i<LIM; i++){
if(vet[i]%2==0 && vet[i]!=0){
par++;
}else if(vet[i]%2==1){
impar++;
}else{
nulo++;
}
}
//percorrer a apresentar o vetor
for(int i =0; i<LIM; i++){
printf("Posição [ %d] = %d \n", i, vet[i]);
}
printf("Total de pares: %d \n", par);
printf("Total de impares: %d \n", impar);
printf("Total de nulos: %d \n", nulo);
return 0;
}
|
the_stack_data/148578094.c | #include <stdio.h>
int main() {
int valor[3], valor_cresc[3], temp[3], i;
for (i=0; i < 3; i++){
scanf("%d", &valor[i]);
valor_cresc[i] = valor[i];
}
for (i=0; i < 3; i++){
if (valor_cresc[0] > valor_cresc[1]) {
temp[0] = valor_cresc[1];
valor_cresc[1] = valor_cresc[0];
valor_cresc[0] = temp[0];
}
if (valor_cresc[1] > valor_cresc[2]) {
temp[0] = valor_cresc[1];
valor_cresc[1] = valor_cresc[2];
valor_cresc[2] = temp[0];
}
}
for (i=0; i < 3; i++) printf("%d\n", valor_cresc[i]);
putchar('\n');
for (i=0; i < 3; i++){
printf("%d\n", valor[i]);
}
return 0;
}
|
the_stack_data/126443.c | /* getopt_long and getopt_long_only entry points for GNU getopt.
Copyright (C) 1987,88,89,90,91,92,93,94,96,97 Free Software Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to [email protected].
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, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "getopt.h"
#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
reject `defined (const)'. */
#ifndef const
#define const
#endif
#endif
#include <stdio.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#define GETOPT_INTERFACE_VERSION 2
#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
#include <gnu-versions.h>
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#define ELIDE_CODE
#endif
#endif
#ifndef ELIDE_CODE
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
#include <stdlib.h>
#endif
#ifndef NULL
#define NULL 0
#endif
int
getopt_long (argc, argv, options, long_options, opt_index)
int argc;
char *const *argv;
const char *options;
const struct option *long_options;
int *opt_index;
{
return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}
/* Like getopt_long, but '-' as well as '--' can indicate a long option.
If an option that starts with '-' (not '--') doesn't match a long option,
but does match a short option, it is parsed as a short option
instead. */
int
getopt_long_only (argc, argv, options, long_options, opt_index)
int argc;
char *const *argv;
const char *options;
const struct option *long_options;
int *opt_index;
{
return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}
#endif /* Not ELIDE_CODE. */
#ifdef TEST
#include <stdio.h>
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] =
{
{"add", 1, 0, 0},
{"append", 0, 0, 0},
{"delete", 1, 0, 0},
{"verbose", 0, 0, 0},
{"create", 0, 0, 0},
{"file", 1, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long (argc, argv, "abc:d:0123456789",
long_options, &option_index);
if (c == -1)
break;
switch (c)
{
case 0:
printf ("option %s", long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case 'd':
printf ("option d with value `%s'\n", optarg);
break;
case '?':
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */
|
the_stack_data/190768397.c | #include<stdio.h>
/* print_struct.c --- try to dump the data in a struct */
struct st{
int a[2];
};
int main(void)
{
struct st a;
*(a.a) = 500;
*(a.a + 1) = 2;
int sz = sizeof(a);
char *p = (char *)&a;
int i;
for (i = 0; i < sz; i++) {
printf("%X", p[i]);
}
printf("\n");
return 0;
}
|
the_stack_data/47838.c | struct student
{
char name[100];
int rno;
long long int ph;
int year;
};
main()
{
int n=5,i;
struct student *std;
std=(struct student*)calloc(1,sizeof(struct student));
/*if(std==NULL)
printf("Memory is Not Allocated");*/
printf("Enter Student Details: \n");
for(i=0;i<n;i++)
{
printf("Name of std-%d: ",i+1);
scanf("%s",(std+i)->name);
printf("Roll Number of std-%d:",i+1);
scanf("%d",&(std+i)->rno);
printf("Phone Number of std-%d: ",i+1);
scanf("%lld",&(std+i)->ph);
printf("Year of Study of std-%d: ",i+1);
scanf("%d",&(std+i)->year);
}
printf("\n\nStudent Details Are: \n");
for(i=0;i<n;i++)
{
printf("\nName of std-%d : %s",i+1,(std+i)->name);
printf("\nRoll Numberof std-%d : %d",i+1,(std+i)->rno);
printf("\nPhone Number of std-%d : %lld",i+1,(std+i)->ph);
printf("\nYear of Study of std-%d : %d",i+1,(std+i)->year);
}
}
|
the_stack_data/580429.c | #include <stdlib.h>
char *
getenv (const char *name)
{
return NULL;
}
|
the_stack_data/169947.c | void kernel_fdtd_2d(int tmax,
int nx,
int ny,
double ex[ 1000 + 0][1200 + 0],
double ey[ 1000 + 0][1200 + 0],
double hz[ 1000 + 0][1200 + 0],
double _fict_[ 500 + 0])
{
int t, i, j;
for(t = 0; t < tmax; t++)
{
for (j = 0; j < ny; j++)
ey[0][j] = _fict_[t];
#pragma clang loop(i1, j1) tile sizes(16, 32)
#pragma clang loop id(i1)
for (i = 1; i < nx; i++)
#pragma clang loop id(j1)
for (j = 0; j < ny; j++)
ey[i][j] = ey[i][j] - 0.5*(hz[i][j]-hz[i-1][j]);
#pragma clang loop(i2, j2) tile sizes(16, 32)
#pragma clang loop id(i2)
for (i = 0; i < nx; i++)
#pragma clang loop id(j2)
for (j = 1; j < ny; j++)
ex[i][j] = ex[i][j] - 0.5*(hz[i][j]-hz[i][j-1]);
#pragma clang loop(i3, j3) tile sizes(16,32)
#pragma clang loop id(i3)
for (i = 0; i < nx - 1; i++)
#pragma clang loop id(j3)
for (j = 0; j < ny - 1; j++)
hz[i][j] = hz[i][j] - 0.7* (ex[i][j+1] - ex[i][j] +
ey[i+1][j] - ey[i][j]);
}
}
|
the_stack_data/100140443.c | #include <stdio.h>
int result=0;
//result 3628800
int cal_n(int i)
{
if(i==1)
return i;
else
return i*cal_n(i-1);
}
int main()
{
result=cal_n(10);
return 0;
} |
the_stack_data/92324421.c | /*
* Write a program to calculate the nth Catalan number by given n (1 < n < 100). Examples:
n Catalan(n)
0 1
5 42
10 16796
15 9694845
*/
#include <stdio.h>
int main() {
unsigned char n;
printf("Please enter an integer (1 < n < 100): ");
scanf("%u", &n);
int i;
long double result = 1;
for (i = 2; i <= n; i++) {
result = (result * (n + i)) / i;
}
printf("%.0llf", result);
return 0;
}
|
the_stack_data/232957025.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
typedef struct{
size_t getvalue;
size_t byte1;
size_t byte2;
size_t byte3;
size_t byte4;
}bytes;
enum {bitmask = 0xFF};
unsigned int little2big(bytes *pbytes, uint32_t value){
pbytes->getvalue = value;
pbytes->byte1 = (pbytes->getvalue&(bitmask));
pbytes->byte2 = (pbytes->getvalue&(bitmask << 8)) >> 8;
pbytes->byte3 = (pbytes->getvalue&(bitmask << 16)) >> 16;
pbytes->byte4 = (pbytes->getvalue&(bitmask << 24)) >> 24;
return (
(pbytes->byte4) | \
(pbytes->byte3 << 8) | \
(pbytes->byte2 << 16) | \
(pbytes->byte1 << 24) \
);
}
int main(int argc, char *argv[]){
bytes *pbytes = malloc(sizeof(bytes));
if(argc != 2){
printf("%s [hex value].\n", argv[0]);
exit(-1);
}
unsigned int value;
sscanf(argv[1], "%x", (&value));
printf("ret: %x\n", little2big(pbytes, value));
free(pbytes);
return 0x0;
}
|
the_stack_data/73575830.c | /*
* COPYRIGHT
*
* uniformrv.c
* Copyright (C) 2014 Exstrom Laboratories LLC
*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* A copy of the GNU General Public License is available on the internet at:
* http://www.gnu.org/copyleft/gpl.html
*
* or you can write to:
*
* The Free Software Foundation, Inc.
* 675 Mass Ave
* Cambridge, MA 02139, USA
*
* Exstrom Laboratories LLC contact:
* stefan(AT)exstrom.com
*
* Exstrom Laboratories LLC
* Longmont, CO 80503, USA
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <time.h> //TcheL: As a patch
// Compile: gcc -lm -o uniformrv uniformrv.c
int main( int argc, char *argv[] )
{
if( argc < 4 )
{
printf("usage: %s n a b seed\n", argv[0]);
printf(" Generates n random numbers uniformly distributed from a to b\n");
printf(" seed = optional random number seed\n");
exit( -1 );
}
unsigned long i, n = strtoul(argv[1], NULL, 10);
double a = strtod(argv[2], NULL);
double b = strtod(argv[3], NULL);
unsigned int seed = argc > 4 ? strtoul(argv[4], NULL, 10) : time(NULL);
double u;
b -= a;
srand(seed);
for(i=0; i<n; ++i){
u = (double)rand()/RAND_MAX;
printf("%lf\n", a+b*u);}
return(0);
}
|
the_stack_data/976735.c | #include<stdio.h>
int main()
{
int n,i;
scanf("%d",&n);
for(i=1;i<=n;i++)
{
if(n % i==0)printf("%d\n",i);
}
return(0);
} |
the_stack_data/162642910.c | /*
* This file is part of the UCB release of Plan 9. It is subject to the license
* terms in the LICENSE file found in the top-level directory of this
* distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
* part of the UCB release of Plan 9, including this file, may be copied,
* modified, propagated, or distributed except according to the terms contained
* in the LICENSE file.
*/
/*
* Suffix table
*/
typedef unsigned char Uchar;
static Uchar sufa[] = {
02,0200+'t', /* -TA */
02,0200+'s', /* -SA */
03,0200+'t','r', /* -TRA */
03,0200+'d','r', /* -DRA */
03,0200+'b','r', /* -BRA */
02,0200+'p', /* -PA */
02,0200+'n', /* -NA */
02,0200+'m', /* -MA */
03,0200+'p','l', /* -PLA */
02,0200+'l', /* -LA */
02,0200+'k', /* -KA */
03,0200+'t','h', /* -THA */
03,0200+'s','h', /* -SHA */
02,0200+'g', /* -GA */
02,0200+'d', /* -DA */
02,0200+'c', /* -CA */
02,0200+'b', /* -BA */
00
};
static Uchar sufc[] = {
04,'e','t',0200+'i', /* ET-IC */
07,'a','l',0200+'i','s',0200+'t','i', /* AL-IS-TIC */
04,'s',0200+'t','i', /* S-TIC */
04,'p',0200+'t','i', /* P-TIC */
05,0200+'l','y','t',0200+'i', /* -LYT-IC */
04,'o','t',0200+'i', /* OT-IC */
05,'a','n',0200+'t','i', /* AN-TIC */
04,'n',0200+'t','i', /* N-TIC */
04,'c',0200+'t','i', /* C-TIC */
04,'a','t',0200+'i', /* AT-IC */
04,'h',0200+'n','i', /* H-NIC */
03,'n',0200+'i', /* N-IC */
03,'m',0200+'i', /* M-IC */
04,'l',0200+'l','i', /* L-LIC */
04,'b',0200+'l','i', /* B-LIC */
04,0200+'c','l','i', /* -CLIC */
03,'l',0200+'i', /* L-IC */
03,'h',0200+'i', /* H-IC */
03,'f',0200+'i', /* F-IC */
03,'d',0200+'i', /* D-IC */
03,0200+'b','i', /* -BIC */
03,'a',0200+'i', /* A-IC */
03,0200+'m','a', /* -MAC */
03,'i',0200+'a', /* I-AC */
00
};
static Uchar sufd[] = {
04,0200+'w','o','r', /* -WORD */
04,0200+'l','o','r', /* -LORD */
04,0200+'f','o','r', /* -FORD */
04,0200+'y','a','r', /* -YARD */
04,0200+'w','a','r', /* -WARD */
05,0200+'g','u','a','r', /* -GUARD */
04,0200+'t','a','r', /* -TARD */
05,0200+'b','o','a','r', /* -BOARD */
04,0200+'n','a','r', /* -NARD */
05,0200+'l','i','a','r', /* -LIARD */
04,0200+'i','a','r', /* -IARD */
04,0200+'g','a','r', /* -GARD */
04,0200+'b','a','r', /* -BARD */
03,0200+'r','o', /* -ROD */
04,0200+'w','o','o', /* -WOOD */
04,0200+'h','o','o', /* -HOOD */
04,0200+'m','o','n', /* -MOND */
04,0200+'t','e','n', /* -TEND */
05,0200+'s','t','a','n', /* -STAND */
04,0200+'l','a','n', /* -LAND */
04,0200+'h','a','n', /* -HAND */
04,0200+'h','o','l', /* -HOLD */
04,0200+'f','o','l', /* -FOLD */
05,0200+'f','i','e','l', /* -FIELD */
03,0200+'v','i', /* -VID */
03,0200+'c','i', /* -CID */
04,0200+'s','a','i', /* -SAID */
04,0200+'m','a','i', /* -MAID */
04,'t',0200+'t','e', /* T-TED */
03,'t',0200+'e', /* T-ED */
04,0200+'d','r','e', /* -DRED */
04,0200+'c','r','e', /* -CRED */
04,0200+'b','r','e', /* -BRED */
05,'v',0200+'e','l','e', /* V-ELED */
0100+04,'a','l',0200+'e', /* AL/ED */
0140+03,0200+'e','e', /* /EED */
040+05,'e','d',0200+'d','e', /* ED-DED */
04,'d',0200+'d','e', /* D-DED */
040+04,'e','d',0200+'e', /* ED-ED */
03,'d',0200+'e', /* D-ED */
05,0200+'d','u','c','e', /* -DUCED */
0300+02,'e', /* E/D */
05,0200+'s','t','e','a', /* -STEAD */
05,0200+'a','h','e','a', /* -AHEAD */
04,0200+'h','e','a', /* -HEAD */
00
};
static Uchar sufe[] = {
05,'a','r',0200+'i','z', /* AR-IZE */
05,'a','n',0200+'i','z', /* AN-IZE */
05,'a','l',0200+'i','z', /* AL-IZE */
06,0200+'a','r','d',0200+'i','z', /* -ARD-IZE */
05,0200+'s','e','l','v', /* -SELVE */
05,0200+'k','n','i','v', /* -KNIVE */
05,0200+'l','i','e','v', /* -LIEVE */
0100+03,0200+'q','u', /* /QUE */
07,'o','n',0200+'t','i','n',0200+'u', /* ON-TIN-UE */
03,0200+'n','u', /* -NUE */
03,0200+'d','u', /* -DUE */
0300+02,'u', /* U/E */
0300+05,'q','u','a','t', /* QUAT/E */
04,'u',0200+'a','t', /* U-ATE */
05,0200+'s','t','a','t', /* -STATE */
04,0200+'t','a','t', /* -TATE */
06,0200+'t','o','r',0200+'a','t', /* -TOR-ATE */
05,'e','n',0200+'a','t', /* EN-ATE */
04,0200+'m','a','t', /* -MATE */
05,0200+'h','o','u','s', /* -HOUSE */
05,0200+'c','l','o','s', /* -CLOSE */
04,'i',0200+'o','s', /* I-OSE */
04,0200+'w','i','s', /* -WISE */
05,'a','s',0200+'u','r', /* AS-URE */
040+04,0200+'s','u','r', /* -SURE */
06,0200+'f','i','g',0200+'u','r', /* -FIG-URE */
040+03,0200+'t','r', /* -TRE */
05,0200+'s','t','o','r', /* -STORE */
04,0200+'f','o','r', /* -FORE */
05,0200+'w','h','e','r', /* -WHERE */
06,0200+'s','p','h','e','r', /* -SPHERE */
03,0200+'d','r', /* -DRE */
03,0200+'c','r', /* -CRE */
03,0200+'b','r', /* -BRE */
05,0200+'s','c','o','p', /* -SCOPE */
04,'y',0200+'o','n', /* Y-ONE */
05,0200+'s','t','o','n', /* -STONE */
05,0200+'p','h','o','n', /* -PHONE */
04,0200+'g','o','n', /* -GONE */
04,'e',0200+'o','n', /* E-ONE */
040+04,0200+'e','n','n', /* -ENNE */
040+05,'a',0200+'r','i','n', /* A-RINE */
05,0200+'c','l','i','n', /* -CLINE */
04,0200+'l','i','n', /* -LINE */
007,00200+'r','o','u',00200+'t','i','n', /*-ROU-TINE */
04,0200+'s','o','m', /* -SOME */
04,0200+'c','o','m', /* -COME */
04,0200+'t','i','m', /* -TIME */
03,0200+'z','l', /* -ZLE */
03,0200+'t','l', /* -TLE */
03,0200+'s','l', /* -SLE */
03,0200+'p','l', /* -PLE */
05,0200+'v','i','l','l', /* -VILLE */
04,'c','k',0200+'l', /* CK-LE */
03,0200+'k','l', /* -KLE */
03,0200+'g','l', /* -GLE */
03,0200+'f','l', /* -FLE */
03,0200+'d','l', /* -DLE */
03,0200+'c','l', /* -CLE */
05,0200+'p','a',0200+'b','l', /* -PA-BLE */
05,'f','a',0200+'b','l', /* FA-BLE */
05,0200+'c','a',0200+'b','l', /* -CA-BLE */
06,0200+'s','t','a','b','l', /* -STABLE */
04,0200+'a','b','l', /* -ABLE */
03,0200+'b','l', /* -BLE */
04,0200+'d','a','l', /* -DALE */
04,0200+'m','a','l', /* -MALE */
04,0200+'s','a','l', /* -SALE */
04,0200+'l','i','k', /* -LIKE */
0340+05,'g',0200+'u','a','g', /* -G/UAGE */
05,0200+'r','i','a','g', /* -RIAGE */
05,'e','r',0200+'a','g', /* ER-AGE */
04,'m',0200+'a','g', /* M-AGE */
04,'k',0200+'a','g', /* K-AGE */
04,'d',0200+'a','g', /* D-AGE */
04,0200+'w','i','f', /* -WIFE */
05,0200+'k','n','i','f', /* -KNIFE */
03,0200+'s','e', /* -SEE */
04,0200+'f','r','e', /* -FREE */
0340+02,'e', /* EE */
04,0200+'w','i','d', /* -WIDE */
04,0200+'t','i','d', /* -TIDE */
04,0200+'s','i','d', /* -SIDE */
06,0200+'q','u','e','n','c', /* -QUENCE */
07,0200+'f','l','u',0200+'e','n','c', /* -FLU-ENCE */
040+06,'e','s',0200+'e','n','c', /* ES-ENCE */
06,'e','r',0200+'e','n','c', /* ER-ENCE */
05,'i',0200+'e','n','c', /* I-ENCE */
040+05,0200+'s','a','n','c', /* -SANCE */
06,'e','r',0200+'a','n','c', /* ER-ANCE */
06,'a','r',0200+'a','n','c', /* AR-ANCE */
05,0200+'n','a','n','c', /* -NANCE */
07,0200+'b','a','l',0200+'a','n','c', /* -BAL-ANCE */
05,'i',0200+'a','n','c', /* I-ANCE */
07,0200+'j','u','s',0200+'t','i','c', /* -JUS-TICE */
05,0200+'s','t','i','c', /* -STICE */
06,0200+'n','o','v',0200+'i','c', /* NOV-ICE */
04,0200+'v','i','c', /* -VICE */
05,0200+'p','i','e','c', /* -PIECE */
05,0200+'p','l','a','c', /* -PLACE */
0340+01, /* /E */
00
};
static Uchar suff[] = {
03,0200+'o','f', /* -OFF */
05,0200+'p','r','o','o', /* -PROOF */
04,0200+'s','e','l', /* -SELF */
03,0200+'r','i', /* -RIF */
040+04,0200+'l','i','e', /* -LIEF */
00
};
static Uchar sufg[] = {
03,0200+'l','o', /* -LOG */
04,0200+'l','o','n', /* -LONG */
05,'t',0200+'t','i','n', /* T-TING */
06,0200+'s','t','r','i','n', /* -STRING */
05,'r',0200+'r','i','n', /* R-RING */
05,'p',0200+'p','i','n', /* P-PING */
05,'n',0200+'n','i','n', /* N-NING */
05,'m',0200+'m','i','n', /* M-MING */
05,'l',0200+'l','i','n', /* L-LING */
05,0200+'z','l','i','n', /* -ZLING */
05,0200+'t','l','i','n', /* -TLING */
040+05,'s',0200+'l','i','n', /* S-LING */
05,'r',0200+'l','i','n', /* R-LING */
05,0200+'p','l','i','n', /* -PLING */
06,'n',0200+'k','l','i','n', /* N-KLING */
05,'k',0200+'l','i','n', /* K-LING */
05,0200+'g','l','i','n', /* -GLING */
05,0200+'f','l','i','n', /* -FLING */
05,0200+'d','l','i','n', /* -DLING */
05,0200+'c','l','i','n', /* -CLING */
05,0200+'b','l','i','n', /* -BLING */
06,'y',0200+'t','h','i','n', /* Y-THING */
07,'e','e','t','h',0200+'i','n', /* EETH-ING */
06,'e',0200+'t','h','i','n', /* E-THING */
05,'g',0200+'g','i','n', /* G-GING */
05,'d',0200+'d','i','n', /* D-DING */
05,'b',0200+'b','i','n', /* B-BING */
03,0200+'i','n', /* -ING */
00
};
static Uchar sufh[] = {
05,0200+'m','o','u','t', /* -MOUTH */
05,0200+'w','o','r','t', /* -WORTH */
04,0200+'w','i','t', /* -WITH */
05,'t',0200+'t','i','s', /* T-TISH */
05,'e',0200+'t','i','s', /* E-TISH */
05,'p',0200+'p','i','s', /* P-PISH */
05,'r',0200+'n','i','s', /* R-NISH */
05,'n',0200+'n','i','s', /* N-NISH */
05,0200+'p','l','i','s', /* -PLISH */
05,0200+'g','u','i','s', /* -GUISH */
05,0200+'g','l','i','s', /* -GLISH */
05,'b',0200+'l','i','s', /* B-LISH */
05,'g',0200+'g','i','s', /* G-GISH */
05,'d',0200+'d','i','s', /* D-DISH */
03,0200+'i','s', /* -ISH */
05,0200+'g','r','a','p', /* -GRAPH */
07,0200+'b','o','r',0200+'o','u','g', /* -BOR-OUGH */
05,0200+'b','u','r','g', /* -BURGH */
04,0200+'v','i','c', /* -VICH */
03,0200+'n','a', /* -NAH */
03,0200+'l','a', /* -LAH */
04,0200+'m','i',0200+'a', /* -MI-AH */
00
};
static Uchar sufi[] = {
03,0200+'t','r', /* -TRI */
03,0200+'c','h', /* -CHI */
0200+03,'i','f', /* IF-I */
0200+03,'e','d', /* ED-I */
05,0200+'a','s','c','i', /* -ASCII */
04,0200+'s','e','m', /* -SEMI */
00
};
static Uchar sufk[] = {
04,0200+'w','o','r', /* -WORK */
04,0200+'m','a','r', /* -MARK */
04,0200+'b','o','o', /* -BOOK */
04,0200+'w','a','l', /* -WALK */
05,0200+'c','r','a','c', /* -CRACK */
04,0200+'b','a','c', /* -BACK */
00
};
static Uchar sufl[] = {
03,0200+'f','u', /* -FUL */
05,'s',0200+'w','e','l', /* S-WELL */
04,0200+'t','e','l', /* -TELL */
05,0200+'s','h','e','l', /* -SHELL */
05,0200+'s','t','a','l', /* -STALL */
04,'s',0200+'t','a', /* S-TAL */
04,0200+'b','a','l', /* -BALL */
04,0200+'c','a','l', /* -CALL */
03,'v',0200+'e', /* V-EL */
03,'u',0200+'e', /* U-EL */
03,'k',0200+'e', /* K-EL */
04,'t','h',0200+'e', /* TH-EL */
05,'t','c','h',0200+'e', /* TCH-EL */
03,'a',0200+'e', /* A-EL */
0140+04,0200+'q','u','a', /* /QUAL */
040+03,'u',0200+'a', /* U-AL */
03,0200+'t','a', /* -TAL */
04,'u','r',0200+'a', /* UR-AL */
040+05,'g',0200+'o',0200+'n','a', /* G-O-NAL */
04,'o','n',0200+'a', /* ON-AL */
03,0200+'n','a', /* -NAL */
04,0200+'t','i','a', /* -TIAL */
04,0200+'s','i','a', /* -SIAL */
040+05,0200+'t','r','i',0200+'a', /* -TRI-AL */
04,'r','i',0200+'a', /* RI-AL */
04,0200+'n','i',0200+'a', /* -NI-AL */
04,0200+'d','i',0200+'a', /* -DI-AL */
04,0200+'c','i','a', /* -CIAL */
03,0200+'g','a', /* -GAL */
04,0200+'m','e','a', /* -MEAL */
/* 040+04,0200+'r','e',0200+'a', /* -RE-AL */
040+04,0200+'r','e','a', /* -REAL */
06,'c',0200+'t','i',0200+'c','a', /* C-TI-CAL */
05,0200+'s','i',0200+'c','a', /* -SI-CAL */
04,0200+'i',0200+'c','a', /* -I-CAL */
03,0200+'c','a', /* -CAL */
03,0200+'b','a', /* -BAL */
06,0200+'n','o',0200+'m','i',0200+'a', /* -NO-MI-AL */
00
};
static Uchar sufm[] = {
03,0200+'n','u', /* -NUM */
05,'o',0200+'r','i',0200+'u', /* O-RI-UM */
040+03,'i',0200+'u', /* I-UM */
040+03,'e',0200+'u', /* E-UM */
05,'i','v',0200+'i','s', /* IV-ISM */
04,0200+'t','i','s', /* -TISM */
05,'i',0200+'m','i','s', /* I-MISM */
05,'a','l',0200+'i','s', /* AL-ISM */
040+04,'e',0200+'i','s', /* E-ISM */
040+04,'a',0200+'i','s', /* A-ISM */
04,0200+'r','o','o', /* -ROOM */
03,0200+'d','o', /* -DOM */
03,0200+'h','a', /* -HAM */
06,0200+'a',0200+'r','i','t','h', /* -A-RITHM */
05,0200+'r','i','t','h', /* -RITHM */
00
};
static Uchar sufn[] = {
05,0200+'k','n','o','w', /* -KNOWN */
04,0200+'t','o','w', /* -TOWN */
04,0200+'d','o','w', /* -DOWN */
04,0200+'t','u','r', /* -TURN */
05,0200+'s','p','o','o', /* -SPOON */
04,0200+'n','o','o', /* -NOON */
04,0200+'m','o','o', /* -MOON */
011,'a','l',0200+'i',0200+'z','a',0200+'t','i','o', /* AL-I-ZA-TION */
07,0200+'i',0200+'z','a',0200+'t','i','o', /* -I-ZA-TION */
07,'l',0200+'i',0200+'a',0200+'t','i','o', /* L-I-A-TION */
04,0200+'t','i','o', /* -TION */
040+05,'s',0200+'s','i','o', /* S-SION */
04,0200+'s','i','o', /* -SION */
04,'n',0200+'i','o', /* N-ION */
04,0200+'g','i','o', /* -GION */
04,0200+'c','i','o', /* -CION */
03,0200+'c','o', /* -CON */
05,0200+'c','o','l','o', /* -COLON */
03,0200+'t','o', /* -TON */
04,'i','s',0200+'o', /* IS-ON */
03,0200+'s','o', /* -SON */
03,0200+'r','i', /* -RIN */
03,0200+'p','i', /* -PIN */
03,0200+'n','i', /* -NIN */
03,0200+'m','i', /* -MIN */
03,0200+'l','i', /* -LIN */
03,0200+'k','i', /* -KIN */
05,0200+'s','t','e','i', /* -STEIN */
04,0200+'t','a','i', /* -TAIN */
05,'g','h','t',0200+'e', /* GHT-EN */
05,0200+'w','o','m',0200+'e', /* -WOM-EN */
03,0200+'m','e', /* -MEN */
04,'o',0200+'k','e', /* O-KEN */
03,'k',0200+'e', /* K-EN */
04,0200+'t','e','e', /* -TEEN */
04,0200+'s','e','e', /* -SEEN */
040+03,0200+'s','a', /* -SAN */
05,0200+'w','o','m',0200+'a', /* -WOM-AN */
03,0200+'m','a', /* -MAN */
04,0200+'t','i','a', /* -TIAN */
04,0200+'s','i','a', /* -SIAN */
040+04,'e',0200+'i','a', /* E-IAN */
04,0200+'c','i','a', /* -CIAN */
0300+03,'i','a', /* IA/N */
05,0200+'c','l','e','a', /* -CLEAN */
04,0200+'m','e','a', /* -MEAN */
040+03,'e',0200+'a', /* E-AN */
00
};
static Uchar sufo[] = {
05,0200+'m','a','c',0200+'r', /* -MAC-RO */
00
};
static Uchar sufp[] = {
05,0200+'g','r','o','u', /* -GROUP */
02,0200+'u', /* -UP */
04,0200+'s','h','i', /* -SHIP */
04,0200+'k','e','e', /* -KEEP */
00
};
static Uchar sufr[] = {
04,0200+'z','a','r', /* -ZARR */
0300+02,'r', /* R/R */
03,0200+'t','o', /* -TOR */
040+03,0200+'s','o', /* -SOR */
040+04,0200+'r','i',0200+'o', /* -RI-OR */
04,'i','z',0200+'e', /* IZ-ER */
05,0200+'c','o','v',0200+'e', /* -COV-ER */
04,0200+'o','v','e', /* -OVER */
04,0200+'e','v',0200+'e', /* -EV-ER */
8,0200+'c','o','m',0200+'p','u','t',0200+'e', /* -COM-PUT-ER */
040+05,'u','s',0200+'t','e', /* US-TER */
05,'o','s','t',0200+'e', /* OST-ER */
040+05,0200+'a','c',0200+'t','e', /* -AC-TER */
06,0200+'w','r','i','t',0200+'e', /* -WRIT-ER */
040+05,'i','s',0200+'t','e', /* IS-TER */
040+05,'e','s',0200+'t','e', /* ES-TER */
040+05,'a','s',0200+'t','e', /* AS-TER */
04,0200+'s','t','e', /* -STER */
05,'a','r',0200+'t','e', /* AR-TER */
04,'r','t',0200+'e', /* RT-ER */
040+05,'m',0200+'e',0200+'t','e', /* M-E-TER */
05,0200+'w','a',0200+'t','e', /* -WA-TER */
03,'r',0200+'e', /* R-ER */
04,'o','p',0200+'e', /* OP-ER */
05,0200+'p','a',0200+'p','e', /* -PA-PER */
04,'w','n',0200+'e', /* WN-ER */
040+04,'s',0200+'n','e', /* S-NER */
04,'o','n',0200+'e', /* ON-ER */
04,'r','m',0200+'e', /* RM-ER */
03,0200+'m','e', /* -MER */
04,'l','l',0200+'e', /* LL-ER */
05,'d',0200+'d','l','e', /* D-DLER */
04,0200+'b','l','e', /* -BLER */
03,'k',0200+'e', /* K-ER */
05,'n',0200+'t','h','e', /* N-THER */
06,0200+'f','a',0200+'t','h','e', /* -FA-THER */
06,'e','i',0200+'t','h','e', /* EI-THER */
04,'t','h',0200+'e', /* TH-ER */
04,'s','h',0200+'e', /* SH-ER */
04,0200+'p','h','e', /* -PHER */
04,'c','h',0200+'e', /* CH-ER */
04,'d','g',0200+'e', /* DG-ER */
04,'r','d',0200+'e', /* RD-ER */
06,'o','u','n','d',0200+'e', /* OUND-ER */
04,'l','d',0200+'e', /* LD-ER */
04,'i','d',0200+'e', /* ID-ER */
05,0200+'d','u','c',0200+'e', /* -DUC-ER */
04,'n','c',0200+'e', /* NC-ER */
0100+02, 0200+'e', /* /ER */
03,0200+'s','a', /* -SAR */
040+06,'a','c',0200+'u',0200+'l','a', /* AC-U-LAR */
040+06,'e','c',0200+'u',0200+'l','a', /* EC-U-LAR */
040+06,'i','c',0200+'u',0200+'l','a', /* IC-U-LAR */
040+06,'e','g',0200+'u',0200+'l','a', /* EG-U-LAR */
00
};
static Uchar sufs[] = {
040+04,'u',0200+'o','u', /* U-OUS */
05,0200+'t','i','o','u', /* -TIOUS */
05,0200+'g','i','o','u', /* -GIOUS */
05,0200+'c','i','o','u', /* -CIOUS */
040+04,'i',0200+'o','u', /* I-OUS */
05,0200+'g','e','o','u', /* -GEOUS */
05,0200+'c','e','o','u', /* -CEOUS */
04,'e',0200+'o','u', /* E-OUS */
0140+02,0200+'u', /* /US */
04,0200+'n','e','s', /* -NESS */
04,0200+'l','e','s', /* -LESS */
0140+02,0200+'s', /* /SS */
040+05,'p',0200+'o',0200+'l','i', /* P-O-LIS */
0140+02,0200+'i', /* /IS */
0100+03,0200+'x','e', /* X/ES */
0100+03,0200+'s','e', /* S/ES */
0100+04,'s','h',0200+'e', /* SH/ES */
0100+04,'c','h',0200+'e', /* CH/ES */
0300+01, /* /S */
00
};
static Uchar suft[] = {
05,0200+'l','i','m',0200+'i', /* -LIM-IT */
06,'i','o','n',0200+'i','s', /* ION-IST */
05,'i','n',0200+'i','s', /* IN-IST */
05,'a','l',0200+'i','s', /* AL-IST */
06,'l',0200+'o',0200+'g','i','s', /* L-O-GIST */
05,'h','t',0200+'e','s', /* HT-EST */
04,'i',0200+'e','s', /* I-EST */
05,'g',0200+'g','e','s', /* G-GEST */
04,'g',0200+'e','s', /* G-EST */
05,'d',0200+'d','e','s', /* D-DEST */
04,'d',0200+'e','s', /* D-EST */
04,0200+'c','a','s', /* -CAST */
05,0200+'h','e','a','r', /* -HEART */
04,0200+'f','o','o', /* -FOOT */
03,'i',0200+'o', /* I-OT */
05,0200+'f','r','o','n', /* -FRONT */
05,0200+'p','r','i','n', /* -PRINT */
04,0200+'m','e','n', /* -MENT */
05,0200+'c','i','e','n', /* -CIENT */
04,'i',0200+'a','n', /* I-ANT */
06,0200+'w','r','i','g','h', /* -WRIGHT */
06,0200+'b','r','i','g','h', /* -BRIGHT */
06,0200+'f','l','i','g','h', /* -FLIGHT */
06,0200+'w','e','i','g','h', /* -WEIGHT */
05,0200+'s','h','i','f', /* -SHIFT */
05,0200+'c','r','a','f', /* -CRAFT */
040+04,'d','g',0200+'e', /* DG-ET */
04,0200+'g','o','a', /* -GOAT */
04,0200+'c','o','a', /* -COAT */
04,0200+'b','o','a', /* -BOAT */
04,0200+'w','h','a', /* -WHAT */
04,0200+'c','u','i', /* -CUIT */
00
};
static Uchar sufy[] = {
040+04,'e','s',0200+'t', /* ES-TY */
040+05,'q','u','i',0200+'t', /* QUI-TY */
04,0200+'t','i',0200+'t', /* -TI-TY */
040+05,'o','s',0200+'i',0200+'t', /* OS-I-TY */
04,0200+'s','i',0200+'t', /* -SI-TY */
05,'i','n',0200+'i',0200+'t', /* IN-I-TY */
04,'n','i',0200+'t', /* NI-TY */
040+010,'f','a',0200+'b','i','l',0200+'i',0200+'t', /* FA-BIL-I-TY */
010,0200+'c','a',0200+'b','i','l',0200+'i',0200+'t', /* -CA-BIL-I-TY */
010,0200+'p','a',0200+'b','i','l',0200+'i',0200+'t', /* -PA-BIL-I-TY */
06,0200+'b','i','l',0200+'i',0200+'t', /* -BIL-I-TY */
03,'i',0200+'t', /* I-TY */
04,0200+'b','u','r', /* -BUR-Y */
04,0200+'t','o',0200+'r', /* -TO-RY */
05,0200+'q','u','a','r', /* -QUAR-Y */
040+04,'u',0200+'a','r', /* U-ARY */
07,0200+'m','e','n',0200+'t','a',0200+'r', /* -MEN-TA-RY */
06,'i','o','n',0200+'a','r', /* ION-ARY */
04,'i',0200+'a','r', /* I-ARY */
04,'n',0200+'o',0200+'m', /* N-O-MY */
03,0200+'p','l', /* -PLY */
04,'g',0200+'g','l', /* G-GLY */
05,0200+'p','a',0200+'b','l', /* -PA-BLY */
05,'f','a',0200+'b','l', /* FA-BLY */
05,0200+'c','a',0200+'b','l', /* -CA-BLY */
04,0200+'a','b','l', /* -ABLY */
03,0200+'b','l', /* -BLY */
02,0200+'l', /* -LY */
03,0200+'s','k', /* -SKY */
040+06,'g',0200+'r','a',0200+'p','h', /* G-RA-PHY */
04,'l',0200+'o',0200+'g', /* L-O-GY */
02,0200+'f', /* -FY */
03,0200+'n','e', /* -NEY */
03,0200+'l','e', /* -LEY */
04,'c','k',0200+'e', /* CK-EY */
03,0200+'k','e', /* -KEY */
04,0200+'b','o','d', /* -BODY */
05,0200+'s','t','u','d', /* -STUDY */
0340+04,'e','e','d', /* EEDY */
02,0200+'b', /* -BY */
03,0200+'w','a', /* -WAY */
03,0200+'d','a', /* -DAY */
00
};
Uchar *suftab[] = {
sufa,
0,
sufc,
sufd,
sufe,
suff,
sufg,
sufh,
sufi,
0,
sufk,
sufl,
sufm,
sufn,
sufo,
sufp,
0,
sufr,
sufs,
suft,
0,
0,
0,
0,
sufy,
0,
};
|
the_stack_data/107953712.c | /*
pidfile.c - interact with pidfiles
Copyright (c) 1995 Martin Schulze <[email protected]>
This file is part of the sysklogd package, a kernel and system log daemon.
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 program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA
*/
/*
* Sat Aug 19 13:24:33 MET DST 1995: Martin Schulze
* First version (v0.2) released
*/
/*
* Edited by Imma.
* July 14, 2010
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/file.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
/* read_pid
*
* Reads the specified pidfile and returns the read pid.
* 0 is returned if either there's no pidfile, it's empty
* or no pid can be read.
*/
int read_pid (char *pid_file)
{
FILE *f;
int pid;
if (!(f = fopen(pid_file, "r"))) {
/*perror(pid_file);*/
return 0;
}
fscanf(f, "%d", &pid);
fclose(f);
return pid;
}
/* check_pid
*
* Reads the pid using read_pid and looks up the pid in the process
* table (using /proc) to determine if the process already exists. If
* so 1 is returned, otherwise 0.
*/
int check_pid (char *pid_file)
{
int pid = read_pid(pid_file);
/* Amazing ! _I_ am already holding the pid file... */
if ((!pid) || (pid == getpid ()))
return 0;
/*
* The 'standard' method of doing this is to try and do a 'fake' kill
* of the process. If an ESRCH error is returned the process cannot
* be found -- GW
*/
/* But... errno is usually changed only on error.. */
if (kill(pid, 0) && errno == ESRCH)
return(0);
return pid;
}
/* write_pid
*
* Writes the pid to the specified file. If that fails 0 is
* returned, otherwise the pid.
*/
int write_pid (char *pid_file)
{
FILE *f;
int fd;
int pid;
if ( ((fd = open(pid_file, O_RDWR|O_CREAT|O_TRUNC, 0644)) == -1)
|| ((f = fdopen(fd, "r+")) == NULL) ) {
/* fprintf(stderr, "Can't open or create %s.\n", pid_file); */
perror(pid_file);
return 0;
}
if (flock(fd, LOCK_EX|LOCK_NB) == -1) {
fscanf(f, "%d", &pid);
fclose(f);
/* printf("Can't lock, lock is held by pid %d.\n", pid); */
return 0;
}
pid = getpid();
if (!fprintf(f,"%d\n", pid)) {
/* printf("Can't write pid , %s.\n", strerror(errno)); */
close(fd);
return 0;
}
fflush(f);
if (flock(fd, LOCK_UN) == -1) {
/* printf("Can't unlock pidfile %s, %s.\n", pid_file, strerror(errno)); */
close(fd);
return 0;
}
close(fd);
return pid;
}
/* remove_pid
*
* Remove the the specified file. The result from unlink(2)
* is returned
*/
int remove_pid (char *pid_file)
{
return unlink (pid_file);
}
|
the_stack_data/124910.c | #include<stdio.h>
int main()
{
int i,j,k,n;
float Matrix[8][8],c,x[8],sum=0.0; //variables are taken as float because system may have real solution
printf("\nEnter the max number of variables in given equations: ");
scanf("%d",&n);
printf("\nEnter the co-efficients :\n\n");
for(i=1; i<=n; i++)
{
for(j=1; j<=(n+1); j++)
{
printf("Equation %d,co-efficient %d :",i,j); //taking values from user
scanf("%f",&Matrix[i][j]);
}
}
for(j=1; j<=n; j++)
{
for(i=1; i<=n; i++)
{
if(i>j)
{
c=Matrix[i][j]/Matrix[j][j]; // This co-efficient will help us to make other elements of column zero
for(k=1; k<=n+1; k++)
{
Matrix[i][k]=Matrix[i][k]-c*Matrix[j][k]; //Making zeros in column
}
}
}
}
x[n]=Matrix[n][n+1]/Matrix[n][n];
for(i=n-1; i>=1; i--)
{
sum=0;
for(j=i+1; j<=n; j++)
{
sum=sum+Matrix[i][j]*x[j]; //calculation the solution
}
x[i]=(Matrix[i][n+1]-sum)/Matrix[i][i];
}
printf("\nThe solution to the equations is: \n");
for(i=1; i<=n; i++)
{
printf("\nx%d=%f\t",i,x[i]); // x1, x2, ... x6 are the solutions to the given system of equations
}
return(0);
}
|
the_stack_data/92326972.c | #include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
/* Upon successful completion, fork() returns a value of 0 to the child process and
returns the process ID of the child process to the parent process. Otherwise, a
value of -1 is returned to the parent process, no child process is created, and
the global variable errno is set to indicate the error.
*/
int main(){
system("clear");
pid_t pid;
int status;
if((pid=fork())==0){
printf("FILHO \n\n");
int a=getpid();
int b=getppid();
printf("Proc atual %d \n processo pai %d \n\n",a,b);
_exit(0);
}
else{
int x=pid;/*evitavel fazer isto;
podia simplesmente invocar "pid_t umPid" e igualar ao wait(&status)*/
wait(&status);
printf("PAI \n\n");
int c=getpid();
int d=getppid();
printf("Processo atual %d \n Processo pai %d \n Processo filho %d \n\n", c,d,x);
}
return 0;
}
|
the_stack_data/122016769.c | /* Generated by re2c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BSIZE 8192
typedef struct Scanner
{
FILE *fp;
unsigned char *cur, *tok, *lim, *eof;
unsigned char buffer[BSIZE];
} Scanner;
int fill(Scanner *s, int len)
{
if (!len)
{
s->cur = s->tok = s->lim = s->buffer;
s->eof = 0;
}
if (!s->eof)
{
int got, cnt = s->tok - s->buffer;
if (cnt > 0)
{
memcpy(s->buffer, s->tok, s->lim - s->tok);
s->tok -= cnt;
s->cur -= cnt;
s->lim -= cnt;
}
cnt = BSIZE - cnt;
if ((got = fread(s->lim, 1, cnt, s->fp)) != cnt)
{
s->eof = &s->lim[got];
}
s->lim += got;
}
else if (s->cur + len > s->eof)
{
return 0; /* not enough input data */
}
return -1;
}
void fputl(const char *s, size_t len, FILE *stream)
{
while(len-- > 0)
{
fputc(*s++, stream);
}
}
enum YYCONDTYPE {
EStateR1,
EStateR2,
};
void scan(Scanner *s)
{
int cond = EStateR1;
fill(s, 0);
for(;;)
{
s->tok = s->cur;
{
unsigned char yych;
if (cond < 1) {
goto yyc_R1;
} else {
goto yyc_R2;
}
/* *********************************** */
yyc_R1:
{
static const unsigned char yybm[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 0, 0, 0, 0, 0, 0,
0, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 0, 0, 0, 0, 0,
0, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
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 ((s->lim - s->cur) < 2) { if(fill(s, 2) >= 0) break; }
yych = *s->cur;
if (yych <= '@') {
if (yych <= '/') goto yy4;
if (yych >= ':') goto yy4;
} else {
if (yych <= 'Z') goto yy2;
if (yych <= '`') goto yy4;
if (yych >= '{') goto yy4;
}
yy2:
++s->cur;
yych = *s->cur;
goto yy7;
yy3:
{
continue;
}
yy4:
++s->cur;
{
continue;
}
yy6:
++s->cur;
if (s->lim <= s->cur) { if(fill(s, 1) >= 0) break; }
yych = *s->cur;
yy7:
if (yybm[0+yych] & 128) {
goto yy6;
}
goto yy3;
}
/* *********************************** */
yyc_R2:
{
static const unsigned char yybm[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 0, 0, 0, 0, 0, 0,
0, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 0, 0, 0, 0, 0,
0, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
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 ((s->lim - s->cur) < 2) { if(fill(s, 2) >= 0) break; }
yych = *s->cur;
if (yych <= '@') {
if (yych <= '/') goto yy12;
if (yych >= ':') goto yy12;
} else {
if (yych <= 'Z') goto yy10;
if (yych <= '`') goto yy12;
if (yych >= '{') goto yy12;
}
yy10:
++s->cur;
yych = *s->cur;
goto yy15;
yy11:
{
continue;
}
yy12:
++s->cur;
{
continue;
}
yy14:
++s->cur;
if (s->lim <= s->cur) { if(fill(s, 1) >= 0) break; }
yych = *s->cur;
yy15:
if (yybm[0+yych] & 128) {
goto yy14;
}
goto yy11;
}
}
}
}
int main(int argc, char **argv)
{
Scanner in;
char c;
if (argc != 2)
{
fprintf(stderr, "%s <file>\n", argv[0]);
return 1;;
}
memset((char*) &in, 0, sizeof(in));
if (!strcmp(argv[1], "-"))
{
in.fp = stdin;
}
else if ((in.fp = fopen(argv[1], "r")) == NULL)
{
fprintf(stderr, "Cannot open file '%s'\n", argv[1]);
return 1;
}
scan(&in);
if (in.fp != stdin)
{
fclose(in.fp);
}
return 0;
}
|
the_stack_data/70450108.c | #include <stdint.h>
#include <immintrin.h>
__m128i simd_transition_phi_table[256] =
{ {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010001, 0x0000000000000007}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000000010100, 0x0000000006000006}
, {0x0000000000010200, 0x0000000000000000}
, {0x0000000000010100, 0x0000000001000001}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000003010103, 0x0000000000000007}
, {0x0000000000010100, 0x0000000006000006}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000001000001}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
, {0x0000000000010100, 0x0000000000000000}
};
|
the_stack_data/152196.c | #include <stdio.h>
int main()
{
int height = 5, length = 4;
int inSpace = 1, outSpace = 2;
for(int i = 1; i <= height; i++) {
for(int j = 1; j <= length; j++) {
for(int k = 1; k <= outSpace; k++)
printf(" ");
printf("0");
for(int k = 1; k <= inSpace; k++)
printf(" ");
printf("0");
for(int k = 1; k <= outSpace; k++)
printf(" ");
printf(" ");
}
outSpace = (i + 1 != height);
inSpace = (i + 1 != height) ? 3 : 5;
printf("\n");
}
return 0;
} |
the_stack_data/34512996.c | void twofft(float data1[], float data2[], float fft1[], float fft2[],
unsigned long n)
{
void four1(float data[], unsigned long nn, int isign);
unsigned long nn3,nn2,jj,j;
float rep,rem,aip,aim;
nn3=1+(nn2=2+n+n);
for (j=1,jj=2;j<=n;j++,jj+=2) {
fft1[jj-1]=data1[j];
fft1[jj]=data2[j];
}
four1(fft1,n,1);
fft2[1]=fft1[2];
fft1[2]=fft2[2]=0.0;
for (j=3;j<=n+1;j+=2) {
rep=0.5*(fft1[j]+fft1[nn2-j]);
rem=0.5*(fft1[j]-fft1[nn2-j]);
aip=0.5*(fft1[j+1]+fft1[nn3-j]);
aim=0.5*(fft1[j+1]-fft1[nn3-j]);
fft1[j]=rep;
fft1[j+1]=aim;
fft1[nn2-j]=rep;
fft1[nn3-j] = -aim;
fft2[j]=aip;
fft2[j+1] = -rem;
fft2[nn2-j]=aip;
fft2[nn3-j]=rem;
}
}
/* (C) Copr. 1986-92 Numerical Recipes Software 7&X*. */
|
the_stack_data/2520.c | #include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#define N 1000
#define FILESIZE 100
#define NAMESIZE 100
static char name[NAMESIZE];
static char buf[FILESIZE];
static char *dir;
void printstats(int reset)
{
int fd;
int r;
sprintf(name, "%s/stats", dir);
if((fd = open(name, O_RDONLY)) < 0) {
return;
}
bzero(buf, FILESIZE);
if ((r = read(fd, buf, FILESIZE)) < 0) {
perror("read");
exit(1);
}
if (!reset)
fprintf(stdout, "=== FS Stats ===\n%s========\n", buf);
if ((r = close(fd)) < 0) {
perror("close");
}
}
static uint64_t
usec_now()
{
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t res = tv.tv_sec;
res *= 1000000;
res += tv.tv_usec;
return res;
}
int main(int argc, char *argv[])
{
int i;
int r;
int fd;
uint64_t start, end;
if (argc != 2) {
printf("Usage: %s basedir\n", argv[0]);
exit(-1);
}
dir = argv[1];
sprintf(buf, "%s/d", argv[1]);
if (mkdir(buf, S_IRWXU) < 0) {
printf("%s: create %s failed %s\n", argv[0], buf, strerror(errno));
exit(1);
}
printstats(1);
start = usec_now();
for (i = 0; ; i++) {
sprintf(name, "%s/d/f%d", argv[1], 0);
if((fd = open(name, O_RDWR | O_CREAT | O_TRUNC, S_IRWXU)) < 0) {
printf("%s: create %s failed %s\n", argv[0], name, strerror(errno));
exit(1);
}
if (write(fd, buf, FILESIZE) != FILESIZE) {
printf("%s: write %s failed %s\n", argv[0], name, strerror(errno));
exit(1);
}
if (fsync(fd) < 0) {
printf("%s: fsync %s failed %s\n", argv[0], name, strerror(errno));
exit(1);
}
close(fd);
end = usec_now();
if (end - start > 1000000)
break;
}
printf("%d files per %ld usec\n", i, end-start);
printstats(0);
}
|
the_stack_data/29825075.c | /*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, [email protected]
* Ralph Irving 2015-2021, [email protected]
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
// ir thread - linux only
#if IR
#include <lirc/lirc_client.h>
/* Avoid name conflicts from syslog.h inclusion in lirc client header */
#ifdef LOG_DEBUG
#undef LOG_DEBUG
#endif
#ifdef LOG_INFO
#undef LOG_INFO
#endif
#include "squeezelite.h"
#define LIRC_CLIENT_ID "squeezelite"
static log_level loglevel;
struct irstate ir;
static struct lirc_config *config = NULL;
static sockfd fd = -1;
static thread_type thread;
#define LOCK_I mutex_lock(ir.mutex)
#define UNLOCK_I mutex_unlock(ir.mutex)
#if !LINKALL
struct lirc {
// LIRC symbols to be dynamically loaded
int (* lirc_init)(char *prog, int verbose);
int (* lirc_deinit)(void);
int (* lirc_readconfig)(char *file, struct lirc_config **config, int (check) (char *s));
void (* lirc_freeconfig)(struct lirc_config *config);
int (* lirc_nextcode)(char **code);
int (* lirc_code2char)(struct lirc_config *config, char *code, char **string);
};
static struct lirc *i;
#endif
#if LINKALL
#define LIRC(h, fn, ...) (lirc_ ## fn)(__VA_ARGS__)
#else
#define LIRC(h, fn, ...) (h)->lirc_##fn(__VA_ARGS__)
#endif
// cmds based on entries in Slim_Device_Remote.ir
// these may appear as config entries in .lircrc files
static struct {
char *cmd;
u32_t code;
} cmdmap[] = {
{ "voldown", 0x768900ff },
{ "volup", 0x7689807f },
{ "rew", 0x7689c03f },
{ "fwd", 0x7689a05f },
{ "pause", 0x768920df },
{ "play", 0x768910ef },
{ "power", 0x768940bf },
{ "muting", 0x7689c43b },
{ "power_on", 0x76898f70 },
{ "power_off",0x76898778 },
{ "preset_1", 0x76898a75 },
{ "preset_2", 0x76894ab5 },
{ "preset_3", 0x7689ca35 },
{ "preset_4", 0x76892ad5 },
{ "preset_5", 0x7689aa55 },
{ "preset_6", 0x76896a95 },
{ NULL, 0 },
};
// selected lirc namespace button names as defaults - some support repeat
static struct {
char *lirc;
u32_t code;
bool repeat;
} keymap[] = {
{ "KEY_VOLUMEDOWN", 0x768900ff, true },
{ "KEY_VOLUMEUP", 0x7689807f, true },
{ "KEY_PREVIOUS", 0x7689c03f, true },
{ "KEY_REWIND", 0x7689c03f, true },
{ "KEY_NEXT", 0x7689a05f, true },
{ "KEY_FORWARD", 0x7689a05f, true },
{ "KEY_PAUSE", 0x768920df, true },
{ "KEY_PLAY", 0x768910ef, false },
{ "KEY_POWER", 0x768940bf, false },
{ "KEY_MUTE", 0x7689c43b, false },
{ "KEY_0", 0x76899867, true },
{ "KEY_1", 0x7689f00f, true },
{ "KEY_2", 0x768908f7, true },
{ "KEY_3", 0x76898877, true },
{ "KEY_4", 0x768948b7, true },
{ "KEY_5", 0x7689c837, true },
{ "KEY_6", 0x768928d7, true },
{ "KEY_7", 0x7689a857, true },
{ "KEY_8", 0x76896897, true },
{ "KEY_9", 0x7689e817, true },
{ "KEY_FAVORITES", 0x768918e7, false },
{ "KEY_FAVORITES", 0x7689e21d, false },
{ "KEY_SEARCH", 0x768958a7, false },
{ "KEY_SEARCH", 0x7689629d, false },
{ "KEY_SHUFFLE", 0x7689d827, false },
{ "KEY_SLEEP", 0x7689b847, false },
{ "KEY_INSERT", 0x7689609f, false }, // Add
{ "KEY_UP", 0x7689e01f, true },
{ "KEY_LEFT", 0x7689906f, true },
{ "KEY_RIGHT", 0x7689d02f, true },
{ "KEY_DOWN", 0x7689b04f, true },
{ "KEY_HOME", 0x768922dd, false },
{ "KEY_MEDIA_REPEAT", 0x768938c7, false },
// { "KEY_TITLE", 0x76897887, false }, // Now Playing
// { "KEY_TITLE", 0x7689a25d, false }, // Now Playing
// { "KEY_TEXT", 0x7689f807, false }, // Size
// { "KEY_BRIGHTNESS_CYCLE", 0x768904fb, false },
{ NULL, 0 , false },
};
static u32_t ir_cmd_map(const char *c) {
int i;
for (i = 0; cmdmap[i].cmd; i++) {
if (!strcmp(c, cmdmap[i].cmd)) {
return cmdmap[i].code;
}
}
return 0;
}
static u32_t ir_key_map(const char *c, const char *r) {
int i;
for (i = 0; keymap[i].lirc; i++) {
if (!strcmp(c, keymap[i].lirc)) {
// inputlirc issues "0", while LIRC uses "00"
if (keymap[i].repeat || !strcmp(r, "0") || !strcmp(r,"00")) {
return keymap[i].code;
}
LOG_DEBUG("repeat suppressed");
break;
}
}
return 0;
}
static void *ir_thread() {
char *code;
while (fd > 0 && LIRC(i, nextcode, &code) == 0) {
u32_t now = gettime_ms();
u32_t ir_code = 0;
if (code == NULL) continue;
if (config) {
// allow lirc_client to decode then lookup cmd in our table
// we can only send one IR event to slimproto so break after first one
char *c;
while (LIRC(i, code2char, config, code, &c) == 0 && c != NULL) {
ir_code = ir_cmd_map(c);
if (ir_code) {
LOG_DEBUG("ir cmd: %s -> %x", c, ir_code);
}
}
}
if (!ir_code) {
// try to match on lirc button name if it is from the standard namespace
// this allows use of non slim remotes without a specific entry in .lircrc
char *b, *r;
strtok(code, " \n"); // discard
r = strtok(NULL, " \n"); // repeat count
b = strtok(NULL, " \n"); // key name
if (r && b) {
ir_code = ir_key_map(b, r);
LOG_DEBUG("ir lirc: %s [%s] -> %x", b, r, ir_code);
}
}
if (ir_code) {
LOCK_I;
if (ir.code) {
LOG_DEBUG("code dropped");
}
ir.code = ir_code;
ir.ts = now;
UNLOCK_I;
wake_controller();
}
free(code);
}
return 0;
}
#if !LINKALL
static bool load_lirc() {
void *handle = dlopen(LIBLIRC, RTLD_NOW);
char *err;
if (!handle) {
LOG_INFO("dlerror: %s", dlerror());
return false;
}
i->lirc_init = dlsym(handle, "lirc_init");
i->lirc_deinit = dlsym(handle, "lirc_deinit");
i->lirc_readconfig = dlsym(handle, "lirc_readconfig");
i->lirc_freeconfig = dlsym(handle, "lirc_freeconfig");
i->lirc_nextcode = dlsym(handle, "lirc_nextcode");
i->lirc_code2char = dlsym(handle, "lirc_code2char");
if ((err = dlerror()) != NULL) {
LOG_INFO("dlerror: %s", err);
return false;
}
LOG_INFO("loaded "LIBLIRC);
return true;
}
#endif
void ir_init(log_level level, char *lircrc) {
loglevel = level;
#if !LINKALL
i = malloc(sizeof(struct lirc));
if (!i || !load_lirc()) {
return;
}
#endif
fd = LIRC(i, init, LIRC_CLIENT_ID, 0);
if (fd > 0) {
if (LIRC(i, readconfig, lircrc, &config, NULL) != 0) {
LOG_WARN("error reading config: %s", lircrc);
}
else {
LOG_DEBUG("loaded lircrc config: %s", lircrc);
}
mutex_create(ir.mutex);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN + IR_THREAD_STACK_SIZE);
pthread_create(&thread, &attr, ir_thread, NULL);
pthread_attr_destroy(&attr);
} else {
LOG_WARN("failed to connect to lircd - ir processing disabled");
}
}
void ir_close(void) {
if (fd > 0) {
fd = -1;
if (config) {
LIRC(i, freeconfig, config);
}
LIRC(i, deinit);
pthread_cancel(thread);
pthread_join(thread, NULL);
mutex_destroy(ir.mutex);
}
}
#endif //#if IR
|
the_stack_data/15923.c | #include <math.h>
double y1(double x)
{
return x;
}
/*
XOPEN(4)
LINK(m)
*/
|
the_stack_data/12638317.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NAME_LENGTH_LIMIT 128
#define OPERATOR_LENGTH_LIMIT 8
typedef struct MemBlock {
size_t lo, hi;
char *name;
struct MemBlock *prev, *next;
} MemBlock;
size_t mem_size = 0;
MemBlock *mem;
MemBlock *make_block(size_t lo, size_t hi, const char *name, MemBlock *prev, MemBlock *next) {
MemBlock *ret = malloc(sizeof(MemBlock));
if(ret == NULL) {
printf("Failed to allocate phisical memory.\n");
exit(-1);
}
ret->lo = lo, ret->hi = hi;
// allocate memory and copy the string
if(strlen(name) != 0) {
ret->name = malloc(sizeof(char) * (strlen(name) + 1));
strcpy(ret->name, name);
} else { // unused block
ret->name = NULL;
}
// handle the prev and next to preserve a doubly-linked list
ret->prev = prev, ret->next = next;
if(prev) {
prev->next = ret;
}
if(next) {
next->prev = ret;
}
return ret;
}
int request_memory(const char *name, size_t size, char strategy) {
MemBlock *hole = NULL;
// select the hole
switch(strategy) {
case 'F': {
hole = mem;
while(hole) {
if(hole->name == NULL && (hole->hi - hole->lo + 1) >= size) {
break;
}
hole = hole->next;
}
break;
}
case 'B': {
MemBlock *cursor = mem;
size_t min_size = -1; // get the max number in size_t
while(cursor) {
size_t hole_size = (cursor-> hi - cursor->lo + 1);
if(cursor->name == NULL && size <= hole_size && hole_size < min_size) {
min_size = hole_size;
hole = cursor;
}
cursor = cursor->next;
}
break;
}
case 'W': {
MemBlock *cursor = mem;
size_t max_size = size - 1;
while(cursor) {
size_t hole_size = (cursor-> hi - cursor->lo + 1);
if(cursor->name == NULL && hole_size > max_size) {
max_size = hole_size;
hole = cursor;
}
cursor = cursor->next;
}
break;
}
default: {
printf("Unknown strategy: %c\n", strategy);
return -1;
}
}
if(!hole || hole->name != NULL) {
printf("No available memory to allocate.\n");
return -2;
}
hole->name = malloc(sizeof(char) * (strlen(name) + 1));
strcpy(hole->name, name);
if(hole->hi - hole->lo + 1 == size) { // the hole size is exactly equal to the requested size
return 0;
}
hole->next = make_block(hole->lo + size, hole->hi, "", hole, hole->next);
hole->hi = hole->lo + size - 1;
return 0;
}
// release all blocks with the given name, and do the merges if possible
int release_memory(const char *name) {
MemBlock *cursor = mem;
int flag = 1;
while(cursor) {
if(cursor->name && strcmp(cursor->name, name) == 0) {
free(cursor->name);
cursor->name = NULL; // mark it unused
flag = 0;
}
// merge with the prev block if possible
if(cursor->name == NULL && cursor->prev && cursor->prev->name == NULL) {
MemBlock *temp = cursor->prev;
cursor->prev = temp->prev;
if(temp->prev) {
temp->prev->next = cursor;
}
cursor->lo = temp->lo;
free(temp);
}
// update the first block in memory if necessary
if(cursor->prev == NULL) {
mem = cursor;
}
cursor = cursor->next;
}
if(flag) {
printf("No memory gets released!\n");
}
return flag;
}
void compact_memory() {
MemBlock *cursor = mem;
while(cursor) {
// unused --> used, swap these two blocks
if(cursor->name && cursor->prev && !cursor->prev->name) {
MemBlock *prev = cursor->prev;
prev->hi = prev->lo + (cursor->hi - cursor->lo);
cursor->lo = prev->hi + 1;
prev->name = cursor->name;
cursor->name = NULL;
}
// unused --> unused, merge thees two blocks
if(!cursor->name && cursor->prev && !cursor->prev->name) {
MemBlock *prev = cursor->prev;
cursor->lo = prev->lo;
cursor->prev = prev->prev;
if(cursor->prev) {
cursor->prev->next = cursor;
}
free(prev);
}
cursor = cursor->next;
}
}
void request_wrapper() {
char name[NAME_LENGTH_LIMIT], strategy;
size_t size;
scanf("%s %zu %c", name, &size, &strategy); // unsafe but convenient
printf(request_memory(name, size, strategy) ? "FAILURE\n" : "SUCCESS\n");
}
void release_wrapper() {
char name[NAME_LENGTH_LIMIT];
scanf("%s", name); // unsafe but convenient
printf(release_memory(name) ? "FAILURE\n" : "SUCCESS\n");
}
void display_usage() {
printf("=============================================================\n");
printf("<this program> <memory size (in bytes)>\n");
printf("Operations:\n");
printf(" RQ <process name> <memory size (in bytes)> <strategy>\n"
" Request for a contigous block of memory (available strategies are F, W and B)\n"
" RL <process name>\n"
" Release the process's contigous block of memory\n"
" C\n"
" Compact unused holes of memory into one single block\n"
" STAT\n"
" Report the regions of free and allocated memory\n"
" X\n"
" Exit\n"
);
printf("=============================================================\n");
}
void display_memory() {
printf("=============================================================\n");
MemBlock *cursor = mem;
while(cursor) {
printf("[%06zu - %06zu] ", cursor->lo, cursor->hi);
if(cursor->name) {
printf("Process %s\n", cursor->name);
} else {
printf("Unused\n");
}
cursor = cursor->next;
}
printf("=============================================================\n");
}
int init(int argc, char **argv) {
if(argc != 2) {
printf("Incorrect number of arguments.\n");
return -1;
}
sscanf(argv[1], "%zu", &mem_size);
mem = make_block(0, mem_size - 1, "", NULL, NULL);
printf("The size of memory is initialized to %zu bytes\n", mem_size);
return 0;
}
void clean_up() {
MemBlock *temp = mem;
while(mem) {
free(mem -> name);
temp = mem;
mem = mem -> next;
free(temp);
}
}
int main(int argc, char **argv) {
if(init(argc, argv) != 0) {
display_usage();
return 0;
}
char op[OPERATOR_LENGTH_LIMIT];
while(1) {
printf("allocator> ");
scanf("%s", op); // unsafe but convenient
if(strcmp(op, "RQ") == 0) {
request_wrapper();
} else if(strcmp(op, "RL") == 0) {
release_wrapper();
} else if(strcmp(op, "C") == 0) {
compact_memory();
} else if(strcmp(op, "STAT") == 0) {
display_memory();
} else if(strcmp(op, "X") == 0) {
clean_up();
break;
} else {
printf("Unrecognized operation.\n");
display_usage();
}
// display_memory();
}
return 0;
}
|
the_stack_data/174558.c | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#include <stdio.h>
#include <stdlib.h>
typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
typedef int (*TestFunc)( Type, void* );
struct Description;
int IsBigEndian(void);
int IsStackGrowingDown_2( int * pI );
int IsStackGrowingDown(void);
int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... );
int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c );
int GetStackAlignment(void);
void PrintArgs( int p, ... );
int check( TestFunc func, Type eT, void* p );
#if defined (UNX) || defined (WNT) || defined (OS2)
#ifdef UNX
#include <unistd.h>
#endif
#include <sys/types.h>
#define I_STDARG
#ifdef I_STDARG
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#define NO_USE_FORK_TO_CHECK
#ifdef USE_FORK_TO_CHECK
#include <sys/wait.h>
#else
#include <signal.h>
#include <setjmp.h>
#endif
#else
#endif
#define printTypeSize(Type,Name) printf( "sizeof(%s)\t= %d\n", Name, \
sizeof (Type) )
#define isSignedType(Type) (((Type)-1) < 0)
#define printTypeSign(Type,Name) printf( "%s\t= %s %s\n", Name, \
( isSignedType(Type) ? "unsigned" : "signed" ), Name )
int IsBigEndian()
{
long l = 1;
return ! *(char*)&l;
}
int IsStackGrowingDown_2( int * pI )
{
int i = 1;
return ((unsigned long)&i) < (unsigned long)pI;
}
int IsStackGrowingDown()
{
int i = 1;
return IsStackGrowingDown_2(&i);
}
int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... )
{
(void) p; (void) l; (void) i; (void) s; /* unused */
if ( IsStackGrowingDown() )
return &c - &b;
else
return &b - &c;
}
int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c )
{
(void) p; (void) l; (void) i; (void) s; /* unused */
if ( IsStackGrowingDown() )
return &c - &b;
else
return &b - &c;
}
int GetStackAlignment()
{
int nStackAlignment = GetStackAlignment_3(0,1,2,3,4,5);
if ( nStackAlignment != GetStackAlignment_2(0,1,2,3,4,5) )
printf( "Pascal calling convention\n" );
return nStackAlignment;
}
#if defined (UNX) || defined (WNT) || defined (OS2)
#ifdef I_STDARG
void PrintArgs( int p, ... )
#else
void PrintArgs( p, va_alist )
int p;
va_dcl
#endif
{
int value;
va_list ap;
#ifdef I_STDARG
va_start( ap, p );
#else
va_start( ap );
#endif
printf( "value = %d", p );
while ( ( value = va_arg(ap, int) ) != 0 )
printf( " %d", value );
printf( "\n" );
va_end(ap);
}
#ifndef USE_FORK_TO_CHECK
static jmp_buf check_env;
static int bSignal;
#if defined (UNX) || defined (OS2)
void SignalHandler( int sig )
#else
void __cdecl SignalHandler( int sig )
#endif
{
bSignal = 1;
/*
fprintf( stderr, "Signal %d caught\n", sig );
signal( sig, SignalHandler );
*/
longjmp( check_env, sig );
}
#endif
int check( TestFunc func, Type eT, void* p )
{
#ifdef USE_FORK_TO_CHECK
pid_t nChild = fork();
if ( nChild )
{
int exitVal;
wait( &exitVal );
if ( exitVal & 0xff )
return -1;
else
return exitVal >> 8;
}
else
{
exit( func( eT, p ) );
}
#else
int result;
bSignal = 0;
if ( !setjmp( check_env ) )
{
signal( SIGSEGV, SignalHandler );
#ifdef UNX
signal( SIGBUS, SignalHandler );
#else
#endif
result = func( eT, p );
signal( SIGSEGV, SIG_DFL );
#ifdef UNX
signal( SIGBUS, SIG_DFL );
#else
#endif
}
if ( bSignal )
return -1;
else
return 0;
#endif
}
#endif
int GetAtAddress( Type eT, void* p )
{
switch ( eT )
{
case t_char: return *((char*)p);
case t_short: return *((short*)p);
case t_int: return *((int*)p);
case t_long: return *((long*)p);
case t_double: return *((double*)p);
}
abort();
}
int SetAtAddress( Type eT, void* p )
{
switch ( eT )
{
case t_char: return *((char*)p) = 0;
case t_short: return *((short*)p) = 0;
case t_int: return *((int*)p) = 0;
case t_long: return *((long*)p) = 0;
case t_double: return *((double*)p)= 0;
}
abort();
}
char* TypeName( Type eT )
{
switch ( eT )
{
case t_char: return "char";
case t_short: return "short";
case t_int: return "int";
case t_long: return "long";
case t_double: return "double";
}
abort();
}
int CheckGetAccess( Type eT, void* p )
{
int b;
b = -1 != check( (TestFunc)GetAtAddress, eT, p );
#if OSL_DEBUG_LEVEL > 1
fprintf( stderr,
"%s read %s at %p\n",
(b? "can" : "can not" ), TypeName(eT), p );
#endif
return b;
}
int CheckSetAccess( Type eT, void* p )
{
int b;
b = -1 != check( (TestFunc)SetAtAddress, eT, p );
#if OSL_DEBUG_LEVEL > 1
fprintf( stderr,
"%s write %s at %p\n",
(b? "can" : "can not" ), TypeName(eT), p );
#endif
return b;
}
int GetAlignment( Type eT )
{
char a[ 16*8 ];
int p = (int)(void*)&a;
int i;
p = ( p + 0xF ) & ~0xF;
for ( i = 1; i < 16; i++ )
if ( CheckGetAccess( eT, (void*)(p+i) ) )
return i;
return 0;
}
int CheckCharAccess( char* p )
{
if ( CheckGetAccess( t_char, p ) )
printf( "can read address %p\n", p );
else
printf( "can not read address %p\n", p );
if ( CheckSetAccess( t_char, p ) )
printf( "can write address %p\n", p );
else
printf( "can not write address %p\n", p );
return 0;
}
struct Description
{
int bBigEndian;
int bStackGrowsDown;
int nStackAlignment;
int nAlignment[3]; /* 2,4,8 */
};
void Description_Ctor( struct Description* pThis )
{
pThis->bBigEndian = IsBigEndian();
pThis->bStackGrowsDown = IsStackGrowingDown();
pThis->nStackAlignment = GetStackAlignment();
if ( sizeof(short) != 2 )
abort();
pThis->nAlignment[0] = GetAlignment( t_short );
if ( sizeof(int) != 4 )
abort();
pThis->nAlignment[1] = GetAlignment( t_int );
if ( sizeof(double) != 8 )
abort();
pThis->nAlignment[2] = GetAlignment( t_double );
}
void Description_Print( struct Description* pThis, char* name )
{
int i;
FILE* f = fopen( name, "w" );
fprintf( f, "#define __%s\n",
pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" );
for ( i = 0; i < 3; i++ )
fprintf( f, "#define __ALIGNMENT%d\t%d\n",
1 << (i+1), pThis->nAlignment[i] );
fprintf( f, "#define __STACKALIGNMENT wird nicht benutzt\t%d\n", pThis->nStackAlignment );
fprintf( f, "#define __STACKDIRECTION\t%d\n",
pThis->bStackGrowsDown ? -1 : 1 );
fprintf( f, "#define __SIZEOFCHAR\t%d\n", sizeof( char ) );
fprintf( f, "#define __SIZEOFSHORT\t%d\n", sizeof( short ) );
fprintf( f, "#define __SIZEOFINT\t%d\n", sizeof( int ) );
fprintf( f, "#define __SIZEOFLONG\t%d\n", sizeof( long ) );
fprintf( f, "#define __SIZEOFPOINTER\t%d\n", sizeof( void* ) );
fprintf( f, "#define __SIZEOFDOUBLE\t%d\n", sizeof( double ) );
fprintf( f, "#define __IEEEDOUBLE\n" );
fprintf( f, "#define _SOLAR_NODESCRIPTION\n" );
fclose(f);
}
int
#ifdef WNT
__cdecl
#endif
main( int argc, char* argv[] )
{
printTypeSign( char, "char" );
printTypeSign( short, "short" );
printTypeSign( int, "int" );
printTypeSign( long, "long" );
printTypeSize( char, "char" );
printTypeSize( short, "short" );
printTypeSize( int, "int" );
printTypeSize( long, "long" );
printTypeSize( float, "float" );
printTypeSize( double, "double" );
printTypeSize( void *, "void *" );
if ( IsBigEndian() )
printf( "BIGENDIAN (Sparc, MC680x0, RS6000)\n" );
else
printf( "LITTLEENDIAN (Intel, VAX, PowerPC)\n" );
if( IsStackGrowingDown() )
printf( "Stack waechst nach unten\n" );
else
printf( "Stack waechst nach oben\n" );
printf( "STACKALIGNMENT : %d\n", GetStackAlignment() );
PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 );
{
char a[64];
int i = 56;
do
{
printf( "Zugriff long auf %i-Aligned Adresse : ", i / 7 );
printf( ( CheckGetAccess( t_long, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
i >>= 1;
} while( i >= 7 );
}
{
char a[64];
int i = 56;
do
{
printf( "Zugriff double auf %i-Aligned Adresse : ", i / 7 );
printf( ( CheckGetAccess( t_double, (double*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
i >>= 1;
} while( i >= 7 );
}
{
char* p = NULL;
CheckCharAccess( p );
p = (char*)&p;
CheckCharAccess( p );
}
if ( argc > 1 )
{
struct Description description;
Description_Ctor( &description );
Description_Print( &description, argv[1] );
}
exit( 0 );
return 0;
}
|
the_stack_data/70451280.c | #include "stdio.h"
main()
{
int digital[10];
int i;
int c;
int ndigital;
int nwhite;
int nother;
ndigital = nwhite = nother = 0;
for(i = 0; i < 10; ++i)
{
digital[i] = 0;
}
while((c = getchar()) != EOF)
{
if(c >= '0' && c <= '9')
{
++digital[c - '0'];
++ndigital;
}else if(c == ' ' || c == '\n' || c == '\t')
{
++nwhite;
}else{
++nother;
}
printf("digits =");
for (i = 0; i < 10; ++i)
{
printf(" %d", digital[i]);
}
printf(", white space = %d, other = %d\n", nwhite, nother);
}
}
|
the_stack_data/34511606.c | #include <ctype.h>
int toupper(int c) {
return islower(c) ? c - 'a' + 'A' : c ;
}
|
the_stack_data/1088668.c | // REQUIRES: x86-registered-target
// REQUIRES: powerpc-registered-target
// UNSUPPORTED: darwin
//
// Generate all the types of files we can bundle.
//
// RUN: %clang -O0 -target %itanium_abi_triple %s -E -o %t.i
// RUN: %clangxx -O0 -target %itanium_abi_triple -x c++ %s -E -o %t.ii
// RUN: %clang -O0 -target %itanium_abi_triple %s -S -emit-llvm -o %t.ll
// RUN: %clang -O0 -target %itanium_abi_triple %s -c -emit-llvm -o %t.bc
// RUN: %clang -O0 -target %itanium_abi_triple %s -S -o %t.s
// RUN: %clang -O0 -target %itanium_abi_triple %s -c -o %t.o
// RUN: %clang -O0 -target %itanium_abi_triple %s -emit-ast -o %t.ast
//
// Generate an empty file to help with the checks of empty files.
//
// RUN: touch %t.empty
//
// Generate a couple of files to bundle with.
//
// RUN: echo 'Content of device file 1' > %t.tgt1
// RUN: echo 'Content of device file 2' > %t.tgt2
//
// Check help message.
//
// RUN: clang-offload-bundler --help | FileCheck %s --check-prefix CK-HELP
// CK-HELP: {{.*}}OVERVIEW: A tool to bundle several input files of the specified type <type>
// CK-HELP: {{.*}}referring to the same source file but different targets into a single
// CK-HELP: {{.*}}one. The resulting file can also be unbundled into different files by
// CK-HELP: {{.*}}this tool if -unbundle is provided.
// CK-HELP: {{.*}}USAGE: clang-offload-bundler [options]
// CK-HELP: {{.*}}-inputs=<string> - [<input file>,...]
// CK-HELP: {{.*}}-outputs=<string> - [<output file>,...]
// CK-HELP: {{.*}}-targets=<string> - [<offload kind>-<target triple>,...]
// CK-HELP: {{.*}}-type=<string> - Type of the files to be bundled/unbundled/checked.
// CK-HELP: {{.*}}Current supported types are:
// CK-HELP: {{.*}}i {{.*}}- cpp-output
// CK-HELP: {{.*}}ii {{.*}}- c++-cpp-output
// CK-HELP: {{.*}}ll {{.*}}- llvm
// CK-HELP: {{.*}}bc {{.*}}- llvm-bc
// CK-HELP: {{.*}}s {{.*}}- assembler
// CK-HELP: {{.*}}o {{.*}}- object
// CK-HELP: {{.*}}gch {{.*}}- precompiled-header
// CK-HELP: {{.*}}ast {{.*}}- clang AST file
// CK-HELP: {{.*}}a {{.*}}- archive of objects
// CK-HELP: {{.*}}ao {{.*}}- archive with one object; output is an unbundled object
// CK-HELP: {{.*}}aoo {{.*}}- archive; output file is a list of unbundled objects
// CK-HELP: {{.*}}-unbundle {{.*}}- Unbundle bundled file into several output files.
//
// Check errors.
//
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR1
// CK-ERR1: error: only one input file supported in unbundling mode
// CK-ERR1: error: number of output files and targets should match in unbundling mode
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR2
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR2
// CK-ERR2: error: number of input files and targets should match in bundling mode
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR3
// CK-ERR3: error: only one output file supported in bundling mode
// CK-ERR3: error: number of input files and targets should match in bundling mode
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR4
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1 -inputs=%t.bundle.i -unbundle 2>&1 | FileCheck %s --check-prefix CK-ERR4
// CK-ERR4: error: number of output files and targets should match in unbundling mode
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2.notexist -outputs=%t.bundle.i 2>&1 | FileCheck %s -DFILE=%t.tgt2.notexist --check-prefix CK-ERR5
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i.notexist -unbundle 2>&1 | FileCheck %s -DFILE=%t.bundle.i.notexist --check-prefix CK-ERR5
// CK-ERR5: error: '[[FILE]]': {{N|n}}o such file or directory
// RUN: not clang-offload-bundler -type=invalid -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s -DTYPE=invalid --check-prefix CK-ERR6
// CK-ERR6: error: '[[TYPE]]': invalid file type specified
// RUN: not clang-offload-bundler 2>&1 | FileCheck %s --check-prefix CK-ERR7
// CK-ERR7-DAG: clang-offload-bundler: for the --type option: must be specified at least once!
// CK-ERR7-DAG: clang-offload-bundler: for the --inputs option: must be specified at least once!
// CK-ERR7-DAG: clang-offload-bundler: for the --targets option: must be specified at least once!
// RUN: not clang-offload-bundler -type=i -targets=hxst-powerpcxxle-ibm-linux-gnu,openxp-pxxerpc64le-ibm-linux-gnu,xpenmp-x86_xx-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR8
// CK-ERR8: error: invalid target 'hxst-powerpcxxle-ibm-linux-gnu', unknown offloading kind 'hxst', unknown target triple 'powerpcxxle-ibm-linux-gnu'
// CK-ERR8: error: invalid target 'openxp-pxxerpc64le-ibm-linux-gnu', unknown offloading kind 'openxp', unknown target triple 'pxxerpc64le-ibm-linux-gnu'
// CK-ERR8: error: invalid target 'xpenmp-x86_xx-pc-linux-gnu', unknown offloading kind 'xpenmp', unknown target triple 'x86_xx-pc-linux-gnu'
// RUN: not clang-offload-bundler -type=i -targets=openmp-powerpc64le-linux,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR9A
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle.i 2>&1 | FileCheck %s --check-prefix CK-ERR9B
// CK-ERR9A: error: expecting exactly one host target but got 0
// CK-ERR9B: error: expecting exactly one host target but got 2
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -outputs=%t.i,%t.tgt1,%t.tgt2 -inputs=%t.bundle.i -unbundle -check-section 2>&1 | FileCheck %s --check-prefix CK-ERR10
// CK-ERR10: error: -unbundle and -check-section are not compatible options
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -inputs=%t.bundle.i,%t.i -check-section 2>&1 | FileCheck %s --check-prefix CK-ERR11
// CK-ERR11: error: only one input file supported in checking mode
// RUN: not clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu -inputs=%t.bundle.i -check-section 2>&1 | FileCheck %s --check-prefix CK-ERR12
// CK-ERR12: error: only one target supported in checking mode
// RUN: not clang-offload-bundler -type=i -targets=openmp-powerpc64le-ibm-linux-gnu -inputs=%t.bundle.i -outputs=%t.r -check-section 2>&1 | FileCheck %s --check-prefix CK-ERR13
// CK-ERR13: error: no output file supported in checking mode
//
// Check text bundle. This is a readable format, so we check for the format we expect to find.
//
// RUN: clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.i,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.i
// RUN: clang-offload-bundler -type=ii -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ii,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.ii
// RUN: clang-offload-bundler -type=ll -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ll,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.ll
// RUN: clang-offload-bundler -type=s -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.s,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.s
// RUN: clang-offload-bundler -type=s -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -inputs=%t.tgt1,%t.s,%t.tgt2 -outputs=%t.bundle3.unordered.s
// RUN: FileCheck %s --input-file %t.bundle3.i --check-prefix CK-TEXTI
// RUN: FileCheck %s --input-file %t.bundle3.ii --check-prefix CK-TEXTI
// RUN: FileCheck %s --input-file %t.bundle3.ll --check-prefix CK-TEXTLL
// RUN: FileCheck %s --input-file %t.bundle3.s --check-prefix CK-TEXTS
// RUN: FileCheck %s --input-file %t.bundle3.unordered.s --check-prefix CK-TEXTS-UNORDERED
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____START__ host-[[HOST:.+]]
// CK-TEXTI: int A = 0;
// CK-TEXTI: test_func(void)
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____END__ host-[[HOST]]
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____START__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTI: Content of device file 1
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____END__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____START__ openmp-x86_64-pc-linux-gnu
// CK-TEXTI: Content of device file 2
// CK-TEXTI: // __CLANG_OFFLOAD_BUNDLE____END__ openmp-x86_64-pc-linux-gnu
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____START__ host-[[HOST:.+]]
// CK-TEXTLL: @A = {{.*}}global i32 0
// CK-TEXTLL: define {{.*}}@test_func()
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____END__ host-[[HOST]]
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____START__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTLL: Content of device file 1
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____END__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____START__ openmp-x86_64-pc-linux-gnu
// CK-TEXTLL: Content of device file 2
// CK-TEXTLL: ; __CLANG_OFFLOAD_BUNDLE____END__ openmp-x86_64-pc-linux-gnu
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____START__ host-[[HOST:.+]]
// CK-TEXTS: .globl {{.*}}test_func
// CK-TEXTS: .globl {{.*}}A
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____END__ host-[[HOST]]
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____START__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTS: Content of device file 1
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____END__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____START__ openmp-x86_64-pc-linux-gnu
// CK-TEXTS: Content of device file 2
// CK-TEXTS: # __CLANG_OFFLOAD_BUNDLE____END__ openmp-x86_64-pc-linux-gnu
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____START__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTS-UNORDERED: Content of device file 1
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____END__ openmp-powerpc64le-ibm-linux-gnu
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____START__ host-[[HOST:.+]]
// CK-TEXTS-UNORDERED: .globl {{.*}}test_func
// CK-TEXTS-UNORDERED: .globl {{.*}}A
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____END__ host-[[HOST]]
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____START__ openmp-x86_64-pc-linux-gnu
// CK-TEXTS-UNORDERED: Content of device file 2
// CK-TEXTS-UNORDERED: # __CLANG_OFFLOAD_BUNDLE____END__ openmp-x86_64-pc-linux-gnu
//
// Check text unbundle. Check if we get the exact same content that we bundled before for each file.
//
// RUN: clang-offload-bundler -type=i -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.i,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.i -unbundle
// RUN: diff %t.i %t.res.i
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=i -targets=openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.tgt1 -inputs=%t.bundle3.i -unbundle
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: clang-offload-bundler -type=ii -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.ii,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.ii -unbundle
// RUN: diff %t.ii %t.res.ii
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ii -targets=openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt2 -inputs=%t.bundle3.ii -unbundle
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ll -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.ll,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.ll -unbundle
// RUN: diff %t.ll %t.res.ll
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ll -targets=openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.tgt1 -inputs=%t.bundle3.ll -unbundle
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: clang-offload-bundler -type=s -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.s,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.s -unbundle
// RUN: diff %t.s %t.res.s
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=s -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.s,%t.res.tgt2 -inputs=%t.bundle3.s -unbundle
// RUN: diff %t.s %t.res.s
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=s -targets=openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt2 -inputs=%t.bundle3.s -unbundle
// RUN: diff %t.tgt2 %t.res.tgt2
// Check if we can unbundle a file with no magic strings.
// RUN: clang-offload-bundler -type=s -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.s,%t.res.tgt1,%t.res.tgt2 -inputs=%t.s -unbundle
// RUN: diff %t.s %t.res.s
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
// RUN: clang-offload-bundler -type=s -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.s,%t.res.tgt2 -inputs=%t.s -unbundle
// RUN: diff %t.s %t.res.s
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
// Check that bindler prints an error if given host bundle does not exist in the fat binary.
// RUN: not clang-offload-bundler -type=s -targets=host-x86_64-xxx-linux-gnu,openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.s,%t.res.tgt1 -inputs=%t.bundle3.s -unbundle 2>&1 | FileCheck %s --check-prefix CK-NO-HOST-BUNDLE
// CK-NO-HOST-BUNDLE: error: Can't find bundle for the host target
//
// Check binary bundle/unbundle. The content that we have before bundling must be the same we have after unbundling.
//
// RUN: clang-offload-bundler -type=bc -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.bc,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.bc
// RUN: clang-offload-bundler -type=gch -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ast,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.gch
// RUN: clang-offload-bundler -type=ast -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.ast,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.ast
// RUN: clang-offload-bundler -type=ast -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -inputs=%t.tgt1,%t.ast,%t.tgt2 -outputs=%t.bundle3.unordered.ast
// RUN: clang-offload-bundler -type=bc -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.bc,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.bc -unbundle
// RUN: diff %t.bc %t.res.bc
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=bc -targets=openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.tgt1 -inputs=%t.bundle3.bc -unbundle
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: clang-offload-bundler -type=gch -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.gch,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.gch -unbundle
// RUN: diff %t.ast %t.res.gch
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=gch -targets=openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt2 -inputs=%t.bundle3.gch -unbundle
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ast -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.ast,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.ast -unbundle
// RUN: diff %t.ast %t.res.ast
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ast -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.ast,%t.res.tgt2 -inputs=%t.bundle3.ast -unbundle
// RUN: diff %t.ast %t.res.ast
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ast -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.ast,%t.res.tgt2 -inputs=%t.bundle3.unordered.ast -unbundle
// RUN: diff %t.ast %t.res.ast
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=ast -targets=openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.tgt1 -inputs=%t.bundle3.ast -unbundle
// RUN: diff %t.tgt1 %t.res.tgt1
// Check if we can unbundle a file with no magic strings.
// RUN: clang-offload-bundler -type=bc -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.bc,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bc -unbundle
// RUN: diff %t.bc %t.res.bc
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
// RUN: clang-offload-bundler -type=bc -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.bc,%t.res.tgt2 -inputs=%t.bc -unbundle
// RUN: diff %t.bc %t.res.bc
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
// Check that we do not have to unbundle all available bundles from the fat binary.
// RUN: clang-offload-bundler -type=ast -targets=host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.ast,%t.res.tgt2 -inputs=%t.bundle3.unordered.ast -unbundle
// RUN: diff %t.ast %t.res.ast
// RUN: diff %t.tgt2 %t.res.tgt2
//
// Check object bundle/unbundle. The content should be bundled into an ELF
// section (we are using a PowerPC little-endian host which uses ELF). We
// have an already bundled file to check the unbundle and do a dry run on the
// bundling as it cannot be tested in all host platforms that will run these
// tests.
//
// RUN: clang-offload-bundler -type=o -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.o,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.o -### 2>&1 \
// RUN: | FileCheck %s -DHOST=%itanium_abi_triple -DINOBJ1=%t.o -DINOBJ2=%t.tgt1 -DINOBJ3=%t.tgt2 -DOUTOBJ=%t.bundle3.o --check-prefix CK-OBJ-CMD
// CK-OBJ-CMD: llvm-objcopy{{(.exe)?}}" "--add-section=__CLANG_OFFLOAD_BUNDLE__host-[[HOST]]={{.*}}" "--add-section=__CLANG_OFFLOAD_BUNDLE_SIZE__host-[[HOST]]={{.+}}.tmp" "--add-section=__CLANG_OFFLOAD_BUNDLE__openmp-powerpc64le-ibm-linux-gnu=[[INOBJ2]]" "--add-section=__CLANG_OFFLOAD_BUNDLE_SIZE__openmp-powerpc64le-ibm-linux-gnu={{.+}}.tmp" "--add-section=__CLANG_OFFLOAD_BUNDLE__openmp-x86_64-pc-linux-gnu=[[INOBJ3]]" "--add-section=__CLANG_OFFLOAD_BUNDLE_SIZE__openmp-x86_64-pc-linux-gnu={{.+}}.tmp" "[[INOBJ1]]" "[[TEMPOBJ:.*]]"
// CK-OBJ-CMD: llvm-objcopy{{(.exe)?}}" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE__host-[[HOST]]=readonly,exclude" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE_SIZE__host-[[HOST]]=readonly,exclude" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE__openmp-powerpc64le-ibm-linux-gnu=readonly,exclude" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE_SIZE__openmp-powerpc64le-ibm-linux-gnu=readonly,exclude" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE__openmp-x86_64-pc-linux-gnu=readonly,exclude" "--set-section-flags=__CLANG_OFFLOAD_BUNDLE_SIZE__openmp-x86_64-pc-linux-gnu=readonly,exclude" "[[TEMPOBJ]]" "[[OUTOBJ]]"
// RUN: clang-offload-bundler -type=o -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.o,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.o
// RUN: clang-offload-bundler -type=o -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.o,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.o -unbundle
// RUN: diff %t.bundle3.o %t.res.o
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=o -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.o,%t.res.tgt2 -inputs=%t.bundle3.o -unbundle
// RUN: diff %t.bundle3.o %t.res.o
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// RUN: clang-offload-bundler -type=o -targets=openmp-powerpc64le-ibm-linux-gnu -outputs=%t.res.tgt1 -inputs=%t.bundle3.o -unbundle
// RUN: diff %t.tgt1 %t.res.tgt1
// Check if we can unbundle a file with no magic strings.
// RUN: clang-offload-bundler -type=o -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.o,%t.res.tgt1,%t.res.tgt2 -inputs=%t.o -unbundle
// RUN: diff %t.o %t.res.o
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
// RUN: clang-offload-bundler -type=o -targets=openmp-powerpc64le-ibm-linux-gnu,host-%itanium_abi_triple,openmp-x86_64-pc-linux-gnu -outputs=%t.res.tgt1,%t.res.o,%t.res.tgt2 -inputs=%t.o -unbundle
// RUN: diff %t.o %t.res.o
// RUN: diff %t.empty %t.res.tgt1
// RUN: diff %t.empty %t.res.tgt2
//
// Check target checking
//
// RUN: clang-offload-bundler -type=bc -targets=host-%itanium_abi_triple -inputs=%t.bundle3.bc -check-section
// RUN: clang-offload-bundler -type=bc -targets=openmp-powerpc64le-ibm-linux-gnu -inputs=%t.bundle3.bc -check-section
// RUN: clang-offload-bundler -type=bc -targets=openmp-x86_64-pc-linux-gnu -inputs=%t.bundle3.bc -check-section
// RUN: not clang-offload-bundler -type=bc -targets=fpga-fpga_aocr-intel-linux-sycldevice -inputs=%t.bundle3.bc -check-section
// RUN: not clang-offload-bundler -type=bc -targets=fpga-fpga_aoco-intel-linux-sycldevice -inputs=%t.bundle3.bc -check-section
// RUN: not clang-offload-bundler -type=bc -targets=fpga-fpga_aocx-intel-linux-sycldevice -inputs=%t.bundle3.bc -check-section
//
// Check archive bundle.
//
// Check file-list mode.
// RUN: echo 'Invalid object' > %t.invalid.o
// RUN: rm -f %t.a
// RUN: llvm-ar crv %t.a %t.bundle3.o %t.invalid.o
// RUN: clang-offload-bundler -type=aoo -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.host.lst,%t.tgt1.lst,%t.tgt2.lst -inputs=%t.a -unbundle
// RUN: wc -l %t.host.lst | FileCheck %s --check-prefix=CHECK-AR-FILE-LIST
// RUN: wc -l %t.tgt1.lst | FileCheck %s --check-prefix=CHECK-AR-FILE-LIST
// RUN: wc -l %t.tgt2.lst | FileCheck %s --check-prefix=CHECK-AR-FILE-LIST
// RUN: diff %t.bundle3.o `cat %t.host.lst`
// RUN: diff %t.tgt1 `cat %t.tgt1.lst`
// RUN: diff %t.tgt2 `cat %t.tgt2.lst`
// CHECK-AR-FILE-LIST: 1
// Check single-file mode.
// RUN: clang-offload-bundler -type=ao -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.host.out,%t.tgt1.out,%t.tgt2.out -inputs=%t.a -unbundle
// RUN: diff %t.bundle3.o %t.host.out
// RUN: diff %t.tgt1 %t.tgt1.out
// RUN: diff %t.tgt2 %t.tgt2.out
// Check that bundler does not accept multi-file archive in single-file mode.
// RUN: cp %t.bundle3.o %t.bundle4.o
// RUN: llvm-ar crv %t.a %t.bundle3.o %t.bundle4.o %t.invalid.o
// RUN: not clang-offload-bundler -type=ao -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.host.out,%t.tgt1.out,%t.tgt2.out -inputs=%t.a -unbundle 2>&1 \
// RUN: | FileCheck %s --check-prefix CHECK-MULTI-FILE-AR-ERROR
// CHECK-MULTI-FILE-AR-ERROR: 'ao' file type is requested, but the archive contains multiple device objects; use 'aoo' instead
// Check -bundle-align option
//
// RUN: clang-offload-bundler -bundle-align=4096 -type=bc -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -inputs=%t.bc,%t.tgt1,%t.tgt2 -outputs=%t.bundle3.bc
// RUN: clang-offload-bundler -type=bc -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.res.bc,%t.res.tgt1,%t.res.tgt2 -inputs=%t.bundle3.bc -unbundle
// RUN: diff %t.bc %t.res.bc
// RUN: diff %t.tgt1 %t.res.tgt1
// RUN: diff %t.tgt2 %t.res.tgt2
// Check archive mode.
// RUN: clang-offload-bundler -type=a -targets=host-%itanium_abi_triple,openmp-powerpc64le-ibm-linux-gnu,openmp-x86_64-pc-linux-gnu -outputs=%t.host.a,%t.tgt1.a,%t.tgt2.a -inputs=%t.a -unbundle
// RUN: cmp %t.host.a %t.a
// RUN: llvm-ar t %t.tgt1.a | FileCheck %s --check-prefix=CHECK-AR-TGT1-LIST
// RUN: llvm-ar t %t.tgt2.a | FileCheck %s --check-prefix=CHECK-AR-TGT2-LIST
// CHECK-AR-TGT1-LIST: openmp-powerpc64le-ibm-linux-gnu.{{.+}}.bundle3.o
// CHECK-AR-TGT1-LIST: openmp-powerpc64le-ibm-linux-gnu.{{.+}}.bundle4.o
// CHECK-AR-TGT2-LIST: openmp-x86_64-pc-linux-gnu.{{.+}}.bundle3.o
// CHECK-AR-TGT2-LIST: openmp-x86_64-pc-linux-gnu.{{.+}}.bundle4.o
// Some code so that we can create a binary out of this file.
int A = 0;
void test_func(void) {
++A;
}
// TODO: SYCL specific fail - analyze and enable
// XFAIL: windows-msvc
|
the_stack_data/139444.c | #include <stdint.h>
#include <immintrin.h>
__m256i simd_transition_saturated_256[256] =
{ {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0c0d08090809, 0x0405040500010001, 0x0c0d0c0d08090809, 0x0405040500010001}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0e0c08090a08, 0x0405060400010200, 0x0c0d0e0c08090a08, 0x0405060400010200}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0f0d0d0f0b09090b, 0x0705050703010103, 0x0f0d0d0f0b09090b, 0x0705050703010103}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
, {0x0c0d0d0c08090908, 0x0405050400010100, 0x0c0d0d0c08090908, 0x0405050400010100}
};
|
the_stack_data/1180595.c | /* */
#include <sys/eventfd.h>
int main(void){return 0;}
|
the_stack_data/100140508.c | /*Programmer Chase Singhofen
Date 10/2/2016
Specifications:Shipping Calculations.
*/
//This program will calculate shipping charges based on miles and weight. Packages over 50 pounds will not be shipped.
// Shipping charges will be based on every 500 miles with no pro ration.
#include<stdio.h>
#include<stdlib.h>
main()
{
double packageWeight, packageDistance, packagePrice=0, shippingCost;
int segmentNum;
printf("Enter the weight of the package:\n");
scanf_s("%lf", &packageWeight);
printf("The weight you have entered is %.2lf\n", packageWeight);
// A package that weighs less than 10lbs will cost $2
if (packageWeight <= 10)
packagePrice = 2.00;
// A package that weighs less than or equal to 50lbs but more than 10lbs will cost $4.50
else
{
if (packageWeight <= 50)
packagePrice = 4.50;
// Do not ship packages weighing more than 50lbs
else
printf("The package will not ship. \n");
}
// Shipping cost the same for 200 miles
//This is one 500 mile segment
printf("How far are you sending the package? \n");
scanf_s("%lf", &packageDistance);
printf("The distance you entered is %.2lf\n", packageDistance);
segmentNum = packageDistance / 500;
if ((int)packageDistance % 500 != 0)
segmentNum = segmentNum + 1;
shippingCost = packagePrice*segmentNum;
//The shipping cost
printf("The shipping cost is: %.2lf\n", shippingCost);
system("pause");
} |
the_stack_data/148579257.c | /*
* dealer.c simulate a dealer's actions with given start cards and a given deck
* ./dealer UpCard DownCard Ones Twos ... Tens/Faces [Ones Twos ... Tens/Faces]
*
* Run this program with 12 or 22 paramaters:
* Param 1 and 2 are dealer's initial cards, use zero to have these pull from deck 1
* Params 3..12 are counts of cards in the first deck <#aces, #twos, #threes, ..., #nines, #tens/faces>
* Params 13..22 are counds of cards in the second deck, used when deck 1 is exhausted
*
* This program will iterate through all possible game plays and output probability of each outcome
*
* User is responsible to ensure no underflow of cards!
*
* NOTE: Passing zeros doesn't really make sense because this program does not check for blackjack
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
int rank[11];
int total;
int count;
} Cards;
void dealer_outcomes(Cards dealer, Cards deck1, Cards deck2, double outcomes[27], double probability)
{
int effective, i;
effective = (dealer.rank[1] && dealer.total<=11) ? dealer.total+10 : dealer.total;
if (effective==21 && dealer.count==2) {
outcomes[1] += probability;
return;
} else if (effective>=17) {
outcomes[effective] += probability;
return;
}
if (!deck1.count)
deck1 = deck2;
for (i=1; i<=10; i++) {
if (deck1.rank[i]) {
deck1.rank[i]--, deck1.count--, deck1.total-=i;
dealer.rank[i]++, dealer.count++, dealer.total+=i;
dealer_outcomes(dealer, deck1, deck2, outcomes, probability * (deck1.rank[i]+1) / (deck1.count+1));
dealer.rank[i]--, dealer.count--, dealer.total-=i;
deck1.rank[i]++, deck1.count++, deck1.total+=i;
}
}
}
int main(int argc, char *argv[])
{
Cards dealer={{0},0,0}, deck1={{0},0,0}, deck2={{0},0,0};
int i;
double outcomes[27]={0};
if (argc != 13 && argc != 23) {
printf("usage: %s UpCard DownCard Ones Twos ... Tens/Faces [Ones Twos ... Tens/Faces]\n", argv[0]);
exit(1);
}
dealer.rank[atoi(argv[1])]++;
dealer.rank[atoi(argv[2])]++;
dealer.total = atoi(argv[1]) + atoi(argv[2]);
dealer.count = !!atoi(argv[1]) + !!atoi(argv[2]);
for (i=1; i<=10; i++) {
deck1.rank[i] = atoi(argv[i+2]);
deck1.total += i * atoi(argv[i+2]);
deck1.count += atoi(argv[i+2]);
if (argc == 22) {
deck2.rank[i] = atoi(argv[i+12]);
deck2.total += i * atoi(argv[i+12]);
deck2.count += atoi(argv[i+12]);
}
}
dealer_outcomes(dealer, deck1, deck2, outcomes, 1.0);
printf("Outcome\tProbability\n");
printf("-------\t-----------\n");
for (i=17; i<=21; i++)
printf("%d\t%.16f\n", i, outcomes[i]);
printf("BJ\t%.16f\n", outcomes[1]);
printf("Bust\t%.16f\n", outcomes[22]+outcomes[23]+outcomes[24]+outcomes[25]+outcomes[26]);
return 0;
}
|
the_stack_data/127680.c | #include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#define MAX_MEM_TO_FLUSH 1<<24
void flushall(int yes)
{
static char *buffer = NULL;
static char val = 1;
if (yes)
{
if (buffer == NULL)
{
buffer = (char *)malloc(MAX_MEM_TO_FLUSH*sizeof(char));
if (buffer == NULL)
{
fprintf(stderr,"flushall.c: malloc of %d bytes failed.\n",MAX_MEM_TO_FLUSH);
exit(1);
}
}
memset(buffer,val++,MAX_MEM_TO_FLUSH);
}
else
{
if (buffer)
{
free(buffer);
buffer = NULL;
}
}
}
|
the_stack_data/190769154.c | #include <stdint.h>
#include <memory.h>
// LITTLE-ENDIAN memory access is REQUIRED
// the following two functions are required to work around -fstrict-aliasing
static inline uintptr_t _br2_load(uintptr_t a, size_t sz) {
uintptr_t r = 0;
memcpy(&r, (void*)a, sz);
return r;
}
static inline void _br2_store(uintptr_t a, uintptr_t v, size_t sz) {
memcpy((void*)a, &v, sz);
}
void bls12_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) {
uintptr_t x6, x0, x13, x1, x7, x15, x2, x8, x17, x3, x9, x19, x4, x10, x21, x5, x11, x25, x27, x29, x31, x23, x33, x12, x36, x24, x37, x14, x39, x26, x40, x16, x42, x28, x43, x18, x45, x30, x46, x20, x48, x32, x49, x35, x22, x51, x34, x52, x38, x41, x44, x47, x50, x53, x54, x55, x56, x57, x58, x59;
x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
/*skip*/
x12 = (x0)+(x6);
x13 = ((x12)<(x0))+(x1);
x14 = (x13)+(x7);
x15 = (((x13)<(x1))+((x14)<(x7)))+(x2);
x16 = (x15)+(x8);
x17 = (((x15)<(x2))+((x16)<(x8)))+(x3);
x18 = (x17)+(x9);
x19 = (((x17)<(x3))+((x18)<(x9)))+(x4);
x20 = (x19)+(x10);
x21 = (((x19)<(x4))+((x20)<(x10)))+(x5);
x22 = (x21)+(x11);
x23 = ((x21)<(x5))+((x22)<(x11));
x24 = (x12)-((uintptr_t)13402431016077863595ULL);
x25 = (x14)-((uintptr_t)2210141511517208575ULL);
x26 = (x25)-((x12)<(x24));
x27 = (x16)-((uintptr_t)7435674573564081700ULL);
x28 = (x27)-(((x14)<(x25))+((x25)<(x26)));
x29 = (x18)-((uintptr_t)7239337960414712511ULL);
x30 = (x29)-(((x16)<(x27))+((x27)<(x28)));
x31 = (x20)-((uintptr_t)5412103778470702295ULL);
x32 = (x31)-(((x18)<(x29))+((x29)<(x30)));
x33 = (x22)-((uintptr_t)1873798617647539866ULL);
x34 = (x33)-(((x20)<(x31))+((x31)<(x32)));
x35 = (x23)<((x23)-(((x22)<(x33))+((x33)<(x34))));
x36 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x37 = (x36)^((uintptr_t)18446744073709551615ULL);
x38 = ((x12)&(x36))|((x24)&(x37));
x39 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x40 = (x39)^((uintptr_t)18446744073709551615ULL);
x41 = ((x14)&(x39))|((x26)&(x40));
x42 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x43 = (x42)^((uintptr_t)18446744073709551615ULL);
x44 = ((x16)&(x42))|((x28)&(x43));
x45 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x46 = (x45)^((uintptr_t)18446744073709551615ULL);
x47 = ((x18)&(x45))|((x30)&(x46));
x48 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x49 = (x48)^((uintptr_t)18446744073709551615ULL);
x50 = ((x20)&(x48))|((x32)&(x49));
x51 = ((uintptr_t)-1ULL)+((x35)==((uintptr_t)0ULL));
x52 = (x51)^((uintptr_t)18446744073709551615ULL);
x53 = ((x22)&(x51))|((x34)&(x52));
x54 = x38;
x55 = x41;
x56 = x44;
x57 = x47;
x58 = x50;
x59 = x53;
/*skip*/
_br2_store((out0)+((uintptr_t)0ULL), x54, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)8ULL), x55, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)16ULL), x56, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)24ULL), x57, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)32ULL), x58, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)40ULL), x59, sizeof(uintptr_t));
/*skip*/
return;
}
void bls12_mul(uintptr_t out0, uintptr_t in0, uintptr_t in1) {
uintptr_t x1, x2, x3, x4, x5, x0, x17, x26, x29, x31, x27, x32, x24, x33, x35, x36, x25, x37, x22, x38, x40, x41, x23, x42, x20, x43, x45, x46, x21, x47, x18, x48, x50, x51, x19, x53, x62, x65, x67, x63, x68, x60, x69, x71, x72, x61, x73, x58, x74, x76, x77, x59, x78, x56, x79, x81, x82, x57, x83, x54, x84, x86, x87, x55, x64, x89, x28, x90, x30, x91, x66, x92, x94, x95, x34, x96, x70, x97, x99, x100, x39, x101, x75, x102, x104, x105, x44, x106, x80, x107, x109, x110, x49, x111, x85, x112, x114, x115, x52, x116, x88, x117, x119, x12, x129, x132, x134, x130, x135, x127, x136, x138, x139, x128, x140, x125, x141, x143, x144, x126, x145, x123, x146, x148, x149, x124, x150, x121, x151, x153, x154, x122, x131, x93, x157, x98, x158, x133, x159, x161, x162, x103, x163, x137, x164, x166, x167, x108, x168, x142, x169, x171, x172, x113, x173, x147, x174, x176, x177, x118, x178, x152, x179, x181, x182, x120, x183, x155, x184, x186, x188, x197, x200, x202, x198, x203, x195, x204, x206, x207, x196, x208, x193, x209, x211, x212, x194, x213, x191, x214, x216, x217, x192, x218, x189, x219, x221, x222, x190, x199, x224, x156, x225, x160, x226, x201, x227, x229, x230, x165, x231, x205, x232, x234, x235, x170, x236, x210, x237, x239, x240, x175, x241, x215, x242, x244, x245, x180, x246, x220, x247, x249, x250, x185, x251, x223, x252, x254, x255, x187, x13, x265, x268, x270, x266, x271, x263, x272, x274, x275, x264, x276, x261, x277, x279, x280, x262, x281, x259, x282, x284, x285, x260, x286, x257, x287, x289, x290, x258, x267, x228, x293, x233, x294, x269, x295, x297, x298, x238, x299, x273, x300, x302, x303, x243, x304, x278, x305, x307, x308, x248, x309, x283, x310, x312, x313, x253, x314, x288, x315, x317, x318, x256, x319, x291, x320, x322, x324, x333, x336, x338, x334, x339, x331, x340, x342, x343, x332, x344, x329, x345, x347, x348, x330, x349, x327, x350, x352, x353, x328, x354, x325, x355, x357, x358, x326, x335, x360, x292, x361, x296, x362, x337, x363, x365, x366, x301, x367, x341, x368, x370, x371, x306, x372, x346, x373, x375, x376, x311, x377, x351, x378, x380, x381, x316, x382, x356, x383, x385, x386, x321, x387, x359, x388, x390, x391, x323, x14, x401, x404, x406, x402, x407, x399, x408, x410, x411, x400, x412, x397, x413, x415, x416, x398, x417, x395, x418, x420, x421, x396, x422, x393, x423, x425, x426, x394, x403, x364, x429, x369, x430, x405, x431, x433, x434, x374, x435, x409, x436, x438, x439, x379, x440, x414, x441, x443, x444, x384, x445, x419, x446, x448, x449, x389, x450, x424, x451, x453, x454, x392, x455, x427, x456, x458, x460, x469, x472, x474, x470, x475, x467, x476, x478, x479, x468, x480, x465, x481, x483, x484, x466, x485, x463, x486, x488, x489, x464, x490, x461, x491, x493, x494, x462, x471, x496, x428, x497, x432, x498, x473, x499, x501, x502, x437, x503, x477, x504, x506, x507, x442, x508, x482, x509, x511, x512, x447, x513, x487, x514, x516, x517, x452, x518, x492, x519, x521, x522, x457, x523, x495, x524, x526, x527, x459, x15, x537, x540, x542, x538, x543, x535, x544, x546, x547, x536, x548, x533, x549, x551, x552, x534, x553, x531, x554, x556, x557, x532, x558, x529, x559, x561, x562, x530, x539, x500, x565, x505, x566, x541, x567, x569, x570, x510, x571, x545, x572, x574, x575, x515, x576, x550, x577, x579, x580, x520, x581, x555, x582, x584, x585, x525, x586, x560, x587, x589, x590, x528, x591, x563, x592, x594, x596, x605, x608, x610, x606, x611, x603, x612, x614, x615, x604, x616, x601, x617, x619, x620, x602, x621, x599, x622, x624, x625, x600, x626, x597, x627, x629, x630, x598, x607, x632, x564, x633, x568, x634, x609, x635, x637, x638, x573, x639, x613, x640, x642, x643, x578, x644, x618, x645, x647, x648, x583, x649, x623, x650, x652, x653, x588, x654, x628, x655, x657, x658, x593, x659, x631, x660, x662, x663, x595, x11, x10, x9, x8, x7, x16, x6, x673, x676, x678, x674, x679, x671, x680, x682, x683, x672, x684, x669, x685, x687, x688, x670, x689, x667, x690, x692, x693, x668, x694, x665, x695, x697, x698, x666, x675, x636, x701, x641, x702, x677, x703, x705, x706, x646, x707, x681, x708, x710, x711, x651, x712, x686, x713, x715, x716, x656, x717, x691, x718, x720, x721, x661, x722, x696, x723, x725, x726, x664, x727, x699, x728, x730, x732, x741, x744, x746, x742, x747, x739, x748, x750, x751, x740, x752, x737, x753, x755, x756, x738, x757, x735, x758, x760, x761, x736, x762, x733, x763, x765, x766, x734, x743, x768, x700, x769, x704, x770, x745, x771, x773, x774, x709, x775, x749, x776, x778, x779, x714, x780, x754, x781, x783, x784, x719, x785, x759, x786, x788, x789, x724, x790, x764, x791, x793, x794, x729, x795, x767, x796, x798, x799, x731, x802, x803, x804, x806, x807, x808, x809, x811, x812, x813, x814, x816, x817, x818, x819, x821, x822, x823, x824, x826, x827, x800, x828, x772, x830, x801, x831, x777, x833, x805, x834, x782, x836, x810, x837, x787, x839, x815, x840, x792, x842, x820, x843, x829, x797, x845, x825, x846, x832, x835, x838, x841, x844, x847, x848, x849, x850, x851, x852, x853;
x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
/*skip*/
x12 = x1;
x13 = x2;
x14 = x3;
x15 = x4;
x16 = x5;
x17 = x0;
x18 = (x17)*(x11);
x19 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64;
x20 = (x17)*(x10);
x21 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64;
x22 = (x17)*(x9);
x23 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64;
x24 = (x17)*(x8);
x25 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64;
x26 = (x17)*(x7);
x27 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x7))>>32 : ((__uint128_t)(x17)*(x7))>>64;
x28 = (x17)*(x6);
x29 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x6))>>32 : ((__uint128_t)(x17)*(x6))>>64;
x30 = (x29)+(x26);
x31 = (x30)<(x29);
x32 = (x31)+(x27);
x33 = (x32)<(x27);
x34 = (x32)+(x24);
x35 = (x34)<(x24);
x36 = (x33)+(x35);
x37 = (x36)+(x25);
x38 = (x37)<(x25);
x39 = (x37)+(x22);
x40 = (x39)<(x22);
x41 = (x38)+(x40);
x42 = (x41)+(x23);
x43 = (x42)<(x23);
x44 = (x42)+(x20);
x45 = (x44)<(x20);
x46 = (x43)+(x45);
x47 = (x46)+(x21);
x48 = (x47)<(x21);
x49 = (x47)+(x18);
x50 = (x49)<(x18);
x51 = (x48)+(x50);
x52 = (x51)+(x19);
x53 = (x28)*((uintptr_t)9940570264628428797ULL);
x54 = (x53)*((uintptr_t)1873798617647539866ULL);
x55 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)1873798617647539866ULL))>>64;
x56 = (x53)*((uintptr_t)5412103778470702295ULL);
x57 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)5412103778470702295ULL))>>64;
x58 = (x53)*((uintptr_t)7239337960414712511ULL);
x59 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)7239337960414712511ULL))>>64;
x60 = (x53)*((uintptr_t)7435674573564081700ULL);
x61 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)7435674573564081700ULL))>>64;
x62 = (x53)*((uintptr_t)2210141511517208575ULL);
x63 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)2210141511517208575ULL))>>64;
x64 = (x53)*((uintptr_t)13402431016077863595ULL);
x65 = sizeof(intptr_t) == 4 ? ((uint64_t)(x53)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x53)*((uintptr_t)13402431016077863595ULL))>>64;
x66 = (x65)+(x62);
x67 = (x66)<(x65);
x68 = (x67)+(x63);
x69 = (x68)<(x63);
x70 = (x68)+(x60);
x71 = (x70)<(x60);
x72 = (x69)+(x71);
x73 = (x72)+(x61);
x74 = (x73)<(x61);
x75 = (x73)+(x58);
x76 = (x75)<(x58);
x77 = (x74)+(x76);
x78 = (x77)+(x59);
x79 = (x78)<(x59);
x80 = (x78)+(x56);
x81 = (x80)<(x56);
x82 = (x79)+(x81);
x83 = (x82)+(x57);
x84 = (x83)<(x57);
x85 = (x83)+(x54);
x86 = (x85)<(x54);
x87 = (x84)+(x86);
x88 = (x87)+(x55);
x89 = (x28)+(x64);
x90 = (x89)<(x28);
x91 = (x90)+(x30);
x92 = (x91)<(x30);
x93 = (x91)+(x66);
x94 = (x93)<(x66);
x95 = (x92)+(x94);
x96 = (x95)+(x34);
x97 = (x96)<(x34);
x98 = (x96)+(x70);
x99 = (x98)<(x70);
x100 = (x97)+(x99);
x101 = (x100)+(x39);
x102 = (x101)<(x39);
x103 = (x101)+(x75);
x104 = (x103)<(x75);
x105 = (x102)+(x104);
x106 = (x105)+(x44);
x107 = (x106)<(x44);
x108 = (x106)+(x80);
x109 = (x108)<(x80);
x110 = (x107)+(x109);
x111 = (x110)+(x49);
x112 = (x111)<(x49);
x113 = (x111)+(x85);
x114 = (x113)<(x85);
x115 = (x112)+(x114);
x116 = (x115)+(x52);
x117 = (x116)<(x52);
x118 = (x116)+(x88);
x119 = (x118)<(x88);
x120 = (x117)+(x119);
x121 = (x12)*(x11);
x122 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x11))>>32 : ((__uint128_t)(x12)*(x11))>>64;
x123 = (x12)*(x10);
x124 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x10))>>32 : ((__uint128_t)(x12)*(x10))>>64;
x125 = (x12)*(x9);
x126 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x9))>>32 : ((__uint128_t)(x12)*(x9))>>64;
x127 = (x12)*(x8);
x128 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x8))>>32 : ((__uint128_t)(x12)*(x8))>>64;
x129 = (x12)*(x7);
x130 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64;
x131 = (x12)*(x6);
x132 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64;
x133 = (x132)+(x129);
x134 = (x133)<(x132);
x135 = (x134)+(x130);
x136 = (x135)<(x130);
x137 = (x135)+(x127);
x138 = (x137)<(x127);
x139 = (x136)+(x138);
x140 = (x139)+(x128);
x141 = (x140)<(x128);
x142 = (x140)+(x125);
x143 = (x142)<(x125);
x144 = (x141)+(x143);
x145 = (x144)+(x126);
x146 = (x145)<(x126);
x147 = (x145)+(x123);
x148 = (x147)<(x123);
x149 = (x146)+(x148);
x150 = (x149)+(x124);
x151 = (x150)<(x124);
x152 = (x150)+(x121);
x153 = (x152)<(x121);
x154 = (x151)+(x153);
x155 = (x154)+(x122);
x156 = (x93)+(x131);
x157 = (x156)<(x93);
x158 = (x157)+(x98);
x159 = (x158)<(x98);
x160 = (x158)+(x133);
x161 = (x160)<(x133);
x162 = (x159)+(x161);
x163 = (x162)+(x103);
x164 = (x163)<(x103);
x165 = (x163)+(x137);
x166 = (x165)<(x137);
x167 = (x164)+(x166);
x168 = (x167)+(x108);
x169 = (x168)<(x108);
x170 = (x168)+(x142);
x171 = (x170)<(x142);
x172 = (x169)+(x171);
x173 = (x172)+(x113);
x174 = (x173)<(x113);
x175 = (x173)+(x147);
x176 = (x175)<(x147);
x177 = (x174)+(x176);
x178 = (x177)+(x118);
x179 = (x178)<(x118);
x180 = (x178)+(x152);
x181 = (x180)<(x152);
x182 = (x179)+(x181);
x183 = (x182)+(x120);
x184 = (x183)<(x120);
x185 = (x183)+(x155);
x186 = (x185)<(x155);
x187 = (x184)+(x186);
x188 = (x156)*((uintptr_t)9940570264628428797ULL);
x189 = (x188)*((uintptr_t)1873798617647539866ULL);
x190 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)1873798617647539866ULL))>>64;
x191 = (x188)*((uintptr_t)5412103778470702295ULL);
x192 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)5412103778470702295ULL))>>64;
x193 = (x188)*((uintptr_t)7239337960414712511ULL);
x194 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)7239337960414712511ULL))>>64;
x195 = (x188)*((uintptr_t)7435674573564081700ULL);
x196 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)7435674573564081700ULL))>>64;
x197 = (x188)*((uintptr_t)2210141511517208575ULL);
x198 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)2210141511517208575ULL))>>64;
x199 = (x188)*((uintptr_t)13402431016077863595ULL);
x200 = sizeof(intptr_t) == 4 ? ((uint64_t)(x188)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x188)*((uintptr_t)13402431016077863595ULL))>>64;
x201 = (x200)+(x197);
x202 = (x201)<(x200);
x203 = (x202)+(x198);
x204 = (x203)<(x198);
x205 = (x203)+(x195);
x206 = (x205)<(x195);
x207 = (x204)+(x206);
x208 = (x207)+(x196);
x209 = (x208)<(x196);
x210 = (x208)+(x193);
x211 = (x210)<(x193);
x212 = (x209)+(x211);
x213 = (x212)+(x194);
x214 = (x213)<(x194);
x215 = (x213)+(x191);
x216 = (x215)<(x191);
x217 = (x214)+(x216);
x218 = (x217)+(x192);
x219 = (x218)<(x192);
x220 = (x218)+(x189);
x221 = (x220)<(x189);
x222 = (x219)+(x221);
x223 = (x222)+(x190);
x224 = (x156)+(x199);
x225 = (x224)<(x156);
x226 = (x225)+(x160);
x227 = (x226)<(x160);
x228 = (x226)+(x201);
x229 = (x228)<(x201);
x230 = (x227)+(x229);
x231 = (x230)+(x165);
x232 = (x231)<(x165);
x233 = (x231)+(x205);
x234 = (x233)<(x205);
x235 = (x232)+(x234);
x236 = (x235)+(x170);
x237 = (x236)<(x170);
x238 = (x236)+(x210);
x239 = (x238)<(x210);
x240 = (x237)+(x239);
x241 = (x240)+(x175);
x242 = (x241)<(x175);
x243 = (x241)+(x215);
x244 = (x243)<(x215);
x245 = (x242)+(x244);
x246 = (x245)+(x180);
x247 = (x246)<(x180);
x248 = (x246)+(x220);
x249 = (x248)<(x220);
x250 = (x247)+(x249);
x251 = (x250)+(x185);
x252 = (x251)<(x185);
x253 = (x251)+(x223);
x254 = (x253)<(x223);
x255 = (x252)+(x254);
x256 = (x255)+(x187);
x257 = (x13)*(x11);
x258 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x11))>>32 : ((__uint128_t)(x13)*(x11))>>64;
x259 = (x13)*(x10);
x260 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x10))>>32 : ((__uint128_t)(x13)*(x10))>>64;
x261 = (x13)*(x9);
x262 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x9))>>32 : ((__uint128_t)(x13)*(x9))>>64;
x263 = (x13)*(x8);
x264 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x8))>>32 : ((__uint128_t)(x13)*(x8))>>64;
x265 = (x13)*(x7);
x266 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64;
x267 = (x13)*(x6);
x268 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64;
x269 = (x268)+(x265);
x270 = (x269)<(x268);
x271 = (x270)+(x266);
x272 = (x271)<(x266);
x273 = (x271)+(x263);
x274 = (x273)<(x263);
x275 = (x272)+(x274);
x276 = (x275)+(x264);
x277 = (x276)<(x264);
x278 = (x276)+(x261);
x279 = (x278)<(x261);
x280 = (x277)+(x279);
x281 = (x280)+(x262);
x282 = (x281)<(x262);
x283 = (x281)+(x259);
x284 = (x283)<(x259);
x285 = (x282)+(x284);
x286 = (x285)+(x260);
x287 = (x286)<(x260);
x288 = (x286)+(x257);
x289 = (x288)<(x257);
x290 = (x287)+(x289);
x291 = (x290)+(x258);
x292 = (x228)+(x267);
x293 = (x292)<(x228);
x294 = (x293)+(x233);
x295 = (x294)<(x233);
x296 = (x294)+(x269);
x297 = (x296)<(x269);
x298 = (x295)+(x297);
x299 = (x298)+(x238);
x300 = (x299)<(x238);
x301 = (x299)+(x273);
x302 = (x301)<(x273);
x303 = (x300)+(x302);
x304 = (x303)+(x243);
x305 = (x304)<(x243);
x306 = (x304)+(x278);
x307 = (x306)<(x278);
x308 = (x305)+(x307);
x309 = (x308)+(x248);
x310 = (x309)<(x248);
x311 = (x309)+(x283);
x312 = (x311)<(x283);
x313 = (x310)+(x312);
x314 = (x313)+(x253);
x315 = (x314)<(x253);
x316 = (x314)+(x288);
x317 = (x316)<(x288);
x318 = (x315)+(x317);
x319 = (x318)+(x256);
x320 = (x319)<(x256);
x321 = (x319)+(x291);
x322 = (x321)<(x291);
x323 = (x320)+(x322);
x324 = (x292)*((uintptr_t)9940570264628428797ULL);
x325 = (x324)*((uintptr_t)1873798617647539866ULL);
x326 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)1873798617647539866ULL))>>64;
x327 = (x324)*((uintptr_t)5412103778470702295ULL);
x328 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)5412103778470702295ULL))>>64;
x329 = (x324)*((uintptr_t)7239337960414712511ULL);
x330 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)7239337960414712511ULL))>>64;
x331 = (x324)*((uintptr_t)7435674573564081700ULL);
x332 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)7435674573564081700ULL))>>64;
x333 = (x324)*((uintptr_t)2210141511517208575ULL);
x334 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)2210141511517208575ULL))>>64;
x335 = (x324)*((uintptr_t)13402431016077863595ULL);
x336 = sizeof(intptr_t) == 4 ? ((uint64_t)(x324)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x324)*((uintptr_t)13402431016077863595ULL))>>64;
x337 = (x336)+(x333);
x338 = (x337)<(x336);
x339 = (x338)+(x334);
x340 = (x339)<(x334);
x341 = (x339)+(x331);
x342 = (x341)<(x331);
x343 = (x340)+(x342);
x344 = (x343)+(x332);
x345 = (x344)<(x332);
x346 = (x344)+(x329);
x347 = (x346)<(x329);
x348 = (x345)+(x347);
x349 = (x348)+(x330);
x350 = (x349)<(x330);
x351 = (x349)+(x327);
x352 = (x351)<(x327);
x353 = (x350)+(x352);
x354 = (x353)+(x328);
x355 = (x354)<(x328);
x356 = (x354)+(x325);
x357 = (x356)<(x325);
x358 = (x355)+(x357);
x359 = (x358)+(x326);
x360 = (x292)+(x335);
x361 = (x360)<(x292);
x362 = (x361)+(x296);
x363 = (x362)<(x296);
x364 = (x362)+(x337);
x365 = (x364)<(x337);
x366 = (x363)+(x365);
x367 = (x366)+(x301);
x368 = (x367)<(x301);
x369 = (x367)+(x341);
x370 = (x369)<(x341);
x371 = (x368)+(x370);
x372 = (x371)+(x306);
x373 = (x372)<(x306);
x374 = (x372)+(x346);
x375 = (x374)<(x346);
x376 = (x373)+(x375);
x377 = (x376)+(x311);
x378 = (x377)<(x311);
x379 = (x377)+(x351);
x380 = (x379)<(x351);
x381 = (x378)+(x380);
x382 = (x381)+(x316);
x383 = (x382)<(x316);
x384 = (x382)+(x356);
x385 = (x384)<(x356);
x386 = (x383)+(x385);
x387 = (x386)+(x321);
x388 = (x387)<(x321);
x389 = (x387)+(x359);
x390 = (x389)<(x359);
x391 = (x388)+(x390);
x392 = (x391)+(x323);
x393 = (x14)*(x11);
x394 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x11))>>32 : ((__uint128_t)(x14)*(x11))>>64;
x395 = (x14)*(x10);
x396 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x10))>>32 : ((__uint128_t)(x14)*(x10))>>64;
x397 = (x14)*(x9);
x398 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x9))>>32 : ((__uint128_t)(x14)*(x9))>>64;
x399 = (x14)*(x8);
x400 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x8))>>32 : ((__uint128_t)(x14)*(x8))>>64;
x401 = (x14)*(x7);
x402 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64;
x403 = (x14)*(x6);
x404 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64;
x405 = (x404)+(x401);
x406 = (x405)<(x404);
x407 = (x406)+(x402);
x408 = (x407)<(x402);
x409 = (x407)+(x399);
x410 = (x409)<(x399);
x411 = (x408)+(x410);
x412 = (x411)+(x400);
x413 = (x412)<(x400);
x414 = (x412)+(x397);
x415 = (x414)<(x397);
x416 = (x413)+(x415);
x417 = (x416)+(x398);
x418 = (x417)<(x398);
x419 = (x417)+(x395);
x420 = (x419)<(x395);
x421 = (x418)+(x420);
x422 = (x421)+(x396);
x423 = (x422)<(x396);
x424 = (x422)+(x393);
x425 = (x424)<(x393);
x426 = (x423)+(x425);
x427 = (x426)+(x394);
x428 = (x364)+(x403);
x429 = (x428)<(x364);
x430 = (x429)+(x369);
x431 = (x430)<(x369);
x432 = (x430)+(x405);
x433 = (x432)<(x405);
x434 = (x431)+(x433);
x435 = (x434)+(x374);
x436 = (x435)<(x374);
x437 = (x435)+(x409);
x438 = (x437)<(x409);
x439 = (x436)+(x438);
x440 = (x439)+(x379);
x441 = (x440)<(x379);
x442 = (x440)+(x414);
x443 = (x442)<(x414);
x444 = (x441)+(x443);
x445 = (x444)+(x384);
x446 = (x445)<(x384);
x447 = (x445)+(x419);
x448 = (x447)<(x419);
x449 = (x446)+(x448);
x450 = (x449)+(x389);
x451 = (x450)<(x389);
x452 = (x450)+(x424);
x453 = (x452)<(x424);
x454 = (x451)+(x453);
x455 = (x454)+(x392);
x456 = (x455)<(x392);
x457 = (x455)+(x427);
x458 = (x457)<(x427);
x459 = (x456)+(x458);
x460 = (x428)*((uintptr_t)9940570264628428797ULL);
x461 = (x460)*((uintptr_t)1873798617647539866ULL);
x462 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)1873798617647539866ULL))>>64;
x463 = (x460)*((uintptr_t)5412103778470702295ULL);
x464 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)5412103778470702295ULL))>>64;
x465 = (x460)*((uintptr_t)7239337960414712511ULL);
x466 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)7239337960414712511ULL))>>64;
x467 = (x460)*((uintptr_t)7435674573564081700ULL);
x468 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)7435674573564081700ULL))>>64;
x469 = (x460)*((uintptr_t)2210141511517208575ULL);
x470 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)2210141511517208575ULL))>>64;
x471 = (x460)*((uintptr_t)13402431016077863595ULL);
x472 = sizeof(intptr_t) == 4 ? ((uint64_t)(x460)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x460)*((uintptr_t)13402431016077863595ULL))>>64;
x473 = (x472)+(x469);
x474 = (x473)<(x472);
x475 = (x474)+(x470);
x476 = (x475)<(x470);
x477 = (x475)+(x467);
x478 = (x477)<(x467);
x479 = (x476)+(x478);
x480 = (x479)+(x468);
x481 = (x480)<(x468);
x482 = (x480)+(x465);
x483 = (x482)<(x465);
x484 = (x481)+(x483);
x485 = (x484)+(x466);
x486 = (x485)<(x466);
x487 = (x485)+(x463);
x488 = (x487)<(x463);
x489 = (x486)+(x488);
x490 = (x489)+(x464);
x491 = (x490)<(x464);
x492 = (x490)+(x461);
x493 = (x492)<(x461);
x494 = (x491)+(x493);
x495 = (x494)+(x462);
x496 = (x428)+(x471);
x497 = (x496)<(x428);
x498 = (x497)+(x432);
x499 = (x498)<(x432);
x500 = (x498)+(x473);
x501 = (x500)<(x473);
x502 = (x499)+(x501);
x503 = (x502)+(x437);
x504 = (x503)<(x437);
x505 = (x503)+(x477);
x506 = (x505)<(x477);
x507 = (x504)+(x506);
x508 = (x507)+(x442);
x509 = (x508)<(x442);
x510 = (x508)+(x482);
x511 = (x510)<(x482);
x512 = (x509)+(x511);
x513 = (x512)+(x447);
x514 = (x513)<(x447);
x515 = (x513)+(x487);
x516 = (x515)<(x487);
x517 = (x514)+(x516);
x518 = (x517)+(x452);
x519 = (x518)<(x452);
x520 = (x518)+(x492);
x521 = (x520)<(x492);
x522 = (x519)+(x521);
x523 = (x522)+(x457);
x524 = (x523)<(x457);
x525 = (x523)+(x495);
x526 = (x525)<(x495);
x527 = (x524)+(x526);
x528 = (x527)+(x459);
x529 = (x15)*(x11);
x530 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x11))>>32 : ((__uint128_t)(x15)*(x11))>>64;
x531 = (x15)*(x10);
x532 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x10))>>32 : ((__uint128_t)(x15)*(x10))>>64;
x533 = (x15)*(x9);
x534 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x9))>>32 : ((__uint128_t)(x15)*(x9))>>64;
x535 = (x15)*(x8);
x536 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x8))>>32 : ((__uint128_t)(x15)*(x8))>>64;
x537 = (x15)*(x7);
x538 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64;
x539 = (x15)*(x6);
x540 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64;
x541 = (x540)+(x537);
x542 = (x541)<(x540);
x543 = (x542)+(x538);
x544 = (x543)<(x538);
x545 = (x543)+(x535);
x546 = (x545)<(x535);
x547 = (x544)+(x546);
x548 = (x547)+(x536);
x549 = (x548)<(x536);
x550 = (x548)+(x533);
x551 = (x550)<(x533);
x552 = (x549)+(x551);
x553 = (x552)+(x534);
x554 = (x553)<(x534);
x555 = (x553)+(x531);
x556 = (x555)<(x531);
x557 = (x554)+(x556);
x558 = (x557)+(x532);
x559 = (x558)<(x532);
x560 = (x558)+(x529);
x561 = (x560)<(x529);
x562 = (x559)+(x561);
x563 = (x562)+(x530);
x564 = (x500)+(x539);
x565 = (x564)<(x500);
x566 = (x565)+(x505);
x567 = (x566)<(x505);
x568 = (x566)+(x541);
x569 = (x568)<(x541);
x570 = (x567)+(x569);
x571 = (x570)+(x510);
x572 = (x571)<(x510);
x573 = (x571)+(x545);
x574 = (x573)<(x545);
x575 = (x572)+(x574);
x576 = (x575)+(x515);
x577 = (x576)<(x515);
x578 = (x576)+(x550);
x579 = (x578)<(x550);
x580 = (x577)+(x579);
x581 = (x580)+(x520);
x582 = (x581)<(x520);
x583 = (x581)+(x555);
x584 = (x583)<(x555);
x585 = (x582)+(x584);
x586 = (x585)+(x525);
x587 = (x586)<(x525);
x588 = (x586)+(x560);
x589 = (x588)<(x560);
x590 = (x587)+(x589);
x591 = (x590)+(x528);
x592 = (x591)<(x528);
x593 = (x591)+(x563);
x594 = (x593)<(x563);
x595 = (x592)+(x594);
x596 = (x564)*((uintptr_t)9940570264628428797ULL);
x597 = (x596)*((uintptr_t)1873798617647539866ULL);
x598 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)1873798617647539866ULL))>>64;
x599 = (x596)*((uintptr_t)5412103778470702295ULL);
x600 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)5412103778470702295ULL))>>64;
x601 = (x596)*((uintptr_t)7239337960414712511ULL);
x602 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)7239337960414712511ULL))>>64;
x603 = (x596)*((uintptr_t)7435674573564081700ULL);
x604 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)7435674573564081700ULL))>>64;
x605 = (x596)*((uintptr_t)2210141511517208575ULL);
x606 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)2210141511517208575ULL))>>64;
x607 = (x596)*((uintptr_t)13402431016077863595ULL);
x608 = sizeof(intptr_t) == 4 ? ((uint64_t)(x596)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x596)*((uintptr_t)13402431016077863595ULL))>>64;
x609 = (x608)+(x605);
x610 = (x609)<(x608);
x611 = (x610)+(x606);
x612 = (x611)<(x606);
x613 = (x611)+(x603);
x614 = (x613)<(x603);
x615 = (x612)+(x614);
x616 = (x615)+(x604);
x617 = (x616)<(x604);
x618 = (x616)+(x601);
x619 = (x618)<(x601);
x620 = (x617)+(x619);
x621 = (x620)+(x602);
x622 = (x621)<(x602);
x623 = (x621)+(x599);
x624 = (x623)<(x599);
x625 = (x622)+(x624);
x626 = (x625)+(x600);
x627 = (x626)<(x600);
x628 = (x626)+(x597);
x629 = (x628)<(x597);
x630 = (x627)+(x629);
x631 = (x630)+(x598);
x632 = (x564)+(x607);
x633 = (x632)<(x564);
x634 = (x633)+(x568);
x635 = (x634)<(x568);
x636 = (x634)+(x609);
x637 = (x636)<(x609);
x638 = (x635)+(x637);
x639 = (x638)+(x573);
x640 = (x639)<(x573);
x641 = (x639)+(x613);
x642 = (x641)<(x613);
x643 = (x640)+(x642);
x644 = (x643)+(x578);
x645 = (x644)<(x578);
x646 = (x644)+(x618);
x647 = (x646)<(x618);
x648 = (x645)+(x647);
x649 = (x648)+(x583);
x650 = (x649)<(x583);
x651 = (x649)+(x623);
x652 = (x651)<(x623);
x653 = (x650)+(x652);
x654 = (x653)+(x588);
x655 = (x654)<(x588);
x656 = (x654)+(x628);
x657 = (x656)<(x628);
x658 = (x655)+(x657);
x659 = (x658)+(x593);
x660 = (x659)<(x593);
x661 = (x659)+(x631);
x662 = (x661)<(x631);
x663 = (x660)+(x662);
x664 = (x663)+(x595);
x665 = (x16)*(x11);
x666 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64;
x667 = (x16)*(x10);
x668 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64;
x669 = (x16)*(x9);
x670 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64;
x671 = (x16)*(x8);
x672 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64;
x673 = (x16)*(x7);
x674 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x7))>>32 : ((__uint128_t)(x16)*(x7))>>64;
x675 = (x16)*(x6);
x676 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x6))>>32 : ((__uint128_t)(x16)*(x6))>>64;
x677 = (x676)+(x673);
x678 = (x677)<(x676);
x679 = (x678)+(x674);
x680 = (x679)<(x674);
x681 = (x679)+(x671);
x682 = (x681)<(x671);
x683 = (x680)+(x682);
x684 = (x683)+(x672);
x685 = (x684)<(x672);
x686 = (x684)+(x669);
x687 = (x686)<(x669);
x688 = (x685)+(x687);
x689 = (x688)+(x670);
x690 = (x689)<(x670);
x691 = (x689)+(x667);
x692 = (x691)<(x667);
x693 = (x690)+(x692);
x694 = (x693)+(x668);
x695 = (x694)<(x668);
x696 = (x694)+(x665);
x697 = (x696)<(x665);
x698 = (x695)+(x697);
x699 = (x698)+(x666);
x700 = (x636)+(x675);
x701 = (x700)<(x636);
x702 = (x701)+(x641);
x703 = (x702)<(x641);
x704 = (x702)+(x677);
x705 = (x704)<(x677);
x706 = (x703)+(x705);
x707 = (x706)+(x646);
x708 = (x707)<(x646);
x709 = (x707)+(x681);
x710 = (x709)<(x681);
x711 = (x708)+(x710);
x712 = (x711)+(x651);
x713 = (x712)<(x651);
x714 = (x712)+(x686);
x715 = (x714)<(x686);
x716 = (x713)+(x715);
x717 = (x716)+(x656);
x718 = (x717)<(x656);
x719 = (x717)+(x691);
x720 = (x719)<(x691);
x721 = (x718)+(x720);
x722 = (x721)+(x661);
x723 = (x722)<(x661);
x724 = (x722)+(x696);
x725 = (x724)<(x696);
x726 = (x723)+(x725);
x727 = (x726)+(x664);
x728 = (x727)<(x664);
x729 = (x727)+(x699);
x730 = (x729)<(x699);
x731 = (x728)+(x730);
x732 = (x700)*((uintptr_t)9940570264628428797ULL);
x733 = (x732)*((uintptr_t)1873798617647539866ULL);
x734 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)1873798617647539866ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)1873798617647539866ULL))>>64;
x735 = (x732)*((uintptr_t)5412103778470702295ULL);
x736 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)5412103778470702295ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)5412103778470702295ULL))>>64;
x737 = (x732)*((uintptr_t)7239337960414712511ULL);
x738 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)7239337960414712511ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)7239337960414712511ULL))>>64;
x739 = (x732)*((uintptr_t)7435674573564081700ULL);
x740 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)7435674573564081700ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)7435674573564081700ULL))>>64;
x741 = (x732)*((uintptr_t)2210141511517208575ULL);
x742 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)2210141511517208575ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)2210141511517208575ULL))>>64;
x743 = (x732)*((uintptr_t)13402431016077863595ULL);
x744 = sizeof(intptr_t) == 4 ? ((uint64_t)(x732)*((uintptr_t)13402431016077863595ULL))>>32 : ((__uint128_t)(x732)*((uintptr_t)13402431016077863595ULL))>>64;
x745 = (x744)+(x741);
x746 = (x745)<(x744);
x747 = (x746)+(x742);
x748 = (x747)<(x742);
x749 = (x747)+(x739);
x750 = (x749)<(x739);
x751 = (x748)+(x750);
x752 = (x751)+(x740);
x753 = (x752)<(x740);
x754 = (x752)+(x737);
x755 = (x754)<(x737);
x756 = (x753)+(x755);
x757 = (x756)+(x738);
x758 = (x757)<(x738);
x759 = (x757)+(x735);
x760 = (x759)<(x735);
x761 = (x758)+(x760);
x762 = (x761)+(x736);
x763 = (x762)<(x736);
x764 = (x762)+(x733);
x765 = (x764)<(x733);
x766 = (x763)+(x765);
x767 = (x766)+(x734);
x768 = (x700)+(x743);
x769 = (x768)<(x700);
x770 = (x769)+(x704);
x771 = (x770)<(x704);
x772 = (x770)+(x745);
x773 = (x772)<(x745);
x774 = (x771)+(x773);
x775 = (x774)+(x709);
x776 = (x775)<(x709);
x777 = (x775)+(x749);
x778 = (x777)<(x749);
x779 = (x776)+(x778);
x780 = (x779)+(x714);
x781 = (x780)<(x714);
x782 = (x780)+(x754);
x783 = (x782)<(x754);
x784 = (x781)+(x783);
x785 = (x784)+(x719);
x786 = (x785)<(x719);
x787 = (x785)+(x759);
x788 = (x787)<(x759);
x789 = (x786)+(x788);
x790 = (x789)+(x724);
x791 = (x790)<(x724);
x792 = (x790)+(x764);
x793 = (x792)<(x764);
x794 = (x791)+(x793);
x795 = (x794)+(x729);
x796 = (x795)<(x729);
x797 = (x795)+(x767);
x798 = (x797)<(x767);
x799 = (x796)+(x798);
x800 = (x799)+(x731);
x801 = (x772)-((uintptr_t)13402431016077863595ULL);
x802 = (x772)<(x801);
x803 = (x777)-((uintptr_t)2210141511517208575ULL);
x804 = (x777)<(x803);
x805 = (x803)-(x802);
x806 = (x803)<(x805);
x807 = (x804)+(x806);
x808 = (x782)-((uintptr_t)7435674573564081700ULL);
x809 = (x782)<(x808);
x810 = (x808)-(x807);
x811 = (x808)<(x810);
x812 = (x809)+(x811);
x813 = (x787)-((uintptr_t)7239337960414712511ULL);
x814 = (x787)<(x813);
x815 = (x813)-(x812);
x816 = (x813)<(x815);
x817 = (x814)+(x816);
x818 = (x792)-((uintptr_t)5412103778470702295ULL);
x819 = (x792)<(x818);
x820 = (x818)-(x817);
x821 = (x818)<(x820);
x822 = (x819)+(x821);
x823 = (x797)-((uintptr_t)1873798617647539866ULL);
x824 = (x797)<(x823);
x825 = (x823)-(x822);
x826 = (x823)<(x825);
x827 = (x824)+(x826);
x828 = (x800)-(x827);
x829 = (x800)<(x828);
x830 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x831 = (x830)^((uintptr_t)18446744073709551615ULL);
x832 = ((x772)&(x830))|((x801)&(x831));
x833 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x834 = (x833)^((uintptr_t)18446744073709551615ULL);
x835 = ((x777)&(x833))|((x805)&(x834));
x836 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x837 = (x836)^((uintptr_t)18446744073709551615ULL);
x838 = ((x782)&(x836))|((x810)&(x837));
x839 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x840 = (x839)^((uintptr_t)18446744073709551615ULL);
x841 = ((x787)&(x839))|((x815)&(x840));
x842 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x843 = (x842)^((uintptr_t)18446744073709551615ULL);
x844 = ((x792)&(x842))|((x820)&(x843));
x845 = ((uintptr_t)-1ULL)+((x829)==((uintptr_t)0ULL));
x846 = (x845)^((uintptr_t)18446744073709551615ULL);
x847 = ((x797)&(x845))|((x825)&(x846));
x848 = x832;
x849 = x835;
x850 = x838;
x851 = x841;
x852 = x844;
x853 = x847;
/*skip*/
_br2_store((out0)+((uintptr_t)0ULL), x848, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)8ULL), x849, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)16ULL), x850, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)24ULL), x851, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)32ULL), x852, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)40ULL), x853, sizeof(uintptr_t));
/*skip*/
return;
}
void bls12_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) {
uintptr_t x6, x7, x0, x8, x1, x13, x9, x2, x15, x10, x3, x17, x11, x4, x19, x5, x21, x12, x25, x14, x27, x16, x29, x18, x31, x20, x22, x23, x24, x26, x28, x30, x32, x33, x34, x35, x36, x37, x38, x39;
x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
/*skip*/
/*skip*/
x12 = (x0)-(x6);
x13 = (x1)-(x7);
x14 = (x13)-((x0)<(x12));
x15 = (x2)-(x8);
x16 = (x15)-(((x1)<(x13))+((x13)<(x14)));
x17 = (x3)-(x9);
x18 = (x17)-(((x2)<(x15))+((x15)<(x16)));
x19 = (x4)-(x10);
x20 = (x19)-(((x3)<(x17))+((x17)<(x18)));
x21 = (x5)-(x11);
x22 = (x21)-(((x4)<(x19))+((x19)<(x20)));
x23 = ((uintptr_t)-1ULL)+((((x5)<(x21))+((x21)<(x22)))==((uintptr_t)0ULL));
x24 = (x12)+((x23)&((uintptr_t)13402431016077863595ULL));
x25 = ((x24)<(x12))+(x14);
x26 = (x25)+((x23)&((uintptr_t)2210141511517208575ULL));
x27 = (((x25)<(x14))+((x26)<((x23)&((uintptr_t)2210141511517208575ULL))))+(x16);
x28 = (x27)+((x23)&((uintptr_t)7435674573564081700ULL));
x29 = (((x27)<(x16))+((x28)<((x23)&((uintptr_t)7435674573564081700ULL))))+(x18);
x30 = (x29)+((x23)&((uintptr_t)7239337960414712511ULL));
x31 = (((x29)<(x18))+((x30)<((x23)&((uintptr_t)7239337960414712511ULL))))+(x20);
x32 = (x31)+((x23)&((uintptr_t)5412103778470702295ULL));
x33 = ((((x31)<(x20))+((x32)<((x23)&((uintptr_t)5412103778470702295ULL))))+(x22))+((x23)&((uintptr_t)1873798617647539866ULL));
x34 = x24;
x35 = x26;
x36 = x28;
x37 = x30;
x38 = x32;
x39 = x33;
/*skip*/
_br2_store((out0)+((uintptr_t)0ULL), x34, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)8ULL), x35, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)16ULL), x36, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)24ULL), x37, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)32ULL), x38, sizeof(uintptr_t));
_br2_store((out0)+((uintptr_t)40ULL), x39, sizeof(uintptr_t));
/*skip*/
return;
}
void G1_add(uintptr_t outx, uintptr_t outy, uintptr_t outz, uintptr_t X1, uintptr_t Y1, uintptr_t Z1, uintptr_t X2, uintptr_t Y2, uintptr_t Z2) {
uintptr_t three_b;
uintptr_t t0;
uintptr_t t1;
uintptr_t t2;
uintptr_t t3;
uintptr_t t4;
uintptr_t t5;
three_b = alloca((uintptr_t)48ULL); // TODO untested
t0 = alloca((uintptr_t)48ULL); // TODO untested
t1 = alloca((uintptr_t)48ULL); // TODO untested
t2 = alloca((uintptr_t)48ULL); // TODO untested
t3 = alloca((uintptr_t)48ULL); // TODO untested
t4 = alloca((uintptr_t)48ULL); // TODO untested
t5 = alloca((uintptr_t)48ULL); // TODO untested
_br2_store(three_b, (uintptr_t)4933130441833534766ULL, sizeof(uintptr_t));
_br2_store((three_b)+((uintptr_t)8ULL), (uintptr_t)15904462746612662304ULL, sizeof(uintptr_t));
_br2_store((three_b)+((uintptr_t)16ULL), (uintptr_t)8034115857496836953ULL, sizeof(uintptr_t));
_br2_store((three_b)+((uintptr_t)24ULL), (uintptr_t)12755092135412849606ULL, sizeof(uintptr_t));
_br2_store((three_b)+((uintptr_t)32ULL), (uintptr_t)7007796720291435703ULL, sizeof(uintptr_t));
_br2_store((three_b)+((uintptr_t)40ULL), (uintptr_t)252692002104915169ULL, sizeof(uintptr_t));
bls12_mul(t0, X1, X2);
bls12_mul(t1, Y1, Y2);
bls12_mul(t2, Z1, Z2);
bls12_add(t3, X1, Y1);
bls12_add(t4, X2, Y2);
bls12_mul(t3, t3, t4);
bls12_add(t4, t0, t1);
bls12_sub(t3, t3, t4);
bls12_add(t4, X1, Z1);
bls12_add(t5, X2, Z2);
bls12_mul(t4, t4, t5);
bls12_add(t5, t0, t2);
bls12_sub(t4, t4, t5);
bls12_add(t5, Y1, Z1);
bls12_add(outx, Y2, Z2);
bls12_mul(t5, t5, outx);
bls12_add(outx, t1, t2);
bls12_sub(t5, t5, outx);
bls12_mul(outz, three_b, t2);
bls12_sub(outx, t1, outz);
bls12_add(outz, outz, t1);
bls12_mul(outy, outx, outz);
bls12_add(t1, t0, t0);
bls12_add(t1, t1, t0);
bls12_mul(t4, three_b, t4);
bls12_mul(t0, t1, t4);
bls12_add(outy, outy, t0);
bls12_mul(t0, t5, t4);
bls12_mul(outx, t3, outx);
bls12_sub(outx, outx, t0);
bls12_mul(t0, t3, t1);
bls12_mul(outz, t5, outz);
bls12_add(outz, outz, t0);
return;
}
void felem_copy(uintptr_t out, uintptr_t elem) {
_br2_store(out, _br2_load(elem, sizeof(uintptr_t)), sizeof(uintptr_t));
_br2_store((out)+((uintptr_t)8ULL), _br2_load((elem)+((uintptr_t)8ULL), sizeof(uintptr_t)), sizeof(uintptr_t));
_br2_store((out)+((uintptr_t)16ULL), _br2_load((elem)+((uintptr_t)16ULL), sizeof(uintptr_t)), sizeof(uintptr_t));
_br2_store((out)+((uintptr_t)24ULL), _br2_load((elem)+((uintptr_t)24ULL), sizeof(uintptr_t)), sizeof(uintptr_t));
_br2_store((out)+((uintptr_t)32ULL), _br2_load((elem)+((uintptr_t)32ULL), sizeof(uintptr_t)), sizeof(uintptr_t));
_br2_store((out)+((uintptr_t)40ULL), _br2_load((elem)+((uintptr_t)40ULL), sizeof(uintptr_t)), sizeof(uintptr_t));
return;
}
void G1_add_alt(uintptr_t outx, uintptr_t outy, uintptr_t outz, uintptr_t X1, uintptr_t Y1, uintptr_t Z1, uintptr_t X2, uintptr_t Y2, uintptr_t Z2) {
uintptr_t X1sep;
uintptr_t Y1sep;
uintptr_t Z1sep;
uintptr_t X2sep;
uintptr_t Y2sep;
uintptr_t Z2sep;
X1sep = alloca((uintptr_t)48ULL); // TODO untested
Y1sep = alloca((uintptr_t)48ULL); // TODO untested
Z1sep = alloca((uintptr_t)48ULL); // TODO untested
X2sep = alloca((uintptr_t)48ULL); // TODO untested
Y2sep = alloca((uintptr_t)48ULL); // TODO untested
Z2sep = alloca((uintptr_t)48ULL); // TODO untested
felem_copy(X1sep, X1);
felem_copy(Y1sep, Y1);
felem_copy(Z1sep, Z1);
felem_copy(X2sep, X2);
felem_copy(Y2sep, Y2);
felem_copy(Z2sep, Z2);
G1_add(outx, outy, outz, X1sep, Y1sep, Z1sep, X2sep, Y2sep, Z2sep);
return;
}
void main() {
}
|
the_stack_data/1097724.c | /**
******************************************************************************
* @file stm32l0xx_ll_exti.c
* @author MCD Application Team
* @version V1.8.0
* @date 25-November-2016
* @brief EXTI LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
*
* 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 STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32l0xx_ll_exti.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32L0xx_LL_Driver
* @{
*/
#if defined (EXTI)
/** @defgroup EXTI_LL EXTI
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup EXTI_LL_Private_Macros
* @{
*/
#define IS_LL_EXTI_LINE_0_31(__VALUE__) (((__VALUE__) & ~LL_EXTI_LINE_ALL_0_31) == 0x00000000U)
#define IS_LL_EXTI_MODE(__VALUE__) (((__VALUE__) == LL_EXTI_MODE_IT) \
|| ((__VALUE__) == LL_EXTI_MODE_EVENT) \
|| ((__VALUE__) == LL_EXTI_MODE_IT_EVENT))
#define IS_LL_EXTI_TRIGGER(__VALUE__) (((__VALUE__) == LL_EXTI_TRIGGER_NONE) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_FALLING) \
|| ((__VALUE__) == LL_EXTI_TRIGGER_RISING_FALLING))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup EXTI_LL_Exported_Functions
* @{
*/
/** @addtogroup EXTI_LL_EF_Init
* @{
*/
/**
* @brief De-initialize the EXTI registers to their default reset values.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are de-initialized
* - ERROR: not applicable
*/
uint32_t LL_EXTI_DeInit(void)
{
/* Interrupt mask register set to default reset values */
LL_EXTI_WriteReg(IMR, 0x3F840000U);
/* Event mask register set to default reset values */
LL_EXTI_WriteReg(EMR, 0x00000000U);
/* Rising Trigger selection register set to default reset values */
LL_EXTI_WriteReg(RTSR, 0x00000000U);
/* Falling Trigger selection register set to default reset values */
LL_EXTI_WriteReg(FTSR, 0x00000000U);
/* Software interrupt event register set to default reset values */
LL_EXTI_WriteReg(SWIER, 0x00000000U);
/* Pending register set to default reset values */
LL_EXTI_WriteReg(PR, 0x007BFFFFU);
return SUCCESS;
}
/**
* @brief Initialize the EXTI registers according to the specified parameters in EXTI_InitStruct.
* @param EXTI_InitStruct pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: EXTI registers are initialized
* - ERROR: not applicable
*/
uint32_t LL_EXTI_Init(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_LL_EXTI_LINE_0_31(EXTI_InitStruct->Line_0_31));
assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->LineCommand));
assert_param(IS_LL_EXTI_MODE(EXTI_InitStruct->Mode));
/* ENABLE LineCommand */
if (EXTI_InitStruct->LineCommand != DISABLE)
{
assert_param(IS_LL_EXTI_TRIGGER(EXTI_InitStruct->Trigger));
/* Configure EXTI Lines in range from 0 to 31 */
if (EXTI_InitStruct->Line_0_31 != LL_EXTI_LINE_NONE)
{
switch (EXTI_InitStruct->Mode)
{
case LL_EXTI_MODE_IT:
/* First Disable Event on provided Lines */
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable IT on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_EVENT:
/* First Disable IT on provided Lines */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Event on provided Lines */
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_MODE_IT_EVENT:
/* Directly Enable IT & Event on provided Lines */
LL_EXTI_EnableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableEvent_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
if (EXTI_InitStruct->Trigger != LL_EXTI_TRIGGER_NONE)
{
switch (EXTI_InitStruct->Trigger)
{
case LL_EXTI_TRIGGER_RISING:
/* First Disable Falling Trigger on provided Lines */
LL_EXTI_DisableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Rising Trigger on provided Lines */
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_FALLING:
/* First Disable Rising Trigger on provided Lines */
LL_EXTI_DisableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
/* Then Enable Falling Trigger on provided Lines */
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
case LL_EXTI_TRIGGER_RISING_FALLING:
LL_EXTI_EnableRisingTrig_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_EnableFallingTrig_0_31(EXTI_InitStruct->Line_0_31);
break;
default:
status = ERROR;
break;
}
}
}
}
/* DISABLE LineCommand */
else
{
/* De-configure EXTI Lines in range from 0 to 31 */
LL_EXTI_DisableIT_0_31(EXTI_InitStruct->Line_0_31);
LL_EXTI_DisableEvent_0_31(EXTI_InitStruct->Line_0_31);
}
return status;
}
/**
* @brief Set each @ref LL_EXTI_InitTypeDef field to default value.
* @param EXTI_InitStruct Pointer to a @ref LL_EXTI_InitTypeDef structure.
* @retval None
*/
void LL_EXTI_StructInit(LL_EXTI_InitTypeDef *EXTI_InitStruct)
{
EXTI_InitStruct->Line_0_31 = LL_EXTI_LINE_NONE;
EXTI_InitStruct->LineCommand = DISABLE;
EXTI_InitStruct->Mode = LL_EXTI_MODE_IT;
EXTI_InitStruct->Trigger = LL_EXTI_TRIGGER_FALLING;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* defined (EXTI) */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/145452425.c | /*
* refclock_hopfpci.c
*
* - clock driver for hopf 6039 PCI board (GPS or DCF77)
* Bernd Altmeier [email protected]
*
* latest source and further information can be found at:
* http://www.ATLSoft.de/ntp
*
* In order to run this driver you have to install and test
* the PCI-board driver for your system first.
*
* On Linux/UNIX
*
* The driver attempts to open the device /dev/hopf6039 .
* The device entry will be made by the installation process of
* the kernel module for the PCI-bus board. The driver sources
* belongs to the delivery equipment of the PCI-board.
*
* On Windows NT/2000
*
* The driver attempts to open the device by calling the function
* "OpenHopfDevice()". This function will be installed by the
* Device Driver for the PCI-bus board. The driver belongs to the
* delivery equipment of the PCI-board.
*
*
* Start 21.03.2000 Revision: 01.20
* changes 22.12.2000 Revision: 01.40 flag1 = 1 sync even if Quarz
*
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#if defined(REFCLOCK) && defined(CLOCK_HOPF_PCI)
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_refclock.h"
#include "ntp_unixtime.h"
#include "ntp_stdlib.h"
#undef fileno
#include <ctype.h>
#undef fileno
#ifndef SYS_WINNT
# include <sys/ipc.h>
# include <assert.h>
# include <unistd.h>
# include <stdio.h>
# include "hopf6039.h"
#else
# include "hopf_PCI_io.h"
#endif
/*
* hopfpci interface definitions
*/
#define PRECISION (-10) /* precision assumed (1 ms) */
#define REFID "hopf" /* reference ID */
#define DESCRIPTION "hopf Elektronik PCI radio board"
#define NSAMPLES 3 /* stages of median filter */
#ifndef SYS_WINNT
# define DEVICE "/dev/hopf6039" /* device name inode*/
#else
# define DEVICE "hopf6039" /* device name WinNT */
#endif
#define LEWAPWAR 0x20 /* leap second warning bit */
#define HOPF_OPMODE 0xC0 /* operation mode mask */
#define HOPF_INVALID 0x00 /* no time code available */
#define HOPF_INTERNAL 0x40 /* internal clock */
#define HOPF_RADIO 0x80 /* radio clock */
#define HOPF_RADIOHP 0xC0 /* high precision radio clock */
/*
* hopfclock unit control structure.
*/
struct hopfclock_unit {
short unit; /* NTP refclock unit number */
char leap_status; /* leap second flag */
};
int fd; /* file descr. */
/*
* Function prototypes
*/
static int hopfpci_start (int, struct peer *);
static void hopfpci_shutdown (int, struct peer *);
static void hopfpci_poll (int unit, struct peer *);
/*
* Transfer vector
*/
struct refclock refclock_hopfpci = {
hopfpci_start, /* start up driver */
hopfpci_shutdown, /* shut down driver */
hopfpci_poll, /* transmit poll message */
noentry, /* not used */
noentry, /* initialize driver (not used) */
noentry, /* not used */
NOFLAGS /* not used */
};
/*
* hopfpci_start - attach to hopf PCI board 6039
*/
static int
hopfpci_start(
int unit,
struct peer *peer
)
{
struct refclockproc *pp;
struct hopfclock_unit *up;
/*
* Allocate and initialize unit structure
*/
up = (struct hopfclock_unit *) emalloc(sizeof(struct hopfclock_unit));
if (!(up)) {
msyslog(LOG_ERR, "hopfPCIClock(%d) emalloc: %m",unit);
#ifdef DEBUG
printf("hopfPCIClock(%d) emalloc\n",unit);
#endif
return (0);
}
memset((char *)up, 0, sizeof(struct hopfclock_unit));
#ifndef SYS_WINNT
fd = open(DEVICE,O_RDWR); /* try to open hopf clock device */
#else
if (!OpenHopfDevice()){
msyslog(LOG_ERR,"Start: %s unit: %d failed!",DEVICE,unit);
return (0);
}
#endif
pp = peer->procptr;
pp->io.clock_recv = noentry;
pp->io.srcclock = (caddr_t)peer;
pp->io.datalen = 0;
pp->io.fd = -1;
pp->unitptr = (caddr_t)up;
get_systime(&pp->lastrec);
/*
* Initialize miscellaneous peer variables
*/
if (pp->unitptr!=0) {
memcpy((char *)&pp->refid, REFID, 4);
peer->precision = PRECISION;
pp->clockdesc = DESCRIPTION;
up->leap_status = 0;
up->unit = (short) unit;
return (1);
}
else {
return 0;
}
}
/*
* hopfpci_shutdown - shut down the clock
*/
static void
hopfpci_shutdown(
int unit,
struct peer *peer
)
{
struct refclockproc *pp;
register struct hopfpciTime *up;
pp = peer->procptr;
up = (struct hopfpciTime *)pp->unitptr;
#ifndef SYS_WINNT
close(fd);
#else
CloseHopfDevice();
// UnmapViewOfFile (up);
#endif
}
/*
* hopfpci_poll - called by the transmit procedure
*/
static void
hopfpci_poll(
int unit,
struct peer *peer
)
{
struct refclockproc *pp;
register struct hopfpciTime *up;
HOPFTIME m_time;
pp = peer->procptr;
up = (struct hopfpciTime *)pp->unitptr;
#ifndef SYS_WINNT
ioctl(fd,HOPF_CLOCK_GET_UTC,&m_time);
#else
GetHopfSystemTime(&m_time);
#endif
pp->polls++;
pp->day = ymd2yd(m_time.wYear,m_time.wMonth,m_time.wDay);
pp->hour = m_time.wHour;
pp->minute = m_time.wMinute;
pp->second = m_time.wSecond;
pp->msec=m_time.wMilliseconds;
pp->usec=0;
if (m_time.wStatus & LEWAPWAR)
pp->leap = LEAP_ADDSECOND;
else
pp->leap = LEAP_NOWARNING;
sprintf(pp->a_lastcode,"ST: %02X T: %02d:%02d:%02d.%03d D: %02d.%02d.%04d",
m_time.wStatus, pp->hour, pp->minute, pp->second, pp->msec,
m_time.wDay, m_time.wMonth, m_time.wYear);
pp->lencode = strlen(pp->a_lastcode);
get_systime(&pp->lastrec);
/*
* If clock has no valid status then report error and exit
*/
if ((m_time.wStatus & HOPF_OPMODE) == HOPF_INVALID) { /* time ok? */
refclock_report(peer, CEVNT_BADTIME);
pp->leap = LEAP_NOTINSYNC;
return;
}
/*
* Test if time is running on internal quarz
* if CLK_FLAG1 is set, sychronize even if no radio operation
*/
if ((m_time.wStatus & HOPF_OPMODE) == HOPF_INTERNAL){
if ((pp->sloppyclockflag & CLK_FLAG1) == 0) {
refclock_report(peer, CEVNT_BADTIME);
pp->leap = LEAP_NOTINSYNC;
return;
}
}
if (!refclock_process(pp)) {
refclock_report(peer, CEVNT_BADTIME);
return;
}
refclock_receive(peer);
record_clock_stats(&peer->srcadr, pp->a_lastcode);
return;
}
#else
int refclock_hopfpci_bs;
#endif /* REFCLOCK */
|
the_stack_data/234517557.c | // DATA RACE in semaphore.(*Registry).RemoveID
// https://syzkaller.appspot.com/bug?id=38896a9da63b2195cd9b5611e05910c5f5cfe65b
// status:fixed
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <linux/futex.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <unistd.h>
__attribute__((noreturn)) static void doexit(int status)
{
volatile unsigned i;
syscall(__NR_exit_group, status);
for (i = 0;; i++) {
}
}
#include <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
const int kFailStatus = 67;
const int kRetryStatus = 69;
static void fail(const char* msg, ...)
{
int e = errno;
va_list args;
va_start(args, msg);
vfprintf(stderr, msg, args);
va_end(args);
fprintf(stderr, " (errno %d)\n", e);
doexit((e == ENOMEM || e == EAGAIN) ? kRetryStatus : kFailStatus);
}
static void use_temporary_dir()
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
fail("failed to mkdtemp");
if (chmod(tmpdir, 0777))
fail("failed to chmod");
if (chdir(tmpdir))
fail("failed to chdir");
}
struct thread_t {
int created, running, call;
pthread_t th;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static int collide;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
while (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &th->running, FUTEX_WAIT, 0, 0);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 0, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
}
return 0;
}
static void execute(int num_calls)
{
int call, thread;
running = 0;
for (call = 0; call < num_calls; call++) {
for (thread = 0; thread < sizeof(threads) / sizeof(threads[0]); thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
pthread_create(&th->th, &attr, thr, th);
}
if (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE)) {
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
if (collide && call % 2)
break;
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 20 * 1000 * 1000;
syscall(SYS_futex, &th->running, FUTEX_WAIT, 1, &ts);
if (running)
usleep((call == num_calls - 1) ? 10000 : 1000);
break;
}
}
}
}
uint64_t r[7] = {0x0, 0x0, 0xffffffffffffffff, 0xffffffffffffffff, 0x0,
0x0, 0x0};
void execute_call(int call)
{
long res;
switch (call) {
case 0:
res = syscall(__NR_semget, 0, 4, 0x200);
if (res != -1)
r[0] = res;
break;
case 1:
res = syscall(__NR_getuid);
if (res != -1)
r[1] = res;
break;
case 2:
memcpy((void*)0x20000640, "./file0", 8);
res = syscall(__NR_open, 0x20000640, 0x80, 0x20);
if (res != -1)
r[2] = res;
break;
case 3:
syscall(__NR_ioctl, r[2], 0x5411, 0x20000680);
break;
case 4:
res = syscall(__NR_fcntl, 0xffffff9c, 0x406, -1);
if (res != -1)
r[3] = res;
break;
case 5:
*(uint32_t*)0x200006c0 = 0x8bd2;
*(uint32_t*)0x200006c4 = 5;
*(uint32_t*)0x200006c8 = 7;
*(uint32_t*)0x200006cc = 4;
syscall(__NR_setsockopt, r[3], 0x10e, 7, 0x200006c0, 0x10);
break;
case 6:
res = syscall(__NR_getgid);
if (res != -1)
r[4] = res;
break;
case 7:
*(uint32_t*)0x20000300 = 0xe8;
res = syscall(__NR_getsockopt, -1, 0, 0x10, 0x20000400, 0x20000300);
if (res != -1)
r[5] = *(uint32_t*)0x20000434;
break;
case 8:
*(uint32_t*)0x20000380 = 0xc;
res = syscall(__NR_getsockopt, 0xffffff9c, 1, 0x11, 0x20000340, 0x20000380);
if (res != -1)
r[6] = *(uint32_t*)0x20000348;
break;
case 9:
*(uint32_t*)0x20000500 = 0x280000;
*(uint32_t*)0x20000504 = r[1];
*(uint32_t*)0x20000508 = r[4];
*(uint32_t*)0x2000050c = r[5];
*(uint32_t*)0x20000510 = r[6];
*(uint32_t*)0x20000514 = 0x60;
*(uint16_t*)0x20000518 = 2;
*(uint16_t*)0x2000051a = 0;
*(uint64_t*)0x20000520 = 0;
*(uint64_t*)0x20000528 = 0;
*(uint64_t*)0x20000530 = 2;
*(uint64_t*)0x20000538 = 5;
*(uint64_t*)0x20000540 = 1;
*(uint64_t*)0x20000548 = 0;
*(uint64_t*)0x20000550 = 0;
syscall(__NR_semctl, r[0], 0, 1, 0x20000500);
break;
case 10:
syscall(__NR_semctl, r[0], 0, 0);
break;
}
}
void loop()
{
execute(11);
collide = 1;
execute(11);
}
int main()
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
use_temporary_dir();
loop();
return 0;
}
|
the_stack_data/126508.c | // see also test_function-6.c
int foo(int /*IN*/ a){
int b,c;
b = a; /* IN */
c = b; /* IN */
return c; /* IN */
}
void main(){
int y,z;
int x,x1,x2;
x1 = x2; /* IN */
x = x1; /* IN */
y = x; /* IN */
z = foo(/*IN*/y); /* IN */
return; /* OUT*/
_SLICE(z);
}
|
the_stack_data/242329498.c | #include<stdio.h>
#define dim 512
void selection_sort(int v[], int n);
int main(void){
int v[dim],n,i;
printf("Entre com a quantidade de elementos:\n");
scanf("%d", &n);
for(i=0;i<n;i++){
scanf("%d", &v[i]);
}
selection_sort(v,n);
for(i=0;i<n;i++){
printf("%d", v[i]);
}
return 0;
}
void selection_sort(int v[], int n){
int maior = 0, temp, maiorI, i;
for(i=0;i<n;i++){
if(maior<v[i]){
maior = v[i];
maiorI=i;
}
}
if(n == 2 && v[1] < v[0]){
temp = v[0];
v[0] = v[1];
v[1] = temp;
}else if(n>2){
temp = v[n-1];
v[n-1] = maior;
v[maiorI] = temp;
selection_sort(v,n-1);
}
}
|
the_stack_data/469051.c | // Índices matriz inferior
#include <stdio.h>
main(){
int m, n;
int i, j;
scanf("%d%d", &m, &n);
for (i = 1; i <= m; i++){
for (j = 1; j <= n; j++){
if (i > j){
printf("(%d,%d)", i, j);
if(i > (j + 1) && j < n){
printf("-");
}
}
}
printf("\n");
}
} |
the_stack_data/100141680.c |
#define _GNU_SOURCE 1
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
static int is_initd = 0;
static int is_on = 0;
static int memtr_fd = -1;
typedef void *(*malloc_type)(size_t size);
typedef void (*free_type)(void *ptr);
typedef void *(*calloc_type)(size_t nmemb, size_t size);
typedef void *(*realloc_type)(void *ptr, size_t size);
static malloc_type orig_malloc;
static free_type orig_free;
static calloc_type orig_calloc;
static realloc_type orig_realloc;
static void memtr_init()
{
char *p;
if (is_initd)
return;
is_initd = 1;
p = getenv("MEMTR");
if (p) {
memtr_fd = open( p, O_CREAT|O_TRUNC|O_RDWR, 0666 );
}
orig_malloc = (malloc_type)dlsym( RTLD_NEXT, "malloc" );
orig_free = (free_type)dlsym( RTLD_NEXT, "free" );
orig_calloc = (calloc_type)dlsym( RTLD_NEXT, "calloc" );
orig_realloc = (realloc_type)dlsym( RTLD_NEXT, "realloc" );
if (orig_malloc && orig_free && orig_realloc && orig_calloc && memtr_fd >= 0) {
is_on = 1;
}
}
void itoa(unsigned long i, char *b)
{
unsigned long shifter = i;
char *p = b;
do {
++p;
shifter = shifter/10;
} while (shifter);
*p = '\0';
do {
*--p = '0' + i%10;
i = i/10;
} while (i);
}
void itox(unsigned long i, char *b)
{
static const char hd[16] = "0123456789abcdef";
int k;
*b = '0'; b++;
*b = 'x'; b++;
for (k=sizeof(long)-1; k>=0; k--) {
unsigned long mask = 0xf0 << (k*8);
*b = hd[ ((i & mask)>>4) >> (k*8) ]; b++;
*b = hd[ (i & (mask>>4)) >> (k*8) ]; b++;
}
*b = 0;
}
static void memtr_print( const char *name, size_t size, void *ptr )
{
char buf1[128], buf2[32];
char *p;
int len;
if (is_on) {
p = buf1;
len = strlen(name);
memcpy( p, name, len );
p += len;
*p = '\t'; p++;
itoa( (int)size, buf2 );
len = strlen( buf2 );
memcpy( p, buf2, len );
p += len;
*p = '\t'; p++;
itox( (unsigned long)ptr, buf2 );
len = strlen( buf2 );
memcpy( p, buf2, len );
p += len;
*p = '\n'; p++;
write( memtr_fd, buf1, p - buf1 );
}
}
void *malloc(size_t size)
{
void *p;
memtr_init();
memtr_print( "m<", size, 0 );
p = orig_malloc( size );
memtr_print( "m>", size, p );
return p;
}
void free(void *ptr)
{
memtr_init();
memtr_print( "f<", 0, ptr );
orig_free( ptr );
memtr_print( "f>", 0, ptr );
}
void *calloc(size_t nmemb, size_t size)
{
void *p;
memtr_init();
memtr_print( "c<", nmemb*size, 0 );
p = orig_calloc( nmemb, size );
memtr_print( "c>", nmemb*size, p );
return p;
}
void *realloc(void *ptr, size_t size)
{
void *p;
memtr_init();
memtr_print( "r<", size, ptr );
p = orig_realloc( ptr, size );
memtr_print( "r>", size, p );
return p;
}
|
the_stack_data/47973.c | /*
* Copyright (c) 2007-2013 Nicira, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA
*
* This code is derived from kernel vxlan module.
*/
#include <linux/version.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0)
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/rculist.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <linux/if_vlan.h>
#include <linux/hash.h>
#include <linux/ethtool.h>
#include <net/arp.h>
#include <net/ndisc.h>
#include <net/ip.h>
#include <net/ip_tunnels.h>
#include <net/icmp.h>
#include <net/udp.h>
#include <net/rtnetlink.h>
#include <net/route.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <net/vxlan.h>
#include "compat.h"
#include "datapath.h"
#include "gso.h"
#include "vlan.h"
#define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
#define VXLAN_FLAGS 0x08000000 /* struct vxlanhdr.vx_flags required value. */
/* VXLAN protocol header */
struct vxlanhdr {
__be32 vx_flags;
__be32 vx_vni;
};
/* Callback from net/ipv4/udp.c to receive packets */
static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
{
struct vxlan_sock *vs;
struct vxlanhdr *vxh;
/* Need Vxlan and inner Ethernet header to be present */
if (!pskb_may_pull(skb, VXLAN_HLEN))
goto error;
/* Return packets with reserved bits set */
vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
(vxh->vx_vni & htonl(0xff))) {
pr_warn("invalid vxlan flags=%#x vni=%#x\n",
ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
goto error;
}
if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
goto drop;
vs = rcu_dereference_sk_user_data(sk);
if (!vs)
goto drop;
vs->rcv(vs, skb, vxh->vx_vni);
return 0;
drop:
/* Consume bad packet */
kfree_skb(skb);
return 0;
error:
/* Return non vxlan pkt */
return 1;
}
static void vxlan_sock_put(struct sk_buff *skb)
{
sock_put(skb->sk);
}
/* On transmit, associate with the tunnel socket */
static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)
{
skb_orphan(skb);
sock_hold(sk);
skb->sk = sk;
skb->destructor = vxlan_sock_put;
}
/* Compute source port for outgoing packet
* first choice to use L4 flow hash since it will spread
* better and maybe available from hardware
* secondary choice is to use jhash on the Ethernet header
*/
__be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
{
unsigned int range = (port_max - port_min) + 1;
u32 hash;
hash = skb_get_rxhash(skb);
if (!hash)
hash = jhash(skb->data, 2 * ETH_ALEN,
(__force u32) skb->protocol);
return htons((((u64) hash * range) >> 32) + port_min);
}
static void vxlan_gso(struct sk_buff *skb)
{
int udp_offset = skb_transport_offset(skb);
struct udphdr *uh;
uh = udp_hdr(skb);
uh->len = htons(skb->len - udp_offset);
/* csum segment if tunnel sets skb with csum. */
if (unlikely(uh->check)) {
struct iphdr *iph = ip_hdr(skb);
uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
skb->len - udp_offset,
IPPROTO_UDP, 0);
uh->check = csum_fold(skb_checksum(skb, udp_offset,
skb->len - udp_offset, 0));
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
}
skb->ip_summed = CHECKSUM_NONE;
}
static int handle_offloads(struct sk_buff *skb)
{
if (skb_is_gso(skb)) {
OVS_GSO_CB(skb)->fix_segment = vxlan_gso;
} else {
if (skb->ip_summed != CHECKSUM_PARTIAL)
skb->ip_summed = CHECKSUM_NONE;
}
return 0;
}
int vxlan_xmit_skb(struct vxlan_sock *vs,
struct rtable *rt, struct sk_buff *skb,
__be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
__be16 src_port, __be16 dst_port, __be32 vni)
{
struct vxlanhdr *vxh;
struct udphdr *uh;
int min_headroom;
int err;
min_headroom = LL_RESERVED_SPACE(rt_dst(rt).dev) + rt_dst(rt).header_len
+ VXLAN_HLEN + sizeof(struct iphdr)
+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
/* Need space for new headers (invalidates iph ptr) */
err = skb_cow_head(skb, min_headroom);
if (unlikely(err))
return err;
if (vlan_tx_tag_present(skb)) {
if (unlikely(!__vlan_put_tag(skb,
skb->vlan_proto,
vlan_tx_tag_get(skb))))
return -ENOMEM;
vlan_set_tci(skb, 0);
}
skb_reset_inner_headers(skb);
vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
vxh->vx_flags = htonl(VXLAN_FLAGS);
vxh->vx_vni = vni;
__skb_push(skb, sizeof(*uh));
skb_reset_transport_header(skb);
uh = udp_hdr(skb);
uh->dest = dst_port;
uh->source = src_port;
uh->len = htons(skb->len);
uh->check = 0;
vxlan_set_owner(vs->sock->sk, skb);
err = handle_offloads(skb);
if (err)
return err;
return iptunnel_xmit(rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, false);
}
static void rcu_free_vs(struct rcu_head *rcu)
{
struct vxlan_sock *vs = container_of(rcu, struct vxlan_sock, rcu);
kfree(vs);
}
static void vxlan_del_work(struct work_struct *work)
{
struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
sk_release_kernel(vs->sock->sk);
call_rcu(&vs->rcu, rcu_free_vs);
}
static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
vxlan_rcv_t *rcv, void *data)
{
struct vxlan_sock *vs;
struct sock *sk;
struct sockaddr_in vxlan_addr = {
.sin_family = AF_INET,
.sin_addr.s_addr = htonl(INADDR_ANY),
.sin_port = port,
};
int rc;
vs = kmalloc(sizeof(*vs), GFP_KERNEL);
if (!vs) {
pr_debug("memory alocation failure\n");
return ERR_PTR(-ENOMEM);
}
INIT_WORK(&vs->del_work, vxlan_del_work);
/* Create UDP socket for encapsulation receive. */
rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
if (rc < 0) {
pr_debug("UDP socket create failed\n");
kfree(vs);
return ERR_PTR(rc);
}
/* Put in proper namespace */
sk = vs->sock->sk;
sk_change_net(sk, net);
rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
sizeof(vxlan_addr));
if (rc < 0) {
pr_debug("bind for UDP socket %pI4:%u (%d)\n",
&vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
sk_release_kernel(sk);
kfree(vs);
return ERR_PTR(rc);
}
vs->rcv = rcv;
vs->data = data;
/* Disable multicast loopback */
inet_sk(sk)->mc_loop = 0;
rcu_assign_sk_user_data(vs->sock->sk, vs);
/* Mark socket as an encapsulation socket. */
udp_sk(sk)->encap_type = 1;
udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
udp_encap_enable();
return vs;
}
struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
vxlan_rcv_t *rcv, void *data,
bool no_share, bool ipv6)
{
return vxlan_socket_create(net, port, rcv, data);
}
void vxlan_sock_release(struct vxlan_sock *vs)
{
ASSERT_OVSL();
rcu_assign_sk_user_data(vs->sock->sk, NULL);
queue_work(system_wq, &vs->del_work);
}
#endif /* 3.12 */
|
the_stack_data/1077262.c | #define MALLOC_UNIT 5000
void strobogrammaticHelper(char ***ret, int *retCtr, int *memUnit, char *tmp, int cur, int n, char isOdd)
{
char *nums1 = "01689";
char *nums2 = "01986";
if (cur == n/2)
{
if (isOdd)
{
int midIdx = n/2;
(*ret)[*retCtr] = calloc(n+1, sizeof(char));
(*ret)[*retCtr+1] = calloc(n+1, sizeof(char));
(*ret)[*retCtr+2] = calloc(n+1, sizeof(char));
memcpy((*ret)[*retCtr], tmp, sizeof(char)*n);
memcpy((*ret)[*retCtr+1], tmp, sizeof(char)*n);
memcpy((*ret)[*retCtr+2], tmp, sizeof(char)*n);
(*ret)[*retCtr][midIdx] = '0';
(*ret)[*retCtr+1][midIdx] = '1';
(*ret)[*retCtr+2][midIdx] = '8';
*retCtr += 3;
*memUnit += 3;
} else
{
(*ret)[*retCtr] = calloc(n+1, sizeof(char));
memcpy((*ret)[*retCtr], tmp, sizeof(char)*n);
*retCtr += 1;
*memUnit += 1;
}
if (*memUnit + 3 >= MALLOC_UNIT)
{
*ret = realloc(*ret, sizeof(char *)*(*retCtr+MALLOC_UNIT));
*memUnit = 0;
}
return ;
}
for (int i = 0; i < 5; i++)
{
// string can not start from '0'
if (cur == 0 && i == 0)
{
continue;
}
tmp[cur] = nums1[i];
tmp[n-cur-1] = nums2[i];
strobogrammaticHelper(ret, retCtr, memUnit, tmp, cur+1, n, isOdd);
}
}
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
char ** findStrobogrammatic(int n, int* returnSize)
{
int **ret = malloc(sizeof(char*)*MALLOC_UNIT);
*returnSize = 0;
char *tmp = calloc(n+1, sizeof(char));
char isOdd = ((n & 0x1) == 0x1 ? 1 : 0);
int memUnit = 0;
strobogrammaticHelper(&ret, returnSize, &memUnit, tmp, 0, n, isOdd);
free(tmp);
return ret;
}
|
the_stack_data/1237030.c | /****************************************************************************
*
* Copyright (C) 2017-2019 PX4 Development Team. 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 PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file board_crashdump.c
*
* Provides common board logic for crashdump callout
* and hardfault log support
*/
#ifdef CONFIG_BOARD_CRASHDUMP
#include <board_config.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <nuttx/board.h>
#include "arm_internal.h"
#include <systemlib/hardfault_log.h>
#include "nvic.h"
#include <syslog.h>
#if defined(CONFIG_STM32F7_BBSRAM) && defined(CONFIG_STM32F7_SAVE_CRASHDUMP)
# define HAS_BBSRAM CONFIG_STM32F7_BBSRAM
# define BBSRAM_FILE_COUNT CONFIG_STM32F7_BBSRAM_FILES
# define SAVE_CRASHDUMP CONFIG_STM32F7_SAVE_CRASHDUMP
#elif defined(CONFIG_STM32H7_BBSRAM) && defined(CONFIG_STM32H7_SAVE_CRASHDUMP)
# define HAS_BBSRAM CONFIG_STM32H7_BBSRAM
# define BBSRAM_FILE_COUNT CONFIG_STM32H7_BBSRAM_FILES
# define SAVE_CRASHDUMP CONFIG_STM32H7_SAVE_CRASHDUMP
#elif defined(CONFIG_STM32_BBSRAM) && defined(CONFIG_STM32_SAVE_CRASHDUMP)
# define HAS_BBSRAM CONFIG_STM32_BBSRAM
# define BBSRAM_FILE_COUNT CONFIG_STM32_BBSRAM_FILES
# define SAVE_CRASHDUMP CONFIG_STM32_SAVE_CRASHDUMP
#endif
int board_hardfault_init(int display_to_console, bool allow_prompt)
{
int hadCrash = -1;
#if defined(HAS_BBSRAM)
/* NB. the use of the console requires the hrt running
* to poll the DMA
*/
/* Using Battery Backed Up SRAM */
int filesizes[BBSRAM_FILE_COUNT + 1] = BSRAM_FILE_SIZES;
stm32_bbsraminitialize(BBSRAM_PATH, filesizes);
#if defined(SAVE_CRASHDUMP)
/* Panic Logging in Battery Backed Up Files */
/*
* In an ideal world, if a fault happens in flight the
* system save it to BBSRAM will then reboot. Upon
* rebooting, the system will log the fault to disk, recover
* the flight state and continue to fly. But if there is
* a fault on the bench or in the air that prohibit the recovery
* or committing the log to disk, the things are too broken to
* fly. So the question is:
*
* Did we have a hard fault and not make it far enough
* through the boot sequence to commit the fault data to
* the SD card?
*/
/* Do we have an uncommitted hard fault in BBSRAM?
* - this will be reset after a successful commit to SD
*/
hadCrash = hardfault_check_status("boot");
if (hadCrash == OK) {
syslog(LOG_ERR, "[boot] There is a hard fault logged. Hold down the SPACE BAR," \
" while booting to review!\n");
/* Yes. So add one to the boot count - this will be reset after a successful
* commit to SD
*/
int reboots = hardfault_increment_reboot("boot", false);
if (reboots < 0) {
return -EIO;
}
if (reboots >= 32000) {
reboots = hardfault_increment_reboot("boot", true);
return -ENOSPC;
}
/* Also end the misery for a user that holds for a key down on the console */
int bytesWaiting = 0;
ioctl(fileno(stdin), FIONREAD, (unsigned long)((uintptr_t) &bytesWaiting));
if (reboots > display_to_console || bytesWaiting != 0) {
/* Since we can not commit the fault dump to disk. Display it
* to the console.
*/
if (!allow_prompt) {
bytesWaiting = 0;
}
if (display_to_console != INT_MAX) {
hardfault_write("boot", fileno(stdout), HARDFAULT_DISPLAY_FORMAT, false);
}
syslog(LOG_ERR, "[boot] There were %d reboots with Hard fault that were not committed to disk%s\n",
reboots,
(bytesWaiting == 0 ? "" : " - Boot halted Due to Key Press\n"));
/* For those of you with a debugger set a break point on up_assert and
* then set dbgContinue = 1 and go.
*/
/* Clear any key press that got us here */
volatile bool dbgContinue = bytesWaiting == 0;
int c = '>';
while (!dbgContinue) {
switch (c) {
case EOF:
case '\n':
case '\r':
case ' ':
goto read;
default:
putchar(c);
putchar('\n');
switch (c) {
case 'D':
case 'd':
hardfault_write("boot", fileno(stdout), HARDFAULT_DISPLAY_FORMAT, false);
break;
case 'C':
case 'c':
hardfault_rearm("boot");
hardfault_increment_reboot("boot", true);
break;
case 'B':
case 'b':
dbgContinue = true;
break;
default:
break;
} // Inner Switch
syslog(LOG_INFO, "\nEnter B - Continue booting\n" \
"Enter C - Clear the fault log\n" \
"Enter D - Dump fault log\n\n?>");
fflush(stdout);
read:
if (!dbgContinue) {
c = getchar();
}
break;
} // outer switch
} // for
} // inner if
} // outer if
#endif // SAVE_CRASHDUMP
#endif // HAS_BBSRAM
return hadCrash == OK ? 1 : 0;
}
static void copy_reverse(stack_word_t *dest, stack_word_t *src, int size)
{
while (size--) {
*dest++ = *src--;
}
}
static uint32_t *__attribute__((noinline)) __sdata_addr(void)
{
return &_sdata;
}
__EXPORT void board_crashdump(uintptr_t currentsp, FAR void *tcb, FAR const char *filename, int lineno)
{
#ifndef BOARD_CRASHDUMP_RESET_ONLY
/* We need a chunk of ram to save the complete context in.
* Since we are going to reboot we will use &_sdata
* which is the lowest memory and the amount we will save
* _should be_ below any resources we need herein.
* Unfortunately this is hard to test. See dead below
*/
fullcontext_s *pdump = (fullcontext_s *)__sdata_addr();
(void)enter_critical_section();
struct tcb_s *rtcb = (struct tcb_s *)tcb;
/* Zero out everything */
memset(pdump, 0, sizeof(fullcontext_s));
/* Save Info */
pdump->info.lineno = lineno;
if (filename) {
int offset = 0;
unsigned int len = strlen((char *)filename) + 1;
if (len > sizeof(pdump->info.filename)) {
offset = len - sizeof(pdump->info.filename) ;
}
strncpy(pdump->info.filename, (char *)&filename[offset], sizeof(pdump->info.filename));
}
/* Save the value of the pointer for current_regs as debugging info.
* It should be NULL in case of an ASSERT and will aid in cross
* checking the validity of system memory at the time of the
* fault.
*/
pdump->info.current_regs = (uintptr_t) CURRENT_REGS;
/* Save Context */
#if CONFIG_TASK_NAME_SIZE > 0
strncpy(pdump->info.name, rtcb->name, CONFIG_TASK_NAME_SIZE);
#endif
pdump->info.pid = rtcb->pid;
pdump->info.fault_regs.cfsr = getreg32(NVIC_CFAULTS);
pdump->info.fault_regs.hfsr = getreg32(NVIC_HFAULTS);
pdump->info.fault_regs.dfsr = getreg32(NVIC_DFAULTS);
pdump->info.fault_regs.mmfsr = getreg32(NVIC_MEMMANAGE_ADDR);
pdump->info.fault_regs.bfsr = getreg32(NVIC_BFAULT_ADDR);
pdump->info.fault_regs.afsr = getreg32(NVIC_AFAULTS);
#if defined(CONFIG_ARCH_CORTEXM7)
pdump->info.fault_regs.abfsr = getreg32(NVIC_ABFSR);
#endif
pdump->info.flags |= eFaultRegPresent;
/* If current_regs is not NULL then we are in an interrupt context
* and the user context is in current_regs else we are running in
* the users context
*/
if (CURRENT_REGS) {
pdump->info.stacks.interrupt.sp = currentsp;
pdump->info.flags |= (eRegsPresent | eUserStackPresent | eIntStackPresent);
memcpy(pdump->info.regs, (void *)CURRENT_REGS, sizeof(pdump->info.regs));
pdump->info.stacks.user.sp = pdump->info.regs[REG_R13];
} else {
/* users context */
pdump->info.flags |= eUserStackPresent;
pdump->info.stacks.user.sp = currentsp;
}
if (pdump->info.pid == 0) {
pdump->info.stacks.user.top = g_idle_topstack - 4;
pdump->info.stacks.user.size = CONFIG_IDLETHREAD_STACKSIZE;
} else {
pdump->info.stacks.user.top = (uint32_t) rtcb->adj_stack_ptr;
pdump->info.stacks.user.size = (uint32_t) rtcb->adj_stack_size;
}
#if CONFIG_ARCH_INTERRUPTSTACK > 3
/* Get the limits on the interrupt stack memory */
pdump->info.stacks.interrupt.top = (uint32_t)&g_intstackbase;
pdump->info.stacks.interrupt.size = (CONFIG_ARCH_INTERRUPTSTACK & ~3);
/* If In interrupt Context save the interrupt stack data centered
* about the interrupt stack pointer
*/
if ((pdump->info.flags & eIntStackPresent) != 0) {
stack_word_t *ps = (stack_word_t *) pdump->info.stacks.interrupt.sp;
copy_reverse(pdump->istack, &ps[arraySize(pdump->istack) / 2], arraySize(pdump->istack));
}
/* Is it Invalid? */
if (!(pdump->info.stacks.interrupt.sp <= pdump->info.stacks.interrupt.top &&
pdump->info.stacks.interrupt.sp > pdump->info.stacks.interrupt.top - pdump->info.stacks.interrupt.size)) {
pdump->info.flags |= eInvalidIntStackPrt;
}
#endif
/* If In interrupt context or User save the user stack data centered
* about the user stack pointer
*/
if ((pdump->info.flags & eUserStackPresent) != 0) {
stack_word_t *ps = (stack_word_t *) pdump->info.stacks.user.sp;
copy_reverse(pdump->ustack, &ps[arraySize(pdump->ustack) / 2], arraySize(pdump->ustack));
}
/* Is it Invalid? */
if (!(pdump->info.stacks.user.sp <= pdump->info.stacks.user.top &&
pdump->info.stacks.user.sp > pdump->info.stacks.user.top - pdump->info.stacks.user.size)) {
pdump->info.flags |= eInvalidUserStackPtr;
}
int rv = px4_savepanic(HARDFAULT_FILENO, (uint8_t *)pdump, sizeof(fullcontext_s));
/* Test if memory got wiped because of using _sdata */
if (rv == -ENXIO) {
char *dead = "Memory wiped - dump not saved!";
while (*dead) {
arm_lowputc(*dead++);
}
} else if (rv == -ENOSPC) {
/* hard fault again */
arm_lowputc('!');
}
#endif /* BOARD_CRASHDUMP_RESET_ONLY */
/* All boards need to do a reset here!
*
* Since we needed a chunk of ram to save the complete
* context in and have corrupted it. We can not allow
* the OS to run again. We used &_sdata which is the lowest memory
* and it could be used by the OS.
*/
board_reset(CONFIG_BOARD_ASSERT_RESET_VALUE);
}
#endif /* CONFIG_BOARD_CRASHDUMP */
|
the_stack_data/115765200.c | #include <stdbool.h>
#include <stdio.h>
extern int k_gcd(int, int);
extern bool is_prime(int);
int main(int argc, char *argv[]) {
printf("%d\n", is_prime(37));
printf("%d\n", is_prime(36));
printf("%d", k_gcd(21, 35));
}
|
the_stack_data/122016622.c | #include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#define PORT 5500 /* Port that will be opened */
#define BACKLOG 20 /* Number of allowed connections */
#define BUFF_SIZE 1024
/* The processData function copies the input string to output */
void processData(char *in, char *out);
/* The recv() wrapper function*/
int receiveData(int s, char *buff, int size, int flags);
/* The send() wrapper function*/
int sendData(int s, char *buff, int size, int flags);
int main()
{
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t ret;
fd_set readfds, allset;
char sendBuff[BUFF_SIZE], rcvBuff[BUFF_SIZE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
//Step 1: Construct a TCP socket to listen connection request
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){ /* calls socket() */
perror("\nError: ");
return 0;
}
//Step 2: Bind address to socket
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))==-1){ /* calls bind() */
perror("\nError: ");
return 0;
}
//Step 3: Listen request from client
if(listen(listenfd, BACKLOG) == -1){ /* calls listen() */
perror("\nError: ");
return 0;
}
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
//Step 4: Communicate with clients
while (1) {
readfds = allset; /* structure assignment */
nready = select(maxfd+1, &readfds, NULL, NULL, NULL);
if(nready < 0){
perror("\nError: ");
return 0;
}
if (FD_ISSET(listenfd, &readfds)) { /* new client connection */
clilen = sizeof(cliaddr);
if((connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen)) < 0)
perror("\nError: ");
else{
printf("You got a connection from %s\n", inet_ntoa(cliaddr.sin_addr)); /* prints client's IP */
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if (i == FD_SETSIZE){
printf("\nToo many clients");
close(connfd);
}
FD_SET(connfd, &allset); /* add new descriptor to set */
if (connfd > maxfd)
maxfd = connfd; /* for select */
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors */
}
}
for (i = 0; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &readfds)) {
ret = receiveData(sockfd, rcvBuff, BUFF_SIZE, 0);
if (ret <= 0){
FD_CLR(sockfd, &allset);
close(sockfd);
client[i] = -1;
}
else {
processData(rcvBuff, sendBuff);
sendData(sockfd, sendBuff, ret, 0);
if (ret <= 0){
FD_CLR(sockfd, &allset);
close(sockfd);
client[i] = -1;
}
}
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
}
return 0;
}
void processData(char *in, char *out){
strcpy (out, in);
}
int receiveData(int s, char *buff, int size, int flags){
int n;
n = recv(s, buff, size, flags);
if(n < 0)
perror("Error: ");
return n;
}
int sendData(int s, char *buff, int size, int flags){
int n;
n = send(s, buff, size, flags);
if(n < 0)
perror("Error: ");
return n;
}
|
the_stack_data/82620.c |
#include <stdio.h>
void scilab_rt_plot3d_i2d2i2d0i0s0d2i2_(int in00, int in01, int matrixin0[in00][in01],
int in10, int in11, double matrixin1[in10][in11],
int in20, int in21, int matrixin2[in20][in21],
double scalarin0,
int scalarin1,
char* scalarin2,
int in30, int in31, double matrixin3[in30][in31],
int in40, int in41, int matrixin4[in40][in41])
{
int i;
int j;
int val0 = 0;
double val1 = 0;
int val2 = 0;
double val3 = 0;
int val4 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%d", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%f", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%d", val2);
printf("%f", scalarin0);
printf("%d", scalarin1);
printf("%s", scalarin2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%d", val4);
}
|
the_stack_data/92326839.c | #include <stdio.h>
#include <math.h>
#include <float.h>
/* arc tangent of y/x */
double atan2(y,x)
double x, y ;
{
double a;
if (fabs(x) >= fabs(y)) {
a = atan(y/x) ;
if (x < 0.0) {
if (y >= 0.0) a += M_PI ;
else a -= M_PI ;
}
}
else {
a = -atan(x/y) ;
if (y < 0.0) a -= (M_PI / 2.0) ;
else a += (M_PI / 2.0);
}
return a ;
}
|
the_stack_data/1133240.c | #include <stdio.h>
int main(void)
{
printf("Fahrenheit\tCelsius\n");
for (int fahr = 300; fahr >= 0; fahr -= 20)
printf("%3d\t\t%6.1f\n", fahr, (5.0 / 9.0) * (fahr - 32.0));
} |
the_stack_data/705863.c | /*
* Copyright (c) 1980, 1993, 1994
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#) Copyright (c) 1980, 1993, 1994 The Regents of the University of California. All rights reserved.
* @(#)banner.c 8.4 (Berkeley) 4/29/95
* $FreeBSD: src/usr.bin/banner/banner.c,v 1.16 2006/11/22 21:05:17 maxim Exp $
* $DragonFly: src/usr.bin/banner/banner.c,v 1.5 2007/08/26 16:44:32 pavalos Exp $
*/
/*
* banner - prints large signs
* banner [-w#] [-d] [-t] message ...
*/
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define MAXMSG 1024
#define DWIDTH 132
#define NCHARS 128
#define NBYTES 9271
/* Pointers into data_table for each ASCII char */
const int asc_ptr[NCHARS] = {
/* ^@ */ 0, 0, 0, 0, 0, 0, 0, 0,
/* ^H */ 0, 0, 0, 0, 0, 0, 0, 0,
/* ^P */ 0, 0, 0, 0, 0, 0, 0, 0,
/* ^X */ 0, 0, 0, 0, 0, 0, 0, 0,
/* */ 1, 3, 50, 81, 104, 281, 483, 590,
/* ( */ 621, 685, 749, 851, 862, 893, 898, 921,
/* 0 */1019, 1150, 1200, 1419, 1599, 1744, 1934, 2111,
/* 8 */2235, 2445, 2622, 2659, 0, 2708, 0, 2715,
/* @ */2857, 3072, 3273, 3403, 3560, 3662, 3730, 3785,
/* H */3965, 4000, 4015, 4115, 4281, 4314, 4432, 4548,
/* P */4709, 4790, 4999, 5188, 5397, 5448, 5576, 5710,
/* X */5892, 6106, 6257, 0, 0, 0, 0, 0,
/* ` */ 50, 6503, 6642, 6733, 6837, 6930, 7073, 7157,
/* h */7380, 7452, 7499, 7584, 7689, 7702, 7797, 7869,
/* p */7978, 8069, 8160, 8222, 8381, 8442, 8508, 8605,
/* x */8732, 8888, 9016, 0, 0, 0, 0, 0
};
/*
* Table of stuff to print. Format:
* 128+n -> print current line n times.
* 64+n -> this is last byte of char.
* else, put m chars at position n (where m
* is the next elt in array) and goto second
* next element in array.
*/
const unsigned char data_table[NBYTES] = {
/* 0 1 2 3 4 5 6 7 8 9 */
/* 0 */ 129, 227, 130, 34, 6, 90, 19, 129, 32, 10,
/* 10 */ 74, 40, 129, 31, 12, 64, 53, 129, 30, 14,
/* 20 */ 54, 65, 129, 30, 14, 53, 67, 129, 30, 14,
/* 30 */ 54, 65, 129, 31, 12, 64, 53, 129, 32, 10,
/* 40 */ 74, 40, 129, 34, 6, 90, 19, 129, 194, 130,
/* 50 */ 99, 9, 129, 97, 14, 129, 96, 18, 129, 95,
/* 60 */ 22, 129, 95, 16, 117, 2, 129, 95, 14, 129,
/* 70 */ 96, 11, 129, 97, 9, 129, 99, 6, 129, 194,
/* 80 */ 129, 87, 4, 101, 4, 131, 82, 28, 131, 87,
/* 90 */ 4, 101, 4, 133, 82, 28, 131, 87, 4, 101,
/* 100 */ 4, 131, 193, 129, 39, 1, 84, 27, 129, 38,
/* 110 */ 3, 81, 32, 129, 37, 5, 79, 35, 129, 36,
/* 120 */ 5, 77, 38, 129, 35, 5, 76, 40, 129, 34,
/* 130 */ 5, 75, 21, 103, 14, 129, 33, 5, 74, 19,
/* 140 */ 107, 11, 129, 32, 5, 73, 17, 110, 9, 129,
/* 150 */ 32, 4, 73, 16, 112, 7, 129, 31, 4, 72,
/* 160 */ 15, 114, 6, 129, 31, 4, 72, 14, 115, 5,
/* 170 */ 129, 30, 4, 71, 15, 116, 5, 129, 27, 97,
/* 180 */ 131, 30, 4, 69, 14, 117, 4, 129, 30, 4,
/* 190 */ 68, 15, 117, 4, 132, 30, 4, 68, 14, 117,
/* 200 */ 4, 129, 27, 97, 131, 30, 5, 65, 15, 116,
/* 210 */ 5, 129, 31, 4, 65, 14, 116, 4, 129, 31,
/* 220 */ 6, 64, 15, 116, 4, 129, 32, 7, 62, 16,
/* 230 */ 115, 4, 129, 32, 9, 61, 17, 114, 5, 129,
/* 240 */ 33, 11, 58, 19, 113, 5, 129, 34, 14, 55,
/* 250 */ 21, 112, 5, 129, 35, 40, 111, 5, 129, 36,
/* 260 */ 38, 110, 5, 129, 37, 35, 109, 5, 129, 38,
/* 270 */ 32, 110, 3, 129, 40, 27, 111, 1, 129, 193,
/* 280 */ 129, 30, 4, 103, 9, 129, 30, 7, 100, 15,
/* 290 */ 129, 30, 10, 99, 17, 129, 33, 10, 97, 6,
/* 300 */ 112, 6, 129, 36, 10, 96, 5, 114, 5, 129,
/* 310 */ 39, 10, 96, 4, 115, 4, 129, 42, 10, 95,
/* 320 */ 4, 116, 4, 129, 45, 10, 95, 3, 117, 3,
/* 330 */ 129, 48, 10, 95, 3, 117, 3, 129, 51, 10,
/* 340 */ 95, 4, 116, 4, 129, 54, 10, 96, 4, 115,
/* 350 */ 4, 129, 57, 10, 96, 5, 114, 5, 129, 60,
/* 360 */ 10, 97, 6, 112, 6, 129, 63, 10, 99, 17,
/* 370 */ 129, 66, 10, 100, 15, 129, 69, 10, 103, 9,
/* 380 */ 129, 39, 9, 72, 10, 129, 36, 15, 75, 10,
/* 390 */ 129, 35, 17, 78, 10, 129, 33, 6, 48, 6,
/* 400 */ 81, 10, 129, 32, 5, 50, 5, 84, 10, 129,
/* 410 */ 32, 4, 51, 4, 87, 10, 129, 31, 4, 52,
/* 420 */ 4, 90, 10, 129, 31, 3, 53, 3, 93, 10,
/* 430 */ 129, 31, 3, 53, 3, 96, 10, 129, 31, 4,
/* 440 */ 52, 4, 99, 10, 129, 32, 4, 51, 4, 102,
/* 450 */ 10, 129, 32, 5, 50, 5, 105, 10, 129, 33,
/* 460 */ 6, 48, 6, 108, 10, 129, 35, 17, 111, 10,
/* 470 */ 129, 36, 15, 114, 7, 129, 40, 9, 118, 4,
/* 480 */ 129, 193, 129, 48, 18, 129, 43, 28, 129, 41,
/* 490 */ 32, 129, 39, 36, 129, 37, 40, 129, 35, 44,
/* 500 */ 129, 34, 46, 129, 33, 13, 68, 13, 129, 32,
/* 510 */ 9, 73, 9, 129, 32, 7, 75, 7, 129, 31,
/* 520 */ 6, 77, 6, 129, 31, 5, 78, 5, 129, 30,
/* 530 */ 5, 79, 5, 129, 20, 74, 132, 30, 4, 80,
/* 540 */ 4, 129, 31, 3, 79, 4, 129, 31, 4, 79,
/* 550 */ 4, 129, 32, 3, 78, 4, 129, 32, 4, 76,
/* 560 */ 6, 129, 33, 4, 74, 7, 129, 34, 4, 72,
/* 570 */ 8, 129, 35, 5, 72, 7, 129, 37, 5, 73,
/* 580 */ 4, 129, 39, 4, 74, 1, 129, 129, 193, 130,
/* 590 */ 111, 6, 129, 109, 10, 129, 108, 12, 129, 107,
/* 600 */ 14, 129, 97, 2, 105, 16, 129, 99, 22, 129,
/* 610 */ 102, 18, 129, 105, 14, 129, 108, 9, 129, 194,
/* 620 */ 130, 63, 25, 129, 57, 37, 129, 52, 47, 129,
/* 630 */ 48, 55, 129, 44, 63, 129, 41, 69, 129, 38,
/* 640 */ 75, 129, 36, 79, 129, 34, 83, 129, 33, 28,
/* 650 */ 90, 28, 129, 32, 23, 96, 23, 129, 32, 17,
/* 660 */ 102, 17, 129, 31, 13, 107, 13, 129, 30, 9,
/* 670 */ 112, 9, 129, 30, 5, 116, 5, 129, 30, 1,
/* 680 */ 120, 1, 129, 194, 130, 30, 1, 120, 1, 129,
/* 690 */ 30, 5, 116, 5, 129, 30, 9, 112, 9, 129,
/* 700 */ 31, 13, 107, 13, 129, 32, 17, 102, 17, 129,
/* 710 */ 32, 23, 96, 23, 129, 33, 28, 90, 28, 129,
/* 720 */ 34, 83, 129, 36, 79, 129, 38, 75, 129, 41,
/* 730 */ 69, 129, 44, 63, 129, 48, 55, 129, 52, 47,
/* 740 */ 129, 57, 37, 129, 63, 25, 129, 194, 129, 80,
/* 750 */ 4, 130, 80, 4, 129, 68, 2, 80, 4, 94,
/* 760 */ 2, 129, 66, 6, 80, 4, 92, 6, 129, 67,
/* 770 */ 7, 80, 4, 90, 7, 129, 69, 7, 80, 4,
/* 780 */ 88, 7, 129, 71, 6, 80, 4, 87, 6, 129,
/* 790 */ 72, 20, 129, 74, 16, 129, 76, 12, 129, 62,
/* 800 */ 40, 131, 76, 12, 129, 74, 16, 129, 72, 20,
/* 810 */ 129, 71, 6, 80, 4, 87, 6, 129, 69, 7,
/* 820 */ 80, 4, 88, 7, 129, 67, 7, 80, 4, 90,
/* 830 */ 7, 129, 66, 6, 80, 4, 92, 6, 129, 68,
/* 840 */ 2, 80, 4, 94, 2, 129, 80, 4, 130, 193,
/* 850 */ 129, 60, 4, 139, 41, 42, 131, 60, 4, 139,
/* 860 */ 193, 130, 34, 6, 129, 32, 10, 129, 31, 12,
/* 870 */ 129, 30, 14, 129, 20, 2, 28, 16, 129, 22,
/* 880 */ 22, 129, 24, 19, 129, 27, 15, 129, 31, 9,
/* 890 */ 129, 194, 129, 60, 4, 152, 193, 130, 34, 6,
/* 900 */ 129, 32, 10, 129, 31, 12, 129, 30, 14, 131,
/* 910 */ 31, 12, 129, 32, 10, 129, 34, 6, 129, 194,
/* 920 */ 129, 30, 4, 129, 30, 7, 129, 30, 10, 129,
/* 930 */ 33, 10, 129, 36, 10, 129, 39, 10, 129, 42,
/* 940 */ 10, 129, 45, 10, 129, 48, 10, 129, 51, 10,
/* 950 */ 129, 54, 10, 129, 57, 10, 129, 60, 10, 129,
/* 960 */ 63, 10, 129, 66, 10, 129, 69, 10, 129, 72,
/* 970 */ 10, 129, 75, 10, 129, 78, 10, 129, 81, 10,
/* 980 */ 129, 84, 10, 129, 87, 10, 129, 90, 10, 129,
/* 990 */ 93, 10, 129, 96, 10, 129, 99, 10, 129, 102,
/* 1000 */ 10, 129, 105, 10, 129, 108, 10, 129, 111, 10,
/* 1010 */ 129, 114, 7, 129, 117, 4, 129, 193, 129, 60,
/* 1020 */ 31, 129, 53, 45, 129, 49, 53, 129, 46, 59,
/* 1030 */ 129, 43, 65, 129, 41, 69, 129, 39, 73, 129,
/* 1040 */ 37, 77, 129, 36, 79, 129, 35, 15, 101, 15,
/* 1050 */ 129, 34, 11, 106, 11, 129, 33, 9, 109, 9,
/* 1060 */ 129, 32, 7, 112, 7, 129, 31, 6, 114, 6,
/* 1070 */ 129, 31, 5, 115, 5, 129, 30, 5, 116, 5,
/* 1080 */ 129, 30, 4, 117, 4, 132, 30, 5, 116, 5,
/* 1090 */ 129, 31, 5, 115, 5, 129, 31, 6, 114, 6,
/* 1100 */ 129, 32, 7, 112, 7, 129, 33, 9, 109, 9,
/* 1110 */ 129, 34, 11, 106, 11, 129, 35, 15, 101, 15,
/* 1120 */ 129, 36, 79, 129, 37, 77, 129, 39, 73, 129,
/* 1130 */ 41, 69, 129, 43, 65, 129, 46, 59, 129, 49,
/* 1140 */ 53, 129, 53, 45, 129, 60, 31, 129, 193, 129,
/* 1150 */ 30, 4, 129, 30, 4, 100, 1, 129, 30, 4,
/* 1160 */ 100, 3, 129, 30, 4, 100, 5, 129, 30, 76,
/* 1170 */ 129, 30, 78, 129, 30, 80, 129, 30, 82, 129,
/* 1180 */ 30, 83, 129, 30, 85, 129, 30, 87, 129, 30,
/* 1190 */ 89, 129, 30, 91, 129, 30, 4, 132, 193, 129,
/* 1200 */ 30, 3, 129, 30, 7, 129, 30, 10, 112, 1,
/* 1210 */ 129, 30, 13, 112, 2, 129, 30, 16, 112, 3,
/* 1220 */ 129, 30, 18, 111, 5, 129, 30, 21, 111, 6,
/* 1230 */ 129, 30, 23, 112, 6, 129, 30, 14, 47, 8,
/* 1240 */ 113, 6, 129, 30, 14, 49, 8, 114, 5, 129,
/* 1250 */ 30, 14, 51, 8, 115, 5, 129, 30, 14, 53,
/* 1260 */ 8, 116, 4, 129, 30, 14, 55, 8, 116, 5,
/* 1270 */ 129, 30, 14, 56, 9, 117, 4, 129, 30, 14,
/* 1280 */ 57, 9, 117, 4, 129, 30, 14, 58, 10, 117,
/* 1290 */ 4, 129, 30, 14, 59, 10, 117, 4, 129, 30,
/* 1300 */ 14, 60, 11, 117, 4, 129, 30, 14, 61, 11,
/* 1310 */ 116, 5, 129, 30, 14, 62, 11, 116, 5, 129,
/* 1320 */ 30, 14, 63, 12, 115, 6, 129, 30, 14, 64,
/* 1330 */ 13, 114, 7, 129, 30, 14, 65, 13, 113, 8,
/* 1340 */ 129, 30, 14, 65, 15, 111, 9, 129, 30, 14,
/* 1350 */ 66, 16, 109, 11, 129, 30, 14, 67, 17, 107,
/* 1360 */ 12, 129, 30, 14, 68, 20, 103, 16, 129, 30,
/* 1370 */ 14, 69, 49, 129, 30, 14, 70, 47, 129, 30,
/* 1380 */ 14, 71, 45, 129, 30, 14, 73, 42, 129, 30,
/* 1390 */ 15, 75, 38, 129, 33, 12, 77, 34, 129, 36,
/* 1400 */ 10, 79, 30, 129, 40, 6, 82, 23, 129, 44,
/* 1410 */ 3, 86, 15, 129, 47, 1, 129, 193, 129, 129,
/* 1420 */ 38, 3, 129, 37, 5, 111, 1, 129, 36, 7,
/* 1430 */ 111, 2, 129, 35, 9, 110, 5, 129, 34, 8,
/* 1440 */ 110, 6, 129, 33, 7, 109, 8, 129, 32, 7,
/* 1450 */ 110, 8, 129, 32, 6, 112, 7, 129, 31, 6,
/* 1460 */ 113, 6, 129, 31, 5, 114, 6, 129, 30, 5,
/* 1470 */ 115, 5, 129, 30, 5, 116, 4, 129, 30, 4,
/* 1480 */ 117, 4, 131, 30, 4, 117, 4, 129, 30, 4,
/* 1490 */ 79, 2, 117, 4, 129, 30, 5, 78, 4, 117,
/* 1500 */ 4, 129, 30, 5, 77, 6, 116, 5, 129, 30,
/* 1510 */ 6, 76, 8, 115, 6, 129, 30, 7, 75, 11,
/* 1520 */ 114, 6, 129, 30, 8, 73, 15, 112, 8, 129,
/* 1530 */ 31, 9, 71, 19, 110, 9, 129, 31, 11, 68,
/* 1540 */ 26, 107, 12, 129, 32, 13, 65, 14, 82, 36,
/* 1550 */ 129, 32, 16, 61, 17, 83, 34, 129, 33, 44,
/* 1560 */ 84, 32, 129, 34, 42, 85, 30, 129, 35, 40,
/* 1570 */ 87, 27, 129, 36, 38, 89, 23, 129, 38, 34,
/* 1580 */ 92, 17, 129, 40, 30, 95, 11, 129, 42, 26,
/* 1590 */ 129, 45, 20, 129, 49, 11, 129, 193, 129, 49,
/* 1600 */ 1, 129, 49, 4, 129, 49, 6, 129, 49, 8,
/* 1610 */ 129, 49, 10, 129, 49, 12, 129, 49, 14, 129,
/* 1620 */ 49, 17, 129, 49, 19, 129, 49, 21, 129, 49,
/* 1630 */ 23, 129, 49, 14, 65, 9, 129, 49, 14, 67,
/* 1640 */ 9, 129, 49, 14, 69, 9, 129, 49, 14, 71,
/* 1650 */ 10, 129, 49, 14, 74, 9, 129, 49, 14, 76,
/* 1660 */ 9, 129, 49, 14, 78, 9, 129, 49, 14, 80,
/* 1670 */ 9, 129, 49, 14, 82, 9, 129, 49, 14, 84,
/* 1680 */ 9, 129, 30, 4, 49, 14, 86, 10, 129, 30,
/* 1690 */ 4, 49, 14, 89, 9, 129, 30, 4, 49, 14,
/* 1700 */ 91, 9, 129, 30, 4, 49, 14, 93, 9, 129,
/* 1710 */ 30, 74, 129, 30, 76, 129, 30, 78, 129, 30,
/* 1720 */ 81, 129, 30, 83, 129, 30, 85, 129, 30, 87,
/* 1730 */ 129, 30, 89, 129, 30, 91, 129, 30, 4, 49,
/* 1740 */ 14, 132, 193, 129, 37, 1, 129, 36, 3, 77,
/* 1750 */ 3, 129, 35, 5, 78, 11, 129, 34, 7, 78,
/* 1760 */ 21, 129, 33, 7, 79, 29, 129, 32, 7, 79,
/* 1770 */ 38, 129, 32, 6, 80, 4, 92, 29, 129, 31,
/* 1780 */ 6, 80, 5, 102, 19, 129, 31, 5, 80, 6,
/* 1790 */ 107, 14, 129, 31, 4, 81, 5, 107, 14, 129,
/* 1800 */ 30, 5, 81, 6, 107, 14, 129, 30, 4, 81,
/* 1810 */ 6, 107, 14, 130, 30, 4, 81, 7, 107, 14,
/* 1820 */ 129, 30, 4, 80, 8, 107, 14, 130, 30, 5,
/* 1830 */ 80, 8, 107, 14, 129, 30, 5, 79, 9, 107,
/* 1840 */ 14, 129, 31, 5, 79, 9, 107, 14, 129, 31,
/* 1850 */ 6, 78, 10, 107, 14, 129, 32, 6, 76, 11,
/* 1860 */ 107, 14, 129, 32, 8, 74, 13, 107, 14, 129,
/* 1870 */ 33, 10, 71, 16, 107, 14, 129, 33, 15, 67,
/* 1880 */ 19, 107, 14, 129, 34, 51, 107, 14, 129, 35,
/* 1890 */ 49, 107, 14, 129, 36, 47, 107, 14, 129, 37,
/* 1900 */ 45, 107, 14, 129, 39, 41, 107, 14, 129, 41,
/* 1910 */ 37, 107, 14, 129, 44, 32, 107, 14, 129, 47,
/* 1920 */ 25, 111, 10, 129, 51, 16, 115, 6, 129, 119,
/* 1930 */ 2, 129, 193, 129, 56, 39, 129, 51, 49, 129,
/* 1940 */ 47, 57, 129, 44, 63, 129, 42, 67, 129, 40,
/* 1950 */ 71, 129, 38, 75, 129, 37, 77, 129, 35, 81,
/* 1960 */ 129, 34, 16, 74, 5, 101, 16, 129, 33, 11,
/* 1970 */ 76, 5, 107, 11, 129, 32, 9, 77, 5, 110,
/* 1980 */ 9, 129, 32, 7, 79, 4, 112, 7, 129, 31,
/* 1990 */ 6, 80, 4, 114, 6, 129, 31, 5, 81, 4,
/* 2000 */ 115, 5, 129, 30, 5, 82, 4, 116, 5, 129,
/* 2010 */ 30, 4, 82, 4, 116, 5, 129, 30, 4, 82,
/* 2020 */ 5, 117, 4, 131, 30, 5, 82, 5, 117, 4,
/* 2030 */ 129, 31, 5, 81, 6, 117, 4, 129, 31, 6,
/* 2040 */ 80, 7, 117, 4, 129, 32, 7, 79, 8, 117,
/* 2050 */ 4, 129, 32, 9, 77, 9, 116, 5, 129, 33,
/* 2060 */ 11, 75, 11, 116, 4, 129, 34, 16, 69, 16,
/* 2070 */ 115, 5, 129, 35, 49, 114, 5, 129, 37, 46,
/* 2080 */ 113, 5, 129, 38, 44, 112, 6, 129, 40, 41,
/* 2090 */ 112, 5, 129, 42, 37, 113, 3, 129, 44, 33,
/* 2100 */ 114, 1, 129, 47, 27, 129, 51, 17, 129, 193,
/* 2110 */ 129, 103, 2, 129, 103, 6, 129, 104, 9, 129,
/* 2120 */ 105, 12, 129, 106, 15, 129, 107, 14, 135, 30,
/* 2130 */ 10, 107, 14, 129, 30, 17, 107, 14, 129, 30,
/* 2140 */ 25, 107, 14, 129, 30, 31, 107, 14, 129, 30,
/* 2150 */ 37, 107, 14, 129, 30, 42, 107, 14, 129, 30,
/* 2160 */ 46, 107, 14, 129, 30, 50, 107, 14, 129, 30,
/* 2170 */ 54, 107, 14, 129, 30, 58, 107, 14, 129, 59,
/* 2180 */ 32, 107, 14, 129, 64, 30, 107, 14, 129, 74,
/* 2190 */ 23, 107, 14, 129, 81, 18, 107, 14, 129, 86,
/* 2200 */ 16, 107, 14, 129, 91, 14, 107, 14, 129, 96,
/* 2210 */ 25, 129, 100, 21, 129, 104, 17, 129, 107, 14,
/* 2220 */ 129, 111, 10, 129, 114, 7, 129, 117, 4, 129,
/* 2230 */ 120, 1, 129, 193, 129, 48, 13, 129, 44, 21,
/* 2240 */ 129, 42, 26, 129, 40, 30, 92, 12, 129, 38,
/* 2250 */ 34, 88, 20, 129, 36, 37, 86, 25, 129, 35,
/* 2260 */ 39, 84, 29, 129, 34, 13, 63, 12, 82, 33,
/* 2270 */ 129, 33, 11, 67, 9, 80, 36, 129, 32, 9,
/* 2280 */ 70, 7, 79, 38, 129, 31, 8, 72, 46, 129,
/* 2290 */ 30, 7, 74, 22, 108, 11, 129, 30, 6, 75,
/* 2300 */ 19, 111, 9, 129, 30, 5, 75, 17, 113, 7,
/* 2310 */ 129, 30, 5, 74, 16, 114, 6, 129, 30, 4,
/* 2320 */ 73, 16, 115, 6, 129, 30, 4, 72, 16, 116,
/* 2330 */ 5, 129, 30, 4, 72, 15, 117, 4, 129, 30,
/* 2340 */ 4, 71, 16, 117, 4, 129, 30, 5, 70, 16,
/* 2350 */ 117, 4, 129, 30, 5, 70, 15, 117, 4, 129,
/* 2360 */ 30, 6, 69, 15, 116, 5, 129, 30, 7, 68,
/* 2370 */ 17, 115, 5, 129, 30, 9, 67, 19, 114, 6,
/* 2380 */ 129, 30, 10, 65, 22, 113, 6, 129, 31, 12,
/* 2390 */ 63, 27, 110, 9, 129, 32, 14, 60, 21, 84,
/* 2400 */ 9, 106, 12, 129, 33, 47, 85, 32, 129, 34,
/* 2410 */ 45, 86, 30, 129, 35, 43, 88, 26, 129, 36,
/* 2420 */ 40, 90, 22, 129, 38, 36, 93, 17, 129, 40,
/* 2430 */ 32, 96, 10, 129, 42, 28, 129, 44, 23, 129,
/* 2440 */ 48, 15, 129, 193, 129, 83, 17, 129, 77, 27,
/* 2450 */ 129, 36, 1, 74, 33, 129, 35, 3, 72, 37,
/* 2460 */ 129, 34, 5, 70, 41, 129, 33, 6, 69, 44,
/* 2470 */ 129, 33, 5, 68, 46, 129, 32, 5, 67, 49,
/* 2480 */ 129, 31, 5, 66, 17, 101, 16, 129, 31, 5,
/* 2490 */ 66, 11, 108, 10, 129, 30, 4, 65, 9, 110,
/* 2500 */ 9, 129, 30, 4, 64, 8, 112, 7, 129, 30,
/* 2510 */ 4, 64, 7, 114, 6, 129, 30, 4, 64, 6,
/* 2520 */ 115, 5, 129, 30, 4, 64, 5, 116, 5, 129,
/* 2530 */ 30, 4, 64, 5, 117, 4, 131, 30, 4, 65,
/* 2540 */ 4, 117, 4, 129, 30, 5, 65, 4, 116, 5,
/* 2550 */ 129, 31, 5, 66, 4, 115, 5, 129, 31, 6,
/* 2560 */ 67, 4, 114, 6, 129, 32, 7, 68, 4, 112,
/* 2570 */ 7, 129, 32, 9, 69, 5, 110, 9, 129, 33,
/* 2580 */ 11, 70, 5, 107, 11, 129, 34, 16, 72, 5,
/* 2590 */ 101, 16, 129, 35, 81, 129, 37, 77, 129, 38,
/* 2600 */ 75, 129, 40, 71, 129, 42, 67, 129, 44, 63,
/* 2610 */ 129, 47, 57, 129, 51, 49, 129, 56, 39, 129,
/* 2620 */ 193, 130, 34, 6, 74, 6, 129, 32, 10, 72,
/* 2630 */ 10, 129, 31, 12, 71, 12, 129, 30, 14, 70,
/* 2640 */ 14, 131, 31, 12, 71, 12, 129, 32, 10, 72,
/* 2650 */ 10, 129, 34, 6, 74, 6, 129, 194, 130, 34,
/* 2660 */ 6, 74, 6, 129, 32, 10, 72, 10, 129, 31,
/* 2670 */ 12, 71, 12, 129, 30, 14, 70, 14, 129, 20,
/* 2680 */ 2, 28, 16, 70, 14, 129, 22, 22, 70, 14,
/* 2690 */ 129, 24, 19, 71, 12, 129, 27, 15, 72, 10,
/* 2700 */ 129, 31, 9, 74, 6, 129, 194, 129, 53, 4,
/* 2710 */ 63, 4, 152, 193, 130, 99, 7, 129, 97, 13,
/* 2720 */ 129, 96, 16, 129, 96, 18, 129, 96, 19, 129,
/* 2730 */ 97, 19, 129, 99, 6, 110, 7, 129, 112, 6,
/* 2740 */ 129, 114, 5, 129, 34, 6, 57, 5, 115, 4,
/* 2750 */ 129, 32, 10, 54, 12, 116, 4, 129, 31, 12,
/* 2760 */ 53, 16, 117, 3, 129, 30, 14, 52, 20, 117,
/* 2770 */ 4, 129, 30, 14, 52, 23, 117, 4, 129, 30,
/* 2780 */ 14, 52, 25, 117, 4, 129, 31, 12, 52, 27,
/* 2790 */ 117, 4, 129, 32, 10, 53, 10, 70, 11, 116,
/* 2800 */ 5, 129, 34, 6, 55, 5, 73, 10, 115, 6,
/* 2810 */ 129, 74, 11, 114, 7, 129, 75, 12, 112, 9,
/* 2820 */ 129, 76, 13, 110, 10, 129, 77, 16, 106, 14,
/* 2830 */ 129, 78, 41, 129, 80, 38, 129, 81, 36, 129,
/* 2840 */ 82, 34, 129, 84, 30, 129, 86, 26, 129, 88,
/* 2850 */ 22, 129, 92, 14, 129, 194, 129, 55, 15, 129,
/* 2860 */ 50, 25, 129, 47, 32, 129, 45, 13, 70, 12,
/* 2870 */ 129, 43, 9, 76, 10, 129, 42, 6, 79, 8,
/* 2880 */ 129, 41, 5, 81, 7, 129, 40, 4, 84, 6,
/* 2890 */ 129, 39, 4, 59, 12, 85, 6, 129, 38, 4,
/* 2900 */ 55, 19, 87, 5, 129, 37, 4, 53, 23, 88,
/* 2910 */ 4, 129, 36, 4, 51, 8, 71, 6, 89, 4,
/* 2920 */ 129, 36, 4, 51, 6, 73, 4, 89, 4, 129,
/* 2930 */ 36, 4, 50, 6, 74, 4, 90, 3, 129, 35,
/* 2940 */ 4, 50, 5, 75, 3, 90, 4, 129, 35, 4,
/* 2950 */ 50, 4, 75, 4, 90, 4, 131, 35, 4, 50,
/* 2960 */ 5, 75, 4, 90, 4, 129, 36, 4, 51, 5,
/* 2970 */ 75, 4, 90, 4, 129, 36, 4, 51, 6, 75,
/* 2980 */ 4, 90, 4, 129, 36, 4, 53, 26, 90, 4,
/* 2990 */ 129, 37, 4, 54, 25, 90, 4, 129, 37, 4,
/* 3000 */ 52, 27, 90, 3, 129, 38, 4, 52, 4, 89,
/* 3010 */ 4, 129, 39, 4, 51, 4, 88, 4, 129, 40,
/* 3020 */ 4, 50, 4, 87, 5, 129, 41, 4, 50, 4,
/* 3030 */ 86, 5, 129, 42, 4, 50, 4, 85, 5, 129,
/* 3040 */ 43, 3, 50, 4, 83, 6, 129, 44, 2, 51,
/* 3050 */ 5, 80, 7, 129, 46, 1, 52, 6, 76, 9,
/* 3060 */ 129, 54, 28, 129, 56, 23, 129, 60, 16, 129,
/* 3070 */ 193, 129, 30, 4, 132, 30, 5, 129, 30, 8,
/* 3080 */ 129, 30, 12, 129, 30, 16, 129, 30, 4, 37,
/* 3090 */ 12, 129, 30, 4, 41, 12, 129, 30, 4, 44,
/* 3100 */ 13, 129, 30, 4, 48, 13, 129, 52, 13, 129,
/* 3110 */ 56, 12, 129, 58, 14, 129, 58, 4, 64, 12,
/* 3120 */ 129, 58, 4, 68, 12, 129, 58, 4, 72, 12,
/* 3130 */ 129, 58, 4, 75, 13, 129, 58, 4, 79, 13,
/* 3140 */ 129, 58, 4, 83, 13, 129, 58, 4, 87, 13,
/* 3150 */ 129, 58, 4, 91, 12, 129, 58, 4, 95, 12,
/* 3160 */ 129, 58, 4, 96, 15, 129, 58, 4, 93, 22,
/* 3170 */ 129, 58, 4, 89, 30, 129, 58, 4, 85, 36,
/* 3180 */ 129, 58, 4, 81, 38, 129, 58, 4, 77, 38,
/* 3190 */ 129, 58, 4, 73, 38, 129, 58, 4, 70, 37,
/* 3200 */ 129, 58, 4, 66, 37, 129, 58, 41, 129, 58,
/* 3210 */ 37, 129, 54, 38, 129, 30, 4, 50, 38, 129,
/* 3220 */ 30, 4, 46, 38, 129, 30, 4, 42, 38, 129,
/* 3230 */ 30, 4, 38, 39, 129, 30, 43, 129, 30, 39,
/* 3240 */ 129, 30, 35, 129, 30, 31, 129, 30, 27, 129,
/* 3250 */ 30, 24, 129, 30, 20, 129, 30, 16, 129, 30,
/* 3260 */ 12, 129, 30, 8, 129, 30, 5, 129, 30, 4,
/* 3270 */ 132, 193, 129, 30, 4, 117, 4, 132, 30, 91,
/* 3280 */ 137, 30, 4, 80, 4, 117, 4, 138, 30, 4,
/* 3290 */ 80, 5, 116, 5, 129, 30, 5, 79, 6, 116,
/* 3300 */ 5, 130, 30, 6, 78, 8, 115, 6, 129, 31,
/* 3310 */ 6, 77, 9, 115, 6, 129, 31, 7, 76, 11,
/* 3320 */ 114, 6, 129, 31, 8, 75, 14, 112, 8, 129,
/* 3330 */ 32, 8, 74, 16, 111, 9, 129, 32, 9, 73,
/* 3340 */ 19, 109, 10, 129, 33, 10, 71, 24, 106, 13,
/* 3350 */ 129, 33, 13, 68, 12, 83, 35, 129, 34, 16,
/* 3360 */ 64, 15, 84, 33, 129, 35, 43, 85, 31, 129,
/* 3370 */ 36, 41, 86, 29, 129, 37, 39, 88, 25, 129,
/* 3380 */ 38, 37, 90, 21, 129, 40, 33, 93, 15, 129,
/* 3390 */ 42, 29, 96, 9, 129, 45, 24, 129, 49, 16,
/* 3400 */ 129, 193, 129, 63, 25, 129, 57, 37, 129, 53,
/* 3410 */ 45, 129, 50, 51, 129, 47, 57, 129, 45, 61,
/* 3420 */ 129, 43, 65, 129, 41, 69, 129, 39, 73, 129,
/* 3430 */ 38, 25, 92, 21, 129, 36, 21, 97, 18, 129,
/* 3440 */ 35, 18, 102, 14, 129, 34, 16, 106, 11, 129,
/* 3450 */ 33, 14, 108, 10, 129, 32, 12, 111, 8, 129,
/* 3460 */ 32, 10, 113, 6, 129, 31, 10, 114, 6, 129,
/* 3470 */ 31, 8, 115, 5, 129, 30, 8, 116, 5, 129,
/* 3480 */ 30, 7, 116, 5, 129, 30, 6, 117, 4, 130,
/* 3490 */ 30, 5, 117, 4, 131, 31, 4, 116, 5, 129,
/* 3500 */ 32, 4, 116, 4, 129, 32, 5, 115, 5, 129,
/* 3510 */ 33, 4, 114, 5, 129, 34, 4, 112, 6, 129,
/* 3520 */ 35, 4, 110, 7, 129, 37, 4, 107, 9, 129,
/* 3530 */ 39, 4, 103, 12, 129, 41, 4, 103, 18, 129,
/* 3540 */ 43, 4, 103, 18, 129, 45, 5, 103, 18, 129,
/* 3550 */ 48, 5, 103, 18, 129, 51, 1, 129, 193, 129,
/* 3560 */ 30, 4, 117, 4, 132, 30, 91, 137, 30, 4,
/* 3570 */ 117, 4, 135, 30, 5, 116, 5, 130, 30, 6,
/* 3580 */ 115, 6, 130, 31, 6, 114, 6, 129, 31, 7,
/* 3590 */ 113, 7, 129, 32, 7, 112, 7, 129, 32, 8,
/* 3600 */ 111, 8, 129, 33, 9, 109, 9, 129, 33, 12,
/* 3610 */ 106, 12, 129, 34, 13, 104, 13, 129, 35, 15,
/* 3620 */ 101, 15, 129, 36, 19, 96, 19, 129, 37, 24,
/* 3630 */ 90, 24, 129, 39, 73, 129, 40, 71, 129, 42,
/* 3640 */ 67, 129, 44, 63, 129, 46, 59, 129, 49, 53,
/* 3650 */ 129, 52, 47, 129, 56, 39, 129, 61, 29, 129,
/* 3660 */ 193, 129, 30, 4, 117, 4, 132, 30, 91, 137,
/* 3670 */ 30, 4, 80, 4, 117, 4, 140, 30, 4, 79,
/* 3680 */ 6, 117, 4, 129, 30, 4, 77, 10, 117, 4,
/* 3690 */ 129, 30, 4, 73, 18, 117, 4, 132, 30, 4,
/* 3700 */ 117, 4, 130, 30, 5, 116, 5, 130, 30, 7,
/* 3710 */ 114, 7, 129, 30, 8, 113, 8, 129, 30, 11,
/* 3720 */ 110, 11, 129, 30, 18, 103, 18, 132, 193, 129,
/* 3730 */ 30, 4, 117, 4, 132, 30, 91, 137, 30, 4,
/* 3740 */ 80, 4, 117, 4, 132, 80, 4, 117, 4, 136,
/* 3750 */ 79, 6, 117, 4, 129, 77, 10, 117, 4, 129,
/* 3760 */ 73, 18, 117, 4, 132, 117, 4, 130, 116, 5,
/* 3770 */ 130, 114, 7, 129, 113, 8, 129, 110, 11, 129,
/* 3780 */ 103, 18, 132, 193, 129, 63, 25, 129, 57, 37,
/* 3790 */ 129, 53, 45, 129, 50, 51, 129, 47, 57, 129,
/* 3800 */ 45, 61, 129, 43, 65, 129, 41, 69, 129, 39,
/* 3810 */ 73, 129, 38, 25, 92, 21, 129, 36, 21, 97,
/* 3820 */ 18, 129, 35, 18, 102, 14, 129, 34, 16, 106,
/* 3830 */ 11, 129, 33, 14, 108, 10, 129, 32, 12, 111,
/* 3840 */ 8, 129, 32, 10, 113, 6, 129, 31, 10, 114,
/* 3850 */ 6, 129, 31, 8, 115, 5, 129, 30, 8, 116,
/* 3860 */ 5, 129, 30, 7, 116, 5, 129, 30, 6, 117,
/* 3870 */ 4, 130, 30, 5, 117, 4, 131, 30, 5, 75,
/* 3880 */ 4, 116, 5, 129, 31, 5, 75, 4, 116, 4,
/* 3890 */ 129, 31, 6, 75, 4, 115, 5, 129, 32, 7,
/* 3900 */ 75, 4, 114, 5, 129, 32, 9, 75, 4, 112,
/* 3910 */ 6, 129, 33, 11, 75, 4, 110, 7, 129, 34,
/* 3920 */ 15, 75, 4, 107, 9, 129, 35, 44, 103, 12,
/* 3930 */ 129, 36, 43, 103, 18, 129, 38, 41, 103, 18,
/* 3940 */ 129, 39, 40, 103, 18, 129, 41, 38, 103, 18,
/* 3950 */ 129, 44, 35, 129, 48, 31, 129, 52, 27, 129,
/* 3960 */ 61, 18, 129, 193, 129, 30, 4, 117, 4, 132,
/* 3970 */ 30, 91, 137, 30, 4, 80, 4, 117, 4, 132,
/* 3980 */ 80, 4, 140, 30, 4, 80, 4, 117, 4, 132,
/* 3990 */ 30, 91, 137, 30, 4, 117, 4, 132, 193, 129,
/* 4000 */ 30, 4, 117, 4, 132, 30, 91, 137, 30, 4,
/* 4010 */ 117, 4, 132, 193, 129, 44, 7, 129, 40, 13,
/* 4020 */ 129, 37, 17, 129, 35, 20, 129, 34, 22, 129,
/* 4030 */ 33, 23, 129, 32, 24, 129, 32, 23, 129, 31,
/* 4040 */ 6, 41, 13, 129, 31, 5, 42, 11, 129, 30,
/* 4050 */ 5, 44, 7, 129, 30, 4, 132, 30, 5, 130,
/* 4060 */ 31, 5, 129, 31, 6, 117, 4, 129, 31, 8,
/* 4070 */ 117, 4, 129, 32, 9, 117, 4, 129, 33, 11,
/* 4080 */ 117, 4, 129, 34, 87, 129, 35, 86, 129, 36,
/* 4090 */ 85, 129, 37, 84, 129, 38, 83, 129, 40, 81,
/* 4100 */ 129, 42, 79, 129, 45, 76, 129, 50, 71, 129,
/* 4110 */ 117, 4, 132, 193, 129, 30, 4, 117, 4, 132,
/* 4120 */ 30, 91, 137, 30, 4, 76, 8, 117, 4, 129,
/* 4130 */ 30, 4, 73, 13, 117, 4, 129, 30, 4, 70,
/* 4140 */ 18, 117, 4, 129, 30, 4, 67, 23, 117, 4,
/* 4150 */ 129, 65, 26, 129, 62, 31, 129, 59, 35, 129,
/* 4160 */ 56, 29, 89, 7, 129, 53, 29, 91, 7, 129,
/* 4170 */ 50, 29, 93, 7, 129, 47, 29, 95, 6, 129,
/* 4180 */ 30, 4, 45, 29, 96, 7, 129, 30, 4, 42,
/* 4190 */ 29, 98, 7, 129, 30, 4, 39, 30, 100, 6,
/* 4200 */ 129, 30, 4, 36, 30, 101, 7, 129, 30, 33,
/* 4210 */ 103, 7, 117, 4, 129, 30, 30, 105, 6, 117,
/* 4220 */ 4, 129, 30, 27, 106, 7, 117, 4, 129, 30,
/* 4230 */ 25, 108, 7, 117, 4, 129, 30, 22, 110, 11,
/* 4240 */ 129, 30, 19, 111, 10, 129, 30, 16, 113, 8,
/* 4250 */ 129, 30, 13, 115, 6, 129, 30, 11, 116, 5,
/* 4260 */ 129, 30, 8, 117, 4, 129, 30, 5, 117, 4,
/* 4270 */ 129, 30, 4, 117, 4, 130, 30, 4, 130, 193,
/* 4280 */ 129, 30, 4, 117, 4, 132, 30, 91, 137, 30,
/* 4290 */ 4, 117, 4, 132, 30, 4, 144, 30, 5, 130,
/* 4300 */ 30, 7, 129, 30, 8, 129, 30, 11, 129, 30,
/* 4310 */ 18, 132, 193, 129, 30, 4, 117, 4, 132, 30,
/* 4320 */ 91, 132, 30, 4, 103, 18, 129, 30, 4, 97,
/* 4330 */ 24, 129, 30, 4, 92, 29, 129, 30, 4, 87,
/* 4340 */ 34, 129, 81, 40, 129, 76, 45, 129, 70, 49,
/* 4350 */ 129, 65, 49, 129, 60, 49, 129, 55, 49, 129,
/* 4360 */ 50, 48, 129, 44, 49, 129, 39, 48, 129, 33,
/* 4370 */ 49, 129, 30, 47, 129, 34, 37, 129, 40, 26,
/* 4380 */ 129, 46, 19, 129, 52, 19, 129, 58, 19, 129,
/* 4390 */ 64, 19, 129, 70, 19, 129, 76, 19, 129, 82,
/* 4400 */ 19, 129, 30, 4, 88, 18, 129, 30, 4, 94,
/* 4410 */ 18, 129, 30, 4, 100, 18, 129, 30, 4, 106,
/* 4420 */ 15, 129, 30, 91, 137, 30, 4, 117, 4, 132,
/* 4430 */ 193, 129, 30, 4, 117, 4, 132, 30, 91, 132,
/* 4440 */ 30, 4, 107, 14, 129, 30, 4, 104, 17, 129,
/* 4450 */ 30, 4, 101, 20, 129, 30, 4, 99, 22, 129,
/* 4460 */ 96, 25, 129, 93, 28, 129, 91, 28, 129, 88,
/* 4470 */ 29, 129, 85, 29, 129, 82, 29, 129, 79, 29,
/* 4480 */ 129, 76, 29, 129, 74, 29, 129, 71, 29, 129,
/* 4490 */ 68, 29, 129, 65, 29, 129, 62, 29, 129, 60,
/* 4500 */ 29, 129, 57, 29, 129, 54, 29, 129, 51, 29,
/* 4510 */ 129, 49, 28, 129, 46, 29, 129, 43, 29, 129,
/* 4520 */ 40, 29, 117, 4, 129, 37, 29, 117, 4, 129,
/* 4530 */ 35, 29, 117, 4, 129, 32, 29, 117, 4, 129,
/* 4540 */ 30, 91, 132, 117, 4, 132, 193, 129, 63, 25,
/* 4550 */ 129, 57, 37, 129, 53, 45, 129, 50, 51, 129,
/* 4560 */ 47, 57, 129, 45, 61, 129, 43, 65, 129, 41,
/* 4570 */ 69, 129, 39, 73, 129, 38, 21, 92, 21, 129,
/* 4580 */ 36, 18, 97, 18, 129, 35, 14, 102, 14, 129,
/* 4590 */ 34, 11, 106, 11, 129, 33, 10, 108, 10, 129,
/* 4600 */ 32, 8, 111, 8, 129, 32, 6, 113, 6, 129,
/* 4610 */ 31, 6, 114, 6, 129, 31, 5, 115, 5, 129,
/* 4620 */ 30, 5, 116, 5, 130, 30, 4, 117, 4, 132,
/* 4630 */ 30, 5, 116, 5, 130, 31, 5, 115, 5, 129,
/* 4640 */ 31, 6, 114, 6, 129, 32, 6, 113, 6, 129,
/* 4650 */ 32, 8, 111, 8, 129, 33, 10, 108, 10, 129,
/* 4660 */ 34, 11, 106, 11, 129, 35, 14, 102, 14, 129,
/* 4670 */ 36, 18, 97, 18, 129, 38, 21, 92, 21, 129,
/* 4680 */ 39, 73, 129, 41, 69, 129, 43, 65, 129, 45,
/* 4690 */ 61, 129, 47, 57, 129, 50, 51, 129, 53, 45,
/* 4700 */ 129, 57, 37, 129, 63, 25, 129, 193, 129, 30,
/* 4710 */ 4, 117, 4, 132, 30, 91, 137, 30, 4, 80,
/* 4720 */ 4, 117, 4, 132, 80, 4, 117, 4, 134, 80,
/* 4730 */ 5, 116, 5, 131, 80, 6, 115, 6, 130, 81,
/* 4740 */ 6, 114, 6, 129, 81, 8, 112, 8, 129, 81,
/* 4750 */ 9, 111, 9, 129, 82, 10, 109, 10, 129, 82,
/* 4760 */ 13, 106, 13, 129, 83, 35, 129, 84, 33, 129,
/* 4770 */ 85, 31, 129, 86, 29, 129, 88, 25, 129, 90,
/* 4780 */ 21, 129, 93, 15, 129, 96, 9, 129, 193, 129,
/* 4790 */ 63, 25, 129, 57, 37, 129, 53, 45, 129, 50,
/* 4800 */ 51, 129, 47, 57, 129, 45, 61, 129, 43, 65,
/* 4810 */ 129, 41, 69, 129, 39, 73, 129, 38, 21, 92,
/* 4820 */ 21, 129, 36, 18, 97, 18, 129, 35, 14, 102,
/* 4830 */ 14, 129, 34, 11, 106, 11, 129, 33, 10, 108,
/* 4840 */ 10, 129, 32, 8, 111, 8, 129, 32, 6, 113,
/* 4850 */ 6, 129, 31, 6, 114, 6, 129, 31, 5, 115,
/* 4860 */ 5, 129, 30, 5, 116, 5, 130, 30, 4, 39,
/* 4870 */ 2, 117, 4, 129, 30, 4, 40, 4, 117, 4,
/* 4880 */ 129, 30, 4, 41, 5, 117, 4, 129, 30, 4,
/* 4890 */ 41, 6, 117, 4, 129, 30, 5, 40, 8, 116,
/* 4900 */ 5, 129, 30, 5, 39, 10, 116, 5, 129, 31,
/* 4910 */ 5, 38, 11, 115, 5, 129, 31, 18, 114, 6,
/* 4920 */ 129, 32, 17, 113, 6, 129, 32, 16, 111, 8,
/* 4930 */ 129, 33, 15, 108, 10, 129, 33, 14, 106, 11,
/* 4940 */ 129, 32, 17, 102, 14, 129, 31, 23, 97, 18,
/* 4950 */ 129, 31, 28, 92, 21, 129, 30, 82, 129, 30,
/* 4960 */ 80, 129, 30, 11, 43, 65, 129, 30, 10, 45,
/* 4970 */ 61, 129, 31, 8, 47, 57, 129, 32, 6, 50,
/* 4980 */ 51, 129, 33, 5, 53, 45, 129, 35, 4, 57,
/* 4990 */ 37, 129, 38, 2, 63, 25, 129, 193, 129, 30,
/* 5000 */ 4, 117, 4, 132, 30, 91, 137, 30, 4, 76,
/* 5010 */ 8, 117, 4, 129, 30, 4, 73, 11, 117, 4,
/* 5020 */ 129, 30, 4, 70, 14, 117, 4, 129, 30, 4,
/* 5030 */ 67, 17, 117, 4, 129, 65, 19, 117, 4, 129,
/* 5040 */ 62, 22, 117, 4, 129, 59, 25, 117, 4, 129,
/* 5050 */ 56, 28, 117, 4, 129, 53, 31, 117, 4, 129,
/* 5060 */ 50, 34, 117, 4, 129, 47, 29, 80, 5, 116,
/* 5070 */ 5, 129, 30, 4, 45, 29, 80, 5, 116, 5,
/* 5080 */ 129, 30, 4, 42, 29, 80, 5, 116, 5, 129,
/* 5090 */ 30, 4, 39, 30, 80, 6, 115, 6, 129, 30,
/* 5100 */ 4, 36, 30, 80, 6, 115, 6, 129, 30, 33,
/* 5110 */ 81, 6, 114, 6, 129, 30, 30, 81, 8, 112,
/* 5120 */ 8, 129, 30, 27, 81, 9, 111, 9, 129, 30,
/* 5130 */ 25, 82, 10, 109, 10, 129, 30, 22, 82, 13,
/* 5140 */ 106, 13, 129, 30, 19, 83, 35, 129, 30, 16,
/* 5150 */ 84, 33, 129, 30, 13, 85, 31, 129, 30, 11,
/* 5160 */ 86, 29, 129, 30, 8, 88, 25, 129, 30, 5,
/* 5170 */ 90, 21, 129, 30, 4, 93, 15, 129, 30, 4,
/* 5180 */ 96, 9, 129, 30, 4, 130, 193, 129, 30, 18,
/* 5190 */ 130, 30, 18, 89, 15, 129, 30, 18, 85, 23,
/* 5200 */ 129, 34, 11, 83, 27, 129, 34, 9, 81, 31,
/* 5210 */ 129, 33, 8, 79, 35, 129, 33, 6, 78, 16,
/* 5220 */ 106, 9, 129, 32, 6, 77, 15, 109, 7, 129,
/* 5230 */ 32, 5, 76, 14, 111, 6, 129, 31, 5, 75,
/* 5240 */ 14, 113, 5, 129, 31, 4, 74, 15, 114, 5,
/* 5250 */ 129, 31, 4, 74, 14, 115, 4, 129, 30, 4,
/* 5260 */ 73, 15, 116, 4, 129, 30, 4, 73, 14, 116,
/* 5270 */ 4, 129, 30, 4, 73, 14, 117, 4, 129, 30,
/* 5280 */ 4, 72, 15, 117, 4, 130, 30, 4, 71, 15,
/* 5290 */ 117, 4, 130, 30, 4, 70, 15, 117, 4, 129,
/* 5300 */ 30, 5, 70, 15, 117, 4, 129, 30, 5, 69,
/* 5310 */ 15, 116, 5, 129, 30, 6, 68, 16, 115, 5,
/* 5320 */ 129, 31, 6, 67, 16, 114, 6, 129, 31, 7,
/* 5330 */ 66, 17, 113, 6, 129, 32, 7, 64, 18, 111,
/* 5340 */ 8, 129, 32, 8, 62, 19, 109, 9, 129, 33,
/* 5350 */ 9, 60, 20, 107, 10, 129, 34, 11, 57, 22,
/* 5360 */ 103, 13, 129, 35, 43, 103, 18, 129, 36, 41,
/* 5370 */ 103, 18, 129, 38, 38, 103, 18, 129, 39, 35,
/* 5380 */ 103, 18, 129, 41, 31, 129, 43, 27, 129, 46,
/* 5390 */ 22, 129, 49, 14, 129, 193, 129, 103, 18, 132,
/* 5400 */ 110, 11, 129, 113, 8, 129, 114, 7, 129, 116,
/* 5410 */ 5, 130, 117, 4, 132, 30, 4, 117, 4, 132,
/* 5420 */ 30, 91, 137, 30, 4, 117, 4, 132, 117, 4,
/* 5430 */ 132, 116, 5, 130, 114, 7, 129, 113, 8, 129,
/* 5440 */ 110, 11, 129, 103, 18, 132, 193, 129, 117, 4,
/* 5450 */ 132, 56, 65, 129, 50, 71, 129, 46, 75, 129,
/* 5460 */ 44, 77, 129, 42, 79, 129, 40, 81, 129, 38,
/* 5470 */ 83, 129, 36, 85, 129, 35, 86, 129, 34, 20,
/* 5480 */ 117, 4, 129, 33, 17, 117, 4, 129, 32, 15,
/* 5490 */ 117, 4, 129, 32, 13, 117, 4, 129, 31, 12,
/* 5500 */ 129, 31, 10, 129, 31, 9, 129, 30, 9, 129,
/* 5510 */ 30, 8, 130, 30, 7, 132, 31, 6, 130, 31,
/* 5520 */ 7, 129, 32, 6, 129, 32, 7, 129, 33, 7,
/* 5530 */ 129, 34, 7, 129, 35, 8, 129, 36, 9, 117,
/* 5540 */ 4, 129, 38, 9, 117, 4, 129, 40, 10, 117,
/* 5550 */ 4, 129, 42, 12, 117, 4, 129, 44, 77, 129,
/* 5560 */ 46, 75, 129, 50, 71, 129, 56, 43, 100, 21,
/* 5570 */ 129, 117, 4, 132, 193, 129, 117, 4, 132, 115,
/* 5580 */ 6, 129, 110, 11, 129, 105, 16, 129, 101, 20,
/* 5590 */ 129, 96, 25, 129, 92, 29, 129, 87, 34, 129,
/* 5600 */ 83, 38, 129, 78, 43, 129, 74, 47, 129, 70,
/* 5610 */ 42, 117, 4, 129, 65, 42, 117, 4, 129, 60,
/* 5620 */ 43, 117, 4, 129, 56, 42, 129, 51, 42, 129,
/* 5630 */ 46, 43, 129, 42, 43, 129, 37, 44, 129, 33,
/* 5640 */ 43, 129, 30, 42, 129, 33, 34, 129, 38, 25,
/* 5650 */ 129, 42, 16, 129, 47, 15, 129, 52, 15, 129,
/* 5660 */ 57, 15, 129, 61, 16, 129, 66, 16, 129, 71,
/* 5670 */ 16, 129, 76, 16, 129, 80, 16, 129, 85, 16,
/* 5680 */ 117, 4, 129, 90, 16, 117, 4, 129, 95, 16,
/* 5690 */ 117, 4, 129, 100, 21, 129, 105, 16, 129, 110,
/* 5700 */ 11, 129, 114, 7, 129, 117, 4, 132, 193, 129,
/* 5710 */ 117, 4, 132, 115, 6, 129, 110, 11, 129, 105,
/* 5720 */ 16, 129, 101, 20, 129, 96, 25, 129, 92, 29,
/* 5730 */ 129, 87, 34, 129, 83, 38, 129, 78, 43, 129,
/* 5740 */ 74, 47, 129, 70, 42, 117, 4, 129, 65, 42,
/* 5750 */ 117, 4, 129, 60, 43, 117, 4, 129, 56, 42,
/* 5760 */ 129, 51, 42, 129, 46, 43, 129, 42, 43, 129,
/* 5770 */ 37, 44, 129, 33, 43, 129, 30, 42, 129, 33,
/* 5780 */ 34, 129, 38, 25, 129, 42, 16, 129, 47, 15,
/* 5790 */ 129, 52, 15, 129, 57, 15, 129, 61, 16, 129,
/* 5800 */ 65, 17, 129, 60, 27, 129, 56, 36, 129, 51,
/* 5810 */ 42, 129, 46, 43, 129, 42, 43, 129, 37, 44,
/* 5820 */ 129, 33, 43, 129, 30, 42, 129, 33, 34, 129,
/* 5830 */ 38, 25, 129, 42, 16, 129, 47, 15, 129, 52,
/* 5840 */ 15, 129, 57, 15, 129, 61, 16, 129, 66, 16,
/* 5850 */ 129, 71, 16, 129, 76, 16, 129, 80, 16, 129,
/* 5860 */ 85, 16, 117, 4, 129, 90, 16, 117, 4, 129,
/* 5870 */ 95, 16, 117, 4, 129, 100, 21, 129, 105, 16,
/* 5880 */ 129, 110, 11, 129, 114, 7, 129, 117, 4, 132,
/* 5890 */ 193, 129, 30, 4, 117, 4, 132, 30, 4, 115,
/* 5900 */ 6, 129, 30, 4, 112, 9, 129, 30, 6, 109,
/* 5910 */ 12, 129, 30, 9, 106, 15, 129, 30, 11, 103,
/* 5920 */ 18, 129, 30, 14, 100, 21, 129, 30, 4, 38,
/* 5930 */ 9, 98, 23, 129, 30, 4, 40, 10, 95, 26,
/* 5940 */ 129, 30, 4, 43, 9, 92, 29, 129, 46, 9,
/* 5950 */ 89, 32, 129, 49, 8, 86, 28, 117, 4, 129,
/* 5960 */ 51, 9, 83, 28, 117, 4, 129, 54, 9, 80,
/* 5970 */ 28, 117, 4, 129, 57, 8, 77, 28, 117, 4,
/* 5980 */ 129, 59, 9, 74, 28, 129, 62, 37, 129, 64,
/* 5990 */ 33, 129, 66, 28, 129, 63, 28, 129, 60, 28,
/* 6000 */ 129, 57, 28, 129, 54, 33, 129, 51, 39, 129,
/* 6010 */ 48, 29, 83, 9, 129, 30, 4, 45, 29, 86,
/* 6020 */ 9, 129, 30, 4, 42, 29, 89, 9, 129, 30,
/* 6030 */ 4, 39, 29, 92, 8, 129, 30, 4, 36, 29,
/* 6040 */ 94, 9, 129, 30, 32, 97, 9, 129, 30, 29,
/* 6050 */ 100, 8, 117, 4, 129, 30, 26, 103, 8, 117,
/* 6060 */ 4, 129, 30, 23, 105, 9, 117, 4, 129, 30,
/* 6070 */ 20, 108, 13, 129, 30, 18, 111, 10, 129, 30,
/* 6080 */ 15, 113, 8, 129, 30, 12, 116, 5, 129, 30,
/* 6090 */ 9, 117, 4, 129, 30, 6, 117, 4, 129, 30,
/* 6100 */ 4, 117, 4, 132, 193, 129, 117, 4, 132, 114,
/* 6110 */ 7, 129, 111, 10, 129, 108, 13, 129, 105, 16,
/* 6120 */ 129, 102, 19, 129, 100, 21, 129, 96, 25, 129,
/* 6130 */ 93, 28, 129, 90, 31, 129, 87, 34, 129, 84,
/* 6140 */ 30, 117, 4, 129, 30, 4, 81, 30, 117, 4,
/* 6150 */ 129, 30, 4, 78, 30, 117, 4, 129, 30, 4,
/* 6160 */ 75, 30, 117, 4, 129, 30, 4, 72, 30, 129,
/* 6170 */ 30, 69, 129, 30, 66, 129, 30, 63, 129, 30,
/* 6180 */ 60, 129, 30, 57, 129, 30, 54, 129, 30, 51,
/* 6190 */ 129, 30, 48, 129, 30, 51, 129, 30, 4, 73,
/* 6200 */ 12, 129, 30, 4, 76, 12, 129, 30, 4, 80,
/* 6210 */ 12, 129, 30, 4, 83, 12, 129, 87, 12, 129,
/* 6220 */ 90, 12, 117, 4, 129, 94, 11, 117, 4, 129,
/* 6230 */ 97, 12, 117, 4, 129, 101, 12, 117, 4, 129,
/* 6240 */ 104, 17, 129, 108, 13, 129, 111, 10, 129, 115,
/* 6250 */ 6, 129, 117, 4, 134, 193, 129, 30, 1, 103,
/* 6260 */ 18, 129, 30, 4, 103, 18, 129, 30, 7, 103,
/* 6270 */ 18, 129, 30, 9, 103, 18, 129, 30, 12, 110,
/* 6280 */ 11, 129, 30, 15, 113, 8, 129, 30, 18, 114,
/* 6290 */ 7, 129, 30, 21, 116, 5, 129, 30, 24, 116,
/* 6300 */ 5, 129, 30, 27, 117, 4, 129, 30, 30, 117,
/* 6310 */ 4, 129, 30, 33, 117, 4, 129, 30, 4, 37,
/* 6320 */ 28, 117, 4, 129, 30, 4, 40, 28, 117, 4,
/* 6330 */ 129, 30, 4, 42, 29, 117, 4, 129, 30, 4,
/* 6340 */ 45, 29, 117, 4, 129, 30, 4, 48, 29, 117,
/* 6350 */ 4, 129, 30, 4, 51, 29, 117, 4, 129, 30,
/* 6360 */ 4, 54, 29, 117, 4, 129, 30, 4, 57, 29,
/* 6370 */ 117, 4, 129, 30, 4, 59, 30, 117, 4, 129,
/* 6380 */ 30, 4, 62, 30, 117, 4, 129, 30, 4, 65,
/* 6390 */ 30, 117, 4, 129, 30, 4, 68, 30, 117, 4,
/* 6400 */ 129, 30, 4, 71, 30, 117, 4, 129, 30, 4,
/* 6410 */ 74, 30, 117, 4, 129, 30, 4, 77, 30, 117,
/* 6420 */ 4, 129, 30, 4, 80, 30, 117, 4, 129, 30,
/* 6430 */ 4, 83, 30, 117, 4, 129, 30, 4, 86, 35,
/* 6440 */ 129, 30, 4, 89, 32, 129, 30, 4, 91, 30,
/* 6450 */ 129, 30, 4, 94, 27, 129, 30, 5, 97, 24,
/* 6460 */ 129, 30, 5, 100, 21, 129, 30, 7, 103, 18,
/* 6470 */ 129, 30, 8, 106, 15, 129, 30, 11, 109, 12,
/* 6480 */ 129, 30, 18, 112, 9, 129, 30, 18, 115, 6,
/* 6490 */ 129, 30, 18, 117, 4, 129, 30, 18, 120, 1,
/* 6500 */ 129, 193, 129, 42, 8, 129, 38, 16, 129, 36,
/* 6510 */ 20, 129, 34, 24, 71, 5, 129, 33, 26, 69,
/* 6520 */ 10, 129, 32, 28, 68, 13, 129, 31, 30, 68,
/* 6530 */ 14, 129, 31, 9, 52, 9, 68, 15, 129, 30,
/* 6540 */ 8, 54, 8, 69, 14, 129, 30, 7, 55, 7,
/* 6550 */ 71, 4, 78, 6, 129, 30, 6, 56, 6, 79,
/* 6560 */ 5, 129, 30, 6, 56, 6, 80, 4, 130, 31,
/* 6570 */ 5, 56, 5, 80, 4, 129, 31, 5, 56, 5,
/* 6580 */ 79, 5, 129, 32, 5, 55, 5, 78, 6, 129,
/* 6590 */ 33, 5, 54, 5, 77, 7, 129, 34, 6, 52,
/* 6600 */ 6, 74, 9, 129, 35, 48, 129, 33, 49, 129,
/* 6610 */ 32, 49, 129, 31, 49, 129, 30, 49, 129, 30,
/* 6620 */ 47, 129, 30, 45, 129, 30, 41, 129, 30, 6,
/* 6630 */ 129, 30, 4, 129, 30, 3, 129, 30, 2, 129,
/* 6640 */ 193, 129, 30, 4, 117, 4, 130, 31, 90, 136,
/* 6650 */ 37, 5, 72, 5, 129, 35, 5, 74, 5, 129,
/* 6660 */ 33, 5, 76, 5, 129, 32, 5, 77, 5, 129,
/* 6670 */ 31, 5, 78, 5, 129, 31, 4, 79, 4, 129,
/* 6680 */ 30, 5, 79, 5, 131, 30, 6, 78, 6, 129,
/* 6690 */ 30, 7, 77, 7, 129, 31, 8, 75, 8, 129,
/* 6700 */ 31, 11, 72, 11, 129, 32, 15, 67, 15, 129,
/* 6710 */ 33, 48, 129, 34, 46, 129, 35, 44, 129, 37,
/* 6720 */ 40, 129, 39, 36, 129, 42, 30, 129, 46, 22,
/* 6730 */ 129, 193, 129, 48, 18, 129, 43, 28, 129, 41,
/* 6740 */ 32, 129, 39, 36, 129, 37, 40, 129, 35, 44,
/* 6750 */ 129, 34, 46, 129, 33, 13, 68, 13, 129, 32,
/* 6760 */ 9, 73, 9, 129, 32, 7, 75, 7, 129, 31,
/* 6770 */ 6, 77, 6, 129, 31, 5, 78, 5, 129, 30,
/* 6780 */ 5, 79, 5, 129, 30, 4, 80, 4, 133, 31,
/* 6790 */ 3, 79, 4, 129, 31, 4, 79, 4, 129, 32,
/* 6800 */ 3, 78, 4, 129, 32, 4, 76, 6, 129, 33,
/* 6810 */ 4, 74, 7, 129, 34, 4, 72, 8, 129, 35,
/* 6820 */ 5, 72, 7, 129, 37, 5, 73, 4, 129, 39,
/* 6830 */ 4, 74, 1, 129, 129, 193, 129, 46, 22, 129,
/* 6840 */ 42, 30, 129, 39, 36, 129, 37, 40, 129, 35,
/* 6850 */ 44, 129, 34, 46, 129, 33, 48, 129, 32, 15,
/* 6860 */ 67, 15, 129, 31, 11, 72, 11, 129, 31, 8,
/* 6870 */ 75, 8, 129, 30, 7, 77, 7, 129, 30, 6,
/* 6880 */ 78, 6, 129, 30, 5, 79, 5, 131, 31, 4,
/* 6890 */ 79, 4, 129, 31, 5, 78, 5, 129, 32, 5,
/* 6900 */ 77, 5, 129, 33, 5, 76, 5, 129, 35, 5,
/* 6910 */ 74, 5, 117, 4, 129, 37, 5, 72, 5, 117,
/* 6920 */ 4, 129, 30, 91, 136, 30, 4, 130, 193, 129,
/* 6930 */ 48, 18, 129, 43, 28, 129, 41, 32, 129, 39,
/* 6940 */ 36, 129, 37, 40, 129, 35, 44, 129, 34, 46,
/* 6950 */ 129, 33, 13, 55, 4, 68, 13, 129, 32, 9,
/* 6960 */ 55, 4, 73, 9, 129, 32, 7, 55, 4, 75,
/* 6970 */ 7, 129, 31, 6, 55, 4, 77, 6, 129, 31,
/* 6980 */ 5, 55, 4, 78, 5, 129, 30, 5, 55, 4,
/* 6990 */ 79, 5, 129, 30, 4, 55, 4, 80, 4, 132,
/* 7000 */ 30, 4, 55, 4, 79, 5, 129, 31, 3, 55,
/* 7010 */ 4, 78, 5, 129, 31, 4, 55, 4, 77, 6,
/* 7020 */ 129, 32, 3, 55, 4, 75, 7, 129, 32, 4,
/* 7030 */ 55, 4, 73, 9, 129, 33, 4, 55, 4, 68,
/* 7040 */ 13, 129, 34, 4, 55, 25, 129, 35, 5, 55,
/* 7050 */ 24, 129, 37, 5, 55, 22, 129, 39, 4, 55,
/* 7060 */ 20, 129, 55, 18, 129, 55, 16, 129, 55, 11,
/* 7070 */ 129, 193, 129, 80, 4, 129, 30, 4, 80, 4,
/* 7080 */ 130, 30, 78, 129, 30, 82, 129, 30, 85, 129,
/* 7090 */ 30, 87, 129, 30, 88, 129, 30, 89, 129, 30,
/* 7100 */ 90, 130, 30, 4, 80, 4, 115, 6, 129, 30,
/* 7110 */ 4, 80, 4, 117, 4, 129, 80, 4, 105, 6,
/* 7120 */ 117, 4, 129, 80, 4, 103, 10, 116, 5, 129,
/* 7130 */ 80, 4, 102, 19, 129, 80, 4, 101, 19, 129,
/* 7140 */ 101, 19, 129, 101, 18, 129, 102, 16, 129, 103,
/* 7150 */ 12, 129, 105, 6, 129, 193, 129, 12, 10, 59,
/* 7160 */ 11, 129, 9, 16, 55, 19, 129, 7, 20, 53,
/* 7170 */ 23, 129, 6, 7, 23, 5, 32, 6, 51, 27,
/* 7180 */ 129, 4, 7, 25, 16, 50, 29, 129, 3, 6,
/* 7190 */ 27, 16, 49, 31, 129, 2, 6, 28, 16, 48,
/* 7200 */ 33, 129, 1, 6, 27, 18, 47, 35, 129, 1,
/* 7210 */ 6, 27, 31, 71, 12, 129, 1, 5, 26, 15,
/* 7220 */ 44, 10, 75, 8, 129, 1, 5, 25, 14, 45,
/* 7230 */ 7, 77, 7, 129, 1, 5, 25, 13, 45, 5,
/* 7240 */ 79, 5, 129, 1, 5, 24, 14, 45, 4, 80,
/* 7250 */ 4, 129, 1, 5, 24, 13, 45, 4, 80, 4,
/* 7260 */ 129, 1, 5, 23, 14, 45, 4, 80, 4, 129,
/* 7270 */ 1, 5, 23, 13, 45, 4, 80, 4, 129, 1,
/* 7280 */ 6, 22, 13, 45, 5, 79, 5, 129, 1, 6,
/* 7290 */ 21, 14, 45, 7, 77, 7, 129, 1, 7, 21,
/* 7300 */ 13, 46, 8, 75, 8, 129, 1, 8, 20, 13,
/* 7310 */ 46, 12, 71, 12, 129, 1, 10, 18, 15, 47,
/* 7320 */ 35, 129, 2, 30, 48, 33, 129, 3, 29, 49,
/* 7330 */ 32, 129, 4, 27, 50, 31, 129, 5, 25, 51,
/* 7340 */ 27, 80, 2, 86, 4, 129, 7, 21, 53, 23,
/* 7350 */ 80, 3, 85, 6, 129, 9, 17, 55, 19, 80,
/* 7360 */ 12, 129, 12, 12, 59, 11, 81, 11, 129, 82,
/* 7370 */ 10, 129, 84, 7, 129, 86, 4, 129, 193, 129,
/* 7380 */ 30, 4, 117, 4, 130, 30, 91, 136, 30, 4,
/* 7390 */ 72, 5, 129, 30, 4, 74, 5, 129, 75, 5,
/* 7400 */ 129, 76, 5, 129, 76, 6, 129, 77, 6, 130,
/* 7410 */ 77, 7, 130, 76, 8, 129, 30, 4, 75, 9,
/* 7420 */ 129, 30, 4, 72, 12, 129, 30, 54, 129, 30,
/* 7430 */ 53, 130, 30, 52, 129, 30, 51, 129, 30, 49,
/* 7440 */ 129, 30, 46, 129, 30, 42, 129, 30, 4, 130,
/* 7450 */ 193, 129, 30, 4, 80, 4, 129, 30, 4, 80,
/* 7460 */ 4, 100, 6, 129, 30, 54, 98, 10, 129, 30,
/* 7470 */ 54, 97, 12, 129, 30, 54, 96, 14, 131, 30,
/* 7480 */ 54, 97, 12, 129, 30, 54, 98, 10, 129, 30,
/* 7490 */ 54, 100, 6, 129, 30, 4, 130, 193, 129, 7,
/* 7500 */ 6, 129, 4, 11, 129, 3, 13, 129, 2, 14,
/* 7510 */ 129, 1, 15, 130, 1, 3, 6, 9, 129, 1,
/* 7520 */ 3, 7, 6, 129, 1, 3, 130, 1, 4, 129,
/* 7530 */ 1, 5, 80, 4, 129, 1, 7, 80, 4, 100,
/* 7540 */ 6, 129, 2, 82, 98, 10, 129, 3, 81, 97,
/* 7550 */ 12, 129, 4, 80, 96, 14, 129, 5, 79, 96,
/* 7560 */ 14, 129, 7, 77, 96, 14, 129, 10, 74, 97,
/* 7570 */ 12, 129, 14, 70, 98, 10, 129, 19, 65, 100,
/* 7580 */ 6, 129, 193, 129, 30, 4, 117, 4, 130, 30,
/* 7590 */ 91, 136, 30, 4, 57, 9, 129, 30, 4, 55,
/* 7600 */ 12, 129, 52, 17, 129, 50, 20, 129, 48, 24,
/* 7610 */ 129, 46, 27, 129, 44, 21, 69, 6, 129, 41,
/* 7620 */ 22, 70, 6, 80, 4, 129, 30, 4, 39, 21,
/* 7630 */ 72, 6, 80, 4, 129, 30, 4, 36, 22, 73,
/* 7640 */ 11, 129, 30, 26, 75, 9, 129, 30, 23, 76,
/* 7650 */ 8, 129, 30, 21, 78, 6, 129, 30, 19, 79,
/* 7660 */ 5, 129, 30, 16, 80, 4, 129, 30, 14, 80,
/* 7670 */ 4, 129, 30, 12, 129, 30, 10, 129, 30, 7,
/* 7680 */ 129, 30, 5, 129, 30, 4, 130, 193, 129, 30,
/* 7690 */ 4, 117, 4, 130, 30, 91, 136, 30, 4, 130,
/* 7700 */ 193, 129, 30, 4, 80, 4, 130, 30, 54, 136,
/* 7710 */ 30, 4, 72, 5, 129, 30, 4, 74, 5, 129,
/* 7720 */ 75, 5, 129, 76, 5, 129, 30, 4, 75, 7,
/* 7730 */ 129, 30, 4, 74, 9, 129, 30, 54, 132, 30,
/* 7740 */ 53, 129, 30, 52, 129, 30, 51, 129, 30, 48,
/* 7750 */ 129, 30, 4, 72, 5, 129, 30, 4, 74, 5,
/* 7760 */ 129, 75, 5, 129, 76, 5, 129, 30, 4, 75,
/* 7770 */ 7, 129, 30, 4, 74, 9, 129, 30, 54, 132,
/* 7780 */ 30, 53, 129, 30, 52, 129, 30, 51, 129, 30,
/* 7790 */ 48, 129, 30, 4, 130, 193, 129, 30, 4, 80,
/* 7800 */ 4, 130, 30, 54, 136, 30, 4, 72, 5, 129,
/* 7810 */ 30, 4, 74, 5, 129, 75, 5, 129, 76, 5,
/* 7820 */ 129, 76, 6, 129, 77, 6, 130, 77, 7, 130,
/* 7830 */ 76, 8, 129, 30, 4, 75, 9, 129, 30, 4,
/* 7840 */ 72, 12, 129, 30, 54, 129, 30, 53, 130, 30,
/* 7850 */ 52, 129, 30, 51, 129, 30, 49, 129, 30, 46,
/* 7860 */ 129, 30, 42, 129, 30, 4, 130, 193, 129, 48,
/* 7870 */ 18, 129, 43, 28, 129, 41, 32, 129, 39, 36,
/* 7880 */ 129, 37, 40, 129, 35, 44, 129, 34, 46, 129,
/* 7890 */ 33, 13, 68, 13, 129, 32, 9, 73, 9, 129,
/* 7900 */ 32, 7, 75, 7, 129, 31, 6, 77, 6, 129,
/* 7910 */ 31, 5, 78, 5, 129, 30, 5, 79, 5, 129,
/* 7920 */ 30, 4, 80, 4, 132, 30, 5, 79, 5, 130,
/* 7930 */ 31, 5, 78, 5, 129, 31, 6, 77, 6, 129,
/* 7940 */ 32, 7, 75, 7, 129, 32, 9, 73, 9, 129,
/* 7950 */ 33, 13, 68, 13, 129, 34, 46, 129, 35, 44,
/* 7960 */ 129, 37, 40, 129, 39, 36, 129, 41, 32, 129,
/* 7970 */ 43, 28, 129, 48, 18, 129, 193, 129, 1, 3,
/* 7980 */ 80, 4, 130, 1, 83, 137, 37, 5, 72, 5,
/* 7990 */ 129, 35, 5, 74, 5, 129, 33, 5, 76, 5,
/* 8000 */ 129, 32, 5, 77, 5, 129, 31, 5, 78, 5,
/* 8010 */ 129, 31, 4, 79, 4, 129, 30, 5, 79, 5,
/* 8020 */ 131, 30, 6, 78, 6, 129, 30, 7, 77, 7,
/* 8030 */ 129, 31, 8, 75, 8, 129, 31, 11, 72, 11,
/* 8040 */ 129, 32, 15, 67, 15, 129, 33, 48, 129, 34,
/* 8050 */ 46, 129, 35, 44, 129, 37, 40, 129, 39, 36,
/* 8060 */ 129, 42, 30, 129, 46, 22, 129, 193, 129, 46,
/* 8070 */ 22, 129, 42, 30, 129, 39, 36, 129, 37, 40,
/* 8080 */ 129, 35, 44, 129, 34, 46, 129, 33, 48, 129,
/* 8090 */ 32, 15, 67, 15, 129, 31, 11, 72, 11, 129,
/* 8100 */ 31, 8, 75, 8, 129, 30, 7, 77, 7, 129,
/* 8110 */ 30, 6, 78, 6, 129, 30, 5, 79, 5, 131,
/* 8120 */ 31, 4, 79, 4, 129, 31, 5, 78, 5, 129,
/* 8130 */ 32, 5, 77, 5, 129, 33, 5, 76, 5, 129,
/* 8140 */ 35, 5, 74, 5, 129, 37, 5, 72, 5, 129,
/* 8150 */ 1, 83, 136, 1, 3, 80, 4, 130, 193, 129,
/* 8160 */ 30, 4, 80, 4, 130, 30, 54, 136, 30, 4,
/* 8170 */ 68, 6, 129, 30, 4, 70, 6, 129, 71, 7,
/* 8180 */ 129, 72, 7, 129, 73, 7, 129, 74, 7, 129,
/* 8190 */ 74, 8, 129, 75, 8, 130, 69, 15, 129, 67,
/* 8200 */ 17, 129, 66, 18, 129, 65, 19, 130, 65, 18,
/* 8210 */ 130, 66, 16, 129, 67, 13, 129, 69, 8, 129,
/* 8220 */ 193, 129, 30, 13, 64, 8, 129, 30, 13, 61,
/* 8230 */ 14, 129, 30, 13, 59, 18, 129, 30, 13, 57,
/* 8240 */ 22, 129, 33, 8, 56, 24, 129, 32, 7, 55,
/* 8250 */ 26, 129, 32, 6, 54, 28, 129, 31, 6, 53,
/* 8260 */ 16, 77, 6, 129, 31, 5, 53, 14, 79, 4,
/* 8270 */ 129, 30, 5, 52, 14, 80, 4, 129, 30, 5,
/* 8280 */ 52, 13, 80, 4, 129, 30, 4, 52, 13, 80,
/* 8290 */ 4, 129, 30, 4, 52, 12, 80, 4, 129, 30,
/* 8300 */ 4, 51, 13, 80, 4, 130, 30, 4, 50, 13,
/* 8310 */ 79, 5, 129, 30, 4, 50, 13, 78, 5, 129,
/* 8320 */ 30, 5, 49, 14, 77, 6, 129, 31, 4, 49,
/* 8330 */ 13, 76, 6, 129, 31, 5, 48, 14, 75, 7,
/* 8340 */ 129, 32, 5, 47, 14, 73, 8, 129, 32, 6,
/* 8350 */ 45, 16, 71, 13, 129, 33, 27, 71, 13, 129,
/* 8360 */ 34, 26, 71, 13, 129, 35, 24, 71, 13, 129,
/* 8370 */ 37, 20, 129, 39, 16, 129, 43, 9, 129, 193,
/* 8380 */ 129, 80, 4, 131, 41, 56, 129, 37, 60, 129,
/* 8390 */ 35, 62, 129, 33, 64, 129, 32, 65, 129, 31,
/* 8400 */ 66, 129, 30, 67, 130, 30, 11, 80, 4, 129,
/* 8410 */ 30, 9, 80, 4, 129, 30, 8, 80, 4, 129,
/* 8420 */ 31, 7, 80, 4, 129, 31, 6, 129, 32, 5,
/* 8430 */ 129, 33, 5, 129, 35, 4, 129, 38, 3, 129,
/* 8440 */ 193, 129, 80, 4, 130, 42, 42, 129, 38, 46,
/* 8450 */ 129, 35, 49, 129, 33, 51, 129, 32, 52, 129,
/* 8460 */ 31, 53, 130, 30, 54, 129, 30, 12, 129, 30,
/* 8470 */ 9, 129, 30, 8, 129, 30, 7, 130, 31, 6,
/* 8480 */ 130, 32, 6, 129, 33, 5, 129, 34, 5, 129,
/* 8490 */ 35, 5, 80, 4, 129, 37, 5, 80, 4, 129,
/* 8500 */ 30, 54, 136, 30, 4, 130, 193, 129, 80, 4,
/* 8510 */ 130, 77, 7, 129, 74, 10, 129, 70, 14, 129,
/* 8520 */ 66, 18, 129, 62, 22, 129, 59, 25, 129, 55,
/* 8530 */ 29, 129, 51, 33, 129, 47, 37, 129, 44, 32,
/* 8540 */ 80, 4, 129, 40, 32, 80, 4, 129, 36, 32,
/* 8550 */ 129, 32, 33, 129, 30, 31, 129, 33, 24, 129,
/* 8560 */ 36, 17, 129, 40, 12, 129, 44, 12, 129, 48,
/* 8570 */ 12, 129, 51, 13, 129, 55, 13, 129, 59, 13,
/* 8580 */ 80, 4, 129, 63, 13, 80, 4, 129, 67, 17,
/* 8590 */ 129, 71, 13, 129, 74, 10, 129, 78, 6, 129,
/* 8600 */ 80, 4, 131, 193, 129, 80, 4, 130, 77, 7,
/* 8610 */ 129, 74, 10, 129, 70, 14, 129, 66, 18, 129,
/* 8620 */ 62, 22, 129, 59, 25, 129, 55, 29, 129, 51,
/* 8630 */ 33, 129, 47, 37, 129, 44, 32, 80, 4, 129,
/* 8640 */ 40, 32, 80, 4, 129, 36, 32, 129, 32, 33,
/* 8650 */ 129, 30, 31, 129, 33, 24, 129, 36, 17, 129,
/* 8660 */ 40, 12, 129, 44, 12, 129, 47, 13, 129, 44,
/* 8670 */ 20, 129, 40, 28, 129, 36, 31, 129, 32, 32,
/* 8680 */ 129, 30, 30, 129, 33, 24, 129, 36, 17, 129,
/* 8690 */ 40, 12, 129, 44, 12, 129, 48, 12, 129, 51,
/* 8700 */ 13, 129, 55, 13, 129, 59, 13, 80, 4, 129,
/* 8710 */ 63, 13, 80, 4, 129, 67, 17, 129, 71, 13,
/* 8720 */ 129, 74, 10, 129, 78, 6, 129, 80, 4, 131,
/* 8730 */ 193, 129, 30, 4, 80, 4, 130, 30, 4, 79,
/* 8740 */ 5, 129, 30, 5, 77, 7, 129, 30, 6, 74,
/* 8750 */ 10, 129, 30, 8, 72, 12, 129, 30, 11, 69,
/* 8760 */ 15, 129, 30, 13, 67, 17, 129, 30, 4, 37,
/* 8770 */ 8, 64, 20, 129, 30, 4, 39, 8, 62, 22,
/* 8780 */ 129, 41, 8, 59, 25, 129, 43, 8, 57, 27,
/* 8790 */ 129, 45, 8, 55, 22, 80, 4, 129, 47, 27,
/* 8800 */ 80, 4, 129, 49, 23, 129, 47, 22, 129, 44,
/* 8810 */ 23, 129, 42, 22, 129, 30, 4, 39, 27, 129,
/* 8820 */ 30, 4, 37, 31, 129, 30, 27, 62, 8, 129,
/* 8830 */ 30, 25, 64, 8, 129, 30, 22, 66, 8, 80,
/* 8840 */ 4, 129, 30, 20, 68, 8, 80, 4, 129, 30,
/* 8850 */ 17, 70, 8, 80, 4, 129, 30, 15, 73, 11,
/* 8860 */ 129, 30, 12, 75, 9, 129, 30, 10, 77, 7,
/* 8870 */ 129, 30, 7, 79, 5, 129, 30, 5, 80, 4,
/* 8880 */ 129, 30, 4, 80, 4, 130, 193, 129, 4, 5,
/* 8890 */ 80, 4, 129, 2, 9, 80, 4, 129, 1, 11,
/* 8900 */ 77, 7, 129, 1, 12, 74, 10, 129, 1, 12,
/* 8910 */ 70, 14, 129, 1, 12, 66, 18, 129, 1, 11,
/* 8920 */ 62, 22, 129, 2, 9, 59, 25, 129, 4, 11,
/* 8930 */ 55, 29, 129, 7, 12, 51, 33, 129, 10, 12,
/* 8940 */ 47, 37, 129, 14, 12, 44, 32, 80, 4, 129,
/* 8950 */ 17, 13, 40, 32, 80, 4, 129, 21, 13, 36,
/* 8960 */ 32, 129, 25, 40, 129, 29, 32, 129, 33, 24,
/* 8970 */ 129, 36, 17, 129, 40, 12, 129, 44, 12, 129,
/* 8980 */ 48, 12, 129, 51, 13, 129, 55, 13, 129, 59,
/* 8990 */ 13, 80, 4, 129, 63, 13, 80, 4, 129, 67,
/* 9000 */ 17, 129, 71, 13, 129, 74, 10, 129, 78, 6,
/* 9010 */ 129, 80, 4, 131, 193, 129, 30, 1, 71, 13,
/* 9020 */ 129, 30, 3, 71, 13, 129, 30, 6, 71, 13,
/* 9030 */ 129, 30, 9, 75, 9, 129, 30, 11, 77, 7,
/* 9040 */ 129, 30, 14, 79, 5, 129, 30, 17, 79, 5,
/* 9050 */ 129, 30, 19, 80, 4, 129, 30, 22, 80, 4,
/* 9060 */ 129, 30, 25, 80, 4, 129, 30, 27, 80, 4,
/* 9070 */ 129, 30, 4, 36, 24, 80, 4, 129, 30, 4,
/* 9080 */ 38, 25, 80, 4, 129, 30, 4, 41, 24, 80,
/* 9090 */ 4, 129, 30, 4, 44, 24, 80, 4, 129, 30,
/* 9100 */ 4, 46, 25, 80, 4, 129, 30, 4, 49, 25,
/* 9110 */ 80, 4, 129, 30, 4, 52, 24, 80, 4, 129,
/* 9120 */ 30, 4, 54, 30, 129, 30, 4, 57, 27, 129,
/* 9130 */ 30, 4, 59, 25, 129, 30, 4, 62, 22, 129,
/* 9140 */ 30, 4, 65, 19, 129, 30, 5, 67, 17, 129,
/* 9150 */ 30, 5, 70, 14, 129, 30, 7, 73, 11, 129,
/* 9160 */ 30, 9, 76, 8, 129, 30, 13, 78, 6, 129,
/* 9170 */ 30, 13, 81, 3, 129, 30, 13, 129, 193, 2,
/* 9180 */ 9, 59, 25, 129, 4, 11, 55, 29, 129, 7,
/* 9190 */ 12, 51, 33, 129, 10, 12, 47, 37, 129, 14,
/* 9200 */ 12, 44, 32, 80, 4, 129, 17, 13, 40, 32,
/* 9210 */ 80, 4, 129, 21, 13, 36, 32, 129, 25, 40,
/* 9220 */ 129, 29, 32, 129, 33, 24, 129, 36, 17, 129,
/* 9230 */ 40, 12, 129, 44, 12, 129, 48, 12, 129, 51,
/* 9240 */ 13, 129, 55, 13, 129, 59, 13, 80, 4, 129,
/* 9250 */ 63, 13, 80, 4, 129, 67, 17, 129, 71, 13,
/* 9260 */ 129, 74, 10, 129, 78, 6, 129, 80, 4, 131,
/* 9270 */ 193
};
char line[DWIDTH];
char *message;
char print[DWIDTH];
int debug, i, j, linen, max, nchars, pc, term, trace, x, y;
int width = DWIDTH; /* -w option: scrunch letters to 80 columns */
static void usage(void);
int
main(int argc, char *argv[])
{
int ch;
while ((ch = getopt(argc, argv, "w:td")) != -1)
switch (ch) {
case 'd':
debug = 1;
break;
case 't':
trace = 1;
break;
case 'w':
width = atoi(optarg);
if (width <= 0 || width > DWIDTH)
errx(1, "illegal argument for -w option");
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
for (i = 0; i < width; i++) {
j = i * DWIDTH / width;
print[j] = 1;
}
/* Have now read in the data. Next get the message to be printed. */
if (*argv) {
for(i=0, j=0; i < argc; i++)
j += strlen(argv[i]) + 1;
if ((message = malloc((size_t)j)) == NULL)
err(1, "malloc");
strcpy(message, *argv);
while (*++argv) {
strcat(message, " ");
strcat(message, *argv);
}
nchars = strlen(message);
} else {
if ((message = malloc((size_t)MAXMSG)) == NULL)
err(1, "malloc");
fprintf(stderr,"Message: ");
if (fgets(message, MAXMSG, stdin) == NULL) {
nchars = 0;
message[0] = '\0';
} else {
nchars = strlen(message);
/* Get rid of newline. */
if (message[nchars - 1] == '\n')
message[--nchars] = '\0';
}
}
/* some debugging print statements */
if (debug) {
printf("const int asc_ptr[NCHARS] = {\n");
for (i = 0; i < 128; i++) {
printf("%4d, ",asc_ptr[i]);
if ((i+1) % 8 == 0)
printf("\n");
}
printf("};\nconst unsigned char data_table[NBYTES] = {\n");
printf("/* ");
for (i = 0; i < 10; i++) printf(" %3d ",i);
printf("*/\n");
for (i = 0; i < NBYTES; i += 10) {
printf("/* %4d */ ",i);
for (j = i; j < i+10; j++) {
x = data_table[j] & 0377;
printf(" %3d, ",x);
}
putchar('\n');
}
printf("};\n");
}
/* check message to make sure it's legal */
j = 0;
for (i = 0; i < nchars; i++)
if ((u_char) message[i] >= NCHARS ||
asc_ptr[(u_char) message[i]] == 0) {
warnx("the character '%c' is not in my character set",
message[i]);
j++;
}
if (j)
exit(1);
if (trace)
printf("Message '%s' is OK\n",message);
/* Now have message. Print it one character at a time. */
for (i = 0; i < nchars; i++) {
if (trace)
printf("Char #%d: %c\n", i, message[i]);
for (j = 0; j < DWIDTH; j++) line[j] = ' ';
pc = asc_ptr[(u_char) message[i]];
term = 0;
max = 0;
linen = 0;
while (!term) {
if (pc < 0 || pc > NBYTES) {
printf("bad pc: %d\n",pc);
exit(1);
}
x = data_table[pc] & 0377;
if (trace)
printf("pc=%d, term=%d, max=%d, linen=%d, x=%d\n",pc,term,max,linen,x);
if (x >= 128) {
if (x>192) term++;
x = x & 63;
while (x--) {
if (print[linen++]) {
for (j=0; j <= max; j++)
if (print[j])
putchar(line[j]);
putchar('\n');
}
}
for (j = 0; j < DWIDTH; j++) line[j] = ' ';
pc++;
}
else {
y = data_table[pc+1];
/* compensate for narrow teminals */
#ifdef notdef
x = (x*width + (DWIDTH/2)) / DWIDTH;
y = (y*width + (DWIDTH/2)) / DWIDTH;
#endif
max = x+y;
while (x < max) line[x++] = '#';
pc += 2;
if (trace)
printf("x=%d, y=%d, max=%d\n",x,y,max);
}
}
}
free(message);
exit(0);
}
static void
usage(void)
{
fprintf(stderr, "usage: banner [-d] [-t] [-w width] message ...\n");
exit(1);
}
|
the_stack_data/115764188.c | extern void __VERIFIER_error() __attribute__ ((__noreturn__));
void __VERIFIER_assert(int cond) { if(!(cond)) { ERROR: __VERIFIER_error(); } }
#define N 175
int main ( ) {
int a[N]; int e;
int i = 0;
while( i < N && a[i] != e ) {
i = i + 1;
}
int x;
for ( x = 0 ; x < i ; x++ ) {
__VERIFIER_assert( a[x] != e );
}
return 0;
}
|
the_stack_data/62366.c |
/* this ALWAYS GENERATED file contains the proxy stub code */
/* File created by MIDL compiler version 8.01.0622 */
/* at Tue Jan 19 12:14:07 2038
*/
/* Compiler settings for ExpTabBar.idl:
Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622
protocol : all , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
/* @@MIDL_FILE_HEADING( ) */
#if defined(_M_AMD64)
#if _MSC_VER >= 1200
#pragma warning(push)
#endif
#pragma warning( disable: 4211 ) /* redefine extern to static */
#pragma warning( disable: 4232 ) /* dllimport identity*/
#pragma warning( disable: 4024 ) /* array to pointer mapping*/
#pragma warning( disable: 4152 ) /* function/data pointer conversion in expression */
#define USE_STUBLESS_PROXY
/* verify that the <rpcproxy.h> version is high enough to compile this file*/
#ifndef __REDQ_RPCPROXY_H_VERSION__
#define __REQUIRED_RPCPROXY_H_VERSION__ 475
#endif
#include "rpcproxy.h"
#include "ndr64types.h"
#ifndef __RPCPROXY_H_VERSION__
#error this stub requires an updated version of <rpcproxy.h>
#endif /* __RPCPROXY_H_VERSION__ */
#include "ExpTabBar_i.h"
#define TYPE_FORMAT_STRING_SIZE 3
#define PROC_FORMAT_STRING_SIZE 1
#define EXPR_FORMAT_STRING_SIZE 1
#define TRANSMIT_AS_TABLE_SIZE 0
#define WIRE_MARSHAL_TABLE_SIZE 0
typedef struct _ExpTabBar_MIDL_TYPE_FORMAT_STRING
{
short Pad;
unsigned char Format[ TYPE_FORMAT_STRING_SIZE ];
} ExpTabBar_MIDL_TYPE_FORMAT_STRING;
typedef struct _ExpTabBar_MIDL_PROC_FORMAT_STRING
{
short Pad;
unsigned char Format[ PROC_FORMAT_STRING_SIZE ];
} ExpTabBar_MIDL_PROC_FORMAT_STRING;
typedef struct _ExpTabBar_MIDL_EXPR_FORMAT_STRING
{
long Pad;
unsigned char Format[ EXPR_FORMAT_STRING_SIZE ];
} ExpTabBar_MIDL_EXPR_FORMAT_STRING;
static const RPC_SYNTAX_IDENTIFIER _RpcTransferSyntax =
{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}};
static const RPC_SYNTAX_IDENTIFIER _NDR64_RpcTransferSyntax =
{{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}};
extern const ExpTabBar_MIDL_TYPE_FORMAT_STRING ExpTabBar__MIDL_TypeFormatString;
extern const ExpTabBar_MIDL_PROC_FORMAT_STRING ExpTabBar__MIDL_ProcFormatString;
extern const ExpTabBar_MIDL_EXPR_FORMAT_STRING ExpTabBar__MIDL_ExprFormatString;
extern const MIDL_STUB_DESC Object_StubDesc;
extern const MIDL_SERVER_INFO IExpTabBand_ServerInfo;
extern const MIDL_STUBLESS_PROXY_INFO IExpTabBand_ProxyInfo;
#if !defined(__RPC_WIN64__)
#error Invalid build platform for this stub.
#endif
static const ExpTabBar_MIDL_PROC_FORMAT_STRING ExpTabBar__MIDL_ProcFormatString =
{
0,
{
0x0
}
};
static const ExpTabBar_MIDL_TYPE_FORMAT_STRING ExpTabBar__MIDL_TypeFormatString =
{
0,
{
NdrFcShort( 0x0 ), /* 0 */
0x0
}
};
/* Object interface: IUnknown, ver. 0.0,
GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
/* Object interface: IDispatch, ver. 0.0,
GUID={0x00020400,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
/* Object interface: IExpTabBand, ver. 0.0,
GUID={0x2625D19C,0xD2BD,0x4EF1,{0xB9,0x04,0x0D,0xE1,0xBE,0xF7,0xAC,0xE1}} */
#pragma code_seg(".orpc")
static const unsigned short IExpTabBand_FormatStringOffsetTable[] =
{
(unsigned short) -1,
(unsigned short) -1,
(unsigned short) -1,
(unsigned short) -1,
0
};
#endif /* defined(_M_AMD64)*/
/* this ALWAYS GENERATED file contains the proxy stub code */
/* File created by MIDL compiler version 8.01.0622 */
/* at Tue Jan 19 12:14:07 2038
*/
/* Compiler settings for ExpTabBar.idl:
Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622
protocol : all , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
/* @@MIDL_FILE_HEADING( ) */
#if defined(_M_AMD64)
#if !defined(__RPC_WIN64__)
#error Invalid build platform for this stub.
#endif
#include "ndr64types.h"
#include "pshpack8.h"
typedef
NDR64_FORMAT_UINT32
__midl_frag1_t;
extern const __midl_frag1_t __midl_frag1;
static const __midl_frag1_t __midl_frag1 =
(NDR64_UINT32) 0 /* 0x0 */;
#include "poppack.h"
/* Object interface: IUnknown, ver. 0.0,
GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
/* Object interface: IDispatch, ver. 0.0,
GUID={0x00020400,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
/* Object interface: IExpTabBand, ver. 0.0,
GUID={0x2625D19C,0xD2BD,0x4EF1,{0xB9,0x04,0x0D,0xE1,0xBE,0xF7,0xAC,0xE1}} */
#pragma code_seg(".orpc")
static const FormatInfoRef IExpTabBand_Ndr64ProcTable[] =
{
(FormatInfoRef)(LONG_PTR) -1,
(FormatInfoRef)(LONG_PTR) -1,
(FormatInfoRef)(LONG_PTR) -1,
(FormatInfoRef)(LONG_PTR) -1,
0
};
static const MIDL_SYNTAX_INFO IExpTabBand_SyntaxInfo [ 2 ] =
{
{
{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
0,
ExpTabBar__MIDL_ProcFormatString.Format,
&IExpTabBand_FormatStringOffsetTable[-3],
ExpTabBar__MIDL_TypeFormatString.Format,
0,
0,
0
}
,{
{{0x71710533,0xbeba,0x4937,{0x83,0x19,0xb5,0xdb,0xef,0x9c,0xcc,0x36}},{1,0}},
0,
0 ,
(unsigned short *) &IExpTabBand_Ndr64ProcTable[-3],
0,
0,
0,
0
}
};
static const MIDL_STUBLESS_PROXY_INFO IExpTabBand_ProxyInfo =
{
&Object_StubDesc,
ExpTabBar__MIDL_ProcFormatString.Format,
&IExpTabBand_FormatStringOffsetTable[-3],
(RPC_SYNTAX_IDENTIFIER*)&_RpcTransferSyntax,
2,
(MIDL_SYNTAX_INFO*)IExpTabBand_SyntaxInfo
};
static const MIDL_SERVER_INFO IExpTabBand_ServerInfo =
{
&Object_StubDesc,
0,
ExpTabBar__MIDL_ProcFormatString.Format,
(unsigned short *) &IExpTabBand_FormatStringOffsetTable[-3],
0,
(RPC_SYNTAX_IDENTIFIER*)&_NDR64_RpcTransferSyntax,
2,
(MIDL_SYNTAX_INFO*)IExpTabBand_SyntaxInfo
};
CINTERFACE_PROXY_VTABLE(7) _IExpTabBandProxyVtbl =
{
0,
&IID_IExpTabBand,
IUnknown_QueryInterface_Proxy,
IUnknown_AddRef_Proxy,
IUnknown_Release_Proxy ,
0 /* IDispatch::GetTypeInfoCount */ ,
0 /* IDispatch::GetTypeInfo */ ,
0 /* IDispatch::GetIDsOfNames */ ,
0 /* IDispatch_Invoke_Proxy */
};
static const PRPC_STUB_FUNCTION IExpTabBand_table[] =
{
STUB_FORWARDING_FUNCTION,
STUB_FORWARDING_FUNCTION,
STUB_FORWARDING_FUNCTION,
STUB_FORWARDING_FUNCTION
};
CInterfaceStubVtbl _IExpTabBandStubVtbl =
{
&IID_IExpTabBand,
&IExpTabBand_ServerInfo,
7,
&IExpTabBand_table[-3],
CStdStubBuffer_DELEGATING_METHODS
};
static const MIDL_STUB_DESC Object_StubDesc =
{
0,
NdrOleAllocate,
NdrOleFree,
0,
0,
0,
0,
0,
ExpTabBar__MIDL_TypeFormatString.Format,
1, /* -error bounds_check flag */
0x60001, /* Ndr library version */
0,
0x801026e, /* MIDL Version 8.1.622 */
0,
0,
0, /* notify & notify_flag routine table */
0x2000001, /* MIDL flag */
0, /* cs routines */
0, /* proxy/server info */
0
};
const CInterfaceProxyVtbl * const _ExpTabBar_ProxyVtblList[] =
{
( CInterfaceProxyVtbl *) &_IExpTabBandProxyVtbl,
0
};
const CInterfaceStubVtbl * const _ExpTabBar_StubVtblList[] =
{
( CInterfaceStubVtbl *) &_IExpTabBandStubVtbl,
0
};
PCInterfaceName const _ExpTabBar_InterfaceNamesList[] =
{
"IExpTabBand",
0
};
const IID * const _ExpTabBar_BaseIIDList[] =
{
&IID_IDispatch,
0
};
#define _ExpTabBar_CHECK_IID(n) IID_GENERIC_CHECK_IID( _ExpTabBar, pIID, n)
int __stdcall _ExpTabBar_IID_Lookup( const IID * pIID, int * pIndex )
{
if(!_ExpTabBar_CHECK_IID(0))
{
*pIndex = 0;
return 1;
}
return 0;
}
const ExtendedProxyFileInfo ExpTabBar_ProxyFileInfo =
{
(PCInterfaceProxyVtblList *) & _ExpTabBar_ProxyVtblList,
(PCInterfaceStubVtblList *) & _ExpTabBar_StubVtblList,
(const PCInterfaceName * ) & _ExpTabBar_InterfaceNamesList,
(const IID ** ) & _ExpTabBar_BaseIIDList,
& _ExpTabBar_IID_Lookup,
1,
2,
0, /* table of [async_uuid] interfaces */
0, /* Filler1 */
0, /* Filler2 */
0 /* Filler3 */
};
#if _MSC_VER >= 1200
#pragma warning(pop)
#endif
#endif /* defined(_M_AMD64)*/
|
the_stack_data/45420.c | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
/**
* function f should be called
* and the program should terminate
*/
void f(void) {
assert(0); // FAIL!
printf("hello, this is \"void f(void)\"\n");
}
void call_f(void)
{
f();
exit(0);
}
int main()
{
while (1) {
call_f();
}
return 0;
}
|
the_stack_data/107953659.c | #include <stdio.h>
#define N 4
int main(void) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N - i - 1; j++)
printf(" ");
for (int j = 0; j < 2 * i + 1; j++)
printf("* ");
printf("\n");
}
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j <= i; j++)
printf(" ");
for (int j = 0; j < 2 * (N - 1 - i) - 1; j++)
printf("* ");
printf("\n");
}
}
/* 输出：
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
把空格变成1个就是另一种风格。
*/
|
the_stack_data/193892360.c | /* ======================================== */
/* ===== Solution to sample problem 4 ===== */
/* ======================================== */
#include<stdio.h>
#include<string.h>
int main () {
// Declare the variables and input the values
int n,i,j,k,flag, count;
char ip[100][20], name[100][20];
scanf("%d", &n);
for(i=0;i<n;i++) {
scanf("%s", ip[i]);
scanf("%s", name[i]);
}
// Compare the first two octets of ip addresses
for (i=0;i<n-1;i++) {
for (j=i+1;j<n;j++) {
if (ip[i][0] == ip[j][0]) {
flag = 1; count=0;
for(k=0;k<10;k++) {
if (ip[i][k] == ip[j][k]) {
if (ip[i][k] == '.') {
if(count<1) count++;
else k=10;
}
} else {
flag = 0;
k = 10;
}
}
if (flag == 1) {
printf("Machines %s and %s are on the same local network\n", name[i], name[j]);
}
}
}
}
return 0;
} |
the_stack_data/54825034.c | #include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
puts("pipe1 running");
printf("PARENT: pid=%d\n", getpid());
int pipefd[2];
pipe(pipefd);
puts("PARENT: fork");
pid_t pid = fork();
if (pid == 0) {
printf("CHILD: pid=%d; ppid=%d\n", getpid(), getppid());
close(pipefd[0]); // fechar a ponta que não vai usar
sleep(10);
write(pipefd[1], "Hello, parent!", 15);
} else {
printf("PARENT: pid=%d; child=%d\n", getpid(), pid);
close(pipefd[1]); // fechar a ponta que não vai usar
printf("PARENT: waiting for message from child\n");
char msg[15];
read(pipefd[0], msg, 15);
printf("PARENT: child sent message \"%s\"\n", msg);
int res;
waitpid(pid, &res, 0);
printf("PARENT: child process %d terminated with %d\n", pid, res);
if (WIFEXITED(res)) {
printf("PARENT: child returned %d\n", WEXITSTATUS(res));
} else {
printf("PARENT: child terminated abnormally\n");
}
}
return 0;
}
|
the_stack_data/15868.c | long
expand(ss, aLaw)
long ss;
int aLaw;
{
long sss, ssm, ssq, sl;
if ( !aLaw ) {
/* process u-law */
sss = ss >> 13;
ssq = ss & 8191;
} else {
/* process a-law */
sss = ss >> 12;
ssm = ss & 4095;
ssq = ssm << 1;
}
sl = sss ? (16384 - ssq) & 16383 : ssq;
return(sl);
}
|
the_stack_data/153355.c | struct sigaction {
int x;
};
extern int sigaction(const struct sigaction *__restrict __act);
int f() {
sigaction(0);
return 0;
}
|
the_stack_data/57950544.c | #include <stdio.h>
int mdc(int a, int b);
int main()
{
int a, b;
printf("\nDigite o valor de a: ");
scanf("%d", &a);
printf("\nDigite o valor de b: ");
scanf("%d", &b);
printf("\nO MDC entre %d e %d é %d", a, b, mdc(a, b));
return 0;
}
int mdc(int a, int b){
return b == 0 ? a : mdc(b, a % b);
} |
the_stack_data/70450043.c | #include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char *argv[]) {
printf("Hello World");
return 0;
}
|
the_stack_data/192331837.c | #include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <unistd.h>
#define LOOPBACK "127.0.0.1"
#define PORT 16971
int main()
{
int listen_sock, client_sock, ret, nready;
int client[FD_SETSIZE];
int max_fd;
ssize_t n;
char buf[16];
socklen_t clilen;
fd_set allset, rset;
struct sockaddr_in cliaddr, __me;
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock < 0) {
perror("Error opening socket");
return listen_sock;
}
memset(&__me, 0, sizeof(__me));
__me.sin_family = AF_INET;
__me.sin_addr.s_addr = htonl(INADDR_ANY);
__me.sin_port = htons(PORT);
ret = bind(listen_sock, (struct sockaddr *)&__me, sizeof(__me));
if (ret < 0) {
perror("Error binding");
return ret;
}
ret = listen(listen_sock, 5);
if (ret < 0) {
perror("Error on listen");
return ret;
}
FD_ZERO(&allset);
FD_SET(listen_sock, &allset);
printf("\n listen fd = %d", listen_sock);
clilen = sizeof(struct sockaddr);
max_fd = listen_sock;
while (1) {
rset = allset;
printf("\n Wait for connection\n");
nready = select(max_fd + 1, &rset, NULL, NULL, NULL);
printf("\n Connection in progress on nready = %d", nready);
if (FD_ISSET(listen_sock, &rset)) {
client_sock = accept(listen_sock, (struct sockaddr *)&cliaddr, &clilen);
printf("\nAccepted connection %d", client_sock);
FD_SET(client_sock, &allset);
if (client_sock > max_fd) max_fd = client_sock;
}
n = read(client_sock, buf, 16);
printf("\nSocket read %d characters", (int)n);
if (n == 0) {
FD_CLR(client_sock, &allset);
close(client_sock);
}
}
close(listen_sock);
return 0;
}
|
the_stack_data/715939.c | #include <string.h>
#define max(a, b) (((a) > (b)) ? (a) : (b))
int removeBoxes(int *boxes, int boxesSize)
{
int dp[boxesSize][boxesSize][boxesSize];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < boxesSize; ++i)
{
for (int k = 0; k <= i; ++k)
dp[i][i][k] = (k + 1) * (k + 1);
}
for (int i = boxesSize - 1; i >= 0; --i)
{
for (int j = i + 1; j < boxesSize; ++j)
{
for (int k = 0; k <= i; ++k)
{
int res = (k + 1) * (k + 1) + dp[i + 1][j][0];
for (int m = i + 1; m <= j; ++m)
{
if (boxes[m] == boxes[i])
res = max(res, dp[i + 1][m - 1][0] + dp[m][j][k + 1]);
}
dp[i][j][k] = res;
}
}
}
return dp[0][boxesSize - 1][0];
} |
the_stack_data/176705104.c | #include <unistd.h>
extern char **environ;
int
execv(const char *path, char *const argv[])
{
return execve(path, argv, environ);
}
|
the_stack_data/694648.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define str_size 100 //Declare the maximum size of the string
void main()
{
char str[str_size];
int alp, digit, splch, i;
alp = digit = splch = i = 0;
printf("\n\nCount total number of alphabets, digits and special characters :\n");
printf("--------------------------------------------------------------------\n");
printf("Input the string : ");
fgets(str, sizeof str, stdin);
/* Checks each character of string*/
while(str[i]!='\0')
{
if((str[i]>='a' && str[i]<='z') || (str[i]>='A' && str[i]<='Z'))
{
alp++;
}
else if(str[i]>='0' && str[i]<='9')
{
digit++;
}
else
{
splch++;
}
i++;
}
printf("Number of Alphabets in the string is : %d\n", alp);
printf("Number of Digits in the string is : %d\n", digit);
printf("Number of Special characters in the string is : %d\n\n", splch);
} |
the_stack_data/134901.c | // RUN: %check %s -std=c99
// RUN: %check %s -std=c89
// RUN: %ucc -std=c11 %s | grep 'anonymous'; [ $? -ne 0 ]
struct A
{
struct
{
int i;
}; // CHECK: /warning: unnamed member '.*' is a C11 extension/
int j;
};
main()
{
struct A a;
a.i = 3;
}
|
the_stack_data/218893028.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
int normalize(char str[100]);
int main(int argc, char const *argv[])
{
char key[100] = "";
char str[100] = "";
if (argc != 2) //get exactly 1 argument
{
printf("Usage: ./vigenere keyword\n");
exit(1);
}
strcpy(key, argv[1]);
if (normalize(key) == 1) // ensure that arg is valid
{
printf("Usage: ./vigenere keyword\n");
exit(1);
}
while (1) //handling empty inputs
{
printf("plaintext: ");
fgets(str, 100, stdin);
if (str[0] != '\n')
break;
}
for (int keyShift = 0, i = 0; i < strlen(str); i++)
{
int keyNumber = key[(i + keyShift) % strlen(key)] - 'a';
if (islower(str[i]))
str[i] = (str[i] - 'a' + keyNumber) % 26 + 'a';
else if (isupper(str[i]))
str[i] = (str[i] - 'A' + keyNumber) % 26 + 'A';
else
keyShift--;
}
printf("ciphertext: %s\n", str);
return 0;
}
int normalize(char str[100])
{
for (size_t i = 0; i < strlen(str); i++)
{
if (!isalpha(str[i]))
return 1;
str[i] = tolower(str[i]);
}
return 0;
}
|
the_stack_data/182952848.c | #include <stdio.h>
/*valor_retorno nombreFunción (parámetros de entrada){
//TODO
}*/
/*Pendientes:
1.- Utilizar un tipo de dato más grande
2.- Validar entrada a solo enteros positivos
*/
//5 * 4 * 3 * 2 * 1 = 5!
long factorial(int n){ //int n = 0;
long res;
if (n == 0){ /* caso base */ // 0 == 0 -> false
return 1;
}else{
res = n * factorial (n - 1);
printf("\n\tFactorial de %i = %li",n, res);
return res; /* llamada a esta misma función */
//120
}
}
int main(void){
factorial(3); // = 5
return 0;
}
|
the_stack_data/15762354.c | /* This is a simple program to collect ASM from.
Author: Dr Anton Gerdelan.
Licence: see LICENSE.txt in repository root.
Repository: https://github.com/capnramses/pro_programming_tools_c_cpp
Using GCC:
gcc -S my_file.c
*/
#include <stdio.h>
void my_print() {
printf("hi from the lib!\n");
}
|
the_stack_data/22011776.c | /* execv() - execute with prepared arguments Author: Kees J. Bot
* 21 Jan 1994
*/
#define execv _execv
#define execve _execve
#include <unistd.h>
extern char * const **_penviron; /* The default environment. */
int execv(const char *path, char * const *argv)
{
return execve(path, argv, *_penviron);
}
|
the_stack_data/603800.c |
#line 1 "format.rl"
/*
* Partial printf implementation.
*/
#define BUFLEN 1024
#include <stdio.h>
typedef void (*WriteFunc)( char *data, int len );
struct format
{
char buf[BUFLEN+1];
int buflen;
WriteFunc write;
int flags;
int width;
int prec;
int cs;
};
void do_conv( struct format *fsm, char c )
{
printf( "flags: %x\n", fsm->flags );
printf( "width: %i\n", fsm->width );
printf( "prec: %i\n", fsm->prec );
printf( "conv: %c\n", c );
printf( "\n" );
}
#define FL_HASH 0x01
#define FL_ZERO 0x02
#define FL_DASH 0x04
#define FL_SPACE 0x08
#define FL_PLUS 0x10
#define FL_HAS_WIDTH 0x0100
#define FL_WIDTH_ARG 0x0200
#define FL_HAS_PREC 0x0400
#define FL_PREC_ARG 0x0800
#define FL_LEN_H 0x010000
#define FL_LEN_HH 0x020000
#define FL_LEN_L 0x040000
#define FL_LEN_LL 0x080000
#line 137 "format.rl"
#line 55 "format.c"
static const int format_start = 11;
static const int format_first_final = 11;
static const int format_error = 0;
static const int format_en_main = 11;
#line 140 "format.rl"
void format_init( struct format *fsm )
{
fsm->buflen = 0;
#line 69 "format.c"
{
fsm->cs = format_start;
}
#line 145 "format.rl"
}
void format_execute( struct format *fsm, const char *data, int len, int isEof )
{
const char *p = data;
const char *pe = data + len;
const char *eof = isEof ? pe : 0;
#line 84 "format.c"
{
if ( p == pe )
goto _test_eof;
switch ( fsm->cs )
{
tr3:
#line 113 "format.rl"
{
if ( fsm->buflen == BUFLEN ) {
fsm->write( fsm->buf, fsm->buflen );
fsm->buflen = 0;
}
fsm->buf[fsm->buflen++] = (*p);
}
goto st11;
tr10:
#line 99 "format.rl"
{
do_conv( fsm, (*p) );
}
goto st11;
tr14:
#line 63 "format.rl"
{ fsm->flags |= FL_HAS_WIDTH; }
#line 99 "format.rl"
{
do_conv( fsm, (*p) );
}
goto st11;
tr19:
#line 69 "format.rl"
{ fsm->flags |= FL_HAS_PREC; }
#line 99 "format.rl"
{
do_conv( fsm, (*p) );
}
goto st11;
tr22:
#line 86 "format.rl"
{ fsm->flags |= FL_LEN_H; }
#line 99 "format.rl"
{
do_conv( fsm, (*p) );
}
goto st11;
tr24:
#line 87 "format.rl"
{ fsm->flags |= FL_LEN_L; }
#line 99 "format.rl"
{
do_conv( fsm, (*p) );
}
goto st11;
st11:
if ( ++p == pe )
goto _test_eof11;
case 11:
#line 142 "format.c"
if ( (*p) == 37 )
goto tr26;
goto tr3;
tr26:
#line 51 "format.rl"
{
fsm->flags = 0;
fsm->width = 0;
fsm->prec = 0;
}
goto st1;
st1:
if ( ++p == pe )
goto _test_eof1;
case 1:
#line 158 "format.c"
switch( (*p) ) {
case 32: goto tr1;
case 35: goto tr2;
case 37: goto tr3;
case 42: goto tr4;
case 43: goto tr5;
case 45: goto tr6;
case 46: goto st4;
case 48: goto tr8;
case 88: goto tr10;
case 104: goto st6;
case 105: goto tr10;
case 108: goto st8;
case 115: goto tr10;
case 117: goto tr10;
case 120: goto tr10;
}
if ( (*p) < 99 ) {
if ( 49 <= (*p) && (*p) <= 57 )
goto tr9;
} else if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr10;
} else
goto tr10;
goto tr0;
tr0:
#line 128 "format.rl"
{
printf("ERROR ON CHAR: 0x%x\n", (*p) );
}
goto st0;
#line 191 "format.c"
st0:
fsm->cs = 0;
goto _out;
tr1:
#line 76 "format.rl"
{ fsm->flags |= FL_SPACE; }
goto st2;
tr2:
#line 73 "format.rl"
{ fsm->flags |= FL_HASH; }
goto st2;
tr5:
#line 77 "format.rl"
{ fsm->flags |= FL_PLUS; }
goto st2;
tr6:
#line 75 "format.rl"
{ fsm->flags |= FL_DASH; }
goto st2;
tr8:
#line 74 "format.rl"
{ fsm->flags |= FL_ZERO; }
goto st2;
st2:
if ( ++p == pe )
goto _test_eof2;
case 2:
#line 219 "format.c"
switch( (*p) ) {
case 32: goto tr1;
case 35: goto tr2;
case 42: goto tr4;
case 43: goto tr5;
case 45: goto tr6;
case 46: goto st4;
case 48: goto tr8;
case 88: goto tr10;
case 104: goto st6;
case 105: goto tr10;
case 108: goto st8;
case 115: goto tr10;
case 117: goto tr10;
case 120: goto tr10;
}
if ( (*p) < 99 ) {
if ( 49 <= (*p) && (*p) <= 57 )
goto tr9;
} else if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr10;
} else
goto tr10;
goto tr0;
tr4:
#line 62 "format.rl"
{ fsm->flags |= FL_WIDTH_ARG; }
goto st3;
st3:
if ( ++p == pe )
goto _test_eof3;
case 3:
#line 253 "format.c"
switch( (*p) ) {
case 46: goto tr13;
case 88: goto tr14;
case 104: goto tr15;
case 105: goto tr14;
case 108: goto tr16;
case 115: goto tr14;
case 117: goto tr14;
case 120: goto tr14;
}
if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr14;
} else if ( (*p) >= 99 )
goto tr14;
goto tr0;
tr13:
#line 63 "format.rl"
{ fsm->flags |= FL_HAS_WIDTH; }
goto st4;
st4:
if ( ++p == pe )
goto _test_eof4;
case 4:
#line 278 "format.c"
switch( (*p) ) {
case 42: goto tr17;
case 88: goto tr19;
case 104: goto tr20;
case 105: goto tr19;
case 108: goto tr21;
case 115: goto tr19;
case 117: goto tr19;
case 120: goto tr19;
}
if ( (*p) < 99 ) {
if ( 48 <= (*p) && (*p) <= 57 )
goto tr18;
} else if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr19;
} else
goto tr19;
goto tr0;
tr17:
#line 68 "format.rl"
{ fsm->flags |= FL_PREC_ARG; }
goto st5;
st5:
if ( ++p == pe )
goto _test_eof5;
case 5:
#line 306 "format.c"
switch( (*p) ) {
case 88: goto tr10;
case 104: goto st6;
case 105: goto tr10;
case 108: goto st8;
case 115: goto tr10;
case 117: goto tr10;
case 120: goto tr10;
}
if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr10;
} else if ( (*p) >= 99 )
goto tr10;
goto tr0;
tr15:
#line 63 "format.rl"
{ fsm->flags |= FL_HAS_WIDTH; }
goto st6;
tr20:
#line 69 "format.rl"
{ fsm->flags |= FL_HAS_PREC; }
goto st6;
st6:
if ( ++p == pe )
goto _test_eof6;
case 6:
#line 334 "format.c"
switch( (*p) ) {
case 88: goto tr22;
case 104: goto tr23;
case 105: goto tr22;
case 115: goto tr22;
case 117: goto tr22;
case 120: goto tr22;
}
if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr22;
} else if ( (*p) >= 99 )
goto tr22;
goto tr0;
tr23:
#line 88 "format.rl"
{ fsm->flags |= FL_LEN_HH; }
goto st7;
tr25:
#line 89 "format.rl"
{ fsm->flags |= FL_LEN_LL; }
goto st7;
st7:
if ( ++p == pe )
goto _test_eof7;
case 7:
#line 361 "format.c"
switch( (*p) ) {
case 88: goto tr10;
case 105: goto tr10;
case 115: goto tr10;
case 117: goto tr10;
case 120: goto tr10;
}
if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr10;
} else if ( (*p) >= 99 )
goto tr10;
goto tr0;
tr16:
#line 63 "format.rl"
{ fsm->flags |= FL_HAS_WIDTH; }
goto st8;
tr21:
#line 69 "format.rl"
{ fsm->flags |= FL_HAS_PREC; }
goto st8;
st8:
if ( ++p == pe )
goto _test_eof8;
case 8:
#line 387 "format.c"
switch( (*p) ) {
case 88: goto tr24;
case 105: goto tr24;
case 108: goto tr25;
case 115: goto tr24;
case 117: goto tr24;
case 120: goto tr24;
}
if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr24;
} else if ( (*p) >= 99 )
goto tr24;
goto tr0;
tr18:
#line 67 "format.rl"
{ fsm->prec = 10 * fsm->prec + ((*p)-'0'); }
goto st9;
st9:
if ( ++p == pe )
goto _test_eof9;
case 9:
#line 410 "format.c"
switch( (*p) ) {
case 88: goto tr19;
case 104: goto tr20;
case 105: goto tr19;
case 108: goto tr21;
case 115: goto tr19;
case 117: goto tr19;
case 120: goto tr19;
}
if ( (*p) < 99 ) {
if ( 48 <= (*p) && (*p) <= 57 )
goto tr18;
} else if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr19;
} else
goto tr19;
goto tr0;
tr9:
#line 61 "format.rl"
{ fsm->width = 10 * fsm->width + ((*p)-'0'); }
goto st10;
st10:
if ( ++p == pe )
goto _test_eof10;
case 10:
#line 437 "format.c"
switch( (*p) ) {
case 46: goto tr13;
case 88: goto tr14;
case 104: goto tr15;
case 105: goto tr14;
case 108: goto tr16;
case 115: goto tr14;
case 117: goto tr14;
case 120: goto tr14;
}
if ( (*p) < 99 ) {
if ( 48 <= (*p) && (*p) <= 57 )
goto tr9;
} else if ( (*p) > 100 ) {
if ( 111 <= (*p) && (*p) <= 112 )
goto tr14;
} else
goto tr14;
goto tr0;
}
_test_eof11: fsm->cs = 11; goto _test_eof;
_test_eof1: fsm->cs = 1; goto _test_eof;
_test_eof2: fsm->cs = 2; goto _test_eof;
_test_eof3: fsm->cs = 3; goto _test_eof;
_test_eof4: fsm->cs = 4; goto _test_eof;
_test_eof5: fsm->cs = 5; goto _test_eof;
_test_eof6: fsm->cs = 6; goto _test_eof;
_test_eof7: fsm->cs = 7; goto _test_eof;
_test_eof8: fsm->cs = 8; goto _test_eof;
_test_eof9: fsm->cs = 9; goto _test_eof;
_test_eof10: fsm->cs = 10; goto _test_eof;
_test_eof: {}
if ( p == eof )
{
switch ( fsm->cs ) {
case 11:
#line 121 "format.rl"
{
if ( fsm->buflen > 0 )
fsm->write( fsm->buf, fsm->buflen );
}
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
#line 125 "format.rl"
{
printf("EOF IN FORMAT\n");
}
#line 128 "format.rl"
{
printf("ERROR ON CHAR: 0x%x\n", (*p) );
}
break;
#line 500 "format.c"
}
}
_out: {}
}
#line 154 "format.rl"
}
int format_finish( struct format *fsm )
{
if ( fsm->cs == format_error )
return -1;
if ( fsm->cs >= format_first_final )
return 1;
return 0;
}
#define INPUT_BUFSIZE 2048
struct format fsm;
char buf[INPUT_BUFSIZE];
void write(char *data, int len )
{
fwrite( data, 1, len, stdout );
}
int main()
{
fsm.write = write;
format_init( &fsm );
while ( 1 ) {
int len = fread( buf, 1, INPUT_BUFSIZE, stdin );
int eof = len != INPUT_BUFSIZE;
format_execute( &fsm, buf, len, eof );
if ( eof )
break;
}
if ( format_finish( &fsm ) <= 0 )
printf("FAIL\n");
return 0;
}
|
the_stack_data/142187.c | #include <stdio.h>
#include <stdbool.h>
/**
* @author: Tanvir Singh
* @version: April 4, 2021
* @description: C program to calculate the date of Easter.
*/
int main() {
int G; //Golden Number (19-year Metonic cycle)
int Y = 2021; //Year
int C; //Century Number
int X; //Number of years in which leap year was dropped
int Z; //Special correction designed to synchronize easter with the moon's orbit
int D; //Sunday
int E; //epact "E"
int N; //Day
int M; //Month
/*
* First computing the golden number
*/
G = (Y % 19) + 1;
/*
* When Y is not multiple of 100, C is the century number
*/
C = (Y / 100) + 1;
/*
* X and Z are the corrections
* X is the number of years, such as 1900, in which leap year was dropped in order to keep in step with sum.
*/
X = ((3*C) / 4) - 12;
/*
* Z is special correction designed to synchronize Easter with the moon's orbit.
*/
Z = (((8*C) + 5) / 25) - 5;
/*
* Fins Sunday
*/
D = ((5 * Y) / 4) - X - 10;
/*
* Find the "epact" E
*/
E = ((11 * G) + 20 + Z - X) % 30;
bool full_moon_flag = false;
/*
* If E = 25 an golder number G is greater than 11, or if E = 24, then increase E by one.
* "epact" specifies when a full moon occurs
*/
if( ((E == 25) && (G > 11)) || (E == 24)){
E += 1;
full_moon_flag = true;
}
/*
* Find full moon
*/
N = 44 - E;
/*
* If N is less than 21 then add 30 to N
* (Easter is supposedly the "first Sunday following the first full moon which occurs on or after March 21."
* Perturbations in the moon's orbit do not make this strictly true, but we are here concerned with the "calendar moon" rather than the actual moon.
* Ths Nth of March is a calendar full moon.
*/
if(N < 21){
N += 30;
}
/*
* Advance to Sunday
*/
N = N + 7 - ((D + N) % 7);
/*
* Get month
* If N is greater than 31, the month M is 4 and day N is (N - 31)
* otherwise the month M is 3 and the day is N.
*/
if(N > 31){
M = 4;
N = (N - 31);
}else{
M = 3;
N = N;
}
printf("Day %d\n", N);
printf("Month: %d\n", M);
printf("Year: %d\n", Y);
return 0;
}
|
the_stack_data/522065.c | /**
* Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight).
* Note:
* Note that in some languages, such as Java, there is no unsigned integer type.
* In this case, the input will be given as a signed integer type.
* It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
* In Java, the compiler represents the signed integers using 2's complement notation.
* Therefore, in Example 3, the input represents the signed integer. -3.
*
*
* Example 1:
* Input: n = 00000000000000000000000000001011
* Output: 3
* Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.
*
* Example 2:
* Input: n = 00000000000000000000000010000000
* Output: 1
* Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.
*
* Example 3:
* Input: n = 11111111111111111111111111111101
* Output: 31
* Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.
*
*
* Constraints:
* The input must be a binary string of length 32.
*
*
* Follow up: If this function is called many times, how would you optimize it?
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int hammingWeight(uint32_t n) {
int count = 0;
for(int i=0; i<32; ++i)
{
if((n>>i)&1)
++count;
}
return count;
} |
the_stack_data/225142539.c | struct buffers
{
unsigned char buff1[50];
unsigned char *buff2;
} globalBuff1,*globalBuff2;
unsigned char * globalBuff;
void badFunc0_0(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
}
void nobadFunc0_0(){
unsigned char buff1[12];
memset(buff1,12,12);
}
void nobadFunc0_1(){
unsigned char buff1[12];
int i;
memset(buff1,12,12);
for(i=0;i<12;i++)
buff1[i]=13;
free(buff1);
}
void nobadFunc1_0(){
unsigned char * buff1;
buff1 = (unsigned char *) malloc(12);
memset(buff1,12,12);
}
void badFunc1_0(){
unsigned char * buff1;
buff1 = (unsigned char *) malloc(12);
memset(buff1,12,12);
free(buff1);
}
void badFunc1_1(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
free(buff1);
}
void nobadFunc2_0_0(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
printf(buff1);
}
void nobadFunc2_0_1(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
printf(buff1+3);
}
void nobadFunc2_0_2(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
printf(*buff1);
}
void nobadFunc2_0_3(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
printf(*(buff1+3));
}
unsigned char * nobadFunc2_0_4(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
return buff1;
}
unsigned char * nobadFunc2_0_5(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
return buff1+3;
}
unsigned char nobadFunc2_0_6(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
return *buff1;
}
unsigned char nobadFunc2_0_7(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
return *(buff1+3);
}
void nobadFunc2_1_0(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
if(*buff1==0)
printf("123123");
}
void nobadFunc2_1_1(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
if(*(buff1+3)==0)
printf("123123");
}
void nobadFunc2_1_2(){
unsigned char buff1[12];
int i;
for(i=0;i<12;i++)
buff1[i]=13;
memset(buff1,12,12);
buff1[2]=5;
}
void nobadFunc3_0(unsigned char * buffAll){
unsigned char * buff1 = buffAll;
memset(buff1,12,12);
}
void nobadFunc3_1(unsigned char * buffAll){
unsigned char * buff1 = buffAll+3;
memset(buff1,12,12);
}
void nobadFunc3_2(struct buffers buffAll){
unsigned char * buff1 = buffAll.buff1;
memset(buff1,12,12);
}
void nobadFunc3_3(struct buffers buffAll){
unsigned char * buff1 = buffAll.buff2;
memset(buff1,12,12);
}
void nobadFunc3_4(struct buffers buffAll){
unsigned char * buff1 = buffAll.buff2+3;
memset(buff1,12,12);
}
void nobadFunc3_5(struct buffers * buffAll){
unsigned char * buff1 = buffAll->buff1;
memset(buff1,12,12);
}
void nobadFunc3_6(struct buffers *buffAll){
unsigned char * buff1 = buffAll->buff2;
memset(buff1,12,12);
}
void nobadFunc4(){
unsigned char * buff1 = globalBuff;
memset(buff1,12,12);
}
void nobadFunc4_0(){
unsigned char * buff1 = globalBuff;
memset(buff1,12,12);
}
void nobadFunc4_1(){
unsigned char * buff1 = globalBuff+3;
memset(buff1,12,12);
}
void nobadFunc4_2(){
unsigned char * buff1 = globalBuff1.buff1;
memset(buff1,12,12);
}
void nobadFunc4_3(){
unsigned char * buff1 = globalBuff1.buff2;
memset(buff1,12,12);
}
void nobadFunc4_4(){
unsigned char * buff1 = globalBuff1.buff2+3;
memset(buff1,12,12);
}
void nobadFunc4_5(){
unsigned char * buff1 = globalBuff2->buff1;
memset(buff1,12,12);
}
void nobadFunc4_6(){
unsigned char * buff1 = globalBuff2->buff2;
memset(buff1,12,12);
}
|
the_stack_data/181393978.c | /* $OpenBSD: yes.c,v 1.9 2015/10/13 07:03:26 doug Exp $ */
/* $NetBSD: yes.c,v 1.3 1994/11/14 04:56:15 jtc Exp $ */
/*
* Copyright (c) 1987, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <err.h>
#include <stdio.h>
#include <unistd.h>
int
main(int argc, char *argv[])
{
if (pledge("stdio", NULL) == -1)
err(1, "pledge");
if (argc > 1)
for (;;)
puts(argv[1]);
else
for (;;)
puts("y");
}
|
the_stack_data/185387.c | int sub(int a,int b){
return(a-b);
}
|
the_stack_data/48965.c | /*
* Copyright (c) 2015-2019 Contributors as noted in the AUTHORS file
*
* This file is part of Solo5, a sandboxed execution environment.
*
* Permission to use, copy, modify, and/or distribute this software
* for any purpose with or without fee is hereby granted, provided
* that the above copyright notice and this permission notice appear
* in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* tap_attach.c: Common functions for attaching to TAP interfaces.
*/
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <ifaddrs.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#if defined(__linux__)
/*
* Linux TAP device specific.
*/
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/if_tun.h>
#elif defined(__FreeBSD__)
#include <net/if.h>
#elif defined(__OpenBSD__)
#include <sys/socket.h>
#include <net/if.h>
#else /* !__linux__ && !__FreeBSD__ && !__OpenBSD__ */
#error Unsupported target
#endif
int tap_attach(const char *ifname)
{
int fd;
/*
* Syntax @<number> indicates a pre-existing open fd, so just pass it
* through if the supplied <number> is in range and O_NONBLOCK can be set.
*/
if (ifname[0] == '@') {
char *endp;
long int maybe_fd = strtol(&ifname[1], &endp, 10);
if (*endp != 0 /* Invalid character at (*endp)? */
|| endp == &ifname[1] /* Empty string? */)
errno = EINVAL;
else if (maybe_fd < 0 || maybe_fd > INT_MAX)
errno = ERANGE;
if (errno)
return -1;
fd = (int)maybe_fd;
if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1)
return -1;
return fd;
}
else if (strlen(ifname) >= IFNAMSIZ) {
errno = ENAMETOOLONG;
return -1;
}
/*
* Verify that the interface exists and is up and running. If we don't do
* this then we get "create on open" behaviour on most systems which is not
* what we want.
*/
struct ifaddrs *ifa, *ifp;
int found = 0;
int up = 0;
if (getifaddrs(&ifa) == -1)
return -1;
ifp = ifa;
while (ifp) {
if (strncmp(ifp->ifa_name, ifname, IFNAMSIZ) == 0) {
found = 1;
up = ifp->ifa_flags & (IFF_UP | IFF_RUNNING);
break;
}
ifp = ifp->ifa_next;
}
freeifaddrs(ifa);
if (!found) {
errno = ENOENT;
return -1;
}
#if defined(__linux__)
if (!up) {
errno = ENETDOWN;
return -1;
}
int err;
struct ifreq ifr;
fd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (fd == -1)
return -1;
/*
* Initialise ifr for TAP interface.
*/
memset(&ifr, 0, sizeof(ifr));
/*
* TODO: IFF_NO_PI may silently truncate packets on read().
*/
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
/*
* Attach to the tap device; we have already verified that it exists, but
* see below.
*/
if (ioctl(fd, TUNSETIFF, (void *)&ifr) == -1) {
err = errno;
close(fd);
errno = err;
return -1;
}
/*
* If we got back a different device than the one requested, e.g. because
* the caller mistakenly passed in '%d' (yes, that's really in the Linux
* API) then fail.
*/
if (strncmp(ifr.ifr_name, ifname, IFNAMSIZ) != 0) {
close(fd);
errno = EINVAL;
return -1;
}
#elif defined(__FreeBSD__)
char devname[strlen(ifname) + 6];
snprintf(devname, sizeof devname, "/dev/%s", ifname);
fd = open(devname, O_RDWR | O_NONBLOCK);
if (fd == -1)
return -1;
#elif defined(__OpenBSD__)
if (!up) {
errno = ENETDOWN;
return -1;
}
char devname[strlen(ifname) + 6];
snprintf(devname, sizeof devname, "/dev/%s", ifname);
fd = open(devname, O_RDWR | O_NONBLOCK);
if (fd == -1)
return -1;
#endif
return fd;
}
void tap_attach_genmac(uint8_t *mac)
{
int rfd = open("/dev/urandom", O_RDONLY);
if (rfd == -1)
err(1, "Could not open /dev/urandom");
int ret;
ret = read(rfd, mac, 6);
assert(ret == 6);
close(rfd);
mac[0] &= 0xfe;
mac[0] |= 0x02;
}
|
the_stack_data/7950452.c | #include <stdio.h>
int Faktorijel(int x){
int i; int fakt=1;
if(x>=1){
for(i=1;i<=x;i++)
{
fakt=fakt*i;
}
} else fakt=1;
return fakt;
}
int main() {
int n;
int i;
double x, suma=0;
printf("Unesite broj n u intervalu [1, 12]: ");
scanf("%d", &n);
printf("Unesite realan broj x: ");
scanf("%lf", &x);
for(i=1;i<=n;i++)
{
suma= suma + (x/Faktorijel(i));
}
printf("Suma od 1 do %d za x = %.3f je %.3f", n, x, suma);
return 0;
}
|
the_stack_data/151705360.c | /* gprof-helper.c -- preload library to profile pthread-enabled programs
*
* Authors: Sam Hocevar <sam at zoy dot org>
* Daniel Jönsson <danieljo at fagotten dot org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the Do What The Fuck You Want To
* Public License as published by Banlu Kemiyatorn. See
* http://sam.zoy.org/projects/COPYING.WTFPL for more details.
*
* Compilation example:
* gcc -shared -fPIC gprof-helper.c -o gprof-helper.so -lpthread -ldl
*
* Usage example:
* LD_PRELOAD=./gprof-helper.so your_program
*/
#define _GNU_SOURCE
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pthread.h>
static void * wrapper_routine(void *);
/* Original pthread function */
static int (*pthread_create_orig)(pthread_t *__restrict,
__const pthread_attr_t *__restrict,
void *(*)(void *),
void *__restrict) = NULL;
/* Library initialization function */
void wooinit(void) __attribute__((constructor));
void wooinit(void)
{
pthread_create_orig = dlsym(RTLD_NEXT, "pthread_create");
fprintf(stderr, "pthreads: using profiling hooks for gprof\n");
if(pthread_create_orig == NULL)
{
char *error = dlerror();
if(error == NULL)
{
error = "pthread_create is NULL";
}
fprintf(stderr, "%s\n", error);
exit(EXIT_FAILURE);
}
}
/* Our data structure passed to the wrapper */
typedef struct wrapper_s
{
void * (*start_routine)(void *);
void * arg;
pthread_mutex_t lock;
pthread_cond_t wait;
struct itimerval itimer;
} wrapper_t;
/* The wrapper function in charge for setting the itimer value */
static void * wrapper_routine(void * data)
{
/* Put user data in thread-local variables */
void * (*start_routine)(void *) = ((wrapper_t*)data)->start_routine;
void * arg = ((wrapper_t*)data)->arg;
/* Set the profile timer value */
setitimer(ITIMER_PROF, &((wrapper_t*)data)->itimer, NULL);
/* Tell the calling thread that we don't need its data anymore */
pthread_mutex_lock(&((wrapper_t*)data)->lock);
pthread_cond_signal(&((wrapper_t*)data)->wait);
pthread_mutex_unlock(&((wrapper_t*)data)->lock);
/* Call the real function */
return start_routine(arg);
}
/* Our wrapper function for the real pthread_create() */
int pthread_create(pthread_t *__restrict thread,
__const pthread_attr_t *__restrict attr,
void * (*start_routine)(void *),
void *__restrict arg)
{
wrapper_t wrapper_data;
int i_return;
/* Initialize the wrapper structure */
wrapper_data.start_routine = start_routine;
wrapper_data.arg = arg;
getitimer(ITIMER_PROF, &wrapper_data.itimer);
pthread_cond_init(&wrapper_data.wait, NULL);
pthread_mutex_init(&wrapper_data.lock, NULL);
pthread_mutex_lock(&wrapper_data.lock);
/* The real pthread_create call */
i_return = pthread_create_orig(thread,
attr,
&wrapper_routine,
&wrapper_data);
/* If the thread was successfully spawned, wait for the data
* to be released */
if(i_return == 0)
{
pthread_cond_wait(&wrapper_data.wait, &wrapper_data.lock);
}
pthread_mutex_unlock(&wrapper_data.lock);
pthread_mutex_destroy(&wrapper_data.lock);
pthread_cond_destroy(&wrapper_data.wait);
return i_return;
}
|
the_stack_data/548774.c | #include <stdio.h>
int main(void)
{
printf("hello, world\n");
}
|
the_stack_data/486501.c | int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
void main()
{
printid(a);
getid(a);
printid(a);
} |
the_stack_data/128696.c | #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#define MAX_BUF 200
#define ULL_BITS (sizeof(unsigned long long) * 8)
struct bigN {
unsigned long long len;
unsigned long long *num;
};
// init to zero, and len = 1
struct bigN* bigN_init(struct bigN *a);
// set to zero, and len = 1
struct bigN* bigN_clear(struct bigN *a);
// free memory
void bigN_free(struct bigN *a);
// sign extend (for now, only bigger)
struct bigN* bigN_extend(struct bigN *a, unsigned long long len);
// parse hex string to bigN
struct bigN* bigN_parse_hex(struct bigN *a, char *buf);
// display hex
void bigN_display_hex(struct bigN *a);
// display bytes in hex to debug
void bigN_display_byte(struct bigN *a);
// a <= b (deep copy)
struct bigN* bigN_copy(struct bigN *a, struct bigN *b);
// a <= -a
struct bigN* bigN_neg(struct bigN *a);
// a <= a + b
struct bigN* bigN_add(struct bigN *a, struct bigN *b);
// a <= a + 1
struct bigN* bigN_add1(struct bigN *a);
// a <= a + (-b)
struct bigN* bigN_sub(struct bigN *a, struct bigN *b);
// compare (a > b)
// int bigN_compare(struct bigN *a, struct bigN *b);
struct bigN* bigN_init(struct bigN *a)
{
a->len = 2ULL;
a->num = malloc(2 * sizeof(unsigned long long));
a->num[0] = 0ULL;
a->num[1] = 0ULL;
return a;
}
void bigN_free(struct bigN *a)
{
free(a->num);
a->len = 0;
}
struct bigN* bigN_clear(struct bigN *a)
{
bigN_free(a);
return bigN_init(a);
}
struct bigN* bigN_extend(struct bigN *a, unsigned long long len)
{
unsigned long long *backup_num = a->num;
unsigned long long backup_len = a->len;
a->len = len;
a->num = realloc(backup_num, sizeof(unsigned long long) * len);
// sign extend
unsigned long long sign_val = (a->num[backup_len - 1] >> (ULL_BITS - 1) ? ULLONG_MAX : 0ULL);
for(; backup_len < a->len; backup_len++){
a->num[backup_len] = sign_val;
}
return a;
}
struct bigN* bigN_parse_hex(struct bigN *a, char *buf_arg)
{
int buf_len = strlen(buf_arg);
int len = buf_len / 16 + 2;
int neg_flag = 0;
char *buf = buf_arg;
if(buf_len > 0 && buf[0] == '-'){
neg_flag = 1;
buf = buf_arg + 1;
buf_len--;
}
bigN_clear(a);
bigN_extend(a, len);
// for end to begin of buffer, convert every 16 byte HEX to 1 unsigned long long
int i = 0;
for(; buf_len >= 0 && i < len; buf_len -= 16, i++){
int start = (buf_len - 17 >= 0 ? buf_len - 17 : 0);
int end = buf_len;
char *endptr;
unsigned long long val = strtoull(buf + start, &endptr, 16);
a->num[i] = val;
buf[start] = '\0';
}
if(neg_flag){
bigN_neg(a);
}
return a;
}
struct bigN* bigN_neg(struct bigN *a)
{
int i = 0;
for(; i < a->len; i++){
a->num[i] = ~a->num[i];
}
return a;
}
struct bigN* bigN_add1(struct bigN *a)
{
// full adder, we want to add 1, set carry to 1
unsigned long long sum = 0;
unsigned long long carry = 1;
unsigned long long next_carry = 0;
int i = 0;
for(; i < a->len; i++){
if(a->num[i] > ULLONG_MAX - carry){
// overflow
next_carry = 1;
}
a->num[i] = a->num[i] + carry;
carry = next_carry;
next_carry = 0;
}
return a;
}
struct bigN* bigN_add(struct bigN *a, struct bigN *b)
{
// sign extend
unsigned long long max_len;
if(a->len > b->len){
max_len = a->len;
}
else{
max_len = b->len;
}
bigN_extend(a, max_len);
bigN_extend(b, max_len);
unsigned long long sum = 0;
unsigned long long carry = 0;
unsigned long long next_carry = 0;
int i = 0;
for(; i < max_len; i++){
unsigned long long num_a = a->num[i], num_b = b->num[i];
if(num_a == ~0ULL && num_b == ~0ULL){
// overflow
next_carry = 1;
}
else if(num_a >= num_b && a->num[i] > ULLONG_MAX - carry - b->num[i]){
// overflow
next_carry = 1;
}
else if(b->num[i] > ULLONG_MAX - carry - a->num[i]){
// overflow
next_carry = 1;
}
a->num[i] = a->num[i] + carry + b->num[i];
carry = next_carry;
next_carry = 0;
}
return a;
}
struct bigN* bigN_sub(struct bigN *a, struct bigN *b)
{
struct bigN c;
bigN_init(&c);
bigN_copy(&c, b);
bigN_neg(&c);
bigN_add(a, &c);
bigN_free(&c);
return a;
}
struct bigN* bigN_copy(struct bigN *a, struct bigN *b)
{
bigN_free(a);
a->len = b->len;
a->num = malloc(a->len * sizeof(unsigned long long));
memcpy(a->num, b->num, a->len * sizeof(unsigned long long));
return a;
}
void bigN_display_byte(struct bigN *a)
{
int i = a->len - 1;
printf("0x");
for(; i >= 0; i--){
printf("%016llx", a->num[i]);
}
puts("");
}
void bigN_display_hex(struct bigN *a)
{
if(a->num[a->len - 1] >> (ULL_BITS - 1)){
// neg
struct bigN b;
bigN_init(&b);
bigN_copy(&b, a);
bigN_neg(&b);
printf("-");
bigN_display_byte(&b);
bigN_free(&b);
}
else{
bigN_display_byte(a);
}
}
int main()
{
struct bigN a, b;
struct bigN a1, b1;
bigN_init(&a);
bigN_init(&b);
bigN_init(&a1);
bigN_init(&b1);
// input hex, i'm lazy to convert hex to dec
char buffer[MAX_BUF + 1];
fgets(buffer, MAX_BUF, stdin);
bigN_parse_hex(&a, buffer);
fgets(buffer, MAX_BUF, stdin);
bigN_parse_hex(&b, buffer);
bigN_copy(&a1, &a);
bigN_copy(&b1, &b);
puts("a & b");
bigN_display_hex(&a1);
bigN_display_hex(&b1);
puts("");
puts("(a - b)");
bigN_sub(&a1, &b1);
bigN_display_hex(&a1);
bigN_free(&a);
bigN_free(&b);
return 0;
}
|
the_stack_data/20327.c |
/* Author: E13200
* Title : Lab02-Excercise1.2-a
* Date : 2017.08.20
* Description : This code will read a text file and writes the output to the standard output
* according to the user specified path. You have to compile the file and the give the command line argumets as follows.
*
* gcc -Wall mycat.c -o test
* follow this formact './testIO <in.txt> 'for example,
* ./test /home/e13200/Desktop/test.txt
* */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h> // header file for the open() function
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
int main(int argc, char const *argv[]){
/* size_t. Unsigned integral type. Alias of one of the fundamental unsigned integer types.
* It is a type able to represent the size of any object in bytes: size_t is the type
* returned by the sizeof operator and is widely used in the standard library to represent
* sizes and counts.
* */
int out;
int buf_size = 1000;
size_t ret;
if (argc != 2){
fprintf(stderr,"Argument error.Please enter correct number of arguments\n");
return 1;
}
// Openning the file to read (only for read)
out = open(argv[1], O_RDONLY);
if(out == -1)
{
fprintf(stderr,"Couldn't open the file\n");
return 1;
}
// Reading data from the file using buffer.
char* buffer = malloc(buf_size+1);
ret = read(out,buffer,buf_size);
if(ret == -1)
{
fprintf(stderr,"Error reading from file\n");
return 1;
}
// We have to null terminate the string ourselves.
buffer[ret] = '\0';
// Writes text file to stdout
printf("The string read back is: %s\n",buffer);
// Close the buffer
free(buffer);
ret = close(out);
if(ret == -1)
{
fprintf(stderr,"Error closing the file after reading.\n");
return 1;
}
return 0;
}
|
the_stack_data/234518541.c | typedef int a;
typedef a *b;
int main()
{
b c[5];
printf("%d", sizeof(a));
return 0 ;
}
|
the_stack_data/182951693.c | // RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \
// RUN: --target=i386-unknown-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-I386 %s
// CHECK-I386: "-cc1" "-triple" "i386-unknown-linux-gnu"
// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\\\}}as" "--32"
// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf_i386"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \
// RUN: --target=x86_64-unknown-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-X86-64 %s
// CHECK-X86-64: "-cc1" "-triple" "x86_64-unknown-linux-gnu"
// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}as" "--64"
// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf_x86_64"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \
// RUN: --target=x86_64-unknown-linux-gnux32 \
// RUN: | FileCheck --check-prefix=CHECK-X32 %s
// CHECK-X32: "-cc1" "-triple" "x86_64-unknown-linux-gnux32"
// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}as" "--x32"
// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf32_x86_64"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \
// RUN: --target=x86_64-unknown-linux-gnu -m32 \
// RUN: | FileCheck --check-prefix=CHECK-I386 %s
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \
// RUN: --target=i386-unknown-linux-gnu -m64 \
// RUN: | FileCheck --check-prefix=CHECK-X86-64 %s
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/multilib_32bit_linux_tree/usr \
// RUN: --target=i386-unknown-linux \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MULTI32-I386 %s
// CHECK-MULTI32-I386: "-cc1" "-triple" "i386-unknown-linux"
// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}as" "--32"
// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}ld"
// CHECK-MULTI32-I386: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]"
// CHECK-MULTI32-I386: "-m" "elf_i386"
// CHECK-MULTI32-I386: "crti.o" "[[gcc_install:.*/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0]]{{/|\\\\}}crtbegin.o"
// CHECK-MULTI32-I386: "-L[[gcc_install]]"
// CHECK-MULTI32-I386: "-L[[gcc_install]]/../../../../i386-unknown-linux/lib/../lib32"
// CHECK-MULTI32-I386: "-L[[gcc_install]]/../../../../i386-unknown-linux/lib"
// CHECK-MULTI32-I386: "-L[[sysroot]]/lib"
// CHECK-MULTI32-I386: "-L[[sysroot]]/usr/lib"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/multilib_32bit_linux_tree/usr \
// RUN: --target=x86_64-unknown-linux \
// RUN: --rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MULTI32-X86-64 %s
// CHECK-MULTI32-X86-64: "-cc1" "-triple" "x86_64-unknown-linux"
// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}as" "--64"
// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}ld"
// CHECK-MULTI32-X86-64: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]"
// CHECK-MULTI32-X86-64: "-m" "elf_x86_64"
// CHECK-MULTI32-X86-64: "crti.o" "[[gcc_install:.*/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0]]/64{{/|\\\\}}crtbegin.o"
// CHECK-MULTI32-X86-64: "-L[[gcc_install]]/64"
// CHECK-MULTI32-X86-64: "-L[[gcc_install]]/../../../../i386-unknown-linux/lib/../lib64"
// CHECK-MULTI32-X86-64: "-L[[gcc_install]]"
// CHECK-MULTI32-X86-64: "-L[[gcc_install]]/../../../../i386-unknown-linux/lib"
// CHECK-MULTI32-X86-64: "-L[[sysroot]]/lib"
// CHECK-MULTI32-X86-64: "-L[[sysroot]]/usr/lib"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/multilib_64bit_linux_tree/usr \
// RUN: --target=i386-unknown-linux \
// RUN: --rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MULTI64-I386 %s
// CHECK-MULTI64-I386: "-cc1" "-triple" "i386-unknown-linux"
// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}as" "--32"
// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}ld"
// CHECK-MULTI64-I386: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]"
// CHECK-MULTI64-I386: "-m" "elf_i386"
// CHECK-MULTI64-I386: "crti.o" "[[gcc_install:.*/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0]]/32{{/|\\\\}}crtbegin.o"
// CHECK-MULTI64-I386: "-L[[gcc_install]]/32"
// CHECK-MULTI64-I386: "-L[[gcc_install]]/../../../../x86_64-unknown-linux/lib/../lib32"
// CHECK-MULTI64-I386: "-L[[gcc_install]]"
// CHECK-MULTI64-I386: "-L[[gcc_install]]/../../../../x86_64-unknown-linux/lib"
// CHECK-MULTI64-I386: "-L[[sysroot]]/lib"
// CHECK-MULTI64-I386: "-L[[sysroot]]/usr/lib"
//
// RUN: %clang -### -o %t %s 2>&1 -no-integrated-as -fuse-ld=ld \
// RUN: --gcc-toolchain=%S/Inputs/multilib_64bit_linux_tree/usr \
// RUN: --target=x86_64-unknown-linux \
// RUN: --rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MULTI64-X86-64 %s
// CHECK-MULTI64-X86-64: "-cc1" "-triple" "x86_64-unknown-linux"
// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}as" "--64"
// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}ld"
// CHECK-MULTI64-X86-64: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]"
// CHECK-MULTI64-X86-64: "-m" "elf_x86_64"
// CHECK-MULTI64-X86-64: "crti.o" "[[gcc_install:.*/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0]]{{/|\\\\}}crtbegin.o"
// CHECK-MULTI64-X86-64: "-L[[gcc_install]]"
// CHECK-MULTI64-X86-64: "-L[[gcc_install]]/../../../../x86_64-unknown-linux/lib/../lib64"
// CHECK-MULTI64-X86-64: "-L[[gcc_install]]/../../../../x86_64-unknown-linux/lib"
// CHECK-MULTI64-X86-64: "-L[[sysroot]]/lib"
// CHECK-MULTI64-X86-64: "-L[[sysroot]]/usr/lib"
|
the_stack_data/57829.c | int foo() { return 5; }
int bar(int X) { return X; }
int main() {
/* foo() is inlined below */
int R0;
#pragma spf assert nomacro
{ R0 = 5; }
/* bar(foo()) is inlined below */
int R1;
#pragma spf assert nomacro
{
int X0 = R0;
R1 = X0;
}
/* foo() is inlined below */
int R2;
#pragma spf assert nomacro
{ R2 = 5; }
int X = R1 + R2;
return 0;
}
|
the_stack_data/103265370.c | /* $OpenBSD: pem_all.c,v 1.15 2014/07/11 08:44:49 jsing Exp $ */
/* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
/* ====================================================================
* Copyright (c) 1998-2002 The OpenSSL Project. 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. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* [email protected].
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED 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 OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* ([email protected]). This product includes software written by Tim
* Hudson ([email protected]).
*
*/
#include <stdio.h>
#include <openssl/opensslconf.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/pkcs7.h>
#include <openssl/x509.h>
#ifndef OPENSSL_NO_DH
#include <openssl/dh.h>
#endif
#ifndef OPENSSL_NO_DSA
#include <openssl/dsa.h>
#endif
#ifndef OPENSSL_NO_RSA
#include <openssl/rsa.h>
#endif
#ifndef OPENSSL_NO_RSA
static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa);
#endif
#ifndef OPENSSL_NO_DSA
static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa);
#endif
#ifndef OPENSSL_NO_EC
static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey);
#endif
IMPLEMENT_PEM_rw(X509_REQ, X509_REQ, PEM_STRING_X509_REQ, X509_REQ)
IMPLEMENT_PEM_write(X509_REQ_NEW, X509_REQ, PEM_STRING_X509_REQ_OLD, X509_REQ)
IMPLEMENT_PEM_rw(X509_CRL, X509_CRL, PEM_STRING_X509_CRL, X509_CRL)
IMPLEMENT_PEM_rw(PKCS7, PKCS7, PEM_STRING_PKCS7, PKCS7)
IMPLEMENT_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE,
PEM_STRING_X509, NETSCAPE_CERT_SEQUENCE)
#ifndef OPENSSL_NO_RSA
/* We treat RSA or DSA private keys as a special case.
*
* For private keys we read in an EVP_PKEY structure with
* PEM_read_bio_PrivateKey() and extract the relevant private
* key: this means can handle "traditional" and PKCS#8 formats
* transparently.
*/
static RSA *
pkey_get_rsa(EVP_PKEY *key, RSA **rsa)
{
RSA *rtmp;
if (!key)
return NULL;
rtmp = EVP_PKEY_get1_RSA(key);
EVP_PKEY_free(key);
if (!rtmp)
return NULL;
if (rsa) {
RSA_free(*rsa);
*rsa = rtmp;
}
return rtmp;
}
RSA *
PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **rsa, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_rsa(pktmp, rsa);
}
RSA *
PEM_read_RSAPrivateKey(FILE *fp, RSA **rsa, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_rsa(pktmp, rsa);
}
IMPLEMENT_PEM_write_cb_const(RSAPrivateKey, RSA, PEM_STRING_RSA, RSAPrivateKey)
IMPLEMENT_PEM_rw_const(RSAPublicKey, RSA, PEM_STRING_RSA_PUBLIC, RSAPublicKey)
IMPLEMENT_PEM_rw(RSA_PUBKEY, RSA, PEM_STRING_PUBLIC, RSA_PUBKEY)
#endif
#ifndef OPENSSL_NO_DSA
static DSA *
pkey_get_dsa(EVP_PKEY *key, DSA **dsa)
{
DSA *dtmp;
if (!key)
return NULL;
dtmp = EVP_PKEY_get1_DSA(key);
EVP_PKEY_free(key);
if (!dtmp)
return NULL;
if (dsa) {
DSA_free(*dsa);
*dsa = dtmp;
}
return dtmp;
}
DSA *
PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
}
IMPLEMENT_PEM_write_cb_const(DSAPrivateKey, DSA, PEM_STRING_DSA, DSAPrivateKey)
IMPLEMENT_PEM_rw(DSA_PUBKEY, DSA, PEM_STRING_PUBLIC, DSA_PUBKEY)
DSA *
PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
}
IMPLEMENT_PEM_rw_const(DSAparams, DSA, PEM_STRING_DSAPARAMS, DSAparams)
#endif
#ifndef OPENSSL_NO_EC
static EC_KEY *
pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey)
{
EC_KEY *dtmp;
if (!key)
return NULL;
dtmp = EVP_PKEY_get1_EC_KEY(key);
EVP_PKEY_free(key);
if (!dtmp)
return NULL;
if (eckey) {
EC_KEY_free(*eckey);
*eckey = dtmp;
}
return dtmp;
}
EC_KEY *
PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
return pkey_get_eckey(pktmp, key); /* will free pktmp */
}
IMPLEMENT_PEM_rw_const(ECPKParameters, EC_GROUP, PEM_STRING_ECPARAMETERS,
ECPKParameters)
IMPLEMENT_PEM_write_cb(ECPrivateKey, EC_KEY, PEM_STRING_ECPRIVATEKEY,
ECPrivateKey)
IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
EC_KEY *
PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb, void *u)
{
EVP_PKEY *pktmp;
pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
return pkey_get_eckey(pktmp, eckey); /* will free pktmp */
}
#endif
#ifndef OPENSSL_NO_DH
IMPLEMENT_PEM_rw_const(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
#endif
IMPLEMENT_PEM_rw(PUBKEY, EVP_PKEY, PEM_STRING_PUBLIC, PUBKEY)
|
the_stack_data/111314.c | struct s {
int:16;
int f:16;
} __attribute__((__packed__));
static void foo(struct s s)
{
while (s.f)
;
}
/*
* check-name: packed-bitfield
* check-command: test-linearize -fmem2reg $file
*
* check-output-contains: store.32
* check-output-contains: load.16
*
* check-output-start
foo:
.L0:
<entry-point>
store.32 %arg1 -> 0[s]
br .L4
.L4:
load.16 %r1 <- 2[s]
cbr %r1, .L4, .L3
.L3:
ret
* check-output-end
*/
|
the_stack_data/136452.c | #include <stdio.h>
#include <stdlib.h>
struct sPILHA{
int pos, *arr;
int MAX;
};
typedef struct sPILHA PILHA;
void criar(PILHA *pi, int tam_MAX);
void push(PILHA *pi, int dado);
int pop(PILHA *pi);
int tamanho(PILHA *pi);
void imprimir(PILHA *pi);
void apagar(PILHA *pi);
int main(void) {
PILHA pilha1, pilha2, pilha3;
criar(&pilha1, 5);
criar(&pilha2, 2);
push(&pilha1, 10);
push(&pilha1, 11);
push(&pilha1, 12);
imprimir(&pilha1);
push(&pilha2, 13);
push(&pilha2, 14);
push(&pilha2, 15);
imprimir(&pilha2);
printf("Pop em Pilha 1 -> %d\n", pop(&pilha1));
printf("Pop em Pilha 2 -> %d\n", pop(&pilha2));
imprimir(&pilha1);
imprimir(&pilha2);
apagar(&pilha1);
apagar(&pilha2);
return 0;
}
void criar(PILHA *pi, int tam_MAX) {
pi->pos = 0;
pi->arr = malloc(sizeof(struct sPILHA) * tam_MAX);
pi->MAX = tam_MAX;
}
void push(PILHA *pi, int dado){
if (pi->pos < pi->MAX)
pi->arr[pi->pos++] = dado;
else
printf("Nao foi possivel inserir %d. Pilha cheia.\n", dado);
}
int pop(PILHA *pi) {
if (pi->pos)
return pi->arr[--pi->pos];
else {
printf("Nao ha elementos. Pilha vazia.\n");
exit(1);
}
}
int tamanho(PILHA *pi){
return pi->pos;
}
void imprimir(PILHA *pi){
printf("P[ ");
for (int i = pi->pos -1 ; i >= 0 ; i--)
printf("%d ", pi->arr[i]);
printf("]\n");
}
void apagar(PILHA *pi){
pi->pos = 0;
free(pi->arr);
} |
the_stack_data/98574228.c |
#include <stdio.h>
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 1; j <= (5 - i); j++)
{
printf(" ");
}
for (int j = 1; j <= i; j++)
{
if (i % 2 == 0)
{
printf("%d", i);
}
else
{
printf("%c", i + 64);
}
}
printf("\n");
}
return 0;
} |
the_stack_data/557638.c | /*******************************************************************************
*
* Copyright (C) 2014-2018 Wave Computing, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/* string to unsigned long */
#include <stdlib.h>
extern unsigned long _strtoxl (const char *, char **, int, int);
unsigned long strtoul(const char *s, char **ptr,int base)
{
return _strtoxl (s, ptr, base, 1);
}
|
the_stack_data/1148783.c | /* -*- mode: C; mode: fold -*- */
/*
* LAME MP3 encoding engine
*
* Copyright (c) 1999-2000 Mark Taylor
* Copyright (c) 2003 Olcios
* Copyright (c) 2008 Robert Hegemann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef HAVE_MPGLIB
#define hip_global_struct mpstr_tag
#include "lame.h"
#include "machine.h"
#include "encoder.h"
#include "interface.h"
#include "util.h"
#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
/*
* OBSOLETE:
* - kept to let it link
* - forward declaration to silence compiler
*/
int CDECL lame_decode_init(void);
int CDECL lame_decode(
unsigned char * mp3buf,
int len,
short pcm_l[],
short pcm_r[] );
int CDECL lame_decode_headers(
unsigned char* mp3buf,
int len,
short pcm_l[],
short pcm_r[],
mp3data_struct* mp3data );
int CDECL lame_decode1(
unsigned char* mp3buf,
int len,
short pcm_l[],
short pcm_r[] );
int CDECL lame_decode1_headers(
unsigned char* mp3buf,
int len,
short pcm_l[],
short pcm_r[],
mp3data_struct* mp3data );
int CDECL lame_decode1_headersB(
unsigned char* mp3buf,
int len,
short pcm_l[],
short pcm_r[],
mp3data_struct* mp3data,
int *enc_delay,
int *enc_padding );
int CDECL lame_decode_exit(void);
#endif
static MPSTR mp;
int
lame_decode_exit(void)
{
ExitMP3(&mp);
return 0;
}
int
lame_decode_init(void)
{
(void) InitMP3(&mp);
return 0;
}
/* copy mono samples */
#define COPY_MONO(DST_TYPE, SRC_TYPE) \
DST_TYPE *pcm_l = (DST_TYPE *)pcm_l_raw; \
SRC_TYPE const *p_samples = (SRC_TYPE const *)p; \
for (i = 0; i < processed_samples; i++) \
*pcm_l++ = (DST_TYPE)(*p_samples++);
/* copy stereo samples */
#define COPY_STEREO(DST_TYPE, SRC_TYPE) \
DST_TYPE *pcm_l = (DST_TYPE *)pcm_l_raw, *pcm_r = (DST_TYPE *)pcm_r_raw; \
SRC_TYPE const *p_samples = (SRC_TYPE const *)p; \
for (i = 0; i < processed_samples; i++) { \
*pcm_l++ = (DST_TYPE)(*p_samples++); \
*pcm_r++ = (DST_TYPE)(*p_samples++); \
}
/*
* For lame_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. either 576 or 1152 depending on MP3 file.
*/
static int
decode1_headersB_clipchoice(PMPSTR pmp, unsigned char *buffer, size_t len,
char pcm_l_raw[], char pcm_r_raw[], mp3data_struct * mp3data,
int *enc_delay, int *enc_padding,
char *p, size_t psize, int decoded_sample_size,
int (*decodeMP3_ptr) (PMPSTR, unsigned char *, int, char *, int,
int *))
{
static const int smpls[2][4] = {
/* Layer I II III */
{0, 384, 1152, 1152}, /* MPEG-1 */
{0, 384, 1152, 576} /* MPEG-2(.5) */
};
int processed_bytes;
int processed_samples; /* processed samples per channel */
int ret;
int i;
int const len_l = len < INT_MAX ? (int) len : INT_MAX;
int const psize_l = psize < INT_MAX ? (int) psize : INT_MAX;
mp3data->header_parsed = 0;
ret = (*decodeMP3_ptr) (pmp, buffer, len_l, p, psize_l, &processed_bytes);
/* three cases:
* 1. headers parsed, but data not complete
* pmp->header_parsed==1
* pmp->framesize=0
* pmp->fsizeold=size of last frame, or 0 if this is first frame
*
* 2. headers, data parsed, but ancillary data not complete
* pmp->header_parsed==1
* pmp->framesize=size of frame
* pmp->fsizeold=size of last frame, or 0 if this is first frame
*
* 3. frame fully decoded:
* pmp->header_parsed==0
* pmp->framesize=0
* pmp->fsizeold=size of frame (which is now the last frame)
*
*/
if (pmp->header_parsed || pmp->fsizeold > 0 || pmp->framesize > 0) {
mp3data->header_parsed = 1;
mp3data->stereo = pmp->fr.stereo;
mp3data->samplerate = freqs[pmp->fr.sampling_frequency];
mp3data->mode = pmp->fr.mode;
mp3data->mode_ext = pmp->fr.mode_ext;
mp3data->framesize = smpls[pmp->fr.lsf][pmp->fr.lay];
/* free format, we need the entire frame before we can determine
* the bitrate. If we haven't gotten the entire frame, bitrate=0 */
if (pmp->fsizeold > 0) /* works for free format and fixed, no overrun, temporal results are < 400.e6 */
mp3data->bitrate = 8 * (4 + pmp->fsizeold) * mp3data->samplerate /
(1.e3 * mp3data->framesize) + 0.5;
else if (pmp->framesize > 0)
mp3data->bitrate = 8 * (4 + pmp->framesize) * mp3data->samplerate /
(1.e3 * mp3data->framesize) + 0.5;
else
mp3data->bitrate = tabsel_123[pmp->fr.lsf][pmp->fr.lay - 1][pmp->fr.bitrate_index];
if (pmp->num_frames > 0) {
/* Xing VBR header found and num_frames was set */
mp3data->totalframes = pmp->num_frames;
mp3data->nsamp = mp3data->framesize * pmp->num_frames;
*enc_delay = pmp->enc_delay;
*enc_padding = pmp->enc_padding;
}
}
switch (ret) {
case MP3_OK:
switch (pmp->fr.stereo) {
case 1:
processed_samples = processed_bytes / decoded_sample_size;
if (decoded_sample_size == sizeof(short)) {
COPY_MONO(short, short)
}
else {
COPY_MONO(sample_t, FLOAT)
}
break;
case 2:
processed_samples = (processed_bytes / decoded_sample_size) >> 1;
if (decoded_sample_size == sizeof(short)) {
COPY_STEREO(short, short)
}
else {
COPY_STEREO(sample_t, FLOAT)
}
break;
default:
processed_samples = -1;
assert(0);
break;
}
break;
case MP3_NEED_MORE:
processed_samples = 0;
break;
case MP3_ERR:
processed_samples = -1;
break;
default:
processed_samples = -1;
assert(0);
break;
}
/*fprintf(stderr,"ok, more, err: %i %i %i\n", MP3_OK, MP3_NEED_MORE, MP3_ERR ); */
/*fprintf(stderr,"ret = %i out=%i\n", ret, processed_samples ); */
return processed_samples;
}
#define OUTSIZE_CLIPPED (4096*sizeof(short))
int
lame_decode1_headersB(unsigned char *buffer,
int len,
short pcm_l[], short pcm_r[], mp3data_struct * mp3data,
int *enc_delay, int *enc_padding)
{
static char out[OUTSIZE_CLIPPED];
return decode1_headersB_clipchoice(&mp, buffer, len, (char *) pcm_l, (char *) pcm_r, mp3data,
enc_delay, enc_padding, out, OUTSIZE_CLIPPED,
sizeof(short), decodeMP3);
}
/*
* For lame_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. Will be at most one frame of
* MPEG data.
*/
int
lame_decode1_headers(unsigned char *buffer,
int len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
{
int enc_delay, enc_padding;
return lame_decode1_headersB(buffer, len, pcm_l, pcm_r, mp3data, &enc_delay, &enc_padding);
}
int
lame_decode1(unsigned char *buffer, int len, short pcm_l[], short pcm_r[])
{
mp3data_struct mp3data;
return lame_decode1_headers(buffer, len, pcm_l, pcm_r, &mp3data);
}
/*
* For lame_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. a multiple of 576 or 1152 depending on MP3 file.
*/
int
lame_decode_headers(unsigned char *buffer,
int len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
{
int ret;
int totsize = 0; /* number of decoded samples per channel */
for (;;) {
switch (ret = lame_decode1_headers(buffer, len, pcm_l + totsize, pcm_r + totsize, mp3data)) {
case -1:
return ret;
case 0:
return totsize;
default:
totsize += ret;
len = 0; /* future calls to decodeMP3 are just to flush buffers */
break;
}
}
}
int
lame_decode(unsigned char *buffer, int len, short pcm_l[], short pcm_r[])
{
mp3data_struct mp3data;
return lame_decode_headers(buffer, len, pcm_l, pcm_r, &mp3data);
}
hip_t hip_decode_init(void)
{
hip_t hip = lame_calloc(hip_global_flags, 1);
InitMP3(hip);
return hip;
}
int hip_decode_exit(hip_t hip)
{
if (hip) {
ExitMP3(hip);
free(hip);
}
return 0;
}
/* we forbid input with more than 1152 samples per channel for output in the unclipped mode */
#define OUTSIZE_UNCLIPPED (1152*2*sizeof(FLOAT))
int
hip_decode1_unclipped(hip_t hip, unsigned char *buffer, size_t len, sample_t pcm_l[], sample_t pcm_r[])
{
static char out[OUTSIZE_UNCLIPPED];
mp3data_struct mp3data;
int enc_delay, enc_padding;
if (hip) {
return decode1_headersB_clipchoice(hip, buffer, len, (char *) pcm_l, (char *) pcm_r, &mp3data,
&enc_delay, &enc_padding, out, OUTSIZE_UNCLIPPED,
sizeof(FLOAT), decodeMP3_unclipped);
}
return 0;
}
/*
* For hip_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. Will be at most one frame of
* MPEG data.
*/
int
hip_decode1_headers(hip_t hip, unsigned char *buffer,
size_t len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
{
int enc_delay, enc_padding;
return hip_decode1_headersB(hip, buffer, len, pcm_l, pcm_r, mp3data, &enc_delay, &enc_padding);
}
int
hip_decode1(hip_t hip, unsigned char *buffer, size_t len, short pcm_l[], short pcm_r[])
{
mp3data_struct mp3data;
return hip_decode1_headers(hip, buffer, len, pcm_l, pcm_r, &mp3data);
}
/*
* For hip_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. a multiple of 576 or 1152 depending on MP3 file.
*/
int
hip_decode_headers(hip_t hip, unsigned char *buffer,
size_t len, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
{
int ret;
int totsize = 0; /* number of decoded samples per channel */
for (;;) {
switch (ret = hip_decode1_headers(hip, buffer, len, pcm_l + totsize, pcm_r + totsize, mp3data)) {
case -1:
return ret;
case 0:
return totsize;
default:
totsize += ret;
len = 0; /* future calls to decodeMP3 are just to flush buffers */
break;
}
}
}
int
hip_decode(hip_t hip, unsigned char *buffer, size_t len, short pcm_l[], short pcm_r[])
{
mp3data_struct mp3data;
return hip_decode_headers(hip, buffer, len, pcm_l, pcm_r, &mp3data);
}
int
hip_decode1_headersB(hip_t hip, unsigned char *buffer,
size_t len,
short pcm_l[], short pcm_r[], mp3data_struct * mp3data,
int *enc_delay, int *enc_padding)
{
static char out[OUTSIZE_CLIPPED];
if (hip) {
return decode1_headersB_clipchoice(hip, buffer, len, (char *) pcm_l, (char *) pcm_r, mp3data,
enc_delay, enc_padding, out, OUTSIZE_CLIPPED,
sizeof(short), decodeMP3);
}
return -1;
}
void hip_set_pinfo(hip_t hip, plotting_data* pinfo)
{
if (hip) {
hip->pinfo = pinfo;
}
}
void hip_set_errorf(hip_t hip, lame_report_function func)
{
if (hip) {
hip->report_err = func;
}
}
void hip_set_debugf(hip_t hip, lame_report_function func)
{
if (hip) {
hip->report_dbg = func;
}
}
void hip_set_msgf (hip_t hip, lame_report_function func)
{
if (hip) {
hip->report_msg = func;
}
}
#endif
/* end of mpglib_interface.c */
|
the_stack_data/14200243.c | /* initial conditions (shape is square):
*
* |<-- 1m -->|
* 150°C __________ 350°C
* |A B|
* | |
* | 0°C |
* | |
* 50°C |D________C| 500°C
*/
#define LENGTH 1 // side length, m
#define INIT_TEMP_BODY 0 // °C
#define INIT_TEMP_A 150 // °C
#define INIT_TEMP_B 350 // °C
#define INIT_TEMP_C 500 // °C
#define INIT_TEMP_D 50 // °C
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define RET_OK 0
#define RET_NEARGS 1
#define RET_BADARGS 2
#define RET_BADMALLOC 3
#define RET_NOTINIT 4
#define NUMARGS 4
#define NPTS_ARG 1
#define NT_ARG 2
#define DT_ARG 3
#define ALPHA_ARG 4
// number of worker threads calculating interior nodes
#define NUM_THREADS 7
#define ERR(err_string) printf("\e[31mError:\e[0m %s\n", (err_string))
#define WARN(warn_string) printf("\e[33mWarning:\e[0m %s\n", (warn_string))
#define USAGE printf("\n\e[32mUsage:\e[0m %s [npts] [nt] [dt] [alpha]\n%s\n%s\n%s\n%s\n\n", argv[0], \
" - npts (int): number of grid points in x and y (decimals will be truncated)", \
" - nt (int): number of time steps (decimals will be truncated)", \
" - dt (float): size of the time steps, in seconds", \
" - alpha (float): thermal diffusivity, in m^2/s")
int retval = RET_OK;
#define TEST_RETVAL(value) if((value) != RET_OK){return (value);}
int init_storage(float** a, const int length) {
*a = (float*)malloc(length * sizeof(float));
if( *a == NULL ) {
ERR("could not allocate memory for nodal meshes - try again, or with a smaller value for npts");
return RET_BADMALLOC;
} else {
return RET_OK;
}
}
// array flipping is 'atomic' (in that I can do it in one line in the main program)
void flip_arrays( float** label_a, float** label_b) {
float* placeholder = *label_a;
*label_a = *label_b;
*label_b = placeholder;
return;
}
// format: [node 0,0],[node 1,0],...;[node 0,1],[node 1,1],...;...,[node (num_points - 1),(num_points - 1)];\n
int write_data(const int frame_num, const float* array, const int num_points) {
//printf("%d:", frame_num);
(void) frame_num;
for( int y = 0; y < num_points; y++ ) {
printf("%.2f", array[y * num_points]);
for( int x = 1; x < num_points; x++ ) {
printf(",%.2f", array[x + (y * num_points)]);
}
printf(";");
}
printf("\n");
return RET_OK;
}
// bitmasks for bool var
#define COPY_MASK 0x01
// for spinning node calculations into other threads
typedef struct {
unsigned char bools;
pthread_mutex_t copy_mutex;
pthread_cond_t copy_sig;
int row_start;
int row_end;
float* current_temps;
float* previous_temps;
int npts;
float fourier;
} calc_data_t;
void* calc_interior( void* calc_data ) {
calc_data_t* cdp = (calc_data_t*)calc_data;
pthread_mutex_lock(&cdp->copy_mutex);
int start = cdp->row_start;
int end = cdp->row_end;
cdp->bools |= COPY_MASK;
pthread_cond_signal(&cdp->copy_sig);
pthread_mutex_unlock(&cdp->copy_mutex);
int P;
for( int y = start; y < end; y++ ) {
for( int x = 1; x < (cdp->npts - 1); x++) {
P = x + (y * cdp->npts);
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += cdp->fourier * ((cdp->previous_temps)[P + 1] + \
(cdp->previous_temps)[P - 1] + (cdp->previous_temps)[P + cdp->npts] + \
(cdp->previous_temps)[P - cdp->npts]);
}
}
return (NULL);
}
void* calc_edges( void* calc_data ) {
calc_data_t* cdp = (calc_data_t*)calc_data;
pthread_mutex_lock(&cdp->copy_mutex);
cdp->bools |= COPY_MASK;
pthread_cond_signal(&cdp->copy_sig);
pthread_mutex_unlock(&cdp->copy_mutex);
int P;
for( int i = 1; i < (cdp->npts - 1); i++ ) {
P = i;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += cdp->fourier * ((2 * (cdp->previous_temps)[P + cdp->npts]) + \
(cdp->previous_temps)[P - 1] + (cdp->previous_temps)[P + 1]);
P = ((i + 1) * cdp->npts) - 1;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += cdp->fourier * ((2 * (cdp->previous_temps)[P - 1]) + \
(cdp->previous_temps)[P - cdp->npts] + (cdp->previous_temps)[P + cdp->npts]);
P = (cdp->npts * (cdp->npts - 1)) + i;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += cdp->fourier * ((2 * (cdp->previous_temps)[P - cdp->npts]) + \
(cdp->previous_temps)[P - 1] + (cdp->previous_temps)[P + 1]);
P = i * cdp->npts;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += cdp->fourier * ((2 * (cdp->previous_temps)[P + 1]) + \
(cdp->previous_temps)[P - cdp->npts] + (cdp->previous_temps)[P + cdp->npts]);
}
return NULL;
}
void* calc_corners( void* calc_data ) {
calc_data_t* cdp = (calc_data_t*)calc_data;
pthread_mutex_lock(&cdp->copy_mutex);
cdp->bools |= COPY_MASK;
pthread_cond_signal(&cdp->copy_sig);
pthread_mutex_unlock(&cdp->copy_mutex);
int P = 0;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += 2 * cdp->fourier * ((cdp->previous_temps)[P + 1] + (cdp->previous_temps)[P + cdp->npts]);
P = cdp->npts - 1;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += 2 * cdp->fourier * ((cdp->previous_temps)[P - 1] + (cdp->previous_temps)[P + cdp->npts]);
P = (cdp->npts * cdp->npts) - 1;
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += 2 * cdp->fourier * ((cdp->previous_temps)[P - 1] + (cdp->previous_temps)[P - cdp->npts]);
P = cdp->npts * (cdp->npts - 1);
(cdp->current_temps)[P] = (cdp->previous_temps)[P] * (1 - (4 * cdp->fourier));
(cdp->current_temps)[P] += 2 * cdp->fourier * ((cdp->previous_temps)[P + 1] + (cdp->previous_temps)[P - cdp->npts]);
return NULL;
}
int main(int argc, char* argv[]) {
if( argc != (NUMARGS + 1)) {
ERR("wrong number of args");
USAGE;
return RET_NEARGS;
}
calc_data_t calc_data;
calc_data.npts = atoi(argv[NPTS_ARG]);
const int area = calc_data.npts * calc_data.npts;
const int nt = atoi(argv[NT_ARG]);
const float dt = atof(argv[DT_ARG]);
const float alpha = atof(argv[ALPHA_ARG]);
// these are all physical values and cannot be zero, so that's a safe check for bad input
if( (calc_data.npts * nt * dt * alpha) == 0 ) {
ERR("invalid input - only nonzero numbers are valid");
USAGE;
return RET_BADARGS;
}
const float dx = (float)LENGTH / calc_data.npts;
calc_data.fourier = (float)(alpha * dt) / (float)(dx * dx);
// We need 2 arrays to store the value of each node at the current and previous time step.
// We'll write the results out to a file as they're calculated so we don't clobber memory.
// We'll also swap which one is current and previous each iteration so we don't have to copy
// memory every time. This is probably premature optimization, but it's a concept I've wanted to
// try out for a while now, so I'm just gonna go for it.
retval = init_storage(&calc_data.current_temps, area); TEST_RETVAL(retval);
retval = init_storage(&calc_data.previous_temps, area); TEST_RETVAL(retval);
// Apply initial conditions - the project assignment seems to imply that the outermost nodes
// suddenly change from the body's initial temperature to the edge initial temperatures at t=0.
// Effectively, this simulates a body with a side length of (calc_data.npts - 2) being suddenly surrounded
// by material with a thickness of 1 node that has been pre-heated to the specified conditions
// (neglecting contact resistance). We'll assume the exterior of this material is adiabatic.
// memcpy is only good for 1 byte data; we need to do it the long way
for( int y = 0; y < calc_data.npts; y++ ) {
for( int x = 0; x < calc_data.npts; x++ ) {
calc_data.current_temps[x + (y * calc_data.npts)] = INIT_TEMP_BODY;
}
}
for( int i = 0; i < calc_data.npts; i++ ) {
// top
calc_data.current_temps[i] = INIT_TEMP_A + \
(i * ((float)(INIT_TEMP_B - INIT_TEMP_A) / (float)(calc_data.npts - 1)));
// bottom
calc_data.current_temps[i + ((calc_data.npts - 1) * calc_data.npts)] = \
INIT_TEMP_D + (i * ((float)(INIT_TEMP_C - INIT_TEMP_D) / (float)(calc_data.npts - 1)));
// left
calc_data.current_temps[i * calc_data.npts] = \
INIT_TEMP_A + (i * ((float)(INIT_TEMP_D - INIT_TEMP_A) / (float)(calc_data.npts - 1)));
// right
calc_data.current_temps[((i + 1) * calc_data.npts) - 1] = \
INIT_TEMP_B + (i * ((float)(INIT_TEMP_C - INIT_TEMP_B) / (float)(calc_data.npts - 1)));
}
// calculate - we're assuming an adiabatic exterior
// worker thread pool
pthread_t thread_pool[NUM_THREADS];
// initialize the condtion var to let the main thread know the child has copied the data...
pthread_cond_init(&calc_data.copy_sig, NULL);
// ...and the mutex it needs to go with it
pthread_mutex_init(&calc_data.copy_mutex, NULL);
for( int i = 0; i < nt; i++ ) {
write_data(i, calc_data.current_temps, calc_data.npts);
// there's probably a cleaner way to get the arrays to flip, but that's a later problem
flip_arrays(&calc_data.current_temps, &calc_data.previous_temps);
// kick off interior node calc threads
// Lock to write to data struct, then unlock and wait for the newly created thread to copy
// in the data. Repeat. After the last thread has copied, we don't need the lock anymore
// so we have to manually unlock it.
pthread_mutex_lock(&calc_data.copy_mutex);
for( int j = 0; j < (NUM_THREADS - 1); j++ ) {
calc_data.row_start = (j * (calc_data.npts / NUM_THREADS)) + 1;
calc_data.row_end = ((j + 1) * (calc_data.npts / NUM_THREADS)) + 1;
calc_data.bools &= ~COPY_MASK;
pthread_create(&(thread_pool[j]), NULL, calc_interior, (void*)(&calc_data));
while( !(calc_data.bools & COPY_MASK) ) {
pthread_cond_wait(&calc_data.copy_sig, &calc_data.copy_mutex);
}
}
calc_data.row_start = ((NUM_THREADS - 1) * (calc_data.npts / NUM_THREADS)) + 1;
calc_data.row_end = calc_data.npts - 1;
calc_data.bools &= ~COPY_MASK;
pthread_create(&(thread_pool[NUM_THREADS - 1]), NULL, calc_interior, (void*)(&calc_data));
while( !(calc_data.bools & COPY_MASK) ) {
pthread_cond_wait(&calc_data.copy_sig, &calc_data.copy_mutex);
}
pthread_mutex_unlock(&calc_data.copy_mutex);
// we'll calculate edges and corners in the main thread, since those don't take long
calc_edges((void*)(&calc_data));
calc_corners((void*)(&calc_data));
// wait for interior node calcs
for( int j = 0; j < NUM_THREADS; j++ ) {
pthread_join(thread_pool[j], NULL);
}
}
// put out our last round of calculations
write_data(nt, calc_data.current_temps, calc_data.npts);
free(calc_data.current_temps);
free(calc_data.previous_temps);
return RET_OK;
}
|
the_stack_data/28263197.c | /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/*****************************************************************************
** The following is a simple implementation of posix conditions
*****************************************************************************/
#if defined(_WIN32)
#undef SAFE_MUTEX /* Avoid safe_mutex redefinitions */
#include "mysys_priv.h"
#include <m_string.h>
#include <process.h>
#include <sys/timeb.h>
/*
Windows native condition variables. We use runtime loading / function
pointers, because they are not available on XP
*/
/* Prototypes and function pointers for condition variable functions */
typedef void (WINAPI * InitializeConditionVariableProc)
(PCONDITION_VARIABLE ConditionVariable);
typedef BOOL (WINAPI * SleepConditionVariableCSProc)
(PCONDITION_VARIABLE ConditionVariable,
PCRITICAL_SECTION CriticalSection,
DWORD dwMilliseconds);
typedef void (WINAPI * WakeAllConditionVariableProc)
(PCONDITION_VARIABLE ConditionVariable);
typedef void (WINAPI * WakeConditionVariableProc)
(PCONDITION_VARIABLE ConditionVariable);
static InitializeConditionVariableProc my_InitializeConditionVariable;
static SleepConditionVariableCSProc my_SleepConditionVariableCS;
static WakeAllConditionVariableProc my_WakeAllConditionVariable;
static WakeConditionVariableProc my_WakeConditionVariable;
/**
Indicates if we have native condition variables,
initialized first time pthread_cond_init is called.
*/
static BOOL have_native_conditions= FALSE;
/**
Check if native conditions can be used, load function pointers
*/
static void check_native_cond_availability(void)
{
HMODULE module= GetModuleHandle("kernel32");
my_InitializeConditionVariable= (InitializeConditionVariableProc)
GetProcAddress(module, "InitializeConditionVariable");
my_SleepConditionVariableCS= (SleepConditionVariableCSProc)
GetProcAddress(module, "SleepConditionVariableCS");
my_WakeAllConditionVariable= (WakeAllConditionVariableProc)
GetProcAddress(module, "WakeAllConditionVariable");
my_WakeConditionVariable= (WakeConditionVariableProc)
GetProcAddress(module, "WakeConditionVariable");
if (my_InitializeConditionVariable)
have_native_conditions= TRUE;
}
/**
Convert abstime to milliseconds
*/
static DWORD get_milliseconds(const struct timespec *abstime)
{
struct timespec current_time;
long long ms;
if (abstime == NULL)
return INFINITE;
set_timespec_nsec(current_time, 0);
ms= (abstime->tv_sec - current_time.tv_sec)*1000LL +
(abstime->tv_nsec - current_time.tv_nsec)/1000000LL;
if(ms < 0 )
ms= 0;
if(ms > UINT_MAX)
ms= INFINITE;
return (DWORD)ms;
}
/*
Old (pre-vista) implementation using events
*/
static int legacy_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
{
cond->waiting= 0;
InitializeCriticalSection(&cond->lock_waiting);
cond->events[SIGNAL]= CreateEvent(NULL, /* no security */
FALSE, /* auto-reset event */
FALSE, /* non-signaled initially */
NULL); /* unnamed */
/* Create a manual-reset event. */
cond->events[BROADCAST]= CreateEvent(NULL, /* no security */
TRUE, /* manual-reset */
FALSE, /* non-signaled initially */
NULL); /* unnamed */
cond->broadcast_block_event= CreateEvent(NULL, /* no security */
TRUE, /* manual-reset */
TRUE, /* signaled initially */
NULL); /* unnamed */
if( cond->events[SIGNAL] == NULL ||
cond->events[BROADCAST] == NULL ||
cond->broadcast_block_event == NULL )
return ENOMEM;
return 0;
}
static int legacy_cond_destroy(pthread_cond_t *cond)
{
DeleteCriticalSection(&cond->lock_waiting);
if (CloseHandle(cond->events[SIGNAL]) == 0 ||
CloseHandle(cond->events[BROADCAST]) == 0 ||
CloseHandle(cond->broadcast_block_event) == 0)
return EINVAL;
return 0;
}
static int legacy_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
struct timespec *abstime)
{
int result;
DWORD timeout;
timeout= get_milliseconds(abstime);
/*
Block access if previous broadcast hasn't finished.
This is just for safety and should normally not
affect the total time spent in this function.
*/
WaitForSingleObject(cond->broadcast_block_event, INFINITE);
EnterCriticalSection(&cond->lock_waiting);
cond->waiting++;
LeaveCriticalSection(&cond->lock_waiting);
LeaveCriticalSection(mutex);
result= WaitForMultipleObjects(2, cond->events, FALSE, timeout);
EnterCriticalSection(&cond->lock_waiting);
cond->waiting--;
if (cond->waiting == 0)
{
/*
We're the last waiter to be notified or to stop waiting, so
reset the manual event.
*/
/* Close broadcast gate */
ResetEvent(cond->events[BROADCAST]);
/* Open block gate */
SetEvent(cond->broadcast_block_event);
}
LeaveCriticalSection(&cond->lock_waiting);
EnterCriticalSection(mutex);
return result == WAIT_TIMEOUT ? ETIMEDOUT : 0;
}
static int legacy_cond_signal(pthread_cond_t *cond)
{
EnterCriticalSection(&cond->lock_waiting);
if(cond->waiting > 0)
SetEvent(cond->events[SIGNAL]);
LeaveCriticalSection(&cond->lock_waiting);
return 0;
}
static int legacy_cond_broadcast(pthread_cond_t *cond)
{
EnterCriticalSection(&cond->lock_waiting);
/*
The mutex protect us from broadcasting if
there isn't any thread waiting to open the
block gate after this call has closed it.
*/
if(cond->waiting > 0)
{
/* Close block gate */
ResetEvent(cond->broadcast_block_event);
/* Open broadcast gate */
SetEvent(cond->events[BROADCAST]);
}
LeaveCriticalSection(&cond->lock_waiting);
return 0;
}
/*
Posix API functions. Just choose between native and legacy implementation.
*/
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
{
/*
Once initialization is used here rather than in my_init(), to
1) avoid my_init() pitfalls- undefined order in which initialization should
run
2) be potentially useful C++ (in static constructors that run before main())
3) just to simplify the API.
Also, the overhead of my_pthread_once is very small.
*/
static my_pthread_once_t once_control= MY_PTHREAD_ONCE_INIT;
my_pthread_once(&once_control, check_native_cond_availability);
if (have_native_conditions)
{
my_InitializeConditionVariable(&cond->native_cond);
return 0;
}
else
return legacy_cond_init(cond, attr);
}
int pthread_cond_destroy(pthread_cond_t *cond)
{
if (have_native_conditions)
return 0; /* no destroy function */
else
return legacy_cond_destroy(cond);
}
int pthread_cond_broadcast(pthread_cond_t *cond)
{
if (have_native_conditions)
{
my_WakeAllConditionVariable(&cond->native_cond);
return 0;
}
else
return legacy_cond_broadcast(cond);
}
int pthread_cond_signal(pthread_cond_t *cond)
{
if (have_native_conditions)
{
my_WakeConditionVariable(&cond->native_cond);
return 0;
}
else
return legacy_cond_signal(cond);
}
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
struct timespec *abstime)
{
if (have_native_conditions)
{
DWORD timeout= get_milliseconds(abstime);
if (!my_SleepConditionVariableCS(&cond->native_cond, mutex, timeout))
return ETIMEDOUT;
return 0;
}
else
return legacy_cond_timedwait(cond, mutex, abstime);
}
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
return pthread_cond_timedwait(cond, mutex, NULL);
}
int pthread_attr_init(pthread_attr_t *connect_att)
{
connect_att->dwStackSize = 0;
connect_att->dwCreatingFlag = 0;
return 0;
}
int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack)
{
connect_att->dwStackSize=stack;
return 0;
}
int pthread_attr_destroy(pthread_attr_t *connect_att)
{
bzero((uchar*) connect_att,sizeof(*connect_att));
return 0;
}
/****************************************************************************
** Fix localtime_r() to be a bit safer
****************************************************************************/
struct tm *localtime_r(const time_t *timep,struct tm *tmp)
{
if (*timep == (time_t) -1) /* This will crash win32 */
{
bzero(tmp,sizeof(*tmp));
}
else
{
struct tm *res=localtime(timep);
if (!res) /* Wrong date */
{
bzero(tmp,sizeof(*tmp)); /* Keep things safe */
return 0;
}
*tmp= *res;
}
return tmp;
}
#endif /* __WIN__ */
|
the_stack_data/703927.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <sys/time.h>
#include <time.h>
#include "err.h"
#undef log
#undef syserr
void syserr_(const char *fmt, ...)
{
va_list fmt_args;
fprintf(stderr, "ERROR: ");
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end (fmt_args);
fprintf(stderr," (%d; %s)\n", errno, strerror(errno));
kill(0, SIGINT); // signal handler is supposed to do a cleanup
exit(1);
}
#define TIME_LEN 26
#define TIMEBUF_LEN 31
char timebuf[TIME_LEN];
static
void load_current_time_()
{
struct timeval tv;
gettimeofday(&tv, NULL);
int millisec = (int)(tv.tv_usec / 1000.0);
if (millisec >= 1000) {
millisec -= 1000;
tv.tv_sec++;
}
struct tm* tm_info = localtime(&tv.tv_sec);
size_t pos = strftime(timebuf, TIME_LEN, "%Y:%m:%d %H:%M:%S", tm_info);
assert(0 <= millisec && millisec < 1000);
snprintf(&timebuf[pos], 6, ".%d", millisec);
}
void log_(const char *fmt, ...) {
load_current_time_();
fprintf(stderr, "%s: ", timebuf);
va_list fmt_args;
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end(fmt_args);
fputc('\n', stderr);
}
void log_nnl(const char *fmt, ...) {
load_current_time_();
fprintf(stderr, "%s: ", timebuf);
va_list fmt_args;
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end(fmt_args);
}
/* = log_middle + macro for prefix */
void log_first_(const char *fmt, ...) {
load_current_time_();
fprintf(stderr, "%s: ", timebuf);
va_list fmt_args;
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end(fmt_args);
}
void log_middle(const char *fmt, ...) {
va_list fmt_args;
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end(fmt_args);
}
void log_last(const char *fmt, ...) {
va_list fmt_args;
va_start(fmt_args, fmt);
vfprintf(stderr, fmt, fmt_args);
va_end(fmt_args);
fputc('\n', stderr);
}
|
the_stack_data/64222.c | /*
* Python bindings module for ${library_name} (${python_module_name})
*
* Copyright (C) ${python_module_copyright}, ${python_module_authors}
*
* Refer to AUTHORS for acknowledgements.
*
* This program 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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
|
the_stack_data/43564.c | /*
* bin2c - Copyright (c) 2010 Kim Holviala <[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:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 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 HOLDERS 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.
*/
/*
* Convert any file into a C #define
*
* Yes, this would have been a perl one-liner, but I didn't want
* to include compile-time dependency for perl...
*/
#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
FILE *fp;
char *source = NULL;
char *name = NULL;
int first = 1;
int zero = 0;
int c;
int i;
/* Parse args */
while ((c = getopt(argc, argv, "n:0")) != -1) {
switch(c) {
case 'n': name = optarg; break;
case '0': zero = 1; break;
}
}
source = argv[optind];
if (!name) name = source;
/* Check args */
if (!source) {
fprintf(stderr, "Usage: %s [-0] [-n <name>] <source>\n", argv[0]);
return 1;
}
/* Try to open the source file */
if ((fp = fopen(source, "r")) == NULL) {
perror("Couldn't open source file");
return 1;
}
/* Convert */
printf("/* Automatically generated from %s */\n\n"
"#define %s { \\\n", source, name);
do {
for (i = 0; i < 16; i++) {
if ((c = fgetc(fp)) == EOF) {
if (zero--) c = '\0';
else break;
}
if (i == 0 && !first) printf(", \\\n");
if (i > 0) printf(", ");
printf("0x%02x", c);
first = 0;
}
} while (c != EOF);
printf("}\n\n");
fclose(fp);
return 0;
}
|
the_stack_data/165767087.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conj(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimag(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__1 = 1;
static doublereal c_b25 = 1.;
static doublereal c_b27 = 0.;
/* > \brief \b DSBGVX */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download DSBGVX + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dsbgvx.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dsbgvx.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dsbgvx.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE DSBGVX( JOBZ, RANGE, UPLO, N, KA, KB, AB, LDAB, BB, */
/* LDBB, Q, LDQ, VL, VU, IL, IU, ABSTOL, M, W, Z, */
/* LDZ, WORK, IWORK, IFAIL, INFO ) */
/* CHARACTER JOBZ, RANGE, UPLO */
/* INTEGER IL, INFO, IU, KA, KB, LDAB, LDBB, LDQ, LDZ, M, */
/* $ N */
/* DOUBLE PRECISION ABSTOL, VL, VU */
/* INTEGER IFAIL( * ), IWORK( * ) */
/* DOUBLE PRECISION AB( LDAB, * ), BB( LDBB, * ), Q( LDQ, * ), */
/* $ W( * ), WORK( * ), Z( LDZ, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > DSBGVX computes selected eigenvalues, and optionally, eigenvectors */
/* > of a real generalized symmetric-definite banded eigenproblem, of */
/* > the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric */
/* > and banded, and B is also positive definite. Eigenvalues and */
/* > eigenvectors can be selected by specifying either all eigenvalues, */
/* > a range of values or a range of indices for the desired eigenvalues. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] JOBZ */
/* > \verbatim */
/* > JOBZ is CHARACTER*1 */
/* > = 'N': Compute eigenvalues only; */
/* > = 'V': Compute eigenvalues and eigenvectors. */
/* > \endverbatim */
/* > */
/* > \param[in] RANGE */
/* > \verbatim */
/* > RANGE is CHARACTER*1 */
/* > = 'A': all eigenvalues will be found. */
/* > = 'V': all eigenvalues in the half-open interval (VL,VU] */
/* > will be found. */
/* > = 'I': the IL-th through IU-th eigenvalues will be found. */
/* > \endverbatim */
/* > */
/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > = 'U': Upper triangles of A and B are stored; */
/* > = 'L': Lower triangles of A and B are stored. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrices A and B. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] KA */
/* > \verbatim */
/* > KA is INTEGER */
/* > The number of superdiagonals of the matrix A if UPLO = 'U', */
/* > or the number of subdiagonals if UPLO = 'L'. KA >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] KB */
/* > \verbatim */
/* > KB is INTEGER */
/* > The number of superdiagonals of the matrix B if UPLO = 'U', */
/* > or the number of subdiagonals if UPLO = 'L'. KB >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] AB */
/* > \verbatim */
/* > AB is DOUBLE PRECISION array, dimension (LDAB, N) */
/* > On entry, the upper or lower triangle of the symmetric band */
/* > matrix A, stored in the first ka+1 rows of the array. The */
/* > j-th column of A is stored in the j-th column of the array AB */
/* > as follows: */
/* > if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for f2cmax(1,j-ka)<=i<=j; */
/* > if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=f2cmin(n,j+ka). */
/* > */
/* > On exit, the contents of AB are destroyed. */
/* > \endverbatim */
/* > */
/* > \param[in] LDAB */
/* > \verbatim */
/* > LDAB is INTEGER */
/* > The leading dimension of the array AB. LDAB >= KA+1. */
/* > \endverbatim */
/* > */
/* > \param[in,out] BB */
/* > \verbatim */
/* > BB is DOUBLE PRECISION array, dimension (LDBB, N) */
/* > On entry, the upper or lower triangle of the symmetric band */
/* > matrix B, stored in the first kb+1 rows of the array. The */
/* > j-th column of B is stored in the j-th column of the array BB */
/* > as follows: */
/* > if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for f2cmax(1,j-kb)<=i<=j; */
/* > if UPLO = 'L', BB(1+i-j,j) = B(i,j) for j<=i<=f2cmin(n,j+kb). */
/* > */
/* > On exit, the factor S from the split Cholesky factorization */
/* > B = S**T*S, as returned by DPBSTF. */
/* > \endverbatim */
/* > */
/* > \param[in] LDBB */
/* > \verbatim */
/* > LDBB is INTEGER */
/* > The leading dimension of the array BB. LDBB >= KB+1. */
/* > \endverbatim */
/* > */
/* > \param[out] Q */
/* > \verbatim */
/* > Q is DOUBLE PRECISION array, dimension (LDQ, N) */
/* > If JOBZ = 'V', the n-by-n matrix used in the reduction of */
/* > A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x, */
/* > and consequently C to tridiagonal form. */
/* > If JOBZ = 'N', the array Q is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDQ */
/* > \verbatim */
/* > LDQ is INTEGER */
/* > The leading dimension of the array Q. If JOBZ = 'N', */
/* > LDQ >= 1. If JOBZ = 'V', LDQ >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] VL */
/* > \verbatim */
/* > VL is DOUBLE PRECISION */
/* > */
/* > If RANGE='V', the lower bound of the interval to */
/* > be searched for eigenvalues. VL < VU. */
/* > Not referenced if RANGE = 'A' or 'I'. */
/* > \endverbatim */
/* > */
/* > \param[in] VU */
/* > \verbatim */
/* > VU is DOUBLE PRECISION */
/* > */
/* > If RANGE='V', the upper bound of the interval to */
/* > be searched for eigenvalues. VL < VU. */
/* > Not referenced if RANGE = 'A' or 'I'. */
/* > \endverbatim */
/* > */
/* > \param[in] IL */
/* > \verbatim */
/* > IL is INTEGER */
/* > */
/* > If RANGE='I', the index of the */
/* > smallest eigenvalue to be returned. */
/* > 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. */
/* > Not referenced if RANGE = 'A' or 'V'. */
/* > \endverbatim */
/* > */
/* > \param[in] IU */
/* > \verbatim */
/* > IU is INTEGER */
/* > */
/* > If RANGE='I', the index of the */
/* > largest eigenvalue to be returned. */
/* > 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. */
/* > Not referenced if RANGE = 'A' or 'V'. */
/* > \endverbatim */
/* > */
/* > \param[in] ABSTOL */
/* > \verbatim */
/* > ABSTOL is DOUBLE PRECISION */
/* > The absolute error tolerance for the eigenvalues. */
/* > An approximate eigenvalue is accepted as converged */
/* > when it is determined to lie in an interval [a,b] */
/* > of width less than or equal to */
/* > */
/* > ABSTOL + EPS * f2cmax( |a|,|b| ) , */
/* > */
/* > where EPS is the machine precision. If ABSTOL is less than */
/* > or equal to zero, then EPS*|T| will be used in its place, */
/* > where |T| is the 1-norm of the tridiagonal matrix obtained */
/* > by reducing A to tridiagonal form. */
/* > */
/* > Eigenvalues will be computed most accurately when ABSTOL is */
/* > set to twice the underflow threshold 2*DLAMCH('S'), not zero. */
/* > If this routine returns with INFO>0, indicating that some */
/* > eigenvectors did not converge, try setting ABSTOL to */
/* > 2*DLAMCH('S'). */
/* > \endverbatim */
/* > */
/* > \param[out] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The total number of eigenvalues found. 0 <= M <= N. */
/* > If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1. */
/* > \endverbatim */
/* > */
/* > \param[out] W */
/* > \verbatim */
/* > W is DOUBLE PRECISION array, dimension (N) */
/* > If INFO = 0, the eigenvalues in ascending order. */
/* > \endverbatim */
/* > */
/* > \param[out] Z */
/* > \verbatim */
/* > Z is DOUBLE PRECISION array, dimension (LDZ, N) */
/* > If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of */
/* > eigenvectors, with the i-th column of Z holding the */
/* > eigenvector associated with W(i). The eigenvectors are */
/* > normalized so Z**T*B*Z = I. */
/* > If JOBZ = 'N', then Z is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDZ */
/* > \verbatim */
/* > LDZ is INTEGER */
/* > The leading dimension of the array Z. LDZ >= 1, and if */
/* > JOBZ = 'V', LDZ >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is DOUBLE PRECISION array, dimension (7*N) */
/* > \endverbatim */
/* > */
/* > \param[out] IWORK */
/* > \verbatim */
/* > IWORK is INTEGER array, dimension (5*N) */
/* > \endverbatim */
/* > */
/* > \param[out] IFAIL */
/* > \verbatim */
/* > IFAIL is INTEGER array, dimension (M) */
/* > If JOBZ = 'V', then if INFO = 0, the first M elements of */
/* > IFAIL are zero. If INFO > 0, then IFAIL contains the */
/* > indices of the eigenvalues that failed to converge. */
/* > If JOBZ = 'N', then IFAIL is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > <= N: if INFO = i, then i eigenvectors failed to converge. */
/* > Their indices are stored in IFAIL. */
/* > > N: DPBSTF returned an error code; i.e., */
/* > if INFO = N + i, for 1 <= i <= N, then the leading */
/* > minor of order i of B is not positive definite. */
/* > The factorization of B could not be completed and */
/* > no eigenvalues or eigenvectors were computed. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date June 2016 */
/* > \ingroup doubleOTHEReigen */
/* > \par Contributors: */
/* ================== */
/* > */
/* > Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA */
/* ===================================================================== */
/* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, integer *n,
integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *
bb, integer *ldbb, doublereal *q, integer *ldq, doublereal *vl,
doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer
*m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work,
integer *iwork, integer *ifail, integer *info)
{
/* System generated locals */
integer ab_dim1, ab_offset, bb_dim1, bb_offset, q_dim1, q_offset, z_dim1,
z_offset, i__1, i__2;
/* Local variables */
integer indd, inde;
char vect[1];
logical test;
integer itmp1, i__, j, indee;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int dgemv_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *);
integer iinfo;
char order[1];
extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
doublereal *, integer *), dswap_(integer *, doublereal *, integer
*, doublereal *, integer *);
logical upper, wantz;
integer jj;
logical alleig, indeig;
integer indibl;
logical valeig;
extern /* Subroutine */ int dlacpy_(char *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *),
xerbla_(char *, integer *, ftnlen), dpbstf_(char *, integer *,
integer *, doublereal *, integer *, integer *), dsbtrd_(
char *, char *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, doublereal *, integer *, doublereal *,
integer *);
integer indisp;
extern /* Subroutine */ int dsbgst_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *),
dstein_(integer *, doublereal *, doublereal *, integer *,
doublereal *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *, integer *, integer *);
integer indiwo;
extern /* Subroutine */ int dsterf_(integer *, doublereal *, doublereal *,
integer *), dstebz_(char *, char *, integer *, doublereal *,
doublereal *, integer *, integer *, doublereal *, doublereal *,
doublereal *, integer *, integer *, doublereal *, integer *,
integer *, doublereal *, integer *, integer *);
integer indwrk;
extern /* Subroutine */ int dsteqr_(char *, integer *, doublereal *,
doublereal *, doublereal *, integer *, doublereal *, integer *);
integer nsplit;
doublereal tmp1;
/* -- LAPACK driver routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* June 2016 */
/* ===================================================================== */
/* Test the input parameters. */
/* Parameter adjustments */
ab_dim1 = *ldab;
ab_offset = 1 + ab_dim1 * 1;
ab -= ab_offset;
bb_dim1 = *ldbb;
bb_offset = 1 + bb_dim1 * 1;
bb -= bb_offset;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
--w;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--work;
--iwork;
--ifail;
/* Function Body */
wantz = lsame_(jobz, "V");
upper = lsame_(uplo, "U");
alleig = lsame_(range, "A");
valeig = lsame_(range, "V");
indeig = lsame_(range, "I");
*info = 0;
if (! (wantz || lsame_(jobz, "N"))) {
*info = -1;
} else if (! (alleig || valeig || indeig)) {
*info = -2;
} else if (! (upper || lsame_(uplo, "L"))) {
*info = -3;
} else if (*n < 0) {
*info = -4;
} else if (*ka < 0) {
*info = -5;
} else if (*kb < 0 || *kb > *ka) {
*info = -6;
} else if (*ldab < *ka + 1) {
*info = -8;
} else if (*ldbb < *kb + 1) {
*info = -10;
} else if (*ldq < 1 || wantz && *ldq < *n) {
*info = -12;
} else {
if (valeig) {
if (*n > 0 && *vu <= *vl) {
*info = -14;
}
} else if (indeig) {
if (*il < 1 || *il > f2cmax(1,*n)) {
*info = -15;
} else if (*iu < f2cmin(*n,*il) || *iu > *n) {
*info = -16;
}
}
}
if (*info == 0) {
if (*ldz < 1 || wantz && *ldz < *n) {
*info = -21;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DSBGVX", &i__1, (ftnlen)6);
return 0;
}
/* Quick return if possible */
*m = 0;
if (*n == 0) {
return 0;
}
/* Form a split Cholesky factorization of B. */
dpbstf_(uplo, n, kb, &bb[bb_offset], ldbb, info);
if (*info != 0) {
*info = *n + *info;
return 0;
}
/* Transform problem to standard eigenvalue problem. */
dsbgst_(jobz, uplo, n, ka, kb, &ab[ab_offset], ldab, &bb[bb_offset], ldbb,
&q[q_offset], ldq, &work[1], &iinfo);
/* Reduce symmetric band matrix to tridiagonal form. */
indd = 1;
inde = indd + *n;
indwrk = inde + *n;
if (wantz) {
*(unsigned char *)vect = 'U';
} else {
*(unsigned char *)vect = 'N';
}
dsbtrd_(vect, uplo, n, ka, &ab[ab_offset], ldab, &work[indd], &work[inde],
&q[q_offset], ldq, &work[indwrk], &iinfo);
/* If all eigenvalues are desired and ABSTOL is less than or equal */
/* to zero, then call DSTERF or SSTEQR. If this fails for some */
/* eigenvalue, then try DSTEBZ. */
test = FALSE_;
if (indeig) {
if (*il == 1 && *iu == *n) {
test = TRUE_;
}
}
if ((alleig || test) && *abstol <= 0.) {
dcopy_(n, &work[indd], &c__1, &w[1], &c__1);
indee = indwrk + (*n << 1);
i__1 = *n - 1;
dcopy_(&i__1, &work[inde], &c__1, &work[indee], &c__1);
if (! wantz) {
dsterf_(n, &w[1], &work[indee], info);
} else {
dlacpy_("A", n, n, &q[q_offset], ldq, &z__[z_offset], ldz);
dsteqr_(jobz, n, &w[1], &work[indee], &z__[z_offset], ldz, &work[
indwrk], info);
if (*info == 0) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
ifail[i__] = 0;
/* L10: */
}
}
}
if (*info == 0) {
*m = *n;
goto L30;
}
*info = 0;
}
/* Otherwise, call DSTEBZ and, if eigenvectors are desired, */
/* call DSTEIN. */
if (wantz) {
*(unsigned char *)order = 'B';
} else {
*(unsigned char *)order = 'E';
}
indibl = 1;
indisp = indibl + *n;
indiwo = indisp + *n;
dstebz_(range, order, n, vl, vu, il, iu, abstol, &work[indd], &work[inde],
m, &nsplit, &w[1], &iwork[indibl], &iwork[indisp], &work[indwrk],
&iwork[indiwo], info);
if (wantz) {
dstein_(n, &work[indd], &work[inde], m, &w[1], &iwork[indibl], &iwork[
indisp], &z__[z_offset], ldz, &work[indwrk], &iwork[indiwo], &
ifail[1], info);
/* Apply transformation matrix used in reduction to tridiagonal */
/* form to eigenvectors returned by DSTEIN. */
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
dcopy_(n, &z__[j * z_dim1 + 1], &c__1, &work[1], &c__1);
dgemv_("N", n, n, &c_b25, &q[q_offset], ldq, &work[1], &c__1, &
c_b27, &z__[j * z_dim1 + 1], &c__1);
/* L20: */
}
}
L30:
/* If eigenvalues are not in order, then sort them, along with */
/* eigenvectors. */
if (wantz) {
i__1 = *m - 1;
for (j = 1; j <= i__1; ++j) {
i__ = 0;
tmp1 = w[j];
i__2 = *m;
for (jj = j + 1; jj <= i__2; ++jj) {
if (w[jj] < tmp1) {
i__ = jj;
tmp1 = w[jj];
}
/* L40: */
}
if (i__ != 0) {
itmp1 = iwork[indibl + i__ - 1];
w[i__] = w[j];
iwork[indibl + i__ - 1] = iwork[indibl + j - 1];
w[j] = tmp1;
iwork[indibl + j - 1] = itmp1;
dswap_(n, &z__[i__ * z_dim1 + 1], &c__1, &z__[j * z_dim1 + 1],
&c__1);
if (*info != 0) {
itmp1 = ifail[i__];
ifail[i__] = ifail[j];
ifail[j] = itmp1;
}
}
/* L50: */
}
}
return 0;
/* End of DSBGVX */
} /* dsbgvx_ */
|
Subsets and Splits